Panda3D

Loading...
Searching...
No Matches
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1 2 3]

►N std | STL namespace
C owner_less< ConstPointerTo< T > > |
C owner_less< PointerTo< T > > |
C owner_less< WeakConstPointerTo< T > > |
C owner_less< WeakPointerTo< T > > |
C_XRRCrtcInfo |
C_XRRModeInfo |
C_XRRScreenResources |
C AccumulatedAttribs | This class is used by the SceneGraphReducer to maintain and accumulate the set of attributes we have encountered on each node that might eventually be applied to the vertices at the leaves
C ACMatrixSwitchType |
C ACScalarSwitchType |
C ActorNode | Like a physical node, but with a little more
C AdaptiveLru | A basic LRU-type algorithm, except that it is adaptive and attempts to avoid evicting pages that have been used more frequently (even if less recently) than other pages
C AdaptiveLruPage | One atomic piece that may be managed by a AdaptiveLru chain
C AdaptiveLruPageDynamicList |
C AdaptiveLruPageStaticList |
C AddHash | This class is used just as a namespace scope to collect together a handful of static functions, which are used to wrap calls to Bob Jenkins' public- domain hash generation function (defined in lookup3.c)
C AIBehaviors | This class implements all the steering behaviors of the AI framework, such as seek, flee, pursue, evade, wander and flock
C AICharacter |
C AINode | This class is used to assign the nodes on the mesh
C AIWorld | A class that implements the virtual AI world which keeps track of the AI characters active at any given time
C AlphaTestAttrib | Enables or disables writing of pixel to framebuffer based on its alpha value relative to a reference alpha value
C AmbientLight | A light source that seems to illuminate all points in space at once
C AnalogNode | This is the primary interface to analog controls like sliders and joysticks associated with a ClientBase
C AndroidGraphicsPipe | This graphics pipe represents the interface for creating OpenGL ES graphics windows on an X-based (e.g
C AndroidGraphicsStateGuardian | A tiny specialization on GLESGraphicsStateGuardian to add some egl-specific information
C AndroidGraphicsWindow | An interface to manage Android windows and their appropriate EGL surfaces
C AngularEulerIntegrator | Performs Euler integration on a vector of physically modelable objects given a quantum dt
C AngularForce | Pure virtual parent of all quat-based forces
C AngularIntegrator | Pure virtual base class for physical modeling
C AngularVectorForce | Simple directed torque force, the angular equivalent of simple vector force
C AnimateVerticesRequest | This class object manages a single asynchronous request to animate vertices on a GeomVertexData object
C AnimBundle | This is the root of an AnimChannel hierarchy
C AnimBundleMaker | Converts an EggTable hierarchy, beginning with a <Bundle> entry, into an AnimBundle hierarchy
C AnimBundleNode | This is a node that contains a pointer to an AnimBundle
C AnimChannel | This template class is the parent class for all kinds of AnimChannels that return different values
C AnimChannelBase | Parent class for all animation channels
C AnimChannelFixed | This template class is a special kind of AnimChannel that always returns just one fixed value
C AnimChannelMatrixDynamic | An animation channel that accepts a matrix each frame from some dynamic input provided by code
C AnimChannelMatrixFixed | A specialization on AnimChannel to add all the special matrix component operations
C AnimChannelMatrixXfmTable | An animation channel that issues a matrix each frame, read from a table such as might have been read from an egg file
C AnimChannelScalarDynamic | An animation channel that accepts a scalar each frame from some dynamic input provided by code
C AnimChannelScalarTable | An animation channel that issues a scalar each frame, read from a table such as might have been read from an egg file
C AnimControl | Controls the timing of a character animation
C AnimControlCollection | This is a named collection of AnimControl pointers
C AnimGroup | This is the base class for AnimChannel and AnimBundle
C AnimInterface | This is the fundamental interface for things that have a play/loop/stop type interface for frame-based animation, such as animated characters
►C AnimPreloadTable | This table records data about a list of animations for a particular model, such as number of frames and frame rate
C AnimRecord |
C AntialiasAttrib | Specifies whether or how to enable antialiasing, if supported by the backend renderer
C ArcEmitter | Describes a planar ring region in which particles are generated
►C array | STL class
C const_iterator | STL iterator class
C const_reverse_iterator | STL iterator class
C iterator | STL iterator class
C reverse_iterator | STL iterator class
C Arrival |
C AssimpLoader | Class that interfaces with Assimp and builds Panda nodes to represent the Assimp structures
C AsyncFuture | This class represents a thread-safe handle to a promised future result of an asynchronous operation, providing methods to query its status and result as well as register callbacks for this future's completion
C AsyncGatheringFuture | Specific future that collects the results of several futures
C AsyncTask | This class represents a concrete task performed by an AsyncManager
C AsyncTaskChain | The AsyncTaskChain is a subset of the AsyncTaskManager
C AsyncTaskCollection | A list of tasks, for instance as returned by some of the AsyncTaskManager query functions
C AsyncTaskManager | A class to manage a loose queue of isolated tasks, which can be performed either synchronously (in the foreground thread) or asynchronously (by a background thread)
C AsyncTaskPause | A special kind of task that simple returns DS_pause, to pause for a specified number of seconds and then finish
C AsyncTaskSequence | A special kind of task that serves as a list of tasks internally
C AtomicAdjustDummyImpl | A trivial implementation for atomic adjustments for systems that don't require multiprogramming, and therefore don't require special atomic operations
C AttribNodeRegistry | This global object records NodePaths that are referenced by scene graph attribs, such as ClipPlaneAttribs and LightAttribs
C AudioLoadRequest | A class object that manages a single asynchronous audio load request
C AudioManager |
C AudioSound |
C AudioVolumeAttrib | Applies a scale to audio volume for positional sounds in the scene graph
C AuxBitplaneAttrib | Modern frame buffers can have 'aux' bitplanes, which are additional bitplanes above and beyond the standard depth and color
C AuxSceneData | This is a base class for a generic data structure that can be attached per- instance to the camera, to store per-instance data that must be preserved over multiple frames
C BamCache | This class maintains a cache of Bam and/or Txo objects generated from model files and texture images (as well as possibly other kinds of loadable objects that can be stored in bam file format)
C BamCacheIndex | This represents the in-memory index that records the list of files stored in the BamCache
C BamCacheRecord | An instance of this class is written to the front of a Bam or Txo file to make the file a cached instance of some other loadable resource
C BamEnums | This class exists just to provide scoping for the enums shared by BamReader and BamWriter
C BamFile | The principle public interface to reading and writing Bam disk files
C BamInfo |
►C BamReader | This is the fundamental interface for extracting binary objects from a Bam file, as generated by a BamWriter
C AuxData |
C BamReaderAuxData | Stores auxiliary data that may be piggybacked on the BamReader during each object's read pass
C BamReaderParam | The parameters that are passed through the Factory to any object constructing itself from a Bam file
C BamToEgg | This program reads a bam file, for instance as written out from a real-time interaction session, and generates a corresponding egg file
C BamWriter | This is the fundamental interface for writing binary objects to a Bam file, to be extracted later by a BamReader
C BaseForce | Pure virtual base class for all forces that could POSSIBLY exist
C BaseIntegrator | Pure virtual integrator class that holds cached matrix information that really should be common to any possible child implementation
C BaseParticle | An individual, physically-modelable particle abstract base class
C BaseParticleEmitter |
C BaseParticleFactory | Pure Virtual base class for creating particles
C BaseParticleRenderer | Pure virtual particle renderer base class
C BasicSkel | This is the most basic of the skeleton classes
C BillboardEffect | Indicates that geometry at this node should automatically rotate to face the camera, or any other arbitrary node
C BinCullHandler | This CullHandler sends all of the geoms it receives into a CullResult object, for binning (and later drawing)
C BindAnimRequest | This class object manages an asynchronous load-and-bind animation request, as issued through PartBundle::load_bind_anim()
C BinToC | A utility program to read a (binary) file and output a table that can be compiled via a C compiler to generate the same data
C BitArray | A dynamic array with an unlimited number of bits
C BitMask | A general bitmask class
C BoundingBox | An axis-aligned bounding box; that is, a minimum and maximum coordinate triple
C BoundingHexahedron | This defines a bounding convex hexahedron
C BoundingLine | This funny bounding volume is an infinite line with no thickness and extending to infinity in both directions
C BoundingPlane | This funny bounding volume is an infinite plane that divides space into two regions: the part behind the normal, which is "inside" the bounding volume, and the part in front of the normal, which is "outside" the bounding volume
C BoundingSphere | This defines a bounding sphere, consisting of a center and a radius
C BoundingVolume | This is an abstract class for any volume in any sense which can be said to define the locality of reference of a node in a graph, along with all of its descendants
C BoxEmitter | Describes a voluminous box region in which particles are generated
C Buffer |
C BufferContext | This is a base class for those kinds of SavedContexts that occupy an easily-measured (and substantial) number of bytes in the video card's frame buffer memory or AGP memory
C BufferContextChain | This class maintains a linked list of BufferContexts that might be allocated on the graphics card in some context
C Buffered_DatagramConnection |
C Buffered_DatagramReader |
C Buffered_DatagramWriter | This is the buffered writer
C BufferResidencyTracker | This class is used to keep track of the current state of all the BufferContexts for a particular graphics context: whether each one is active (rendered this frame) or inactive (not rendered this frame), and whether it is resident or nonresident in video memory
C BulletAllHitsRayResult |
C BulletBaseCharacterControllerNode |
C BulletBodyNode |
C BulletBoxShape |
C BulletCapsuleShape |
C BulletCharacterControllerNode |
C BulletClosestHitRayResult |
C BulletClosestHitSweepResult |
C BulletConeShape |
C BulletConeTwistConstraint |
C BulletConstraint |
C BulletContact |
C BulletContactCallbackData |
C BulletContactResult |
C BulletConvexHullShape |
C BulletConvexPointCloudShape |
C BulletCylinderShape |
C BulletDebugNode |
C BulletFilterCallbackData |
C BulletGenericConstraint |
C BulletGhostNode |
C BulletHeightfieldShape |
C BulletHelper |
C BulletHingeConstraint | The hinge constraint lets two bodies rotate around a given axis while adhering to specified limits
C BulletManifoldPoint |
C BulletMinkowskiSumShape |
C BulletMultiSphereShape |
C BulletPersistentManifold |
C BulletPlaneShape |
C BulletRayHit |
C BulletRigidBodyNode |
C BulletRotationalLimitMotor | Rotation Limit structure for generic joints
C BulletShape |
C BulletSliderConstraint |
C BulletSoftBodyConfig |
C BulletSoftBodyControl |
C BulletSoftBodyMaterial |
C BulletSoftBodyNode |
C BulletSoftBodyNodeElement |
C BulletSoftBodyShape |
C BulletSoftBodyWorldInfo |
C BulletSphereShape |
C BulletSphericalConstraint | A constraint between two rigid bodies, each with a pivot point
C BulletTickCallbackData |
C BulletTranslationalLimitMotor | Rotation Limit structure for generic joints
C BulletTriangleMesh |
C BulletTriangleMeshShape |
C BulletVehicle | Simulates a raycast vehicle which casts a ray per wheel at the ground as a cheap replacement for complex suspension simulation
C BulletVehicleTuning |
C BulletWheel | One wheel of a BulletVehicle
C BulletWheelRaycastInfo |
C BulletWorld |
C ButtonEvent | Records a button event of some kind
C ButtonEventList | Records a set of button events that happened recently
C ButtonHandle | A ButtonHandle represents a single button from any device, including keyboard buttons and mouse buttons (but see KeyboardButton and MouseButton)
C ButtonMap | This class represents a map containing all of the buttons of a (keyboard) device, though it can also be used as a generic mapping between ButtonHandles
C ButtonNode | This is the primary interface to on/off button devices associated with a ClientBase
C ButtonRegistry | Maintains all the assigned ButtonHandles in a given system
C ButtonThrower | Throws Panda Events for button down/up events generated within the data graph
C CachedTypedWritableReferenceCount | This is a special extension to ReferenceCount that includes dual reference counts: the standard reference count number, which includes all references to the object, and a separate number (the cache reference count) that counts the number of references to the object just within its cache alone
C CacheStats | This is used to track the utilization of the TransformState and RenderState caches, for low-level performance tuning information
C CallbackData | This is a generic data block that is passed along to a CallbackObject when a callback is made
►C CallbackGraphicsWindow | This special window object doesn't represent a window in its own right, but instead hooks into some third-party API for creating and rendering to windows via callbacks
C EventsCallbackData |
C PropertiesCallbackData |
C RenderCallbackData |
C WindowCallbackData |
C CallbackNode | A special node that can issue arbitrary callbacks to user code, either during the cull or draw traversals
C CallbackObject | This is a generic object that can be assigned to a callback at various points in the rendering process
C Camera | A node that can be positioned around in the scene graph to represent a point of view for rendering a scene
C CardMaker | This class generates 2-d "cards", that is, rectangular polygons, particularly useful for showing textures etc
C CConnectionRepository | This class implements the C++ side of the ConnectionRepository object
C CConstrainHprInterval | A constraint interval that will constrain the orientation of one node to the orientation of another
C CConstrainPosHprInterval | A constraint interval that will constrain the position and orientation of one node to the position and orientation of another
C CConstrainPosInterval | A constraint interval that will constrain the position of one node to the position of another
C CConstraintInterval | The base class for a family of intervals that constrain some property to a value over time
C CConstrainTransformInterval | A constraint interval that will constrain the transform of one node to the transform of another
C CDistributedSmoothNodeBase | This class defines some basic methods of DistributedSmoothNodeBase which have been moved into C++ as a performance optimization
C char_cmp |
C Character | An animated character, with skeleton-morph animation and either soft- skinned or hard-skinned vertices
C CharacterJoint | This represents one joint of the character's animation, containing an animating transform matrix
C CharacterJointBundle | The collection of all the joints and sliders in the character
C CharacterJointEffect | This effect will be added automatically to a node by CharacterJoint::add_net_transform() and CharacterJoint::add_local_transform()
C CharacterMaker | Converts an EggGroup hierarchy, beginning with a group with <Dart> set, to a character node with joints
C CharacterSlider | This is a morph slider within the character
C CharacterVertexSlider | This is a specialization on VertexSlider that returns the slider value associated with a particular CharacterSlider object
C ChecksumHashGenerator | This is a specific kind of HashGenerator that simply adds up all of the ints
C CInterval | The base class for timeline components
C CIntervalManager | This object holds a number of currently-playing intervals and is responsible for advancing them each frame as needed
C CircBuffer | This class implements a queue of some type via a circular buffer
C CLerpAnimEffectInterval | This interval lerps between different amounts of control effects for various AnimControls that might be playing on an actor
C CLerpInterval | The base class for a family of intervals that linearly interpolate one or more numeric values over time
C CLerpNodePathInterval | An interval that lerps one or more properties (like pos, hpr, etc.) on a NodePath over time
C ClientAnalogDevice | A device, attached to the ClientBase by a AnalogNode, that records the data from a single named analog device
C ClientBase | An abstract base class for a family of client device interfaces–including trackers, buttons, dials, and other analog inputs
C ClientButtonDevice | A device, attached to the ClientBase by a ButtonNode, that records the data from a single named button device
C ClientDevice | Any of a number of different devices that might be attached to a ClientBase, including trackers, etc
C ClientDialDevice | A device, attached to the ClientBase by a DialNode, that records the data from a single named dial device
C ClientTrackerDevice | A device, attached to the ClientBase by a TrackerNode, that records the data from a single tracker device
►C ClipPlaneAttrib | This functions similarly to a LightAttrib
C BamAuxData |
C ClockObject | A ClockObject keeps track of elapsed real time and discrete time
C CLwoClip | This class is a wrapper around LwoClip and stores additional information useful during the conversion-to-egg process
C CLwoLayer | This class is a wrapper around LwoLayer and stores additional information useful during the conversion-to-egg process
C CLwoPoints | This class is a wrapper around LwoPoints and stores additional information useful during the conversion-to-egg process
C CLwoPolygons | This class is a wrapper around LwoPolygons and stores additional information useful during the conversion-to-egg process
C CLwoSurface | This class is a wrapper around LwoSurface and stores additional information useful during the conversion-to-egg process
C CLwoSurfaceBlock | This class is a wrapper around LwoSurfaceBlock and stores additional information useful during the conversion-to-egg process
C CLwoSurfaceBlockTMap | This class is a wrapper around LwoSurfaceBlockTMap and stores additional information useful during the conversion-to-egg process
C CMetaInterval | This interval contains a list of nested intervals, each of which has its own begin and end times
C CMotionTrail | The method used in creating the motion trail is based on taking samples of time and transformations (the position and orientation matrix) in real- time
C CMotionTrailFrame |
C CMotionTrailVertex |
C CocoaGraphicsBuffer | This is a light wrapper around GLGraphicsBuffer (ie
C CocoaGraphicsPipe | This graphics pipe represents the interface for creating OpenGL graphics windows on a Cocoa-based (e.g
C CocoaGraphicsStateGuardian | A tiny specialization on GLGraphicsStateGuardian to add some Cocoa-specific information
C CocoaGraphicsWindow | An interface to the Cocoa system for managing OpenGL windows under Mac OS X
C CocoaPandaApp |
C CocoaPandaAppDelegate |
C CocoaPandaView |
C CocoaPandaWindow |
C CocoaPandaWindowDelegate |
►C CollisionBox | A cuboid collision volume or object
C PointDef |
C CollisionCapsule | This implements a solid consisting of a cylinder with hemispherical endcaps, also known as a capsule or a spherocylinder
C CollisionEntry | Defines a single collision event
C CollisionFloorMesh | This object represents a solid made entirely of triangles, which will only be tested again z axis aligned rays
C CollisionGeom | A special CollisionPolygon created just for the purpose of detecting collision against geometry
C CollisionHandler | The abstract interface to a number of classes that decide what to do when a collision is detected
C CollisionHandlerEvent | A specialized kind of CollisionHandler that throws an event for each collision detected
C CollisionHandlerFloor | A specialized kind of CollisionHandler that sets the Z height of the collider to a fixed linear offset from the highest detected collision point each frame
C CollisionHandlerFluidPusher | A CollisionHandlerPusher that makes use of timing and spatial information from fluid collisions to improve collision response
C CollisionHandlerGravity | A specialized kind of CollisionHandler that sets the Z height of the collider to a fixed linear offset from the highest detected collision point each frame
C CollisionHandlerHighestEvent | A specialized kind of CollisionHandler that throws an event for each collision detected
C CollisionHandlerPhysical | The abstract base class for a number of CollisionHandlers that have some physical effect on their moving bodies: they need to update the nodes' positions based on the effects of the collision
C CollisionHandlerPusher | A specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
C CollisionHandlerQueue | A special kind of CollisionHandler that does nothing except remember the CollisionEntries detected the last pass
C CollisionInvSphere | An inverted sphere: this is a sphere whose collision surface is the inside surface of the sphere
C CollisionLevelState | This is the state information the CollisionTraverser retains for each level during traversal
►C CollisionLevelStateBase | This is the state information the CollisionTraverser retains for each level during traversal
C ColliderDef |
C CollisionLine | An infinite line, similar to a CollisionRay, except that it extends in both directions
C CollisionNode | A node in the scene graph that can hold any number of CollisionSolids
C CollisionParabola | This defines a parabolic arc, or subset of an arc, similar to the path of a projectile or falling object
C CollisionPlane |
C CollisionPolygon |
C CollisionRay | An infinite ray, with a specific origin and direction
C CollisionSegment | A finite line segment, with two specific endpoints but no thickness
C CollisionSolid | The abstract base class for all things that can collide with other things in the world, and all the things they can collide with (except geometry)
C CollisionSphere | A spherical collision volume or object
C CollisionTraverser | This class manages the traversal through the scene graph to detect collisions
C ColorAttrib | Indicates what color should be applied to renderable geometry
C ColorBlendAttrib | This specifies how colors are blended into the frame buffer, for special effects
C colorhist_item |
C colorhist_list_item |
C ColorInterpolationFunction | Abstract class from which all other functions should inherit
C ColorInterpolationFunctionConstant | Defines a constant color over the lifetime of the segment
C ColorInterpolationFunctionLinear | Defines a linear interpolation over the lifetime of the segment
C ColorInterpolationFunctionSinusoid | Defines a sinusoidal blending between two colors
C ColorInterpolationFunctionStepwave | Defines a discrete cyclical transition between two colors
C ColorInterpolationManager | High level class for color interpolation
C ColorInterpolationSegment | A single unit of interpolation
C ColorScaleAttrib | Applies a scale to colors in the scene graph and on vertices
C ColorWriteAttrib | Enables or disables writing to the color buffer
C compare_to | An STL function object class, this is intended to be used on any ordered collection of class objects that contain a compare_to() method
C CompareTo | An STL function object class, this is intended to be used on any ordered collection of classes that contain a compare_to() method
C CompassEffect | A CompassEffect causes a node to inherit its rotation (or pos or scale, if specified) from some other reference node in the graph, or more often from the root
►C ComputeNode | A special node, the sole purpose of which is to invoke a dispatch operation on the assigned compute shader
►C Dispatcher |
C CData |
C ConditionVar | A condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
C ConditionVarDirect | A condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
C ConditionVarDummyImpl | A fake condition variable implementation for single-threaded applications that don't need any synchronization control
C ConditionVarFull | This class implements a condition variable; see ConditionVar for a brief introduction to this class
C ConditionVarFullDirect | A condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
C ConfigDeclaration | A single declaration of a config variable, typically defined as one line in a .prc file, e.g
C ConfigFlags | This class is the base class of both ConfigVariable and ConfigVariableCore
C ConfigPage | A page of ConfigDeclarations that may be loaded or unloaded
C ConfigPageManager | A global object that maintains the set of ConfigPages everywhere in the world, and keeps them in sorted order
C Configurable | An object that has data or parameters that are set less frequently (at least occasionally) than every frame
C ConfigVariable | This is a generic, untyped ConfigVariable
C ConfigVariableBase | This class is the base class for both ConfigVariableList and ConfigVariable (and hence for all of the ConfigVariableBool, ConfigVaribleString, etc
C ConfigVariableBool | This is a convenience class to specialize ConfigVariable as a boolean type
C ConfigVariableColor | This is a convenience class to specialize ConfigVariable as a set of floating-point types representing a color value
C ConfigVariableCore | The internal definition of a ConfigVariable
C ConfigVariableDouble | This is a convenience class to specialize ConfigVariable as a floating- point type
C ConfigVariableEnum | This class specializes ConfigVariable as an enumerated type
C ConfigVariableFilename | This is a convenience class to specialize ConfigVariable as a Filename type
C ConfigVariableInt | This is a convenience class to specialize ConfigVariable as an integer type
C ConfigVariableInt64 | This is a convenience class to specialize ConfigVariable as a 64-bit integer type
C ConfigVariableList | This class is similar to ConfigVariable, but it reports its value as a list of strings
C ConfigVariableManager | A global object that maintains the set of ConfigVariables (actually, ConfigVariableCores) everywhere in the world, and keeps them in sorted order
C ConfigVariableSearchPath | This is similar to a ConfigVariableList, but it returns its list as a DSearchPath, as a list of directories
C ConfigVariableString | This is a convenience class to specialize ConfigVariable as a string type
C Connection | Represents a single TCP or UDP socket for input or output
C ConnectionListener | This is a special kind of ConnectionReader that waits for activity on a rendezvous port and accepts a TCP connection (instead of attempting to read a datagram from the rendezvous port)
C ConnectionListenerData |
►C ConnectionManager | The primary interface to the low-level networking layer in this package
C Interface |
C ConnectionReader | This is an abstract base class for a family of classes that listen for activity on a socket and respond to it, for instance by reading a datagram and serving it (or queueing it up for later service)
C ConnectionWriter | This class handles threaded delivery of datagrams to various TCP or UDP sockets
C ConstPointerTo | A ConstPointerTo is similar to a PointerTo, except it keeps a const pointer to the thing
C ConstPointerToArray | Similar to PointerToArray, except that its contents may not be modified
C ControllerDemoViewController |
C CopyOnWriteObj | This is similar to RefCountObj, but it implements a CopyOnWriteObject inheritance instead of a ReferenceCount inheritance
C CopyOnWriteObj1 | For objects (e.g
C CopyOnWriteObject | This base class provides basic reference counting, but also can be used with a CopyOnWritePointer to provide get_read_pointer() and get_write_pointer()
C CopyOnWritePointer | This safely stores the primary, owned pointer to a CopyOnWriteObject
C CopyOnWritePointerTo | A template wrapper around the above class, mainly to handle the little typecasting niceties
C CPointerCallbackObject | This is a specialization on CallbackObject to allow association with a C-style function pointer and a void * parameter
C CPT_InternalName | This is a const pointer to an InternalName, and should be used in lieu of a CPT(InternalName) in function arguments
C CubicCurveseg | A CubicCurveseg is any curve that can be completely described by four 4-valued basis vectors, one for each dimension in three-space, and one for the homogeneous coordinate
C CullableObject | The smallest atom of cull
C CullBin | A collection of Geoms and their associated state, for a particular scene
C CullBinAttrib | Assigns geometry to a particular bin by name
C CullBinBackToFront | A specific kind of CullBin that sorts geometry in order from furthest to nearest based on the center of its bounding volume
C CullBinEnums | Provides scoping for the enumerated type shared by CullBin and CullBinManager
C CullBinFixed | A specific kind of CullBin that sorts geometry in the order specified by the user-specified draw_order parameter
C CullBinFrontToBack | A specific kind of CullBin that sorts geometry in order from nearest to furthest based on the center of its bounding volume
C CullBinManager | This is a global object that maintains the collection of named CullBins in the world
C CullBinStateSorted | A specific kind of CullBin that sorts geometry to collect items of the same state together, so that minimal state changes are required on the GSG to render them
C CullBinUnsorted | A specific kind of CullBin that does not reorder the geometry; it simply passes it through to the GSG in the same order it was encountered, which will be in scene-graph order
C CullFaceAttrib | Indicates which faces should be culled based on their vertex ordering
C CullHandler | This defines the abstract interface for an object that receives Geoms identified by the CullTraverser
C CullPlanes | This represents the set of clip planes and/or occluders that are definitely in effect for the current node of the CullTraverserData, as well as on all child nodes
C CullResult | This stores the result of a BinCullHandler traversal: an ordered collection of CullBins, each of which holds a number of Geoms and RenderStates to be rendered in some defined order
C CullTraverser | This object performs a depth-first traversal of the scene graph, with optional view-frustum culling, collecting CullState and searching for GeomNodes
C CullTraverserData | This collects together the pieces of data that are accumulated for each node while walking the scene graph during the cull traversal
►C CurveFitter |
C DataPoint |
C CVSCopy | This is the base class for a family of programs that copy files, typically model files like .flt files and their associated textures, into a CVS- controlled source tree
C CVSSourceDirectory | This represents one particular directory in the hierarchy of source directory files
►C CVSSourceTree | This represents the root of the tree of source directory files
C FilePath |
C CycleData | A single page of data maintained by a PipelineCycler
C CycleDataLockedReader | This template class calls PipelineCycler::read() in the constructor and PipelineCycler::release_read() in the destructor
C CycleDataLockedStageReader | This class is similar to CycleDataLockedReader, except it allows reading from a particular stage of the pipeline
C CycleDataReader | This template class calls PipelineCycler::read_unlocked(), and then provides a transparent read-only access to the CycleData
C CycleDataStageReader | This class is similar to CycleDataReader, except it allows reading from a particular stage of the pipeline
C CycleDataStageWriter | This class is similar to CycleDataWriter, except it allows writing to a particular stage of the pipeline
C CycleDataWriter | This template class calls PipelineCycler::write() in the constructor and PipelineCycler::release_write() in the destructor
C CyclerHolder | A lightweight C++ object whose constructor calls acquire() and whose destructor calls release() on a PipelineCyclerBase object
C CylindricalLens | A cylindrical lens
►C DaeCharacter | Class representing an animated character
C Joint |
C DaeMaterials | This class is seperated from the converter file because otherwise it would get too big and needlessly complicated
C DAEToEgg | A program to read a DAE file and generate an egg file
C DAEToEggConverter | This class supervises the construction of an EggData structure from a DAE file
C Datagram | An ordered list of data elements, formatted in memory for transmission over a socket or writing to a data file
C DatagramBuffer | This class can be used to write a series of datagrams into a memory buffer
C DatagramGenerator | This class defines the abstract interace to any source of datagrams, whether it be from a file or from the net
C DatagramGeneratorNet | This class provides datagrams one-at-a-time as read directly from the net, via a TCP connection
C DatagramInputFile | This class can be used to read a binary file that consists of an arbitrary header followed by a number of datagrams
C DatagramIterator | A class to retrieve the individual data elements previously stored in a Datagram
C DatagramOutputFile | This class can be used to write a binary file that consists of an arbitrary header followed by a number of datagrams
C DatagramQueue | A thread-safe, FIFO queue of NetDatagrams
C DatagramSink | This class defines the abstract interface to sending datagrams to any target, whether it be into a file or across the net
C DatagramSinkNet | This class accepts datagrams one-at-a-time and sends them over the net, via a TCP connection
C DatagramTCPHeader | A class that encapsulates the extra bytes that are sent in front of each datagram to identify it when it is sent on TCP
C DatagramUDPHeader | A class that encapsulates the extra bytes that are sent in front of each datagram to identify it when it is sent on UDP
C DataGraphTraverser | This object supervises the traversal of the data graph and the moving of data from one DataNode to its children
C DataNode | The fundamental type of node for the data graph
C DataNodeTransmit | Encapsulates the data generated from (or sent into) any particular DataNode
C DCArrayParameter | This represents an array of some other kind of object, meaning this parameter type accepts an arbitrary (or possibly fixed) number of nested fields, all of which are of the same type
C DCAtomicField | A single atomic field of a Distributed Class, as read from a .dc file
C DCClass | Defines a particular DistributedClass as read from an input .dc file
C DCClassParameter | This represents a class (or struct) object used as a parameter itself
C DCDeclaration | This is a common interface for a declaration in a DC file
C DCField | A single field of a Distributed Class, either atomic or molecular
C DCFile | Represents the complete list of Distributed Class descriptions as read from a .dc file
C DCKeyword | This represents a single keyword declaration in the dc file
C DCKeywordList | This is a list of keywords (see DCKeyword) that may be set on a particular field
C DCMolecularField | A single molecular field of a Distributed Class, as read from a .dc file
C DCNumericRange | Represents a range of legal integer or floating-point values
C DCPackData | This is a block of data that receives the results of DCPacker
C DCPacker | This class can be used for packing a series of numeric and string data into a binary stream, according to the DC specification
►C DCPackerCatalog | This object contains the names of all of the nested fields available within a particular field
C Entry |
C LiveCatalog |
C LiveCatalogEntry |
C DCPackerInterface | This defines the internal interface for packing values into a DCField
C DCParameter | Represents the type specification for a single parameter within a field specification
C DCSimpleParameter | This is the most fundamental kind of parameter type: a single number or string, one of the DCSubatomicType elements
►C DCSwitch | This represents a switch statement, which can appear inside a class body and represents two or more alternative unpacking schemes based on the first field read
C SwitchCase |
C SwitchFields |
C DCSwitchParameter | This represents a switch object used as a parameter itself, which packs the appropriate fields of the switch into the message
►C DCTokenType |
C U |
C DCTypedef | This represents a single typedef declaration in the dc file
C DecalEffect | Applied to a GeomNode to indicate that the children of this GeomNode are coplanar and should be drawn as decals (eliminating Z-fighting)
C Declaration |
C DeferredNodeProperty | This class keeps track of all the state we must make note of during the graph traversal, but cannot apply immediately
C DeletedBufferChain | This template class can be used to provide faster allocation/deallocation for many Panda objects
C DeletedChain | This template class can be used to provide faster allocation/deallocation for many Panda objects
C DepthOffsetAttrib | This is a special kind of attribute that instructs the graphics driver to apply an offset or bias to the generated depth values for rendered polygons, before they are written to the depth buffer
C DepthTestAttrib | Enables or disables writing to the depth buffer
C DepthWriteAttrib | Enables or disables writing to the depth buffer
C DestTextureImage | This represents a texture filename as it has been resized and copied to the map directory (e.g
C DialNode | This is the primary interface to infinite dial type devices associated with a ClientBase
C DirectD | DirectD is a client/server app for starting panda/direct
C DirectDClient | DirectDClient is a test app for DirectDServer
C DirectDServer | Start a directdServer on each of the machines you which to start panda on
C DirectionalLight | A light shining from infinitely far away in a particular direction, like sunlight
C DiscEmitter | Describes a planar disc region from which particles are generated
C DisplayInformation | This class contains various display information
C DisplayMode |
►C DisplayRegion | A rectangular subregion within a window for rendering into
C Region |
C DisplayRegionCullCallbackData | This specialization on CallbackData is passed when the callback is initiated from the cull traversal, for a DisplayRegion
C DisplayRegionDrawCallbackData | This specialization on CallbackData is passed when the callback is initiated from the draw traversal, for a DisplayRegion
C DisplayRegionPipelineReader | Encapsulates the data from a DisplayRegion, pre-fetched for one stage of the pipeline
C DisplaySearchParameters | Parameters used for searching display capabilities
C DocumentSpec | A descriptor that refers to a particular version of a document
C DoubleBitMask | This is a special BitMask type that is implemented as a pair of lesser BitMask types, to present a double-wide bit mask
►C DownloadDb | A listing of files within multifiles for management of client-side synchronization with a server-provided set of files
C Db |
C FileRecord |
C MultifileRecord |
C DrawableRegion | This is a base class for GraphicsWindow (actually, GraphicsOutput) and DisplayRegion, both of which are conceptually rectangular regions into which drawing commands may be issued
C DrawCullHandler | This special kind of CullHandler immediately draws its contents as soon as it receives them
C DriveInterface | This is a TFormer, similar to Trackball, that moves around a transform matrix in response to mouse input
►C DSearchPath | This class stores a list of directories that can be searched, in order, to locate a particular file
C Results |
►C DXFFile | A generic DXF-reading class
C Color |
C DXFLayer | This represents a "layer" as read from the DXF file
C DXFLayerMap | A map of string (layer name) to DXFLayer: that is, the layers of a file ordered by name
C DXFPoints | A simple program to read a dxf file and list the points contained within it to a text file
C DXFToEgg | A program to read a DXF file and generate an egg file
C DXFToEggConverter | This class supervises the construction of an EggData structure from a DXF file
C DXFToEggLayer | The specialization of DXFLayer used by DXFToEggConverter
C DXFVertex | Stored within DXFFile, this is the basic Vertex data of a DXF file
C DXGeomMunger9 | This specialization on GeomMunger finesses vertices for DirectX rendering
C DXGraphicsDevice9 | A GraphicsDevice necessary for multi-window rendering in DX
C DXGraphicsStateGuardian9 | A GraphicsStateGuardian for rendering into DirectX9 contexts
C DXIndexBufferContext9 | Caches a GeomPrimitive in the DirectX device as an index buffer
C DXOcclusionQueryContext9 |
C DXScreenData |
C DXShaderContext9 | Xyz
C DXTextureContext9 |
C DXVertexBufferContext9 | Caches a GeomVertexArrayData in the DirectX device as a vertex buffer
C EAGLView |
C EaseInBlendType |
C EaseInOutBlendType |
C EaseOutBlendType |
C EggAnimData | A base class for EggSAnimData and EggXfmAnimData, which contain rows and columns of numbers
C EggAnimPreload | This corresponds to an <AnimPreload> entry
C EggAttributes | The set of attributes that may be applied to vertices as well as polygons, such as surface normal and color
C EggBackPointer | This stores a pointer from an EggJointData or EggSliderData object back to the referencing data in an egg file
C EggBase | This is a base class for both EggSingleBase and EggMultiBase
C EggBin | A type of group node that holds related subnodes
C EggBinMaker | This is a handy class for collecting related nodes together
C EggBinMakerCompareNodes | This is just an STL function object, used to sort nodes within EggBinMaker
C EggBinner | A special binner used only within this package to pre-process the egg tree for the loader and group things together as appropriate
►C EggCharacterCollection | Represents a set of characters, as read and collected from possibly several model and/or animation egg files
C EggInfo |
C EggCharacterData | Represents a single character, as read and collected from several models and animation files
C EggCharacterDb | This class is used during joint optimization or restructuring to store the table of interim joint computations
C EggCharacterFilter | This is the base class for a family of programs that operate on a number of character models and their associated animation files together
C EggComment | A comment that appears in an egg file within a <Comment> entry
C EggComponentData | This is the base class of both EggJointData and EggSliderData
C EggCompositePrimitive | The base class for primitives such as triangle strips and triangle fans, which include several component triangles, each of which might have its own color and/or normal
C EggConverter | This is a general base class for programs that convert between egg files and some other format
C EggCoordinateSystem | The <CoordinateSystem> entry at the top of an egg file
C EggCrop | A program to read an egg file and write an equivalent egg file, possibly performing some minor operations along the way
C EggCurve | A parametric curve of some kind
C EggData | This is the primary interface into all the egg data, and the root of the egg file structure
C EggExternalReference | Defines a reference to another egg file which should be inserted at this point
C EggFile | This represents a single egg file known to the palettizer
►C EggFilenameNode | This is an egg node that contains a filename
C IndirectOrderByBasename |
C EggFilter | This is the base class for a program that reads an egg file, operates on it, and writes another egg file out
C EggGroup | The main glue of the egg hierarchy, this corresponds to the <Group>, <Instance>, and <Joint> type nodes
C EggGroupNode | A base class for nodes in the hierarchy that are not leaf nodes
C EggGroupUniquifier | This is a specialization of EggNameUniquifier to generate unique names for EggGroup nodes
C EggJointData | This is one node of a hierarchy of EggJointData nodes, each of which represents a single joint of the character hierarchy across all loaded files: the various models, the LOD's of each model, and the various animation channel files
C EggJointNodePointer | This stores a pointer back to a <Joint> node
C EggJointPointer | This is a base class for EggJointNodePointer and EggMatrixTablePointer
C EggLine | A line segment, or a series of connected line segments, defined by a <Line> entry
C EggListTextures | Reads an egg file and outputs the list of textures it uses
C EggLoader | Converts an egg data structure, possibly read from an egg file but not necessarily, into a scene graph suitable for rendering
C EggMakeFont | This program uses FreeType to generate an egg file and a series of texture images from a font file input, such as a TTF file
C EggMakeSomething | A base class for a family of programs that generate egg models of various fundamental shapes
C EggMakeTube | A program to generate an egg file representing a tube model, similar in shape to a CollisionCapsule
C EggMaterial |
C EggMaterialCollection | This is a collection of materials by MRef name
C EggMatrixTablePointer | This stores a pointer back to an EggXfmSAnim table (i.e
C EggMesher | Collects together unrelated EggPrimitives, determines their edge connectivity, and generates a set of EggTriangleStrips that represent the same geometry
C EggMesherEdge | Represents one edge of a triangle, as used by the EggMesher to discover connected triangles
C EggMesherFanMaker | This class is used by EggMesher::find_fans() to attempt to make an EggTriangleFan out of the polygons connected to the indicated vertex
C EggMesherStrip | Represents a triangle strip or quad strip in progress, as assembled by the mesher
C EggMorph | A single <Dxyz> or <Duv> or some such entry
C EggMorphList | A collection of <Dxyz>'s or <Duv>'s or some such
C EggMultiBase | This specialization of ProgramBase is intended for programs that read and/or write multiple egg files
C EggMultiFilter | This is a base class for a program that reads in a number of egg files, operates on them, and writes them out again (presumably to a different directory)
C EggNamedObject | This is a fairly low-level base class–any egg object that has a name
C EggNameUniquifier | This is a handy class for guaranteeing unique node names in an egg hierarchy
C EggNode | A base class for things that may be directly added into the egg hierarchy
C EggNurbsCurve | A parametric NURBS curve
C EggNurbsSurface | A parametric NURBS surface
C EggObject | The highest-level base class in the egg directory
C EggOptchar | Performs basic optimizations of a character model and its associated animations, by analyzing the animation tables and removing unneeded joints and/or morphs
C EggOptcharUserData | This class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the maya converter
C EggPalettize | This is the program wrapper for egg-palettize, but it mainly serves to read in all the command-line parameters and then invoke the Palettizer
C EggParameters | The values stored in this structure are global parameters that control some aspects of the egg library
C EggPatch | A single "patch", a special primitive to be rendered only with a tessellation shader
C EggPoint | A single point, or a collection of points as defined by a single <PointLight> entry
C EggPolygon | A single polygon
C EggPolysetMaker | A specialization on EggBinMaker for making polysets that share the same basic rendering characteristic
C EggPoolUniquifier | This is a specialization of EggNameUniquifier to generate unique names for textures, materials, and vertex pools prior to writing out an egg file
C EggPrimitive | A base class for any of a number of kinds of geometry primitives: polygons, point lights, nurbs patches, parametrics curves, etc
C EggQtess | A program to tesselate NURBS surfaces appearing within an egg file into polygons, using variations on a quick uniform tesselation
C EggReader | This is the base class for a program that reads egg files, but doesn't write an egg file
C EggRename | A program to read an egg file and write an equivalent egg file, with stripping prefix for now, but more along the way
C EggRenderMode | This class stores miscellaneous rendering properties that is associated with geometry, and which may be set on the geometry primitive level, on the group above it, or indirectly via a texture
C EggRenderState | This class is used within this package only to record the render state that should be assigned to each primitive
C EggRetargetAnim | Retargets one or more animation files from one particular skeleton to a similar, but differently scaled skeleton by preserving the rotation information but discarding translation and/or scale
C EggSAnimData | Corresponding to an entry, this stores a single column of numbers, for instance for a morph target, or as one column in an EggXfmSAnim
C EggSaver | Converts the scene graph beginning at the indicated node into an EggData structure, for writing to an egg file
C EggScalarTablePointer | This stores a pointer back to an EggSAnimData table (i.e
C EggSingleBase | This specialization of EggBase is intended for programs that read and/or write a single egg file
C EggSliderData | This corresponds to a single morph slider control
C EggSliderPointer | This is a base class for EggVertexPointer and EggScalarTablePointer
C EggSurface | A parametric surface of some kind
C EggSwitchCondition | This corresponds to a <SwitchCondition> entry within a group
C EggSwitchConditionDistance | A SwitchCondition that switches the levels-of-detail based on distance from the camera's eyepoint
C EggTable | This corresponds to a a <Bundle> entry
C EggTexture | Defines a texture map that may be applied to geometry
C EggTextureCards | Generates an egg file featuring a number of polygons, one for each named texture
C EggTextureCollection | This is a collection of textures by TRef name
C EggToBam |
C EggToC |
C EggToDAE | A program to read an egg file and write a DAE file
C EggToDXF | A program to read an egg file and write a DXF file
C EggToDXFLayer | A single layer in the DXF file to be written by EggToDXF
C EggToFlt | A program to read an egg file and write a flt file
C EggTokenType |
C EggToMaya | A program to read an egg file and write a maya file
C EggToObj |
C EggToObjConverter | Convert an obj file to egg data
C EggTopstrip | Reads a character model and/or animations and strips out the animation from one of the top joints from the entire character
C EggToSomething | This is the general base class for a file-converter program that reads some model file format and generates an egg file
C EggToSomethingConverter | This is a base class for a family of converter classes that manage a conversion from egg format to some other file type
C EggToX | A program to read in a egg file and write an equivalent, or nearly equivalent, DirectX-style "x" file
C EggTrans | A program to read an egg file and write an equivalent egg file, possibly performing some minor operations along the way
C EggTransform | This represents the <Transform> entry of a group or texture node: a list of component transform operations, applied in order, that describe a net transform matrix
C EggTriangleFan | A connected fan of triangles
C EggTriangleStrip | A connected strip of triangles
C EggUserData | This is a base class for a user-defined data type to extend egg structures in processing code
C EggVertex | Any one-, two-, three-, or four-component vertex, possibly with attributes such as a normal
C EggVertexAux | The set of named auxiliary data that may or may not be assigned to a vertex
C EggVertexPointer | This stores a pointer back to a <Vertex>, or to a particular pritimive like a <Polygon>, representing a morph offset
C EggVertexPool | A collection of vertices
C EggVertexUV | The set of UV's that may or may not be assigned to a vertex
C EggWriter | This is the base class for a program that generates an egg file output, but doesn't read any for input
C EggXfmAnimData | Corresponding to an <Xfm$Anim> entry, this stores a two-dimensional table with up to nine columns, one for each component of a transformation
C EggXfmSAnim | This corresponds to an <Xfm$Anim_S$> entry, which is a collection of up to nine entries that specify the nine components of a transformation
C eglGraphicsBuffer | An offscreen buffer in the EGL environment
C eglGraphicsPipe | This graphics pipe represents the interface for creating OpenGL ES graphics windows on an X-based (e.g
C eglGraphicsStateGuardian | A tiny specialization on GLESGraphicsStateGuardian to add some egl-specific information
C Evade |
C Event | A named event, possibly with parameters
C EventHandler | A class to monitor events from the C++ side of things
C EventParameter | An optional parameter associated with an event
C EventQueue | A queue of pending events
C EventReceiver | An abstract base class for anything that might care about receiving events
C ExecutionEnvironment | Encapsulates access to the environment variables and command-line arguments at the time of execution
C Extension | The default class template does not define any methods
C ExtensionBase | This is where all extensions should derive from
C ExternalThread | The special "external thread" class
C Extractor | This class automatically extracts the contents of a Multifile to the current directory (or to a specified directory) in the background
C Factory | A Factory can be used to create an instance of a particular subclass of some general base class
C FactoryBase | A Factory can be used to create an instance of a particular subclass of some general base class
C FactoryParam | The base class of any number of specific pieces of parameter information that might be passed to a Factory's CreateFunc to control what kind of instance is created
C FactoryParams | An instance of this class is passed to the Factory when requesting it to do its business and construct a new something
C FadeLODNode | A Level-of-Detail node with alpha based switching
C FadeLODNodeData | This is the data that is associated with a particular instance of the FadeLODNode for the scene graph
C FfmpegAudio | A stream that generates a sequence of audio samples
C FfmpegAudioCursor | A stream that generates a sequence of audio samples
C FfmpegVideo |
►C FfmpegVideoCursor |
C FfmpegBuffer |
C FfmpegVirtualFile | Enables ffmpeg to access panda's VFS
C FFTCompressor | This class manages a lossy compression and decompression of a stream of floating-point numbers to a datagram, based a fourier transform algorithm (similar in principle to JPEG compression)
C Filename | The name of a file, such as a texture file or an Egg file
C FilenameUnifier | This static class does the job of converting filenames from relative to absolute to canonical or whatever is appropriate
C FileReference | Keeps a reference-counted pointer to a file on disk
►C FilterProperties | Stores a configuration for a set of audio DSP filters
C FilterConfig |
C FindApproxLevelEntry | This class is local to this package only; it doesn't get exported
C FindApproxPath | This class is local to this package only; it doesn't get exported
C FiniteBoundingVolume | A special kind of GeometricBoundingVolume that is known to be finite
C first_of_pair_iterator | This is an iterator adaptor that converts any iterator that returns a pair (e.g
C FirstOfPairCompare | An STL function object class, this is intended to be used on any ordered collection of pairs of objects
C FirstOfPairLess | An STL function object class, this is intended to be used on any ordered collection of pairs of objects
C FisheyeLens | A fisheye lens
C FisheyeMaker | This class is similar to CardMaker, but instead of generating ordinary cards, it generates a circular rose that represents the projection of a 3-D scene through a fisheye lens
C FlacAudio | Reads FLAC audio files
C FlacAudioCursor | Implements decoding of FLAC audio files
C Flee |
C floating_point_hash | This hash_compare class hashes a float or a double
C floating_point_threshold | Compares two floating point numbers, within threshold of equivalence
C Flock | This class is used to define the flock attributes and the AI characters which are part of the flock
C FltBead | A base class for any of a broad family of flt records that represent particular beads in the hierarchy
C FltBeadID | A base class for any of a broad family of flt beads that include an ID
C FltCopy | A program to copy Multigen .flt files into the cvs tree
C FltCurve | A single curve, like a Bezier or B-Spline
C FltExternalReference | An external reference to another flt file (possibly to a specific bead within the flt file)
C FltEyepoint | A single eyepoint entry in the eyepoint/trackplane palette
C FltFace | A single face bead, e.g
C FltGeometry | This is a base class for both FltFace and FltMesh, which are two different kinds of geometric primitives that might be encountered in a MultiGen file
C FltGroup | The main grouping bead of the flt file
C FltHeader | This is the first bead in the file, the top of the bead hierarchy, and the primary interface to reading and writing a Flt file
C FltInfo | A program to read a flt file and report interesting things about it
C FltInstanceDefinition | This special kind of record marks the top node of an instance subtree
C FltInstanceRef | This bead appears in the hierarchy to refer to a FltInstanceDefinition node defined elsewhere
C FltLightSourceDefinition | Represents a single entry in the light source palette
C FltLocalVertexPool | A local vertex pool, as might appear in the middle of the hierarchy, for instance for a mesh
C FltLOD | A Level-of-Detail record
C FltMaterial | Represents a single material in the material palette
C FltMesh | A mesh of connected polygons and tristrips, etc., with a local vertex pool
C FltMeshPrimitive | A single primitive of a mesh, like a triangle strip or fan
C FltObject | The main objecting bead of the flt file
C FltPackedColor | A packed color record, A, B, G, R
C FltRecord | The base class for all kinds of records in a MultiGen OpenFlight file
C FltRecordReader | This class turns an istream into a sequence of FltRecords by reading a sequence of Datagrams and extracting the opcode from each one
C FltRecordWriter | This class writes a sequence of FltRecords to an ostream, handling opcode and size counts properly
►C FltTexture | Represents a single texture in the texture palette
C GeospecificControlPoint |
C LODScale |
C SubtextureDef |
C FltToEgg | A program to read a flt file and generate an egg file
C FltToEggConverter | This class supervises the construction of an EggData structure from the data represented by the FltHeader
C FltToEggLevelState | This keeps track of relevant things about the traversal as we walk through the flt hierarchy
C FltTrackplane | A single trackplane entry in the eyepoint/trackplane palette
C FltTrans | A program to read a flt file and write an equivalent flt file, possibly performing some minor operations along the way
C FltTransformGeneralMatrix | A general 4x4 matrix
C FltTransformPut | A "put", which is a MultiGen concept of defining a transformation by mapping three arbitrary points to three new arbitrary points
C FltTransformRecord | A base class for a number of types of ancillary records that follow beads and indicate some kind of a transformation
C FltTransformRotateAboutEdge | A transformation that rotates about a particular axis in space, defined by two endpoints
C FltTransformRotateAboutPoint | A transformation that rotates about a particular axis in space, defined by a point and vector
C FltTransformRotateScale | A combination rotation and scale
C FltTransformScale | A transformation that applies a (possibly nonuniform) scale
C FltTransformTranslate | A transformation that applies a translation
C FltUnsupportedRecord |
C FltVectorRecord | This is an ancillary record of the old (pre-15.4) face node
C FltVertex | Represents a single vertex in the vertex palette
C FltVertexList | A list of vertices, typically added as a child of a face bead
C FmodAudioManager |
C FmodAudioSound |
C Fog | Specifies how atmospheric fog effects are applied to geometry
C FogAttrib | Applies a Fog to the geometry at and below this node
C FontPool | This is the preferred interface for loading fonts for the TextNode system
C ForceNode | A force that lives in the scene graph and is therefore subject to local coordinate systems
C FrameBufferProperties | A container for the various kinds of properties we might ask to have on a graphics frameBuffer before we create a GSG
C FrameRateMeter | This is a special TextNode that automatically updates itself with the current frame rate
C GamepadButton | This class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to gamepad buttons
C GenericAsyncTask | Associates a generic C-style function pointer with an AsyncTask object
C GenericThread | A generic thread type that allows calling a C-style thread function without having to subclass
►C Geom | A container for geometry primitives
C CacheEntry |
C CacheKey |
C GeomCacheEntry | This object contains a single cache entry in the GeomCacheManager
C GeomCacheManager | This is used to keep track of, and limit the size of, the cache of munged vertices, which would otherwise be distributed through all of the GeomVertexData objects in the system
C GeomContext | This is a special class object that holds all the information returned by a particular GSG to indicate the geom's internal context identifier
C GeomDrawCallbackData | This specialization on CallbackData is passed when the callback is initiated from deep within the draw traversal, for a particular Geom
C GeomEnums | This class exists just to provide scoping for the various enumerated types used by Geom, GeomVertexData, GeomVertexArrayData, GeomPrimitive, and other related classes
C GeometricBoundingVolume | This is another abstract class, for a general class of bounding volumes that actually enclose points in 3-d space, such as BSP's and bounding spheres
C GeoMipTerrain | GeoMipTerrain, meaning Panda3D GeoMipMapping, can convert a heightfield image into a 3D terrain, consisting of several GeomNodes
C GeomLines | Defines a series of disconnected line segments
C GeomLinesAdjacency | Defines a series of disconnected line segments with adjacency information, for use with geometry shaders
C GeomLinestrips | Defines a series of line strips
C GeomLinestripsAdjacency | Defines a series of line strips with adjacency information
C GeomMunger | Objects of this class are used to convert vertex data from a Geom into a format suitable for passing to the rendering backend
►C GeomNode | A node that holds Geom objects, renderable pieces of geometry
C BamAuxData |
C GeomEntry |
C Geoms |
C GeomParticleRenderer |
C GeomPatches | Defines a series of "patches", fixed-size groupings of vertices that must be processed by a tessellation shader
C GeomPipelineReader | Encapsulates the data from a Geom, pre-fetched for one stage of the pipeline
C GeomPoints | Defines a series of disconnected points
C GeomPrimitive | This is an abstract base class for a family of classes that represent the fundamental geometry primitives that may be stored in a Geom
C GeomPrimitivePipelineReader | Encapsulates the data from a GeomPrimitive, pre-fetched for one stage of the pipeline
C GeomTextGlyph | This is a specialization on Geom for containing a primitive intended to represent a TextGlyph
C GeomTransformer | An object specifically designed to transform the vertices of a Geom without disturbing indexing or affecting any other Geoms that may share the same vertex arrays, and without needlessly wasting memory when different Geoms sharing the same vertex arrays are transformed by the same amount
C GeomTriangles | Defines a series of disconnected triangles
C GeomTrianglesAdjacency | Defines a series of disconnected triangles, with adjacency information
C GeomTrifans | Defines a series of triangle fans
C GeomTristrips | Defines a series of triangle strips
C GeomTristripsAdjacency | Defines a series of triangle strips with adjacency information
C GeomVertexAnimationSpec | This object describes how the vertex animation, if any, represented in a GeomVertexData is encoded
C GeomVertexArrayData | This is the data for one array of a GeomVertexData structure
C GeomVertexArrayDataHandle | This data object is returned by GeomVertexArrayData::get_handle() or modify_handle()
C GeomVertexArrayFormat | This describes the structure of a single array within a Geom data
C GeomVertexColumn | This defines how a single column is interleaved within a vertex array stored within a Geom
►C GeomVertexData | This defines the actual numeric vertex data stored in a Geom, in the structure defined by a particular GeomVertexFormat object
C CacheEntry |
C CacheKey |
C GeomVertexDataPipelineBase | The common code from GeomVertexDataPipelineReader and GeomVertexDataPipelineWriter
C GeomVertexDataPipelineReader | Encapsulates the data from a GeomVertexData, pre-fetched for one stage of the pipeline
C GeomVertexDataPipelineWriter | Encapsulates the data from a GeomVertexData, pre-fetched for one stage of the pipeline
C GeomVertexFormat | This class defines the physical layout of the vertex data stored within a Geom
C GeomVertexReader | This object provides a high-level interface for quickly reading a sequence of numeric values from a vertex table
C GeomVertexRewriter | This object provides the functionality of both a GeomVertexReader and a GeomVertexWriter, combined together into one convenient package
C GeomVertexWriter | This object provides a high-level interface for quickly writing a sequence of numeric values from a vertex table
C GlobalPointerRegistry | This class maintains a one-to-one mapping from TypeHandle to a void * pointer
C GlobPattern | This class can be used to test for string matches against standard Unix- shell filename globbing conventions
C glxGraphicsBuffer | An offscreen buffer in the GLX environment
C glxGraphicsPipe | This graphics pipe represents the interface for creating OpenGL graphics windows on an X-based (e.g
C glxGraphicsPixmap | Another offscreen buffer in the GLX environment
C glxGraphicsStateGuardian | A tiny specialization on GLGraphicsStateGuardian to add some glx-specific information
C glxGraphicsWindow | An interface to the glx system for managing GL windows under X
C GPUCommand | Class for storing data to be transferred to the GPU
C GPUCommandList | RenderPipeline
C GraphicsBuffer | An offscreen buffer for rendering into
C GraphicsDevice | An abstract device object that is part of Graphics Pipe
C GraphicsEngine | This class is the main interface to controlling the render process
C GraphicsOutput | This is a base class for the various different classes that represent the result of a frame of rendering
C GraphicsOutputBase | An abstract base class for GraphicsOutput, for all the usual reasons
C GraphicsPipe | An object to create GraphicsOutputs that share a particular 3-D API
C GraphicsPipeSelection | This maintains a list of GraphicsPipes by type that are available for creation
C GraphicsStateGuardian | Encapsulates all the communication with a particular instance of a given rendering backend
C GraphicsStateGuardianBase | This is a base class for the GraphicsStateGuardian class, which is itself a base class for the various GSG's for different platforms
C GraphicsThreadingModel | This represents the user's specification of how a particular frame is handled by the various threads
C GraphicsWindow | A window, fullscreen or on a desktop, into which a graphics device sends its output for interactive display
C GraphicsWindowInputDevice | This is a virtual input device that represents the keyboard and mouse pair that is associated with a particular window
C GraphicsWindowProc | Defines an interface for storing platform-specific window processor methods
C GraphicsWindowProcCallbackData | This specialization on CallbackData is passed when the callback is initiated from from an implementation of the GraphicsWindowProc class, such as PythonGraphicsWindowProc
C HashGenerator | This class generates an arbitrary hash number from a sequence of ints
C HashGeneratorBase | This is the base class for a number of classes that generate arbitrary hash numbers for complex objects, based fundamentally on a sequence of integers
C HashVal | Stores a 128-bit value that represents the hashed contents (typically MD5) of a file or buffer
C Header |
C HeightfieldTesselator | Converts a height field in the form of a greyscale image into a scene consisting of a number of GeomNodes
C HermiteCurve | A parametric curve defined by a sequence of control vertices, each with an in and out tangent
C HermiteCurveCV | A single CV of a Hermite curve
C HideInterval | An interval that calls NodePath::hide()
C HTTPDate | A container for an HTTP-legal time/date indication
C HTTPEntityTag | A container for an "entity tag" from an HTTP server
C IESDataset | This class generates a LUT from IES data
C IffChunk | The basic kind of record in an EA "IFF" file, which the LightWave object file is based on
C IffGenericChunk | A class for a generic kind of IffChunk that is not understood by a particular IffReader
C IffId | A four-byte chunk ID appearing in an "IFF" file
C IffInputFile | A wrapper around an istream used for reading an IFF file
C ImageBase | This specialization of ProgramBase is intended for programs that read and/or write a single image file
C ImageFile | This is the base class of both TextureImage and PaletteImage
C ImageFilter | This is the base class for a program that reads an image file, operates on it, and writes another image file out
C ImageFixHiddenColor | This program repairs an image's RGB values hidden behind an A value of 0
C ImageInfo | This program reads the headers of a series of one or more images and reports their sizes to standard output
C ImageReader | This is the base class for a program that reads an image file, but doesn't write an image file
C ImageResize | A program to read an image file and resize it to a larger or smaller image file
C ImageTrans | A program to read an image file and write an equivalent image file, possibly performing some minor operations along the way
C ImageTransformColors | This program can apply a 4x4 color transform to all of the colors in the pixels of a series of images
C ImageWriter | This is the base class for a program that generates an image file output, but doesn't read any for input
C IndexBufferContext | This is a special class object that holds all the information returned by a particular GSG to indicate the vertex data array's internal context identifier
C IndexedFaceSet | Decodes the vertices and faces in a VRML indexed face set, and creates the corresponding egg geometry
C IndexRemapper | This class manages a mapping of integers to integers
C indirect_compare_names | An STL function object class, this is intended to be used on any ordered collection of pointers to classes that define a get_name() method, particularly for things that derive from Namable
C indirect_compare_names_hash |
C indirect_compare_to | An STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain a compare_to() method
C indirect_compare_to_hash |
C indirect_equals_hash | An STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator ==() method
C indirect_less | An STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator <() method
C indirect_less_hash |
C indirect_method_hash | This hash_compare class hashes a pointer to a class object
C IndirectCompareNames | An STL function object class, this is intended to be used on any ordered collection of pointers to classes that define a get_name() method, particularly for things that derive from Namable
C IndirectCompareSort | An STL function object class, this is intended to be used on any ordered collection of pointers to classes that define a get_sort() method
C IndirectCompareTo | An STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain a compare_to() method
C IndirectLess | An STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator <() method
C InkblotVideo | A cellular automaton that generates an amusing pattern of swirling colors
C InkblotVideoCursor | A cellular automaton that generates an amusing pattern of swirling colors
►C InputDevice | This is a structure representing a single input device
C AxisState |
C BatteryData |
C ButtonState |
C InputDeviceManager | This class keeps track of all the devices on a system, and sends out events when a device has been hot-plugged
C InputDeviceNode | Reads the controller data sent from the InputDeviceManager, and transmits it down the data graph
C InputDeviceSet | Manages a list of InputDevice objects, as returned by various InputDeviceManager methods
C integer_hash | This is the default hash_compare class, which assumes the Key is a size_t value or can be implicitly converted to a size_t value (for instance, via a size_t typecast operator)
C InternalLightManager | Internal class used for handling lights and shadows
C InternalName | Encodes a string name in a hash table, mapping it to a pointer
C InternalNameCollection |
C InterrogateComponent | The base class for things that are part of the interrogate database
C InterrogateDatabase | This stores all of the interrogate data and handles reading the data from a disk file when necessary
C InterrogateElement | An internal representation of a data element, like a data member or a global variable
C InterrogateFunction | An internal representation of a function
C InterrogateFunctionWrapper | An internal representation of a callable function
C InterrogateMakeSeq | Represents a synthetic method created via the MAKE_SEQ() macro
C InterrogateManifest | An internal representation of a manifest constant
C InterrogateModuleDef |
►C InterrogateType | An internal representation of a type
C Derivation |
C EnumValue |
C InterrogateUniqueNameDef |
C IntersectionBoundingVolume | This special bounding volume is the intersection of all of its constituent bounding volumes
C IoPtaDatagramFloat | This class is used to read and write a PTA_stdfloat from a Datagram, in support of Bam
C IoPtaDatagramInt | This class is used to read and write a PTA_int from a Datagram, in support of Bam
C IoPtaDatagramShort | This class is used to read and write a PTA_ushort from a Datagram, in support of Bam
C ios | STL class
C iostream |
C IPhoneGraphicsPipe | This graphics pipe represents the interface for creating OpenGL graphics windows on the various IPHONE's
C IPhoneGraphicsStateGuardian |
C IPhoneGraphicsWindow | An interface to the osx/ system for managing GL windows under X
C IPipeStream |
C IsoPlacer | Contains the logic used to place isoparams where they'll do the most good on a surface
C istream | STL class
C IStreamWrapper | This class provides a locking wrapper around an arbitrary istream pointer
C istringstream | STL class
C ISubStream | An istream object that presents a subwindow into another istream
C JointVertexTransform | This is a specialization on VertexTransform that returns the transform necessary to move vertices as if they were assigned to the indicated joint
C KeyboardButton | This class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard keyboard keys
C Lens | A base class for any number of different kinds of lenses, linear and otherwise
C LensNode | A node that contains a Lens
C LerpBlendType |
C Light | The abstract interface to all kinds of lights
►C LightAttrib | Indicates which set of lights should be considered "on" to illuminate geometry at this level and below
C BamAuxData |
C LightLensNode | A derivative of Light and of Camera
C LightMutex | This is a standard, non-reentrant mutex, similar to the Mutex class
C LightMutexDirect | This class implements a lightweight Mutex by making direct calls to the underlying implementation layer
C LightMutexHolder | Similar to MutexHolder, but for a light mutex
C LightNode | A derivative of Light and of PandaNode
C LightRampAttrib | A Light Ramp is any unary operator that takes a rendered pixel as input, and adjusts the brightness of that pixel
C LightReMutex | A lightweight reentrant mutex
C LightReMutexDirect | This class implements a standard lightReMutex by making direct calls to the underlying implementation layer
C LightReMutexHolder | Similar to MutexHolder, but for a light reentrant mutex
C LinearControlForce | Simple directed vector force
C LinearCylinderVortexForce | Defines a cylinder inside of which all forces are tangential to the theta of the particle wrt the z-axis in local coord
C LinearDistanceForce | Pure virtual class for sinks and sources
C LinearEulerIntegrator | Performs Euler integration on a vector of physically modelable objects given a quantum dt
C LinearForce | A force that acts on a PhysicsObject by way of an Integrator
C LinearFrictionForce | Friction-based drag force
C LinearIntegrator | Pure virtual base class for physical modeling
C LinearJitterForce | Completely random noise force vector
C LinearNoiseForce | Repeating noise force vector
C LinearRandomForce | Pure virtual, parent to noiseForce and jitterForce
C LinearSinkForce | Attractor force
C LinearSourceForce | Repellant force
C LinearUserDefinedForce | A programmable force that takes an evaluator function
C LinearVectorForce | Simple directed vector force
C LineEmitter | Describes a linear region in which particles are generated
C LineParticleRenderer | Renders a line from last position to current position – good for rain, sparks, etc
C LineSegs | Encapsulates creation of a series of connected or disconnected line segments or points, for drawing paths or rays
C LineStream | This is a special ostream that writes to a memory buffer, like ostrstream
C LineStreamBuf | Used by LineStream to implement an ostream that writes to a memory buffer, whose contents can be continuously extracted as a sequence of lines of text
C LinkedListNode | This just stores the pointers to implement a doubly-linked list of some kind of object
►C Loader | A convenient class for loading models from disk, in bam or egg format (or any of a number of other formats implemented by a LoaderFileType, such as ptloader)
C Results |
C LoaderFileType | This is the base class for a family of scene-graph file types that the Loader supports
C LoaderFileTypeAssimp | This defines the Loader interface that uses the Assimp library to load various model formats
C LoaderFileTypeBam | This defines the Loader interface to read Bam files
C LoaderFileTypeEgg | This defines the Loader interface to read Egg files
C LoaderFileTypePandatool | This defines the Loader interface to files whose converters are defined within the Pandatool package and inherit from SomethingToEggConverter, like FltToEggConverter and LwoToEggConverter
C LoaderFileTypeRegistry | This class maintains the set of all known LoaderFileTypes in the universe
C LoaderFileTypeSrt | This defines the Loader interface to read SpeedTree SRT files, which describe a single tree
C LoaderFileTypeStf | This defines the Loader interface to read SpeedTree STF files–a simple text file that describes a forest of trees (references to SRT files)
C LoaderOptions | Specifies parameters that may be passed to the loader
C LODNode | A Level-of-Detail node
C LogicOpAttrib | If enabled, specifies that a custom logical operation be performed instead of any color blending
C LSimpleMatrix | This class provides an underlying storage of the various linear-algebra classes (e.g
C LwoBoundingBox | Stores the bounding box for the vertex data in a layer
C LwoChunk | A specialization of IffChunk for Lightwave Object files
C LwoClip | A single image file, or a numbered sequence of images (e.g
C LwoDiscontinuousVertexMap | A mapping of floating-point values per integer index
C LwoGroupChunk | A particular kind of LwoChunk that is expected to contain an arbitrary number of child chunks
C LwoHeader | The first chunk in a Lightwave Object file
C LwoInputFile | A specialization of IffInputFile to handle reading a Lightwave Object file
C LwoLayer | Signals the start of a new layer
C LwoPoints | An array of points that will be referenced by later chunks
►C LwoPolygons | An array of polygons that will be referenced by later chunks
C Polygon |
C LwoPolygonTags | An association of polygons defined in the most recent LwoPolygons chunk to tag ids defined in the most recent LwoTags chunk
C LwoScan | A program to read a Lightwave file and report its structure and contents
C LwoStillImage | A single still image associated with a LwoClip chunk
C LwoSurface | Describes the shading attributes of a surface
C LwoSurfaceBlock | A texture layer or shader, part of a LwoSurface chunk
C LwoSurfaceBlockAxis | Indicates the axis for this particular shader's projection
C LwoSurfaceBlockChannel | Indicates which channel the texture in this LwoSurfaceBlock is applied to
C LwoSurfaceBlockCoordSys | Specifies whether texture coordinates are computed based on the vertices' world coordinates or local coordinates
C LwoSurfaceBlockEnabled | Indicates whether this particular layer or shader should be rendered or not
C LwoSurfaceBlockHeader | The header chunk within a LwoSurfaceBlock chunk
C LwoSurfaceBlockImage | Specifies the particular image that is being applied as a texture
C LwoSurfaceBlockOpacity | Indicates how transparent or opaque this particular layer is in relation to the layers beneath it
C LwoSurfaceBlockProjection | Indicates the projection mode for this particular shader
C LwoSurfaceBlockRefObj | Specifies a reference object that the texture UV's are to be computed relative to
C LwoSurfaceBlockRepeat | For cylindrical and spherical projections, this parameter controls how many times the image repeats over each full interval, in either dimension
C LwoSurfaceBlockTMap | The tMap chunk within a LwoSurfaceBlock chunk
C LwoSurfaceBlockTransform | Specifies a center point, scale, or rotation for the texture coordinates in this shader's texture mapping
C LwoSurfaceBlockVMapName | Specifies the name of a set of UV's defined on the polygons that use this model
C LwoSurfaceBlockWrap | Specifies how the texture image appears for areas outside the image
C LwoSurfaceColor | Records the base color of a surface, as an entry within a LwoSurface chunk
C LwoSurfaceParameter | Records some parameter value of a surface material, as an entry within a LwoSurface chunk
C LwoSurfaceSidedness | Records whether polygons are frontfacing only or backfacing also
C LwoSurfaceSmoothingAngle | Indicates the maximum angle (in radians) between adjacent polygons that should be smooth-shaded
C LwoTags | An array of tag strings that will be referenced by later chunks
C LwoToEgg | A program to read a Lightwave file and generate an egg file
C LwoToEggConverter | This class supervises the construction of an EggData structure from the data represented by the LwoHeader
C LwoVertexMap | A mapping of floating-point values per integer index
C MainThread | The special "main thread" class
►C map | STL class
C const_iterator | STL iterator class
C const_reverse_iterator | STL iterator class
C iterator | STL iterator class
C reverse_iterator | STL iterator class
C Material | Defines the way an object appears in the presence of lighting
C MaterialAttrib | Indicates which, if any, material should be applied to geometry
C MaterialCollection |
C MaterialPool | The MaterialPool (there is only one in the universe) serves to unify different pointers to the same Material, so we do not (a) waste memory with many different Material objects that are all equivalent, and (b) waste time switching the graphics engine between different Material states that are really the same thing
C MathNumbers |
C MatrixLens | A completely generic linear lens
C MaxEggOptions |
C MaxEggPlugin |
C MaxNodeDesc | Describes a single instance of a node in the Max scene graph, relating it to the corresponding egg structures (e.g
C MaxNodeTree | Describes a complete tree of max nodes for conversion
C MaxOptionsDialog |
C MaxToEggConverter | This class supervises the construction of an EggData structure from a Max model
C MayaApi | This class presents a wrapper around the global Maya interface
C MayaBlendDesc | A handle to a Maya blend shape description
C MayaCopy | A program to copy Maya .mb files into the cvs tree
C MayaEggGroupUserData | This class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the maya converter
C MayaNodeDesc | Describes a single instance of a node in the Maya scene graph, relating it to the corresponding egg structures (e.g
C MayaNodeTree | Describes a complete tree of maya nodes for conversion
C MayaPview | This class serves as a plug-in to Maya to allow viewing the current Maya selection as it will be converted to Panda
C MayaSavePview | This class serves as a plug-in to Maya to save the scene and view it using the external pview program, rather than linking in any part of Panda to a Maya plugin
C MayaShader | Corresponds to a single "shader" in Maya
C MayaShaderColorDef | This defines the various attributes that Maya may associate with the "color" channel for a particular shader (as well as on the "transparency" channel)
C MayaShaders | Collects the set of MayaShaders that have been encountered so far
C MayaToEgg |
C MayaToEggClient |
C MayaToEggConverter | This class supervises the construction of an EggData structure from a single Maya file, or from the data already in the global Maya model space
C MayaToEggServer |
C MemBuffer |
C MemoryBase | This class is intended to be the base class of all objects in Panda that might be allocated and deleted via the new and delete operators
C MemoryHook | This class provides a wrapper around the various possible malloc schemes Panda might employ
C MemoryUsage | This class is used strictly for debugging purposes, specifically for tracking memory leaks of reference-counted objects: it keeps a record of every such object currently allocated
C MemoryUsagePointerCounts | This is a supporting class for MemoryUsage
C MemoryUsagePointers | This is a list of pointers returned by a MemoryUsage object in response to some query
C Mersenne |
C MeshDrawer | Mesh drawer creates a single geom object that can be shaped with different draw commands
C MeshDrawer2D | This class allows the drawing of 2D objects - mainly based on quads and rectangles
C method_hash | This hash_compare class hashes a class object
C MicrophoneAudio | Class MicrophoneAudio provides the means to read raw audio samples from a microphone
C ModelFlattenRequest | This class object manages a single asynchronous request to flatten a model
C ModelLoadRequest | A class object that manages a single asynchronous model load request
C ModelNode | This node is placed at key points within the scene graph to indicate the roots of "models": subtrees that are conceptually to be treated as a single unit, like a car or a room, for instance
C ModelPool | This class unifies all references to the same filename, so that multiple attempts to load the same model will return the same pointer
►C ModelRoot | A node of this type is created automatically at the root of each model file that is loaded
C ModelReference |
C ModelSaveRequest | A class object that manages a single asynchronous model save request
C ModifierButtons | This class monitors the state of a number of individual buttons and tracks whether each button is known to be down or up
C MouseAndKeyboard | Reads the mouse and/or keyboard data sent from a GraphicsWindow, and transmits it down the data graph
C MouseButton | This class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard mouse buttons
C MouseInterfaceNode | This is the base class for some classes that monitor the mouse and keyboard input and perform some action due to their state
C MouseRecorder | This object records any data generated by a particular MouseAndKeyboard node on the datagraph for a session for eventual playback via a DataGraphPlayback (and a PlaybackController)
C MouseSubregion | The MouseSubregion object scales the mouse inputs from within a rectangular region of the screen, as if they were the full-screen inputs
C MouseWatcher | This TFormer maintains a list of rectangular regions on the screen that are considered special mouse regions; typically these will be click buttons
C MouseWatcherBase | This represents a collection of MouseWatcherRegions that may be managed as a group
C MouseWatcherGroup | This represents a collection of MouseWatcherRegions that may be managed as a group
C MouseWatcherParameter | This is sent along as a parameter to most events generated for a region to indicate the mouse and button state for the event
C MouseWatcherRegion | This is the class that defines a rectangular region on the screen for the MouseWatcher
C MovieAudio | A MovieAudio is actually any source that provides a sequence of audio samples
C MovieAudioCursor | A MovieAudio is actually any source that provides a sequence of audio samples
C MovieTypeRegistry | This class records the different types of MovieAudio and MovieVideo that are available for loading
C MovieVideo | A MovieVideo is actually any source that provides a sequence of video frames
►C MovieVideoCursor | A MovieVideo is actually any source that provides a sequence of video frames
C Buffer |
C MovingPart | This is the template instantiation of MovingPartBase, on the particular type of value provided by the channel
C MovingPartBase | This is the base class for a single animatable piece that may be bound to one channel (or more, if blending is in effect)
C MovingPartMatrix | This is a particular kind of MovingPart that accepts a matrix each frame
C MovingPartScalar | This is a particular kind of MovingPart that accepts a scalar each frame
C Multifile | A file that contains a set of files
C MultiplexStream | This is a special ostream that forwards the data that is written to it to any number of other sources, for instance other ostreams, or explicitly to a disk file or to system logging utilities
C MultiplexStreamBuf | Used by MultiplexStream to implement an ostream that sends what is written to it to any number of additional sources, like other ostreams
C MultitexReducer | This object presents an interface for generating new texture images that represent the combined images from one or more individual textures, reproducing certain kinds of multitexture effects without depending on multitexture support in the hardware
C Mutex | A standard mutex, or mutual exclusion lock
C MutexDirect | This class implements a standard mutex by making direct calls to the underlying implementation layer
C MutexDummyImpl | A fake mutex implementation for single-threaded applications that don't need any synchronization control
C MutexHolder | A lightweight C++ object whose constructor calls acquire() and whose destructor calls release() on a mutex
C Namable | A base class for all things which can have a name
C NamableOrderByName | An STL function object for sorting an array of pointers to Namables into order by name
C NameUniquifier | A handy class for converting a list of arbitrary names (strings) so that each name is guaranteed to be unique in the list
C NativeNumericData | NativeNumericData and ReversedNumericData work together to provide a sneaky interface for automatically byte-swapping numbers, when necessary, to transparency support big-endian and little-endian architectures
►C NativeWindowHandle | This subclass of WindowHandle exists to allow simple creation of a WindowHandle of the appropriate type to the current OS
C IntHandle |
C SubprocessHandle |
C NetAddress | Represents a network address to which UDP packets may be sent or to which a TCP socket may be bound
C NetDatagram | A specific kind of Datagram, especially for sending across or receiving from a network
C NeverFreeMemory | This class is used to allocate bytes of memory from a pool that is never intended to be freed
C NoBlendType |
C Node | This class is used to assign the nodes on the mesh
C NodeCachedReferenceCount | This class further specializes CachedTypedWritableReferenceCount to also add a node_ref_count, for the purposes of counting the number of times the object is referenced by a "node", presumably a PandaNode
C NodeConstPointerTo | A NodeConstPointerTo is similar to a NodePointerTo, except it keeps a const pointer to the thing
C NodeCullCallbackData | This kind of CallbackData is passed to the CallbackObject added to CallbackNode:set_cull_callback()
C NodePath | NodePath is the fundamental system for disambiguating instances, and also provides a higher-level interface for manipulating the scene graph
C NodePathCollection | This is a set of zero or more NodePaths
C NodePathComponent | This is one component of a NodePath
C NodePointerTo | This implements the special NodePointerTo template class, which works just like PointerTo except it manages the objects node_ref_count instead of the normal ref_count
C NodePointerToBase | This is similar to PointerToBase, but it manages objects of type NodeReferenceCount or NodeCachedReferenceCount, and it updates the node_ref_count instead of the regular ref_count
C NodeRefCountObj | This works like RefCountObj, but it inherits from NodeReferenceCount instead of ReferenceCount
C NodeReferenceCount | This class specializes ReferenceCount to add an additional counter, called node_ref_count, for the purposes of counting the number of times the object is referenced by a "node", whatever that may mean in context
C NodeVertexTransform | This VertexTransform gets its matrix from the Transform stored on a node
C NonlinearImager | This class object combines the rendered output of a 3-d from one or more linear (e.g
C Notify | An object that handles general error reporting to the user
C NotifyCategory | A particular category of error messages
C NotifyCategoryGetCategory_prc |
C NotifyCategoryProxy | A handy wrapper around a NotifyCategory pointer
C NullAudioManager |
C NullAudioSound |
C NurbsBasisVector | This encapsulates a series of matrices that are used to represent the sequential segments of a NurbsCurveEvaluator
C NurbsCurve | A Nonuniform Rational B-Spline
C NurbsCurveEvaluator | This class is an abstraction for evaluating NURBS curves
C NurbsCurveInterface | This abstract class defines the interface only for a Nurbs-style curve, with knots and coordinates in homogeneous space
C NurbsCurveResult | The result of a NurbsCurveEvaluator
C NurbsSurfaceEvaluator | This class is an abstraction for evaluating NURBS surfaces
C NurbsSurfaceResult | The result of a NurbsSurfaceEvaluator
C NurbsVertex | This represents a single control vertex in a NurbsEvaluator
C ObjToEgg | A program to read a Obj file and generate an egg file
C ObjToEggConverter | Convert an Obj file to egg data
C ObstacleAvoidance |
C OccluderEffect | This functions similarly to a LightAttrib or ClipPlaneAttrib
C OccluderNode | A node in the scene graph that can hold an occluder polygon, which must be a rectangle
C OcclusionQueryContext | Returned from a GSG in response to begin_occlusion_query()
C OdeAMotorJoint |
C OdeBallJoint |
C OdeBody |
C OdeBoxGeom |
C OdeCappedCylinderGeom |
C OdeCollisionEntry | A class used to hold information about a collision that has occurred
C OdeContact |
C OdeContactGeom |
C OdeContactJoint |
C OdeConvexGeom |
C OdeCylinderGeom |
C OdeFixedJoint |
C OdeGeom |
C OdeHashSpace |
C OdeHinge2Joint |
C OdeHingeJoint |
C OdeJoint |
C OdeJointCollection |
C OdeJointFeedback |
C OdeJointGroup |
C OdeLMotorJoint |
C OdeMass |
C OdeNullJoint |
C OdePlane2dJoint |
C OdePlaneGeom |
C OdeQuadTreeSpace |
C OdeRayGeom |
C OdeSimpleSpace |
C OdeSliderJoint |
C OdeSpace |
C OdeSphereGeom |
C OdeSurfaceParameters |
C OdeTriMeshData |
C OdeTriMeshGeom |
C OdeUniversalJoint |
C OdeUtil |
C OdeWorld |
C OmniBoundingVolume | This is a special kind of GeometricBoundingVolume that fills all of space
C OpenALAudioManager |
C OpenALAudioSound |
C OPipeStream |
C ordered_vector | This template class presents an interface similar to the STL set or multiset (and ov_set and ov_multiset are implemented specifically, below), but it is implemented using a vector that is kept always in sorted order
C OrientedParticle | Describes a particle that has angular characteristics (velocity, orientation)
C OrientedParticleFactory | Creates particles that are affected by angular forces
C OrthographicLens | An orthographic lens
C OSphereLens | A OSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
C ostream | STL class
C OStreamWrapper | This class provides a locking wrapper around an arbitrary ostream pointer
C ostringstream | STL class
C OSubStream | An ostream object that presents a subwindow into another ostream
C osxGraphicsBuffer | An offscreen buffer in the OSX environment
C osxGraphicsPipe | This graphics pipe represents the interface for creating OpenGL graphics windows on the various OSX's
C osxGraphicsStateGuardian | A tiny specialization on GLGraphicsStateGuardian to add some wgl-specific information
C osxGraphicsWindow | An interface to the osx/ system for managing GL windows under X
C ov_multiset | A specialization of ordered_vector that emulates a standard STL set: many copies of each element are allowed
C ov_set | A specialization of ordered_vector that emulates a standard STL set: one copy of each element is allowed
C pair | STL class
C PaletteGroup | This is the highest level of grouping for TextureImages
C PaletteGroups | A set of PaletteGroups
C PaletteImage | This is a single palette image, one of several within a PalettePage, which is in turn one of several pages within a PaletteGroup
C PalettePage | This is a particular collection of textures, within a PaletteGroup, that all share the same TextureProperties
C Palettizer | This is the main engine behind egg-palettize
►C pallocator_array |
C rebind |
►C pallocator_single | This is our own Panda specialization on the default STL allocator
C rebind |
C PandaFramework | This class serves to provide a high-level framework for basic applications that use Panda in simple ways (like opening a window to view models, etc.)
C PandaIOStream | Custom implementation of Assimp::IOStream
C PandaIOSystem | Custom implementation of Assimp::IOSystem
C PandaLogger | Custom implementation of Assimp::Logger
►C PandaNode | A basic node of the scene graph or data graph
C Children |
C DownConnection |
C Parents |
C Stashed |
C PandaNodeChain | This class maintains a linked list of PandaNodes
C PandaNodePipelineReader | Encapsulates the data from a PandaNode, pre-fetched for one stage of the pipeline
C PandaSystem | This class is used as a namespace to group several global properties of Panda
►C ParametricCurve | A virtual base class for parametric curves
C BezierSeg |
C ParametricCurveCollection | This is a set of zero or more ParametricCurves, which may or may not be related
C ParamNodePath | A class object for storing a NodePath as a parameter
C ParamTextureImage | A class object for storing a pointer to a Texture along with a set of properties that indicates which image to bind to a shader input
C ParamTextureSampler | A class object for storing a pointer to a Texture along with a sampler state that indicates how to to sample the given texture
C ParamTypedRefCount | A class object for storing specifically objects of type TypedReferenceCount, which is different than TypedWritableReferenceCount
C ParamValue | A handy class object for storing simple values (like integers or strings) passed along with an Event or to be used as a shader input
C ParamValueBase | A non-template base class of ParamValue (below), which serves mainly to define the placeholder for the virtual output function
C ParasiteBuffer | This is a special GraphicsOutput type that acts a lot like a GraphicsBuffer, effectively allowing rendering to an offscreen buffer, except it does not create any framebuffer space for itself
C PartBundle | This is the root of a MovingPart hierarchy
C PartBundleHandle | This is a trivial class returned by PartBundleNode::get_bundle()
C PartBundleNode | This is a node that contains a pointer to an PartBundle
C PartGroup | This is the base class for PartRoot and MovingPart
C ParticleSystem | Contains and manages a particle system
C ParticleSystemManager | Manages a set of individual ParticleSystem objects, so that each individual one doesn't have to be updated and rendered every frame See Also : particleSystemManager.cxx
C PartSubset | This class is used to define a subset of part names to apply to the PartBundle::bind_anim() operation
C PathFind | This class contains all the members and functions that are required to form an interface between the AIBehaviors class and the PathFinder class
C PathFinder | This class implements pathfinding using A* algorithm
C PathFollow |
C PathReplace | This encapsulates the user's command-line request to replace existing, incorrect pathnames to models and textures from a file with correct pathnames
C pdeque | This is our own Panda specialization on the default STL deque
C PerlinNoise | This is the base class for PerlinNoise2 and PerlinNoise3, different dimensions of Perlin noise implementation
C PerlinNoise2 | This class provides an implementation of Perlin noise for 2 variables
C PerlinNoise3 | This class provides an implementation of Perlin noise for 3 variables
C PerspectiveLens | A perspective-type lens: a normal camera
C PfmBba | Generates a bounding-box description of a pfm file
C PfmFile | Defines a pfm file, a 2-d table of floating-point numbers, either 3-component or 1-component, or with a special extension, 2- or 4-component
C PfmTrans | Operates on a pfm file
C PfmVizzer | This class aids in the visualization and manipulation of PfmFile objects
C PGButton | This is a particular kind of PGItem that is specialized to behave like a normal button object
C PGButtonNotify | Objects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
C PGCullTraverser | This is a specialization of CullTraverser for use within the pgui system
C PGEntry | This is a particular kind of PGItem that handles simple one-line or short multi-line text entries, of the sort where the user can type any string
C PGFrameStyle |
C PGItem | This is the base class for all the various kinds of gui widget objects
C PGItemNotify | Objects that inherit from this class can receive specialized messages when PGItems change in certain ways
C PGMouseWatcherBackground | This is a special kind of MouseWatcherRegion that doesn't have a rectangle and is never active, but just quietly listens for keypresses and sends them to all the PGItems with background focus
C PGMouseWatcherGroup | This is a specialization on MouseWatcherGroup, to associate it with a PGTop
C PGMouseWatcherParameter | This specialization on MouseWatcherParameter allows us to tag on additional elements to events for the gui system, and also inherits from TypedWritableReferenceCount so we can attach this thing to an event
C PGMouseWatcherRegion | This is a specialization on MouseWatcherRegion, to add a bit more fields that are relevant to the PG system
C PGScrollFrame | This is a special kind of frame that pretends to be much larger than it actually is
C PGSliderBar | This is a particular kind of PGItem that draws a little bar with a slider that moves from left to right indicating a value between the ranges
C PGSliderBarNotify | Objects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
C PGTop | The "top" node of the new Panda GUI system
C PGVirtualFrame | This represents a frame that is rendered as a window onto another (possibly much larger) canvas
C PGWaitBar | This is a particular kind of PGItem that draws a little bar that fills from left to right to indicate a slow process gradually completing, like a traditional "wait, loading" bar
C Physical | Defines a set of physically modeled attributes
C PhysicalNode | Graph node that encapsulated a series of physical objects
C PhysicsCollisionHandler | A specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
C PhysicsManager | Physics don't get much higher-level than this
C PhysicsObject | A body on which physics will be applied
C PhysicsObjectCollection | This is a set of zero or more PhysicsObjects
C PhysxActor | Actors are the main simulation objects
C PhysxActorDesc | Descriptor for PhysxActor
C PhysxBodyDesc | Descriptor for the optional rigid body dynamic state of PhysxActor
C PhysxBounds3 | Represention of a axis aligned bounding box
C PhysxBox | Represents an oriented bounding box, as a center point, extents(radii) and a rotation
C PhysxBoxController | Box character controller
C PhysxBoxControllerDesc | Descriptor class for PhysxBoxController
C PhysxBoxForceFieldShape | A box shaped region used to define a force field
C PhysxBoxForceFieldShapeDesc | Descriptor for a box force field shape
C PhysxBoxShape | A box shaped collision detection primitive
C PhysxBoxShapeDesc | Descriptor class for PhysxBoxShape
C PhysxCapsule | Represents a capsule
C PhysxCapsuleController | A capsule character controller
C PhysxCapsuleControllerDesc | Descriptor class for PhysxCapsuleController
C PhysxCapsuleForceFieldShape | A capsule shaped region used to define a force field
C PhysxCapsuleForceFieldShapeDesc | Descriptor for a capsule force field shape
C PhysxCapsuleShape | A capsule shaped collision detection primitive, also known as a line swept sphere
C PhysxCapsuleShapeDesc | Descriptor class for PhysxCapsuleShape
C PhysxCcdSkeleton | A Convex Mesh
C PhysxCcdSkeletonDesc |
C PhysxCloth |
C PhysxClothDesc | Descriptor for PhysxCloth
C PhysxClothMesh |
C PhysxClothMeshDesc |
C PhysxClothNode | Renderable geometry which represents a cloth mesh
C PhysxConstraintDominance | Expresses the dominance relationship of a constraint
C PhysxContactPair | An instance of this class is send with contact reporting events
C PhysxContactPoint | A helper structure for iterating over contact streams reported by PhysxContactPair
C PhysxContactReport | Implementation of the NxUserContactReport interface
C PhysxController | Abstract base class for character controllers
C PhysxControllerDesc | Descriptor class for a character controller
C PhysxControllerReport | Implementation of the NxUserControllerHitReport interface
C PhysxControllerShapeHit |
C PhysxControllersHit |
C PhysxConvexForceFieldShape | A convex shaped region used to define force field
C PhysxConvexForceFieldShapeDesc | A descriptor for a convex force field shape
C PhysxConvexMesh | A Convex Mesh
C PhysxConvexMeshDesc |
C PhysxConvexShape | A shapes which is used to represent an instance of an convex mesh
C PhysxConvexShapeDesc | Descriptor class for PhysxConvexShape
C PhysxCylindricalJoint | Cylindrical Joints permit relative translational movement between two bodies along an axis, and also relative rotation along the axis
C PhysxCylindricalJointDesc | Descriptor class for sliding joint
C PhysxD6Joint | A D6 joint is a general constraint between two actors
C PhysxD6JointDesc |
C PhysxDebugGeomNode | Renderable geometry which represents visualizations of physics objects
C PhysxDistanceJoint | A distance joint maintains a certain distance between two points on two actors
C PhysxDistanceJointDesc | Descriptor class for distance joint
C PhysxEnums | This class exists just to provide scoping for the enums shared by PhysX classes
C PhysxFileStream |
C PhysxFixedJoint | A fixed joint permits no relative movement between two bodies
C PhysxFixedJointDesc | Descriptor class for fixed joint
C PhysxForceField | A force field effector
C PhysxForceFieldDesc | Descriptor class for force fields
C PhysxForceFieldShape | Abstract base class for force field shapes
C PhysxForceFieldShapeDesc | Abstract base class for descriptors for force field shapes descriptors
C PhysxForceFieldShapeGroup |
C PhysxForceFieldShapeGroupDesc |
C PhysxGroupsMask | 128-bit bitmask class
C PhysxHeightField | A height field object
C PhysxHeightFieldDesc | Descriptor class for height fields
C PhysxHeightFieldShape | This class is a shape instance of a height field object of type PhysxHeightField
C PhysxHeightFieldShapeDesc | Descriptor class for PhysxHeightFieldShape
C PhysxJoint | Abstract base class for the different types of joints
C PhysxJointDesc | Abstract base class for joint descriptors
C PhysxJointDriveDesc | Used to describe drive properties for a PhysxD6Joint
C PhysxJointLimitDesc | Describes a joint limit
C PhysxJointLimitSoftDesc | Describes a joint limit
C PhysxKitchen |
C PhysxLinearInterpolationValues |
C PhysxManager | The central interface to the PhysX subsystem
C PhysxMask | 32-bit bitmask class
C PhysxMaterial | A class for describing a shape's surface properties
C PhysxMaterialDesc | Descriptor class for materials
C PhysxMemoryReadBuffer |
C PhysxMemoryWriteBuffer |
C PhysxMeshHash | Utility class used in building links between a tetrahedron mesh (soft body) and a triangle mesh used for rendering the soft body
C PhysxMeshPool | This class unifies all references to the same filename, so that multiple attempts to load the same mesh will return the same pointer
C PhysxMotorDesc | Describes a joint motor
C PhysxObject |
C PhysxObjectCollection |
C PhysxOverlapReport | Objects of this class are returned by the 'overlap shape' methods, for example overlapSphereShapes
C PhysxPlane |
C PhysxPlaneShape | A plane collision detection primitive
C PhysxPlaneShapeDesc | Descriptor class for PhysxPlaneShape
C PhysxPointInPlaneJoint | A point in plane joint constrains a point on one body to only move inside a plane attached to another body
C PhysxPointInPlaneJointDesc | Descriptor class for point-in-plane joint
C PhysxPointOnLineJoint | A point on line joint constrains a point on one body to only move along a line attached to another body
C PhysxPointOnLineJointDesc | Descriptor class for point-on-line joint
C PhysxPrismaticJoint | A prismatic joint permits relative translational movement between two bodies along an axis, but no relative rotational movement
C PhysxPrismaticJointDesc | Descriptor class for prismatic joint
C PhysxPulleyJoint | A pulley joint simulates a rope between two objects passing over two pulleys
C PhysxPulleyJointDesc | Descriptor class for distance joint
C PhysxRay | Represents an ray as an origin and direction
C PhysxRaycastHit | This structure captures results for a single raycast query
C PhysxRaycastReport | Objects of this class are returned by the 'raycast all' methods
C PhysxRevoluteJoint | A joint which behaves in a similar way to a hinge or axel
C PhysxRevoluteJointDesc | Descriptor class for distance joint
C PhysxScene | A scene is a collection of bodies, constraints, and effectors which can interact
C PhysxSceneDesc | Descriptor for PhysxScene
C PhysxSceneStats2 |
C PhysxSegment | Represents a line segment
C PhysxShape | Abstract base class for shapes
C PhysxShapeDesc | Abstract base class for shape descriptors
C PhysxSoftBody |
C PhysxSoftBodyDesc | Descriptor for PhysxSoftBody
C PhysxSoftBodyMesh |
C PhysxSoftBodyMeshDesc |
C PhysxSoftBodyNode | Renderable geometry which represents a soft body mesh
C PhysxSphere | Represents a sphere defined by its center point and radius
C PhysxSphereForceFieldShape | A spherical force field shape
C PhysxSphereForceFieldShapeDesc | A descriptor for a sphere force field shape
C PhysxSphereShape | A sphere shaped collision detection primitive
C PhysxSphereShapeDesc | Descriptor class for PhysxSphereShape
C PhysxSphericalJoint | A sphere joint constrains two points on two bodies to coincide
C PhysxSphericalJointDesc | Descriptor class for distance joint
C PhysxSpringDesc | Describes a joint spring
C PhysxTriangleMesh |
C PhysxTriangleMeshDesc |
C PhysxTriangleMeshShape | A shapes which is used to represent an instance of an convex mesh
C PhysxTriangleMeshShapeDesc | Descriptor class for PhysxTriangleMeshShape
C PhysxTriggerReport | Implementation of the NxUserTriggerReport interface
C PhysxUserEntityReport |
C PhysxUtilLib |
C PhysxVehicle |
C PhysxVehicleDesc |
C PhysxWheel |
C PhysxWheelDesc |
C PhysxWheelShape | A special shape used for simulating a car wheel
C PhysxWheelShapeDesc | Descriptor class for PhysxWheelShape
C PiecewiseCurve | A PiecewiseCurve is a curve made up of several curve segments, connected in a head-to-tail fashion
C Pipeline | This class manages a staged pipeline of data, for instance the render pipeline, so that each stage of the pipeline can simultaneously access different copies of the same data
C PipelineCycler | This class maintains different copies of a page of data between stages of the graphics pipeline (or any other pipelining context)
C PipelineCyclerLinks | This just stores the pointers to implement a doubly-linked list of PipelineCyclers for a particular Pipeline object
C PipelineCyclerTrivialImpl | This is the trivial, non-threaded implementation of PipelineCyclerBase
C PipeOcclusionCullTraverser | This specialization of CullTraverser uses the graphics pipe itself to perform occlusion culling
C PipeStreamBuf |
C pixel |
C PlaneNode | A node that contains a plane
C plist | This is our own Panda specialization on the default STL list
C pmap | This is our own Panda specialization on the default STL map
C pmultimap | This is our own Panda specialization on the default STL multimap
C pmultiset | This is our own Panda specialization on the default STL multiset
C PNMBrush | This class is used to control the shape and color of the drawing operations performed by a PNMPainter object
C PNMFileType | This is the base class of a family of classes that represent particular image file types that PNMImage supports
►C PNMFileTypePfm | For reading and writing PFM files using the basic PNMImage interface, as if they were basic RGB files
C Reader |
C Writer |
C PNMFileTypeRegistry | This class maintains the set of all known PNMFileTypes in the universe
►C PNMImage | The name of this class derives from the fact that we originally implemented it as a layer on top of the "pnm library", based on netpbm, which was built to implement pbm, pgm, and pbm files, and is the underlying support of a number of public-domain image file converters
C CRow |
C Row |
►C PNMImageHeader | This is the base class of PNMImage, PNMReader, and PNMWriter
C Histogram |
C PixelSpec |
C PixelSpecCount |
C PNMPainter | This class provides a number of convenient methods for painting drawings directly into a PNMImage
C PNMReader | This is an abstract base class that defines the interface for reading image files of various types
C PNMTextGlyph | A single glyph in a PNMTextMaker
C PNMTextMaker | This object uses the Freetype library to generate text directly into an image
C PNMWriter | This is an abstract base class that defines the interface for writing image files of various types
C PointEmitter | Describes a planar ring region in which particles are generated
C pointer_hash | This is the default hash_compare class, which assumes the Key is a pointer value
C PointerData | Holds the data that might be generated by a 2-d pointer input device, such as the mouse in the GraphicsWindow
C PointerEvent | Records a pointer movement event
C PointerEventList | Records a set of pointer events that happened recently
C PointerSlotStorage | Class to keep a list of pointers and nullpointers
C PointerTo | This file defines the classes PointerTo and ConstPointerTo (and their abbreviations, PT and CPT)
C PointerToArray | A special kind of PointerTo that stores an array of the indicated element type, instead of a single element
C PointerToArrayBase | This is the base class for PointerToArray and ConstPointerToArray
C PointerToBase | This is the base class for PointerTo and ConstPointerTo
C PointerToVoid | This is the non-template part of the base class for PointerTo and ConstPointerTo
C PointLight | A light originating from a single point in space, and shining in all directions
C PointParticle | Describes a particle that requires representation by a point (pixel, sparkle, billboard)
C PointParticleFactory | Creates point particles to user specs
C PointParticleRenderer | Simple point/point particle renderer
C PolylightEffect | A PolylightEffect can be used on a node to define a LightGroup for that node
C PolylightNode | A PolylightNode
C PortalClipper | This object performs a depth-first traversal of the scene graph, with optional view-frustum culling, collecting CullState and searching for GeomNodes
C PortalNode | A node in the scene graph that can hold a Portal Polygon, which is a rectangle
C PosixGraphicsStateGuardian | This GSG is used only for CallbackGraphicsWindow (which might not be using the glx interfaces), to add the ability to peek in libGL.so to find the extension functions
►C PreparedGraphicsObjects | A table of objects that are saved within the graphics context for reference by handle later
C EnqueuedObject | This is a handle to an enqueued object, from which the result can be obtained upon completion
C PrimeNumberGenerator | This class generates a table of prime numbers, up to the limit of an int
►C ProfileTimer |
C AutoTimer |
C ProgramBase | This is intended to be the base class for most general-purpose utility programs in the PANDATOOL tree
C ProjectionScreen | A ProjectionScreen implements a simple system for projective texturing
C pset | This is our own Panda specialization on the default STL set
C PSphereLens | A PSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
C PSSMCameraRig | RenderPipeline
C PStatClient | Manages the communications to report statistics via a network connection to a remote PStatServer
C PStatClientControlMessage | This kind of message is sent from the client to the server on the TCP socket to establish critical control information
C PStatClientData | The data associated with a particular client, but not with any one particular frame or thread: the list of collectors and threads, for instance
C PStatClientVersion | Records the version number of a particular client
C PStatCollector | A lightweight class that represents a single element that may be timed and/or counted via stats
►C PStatCollectorDef | Defines the details about the Collectors: the name, the suggested color, etc
C ColorDef |
C PStatCollectorForward | This class serves as a cheap forward reference to a PStatCollector, so that classes that are defined before the pstats module may access the PStatCollector
C PStatCollectorForwardBase | This class serves as a cheap forward reference to a PStatCollector, which is defined in the pstatclient module (and is not directly accessible here in the express module)
C PStatFrameData | Contains the raw timing and level data for a single frame
C PStatGPUTimer | This is a special type of PStatTimer that also uses a timer query on the GSG to measure how long a task actually takes to execute on the GPU, rather than how long it took for the API commands to be queued up
►C PStatGraph | This is an abstract base class for several different kinds of graphs that have a few things in common, like labels and guide bars
C GuideBar |
C PStatListener | This is the TCP rendezvous socket listener
C PStatMonitor | This is an abstract class that presents the interface to any number of different front-ends for the stats monitor
C PStatPianoRoll | This is an abstract class that presents the interface for drawing a piano- roll type chart: it shows the time spent in each of a number of collectors as a horizontal bar of color, with time as the horizontal axis
C PStatReader | This is the class that does all the work for handling communications from a single Panda client
C PStatServer | The overall manager of the network connections
C PStatServerControlMessage | This kind of message is sent from the server to the client on the TCP socket to establish critical control information
C PStatStripChart | This is an abstract class that presents the interface for drawing a basic strip-chart, showing the relative value over an interval of time for several different collectors, differentiated by bands of color
C PStatThread | A lightweight class that represents a single thread of execution to PStats
C PStatThreadData | A collection of FrameData structures for recently-received frames within a particular thread
C PStatTimer | A lightweight class that can be used to automatically start and stop a PStatCollector around a section of code
C PStatView | A View boils down the frame data to a linear list of times spent in a number of different Collectors, within a particular thread
C PStatViewLevel | This is a single level value, or band of color, within a View
C PtsToBam |
C Pursue |
C pvector | This is our own Panda specialization on the default STL vector
C QtessGlobals | Simply used as a namespace to scope some global variables for this program, set from the command line
C QtessInputEntry | Stores one entry in the qtess input file
C QtessInputFile | Stores all the information read from a tesselation input file: a list of QtessInputEntry's
C QtessSurface | A reference to an EggNurbsSurface in the egg file, and its parameters as set by the user input file and as computed in relation to the other surfaces
C QueryContext | This is a base class for queries that might require a round-trip to the graphics engine
C QueuedConnectionListener | This flavor of ConnectionListener will queue up all of the TCP connections it established for later detection by the client code
C QueuedConnectionManager | This flavor of ConnectionManager will queue up all of the reset-connection messages from the ConnectionReaders and ConnectionWriters and report them to the client on demand
C QueuedConnectionReader | This flavor of ConnectionReader will read from its sockets and queue up all of the datagrams read for later receipt by the client code
C QueuedReturn | This is the implementation of a family of things that queue up their return values for later retrieval by client code, like QueuedConnectionReader, QueuedConnectionListener, QueuedConnectionManager
C Ramfile | An in-memory buffer specifically designed for downloading files to memory
C Randomizer | A handy class to return random numbers
C RangeDescription | This describes a sparse range of Unicode character codes for conversion that may be specified on the command line
C RangeIterator | Walks through all the Unicode characters described by a RangeDescription class
C RecentConnectionReader | This flavor of ConnectionReader will read from its sockets and retain only the single most recent datagram for inspection by client code
C RecorderBase | This is the base class to a number of objects that record particular kinds of user input (like a MouseRecorder) to use in conjunction with a RecorderController to record the user's inputs for a session
C RecorderController | This object manages the process of recording the user's runtime inputs to a bam file so that the session can be recreated later
C RecorderFrame | This object represents one frame of data in the recorded session file
C RecorderHeader | This object contains the header information written out at the beginning of a recorded session file
C RecorderTable | This object is used by the RecorderController to write (and read) a record of the set of recorders in use to the bam file
C RectangleEmitter | Describes a planar square region in which particles are generated
C RectangleLight | This is a type of area light that is an axis aligned rectangle, pointing along the Y axis in the positive direction
C RefCountObj | Another kind of proxy, similar to RefCountProxy
C RefCountProxy | A "proxy" to use to make a reference-countable object whenever the object cannot inherit from ReferenceCount for some reason
C ReferenceCount | A base class for all things that want to be reference-counted
C ReferenceCountedVector | This defines the object that is actually stored and reference-counted internally by a PointerToArray
C ReMutex | A reentrant mutex
C ReMutexDirect | This class implements a standard reMutex by making direct calls to the underlying implementation layer
C ReMutexHolder | Similar to MutexHolder, but for a reentrant mutex
C RenderAttrib | This is the base class for a number of render attributes (other than transform) that may be set on scene graph nodes to control the appearance of geometry
C RenderAttribRegistry | This class is used to associate each RenderAttrib with a different slot index at runtime, so we can store a list of RenderAttribs in the RenderState object, and very quickly look them up by type
C RenderBuffer | A RenderBuffer is an arbitrary subset of the various layers (depth buffer, color buffer, etc.) of a drawing region
C RenderEffect | This is the base class for a number of special render effects that may be set on scene graph nodes to change the way they render
C RenderEffects | This represents a unique collection of RenderEffect objects that correspond to a particular renderable state
C RenderModeAttrib | Specifies how polygons are to be drawn
C RenderState | This represents a unique collection of RenderAttrib objects that correspond to a particular renderable state
C RescaleNormalAttrib | Specifies how polygons are to be drawn
C ReversedNumericData | NativeNumericData and ReversedNumericData work together to provide a sneaky interface for automatically byte-swapping numbers, when necessary, to transparency support big-endian and little-endian architectures
C RigidBodyCombiner | This is a special node that combines multiple independently-moving rigid nodes into one Geom internally (or as few Geoms as possible), for the purposes of improving rendering performance
C RingBuffer |
C RingEmitter | Describes a planar ring region in which particles are generated
C RocketFileInterface | Implementation of FileInterface to allow libRocket to read files from the virtual file system
C RocketInputHandler | DataNode that listens for keyboard and mouse events and passes them to libRocket
C RocketRegion | Represents a region in a window or buffer where the libRocket UI will be rendered to
C RocketRenderInterface | Class that provides the main render interface for libRocket integration
C RocketSystemInterface | This is an implementation of SystemInterface that redirects the log output to Panda's notify system
C RopeNode | This class draws a visible representation of the NURBS curve stored in its NurbsCurveEvaluator
C RPLight | RenderPipeline
C RPPointLight | RenderPipeline
C RPSpotLight | RenderPipeline
►C SampleClass | A basic description of the function and purpose of SampleClass
C NestedClass |
C SamplerContext | This is a special class object that holds a handle to the sampler state object given by the graphics back-end for a particular combination of texture sampling settings
C SamplerState | Represents a set of settings that indicate how a texture is sampled
C SavedContext | This is the base class for all GSG-specific context objects, such as TextureContext and GeomContext
C sBodyParams |
C SceneGraphAnalyzer | A handy class that can scrub over a scene graph and collect interesting statistics on it
C SceneGraphAnalyzerMeter | This is a special TextNode that automatically updates itself with output from a SceneGraphAnalyzer instance
C SceneGraphReducer | An interface for simplifying ("flattening") scene graphs by eliminating unneeded nodes and collapsing out unneeded state changes and transforms
C SceneSetup | This object holds the camera position, etc., and other general setup information for rendering a particular scene
C ScissorAttrib | This restricts rendering to within a rectangular region of the scene, without otherwise affecting the viewport or lens properties
C ScissorEffect | This provides a higher-level wrapper around ScissorAttrib
C second_of_pair_iterator | This is an iterator adaptor that converts any iterator that returns a pair (e.g
C Seek |
C SelectiveChildNode | A base class for nodes like LODNode and SequenceNode that select only one visible child at a time
C Semaphore | A classic semaphore synchronization primitive
C sequence_hash | This hash_compare class hashes a string
C SequenceNode | A node that automatically cycles through rendering each one of its children according to its frame rate
C SFNodeRef |
C ShadeModelAttrib | Specifies whether flat shading (per-polygon) or smooth shading (per-vertex) is in effect
►C Shader |
C ShaderArgId |
C ShaderArgInfo |
C ShaderCaps |
C ShaderFile |
C ShaderMatSpec |
C ShaderPtrData |
C ShaderPtrSpec |
C ShaderTexSpec |
C ShaderVarSpec |
C ShaderAttrib |
C ShaderBuffer | This is a generic buffer object that lives in graphics memory
C ShaderContext | The ShaderContext is meant to contain the compiled version of a shader string
C ShaderGenerator |
C ShaderInput | This is a small container class that can hold any one of the value types that can be passed as input to a shader
C ShaderPool | This is the preferred interface for loading shaders for the TextNode system
C ShaderTerrainMesh | Terrain Renderer class utilizing the GPU
C ShadowAtlas | Class which manages distributing shadow maps in an atlas
C ShadowManager |
C ShadowSource | RenderPipeline
C SheetNode | This class draws a visible representation of the NURBS surface stored in its NurbsSurfaceEvaluator
C ShowBoundsEffect | Applied to a GeomNode to cause a visible bounding volume to be drawn for this node
C ShowInterval | An interval that calls NodePath::show()
C SimpleAllocator | An implementation of a very simple block allocator
C SimpleAllocatorBlock | A single block as returned from SimpleAllocator::alloc()
C SimpleHashMap | This template class implements an unordered map of keys to data, implemented as a hashtable
C SimpleKeyValuePair | Entry in the SimpleHashMap
C SimpleKeyValuePair< Key, std::nullptr_t > | Specialisation of SimpleKeyValuePair to not waste memory for nullptr_t values
C SimpleLru | An implementation of a very simple LRU algorithm
C SimpleLruPage | One atomic piece that may be managed by a SimpleLru chain
C SliderTable | Stores the total set of VertexSliders that the vertices in a particular GeomVertexData object might depend on
►C SmoothMover | This class handles smoothing of sampled motion points over time, e.g
C SamplePoint |
C Socket_Address | A simple place to store and manipulate tcp and port address for communication layer
C Socket_fdset |
C Socket_IP | Base functionality for a INET domain Socket This call should be the starting point for all other unix domain sockets
C Socket_Selector |
C Socket_TCP | Base functionality for a TCP connected socket This class is pretty useless by itself but it does hide some of the platform differences from machine to machine
C Socket_TCP_Listen | Base functionality for a TCP rendezvous socket
C Socket_UDP | Base functionality for a combination UDP Reader and Writer
C Socket_UDP_Incoming | Base functionality for a UDP Reader
C Socket_UDP_Outgoing | Base functionality for a UDP sending socket
C SomethingToEgg | This is the general base class for a file-converter program that reads some model file format and generates an egg file
C SomethingToEggConverter | This is a base class for a family of converter classes that manage a conversion from some file type to egg format
C SortPlacementBySize |
C SourceTextureImage | This is a texture image reference as it appears in an egg file: the source image of the texture
C SparkleParticleRenderer | Pretty sparkly things
C SparseArray | This class records a set of integers, where each integer is either present or not present in the set
►C SpeedTreeNode | Interfaces with the SpeedTree library to render SpeedTree objects, especially trees, within the Panda3D scene graph
C InstanceList |
C SphereLight | A sphere light is like a point light, except that it represents a sphere with a radius, rather than being an infinitely thin point in space
C SphereSurfaceEmitter | Describes a curved space in which particles are generated
C SphereVolumeEmitter | Describes a voluminous spherical region in which particles are generated
C Spotlight | A light originating from a single point in space, and shining in a particular direction, with a cone-shaped falloff
C SpriteAnim | Helper class used by SpriteParticleRenderer to keep track of its textures and their respective UVs and source types
C SpriteParticleRenderer | Renders a particle system with high-speed nasty trick sprites
C SpriteWriter | Helper class used by SpriteParticleRenderer to keep track of the various GeomVertexWriters associated with each geom created in SpriteParticleRenderer::init_geoms()
C sSurfaceParams |
C StackedPerlinNoise2 | Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
C StackedPerlinNoise3 | Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
C StandardMunger | Performs some generic munging that is appropriate for all GSG types; for instance, applies ColorAttrib and ColorScaleAttrib to the vertices, and checks for hardware-accelerated animation capabilities
C StateMunger | This is just a simple derivative of GeomMunger that adds the ability to munge states
C StaticDeletedChain | This template class is used to conveniently declare a single instance of the DeletedChain template object, above, for a particular type
C StaticTextFont | A StaticTextFont is loaded up from a model that was previously generated via egg-mkfont, and contains all of its glyphs already generated and available for use
C STBasicTerrain | A specific implementation of STTerrain that supports basic heightmaps loaded from an image file, as described in a terrain.txt file similar to those provided with the SpeedTree example application
C stbi_io_callbacks |
C StencilAttrib | A StencilAttrib is a collection of all stencil render states
C StereoDisplayRegion | This is a special DisplayRegion wrapper that actually includes a pair of DisplayRegions internally: the left and right eyes
C stl_hash_compare |
C StreamReader | A class to read sequential binary data directly from an istream
C StreamWrapper | This class provides a locking wrapper around a combination ostream/istream pointer
C StreamWrapperBase | The base class for both IStreamWrapper and OStreamWrapper, this provides the common locking interface
C StreamWriter | A StreamWriter object is used to write sequential binary data directly to an ostream
►C string | STL class
C const_iterator | STL iterator class
C const_reverse_iterator | STL iterator class
C iterator | STL iterator class
C reverse_iterator | STL iterator class
C StringDecoder | The base class to a family of classes that decode various kinds of encoded byte streams
C StringStream | A bi-directional stream object that reads and writes data to an internal buffer, which can be retrieved and/or set as a string in Python 2 or a bytes object in Python 3
C stringstream | STL class
C StringStreamBuf | Used by StringStream to implement an stream that reads from and/or writes to a memory buffer, whose contents can be appended to or extracted at any time by application code
C StringUtf16Decoder | This decoder extracts characters two at a time to get a plain wide character sequence
C StringUtf8Decoder | This decoder extracts utf-8 sequences
C STTerrain | This is the abstract base class that defines the interface needed to describe a terrain for rendering by SpeedTree
C STTransform | Represents a transform that may be applied to a particular instance of a tree when added to the SpeedTreeNode
C STTree | Encapsulates a single tree model in the SpeedTree library, as loaded from an SRT file
C SubdivSegment | Represents a single hypothetical subdivided segment, under consideration by the IsoPlacer
C SubfileInfo | This class records a particular byte sub-range within an existing file on disk
►C SubprocessWindowBuffer | This is a special class that is designed to faciliate SubprocessWindow
C Event |
C SubStream | Combined ISubStream and OSubStream for bidirectional I/O
C SubStreamBuf | The streambuf object that implements ISubStream
C SwitchNode | A node that renders only one of its children, according to the user's indication
C TagStateManager | This class handles all different tag states
C TangentRingEmitter | Describes a planar ring region in which tangent particles are generated, and particles fly off tangential to the ring
C TemporaryFile | This is a special kind of FileReference class that automatically deletes the file in question when it is deleted
C TestCopy | A program to copy ordinary files into the cvs tree
C TexGenAttrib | Computes texture coordinates for geometry automatically based on vertex position and/or normal
C TexMatrixAttrib | Applies a transform matrix to UV's before they are rendered
C TexProjectorEffect | This effect automatically applies a computed texture matrix to the specified texture stage, according to the relative position of two specified nodes
C TextAssembler | This class is not normally used directly by user code, but is used by the TextNode to lay out a block of text and convert it into rows of Geoms according to the TextProperties
C TextEncoder | This class can be used to convert text between multiple representations, e.g
C TextFont | An encapsulation of a font; i.e
C TextGlyph | A representation of a single glyph (character) from a font
C TextGraphic | This defines a special model that has been constructed for the purposes of embedding an arbitrary graphic image within a text paragraph
C TextMonitor | A simple, scrolling-text stats monitor
C TextNode | The primary interface to this module
C TextProperties | This defines the set of visual properties that may be assigned to the individual characters of the text
C TextPropertiesManager | This defines all of the TextProperties structures that might be referenced by name from an embedded text string
C TextStats | A simple, scrolling-text stats server
C Texture | Represents a texture object, which is typically a single 2-d image but may also represent a 1-d or 3-d texture image, or the six 2-d faces of a cube map texture
C TextureAttrib | Indicates the set of TextureStages and their associated Textures that should be applied to (or removed from) a node
C TextureCollection | Manages a list of Texture objects, as returned by TexturePool::find_all_textures()
C TextureContext | This is a special class object that holds all the information returned by a particular GSG to indicate the texture's internal context identifier
C TextureImage | This represents a single source texture that is referenced by one or more egg files
C TextureMemoryCounter | This class is used to gather statistics on texture memory usage, etc
C TexturePeeker | An instance of this object is returned by Texture::peek()
C TexturePlacement | This corresponds to a particular assignment of a TextureImage with a PaletteGroup, and specifically describes which PaletteImage (if any), and where on the PaletteImage, the TextureImage has been assigned to
C TexturePool | This is the preferred interface for loading textures from image files
C TexturePoolFilter | This is an abstract base class, a placeholder for any number of different classes that may wish to implement an effect on every texture loaded from disk via the TexturePool
C TexturePosition | This represents a particular position of a texture within a PaletteImage
C TextureProperties | This is the set of characteristics of a texture that, if different from another texture, prevent the two textures from sharing a PaletteImage
C TextureReference | This is the particular reference of a texture filename by an egg file
C TextureReloadRequest | This loader request will call Texture::get_ram_image() in a sub-thread, to force the texture's image to be re-read from disk
C TextureRequest | These are the things that a user might explicitly request to adjust on a texture via a line in the .txa file
C TextureStage | Defines the properties of a named stage of the multitexture pipeline
C TextureStageCollection |
C TextureStagePool | The TextureStagePool (there is only one in the universe) serves to unify different pointers to the same TextureStage, mainly to help developers use a common pointer to access things that are loaded from different model files
►C Thread | A thread; that is, a lightweight process
C PStatsCallback |
C ThreadSafeConstPointerTo |
C ThreadSafePointerTo | This works exactly like PointerTo, except that the object is designed to be thread-safe: it is generally safe to make unprotected assignments to this pointer, in the sense that the last assignment will win and the reference counts will be properly maintained
C ThreadSafePointerToBase | This is the base class for ThreadSafePointerTo and ThreadSafeConstPointerTo
C Time_Accumulator |
C Time_Clock | This class is to provide a consistant interface and storage to clock time
C Time_Out |
C Time_Span |
C TimedCycle | A class for anything that needs to cycle over some finite list of elements in increments based on time
C TimerQueryContext |
C TimeVal |
C TiXmlAttribute | An attribute is a name-value pair
C TiXmlAttributeSet |
C TiXmlBase | TiXmlBase is a base class for every class in TinyXml
C TiXmlComment | An XML comment
C TiXmlCursor |
C TiXmlDeclaration | In correct XML the declaration is the first entry in the file
C TiXmlDocument | Always the top level node
C TiXmlElement | The element is a container class
C TiXmlHandle | A TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing
C TiXmlNode | The parent class for everything in the Document Object Model
C TiXmlPrinter | Print to memory functionality
C TiXmlText | XML text
C TiXmlUnknown | Any tag that tinyXml doesn't recognize is saved as an unknown
C TiXmlVisitor | Implements the interface to the "Visitor pattern" (see the Accept() method.) If you call the Accept() method, it requires being passed a TiXmlVisitor class to handle callbacks
C TouchInfo | Stores information for a single touch event
C Trackball | Trackball acts like Performer in trackball mode
C TrackerData | Stores the kinds of data that a tracker might output
C TrackerNode | This class reads the position and orientation information from a tracker device and makes it available as a transformation on the data graph
C Transform2SG | Input: Transform (matrix)
C TransformBlend | This defines a single entry in a TransformBlendTable
C TransformBlendTable | This structure collects together the different combinations of transforms and blend amounts used by a GeomVertexData, to facilitate computing dynamic vertices on the CPU at runtime
C TransformState | Indicates a coordinate-system transform on vertices
C TransformTable | Stores the total set of VertexTransforms that the vertices in a particular GeomVertexData object might depend on
C TransparencyAttrib | This controls the enabling of transparency
C Triangulator | This class can triangulate a convex or concave polygon, even one with holes
C Triangulator3 | This is an extension of Triangulator to handle polygons with three- dimensional points
C TrueClock | An interface to whatever real-time clock we might have available in the current environment
C TxaFile | This represents the .txa file (usually textures.txa) that contains the user instructions for resizing, grouping, etc
C TxaFileFilter | This is an abstract base class, a placeholder for any number of different classes that may wish to implement an effect on every texture loaded from disk via the TexturePool
C TxaLine | This is a single matching line in the .txa file
C typecast_iterator | This is an iterator adaptor that explicitly typecasts each value returned by the base iterator to the indicated type
C TypedObject | This is an abstract class that all classes which use TypeHandle, and also provide virtual functions to support polymorphism, should inherit from
C TypedReferenceCount | A base class for things which need to inherit from both TypedObject and from ReferenceCount
C TypedSkel | Skeleton object that inherits from TypedObject
C TypedWritable | Base class for objects that can be written to and read from Bam files
C TypedWritableReferenceCount | A base class for things which need to inherit from both TypedWritable and from ReferenceCount
C TypeHandle | TypeHandle is the identifier used to differentiate C++ class types
C TypeRegistry | Maintains all the assigned TypeHandles in a given system
C TypeRegistryNode | This is a single entry in the TypeRegistry
►C UnicodeLatinMap | This class mainly serves as a container for a largish table of the subset of the Unicode character set that corresponds to the Latin alphabet, with its various accent marks and so on
C Entry |
C UnionBoundingVolume | This special bounding volume is the union of all of its constituent bounding volumes
C UniqueEggMaterials | An STL function object for sorting materials into order by properties
C UniqueEggTextures | An STL function object for sorting textures into order by properties
C UniqueEggVertices | An STL function object for sorting vertices into order by properties
C UniqueIdAllocator | Manage a set of ID values from min to max inclusive
C UpdateSeq | This is a sequence number that increments monotonically
C URLSpec | A container for a URL, e.g
C UserDataAudio | A UserDataAudio is a way for the user to manually supply raw audio samples
C UserDataAudioCursor | A UserDataAudioCursor is a means to manually supply a sequence of raw audio samples
C UserPersistentData |
C UserVertexSlider | This is a specialization on VertexSlider that allows the user to specify any arbitrary slider valie he likes
C UserVertexTransform | This is a specialization on VertexTransform that allows the user to specify any arbitrary transform matrix he likes
C UvScrollNode | This node is placed at key points within the scene graph to animate uvs
►C vector | STL class
C const_iterator | STL iterator class
C const_reverse_iterator | STL iterator class
C iterator | STL iterator class
C reverse_iterator | STL iterator class
C VertexBufferContext | This is a special class object that holds all the information returned by a particular GSG to indicate the vertex data array's internal context identifier
C VertexDataBlock | A block of bytes that stores the actual raw vertex data referenced by a GeomVertexArrayData object
C VertexDataBook | A collection of VertexDataPages, which can be used to allocate new VertexDataBlock objects
C VertexDataBuffer | A block of bytes that stores the actual raw vertex data referenced by a GeomVertexArrayData object
C VertexDataPage | A block of bytes that holds one or more VertexDataBlocks
C VertexDataSaveBlock | A block of bytes on the save file
C VertexDataSaveFile | A temporary file to hold the vertex data that has been evicted from memory and written to disk
C VertexElementArray | This class gives the ability for a user-friendly way of creating a vertex declaration for DirectX 9
C VertexMembership | This class is used to help EggOptchar quantize the membership of one vertex among its various groups
C VertexSlider | This is an abstract base class that retains some slider value, which is a linear value that typically ranges from 0.0 to 1.0, and is used to control the animation of morphs (blend shapes)
C VertexTransform | This is an abstract base class that holds a pointer to some transform, computed in some arbitrary way, that is to be applied to vertices during rendering
C VideoTexture | The base class for a family of animated Textures that take their input from a video source, such as a movie file
C VirtualFile | The abstract base class for a file or directory within the VirtualFileSystem
C VirtualFileComposite | A composite directory within the VirtualFileSystem: this maps to more than one directory on different mount points
C VirtualFileList | A list of VirtualFiles, as returned by VirtualFile::scan_directory()
C VirtualFileMount | The abstract base class for a mount definition used within a VirtualFileSystem
C VirtualFileMountMultifile | Maps a Multifile's contents into the VirtualFileSystem
C VirtualFileMountRamdisk | Simulates an actual directory on disk with in-memory storage
C VirtualFileMountSystem | Maps an actual OS directory into the VirtualFileSystem
C VirtualFileSimple | A simple file or directory within the VirtualFileSystem: this maps to exactly one file on one mount point
C VirtualFileSystem | A hierarchy of directories and files that appears to be one continuous file system, even though the files may originate from several different sources that may not be related to the actual OS's file system
C VirtualMouse | Poses as a MouseAndKeyboard object in the datagraph, but accepts input from user calls, rather than reading the actual mouse and keyboard from an input device
C VRMLAppearance |
C VrmlFieldValue |
►C VrmlNode |
C Field |
►C VrmlNodeType |
C NameTypeRec |
C VRMLToEgg | A program to read a VRML file and generate an egg file
C VRMLToEggConverter | This class supervises the construction of an EggData structure from a VRML file
C VRMLTrans | A program to read a VRML file and output an essentially similar VRML file
C VrpnAnalog | This is the actual interface to a particular VRPN analog device, and all of its numbered controls
C VrpnAnalogDevice | The Panda interface to a VRPN analog device
C VrpnButton | This is the actual interface to a particular VRPN button device, and all of its numbered buttons
C VrpnButtonDevice | The Panda interface to a VRPN button
C VrpnClient | A specific ClientBase that connects to a VRPN server and records information on the connected VRPN devices
C VrpnDial | This is the actual interface to a particular VRPN dial device, and all of its numbered dials
C VrpnDialDevice | The Panda interface to a VRPN dial device
C VrpnTracker | This is the actual interface to a particular VRPN tracker object, and all of its sensors
C VrpnTrackerDevice | The Panda interface to a VRPN tracker
C WaitInterval | This interval does absolutely nothing, and is mainly useful for marking time between other intervals within a sequence
C Wander |
C WavAudio | A native PCM .wav loader
C WavAudioCursor | Used for reading PCM .wav files
C wdxGraphicsBuffer9 | An offscreen render buffer
C wdxGraphicsPipe9 | This graphics pipe represents the interface for creating DirectX9 graphics windows
C wdxGraphicsWindow9 | A single graphics window for rendering DirectX under Microsoft Windows
C WeakConstPointerTo | A WeakConstPointerTo is similar to a WeakPointerTo, except it keeps a const pointer to the thing, that will be cleared to NULL when the thing deleted
C WeakNodePath | This class is a wrapper around a NodePath that, unlike the actual NodePath class, doesn't hold a reference count to the node
C WeakPointerCallback | Derive from this class and override the callback() method if you want to get an immediate callback from a WeakPointerTo object when its referenced pointer is deleted
C WeakPointerTo | WeakPointerTo is similar to PointerTo, except that it does not actually prevent the referenced pointer from deleting
C WeakPointerToBase | This is the base class for PointerTo and ConstPointerTo
C WeakPointerToVoid | This is the specialization of PointerToVoid for weak pointers
C WeakReferenceList | This is an object shared by all the weak pointers that point to the same ReferenceCount object
C WebcamVideo | Allows you to open a webcam or other video capture device as a video stream
C wglGraphicsBuffer | An offscreen render buffer
C wglGraphicsPipe | This graphics pipe represents the interface for creating OpenGL graphics windows on the various Windows OSes
C wglGraphicsStateGuardian | A tiny specialization on GLGraphicsStateGuardian to add some wgl-specific information
C wglGraphicsWindow | A single graphics window for rendering OpenGL under Microsoft Windows
C WindowFramework | This encapsulates the data that is normally associated with a single window, or with a single display region within a window
►C WindowHandle | This object represents a window on the desktop, not necessarily a Panda window
C OSHandle |
C WindowProperties | A container for the various kinds of properties we might ask to have on a graphics window before we open it
C WindowsGuid | This is an implementation of the Windows GUID object, used everywhere as a world-unique identifier for anything and everything
C WinGraphicsPipe | This is an abstract base class for wglGraphicsPipe and wdxGraphicsPipe; that is, those graphics pipes that are specialized for working with Microsoft Windows
C WinGraphicsWindow | An abstract base class for glGraphicsWindow and dxGraphicsWindow (and, in general, graphics windows that interface with the Microsoft Windows API)
C WinStatsChartMenu | A pulldown menu of charts available for a particular thread
C WinStatsGraph | This is just an abstract base class to provide a common pointer type for the various kinds of graphs that may be created for a WinStatsMonitor
C WinStatsLabel | A text label that will draw in color appropriate for a particular collector
C WinStatsLabelStack | A window that contains a stack of labels from bottom to top
►C WinStatsMonitor | This class represents a connection to a PStatsClient and manages the data exchange with the client
C MenuDef |
C WinStatsPianoRoll | A window that draws a piano-roll style chart, which shows the collectors explicitly stopping and starting, one frame at a time
C WinStatsServer | The class that owns the main loop, waiting for client connections
C WinStatsStripChart | A window that draws a strip chart, given a view
C WithOutputFile | This is the bare functionality (intended to be inherited from along with ProgramBase or some derivative) for a program that might generate an output file
C WordWrapStream | A special ostream that formats all of its output through ProgramBase::show_text()
C WordWrapStreamBuf | Used by WordWrapStream to implement an ostream that flushes its output to ProgramBase::show_text()
C WorkingNodePath | This is a class designed to support low-overhead traversals of the complete scene graph, with a memory of the complete path through the graph at any given point
C WritableConfigurable | Defined as a fix to allow creating Configurable and Writable objects
C WritableParam | The specific derivation of FactoryParam that contains the information needed by a TypedWritable object
►C wstring | STL class
C const_iterator | STL iterator class
C const_reverse_iterator | STL iterator class
C iterator | STL iterator class
C reverse_iterator | STL iterator class
C x11GraphicsPipe | This graphics pipe represents the interface for creating graphics windows on an X-based client
C x11GraphicsWindow | Interfaces to the X11 window system
C XFile | This represents the complete contents of an X file (file.x) in memory
►C XFileAnimationSet | This represents a tree of EggTables, corresponding to Animation entries in the X file
C FrameData |
C FrameEntry |
C XFileArrayDef | Defines one level of array bounds for an associated XFileDataDef element
C XFileDataDef | A definition of a single data element appearing within a template record
C XFileDataNode | This is an abstract base class for an XFileNode which is also an XFileDataObject
C XFileDataNodeReference | This is a nested reference to an instance of a template object, declared via the syntax:
C XFileDataNodeTemplate | This is a node which contains all of the data elements defined by a template
C XFileDataObject | The abstract base class for a number of different types of data elements that may be stored in the X file
C XFileDataObjectArray | An array of nested data elements
C XFileDataObjectDouble | An double-valued data element
C XFileDataObjectInteger | An integer-valued data element
C XFileDataObjectString | An string-valued data element
►C XFileFace | This represents a single face of an XFileMesh
C Vertex |
C XFileMaker | This class converts a Panda scene graph into a .X file and writes it out
C XFileMaterial | This represents an X file "material", which consists of a color, lighting, and/or texture specification
C XFileMesh | This is a collection of polygons; i.e
C XFileNode | A single node of an X file
C XFileNormal | This represents a single normal associated with an XFileFace
C XFileParseData | This class is used to fill up the data into an XFileDataNodeTemplate object as the data values are parsed out of the X file
C XFileParseDataList | A container for a pvector of the above objects
C XFileTemplate | A template definition in the X file
C XFileToEgg | A program to read a DirectX "x" file and generate an egg file
C XFileToEggConverter |
C XFileTrans | A program to read a X file and output an essentially similar X file
C XFileVertex | This represents a single vertex associated with an XFileFace
C XFileVertexPool | This is a collection of unique vertices as extracted out of a Geom or a series of Geoms
C XRRScreenSize |
►C XTokenType |
C U |
C ZSpinParticle | Describes a particle that spins along its z axis
C ZSpinParticleFactory |