Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
oC_GPU_DEVICE
oC_KEY_ELEMENT
oC_KEY_LIST
oC_PROCESSOR_POWER_INFORMATION
oCAccumulatedAttribsThis 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
oCACMatrixSwitchType
oCACScalarSwitchType
oCActorNodeLike a physical node, but with a little more
oCAdaptiveLruA 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
oCAdaptiveLruPageOne atomic piece that may be managed by a AdaptiveLru chain
oCAdaptiveLruPageDynamicList
oCAdaptiveLruPageStaticList
oCAddHashThis 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)
oCAddNodeCB
oCAIBehaviors
oCAICharacter
oCAICharPoolThis class implements a linked list of AI Characters allowing the user to add and delete characters from the linked list
oCAINodeThis class is used to assign the nodes on the mesh
oCAIWorldA class that implements the virtual AI world which keeps track of the AI characters active at any given time
oCAlphaTestAttribEnables or disables writing of pixel to framebuffer based on its alpha value relative to a reference alpha value
oCAmbientLightA light source that seems to illuminate all points in space at once
oCAnalogNodeThis is the primary interface to analog controls like sliders and joysticks associated with a ClientBase
oCAndroidGraphicsPipeThis graphics pipe represents the interface for creating OpenGL ES graphics windows on an X-based (e.g
oCAndroidGraphicsStateGuardianA tiny specialization on GLESGraphicsStateGuardian to add some egl-specific information
oCAndroidGraphicsWindowAn interface to manage Android windows and their appropriate EGL surfaces
oCAngularEulerIntegratorPerforms Euler integration on a vector of physically modelable objects given a quantum dt
oCAngularForcePure virtual parent of all quat-based forces
oCAngularIntegratorPure virtual base class for physical modeling
oCAngularVectorForceSimple directed torque force, the angular equivalent of simple vector force
oCAnimateVerticesRequestThis class object manages a single asynchronous request to animate vertices on a GeomVertexData object
oCAnimBundleThis is the root of an AnimChannel hierarchy
oCAnimBundleMakerConverts an EggTable hierarchy, beginning with a <Bundle> entry, into an AnimBundle hierarchy
oCAnimBundleNodeThis is a node that contains a pointer to an AnimBundle
oCAnimChannelThis template class is the parent class for all kinds of AnimChannels that return different values
oCAnimChannelBaseParent class for all animation channels
oCAnimChannelFixedThis template class is a special kind of AnimChannel that always returns just one fixed value
oCAnimChannelMatrixDynamicAn animation channel that accepts a matrix each frame from some dynamic input provided by code
oCAnimChannelMatrixFixedA specialization on AnimChannel to add all the special matrix component operations
oCAnimChannelMatrixXfmTableAn animation channel that issues a matrix each frame, read from a table such as might have been read from an egg file
oCAnimChannelScalarDynamicAn animation channel that accepts a scalar each frame from some dynamic input provided by code
oCAnimChannelScalarTableAn animation channel that issues a scalar each frame, read from a table such as might have been read from an egg file
oCAnimControlControls the timing of a character animation
oCAnimControlCollectionThis is a named collection of AnimControl pointers
oCAnimGroupThis is the base class for AnimChannel and AnimBundle
oCAnimGroupAlphabeticalOrder
oCAnimInterfaceThis is the fundamental interface for things that have a play/loop/stop type interface for frame-based animation, such as animated characters
oCAnimPreloadTableThis table records data about a list of animations for a particular model, such as number of frames and frame rate
oCAntialiasAttribSpecifies whether or how to enable antialiasing, if supported by the backend renderer
oCArcEmitterDescribes a planar ring region in which particles are generated
oCArrival
oCAssimpLoaderClass that interfaces with Assimp and builds Panda nodes to represent the Assimp structures
oCAsyncTaskThis class represents a concrete task performed by an AsyncManager
oCAsyncTaskBaseThe abstract base class for AsyncTask
oCAsyncTaskChainThe AsyncTaskChain is a subset of the AsyncTaskManager
oCAsyncTaskCollectionA list of tasks, for instance as returned by some of the AsyncTaskManager query functions
oCAsyncTaskManagerA 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)
oCAsyncTaskPauseA special kind of task that simple returns DS_pause, to pause for a specified number of seconds and then finish
oCAsyncTaskSequenceA special kind of task that serves as a list of tasks internally
oCAtomicAdjustDummyImplA trivial implementation for atomic adjustments for systems that don't require multiprogramming, and therefore don't require special atomic operations
oCAttribNodeRegistryThis global object records NodePaths that are referenced by scene graph attribs, such as ClipPlaneAttribs and LightAttribs
oCAudioLoadRequestA class object that manages a single asynchronous audio load request
oCAudioManager
oCAudioSound
oCAudioVolumeAttribApplies a scale to audio volume for positional sounds in the scene graph
oCAuxBitplaneAttribModern frame buffers can have 'aux' bitplanes, which are additional bitplanes above and beyond the standard depth and color
oCAuxSceneDataThis 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
oCAwMouseAndKeyboardThin wrappings arround WebCore.h
oCAwWebCoreThin wrappings arround WebCore.h
oCAwWebViewThin bindings, wraps a WebView * returned from WebCore.createWebView
oCAwWebViewListenerThin bindings, wraps a WebViewListener
oCBamCacheThis 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)
oCBamCacheIndexThis represents the in-memory index that records the list of files stored in the BamCache
oCBamCacheRecordAn 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
oCBamEnumsThis class exists just to provide scoping for the enums shared by BamReader and BamWriter
oCBamFileThe principle public interface to reading and writing Bam disk files
oCBamInfo
oCBamReaderThis is the fundamental interface for extracting binary objects from a Bam file, as generated by a BamWriter
oCBamReaderAuxDataStores auxiliary data that may be piggybacked on the BamReader during each object's read pass
oCBamReaderParamThe parameters that are passed through the Factory to any object constructing itself from a Bam file
oCBamToEggThis program reads a bam file, for instance as written out from a real-time interaction session, and generates a corresponding egg file
oCBamWriterThis is the fundamental interface for writing binary objects to a Bam file, to be extracted later by a BamReader
oCBaseForcePure virtual base class for all forces that could POSSIBLY exist
oCBaseIncomingSetA base structre for a listening socket and a set of connection that have been received with there read functions
oCBaseIntegratorPure virtual integrator class that holds cached matrix information that really should be common to any possible child implementation
oCBaseParticleAn individual, physically-modelable particle abstract base class
oCBaseParticleEmitterDescribes a physical region in space in which particles are randomly generated
oCBaseParticleFactoryPure Virtual base class for creating particles
oCBaseParticleRendererPure virtual particle renderer base class
oCBasicSkelThis is the most basic of the skeleton classes
oCBillboardEffectIndicates that geometry at this node should automatically rotate to face the camera, or any other arbitrary node
oCBinCullHandlerThis CullHandler sends all of the geoms it receives into a CullResult object, for binning (and later drawing)
oCBindAnimRequestThis class object manages an asynchronous load-and-bind animation request, as issued through PartBundle::load_bind_anim()
oCBinToCA utility program to read a (binary) file and output a table that can be compiled via a C compiler to generate the same data
oCBitArrayA dynamic array with an unlimited number of bits
oCBitMaskA general bitmask class
oCbitstream
oCBoundingBoxAn axis-aligned bounding box; that is, a minimum and maximum coordinate triple
oCBoundingHexahedronThis defines a bounding convex hexahedron
oCBoundingLineThis funny bounding volume is an infinite line with no thickness and extending to infinity in both directions
oCBoundingPlaneThis 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
oCBoundingSphereThis defines a bounding sphere, consisting of a center and a radius
oCBoundingVolumeThis 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
oCBoxEmitterDescribes a voluminous box region in which particles are generated
oCBuffer
oCBufferContextThis 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
oCBufferContextChainThis class maintains a linked list of BufferContexts that might be allocated on the graphics card in some context
oCBuffered_DatagramConnection
oCBuffered_DatagramReader
oCBuffered_DatagramWriterThis is the buffered writer
oCBufferedWriter_Growable
oCBufferResidencyTrackerThis 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
oCBulletAllHitsRayResult
oCBulletBaseCharacterControllerNode
oCBulletBodyNode
oCBulletBoxShape
oCBulletCapsuleShape
oCBulletCharacterControllerNode
oCBulletClosestHitRayResult
oCBulletClosestHitSweepResult
oCBulletConeShape
oCBulletConeTwistConstraint
oCBulletConstraint
oCBulletContact
oCBulletContactCallbackData
oCBulletContactResult
oCBulletConvexHullShape
oCBulletConvexPointCloudShape
oCBulletCylinderShape
oCBulletDebugNode
oCBulletFilterCallbackData
oCBulletGenericConstraint
oCBulletGhostNode
oCBulletHeightfieldShape
oCBulletHelper
oCBulletHingeConstraintThe hinge constraint lets two bodies rotate around a given axis while adhering to specified limits
oCBulletManifoldPoint
oCBulletMinkowskiSumShape
oCBulletMultiSphereShape
oCBulletPersistentManifold
oCBulletPlaneShape
oCBulletRayHit
oCBulletRigidBodyNode
oCBulletRotationalLimitMotorRotation Limit structure for generic joints
oCBulletShape
oCBulletSliderConstraint
oCBulletSoftBodyConfig
oCBulletSoftBodyControl
oCBulletSoftBodyMaterial
oCBulletSoftBodyNode
oCBulletSoftBodyNodeElement
oCBulletSoftBodyShape
oCBulletSoftBodyWorldInfo
oCBulletSphereShape
oCBulletSphericalConstraintA constraint between two rigid bodies, each with a pivot point
oCBulletTickCallbackData
oCBulletTranslationalLimitMotorRotation Limit structure for generic joints
oCBulletTriangleMesh
oCBulletTriangleMeshShape
oCBulletVehicleSimulates a raycast vehicle which casts a ray per wheel at the ground as a cheap replacement for complex suspension simulation
oCBulletVehicleTuning
oCBulletWheelOne wheel of a BulletVehicle
oCBulletWheelRaycastInfo
oCBulletWorld
oCButtonEventRecords a button event of some kind
oCButtonEventListRecords a set of button events that happened recently
oCButtonHandleA ButtonHandle represents a single button from any device, including keyboard buttons and mouse buttons (but see KeyboardButton and MouseButton)
oCButtonMapThis 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
oCButtonNodeThis is the primary interface to on/off button devices associated with a ClientBase
oCButtonRegistryMaintains all the assigned ButtonHandles in a given system
oCButtonThrowerThrows Panda Events for button down/up events generated within the data graph
oCCachedTypedWritableReferenceCountThis 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
oCCacheStatsThis is used to track the utilization of the TransformState and RenderState caches, for low-level performance tuning information
oCCallbackDataThis is a generic data block that is passed along to a CallbackObject when a callback is made
oCCallbackGraphicsWindowThis 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
oCCallbackNodeA special node that can issue arbitrary callbacks to user code, either during the cull or draw traversals
oCCallbackObjectThis is a generic object that can be assigned to a callback at various points in the rendering process
oCCameraA node that can be positioned around in the scene graph to represent a point of view for rendering a scene
oCCardMakerThis class generates 2-d "cards", that is, rectangular polygons, particularly useful for showing textures etc
oCCConnectionRepositoryThis class implements the C++ side of the ConnectionRepository object
oCCConstrainHprIntervalA constraint interval that will constrain the orientation of one node to the orientation of another
oCCConstrainPosHprIntervalA constraint interval that will constrain the position and orientation of one node to the position and orientation of another
oCCConstrainPosIntervalA constraint interval that will constrain the position of one node to the position of another
oCCConstraintIntervalThe base class for a family of intervals that constrain some property to a value over time
oCCConstrainTransformIntervalA constraint interval that will constrain the transform of one node to the transform of another
oCCDistributedSmoothNodeBaseThis class defines some basic methods of DistributedSmoothNodeBase which have been moved into C++ as a performance optimization
oCCFChannelRepresents an open communication channel in the connected-frame protocol
oCCFCommandA single command in the Connected-Frame protocol
oCCFDoCullCommandStarts the cull process for a particular DisplayRegion
oCCharacterAn animated character, with skeleton-morph animation and either soft-skinned or hard-skinned vertices
oCCharacterJointThis represents one joint of the character's animation, containing an animating transform matrix
oCCharacterJointBundleThe collection of all the joints and sliders in the character
oCCharacterJointEffectThis effect will be added automatically to a node by CharacterJoint::add_net_transform() and CharacterJoint::add_local_transform()
oCCharacterMakerConverts an EggGroup hierarchy, beginning with a group with <Dart> set, to a character node with joints
oCCharacterSliderThis is a morph slider within the character
oCCharacterVertexSliderThis is a specialization on VertexSlider that returns the slider value associated with a particular CharacterSlider object
oCChecksumHashGeneratorThis is a specific kind of HashGenerator that simply adds up all of the ints
oCCIntervalThe base class for timeline components
oCCIntervalManagerThis object holds a number of currently-playing intervals and is responsible for advancing them each frame as needed
oCCircBufferThis class implements a queue of some type via a circular buffer
oCCLerpAnimEffectIntervalThis interval lerps between different amounts of control effects for various AnimControls that might be playing on an actor
oCCLerpIntervalThe base class for a family of intervals that linearly interpolate one or more numeric values over time
oCCLerpNodePathIntervalAn interval that lerps one or more properties (like pos, hpr, etc.) on a NodePath over time
oCClientAnalogDeviceA device, attached to the ClientBase by a AnalogNode, that records the data from a single named analog device
oCClientBaseAn abstract base class for a family of client device interfaces–including trackers, buttons, dials, and other analog inputs
oCClientButtonDeviceA device, attached to the ClientBase by a ButtonNode, that records the data from a single named button device
oCClientDeviceAny of a number of different devices that might be attached to a ClientBase, including trackers, etc
oCClientDialDeviceA device, attached to the ClientBase by a DialNode, that records the data from a single named dial device
oCClientState
oCClientTrackerDeviceA device, attached to the ClientBase by a TrackerNode, that records the data from a single tracker device
oCClipPlaneAttribThis functions similarly to a LightAttrib
oCClockObjectA ClockObject keeps track of elapsed real time and discrete time
oCCLwoClipThis class is a wrapper around LwoClip and stores additional information useful during the conversion-to-egg process
oCCLwoLayerThis class is a wrapper around LwoLayer and stores additional information useful during the conversion-to-egg process
oCCLwoPointsThis class is a wrapper around LwoPoints and stores additional information useful during the conversion-to-egg process
oCCLwoPolygonsThis class is a wrapper around LwoPolygons and stores additional information useful during the conversion-to-egg process
oCCLwoSurfaceThis class is a wrapper around LwoSurface and stores additional information useful during the conversion-to-egg process
oCCLwoSurfaceBlockThis class is a wrapper around LwoSurfaceBlock and stores additional information useful during the conversion-to-egg process
oCCLwoSurfaceBlockTMapThis class is a wrapper around LwoSurfaceBlockTMap and stores additional information useful during the conversion-to-egg process
oCCMetaIntervalThis interval contains a list of nested intervals, each of which has its own begin and end times
oCCMotionTrailThe method used in creating the motion trail is based on taking samples of time and transformations (the position and orientation matrix) in real-time
oCCMotionTrailFrame
oCCMotionTrailVertex
oCCocoaGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on a Cocoa-based (e.g
oCCocoaGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some Cocoa-specific information
oCCocoaGraphicsWindowAn interface to the Cocoa system for managing OpenGL windows under Mac OS X
oCCocoaPandaApp
oCCocoaPandaView
oCCocoaPandaWindow
oCCocoaPandaWindowDelegate
oCColladaBindMaterialClass that deals with binding materials to COLLADA geometry
oCColladaInputClass that deals with COLLADA data sources
oCColladaLoaderObject that interfaces with the COLLADA DOM library and loads the COLLADA structures into Panda nodes
oCColladaPrimitiveClass that deals with COLLADA primitive structures, such as <triangles> and <polylist>
oCCollisionBoxA cuboid collision volume or object
oCCollisionEntryDefines a single collision event
oCCollisionEntrySorter
oCCollisionFloorMeshThis object represents a solid made entirely of triangles, which will only be tested again z axis aligned rays
oCCollisionGeomA special CollisionPolygon created just for the purpose of detecting collision against geometry
oCCollisionHandlerThe abstract interface to a number of classes that decide what to do when a collision is detected
oCCollisionHandlerEventA specialized kind of CollisionHandler that throws an event for each collision detected
oCCollisionHandlerFloorA 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
oCCollisionHandlerFluidPusherA CollisionHandlerPusher that makes use of timing and spatial information from fluid collisions to improve collision response
oCCollisionHandlerGravityA 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
oCCollisionHandlerHighestEventA specialized kind of CollisionHandler that throws an event for each collision detected
oCCollisionHandlerPhysicalThe 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
oCCollisionHandlerPusherA specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
oCCollisionHandlerQueueA special kind of CollisionHandler that does nothing except remember the CollisionEntries detected the last pass
oCCollisionInvSphereAn inverted sphere: this is a sphere whose collision surface is the inside surface of the sphere
oCCollisionLevelStateThis is the state information the CollisionTraverser retains for each level during traversal
oCCollisionLevelStateBaseThis is the state information the CollisionTraverser retains for each level during traversal
oCCollisionLineAn infinite line, similar to a CollisionRay, except that it extends in both directions
oCCollisionNodeA node in the scene graph that can hold any number of CollisionSolids
oCCollisionParabolaThis defines a parabolic arc, or subset of an arc, similar to the path of a projectile or falling object
oCCollisionPlane
oCCollisionPolygon
oCCollisionRayAn infinite ray, with a specific origin and direction
oCCollisionSegmentA finite line segment, with two specific endpoints but no thickness
oCCollisionSolidThe 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)
oCCollisionSolidUndefinedPair
oCCollisionSphereA spherical collision volume or object
oCCollisionTraverserThis class manages the traversal through the scene graph to detect collisions
oCCollisionTubeThis implements a solid roughly in cylindrical shape
oCcolor
oCColorAttribIndicates what color should be applied to renderable geometry
oCColorBlendAttribThis specifies how colors are blended into the frame buffer, for special effects
oCcolorhist_item
oCcolorhist_list_item
oCColorInterpolationFunctionAbstract class from which all other functions should inherit
oCColorInterpolationFunctionConstantDefines a constant color over the lifetime of the segment
oCColorInterpolationFunctionLinearDefines a linear interpolation over the lifetime of the segment
oCColorInterpolationFunctionSinusoidDefines a sinusoidal blending between two colors
oCColorInterpolationFunctionStepwaveDefines a discrete cyclical transition between two colors
oCColorInterpolationManagerHigh level class for color interpolation
oCColorInterpolationSegmentA single unit of interpolation
oCColorScaleAttribApplies a scale to colors in the scene graph and on vertices
oCColorWriteAttribEnables or disables writing to the color buffer
oCcompare_toAn STL function object class, this is intended to be used on any ordered collection of class objects that contain a compare_to() method
oCCompareConfigDeclarations
oCCompareConfigPages
oCCompareLightPriorities
oCComparePlaneNodePriorities
oCCompareToAn STL function object class, this is intended to be used on any ordered collection of classes that contain a compare_to() method
oCCompassEffectA 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
oCComputeNodeA special node, the sole purpose of which is to invoke a dispatch operation on the assigned compute shader
oCConditionVarA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
oCConditionVarDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
oCConditionVarDummyImplA fake condition variable implementation for single-threaded applications that don't need any synchronization control
oCConditionVarFullThis class implements a condition variable; see ConditionVar for a brief introduction to this class
oCConditionVarFullDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
oCConfigDeclarationA single declaration of a config variable, typically defined as one line in a .prc file, e.g
oCConfigFlagsThis class is the base class of both ConfigVariable and ConfigVariableCore
oCConfigPageA page of ConfigDeclarations that may be loaded or unloaded
oCConfigPageManagerA global object that maintains the set of ConfigPages everywhere in the world, and keeps them in sorted order
oCConfigurableAn object that has data or parameters that are set less frequently (at least occasionally) than every frame
oCConfigVariableThis is a generic, untyped ConfigVariable
oCConfigVariableBaseThis class is the base class for both ConfigVariableList and ConfigVariable (and hence for all of the ConfigVariableBool, ConfigVaribleString, etc
oCConfigVariableBoolThis is a convenience class to specialize ConfigVariable as a boolean type
oCConfigVariableColorThis is a convenience class to specialize ConfigVariable as a set of floating-point types representing a color value
oCConfigVariableCoreThe internal definition of a ConfigVariable
oCConfigVariableDoubleThis is a convenience class to specialize ConfigVariable as a floating-point type
oCConfigVariableEnumThis class specializes ConfigVariable as an enumerated type
oCConfigVariableFilenameThis is a convenience class to specialize ConfigVariable as a Filename type
oCConfigVariableIntThis is a convenience class to specialize ConfigVariable as an integer type
oCConfigVariableInt64This is a convenience class to specialize ConfigVariable as a 64-bit integer type
oCConfigVariableListThis class is similar to ConfigVariable, but it reports its value as a list of strings
oCConfigVariableManagerA global object that maintains the set of ConfigVariables (actually, ConfigVariableCores) everywhere in the world, and keeps them in sorted order
oCConfigVariableSearchPathThis is similar to a ConfigVariableList, but it returns its list as a DSearchPath, as a list of directories
oCConfigVariableStringThis is a convenience class to specialize ConfigVariable as a string type
oCConnectionRepresents a single TCP or UDP socket for input or output
oCConnectionListenerThis 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)
oCConnectionListenerData
oCConnectionManagerThe primary interface to the low-level networking layer in this package
oCConnectionReaderThis 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)
oCConnectionWriterThis class handles threaded delivery of datagrams to various TCP or UDP sockets
oCConstPointerToA ConstPointerTo is similar to a PointerTo, except it keeps a const pointer to the thing
oCConstPointerToArraySimilar to PointerToArray, except that its contents may not be modified
oCControllerDemoViewController
oCCopyOnWriteObjThis is similar to RefCountObj, but it implements a CopyOnWriteObject inheritance instead of a ReferenceCount inheritance
oCCopyOnWriteObj1For objects (e.g
oCCopyOnWriteObjectThis base class provides basic reference counting, but also can be used with a CopyOnWritePointer to provide get_read_pointer() and get_write_pointer()
oCCopyOnWritePointerThis safely stores the primary, owned pointer to a CopyOnWriteObject
oCCopyOnWritePointerToA template wrapper around the above class, mainly to handle the little typecasting niceties
oCCPointerCallbackObjectThis is a specialization on CallbackObject to allow association with a C-style function pointer and a void * parameter
oCCPT_InternalNameThis is a const pointer to an InternalName, and should be used in lieu of a CPT(InternalName) in function arguments
oCCPU_ID
oCCPU_ID_BINARY_DATA
oCCPU_ID_REGISTERS
oCCubeFaceDef
oCCubicCurvesegA 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
oCCullableObjectThe smallest atom of cull
oCCullBinA collection of Geoms and their associated state, for a particular scene
oCCullBinAttribAssigns geometry to a particular bin by name
oCCullBinBackToFrontA specific kind of CullBin that sorts geometry in order from furthest to nearest based on the center of its bounding volume
oCCullBinEnumsProvides scoping for the enumerated type shared by CullBin and CullBinManager
oCCullBinFixedA specific kind of CullBin that sorts geometry in the order specified by the user-specified draw_order parameter
oCCullBinFrontToBackA specific kind of CullBin that sorts geometry in order from nearest to furthest based on the center of its bounding volume
oCCullBinManagerThis is a global object that maintains the collection of named CullBins in the world
oCCullBinStateSortedA 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
oCCullBinUnsortedA 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
oCCullFaceAttribIndicates which faces should be culled based on their vertex ordering
oCCullHandlerThis defines the abstract interface for an object that receives Geoms identified by the CullTraverser
oCCullPlanesThis 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
oCCullResultThis 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
oCCullTraverserThis object performs a depth-first traversal of the scene graph, with optional view-frustum culling, collecting CullState and searching for GeomNodes
oCCullTraverserDataThis collects together the pieces of data that are accumulated for each node while walking the scene graph during the cull traversal
oCCurveFitter
oCCVSCopyThis 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
oCCVSSourceDirectoryThis represents one particular directory in the hierarchy of source directory files
oCCVSSourceTreeThis represents the root of the tree of source directory files
oCCycleDataA single page of data maintained by a PipelineCycler
oCCycleDataLockedReaderThis template class calls PipelineCycler::read() in the constructor and PipelineCycler::release_read() in the destructor
oCCycleDataLockedStageReaderThis class is similar to CycleDataLockedReader, except it allows reading from a particular stage of the pipeline
oCCycleDataReaderThis template class calls PipelineCycler::read_unlocked(), and then provides a transparent read-only access to the CycleData
oCCycleDataStageReaderThis class is similar to CycleDataReader, except it allows reading from a particular stage of the pipeline
oCCycleDataStageWriterThis class is similar to CycleDataWriter, except it allows writing to a particular stage of the pipeline
oCCycleDataWriterThis template class calls PipelineCycler::write() in the constructor and PipelineCycler::release_write() in the destructor
oCCyclerHolderA lightweight C++ object whose constructor calls acquire() and whose destructor calls release() on a PipelineCyclerBase object
oCCylindricalLensA cylindrical lens
oCDaeCharacterClass representing an animated character
oCDaeMaterialsThis class is seperated from the converter file because otherwise it would get too big and needlessly complicated
oCdaeSmartRef
oCdaeTArray
oCDAEToEggA program to read a DAE file and generate an egg file
oCDAEToEggConverterThis class supervises the construction of an EggData structure from a DAE file
oCDatagramAn ordered list of data elements, formatted in memory for transmission over a socket or writing to a data file
oCDatagramGeneratorThis class defines the abstract interace to any source of datagrams, whether it be from a file or from the net
oCDatagramGeneratorNetThis class provides datagrams one-at-a-time as read directly from the net, via a TCP connection
oCDatagramInputFileThis class can be used to read a binary file that consists of an arbitrary header followed by a number of datagrams
oCDatagramIteratorA class to retrieve the individual data elements previously stored in a Datagram
oCDatagramOutputFileThis class can be used to write a binary file that consists of an arbitrary header followed by a number of datagrams
oCDatagramQueueA thread-safe, FIFO queue of NetDatagrams
oCDatagramSinkThis class defines the abstract interface to sending datagrams to any target, whether it be into a file or across the net
oCDatagramSinkNetThis class accepts datagrams one-at-a-time and sends them over the net, via a TCP connection
oCDatagramTCPHeaderA class that encapsulates the extra bytes that are sent in front of each datagram to identify it when it is sent on TCP
oCDatagramUDPHeaderA class that encapsulates the extra bytes that are sent in front of each datagram to identify it when it is sent on UDP
oCDataGraphTraverserThis object supervises the traversal of the data graph and the moving of data from one DataNode to its children
oCDataNodeThe fundamental type of node for the data graph
oCDataNodeTransmitEncapsulates the data generated from (or sent into) any particular DataNode
oCDCArrayParameterThis 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
oCDCAtomicFieldA single atomic field of a Distributed Class, as read from a .dc file
oCDCClassDefines a particular DistributedClass as read from an input .dc file
oCDCClassParameterThis represents a class (or struct) object used as a parameter itself
oCDCDeclarationThis is a common interface for a declaration in a DC file
oCDCFieldA single field of a Distributed Class, either atomic or molecular
oCDCFileRepresents the complete list of Distributed Class descriptions as read from a .dc file
oCDCKeywordThis represents a single keyword declaration in the dc file
oCDCKeywordListThis is a list of keywords (see DCKeyword) that may be set on a particular field
oCDCMolecularFieldA single molecular field of a Distributed Class, as read from a .dc file
oCDCNumericRangeRepresents a range of legal integer or floating-point values
oCDConfigThis class emulates the old dconfig-style interface to our Panda config system
oCDCPackDataThis is a block of data that receives the results of DCPacker
oCDCPackerThis class can be used for packing a series of numeric and string data into a binary stream, according to the DC specification
oCDCPackerCatalogThis object contains the names of all of the nested fields available within a particular field
oCDCPackerInterfaceThis defines the internal interface for packing values into a DCField
oCDCParameterRepresents the type specification for a single parameter within a field specification
oCDCSimpleParameterThis is the most fundamental kind of parameter type: a single number or string, one of the DCSubatomicType elements
oCDCSwitchThis 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
oCDCSwitchParameterThis represents a switch object used as a parameter itself, which packs the appropriate fields of the switch into the message
oCDCTokenType
oCDCTypedefThis represents a single typedef declaration in the dc file
oCDDSCaps2
oCDDSHeader
oCDDSPixelFormat
oCDecalEffectApplied to a GeomNode to indicate that the children of this GeomNode are coplanar and should be drawn as decals (eliminating Z-fighting)
oCDeclaration
oCDeferredNodePropertyThis class keeps track of all the state we must make note of during the graph traversal, but cannot apply immediately
oCDeletedBufferChainThis template class can be used to provide faster allocation/deallocation for many Panda objects
oCDeletedChainThis template class can be used to provide faster allocation/deallocation for many Panda objects
oCDepthOffsetAttribThis 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
oCDepthTestAttribEnables or disables writing to the depth buffer
oCDepthWriteAttribEnables or disables writing to the depth buffer
oCDestTextureImageThis represents a texture filename as it has been resized and copied to the map directory (e.g
oCDialNodeThis is the primary interface to infinite dial type devices associated with a ClientBase
oCDInput9Info
oCDirectDDirectD is a client/server app for starting panda/direct
oCDirectDClientDirectDClient is a test app for DriectDServer
oCDirectDServerStart a directdServer on each of the machines you which to start panda on
oCDirectionalLightA light shining from infinitely far away in a particular direction, like sunlight
oCDiscEmitterDescribes a planar disc region from which particles are generated
oCDISPLAY_FORMAT
oCDisplayInformationThis class contains various display information
oCDisplayMode
oCDisplayRegionA rectangular subregion within a window for rendering into
oCDisplayRegionBaseAn abstract base class for DisplayRegion, mainly so we can store DisplayRegion pointers in a Camera
oCDisplayRegionCullCallbackDataThis specialization on CallbackData is passed when the callback is initiated from the cull traversal, for a DisplayRegion
oCDisplayRegionDrawCallbackDataThis specialization on CallbackData is passed when the callback is initiated from the draw traversal, for a DisplayRegion
oCDisplayRegionPipelineReaderEncapsulates the data from a DisplayRegion, pre-fetched for one stage of the pipeline
oCDisplaySearchParametersParameters used for searching display capabilities
oCDiyFp
oCDocumentSpecA descriptor that refers to a particular version of a document
oCDoubleAlmostMatchesAn STL function object to determine if a double is vert nearly equal the supplied value
oCDoubleBitMaskThis is a special BitMask type that is implemented as a pair of lesser BitMask types, to present a double-wide bit mask
oCDoublesAlmostEqualAn STL function object to determine if two doubles are very nearly equal
oCDownloadDbA listing of files within multifiles for management of client-side synchronization with a server-provided set of files
oCDrawableRegionThis is a base class for GraphicsWindow (actually, GraphicsOutput) and DisplayRegion, both of which are conceptually rectangular regions into which drawing commands may be issued
oCDrawCullHandlerThis special kind of CullHandler immediately draws its contents as soon as it receives them
oCDriveInterfaceThis is a TFormer, similar to Trackball, that moves around a transform matrix in response to mouse input
oCDSearchPathThis class stores a list of directories that can be searched, in order, to locate a particular file
oCDXFFileA generic DXF-reading class
oCDXFLayerThis represents a "layer" as read from the DXF file
oCDXFLayerMapA map of string (layer name) to DXFLayer: that is, the layers of a file ordered by name
oCDXFPointsA simple program to read a dxf file and list the points contained within it to a text file
oCDXFToEggA program to read a DXF file and generate an egg file
oCDXFToEggConverterThis class supervises the construction of an EggData structure from a DXF file
oCDXFToEggLayerThe specialization of DXFLayer used by DXFToEggConverter
oCDXFVertexStored within DXFFile, this is the basic Vertex data of a DXF file
oCDXGeomMunger9This specialization on GeomMunger finesses vertices for DirectX rendering
oCDXGraphicsDevice9A GraphicsDevice necessary for multi-window rendering in DX
oCDXGraphicsStateGuardian9A GraphicsStateGuardian for rendering into DirectX9 contexts
oCDXIndexBufferContext9Caches a GeomPrimitive in the DirectX device as an index buffer
oCDXOcclusionQueryContext9
oCDXScreenData
oCDXShaderContext9Xyz
oCDXTextureContext9
oCEAGLView
oCEaseInBlendType
oCEaseInOutBlendType
oCEaseOutBlendType
oCEggAnimDataA base class for EggSAnimData and EggXfmAnimData, which contain rows and columns of numbers
oCEggAnimPreloadThis corresponds to an <AnimPreload> entry
oCEggAttributesThe set of attributes that may be applied to vertices as well as polygons, such as surface normal and color
oCEggBackPointerThis stores a pointer from an EggJointData or EggSliderData object back to the referencing data in an egg file
oCEggBaseThis is a base class for both EggSingleBase and EggMultiBase
oCEggBinA type of group node that holds related subnodes
oCEggBinMakerThis is a handy class for collecting related nodes together
oCEggBinMakerCompareNodesThis is just an STL function object, used to sort nodes within EggBinMaker
oCEggBinnerA special binner used only within this package to pre-process the egg tree for the loader and group things together as appropriate
oCEggCharacterCollectionRepresents a set of characters, as read and collected from possibly several model and/or animation egg files
oCEggCharacterDataRepresents a single character, as read and collected from several models and animation files
oCEggCharacterDbThis class is used during joint optimization or restructuring to store the table of interim joint computations
oCEggCharacterFilterThis is the base class for a family of programs that operate on a number of character models and their associated animation files together
oCEggCommentA comment that appears in an egg file within a <Comment> entry
oCEggComponentDataThis is the base class of both EggJointData and EggSliderData
oCEggCompositePrimitiveThe 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
oCEggConverterThis is a general base class for programs that convert between egg files and some other format
oCEggCoordinateSystemThe <CoordinateSystem> entry at the top of an egg file
oCEggCropA program to read an egg file and write an equivalent egg file, possibly performing some minor operations along the way
oCEggCurveA parametric curve of some kind
oCEggDataThis is the primary interface into all the egg data, and the root of the egg file structure
oCEggExternalReferenceDefines a reference to another egg file which should be inserted at this point
oCEggFileThis represents a single egg file known to the palettizer
oCEggFilenameNodeThis is an egg node that contains a filename
oCEggFilterThis is the base class for a program that reads an egg file, operates on it, and writes another egg file out
oCEggGroupThe main glue of the egg hierarchy, this corresponds to the <Group>, <Instance>, and <Joint> type nodes
oCEggGroupNodeA base class for nodes in the hierarchy that are not leaf nodes
oCEggGroupUniquifierThis is a specialization of EggNameUniquifier to generate unique names for EggGroup nodes
oCEggJointDataThis 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
oCEggJointNodePointerThis stores a pointer back to a <Joint> node
oCEggJointPointerThis is a base class for EggJointNodePointer and EggMatrixTablePointer
oCEggLineA line segment, or a series of connected line segments, defined by a <Line> entry
oCEggListTexturesReads an egg file and outputs the list of textures it uses
oCEggLoaderConverts an egg data structure, possibly read from an egg file but not necessarily, into a scene graph suitable for rendering
oCEggMakeFontThis program uses FreeType to generate an egg file and a series of texture images from a font file input, such as a TTF file
oCEggMakeSomethingA base class for a family of programs that generate egg models of various fundamental shapes
oCEggMakeTubeA program to generate an egg file representing a tube model, similar in shape to a CollisionTube
oCEggMaterial
oCEggMaterialCollectionThis is a collection of materials by MRef name
oCEggMatrixTablePointerThis stores a pointer back to an EggXfmSAnim table (i.e
oCEggMesherCollects together unrelated EggPrimitives, determines their edge connectivity, and generates a set of EggTriangleStrips that represent the same geometry
oCEggMesherEdgeRepresents one edge of a triangle, as used by the EggMesher to discover connected triangles
oCEggMesherFanMakerThis class is used by EggMesher::find_fans() to attempt to make an EggTriangleFan out of the polygons connected to the indicated vertex
oCEggMesherStripRepresents a triangle strip or quad strip in progress, as assembled by the mesher
oCEggMorphA single <Dxyz> or <Duv> or some such entry
oCEggMorphListA collection of <Dxyz>'s or <Duv>'s or some such
oCEggMultiBaseThis specialization of ProgramBase is intended for programs that read and/or write multiple egg files
oCEggMultiFilterThis 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)
oCEggNamedObjectThis is a fairly low-level base class–any egg object that has a name
oCEggNameUniquifierThis is a handy class for guaranteeing unique node names in an egg hierarchy
oCEggNodeA base class for things that may be directly added into the egg hierarchy
oCEggNurbsCurveA parametric NURBS curve
oCEggNurbsSurfaceA parametric NURBS surface
oCEggObjectThe highest-level base class in the egg directory
oCEggOptcharPerforms basic optimizations of a character model and its associated animations, by analyzing the animation tables and removing unneeded joints and/or morphs
oCEggOptcharUserDataThis class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the maya converter
oCEggPalettizeThis is the program wrapper for egg-palettize, but it mainly serves to read in all the command-line parameters and then invoke the Palettizer
oCEggParametersThe values stored in this structure are global parameters that control some aspects of the egg library
oCEggPatchA single "patch", a special primitive to be rendered only with a tessellation shader
oCEggPointA single point, or a collection of points as defined by a single <PointLight> entry
oCEggPolygonA single polygon
oCEggPolysetMakerA specialization on EggBinMaker for making polysets that share the same basic rendering characteristic
oCEggPoolUniquifierThis is a specialization of EggNameUniquifier to generate unique names for textures, materials, and vertex pools prior to writing out an egg file
oCEggPrimitiveA base class for any of a number of kinds of geometry primitives: polygons, point lights, nurbs patches, parametrics curves, etc
oCEggQtessA program to tesselate NURBS surfaces appearing within an egg file into polygons, using variations on a quick uniform tesselation
oCEggReaderThis is the base class for a program that reads egg files, but doesn't write an egg file
oCEggRenameA program to read an egg file and write an equivalent egg file, with stripping prefix for now, but more along the way
oCEggRenderModeThis 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
oCEggRenderStateThis class is used within this package only to record the render state that should be assigned to each primitive
oCEggRetargetAnimRetargets 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
oCEggSAnimDataCorresponding 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
oCEggSaverConverts the scene graph beginning at the indicated node into an EggData structure, for writing to an egg file
oCEggScalarTablePointerThis stores a pointer back to an EggSAnimData table (i.e
oCEggSingleBaseThis specialization of EggBase is intended for programs that read and/or write a single egg file
oCEggSliderDataThis corresponds to a single morph slider control
oCEggSliderPointerThis is a base class for EggVertexPointer and EggScalarTablePointer
oCEggSurfaceA parametric surface of some kind
oCEggSwitchConditionThis corresponds to a <SwitchCondition> entry within a group
oCEggSwitchConditionDistanceA SwitchCondition that switches the levels-of-detail based on distance from the camera's eyepoint
oCEggTableThis corresponds to a
oCEggTextureDefines a texture map that may be applied to geometry
oCEggTextureCardsGenerates an egg file featuring a number of polygons, one for each named texture
oCEggTextureCollectionThis is a collection of textures by TRef name
oCEggToBam
oCEggToC
oCEggToDAEA program to read an egg file and write a DAE file
oCEggToDXFA program to read an egg file and write a DXF file
oCEggToDXFLayerA single layer in the DXF file to be written by EggToDXF
oCEggToFltA program to read an egg file and write a flt file
oCEggTokenType
oCEggToMayaA program to read an egg file and write a maya file
oCEggToObj
oCEggToObjConverterConvert an obj file to egg data
oCEggTopstripReads a character model and/or animations and strips out the animation from one of the top joints from the entire character
oCEggToSomethingThis is the general base class for a file-converter program that reads some model file format and generates an egg file
oCEggToSomethingConverterThis is a base class for a family of converter classes that manage a conversion from egg format to some other file type
oCEggToXA program to read in a egg file and write an equivalent, or nearly equivalent, DirectX-style "x" file
oCEggTransA program to read an egg file and write an equivalent egg file, possibly performing some minor operations along the way
oCEggTransformThis 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
oCEggTriangleFanA connected fan of triangles
oCEggTriangleStripA connected strip of triangles
oCEggUserDataThis is a base class for a user-defined data type to extend egg structures in processing code
oCEggVertexAny one-, two-, three-, or four-component vertex, possibly with attributes such as a normal
oCEggVertexAuxThe set of named auxiliary data that may or may not be assigned to a vertex
oCEggVertexPointerThis stores a pointer back to a <Vertex>, or to a particular pritimive like a <Polygon>, representing a morph offset
oCEggVertexPoolA collection of vertices
oCEggVertexUVThe set of UV's that may or may not be assigned to a vertex
oCEggWriterThis is the base class for a program that generates an egg file output, but doesn't read any for input
oCEggXfmAnimDataCorresponding to an <Xfm$Anim> entry, this stores a two-dimensional table with up to nine columns, one for each component of a transformation
oCEggXfmSAnimThis 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
oCeglGraphicsBufferAn offscreen buffer in the EGL environment
oCeglGraphicsPipeThis graphics pipe represents the interface for creating OpenGL ES graphics windows on an X-based (e.g
oCeglGraphicsPixmapAnother offscreen buffer in the EGL environment
oCeglGraphicsStateGuardianA tiny specialization on GLESGraphicsStateGuardian to add some egl-specific information
oCeglGraphicsWindowAn interface to the egl system for managing GLES windows under X
oCEvade
oCEventA named event, possibly with parameters
oCEventHandlerA class to monitor events from the C++ side of things
oCEventParameterAn optional parameter associated with an event
oCEventQueueA queue of pending events
oCEventReceiverAn abstract base class for anything that might care about receiving events
oCExecutionEnvironmentEncapsulates access to the environment variables and command-line arguments at the time of execution
oCExtensionThe default class template does not define any methods
oCExtensionBaseThis is where all extensions should derive from
oCExternalThreadThe special "external thread" class
oCExtractorThis class automatically extracts the contents of a Multifile to the current directory (or to a specified directory) in the background
oCFactoryA Factory can be used to create an instance of a particular subclass of some general base class
oCFactoryBaseA Factory can be used to create an instance of a particular subclass of some general base class
oCFactoryParamThe 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
oCFactoryParamsAn instance of this class is passed to the Factory when requesting it to do its business and construct a new something
oCFadeLODNodeA Level-of-Detail node with alpha based switching
oCFadeLODNodeDataThis is the data that is associated with a particular instance of the FadeLODNode for the scene graph
oCfake_istream_buffer
oCFfmpegAudioA stream that generates a sequence of audio samples
oCFfmpegAudioCursorA stream that generates a sequence of audio samples
oCFfmpegVideo
oCFfmpegVideoCursor
oCFfmpegVirtualFileEnables ffmpeg to access panda's VFS
oCFFTCompressorThis 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)
oCFileDef
oCFilenameThe name of a file, such as a texture file or an Egg file
oCFilenameUnifierThis static class does the job of converting filenames from relative to absolute to canonical or whatever is appropriate
oCFileReferenceKeeps a reference-counted pointer to a file on disk
oCFilterPropertiesStores a configuration for a set of audio DSP filters
oCFINALThis describes the structure of a single array within a Geom data
oCFindApproxLevelEntryThis class is local to this package only; it doesn't get exported
oCFindApproxPathThis class is local to this package only; it doesn't get exported
oCFiniteBoundingVolumeA special kind of GeometricBoundingVolume that is known to be finite
oCfirst_of_pair_iteratorThis is an iterator adaptor that converts any iterator that returns a pair (e.g
oCFirstOfPairCompareAn STL function object class, this is intended to be used on any ordered collection of pairs of objects
oCFirstOfPairLessAn STL function object class, this is intended to be used on any ordered collection of pairs of objects
oCFisheyeLensA fisheye lens
oCFisheyeMakerThis 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
oCFlee
oCfloating_point_hashThis hash_compare class hashes a float or a double
oCfloating_point_thresholdCompares two floating point numbers, within threshold of equivalence
oCFlockThis class is used to define the flock attributes and the AI characters which are part of the flock
oCFltBeadA base class for any of a broad family of flt records that represent particular beads in the hierarchy
oCFltBeadIDA base class for any of a broad family of flt beads that include an ID
oCFltCopyA program to copy Multigen .flt files into the cvs tree
oCFltCurveA single curve, like a Bezier or B-Spline
oCFltExternalReferenceAn external reference to another flt file (possibly to a specific bead within the flt file)
oCFltEyepointA single eyepoint entry in the eyepoint/trackplane palette
oCFltFaceA single face bead, e.g
oCFltGeometryThis 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
oCFltGroupThe main grouping bead of the flt file
oCFltHeaderThis is the first bead in the file, the top of the bead hierarchy, and the primary interface to reading and writing a Flt file
oCFltInfoA program to read a flt file and report interesting things about it
oCFltInstanceDefinitionThis special kind of record marks the top node of an instance subtree
oCFltInstanceRefThis bead appears in the hierarchy to refer to a FltInstanceDefinition node defined elsewhere
oCFltLightSourceDefinitionRepresents a single entry in the light source palette
oCFltLocalVertexPoolA local vertex pool, as might appear in the middle of the hierarchy, for instance for a mesh
oCFltLODA Level-of-Detail record
oCFltMaterialRepresents a single material in the material palette
oCFltMeshA mesh of connected polygons and tristrips, etc., with a local vertex pool
oCFltMeshPrimitiveA single primitive of a mesh, like a triangle strip or fan
oCFltObjectThe main objecting bead of the flt file
oCFltPackedColorA packed color record, A, B, G, R
oCFltRecordThe base class for all kinds of records in a MultiGen OpenFlight file
oCFltRecordReaderThis class turns an istream into a sequence of FltRecords by reading a sequence of Datagrams and extracting the opcode from each one
oCFltRecordWriterThis class writes a sequence of FltRecords to an ostream, handling opcode and size counts properly
oCFltTextureRepresents a single texture in the texture palette
oCFltToEggA program to read a flt file and generate an egg file
oCFltToEggConverterThis class supervises the construction of an EggData structure from the data represented by the FltHeader
oCFltToEggLevelStateThis keeps track of relevant things about the traversal as we walk through the flt hierarchy
oCFltTrackplaneA single trackplane entry in the eyepoint/trackplane palette
oCFltTransA program to read a flt file and write an equivalent flt file, possibly performing some minor operations along the way
oCFltTransformGeneralMatrixA general 4x4 matrix
oCFltTransformPutA "put", which is a MultiGen concept of defining a transformation by mapping three arbitrary points to three new arbitrary points
oCFltTransformRecordA base class for a number of types of ancillary records that follow beads and indicate some kind of a transformation
oCFltTransformRotateAboutEdgeA transformation that rotates about a particular axis in space, defined by two endpoints
oCFltTransformRotateAboutPointA transformation that rotates about a particular axis in space, defined by a point and vector
oCFltTransformRotateScaleA combination rotation and scale
oCFltTransformScaleA transformation that applies a (possibly nonuniform) scale
oCFltTransformTranslateA transformation that applies a translation
oCFltUnsupportedRecord
oCFltVectorRecordThis is an ancillary record of the old (pre-15.4) face node
oCFltVertexRepresents a single vertex in the vertex palette
oCFltVertexListA list of vertices, typically added as a child of a face bead
oCFmodAudioManager
oCFmodAudioSound
oCFogSpecifies how atmospheric fog effects are applied to geometry
oCFogAttribApplies a Fog to the geometry at and below this node
oCFontPoolThis is the preferred interface for loading fonts for the TextNode system
oCForceNodeA force that lives in the scene graph and is therefore subject to local coordinate systems
oCFrameBufferPropertiesA container for the various kinds of properties we might ask to have on a graphics frameBuffer before we create a GSG
oCFrameRateMeterThis is a special TextNode that automatically updates itself with the current frame rate
oCFrameSampleThis class is used within this module only–in fact, within PStatView::set_to_frame() only–to help collect event data out of the PStatFrameData object and boil it down to a list of elapsed times
oCGenericAsyncTaskAssociates a generic C-style function pointer with an AsyncTask object
oCGenericThreadA generic thread type that allows calling a C-style thread function without having to subclass
oCGeomA container for geometry primitives
oCGeomCacheEntryThis object contains a single cache entry in the GeomCacheManager
oCGeomCacheManagerThis 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
oCGeomContextThis is a special class object that holds all the information returned by a particular GSG to indicate the geom's internal context identifier
oCGeomDrawCallbackDataThis specialization on CallbackData is passed when the callback is initiated from deep within the draw traversal, for a particular Geom
oCGeomEnumsThis class exists just to provide scoping for the various enumerated types used by Geom, GeomVertexData, GeomVertexArrayData, GeomPrimitive, and other related classes
oCGeometricBoundingVolumeThis 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
oCGeoMipTerrainGeoMipTerrain, meaning Panda3D GeoMipMapping, can convert a heightfield image into a 3D terrain, consisting of several GeomNodes
oCGeomLinesDefines a series of disconnected line segments
oCGeomLinestripsDefines a series of line strips
oCGeomMungerObjects of this class are used to convert vertex data from a Geom into a format suitable for passing to the rendering backend
oCGeomNodeA node that holds Geom objects, renderable pieces of geometry
oCGeomParticleRenderer
oCGeomPatchesDefines a series of "patches", fixed-size groupings of vertices that must be processed by a tessellation shader
oCGeomPipelineReaderEncapsulates the data from a Geom, pre-fetched for one stage of the pipeline
oCGeomPointsDefines a series of disconnected points
oCGeomPrimitiveThis is an abstract base class for a family of classes that represent the fundamental geometry primitives that may be stored in a Geom
oCGeomPrimitivePipelineReaderEncapsulates the data from a GeomPrimitive, pre-fetched for one stage of the pipeline
oCGeomTransformerAn 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
oCGeomTrianglesDefines a series of disconnected triangles
oCGeomTrifansDefines a series of triangle fans
oCGeomTristripsDefines a series of triangle strips
oCGeomVertexAnimationSpecThis object describes how the vertex animation, if any, represented in a GeomVertexData is encoded
oCGeomVertexArrayDataThis is the data for one array of a GeomVertexData structure
oCGeomVertexArrayDataHandleThis data object is returned by GeomVertexArrayData::get_handle() or modify_handle()
oCGeomVertexColumnThis defines how a single column is interleaved within a vertex array stored within a Geom
oCGeomVertexDataThis defines the actual numeric vertex data stored in a Geom, in the structure defined by a particular GeomVertexFormat object
oCGeomVertexDataPipelineBaseThe common code from GeomVertexDataPipelineReader and GeomVertexDataPipelineWriter
oCGeomVertexDataPipelineReaderEncapsulates the data from a GeomVertexData, pre-fetched for one stage of the pipeline
oCGeomVertexDataPipelineWriterEncapsulates the data from a GeomVertexData, pre-fetched for one stage of the pipeline
oCGeomVertexReaderThis object provides a high-level interface for quickly reading a sequence of numeric values from a vertex table
oCGeomVertexRewriterThis object provides the functionality of both a GeomVertexReader and a GeomVertexWriter, combined together into one convenient package
oCGeomVertexWriterThis object provides a high-level interface for quickly writing a sequence of numeric values from a vertex table
oCGLContext
oCGLLight
oCGLList
oCGLMaterial
oCGlobalPointerRegistryThis class maintains a one-to-one mapping from TypeHandle to a void * pointer
oCGlobPatternThis class can be used to test for string matches against standard Unix-shell filename globbing conventions
oCGLParam
oCGLParamBuffer
oCGLScissor
oCGLSpecBuf
oCGLTexture
oCGLVertex
oCGLViewport
oCglxGraphicsBufferAn offscreen buffer in the GLX environment
oCglxGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on an X-based (e.g
oCglxGraphicsPixmapAnother offscreen buffer in the GLX environment
oCglxGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some glx-specific information
oCglxGraphicsWindowAn interface to the glx system for managing GL windows under X
oCGLXHyperpipeConfigSGIX
oCGLXHyperpipeNetworkSGIX
oCGLXPipeRect
oCGLXPipeRectLimits
oCGLXStereoNotifyEventEXT
oCGraphicsBufferAn offscreen buffer for rendering into
oCGraphicsDeviceAn abstract device object that is part of Graphics Pipe
oCGraphicsEngineThis class is the main interface to controlling the render process
oCGraphicsOutputThis is a base class for the various different classes that represent the result of a frame of rendering
oCGraphicsOutputBaseAn abstract base class for GraphicsOutput, for all the usual reasons
oCGraphicsPipeAn object to create GraphicsOutputs that share a particular 3-D API
oCGraphicsPipeSelectionThis maintains a list of GraphicsPipes by type that are available for creation
oCGraphicsStateGuardianEncapsulates all the communication with a particular instance of a given rendering backend
oCGraphicsStateGuardianBaseThis is a base class for the GraphicsStateGuardian class, which is itself a base class for the various GSG's for different platforms
oCGraphicsThreadingModelThis represents the user's specification of how a particular frame is handled by the various threads
oCGraphicsWindowA window, fullscreen or on a desktop, into which a graphics device sends its output for interactive display
oCGraphicsWindowInputDeviceThis is a structure representing a single input device that may be associated with a window
oCGraphicsWindowProcDefines an interface for storing platform-specific window processor methods
oCGraphicsWindowProcCallbackDataThis specialization on CallbackData is passed when the callback is initiated from from an implementation of the GraphicsWindowProc class, such as PythonGraphicsWindowProc
oCgridded_file_info
oCGriddedFilename
oCGroupRefEntryA temporary class used in EggVertex::write(), below, to hold the groups that reference each vertex prior to outputting them as a formatted list
oCGtkStatsChartMenuA pulldown menu of charts available for a particular thread
oCGtkStatsGraphThis is just an abstract base class to provide a common pointer type for the various kinds of graphs that may be created for a GtkStatsMonitor
oCGtkStatsLabelA text label that will draw in color appropriate for a particular collector
oCGtkStatsLabelStackA widget that contains a stack of labels from bottom to top
oCGtkStatsMonitorThis class represents a connection to a PStatsClient and manages the data exchange with the client
oCGtkStatsPianoRollA window that draws a piano-roll style chart, which shows the collectors explicitly stopping and starting, one frame at a time
oCGtkStatsServerThe class that owns the main loop, waiting for client connections
oCGtkStatsStripChartA window that draws a strip chart, given a view
oCHashGeneratorThis class generates an arbitrary hash number from a sequence of ints
oCHashGeneratorBaseThis is the base class for a number of classes that generate arbitrary hash numbers for complex objects, based fundamentally on a sequence of integers
oCHashValStores a 128-bit value that represents the hashed contents (typically MD5) of a file or buffer
oCHeader
oCHeightfieldTesselatorConverts a height field in the form of a greyscale image into a scene consisting of a number of GeomNodes
oCHermiteCurveA parametric curve defined by a sequence of control vertices, each with an in and out tangent
oCHermiteCurveCVA single CV of a Hermite curve
oCHideIntervalAn interval that calls NodePath::hide()
oCHttp_BufferedReader
oCHttp_Request
oCHttpConnection
oCHTTPDateA container for an HTTP-legal time/date indication
oCHTTPEntityTagA container for an "entity tag" from an HTTP server
oCIffChunkThe basic kind of record in an EA "IFF" file, which the LightWave object file is based on
oCIffGenericChunkA class for a generic kind of IffChunk that is not understood by a particular IffReader
oCIffIdA four-byte chunk ID appearing in an "IFF" file
oCIffInputFileA wrapper around an istream used for reading an IFF file
oCImageBaseThis specialization of ProgramBase is intended for programs that read and/or write a single image file
oCImageFileThis is the base class of both TextureImage and PaletteImage
oCImageFilterThis is the base class for a program that reads an image file, operates on it, and writes another image file out
oCImageFixHiddenColorThis program repairs an image's RGB values hidden behind an A value of 0
oCImageInfoThis program reads the headers of a series of one or more images and reports their sizes to standard output
oCImageReaderThis is the base class for a program that reads an image file, but doesn't write an image file
oCImageResizeA program to read an image file and resize it to a larger or smaller image file
oCImageTransA program to read an image file and write an equivalent image file, possibly performing some minor operations along the way
oCImageTransformColorsThis program can apply a 4x4 color transform to all of the colors in the pixels of a series of images
oCImageWriterThis is the base class for a program that generates an image file output, but doesn't read any for input
oCIndexBufferContextThis 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
oCIndexedFaceSetDecodes the vertices and faces in a VRML indexed face set, and creates the corresponding egg geometry
oCIndexRemapperThis class manages a mapping of integers to integers
oCindirect_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
oCindirect_compare_names_hash
oCindirect_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
oCindirect_compare_to_hash
oCindirect_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
oCindirect_lessAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator <() method
oCindirect_less_hash
oCindirect_method_hashThis hash_compare class hashes a pointer to a class object
oCIndirectCompareNamesAn 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
oCIndirectCompareSortAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that define a get_sort() method
oCIndirectCompareToAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain a compare_to() method
oCIndirectLessAn STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator <() method
oCInitDtoolutil
oCInitMemoryHook
oCInkblotVideoA cellular automaton that generates an amusing pattern of swirling colors
oCInkblotVideoCursorA cellular automaton that generates an amusing pattern of swirling colors
oCinteger_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)
oCInternalNameCollection
oCInterrogateComponentThe base class for things that are part of the interrogate database
oCInterrogateDatabaseThis stores all of the interrogate data and handles reading the data from a disk file when necessary
oCInterrogateElementAn internal representation of a data element, like a data member or a global variable
oCInterrogateFunctionAn internal representation of a function
oCInterrogateFunctionWrapperAn internal representation of a callable function
oCInterrogateMakeSeqRepresents a synthetic method created via the MAKE_SEQ() macro
oCInterrogateManifestAn internal representation of a manifest constant
oCInterrogateModuleDef
oCInterrogateTypeAn internal representation of a type
oCInterrogateUniqueNameDef
oCIntersectionBoundingVolumeThis special bounding volume is the intersection of all of its constituent bounding volumes
oCIoPtaDatagramFloatThis class is used to read and write a PTA_stdfloat from a Datagram, in support of Bam
oCIoPtaDatagramIntThis class is used to read and write a PTA_int from a Datagram, in support of Bam
oCIoPtaDatagramShortThis class is used to read and write a PTA_ushort from a Datagram, in support of Bam
oCIPhoneGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on the various IPHONE's
oCIPhoneGraphicsStateGuardian
oCIPhoneGraphicsWindowAn interface to the osx/ system for managing GL windows under X
oCIPipeStream
oCIsLocalVertexSplitter
oCIsoPlacerContains the logic used to place isoparams where they'll do the most good on a surface
oCIStreamWrapperThis class provides a locking wrapper around an arbitrary istream pointer
oCistringstream
oCISubStreamAn istream object that presents a subwindow into another istream
oCJointVertexTransformThis is a specialization on VertexTransform that returns the transform necessary to move vertices as if they were assigned to the indicated joint
oCKeyboardButtonThis class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard keyboard keys
oCKeyNumber
oCLensA base class for any number of different kinds of lenses, linear and otherwise
oCLensNodeA node that contains a Lens
oCLerpBlendType
oCLightThe abstract interface to all kinds of lights
oCLightAttribIndicates which set of lights should be considered "on" to illuminate geometry at this level and below
oCLightLensNodeA derivative of Light and of Camera
oCLightMutexThis is a standard, non-reentrant mutex, similar to the Mutex class
oCLightMutexDirectThis class implements a lightweight Mutex by making direct calls to the underlying implementation layer
oCLightMutexHolderSimilar to MutexHolder, but for a light mutex
oCLightNodeA derivative of Light and of PandaNode
oCLightRampAttribA Light Ramp is any unary operator that takes a rendered pixel as input, and adjusts the brightness of that pixel
oCLightReMutexA lightweight reentrant mutex
oCLightReMutexDirectThis class implements a standard lightReMutex by making direct calls to the underlying implementation layer
oCLightReMutexHolderSimilar to MutexHolder, but for a light reentrant mutex
oCLinearControlForceSimple directed vector force
oCLinearCylinderVortexForceDefines a cylinder inside of which all forces are tangential to the theta of the particle wrt the z-axis in local coord
oCLinearDistanceForcePure virtual class for sinks and sources
oCLinearEulerIntegratorPerforms Euler integration on a vector of physically modelable objects given a quantum dt
oCLinearForceA force that acts on a PhysicsObject by way of an Integrator
oCLinearFrictionForceFriction-based drag force
oCLinearIntegratorPure virtual base class for physical modeling
oCLinearJitterForceCompletely random noise force vector
oCLinearNoiseForceRepeating noise force vector
oCLinearRandomForcePure virtual, parent to noiseForce and jitterForce
oCLinearSinkForceAttractor force
oCLinearSourceForceRepellant force
oCLinearUserDefinedForceProgrammable force that takes an evaluator fn
oCLinearVectorForceSimple directed vector force
oCLineEmitterDescribes a linear region in which particles are generated
oCLineParticleRendererRenders a line from last position to current position – good for rain, sparks, etc
oCLineSegsEncapsulates creation of a series of connected or disconnected line segments or points, for drawing paths or rays
oCLineStreamThis is a special ostream that writes to a memory buffer, like ostrstream
oCLineStreamBufUsed 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
oCLinkedListNodeThis just stores the pointers to implement a doubly-linked list of some kind of object
oCLMatrix3dThis is a 3-by-3 transform matrix
oCLMatrix3fThis is a 3-by-3 transform matrix
oCLMatrix4dThis is a 4-by-4 transform matrix
oCLMatrix4fThis is a 4-by-4 transform matrix
oCLoaderA 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)
oCLoaderFileTypeThis is the base class for a family of scene-graph file types that the Loader supports
oCLoaderFileTypeAssimpThis defines the Loader interface that uses the Assimp library to load various model formats
oCLoaderFileTypeBamThis defines the Loader interface to read Bam files
oCLoaderFileTypeDaeThis defines the Loader interface to read Dae files
oCLoaderFileTypeEggThis defines the Loader interface to read Egg files
oCLoaderFileTypePandatoolThis defines the Loader interface to files whose converters are defined within the Pandatool package and inherit from SomethingToEggConverter, like FltToEggConverter and LwoToEggConverter
oCLoaderFileTypeRegistryThis class maintains the set of all known LoaderFileTypes in the universe
oCLoaderFileTypeSrtThis defines the Loader interface to read SpeedTree SRT files, which describe a single tree
oCLoaderFileTypeStfThis defines the Loader interface to read SpeedTree STF files–a simple text file that describes a forest of trees (references to SRT files)
oCLoaderOptionsSpecifies parameters that may be passed to the loader
oCLODInstance
oCLODNodeA Level-of-Detail node
oCLONG_INTEGER
oCLOrientationdThis is a unit quaternion representing an orientation
oCLOrientationfThis is a unit quaternion representing an orientation
oCLPoint2dThis is a two-component point in space
oCLPoint2fThis is a two-component point in space
oCLPoint2iThis is a two-component point in space
oCLPoint3dThis is a three-component point in space (as opposed to a three-component vector, which represents a direction and a distance)
oCLPoint3fThis is a three-component point in space (as opposed to a three-component vector, which represents a direction and a distance)
oCLPoint3iThis is a three-component point in space (as opposed to a three-component vector, which represents a direction and a distance)
oCLPoint4dThis is a four-component point in space
oCLPoint4fThis is a four-component point in space
oCLPoint4iThis is a four-component point in space
oCLQuaterniondThis is the base quaternion class
oCLQuaternionfThis is the base quaternion class
oCLRotationdThis is a unit quaternion representing a rotation
oCLRotationfThis is a unit quaternion representing a rotation
oCLSimpleMatrixThis class provides an underlying storage of the various linear-algebra classes (e.g
oCLVecBase2dThis is the base class for all two-component vectors and points
oCLVecBase2fThis is the base class for all two-component vectors and points
oCLVecBase2iThis is the base class for all two-component vectors and points
oCLVecBase3dThis is the base class for all three-component vectors and points
oCLVecBase3fThis is the base class for all three-component vectors and points
oCLVecBase3iThis is the base class for all three-component vectors and points
oCLVecBase4dThis is the base class for all three-component vectors and points
oCLVecBase4fThis is the base class for all three-component vectors and points
oCLVecBase4iThis is the base class for all three-component vectors and points
oCLVector2dThis is a two-component vector offset
oCLVector2fThis is a two-component vector offset
oCLVector2iThis is a two-component vector offset
oCLVector3dThis is a three-component vector distance (as opposed to a three-component point, which represents a particular point in space)
oCLVector3fThis is a three-component vector distance (as opposed to a three-component point, which represents a particular point in space)
oCLVector3iThis is a three-component vector distance (as opposed to a three-component point, which represents a particular point in space)
oCLVector4dThis is a four-component vector distance
oCLVector4fThis is a four-component vector distance
oCLVector4iThis is a four-component vector distance
oCLwoBoundingBoxStores the bounding box for the vertex data in a layer
oCLwoChunkA specialization of IffChunk for Lightwave Object files
oCLwoClipA single image file, or a numbered sequence of images (e.g
oCLwoDiscontinuousVertexMapA mapping of floating-point values per integer index
oCLwoGroupChunkA particular kind of LwoChunk that is expected to contain an arbitrary number of child chunks
oCLwoHeaderThe first chunk in a Lightwave Object file
oCLwoInputFileA specialization of IffInputFile to handle reading a Lightwave Object file
oCLwoLayerSignals the start of a new layer
oCLwoPointsAn array of points that will be referenced by later chunks
oCLwoPolygonsAn array of polygons that will be referenced by later chunks
oCLwoPolygonTagsAn association of polygons defined in the most recent LwoPolygons chunk to tag ids defined in the most recent LwoTags chunk
oCLwoScanA program to read a Lightwave file and report its structure and contents
oCLwoStillImageA single still image associated with a LwoClip chunk
oCLwoSurfaceDescribes the shading attributes of a surface
oCLwoSurfaceBlockA texture layer or shader, part of a LwoSurface chunk
oCLwoSurfaceBlockAxisIndicates the axis for this particular shader's projection
oCLwoSurfaceBlockChannelIndicates which channel the texture in this LwoSurfaceBlock is applied to
oCLwoSurfaceBlockCoordSysSpecifies whether texture coordinates are computed based on the vertices' world coordinates or local coordinates
oCLwoSurfaceBlockEnabledIndicates whether this particular layer or shader should be rendered or not
oCLwoSurfaceBlockHeaderThe header chunk within a LwoSurfaceBlock chunk
oCLwoSurfaceBlockImageSpecifies the particular image that is being applied as a texture
oCLwoSurfaceBlockOpacityIndicates how transparent or opaque this particular layer is in relation to the layers beneath it
oCLwoSurfaceBlockProjectionIndicates the projection mode for this particular shader
oCLwoSurfaceBlockRefObjSpecifies a reference object that the texture UV's are to be computed relative to
oCLwoSurfaceBlockRepeatFor cylindrical and spherical projections, this parameter controls how many times the image repeats over each full interval, in either dimension
oCLwoSurfaceBlockTMapThe tMap chunk within a LwoSurfaceBlock chunk
oCLwoSurfaceBlockTransformSpecifies a center point, scale, or rotation for the texture coordinates in this shader's texture mapping
oCLwoSurfaceBlockVMapNameSpecifies the name of a set of UV's defined on the polygons that use this model
oCLwoSurfaceBlockWrapSpecifies how the texture image appears for areas outside the image
oCLwoSurfaceColorRecords the base color of a surface, as an entry within a LwoSurface chunk
oCLwoSurfaceParameterRecords some parameter value of a surface material, as an entry within a LwoSurface chunk
oCLwoSurfaceSidednessRecords whether polygons are frontfacing only or backfacing also
oCLwoSurfaceSmoothingAngleIndicates the maximum angle (in radians) between adjacent polygons that should be smooth-shaded
oCLwoTagsAn array of tag strings that will be referenced by later chunks
oCLwoToEggA program to read a Lightwave file and generate an egg file
oCLwoToEggConverterThis class supervises the construction of an EggData structure from the data represented by the LwoHeader
oCLwoVertexMapA mapping of floating-point values per integer index
oCM3
oCM34
oCM4
oCMainThreadThe special "main thread" class
oCmallinfo
oCMaterialDefines the way an object appears in the presence of lighting
oCMaterialAttribIndicates which, if any, material should be applied to geometry
oCMaterialCollection
oCMaterialPoolThe 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
oCMathNumbers
oCMatrixLensA completely generic linear lens
oCMaxEggImporter
oCMaxEggImporterClassDesc
oCMaxEggJoint
oCMaxEggLoader
oCMaxEggMesh
oCMaxEggOptions
oCMaxEggPlugin
oCMaxEggPluginClassDesc
oCMaxEggPluginCreateMouseCallBack
oCMaxEggTex
oCMaxEggVertex
oCMaxNodeDescDescribes a single instance of a node in the Max scene graph, relating it to the corresponding egg structures (e.g
oCMaxNodeTreeDescribes a complete tree of max nodes for conversion
oCMaxOptionsDialog
oCMaxToEggConverterThis class supervises the construction of an EggData structure from a Max model
oCMayaAnim
oCMayaApiThis class presents a wrapper around the global Maya interface
oCMayaBlendDescA handle to a Maya blend shape description
oCMayaCopyA program to copy Maya .mb files into the cvs tree
oCMayaEggGeom
oCMayaEggGroup
oCMayaEggGroupUserDataThis class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the maya converter
oCMayaEggImporter
oCMayaEggJoint
oCMayaEggLoader
oCMayaEggMesh
oCMayaEggNurbsSurface
oCMayaEggTex
oCMayaEggVertex
oCMayaNodeDescDescribes a single instance of a node in the Maya scene graph, relating it to the corresponding egg structures (e.g
oCMayaNodeTreeDescribes a complete tree of maya nodes for conversion
oCMayaPviewThis class serves as a plug-in to Maya to allow viewing the current Maya selection as it will be converted to Panda
oCMayaSavePviewThis 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
oCMayaShaderCorresponds to a single "shader" in Maya
oCMayaShaderColorDefThis defines the various attributes that Maya may associate with the "color" channel for a particular shader (as well as on the "transparency" channel)
oCMayaShadersCollects the set of MayaShaders that have been encountered so far
oCMayaToEgg
oCMayaToEggClient
oCMayaToEggConverterThis class supervises the construction of an EggData structure from a single Maya file, or from the data already in the global Maya model space
oCMayaToEggServer
oCMayaVerInfo
oCMemBufferThis a base class designed to be used to for items that will share portions of a memorty buufer and want to avoid copying the data
oCMemoryBaseThis 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
oCMemoryHookThis class provides a wrapper around the various possible malloc schemes Panda might employ
oCMersenne
oCMeshDrawerMesh drawer creates a single geom object that can be shaped with different draw commands
oCMeshDrawer2DThis class allows the drawing of 2d objects - mainly based on quads and rectangles
oCmethod_hashThis hash_compare class hashes a class object
oCMEV_Compare
oCMicrophoneAudioClass MicrophoneAudio provides the means to read raw audio samples from a microphone
oCModelFlattenRequestThis class object manages a single asynchronous request to flatten a model
oCModelLoadRequestA class object that manages a single asynchronous model load request
oCModelNodeThis 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
oCModelPoolThis class unifies all references to the same filename, so that multiple attempts to load the same model will return the same pointer
oCModelRootA node of this type is created automatically at the root of each model file that is loaded
oCModelSaveRequestA class object that manages a single asynchronous model save request
oCModifierButtonsThis class monitors the state of a number of individual buttons and tracks whether each button is known to be down or up
oCMouseAndKeyboardReads the mouse and/or keyboard data sent from a GraphicsWindow, and transmits it down the data graph
oCMouseButtonThis class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard mouse buttons
oCMouseDataHolds the data that might be generated by a 2-d pointer input device, such as the mouse in the GraphicsWindow
oCMouseInterfaceNodeThis is the base class for some classes that monitor the mouse and keyboard input and perform some action due to their state
oCMouseRecorderThis 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)
oCMouseSubregionThe MouseSubregion object scales the mouse inputs from within a rectangular region of the screen, as if they were the full-screen inputs
oCMouseWatcherThis TFormer maintains a list of rectangular regions on the screen that are considered special mouse regions; typically these will be click buttons
oCMouseWatcherBaseThis represents a collection of MouseWatcherRegions that may be managed as a group
oCMouseWatcherGroupThis represents a collection of MouseWatcherRegions that may be managed as a group
oCMouseWatcherParameterThis is sent along as a parameter to most events generated for a region to indicate the mouse and button state for the event
oCMouseWatcherRegionThis is the class that defines a rectangular region on the screen for the MouseWatcher
oCMovieAudioA MovieAudio is actually any source that provides a sequence of audio samples
oCMovieAudioCursorA MovieAudio is actually any source that provides a sequence of audio samples
oCMovieTypeRegistryThis class records the different types of MovieAudio and MovieVideo that are available for loading
oCMovieVideoA MovieVideo is actually any source that provides a sequence of video frames
oCMovieVideoCursorA MovieVideo is actually any source that provides a sequence of video frames
oCMovingPartThis is the template instantiation of MovingPartBase, on the particular type of value provided by the channel
oCMovingPartBaseThis is the base class for a single animatable piece that may be bound to one channel (or more, if blending is in effect)
oCMovingPartMatrixThis is a particular kind of MovingPart that accepts a matrix each frame
oCMovingPartScalarThis is a particular kind of MovingPart that accepts a scalar each frame
oCMultifileA file that contains a set of files
oCMultiplexStreamThis 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
oCMultiplexStreamBufUsed by MultiplexStream to implement an ostream that sends what is written to it to any number of additional sources, like other ostreams
oCMultitexReducerThis 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
oCMutexA standard mutex, or mutual exclusion lock
oCMutexDirectThis class implements a standard mutex by making direct calls to the underlying implementation layer
oCMutexDummyImplA fake mutex implementation for single-threaded applications that don't need any synchronization control
oCMutexHolderA lightweight C++ object whose constructor calls acquire() and whose destructor calls release() on a mutex
oCNamableA base class for all things which can have a name
oCNamableOrderByNameAn STL function object for sorting an array of pointers to Namables into order by name
oCNameUniquifierA handy class for converting a list of arbitrary names (strings) so that each name is guaranteed to be unique in the list
oCNativeNumericDataNativeNumericData 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
oCNativeWindowHandleThis subclass of WindowHandle exists to allow simple creation of a WindowHandle of the appropriate type to the current OS
oCNetAddressRepresents a network address to which UDP packets may be sent or to which a TCP socket may be bound
oCNetDatagramA specific kind of Datagram, especially for sending across or receiving from a network
oCNeverFreeMemoryThis class is used to allocate bytes of memory from a pool that is never intended to be freed
oCNoBlendType
oCNodeThis class is used to assign the nodes on the mesh
oCNodeCachedReferenceCountThis 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
oCNodeConstPointerToA NodeConstPointerTo is similar to a NodePointerTo, except it keeps a const pointer to the thing
oCNodeCullCallbackDataThis kind of CallbackData is passed to the CallbackObject added to CallbackNode:set_cull_callback()
oCNodePathNodePath is the fundamental system for disambiguating instances, and also provides a higher-level interface for manipulating the scene graph
oCNodePathCollectionThis is a set of zero or more NodePaths
oCNodePathComponentThis is one component of a NodePath
oCNodePointerToThis 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
oCNodePointerToBaseThis 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
oCNodeRefCountObjThis works like RefCountObj, but it inherits from NodeReferenceCount instead of ReferenceCount
oCNodeReferenceCountThis 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
oCNodeVertexTransformThis VertexTransform gets its matrix from the Transform stored on a node
oCNonlinearImagerThis class object combines the rendered output of a 3-d from one or more linear (e.g
oCNotifyAn object that handles general error reporting to the user
oCNotifyCategoryA particular category of error messages
oCNotifyCategoryGetCategory_prc
oCNotifyCategoryProxyA handy wrapper around a NotifyCategory pointer
oCNullAudioManager
oCNullAudioSound
oCNurbsBasisVectorThis encapsulates a series of matrices that are used to represent the sequential segments of a NurbsCurveEvaluator
oCNurbsCurveA Nonuniform Rational B-Spline
oCNurbsCurveEvaluatorThis class is an abstraction for evaluating NURBS curves
oCNurbsCurveInterfaceThis abstract class defines the interface only for a Nurbs-style curve, with knots and coordinates in homogeneous space
oCNurbsCurveResultThe result of a NurbsCurveEvaluator
oCNurbsSurfaceEvaluatorThis class is an abstraction for evaluating NURBS surfaces
oCNurbsSurfaceResultThe result of a NurbsSurfaceEvaluator
oCNurbsVertexThis represents a single control vertex in a NurbsEvaluator
oCObjToEggA program to read a Obj file and generate an egg file
oCObjToEggConverterConvert an Obj file to egg data
oCObstacleAvoidance
oCOccluderEffectThis functions similarly to a LightAttrib or ClipPlaneAttrib
oCOccluderNodeA node in the scene graph that can hold an occluder polygon, which must be a rectangle
oCOcclusionQueryContextReturned from a GSG in response to begin_occlusion_query()
oCOdeAMotorJoint
oCOdeBallJoint
oCOdeBody
oCOdeBoxGeom
oCOdeCappedCylinderGeom
oCOdeCollisionEntryA class used to hold information about a collision that has occurred
oCOdeContact
oCOdeContactGeom
oCOdeContactJoint
oCOdeConvexGeom
oCOdeCylinderGeom
oCOdeFixedJoint
oCOdeGeom
oCOdeHashSpace
oCOdeHeightfieldGeom
oCOdeHinge2Joint
oCOdeHingeJoint
oCOdeJoint
oCOdeJointCollection
oCOdeJointFeedback
oCOdeJointGroup
oCOdeLMotorJoint
oCOdeMass
oCOdeNullJoint
oCOdePlane2dJoint
oCOdePlaneGeom
oCOdeQuadTreeSpace
oCOdeRayGeom
oCOdeSimpleSpace
oCOdeSliderJoint
oCOdeSpace
oCOdeSphereGeom
oCOdeSurfaceParameters
oCOdeTriMeshData
oCOdeTriMeshGeom
oCOdeUniversalJoint
oCOdeUtil
oCOdeWorld
oCOmniBoundingVolumeThis is a special kind of GeometricBoundingVolume that fills all of space
oCOpenALAudioManager
oCOpenALAudioSound
oCOPipeStream
oCoption
oCordered_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
oCOrderJointsByNewDepth
oCOrientedParticleDescribes a particle that has angular characteristics (velocity, orientation)
oCOrientedParticleFactoryCreates particles that are affected by angular forces
oCOrthographicLensAn orthographic lens
oCOSphereLensA OSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
oCOStreamWrapperThis class provides a locking wrapper around an arbitrary ostream pointer
oCostringstream
oCOSubStreamAn ostream object that presents a subwindow into another ostream
oCosxGraphicsBufferAn offscreen buffer in the OSX environment
oCosxGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on the various OSX's
oCosxGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some wgl-specific information
oCosxGraphicsWindowAn interface to the osx/ system for managing GL windows under X
oCov_multisetA specialization of ordered_vector that emulates a standard STL set: many copies of each element are allowed
oCov_setA specialization of ordered_vector that emulates a standard STL set: one copy of each element is allowed
oCPaletteGroupThis is the highest level of grouping for TextureImages
oCPaletteGroupsA set of PaletteGroups
oCPaletteImageThis is a single palette image, one of several within a PalettePage, which is in turn one of several pages within a PaletteGroup
oCPalettePageThis is a particular collection of textures, within a PaletteGroup, that all share the same TextureProperties
oCPalettizerThis is the main engine behind egg-palettize
oCpallocator_array
oCpallocator_singleThis is our own Panda specialization on the default STL allocator
oCPandaFrameworkThis 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.)
oCPandaGetoptThe implementation within this file of the various getopt() functions
oCPandaIOStreamCustom implementation of Assimp::IOStream
oCPandaIOSystemCustom implementation of Assimp::IOSystem
oCPandaLoggerCustom implementation of Assimp::Logger
oCPandaNodeA basic node of the scene graph or data graph
oCPandaNodeChainThis class maintains a linked list of PandaNodes
oCPandaNodePipelineReaderEncapsulates the data from a PandaNode, pre-fetched for one stage of the pipeline
oCPandaSystemThis class is used as a namespace to group several global properties of Panda
oCParametricCurveA virtual base class for parametric curves
oCParametricCurveCollectionThis is a set of zero or more ParametricCurves, which may or may not be related
oCParamNodePathA class object for storing a NodePath as a parameter
oCParamTextureImageA 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
oCParamTextureSamplerA class object for storing a pointer to a Texture along with a sampler state that indicates how to to sample the given texture
oCParamTypedRefCountA class object for storing specifically objects of type TypedReferenceCount, which is different than TypedWritableReferenceCount
oCParamValueA handy class object for storing simple values (like integers or strings) passed along with an Event or to be used as a shader input
oCParamValueBaseA non-template base class of ParamValue (below), which serves mainly to define the placeholder for the virtual output function
oCParasiteBufferThis 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
oCParsedHttpRequest
oCPartBundleThis is the root of a MovingPart hierarchy
oCPartBundleHandleThis is a trivial class returned by PartBundleNode::get_bundle()
oCPartBundleNodeThis is a node that contains a pointer to an PartBundle
oCPartGroupThis is the base class for PartRoot and MovingPart
oCPartGroupAlphabeticalOrder
oCParticleSystemContains and manages a particle system
oCParticleSystemManagerManages 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
oCPartSubsetThis class is used to define a subset of part names to apply to the PartBundle::bind_anim() operation
oCPathFindThis class contains all the members and functions that are required to form an interface between the AIBehaviors class and the PathFinder class
oCPathFinderThis class implements pathfinding using A* algorithm
oCPathFollow
oCPathReplaceThis encapsulates the user's command-line request to replace existing, incorrect pathnames to models and textures from a file with correct pathnames
oCpdequeThis is our own Panda specialization on the default STL deque
oCPerlinNoiseThis is the base class for PerlinNoise2 and PerlinNoise3, different dimensions of Perlin noise implementation
oCPerlinNoise2This class provides an implementation of Perlin noise for 2 variables
oCPerlinNoise3This class provides an implementation of Perlin noise for 3 variables
oCPerspectiveLensA perspective-type lens: a normal camera
oCPfmBbaGenerates a bounding-box description of a pfm file
oCPfmFileDefines 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
oCPfmTransOperates on a pfm file
oCPfmVizzerThis class aids in the visualization and manipulation of PfmFile objects
oCPGButtonThis is a particular kind of PGItem that is specialized to behave like a normal button object
oCPGButtonNotifyObjects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
oCPGCullTraverserThis is a specialization of CullTraverser for use within the pgui system
oCPGEntryThis 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
oCPGFrameStyle
oCPGItemThis is the base class for all the various kinds of gui widget objects
oCPGItemNotifyObjects that inherit from this class can receive specialized messages when PGItems change in certain ways
oCPGMouseWatcherBackgroundThis 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
oCPGMouseWatcherGroupThis is a specialization on MouseWatcherGroup, to associate it with a PGTop
oCPGMouseWatcherParameterThis 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
oCPGMouseWatcherRegionThis is a specialization on MouseWatcherRegion, to add a bit more fields that are relevant to the PG system
oCPGScrollFrameThis is a special kind of frame that pretends to be much larger than it actually is
oCPGSliderBarThis 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
oCPGSliderBarNotifyObjects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
oCPGTopThe "top" node of the new Panda GUI system
oCPGVirtualFrameThis represents a frame that is rendered as a window onto another (possibly much larger) canvas
oCPGWaitBarThis 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
oCPhysicalDefines a set of physically modeled attributes
oCPhysicalNodeGraph node that encapsulated a series of physical objects
oCPhysicsCollisionHandlerA specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
oCPhysicsManagerPhysics don't get much higher-level than this
oCPhysicsObjectA body on which physics will be applied
oCPhysicsObjectCollectionThis is a set of zero or more PhysicsObjects
oCPhysxActorActors are the main simulation objects
oCPhysxActorDescDescriptor for PhysxActor
oCPhysxBodyDescDescriptor for the optional rigid body dynamic state of PhysxActor
oCPhysxBounds3Represention of a axis aligned bounding box
oCPhysxBoxRepresents an oriented bounding box, as a center point, extents(radii) and a rotation
oCPhysxBoxControllerBox character controller
oCPhysxBoxControllerDescDescriptor class for PhysxBoxController
oCPhysxBoxForceFieldShapeA box shaped region used to define a force field
oCPhysxBoxForceFieldShapeDescDescriptor for a box force field shape
oCPhysxBoxShapeA box shaped collision detection primitive
oCPhysxBoxShapeDescDescriptor class for PhysxBoxShape
oCPhysxCapsuleRepresents a capsule
oCPhysxCapsuleControllerA capsule character controller
oCPhysxCapsuleControllerDescDescriptor class for PhysxCapsuleController
oCPhysxCapsuleForceFieldShapeA capsule shaped region used to define a force field
oCPhysxCapsuleForceFieldShapeDescDescriptor for a capsule force field shape
oCPhysxCapsuleShapeA capsule shaped collision detection primitive, also known as a line swept sphere
oCPhysxCapsuleShapeDescDescriptor class for PhysxCapsuleShape
oCPhysxCcdSkeletonA Convex Mesh
oCPhysxCcdSkeletonDesc
oCPhysxCloth
oCPhysxClothDescDescriptor for PhysxCloth
oCPhysxClothMesh
oCPhysxClothMeshDesc
oCPhysxClothNodeRenderable geometry which represents a cloth mesh
oCPhysxConstraintDominanceExpresses the dominance relationship of a constraint
oCPhysxContactPairAn instance of this class is send with contact reporting events
oCPhysxContactPointA helper structure for iterating over contact streams reported by PhysxContactPair
oCPhysxContactReportImplementation of the NxUserContactReport interface
oCPhysxControllerAbstract base class for character controllers
oCPhysxControllerDescDescriptor class for a character controller
oCPhysxControllerReportImplementation of the NxUserControllerHitReport interface
oCPhysxControllerShapeHit
oCPhysxControllersHit
oCPhysxConvexForceFieldShapeA convex shaped region used to define force field
oCPhysxConvexForceFieldShapeDescA descriptor for a convex force field shape
oCPhysxConvexMeshA Convex Mesh
oCPhysxConvexMeshDesc
oCPhysxConvexShapeA shapes which is used to represent an instance of an convex mesh
oCPhysxConvexShapeDescDescriptor class for PhysxConvexShape
oCPhysxCylindricalJointCylindrical Joints permit relative translational movement between two bodies along an axis, and also relative rotation along the axis
oCPhysxCylindricalJointDescDescriptor class for sliding joint
oCPhysxD6JointA D6 joint is a general constraint between two actors
oCPhysxD6JointDesc
oCPhysxDebugGeomNodeRenderable geometry which represents visualizations of physics objects
oCPhysxDistanceJointA distance joint maintains a certain distance between two points on two actors
oCPhysxDistanceJointDescDescriptor class for distance joint
oCPhysxEnumsThis class exists just to provide scoping for the enums shared by PhysX classes
oCPhysxFileStream
oCPhysxFixedJointA fixed joint permits no relative movement between two bodies
oCPhysxFixedJointDescDescriptor class for fixed joint
oCPhysxForceFieldA force field effector
oCPhysxForceFieldDescDescriptor class for force fields
oCPhysxForceFieldShapeAbstract base class for force field shapes
oCPhysxForceFieldShapeDescAbstract base class for descriptors for force field shapes descriptors
oCPhysxForceFieldShapeGroup
oCPhysxForceFieldShapeGroupDesc
oCPhysxGroupsMask128-bit bitmask class
oCPhysxHeightFieldA height field object
oCPhysxHeightFieldDescDescriptor class for height fields
oCPhysxHeightFieldShapeThis class is a shape instance of a height field object of type PhysxHeightField
oCPhysxHeightFieldShapeDescDescriptor class for PhysxHeightFieldShape
oCPhysxJointAbstract base class for the different types of joints
oCPhysxJointDescAbstract base class for joint descriptors
oCPhysxJointDriveDescUsed to describe drive properties for a PhysxD6Joint
oCPhysxJointLimitDescDescribes a joint limit
oCPhysxJointLimitSoftDescDescribes a joint limit
oCPhysxKitchen
oCPhysxLinearInterpolationValues
oCPhysxManagerThe central interface to the PhysX subsystem
oCPhysxMask32-bit bitmask class
oCPhysxMaterialA class for describing a shape's surface properties
oCPhysxMaterialDescDescriptor class for materials
oCPhysxMemoryReadBuffer
oCPhysxMemoryWriteBuffer
oCPhysxMeshHashUtility class used in building links between a tetrahedron mesh (soft body) and a triangle mesh used for rendering the soft body
oCPhysxMeshPoolThis class unifies all references to the same filename, so that multiple attempts to load the same mesh will return the same pointer
oCPhysxMotorDescDescribes a joint motor
oCPhysxObject
oCPhysxObjectCollection
oCPhysxOverlapReportObjects of this class are returned by the 'overlap shape' methods, for example overlapSphereShapes
oCPhysxPlane
oCPhysxPlaneShapeA plane collision detection primitive
oCPhysxPlaneShapeDescDescriptor class for PhysxPlaneShape
oCPhysxPointInPlaneJointA point in plane joint constrains a point on one body to only move inside a plane attached to another body
oCPhysxPointInPlaneJointDescDescriptor class for point-in-plane joint
oCPhysxPointOnLineJointA point on line joint constrains a point on one body to only move along a line attached to another body
oCPhysxPointOnLineJointDescDescriptor class for point-on-line joint
oCPhysxPrismaticJointA prismatic joint permits relative translational movement between two bodies along an axis, but no relative rotational movement
oCPhysxPrismaticJointDescDescriptor class for prismatic joint
oCPhysxPulleyJointA pulley joint simulates a rope between two objects passing over two pulleys
oCPhysxPulleyJointDescDescriptor class for distance joint
oCPhysxRayRepresents an ray as an origin and direction
oCPhysxRaycastHitThis structure captures results for a single raycast query
oCPhysxRaycastReportObjects of this class are returned by the 'raycast all' methods
oCPhysxRevoluteJointA joint which behaves in a similar way to a hinge or axel
oCPhysxRevoluteJointDescDescriptor class for distance joint
oCPhysxSceneA scene is a collection of bodies, constraints, and effectors which can interact
oCPhysxSceneDescDescriptor for PhysxScene
oCPhysxSceneStats2
oCPhysxSegmentRepresents a line segment
oCPhysxShapeAbstract base class for shapes
oCPhysxShapeDescAbstract base class for shape descriptors
oCPhysxSoftBody
oCPhysxSoftBodyDescDescriptor for PhysxSoftBody
oCPhysxSoftBodyMesh
oCPhysxSoftBodyMeshDesc
oCPhysxSoftBodyNodeRenderable geometry which represents a soft body mesh
oCPhysxSphereRepresents a sphere defined by its center point and radius
oCPhysxSphereForceFieldShapeA spherical force field shape
oCPhysxSphereForceFieldShapeDescA descriptor for a sphere force field shape
oCPhysxSphereShapeA sphere shaped collision detection primitive
oCPhysxSphereShapeDescDescriptor class for PhysxSphereShape
oCPhysxSphericalJointA sphere joint constrains two points on two bodies to coincide
oCPhysxSphericalJointDescDescriptor class for distance joint
oCPhysxSpringDescDescribes a joint spring
oCPhysxTriangleMesh
oCPhysxTriangleMeshDesc
oCPhysxTriangleMeshShapeA shapes which is used to represent an instance of an convex mesh
oCPhysxTriangleMeshShapeDescDescriptor class for PhysxTriangleMeshShape
oCPhysxTriggerReportImplementation of the NxUserTriggerReport interface
oCPhysxUserEntityReport
oCPhysxUtilLib
oCPhysxVehicle
oCPhysxVehicleDesc
oCPhysxWheel
oCPhysxWheelDesc
oCPhysxWheelShapeA special shape used for simulating a car wheel
oCPhysxWheelShapeDescDescriptor class for PhysxWheelShape
oCPiecewiseCurveA PiecewiseCurve is a curve made up of several curve segments, connected in a head-to-tail fashion
oCPipelineThis 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
oCPipelineCyclerThis class maintains different copies of a page of data between stages of the graphics pipeline (or any other pipelining context)
oCPipelineCyclerLinksThis just stores the pointers to implement a doubly-linked list of PipelineCyclers for a particular Pipeline object
oCPipelineCyclerTrivialImplThis is the trivial, non-threaded implementation of PipelineCyclerBase
oCPipeOcclusionCullTraverserThis specialization of CullTraverser uses the graphics pipe itself to perform occlusion culling
oCPipeStreamBuf
oCpixel
oCPlaneNodeA node that contains a plane
oCplistThis is our own Panda specialization on the default STL list
oCpmapThis is our own Panda specialization on the default STL map
oCpmultimapThis is our own Panda specialization on the default STL multimap
oCpmultisetThis is our own Panda specialization on the default STL multiset
oCPNMBlendImageBrush
oCPNMBlendPixelBrush
oCPNMBrushThis class is used to control the shape and color of the drawing operations performed by a PNMPainter object
oCPNMDarkenImageBrush
oCPNMDarkenPixelBrush
oCPNMFileTypeThis is the base class of a family of classes that represent particular image file types that PNMImage supports
oCPNMFileTypePfmFor reading and writing PFM files using the basic PNMImage interface, as if they were basic RGB files
oCPNMFileTypeRegistryThis class maintains the set of all known PNMFileTypes in the universe
oCPNMImageThe 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
oCPNMImageBrush
oCPNMImageHeaderThis is the base class of PNMImage, PNMReader, and PNMWriter
oCPNMLightenImageBrush
oCPNMLightenPixelBrush
oCPNMPainterThis class provides a number of convenient methods for painting drawings directly into a PNMImage
oCPNMPixelBrush
oCPNMReaderThis is an abstract base class that defines the interface for reading image files of various types
oCPNMSetImageBrush
oCPNMSetPixelBrush
oCPNMTextGlyphA single glyph in a PNMTextMaker
oCPNMTextMakerThis object uses the Freetype library to generate text directly into an image
oCPNMTransparentBrush
oCPNMWriterThis is an abstract base class that defines the interface for writing image files of various types
oCPointEmitterDescribes a planar ring region in which particles are generated
oCpointer_hashThis is the default hash_compare class, which assumes the Key is a pointer value
oCPointerEventRecords a pointer movement event
oCPointerEventListRecords a set of pointer events that happened recently
oCPointerToPointerTo is a template class which implements a smart pointer to an object derived from ReferenceCount
oCPointerToArrayA special kind of PointerTo that stores an array of the indicated element type, instead of a single element
oCPointerToArrayBaseThis is the base class for PointerToArray and ConstPointerToArray
oCPointerToBaseThis is the base class for PointerTo and ConstPointerTo
oCPointerToVoidThis is the non-template part of the base class for PointerTo and ConstPointerTo
oCPointLightA light originating from a single point in space, and shining in all directions
oCPointParticleDescribes a particle that requires representation by a point (pixel, sparkle, billboard)
oCPointParticleFactoryCreates point particles to user specs
oCPointParticleRendererSimple point/point particle renderer
oCPolylightEffectA PolylightEffect can be used on a node to define a LightGroup for that node
oCPolylightNodeA PolylightNode
oCPortalClipperThis object performs a depth-first traversal of the scene graph, with optional view-frustum culling, collecting CullState and searching for GeomNodes
oCPortalNodeA node in the scene graph that can hold a Portal Polygon, which is a rectangle
oCPosixGraphicsStateGuardianThis 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
oCPreparedGraphicsObjectsA table of objects that are saved within the graphics context for reference by handle later
oCPrimeNumberGeneratorThis class generates a table of prime numbers, up to the limit of an int
oCProfileTimer
oCProgramBaseThis is intended to be the base class for most general-purpose utility programs in the PANDATOOL tree
oCProjectionScreenA ProjectionScreen implements a simple system for projective texturing
oCpsetThis is our own Panda specialization on the default STL set
oCPSphereLensA PSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
oCPStatClientManages the communications to report statistics via a network connection to a remote PStatServer
oCPStatClientControlMessageThis kind of message is sent from the client to the server on the TCP socket to establish critical control information
oCPStatClientDataThe data associated with a particular client, but not with any one particular frame or thread: the list of collectors and threads, for instance
oCPStatClientVersionRecords the version number of a particular client
oCPStatCollectorA lightweight class that represents a single element that may be timed and/or counted via stats
oCPStatCollectorDefDefines the details about the Collectors: the name, the suggested color, etc
oCPStatCollectorForwardThis class serves as a cheap forward reference to a PStatCollector, so that classes that are defined before the pstats module may access the PStatCollector
oCPStatCollectorForwardBaseThis 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)
oCPStatFrameDataContains the raw timing and level data for a single frame
oCPStatGPUTimerThis 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
oCPStatGraphThis is an abstract base class for several different kinds of graphs that have a few things in common, like labels and guide bars
oCPStatListenerThis is the TCP rendezvous socket listener
oCPStatMonitorThis is an abstract class that presents the interface to any number of different front-ends for the stats monitor
oCPStatPianoRollThis 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
oCPStatReaderThis is the class that does all the work for handling communications from a single Panda client
oCPStatServerThe overall manager of the network connections
oCPStatServerControlMessageThis kind of message is sent from the server to the client on the TCP socket to establish critical control information
oCPStatStripChartThis 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
oCPStatThreadA lightweight class that represents a single thread of execution to PStats
oCPStatThreadDataA collection of FrameData structures for recently-received frames within a particular thread
oCPStatTimerA lightweight class that can be used to automatically start and stop a PStatCollector around a section of code
oCPStatViewA View boils down the frame data to a linear list of times spent in a number of different Collectors, within a particular thread
oCPStatViewLevelThis is a single level value, or band of color, within a View
oCPtsToBam
oCPursue
oCpvectorThis is our own Panda specialization on the default STL vector
oCPviewAppDelegate
oCQtessGlobalsSimply used as a namespace to scope some global variables for this program, set from the command line
oCQtessInputEntryStores one entry in the qtess input file
oCQtessInputFileStores all the information read from a tesselation input file: a list of QtessInputEntry's
oCQtessSurfaceA 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
oCQueryContextThis is a base class for queries that might require a round-trip to the graphics engine
oCQueuedConnectionListenerThis flavor of ConnectionListener will queue up all of the TCP connections it established for later detection by the client code
oCQueuedConnectionManagerThis 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
oCQueuedConnectionReaderThis flavor of ConnectionReader will read from its sockets and queue up all of the datagrams read for later receipt by the client code
oCQueuedReturnThis is the implementation of a family of things that queue up their return values for later retrieval by client code, like QueuedConnectionReader, QueuedConnectionListener, QueuedConnectionManager
oCRamfileAn in-memory buffer specifically designed for downloading files to memory
oCRandomizerA handy class to return random numbers
oCRangeDescriptionThis describes a sparse range of Unicode character codes for conversion that may be specified on the command line
oCRangeIteratorWalks through all the Unicode characters described by a RangeDescription class
oCRecentConnectionReaderThis flavor of ConnectionReader will read from its sockets and retain only the single most recent datagram for inspection by client code
oCRecorderBaseThis 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
oCRecorderControllerThis object manages the process of recording the user's runtime inputs to a bam file so that the session can be recreated later
oCRecorderFrameThis object represents one frame of data in the recorded session file
oCRecorderHeaderThis object contains the header information written out at the beginning of a recorded session file
oCRecorderTableThis object is used by the RecorderController to write (and read) a record of the set of recorders in use to the bam file
oCRectangleEmitterDescribes a planar square region in which particles are generated
oCRefCountObjAnother kind of proxy, similar to RefCountProxy
oCRefCountProxyA "proxy" to use to make a reference-countable object whenever the object cannot inherit from ReferenceCount for some reason
oCReferenceCountA base class for all things that want to be reference-counted
oCReferenceCountedVectorThis defines the object that is actually stored and reference-counted internally by a PointerToArray
oCRemoveNodeCB
oCReMutexA reentrant mutex
oCReMutexDirectThis class implements a standard reMutex by making direct calls to the underlying implementation layer
oCReMutexHolderSimilar to MutexHolder, but for a reentrant mutex
oCRenderAttribThis 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
oCRenderAttribRegistryThis 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
oCRenderBufferA RenderBuffer is an arbitrary subset of the various layers (depth buffer, color buffer, etc.) of a drawing region
oCRenderEffectThis 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
oCRenderEffectsThis represents a unique collection of RenderEffect objects that correspond to a particular renderable state
oCRenderModeAttribSpecifies how polygons are to be drawn
oCRenderStateThis represents a unique collection of RenderAttrib objects that correspond to a particular renderable state
oCRescaleNormalAttribSpecifies how polygons are to be drawn
oCReversedNumericDataNativeNumericData 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
oCRigidBodyCombinerThis 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
oCRingBufferThis is an implemention of the membuffer with ring buffer interface on it...
oCRingBuffer_SlideThis is an implemention of the membuffer with ring buffer interface on it...
oCRingEmitterDescribes a planar ring region in which particles are generated
oCRocketFileInterfaceImplementation of FileInterface to allow libRocket to read files from the virtual file system
oCRocketInputHandlerDataNode that listens for keyboard and mouse events and passes them to libRocket
oCRocketRegionRepresents a region in a window or buffer where the libRocket UI will be rendered to
oCRocketRenderInterfaceClass that provides the main render interface for libRocket integration
oCRocketSystemInterfaceThis is an implementation of SystemInterface that redirects the log output to Panda's notify system
oCRopeNodeThis class draws a visible representation of the NURBS curve stored in its NurbsCurveEvaluator
oCSampleClassA basic description of the function and purpose of SampleClass
oCSamplerContextThis 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
oCSamplerStateRepresents a set of settings that indicate how a texture is sampled
oCSavedContextThis is the base class for all GSG-specific context objects, such as TextureContext and GeomContext
oCsBodyParams
oCSceneGraphAnalyzerA handy class that can scrub over a scene graph and collect interesting statistics on it
oCSceneGraphAnalyzerMeterThis is a special TextNode that automatically updates itself with output from a SceneGraphAnalyzer instance
oCSceneGraphReducerAn interface for simplifying ("flattening") scene graphs by eliminating unneeded nodes and collapsing out unneeded state changes and transforms
oCSceneSetupThis object holds the camera position, etc., and other general setup information for rendering a particular scene
oCScissorAttribThis restricts rendering to within a rectangular region of the scene, without otherwise affecting the viewport or lens properties
oCScissorEffectThis provides a higher-level wrapper around ScissorAttrib
oCsdVector4
oCsecond_of_pair_iteratorThis is an iterator adaptor that converts any iterator that returns a pair (e.g
oCSeek
oCSelectiveChildNodeA base class for nodes like LODNode and SequenceNode that select only one visible child at a time
oCSemaphoreA classic semaphore synchronization primitive
oCsequence_hashThis hash_compare class hashes a string
oCSequenceNodeA node that automatically cycles through rendering each one of its children according to its frame rate
oCSFNodeRef
oCShadeModelAttribSpecifies whether flat shading (per-polygon) or smooth shading (per-vertex) is in effect
oCShader
oCShaderAttrib
oCShaderContextThe ShaderContext is meant to contain the compiled version of a shader string
oCShaderGeneratorThe ShaderGenerator is a device that effectively replaces the classic fixed function pipeline with a 'next-gen' fixed function pipeline
oCShaderInputThis is a small container class that can hold any one of the value types that can be passed as input to a shader
oCShaderPoolThis is the preferred interface for loading shaders for the TextNode system
oCSheetNodeThis class draws a visible representation of the NURBS surface stored in its NurbsSurfaceEvaluator
oCShoveDataUsed within CollisionHandlerPusher::handle_entries(), to track multiple shoves onto a given collider
oCShowBoundsEffectApplied to a GeomNode to cause a visible bounding volume to be drawn for this node
oCShowIntervalAn interval that calls NodePath::show()
oCSimpleAllocatorAn implementation of a very simple block allocator
oCSimpleAllocatorBlockA single block as returned from SimpleAllocator::alloc()
oCSimpleHashMapThis template class implements an unordered map of keys to data, implemented as a hashtable
oCSimpleLruAn implementation of a very simple LRU algorithm
oCSimpleLruPageOne atomic piece that may be managed by a SimpleLru chain
oCSliderTableStores the total set of VertexSliders that the vertices in a particular GeomVertexData object might depend on
oCSmoothMoverThis class handles smoothing of sampled motion points over time, e.g
oCSocket_AddressA simple place to store and munipulate tcp and port address for communication layer
oCSocket_fdset
oCSocket_IPBase functionality for a INET domain Socket this call should be the starting point for all other unix domain sockets
oCSocket_Selector
oCSocket_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
oCSocket_TCP_ListenBase functionality for a TCP rendezvous socket
oCSocket_UDPBase functionality for a combination UDP Reader and Writer
oCSocket_UDP_IncomingBase functionality for a UDP Reader
oCSocket_UDP_OutgoingBase functionality for a UDP Sending Socket
oCSoftCVSThis program prepares a SoftImage database for CVS by renaming everything to version 1-0, and adding new files to CVS
oCSoftEggGroupUserDataThis class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the softimage converter
oCSoftFilenameThis encapsulates a SoftImage versioned filename, of the form base.v-v.ext: it consists of a directory name, a base, a major and minor version number, and an optional extension
oCSoftNodeDescDescribes a single instance of a node aka element in the Soft scene graph, relating it to the corresponding egg structures (e.g
oCSoftNodeTreeDescribes a complete tree of soft nodes for conversion
oCSoftToEggConverterThis class supervises the construction of an EggData structure from a single Softimage file, or from the data already in th cout << "egg name = " << eggFilename << endl;e global Softimage model space
oCSomethingToEggThis is the general base class for a file-converter program that reads some model file format and generates an egg file
oCSomethingToEggConverterThis is a base class for a family of converter classes that manage a conversion from some file type to egg format
oCSortByColliderSort
oCSortByExternalIndex
oCSortByState
oCSortCollectorLabels1
oCSortCollectorLabels2
oCSortCollectorLevels
oCSortFieldsByIndex
oCSortGroupsByDependencyOrder
oCSortGroupsByPreference
oCSortPlacementBySize
oCSourceTextureImageThis is a texture image reference as it appears in an egg file: the source image of the texture
oCSparkleParticleRendererPretty sparkly things
oCSparseArrayThis class records a set of integers, where each integer is either present or not present in the set
oCSpeedTreeNodeInterfaces with the SpeedTree library to render SpeedTree objects, especially trees, within the Panda3D scene graph
oCSphereSurfaceEmitterDescribes a curved space in which particles are generated
oCSphereVolumeEmitterDescribes a voluminous spherical region in which particles are generated
oCSpotlightA light originating from a single point in space, and shining in a particular direction, with a cone-shaped falloff
oCSpriteAnimHelper class used by SpriteParticleRenderer to keep track of its textures and their respective UVs and source types
oCSpriteParticleRendererRenders a particle system with high-speed nasty trick sprites
oCSpriteWriterHelper class used by SpriteParticleRenderer to keep track of the various GeomVertexWriters associated with each geom created in SpriteParticleRenderer::init_geoms()
oCsSurfaceParams
oCStackedPerlinNoise2Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
oCStackedPerlinNoise3Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
oCStandardMungerPerforms 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
oCStateMungerThis is just a simple derivative of GeomMunger that adds the ability to munge states
oCStaticDeletedChainThis template class is used to conveniently declare a single instance of the DeletedChain template object, above, for a particular type
oCStaticTextFontA 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
oCSTBasicTerrainA 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
oCSTCustomAllocator
oCStencilAttribA StencilAttrib is a collection of all stencil render states
oCStereoDisplayRegionThis is a special DisplayRegion wrapper that actually includes a pair of DisplayRegions internally: the left and right eyes
oCstl_hash_compare
oCStreamReaderA class to read sequential binary data directly from an istream
oCStreamWrapperThis class provides a locking wrapper around a combination ostream/istream pointer
oCStreamWrapperBaseThe base class for both IStreamWrapper and OStreamWrapper, this provides the common locking interface
oCStreamWriterA StreamWriter object is used to write sequential binary data directly to an ostream
oCStringDecoderThe base class to a family of classes that decode various kinds of encoded byte streams
oCstringstream
oCStringStreamA bi-directional stream object that reads and writes data to an internal buffer, which can be retrieved and/or set as a string
oCStringStreamBufUsed 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
oCStringUnicodeDecoderThis decoder extracts characters two at a time to get a plain wide character sequence
oCStringUtf8DecoderThis decoder extracts utf-8 sequences
oCStrTargetBuffer
oCSTTerrainThis is the abstract base class that defines the interface needed to describe a terrain for rendering by SpeedTree
oCSTTransformRepresents a transform that may be applied to a particular instance of a tree when added to the SpeedTreeNode
oCSTTreeEncapsulates a single tree model in the SpeedTree library, as loaded from an SRT file
oCSubdivSegmentRepresents a single hypothetical subdivided segment, under consideration by the IsoPlacer
oCSubfileInfoThis class records a particular byte sub-range within an existing file on disk
oCSubprocessWindowBufferThis is a special class that is designed to faciliate SubprocessWindow
oCSubStreamCombined ISubStream and OSubStream for bidirectional I/O
oCSubStreamBufThe streambuf object that implements ISubStream
oCSwitchNodeA node that renders only one of its children, according to the user's indication
oCTangentRingEmitterDescribes a planar ring region in which tangent particles are generated, and particles fly off tangential to the ring
oCTemporaryFileThis is a special kind of FileReference class that automatically deletes the file in question when it is deleted
oCTestCopyA program to copy ordinary files into the cvs tree
oCTexGenAttribComputes texture coordinates for geometry automatically based on vertex position and/or normal
oCTexMatrixAttribApplies a transform matrix to UV's before they are rendered
oCTexProjectorEffectThis effect automatically applies a computed texture matrix to the specified texture stage, according to the relative position of two specified nodes
oCTextAssemblerThis 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
oCTextEncoderThis class can be used to convert text between multiple representations, e.g
oCTextFontAn encapsulation of a font; i.e
oCTextGlyphA representation of a single glyph (character) from a font
oCTextGraphicThis defines a special model that has been constructed for the purposes of embedding an arbitrary graphic image within a text paragraph
oCTextMonitorA simple, scrolling-text stats monitor
oCTextNodeThe primary interface to this module
oCTextPropertiesThis defines the set of visual properties that may be assigned to the individual characters of the text
oCTextPropertiesManagerThis defines all of the TextProperties structures that might be referenced by name from an embedded text string
oCTextStatsA simple, scrolling-text stats server
oCTextureRepresents 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
oCTextureAttribIndicates the set of TextureStages and their associated Textures that should be applied to (or removed from) a node
oCTextureCollectionManages a list of Texture objects, as returned by TexturePool::find_all_textures()
oCTextureContextThis is a special class object that holds all the information returned by a particular GSG to indicate the texture's internal context identifier
oCTextureImageThis represents a single source texture that is referenced by one or more egg files
oCTextureMemoryCounterThis class is used to gather statistics on texture memory usage, etc
oCTexturePeekerAn instance of this object is returned by Texture::peek()
oCTexturePlacementThis 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
oCTexturePoolThis is the preferred interface for loading textures from image files
oCTexturePoolFilterThis 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
oCTexturePositionThis represents a particular position of a texture within a PaletteImage
oCTexturePropertiesThis is the set of characteristics of a texture that, if different from another texture, prevent the two textures from sharing a PaletteImage
oCTextureReferenceThis is the particular reference of a texture filename by an egg file
oCTextureReloadRequestThis loader request will call Texture::get_ram_image() in a sub-thread, to force the texture's image to be re-read from disk
oCTextureRequestThese are the things that a user might explicitly request to adjust on a texture via a line in the .txa file
oCTextureStageDefines the properties of a named stage of the multitexture pipeline
oCTextureStageCollection
oCTextureStagePoolThe 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
oCThreadA thread; that is, a lightweight process
oCThreadSafeConstPointerTo
oCThreadSafePointerToThis 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
oCThreadSafePointerToBaseThis is the base class for ThreadSafePointerTo and ThreadSafeConstPointerTo
oCTime_Accumulator
oCTime_Clock
oCTime_Out
oCTime_Span
oCTimedCycleA class for anything that needs to cycle over some finite list of elements in increments based on time
oCTimerQueryContext
oCTimeVal
oCTinyGeomMungerThis specialization on GeomMunger finesses vertices for TinyPanda rendering
oCTinyGraphicsBufferAn offscreen graphics buffer
oCTinyGraphicsStateGuardianAn interface to the TinyPanda software rendering code within this module
oCTinyOffscreenGraphicsPipeThis graphics pipe creates offscreen buffers only, but is completely platform-independent
oCTinyTextureContext
oCTiXmlAttributeAn attribute is a name-value pair
oCTiXmlAttributeSet
oCTiXmlBaseTiXmlBase is a base class for every class in TinyXml
oCTiXmlCommentAn XML comment
oCTiXmlCursor
oCTiXmlDeclarationIn correct XML the declaration is the first entry in the file
oCTiXmlDocumentAlways the top level node
oCTiXmlElementThe element is a container class
oCTiXmlHandleA TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing
oCTiXmlNodeThe parent class for everything in the Document Object Model
oCTiXmlParsingData
oCTiXmlPrinterPrint to memory functionality
oCTiXmlTextXML text
oCTiXmlUnknownAny tag that tinyXml doesn't recognize is saved as an unknown
oCTiXmlVisitorImplements 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
oCTouchInfoStores information for a single touch event
oCTrackballTrackball acts like Performer in trackball mode
oCTrackerDataStores the kinds of data that a tracker might output
oCTrackerNodeThis is the primary interface to a Tracker object associated with a ClientBase
oCTransform2SGInput: Transform (matrix)
oCTransformBlendThis defines a single entry in a TransformBlendTable
oCTransformBlendTableThis 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
oCTransformTableStores the total set of VertexTransforms that the vertices in a particular GeomVertexData object might depend on
oCTransparencyAttribThis controls the enabling of transparency
oCTriangulatorThis class can triangulate a convex or concave polygon, even one with holes
oCTriangulator3This is an extension of Triangulator to handle polygons with three-dimensional points
oCTrueClockAn interface to whatever real-time clock we might have available in the current environment
oCTxaFileThis represents the .txa file (usually textures.txa) that contains the user instructions for resizing, grouping, etc
oCTxaFileFilterThis 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
oCTxaLineThis is a single matching line in the .txa file
oCtypecast_iteratorThis is an iterator adaptor that explicitly typecasts each value returned by the base iterator to the indicated type
oCTypedObjectThis is an abstract class that all classes which use TypeHandle, and also provide virtual functions to support polymorphism, should inherit from
oCTypedReferenceCountA base class for things which need to inherit from both TypedObject and from ReferenceCount
oCTypedSkelSkeleton object that inherits from TypedObject
oCTypedWritableBase class for objects that can be written to and read from Bam files
oCTypedWritableReferenceCountA base class for things which need to inherit from both TypedWritable and from ReferenceCount
oCTypeHandleTypeHandle is the identifier used to differentiate C++ class types
oCTypeRegistryMaintains all the assigned TypeHandles in a given system
oCTypeRegistryNodeThis is a single entry in the TypeRegistry
oCUnalignedLMatrix4dThis is an "unaligned" LMatrix4
oCUnalignedLMatrix4fThis is an "unaligned" LMatrix4
oCUnalignedLVecBase4dThis is an "unaligned" LVecBase4
oCUnalignedLVecBase4fThis is an "unaligned" LVecBase4
oCUnalignedLVecBase4iThis is an "unaligned" LVecBase4
oCUnicodeLatinMapThis 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
oCUnionBoundingVolumeThis special bounding volume is the union of all of its constituent bounding volumes
oCUniqueEggMaterialsAn STL function object for sorting materials into order by properties
oCUniqueEggTexturesAn STL function object for sorting textures into order by properties
oCUniqueEggVerticesAn STL function object for sorting vertices into order by properties
oCUniqueIdAllocatorManage a set of ID values from min to max inclusive
oCUpdateSeqThis is a sequence number that increments monotonically
oCURLSpecA container for a URL, e.g
oCUserDataAudioA UserDataAudio is a way for the user to manually supply raw audio samples
oCUserDataAudioCursorA UserDataAudioCursor is a means to manually supply a sequence of raw audio samples
oCUserPersitentData
oCUserVertexSliderThis is a specialization on VertexSlider that allows the user to specify any arbitrary slider valie he likes
oCUserVertexTransformThis is a specialization on VertexTransform that allows the user to specify any arbitrary transform matrix he likes
oCUvScrollNodeThis node is placed at key points within the scene graph to animate uvs
oCV2
oCV3
oCV4
oCVertexBufferContextThis 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
oCVertexDataBlockA block of bytes that stores the actual raw vertex data referenced by a GeomVertexArrayData object
oCVertexDataBookA collection of VertexDataPages, which can be used to allocate new VertexDataBlock objects
oCVertexDataBufferA block of bytes that stores the actual raw vertex data referenced by a GeomVertexArrayData object
oCVertexDataPageA block of bytes that holds one or more VertexDataBlocks
oCVertexDataSaveBlockA block of bytes on the save file
oCVertexDataSaveFileA temporary file to hold the vertex data that has been evicted from memory and written to disk
oCVertexElementArrayThis class gives the ability for a user-friendly way of creating a vertex declaration for DirectX 9
oCVertexMembershipThis class is used to help EggOptchar quantize the membership of one vertex among its various groups
oCVertexSliderThis 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)
oCVertexTransformThis 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
oCVideoTextureThe base class for a family of animated Textures that take their input from a video source, such as a movie file
oCVirtualFileThe abstract base class for a file or directory within the VirtualFileSystem
oCVirtualFileCompositeA composite directory within the VirtualFileSystem: this maps to more than one directory on different mount points
oCVirtualFileListA list of VirtualFiles, as returned by VirtualFile::scan_directory()
oCVirtualFileMountThe abstract base class for a mount definition used within a VirtualFileSystem
oCVirtualFileMountMultifileMaps a Multifile's contents into the VirtualFileSystem
oCVirtualFileMountRamdiskSimulates an actual directory on disk with in-memory storage
oCVirtualFileMountSystemMaps an actual OS directory into the VirtualFileSystem
oCVirtualFileSimpleA simple file or directory within the VirtualFileSystem: this maps to exactly one file on one mount point
oCVirtualFileSystemA 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
oCVirtualMousePoses 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
oCVRMLAppearance
oCVrmlFieldValue
oCVrmlNode
oCVrmlNodeType
oCVRMLToEggA program to read a VRML file and generate an egg file
oCVRMLToEggConverterThis class supervises the construction of an EggData structure from a VRML file
oCVRMLTransA program to read a VRML file and output an essentially similar VRML file
oCVrpnAnalogThis is the actual interface to a particular VRPN analog device, and all of its numbered controls
oCVrpnAnalogDeviceThe Panda interface to a VRPN analog device
oCVrpnButtonThis is the actual interface to a particular VRPN button device, and all of its numbered buttons
oCVrpnButtonDeviceThe Panda interface to a VRPN button
oCVrpnClientA specific ClientBase that connects to a VRPN server and records information on the connected VRPN devices
oCVrpnDialThis is the actual interface to a particular VRPN dial device, and all of its numbered dials
oCVrpnDialDeviceThe Panda interface to a VRPN dial device
oCVrpnTrackerThis is the actual interface to a particular VRPN tracker object, and all of its sensors
oCVrpnTrackerDeviceThe Panda interface to a VRPN tracker
oCWaitIntervalThis interval does absolutely nothing, and is mainly useful for marking time between other intervals within a sequence
oCWander
oCWavAudioA native PCM .wav loader
oCWavAudioCursorUsed for reading PCM .wav files
oCwdxGraphicsBuffer9An offscreen render buffer
oCwdxGraphicsPipe9This graphics pipe represents the interface for creating DirectX9 graphics windows
oCwdxGraphicsWindow9A single graphics window for rendering DirectX under Microsoft Windows
oCWeakConstPointerToA 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
oCWeakNodePathThis class is a wrapper around a NodePath that, unlike the actual NodePath class, doesn't hold a reference count to the node
oCWeakPointerCallbackDerive 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
oCWeakPointerToWeakPointerTo is similar to PointerTo, except that it does not actually prevent the referenced pointer from deleting
oCWeakPointerToBaseThis is the base class for PointerTo and ConstPointerTo
oCWeakPointerToVoidThis is the specialization of PointerToVoid for weak pointers
oCWeakReferenceListThis is a list of WeakPointerTo's that share a reference to a given ReferenceCount object
oCWebBrowserTextureA Wrapper class for Awesomium webview
oCWebcamVideoAllows you to open a webcam or other video capture device as a video stream
oCwglGraphicsBufferAn offscreen render buffer
oCwglGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on the various Windows OSes
oCwglGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some wgl-specific information
oCwglGraphicsWindowA single graphics window for rendering OpenGL under Microsoft Windows
oCWHQL
oCWINDOW_METRICS
oCWindowFrameworkThis encapsulates the data that is normally associated with a single window, or with a single display region within a window
oCWindowHandleThis object represents a window on the desktop, not necessarily a Panda window
oCWindowPropertiesA container for the various kinds of properties we might ask to have on a graphics window before we open it
oCWindowsGuidThis is an implementation of the Windows GUID object, used everywhere as a world-unique identifier for anything and everything
oCWinGraphicsPipeThis is an abstract base class for wglGraphicsPipe and wdxGraphicsPipe; that is, those graphics pipes that are specialized for working with Microsoft Windows
oCWinGraphicsWindowAn abstract base class for glGraphicsWindow and dxGraphicsWindow (and, in general, graphics windows that interface with the Microsoft Windows API)
oCWinStatsChartMenuA pulldown menu of charts available for a particular thread
oCWinStatsGraphThis 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
oCWinStatsLabelA text label that will draw in color appropriate for a particular collector
oCWinStatsLabelStackA window that contains a stack of labels from bottom to top
oCWinStatsMonitorThis class represents a connection to a PStatsClient and manages the data exchange with the client
oCWinStatsPianoRollA window that draws a piano-roll style chart, which shows the collectors explicitly stopping and starting, one frame at a time
oCWinStatsServerThe class that owns the main loop, waiting for client connections
oCWinStatsStripChartA window that draws a strip chart, given a view
oCWithOutputFileThis is the bare functionality (intended to be inherited from along with ProgramBase or some derivative) for a program that might generate an output file
oCWordWrapStreamA special ostream that formats all of its output through ProgramBase::show_text()
oCWordWrapStreamBufUsed by WordWrapStream to implement an ostream that flushes its output to ProgramBase::show_text()
oCWorkingNodePathThis 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
oCWritableConfigurableDefined as a fix to allow creating Configurable and Writable objects
oCWritableParamThe specific derivation of FactoryParam that contains the information needed by a TypedWritable object
oCx11GraphicsPipeThis graphics pipe represents the interface for creating graphics windows on an X-based client
oCx11GraphicsWindowInterfaces to the X11 window system
oCXFileThis represents the complete contents of an X file (file.x) in memory
oCXFileAnimationSetThis represents a tree of EggTables, corresponding to Animation entries in the X file
oCXFileArrayDefDefines one level of array bounds for an associated XFileDataDef element
oCXFileDataDefA definition of a single data element appearing within a template record
oCXFileDataNodeThis is an abstract base class for an XFileNode which is also an XFileDataObject
oCXFileDataNodeReferenceThis is a nested reference to an instance of a template object, declared via the syntax:
oCXFileDataNodeTemplateThis is a node which contains all of the data elements defined by a template
oCXFileDataObjectThe abstract base class for a number of different types of data elements that may be stored in the X file
oCXFileDataObjectArrayAn array of nested data elements
oCXFileDataObjectDoubleAn double-valued data element
oCXFileDataObjectIntegerAn integer-valued data element
oCXFileDataObjectStringAn string-valued data element
oCXFileFaceThis represents a single face of an XFileMesh
oCXFileMakerThis class converts a Panda scene graph into a .X file and writes it out
oCXFileMaterialThis represents an X file "material", which consists of a color, lighting, and/or texture specification
oCXFileMeshThis is a collection of polygons; i.e
oCXFileNodeA single node of an X file
oCXFileNormalThis represents a single normal associated with an XFileFace
oCXFileParseDataThis class is used to fill up the data into an XFileDataNodeTemplate object as the data values are parsed out of the X file
oCXFileParseDataListA container for a pvector of the above objects
oCXFileTemplateA template definition in the X file
oCXFileToEggA program to read a DirectX "x" file and generate an egg file
oCXFileToEggConverter
oCXFileTransA program to read a X file and output an essentially similar X file
oCXFileVertexThis represents a single vertex associated with an XFileFace
oCXFileVertexPoolThis is a collection of unique vertices as extracted out of a Geom or a series of Geoms
oCXTokenType
oCZBuffer
oCZBufferPoint
oCZSpinParticleDescribes a particle that spins along its z axis
oCZSpinParticleFactory
oCZTextureDef
\CZTextureLevel