Panda3D
Class List

Don't mind the mess!

We're currently in the process of migrating the Panda3D API Reference to a new service. This is a temporary layout in the meantime.

Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
 NstdSTL namespace
 CAccumulatedAttribsThis 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
 CACMatrixSwitchType
 CACScalarSwitchType
 CActorNodeLike a physical node, but with a little more
 CAdaptiveLruA 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
 CAdaptiveLruPageOne atomic piece that may be managed by a AdaptiveLru chain
 CAdaptiveLruPageDynamicList
 CAdaptiveLruPageStaticList
 CAddHashThis 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)
 CAIBehaviorsThis class implements all the steering behaviors of the AI framework, such as seek, flee, pursue, evade, wander and flock
 CAICharacter
 CAINodeThis class is used to assign the nodes on the mesh
 CAIWorldA class that implements the virtual AI world which keeps track of the AI characters active at any given time
 CAlphaTestAttribEnables or disables writing of pixel to framebuffer based on its alpha value relative to a reference alpha value
 CAmbientLightA light source that seems to illuminate all points in space at once
 CAnalogNodeThis is the primary interface to analog controls like sliders and joysticks associated with a ClientBase
 CAndroidGraphicsPipeThis graphics pipe represents the interface for creating OpenGL ES graphics windows on an X-based (e.g
 CAndroidGraphicsStateGuardianA tiny specialization on GLESGraphicsStateGuardian to add some egl-specific information
 CAndroidGraphicsWindowAn interface to manage Android windows and their appropriate EGL surfaces
 CAngularEulerIntegratorPerforms Euler integration on a vector of physically modelable objects given a quantum dt
 CAngularForcePure virtual parent of all quat-based forces
 CAngularIntegratorPure virtual base class for physical modeling
 CAngularVectorForceSimple directed torque force, the angular equivalent of simple vector force
 CAnimateVerticesRequestThis class object manages a single asynchronous request to animate vertices on a GeomVertexData object
 CAnimBundleThis is the root of an AnimChannel hierarchy
 CAnimBundleMakerConverts an EggTable hierarchy, beginning with a <Bundle> entry, into an AnimBundle hierarchy
 CAnimBundleNodeThis is a node that contains a pointer to an AnimBundle
 CAnimChannelThis template class is the parent class for all kinds of AnimChannels that return different values
 CAnimChannelBaseParent class for all animation channels
 CAnimChannelFixedThis template class is a special kind of AnimChannel that always returns just one fixed value
 CAnimChannelMatrixDynamicAn animation channel that accepts a matrix each frame from some dynamic input provided by code
 CAnimChannelMatrixFixedA specialization on AnimChannel to add all the special matrix component operations
 CAnimChannelMatrixXfmTableAn animation channel that issues a matrix each frame, read from a table such as might have been read from an egg file
 CAnimChannelScalarDynamicAn animation channel that accepts a scalar each frame from some dynamic input provided by code
 CAnimChannelScalarTableAn animation channel that issues a scalar each frame, read from a table such as might have been read from an egg file
 CAnimControlControls the timing of a character animation
 CAnimControlCollectionThis is a named collection of AnimControl pointers
 CAnimGroupThis is the base class for AnimChannel and AnimBundle
 CAnimInterfaceThis is the fundamental interface for things that have a play/loop/stop type interface for frame-based animation, such as animated characters
 CAnimPreloadTableThis table records data about a list of animations for a particular model, such as number of frames and frame rate
 CAntialiasAttribSpecifies whether or how to enable antialiasing, if supported by the backend renderer
 CArcEmitterDescribes a planar ring region in which particles are generated
 CArrival
 CAssimpLoaderClass that interfaces with Assimp and builds Panda nodes to represent the Assimp structures
 CAsyncFutureThis 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
 CAsyncGatheringFutureSpecific future that collects the results of several futures
 CAsyncTaskThis class represents a concrete task performed by an AsyncManager
 CAsyncTaskChainThe AsyncTaskChain is a subset of the AsyncTaskManager
 CAsyncTaskCollectionA list of tasks, for instance as returned by some of the AsyncTaskManager query functions
 CAsyncTaskManagerA 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)
 CAsyncTaskPauseA special kind of task that simple returns DS_pause, to pause for a specified number of seconds and then finish
 CAsyncTaskSequenceA special kind of task that serves as a list of tasks internally
 CAtomicAdjustDummyImplA trivial implementation for atomic adjustments for systems that don't require multiprogramming, and therefore don't require special atomic operations
 CAttribNodeRegistryThis global object records NodePaths that are referenced by scene graph attribs, such as ClipPlaneAttribs and LightAttribs
 CAudioLoadRequestA class object that manages a single asynchronous audio load request
 CAudioManager
 CAudioSound
 CAudioVolumeAttribApplies a scale to audio volume for positional sounds in the scene graph
 CAuxBitplaneAttribModern frame buffers can have 'aux' bitplanes, which are additional bitplanes above and beyond the standard depth and color
 CAuxSceneDataThis 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
 CBamCacheThis 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)
 CBamCacheIndexThis represents the in-memory index that records the list of files stored in the BamCache
 CBamCacheRecordAn 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
 CBamEnumsThis class exists just to provide scoping for the enums shared by BamReader and BamWriter
 CBamFileThe principle public interface to reading and writing Bam disk files
 CBamInfo
 CBamReaderThis is the fundamental interface for extracting binary objects from a Bam file, as generated by a BamWriter
 CBamReaderAuxDataStores auxiliary data that may be piggybacked on the BamReader during each object's read pass
 CBamReaderParamThe parameters that are passed through the Factory to any object constructing itself from a Bam file
 CBamToEggThis program reads a bam file, for instance as written out from a real-time interaction session, and generates a corresponding egg file
 CBamWriterThis is the fundamental interface for writing binary objects to a Bam file, to be extracted later by a BamReader
 CBaseForcePure virtual base class for all forces that could POSSIBLY exist
 CBaseIntegratorPure virtual integrator class that holds cached matrix information that really should be common to any possible child implementation
 CBaseParticleAn individual, physically-modelable particle abstract base class
 CBaseParticleEmitter
 CBaseParticleFactoryPure Virtual base class for creating particles
 CBaseParticleRendererPure virtual particle renderer base class
 CBasicSkelThis is the most basic of the skeleton classes
 CBillboardEffectIndicates that geometry at this node should automatically rotate to face the camera, or any other arbitrary node
 CBinCullHandlerThis CullHandler sends all of the geoms it receives into a CullResult object, for binning (and later drawing)
 CBindAnimRequestThis class object manages an asynchronous load-and-bind animation request, as issued through PartBundle::load_bind_anim()
 CBinToCA utility program to read a (binary) file and output a table that can be compiled via a C compiler to generate the same data
 CBitArrayA dynamic array with an unlimited number of bits
 CBitMaskA general bitmask class
 CBoundingBoxAn axis-aligned bounding box; that is, a minimum and maximum coordinate triple
 CBoundingHexahedronThis defines a bounding convex hexahedron
 CBoundingLineThis funny bounding volume is an infinite line with no thickness and extending to infinity in both directions
 CBoundingPlaneThis 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
 CBoundingSphereThis defines a bounding sphere, consisting of a center and a radius
 CBoundingVolumeThis 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
 CBoxEmitterDescribes a voluminous box region in which particles are generated
 CBuffer
 CBufferContextThis 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
 CBufferContextChainThis class maintains a linked list of BufferContexts that might be allocated on the graphics card in some context
 CBuffered_DatagramConnection
 CBuffered_DatagramReader
 CBuffered_DatagramWriterThis is the buffered writer
 CBufferResidencyTrackerThis 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
 CBulletAllHitsRayResult
 CBulletBaseCharacterControllerNode
 CBulletBodyNode
 CBulletBoxShape
 CBulletCapsuleShape
 CBulletCharacterControllerNode
 CBulletClosestHitRayResult
 CBulletClosestHitSweepResult
 CBulletConeShape
 CBulletConeTwistConstraint
 CBulletConstraint
 CBulletContact
 CBulletContactCallbackData
 CBulletContactResult
 CBulletConvexHullShape
 CBulletConvexPointCloudShape
 CBulletCylinderShape
 CBulletDebugNode
 CBulletFilterCallbackData
 CBulletGenericConstraint
 CBulletGhostNode
 CBulletHeightfieldShape
 CBulletHelper
 CBulletHingeConstraintThe hinge constraint lets two bodies rotate around a given axis while adhering to specified limits
 CBulletManifoldPoint
 CBulletMinkowskiSumShape
 CBulletMultiSphereShape
 CBulletPersistentManifold
 CBulletPlaneShape
 CBulletRayHit
 CBulletRigidBodyNode
 CBulletRotationalLimitMotorRotation Limit structure for generic joints
 CBulletShape
 CBulletSliderConstraint
 CBulletSoftBodyConfig
 CBulletSoftBodyControl
 CBulletSoftBodyMaterial
 CBulletSoftBodyNode
 CBulletSoftBodyNodeElement
 CBulletSoftBodyShape
 CBulletSoftBodyWorldInfo
 CBulletSphereShape
 CBulletSphericalConstraintA constraint between two rigid bodies, each with a pivot point
 CBulletTickCallbackData
 CBulletTranslationalLimitMotorRotation Limit structure for generic joints
 CBulletTriangleMesh
 CBulletTriangleMeshShape
 CBulletVehicleSimulates a raycast vehicle which casts a ray per wheel at the ground as a cheap replacement for complex suspension simulation
 CBulletVehicleTuning
 CBulletWheelOne wheel of a BulletVehicle
 CBulletWheelRaycastInfo
 CBulletWorld
 CButtonEventRecords a button event of some kind
 CButtonEventListRecords a set of button events that happened recently
 CButtonHandleA ButtonHandle represents a single button from any device, including keyboard buttons and mouse buttons (but see KeyboardButton and MouseButton)
 CButtonMapThis 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
 CButtonNodeThis is the primary interface to on/off button devices associated with a ClientBase
 CButtonRegistryMaintains all the assigned ButtonHandles in a given system
 CButtonThrowerThrows Panda Events for button down/up events generated within the data graph
 CCachedTypedWritableReferenceCountThis 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
 CCacheStatsThis is used to track the utilization of the TransformState and RenderState caches, for low-level performance tuning information
 CCallbackDataThis is a generic data block that is passed along to a CallbackObject when a callback is made
 CCallbackGraphicsWindowThis 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
 CCallbackNodeA special node that can issue arbitrary callbacks to user code, either during the cull or draw traversals
 CCallbackObjectThis is a generic object that can be assigned to a callback at various points in the rendering process
 CCameraA node that can be positioned around in the scene graph to represent a point of view for rendering a scene
 CCardMakerThis class generates 2-d "cards", that is, rectangular polygons, particularly useful for showing textures etc
 CCConnectionRepositoryThis class implements the C++ side of the ConnectionRepository object
 CCConstrainHprIntervalA constraint interval that will constrain the orientation of one node to the orientation of another
 CCConstrainPosHprIntervalA constraint interval that will constrain the position and orientation of one node to the position and orientation of another
 CCConstrainPosIntervalA constraint interval that will constrain the position of one node to the position of another
 CCConstraintIntervalThe base class for a family of intervals that constrain some property to a value over time
 CCConstrainTransformIntervalA constraint interval that will constrain the transform of one node to the transform of another
 CCDistributedSmoothNodeBaseThis class defines some basic methods of DistributedSmoothNodeBase which have been moved into C++ as a performance optimization
 Cchar_cmp
 CCharacterAn animated character, with skeleton-morph animation and either soft- skinned or hard-skinned vertices
 CCharacterJointThis represents one joint of the character's animation, containing an animating transform matrix
 CCharacterJointBundleThe collection of all the joints and sliders in the character
 CCharacterJointEffectThis effect will be added automatically to a node by CharacterJoint::add_net_transform() and CharacterJoint::add_local_transform()
 CCharacterMakerConverts an EggGroup hierarchy, beginning with a group with <Dart> set, to a character node with joints
 CCharacterSliderThis is a morph slider within the character
 CCharacterVertexSliderThis is a specialization on VertexSlider that returns the slider value associated with a particular CharacterSlider object
 CChecksumHashGeneratorThis is a specific kind of HashGenerator that simply adds up all of the ints
 CCIntervalThe base class for timeline components
 CCIntervalManagerThis object holds a number of currently-playing intervals and is responsible for advancing them each frame as needed
 CCircBufferThis class implements a queue of some type via a circular buffer
 CCLerpAnimEffectIntervalThis interval lerps between different amounts of control effects for various AnimControls that might be playing on an actor
 CCLerpIntervalThe base class for a family of intervals that linearly interpolate one or more numeric values over time
 CCLerpNodePathIntervalAn interval that lerps one or more properties (like pos, hpr, etc.) on a NodePath over time
 CClientAnalogDeviceA device, attached to the ClientBase by a AnalogNode, that records the data from a single named analog device
 CClientBaseAn abstract base class for a family of client device interfaces–including trackers, buttons, dials, and other analog inputs
 CClientButtonDeviceA device, attached to the ClientBase by a ButtonNode, that records the data from a single named button device
 CClientDeviceAny of a number of different devices that might be attached to a ClientBase, including trackers, etc
 CClientDialDeviceA device, attached to the ClientBase by a DialNode, that records the data from a single named dial device
 CClientTrackerDeviceA device, attached to the ClientBase by a TrackerNode, that records the data from a single tracker device
 CClipPlaneAttribThis functions similarly to a LightAttrib
 CClockObjectA ClockObject keeps track of elapsed real time and discrete time
 CCLwoClipThis class is a wrapper around LwoClip and stores additional information useful during the conversion-to-egg process
 CCLwoLayerThis class is a wrapper around LwoLayer and stores additional information useful during the conversion-to-egg process
 CCLwoPointsThis class is a wrapper around LwoPoints and stores additional information useful during the conversion-to-egg process
 CCLwoPolygonsThis class is a wrapper around LwoPolygons and stores additional information useful during the conversion-to-egg process
 CCLwoSurfaceThis class is a wrapper around LwoSurface and stores additional information useful during the conversion-to-egg process
 CCLwoSurfaceBlockThis class is a wrapper around LwoSurfaceBlock and stores additional information useful during the conversion-to-egg process
 CCLwoSurfaceBlockTMapThis class is a wrapper around LwoSurfaceBlockTMap and stores additional information useful during the conversion-to-egg process
 CCMetaIntervalThis interval contains a list of nested intervals, each of which has its own begin and end times
 CCMotionTrailThe method used in creating the motion trail is based on taking samples of time and transformations (the position and orientation matrix) in real- time
 CCMotionTrailFrame
 CCMotionTrailVertex
 CCocoaGraphicsBufferThis is a light wrapper around GLGraphicsBuffer (ie
 CCocoaGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on a Cocoa-based (e.g
 CCocoaGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some Cocoa-specific information
 CCocoaGraphicsWindowAn interface to the Cocoa system for managing OpenGL windows under Mac OS X
 CCocoaPandaApp
 CCocoaPandaAppDelegate
 CCocoaPandaView
 CCocoaPandaWindow
 CCocoaPandaWindowDelegate
 CCollisionBoxA cuboid collision volume or object
 CCollisionCapsuleThis implements a solid consisting of a cylinder with hemispherical endcaps, also known as a capsule or a spherocylinder
 CCollisionEntryDefines a single collision event
 CCollisionFloorMeshThis object represents a solid made entirely of triangles, which will only be tested again z axis aligned rays
 CCollisionGeomA special CollisionPolygon created just for the purpose of detecting collision against geometry
 CCollisionHandlerThe abstract interface to a number of classes that decide what to do when a collision is detected
 CCollisionHandlerEventA specialized kind of CollisionHandler that throws an event for each collision detected
 CCollisionHandlerFloorA 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
 CCollisionHandlerFluidPusherA CollisionHandlerPusher that makes use of timing and spatial information from fluid collisions to improve collision response
 CCollisionHandlerGravityA 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
 CCollisionHandlerHighestEventA specialized kind of CollisionHandler that throws an event for each collision detected
 CCollisionHandlerPhysicalThe 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
 CCollisionHandlerPusherA specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
 CCollisionHandlerQueueA special kind of CollisionHandler that does nothing except remember the CollisionEntries detected the last pass
 CCollisionInvSphereAn inverted sphere: this is a sphere whose collision surface is the inside surface of the sphere
 CCollisionLevelStateThis is the state information the CollisionTraverser retains for each level during traversal
 CCollisionLevelStateBaseThis is the state information the CollisionTraverser retains for each level during traversal
 CCollisionLineAn infinite line, similar to a CollisionRay, except that it extends in both directions
 CCollisionNodeA node in the scene graph that can hold any number of CollisionSolids
 CCollisionParabolaThis defines a parabolic arc, or subset of an arc, similar to the path of a projectile or falling object
 CCollisionPlane
 CCollisionPolygon
 CCollisionRayAn infinite ray, with a specific origin and direction
 CCollisionSegmentA finite line segment, with two specific endpoints but no thickness
 CCollisionSolidThe 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)
 CCollisionSphereA spherical collision volume or object
 CCollisionTraverserThis class manages the traversal through the scene graph to detect collisions
 CColorAttribIndicates what color should be applied to renderable geometry
 CColorBlendAttribThis specifies how colors are blended into the frame buffer, for special effects
 Ccolorhist_item
 Ccolorhist_list_item
 CColorInterpolationFunctionAbstract class from which all other functions should inherit
 CColorInterpolationFunctionConstantDefines a constant color over the lifetime of the segment
 CColorInterpolationFunctionLinearDefines a linear interpolation over the lifetime of the segment
 CColorInterpolationFunctionSinusoidDefines a sinusoidal blending between two colors
 CColorInterpolationFunctionStepwaveDefines a discrete cyclical transition between two colors
 CColorInterpolationManagerHigh level class for color interpolation
 CColorInterpolationSegmentA single unit of interpolation
 CColorScaleAttribApplies a scale to colors in the scene graph and on vertices
 CColorWriteAttribEnables or disables writing to the color buffer
 Ccompare_toAn STL function object class, this is intended to be used on any ordered collection of class objects that contain a compare_to() method
 CCompareToAn STL function object class, this is intended to be used on any ordered collection of classes that contain a compare_to() method
 CCompassEffectA 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
 CComputeNodeA special node, the sole purpose of which is to invoke a dispatch operation on the assigned compute shader
 CConditionVarA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
 CConditionVarDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
 CConditionVarDummyImplA fake condition variable implementation for single-threaded applications that don't need any synchronization control
 CConditionVarFullThis class implements a condition variable; see ConditionVar for a brief introduction to this class
 CConditionVarFullDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
 CConfigDeclarationA single declaration of a config variable, typically defined as one line in a .prc file, e.g
 CConfigFlagsThis class is the base class of both ConfigVariable and ConfigVariableCore
 CConfigPageA page of ConfigDeclarations that may be loaded or unloaded
 CConfigPageManagerA global object that maintains the set of ConfigPages everywhere in the world, and keeps them in sorted order
 CConfigurableAn object that has data or parameters that are set less frequently (at least occasionally) than every frame
 CConfigVariableThis is a generic, untyped ConfigVariable
 CConfigVariableBaseThis class is the base class for both ConfigVariableList and ConfigVariable (and hence for all of the ConfigVariableBool, ConfigVaribleString, etc
 CConfigVariableBoolThis is a convenience class to specialize ConfigVariable as a boolean type
 CConfigVariableColorThis is a convenience class to specialize ConfigVariable as a set of floating-point types representing a color value
 CConfigVariableCoreThe internal definition of a ConfigVariable
 CConfigVariableDoubleThis is a convenience class to specialize ConfigVariable as a floating- point type
 CConfigVariableEnumThis class specializes ConfigVariable as an enumerated type
 CConfigVariableFilenameThis is a convenience class to specialize ConfigVariable as a Filename type
 CConfigVariableIntThis is a convenience class to specialize ConfigVariable as an integer type
 CConfigVariableInt64This is a convenience class to specialize ConfigVariable as a 64-bit integer type
 CConfigVariableListThis class is similar to ConfigVariable, but it reports its value as a list of strings
 CConfigVariableManagerA global object that maintains the set of ConfigVariables (actually, ConfigVariableCores) everywhere in the world, and keeps them in sorted order
 CConfigVariableSearchPathThis is similar to a ConfigVariableList, but it returns its list as a DSearchPath, as a list of directories
 CConfigVariableStringThis is a convenience class to specialize ConfigVariable as a string type
 CConnectionRepresents a single TCP or UDP socket for input or output
 CConnectionListenerThis 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)
 CConnectionListenerData
 CConnectionManagerThe primary interface to the low-level networking layer in this package
 CConnectionReaderThis 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)
 CConnectionWriterThis class handles threaded delivery of datagrams to various TCP or UDP sockets
 CConstPointerToA ConstPointerTo is similar to a PointerTo, except it keeps a const pointer to the thing
 CConstPointerToArraySimilar to PointerToArray, except that its contents may not be modified
 CControllerDemoViewController
 CCopyOnWriteObjThis is similar to RefCountObj, but it implements a CopyOnWriteObject inheritance instead of a ReferenceCount inheritance
 CCopyOnWriteObj1For objects (e.g
 CCopyOnWriteObjectThis base class provides basic reference counting, but also can be used with a CopyOnWritePointer to provide get_read_pointer() and get_write_pointer()
 CCopyOnWritePointerThis safely stores the primary, owned pointer to a CopyOnWriteObject
 CCopyOnWritePointerToA template wrapper around the above class, mainly to handle the little typecasting niceties
 CCPointerCallbackObjectThis is a specialization on CallbackObject to allow association with a C-style function pointer and a void * parameter
 CCPT_InternalNameThis is a const pointer to an InternalName, and should be used in lieu of a CPT(InternalName) in function arguments
 CCubicCurvesegA 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
 CCullableObjectThe smallest atom of cull
 CCullBinA collection of Geoms and their associated state, for a particular scene
 CCullBinAttribAssigns geometry to a particular bin by name
 CCullBinBackToFrontA specific kind of CullBin that sorts geometry in order from furthest to nearest based on the center of its bounding volume
 CCullBinEnumsProvides scoping for the enumerated type shared by CullBin and CullBinManager
 CCullBinFixedA specific kind of CullBin that sorts geometry in the order specified by the user-specified draw_order parameter
 CCullBinFrontToBackA specific kind of CullBin that sorts geometry in order from nearest to furthest based on the center of its bounding volume
 CCullBinManagerThis is a global object that maintains the collection of named CullBins in the world
 CCullBinStateSortedA 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
 CCullBinUnsortedA 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
 CCullFaceAttribIndicates which faces should be culled based on their vertex ordering
 CCullHandlerThis defines the abstract interface for an object that receives Geoms identified by the CullTraverser
 CCullPlanesThis 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
 CCullResultThis 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
 CCullTraverserThis object performs a depth-first traversal of the scene graph, with optional view-frustum culling, collecting CullState and searching for GeomNodes
 CCullTraverserDataThis collects together the pieces of data that are accumulated for each node while walking the scene graph during the cull traversal
 CCurveFitter
 CCVSCopyThis 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
 CCVSSourceDirectoryThis represents one particular directory in the hierarchy of source directory files
 CCVSSourceTreeThis represents the root of the tree of source directory files
 CCycleDataA single page of data maintained by a PipelineCycler
 CCycleDataLockedReaderThis template class calls PipelineCycler::read() in the constructor and PipelineCycler::release_read() in the destructor
 CCycleDataLockedStageReaderThis class is similar to CycleDataLockedReader, except it allows reading from a particular stage of the pipeline
 CCycleDataReaderThis template class calls PipelineCycler::read_unlocked(), and then provides a transparent read-only access to the CycleData
 CCycleDataStageReaderThis class is similar to CycleDataReader, except it allows reading from a particular stage of the pipeline
 CCycleDataStageWriterThis class is similar to CycleDataWriter, except it allows writing to a particular stage of the pipeline
 CCycleDataWriterThis template class calls PipelineCycler::write() in the constructor and PipelineCycler::release_write() in the destructor
 CCyclerHolderA lightweight C++ object whose constructor calls acquire() and whose destructor calls release() on a PipelineCyclerBase object
 CCylindricalLensA cylindrical lens
 CDaeCharacterClass representing an animated character
 CDaeMaterialsThis class is seperated from the converter file because otherwise it would get too big and needlessly complicated
 CDAEToEggA program to read a DAE file and generate an egg file
 CDAEToEggConverterThis class supervises the construction of an EggData structure from a DAE file
 CDatagramAn ordered list of data elements, formatted in memory for transmission over a socket or writing to a data file
 CDatagramBufferThis class can be used to write a series of datagrams into a memory buffer
 CDatagramGeneratorThis class defines the abstract interace to any source of datagrams, whether it be from a file or from the net
 CDatagramGeneratorNetThis class provides datagrams one-at-a-time as read directly from the net, via a TCP connection
 CDatagramInputFileThis class can be used to read a binary file that consists of an arbitrary header followed by a number of datagrams
 CDatagramIteratorA class to retrieve the individual data elements previously stored in a Datagram
 CDatagramOutputFileThis class can be used to write a binary file that consists of an arbitrary header followed by a number of datagrams
 CDatagramQueueA thread-safe, FIFO queue of NetDatagrams
 CDatagramSinkThis class defines the abstract interface to sending datagrams to any target, whether it be into a file or across the net
 CDatagramSinkNetThis class accepts datagrams one-at-a-time and sends them over the net, via a TCP connection
 CDatagramTCPHeaderA class that encapsulates the extra bytes that are sent in front of each datagram to identify it when it is sent on TCP
 CDatagramUDPHeaderA class that encapsulates the extra bytes that are sent in front of each datagram to identify it when it is sent on UDP
 CDataGraphTraverserThis object supervises the traversal of the data graph and the moving of data from one DataNode to its children
 CDataNodeThe fundamental type of node for the data graph
 CDataNodeTransmitEncapsulates the data generated from (or sent into) any particular DataNode
 CDCArrayParameterThis 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
 CDCAtomicFieldA single atomic field of a Distributed Class, as read from a .dc file
 CDCClassDefines a particular DistributedClass as read from an input .dc file
 CDCClassParameterThis represents a class (or struct) object used as a parameter itself
 CDCDeclarationThis is a common interface for a declaration in a DC file
 CDCFieldA single field of a Distributed Class, either atomic or molecular
 CDCFileRepresents the complete list of Distributed Class descriptions as read from a .dc file
 CDCKeywordThis represents a single keyword declaration in the dc file
 CDCKeywordListThis is a list of keywords (see DCKeyword) that may be set on a particular field
 CDCMolecularFieldA single molecular field of a Distributed Class, as read from a .dc file
 CDCNumericRangeRepresents a range of legal integer or floating-point values
 CDCPackDataThis is a block of data that receives the results of DCPacker
 CDCPackerThis class can be used for packing a series of numeric and string data into a binary stream, according to the DC specification
 CDCPackerCatalogThis object contains the names of all of the nested fields available within a particular field
 CDCPackerInterfaceThis defines the internal interface for packing values into a DCField
 CDCParameterRepresents the type specification for a single parameter within a field specification
 CDCSimpleParameterThis is the most fundamental kind of parameter type: a single number or string, one of the DCSubatomicType elements
 CDCSwitchThis 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
 CDCSwitchParameterThis represents a switch object used as a parameter itself, which packs the appropriate fields of the switch into the message
 CDCTokenType
 CDCTypedefThis represents a single typedef declaration in the dc file
 CDecalEffectApplied to a GeomNode to indicate that the children of this GeomNode are coplanar and should be drawn as decals (eliminating Z-fighting)
 CDeclaration
 CDeferredNodePropertyThis class keeps track of all the state we must make note of during the graph traversal, but cannot apply immediately
 CDeletedBufferChainThis template class can be used to provide faster allocation/deallocation for many Panda objects
 CDeletedChainThis template class can be used to provide faster allocation/deallocation for many Panda objects
 CDepthOffsetAttribThis 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
 CDepthTestAttribEnables or disables writing to the depth buffer
 CDepthWriteAttribEnables or disables writing to the depth buffer
 CDestTextureImageThis represents a texture filename as it has been resized and copied to the map directory (e.g
 CDialNodeThis is the primary interface to infinite dial type devices associated with a ClientBase
 CDirectDDirectD is a client/server app for starting panda/direct
 CDirectDClientDirectDClient is a test app for DirectDServer
 CDirectDServerStart a directdServer on each of the machines you which to start panda on
 CDirectionalLightA light shining from infinitely far away in a particular direction, like sunlight
 CDiscEmitterDescribes a planar disc region from which particles are generated
 CDisplayInformationThis class contains various display information
 CDisplayMode
 CDisplayRegionA rectangular subregion within a window for rendering into
 CDisplayRegionCullCallbackDataThis specialization on CallbackData is passed when the callback is initiated from the cull traversal, for a DisplayRegion
 CDisplayRegionDrawCallbackDataThis specialization on CallbackData is passed when the callback is initiated from the draw traversal, for a DisplayRegion
 CDisplayRegionPipelineReaderEncapsulates the data from a DisplayRegion, pre-fetched for one stage of the pipeline
 CDisplaySearchParametersParameters used for searching display capabilities
 CDocumentSpecA descriptor that refers to a particular version of a document
 CDoubleBitMaskThis is a special BitMask type that is implemented as a pair of lesser BitMask types, to present a double-wide bit mask
 CDownloadDbA listing of files within multifiles for management of client-side synchronization with a server-provided set of files
 CDrawableRegionThis is a base class for GraphicsWindow (actually, GraphicsOutput) and DisplayRegion, both of which are conceptually rectangular regions into which drawing commands may be issued
 CDrawCullHandlerThis special kind of CullHandler immediately draws its contents as soon as it receives them
 CDriveInterfaceThis is a TFormer, similar to Trackball, that moves around a transform matrix in response to mouse input
 CDSearchPathThis class stores a list of directories that can be searched, in order, to locate a particular file
 CDXFFileA generic DXF-reading class
 CDXFLayerThis represents a "layer" as read from the DXF file
 CDXFLayerMapA map of string (layer name) to DXFLayer: that is, the layers of a file ordered by name
 CDXFPointsA simple program to read a dxf file and list the points contained within it to a text file
 CDXFToEggA program to read a DXF file and generate an egg file
 CDXFToEggConverterThis class supervises the construction of an EggData structure from a DXF file
 CDXFToEggLayerThe specialization of DXFLayer used by DXFToEggConverter
 CDXFVertexStored within DXFFile, this is the basic Vertex data of a DXF file
 CDXGeomMunger9This specialization on GeomMunger finesses vertices for DirectX rendering
 CDXGraphicsDevice9A GraphicsDevice necessary for multi-window rendering in DX
 CDXGraphicsStateGuardian9A GraphicsStateGuardian for rendering into DirectX9 contexts
 CDXIndexBufferContext9Caches a GeomPrimitive in the DirectX device as an index buffer
 CDXOcclusionQueryContext9
 CDXScreenData
 CDXShaderContext9Xyz
 CDXTextureContext9
 CDXVertexBufferContext9Caches a GeomVertexArrayData in the DirectX device as a vertex buffer
 CEAGLView
 CEaseInBlendType
 CEaseInOutBlendType
 CEaseOutBlendType
 CEggAnimDataA base class for EggSAnimData and EggXfmAnimData, which contain rows and columns of numbers
 CEggAnimPreloadThis corresponds to an <AnimPreload> entry
 CEggAttributesThe set of attributes that may be applied to vertices as well as polygons, such as surface normal and color
 CEggBackPointerThis stores a pointer from an EggJointData or EggSliderData object back to the referencing data in an egg file
 CEggBaseThis is a base class for both EggSingleBase and EggMultiBase
 CEggBinA type of group node that holds related subnodes
 CEggBinMakerThis is a handy class for collecting related nodes together
 CEggBinMakerCompareNodesThis is just an STL function object, used to sort nodes within EggBinMaker
 CEggBinnerA special binner used only within this package to pre-process the egg tree for the loader and group things together as appropriate
 CEggCharacterCollectionRepresents a set of characters, as read and collected from possibly several model and/or animation egg files
 CEggCharacterDataRepresents a single character, as read and collected from several models and animation files
 CEggCharacterDbThis class is used during joint optimization or restructuring to store the table of interim joint computations
 CEggCharacterFilterThis is the base class for a family of programs that operate on a number of character models and their associated animation files together
 CEggCommentA comment that appears in an egg file within a <Comment> entry
 CEggComponentDataThis is the base class of both EggJointData and EggSliderData
 CEggCompositePrimitiveThe 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
 CEggConverterThis is a general base class for programs that convert between egg files and some other format
 CEggCoordinateSystemThe <CoordinateSystem> entry at the top of an egg file
 CEggCropA program to read an egg file and write an equivalent egg file, possibly performing some minor operations along the way
 CEggCurveA parametric curve of some kind
 CEggDataThis is the primary interface into all the egg data, and the root of the egg file structure
 CEggExternalReferenceDefines a reference to another egg file which should be inserted at this point
 CEggFileThis represents a single egg file known to the palettizer
 CEggFilenameNodeThis is an egg node that contains a filename
 CEggFilterThis is the base class for a program that reads an egg file, operates on it, and writes another egg file out
 CEggGroupThe main glue of the egg hierarchy, this corresponds to the <Group>, <Instance>, and <Joint> type nodes
 CEggGroupNodeA base class for nodes in the hierarchy that are not leaf nodes
 CEggGroupUniquifierThis is a specialization of EggNameUniquifier to generate unique names for EggGroup nodes
 CEggJointDataThis 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
 CEggJointNodePointerThis stores a pointer back to a <Joint> node
 CEggJointPointerThis is a base class for EggJointNodePointer and EggMatrixTablePointer
 CEggLineA line segment, or a series of connected line segments, defined by a <Line> entry
 CEggListTexturesReads an egg file and outputs the list of textures it uses
 CEggLoaderConverts an egg data structure, possibly read from an egg file but not necessarily, into a scene graph suitable for rendering
 CEggMakeFontThis program uses FreeType to generate an egg file and a series of texture images from a font file input, such as a TTF file
 CEggMakeSomethingA base class for a family of programs that generate egg models of various fundamental shapes
 CEggMakeTubeA program to generate an egg file representing a tube model, similar in shape to a CollisionCapsule
 CEggMaterial
 CEggMaterialCollectionThis is a collection of materials by MRef name
 CEggMatrixTablePointerThis stores a pointer back to an EggXfmSAnim table (i.e
 CEggMesherCollects together unrelated EggPrimitives, determines their edge connectivity, and generates a set of EggTriangleStrips that represent the same geometry
 CEggMesherEdgeRepresents one edge of a triangle, as used by the EggMesher to discover connected triangles
 CEggMesherFanMakerThis class is used by EggMesher::find_fans() to attempt to make an EggTriangleFan out of the polygons connected to the indicated vertex
 CEggMesherStripRepresents a triangle strip or quad strip in progress, as assembled by the mesher
 CEggMorphA single <Dxyz> or <Duv> or some such entry
 CEggMorphListA collection of <Dxyz>'s or <Duv>'s or some such
 CEggMultiBaseThis specialization of ProgramBase is intended for programs that read and/or write multiple egg files
 CEggMultiFilterThis 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)
 CEggNamedObjectThis is a fairly low-level base class–any egg object that has a name
 CEggNameUniquifierThis is a handy class for guaranteeing unique node names in an egg hierarchy
 CEggNodeA base class for things that may be directly added into the egg hierarchy
 CEggNurbsCurveA parametric NURBS curve
 CEggNurbsSurfaceA parametric NURBS surface
 CEggObjectThe highest-level base class in the egg directory
 CEggOptcharPerforms basic optimizations of a character model and its associated animations, by analyzing the animation tables and removing unneeded joints and/or morphs
 CEggOptcharUserDataThis class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the maya converter
 CEggPalettizeThis is the program wrapper for egg-palettize, but it mainly serves to read in all the command-line parameters and then invoke the Palettizer
 CEggParametersThe values stored in this structure are global parameters that control some aspects of the egg library
 CEggPatchA single "patch", a special primitive to be rendered only with a tessellation shader
 CEggPointA single point, or a collection of points as defined by a single <PointLight> entry
 CEggPolygonA single polygon
 CEggPolysetMakerA specialization on EggBinMaker for making polysets that share the same basic rendering characteristic
 CEggPoolUniquifierThis is a specialization of EggNameUniquifier to generate unique names for textures, materials, and vertex pools prior to writing out an egg file
 CEggPrimitiveA base class for any of a number of kinds of geometry primitives: polygons, point lights, nurbs patches, parametrics curves, etc
 CEggQtessA program to tesselate NURBS surfaces appearing within an egg file into polygons, using variations on a quick uniform tesselation
 CEggReaderThis is the base class for a program that reads egg files, but doesn't write an egg file
 CEggRenameA program to read an egg file and write an equivalent egg file, with stripping prefix for now, but more along the way
 CEggRenderModeThis 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
 CEggRenderStateThis class is used within this package only to record the render state that should be assigned to each primitive
 CEggRetargetAnimRetargets 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
 CEggSAnimDataCorresponding to an <S$Anim> entry, this stores a single column of numbers, for instance for a morph target, or as one column in an EggXfmSAnim
 CEggSaverConverts the scene graph beginning at the indicated node into an EggData structure, for writing to an egg file
 CEggScalarTablePointerThis stores a pointer back to an EggSAnimData table (i.e
 CEggSingleBaseThis specialization of EggBase is intended for programs that read and/or write a single egg file
 CEggSliderDataThis corresponds to a single morph slider control
 CEggSliderPointerThis is a base class for EggVertexPointer and EggScalarTablePointer
 CEggSurfaceA parametric surface of some kind
 CEggSwitchConditionThis corresponds to a <SwitchCondition> entry within a group
 CEggSwitchConditionDistanceA SwitchCondition that switches the levels-of-detail based on distance from the camera's eyepoint
 CEggTableThis corresponds to a
 CEggTextureDefines a texture map that may be applied to geometry
 CEggTextureCardsGenerates an egg file featuring a number of polygons, one for each named texture
 CEggTextureCollectionThis is a collection of textures by TRef name
 CEggToBam
 CEggToC
 CEggToDAEA program to read an egg file and write a DAE file
 CEggToDXFA program to read an egg file and write a DXF file
 CEggToDXFLayerA single layer in the DXF file to be written by EggToDXF
 CEggToFltA program to read an egg file and write a flt file
 CEggTokenType
 CEggToMayaA program to read an egg file and write a maya file
 CEggToObj
 CEggToObjConverterConvert an obj file to egg data
 CEggTopstripReads a character model and/or animations and strips out the animation from one of the top joints from the entire character
 CEggToSomethingThis is the general base class for a file-converter program that reads some model file format and generates an egg file
 CEggToSomethingConverterThis is a base class for a family of converter classes that manage a conversion from egg format to some other file type
 CEggToXA program to read in a egg file and write an equivalent, or nearly equivalent, DirectX-style "x" file
 CEggTransA program to read an egg file and write an equivalent egg file, possibly performing some minor operations along the way
 CEggTransformThis 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
 CEggTriangleFanA connected fan of triangles
 CEggTriangleStripA connected strip of triangles
 CEggUserDataThis is a base class for a user-defined data type to extend egg structures in processing code
 CEggVertexAny one-, two-, three-, or four-component vertex, possibly with attributes such as a normal
 CEggVertexAuxThe set of named auxiliary data that may or may not be assigned to a vertex
 CEggVertexPointerThis stores a pointer back to a <Vertex>, or to a particular pritimive like a <Polygon>, representing a morph offset
 CEggVertexPoolA collection of vertices
 CEggVertexUVThe set of UV's that may or may not be assigned to a vertex
 CEggWriterThis is the base class for a program that generates an egg file output, but doesn't read any for input
 CEggXfmAnimDataCorresponding to an <Xfm$Anim> entry, this stores a two-dimensional table with up to nine columns, one for each component of a transformation
 CEggXfmSAnimThis corresponds to an <Xfm$Anim_S$> entry, which is a collection of up to nine <S$Anim> entries that specify the nine components of a transformation
 CeglGraphicsBufferAn offscreen buffer in the EGL environment
 CeglGraphicsPipeThis graphics pipe represents the interface for creating OpenGL ES graphics windows on an X-based (e.g
 CeglGraphicsPixmapAnother offscreen buffer in the EGL environment
 CeglGraphicsStateGuardianA tiny specialization on GLESGraphicsStateGuardian to add some egl-specific information
 CeglGraphicsWindowAn interface to the egl system for managing GLES windows under X
 CEvade
 CEventA named event, possibly with parameters
 CEventHandlerA class to monitor events from the C++ side of things
 CEventParameterAn optional parameter associated with an event
 CEventQueueA queue of pending events
 CEventReceiverAn abstract base class for anything that might care about receiving events
 CExecutionEnvironmentEncapsulates access to the environment variables and command-line arguments at the time of execution
 CExtensionThe default class template does not define any methods
 CExtensionBaseThis is where all extensions should derive from
 CExternalThreadThe special "external thread" class
 CExtractorThis class automatically extracts the contents of a Multifile to the current directory (or to a specified directory) in the background
 CFactoryA Factory can be used to create an instance of a particular subclass of some general base class
 CFactoryBaseA Factory can be used to create an instance of a particular subclass of some general base class
 CFactoryParamThe 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
 CFactoryParamsAn instance of this class is passed to the Factory when requesting it to do its business and construct a new something
 CFadeLODNodeA Level-of-Detail node with alpha based switching
 CFadeLODNodeDataThis is the data that is associated with a particular instance of the FadeLODNode for the scene graph
 CFfmpegAudioA stream that generates a sequence of audio samples
 CFfmpegAudioCursorA stream that generates a sequence of audio samples
 CFfmpegVideo
 CFfmpegVideoCursor
 CFfmpegVirtualFileEnables ffmpeg to access panda's VFS
 CFFTCompressorThis 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)
 CFilenameThe name of a file, such as a texture file or an Egg file
 CFilenameUnifierThis static class does the job of converting filenames from relative to absolute to canonical or whatever is appropriate
 CFileReferenceKeeps a reference-counted pointer to a file on disk
 CFilterPropertiesStores a configuration for a set of audio DSP filters
 CFindApproxLevelEntryThis class is local to this package only; it doesn't get exported
 CFindApproxPathThis class is local to this package only; it doesn't get exported
 CFiniteBoundingVolumeA special kind of GeometricBoundingVolume that is known to be finite
 Cfirst_of_pair_iteratorThis is an iterator adaptor that converts any iterator that returns a pair (e.g
 CFirstOfPairCompareAn STL function object class, this is intended to be used on any ordered collection of pairs of objects
 CFirstOfPairLessAn STL function object class, this is intended to be used on any ordered collection of pairs of objects
 CFisheyeLensA fisheye lens
 CFisheyeMakerThis 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
 CFlacAudioReads FLAC audio files
 CFlacAudioCursorImplements decoding of FLAC audio files
 CFlee
 Cfloating_point_hashThis hash_compare class hashes a float or a double
 Cfloating_point_thresholdCompares two floating point numbers, within threshold of equivalence
 CFlockThis class is used to define the flock attributes and the AI characters which are part of the flock
 CFltBeadA base class for any of a broad family of flt records that represent particular beads in the hierarchy
 CFltBeadIDA base class for any of a broad family of flt beads that include an ID
 CFltCopyA program to copy Multigen .flt files into the cvs tree
 CFltCurveA single curve, like a Bezier or B-Spline
 CFltExternalReferenceAn external reference to another flt file (possibly to a specific bead within the flt file)
 CFltEyepointA single eyepoint entry in the eyepoint/trackplane palette
 CFltFaceA single face bead, e.g
 CFltGeometryThis 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
 CFltGroupThe main grouping bead of the flt file
 CFltHeaderThis is the first bead in the file, the top of the bead hierarchy, and the primary interface to reading and writing a Flt file
 CFltInfoA program to read a flt file and report interesting things about it
 CFltInstanceDefinitionThis special kind of record marks the top node of an instance subtree
 CFltInstanceRefThis bead appears in the hierarchy to refer to a FltInstanceDefinition node defined elsewhere
 CFltLightSourceDefinitionRepresents a single entry in the light source palette
 CFltLocalVertexPoolA local vertex pool, as might appear in the middle of the hierarchy, for instance for a mesh
 CFltLODA Level-of-Detail record
 CFltMaterialRepresents a single material in the material palette
 CFltMeshA mesh of connected polygons and tristrips, etc., with a local vertex pool
 CFltMeshPrimitiveA single primitive of a mesh, like a triangle strip or fan
 CFltObjectThe main objecting bead of the flt file
 CFltPackedColorA packed color record, A, B, G, R
 CFltRecordThe base class for all kinds of records in a MultiGen OpenFlight file
 CFltRecordReaderThis class turns an istream into a sequence of FltRecords by reading a sequence of Datagrams and extracting the opcode from each one
 CFltRecordWriterThis class writes a sequence of FltRecords to an ostream, handling opcode and size counts properly
 CFltTextureRepresents a single texture in the texture palette
 CFltToEggA program to read a flt file and generate an egg file
 CFltToEggConverterThis class supervises the construction of an EggData structure from the data represented by the FltHeader
 CFltToEggLevelStateThis keeps track of relevant things about the traversal as we walk through the flt hierarchy
 CFltTrackplaneA single trackplane entry in the eyepoint/trackplane palette
 CFltTransA program to read a flt file and write an equivalent flt file, possibly performing some minor operations along the way
 CFltTransformGeneralMatrixA general 4x4 matrix
 CFltTransformPutA "put", which is a MultiGen concept of defining a transformation by mapping three arbitrary points to three new arbitrary points
 CFltTransformRecordA base class for a number of types of ancillary records that follow beads and indicate some kind of a transformation
 CFltTransformRotateAboutEdgeA transformation that rotates about a particular axis in space, defined by two endpoints
 CFltTransformRotateAboutPointA transformation that rotates about a particular axis in space, defined by a point and vector
 CFltTransformRotateScaleA combination rotation and scale
 CFltTransformScaleA transformation that applies a (possibly nonuniform) scale
 CFltTransformTranslateA transformation that applies a translation
 CFltUnsupportedRecord
 CFltVectorRecordThis is an ancillary record of the old (pre-15.4) face node
 CFltVertexRepresents a single vertex in the vertex palette
 CFltVertexListA list of vertices, typically added as a child of a face bead
 CFmodAudioManager
 CFmodAudioSound
 CFogSpecifies how atmospheric fog effects are applied to geometry
 CFogAttribApplies a Fog to the geometry at and below this node
 CFontPoolThis is the preferred interface for loading fonts for the TextNode system
 CForceNodeA force that lives in the scene graph and is therefore subject to local coordinate systems
 CFrameBufferPropertiesA container for the various kinds of properties we might ask to have on a graphics frameBuffer before we create a GSG
 CFrameRateMeterThis is a special TextNode that automatically updates itself with the current frame rate
 CGamepadButtonThis class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to gamepad buttons
 CGenericAsyncTaskAssociates a generic C-style function pointer with an AsyncTask object
 CGenericThreadA generic thread type that allows calling a C-style thread function without having to subclass
 CGeomA container for geometry primitives
 CGeomCacheEntryThis object contains a single cache entry in the GeomCacheManager
 CGeomCacheManagerThis 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
 CGeomContextThis is a special class object that holds all the information returned by a particular GSG to indicate the geom's internal context identifier
 CGeomDrawCallbackDataThis specialization on CallbackData is passed when the callback is initiated from deep within the draw traversal, for a particular Geom
 CGeomEnumsThis class exists just to provide scoping for the various enumerated types used by Geom, GeomVertexData, GeomVertexArrayData, GeomPrimitive, and other related classes
 CGeometricBoundingVolumeThis 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
 CGeoMipTerrainGeoMipTerrain, meaning Panda3D GeoMipMapping, can convert a heightfield image into a 3D terrain, consisting of several GeomNodes
 CGeomLinesDefines a series of disconnected line segments
 CGeomLinesAdjacencyDefines a series of disconnected line segments with adjacency information, for use with geometry shaders
 CGeomLinestripsDefines a series of line strips
 CGeomLinestripsAdjacencyDefines a series of line strips with adjacency information
 CGeomMungerObjects of this class are used to convert vertex data from a Geom into a format suitable for passing to the rendering backend
 CGeomNodeA node that holds Geom objects, renderable pieces of geometry
 CGeomParticleRenderer
 CGeomPatchesDefines a series of "patches", fixed-size groupings of vertices that must be processed by a tessellation shader
 CGeomPipelineReaderEncapsulates the data from a Geom, pre-fetched for one stage of the pipeline
 CGeomPointsDefines a series of disconnected points
 CGeomPrimitiveThis is an abstract base class for a family of classes that represent the fundamental geometry primitives that may be stored in a Geom
 CGeomPrimitivePipelineReaderEncapsulates the data from a GeomPrimitive, pre-fetched for one stage of the pipeline
 CGeomTextGlyphThis is a specialization on Geom for containing a primitive intended to represent a TextGlyph
 CGeomTransformerAn 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
 CGeomTrianglesDefines a series of disconnected triangles
 CGeomTrianglesAdjacencyDefines a series of disconnected triangles, with adjacency information
 CGeomTrifansDefines a series of triangle fans
 CGeomTristripsDefines a series of triangle strips
 CGeomTristripsAdjacencyDefines a series of triangle strips with adjacency information
 CGeomVertexAnimationSpecThis object describes how the vertex animation, if any, represented in a GeomVertexData is encoded
 CGeomVertexArrayDataThis is the data for one array of a GeomVertexData structure
 CGeomVertexArrayDataHandleThis data object is returned by GeomVertexArrayData::get_handle() or modify_handle()
 CGeomVertexArrayFormatThis describes the structure of a single array within a Geom data
 CGeomVertexColumnThis defines how a single column is interleaved within a vertex array stored within a Geom
 CGeomVertexDataThis defines the actual numeric vertex data stored in a Geom, in the structure defined by a particular GeomVertexFormat object
 CGeomVertexDataPipelineBaseThe common code from GeomVertexDataPipelineReader and GeomVertexDataPipelineWriter
 CGeomVertexDataPipelineReaderEncapsulates the data from a GeomVertexData, pre-fetched for one stage of the pipeline
 CGeomVertexDataPipelineWriterEncapsulates the data from a GeomVertexData, pre-fetched for one stage of the pipeline
 CGeomVertexFormatThis class defines the physical layout of the vertex data stored within a Geom
 CGeomVertexReaderThis object provides a high-level interface for quickly reading a sequence of numeric values from a vertex table
 CGeomVertexRewriterThis object provides the functionality of both a GeomVertexReader and a GeomVertexWriter, combined together into one convenient package
 CGeomVertexWriterThis object provides a high-level interface for quickly writing a sequence of numeric values from a vertex table
 CGlobalPointerRegistryThis class maintains a one-to-one mapping from TypeHandle to a void * pointer
 CGlobPatternThis class can be used to test for string matches against standard Unix- shell filename globbing conventions
 CglxGraphicsBufferAn offscreen buffer in the GLX environment
 CglxGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on an X-based (e.g
 CglxGraphicsPixmapAnother offscreen buffer in the GLX environment
 CglxGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some glx-specific information
 CglxGraphicsWindowAn interface to the glx system for managing GL windows under X
 CGPUCommandClass for storing data to be transferred to the GPU
 CGPUCommandListRenderPipeline
 CGraphicsBufferAn offscreen buffer for rendering into
 CGraphicsDeviceAn abstract device object that is part of Graphics Pipe
 CGraphicsEngineThis class is the main interface to controlling the render process
 CGraphicsOutputThis is a base class for the various different classes that represent the result of a frame of rendering
 CGraphicsOutputBaseAn abstract base class for GraphicsOutput, for all the usual reasons
 CGraphicsPipeAn object to create GraphicsOutputs that share a particular 3-D API
 CGraphicsPipeSelectionThis maintains a list of GraphicsPipes by type that are available for creation
 CGraphicsStateGuardianEncapsulates all the communication with a particular instance of a given rendering backend
 CGraphicsStateGuardianBaseThis is a base class for the GraphicsStateGuardian class, which is itself a base class for the various GSG's for different platforms
 CGraphicsThreadingModelThis represents the user's specification of how a particular frame is handled by the various threads
 CGraphicsWindowA window, fullscreen or on a desktop, into which a graphics device sends its output for interactive display
 CGraphicsWindowInputDeviceThis is a virtual input device that represents the keyboard and mouse pair that is associated with a particular window
 CGraphicsWindowProcDefines an interface for storing platform-specific window processor methods
 CGraphicsWindowProcCallbackDataThis specialization on CallbackData is passed when the callback is initiated from from an implementation of the GraphicsWindowProc class, such as PythonGraphicsWindowProc
 CHashGeneratorThis class generates an arbitrary hash number from a sequence of ints
 CHashGeneratorBaseThis is the base class for a number of classes that generate arbitrary hash numbers for complex objects, based fundamentally on a sequence of integers
 CHashValStores a 128-bit value that represents the hashed contents (typically MD5) of a file or buffer
 CHeader
 CHeightfieldTesselatorConverts a height field in the form of a greyscale image into a scene consisting of a number of GeomNodes
 CHermiteCurveA parametric curve defined by a sequence of control vertices, each with an in and out tangent
 CHermiteCurveCVA single CV of a Hermite curve
 CHideIntervalAn interval that calls NodePath::hide()
 CHTTPDateA container for an HTTP-legal time/date indication
 CHTTPEntityTagA container for an "entity tag" from an HTTP server
 CIESDatasetThis class generates a LUT from IES data
 CIffChunkThe basic kind of record in an EA "IFF" file, which the LightWave object file is based on
 CIffGenericChunkA class for a generic kind of IffChunk that is not understood by a particular IffReader
 CIffIdA four-byte chunk ID appearing in an "IFF" file
 CIffInputFileA wrapper around an istream used for reading an IFF file
 CImageBaseThis specialization of ProgramBase is intended for programs that read and/or write a single image file
 CImageFileThis is the base class of both TextureImage and PaletteImage
 CImageFilterThis is the base class for a program that reads an image file, operates on it, and writes another image file out
 CImageFixHiddenColorThis program repairs an image's RGB values hidden behind an A value of 0
 CImageInfoThis program reads the headers of a series of one or more images and reports their sizes to standard output
 CImageReaderThis is the base class for a program that reads an image file, but doesn't write an image file
 CImageResizeA program to read an image file and resize it to a larger or smaller image file
 CImageTransA program to read an image file and write an equivalent image file, possibly performing some minor operations along the way
 CImageTransformColorsThis program can apply a 4x4 color transform to all of the colors in the pixels of a series of images
 CImageWriterThis is the base class for a program that generates an image file output, but doesn't read any for input
 CIndexBufferContextThis 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
 CIndexedFaceSetDecodes the vertices and faces in a VRML indexed face set, and creates the corresponding egg geometry
 CIndexRemapperThis class manages a mapping of integers to integers
 Cindirect_compare_namesAn 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
 Cindirect_compare_names_hash
 Cindirect_compare_toAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain a compare_to() method
 Cindirect_compare_to_hash
 Cindirect_equals_hashAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator ==() method
 Cindirect_lessAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator <() method
 Cindirect_less_hash
 Cindirect_method_hashThis hash_compare class hashes a pointer to a class object
 CIndirectCompareNamesAn 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
 CIndirectCompareSortAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that define a get_sort() method
 CIndirectCompareToAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain a compare_to() method
 CIndirectLessAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator <() method
 CInkblotVideoA cellular automaton that generates an amusing pattern of swirling colors
 CInkblotVideoCursorA cellular automaton that generates an amusing pattern of swirling colors
 CInputDeviceThis is a structure representing a single input device
 CInputDeviceManagerThis class keeps track of all the devices on a system, and sends out events when a device has been hot-plugged
 CInputDeviceNodeReads the controller data sent from the InputDeviceManager, and transmits it down the data graph
 CInputDeviceSetManages a list of InputDevice objects, as returned by various InputDeviceManager methods
 Cinteger_hashThis 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)
 CInternalLightManagerInternal class used for handling lights and shadows
 CInternalNameEncodes a string name in a hash table, mapping it to a pointer
 CInternalNameCollection
 CInterrogateComponentThe base class for things that are part of the interrogate database
 CInterrogateDatabaseThis stores all of the interrogate data and handles reading the data from a disk file when necessary
 CInterrogateElementAn internal representation of a data element, like a data member or a global variable
 CInterrogateFunctionAn internal representation of a function
 CInterrogateFunctionWrapperAn internal representation of a callable function
 CInterrogateMakeSeqRepresents a synthetic method created via the MAKE_SEQ() macro
 CInterrogateManifestAn internal representation of a manifest constant
 CInterrogateModuleDef
 CInterrogateTypeAn internal representation of a type
 CInterrogateUniqueNameDef
 CIntersectionBoundingVolumeThis special bounding volume is the intersection of all of its constituent bounding volumes
 CIoPtaDatagramFloatThis class is used to read and write a PTA_stdfloat from a Datagram, in support of Bam
 CIoPtaDatagramIntThis class is used to read and write a PTA_int from a Datagram, in support of Bam
 CIoPtaDatagramShortThis class is used to read and write a PTA_ushort from a Datagram, in support of Bam
 CIPhoneGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on the various IPHONE's
 CIPhoneGraphicsStateGuardian
 CIPhoneGraphicsWindowAn interface to the osx/ system for managing GL windows under X
 CIPipeStream
 CIsoPlacerContains the logic used to place isoparams where they'll do the most good on a surface
 CIStreamWrapperThis class provides a locking wrapper around an arbitrary istream pointer
 CISubStreamAn istream object that presents a subwindow into another istream
 CJointVertexTransformThis is a specialization on VertexTransform that returns the transform necessary to move vertices as if they were assigned to the indicated joint
 CKeyboardButtonThis class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard keyboard keys
 CLensA base class for any number of different kinds of lenses, linear and otherwise
 CLensNodeA node that contains a Lens
 CLerpBlendType
 CLightThe abstract interface to all kinds of lights
 CLightAttribIndicates which set of lights should be considered "on" to illuminate geometry at this level and below
 CLightLensNodeA derivative of Light and of Camera
 CLightMutexThis is a standard, non-reentrant mutex, similar to the Mutex class
 CLightMutexDirectThis class implements a lightweight Mutex by making direct calls to the underlying implementation layer
 CLightMutexHolderSimilar to MutexHolder, but for a light mutex
 CLightNodeA derivative of Light and of PandaNode
 CLightRampAttribA Light Ramp is any unary operator that takes a rendered pixel as input, and adjusts the brightness of that pixel
 CLightReMutexA lightweight reentrant mutex
 CLightReMutexDirectThis class implements a standard lightReMutex by making direct calls to the underlying implementation layer
 CLightReMutexHolderSimilar to MutexHolder, but for a light reentrant mutex
 CLinearControlForceSimple directed vector force
 CLinearCylinderVortexForceDefines a cylinder inside of which all forces are tangential to the theta of the particle wrt the z-axis in local coord
 CLinearDistanceForcePure virtual class for sinks and sources
 CLinearEulerIntegratorPerforms Euler integration on a vector of physically modelable objects given a quantum dt
 CLinearForceA force that acts on a PhysicsObject by way of an Integrator
 CLinearFrictionForceFriction-based drag force
 CLinearIntegratorPure virtual base class for physical modeling
 CLinearJitterForceCompletely random noise force vector
 CLinearNoiseForceRepeating noise force vector
 CLinearRandomForcePure virtual, parent to noiseForce and jitterForce
 CLinearSinkForceAttractor force
 CLinearSourceForceRepellant force
 CLinearUserDefinedForceA programmable force that takes an evaluator function
 CLinearVectorForceSimple directed vector force
 CLineEmitterDescribes a linear region in which particles are generated
 CLineParticleRendererRenders a line from last position to current position – good for rain, sparks, etc
 CLineSegsEncapsulates creation of a series of connected or disconnected line segments or points, for drawing paths or rays
 CLineStreamThis is a special ostream that writes to a memory buffer, like ostrstream
 CLineStreamBufUsed 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
 CLinkedListNodeThis just stores the pointers to implement a doubly-linked list of some kind of object
 CLoaderA 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)
 CLoaderFileTypeThis is the base class for a family of scene-graph file types that the Loader supports
 CLoaderFileTypeAssimpThis defines the Loader interface that uses the Assimp library to load various model formats
 CLoaderFileTypeBamThis defines the Loader interface to read Bam files
 CLoaderFileTypeEggThis defines the Loader interface to read Egg files
 CLoaderFileTypePandatoolThis defines the Loader interface to files whose converters are defined within the Pandatool package and inherit from SomethingToEggConverter, like FltToEggConverter and LwoToEggConverter
 CLoaderFileTypeRegistryThis class maintains the set of all known LoaderFileTypes in the universe
 CLoaderFileTypeSrtThis defines the Loader interface to read SpeedTree SRT files, which describe a single tree
 CLoaderFileTypeStfThis defines the Loader interface to read SpeedTree STF files–a simple text file that describes a forest of trees (references to SRT files)
 CLoaderOptionsSpecifies parameters that may be passed to the loader
 CLODNodeA Level-of-Detail node
 CLogicOpAttribIf enabled, specifies that a custom logical operation be performed instead of any color blending
 CLSimpleMatrixThis class provides an underlying storage of the various linear-algebra classes (e.g
 CLwoBoundingBoxStores the bounding box for the vertex data in a layer
 CLwoChunkA specialization of IffChunk for Lightwave Object files
 CLwoClipA single image file, or a numbered sequence of images (e.g
 CLwoDiscontinuousVertexMapA mapping of floating-point values per integer index
 CLwoGroupChunkA particular kind of LwoChunk that is expected to contain an arbitrary number of child chunks
 CLwoHeaderThe first chunk in a Lightwave Object file
 CLwoInputFileA specialization of IffInputFile to handle reading a Lightwave Object file
 CLwoLayerSignals the start of a new layer
 CLwoPointsAn array of points that will be referenced by later chunks
 CLwoPolygonsAn array of polygons that will be referenced by later chunks
 CLwoPolygonTagsAn association of polygons defined in the most recent LwoPolygons chunk to tag ids defined in the most recent LwoTags chunk
 CLwoScanA program to read a Lightwave file and report its structure and contents
 CLwoStillImageA single still image associated with a LwoClip chunk
 CLwoSurfaceDescribes the shading attributes of a surface
 CLwoSurfaceBlockA texture layer or shader, part of a LwoSurface chunk
 CLwoSurfaceBlockAxisIndicates the axis for this particular shader's projection
 CLwoSurfaceBlockChannelIndicates which channel the texture in this LwoSurfaceBlock is applied to
 CLwoSurfaceBlockCoordSysSpecifies whether texture coordinates are computed based on the vertices' world coordinates or local coordinates
 CLwoSurfaceBlockEnabledIndicates whether this particular layer or shader should be rendered or not
 CLwoSurfaceBlockHeaderThe header chunk within a LwoSurfaceBlock chunk
 CLwoSurfaceBlockImageSpecifies the particular image that is being applied as a texture
 CLwoSurfaceBlockOpacityIndicates how transparent or opaque this particular layer is in relation to the layers beneath it
 CLwoSurfaceBlockProjectionIndicates the projection mode for this particular shader
 CLwoSurfaceBlockRefObjSpecifies a reference object that the texture UV's are to be computed relative to
 CLwoSurfaceBlockRepeatFor cylindrical and spherical projections, this parameter controls how many times the image repeats over each full interval, in either dimension
 CLwoSurfaceBlockTMapThe tMap chunk within a LwoSurfaceBlock chunk
 CLwoSurfaceBlockTransformSpecifies a center point, scale, or rotation for the texture coordinates in this shader's texture mapping
 CLwoSurfaceBlockVMapNameSpecifies the name of a set of UV's defined on the polygons that use this model
 CLwoSurfaceBlockWrapSpecifies how the texture image appears for areas outside the image
 CLwoSurfaceColorRecords the base color of a surface, as an entry within a LwoSurface chunk
 CLwoSurfaceParameterRecords some parameter value of a surface material, as an entry within a LwoSurface chunk
 CLwoSurfaceSidednessRecords whether polygons are frontfacing only or backfacing also
 CLwoSurfaceSmoothingAngleIndicates the maximum angle (in radians) between adjacent polygons that should be smooth-shaded
 CLwoTagsAn array of tag strings that will be referenced by later chunks
 CLwoToEggA program to read a Lightwave file and generate an egg file
 CLwoToEggConverterThis class supervises the construction of an EggData structure from the data represented by the LwoHeader
 CLwoVertexMapA mapping of floating-point values per integer index
 CMainThreadThe special "main thread" class
 CMaterialDefines the way an object appears in the presence of lighting
 CMaterialAttribIndicates which, if any, material should be applied to geometry
 CMaterialCollection
 CMaterialPoolThe 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
 CMathNumbers
 CMatrixLensA completely generic linear lens
 CMaxEggOptions
 CMaxEggPlugin
 CMaxNodeDescDescribes a single instance of a node in the Max scene graph, relating it to the corresponding egg structures (e.g
 CMaxNodeTreeDescribes a complete tree of max nodes for conversion
 CMaxOptionsDialog
 CMaxToEggConverterThis class supervises the construction of an EggData structure from a Max model
 CMayaApiThis class presents a wrapper around the global Maya interface
 CMayaBlendDescA handle to a Maya blend shape description
 CMayaCopyA program to copy Maya .mb files into the cvs tree
 CMayaEggGroupUserDataThis class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the maya converter
 CMayaNodeDescDescribes a single instance of a node in the Maya scene graph, relating it to the corresponding egg structures (e.g
 CMayaNodeTreeDescribes a complete tree of maya nodes for conversion
 CMayaPviewThis class serves as a plug-in to Maya to allow viewing the current Maya selection as it will be converted to Panda
 CMayaSavePviewThis 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
 CMayaShaderCorresponds to a single "shader" in Maya
 CMayaShaderColorDefThis defines the various attributes that Maya may associate with the "color" channel for a particular shader (as well as on the "transparency" channel)
 CMayaShadersCollects the set of MayaShaders that have been encountered so far
 CMayaToEgg
 CMayaToEggClient
 CMayaToEggConverterThis class supervises the construction of an EggData structure from a single Maya file, or from the data already in the global Maya model space
 CMayaToEggServer
 CMemBuffer
 CMemoryBaseThis 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
 CMemoryHookThis class provides a wrapper around the various possible malloc schemes Panda might employ
 CMemoryUsageThis 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
 CMemoryUsagePointerCountsThis is a supporting class for MemoryUsage
 CMemoryUsagePointersThis is a list of pointers returned by a MemoryUsage object in response to some query
 CMersenne
 CMeshDrawerMesh drawer creates a single geom object that can be shaped with different draw commands
 CMeshDrawer2DThis class allows the drawing of 2d objects - mainly based on quads and rectangles
 Cmethod_hashThis hash_compare class hashes a class object
 CMicrophoneAudioClass MicrophoneAudio provides the means to read raw audio samples from a microphone
 CModelFlattenRequestThis class object manages a single asynchronous request to flatten a model
 CModelLoadRequestA class object that manages a single asynchronous model load request
 CModelNodeThis 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
 CModelPoolThis class unifies all references to the same filename, so that multiple attempts to load the same model will return the same pointer
 CModelRootA node of this type is created automatically at the root of each model file that is loaded
 CModelSaveRequestA class object that manages a single asynchronous model save request
 CModifierButtonsThis class monitors the state of a number of individual buttons and tracks whether each button is known to be down or up
 CMouseAndKeyboardReads the mouse and/or keyboard data sent from a GraphicsWindow, and transmits it down the data graph
 CMouseButtonThis class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard mouse buttons
 CMouseInterfaceNodeThis is the base class for some classes that monitor the mouse and keyboard input and perform some action due to their state
 CMouseRecorderThis 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)
 CMouseSubregionThe MouseSubregion object scales the mouse inputs from within a rectangular region of the screen, as if they were the full-screen inputs
 CMouseWatcherThis TFormer maintains a list of rectangular regions on the screen that are considered special mouse regions; typically these will be click buttons
 CMouseWatcherBaseThis represents a collection of MouseWatcherRegions that may be managed as a group
 CMouseWatcherGroupThis represents a collection of MouseWatcherRegions that may be managed as a group
 CMouseWatcherParameterThis is sent along as a parameter to most events generated for a region to indicate the mouse and button state for the event
 CMouseWatcherRegionThis is the class that defines a rectangular region on the screen for the MouseWatcher
 CMovieAudioA MovieAudio is actually any source that provides a sequence of audio samples
 CMovieAudioCursorA MovieAudio is actually any source that provides a sequence of audio samples
 CMovieTypeRegistryThis class records the different types of MovieAudio and MovieVideo that are available for loading
 CMovieVideoA MovieVideo is actually any source that provides a sequence of video frames
 CMovieVideoCursorA MovieVideo is actually any source that provides a sequence of video frames
 CMovingPartThis is the template instantiation of MovingPartBase, on the particular type of value provided by the channel
 CMovingPartBaseThis is the base class for a single animatable piece that may be bound to one channel (or more, if blending is in effect)
 CMovingPartMatrixThis is a particular kind of MovingPart that accepts a matrix each frame
 CMovingPartScalarThis is a particular kind of MovingPart that accepts a scalar each frame
 CMultifileA file that contains a set of files
 CMultiplexStreamThis 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
 CMultiplexStreamBufUsed by MultiplexStream to implement an ostream that sends what is written to it to any number of additional sources, like other ostreams
 CMultitexReducerThis 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
 CMutexA standard mutex, or mutual exclusion lock
 CMutexDirectThis class implements a standard mutex by making direct calls to the underlying implementation layer
 CMutexDummyImplA fake mutex implementation for single-threaded applications that don't need any synchronization control
 CMutexHolderA lightweight C++ object whose constructor calls acquire() and whose destructor calls release() on a mutex
 CNamableA base class for all things which can have a name
 CNamableOrderByNameAn STL function object for sorting an array of pointers to Namables into order by name
 CNameUniquifierA handy class for converting a list of arbitrary names (strings) so that each name is guaranteed to be unique in the list
 CNativeNumericDataNativeNumericData 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
 CNativeWindowHandleThis subclass of WindowHandle exists to allow simple creation of a WindowHandle of the appropriate type to the current OS
 CNetAddressRepresents a network address to which UDP packets may be sent or to which a TCP socket may be bound
 CNetDatagramA specific kind of Datagram, especially for sending across or receiving from a network
 CNeverFreeMemoryThis class is used to allocate bytes of memory from a pool that is never intended to be freed
 CNoBlendType
 CNodeThis class is used to assign the nodes on the mesh
 CNodeCachedReferenceCountThis 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
 CNodeConstPointerToA NodeConstPointerTo is similar to a NodePointerTo, except it keeps a const pointer to the thing
 CNodeCullCallbackDataThis kind of CallbackData is passed to the CallbackObject added to CallbackNode:set_cull_callback()
 CNodePathNodePath is the fundamental system for disambiguating instances, and also provides a higher-level interface for manipulating the scene graph
 CNodePathCollectionThis is a set of zero or more NodePaths
 CNodePathComponentThis is one component of a NodePath
 CNodePointerToThis 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
 CNodePointerToBaseThis 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
 CNodeRefCountObjThis works like RefCountObj, but it inherits from NodeReferenceCount instead of ReferenceCount
 CNodeReferenceCountThis 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
 CNodeVertexTransformThis VertexTransform gets its matrix from the Transform stored on a node
 CNonlinearImagerThis class object combines the rendered output of a 3-d from one or more linear (e.g
 CNotifyAn object that handles general error reporting to the user
 CNotifyCategoryA particular category of error messages
 CNotifyCategoryGetCategory_prc
 CNotifyCategoryProxyA handy wrapper around a NotifyCategory pointer
 CNullAudioManager
 CNullAudioSound
 CNurbsBasisVectorThis encapsulates a series of matrices that are used to represent the sequential segments of a NurbsCurveEvaluator
 CNurbsCurveA Nonuniform Rational B-Spline
 CNurbsCurveEvaluatorThis class is an abstraction for evaluating NURBS curves
 CNurbsCurveInterfaceThis abstract class defines the interface only for a Nurbs-style curve, with knots and coordinates in homogeneous space
 CNurbsCurveResultThe result of a NurbsCurveEvaluator
 CNurbsSurfaceEvaluatorThis class is an abstraction for evaluating NURBS surfaces
 CNurbsSurfaceResultThe result of a NurbsSurfaceEvaluator
 CNurbsVertexThis represents a single control vertex in a NurbsEvaluator
 CObjToEggA program to read a Obj file and generate an egg file
 CObjToEggConverterConvert an Obj file to egg data
 CObstacleAvoidance
 COccluderEffectThis functions similarly to a LightAttrib or ClipPlaneAttrib
 COccluderNodeA node in the scene graph that can hold an occluder polygon, which must be a rectangle
 COcclusionQueryContextReturned from a GSG in response to begin_occlusion_query()
 COdeAMotorJoint
 COdeBallJoint
 COdeBody
 COdeBoxGeom
 COdeCappedCylinderGeom
 COdeCollisionEntryA class used to hold information about a collision that has occurred
 COdeContact
 COdeContactGeom
 COdeContactJoint
 COdeConvexGeom
 COdeCylinderGeom
 COdeFixedJoint
 COdeGeom
 COdeHashSpace
 COdeHinge2Joint
 COdeHingeJoint
 COdeJoint
 COdeJointCollection
 COdeJointFeedback
 COdeJointGroup
 COdeLMotorJoint
 COdeMass
 COdeNullJoint
 COdePlane2dJoint
 COdePlaneGeom
 COdeQuadTreeSpace
 COdeRayGeom
 COdeSimpleSpace
 COdeSliderJoint
 COdeSpace
 COdeSphereGeom
 COdeSurfaceParameters
 COdeTriMeshData
 COdeTriMeshGeom
 COdeUniversalJoint
 COdeUtil
 COdeWorld
 COmniBoundingVolumeThis is a special kind of GeometricBoundingVolume that fills all of space
 COpenALAudioManager
 COpenALAudioSound
 COPipeStream
 Cordered_vectorThis 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
 COrientedParticleDescribes a particle that has angular characteristics (velocity, orientation)
 COrientedParticleFactoryCreates particles that are affected by angular forces
 COrthographicLensAn orthographic lens
 COSphereLensA OSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
 COStreamWrapperThis class provides a locking wrapper around an arbitrary ostream pointer
 COSubStreamAn ostream object that presents a subwindow into another ostream
 CosxGraphicsBufferAn offscreen buffer in the OSX environment
 CosxGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on the various OSX's
 CosxGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some wgl-specific information
 CosxGraphicsWindowAn interface to the osx/ system for managing GL windows under X
 Cov_multisetA specialization of ordered_vector that emulates a standard STL set: many copies of each element are allowed
 Cov_setA specialization of ordered_vector that emulates a standard STL set: one copy of each element is allowed
 CPaletteGroupThis is the highest level of grouping for TextureImages
 CPaletteGroupsA set of PaletteGroups
 CPaletteImageThis is a single palette image, one of several within a PalettePage, which is in turn one of several pages within a PaletteGroup
 CPalettePageThis is a particular collection of textures, within a PaletteGroup, that all share the same TextureProperties
 CPalettizerThis is the main engine behind egg-palettize
 Cpallocator_array
 Cpallocator_singleThis is our own Panda specialization on the default STL allocator
 CPandaFrameworkThis 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.)
 CPandaIOStreamCustom implementation of Assimp::IOStream
 CPandaIOSystemCustom implementation of Assimp::IOSystem
 CPandaLoggerCustom implementation of Assimp::Logger
 CPandaNodeA basic node of the scene graph or data graph
 CPandaNodeChainThis class maintains a linked list of PandaNodes
 CPandaNodePipelineReaderEncapsulates the data from a PandaNode, pre-fetched for one stage of the pipeline
 CPandaSystemThis class is used as a namespace to group several global properties of Panda
 CParametricCurveA virtual base class for parametric curves
 CParametricCurveCollectionThis is a set of zero or more ParametricCurves, which may or may not be related
 CParamNodePathA class object for storing a NodePath as a parameter
 CParamTextureImageA 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
 CParamTextureSamplerA class object for storing a pointer to a Texture along with a sampler state that indicates how to to sample the given texture
 CParamTypedRefCountA class object for storing specifically objects of type TypedReferenceCount, which is different than TypedWritableReferenceCount
 CParamValueA handy class object for storing simple values (like integers or strings) passed along with an Event or to be used as a shader input
 CParamValueBaseA non-template base class of ParamValue (below), which serves mainly to define the placeholder for the virtual output function
 CParasiteBufferThis 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
 CPartBundleThis is the root of a MovingPart hierarchy
 CPartBundleHandleThis is a trivial class returned by PartBundleNode::get_bundle()
 CPartBundleNodeThis is a node that contains a pointer to an PartBundle
 CPartGroupThis is the base class for PartRoot and MovingPart
 CParticleSystemContains and manages a particle system
 CParticleSystemManagerManages 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
 CPartSubsetThis class is used to define a subset of part names to apply to the PartBundle::bind_anim() operation
 CPathFindThis class contains all the members and functions that are required to form an interface between the AIBehaviors class and the PathFinder class
 CPathFinderThis class implements pathfinding using A* algorithm
 CPathFollow
 CPathReplaceThis encapsulates the user's command-line request to replace existing, incorrect pathnames to models and textures from a file with correct pathnames
 CpdequeThis is our own Panda specialization on the default STL deque
 CPerlinNoiseThis is the base class for PerlinNoise2 and PerlinNoise3, different dimensions of Perlin noise implementation
 CPerlinNoise2This class provides an implementation of Perlin noise for 2 variables
 CPerlinNoise3This class provides an implementation of Perlin noise for 3 variables
 CPerspectiveLensA perspective-type lens: a normal camera
 CPfmBbaGenerates a bounding-box description of a pfm file
 CPfmFileDefines 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
 CPfmTransOperates on a pfm file
 CPfmVizzerThis class aids in the visualization and manipulation of PfmFile objects
 CPGButtonThis is a particular kind of PGItem that is specialized to behave like a normal button object
 CPGButtonNotifyObjects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
 CPGCullTraverserThis is a specialization of CullTraverser for use within the pgui system
 CPGEntryThis 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
 CPGFrameStyle
 CPGItemThis is the base class for all the various kinds of gui widget objects
 CPGItemNotifyObjects that inherit from this class can receive specialized messages when PGItems change in certain ways
 CPGMouseWatcherBackgroundThis 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
 CPGMouseWatcherGroupThis is a specialization on MouseWatcherGroup, to associate it with a PGTop
 CPGMouseWatcherParameterThis 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
 CPGMouseWatcherRegionThis is a specialization on MouseWatcherRegion, to add a bit more fields that are relevant to the PG system
 CPGScrollFrameThis is a special kind of frame that pretends to be much larger than it actually is
 CPGSliderBarThis 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
 CPGSliderBarNotifyObjects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
 CPGTopThe "top" node of the new Panda GUI system
 CPGVirtualFrameThis represents a frame that is rendered as a window onto another (possibly much larger) canvas
 CPGWaitBarThis 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
 CPhysicalDefines a set of physically modeled attributes
 CPhysicalNodeGraph node that encapsulated a series of physical objects
 CPhysicsCollisionHandlerA specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
 CPhysicsManagerPhysics don't get much higher-level than this
 CPhysicsObjectA body on which physics will be applied
 CPhysicsObjectCollectionThis is a set of zero or more PhysicsObjects
 CPhysxActorActors are the main simulation objects
 CPhysxActorDescDescriptor for PhysxActor
 CPhysxBodyDescDescriptor for the optional rigid body dynamic state of PhysxActor
 CPhysxBounds3Represention of a axis aligned bounding box
 CPhysxBoxRepresents an oriented bounding box, as a center point, extents(radii) and a rotation
 CPhysxBoxControllerBox character controller
 CPhysxBoxControllerDescDescriptor class for PhysxBoxController
 CPhysxBoxForceFieldShapeA box shaped region used to define a force field
 CPhysxBoxForceFieldShapeDescDescriptor for a box force field shape
 CPhysxBoxShapeA box shaped collision detection primitive
 CPhysxBoxShapeDescDescriptor class for PhysxBoxShape
 CPhysxCapsuleRepresents a capsule
 CPhysxCapsuleControllerA capsule character controller
 CPhysxCapsuleControllerDescDescriptor class for PhysxCapsuleController
 CPhysxCapsuleForceFieldShapeA capsule shaped region used to define a force field
 CPhysxCapsuleForceFieldShapeDescDescriptor for a capsule force field shape
 CPhysxCapsuleShapeA capsule shaped collision detection primitive, also known as a line swept sphere
 CPhysxCapsuleShapeDescDescriptor class for PhysxCapsuleShape
 CPhysxCcdSkeletonA Convex Mesh
 CPhysxCcdSkeletonDesc
 CPhysxCloth
 CPhysxClothDescDescriptor for PhysxCloth
 CPhysxClothMesh
 CPhysxClothMeshDesc
 CPhysxClothNodeRenderable geometry which represents a cloth mesh
 CPhysxConstraintDominanceExpresses the dominance relationship of a constraint
 CPhysxContactPairAn instance of this class is send with contact reporting events
 CPhysxContactPointA helper structure for iterating over contact streams reported by PhysxContactPair
 CPhysxContactReportImplementation of the NxUserContactReport interface
 CPhysxControllerAbstract base class for character controllers
 CPhysxControllerDescDescriptor class for a character controller
 CPhysxControllerReportImplementation of the NxUserControllerHitReport interface
 CPhysxControllerShapeHit
 CPhysxControllersHit
 CPhysxConvexForceFieldShapeA convex shaped region used to define force field
 CPhysxConvexForceFieldShapeDescA descriptor for a convex force field shape
 CPhysxConvexMeshA Convex Mesh
 CPhysxConvexMeshDesc
 CPhysxConvexShapeA shapes which is used to represent an instance of an convex mesh
 CPhysxConvexShapeDescDescriptor class for PhysxConvexShape
 CPhysxCylindricalJointCylindrical Joints permit relative translational movement between two bodies along an axis, and also relative rotation along the axis
 CPhysxCylindricalJointDescDescriptor class for sliding joint
 CPhysxD6JointA D6 joint is a general constraint between two actors
 CPhysxD6JointDesc
 CPhysxDebugGeomNodeRenderable geometry which represents visualizations of physics objects
 CPhysxDistanceJointA distance joint maintains a certain distance between two points on two actors
 CPhysxDistanceJointDescDescriptor class for distance joint
 CPhysxEnumsThis class exists just to provide scoping for the enums shared by PhysX classes
 CPhysxFileStream
 CPhysxFixedJointA fixed joint permits no relative movement between two bodies
 CPhysxFixedJointDescDescriptor class for fixed joint
 CPhysxForceFieldA force field effector
 CPhysxForceFieldDescDescriptor class for force fields
 CPhysxForceFieldShapeAbstract base class for force field shapes
 CPhysxForceFieldShapeDescAbstract base class for descriptors for force field shapes descriptors
 CPhysxForceFieldShapeGroup
 CPhysxForceFieldShapeGroupDesc
 CPhysxGroupsMask128-bit bitmask class
 CPhysxHeightFieldA height field object
 CPhysxHeightFieldDescDescriptor class for height fields
 CPhysxHeightFieldShapeThis class is a shape instance of a height field object of type PhysxHeightField
 CPhysxHeightFieldShapeDescDescriptor class for PhysxHeightFieldShape
 CPhysxJointAbstract base class for the different types of joints
 CPhysxJointDescAbstract base class for joint descriptors
 CPhysxJointDriveDescUsed to describe drive properties for a PhysxD6Joint
 CPhysxJointLimitDescDescribes a joint limit
 CPhysxJointLimitSoftDescDescribes a joint limit
 CPhysxKitchen
 CPhysxLinearInterpolationValues
 CPhysxManagerThe central interface to the PhysX subsystem
 CPhysxMask32-bit bitmask class
 CPhysxMaterialA class for describing a shape's surface properties
 CPhysxMaterialDescDescriptor class for materials
 CPhysxMemoryReadBuffer
 CPhysxMemoryWriteBuffer
 CPhysxMeshHashUtility class used in building links between a tetrahedron mesh (soft body) and a triangle mesh used for rendering the soft body
 CPhysxMeshPoolThis class unifies all references to the same filename, so that multiple attempts to load the same mesh will return the same pointer
 CPhysxMotorDescDescribes a joint motor
 CPhysxObject
 CPhysxObjectCollection
 CPhysxOverlapReportObjects of this class are returned by the 'overlap shape' methods, for example overlapSphereShapes
 CPhysxPlane
 CPhysxPlaneShapeA plane collision detection primitive
 CPhysxPlaneShapeDescDescriptor class for PhysxPlaneShape
 CPhysxPointInPlaneJointA point in plane joint constrains a point on one body to only move inside a plane attached to another body
 CPhysxPointInPlaneJointDescDescriptor class for point-in-plane joint
 CPhysxPointOnLineJointA point on line joint constrains a point on one body to only move along a line attached to another body
 CPhysxPointOnLineJointDescDescriptor class for point-on-line joint
 CPhysxPrismaticJointA prismatic joint permits relative translational movement between two bodies along an axis, but no relative rotational movement
 CPhysxPrismaticJointDescDescriptor class for prismatic joint
 CPhysxPulleyJointA pulley joint simulates a rope between two objects passing over two pulleys
 CPhysxPulleyJointDescDescriptor class for distance joint
 CPhysxRayRepresents an ray as an origin and direction
 CPhysxRaycastHitThis structure captures results for a single raycast query
 CPhysxRaycastReportObjects of this class are returned by the 'raycast all' methods
 CPhysxRevoluteJointA joint which behaves in a similar way to a hinge or axel
 CPhysxRevoluteJointDescDescriptor class for distance joint
 CPhysxSceneA scene is a collection of bodies, constraints, and effectors which can interact
 CPhysxSceneDescDescriptor for PhysxScene
 CPhysxSceneStats2
 CPhysxSegmentRepresents a line segment
 CPhysxShapeAbstract base class for shapes
 CPhysxShapeDescAbstract base class for shape descriptors
 CPhysxSoftBody
 CPhysxSoftBodyDescDescriptor for PhysxSoftBody
 CPhysxSoftBodyMesh
 CPhysxSoftBodyMeshDesc
 CPhysxSoftBodyNodeRenderable geometry which represents a soft body mesh
 CPhysxSphereRepresents a sphere defined by its center point and radius
 CPhysxSphereForceFieldShapeA spherical force field shape
 CPhysxSphereForceFieldShapeDescA descriptor for a sphere force field shape
 CPhysxSphereShapeA sphere shaped collision detection primitive
 CPhysxSphereShapeDescDescriptor class for PhysxSphereShape
 CPhysxSphericalJointA sphere joint constrains two points on two bodies to coincide
 CPhysxSphericalJointDescDescriptor class for distance joint
 CPhysxSpringDescDescribes a joint spring
 CPhysxTriangleMesh
 CPhysxTriangleMeshDesc
 CPhysxTriangleMeshShapeA shapes which is used to represent an instance of an convex mesh
 CPhysxTriangleMeshShapeDescDescriptor class for PhysxTriangleMeshShape
 CPhysxTriggerReportImplementation of the NxUserTriggerReport interface
 CPhysxUserEntityReport
 CPhysxUtilLib
 CPhysxVehicle
 CPhysxVehicleDesc
 CPhysxWheel
 CPhysxWheelDesc
 CPhysxWheelShapeA special shape used for simulating a car wheel
 CPhysxWheelShapeDescDescriptor class for PhysxWheelShape
 CPiecewiseCurveA PiecewiseCurve is a curve made up of several curve segments, connected in a head-to-tail fashion
 CPipelineThis 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
 CPipelineCyclerThis class maintains different copies of a page of data between stages of the graphics pipeline (or any other pipelining context)
 CPipelineCyclerLinksThis just stores the pointers to implement a doubly-linked list of PipelineCyclers for a particular Pipeline object
 CPipelineCyclerTrivialImplThis is the trivial, non-threaded implementation of PipelineCyclerBase
 CPipeOcclusionCullTraverserThis specialization of CullTraverser uses the graphics pipe itself to perform occlusion culling
 CPipeStreamBuf
 Cpixel
 CPlaneNodeA node that contains a plane
 CplistThis is our own Panda specialization on the default STL list
 CpmapThis is our own Panda specialization on the default STL map
 CpmultimapThis is our own Panda specialization on the default STL multimap
 CpmultisetThis is our own Panda specialization on the default STL multiset
 CPNMBrushThis class is used to control the shape and color of the drawing operations performed by a PNMPainter object
 CPNMFileTypeThis is the base class of a family of classes that represent particular image file types that PNMImage supports
 CPNMFileTypePfmFor reading and writing PFM files using the basic PNMImage interface, as if they were basic RGB files
 CPNMFileTypeRegistryThis class maintains the set of all known PNMFileTypes in the universe
 CPNMImageThe 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
 CPNMImageHeaderThis is the base class of PNMImage, PNMReader, and PNMWriter
 CPNMPainterThis class provides a number of convenient methods for painting drawings directly into a PNMImage
 CPNMReaderThis is an abstract base class that defines the interface for reading image files of various types
 CPNMTextGlyphA single glyph in a PNMTextMaker
 CPNMTextMakerThis object uses the Freetype library to generate text directly into an image
 CPNMWriterThis is an abstract base class that defines the interface for writing image files of various types
 CPointEmitterDescribes a planar ring region in which particles are generated
 Cpointer_hashThis is the default hash_compare class, which assumes the Key is a pointer value
 CPointerDataHolds the data that might be generated by a 2-d pointer input device, such as the mouse in the GraphicsWindow
 CPointerEventRecords a pointer movement event
 CPointerEventListRecords a set of pointer events that happened recently
 CPointerSlotStorageClass to keep a list of pointers and nullpointers
 CPointerToThis file defines the classes PointerTo and ConstPointerTo (and their abbreviations, PT and CPT)
 CPointerToArrayA special kind of PointerTo that stores an array of the indicated element type, instead of a single element
 CPointerToArrayBaseThis is the base class for PointerToArray and ConstPointerToArray
 CPointerToBaseThis is the base class for PointerTo and ConstPointerTo
 CPointerToVoidThis is the non-template part of the base class for PointerTo and ConstPointerTo
 CPointLightA light originating from a single point in space, and shining in all directions
 CPointParticleDescribes a particle that requires representation by a point (pixel, sparkle, billboard)
 CPointParticleFactoryCreates point particles to user specs
 CPointParticleRendererSimple point/point particle renderer
 CPolylightEffectA PolylightEffect can be used on a node to define a LightGroup for that node
 CPolylightNodeA PolylightNode
 CPortalClipperThis object performs a depth-first traversal of the scene graph, with optional view-frustum culling, collecting CullState and searching for GeomNodes
 CPortalNodeA node in the scene graph that can hold a Portal Polygon, which is a rectangle
 CPosixGraphicsStateGuardianThis 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
 CPreparedGraphicsObjectsA table of objects that are saved within the graphics context for reference by handle later
 CPrimeNumberGeneratorThis class generates a table of prime numbers, up to the limit of an int
 CProfileTimer
 CProgramBaseThis is intended to be the base class for most general-purpose utility programs in the PANDATOOL tree
 CProjectionScreenA ProjectionScreen implements a simple system for projective texturing
 CpsetThis is our own Panda specialization on the default STL set
 CPSphereLensA PSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
 CPSSMCameraRigRenderPipeline
 CPStatClientManages the communications to report statistics via a network connection to a remote PStatServer
 CPStatClientControlMessageThis kind of message is sent from the client to the server on the TCP socket to establish critical control information
 CPStatClientDataThe data associated with a particular client, but not with any one particular frame or thread: the list of collectors and threads, for instance
 CPStatClientVersionRecords the version number of a particular client
 CPStatCollectorA lightweight class that represents a single element that may be timed and/or counted via stats
 CPStatCollectorDefDefines the details about the Collectors: the name, the suggested color, etc
 CPStatCollectorForwardThis class serves as a cheap forward reference to a PStatCollector, so that classes that are defined before the pstats module may access the PStatCollector
 CPStatCollectorForwardBaseThis 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)
 CPStatFrameDataContains the raw timing and level data for a single frame
 CPStatGPUTimerThis 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
 CPStatGraphThis is an abstract base class for several different kinds of graphs that have a few things in common, like labels and guide bars
 CPStatListenerThis is the TCP rendezvous socket listener
 CPStatMonitorThis is an abstract class that presents the interface to any number of different front-ends for the stats monitor
 CPStatPianoRollThis 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
 CPStatReaderThis is the class that does all the work for handling communications from a single Panda client
 CPStatServerThe overall manager of the network connections
 CPStatServerControlMessageThis kind of message is sent from the server to the client on the TCP socket to establish critical control information
 CPStatStripChartThis 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
 CPStatThreadA lightweight class that represents a single thread of execution to PStats
 CPStatThreadDataA collection of FrameData structures for recently-received frames within a particular thread
 CPStatTimerA lightweight class that can be used to automatically start and stop a PStatCollector around a section of code
 CPStatViewA View boils down the frame data to a linear list of times spent in a number of different Collectors, within a particular thread
 CPStatViewLevelThis is a single level value, or band of color, within a View
 CPtsToBam
 CPursue
 CpvectorThis is our own Panda specialization on the default STL vector
 CQtessGlobalsSimply used as a namespace to scope some global variables for this program, set from the command line
 CQtessInputEntryStores one entry in the qtess input file
 CQtessInputFileStores all the information read from a tesselation input file: a list of QtessInputEntry's
 CQtessSurfaceA 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
 CQueryContextThis is a base class for queries that might require a round-trip to the graphics engine
 CQueuedConnectionListenerThis flavor of ConnectionListener will queue up all of the TCP connections it established for later detection by the client code
 CQueuedConnectionManagerThis 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
 CQueuedConnectionReaderThis flavor of ConnectionReader will read from its sockets and queue up all of the datagrams read for later receipt by the client code
 CQueuedReturnThis is the implementation of a family of things that queue up their return values for later retrieval by client code, like QueuedConnectionReader, QueuedConnectionListener, QueuedConnectionManager
 CRamfileAn in-memory buffer specifically designed for downloading files to memory
 CRandomizerA handy class to return random numbers
 CRangeDescriptionThis describes a sparse range of Unicode character codes for conversion that may be specified on the command line
 CRangeIteratorWalks through all the Unicode characters described by a RangeDescription class
 CRecentConnectionReaderThis flavor of ConnectionReader will read from its sockets and retain only the single most recent datagram for inspection by client code
 CRecorderBaseThis 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
 CRecorderControllerThis object manages the process of recording the user's runtime inputs to a bam file so that the session can be recreated later
 CRecorderFrameThis object represents one frame of data in the recorded session file
 CRecorderHeaderThis object contains the header information written out at the beginning of a recorded session file
 CRecorderTableThis object is used by the RecorderController to write (and read) a record of the set of recorders in use to the bam file
 CRectangleEmitterDescribes a planar square region in which particles are generated
 CRectangleLightThis is a type of area light that is an axis aligned rectangle, pointing along the Y axis in the positive direction
 CRefCountObjAnother kind of proxy, similar to RefCountProxy
 CRefCountProxyA "proxy" to use to make a reference-countable object whenever the object cannot inherit from ReferenceCount for some reason
 CReferenceCountA base class for all things that want to be reference-counted
 CReferenceCountedVectorThis defines the object that is actually stored and reference-counted internally by a PointerToArray
 CReMutexA reentrant mutex
 CReMutexDirectThis class implements a standard reMutex by making direct calls to the underlying implementation layer
 CReMutexHolderSimilar to MutexHolder, but for a reentrant mutex
 CRenderAttribThis 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
 CRenderAttribRegistryThis 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
 CRenderBufferA RenderBuffer is an arbitrary subset of the various layers (depth buffer, color buffer, etc.) of a drawing region
 CRenderEffectThis 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
 CRenderEffectsThis represents a unique collection of RenderEffect objects that correspond to a particular renderable state
 CRenderModeAttribSpecifies how polygons are to be drawn
 CRenderStateThis represents a unique collection of RenderAttrib objects that correspond to a particular renderable state
 CRescaleNormalAttribSpecifies how polygons are to be drawn
 CReversedNumericDataNativeNumericData 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
 CRigidBodyCombinerThis 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
 CRingBuffer
 CRingEmitterDescribes a planar ring region in which particles are generated
 CRocketFileInterfaceImplementation of FileInterface to allow libRocket to read files from the virtual file system
 CRocketInputHandlerDataNode that listens for keyboard and mouse events and passes them to libRocket
 CRocketRegionRepresents a region in a window or buffer where the libRocket UI will be rendered to
 CRocketRenderInterfaceClass that provides the main render interface for libRocket integration
 CRocketSystemInterfaceThis is an implementation of SystemInterface that redirects the log output to Panda's notify system
 CRopeNodeThis class draws a visible representation of the NURBS curve stored in its NurbsCurveEvaluator
 CRPLightRenderPipeline
 CRPPointLightRenderPipeline
 CRPSpotLightRenderPipeline
 CSampleClassA basic description of the function and purpose of SampleClass
 CSamplerContextThis 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
 CSamplerStateRepresents a set of settings that indicate how a texture is sampled
 CSavedContextThis is the base class for all GSG-specific context objects, such as TextureContext and GeomContext
 CsBodyParams
 CSceneGraphAnalyzerA handy class that can scrub over a scene graph and collect interesting statistics on it
 CSceneGraphAnalyzerMeterThis is a special TextNode that automatically updates itself with output from a SceneGraphAnalyzer instance
 CSceneGraphReducerAn interface for simplifying ("flattening") scene graphs by eliminating unneeded nodes and collapsing out unneeded state changes and transforms
 CSceneSetupThis object holds the camera position, etc., and other general setup information for rendering a particular scene
 CScissorAttribThis restricts rendering to within a rectangular region of the scene, without otherwise affecting the viewport or lens properties
 CScissorEffectThis provides a higher-level wrapper around ScissorAttrib
 Csecond_of_pair_iteratorThis is an iterator adaptor that converts any iterator that returns a pair (e.g
 CSeek
 CSelectiveChildNodeA base class for nodes like LODNode and SequenceNode that select only one visible child at a time
 CSemaphoreA classic semaphore synchronization primitive
 Csequence_hashThis hash_compare class hashes a string
 CSequenceNodeA node that automatically cycles through rendering each one of its children according to its frame rate
 CSFNodeRef
 CShadeModelAttribSpecifies whether flat shading (per-polygon) or smooth shading (per-vertex) is in effect
 CShader
 CShaderAttrib
 CShaderBufferThis is a generic buffer object that lives in graphics memory
 CShaderContextThe ShaderContext is meant to contain the compiled version of a shader string
 CShaderGenerator
 CShaderInputThis is a small container class that can hold any one of the value types that can be passed as input to a shader
 CShaderPoolThis is the preferred interface for loading shaders for the TextNode system
 CShaderTerrainMeshTerrain Renderer class utilizing the GPU
 CShadowAtlasClass which manages distributing shadow maps in an atlas
 CShadowManager
 CShadowSourceRenderPipeline
 CSheetNodeThis class draws a visible representation of the NURBS surface stored in its NurbsSurfaceEvaluator
 CShowBoundsEffectApplied to a GeomNode to cause a visible bounding volume to be drawn for this node
 CShowIntervalAn interval that calls NodePath::show()
 CSimpleAllocatorAn implementation of a very simple block allocator
 CSimpleAllocatorBlockA single block as returned from SimpleAllocator::alloc()
 CSimpleHashMapThis template class implements an unordered map of keys to data, implemented as a hashtable
 CSimpleKeyValuePairEntry in the SimpleHashMap
 CSimpleKeyValuePair< Key, std::nullptr_t >Specialisation of SimpleKeyValuePair to not waste memory for nullptr_t values
 CSimpleLruAn implementation of a very simple LRU algorithm
 CSimpleLruPageOne atomic piece that may be managed by a SimpleLru chain
 CSliderTableStores the total set of VertexSliders that the vertices in a particular GeomVertexData object might depend on
 CSmoothMoverThis class handles smoothing of sampled motion points over time, e.g
 CSocket_AddressA simple place to store and manipulate tcp and port address for communication layer
 CSocket_fdset
 CSocket_IPBase functionality for a INET domain Socket This call should be the starting point for all other unix domain sockets
 CSocket_Selector
 CSocket_TCPBase 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
 CSocket_TCP_ListenBase functionality for a TCP rendezvous socket
 CSocket_UDPBase functionality for a combination UDP Reader and Writer
 CSocket_UDP_IncomingBase functionality for a UDP Reader
 CSocket_UDP_OutgoingBase functionality for a UDP sending socket
 CSomethingToEggThis is the general base class for a file-converter program that reads some model file format and generates an egg file
 CSomethingToEggConverterThis is a base class for a family of converter classes that manage a conversion from some file type to egg format
 CSortPlacementBySize
 CSourceTextureImageThis is a texture image reference as it appears in an egg file: the source image of the texture
 CSparkleParticleRendererPretty sparkly things
 CSparseArrayThis class records a set of integers, where each integer is either present or not present in the set
 CSpeedTreeNodeInterfaces with the SpeedTree library to render SpeedTree objects, especially trees, within the Panda3D scene graph
 CSphereLightA 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
 CSphereSurfaceEmitterDescribes a curved space in which particles are generated
 CSphereVolumeEmitterDescribes a voluminous spherical region in which particles are generated
 CSpotlightA light originating from a single point in space, and shining in a particular direction, with a cone-shaped falloff
 CSpriteAnimHelper class used by SpriteParticleRenderer to keep track of its textures and their respective UVs and source types
 CSpriteParticleRendererRenders a particle system with high-speed nasty trick sprites
 CSpriteWriterHelper class used by SpriteParticleRenderer to keep track of the various GeomVertexWriters associated with each geom created in SpriteParticleRenderer::init_geoms()
 CsSurfaceParams
 CStackedPerlinNoise2Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
 CStackedPerlinNoise3Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
 CStandardMungerPerforms 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
 CStateMungerThis is just a simple derivative of GeomMunger that adds the ability to munge states
 CStaticDeletedChainThis template class is used to conveniently declare a single instance of the DeletedChain template object, above, for a particular type
 CStaticTextFontA 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
 CSTBasicTerrainA 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
 Cstbi_io_callbacks
 CStencilAttribA StencilAttrib is a collection of all stencil render states
 CStereoDisplayRegionThis is a special DisplayRegion wrapper that actually includes a pair of DisplayRegions internally: the left and right eyes
 Cstl_hash_compare
 CStreamReaderA class to read sequential binary data directly from an istream
 CStreamWrapperThis class provides a locking wrapper around a combination ostream/istream pointer
 CStreamWrapperBaseThe base class for both IStreamWrapper and OStreamWrapper, this provides the common locking interface
 CStreamWriterA StreamWriter object is used to write sequential binary data directly to an ostream
 CStringDecoderThe base class to a family of classes that decode various kinds of encoded byte streams
 CStringStreamA 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
 CStringStreamBufUsed 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
 CStringUtf16DecoderThis decoder extracts characters two at a time to get a plain wide character sequence
 CStringUtf8DecoderThis decoder extracts utf-8 sequences
 CSTTerrainThis is the abstract base class that defines the interface needed to describe a terrain for rendering by SpeedTree
 CSTTransformRepresents a transform that may be applied to a particular instance of a tree when added to the SpeedTreeNode
 CSTTreeEncapsulates a single tree model in the SpeedTree library, as loaded from an SRT file
 CSubdivSegmentRepresents a single hypothetical subdivided segment, under consideration by the IsoPlacer
 CSubfileInfoThis class records a particular byte sub-range within an existing file on disk
 CSubprocessWindowBufferThis is a special class that is designed to faciliate SubprocessWindow
 CSubStreamCombined ISubStream and OSubStream for bidirectional I/O
 CSubStreamBufThe streambuf object that implements ISubStream
 CSwitchNodeA node that renders only one of its children, according to the user's indication
 CTagStateManagerThis class handles all different tag states
 CTangentRingEmitterDescribes a planar ring region in which tangent particles are generated, and particles fly off tangential to the ring
 CTemporaryFileThis is a special kind of FileReference class that automatically deletes the file in question when it is deleted
 CTestCopyA program to copy ordinary files into the cvs tree
 CTexGenAttribComputes texture coordinates for geometry automatically based on vertex position and/or normal
 CTexMatrixAttribApplies a transform matrix to UV's before they are rendered
 CTexProjectorEffectThis effect automatically applies a computed texture matrix to the specified texture stage, according to the relative position of two specified nodes
 CTextAssemblerThis 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
 CTextEncoderThis class can be used to convert text between multiple representations, e.g
 CTextFontAn encapsulation of a font; i.e
 CTextGlyphA representation of a single glyph (character) from a font
 CTextGraphicThis defines a special model that has been constructed for the purposes of embedding an arbitrary graphic image within a text paragraph
 CTextMonitorA simple, scrolling-text stats monitor
 CTextNodeThe primary interface to this module
 CTextPropertiesThis defines the set of visual properties that may be assigned to the individual characters of the text
 CTextPropertiesManagerThis defines all of the TextProperties structures that might be referenced by name from an embedded text string
 CTextStatsA simple, scrolling-text stats server
 CTextureRepresents 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
 CTextureAttribIndicates the set of TextureStages and their associated Textures that should be applied to (or removed from) a node
 CTextureCollectionManages a list of Texture objects, as returned by TexturePool::find_all_textures()
 CTextureContextThis is a special class object that holds all the information returned by a particular GSG to indicate the texture's internal context identifier
 CTextureImageThis represents a single source texture that is referenced by one or more egg files
 CTextureMemoryCounterThis class is used to gather statistics on texture memory usage, etc
 CTexturePeekerAn instance of this object is returned by Texture::peek()
 CTexturePlacementThis 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
 CTexturePoolThis is the preferred interface for loading textures from image files
 CTexturePoolFilterThis 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
 CTexturePositionThis represents a particular position of a texture within a PaletteImage
 CTexturePropertiesThis is the set of characteristics of a texture that, if different from another texture, prevent the two textures from sharing a PaletteImage
 CTextureReferenceThis is the particular reference of a texture filename by an egg file
 CTextureReloadRequestThis loader request will call Texture::get_ram_image() in a sub-thread, to force the texture's image to be re-read from disk
 CTextureRequestThese are the things that a user might explicitly request to adjust on a texture via a line in the .txa file
 CTextureStageDefines the properties of a named stage of the multitexture pipeline
 CTextureStageCollection
 CTextureStagePoolThe 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
 CThreadA thread; that is, a lightweight process
 CThreadSafeConstPointerTo
 CThreadSafePointerToThis 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
 CThreadSafePointerToBaseThis is the base class for ThreadSafePointerTo and ThreadSafeConstPointerTo
 CTime_Accumulator
 CTime_ClockThis class is to provide a consistant interface and storage to clock time
 CTime_Out
 CTime_Span
 CTimedCycleA class for anything that needs to cycle over some finite list of elements in increments based on time
 CTimerQueryContext
 CTimeVal
 CTiXmlAttributeAn attribute is a name-value pair
 CTiXmlAttributeSet
 CTiXmlBaseTiXmlBase is a base class for every class in TinyXml
 CTiXmlCommentAn XML comment
 CTiXmlCursor
 CTiXmlDeclarationIn correct XML the declaration is the first entry in the file
 CTiXmlDocumentAlways the top level node
 CTiXmlElementThe element is a container class
 CTiXmlHandleA TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing
 CTiXmlNodeThe parent class for everything in the Document Object Model
 CTiXmlPrinterPrint to memory functionality
 CTiXmlTextXML text
 CTiXmlUnknownAny tag that tinyXml doesn't recognize is saved as an unknown
 CTiXmlVisitorImplements 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
 CTouchInfoStores information for a single touch event
 CTrackballTrackball acts like Performer in trackball mode
 CTrackerDataStores the kinds of data that a tracker might output
 CTrackerNodeThis class reads the position and orientation information from a tracker device and makes it available as a transformation on the data graph
 CTransform2SGInput: Transform (matrix)
 CTransformBlendThis defines a single entry in a TransformBlendTable
 CTransformBlendTableThis 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
 CTransformStateIndicates a coordinate-system transform on vertices
 CTransformTableStores the total set of VertexTransforms that the vertices in a particular GeomVertexData object might depend on
 CTransparencyAttribThis controls the enabling of transparency
 CTriangulatorThis class can triangulate a convex or concave polygon, even one with holes
 CTriangulator3This is an extension of Triangulator to handle polygons with three- dimensional points
 CTrueClockAn interface to whatever real-time clock we might have available in the current environment
 CTxaFileThis represents the .txa file (usually textures.txa) that contains the user instructions for resizing, grouping, etc
 CTxaFileFilterThis 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
 CTxaLineThis is a single matching line in the .txa file
 Ctypecast_iteratorThis is an iterator adaptor that explicitly typecasts each value returned by the base iterator to the indicated type
 CTypedObjectThis is an abstract class that all classes which use TypeHandle, and also provide virtual functions to support polymorphism, should inherit from
 CTypedReferenceCountA base class for things which need to inherit from both TypedObject and from ReferenceCount
 CTypedSkelSkeleton object that inherits from TypedObject
 CTypedWritableBase class for objects that can be written to and read from Bam files
 CTypedWritableReferenceCountA base class for things which need to inherit from both TypedWritable and from ReferenceCount
 CTypeHandleTypeHandle is the identifier used to differentiate C++ class types
 CTypeRegistryMaintains all the assigned TypeHandles in a given system
 CTypeRegistryNodeThis is a single entry in the TypeRegistry
 CUnicodeLatinMapThis 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
 CUnionBoundingVolumeThis special bounding volume is the union of all of its constituent bounding volumes
 CUniqueEggMaterialsAn STL function object for sorting materials into order by properties
 CUniqueEggTexturesAn STL function object for sorting textures into order by properties
 CUniqueEggVerticesAn STL function object for sorting vertices into order by properties
 CUniqueIdAllocatorManage a set of ID values from min to max inclusive
 CUpdateSeqThis is a sequence number that increments monotonically
 CURLSpecA container for a URL, e.g
 CUserDataAudioA UserDataAudio is a way for the user to manually supply raw audio samples
 CUserDataAudioCursorA UserDataAudioCursor is a means to manually supply a sequence of raw audio samples
 CUserPersistentData
 CUserVertexSliderThis is a specialization on VertexSlider that allows the user to specify any arbitrary slider valie he likes
 CUserVertexTransformThis is a specialization on VertexTransform that allows the user to specify any arbitrary transform matrix he likes
 CUvScrollNodeThis node is placed at key points within the scene graph to animate uvs
 CVertexBufferContextThis 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
 CVertexDataBlockA block of bytes that stores the actual raw vertex data referenced by a GeomVertexArrayData object
 CVertexDataBookA collection of VertexDataPages, which can be used to allocate new VertexDataBlock objects
 CVertexDataBufferA block of bytes that stores the actual raw vertex data referenced by a GeomVertexArrayData object
 CVertexDataPageA block of bytes that holds one or more VertexDataBlocks
 CVertexDataSaveBlockA block of bytes on the save file
 CVertexDataSaveFileA temporary file to hold the vertex data that has been evicted from memory and written to disk
 CVertexElementArrayThis class gives the ability for a user-friendly way of creating a vertex declaration for DirectX 9
 CVertexMembershipThis class is used to help EggOptchar quantize the membership of one vertex among its various groups
 CVertexSliderThis 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)
 CVertexTransformThis 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
 CVideoTextureThe base class for a family of animated Textures that take their input from a video source, such as a movie file
 CVirtualFileThe abstract base class for a file or directory within the VirtualFileSystem
 CVirtualFileCompositeA composite directory within the VirtualFileSystem: this maps to more than one directory on different mount points
 CVirtualFileListA list of VirtualFiles, as returned by VirtualFile::scan_directory()
 CVirtualFileMountThe abstract base class for a mount definition used within a VirtualFileSystem
 CVirtualFileMountMultifileMaps a Multifile's contents into the VirtualFileSystem
 CVirtualFileMountRamdiskSimulates an actual directory on disk with in-memory storage
 CVirtualFileMountSystemMaps an actual OS directory into the VirtualFileSystem
 CVirtualFileSimpleA simple file or directory within the VirtualFileSystem: this maps to exactly one file on one mount point
 CVirtualFileSystemA 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
 CVirtualMousePoses 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
 CVRMLAppearance
 CVrmlFieldValue
 CVrmlNode
 CVrmlNodeType
 CVRMLToEggA program to read a VRML file and generate an egg file
 CVRMLToEggConverterThis class supervises the construction of an EggData structure from a VRML file
 CVRMLTransA program to read a VRML file and output an essentially similar VRML file
 CVrpnAnalogThis is the actual interface to a particular VRPN analog device, and all of its numbered controls
 CVrpnAnalogDeviceThe Panda interface to a VRPN analog device
 CVrpnButtonThis is the actual interface to a particular VRPN button device, and all of its numbered buttons
 CVrpnButtonDeviceThe Panda interface to a VRPN button
 CVrpnClientA specific ClientBase that connects to a VRPN server and records information on the connected VRPN devices
 CVrpnDialThis is the actual interface to a particular VRPN dial device, and all of its numbered dials
 CVrpnDialDeviceThe Panda interface to a VRPN dial device
 CVrpnTrackerThis is the actual interface to a particular VRPN tracker object, and all of its sensors
 CVrpnTrackerDeviceThe Panda interface to a VRPN tracker
 CWaitIntervalThis interval does absolutely nothing, and is mainly useful for marking time between other intervals within a sequence
 CWander
 CWavAudioA native PCM .wav loader
 CWavAudioCursorUsed for reading PCM .wav files
 CwdxGraphicsBuffer9An offscreen render buffer
 CwdxGraphicsPipe9This graphics pipe represents the interface for creating DirectX9 graphics windows
 CwdxGraphicsWindow9A single graphics window for rendering DirectX under Microsoft Windows
 CWeakConstPointerToA 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
 CWeakNodePathThis class is a wrapper around a NodePath that, unlike the actual NodePath class, doesn't hold a reference count to the node
 CWeakPointerCallbackDerive 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
 CWeakPointerToWeakPointerTo is similar to PointerTo, except that it does not actually prevent the referenced pointer from deleting
 CWeakPointerToBaseThis is the base class for PointerTo and ConstPointerTo
 CWeakPointerToVoidThis is the specialization of PointerToVoid for weak pointers
 CWeakReferenceListThis is an object shared by all the weak pointers that point to the same ReferenceCount object
 CWebcamVideoAllows you to open a webcam or other video capture device as a video stream
 CwglGraphicsBufferAn offscreen render buffer
 CwglGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on the various Windows OSes
 CwglGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some wgl-specific information
 CwglGraphicsWindowA single graphics window for rendering OpenGL under Microsoft Windows
 CWindowFrameworkThis encapsulates the data that is normally associated with a single window, or with a single display region within a window
 CWindowHandleThis object represents a window on the desktop, not necessarily a Panda window
 CWindowPropertiesA container for the various kinds of properties we might ask to have on a graphics window before we open it
 CWindowsGuidThis is an implementation of the Windows GUID object, used everywhere as a world-unique identifier for anything and everything
 CWinGraphicsPipeThis is an abstract base class for wglGraphicsPipe and wdxGraphicsPipe; that is, those graphics pipes that are specialized for working with Microsoft Windows
 CWinGraphicsWindowAn abstract base class for glGraphicsWindow and dxGraphicsWindow (and, in general, graphics windows that interface with the Microsoft Windows API)
 CWinStatsChartMenuA pulldown menu of charts available for a particular thread
 CWinStatsGraphThis 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
 CWinStatsLabelA text label that will draw in color appropriate for a particular collector
 CWinStatsLabelStackA window that contains a stack of labels from bottom to top
 CWinStatsMonitorThis class represents a connection to a PStatsClient and manages the data exchange with the client
 CWinStatsPianoRollA window that draws a piano-roll style chart, which shows the collectors explicitly stopping and starting, one frame at a time
 CWinStatsServerThe class that owns the main loop, waiting for client connections
 CWinStatsStripChartA window that draws a strip chart, given a view
 CWithOutputFileThis is the bare functionality (intended to be inherited from along with ProgramBase or some derivative) for a program that might generate an output file
 CWordWrapStreamA special ostream that formats all of its output through ProgramBase::show_text()
 CWordWrapStreamBufUsed by WordWrapStream to implement an ostream that flushes its output to ProgramBase::show_text()
 CWorkingNodePathThis 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
 CWritableConfigurableDefined as a fix to allow creating Configurable and Writable objects
 CWritableParamThe specific derivation of FactoryParam that contains the information needed by a TypedWritable object
 Cx11GraphicsPipeThis graphics pipe represents the interface for creating graphics windows on an X-based client
 Cx11GraphicsWindowInterfaces to the X11 window system
 CXFileThis represents the complete contents of an X file (file.x) in memory
 CXFileAnimationSetThis represents a tree of EggTables, corresponding to Animation entries in the X file
 CXFileArrayDefDefines one level of array bounds for an associated XFileDataDef element
 CXFileDataDefA definition of a single data element appearing within a template record
 CXFileDataNodeThis is an abstract base class for an XFileNode which is also an XFileDataObject
 CXFileDataNodeReferenceThis is a nested reference to an instance of a template object, declared via the syntax:
 CXFileDataNodeTemplateThis is a node which contains all of the data elements defined by a template
 CXFileDataObjectThe abstract base class for a number of different types of data elements that may be stored in the X file
 CXFileDataObjectArrayAn array of nested data elements
 CXFileDataObjectDoubleAn double-valued data element
 CXFileDataObjectIntegerAn integer-valued data element
 CXFileDataObjectStringAn string-valued data element
 CXFileFaceThis represents a single face of an XFileMesh
 CXFileMakerThis class converts a Panda scene graph into a .X file and writes it out
 CXFileMaterialThis represents an X file "material", which consists of a color, lighting, and/or texture specification
 CXFileMeshThis is a collection of polygons; i.e
 CXFileNodeA single node of an X file
 CXFileNormalThis represents a single normal associated with an XFileFace
 CXFileParseDataThis class is used to fill up the data into an XFileDataNodeTemplate object as the data values are parsed out of the X file
 CXFileParseDataListA container for a pvector of the above objects
 CXFileTemplateA template definition in the X file
 CXFileToEggA program to read a DirectX "x" file and generate an egg file
 CXFileToEggConverter
 CXFileTransA program to read a X file and output an essentially similar X file
 CXFileVertexThis represents a single vertex associated with an XFileFace
 CXFileVertexPoolThis is a collection of unique vertices as extracted out of a Geom or a series of Geoms
 CXRRScreenSize
 CXTokenType
 CZSpinParticleDescribes a particle that spins along its z axis
 CZSpinParticleFactory