73 #if !defined(CPPPARSER) && !defined(LINK_ALL_STATIC) && !defined(BUILDING_PANDA_GOBJ) 74 #error Buildsystem error: BUILDING_PANDA_GOBJ not defined 77 Configure(config_gobj);
78 NotifyCategoryDef(gobj,
"");
79 NotifyCategoryDef(shader,
"");
82 (
"max-texture-dimension", -1,
83 PRC_DESC(
"Set this to the maximum size a texture is allowed to be in either " 84 "dimension. This is generally intended as a simple way to restrict " 85 "texture sizes for limited graphics cards. When this is greater " 86 "than zero, each texture image loaded from a file (but only those " 87 "loaded from a file) will be automatically scaled down, if " 88 "necessary, so that neither dimension is larger than this value. " 89 "If this is less than zero, the size limit is taken from the " 90 "primary GSG. If this is exactly zero, there is no limit."));
93 (
"texture-scale", 1.0,
94 PRC_DESC(
"This is a global scale factor that is applied to each texture " 95 "as it is loaded from disk. For instance, a value of 0.5 will " 96 "reduce each texture to one-half its size in each dimension. This " 97 "scale factor is applied before textures-power-2 or " 98 "max-texture-dimension."));
101 (
"texture-scale-limit", 4,
102 PRC_DESC(
"This specifies the limit below which texture-scale will not " 103 "reduce a texture image. This is a single dimension which applies " 104 "to both X and Y."));
107 (
"exclude-texture-scale",
108 PRC_DESC(
"This is a list of glob patterns for texture filenames " 109 "(excluding the directory part of the filename, but including " 110 "the extension); for instance, 'digits_*.png'. Any texture " 111 "filenames that match one of these patterns will not be affected " 112 "by max-texture-dimension or texture-scale."));
115 (
"keep-texture-ram",
false,
116 PRC_DESC(
"Set this to true to retain the ram image for each texture after it " 117 "has been prepared with the GSG. This will allow the texture to be " 118 "prepared with multiple GSG's, or to be re-prepared later after it is " 119 "explicitly released from the GSG, without having to reread the " 120 "texture image from disk; but it will consume memory somewhat " 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 (
"vertices-float64",
false,
265 PRC_DESC(
"When this is true, the default float format for vertices " 266 "will be a 64-bit double-precision float, instead " 267 "of the normal 32-bit single-precision float. This must be set " 268 "at static init time to have the broadest effect. You almost never " 269 "want to set this true, since current hardware does not support " 270 "double-precision vertices, and setting this will just require the " 271 "driver to downsample the vertices at load time, making everything " 275 (
"vertex-column-alignment", 4,
276 PRC_DESC(
"This specifies the default byte alignment for each column of " 277 "data within a GeomVertexData when it is assembled using the default " 278 "interfaces. Normally, you should not change this config variable " 279 "(which would change this value globally), but instead specify any " 280 "alignment requirements on a per-column basis as you construct a " 281 "GeomVertexFormat. Setting this value globally could result in " 282 "much needless wasted space in all vertex data objects, but it " 283 "could be useful for simple experiments. Also see " 284 "vertex-animation-align-16 for a variable that controls " 285 "this alignment for the vertex animation columns only."));
288 (
"vertex-animation-align-16",
294 PRC_DESC(
"If this is true, then animated vertices will be created with 4-component " 295 "floats and aligned to 16-byte boundaries, to allow efficient vectorization " 296 "(e.g. SSE2) operations when computing animations. If this is false, " 297 "animated vertices will be packed as tightly as possible, in the normal way, " 298 "which will optimize the amount of memory that must be sent to the graphics " 299 "card, but prevent the use of SSE2 to calculate animation. This does not " 300 "affect unanimated vertices, which are always packed tightly. This also " 301 "impacts only vertex formats created within Panda subsystems; custom " 302 "vertex formats are not affected."));
305 (
"textures-power-2", ATS_down,
306 PRC_DESC(
"Specify whether textures should automatically be constrained to " 307 "dimensions which are a power of 2 when they are loaded from " 308 "disk. Set this to 'none' to disable this feature, or to " 309 "'down' or 'up' to scale down or up to the nearest power of 2, " 310 "respectively. This only has effect on textures which are not " 311 "already a power of 2."));
314 (
"textures-square", ATS_none,
315 PRC_DESC(
"Specify whether textures should automatically be constrained to " 316 "a square aspect ratio when they are loaded from disk. Set this " 317 "to 'none', 'down', or 'up'. See textures-power-2."));
320 (
"textures-auto-power-2",
false,
321 PRC_DESC(
"If this is true, then panda will wait until you open a window, " 322 "and then ask the window if it supports non-power-of-two textures. " 323 "If so, then the config variable textures_power_2 will " 324 "automatically be adjusted. The pitfall of doing this is that if " 325 "you then open a second window that doesn't support the same " 326 "capabilities, it will have no choice but to print an error message."));
329 (
"textures-header-only",
false,
330 PRC_DESC(
"If this is true, texture images will not actually be loaded from " 331 "disk, but the image header information will be consulted to verify " 332 "number of channels and so forth. The texture images themselves " 333 "will be generated in a default blue color."));
336 (
"simple-image-size",
"16 16",
337 PRC_DESC(
"This is an x y pair that specifies the maximum size of an " 338 "automatically-generated " 339 "texture simple image. The simple image can displayed before " 340 "the texture has been loaded from disk."));
343 (
"simple-image-threshold", 0.1,
344 PRC_DESC(
"This is a value that indicates how closely a texture's " 346 "image should approximate the original image. The smaller the " 347 "number, the closer the match; small numbers will result in " 348 "simple images close to the maximum size specified by " 349 "simple-image-size. Larger numbers will result in smaller " 350 "simple images. Generally the value should be considerably " 354 (
"geom-cache-size", 5000,
355 PRC_DESC(
"Specifies the maximum number of entries in the cache " 356 "for storing pre-processed data for rendering " 357 "vertices. This limit is flexible, and may be " 358 "temporarily exceeded if many different Geoms are " 359 "pre-processed during the space of a single frame."));
362 (
"geom-cache-min-frames", 1,
363 PRC_DESC(
"Specifies the minimum number of frames any one particular " 364 "object will remain in the geom cache, even if geom-cache-size " 368 (
"released-vbuffer-cache-size", 1048576,
369 PRC_DESC(
"Specifies the size in bytes of the cache of vertex " 370 "buffers that have recently been released. If a new vertex " 371 "buffer is prepared while a recently-released one of the same " 372 "size is still in the cache, that same buffer is recycled. This " 373 "cuts down on the overhead of creating and destroying vertex " 374 "buffers on the graphics card."));
377 (
"released-ibuffer-cache-size", 102400,
378 PRC_DESC(
"Specifies the size in bytes of the cache of index " 379 "buffers that have recently been released. If a new index " 380 "buffer is prepared while a recently-released one of the same " 381 "size is still in the cache, that same buffer is recycled. This " 382 "cuts down on the overhead of creating and destroying index " 383 "buffers on the graphics card."));
386 (
"default-near", 1.0,
387 PRC_DESC(
"The default near clipping distance for all cameras."));
390 (
"default-far", 100000.0,
391 PRC_DESC(
"The default far clipping distance for all cameras."));
394 (
"lens-far-limit", 0.0000001,
395 PRC_DESC(
"This number is used to reduce the effect of numeric inaccuracies " 396 "in Lens::extrude(). It should be a very small, positive number, " 397 "almost zero; set it larger if Lens::extrude() returns values " 398 "that appear meaningless, and set it smaller if you appear to be " 399 "unable to move the far plane out far enough."));
402 (
"default-fov", 30.0,
403 PRC_DESC(
"The default field of view in degrees for all cameras. This is " 404 "defined as a min_fov; that is, it is the field-of-view for the " 405 "smallest of the X and Y sizes of the window, which is usually " 406 "the vertical field of view (windows are usually wider than they " 407 "are tall). For a 4x3 window, 30 degrees vertical is roughly " 408 "40 degrees horizontal."));
412 PRC_DESC(
"The default interocular distance for stereo cameras."));
415 (
"default-converge", 25.0,
416 PRC_DESC(
"The default convergence distance for stereo cameras."));
419 (
"default-keystone", 0.0f,
420 PRC_DESC(
"The default keystone correction, as an x y pair, for all cameras."));
423 (
"vertex-save-file-directory",
"",
424 PRC_DESC(
"The directory in which the saved vertex data file is created " 425 "for saving vertex buffers that have been evicted from RAM. If " 426 "this is the empty string, or an invalid directory, a system " 427 "default directory will be chosen."));
430 (
"vertex-save-file-prefix",
"p3d_vdata_",
431 PRC_DESC(
"A prefix used to generate the filename for the saved vertex " 432 "data file which is created for saving vertex buffers that have " 433 "been evicted from RAM. A uniquifying sequence number and " 434 "filename extension will be appended to this string."));
437 (
"vertex-data-small-size", 64,
438 PRC_DESC(
"When a GeomVertexArrayData is this number of bytes or smaller, it " 439 "is deemed too small to pay the overhead of paging it in and out, " 440 "and it is permanently retained resident."));
443 (
"vertex-data-page-threads", 1,
444 PRC_DESC(
"When this is nonzero (and Panda has been compiled with thread " 445 "support) then this number of sub-threads will be spawned to " 446 "evict vertex pages to disk and read them back again. When this " 447 "is 0, this work will be done in the main thread, which may " 448 "introduce occasional random chugs in rendering."));
451 (
"graphics-memory-limit", -1,
452 PRC_DESC(
"This is a default limit that is imposed on each GSG at " 453 "GSG creation time. It limits the total amount of graphics " 454 "memory, including texture memory and vertex buffer memory, " 455 "that will be consumed by the GSG, regardless of whether the " 456 "hardware claims to provide more graphics memory than this. " 457 "It is useful to put a ceiling on graphics memory consumed, since " 458 "some drivers seem to allow the application to consume more " 459 "memory than the hardware can realistically support. " 460 "Set this to -1 to have no limit other than the normal " 461 "hardware-imposed limit."));
464 (
"sampler-object-limit", 2048,
465 PRC_DESC(
"This is a default limit that is imposed on each GSG at " 466 "GSG creation time. It limits the total amount of sampler " 467 "objects that will be k.ept by the GSG, regardless of whether " 468 "the hardware claims to provide more sampler objects than this. " 469 "Direct3D 10-capable hardware supports at least 4096 distinct " 470 "sampler objects, but we provide a slightly more conservative " 471 "limit by default."));
474 (
"adaptive-lru-weight", 0.2,
475 PRC_DESC(
"Specifies the weight factor used to compute the AdaptiveLru's " 476 "exponential moving average."));
479 (
"adaptive-lru-max-updates-per-frame", 40,
480 PRC_DESC(
"The number of pages the AdaptiveLru class will update per " 481 "frame. Do not set this too high or it will degrade " 485 (
"async-load-delay", 0.0,
486 PRC_DESC(
"If this is nonzero, it represents an artificial delay, " 487 "in seconds, that is imposed on every asynchronous load attempt " 488 "(within the thread). Its purpose is to help debug errors that " 489 "may occur when an asynchronous load is delayed. The " 490 "delay is per-model, and all aync loads will be queued " 491 "up behind the delay--it is as if the time it takes to read a " 492 "file is increased by this amount per read."));
495 (
"lens-geom-segments", 50,
496 PRC_DESC(
"This is the number of times to subdivide the visualization " 497 "wireframe created when Lens::make_geometry() (or " 498 "LensNode::show_frustum()) is called, for representing accurate " 499 "curves. Note that this is only " 500 "used for a nonlinear lens such as a cylindrical or fisheye " 501 "lens; for a normal perspective or orthographic lens, the " 502 "wireframe is not subdivided."));
505 (
"stereo-lens-old-convergence",
false,
506 PRC_DESC(
"In Panda3D 1.8 and below, when using a stereo lens, Panda " 507 "generate an incorrect frustum skew for a given convergence " 508 "distance, meaning that the left-right images wouldn't " 509 "overlap at the configured distance. This calculation has " 510 "since been corrected, but if your application relies on the " 511 "old, incorrect behavior, this may be set to 'true' to switch " 512 "back to the old calculation."));
515 (
"basic-shaders-only",
false,
516 PRC_DESC(
"Set this to true if you aren't interested in shader model three " 517 "and beyond. Setting this flag will cause panda to disable " 518 "bleeding-edge shader functionality which tends to be unreliable " 519 "or broken. At some point, when functionality that is currently " 520 "flaky becomes reliable, we may expand the definition of what " 521 "constitutes 'basic' shaders."));
524 (
"cg-glsl-version",
"",
525 PRC_DESC(
"If this is set, it forces the Cg compiler to generate GLSL " 526 "code conforming to the given GLSL version when using the " 527 "glslv, glslf or glslg profiles. Use this when you are having " 528 "problems with these profiles. Example values are 120 or 150."));
531 (
"glsl-preprocess",
true,
532 PRC_DESC(
"If this is enabled, Panda looks for lines starting with " 533 "#pragma include when loading a GLSL shader and processes " 534 "it appropriately. This can be useful if you have code that " 535 "is shared between multiple shaders. Set this to false if " 536 "you have no need for this feature or if you do your own " 537 "preprocessing of GLSL shaders."));
540 (
"glsl-include-recursion-limit", 10,
541 PRC_DESC(
"This sets a limit on how many nested #pragma include " 542 "directives that Panda will follow when glsl-preprocess is " 543 "enabled. This is used to prevent infinite recursion when " 544 "two shader files include each other."));
546 ConfigureFn(config_gobj) {
547 AnimateVerticesRequest::init_type();
548 BufferContext::init_type();
550 GeomCacheEntry::init_type();
551 GeomPipelineReader::init_type();
552 GeomContext::init_type();
553 GeomLines::init_type();
554 GeomLinesAdjacency::init_type();
555 GeomLinestrips::init_type();
556 GeomLinestripsAdjacency::init_type();
557 GeomMunger::init_type();
558 GeomPoints::init_type();
559 GeomPrimitive::init_type();
560 GeomPrimitivePipelineReader::init_type();
561 GeomTriangles::init_type();
562 GeomTrianglesAdjacency::init_type();
563 GeomTrifans::init_type();
564 GeomTristrips::init_type();
565 GeomTristripsAdjacency::init_type();
566 GeomPatches::init_type();
567 GeomVertexArrayData::init_type();
568 GeomVertexArrayDataHandle::init_type();
569 GeomVertexArrayFormat::init_type();
570 GeomVertexData::init_type();
571 GeomVertexDataPipelineReader::init_type();
572 GeomVertexDataPipelineWriter::init_type();
573 GeomVertexFormat::init_type();
574 IndexBufferContext::init_type();
575 InternalName::init_type();
577 Material::init_type();
578 MatrixLens::init_type();
579 OcclusionQueryContext::init_type();
580 OrthographicLens::init_type();
581 ParamTextureImage::init_type();
582 ParamTextureSampler::init_type();
583 PerspectiveLens::init_type();
584 PreparedGraphicsObjects::EnqueuedObject::init_type();
585 QueryContext::init_type();
586 SamplerContext::init_type();
587 SamplerState::init_type();
588 ShaderContext::init_type();
590 SliderTable::init_type();
591 Texture::init_type();
592 TextureContext::init_type();
593 TexturePoolFilter::init_type();
594 TextureReloadRequest::init_type();
595 TextureStage::init_type();
596 TimerQueryContext::init_type();
597 TransformBlend::init_type();
598 TransformBlendTable::init_type();
599 TransformTable::init_type();
600 UserVertexSlider::init_type();
601 UserVertexTransform::init_type();
602 VertexBufferContext::init_type();
603 VertexSlider::init_type();
604 VertexDataBuffer::init_type();
605 VertexDataPage::init_type();
606 VertexTransform::init_type();
607 VideoTexture::init_type();
612 GeomLines::register_with_read_factory();
613 GeomLinesAdjacency::register_with_read_factory();
616 GeomPoints::register_with_read_factory();
617 GeomTriangles::register_with_read_factory();
618 GeomTrianglesAdjacency::register_with_read_factory();
619 GeomTrifans::register_with_read_factory();
622 GeomPatches::register_with_read_factory();
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Shader.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Lens.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Factory method to generate a InternalName object.
This is a convenience class to specialize ConfigVariable as a Filename type.
This is a convenience class to specialize ConfigVariable as a boolean type.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
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.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type UserVertexSlider.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Lens.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
This class is similar to ConfigVariable, but it reports its value as a list of strings.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
This is a convenience class to specialize ConfigVariable as a floating- point type.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Factory method to generate a TextureStage object.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
This is a convenience class to specialize ConfigVariable as a string type.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
This class specializes ConfigVariable as an enumerated type.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type ParamValue.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Lens.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
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.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
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.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type Geom.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Factory method to generate a Material object.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
static void register_with_read_factory()
Tells the BamReader how to create objects of type GeomVertexData.