Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_KEY_ELEMENT
_KEY_LIST
_LruPageType
LruPage::_LruPageVariables
Lru::_LruVariables
_PROCESSOR_POWER_INFORMATION
AccumulatedAttribsThis 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
ACMatrixSwitchType
ACScalarSwitchType
ActorNodeLike a physical node, but with a little more
AdaptiveLruA 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
AdaptiveLruPageOne atomic piece that may be managed by a AdaptiveLru chain
AdaptiveLruPageDynamicList
AdaptiveLruPageStaticList
AddHashThis 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)
AddNodeCB
AIBehaviors
AICharacter
AICharPoolThis class implements a linked list of AI Characters allowing the user to add and delete characters from the linked list
AINodeThis class is used to assign the nodes on the mesh
AIWorldA class that implements the virtual AI world which keeps track of the AI characters active at any given time
AlphaTestAttribEnables or disables writing of pixel to framebuffer based on its alpha value relative to a reference alpha value
AmbientLightA light source that seems to illuminate all points in space at once
AnalogNodeThis is the primary interface to analog controls like sliders and joysticks associated with a ClientBase
ClientAnalogDevice::AnalogState
AngularEulerIntegratorPerforms Euler integration on a vector of physically modelable objects given a quantum dt
AngularForcePure virtual parent of all quat-based forces
AngularIntegratorPure virtual base class for physical modeling
AngularVectorForceSimple directed torque force, the angular equivalent of simple vector force
AnimateVerticesRequestThis class object manages a single asynchronous request to animate vertices on a GeomVertexData object
AnimBundleThis is the root of an AnimChannel hierarchy
AnimBundleMakerConverts an EggTable hierarchy, beginning with a <Bundle> entry, into an AnimBundle hierarchy
AnimBundleNodeThis is a node that contains a pointer to an AnimBundle
AnimChannel< SwitchType >This template class is the parent class for all kinds of AnimChannels that return different values
AnimChannelBaseParent class for all animation channels
AnimChannelFixed< SwitchType >This template class is a special kind of AnimChannel that always returns just one fixed value
AnimChannelMatrixDynamicAn animation channel that accepts a matrix each frame from some dynamic input provided by code
AnimChannelMatrixFixedA specialization on AnimChannel to add all the special matrix component operations
AnimChannelMatrixXfmTableAn animation channel that issues a matrix each frame, read from a table such as might have been read from an egg file
AnimChannelScalarDynamicAn animation channel that accepts a scalar each frame from some dynamic input provided by code
AnimChannelScalarTableAn animation channel that issues a scalar each frame, read from a table such as might have been read from an egg file
AnimControlControls the timing of a character animation
AnimControlCollectionThis is a named collection of AnimControl pointers
AnimGroupThis is the base class for AnimChannel and AnimBundle
AnimGroupAlphabeticalOrder
AnimInterfaceThis is the fundamental interface for things that have a play/loop/stop type interface for frame-based animation, such as animated characters
AnimPreloadTableThis table records data about a list of animations for a particular model, such as number of frames and frame rate
AnimPreloadTable::AnimRecord
AntialiasAttribSpecifies whether or how to enable antialiasing, if supported by the backend renderer
ArcEmitterDescribes a planar ring region in which particles are generated
Arrival
AssimpLoaderClass that interfaces with Assimp and builds Panda nodes to represent the Assimp structures
AsyncTaskThis class represents a concrete task performed by an AsyncManager
AsyncTaskBaseThe abstract base class for AsyncTask
AsyncTaskChainThe AsyncTaskChain is a subset of the AsyncTaskManager
AsyncTaskChain::AsyncTaskChainThread
AsyncTaskCollectionA list of tasks, for instance as returned by some of the AsyncTaskManager query functions
AsyncTaskManagerA 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)
AsyncTaskPauseA special kind of task that simple returns DS_pause, to pause for a specified number of seconds and then finish
AsyncTaskSequenceA special kind of task that serves as a list of tasks internally
AsyncTaskManager::AsyncTaskSortName
AsyncTaskChain::AsyncTaskSortPriority
AsyncTaskChain::AsyncTaskSortWakeTime
AtomicAdjustDummyImplA trivial implementation for atomic adjustments for systems that don't require multiprogramming, and therefore don't require special atomic operations
AttribNodeRegistryThis global object records NodePaths that are referenced by scene graph attribs, such as ClipPlaneAttribs and LightAttribs
AudioLoadRequestA class object that manages a single asynchronous audio load request
AudioManager
AudioSound
AudioVolumeAttribApplies a scale to audio volume for positional sounds in the scene graph
ProfileTimer::AutoTimer
AuxBitplaneAttribModern frame buffers can have 'aux' bitplanes, which are additional bitplanes above and beyond the standard depth and color
BamReader::AuxData
AuxSceneDataThis 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
AwMouseAndKeyboardThin wrappings arround WebCore.h
AwWebCoreThin wrappings arround WebCore.h
AwWebViewThin bindings, wraps a WebView * returned from WebCore.createWebView
AwWebViewListenerThin bindings, wraps a WebViewListener
GeomNode::BamAuxData
LightAttrib::BamAuxData
BamCacheThis 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)
BamCacheIndexThis represents the in-memory index that records the list of files stored in the BamCache
BamCacheRecordAn 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
BamEnumsThis class exists just to provide scoping for the enums shared by BamReader and BamWriter
BamFileThe principle public interface to reading and writing Bam disk files
BamInfo
BamReaderThis is the fundamental interface for extracting binary objects from a Bam file, as generated by a BamWriter
BamReaderAuxDataStores auxiliary data that may be piggybacked on the BamReader during each object's read pass
BamReaderParamThe parameters that are passed through the Factory to any object constructing itself from a Bam file
BamToEggThis program reads a bam file, for instance as written out from a real-time interaction session, and generates a corresponding egg file
BamWriterThis is the fundamental interface for writing binary objects to a Bam file, to be extracted later by a BamReader
BaseForcePure virtual base class for all forces that could POSSIBLY exist
BaseIncomingSet< _INCLASS1, _IN_LISTEN, MESSAGE_READER_BUF, MESSAGE_READER_UPPASS >A base structre for a listening socket and a set of connection that have been received with there read functions
BaseIntegratorPure virtual integrator class that holds cached matrix information that really should be common to any possible child implementation
BaseParticleAn individual, physically-modelable particle abstract base class
BaseParticleEmitterDescribes a physical region in space in which particles are randomly generated
BaseParticleFactoryPure Virtual base class for creating particles
BaseParticleRendererPure virtual particle renderer base class
BasicSkelThis is the most basic of the skeleton classes
ParametricCurve::BezierSeg
BillboardEffectIndicates that geometry at this node should automatically rotate to face the camera, or any other arbitrary node
BinCullHandlerThis CullHandler sends all of the geoms it receives into a CullResult object, for binning (and later drawing)
BindAnimRequestThis class object manages an asynchronous load-and-bind animation request, as issued through PartBundle::load_bind_anim()
BinToCA utility program to read a (binary) file and output a table that can be compiled via a C compiler to generate the same data
BitArrayA dynamic array with an unlimited number of bits
BitMask< WType, nbits >A general bitmask class
bitstream
BoundingBoxAn axis-aligned bounding box; that is, a minimum and maximum coordinate triple
BoundingHexahedronThis defines a bounding convex hexahedron
BoundingLineThis funny bounding volume is an infinite line with no thickness and extending to infinity in both directions
BoundingPlaneThis 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
BoundingSphereThis defines a bounding sphere, consisting of a center and a radius
BoundingVolumeThis 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
PandaNode::BoundsData
BoxEmitterDescribes a voluminous box region in which particles are generated
Buffer
MovieVideoCursor::Buffer
BufferContextThis 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
BufferContextChainThis class maintains a linked list of BufferContexts that might be allocated on the graphics card in some context
Buffered_DatagramConnection
Buffered_DatagramReader
Buffered_DatagramWriterThis is the buffered writer
BufferedWriter_Growable
BufferResidencyTrackerThis 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
BulletAllHitsRayResult
BulletBaseCharacterControllerNode
BulletBodyNode
BulletBoxShape
BulletCapsuleShape
BulletCharacterControllerNode
BulletClosestHitRayResult
BulletClosestHitSweepResult
BulletConeShape
BulletConeTwistConstraint
BulletConstraint
BulletContact
BulletContactResult
BulletConvexHullShape
BulletConvexPointCloudShape
BulletCylinderShape
BulletDebugNode
BulletGenericConstraint
BulletGhostNode
BulletHeightfieldShape
BulletHelper
BulletHingeConstraintThe hinge constraint lets two bodies rotate around a given axis while adhering to specified limits
BulletManifoldPoint
BulletMultiSphereShape
BulletPersistentManifold
BulletPlaneShape
BulletRayHit
BulletRigidBodyNode
BulletShape
BulletSliderConstraint
BulletSoftBodyConfig
BulletSoftBodyMaterial
BulletSoftBodyNode
BulletSoftBodyNodeElement
BulletSoftBodyShape
BulletSoftBodyWorldInfo
BulletSphereShape
BulletSphericalConstraintA constraint between two rigid bodies, each with a pivot point
BulletTriangleMesh
BulletTriangleMeshShape
BulletVehicle
BulletVehicleTuningSimulates a raycast vehicle which casts a ray per wheel at the ground as a cheap replacement for complex suspension simulation
BulletWheelOne wheel of a BulletVehicle
BulletWorld
ButtonEventRecords a button event of some kind
ButtonEventListRecords a set of button events that happened recently
ButtonHandleA ButtonHandle represents a single button from any device, including keyboard buttons and mouse buttons (but see KeyboardButton and MouseButton)
ButtonNodeThis is the primary interface to on/off button devices associated with a ClientBase
ButtonRegistryMaintains all the assigned ButtonHandles in a given system
ClientButtonDevice::ButtonState
ButtonThrowerThrows Panda Events for button down/up events generated within the data graph
CachedTypedWritableReferenceCountThis 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
Geom::CacheEntry
GeomVertexData::CacheEntry
Geom::CacheKey
GeomVertexData::CacheKey
CacheStatsThis is used to track the utilization of the TransformState and RenderState caches, for low-level performance tuning information
CallbackDataThis is a generic data block that is passed along to a CallbackObject when a callback is made
CallbackGraphicsWindowThis 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
CallbackNodeA special node that can issue arbitrary callbacks to user code, either during the cull or draw traversals
CallbackObjectThis is a generic object that can be assigned to a callback at various points in the rendering process
CameraA node that can be positioned around in the scene graph to represent a point of view for rendering a scene
CardMakerThis class generates 2-d "cards", that is, rectangular polygons, particularly useful for showing textures etc
CConnectionRepositoryThis class implements the C++ side of the ConnectionRepository object
CConstrainHprIntervalA constraint interval that will constrain the orientation of one node to the orientation of another
CConstrainPosHprIntervalA constraint interval that will constrain the position and orientation of one node to the position and orientation of another
CConstrainPosIntervalA constraint interval that will constrain the position of one node to the position of another
CConstraintIntervalThe base class for a family of intervals that constrain some property to a value over time
CConstrainTransformIntervalA constraint interval that will constrain the transform of one node to the transform of another
GraphicsOutput::CData
Lens::CData
Texture::CData
CDistributedSmoothNodeBaseThis class defines some basic methods of DistributedSmoothNodeBase which have been moved into C++ as a performance optimization
CFChannelRepresents an open communication channel in the connected-frame protocol
CFCommandA single command in the Connected-Frame protocol
CFDoCullCommandStarts the cull process for a particular DisplayRegion
CharacterAn animated character, with skeleton-morph animation and either soft-skinned or hard-skinned vertices
CharacterJointThis represents one joint of the character's animation, containing an animating transform matrix
CharacterJointBundleThe collection of all the joints and sliders in the character
CharacterJointEffectThis effect will be added automatically to a node by CharacterJoint::add_net_transform() and CharacterJoint::add_local_transform()
CharacterMakerConverts an EggGroup hierarchy, beginning with a group with <Dart> set, to a character node with joints
CharacterSliderThis is a morph slider within the character
CharacterVertexSliderThis is a specialization on VertexSlider that returns the slider value associated with a particular CharacterSlider object
ChecksumHashGeneratorThis is a specific kind of HashGenerator that simply adds up all of the ints
PandaNode::Children
CIntervalThe base class for timeline components
CIntervalManagerThis object holds a number of currently-playing intervals and is responsible for advancing them each frame as needed
CircBuffer< Thing, max_size >This class implements a queue of some type via a circular buffer
CLerpAnimEffectIntervalThis interval lerps between different amounts of control effects for various AnimControls that might be playing on an actor
CLerpIntervalThe base class for a family of intervals that linearly interpolate one or more numeric values over time
CLerpNodePathIntervalAn interval that lerps one or more properties (like pos, hpr, etc.) on a NodePath over time
ClientAnalogDeviceA device, attached to the ClientBase by a AnalogNode, that records the data from a single named analog device
ClientBaseAn abstract base class for a family of client device interfaces--including trackers, buttons, dials, and other analog inputs
ClientButtonDeviceA device, attached to the ClientBase by a ButtonNode, that records the data from a single named button device
ClientDeviceAny of a number of different devices that might be attached to a ClientBase, including trackers, etc
ClientDialDeviceA device, attached to the ClientBase by a DialNode, that records the data from a single named dial device
ClientState
ClientTrackerDeviceA device, attached to the ClientBase by a TrackerNode, that records the data from a single tracker device
ClipPlaneAttribThis functions similarly to a LightAttrib
ClockObjectA ClockObject keeps track of elapsed real time and discrete time
CLwoClipThis class is a wrapper around LwoClip and stores additional information useful during the conversion-to-egg process
CLwoLayerThis class is a wrapper around LwoLayer and stores additional information useful during the conversion-to-egg process
CLwoPointsThis class is a wrapper around LwoPoints and stores additional information useful during the conversion-to-egg process
CLwoPolygonsThis class is a wrapper around LwoPolygons and stores additional information useful during the conversion-to-egg process
CLwoSurfaceThis class is a wrapper around LwoSurface and stores additional information useful during the conversion-to-egg process
CLwoSurfaceBlockThis class is a wrapper around LwoSurfaceBlock and stores additional information useful during the conversion-to-egg process
CLwoSurfaceBlockTMapThis class is a wrapper around LwoSurfaceBlockTMap and stores additional information useful during the conversion-to-egg process
CMetaIntervalThis interval contains a list of nested intervals, each of which has its own begin and end times
CMotionTrailThe method used in creating the motion trail is based on taking samples of time and transformations (the position and orientation matrix) in real-time
CMotionTrailFrame
CMotionTrailVertex
ColladaBindMaterialClass that deals with binding materials to COLLADA geometry
ColladaInputClass that deals with COLLADA data sources
ColladaLoaderObject that interfaces with the COLLADA DOM library and loads the COLLADA structures into Panda nodes
ColladaPrimitiveClass that deals with COLLADA primitive structures, such as <triangles> and <polylist>
CollisionHandlerPhysical::ColliderDef
CollisionLevelStateBase::ColliderDef
CollisionBoxA cuboid collision volume or object
CollisionEntryDefines a single collision event
CollisionEntrySorter
CollisionFloorMeshThis object represents a solid made entirely of triangles, which will only be tested again z axis aligned rays
CollisionGeomA special CollisionPolygon created just for the purpose of detecting collision against geometry
CollisionHandlerThe abstract interface to a number of classes that decide what to do when a collision is detected
CollisionHandlerEventA specialized kind of CollisionHandler that throws an event for each collision detected
CollisionHandlerFloorA 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
CollisionHandlerFluidPusherA CollisionHandlerPusher that makes use of timing and spatial information from fluid collisions to improve collision response
CollisionHandlerGravityA 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
CollisionHandlerHighestEventA specialized kind of CollisionHandler that throws an event for each collision detected
CollisionHandlerPhysicalThe 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
CollisionHandlerPusherA specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
CollisionHandlerQueueA special kind of CollisionHandler that does nothing except remember the CollisionEntries detected the last pass
CollisionInvSphereAn inverted sphere: this is a sphere whose collision surface is the inside surface of the sphere
CollisionLevelState< MaskType >This is the state information the CollisionTraverser retains for each level during traversal
CollisionLevelStateBaseThis is the state information the CollisionTraverser retains for each level during traversal
CollisionLineAn infinite line, similar to a CollisionRay, except that it extends in both directions
CollisionNodeA node in the scene graph that can hold any number of CollisionSolids
CollisionParabolaThis defines a parabolic arc, or subset of an arc, similar to the path of a projectile or falling object
CollisionPlane
CollisionPolygon
CollisionRayAn infinite ray, with a specific origin and direction
CollisionSegmentA finite line segment, with two specific endpoints but no thickness
CollisionSolidThe 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)
CollisionSolidUndefinedPair
CollisionSphereA spherical collision volume or object
CollisionTraverserThis class manages the traversal through the scene graph to detect collisions
CollisionTubeThis implements a solid roughly in cylindrical shape
color
DXFFile::Color
ColorAttribIndicates what color should be applied to renderable geometry
ColorBlendAttribThis specifies how colors are blended into the frame buffer, for special effects
PStatStripChart::ColorData
PStatCollectorDef::ColorDef
colorhist_item
colorhist_list_item
ColorInterpolationFunctionAbstract class from which all other functions should inherit
ColorInterpolationFunctionConstantDefines a constant color over the lifetime of the segment
ColorInterpolationFunctionLinearDefines a linear interpolation over the lifetime of the segment
ColorInterpolationFunctionSinusoidDefines a sinusoidal blending between two colors
ColorInterpolationFunctionStepwaveDefines a discrete cyclical transition between two colors
ColorInterpolationManagerHigh level class for color interpolation
ColorInterpolationSegmentA single unit of interpolation
ColorScaleAttribApplies a scale to colors in the scene graph and on vertices
ColorWriteAttribEnables or disables writing to the color buffer
compare_to< Key >An STL function object class, this is intended to be used on any ordered collection of class objects that contain a compare_to() method
CompareConfigDeclarations
CompareConfigPages
CompareLightPriorities
ComparePlaneNodePriorities
CompareTo< ObjectType >An STL function object class, this is intended to be used on any ordered collection of classes that contain a compare_to() method
CompassEffectA 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
RocketRenderInterface::CompiledGeometry
ConditionVarA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
ConditionVarDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
ConditionVarDummyImplA fake condition variable implementation for single-threaded applications that don't need any synchronization control
ConditionVarFullThis class implements a condition variable; see ConditionVar for a brief introduction to this class
ConditionVarFullDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
ConfigDeclarationA single declaration of a config variable, typically defined as one line in a .prc file, e.g
ConfigFlagsThis class is the base class of both ConfigVariable and ConfigVariableCore
ConfigPageA page of ConfigDeclarations that may be loaded or unloaded
ConfigPageManagerA global object that maintains the set of ConfigPages everywhere in the world, and keeps them in sorted order
ConfigurableAn object that has data or parameters that are set less frequently (at least occasionally) than every frame
ConfigVariableThis is a generic, untyped ConfigVariable
ConfigVariableBaseThis class is the base class for both ConfigVariableList and ConfigVariable (and hence for all of the ConfigVariableBool, ConfigVaribleString, etc
ConfigVariableBoolThis is a convenience class to specialize ConfigVariable as a boolean type
ConfigVariableCoreThe internal definition of a ConfigVariable
ConfigVariableDoubleThis is a convenience class to specialize ConfigVariable as a floating-point type
ConfigVariableEnum< EnumType >This class specializes ConfigVariable as an enumerated type
ConfigVariableFilenameThis is a convenience class to specialize ConfigVariable as a Filename type
ConfigVariableIntThis is a convenience class to specialize ConfigVariable as an integer type
ConfigVariableInt64This is a convenience class to specialize ConfigVariable as a 64-bit integer type
ConfigVariableListThis class is similar to ConfigVariable, but it reports its value as a list of strings
ConfigVariableManagerA global object that maintains the set of ConfigVariables (actually, ConfigVariableCores) everywhere in the world, and keeps them in sorted order
ConfigVariableSearchPathThis is similar to a ConfigVariableList, but it returns its list as a DSearchPath, as a list of directories
ConfigVariableStringThis is a convenience class to specialize ConfigVariable as a string type
ConnectionRepresents a single TCP or UDP socket for input or output
ConnectionListenerThis 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)
ConnectionListenerData
ConnectionManagerThe primary interface to the low-level networking layer in this package
ConnectionReaderThis 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)
ConnectionWriterThis class handles threaded delivery of datagrams to various TCP or UDP sockets
ConstPointerTo< T >A ConstPointerTo is similar to a PointerTo, except it keeps a const pointer to the thing
ConstPointerToArray< Element >Similar to PointerToArray, except that its contents may not be modified
ControllerDemoViewController
CopyOnWriteObj< Base >This is similar to RefCountObj, but it implements a CopyOnWriteObject inheritance instead of a ReferenceCount inheritance
CopyOnWriteObj1< Base, Param1 >For objects (e.g
CopyOnWriteObjectThis base class provides basic reference counting, but also can be used with a CopyOnWritePointer to provide get_read_pointer() and get_write_pointer()
CopyOnWritePointerThis safely stores the primary, owned pointer to a CopyOnWriteObject
CopyOnWritePointerTo< T >A template wrapper around the above class, mainly to handle the little typecasting niceties
CPointerCallbackObjectThis is a specialization on CallbackObject to allow association with a C-style function pointer and a void * parameter
CPU_ID
CPU_ID_BINARY_DATA
CPU_ID_BINARY_DATA_ARRAY
CPU_ID_REGISTERS
LMatrix3f::CRow
LMatrix4f::CRow
LMatrix3d::CRow
LMatrix4d::CRow
CubeFaceDef
CubicCurvesegA 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
CullableObjectThe smallest atom of cull
CullBinA collection of Geoms and their associated state, for a particular scene
CullBinAttribAssigns geometry to a particular bin by name
CullBinBackToFrontA specific kind of CullBin that sorts geometry in order from furthest to nearest based on the center of its bounding volume
CullBinEnumsProvides scoping for the enumerated type shared by CullBin and CullBinManager
CullBinFixedA specific kind of CullBin that sorts geometry in the order specified by the user-specified draw_order parameter
CullBinFrontToBackA specific kind of CullBin that sorts geometry in order from nearest to furthest based on the center of its bounding volume
CullBinManagerThis is a global object that maintains the collection of named CullBins in the world
CullBinStateSortedA 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
CullBinUnsortedA 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
CullFaceAttribIndicates which faces should be culled based on their vertex ordering
CullHandlerThis defines the abstract interface for an object that receives Geoms identified by the CullTraverser
CullPlanesThis 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
CullResultThis 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
CullTraverserThis object performs a depth-first traversal of the scene graph, with optional view-frustum culling, collecting CullState and searching for GeomNodes
CullTraverserDataThis collects together the pieces of data that are accumulated for each node while walking the scene graph during the cull traversal
CurveFitter
PiecewiseCurve::Curveseg
NurbsCurve::CV
CVSCopyThis 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
CVSSourceDirectoryThis represents one particular directory in the hierarchy of source directory files
CVSSourceTreeThis represents the root of the tree of source directory files
CycleDataA single page of data maintained by a PipelineCycler
CycleDataLockedReader< CycleDataType >This template class calls PipelineCycler::read() in the constructor and PipelineCycler::release_read() in the destructor
CycleDataLockedStageReader< CycleDataType >This class is similar to CycleDataLockedReader, except it allows reading from a particular stage of the pipeline
CycleDataReader< CycleDataType >This template class calls PipelineCycler::read_unlocked(), and then provides a transparent read-only access to the CycleData
CycleDataStageReader< CycleDataType >This class is similar to CycleDataReader, except it allows reading from a particular stage of the pipeline
CycleDataStageWriter< CycleDataType >This class is similar to CycleDataWriter, except it allows writing to a particular stage of the pipeline
CycleDataWriter< CycleDataType >This template class calls PipelineCycler::write() in the constructor and PipelineCycler::release_write() in the destructor
CyclerHolderA lightweight C++ object whose constructor calls acquire() and whose destructor calls release() on a PipelineCyclerBase object
CylindricalLensA cylindrical lens
DaeCharacterClass representing an animated character
DaeMaterialsThis class is seperated from the converter file because otherwise it would get too big and needlessly complicated
DAEToEggA program to read a DAE file and generate an egg file
DAEToEggConverterThis class supervises the construction of an EggData structure from a DAE file
DatagramAn ordered list of data elements, formatted in memory for transmission over a socket or writing to a data file
DatagramGeneratorThis class defines the abstract interace to any source of datagrams, whether it be from a file or from the net
DatagramGeneratorNetThis class provides datagrams one-at-a-time as read directly from the net, via a TCP connection
DatagramInputFileThis class can be used to read a binary file that consists of an arbitrary header followed by a number of datagrams
DatagramIteratorA class to retrieve the individual data elements previously stored in a Datagram
DatagramOutputFileThis class can be used to write a binary file that consists of an arbitrary header followed by a number of datagrams
DatagramQueueA thread-safe, FIFO queue of NetDatagrams
DatagramSinkThis class defines the abstract interface to sending datagrams to any target, whether it be into a file or across the net
DatagramSinkNetThis class accepts datagrams one-at-a-time and sends them over the net, via a TCP connection
DatagramTCPHeaderA class that encapsulates the extra bytes that are sent in front of each datagram to identify it when it is sent on TCP
DatagramUDPHeaderA class that encapsulates the extra bytes that are sent in front of each datagram to identify it when it is sent on UDP
DataGraphTraverserThis object supervises the traversal of the data graph and the moving of data from one DataNode to its children
DataNodeThe fundamental type of node for the data graph
DataNodeTransmitEncapsulates the data generated from (or sent into) any particular DataNode
CurveFitter::DataPoint
DownloadDb::Db
DCArrayParameterThis 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
DCAtomicFieldA single atomic field of a Distributed Class, as read from a .dc file
DCClassDefines a particular DistributedClass as read from an input .dc file
DCClassParameterThis represents a class (or struct) object used as a parameter itself
DCDeclarationThis is a common interface for a declaration in a DC file
DCFieldA single field of a Distributed Class, either atomic or molecular
DCFileRepresents the complete list of Distributed Class descriptions as read from a .dc file
DCKeywordThis represents a single keyword declaration in the dc file
DCKeywordListThis is a list of keywords (see DCKeyword) that may be set on a particular field
DCMolecularFieldA single molecular field of a Distributed Class, as read from a .dc file
DCNumericRange< NUM >Represents a range of legal integer or floating-point values
DConfigThis class emulates the old dconfig-style interface to our Panda config system
DCPackDataThis is a block of data that receives the results of DCPacker
DCPackerThis class can be used for packing a series of numeric and string data into a binary stream, according to the DC specification
DCPackerCatalogThis object contains the names of all of the nested fields available within a particular field
DCPackerInterfaceThis defines the internal interface for packing values into a DCField
DCParameterRepresents the type specification for a single parameter within a field specification
DCSimpleParameterThis is the most fundamental kind of parameter type: a single number or string, one of the DCSubatomicType elements
DCSwitchThis 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
DCSwitchParameterThis represents a switch object used as a parameter itself, which packs the appropriate fields of the switch into the message
DCTokenType
DCTypedefThis represents a single typedef declaration in the dc file
DDSCaps2
DDSHeader
DDSPixelFormat
DecalEffectApplied to a GeomNode to indicate that the children of this GeomNode are coplanar and should be drawn as decals (eliminating Z-fighting)
Declaration
DeferredNodePropertyThis class keeps track of all the state we must make note of during the graph traversal, but cannot apply immediately
DeletedBufferChainThis template class can be used to provide faster allocation/deallocation for many Panda objects
DeletedChain< Type >This template class can be used to provide faster allocation/deallocation for many Panda objects
DepthOffsetAttribThis 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
DepthTestAttribEnables or disables writing to the depth buffer
DepthWriteAttribEnables or disables writing to the depth buffer
InterrogateType::Derivation
DestTextureImageThis represents a texture filename as it has been resized and copied to the map directory (e.g
DialNodeThis is the primary interface to infinite dial type devices associated with a ClientBase
ClientDialDevice::DialState
DInput8Info
DInput9Info
DirectDDirectD is a client/server app for starting panda/direct
DirectDClientDirectDClient is a test app for DriectDServer
DirectDServerStart a directdServer on each of the machines you which to start panda on
DirectionalLightA light shining from infinitely far away in a particular direction, like sunlight
DiscEmitterDescribes a planar disc region from which particles are generated
DISPLAY_FORMAT
DisplayInformationThis class contains various display information
DisplayMode
DisplayRegionA rectangular subregion within a window for rendering into
DisplayRegionBaseAn abstract base class for DisplayRegion, mainly so we can store DisplayRegion pointers in a Camera
DisplayRegionCullCallbackDataThis specialization on CallbackData is passed when the callback is initiated from the cull traversal, for a DisplayRegion
DisplayRegionDrawCallbackDataThis specialization on CallbackData is passed when the callback is initiated from the draw traversal, for a DisplayRegion
DisplayRegionPipelineReaderEncapsulates the data from a DisplayRegion, pre-fetched for one stage of the pipeline
DisplaySearchParametersParameters used for searching display capabilities
DocumentSpecA descriptor that refers to a particular version of a document
DoubleAlmostMatchesAn STL function object to determine if a double is vert nearly equal the supplied value
DoubleBitMask< BMType >This is a special BitMask type that is implemented as a pair of lesser BitMask types, to present a double-wide bit mask
DoublesAlmostEqualAn STL function object to determine if two doubles are very nearly equal
PandaNode::DownConnection
DownList
DownloadDbA listing of files within multifiles for management of client-side synchronization with a server-provided set of files
DrawableRegionThis is a base class for GraphicsWindow (actually, GraphicsOutput) and DisplayRegion, both of which are conceptually rectangular regions into which drawing commands may be issued
DrawCullHandlerThis special kind of CullHandler immediately draws its contents as soon as it receives them
DriveInterfaceThis is a TFormer, similar to Trackball, that moves around a transform matrix in response to mouse input
DSearchPathThis class stores a list of directories that can be searched, in order, to locate a particular file
DXFFileA generic DXF-reading class
DXFLayerThis represents a "layer" as read from the DXF file
DXFLayerMapA map of string (layer name) to DXFLayer: that is, the layers of a file ordered by name
DXFPointsA simple program to read a dxf file and list the points contained within it to a text file
DXFToEggA program to read a DXF file and generate an egg file
DXFToEggConverterThis class supervises the construction of an EggData structure from a DXF file
DXFToEggLayerThe specialization of DXFLayer used by DXFToEggConverter
DXFVertexStored within DXFFile, this is the basic Vertex data of a DXF file
DXGeomMunger8This specialization on GeomMunger finesses vertices for DirectX rendering
DXGeomMunger9This specialization on GeomMunger finesses vertices for DirectX rendering
DXGraphicsDevice8A GraphicsDevice necessary for multi-window rendering in DX
DXGraphicsDevice9A GraphicsDevice necessary for multi-window rendering in DX
DXGraphicsStateGuardian8A GraphicsStateGuardian for rendering into DirectX8 contexts
DXGraphicsStateGuardian9A GraphicsStateGuardian for rendering into DirectX9 contexts
DXIndexBufferContext8Caches a GeomPrimitive in the DirectX device as an index buffer
DXIndexBufferContext9Caches a GeomPrimitive in the DirectX device as an index buffer
DXOcclusionQueryContext9
DXScreenData
DXShaderContext9Xyz
DXTextureContext8
DXTextureContext9
DXVertexBufferContext8Caches a GeomVertexArrayData in the DirectX device as a vertex buffer
EAGLView
EaseInBlendType
EaseInOutBlendType
EaseOutBlendType
EggAnimDataA base class for EggSAnimData and EggXfmAnimData, which contain rows and columns of numbers
EggAnimPreloadThis corresponds to an <AnimPreload> entry
EggAttributesThe set of attributes that may be applied to vertices as well as polygons, such as surface normal and color
EggBackPointerThis stores a pointer from an EggJointData or EggSliderData object back to the referencing data in an egg file
EggBaseThis is a base class for both EggSingleBase and EggMultiBase
EggBinA type of group node that holds related subnodes
EggBinMakerThis is a handy class for collecting related nodes together
EggBinMakerCompareNodesThis is just an STL function object, used to sort nodes within EggBinMaker
EggBinnerA special binner used only within this package to pre-process the egg tree for the loader and group things together as appropriate
EggCharacterCollectionRepresents a set of characters, as read and collected from possibly several model and/or animation egg files
EggCharacterDataRepresents a single character, as read and collected from several models and animation files
EggCharacterDbThis class is used during joint optimization or restructuring to store the table of interim joint computations
EggCharacterFilterThis is the base class for a family of programs that operate on a number of character models and their associated animation files together
EggCommentA comment that appears in an egg file within a <Comment> entry
EggComponentDataThis is the base class of both EggJointData and EggSliderData
EggCompositePrimitiveThe 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
EggConverterThis is a general base class for programs that convert between egg files and some other format
EggCoordinateSystemThe <CoordinateSystem> entry at the top of an egg file
EggCropA program to read an egg file and write an equivalent egg file, possibly performing some minor operations along the way
EggCurveA parametric curve of some kind
EggDataThis is the primary interface into all the egg data, and the root of the egg file structure
EggExternalReferenceDefines a reference to another egg file which should be inserted at this point
EggFileThis represents a single egg file known to the palettizer
EggFilenameNodeThis is an egg node that contains a filename
EggFilterThis is the base class for a program that reads an egg file, operates on it, and writes another egg file out
EggGroupThe main glue of the egg hierarchy, this corresponds to the <Group>, <Instance>, and <Joint> type nodes
EggGroupNodeA base class for nodes in the hierarchy that are not leaf nodes
EggGroupUniquifierThis is a specialization of EggNameUniquifier to generate unique names for EggGroup nodes
EggCharacterCollection::EggInfo
EggJointDataThis 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
EggJointNodePointerThis stores a pointer back to a <Joint> node
EggJointPointerThis is a base class for EggJointNodePointer and EggMatrixTablePointer
EggLineA line segment, or a series of connected line segments, defined by a <Line> entry
EggListTexturesReads an egg file and outputs the list of textures it uses
EggLoaderConverts an egg data structure, possibly read from an egg file but not necessarily, into a scene graph suitable for rendering
EggMakeFontThis program uses FreeType to generate an egg file and a series of texture images from a font file input, such as a TTF file
EggMakeSomethingA base class for a family of programs that generate egg models of various fundamental shapes
EggMakeTubeA program to generate an egg file representing a tube model, similar in shape to a CollisionTube
EggMaterial
EggMaterialCollectionThis is a collection of materials by MRef name
EggMatrixTablePointerThis stores a pointer back to an EggXfmSAnim table (i.e
EggMesherCollects together unrelated EggPrimitives, determines their edge connectivity, and generates a set of EggTriangleStrips that represent the same geometry
EggMesherEdgeRepresents one edge of a triangle, as used by the EggMesher to discover connected triangles
EggMesherFanMakerThis class is used by EggMesher::find_fans() to attempt to make an EggTriangleFan out of the polygons connected to the indicated vertex
EggMesherStripRepresents a triangle strip or quad strip in progress, as assembled by the mesher
EggMorph< Parameter >A single <Dxyz> or <Duv> or some such entry
EggMorphList< MorphType >A collection of <Dxyz>'s or <Duv>'s or some such
EggMultiBaseThis specialization of ProgramBase is intended for programs that read and/or write multiple egg files
EggMultiFilterThis 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)
EggNamedObjectThis is a fairly low-level base class--any egg object that has a name
EggNameUniquifierThis is a handy class for guaranteeing unique node names in an egg hierarchy
EggNodeA base class for things that may be directly added into the egg hierarchy
EggNurbsCurveA parametric NURBS curve
EggNurbsSurfaceA parametric NURBS surface
EggObjectThe highest-level base class in the egg directory
EggOptcharPerforms basic optimizations of a character model and its associated animations, by analyzing the animation tables and removing unneeded joints and/or morphs
EggOptcharUserDataThis class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the maya converter
EggPalettizeThis is the program wrapper for egg-palettize, but it mainly serves to read in all the command-line parameters and then invoke the Palettizer
EggParametersThe values stored in this structure are global parameters that control some aspects of the egg library
EggPointA single point, or a collection of points as defined by a single <PointLight> entry
EggPolygonA single polygon
EggPolysetMakerA specialization on EggBinMaker for making polysets that share the same basic rendering characteristic
EggPoolUniquifierThis is a specialization of EggNameUniquifier to generate unique names for textures, materials, and vertex pools prior to writing out an egg file
EggPrimitiveA base class for any of a number of kinds of geometry primitives: polygons, point lights, nurbs patches, parametrics curves, etc
EggQtessA program to tesselate NURBS surfaces appearing within an egg file into polygons, using variations on a quick uniform tesselation
EggReaderThis is the base class for a program that reads egg files, but doesn't write an egg file
EggRenameA program to read an egg file and write an equivalent egg file, with stripping prefix for now, but more along the way
EggRenderModeThis 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
EggRenderStateThis class is used within this package only to record the render state that should be assigned to each primitive
EggRetargetAnimRetargets 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
EggSAnimDataCorresponding 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
EggScalarTablePointerThis stores a pointer back to an EggSAnimData table (i.e
EggSingleBaseThis specialization of EggBase is intended for programs that read and/or write a single egg file
EggSliderDataThis corresponds to a single morph slider control
EggSliderPointerThis is a base class for EggVertexPointer and EggScalarTablePointer
EggSurfaceA parametric surface of some kind
EggSwitchConditionThis corresponds to a <SwitchCondition> entry within a group
EggSwitchConditionDistanceA SwitchCondition that switches the levels-of-detail based on distance from the camera's eyepoint
EggTableThis corresponds to a
EggTextureDefines a texture map that may be applied to geometry
EggTextureCardsGenerates an egg file featuring a number of polygons, one for each named texture
EggTextureCollectionThis is a collection of textures by TRef name
EggToBam
EggToC
EggToDAEA program to read an egg file and write a DAE file
EggToDXFA program to read an egg file and write a DXF file
EggToDXFLayerA single layer in the DXF file to be written by EggToDXF
EggToFltA program to read an egg file and write a flt file
EggTokenType
EggToMayaA program to read an egg file and write a maya file
EggTopstripReads a character model and/or animations and strips out the animation from one of the top joints from the entire character
EggToSomethingThis is the general base class for a file-converter program that reads some model file format and generates an egg file
EggToXA program to read in a egg file and write an equivalent, or nearly equivalent, DirectX-style "x" file
EggTransA program to read an egg file and write an equivalent egg file, possibly performing some minor operations along the way
EggTransformThis 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
EggTriangleFanA connected fan of triangles
EggTriangleStripA connected strip of triangles
EggUserDataThis is a base class for a user-defined data type to extend egg structures in processing code
EggVertexAny one-, two-, three-, or four-component vertex, possibly with attributes such as a normal
EggVertexAuxThe set of named auxiliary data that may or may not be assigned to a vertex
EggVertexPointerThis stores a pointer back to a <Vertex>, or to a particular pritimive like a <Polygon>, representing a morph offset
EggVertexPoolA collection of vertices
EggVertexUVThe set of UV's that may or may not be assigned to a vertex
EggWriterThis is the base class for a program that generates an egg file output, but doesn't read any for input
EggXfmAnimDataCorresponding to an <Xfm$Anim> entry, this stores a two-dimensional table with up to nine columns, one for each component of a transformation
EggXfmSAnimThis 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
eglGraphicsBufferAn offscreen buffer in the EGL environment
eglGraphicsPipeThis graphics pipe represents the interface for creating OpenGL ES graphics windows on an X-based (e.g
eglGraphicsPixmapAnother offscreen buffer in the EGL environment
eglGraphicsStateGuardianA tiny specialization on GLESGraphicsStateGuardian to add some egl-specific information
eglGraphicsWindowAn interface to the egl system for managing GLES windows under X
DCPackerCatalog::Entry
UnicodeLatinMap::Entry
InterrogateType::EnumValue
Evade
EventA named event, possibly with parameters
SubprocessWindowBuffer::Event
EventHandlerA class to monitor events from the C++ side of things
EventParameterAn optional parameter associated with an event
EventQueueA queue of pending events
EventReceiverAn abstract base class for anything that might care about receiving events
CallbackGraphicsWindow::EventsCallbackData
EventStorePandaNodeA class object for storing specifically objects of type PandaNode
EventStoreTypedRefCountA class object for storing specifically objects of type TypedReferenceCount, which is different than TypedWritableReferenceCount
EventStoreValue< Type >A handy class object for storing simple values (like integers or strings) passed along with an Event
EventStoreValueBaseA non-template base class of EventStoreValue (below), which serves mainly to define the placeholder for the virtual output function
ExecutionEnvironmentEncapsulates access to the environment variables and command-line arguments at the time of execution
ExternalThreadThe special "external thread" class
ExtractorThis class automatically extracts the contents of a Multifile to the current directory (or to a specified directory) in the background
OdeTriMeshData::FaceNormal
Factory< Type >A Factory can be used to create an instance of a particular subclass of some general base class
FactoryBaseA Factory can be used to create an instance of a particular subclass of some general base class
FactoryParamThe 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
FactoryParamsAn instance of this class is passed to the Factory when requesting it to do its business and construct a new something
FadeLODNodeA Level-of-Detail node with alpha based switching
FadeLODNodeDataThis is the data that is associated with a particular instance of the FadeLODNode for the scene graph
fake_istream_buffer
FFTCompressorThis 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)
VrmlNode::Field
FileDef
FilenameThe name of a file, such as a texture file or an Egg file
FilenameUnifierThis static class does the job of converting filenames from relative to absolute to canonical or whatever is appropriate
CVSSourceTree::FilePath
DownloadDb::FileRecord
FileReferenceKeeps a reference-counted pointer to a file on disk
FilterProperties::FilterConfig
FilterPropertiesStores a configuration for a set of audio DSP filters
FindApproxLevelEntryThis class is local to this package only; it doesn't get exported
FindApproxPathThis class is local to this package only; it doesn't get exported
FiniteBoundingVolumeA special kind of GeometricBoundingVolume that is known to be finite
first_of_pair_iterator< pair_iterator >This is an iterator adaptor that converts any iterator that returns a pair (e.g
FirstOfPairCompare< ObjectType, Compare >An STL function object class, this is intended to be used on any ordered collection of pairs of objects
FirstOfPairLess< ObjectType >An STL function object class, this is intended to be used on any ordered collection of pairs of objects
FisheyeLensA fisheye lens
FisheyeMakerThis 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
Flee
floating_point_hash< Key >This hash_compare class hashes a float or a double
floating_point_threshold< Key >Compares two floating point numbers, within threshold of equivalence
FlockThis class is used to define the flock attributes and the AI characters which are part of the flock
FltBeadA base class for any of a broad family of flt records that represent particular beads in the hierarchy
FltBeadIDA base class for any of a broad family of flt beads that include an ID
FltCopyA program to copy Multigen .flt files into the cvs tree
FltCurveA single curve, like a Bezier or B-Spline
FltExternalReferenceAn external reference to another flt file (possibly to a specific bead within the flt file)
FltEyepointA single eyepoint entry in the eyepoint/trackplane palette
FltFaceA single face bead, e.g
FltGeometryThis 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
FltGroupThe main grouping bead of the flt file
FltHeaderThis is the first bead in the file, the top of the bead hierarchy, and the primary interface to reading and writing a Flt file
FltInfoA program to read a flt file and report interesting things about it
FltInstanceDefinitionThis special kind of record marks the top node of an instance subtree
FltInstanceRefThis bead appears in the hierarchy to refer to a FltInstanceDefinition node defined elsewhere
FltLightSourceDefinitionRepresents a single entry in the light source palette
FltLocalVertexPoolA local vertex pool, as might appear in the middle of the hierarchy, for instance for a mesh
FltLODA Level-of-Detail record
FltMaterialRepresents a single material in the material palette
FltMeshA mesh of connected polygons and tristrips, etc., with a local vertex pool
FltMeshPrimitiveA single primitive of a mesh, like a triangle strip or fan
FltObjectThe main objecting bead of the flt file
FltPackedColorA packed color record, A, B, G, R
FltRecordThe base class for all kinds of records in a MultiGen OpenFlight file
FltRecordReaderThis class turns an istream into a sequence of FltRecords by reading a sequence of Datagrams and extracting the opcode from each one
FltRecordWriterThis class writes a sequence of FltRecords to an ostream, handling opcode and size counts properly
FltTextureRepresents a single texture in the texture palette
FltToEggA program to read a flt file and generate an egg file
FltToEggConverterThis class supervises the construction of an EggData structure from the data represented by the FltHeader
FltToEggLevelStateThis keeps track of relevant things about the traversal as we walk through the flt hierarchy
FltTrackplaneA single trackplane entry in the eyepoint/trackplane palette
FltTransA program to read a flt file and write an equivalent flt file, possibly performing some minor operations along the way
FltTransformGeneralMatrixA general 4x4 matrix
FltTransformPutA "put", which is a MultiGen concept of defining a transformation by mapping three arbitrary points to three new arbitrary points
FltTransformRecordA base class for a number of types of ancillary records that follow beads and indicate some kind of a transformation
FltTransformRotateAboutEdgeA transformation that rotates about a particular axis in space, defined by two endpoints
FltTransformRotateAboutPointA transformation that rotates about a particular axis in space, defined by a point and vector
FltTransformRotateScaleA combination rotation and scale
FltTransformScaleA transformation that applies a (possibly nonuniform) scale
FltTransformTranslateA transformation that applies a translation
FltUnsupportedRecord
FltVectorRecordThis is an ancillary record of the old (pre-15.4) face node
FltVertexRepresents a single vertex in the vertex palette
FltVertexListA list of vertices, typically added as a child of a face bead
FogSpecifies how atmospheric fog effects are applied to geometry
FogAttribApplies a Fog to the geometry at and below this node
FontPoolThis is the preferred interface for loading fonts for the TextNode system
ForceNodeA force that lives in the scene graph and is therefore subject to local coordinate systems
FrameBufferPropertiesA container for the various kinds of properties we might ask to have on a graphics frameBuffer before we create a GSG
XFileAnimationSet::FrameData
XFileAnimationSet::FrameEntry
FrameRateMeterThis is a special TextNode that automatically updates itself with the current frame rate
FrameSampleThis 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
GenericAsyncTaskAssociates a generic C-style function pointer with an AsyncTask object
GenericThreadA generic thread type that allows calling a C-style thread function without having to subclass
GeomA container for geometry primitives
GeomCacheEntryThis object contains a single cache entry in the GeomCacheManager
GeomCacheManagerThis 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
GeomContextThis is a special class object that holds all the information returned by a particular GSG to indicate the geom's internal context identifier
GeomDrawCallbackDataThis specialization on CallbackData is passed when the callback is initiated from deep within the draw traversal, for a particular Geom
GeomNode::GeomEntry
GeomEnumsThis class exists just to provide scoping for the various enumerated types used by Geom, GeomVertexData, GeomVertexArrayData, GeomPrimitive, and other related classes
GeometricBoundingVolumeThis 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
GeoMipTerrainGeoMipTerrain, meaning Panda3D GeoMipMapping, can convert a heightfield image into a 3D terrain, consisting of several GeomNodes
GeomLinesDefines a series of disconnected line segments
GeomLinestripsDefines a series of line strips
GeomMungerObjects of this class are used to convert vertex data from a Geom into a format suitable for passing to the rendering backend
GeomNodeA node that holds Geom objects, renderable pieces of geometry
GeomParticleRenderer
GeomPipelineReaderEncapsulates the data from a Geom, pre-fetched for one stage of the pipeline
GeomPointsDefines a series of disconnected points
GeomPrimitiveThis is an abstract base class for a family of classes that represent the fundamental geometry primitives that may be stored in a Geom
GeomPrimitivePipelineReaderEncapsulates the data from a GeomPrimitive, pre-fetched for one stage of the pipeline
GeomNode::Geoms
GeomTransformerAn 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
GeomTrianglesDefines a series of disconnected triangles
GeomTrifansDefines a series of triangle fans
GeomTristripsDefines a series of triangle strips
GeomVertexAnimationSpecThis object describes how the vertex animation, if any, represented in a GeomVertexData is encoded
GeomVertexArrayDataThis is the data for one array of a GeomVertexData structure
GeomVertexArrayDataHandleThis data object is returned by GeomVertexArrayData::get_handle() or modify_handle()
GeomVertexArrayFormatThis describes the structure of a single array within a Geom data
GeomVertexColumnThis defines how a single column is interleaved within a vertex array stored within a Geom
GeomVertexDataThis defines the actual numeric vertex data stored in a Geom, in the structure defined by a particular GeomVertexFormat object
GeomVertexDataPipelineBaseThe common code from GeomVertexDataPipelineReader and GeomVertexDataPipelineWriter
GeomVertexDataPipelineReaderEncapsulates the data from a GeomVertexData, pre-fetched for one stage of the pipeline
GeomVertexDataPipelineWriterEncapsulates the data from a GeomVertexData, pre-fetched for one stage of the pipeline
GeomVertexFormatThis class defines the physical layout of the vertex data stored within a Geom
GeomVertexReaderThis object provides a high-level interface for quickly reading a sequence of numeric values from a vertex table
GeomVertexRewriterThis object provides the functionality of both a GeomVertexReader and a GeomVertexWriter, combined together into one convenient package
GeomVertexWriterThis object provides a high-level interface for quickly writing a sequence of numeric values from a vertex table
FltTexture::GeospecificControlPoint
GLContext
GLLight
GLList
GLMaterial
GlobalPointerRegistryThis class maintains a one-to-one mapping from TypeHandle to a void * pointer
GlobPatternThis class can be used to test for string matches against standard Unix-shell filename globbing conventions
GLParam
GLParamBuffer
GLScissor
GLSpecBuf
GLTexture
GLVertex
GLViewport
GLXBufferClobberEventSGIX
glxGraphicsBufferAn offscreen buffer in the GLX environment
glxGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on an X-based (e.g
glxGraphicsPixmapAnother offscreen buffer in the GLX environment
glxGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some glx-specific information
glxGraphicsWindowAn interface to the glx system for managing GL windows under X
GraphicsBufferAn offscreen buffer for rendering into
GraphicsDeviceAn abstract device object that is part of Graphics Pipe
GraphicsEngineThis class is the main interface to controlling the render process
GraphicsOutputThis is a base class for the various different classes that represent the result of a frame of rendering
GraphicsOutputBaseAn abstract base class for GraphicsOutput, for all the usual reasons
GraphicsPipeAn object to create GraphicsOutputs that share a particular 3-D API
GraphicsPipeSelectionThis maintains a list of GraphicsPipes by type that are available for creation
GraphicsStateGuardianEncapsulates all the communication with a particular instance of a given rendering backend
GraphicsStateGuardianBaseThis is a base class for the GraphicsStateGuardian class, which is itself a base class for the various GSG's for different platforms
GraphicsThreadingModelThis represents the user's specification of how a particular frame is handled by the various threads
GraphicsWindowA window, fullscreen or on a desktop, into which a graphics device sends its output for interactive display
GraphicsWindowInputDeviceThis is a structure representing a single input device that may be associated with a window
GraphicsWindowProcDefines an interface for storing platform-specific window processor methods
GraphicsWindowProcCallbackDataThis specialization on CallbackData is passed when the callback is initiated from from an implementation of the GraphicsWindowProc class, such as PythonGraphicsWindowProc
gridded_file_info
GriddedFilename
GroupRefEntryA temporary class used in EggVertex::write(), below, to hold the groups that reference each vertex prior to outputting them as a formatted list
GtkStatsChartMenuA pulldown menu of charts available for a particular thread
GtkStatsGraphThis 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
GtkStatsLabelA text label that will draw in color appropriate for a particular collector
GtkStatsLabelStackA widget that contains a stack of labels from bottom to top
GtkStatsMonitorThis class represents a connection to a PStatsClient and manages the data exchange with the client
GtkStatsPianoRollA window that draws a piano-roll style chart, which shows the collectors explicitly stopping and starting, one frame at a time
GtkStatsServerThe class that owns the main loop, waiting for client connections
GtkStatsStripChartA window that draws a strip chart, given a view
PStatGraph::GuideBar
HashGeneratorThis class generates an arbitrary hash number from a sequence of ints
HashGeneratorBaseThis is the base class for a number of classes that generate arbitrary hash numbers for complex objects, based fundamentally on a sequence of integers
HashValStores a 128-bit value that represents the hashed contents (typically MD5) of a file or buffer
Header
HeightfieldTesselatorConverts a height field in the form of a greyscale image into a scene consisting of a number of GeomNodes
HermiteCurveA parametric curve defined by a sequence of control vertices, each with an in and out tangent
HermiteCurveCVA single CV of a Hermite curve
HideIntervalAn interval that calls NodePath::hide()
PNMImageHeader::Histogram
Http_BufferedReader
Http_Request
HttpConnection
HTTPDateA container for an HTTP-legal time/date indication
HTTPEntityTagA container for an "entity tag" from an HTTP server
IffChunkThe basic kind of record in an EA "IFF" file, which the LightWave object file is based on
IffGenericChunkA class for a generic kind of IffChunk that is not understood by a particular IffReader
IffIdA four-byte chunk ID appearing in an "IFF" file
IffInputFileA wrapper around an istream used for reading an IFF file
ImageBaseThis specialization of ProgramBase is intended for programs that read and/or write a single image file
ImageFileThis is the base class of both TextureImage and PaletteImage
ImageFilterThis is the base class for a program that reads an image file, operates on it, and writes another image file out
ImageFixHiddenColorThis program repairs an image's RGB values hidden behind an A value of 0
ImageInfoThis program reads the headers of a series of one or more images and reports their sizes to standard output
ImageReaderThis is the base class for a program that reads an image file, but doesn't write an image file
ImageResizeA program to read an image file and resize it to a larger or smaller image file
ImageTransA program to read an image file and write an equivalent image file, possibly performing some minor operations along the way
ImageTransformColorsThis program can apply a 4x4 color transform to all of the colors in the pixels of a series of images
ImageWriterThis is the base class for a program that generates an image file output, but doesn't read any for input
IndexBufferContextThis 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
IndexedFaceSetDecodes the vertices and faces in a VRML indexed face set, and creates the corresponding egg geometry
IndexRemapperThis class manages a mapping of integers to integers
indirect_compare_names< Key >An STL function object class, this is intended to be used on any ordered collection of pointers to classes that define a get_name() method, particularly for things that derive from Namable
indirect_compare_names_hash< Key >
indirect_compare_to< Key >An STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain a compare_to() method
indirect_compare_to_hash< Key >
indirect_less< Key >An STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator <() method
indirect_less_hash< Key >
indirect_method_hash< Key, Compare >This hash_compare class hashes a pointer to a class object
IndirectCompareNames< ObjectType >An STL function object class, this is intended to be used on any ordered collection of pointers to classes that define a get_name() method, particularly for things that derive from Namable
IndirectCompareSort< ObjectType >An STL function object class, this is intended to be used on any ordered collection of pointers to classes that define a get_sort() method
IndirectCompareTo< ObjectType >An STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain a compare_to() method
IndirectLess< ObjectType >An STL function object class, this is intended to be used on any ordered collection of pointers to classes that contain an operator <() method
EggFilenameNode::IndirectOrderByBasename
InitDtoolutil
InitMemoryHook
InkblotVideoA cellular automaton that generates an amusing pattern of swirling colors
InkblotVideoCursorA cellular automaton that generates an amusing pattern of swirling colors
SpeedTreeNode::InstanceList
integer_hash< Key, Compare >This is the default hash_compare class, which assumes the Key is a size_t value or can be implicitly converted to a size_t value (for instance, via a size_t typecast operator)
InternalNameEncodes a string name in a hash table, mapping it to a pointer
InternalNameCollection
STBasicTerrain::InterpolationData< ValueType >
InterrogateComponentThe base class for things that are part of the interrogate database
InterrogateDatabaseThis stores all of the interrogate data and handles reading the data from a disk file when necessary
InterrogateElementAn internal representation of a data element, like a data member or a global variable
InterrogateFunctionAn internal representation of a function
InterrogateFunctionWrapperAn internal representation of a callable function
InterrogateMakeSeqRepresents a synthetic method created via the MAKE_SEQ() macro
InterrogateManifestAn internal representation of a manifest constant
InterrogateModuleDef
InterrogateTypeAn internal representation of a type
InterrogateUniqueNameDef
IntersectionBoundingVolumeThis special bounding volume is the intersection of all of its constituent bounding volumes
NativeWindowHandle::IntHandle
IoPtaDatagramFloatThis class is used to read and write a PTA_stdfloat from a Datagram, in support of Bam
IoPtaDatagramIntThis class is used to read and write a PTA_int from a Datagram, in support of Bam
IoPtaDatagramShortThis class is used to read and write a PTA_ushort from a Datagram, in support of Bam
IPhoneGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on the various IPHONE's
IPhoneGraphicsStateGuardian
IPhoneGraphicsWindowAn interface to the osx/ system for managing GL windows under X
IPipeStream
IsLocalVertexSplitter
IsoPlacerContains the logic used to place isoparams where they'll do the most good on a surface
IStreamWrapperThis class provides a locking wrapper around an arbitrary istream pointer
istringstream
ISubStreamAn istream object that presents a subwindow into another istream
JointVertexTransformThis is a specialization on VertexTransform that returns the transform necessary to move vertices as if they were assigned to the indicated joint
KeyboardButtonThis class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard keyboard keys
KeyNumber
LensA base class for any number of different kinds of lenses, linear and otherwise
LensNodeA node that contains a Lens
LensNode::LensSlot
LerpBlendType
less
LFrustumd
LightThe abstract interface to all kinds of lights
LightAttribIndicates which set of lights should be considered "on" to illuminate geometry at this level and below
LightLensNodeA derivative of Light and of Camera
LightMutexThis is a standard, non-reentrant mutex, similar to the Mutex class
LightMutexDirectThis class implements a lightweight Mutex by making direct calls to the underlying implementation layer
LightMutexHolderSimilar to MutexHolder, but for a light mutex
LightNodeA derivative of Light and of PandaNode
LightRampAttribA Light Ramp is any unary operator that takes a rendered pixel as input, and adjusts the brightness of that pixel
LightReMutexA lightweight reentrant mutex
LightReMutexDirectThis class implements a standard lightReMutex by making direct calls to the underlying implementation layer
LightReMutexHolderSimilar to MutexHolder, but for a light reentrant mutex
LinearControlForceSimple directed vector force
LinearCylinderVortexForceDefines a cylinder inside of which all forces are tangential to the theta of the particle wrt the z-axis in local coord
LinearDistanceForcePure virtual class for sinks and sources
LinearEulerIntegratorPerforms Euler integration on a vector of physically modelable objects given a quantum dt
LinearForceA force that acts on a PhysicsObject by way of an Integrator
LinearFrictionForceFriction-based drag force
LinearIntegratorPure virtual base class for physical modeling
LinearJitterForceCompletely random noise force vector
LinearNoiseForceRepeating noise force vector
LinearRandomForcePure virtual, parent to noiseForce and jitterForce
LinearSinkForceAttractor force
LinearSourceForceRepellant force
LinearUserDefinedForceProgrammable force that takes an evaluator fn
LinearVectorForceSimple directed vector force
LineEmitterDescribes a linear region in which particles are generated
LineParticleRendererRenders a line from last position to current position -- good for rain, sparks, etc
LineSegsEncapsulates creation of a series of connected or disconnected line segments or points, for drawing paths or rays
LineStreamThis is a special ostream that writes to a memory buffer, like ostrstream
LineStreamBufUsed 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
LinkedListNodeThis just stores the pointers to implement a doubly-linked list of some kind of object
DCPackerCatalog::LiveCatalog
DCPackerCatalog::LiveCatalogEntry
LMatrix3dThis is a 3-by-3 transform matrix
LMatrix3fThis is a 3-by-3 transform matrix
LMatrix4dThis is a 4-by-4 transform matrix
LMatrix4fThis is a 4-by-4 transform matrix
LoaderA 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)
LoaderFileTypeThis is the base class for a family of scene-graph file types that the Loader supports
LoaderFileTypeAssimpThis defines the Loader interface that uses the Assimp library to load various model formats
LoaderFileTypeBamThis defines the Loader interface to read Bam files
LoaderFileTypeDaeThis defines the Loader interface to read Dae files
LoaderFileTypeEggThis defines the Loader interface to read Egg files
LoaderFileTypePandatoolThis defines the Loader interface to files whose converters are defined within the Pandatool package and inherit from SomethingToEggConverter, like FltToEggConverter and LwoToEggConverter
LoaderFileTypeRegistryThis class maintains the set of all known LoaderFileTypes in the universe
LoaderFileTypeSrtThis defines the Loader interface to read SpeedTree SRT files, which describe a single tree
LoaderFileTypeStfThis defines the Loader interface to read SpeedTree STF files--a simple text file that describes a forest of trees (references to SRT files)
LoaderOptionsSpecifies parameters that may be passed to the loader
LODInstance
LODNodeA Level-of-Detail node
FltTexture::LODScale
LONG_INTEGER
LOrientationdThis is a unit quaternion representing an orientation
LOrientationfThis is a unit quaternion representing an orientation
LParaboladAn abstract mathematical description of a parabola, particularly useful for describing arcs of projectiles
LPlanedAn abstract mathematical description of a plane
LPoint2dThis is a two-component point in space
LPoint2fThis is a two-component point in space
LPoint3dThis is a three-component point in space (as opposed to a three-component vector, which represents a direction and a distance)
LPoint3fThis is a three-component point in space (as opposed to a three-component vector, which represents a direction and a distance)
LPoint4dThis is a four-component point in space
LPoint4fThis is a four-component point in space
LQuaterniondThis is the base quaternion class
LQuaternionfThis is the base quaternion class
LRotationdThis is a unit quaternion representing a rotation
LRotationfThis is a unit quaternion representing a rotation
LruLeast Recently Used algorithm implementation: In the Lru, each "memory page" has an associated class LruPage
LruPage
LSimpleMatrix< FloatType, NumRows, NumCols >This class provides an underlying storage of the various linear-algebra classes (e.g
LVecBase2dThis is the base class for all two-component vectors and points
LVecBase2fThis is the base class for all two-component vectors and points
LVecBase3dThis is the base class for all three-component vectors and points
LVecBase3fThis is the base class for all three-component vectors and points
LVecBase4dThis is the base class for all three-component vectors and points
LVecBase4fThis is the base class for all three-component vectors and points
LVector2dThis is a two-component vector offset
LVector2fThis is a two-component vector offset
LVector3dThis is a three-component vector distance (as opposed to a three-component point, which represents a particular point in space)
LVector3fThis is a three-component vector distance (as opposed to a three-component point, which represents a particular point in space)
LVector4dThis is a four-component vector distance
LVector4fThis is a four-component vector distance
LwoBoundingBoxStores the bounding box for the vertex data in a layer
LwoChunkA specialization of IffChunk for Lightwave Object files
LwoClipA single image file, or a numbered sequence of images (e.g
LwoDiscontinuousVertexMapA mapping of floating-point values per integer index
LwoGroupChunkA particular kind of LwoChunk that is expected to contain an arbitrary number of child chunks
LwoHeaderThe first chunk in a Lightwave Object file
LwoInputFileA specialization of IffInputFile to handle reading a Lightwave Object file
LwoLayerSignals the start of a new layer
LwoPointsAn array of points that will be referenced by later chunks
LwoPolygonsAn array of polygons that will be referenced by later chunks
LwoPolygonTagsAn association of polygons defined in the most recent LwoPolygons chunk to tag ids defined in the most recent LwoTags chunk
LwoScanA program to read a Lightwave file and report its structure and contents
LwoStillImageA single still image associated with a LwoClip chunk
LwoSurfaceDescribes the shading attributes of a surface
LwoSurfaceBlockA texture layer or shader, part of a LwoSurface chunk
LwoSurfaceBlockAxisIndicates the axis for this particular shader's projection
LwoSurfaceBlockChannelIndicates which channel the texture in this LwoSurfaceBlock is applied to
LwoSurfaceBlockCoordSysSpecifies whether texture coordinates are computed based on the vertices' world coordinates or local coordinates
LwoSurfaceBlockEnabledIndicates whether this particular layer or shader should be rendered or not
LwoSurfaceBlockHeaderThe header chunk within a LwoSurfaceBlock chunk
LwoSurfaceBlockImageSpecifies the particular image that is being applied as a texture
LwoSurfaceBlockOpacityIndicates how transparent or opaque this particular layer is in relation to the layers beneath it
LwoSurfaceBlockProjectionIndicates the projection mode for this particular shader
LwoSurfaceBlockRefObjSpecifies a reference object that the texture UV's are to be computed relative to
LwoSurfaceBlockRepeatFor cylindrical and spherical projections, this parameter controls how many times the image repeats over each full interval, in either dimension
LwoSurfaceBlockTMapThe tMap chunk within a LwoSurfaceBlock chunk
LwoSurfaceBlockTransformSpecifies a center point, scale, or rotation for the texture coordinates in this shader's texture mapping
LwoSurfaceBlockVMapNameSpecifies the name of a set of UV's defined on the polygons that use this model
LwoSurfaceBlockWrapSpecifies how the texture image appears for areas outside the image
LwoSurfaceColorRecords the base color of a surface, as an entry within a LwoSurface chunk
LwoSurfaceParameterRecords some parameter value of a surface material, as an entry within a LwoSurface chunk
LwoSurfaceSidednessRecords whether polygons are frontfacing only or backfacing also
LwoSurfaceSmoothingAngleIndicates the maximum angle (in radians) between adjacent polygons that should be smooth-shaded
LwoTagsAn array of tag strings that will be referenced by later chunks
LwoToEggA program to read a Lightwave file and generate an egg file
LwoToEggConverterThis class supervises the construction of an EggData structure from the data represented by the LwoHeader
LwoVertexMapA mapping of floating-point values per integer index
M3
M34
M4
MainThreadThe special "main thread" class
mallinfo
MaterialDefines the way an object appears in the presence of lighting
MaterialAttribIndicates which, if any, material should be applied to geometry
MaterialCollection
MaterialPoolThe 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
MathNumbers
MatrixLensA completely generic linear lens
MaxEggImporter
MaxEggImporterClassDesc
MaxEggJoint
MaxEggLoader
MaxEggMesh
MaxEggOptions
MaxEggPlugin
MaxEggPluginClassDesc
MaxEggPluginCreateMouseCallBack
MaxEggTex
MaxEggVertex
MaxNodeDescDescribes a single instance of a node in the Max scene graph, relating it to the corresponding egg structures (e.g
MaxNodeTreeDescribes a complete tree of max nodes for conversion
MaxOptionsDialog
MaxToEggConverterThis class supervises the construction of an EggData structure from a Max model
MayaAnim
MayaApiThis class presents a wrapper around the global Maya interface
MayaBlendDescA handle to a Maya blend shape description
MayaCopyA program to copy Maya .mb files into the cvs tree
MayaEggGeom
MayaEggGroup
MayaEggGroupUserDataThis class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the maya converter
MayaEggImporter
MayaEggJoint
MayaEggLoader
MayaEggMesh
MayaEggNurbsSurface
MayaEggTex
MayaEggVertex
MayaNodeDescDescribes a single instance of a node in the Maya scene graph, relating it to the corresponding egg structures (e.g
MayaNodeTreeDescribes a complete tree of maya nodes for conversion
MayaPviewThis class serves as a plug-in to Maya to allow viewing the current Maya selection as it will be converted to Panda
MayaSavePviewThis 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
MayaShaderCorresponds to a single "shader" in Maya
MayaShaderColorDefThis defines the various attributes that Maya may associate with the "color" channel for a particular shader (as well as on the "transparency" channel)
MayaShadersCollects the set of MayaShaders that have been encountered so far
MayaToEgg
MayaToEggClient
MayaToEggConverterThis class supervises the construction of an EggData structure from a single Maya file, or from the data already in the global Maya model space
MayaToEggServer
MemBufferThis 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
MemoryBaseThis 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
MemoryHookThis class provides a wrapper around the various possible malloc schemes Panda might employ
WinStatsMonitor::MenuDef
GtkStatsMonitor::MenuDef
Mersenne
MeshDrawerMesh drawer creates a single geom object that can be shaped with different draw commands
MeshDrawer2DThis class allows the drawing of 2d objects - mainly based on quads and rectangles
method_hash< Key, Compare >This hash_compare class hashes a class object
MEV_Compare
MicrophoneAudioClass MicrophoneAudio provides the means to read raw audio samples from a microphone
ModelFlattenRequestThis class object manages a single asynchronous request to flatten a model
ModelLoadRequestA class object that manages a single asynchronous model load request
ModelNodeThis 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
ModelPoolThis class unifies all references to the same filename, so that multiple attempts to load the same model will return the same pointer
ModelRoot::ModelReference
ModelRootA node of this type is created automatically at the root of each model file that is loaded
ModifierButtonsThis class monitors the state of a number of individual buttons and tracks whether each button is known to be down or up
MouseAndKeyboardReads the mouse and/or keyboard data sent from a GraphicsWindow, and transmits it down the data graph
MouseButtonThis class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard mouse buttons
MouseDataHolds the data that might be generated by a 2-d pointer input device, such as the mouse in the GraphicsWindow
x11GraphicsWindow::MouseDeviceInfo
MouseInterfaceNodeThis is the base class for some classes that monitor the mouse and keyboard input and perform some action due to their state
MouseRecorderThis 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)
MouseSubregionThe MouseSubregion object scales the mouse inputs from within a rectangular region of the screen, as if they were the full-screen inputs
MouseWatcherThis TFormer maintains a list of rectangular regions on the screen that are considered special mouse regions; typically these will be click buttons
MouseWatcherGroupThis represents a collection of MouseWatcherRegions that may be managed as a group
MouseWatcherParameterThis is sent along as a parameter to most events generated for a region to indicate the mouse and button state for the event
MouseWatcherRegionThis is the class that defines a rectangular region on the screen for the MouseWatcher
MovieAudioA MovieAudio is actually any source that provides a sequence of audio samples
MovieAudioCursorA MovieAudio is actually any source that provides a sequence of audio samples
MovieVideoA MovieVideo is actually any source that provides a sequence of video frames
MovieVideoCursorA MovieVideo is actually any source that provides a sequence of video frames
MovingPart< SwitchType >This is the template instantiation of MovingPartBase, on the particular type of value provided by the channel
MovingPartBaseThis is the base class for a single animatable piece that may be bound to one channel (or more, if blending is in effect)
MovingPartMatrixThis is a particular kind of MovingPart that accepts a matrix each frame
MovingPartScalarThis is a particular kind of MovingPart that accepts a scalar each frame
MultifileA file that contains a set of files
DownloadDb::MultifileRecord
MultiplexStreamThis 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
MultiplexStreamBufUsed by MultiplexStream to implement an ostream that sends what is written to it to any number of additional sources, like other ostreams
MultitexReducerThis 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
MutexA standard mutex, or mutual exclusion lock
MutexDirectThis class implements a standard mutex by making direct calls to the underlying implementation layer
MutexDummyImplA fake mutex implementation for single-threaded applications that don't need any synchronization control
MutexHolderA lightweight C++ object whose constructor calls acquire() and whose destructor calls release() on a mutex
NamableA base class for all things which can have a name
NamableOrderByNameAn STL function object for sorting an array of pointers to Namables into order by name
VrmlNodeType::NameTypeRec
NameUniquifierA handy class for converting a list of arbitrary names (strings) so that each name is guaranteed to be unique in the list
NativeNumericDataNativeNumericData 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
NativeWindowHandleThis subclass of WindowHandle exists to allow simple creation of a WindowHandle of the appropriate type to the current OS
SampleClass::NestedClass
NetAddressRepresents a network address to which UDP packets may be sent or to which a TCP socket may be bound
NetDatagramA specific kind of Datagram, especially for sending across or receiving from a network
NeverFreeMemoryThis class is used to allocate bytes of memory from a pool that is never intended to be freed
NoBlendType
AICharPool::node
NodeThis class is used to assign the nodes on the mesh
NodeCachedReferenceCountThis 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
NodeConstPointerTo< T >A NodeConstPointerTo is similar to a NodePointerTo, except it keeps a const pointer to the thing
NodeCullCallbackDataThis kind of CallbackData is passed to the CallbackObject added to CallbackNode:set_cull_callback()
NodePathNodePath is the fundamental system for disambiguating instances, and also provides a higher-level interface for manipulating the scene graph
NodePathCollectionThis is a set of zero or more NodePaths
NodePathComponentThis is one component of a NodePath
NodePointerTo< T >This implements the special NodePointerTo template class, which works just like PointerTo except it manages the objects node_ref_count instead of the normal ref_count
NodePointerToBase< T >This is similar to PointerToBase, but it manages objects of type NodeReferenceCount or NodeCachedReferenceCount, and it updates the node_ref_count instead of the regular ref_count
NodeRefCountObj< Base >This works like RefCountObj, but it inherits from NodeReferenceCount instead of ReferenceCount
NodeReferenceCountThis 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
NodeVertexTransformThis VertexTransform gets its matrix from the Transform stored on a node
NonlinearImagerThis class object combines the rendered output of a 3-d from one or more linear (e.g
NotifyAn object that handles general error reporting to the user
NotifyCategoryA particular category of error messages
NotifyCategoryProxy< GetCategory >A handy wrapper around a NotifyCategory pointer
NullAudioManager
NullAudioSound
NurbsBasisVectorThis encapsulates a series of matrices that are used to represent the sequential segments of a NurbsCurveEvaluator
NurbsCurveA Nonuniform Rational B-Spline
NurbsCurveEvaluatorThis class is an abstraction for evaluating NURBS curves
NurbsCurveInterfaceThis abstract class defines the interface only for a Nurbs-style curve, with knots and coordinates in homogeneous space
NurbsCurveResultThe result of a NurbsCurveEvaluator
NurbsSurfaceEvaluatorThis class is an abstraction for evaluating NURBS surfaces
NurbsSurfaceResultThe result of a NurbsSurfaceEvaluator
NurbsVertexThis represents a single control vertex in a NurbsEvaluator
ObjToEggA program to read a Obj file and generate an egg file
ObjToEggConverterConvert an Obj file to egg data
ObstacleAvoidance
OccluderEffectThis functions similarly to a LightAttrib or ClipPlaneAttrib
OccluderNodeA node in the scene graph that can hold an occluder polygon, which must be a rectangle
OcclusionQueryContextReturned from a GSG in response to begin_occlusion_query()
OdeAMotorJoint
OdeBallJoint
OdeBody
OdeBoxGeom
OdeCappedCylinderGeom
OdeCollisionEntryA class used to hold information about a collision that has occurred
OdeContact
OdeContactGeom
OdeContactJoint
OdeConvexGeom
OdeCylinderGeom
OdeFixedJoint
OdeGeom
OdeHashSpace
OdeHeightfieldGeom
OdeHinge2Joint
OdeHingeJoint
OdeJoint
OdeJointCollection
OdeJointFeedback
OdeJointGroup
OdeLMotorJoint
OdeMass
OdeNullJoint
OdePlane2dJoint
OdePlaneGeom
OdeQuadTreeSpace
OdeRayGeom
OdeSimpleSpace
OdeSliderJoint
OdeSpace
OdeSphereGeom
OdeSurfaceParameters
OdeTriMeshData
OdeTriMeshGeom
OdeUniversalJoint
OdeUtil
OdeWorld
OmniBoundingVolumeThis is a special kind of GeometricBoundingVolume that fills all of space
OPipeStream
option
ordered_vector< Key, Compare >This template class presents an interface similar to the STL set or multiset (and ov_set and ov_multiset are implemented specifically, below), but it is implemented using a vector that is kept always in sorted order
OrderJointsByNewDepth
OrientedParticleDescribes a particle that has angular characteristics (velocity, orientation)
OrientedParticleFactoryCreates particles that are affected by angular forces
OrthographicLensAn orthographic lens
WindowHandle::OSHandle
OsMesaGraphicsBufferAn offscreen buffer using direct calls to Mesa
OsMesaGraphicsPipeThis graphics pipe represents the interface for rendering with direct calls to the Mesa open-source software-only implementation of OpenGL
OSMesaGraphicsStateGuardianA tiny specialization on MesaGraphicsStateGuardian to add a reference to the OSMesaContext
OSphereLensA OSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
OStreamWrapperThis class provides a locking wrapper around an arbitrary ostream pointer
ostringstream
OSubStreamAn ostream object that presents a subwindow into another ostream
osxGraphicsBufferAn offscreen buffer in the OSX environment
osxGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on the various OSX's
osxGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some wgl-specific information
osxGraphicsWindowAn interface to the osx/ system for managing GL windows under X
ov_multiset< Key, Compare >A specialization of ordered_vector that emulates a standard STL set: many copies of each element are allowed
ov_set< Key, Compare >A specialization of ordered_vector that emulates a standard STL set: one copy of each element is allowed
PageTypeStatistics
PaletteGroupThis is the highest level of grouping for TextureImages
PaletteGroupsA set of PaletteGroups
PaletteImageThis is a single palette image, one of several within a PalettePage, which is in turn one of several pages within a PaletteGroup
PalettePageThis is a particular collection of textures, within a PaletteGroup, that all share the same TextureProperties
PalettizerThis is the main engine behind egg-palettize
PandaFrameworkThis 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.)
PandaGetoptThe implementation within this file of the various getopt() functions
PandaIOStreamCustom implementation of Assimp::IOStream
PandaIOSystemCustom implementation of Assimp::IOSystem
PandaLoggerCustom implementation of Assimp::Logger
PandaNodeA basic node of the scene graph or data graph
PandaNodeChainThis class maintains a linked list of PandaNodes
PandaNodePipelineReaderEncapsulates the data from a PandaNode, pre-fetched for one stage of the pipeline
PandaSystemThis class is used as a namespace to group several global properties of Panda
InterrogateFunctionWrapper::Parameter
ParametricCurveA virtual base class for parametric curves
ParametricCurveCollectionThis is a set of zero or more ParametricCurves, which may or may not be related
ParasiteBufferThis 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
PandaNode::Parents
ParsedHttpRequest
PartBundleThis is the root of a MovingPart hierarchy
PartBundleHandleThis is a trivial class returned by PartBundleNode::get_bundle()
PartBundleNodeThis is a node that contains a pointer to an PartBundle
PartGroupThis is the base class for PartRoot and MovingPart
PartGroupAlphabeticalOrder
ParticleSystemContains and manages a particle system
ParticleSystemManagerManages 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
PartSubsetThis class is used to define a subset of part names to apply to the PartBundle::bind_anim() operation
PathFindThis class contains all the members and functions that are required to form an interface between the AIBehaviors class and the PathFinder class
PathFinderThis class implements pathfinding using A* algorithm
PathFollow
PathReplaceThis encapsulates the user's command-line request to replace existing, incorrect pathnames to models and textures from a file with correct pathnames
PerlinNoiseThis is the base class for PerlinNoise2 and PerlinNoise3, different dimensions of Perlin noise implementation
PerlinNoise2This class provides an implementation of Perlin noise for 2 variables
PerlinNoise3This class provides an implementation of Perlin noise for 3 variables
PerspectiveLensA perspective-type lens: a normal camera
PfmBbaGenerates a bounding-box description of a pfm file
PfmFileDefines a pfm file, a 2-d table of floating-point numbers, either 3-component or 1-component
PfmTransOperates on a pfm file
PGButtonThis is a particular kind of PGItem that is specialized to behave like a normal button object
PGButtonNotifyObjects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
PGCullTraverserThis is a specialization of CullTraverser for use within the pgui system
PGEntryThis 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
PGFrameStyle
PGItemThis is the base class for all the various kinds of gui widget objects
PGItemNotifyObjects that inherit from this class can receive specialized messages when PGItems change in certain ways
PGMouseWatcherBackgroundThis 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
PGMouseWatcherGroupThis is a specialization on MouseWatcherGroup, to associate it with a PGTop
PGMouseWatcherParameterThis 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
PGMouseWatcherRegionThis is a specialization on MouseWatcherRegion, to add a bit more fields that are relevant to the PG system
PGScrollFrameThis is a special kind of frame that pretends to be much larger than it actually is
PGSliderBarThis 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
PGSliderBarNotifyObjects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
PGTopThe "top" node of the new Panda GUI system
PGVirtualFrameThis represents a frame that is rendered as a window onto another (possibly much larger) canvas
PGWaitBarThis 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
PhysicalDefines a set of physically modeled attributes
PhysicalNodeGraph node that encapsulated a series of physical objects
PhysicsCollisionHandlerA specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
PhysicsManagerPhysics don't get much higher-level than this
PhysicsObjectA body on which physics will be applied
PhysicsObjectCollectionThis is a set of zero or more PhysicsObjects
PhysxActorActors are the main simulation objects
PhysxActorDescDescriptor for PhysxActor
PhysxBodyDescDescriptor for the optional rigid body dynamic state of PhysxActor
PhysxBounds3Represention of a axis aligned bounding box
PhysxBoxRepresents an oriented bounding box, as a center point, extents(radii) and a rotation
PhysxBoxControllerBox character controller
PhysxBoxControllerDescDescriptor class for PhysxBoxController
PhysxBoxForceFieldShapeA box shaped region used to define a force field
PhysxBoxForceFieldShapeDescDescriptor for a box force field shape
PhysxBoxShapeA box shaped collision detection primitive
PhysxBoxShapeDescDescriptor class for PhysxBoxShape
PhysxCapsuleRepresents a capsule
PhysxCapsuleControllerA capsule character controller
PhysxCapsuleControllerDescDescriptor class for PhysxCapsuleController
PhysxCapsuleForceFieldShapeA capsule shaped region used to define a force field
PhysxCapsuleForceFieldShapeDescDescriptor for a capsule force field shape
PhysxCapsuleShapeA capsule shaped collision detection primitive, also known as a line swept sphere
PhysxCapsuleShapeDescDescriptor class for PhysxCapsuleShape
PhysxCloth
PhysxClothDescDescriptor for PhysxCloth
PhysxClothMesh
PhysxClothMeshDesc
PhysxClothNodeRenderable geometry which represents a cloth mesh
PhysxConstraintDominanceExpresses the dominance relationship of a constraint
PhysxContactPairAn instance of this class is send with contact reporting events
PhysxContactPointA helper structure for iterating over contact streams reported by PhysxContactPair
PhysxContactReportImplementation of the NxUserContactReport interface
PhysxControllerAbstract base class for character controllers
PhysxControllerDescDescriptor class for a character controller
PhysxControllerReportImplementation of the NxUserControllerHitReport interface
PhysxConvexForceFieldShapeA convex shaped region used to define force field
PhysxConvexForceFieldShapeDescA descriptor for a convex force field shape
PhysxConvexMeshA Convex Mesh
PhysxConvexMeshDesc
PhysxConvexShapeA shapes which is used to represent an instance of an convex mesh
PhysxConvexShapeDescDescriptor class for PhysxConvexShape
PhysxCylindricalJointCylindrical Joints permit relative translational movement between two bodies along an axis, and also relative rotation along the axis
PhysxCylindricalJointDescDescriptor class for sliding joint
PhysxD6JointA D6 joint is a general constraint between two actors
PhysxD6JointDesc
PhysxDebugGeomNodeRenderable geometry which represents visualizations of physics objects
PhysxDistanceJointA distance joint maintains a certain distance between two points on two actors
PhysxDistanceJointDescDescriptor class for distance joint
PhysxEnumsThis class exists just to provide scoping for the enums shared by PhysX classes
PhysxFileStream
PhysxFixedJointA fixed joint permits no relative movement between two bodies
PhysxFixedJointDescDescriptor class for fixed joint
PhysxForceFieldA force field effector
PhysxForceFieldDescDescriptor class for force fields
PhysxForceFieldShapeAbstract base class for force field shapes
PhysxForceFieldShapeDescAbstract base class for descriptors for force field shapes descriptors
PhysxForceFieldShapeGroup
PhysxForceFieldShapeGroupDesc
PhysxGroupsMask128-bit bitmask class
PhysxHeightFieldA height field object
PhysxHeightFieldDescDescriptor class for height fields
PhysxHeightFieldShapeThis class is a shape instance of a height field object of type PhysxHeightField
PhysxHeightFieldShapeDescDescriptor class for PhysxHeightFieldShape
PhysxJointAbstract base class for the different types of joints
PhysxJointDescAbstract base class for joint descriptors
PhysxJointDriveDescUsed to describe drive properties for a PhysxD6Joint
PhysxJointLimitDescDescribes a joint limit
PhysxJointLimitSoftDescDescribes a joint limit
PhysxKitchen
PhysxLinearInterpolationValues
PhysxManagerThe central interface to the PhysX subsystem
PhysxMask32-bit bitmask class
PhysxMaterialA class for describing a shape's surface properties
PhysxMaterialDescDescriptor class for materials
PhysxMemoryReadBuffer
PhysxMemoryWriteBuffer
PhysxMeshHashUtility class used in building links between a tetrahedron mesh (soft body) and a triangle mesh used for rendering the soft body
PhysxMeshPoolThis class unifies all references to the same filename, so that multiple attempts to load the same mesh will return the same pointer
PhysxMotorDescDescribes a joint motor
PhysxObject
PhysxObjectCollection< T >
PhysxOverlapReportObjects of this class are returned by the 'overlap shape' methods, for example overlapSphereShapes
PhysxPlane
PhysxPlaneShapeA plane collision detection primitive
PhysxPlaneShapeDescDescriptor class for PhysxPlaneShape
PhysxPointInPlaneJointA point in plane joint constrains a point on one body to only move inside a plane attached to another body
PhysxPointInPlaneJointDescDescriptor class for point-in-plane joint
PhysxPointOnLineJointA point on line joint constrains a point on one body to only move along a line attached to another body
PhysxPointOnLineJointDescDescriptor class for point-on-line joint
PhysxPrismaticJointA prismatic joint permits relative translational movement between two bodies along an axis, but no relative rotational movement
PhysxPrismaticJointDescDescriptor class for prismatic joint
PhysxPulleyJointA pulley joint simulates a rope between two objects passing over two pulleys
PhysxPulleyJointDescDescriptor class for distance joint
PhysxRayRepresents an ray as an origin and direction
PhysxRaycastHitThis structure captures results for a single raycast query
PhysxRaycastReportObjects of this class are returned by the 'raycast all' methods
PhysxRevoluteJointA joint which behaves in a similar way to a hinge or axel
PhysxRevoluteJointDescDescriptor class for distance joint
PhysxSceneA scene is a collection of bodies, constraints, and effectors which can interact
PhysxSceneDescDescriptor for PhysxScene
PhysxSceneStats2
PhysxSegmentRepresents a line segment
PhysxShapeAbstract base class for shapes
PhysxShapeDescAbstract base class for shape descriptors
PhysxSoftBody
PhysxSoftBodyDescDescriptor for PhysxSoftBody
PhysxSoftBodyMesh
PhysxSoftBodyMeshDesc
PhysxSoftBodyNodeRenderable geometry which represents a soft body mesh
PhysxSphereRepresents a sphere defined by its center point and radius
PhysxSphereForceFieldShapeA spherical force field shape
PhysxSphereForceFieldShapeDescA descriptor for a sphere force field shape
PhysxSphereShapeA sphere shaped collision detection primitive
PhysxSphereShapeDescDescriptor class for PhysxSphereShape
PhysxSphericalJointA sphere joint constrains two points on two bodies to coincide
PhysxSphericalJointDescDescriptor class for distance joint
PhysxSpringDescDescribes a joint spring
PhysxTriangleMesh
PhysxTriangleMeshDesc
PhysxTriangleMeshShapeA shapes which is used to represent an instance of an convex mesh
PhysxTriangleMeshShapeDescDescriptor class for PhysxTriangleMeshShape
PhysxTriggerReportImplementation of the NxUserTriggerReport interface
PhysxUserEntityReport
PhysxUtilLib
PhysxVehicle
PhysxVehicleDesc
PhysxWheel
PhysxWheelDesc
PhysxWheelShapeA special shape used for simulating a car wheel
PhysxWheelShapeDescDescriptor class for PhysxWheelShape
PiecewiseCurveA PiecewiseCurve is a curve made up of several curve segments, connected in a head-to-tail fashion
PipelineThis 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
PipelineCycler< CycleDataType >This class maintains different copies of a page of data between stages of the graphics pipeline (or any other pipelining context)
PipelineCyclerLinksThis just stores the pointers to implement a doubly-linked list of PipelineCyclers for a particular Pipeline object
PipelineCyclerTrivialImplThis is the trivial, non-threaded implementation of PipelineCyclerBase
PipeOcclusionCullTraverserThis specialization of CullTraverser uses the graphics pipe itself to perform occlusion culling
PipeStreamBuf
pixel
PNMImageHeader::PixelSpec
PNMImageHeader::PixelSpecCount
PlaneNodeA node that contains a plane
PNMBlendImageBrush
PNMBlendPixelBrush
PNMBrushThis class is used to control the shape and color of the drawing operations performed by a PNMPainter object
PNMDarkenImageBrush
PNMDarkenPixelBrush
PNMFileTypeThis is the base class of a family of classes that represent particular image file types that PNMImage supports
PNMFileTypeRegistryThis class maintains the set of all known PNMFileTypes in the universe
PNMImageThe 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
PNMImageBrush
PNMImageHeaderThis is the base class of PNMImage, PNMReader, and PNMWriter
PNMLightenImageBrush
PNMLightenPixelBrush
PNMPainterThis class provides a number of convenient methods for painting drawings directly into a PNMImage
PNMPixelBrush
PNMReaderThis is an abstract base class that defines the interface for reading image files of various types
PNMSetImageBrush
PNMSetPixelBrush
PNMTextGlyphA single glyph in a PNMTextMaker
PNMTextMakerThis object uses the Freetype library to generate text directly into an image
PNMTransparentBrush
PNMWriterThis is an abstract base class that defines the interface for writing image files of various types
CollisionBox::PointDef
PointEmitterDescribes a planar ring region in which particles are generated
pointer_hashThis is the default hash_compare class, which assumes the Key is a pointer value
PointerEventRecords a pointer movement event
PointerEventListRecords a set of pointer events that happened recently
PointerTo< T >PointerTo is a template class which implements a smart pointer to an object derived from ReferenceCount
PointerToArray< Element >A special kind of PointerTo that stores an array of the indicated element type, instead of a single element
PointerToArrayBase< Element >This is the base class for PointerToArray and ConstPointerToArray
PointerToBase< T >This is the base class for PointerTo and ConstPointerTo
PointerToVoidThis is the non-template part of the base class for PointerTo and ConstPointerTo
PointLightA light originating from a single point in space, and shining in all directions
PointParticleDescribes a particle that requires representation by a point (pixel, sparkle, billboard)
PointParticleFactoryCreates point particles to user specs
PointParticleRendererSimple point/point particle renderer
LwoPolygons::Polygon
PolylightEffectA PolylightEffect can be used on a node to define a LightGroup for that node
PolylightNodeA PolylightNode
PortalClipperThis object performs a depth-first traversal of the scene graph, with optional view-frustum culling, collecting CullState and searching for GeomNodes
PortalNodeA node in the scene graph that can hold a Portal Polygon, which is a rectangle
PosixGraphicsStateGuardianThis 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
PreparedGraphicsObjectsA table of objects that are saved within the graphics context for reference by handle later
PrimeNumberGeneratorThis class generates a table of prime numbers, up to the limit of an int
ProfileTimer
ProgramBaseThis is intended to be the base class for most general-purpose utility programs in the PANDATOOL tree
ProjectionScreenA ProjectionScreen implements a simple system for projective texturing
CallbackGraphicsWindow::PropertiesCallbackData
PSphereLensA PSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
PStatClientManages the communications to report statistics via a network connection to a remote PStatServer
PStatClientControlMessageThis kind of message is sent from the client to the server on the TCP socket to establish critical control information
PStatClientDataThe data associated with a particular client, but not with any one particular frame or thread: the list of collectors and threads, for instance
PStatClientVersionRecords the version number of a particular client
PStatCollectorA lightweight class that represents a single element that may be timed and/or counted via stats
PStatCollectorDefDefines the details about the Collectors: the name, the suggested color, etc
PStatCollectorForwardThis class serves as a cheap forward reference to a PStatCollector, so that classes that are defined before the pstats module may access the PStatCollector
PStatCollectorForwardBaseThis 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)
PStatFrameDataContains the raw timing and level data for a single frame
PStatGraphThis is an abstract base class for several different kinds of graphs that have a few things in common, like labels and guide bars
PStatListenerThis is the TCP rendezvous socket listener
PStatMonitorThis is an abstract class that presents the interface to any number of different front-ends for the stats monitor
PStatPianoRollThis 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
PStatReaderThis is the class that does all the work for handling communications from a single Panda client
Thread::PStatsCallback
PStatServerThe overall manager of the network connections
PStatServerControlMessageThis kind of message is sent from the server to the client on the TCP socket to establish critical control information
PStatStripChartThis 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
PStatThreadA lightweight class that represents a single thread of execution to PStats
PStatThreadDataA collection of FrameData structures for recently-received frames within a particular thread
PStatTimerA lightweight class that can be used to automatically start and stop a PStatCollector around a section of code
PStatViewA View boils down the frame data to a linear list of times spent in a number of different Collectors, within a particular thread
PStatViewLevelThis is a single level value, or band of color, within a View
Pursue
PviewAppDelegate
PythonGraphicsWindowProcExtends GraphicsWindowProc to provde callback functionality to a python program
QtessGlobalsSimply used as a namespace to scope some global variables for this program, set from the command line
QtessInputEntryStores one entry in the qtess input file
QtessInputFileStores all the information read from a tesselation input file: a list of QtessInputEntry's
QtessSurfaceA 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
QueryContextThis is a base class for queries that might require a round-trip to the graphics engine
QueuedConnectionListenerThis flavor of ConnectionListener will queue up all of the TCP connections it established for later detection by the client code
QueuedConnectionManagerThis 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
QueuedConnectionReaderThis flavor of ConnectionReader will read from its sockets and queue up all of the datagrams read for later receipt by the client code
QueuedReturn< Thing >This is the implementation of a family of things that queue up their return values for later retrieval by client code, like QueuedConnectionReader, QueuedConnectionListener, QueuedConnectionManager
RamfileAn in-memory buffer specifically designed for downloading files to memory
Texture::RamImage
RandomizerA handy class to return random numbers
RangeDescriptionThis describes a sparse range of Unicode character codes for conversion that may be specified on the command line
RangeIteratorWalks through all the Unicode characters described by a RangeDescription class
RecentConnectionReaderThis flavor of ConnectionReader will read from its sockets and retain only the single most recent datagram for inspection by client code
RecorderBaseThis 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
RecorderControllerThis object manages the process of recording the user's runtime inputs to a bam file so that the session can be recreated later
RecorderFrameThis object represents one frame of data in the recorded session file
RecorderHeaderThis object contains the header information written out at the beginning of a recorded session file
RecorderTableThis object is used by the RecorderController to write (and read) a record of the set of recorders in use to the bam file
AwWebView::RectA simple rectangle class, used with WebView::render
RectangleEmitterDescribes a planar square region in which particles are generated
RefCountObj< Base >Another kind of proxy, similar to RefCountProxy
RefCountProxy< Base >A "proxy" to use to make a reference-countable object whenever the object cannot inherit from ReferenceCount for some reason
ReferenceCountA base class for all things that want to be reference-counted
ReferenceCountedVector< Element >This defines the object that is actually stored and reference-counted internally by a PointerToArray
ButtonRegistry::RegistryNode
RemoveNodeCB
ReMutexA reentrant mutex
ReMutexDirectThis class implements a standard reMutex by making direct calls to the underlying implementation layer
ReMutexHolderSimilar to MutexHolder, but for a reentrant mutex
RenderAttribThis 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
RenderAttribRegistryThis 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
RenderBufferA RenderBuffer is an arbitrary subset of the various layers (depth buffer, color buffer, etc.) of a drawing region
CallbackGraphicsWindow::RenderCallbackData
RenderEffectThis 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
RenderEffectsThis represents a unique collection of RenderEffect objects that correspond to a particular renderable state
RenderModeAttribSpecifies how polygons are to be drawn
RenderStateThis represents a unique collection of RenderAttrib objects that correspond to a particular renderable state
GraphicsOutput::RenderTexture
RescaleNormalAttribSpecifies how polygons are to be drawn
respawn_record_struct
CullBin::ResultGraphBuilder
DSearchPath::Results
Loader::Results
ReversedNumericDataNativeNumericData 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
RigidBodyCombinerThis 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
RingBufferThis is an implemention of the membuffer with ring buffer interface on it...
RingBuffer_SlideThis is an implemention of the membuffer with ring buffer interface on it...
RingEmitterDescribes a planar ring region in which particles are generated
RocketFileInterface
RocketInputHandlerDataNode that listens for keyboard and mouse events and passes them to libRocket
RocketRegionRepresents a region in a window or buffer where the libRocket UI will be rendered to
RocketRenderInterfaceClass that provides the main render interface for libRocket integration
RocketSystemInterface
RopeNodeThis class draws a visible representation of the NURBS curve stored in its NurbsCurveEvaluator
LMatrix3f::Row
LMatrix4f::Row
LMatrix4d::Row
LMatrix3d::Row
SampleClassA basic description of the function and purpose of SampleClass
SmoothMover::SamplePoint
SavedContextThis is the base class for all GSG-specific context objects, such as TextureContext and GeomContext
sBodyParams
SceneGraphAnalyzerA handy class that can scrub over a scene graph and collect interesting statistics on it
SceneGraphAnalyzerMeterThis is a special TextNode that automatically updates itself with output from a SceneGraphAnalyzer instance
SceneGraphReducerAn interface for simplifying ("flattening") scene graphs by eliminating unneeded nodes and collapsing out unneeded state changes and transforms
SceneSetupThis object holds the camera position, etc., and other general setup information for rendering a particular scene
ScissorAttribThis restricts rendering to within a rectangular region of the scene, without otherwise affecting the viewport or lens properties
ScissorEffectThis provides a higher-level wrapper around ScissorAttrib
sdVector4
second_of_pair_iterator< pair_iterator >This is an iterator adaptor that converts any iterator that returns a pair (e.g
Seek
SelectiveChildNodeA base class for nodes like LODNode and SequenceNode that select only one visible child at a time
SemaphoreA classic semaphore synchronization primitive
sequence_hash< Key, Compare >This hash_compare class hashes a string
SequenceNodeA node that automatically cycles through rendering each one of its children according to its frame rate
SFNodeRef
ShadeModelAttribSpecifies whether flat shading (per-polygon) or smooth shading (per-vertex) is in effect
Shader
Shader::ShaderArgId
Shader::ShaderArgInfo
ShaderAttrib
Shader::ShaderCaps
ShaderContextThe ShaderContext is meant to contain the compiled version of a shader string
Shader::ShaderFile
ShaderGeneratorThe ShaderGenerator is a device that effectively replaces the classic fixed function pipeline with a 'next-gen' fixed function pipeline
ShaderInputThis is a small container class that can hold any one of the value types that can be passed as input to a shader
Shader::ShaderMatSpec
ShaderPoolThis is the preferred interface for loading shaders for the TextNode system
Shader::ShaderPtrData
Shader::ShaderPtrSpec
Shader::ShaderTexSpec
Shader::ShaderVarSpec
SheetNodeThis class draws a visible representation of the NURBS surface stored in its NurbsSurfaceEvaluator
ShoveDataUsed within CollisionHandlerPusher::handle_entries(), to track multiple shoves onto a given collider
ShowBoundsEffectApplied to a GeomNode to cause a visible bounding volume to be drawn for this node
ShowIntervalAn interval that calls NodePath::show()
SimpleAllocatorAn implementation of a very simple block allocator
SimpleAllocatorBlockA single block as returned from SimpleAllocator::alloc()
SimpleHashMap< Key, Value, Compare >This template class implements an unordered map of keys to data, implemented as a hashtable
SimpleLruAn implementation of a very simple LRU algorithm
SimpleLruPageOne atomic piece that may be managed by a SimpleLru chain
SliderTableStores the total set of VertexSliders that the vertices in a particular GeomVertexData object might depend on
SmoothMoverThis class handles smoothing of sampled motion points over time, e.g
Socket_AddressA simple place to store and munipulate tcp and port address for communication layer
Socket_fdset
Socket_IPBase functionality for a INET domain Socket this call should be the starting point for all other unix domain sockets
Socket_Selector
Socket_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
Socket_TCP_ListenBase functionality for a TCP rendezvous socket
Socket_UDPBase functionality for a combination UDP Reader and Writer
Socket_UDP_IncomingBase functionality for a UDP Reader
Socket_UDP_OutgoingBase functionality for a UDP Sending Socket
ConnectionReader::SocketInfo
SoftCVSThis program prepares a SoftImage database for CVS by renaming everything to version 1-0, and adding new files to CVS
SoftEggGroupUserDataThis class contains extra user data which is piggybacked onto EggGroup objects for the purpose of the softimage converter
SoftFilenameThis 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
SoftNodeDescDescribes a single instance of a node aka element in the Soft scene graph, relating it to the corresponding egg structures (e.g
SoftNodeTreeDescribes a complete tree of soft nodes for conversion
SoftToEggConverterThis 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
SomethingToEggThis is the general base class for a file-converter program that reads some model file format and generates an egg file
SomethingToEggConverterThis is a base class for a family of converter classes that manage a conversion from some file type to egg format
SortByColliderSort
SortByExternalIndex
SortByState
SortCollectorLabels1
SortCollectorLabels2
SortCollectorLevels
CollisionHandlerEvent::SortEntries
SortFieldsByIndex
SortGroupsByDependencyOrder
SortGroupsByPreference
SortPlacementBySize
SourceTextureImageThis is a texture image reference as it appears in an egg file: the source image of the texture
SparkleParticleRendererPretty sparkly things
SparseArrayThis class records a set of integers, where each integer is either present or not present in the set
SpeedTreeNodeInterfaces with the SpeedTree library to render SpeedTree objects, especially trees, within the Panda3D scene graph
SphereSurfaceEmitterDescribes a curved space in which particles are generated
SphereVolumeEmitterDescribes a voluminous spherical region in which particles are generated
STTerrain::SplatLayer
SpotlightA light originating from a single point in space, and shining in a particular direction, with a cone-shaped falloff
SpriteAnimHelper class used by SpriteParticleRenderer to keep track of its textures and their respective UVs and source types
SpriteParticleRendererRenders a particle system with high-speed nasty trick sprites
SpriteWriterHelper class used by SpriteParticleRenderer to keep track of the various GeomVertexWriters associated with each geom created in SpriteParticleRenderer::init_geoms()
sSurfaceParams
StackedPerlinNoise2Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
StackedPerlinNoise3Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
StandardMungerPerforms 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
PandaNode::Stashed
StateMungerThis is just a simple derivative of GeomMunger that adds the ability to munge states
StaticDeletedChain< Type >This template class is used to conveniently declare a single instance of the DeletedChain template object, above, for a particular type
StaticTextFontA 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
STBasicTerrainA 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
STCustomAllocator
StencilAttribA StencilAttrib is a collection of all stencil render states
StencilRenderStatesAn abstract cross-platform class for setting stencil buffer render states
StereoDisplayRegionThis is a special DisplayRegion wrapper that actually includes a pair of DisplayRegions internally: the left and right eyes
stl_hash_compare< Key, Compare >
StreamReaderA class to read sequential binary data directly from an istream
StreamWrapperThis class provides a locking wrapper around a combination ostream/istream pointer
StreamWrapperBaseThe base class for both IStreamWrapper and OStreamWrapper, this provides the common locking interface
StreamWriterA StreamWriter object is used to write sequential binary data directly to an ostream
OdeTriMeshData::StridedTri
OdeTriMeshData::StridedVertex
StringDecoderThe base class to a family of classes that decode various kinds of encoded byte streams
StringStreamA bi-directional stream object that reads and writes data to an internal buffer, which can be retrieved and/or set as a string
stringstream
StringStreamBufUsed 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
StringUnicodeDecoderThis decoder extracts characters two at a time to get a plain wide character sequence
StringUtf8DecoderThis decoder extracts utf-8 sequences
StrTargetBuffer
STTerrainThis is the abstract base class that defines the interface needed to describe a terrain for rendering by SpeedTree
STTransformRepresents a transform that may be applied to a particular instance of a tree when added to the SpeedTreeNode
STTreeEncapsulates a single tree model in the SpeedTree library, as loaded from an SRT file
SubdivSegmentRepresents a single hypothetical subdivided segment, under consideration by the IsoPlacer
SubfileInfoThis class records a particular byte sub-range within an existing file on disk
NativeWindowHandle::SubprocessHandle
SubprocessWindowBufferThis is a special class that is designed to faciliate SubprocessWindow
SubStreamCombined ISubStream and OSubStream for bidirectional I/O
SubStreamBufThe streambuf object that implements ISubStream
FltTexture::SubtextureDef
LODNode::Switch
DCSwitch::SwitchCase
DCSwitch::SwitchFields
SwitchNodeA node that renders only one of its children, according to the user's indication
TangentRingEmitterDescribes a planar ring region in which tangent particles are generated, and particles fly off tangential to the ring
TemporaryFileThis is a special kind of FileReference class that automatically deletes the file in question when it is deleted
TestCopyA program to copy ordinary files into the cvs tree
TexGenAttribComputes texture coordinates for geometry automatically based on vertex position and/or normal
TexMatrixAttribApplies a transform matrix to UV's before they are rendered
TexProjectorEffectThis effect automatically applies a computed texture matrix to the specified texture stage, according to the relative position of two specified nodes
TextAssemblerThis 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
TextEncoderThis class can be used to convert text between multiple representations, e.g
TextFontAn encapsulation of a font; i.e
TextGlyphA representation of a single glyph (character) from a font
TextGraphicThis defines a special model that has been constructed for the purposes of embedding an arbitrary graphic image within a text paragraph
TextMonitorA simple, scrolling-text stats monitor
TextNodeThe primary interface to this module
TextPropertiesThis defines the set of visual properties that may be assigned to the individual characters of the text
TextPropertiesManagerThis defines all of the TextProperties structures that might be referenced by name from an embedded text string
TextStatsA simple, scrolling-text stats server
TextureRepresents 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
TextureAttribIndicates the set of TextureStages and their associated Textures that should be applied to (or removed from) a node
TextureCollectionManages a list of Texture objects, as returned by TexturePool::find_all_textures()
TextureContextThis is a special class object that holds all the information returned by a particular GSG to indicate the texture's internal context identifier
TextureImageThis represents a single source texture that is referenced by one or more egg files
TextureMemoryCounterThis class is used to gather statistics on texture memory usage, etc
TexturePeekerAn instance of this object is returned by Texture::peek()
TexturePlacementThis 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
TexturePoolThis is the preferred interface for loading textures from image files
TexturePoolFilterThis 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
TexturePositionThis represents a particular position of a texture within a PaletteImage
TexturePropertiesThis is the set of characteristics of a texture that, if different from another texture, prevent the two textures from sharing a PaletteImage
TextureReferenceThis is the particular reference of a texture filename by an egg file
TextureReloadRequestThis loader request will call Texture::get_ram_image() in a sub-thread, to force the texture's image to be re-read from disk
DXGraphicsStateGuardian9::TextureRenderStates
TextureRequestThese are the things that a user might explicitly request to adjust on a texture via a line in the .txa file
TextureStageDefines the properties of a named stage of the multitexture pipeline
TextureStageCollection
TextureStagePoolThe 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
DXGraphicsStateGuardian9::TextureStageStates
ThreadA thread; that is, a lightweight process
ThreadSafeConstPointerTo< T >
ThreadSafePointerTo< T >This works exactly like PointerTo, except that the object is designed to be thread-safe: it is generally safe to make unprotected assignments to this pointer, in the sense that the last assignment will win and the reference counts will be properly maintained
ThreadSafePointerToBase< T >This is the base class for ThreadSafePointerTo and ThreadSafeConstPointerTo
Time_Accumulator
Time_Clock
Time_Out
Time_Span
TimedCycleA class for anything that needs to cycle over some finite list of elements in increments based on time
ProfileTimer::TimerEntry
TimeVal
TinyGeomMungerThis specialization on GeomMunger finesses vertices for TinyPanda rendering
TinyGraphicsBufferAn offscreen graphics buffer
TinyGraphicsStateGuardianAn interface to the TinyPanda software rendering code within this module
TinyOffscreenGraphicsPipeThis graphics pipe creates offscreen buffers only, but is completely platform-independent
TinyTextureContext
TiXmlAttributeAn attribute is a name-value pair
TiXmlAttributeSet
TiXmlBaseTiXmlBase is a base class for every class in TinyXml
TiXmlCommentAn XML comment
TiXmlCursor
TiXmlDeclarationIn correct XML the declaration is the first entry in the file
TiXmlDocumentAlways the top level node
TiXmlElementThe element is a container class
TiXmlHandleA TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing
TiXmlNodeThe parent class for everything in the Document Object Model
TiXmlParsingData
TiXmlPrinterPrint to memory functionality
TiXmlTextXML text
TiXmlUnknownAny tag that tinyXml doesn't recognize is saved as an unknown
TiXmlVisitorImplements 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
TouchInfoStores information for a single touch event
TrackballTrackball acts like Performer in trackball mode
TrackerDataStores the kinds of data that a tracker might output
TrackerNodeThis is the primary interface to a Tracker object associated with a ClientBase
Transform2SGInput: Transform (matrix)
TransformBlendThis defines a single entry in a TransformBlendTable
TransformBlendTableThis 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
TransformStateIndicates a coordinate-system transform on vertices
TransformTableStores the total set of VertexTransforms that the vertices in a particular GeomVertexData object might depend on
TransparencyAttribThis controls the enabling of transparency
CollisionFloorMesh::TriangleIndices
TriangulatorThis class can triangulate a convex or concave polygon, even one with holes
TrueClockAn interface to whatever real-time clock we might have available in the current environment
TxaFileThis represents the .txa file (usually textures.txa) that contains the user instructions for resizing, grouping, etc
TxaFileFilterThis 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
TxaLineThis is a single matching line in the .txa file
typecast_iterator< base_iterator, new_type >This is an iterator adaptor that explicitly typecasts each value returned by the base iterator to the indicated type
TypedObjectThis is an abstract class that all classes which use TypeHandle, and also provide virtual functions to support polymorphism, should inherit from
TypedReferenceCountA base class for things which need to inherit from both TypedObject and from ReferenceCount
TypedSkelSkeleton object that inherits from TypedObject
TypedWritableBase class for objects that can be written to and read from Bam files
TypedWritableReferenceCountA base class for things which need to inherit from both TypedWritable and from ReferenceCount
TypeHandleTypeHandle is the identifier used to differentiate C++ class types
TypeRegistryMaintains all the assigned TypeHandles in a given system
TypeRegistryNodeThis is a single entry in the TypeRegistry
XTokenType::U
DCTokenType::U
UnalignedLMatrix4dThis is an "unaligned" LMatrix4
UnalignedLMatrix4fThis is an "unaligned" LMatrix4
UnalignedLVecBase4dThis is an "unaligned" LVecBase4
UnalignedLVecBase4fThis is an "unaligned" LVecBase4
UnicodeLatinMapThis 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
UnionBoundingVolumeThis special bounding volume is the union of all of its constituent bounding volumes
UniqueEggMaterialsAn STL function object for sorting materials into order by properties
UniqueEggTexturesAn STL function object for sorting textures into order by properties
UniqueEggVerticesAn STL function object for sorting vertices into order by properties
UniqueIdAllocatorManage a set of ID values from min to max inclusive
UpdateSeqThis is a sequence number that increments monotonically
URLSpecA container for a URL, e.g
UserDataAudioA UserDataAudio is a way for the user to manually supply raw audio samples
UserDataAudioCursorA UserDataAudioCursor is a means to manually supply a sequence of raw audio samples
UserPersitentData
UserVertexSliderThis is a specialization on VertexSlider that allows the user to specify any arbitrary slider valie he likes
UserVertexTransformThis is a specialization on VertexTransform that allows the user to specify any arbitrary transform matrix he likes
UvScrollNodeThis node is placed at key points within the scene graph to animate uvs
V2
V3
V4
XFileFace::Vertex
VertexBufferContextThis 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
VertexDataBlockA block of bytes that stores the actual raw vertex data referenced by a GeomVertexArrayData object
VertexDataBookA collection of VertexDataPages, which can be used to allocate new VertexDataBlock objects
VertexDataBufferA block of bytes that stores the actual raw vertex data referenced by a GeomVertexArrayData object
VertexDataPageA block of bytes that holds one or more VertexDataBlocks
VertexDataSaveBlockA block of bytes on the save file
VertexDataSaveFileA temporary file to hold the vertex data that has been evicted from memory and written to disk
VertexElementArrayThis class gives the ability for a user-friendly way of creating a vertex declaration for DirectX 9
VertexMembershipThis class is used to help EggOptchar quantize the membership of one vertex among its various groups
VertexSliderThis 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)
VertexTransformThis 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
VideoTextureThe base class for a family of animated Textures that take their input from a video source, such as a movie file
VirtualFileThe abstract base class for a file or directory within the VirtualFileSystem
VirtualFileCompositeA composite directory within the VirtualFileSystem: this maps to more than one directory on different mount points
VirtualFileListA list of VirtualFiles, as returned by VirtualFile::scan_directory()
VirtualFileMountThe abstract base class for a mount definition used within a VirtualFileSystem
VirtualFileMountMultifileMaps a Multifile's contents into the VirtualFileSystem
VirtualFileMountRamdiskSimulates an actual directory on disk with in-memory storage
VirtualFileMountSystemMaps an actual OS directory into the VirtualFileSystem
VirtualFileSimpleA simple file or directory within the VirtualFileSystem: this maps to exactly one file on one mount point
VirtualFileSystemA 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
VirtualMousePoses 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
VRMLAppearance
VrmlFieldValue
VrmlNode
VrmlNodeType
VRMLToEggA program to read a VRML file and generate an egg file
VRMLToEggConverterThis class supervises the construction of an EggData structure from a VRML file
VRMLTransA program to read a VRML file and output an essentially similar VRML file
VrpnAnalogThis is the actual interface to a particular VRPN analog device, and all of its numbered controls
VrpnAnalogDeviceThe Panda interface to a VRPN analog device
VrpnButtonThis is the actual interface to a particular VRPN button device, and all of its numbered buttons
VrpnButtonDeviceThe Panda interface to a VRPN button
VrpnClientA specific ClientBase that connects to a VRPN server and records information on the connected VRPN devices
VrpnDialThis is the actual interface to a particular VRPN dial device, and all of its numbered dials
VrpnDialDeviceThe Panda interface to a VRPN dial device
VrpnTrackerThis is the actual interface to a particular VRPN tracker object, and all of its sensors
VrpnTrackerDeviceThe Panda interface to a VRPN tracker
WaitIntervalThis interval does absolutely nothing, and is mainly useful for marking time between other intervals within a sequence
Wander
wdxGraphicsBuffer8An offscreen render buffer
wdxGraphicsBuffer9An offscreen render buffer
wdxGraphicsPipe8This graphics pipe represents the interface for creating DirectX8 graphics windows
wdxGraphicsPipe9This graphics pipe represents the interface for creating DirectX9 graphics windows
wdxGraphicsWindow8A single graphics window for rendering DirectX under Microsoft Windows
wdxGraphicsWindow9A single graphics window for rendering DirectX under Microsoft Windows
WeakConstPointerTo< T >A WeakConstPointerTo is similar to a WeakPointerTo, except it keeps a const pointer to the thing, that will be cleared to NULL when the thing deleted
WeakNodePathThis class is a wrapper around a NodePath that, unlike the actual NodePath class, doesn't hold a reference count to the node
WeakPointerCallbackDerive 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
WeakPointerTo< T >WeakPointerTo is similar to PointerTo, except that it does not actually prevent the referenced pointer from deleting
WeakPointerToBase< T >This is the base class for PointerTo and ConstPointerTo
WeakPointerToVoidThis is the specialization of PointerToVoid for weak pointers
WeakReferenceListThis is a list of WeakPointerTo's that share a reference to a given ReferenceCount object
WebBrowserTextureA Wrapper class for Awesomium webview
WebcamVideoAllows you to open a webcam or other video capture device as a video stream
wglGraphicsBufferAn offscreen render buffer
wglGraphicsPipeThis graphics pipe represents the interface for creating OpenGL graphics windows on the various Windows OSes
wglGraphicsStateGuardianA tiny specialization on GLGraphicsStateGuardian to add some wgl-specific information
wglGraphicsWindowA single graphics window for rendering OpenGL under Microsoft Windows
WHQL
WINDOW_METRICS
CallbackGraphicsWindow::WindowCallbackData
WindowFrameworkThis encapsulates the data that is normally associated with a single window, or with a single display region within a window
WindowHandleThis object represents a window on the desktop, not necessarily a Panda window
WindowPropertiesA container for the various kinds of properties we might ask to have on a graphics window before we open it
WindowsGuidThis is an implementation of the Windows GUID object, used everywhere as a world-unique identifier for anything and everything
WinGraphicsPipeThis is an abstract base class for wglGraphicsPipe and wdxGraphicsPipe; that is, those graphics pipes that are specialized for working with Microsoft Windows
WinGraphicsWindowAn abstract base class for glGraphicsWindow and dxGraphicsWindow (and, in general, graphics windows that interface with the Microsoft Windows API)
WinStatsChartMenuA pulldown menu of charts available for a particular thread
WinStatsGraphThis 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
WinStatsLabelA text label that will draw in color appropriate for a particular collector
WinStatsLabelStackA window that contains a stack of labels from bottom to top
WinStatsMonitorThis class represents a connection to a PStatsClient and manages the data exchange with the client
WinStatsPianoRollA window that draws a piano-roll style chart, which shows the collectors explicitly stopping and starting, one frame at a time
WinStatsServerThe class that owns the main loop, waiting for client connections
WinStatsStripChartA window that draws a strip chart, given a view
WithOutputFileThis is the bare functionality (intended to be inherited from along with ProgramBase or some derivative) for a program that might generate an output file
WordWrapStreamA special ostream that formats all of its output through ProgramBase::show_text()
WordWrapStreamBufUsed by WordWrapStream to implement an ostream that flushes its output to ProgramBase::show_text()
WorkingNodePathThis 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
WritableConfigurableDefined as a fix to allow creating Configurable and Writable objects
WritableParamThe specific derivation of FactoryParam that contains the information needed by a TypedWritable object
x11GraphicsPipeThis graphics pipe represents the interface for creating graphics windows on an X-based client
x11GraphicsWindowInterfaces to the X11 window system
XFileThis represents the complete contents of an X file (file.x) in memory
XFileAnimationSetThis represents a tree of EggTables, corresponding to Animation entries in the X file
XFileArrayDefDefines one level of array bounds for an associated XFileDataDef element
XFileDataDefA definition of a single data element appearing within a template record
XFileDataNodeThis is an abstract base class for an XFileNode which is also an XFileDataObject
XFileDataNodeReferenceThis is a nested reference to an instance of a template object, declared via the syntax:
XFileDataNodeTemplateThis is a node which contains all of the data elements defined by a template
XFileDataObjectThe abstract base class for a number of different types of data elements that may be stored in the X file
XFileDataObjectArrayAn array of nested data elements
XFileDataObjectDoubleAn double-valued data element
XFileDataObjectIntegerAn integer-valued data element
XFileDataObjectStringAn string-valued data element
XFileFaceThis represents a single face of an XFileMesh
XFileMakerThis class converts a Panda scene graph into a .X file and writes it out
XFileMaterialThis represents an X file "material", which consists of a color, lighting, and/or texture specification
XFileMeshThis is a collection of polygons; i.e
XFileNodeA single node of an X file
XFileNormalThis represents a single normal associated with an XFileFace
XFileParseDataThis class is used to fill up the data into an XFileDataNodeTemplate object as the data values are parsed out of the X file
XFileParseDataListA container for a pvector of the above objects
XFileTemplateA template definition in the X file
XFileToEggA program to read a DirectX "x" file and generate an egg file
XFileToEggConverter
XFileTransA program to read a X file and output an essentially similar X file
XFileVertexThis represents a single vertex associated with an XFileFace
XFileVertexPoolThis is a collection of unique vertices as extracted out of a Geom or a series of Geoms
XTokenType
ZBuffer
ZBufferPoint
ZSpinParticleDescribes a particle that spins along its z axis
ZSpinParticleFactory
ZTextureDef
ZTextureLevel