15 #include "animateVerticesRequest.h"
16 #include "bufferContext.h"
17 #include "config_util.h"
18 #include "config_gobj.h"
20 #include "geomCacheEntry.h"
21 #include "geomMunger.h"
22 #include "geomPrimitive.h"
23 #include "geomTriangles.h"
24 #include "geomTristrips.h"
25 #include "geomTrifans.h"
26 #include "geomPatches.h"
27 #include "geomLines.h"
28 #include "geomLinestrips.h"
29 #include "geomPoints.h"
30 #include "geomVertexArrayData.h"
31 #include "geomVertexArrayFormat.h"
32 #include "geomVertexData.h"
33 #include "geomVertexFormat.h"
36 #include "occlusionQueryContext.h"
37 #include "orthographicLens.h"
38 #include "matrixLens.h"
39 #include "paramTexture.h"
40 #include "perspectiveLens.h"
41 #include "queryContext.h"
42 #include "sliderTable.h"
44 #include "texturePoolFilter.h"
45 #include "textureReloadRequest.h"
46 #include "textureStage.h"
47 #include "textureContext.h"
48 #include "timerQueryContext.h"
49 #include "samplerContext.h"
50 #include "samplerState.h"
52 #include "shaderContext.h"
53 #include "transformBlend.h"
54 #include "transformBlendTable.h"
55 #include "transformTable.h"
56 #include "userVertexSlider.h"
57 #include "userVertexTransform.h"
58 #include "vertexDataBuffer.h"
59 #include "vertexTransform.h"
60 #include "vertexSlider.h"
61 #include "videoTexture.h"
62 #include "geomContext.h"
63 #include "vertexBufferContext.h"
64 #include "indexBufferContext.h"
65 #include "internalName.h"
68 #include "string_utils.h"
70 Configure(config_gobj);
71 NotifyCategoryDef(gobj,
"");
72 NotifyCategoryDef(shader,
"");
75 (
"max-texture-dimension", -1,
76 PRC_DESC(
"Set this to the maximum size a texture is allowed to be in either "
77 "dimension. This is generally intended as a simple way to restrict "
78 "texture sizes for limited graphics cards. When this is greater "
79 "than zero, each texture image loaded from a file (but only those "
80 "loaded from a file) will be automatically scaled down, if "
81 "necessary, so that neither dimension is larger than this value. "
82 "If this is less than zero, the size limit is taken from the "
83 "primary GSG. If this is exactly zero, there is no limit."));
86 (
"texture-scale", 1.0,
87 PRC_DESC(
"This is a global scale factor that is applied to each texture "
88 "as it is loaded from disk. For instance, a value of 0.5 will "
89 "reduce each texture to one-half its size in each dimension. This "
90 "scale factor is applied before textures-power-2 or "
91 "max-texture-dimension."));
94 (
"texture-scale-limit", 4,
95 PRC_DESC(
"This specifies the limit below which texture-scale will not "
96 "reduce a texture image. This is a single dimension which applies "
100 (
"exclude-texture-scale",
101 PRC_DESC(
"This is a list of glob patterns for texture filenames "
102 "(excluding the directory part of the filename, but including "
103 "the extension); for instance, 'digits_*.png'. Any texture "
104 "filenames that match one of these patterns will not be affected "
105 "by max-texture-dimension or texture-scale."));
108 (
"keep-texture-ram",
false,
109 PRC_DESC(
"Set this to true to retain the ram image for each texture after it "
110 "has been prepared with the GSG. This will allow the texture to be "
111 "prepared with multiple GSG's, or to be re-prepared later after it is "
112 "explicitly released from the GSG, without having to reread the "
113 "texture image from disk; but it will consume memory somewhat "
117 (
"compressed-textures",
false,
118 PRC_DESC(
"Set this to true to compress textures as they are loaded into "
119 "texture memory, if the driver supports this. Specifically, this "
120 "changes the meaning of set_compression(Texture::CM_default) to "
124 (
"driver-compress-textures",
false,
125 PRC_DESC(
"Set this true to ask the graphics driver to compress textures, "
126 "rather than compressing them in-memory first. Depending on "
127 "your graphics driver, you may or may not get better performance "
128 "or results by setting this true. Setting it true may also "
129 "allow you to take advantage of some exotic compression algorithm "
130 "other than DXT1/3/5 that your graphics driver supports, but "
131 "which is unknown to Panda. If the libsquish library is not "
132 "compiled into Panda, textures cannot be compressed in-memory, "
133 "and will always be handed to the graphics driver, regardless "
134 "of this setting."));
137 (
"driver-generate-mipmaps",
true,
138 PRC_DESC(
"Set this true to use the hardware to generate mipmaps "
139 "automatically in all cases, if supported. Set it false "
140 "to generate mipmaps in software when possible."));
143 (
"vertex-buffers",
true,
144 PRC_DESC(
"Set this true to allow the use of vertex buffers (or buffer "
145 "objects, as OpenGL dubs them) for rendering vertex data. This "
146 "can greatly improve rendering performance on "
147 "higher-end graphics cards, at the cost of some additional "
148 "graphics memory (which might otherwise be used for textures "
149 "or offscreen buffers). On lower-end graphics cards this will "
150 "make little or no difference."));
153 (
"vertex-arrays",
true,
154 PRC_DESC(
"Set this true to allow the use of vertex arrays for rendering "
155 "OpenGL vertex data. This, or vertex buffers, is the normal "
156 "way of issuing vertices ever since OpenGL 1.1, and you "
157 "almost always want to have this set to true. However, some very "
158 "buggy graphics drivers may have problems handling vertex arrays "
159 "correctly, so if you are experiencing problems you might try "
160 "setting this to false. If this is false, Panda will fall back "
161 "to using immediate-mode commands like glVertex3f(), etc., to "
162 "issue the vertices, which is potentially much slower than "
163 "vertex arrays. Setting this false also disables vertex buffers, "
164 "effectively ignoring the setting of the vertex-buffers variable "
165 "(since vertex buffers are a special case of vertex arrays in "
166 "OpenGL). This variable is normally not enabled in a production "
167 "build. This has no effect on DirectX rendering."));
170 (
"display-lists",
false,
171 PRC_DESC(
"Set this true to allow the use of OpenGL display lists for "
172 "rendering static geometry. On some systems, this can result "
173 "in a performance improvement over vertex buffers alone; on "
174 "other systems (particularly low-end systems) it makes little to "
175 "no difference. On some systems, using display lists can actually "
176 "reduce performance. This has no effect on DirectX rendering or "
177 "on dynamic geometry (e.g. soft-skinned animation)."));
180 (
"hardware-animated-vertices",
false,
181 PRC_DESC(
"Set this true to allow the transforming of soft-skinned "
182 "animated vertices via hardware, if supported, or false always "
183 "to perform the vertex animation via software within Panda. "
184 "If you have a card that supports this, and your scene does "
185 "not contain too many vertices already, this can provide a "
186 "performance boost by offloading some work from your CPU onto "
187 "your graphics card. It may also help by reducing the bandwidth "
188 "necessary on your computer's bus. However, in some cases it "
189 "may actually reduce performance."));
192 (
"hardware-point-sprites",
true,
193 PRC_DESC(
"Set this true to allow the use of hardware extensions when "
194 "rendering perspective-scaled points and point sprites. When "
195 "false, these large points are always simulated via quads "
196 "computed in software, even if the hardware claims it can "
197 "support them directly."));
200 (
"hardware-points",
true,
201 PRC_DESC(
"Set this true to allow the use of hardware extensions when "
202 "rendering large points. When false, large points (even if "
203 "untextured) will be simulated via quads computed in software."));
206 (
"singular-points",
true,
207 PRC_DESC(
"Set this true to insist that when RenderModeAttrib::M_points is "
208 "used, each point appears only once in the result, even if "
209 "the vertex is referenced multiple times. This is particularly "
210 "important when rendering points from a triangle mesh and you "
211 "don't want the points to appear repeatedly."));
214 (
"matrix-palette",
false,
215 PRC_DESC(
"Set this true to allow the use of the matrix palette when "
216 "animating vertices in hardware. The matrix palette is "
217 "not supported by all devices, but if it is, using "
218 "it can allow animation of more sophisticated meshes "
219 "in hardware, and it can also improve the "
220 "performance of animating some simpler meshes. Without "
221 "this option, certain meshes will have to be animated in "
222 "software. However, this option is not enabled by default, "
223 "because its support seems to be buggy in certain drivers "
224 "(ATI FireGL T2 8.103 in particular.)"));
227 (
"display-list-animation",
false,
228 PRC_DESC(
"Set this true to allow the use of OpenGL display lists for "
229 "rendering animated geometry (when the geometry is animated "
230 "by the hardware). This is not on by default because there "
231 "appear to be some driver issues with this on my FireGL T2, "
232 "but it should be perfectly doable in principle, and might get "
233 "you a small performance boost."));
236 (
"connect-triangle-strips",
true,
237 PRC_DESC(
"Set this true to send a batch of triangle strips to the graphics "
238 "card as one long triangle strip, connected by degenerate "
239 "triangles, or false to send them as separate triangle strips "
240 "with no degenerate triangles. On PC hardware, using one long "
241 "triangle strip may help performance by reducing the number "
242 "of separate graphics calls that have to be made."));
245 (
"preserve-triangle-strips",
false,
246 PRC_DESC(
"Set this true to indicate a preference for keeping triangle strips "
247 "when possible, instead of decomposing them into triangles. When "
248 "this is true, flatten_strong and unify operations may be less "
249 "effective at combining multiple Geoms together, but they will "
250 "not implicitly decompose triangle strips."));
253 (
"dump-generated-shaders",
false,
254 PRC_DESC(
"Set this true to cause all generated shaders to be written "
255 "to disk. This is useful for debugging broken shader "
259 (
"cache-generated-shaders",
true,
260 PRC_DESC(
"Set this true to cause all generated shaders to be cached in "
261 "memory. This is useful to prevent unnecessary recompilation."));
264 (
"enforce-attrib-lock",
true,
265 PRC_DESC(
"When a MaterialAttrib, TextureAttrib, or LightAttrib is "
266 "constructed, the corresponding Material, Texture, or Light "
267 "is 'attrib locked.' The attrib lock prevents qualitative "
268 "changes to the object. This makes it possible to hardwire "
269 "information about material, light, and texture properties "
270 "into generated shaders. This config variable can disable "
271 "the attrib lock. Disabling the lock will break the shader "
272 "generator, but doing so may be necessary for backward "
273 "compatibility with old code."));
276 (
"vertices-float64",
false,
277 PRC_DESC(
"When this is true, the default float format for vertices "
278 "will be a 64-bit double-precision float, instead "
279 "of the normal 32-bit single-precision float. This must be set "
280 "at static init time to have the broadest effect. You almost never "
281 "want to set this true, since current hardware does not support "
282 "double-precision vertices, and setting this will just require the "
283 "driver to downsample the vertices at load time, making everything "
287 (
"vertex-column-alignment", 4,
288 PRC_DESC(
"This specifies the default byte alignment for each column of "
289 "data within a GeomVertexData when it is assembled using the default "
290 "interfaces. Normally, you should not change this config variable "
291 "(which would change this value globally), but instead specify any "
292 "alignment requirements on a per-column basis as you construct a "
293 "GeomVertexFormat. Setting this value globally could result in "
294 "much needless wasted space in all vertex data objects, but it "
295 "could be useful for simple experiments. Also see "
296 "vertex-animation-align-16 for a variable that controls "
297 "this alignment for the vertex animation columns only."));
300 (
"vertex-animation-align-16",
306 PRC_DESC(
"If this is true, then animated vertices will be created with 4-component "
307 "floats and aligned to 16-byte boundaries, to allow efficient vectorization "
308 "(e.g. SSE2) operations when computing animations. If this is false, "
309 "animated vertices will be packed as tightly as possible, in the normal way, "
310 "which will optimize the amount of memory that must be sent to the graphics "
311 "card, but prevent the use of SSE2 to calculate animation. This does not "
312 "affect unanimated vertices, which are always packed tightly. This also "
313 "impacts only vertex formats created within Panda subsystems; custom "
314 "vertex formats are not affected."));
317 (
"textures-power-2", ATS_down,
318 PRC_DESC(
"Specify whether textures should automatically be constrained to "
319 "dimensions which are a power of 2 when they are loaded from "
320 "disk. Set this to 'none' to disable this feature, or to "
321 "'down' or 'up' to scale down or up to the nearest power of 2, "
322 "respectively. This only has effect on textures which are not "
323 "already a power of 2."));
326 (
"textures-square", ATS_none,
327 PRC_DESC(
"Specify whether textures should automatically be constrained to "
328 "a square aspect ratio when they are loaded from disk. Set this "
329 "to 'none', 'down', or 'up'. See textures-power-2."));
332 (
"textures-auto-power-2",
false,
333 PRC_DESC(
"If this is true, then panda will wait until you open a window, "
334 "and then ask the window if it supports non-power-of-two textures. "
335 "If so, then the config variable textures_power_2 will "
336 "automatically be adjusted. The pitfall of doing this is that if "
337 "you then open a second window that doesn't support the same "
338 "capabilities, it will have no choice but to print an error message."));
341 (
"textures-header-only",
false,
342 PRC_DESC(
"If this is true, texture images will not actually be loaded from "
343 "disk, but the image header information will be consulted to verify "
344 "number of channels and so forth. The texture images themselves "
345 "will be generated in a default blue color."));
348 (
"simple-image-size",
"16 16",
349 PRC_DESC(
"This is an x y pair that specifies the maximum size of an "
350 "automatically-generated "
351 "texture simple image. The simple image can displayed before "
352 "the texture has been loaded from disk."));
355 (
"simple-image-threshold", 0.1,
356 PRC_DESC(
"This is a value that indicates how closely a texture's "
358 "image should approximate the original image. The smaller the "
359 "number, the closer the match; small numbers will result in "
360 "simple images close to the maximum size specified by "
361 "simple-image-size. Larger numbers will result in smaller "
362 "simple images. Generally the value should be considerably "
366 (
"shader-utilization", SUT_none,
367 PRC_DESC(
"At times, panda may generate shaders. This variable controls what "
368 "kinds of shaders can be generated. If you set it to SUT_none, "
369 "shader generation will be be disabled. If you set it to SUT_basic, "
370 "then DX9 shaders may be generated, if you set it to SUT_advanced, "
371 "then DX10 shaders may be generated."));
374 (
"shader-auto-utilization",
false,
375 PRC_DESC(
"If this is true, then panda will wait until you open a window, "
376 "and then ask the window if it supports basic or advanced shaders. "
377 "If so, then the config variable shader-utilization will "
378 "automatically be adusted. The pitfall of doing this is that if "
379 "you then open a second window that doesn't support the same "
380 "capabilities, it will have no choice but to print an error message."));
383 (
"geom-cache-size", 5000,
384 PRC_DESC(
"Specifies the maximum number of entries in the cache "
385 "for storing pre-processed data for rendering "
386 "vertices. This limit is flexible, and may be "
387 "temporarily exceeded if many different Geoms are "
388 "pre-processed during the space of a single frame."));
391 (
"geom-cache-min-frames", 1,
392 PRC_DESC(
"Specifies the minimum number of frames any one particular "
393 "object will remain in the geom cache, even if geom-cache-size "
397 (
"released-vbuffer-cache-size", 1048576,
398 PRC_DESC(
"Specifies the size in bytes of the cache of vertex "
399 "buffers that have recently been released. If a new vertex "
400 "buffer is prepared while a recently-released one of the same "
401 "size is still in the cache, that same buffer is recycled. This "
402 "cuts down on the overhead of creating and destroying vertex "
403 "buffers on the graphics card."));
406 (
"released-ibuffer-cache-size", 102400,
407 PRC_DESC(
"Specifies the size in bytes of the cache of index "
408 "buffers that have recently been released. If a new index "
409 "buffer is prepared while a recently-released one of the same "
410 "size is still in the cache, that same buffer is recycled. This "
411 "cuts down on the overhead of creating and destroying index "
412 "buffers on the graphics card."));
415 (
"default-near", 1.0,
416 PRC_DESC(
"The default near clipping distance for all cameras."));
419 (
"default-far", 100000.0,
420 PRC_DESC(
"The default far clipping distance for all cameras."));
423 (
"lens-far-limit", 0.0000001,
424 PRC_DESC(
"This number is used to reduce the effect of numeric inaccuracies "
425 "in Lens::extrude(). It should be a very small, positive number, "
426 "almost zero; set it larger if Lens::extrude() returns values "
427 "that appear meaningless, and set it smaller if you appear to be "
428 "unable to move the far plane out far enough."));
431 (
"default-fov", 30.0,
432 PRC_DESC(
"The default field of view in degrees for all cameras. This is "
433 "defined as a min_fov; that is, it is the field-of-view for the "
434 "smallest of the X and Y sizes of the window, which is usually "
435 "the vertical field of view (windows are usually wider than they "
436 "are tall). For a 4x3 window, 30 degrees vertical is roughly "
437 "40 degrees horizontal."));
441 PRC_DESC(
"The default interocular distance for stereo cameras."));
444 (
"default-converge", 25.0,
445 PRC_DESC(
"The default convergence distance for stereo cameras."));
448 (
"default-keystone", 0.0f,
449 PRC_DESC(
"The default keystone correction, as an x y pair, for all cameras."));
452 (
"vertex-save-file-directory",
"",
453 PRC_DESC(
"The directory in which the saved vertex data file is created "
454 "for saving vertex buffers that have been evicted from RAM. If "
455 "this is the empty string, or an invalid directory, a system "
456 "default directory will be chosen."));
459 (
"vertex-save-file-prefix",
"p3d_vdata_",
460 PRC_DESC(
"A prefix used to generate the filename for the saved vertex "
461 "data file which is created for saving vertex buffers that have "
462 "been evicted from RAM. A uniquifying sequence number and "
463 "filename extension will be appended to this string."));
466 (
"vertex-data-small-size", 64,
467 PRC_DESC(
"When a GeomVertexArrayData is this number of bytes or smaller, it "
468 "is deemed too small to pay the overhead of paging it in and out, "
469 "and it is permanently retained resident."));
472 (
"vertex-data-page-threads", 1,
473 PRC_DESC(
"When this is nonzero (and Panda has been compiled with thread "
474 "support) then this number of sub-threads will be spawned to "
475 "evict vertex pages to disk and read them back again. When this "
476 "is 0, this work will be done in the main thread, which may "
477 "introduce occasional random chugs in rendering."));
480 (
"graphics-memory-limit", -1,
481 PRC_DESC(
"This is a default limit that is imposed on each GSG at "
482 "GSG creation time. It limits the total amount of graphics "
483 "memory, including texture memory and vertex buffer memory, "
484 "that will be consumed by the GSG, regardless of whether the "
485 "hardware claims to provide more graphics memory than this. "
486 "It is useful to put a ceiling on graphics memory consumed, since "
487 "some drivers seem to allow the application to consume more "
488 "memory than the hardware can realistically support. "
489 "Set this to -1 to have no limit other than the normal "
490 "hardware-imposed limit."));
493 (
"sampler-object-limit", 2048,
494 PRC_DESC(
"This is a default limit that is imposed on each GSG at "
495 "GSG creation time. It limits the total amount of sampler "
496 "objects that will be k.ept by the GSG, regardless of whether "
497 "the hardware claims to provide more sampler objects than this. "
498 "Direct3D 10-capable hardware supports at least 4096 distinct "
499 "sampler objects, but we provide a slightly more conservative "
500 "limit by default."));
503 (
"adaptive-lru-weight", 0.2,
504 PRC_DESC(
"Specifies the weight factor used to compute the AdaptiveLru's "
505 "exponential moving average."));
508 (
"adaptive-lru-max-updates-per-frame", 40,
509 PRC_DESC(
"The number of pages the AdaptiveLru class will update per "
510 "frame. Do not set this too high or it will degrade "
514 (
"async-load-delay", 0.0,
515 PRC_DESC(
"If this is nonzero, it represents an artificial delay, "
516 "in seconds, that is imposed on every asynchronous load attempt "
517 "(within the thread). Its purpose is to help debug errors that "
518 "may occur when an asynchronous load is delayed. The "
519 "delay is per-model, and all aync loads will be queued "
520 "up behind the delay--it is as if the time it takes to read a "
521 "file is increased by this amount per read."));
524 (
"lens-geom-segments", 50,
525 PRC_DESC(
"This is the number of times to subdivide the visualization "
526 "wireframe created when Lens::make_geometry() (or "
527 "LensNode::show_frustum()) is called, for representing accurate "
528 "curves. Note that this is only "
529 "used for a nonlinear lens such as a cylindrical or fisheye "
530 "lens; for a normal perspective or orthographic lens, the "
531 "wireframe is not subdivided."));
534 (
"stereo-lens-old-convergence",
false,
535 PRC_DESC(
"In Panda3D 1.8 and below, when using a stereo lens, Panda "
536 "generate an incorrect frustum skew for a given convergence "
537 "distance, meaning that the left-right images wouldn't "
538 "overlap at the configured distance. This calculation has "
539 "since been corrected, but if your application relies on the "
540 "old, incorrect behavior, this may be set to 'true' to switch "
541 "back to the old calculation."));
544 (
"cg-glsl-version",
"",
545 PRC_DESC(
"If this is set, it forces the Cg compiler to generate GLSL "
546 "code conforming to the given GLSL version when using the "
547 "glslv, glslf or glslg profiles. Use this when you are having "
548 "problems with these profiles. Example values are 120 or 150."));
551 (
"glsl-preprocess",
true,
552 PRC_DESC(
"If this is enabled, Panda looks for lines starting with "
553 "#pragma include when loading a GLSL shader and processes "
554 "it appropriately. This can be useful if you have code that "
555 "is shared between multiple shaders. Set this to false if "
556 "you have no need for this feature or if you do your own "
557 "preprocessing of GLSL shaders."));
560 (
"glsl-include-recursion-limit", 10,
561 PRC_DESC(
"This sets a limit on how many nested #pragma include "
562 "directives that Panda will follow when glsl-preprocess is "
563 "enabled. This is used to prevent infinite recursion when "
564 "two shader files include each other."));
566 ConfigureFn(config_gobj) {
567 AnimateVerticesRequest::init_type();
568 BufferContext::init_type();
570 GeomCacheEntry::init_type();
571 GeomPipelineReader::init_type();
572 GeomContext::init_type();
573 GeomLines::init_type();
574 GeomLinestrips::init_type();
575 GeomMunger::init_type();
576 GeomPoints::init_type();
577 GeomPrimitive::init_type();
578 GeomPrimitivePipelineReader::init_type();
579 GeomTriangles::init_type();
580 GeomTrifans::init_type();
581 GeomTristrips::init_type();
582 GeomPatches::init_type();
583 GeomVertexArrayData::init_type();
584 GeomVertexArrayDataHandle::init_type();
585 GeomVertexArrayFormat::init_type();
586 GeomVertexData::init_type();
587 GeomVertexDataPipelineReader::init_type();
588 GeomVertexDataPipelineWriter::init_type();
589 GeomVertexFormat::init_type();
590 IndexBufferContext::init_type();
591 InternalName::init_type();
593 Material::init_type();
594 MatrixLens::init_type();
595 OcclusionQueryContext::init_type();
596 OrthographicLens::init_type();
597 ParamTextureImage::init_type();
598 ParamTextureSampler::init_type();
599 PerspectiveLens::init_type();
600 QueryContext::init_type();
601 SamplerContext::init_type();
602 SamplerState::init_type();
603 ShaderContext::init_type();
605 SliderTable::init_type();
606 Texture::init_type();
607 TextureContext::init_type();
608 TexturePoolFilter::init_type();
609 TextureReloadRequest::init_type();
610 TextureStage::init_type();
611 TimerQueryContext::init_type();
612 TransformBlend::init_type();
613 TransformBlendTable::init_type();
614 TransformTable::init_type();
615 UserVertexSlider::init_type();
616 UserVertexTransform::init_type();
617 VertexBufferContext::init_type();
618 VertexSlider::init_type();
619 VertexDataBuffer::init_type();
620 VertexDataPage::init_type();
621 VertexTransform::init_type();
622 VideoTexture::init_type();
635 GeomVertexArrayFormat::register_with_read_factory();
637 GeomVertexFormat::register_with_read_factory();
638 InternalName::register_with_read_factory();
656 operator << (ostream &out, ShaderUtilization sgc) {
659 return out <<
"none";
662 return out <<
"basic";
665 return out <<
"advanced";
667 case SUT_unspecified:
668 return out <<
"unspecified";
671 return out <<
"**invalid ShaderUtilization (" << (int)sgc <<
")**";
675 operator >> (istream &in, ShaderUtilization &sgc) {
679 if (cmp_nocase(word,
"none") == 0 ||
680 cmp_nocase(word,
"0") == 0 ||
681 cmp_nocase(word,
"#f") == 0 ||
682 (!word.empty() && tolower(word[0]) ==
'f')) {
685 }
else if (cmp_nocase(word,
"basic") == 0 ||
686 cmp_nocase(word,
"1") == 0 ||
687 cmp_nocase(word,
"#t") == 0 ||
688 (!word.empty() && tolower(word[0]) ==
't')) {
691 }
else if (cmp_nocase(word,
"advanced") == 0) {
695 gobj_cat->error() <<
"Invalid ShaderUtilization value: " << word <<
"\n";
static void register_with_read_factory()
Tells the BamReader how to create objects of type Shader.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Lens.
This is a convenience class to specialize ConfigVariable as a Filename type.
This is a convenience class to specialize ConfigVariable as a boolean type.
static void register_with_read_factory()
Tells the BamReader how to create objects of type ParamValue.
static void register_with_read_factory()
Factory method to generate a Texture object.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
static void register_with_read_factory()
Tells the BamReader how to create objects of type UserVertexSlider.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Lens.
This class is similar to ConfigVariable, but it reports its value as a list of strings.
This is a convenience class to specialize ConfigVariable as a floating-point type.
static void register_with_read_factory()
Factory method to generate a TextureStage object.
This is a convenience class to specialize ConfigVariable as a string type.
This class specializes ConfigVariable as an enumerated type.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
static void register_with_read_factory()
Tells the BamReader how to create objects of type ParamValue.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Lens.
static void register_with_read_factory()
Tells the BamReader how to create objects of type SliderTable.
This is a convenience class to specialize ConfigVariable as an integer type.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
static void register_with_read_factory()
Tells the BamReader how to create objects of type GeomVertexArrayData.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
static void register_with_read_factory()
Factory method to generate a Material object.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
static void register_with_read_factory()
Tells the BamReader how to create objects of type GeomVertexData.