Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_AttrNotFound
_BoundedSemaphore
_CFGLGlobals
_Condition
_DummyThread
_ElementInterfaceInternal element class
_Event
_ExtFilter
_Filter
_local
_MainThread
_MessageListenerTypeLeakDetector
_MessageListenerTypeLeakDetectorCreator
_MessageTypeLeakDetector
_MessageTypeLeakDetectorCreator
_NameFilter
_PathFilter
_PatternFilter
_RLock
_Semaphore
_SimpleElementPath
_TaskNamePatternLeakDetector
_Timer
_TypeFilter
_Verbose
AcceptInterval
ActionAddNewObj
ActionBase
ActionChangeHierarchy
ActionDeleteObj
ActionDeleteObjById
ActionDeselectAll
ActionMgr
ActionSelectObj
ActionTransformObj
ActionUpdateObjectProp
Actor
ActorControl
ActorInterval
ActorNode
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
AIBehaviors
AICharacter
AINodeThis class is used to assign the nodes on the mesh
aiWebServer
AIWorld
AlphabetCounter
AlphaTestAttribEnables or disables writing of pixel to framebuffer based on its alpha value relative to a reference alpha value
AlreadyInTransition
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
AnfaPhasedObject
AngleDial
AngularEulerIntegrator
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
AnimBundleNodeThis is a node that contains a pointer to an AnimBundle
AnimChannelACMatrixSwitchType
AnimChannelACScalarSwitchType
AnimChannelBaseParent class for all animation channels
AnimChannelMatrixDynamicAn animation channel that accepts a matrix each frame from some dynamic input provided by code
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
AnimControlInterval
AnimControlUI
Actor.AnimDef
AnimFileDrop
AnimGroupThis is the base class for AnimChannel and AnimBundle
AnimInterfaceThis is the fundamental interface for things that have a play/loop/stop type interface for frame-based animation, such as animated characters
AnimMgr
AnimMgrBase
AnimPanel
AnimPreloadTableThis table records data about a list of animations for a particular model, such as number of frames and frame rate
AntialiasAttribSpecifies whether or how to enable antialiasing, if supported by the backend renderer
AppRunner
AppShell
ArcEmitter
Archive
Archive
archiveresource
ArchiveTarget
ArgumentEater
ArgumentError
ArgumentError
ArgumentError
ARToolKitARToolKit is a software library for building Augmented Reality (AR) applications
AsyncRequest
AsyncTaskThis class represents a concrete task performed by an AsyncManager
AsyncTaskBaseThe abstract base class for AsyncTask
AsyncTaskChainThe AsyncTaskChain is a subset of the AsyncTaskManager
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
AsyncTestCase
AsyncTestLoader
AsyncTestSuite
AsyncTextTestRunner
AttribNodeRegistryThis global object records NodePaths that are referenced by scene graph attribs, such as ClipPlaneAttribs and LightAttribs
AttrSetter
Audio3DManager
AudioManager
AudioSound
AudioVolumeAttribApplies a scale to audio volume for positional sounds in the scene graph
AutonomousLerp
AuxBitplaneAttribModern frame buffers can have 'aux' bitplanes, which are additional bitplanes above and beyond the standard depth and color
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
Averager
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)
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
BamReaderThis is the fundamental interface for extracting binary objects from a Bam file, as generated by a BamWriter
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
BaseIntegratorPure virtual integrator class that holds cached matrix information that really should be common to any possible child implementation
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
BaseTypeDescriptor
BattleWalker
BillboardEffectIndicates that geometry at this node should automatically rotate to face the camera, or any other arbitrary node
binaryresource
BindAnimRequestThis class object manages an asynchronous load-and-bind animation request, as issued through PartBundle.load_bind_anim()
BitArrayA dynamic array with an unlimited number of bits
BitMask16
BitMask32
BitMask64
BoundedSemaphore
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
BoxEmitterDescribes a voluminous box region in which particles are generated
bp
BpDb
BpMan
BrowserObject
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
Buffered_DatagramConnection
BufferedDistancePhasedNode
BufferViewer
BulletinBoard
BulletinBoardWatcher
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
ButtonThrowerThrows Panda Events for button down/up events generated within the data graph
CachedDOData
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
Loader.Callback
CallbackDataThis is a generic data block that is passed along to a CallbackObject when a callback is made
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
CArchive
CArchive
CardMakerThis class generates 2-d "cards", that is, rectangular polygons, particularly useful for showing textures etc
CartesianGridBase
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
CDistributedSmoothNodeBaseThis class defines some basic methods of DistributedSmoothNodeBase which have been moved into C++ as a performance optimization
CertRecord
Multifile.CertRecord
char
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()
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
CheckContainers
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
class_p3d
class_package
class_solo
ClassicFSM
ClassicStyle
ClassInspector
ClassInspector
ClassTree
ClassTypeDescriptor
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
ServerRepository.Client
ClientBaseAn abstract base class for a family of client device interfaces--including trackers, buttons, dials, and other analog inputs
ClientRepository
ClientRepositoryBase
ClipPlaneAttribThis functions similarly to a LightAttrib
ClockDelta
ClockObjectA ClockObject keeps track of elapsed real time and discrete time
ClusterClient
ClusterClientSync
ClusterConfigItem
ClusterMsgHandler
ClusterServer
CMetaInterval
CodeDatabase
CodeInspector
CodeInspector
CollectTarget
CollisionBoxA cuboid collision volume or object
CollisionDSSolidA collision volume or object made up of the intersection of two spheres (potentially a lens) and two half-spaces (planes)
CollisionEntryDefines a single collision event
CollisionFloorMeshThis object represents a solid made entirely of triangles, which will only be tested again z axis aligned rays
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
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
CollisionRecorderThis class is used to help debug the work the collisions system is doing
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)
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
CollisionVisualizerThis class is used to help debug the work the collisions system is doing
ColorAttribIndicates what color should be applied to renderable geometry
ColorBlendAttribThis specifies how colors are blended into the frame buffer, for special effects
ColorEntry
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
ColorLerpFunctorClass for Lerping between colors
ColorPicker
ColorScaleAttribApplies a scale to colors in the scene graph and on vertices
ColorScaleLerpFunctorClass for Lerping between color scales
ColorWriteAttribEnables or disables writing to the color buffer
CommonFilters
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
CompilationEnvironment
ComplexInspector
ComplexInspector
ConcreteStruct
Condition
ConditionVar
ConditionVarDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
ConditionVarFull
ConditionVarFullDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
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
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
ConfigVariableDoubleThis is a convenience class to specialize ConfigVariable as a floating-point 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)
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)
ConnectionRepository
ConnectionWriterThis class handles threaded delivery of datagrams to various TCP or UDP sockets
ConstTypeDescriptor
ContainerLeakDetector
ContainerReport
ControlManager
CopyOnWriteObjectThis base class provides basic reference counting, but also can be used with a CopyOnWritePointer to provide get_read_pointer() and get_write_pointer()
CountedResource
CppMemoryUsage
CPTADouble
CPTAFloat
CPTAInt
CPTAMat3
CPTAMat4
CPTAUchar
CPTAUshort
CRCache
CRDataCache
Mat3.CRow
Mat4.CRow
CRow
Mat3D.CRow
Mat4D.CRow
CTOC
CTOC
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
CullBinAttribAssigns geometry to a particular bin by name
CullBinEnumsProvides scoping for the enumerated type shared by CullBin and CullBinManager
CullBinManagerThis is a global object that maintains the collection of named CullBins in the world
CullFaceAttribIndicates which faces should be culled based on their vertex ordering
CullHandler
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
CursorResource
CurveAnimUI
CurveDegreeUI
CurveEditor
CurveFitter
CylindricalLensA cylindrical lens
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
DatagramIteratorA class to retrieve the individual data elements previously stored in a Datagram
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
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
dataresource
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
DCAtomicField
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
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
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
DCTypedefThis represents a single typedef declaration in the dc file
DecalEffectApplied to a GeomNode to indicate that the children of this GeomNode are coplanar and should be drawn as decals (eliminating Z-fighting)
DecompressorThis manages run-time decompression of a zlib-compressed stream, as a background or foreground task
Default
DelayedCall
DelayedFunctor
DeltaProfiler
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
DerivedPOD
DerivedTypeDescriptor
DestructiveScratchPad
DevWalker
Dial
DialNodeThis is the primary interface to infinite dial type devices associated with a ClientBase
DialWidget
DictionaryInspector
DictionaryInspector
Diff
DirectAnalogs
DirectBoundingBox
DirectButton
DirectButtons
DirectCameraControl
DirectCheckBox
DirectCheckButton
DirectDeviceManager
DirectDialog
DirectDials
DirectEntry
DirectEntryScroll
DirectFastrak
DirectFrame
DirectGrid
DirectGuiBase
DirectGuiWidget
DirectionalLightA light shining from infinitely far away in a particular direction, like sunlight
DirectJoybox
DirectLabel
DirectLight
DirectLights
DirectManipulationControl
DirectMySQLdbConnection
DirectNodePath
DirectNotify
DirectObject
DirectOptionMenu
DirectoryImporter
DirectRadamec
DirectRadioButton
DirectScrollBar
DirectScrolledFrame
DirectScrolledList
DirectScrolledListItem
DirectSession
DirectSessionPanel
DirectSlider
DirectTimecodeReader
DirectTracker
DirectWaitBar
DirFilter
dirresource
DiscEmitterDescribes a planar disc region from which particles are generated
DisplayConnection
DisplayInformationThis class contains various display information
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
DisplayRegionContext
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
DisplayRegionList
DisplaySearchParametersParameters used for searching display capabilities
DistancePhasedNode
DistributedActor
DistributedCamera
DistributedCameraAI
DistributedCameraOV
DistributedCartesianGrid
DistributedCartesianGridAI
DistributedLargeBlobSender
DistributedLargeBlobSenderAI
DistributedNode
DistributedNodeAI
DistributedNodeUD
DistributedObject
DistributedObjectAI
DistributedObjectBase
DistributedObjectGlobal
DistributedObjectGlobalAI
DistributedObjectGlobalUD
DistributedObjectOV
DistributedObjectUD
DistributedSmoothNode
DistributedSmoothNodeAI
DistributedSmoothNodeBase
dJointFeedback
DoCollectionManager
DocumentSpecA descriptor that refers to a particular version of a document
DoHierarchy
DoInterestManager
DoubleBitMaskNative
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
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
DummyAcceptor
DummyClusterClient
DummyTaskClass
DWBPackageInstaller
dxBody
dxGeom
dxJoint
dxJointGroup
dxSpace
dxTriMeshData
dxWorld
DynamicTextFontA DynamicTextFont is a special TextFont object that rasterizes its glyphs from a standard font file (e.g
DynamicTextPageA single "page" of a DynamicTextFont
EaseInBlendType
EaseInOutBlendType
EaseOutBlendType
EditHotKeyDialog
EggAnimData
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
EggBinA type of group node that holds related subnodes
EggBinMakerThis is a handy class for collecting related nodes together
EggCacher
EggCommentA comment that appears in an egg file within a <Comment> entry
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
EggCoordinateSystemThe <CoordinateSystem> entry at the top of an egg file
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
EggFilenameNodeThis is an egg node that contains a filename
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
EggLineA line segment, or a series of connected line segments, defined by a <Line> entry
EggMaterial
EggMaterialCollectionThis is a collection of materials by MRef name
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
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
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
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
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
EggTextureCollectionThis is a collection of textures by TRef name
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
EggVertexPoolA collection of vertices
EggVertexUVThe set of UV's that may or may not be assigned to a vertex
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
ElementTreeElementTree wrapper class
EnterExit
EntryScale
EntryScaleGroup
Enum
EnumIter
EnumTypeDescriptor
error
Event
EventA named event, possibly with parameters
EventArgument
EventGroup
EventHandlerA class to monitor events from the C++ side of things
EventInterval
EventManager
EventParameterAn optional parameter associated with an event
EventPulse
EventQueueA queue of pending events
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
EventStoreValueBaseA non-template base class of EventStoreValue (below), which serves mainly to define the placeholder for the virtual output function
ExcelHandler
Packager.ExcludeFilename
ExclusiveObjectPool
ExecutionEnvironmentEncapsulates access to the environment variables and command-line arguments at the time of execution
ExeTargetIconfile = None for name in self.cfg.sections(): if self.cfg.get (name, "type") == "STANDALONE": try: iconfile = self.cfg.get (name, "iconfile") except: pass if iconfile: from icon import CopyIcons CopyIcons (myexe, iconfile)
ExternalThread
ExternalThreadThe special "external thread" class
ExtFilter
ExtractorThis class automatically extracts the contents of a Multifile to the current directory (or to a specified directory) in the background
Factory
FadeLODNodeA Level-of-Detail node with alpha based switching
ObjectRef.FailedEval
FakeDelObject
FakeObject
FallTest
FFIEnvironment
FFIExternalObject
FFIInterrogateDatabase
FFIMethodArgumentTree
FFIMethodArgumentTreeCollection
FfmpegAudioA stream that generates a sequence of audio samples
FfmpegAudioCursorA stream that generates a sequence of audio samples
FFMpegTexture
FfmpegVideo
FfmpegVideoCursor
file
FileFilter
FileMgr
FilenameThe name of a file, such as a texture file or an Egg file
FileSpec
FileSpec
FileStreamImplements a C++ stream object suitable for reading from and/or writing to files on disk
FilterConfig
FilterManager
FilterPropertiesStores a configuration for a set of audio DSP filters
FindContainers
FiniteBoundingVolumeA special kind of GeometricBoundingVolume that is known to be finite
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
Fixture
Floater
FloaterGroup
FloaterWidget
FloatLerpFunctor
FloatQueryLerpFunctor
FlockThis class is used to define the flock attributes and the AI characters which are part of the flock
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
ForceGroup
ForceNodeA force that lives in the scene graph and is therefore subject to local coordinate systems
FourState
FourStateAI
FPTObjsNamed
FPTObjsOfType
FrameBufferPropertiesA container for the various kinds of properties we might ask to have on a graphics frameBuffer before we create a GSG
FrameDelayedCall
FrameProfiler
FrameRateMeterThis is a special TextNode that automatically updates itself with the current frame rate
FreetypeFontThis is a common base class for both DynamicTextFont and PNMTextMaker
Freezer
FrustumBase
FrustumD
FSM
FSMException
FSMInspector
fstream
FullExeTarget
Func
func_closure
FuncImporter
FunctionCall
FunctionInspector
FunctionInspector
FunctionInterval### See examples of function intervals in IntervalTest.py ### ###
FunctionSpecification
FunctionTypeDescriptor
Functor
GarbageLeakDetector
GarbageLogger
GarbageReport
GarbageReportScheduler
GCTrigger
GeomA container for geometry primitives
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
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
GeomNodeA node that holds Geom objects, renderable pieces of geometry
GeomParticleRenderer
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
GeomTextGlyphThis is a specialization on Geom for containing a primitive intended to represent a DynamicTextGlyph
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
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
GhostWalker
GlobalForceGroup
GlobalFunctionSpecification
GlobalValueSpecification
GlobPatternThis class can be used to test for string matches against standard Unix-shell filename globbing conventions
GoldenRectangle
GraphEditorUI
GraphEditorWindow
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
GravityWalker
GridParent
GridSizeUI
GRPICONDIR
GRPICONDIRENTRY
HashValStores a 128-bit value that represents the hashed contents (typically MD5) of a file or buffer
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
HideIntervalAn interval that calls NodePath.hide()
HierarchyException
PNMImageHeader.Histogram
Histogram
Packager.HostEntry
HostInfo
HotkeyBreaker
HotKeyPanel
HotKeyUI
HprInterval
HprLerpFunctorClass for Lerping between orientations in space
HprScaleInterval
HprScaleLerpFunctorClass for Lerping between orientation and scale
HTMLStringToElements
HTMLTree
HTTPChannelA single channel of communication from an HTTPClient
HTTPClientHandles contacting an HTTP server and retrieving a document
HTTPCookieA cookie sent from an HTTP server to be stored on the client and returned when the path and/or domain matches
HTTPDateA container for an HTTP-legal time/date indication
HTTPEntityTagA container for an "entity tag" from an HTTP server
HTTPEnumThis class is just used as a namespace wrapper for some of the enumerated types used by various classes within the HTTPClient family
ICONDIRENTRY
ICONDIRHEADER
IconFile
IDecompressStreamAn input stream object that uses zlib to decompress (inflate) the input from another source stream on-the-fly
IDecryptStreamAn input stream object that uses OpenSSL to decrypt the input from another source stream on-the-fly
IFileStreamImplements a C++ stream object suitable for reading from files on disk
ifstream
IgnoreInterval
Importer
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
IndirectInterval
Indirection
InkblotVideoA cellular automaton that generates an amusing pattern of swirling colors
InkblotVideoCursorA cellular automaton that generates an amusing pattern of swirling colors
InputState
InputStateForceToken
InputStateToken
InputStateTokenGroup
InputStateWatchToken
Inspector
InspectorClasses
InspectorWindow
InstalledHostData
InstalledPackageData
Installer
PackageInfo.InstallStep
InstallTarget
InstanceInspector
InstanceInspector
InstanceMethodInspector
InstanceMethodInspector
int
InterestHandle
InterestState
InterestWatcher
InternalNameEncodes a string name in a hash table, mapping it to a pointer
InternalNameCollection
InterrogateDatabase
InterrogateDerivation
InterrogateEnumValue
InterrogateFunction
InterrogateParameter
InterrogateTokenizerInterrogate Database Tokenizer
InterrogateType
InterrogateWrapper
Interval
IntervalManager
IntLerpFunctor
IntQueryLerpFunctor
InvalidResource
ios
ios_base
iostream
ISocketStreamThis is a base class for istreams implemented in Panda that read from a (possibly non-blocking) socket
istream
IStreamWrapperThis class provides a locking wrapper around an arbitrary istream pointer
ISubStreamAn istream object that presents a subwindow into another istream
Job
JobManager
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
LandingPage
LayerEditorUI
LazySortTest
LeakDetector
LensA base class for any number of different kinds of lenses, linear and otherwise
LensNodeA node that contains a Lens
Lerp
LerpAnimInterval
LerpBlendType
LerpColorInterval
LerpColorScaleInterval
LerpFunc
LerpFuncNS
LerpFunctionInterval
LerpFunctionNoStateInterval
LerpFunctor
LerpHprInterval
LerpHprScaleInterval
LerpNodePathInterval
LerpPosHprInterval
LerpPosHprScaleInterval
LerpPosHprScaleShearInterval
LerpPosIntervalIt is legal to pass in a functor (a callable Python function that returns an appropriate value) for the any of the pos, hpr, scale, or shear parameters in the intervals below
LerpPosQuatInterval
LerpPosQuatScaleInterval
LerpPosQuatScaleShearInterval
LerpQuatInterval
LerpQuatScaleInterval
LerpScaleInterval
LerpShearInterval
LerpTexOffsetInterval
LerpTexRotateInterval
LerpTexScaleInterval
LevelEditor
LevelEditorBase
LevelEditorUI
LevelEditorUIBase
LevelLoader
LevelLoaderBase
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
LightMutex
LightMutexDirectThis class implements a lightweight Mutex by making direct calls to the underlying implementation layer
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
LightReMutex
LightReMutexDirectThis class implements a standard lightReMutex by making direct calls to the underlying implementation layer
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
LinearEulerIntegrator
LinearForce
LinearFrictionForceFriction-based drag force
LinearIntegratorPure virtual base class for physical modeling
LinearJitterForce
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
LineNodePath
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
LinkedListNodeThis just stores the pointers to implement a doubly-linked list of some kind of object
Loader
LoaderFileTypeThis is the base class for a family of scene-graph file types that the Loader supports
LoaderFileTypeRegistryThis class maintains the set of all known LoaderFileTypes in the universe
LoaderOptionsSpecifies parameters that may be passed to the loader
Lock
Lock
LockType
LODNodeA Level-of-Detail node
Logger
LOrientationdThis is a unit quaternion representing an orientation
LOrientationfThis is a unit quaternion representing an orientation
LRotationdThis is a unit quaternion representing a rotation
LRotationfThis is a unit quaternion representing a rotation
lTOC
MainThreadThe special "main thread" class
MainThread
ManifestSpecification
Mat3This is a 3-by-3 transform matrix
Mat3DThis is a 3-by-3 transform matrix
Mat4This is a 4-by-4 transform matrix
Mat4DThis is a 4-by-4 transform matrix
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
MayaConverter
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
MemoryExplorer
MemoryExplorerItem
MemoryHookThis class provides a wrapper around the various possible malloc schemes Panda might employ
MEMORYSTATUS
MemoryUsageThis class is used strictly for debugging purposes, specifically for tracking memory leaks of reference-counted objects: it keeps a record of every such object currently allocated
MemoryUsagePointersThis is a list of pointers returned by a MemoryUsage object in response to some query
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
MessageLeakDetectorBase
MessageListenerTypesLeakDetector
MessageTypesLeakDetector
Messenger
MessengerLeakDetector
MessengerLeakObject
metaclass_def
MetaInterval
MethodArgumentSpecification
MethodSpecification
MethodWrapper
MicrophoneAudioClass MicrophoneAudio provides the means to read raw audio samples from a microphone
MiniLog
MiniLogSentry
MiniTask
MiniTaskManager
MkImporter
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
ModelReference
ModelRootA node of this type is created automatically at the root of each model file that is loaded
ModFilter
ModifierButtonsThis class monitors the state of a number of individual buttons and tracks whether each button is known to be down or up
Module
Freezer.ModuleDef
ModuleFinder
ModuleInspector
ModuleInspector
moduleresource
Mopath
MopathInterval
MopathRecorder
MotionTrail
MotionTrailFrame
MotionTrailVertex
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
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)
MouseResource
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
MovieTextureA texture that fetches video frames from an underlying object of class Movie
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
MovingPartACMatrixSwitchType
MovingPartACScalarSwitchType
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
MultiLerpFunctor
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
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
Mutex
MutexDirectThis class implements a standard mutex by making direct calls to the underlying implementation layer
NamableA base class for all things which can have a name
NativeWindowHandleThis subclass of WindowHandle exists to allow simple creation of a WindowHandle of the appropriate type to the current OS
NetAddress
NetDatagramA specific kind of Datagram, especially for sending across or receiving from a network
NetMessenger
NeverFreeMemoryThis class is used to allocate bytes of memory from a pool that is never intended to be freed
NewStyle
NoBlendType
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
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
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
NoDictKey
NonlinearImagerThis class object combines the rendered output of a 3-d from one or more linear (e.g
NonPhysicsWalker
Notifier
NotifyAn object that handles general error reporting to the user
NotifyCategoryA particular category of error messages
NotifyPanel
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
ServerRepository.Object
ObjectBase
ObjectCurve
ObjectDoubleSmileys
ObjectGen
ObjectHandler
ObjectHandles
ObjectMgr
ObjectMgrBase
ObjectPalette
ObjectPaletteBase
ObjectPaletteUI
ObjectPool
ObjectProp
ObjectPropertyUI
ObjectPropUI
ObjectPropUICheck
ObjectPropUICombo
ObjectPropUIEntry
ObjectPropUIRadio
ObjectPropUISlider
ObjectPropUISpinner
ObjectPropUITime
ObjectRef
ObjectReport
ObjectSmiley
ObjectTypeLeakDetector
ObjectTypesLeakDetector
ObserverWalker
OCompressStreamAn input stream object that uses zlib to compress (deflate) data to another destination stream on-the-fly
OdeAMotorJoint
OdeBallJoint
OdeBody
OdeBoxGeom
OdeCappedCylinderGeom
OdeCollisionEntryA class used to hold information about a collision that has occurred
OdeContact
OdeContactGeom
OdeContactJoint
OdeCylinderGeom
OdeFixedJoint
OdeGeom
OdeHashSpace
OdeHinge2Joint
OdeHingeJoint
OdeJoint
OdeJointCollection
OdeJointFeedback
OdeJointGroup
OdeLMotorJoint
OdeMass
OdeNullJoint
OdePlane2dJoint
OdePlaneGeom
OdeQuadTreeSpace
OdeRayGeom
OdeSimpleSpace
OdeSliderJoint
OdeSpace
OdeSphereGeom
OdeSurfaceParameters
OdeTriMeshData
OdeTriMeshGeom
OdeUniversalJoint
OdeUtil
OdeWorld
OEncryptStreamAn input stream object that uses OpenSSL to encrypt data to another destination stream on-the-fly
OFileStreamImplements a C++ stream object suitable for writing to files on disk
ofstream
OkCancelDialog
OkDialog
OldClientRepository
OmniBoundingVolumeThis is a special kind of GeometricBoundingVolume that fills all of space
OnScreenDebug
OnscreenGeom
OnscreenImage
OnscreenText
OpenCVTextureA specialization on VideoTexture that takes its input using the CV library, to produce an animated texture, with its source taken from an .avi file or from a camera input
OrthographicLensAn orthographic lens
WindowHandle.OSHandle
OSHandle
OSocketStreamA base class for ostreams that write to a (possibly non-blocking) socket
ostream
OStreamWrapperThis class provides a locking wrapper around an arbitrary ostream pointer
OutsideOfPackageError
PatchMaker.Package
Packager.Package
PackageArchive
PackageArchiveImporterBase class for archive-based importing
PackageMerger.PackageEntry
Packager.PackageEntry
PackageInfo
PackageInstaller
PackageMerger
PackageMergerError
Packager
PackagerError
PackageTree
PatchMaker.PackageVersion
Packager.PackFile
PaletteTreeCtrl
panda3d_import_manager
panda3d_module
panda3d_multisubmodule
panda3d_submodule
PandaActor
PandaLoaderA 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)
PandaModuleFinder
PandaNodeA basic node of the scene graph or data graph
PandaSystemThis class is used as a namespace to group several global properties of Panda
PandaTextDropTarget
ParaboladAn abstract mathematical description of a parabola, particularly useful for describing arcs of projectiles
ParabolafAn abstract mathematical description of a parabola, particularly useful for describing arcs of projectiles
Parallel
ParallelEndTogether
ParametricCurveA virtual base class for parametric curves
ParametricCurveCollectionThis is a set of zero or more ParametricCurves, which may or may not be related
ParamObj
ParamObjTest
ParamObj.ParamSet
ParamObjTest.ParamSet
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
ParentInterval
ParentMgr
ParseTreeInfo
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
Actor.PartDef
PartGroupThis is the base class for PartRoot and MovingPart
ParticleEffect
ParticleFloorTest
ParticleInterval
ParticlePanel
Particles
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
PatcherApplies a patch synchronously
Patchfile
PatchMaker.Patchfile
PatchMaker
PatternFilter
PackageInstaller.PendingPackage
PercentStats
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
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
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
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
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
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
PhasedObject
PhysicalDefines a set of physically modeled attributes
PhysicalNode
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
PhysicsWalker
Pickler
PiecewiseCurveA PiecewiseCurve is a curve made up of several curve segments, connected in a head-to-tail fashion
PipeOcclusionCullTraverserThis specialization of CullTraverser uses the graphics pipe itself to perform occlusion culling
PNMImageHeader.PixelSpec
PixelSpec
PixelSpecCount
PNMImageHeader.PixelSpecCount
PkgFilter
pkgresource
Placer
PlaneAn abstract mathematical description of a plane
PlaneDAn abstract mathematical description of a plane
PlaneNodeA node that contains a plane
PNMBrushThis class is used to control the shape and color of the drawing operations performed by a PNMPainter object
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
PNMImageHeaderThis is the base class of PNMImage, PNMReader, and PNMWriter
PNMPainterThis class provides a number of convenient methods for painting drawings directly into a PNMImage
PNMTextGlyphA single glyph in a PNMTextMaker
PNMTextMakerThis object uses the Freetype library to generate text directly into an image
POD
PODtest
Point2This is a two-component point in space
Point2DThis is a two-component point in space
Point3This is a three-component point in space (as opposed to a three-component vector, which represents a direction and a distance)
Point3DThis is a three-component point in space (as opposed to a three-component vector, which represents a direction and a distance)
Point4This is a four-component point in space
Point4DThis is a four-component point in space
PointEmitterDescribes a planar ring region in which particles are generated
PointerEventListRecords a set of pointer events that happened recently
PointerToArrayBasedouble
PointerToArrayBasefloat
PointerToArrayBaseint
PointerToArrayBaseMat3
PointerToArrayBaseMat4
PointerToArrayBaseVBase2
PointerToArrayBaseVBase3
PointerToArrayBaseVBase4
PointerToBaseConnection
PointerToBaseReferenceCountedVectordouble
PointerToBaseReferenceCountedVectorfloat
PointerToBaseReferenceCountedVectorint
PointerToBaseReferenceCountedVectorMat3
PointerToBaseReferenceCountedVectorMat4
PointerToBaseReferenceCountedVectorVBase2
PointerToBaseReferenceCountedVectorVBase3
PointerToBaseReferenceCountedVectorVBase4
PointerToConnection
PointerToVoidThis is the non-template part of the base class for PointerTo and ConstPointerTo
PointerTypeDescriptor
PointLightA light originating from a single point in space, and shining in all directions
PointParticleFactoryCreates point particles to user specs
PointParticleRendererSimple point/point particle renderer
PolylightEffectA PolylightEffect can be used on a node to define a LightGroup for that node
PolylightNodeA PolylightNode
Pool
PortalNodeA node in the scene graph that can hold a Portal Polygon, which is a rectangle
PosHprInterval
PosHprLerpFunctorClass for Lerping between positions and orientations in space
PosHprScaleInterval
PosHprScaleLerpFunctorClass for Lerping between position, orientation, and scale
PosInterval
PosLerpFunctorClass for Lerping between positions in space
PreparedGraphicsObjectsA table of objects that are saved within the graphics context for reference by handle later
PrimitiveTypeDescriptor
PriorityCallbacks
Process
ProfileSession
ProfileTimer
ProgressBar
ProjectileInterval
ProjectionScreenA ProjectionScreen implements a simple system for projective texturing
ProtoDropTarget
ProtoObjs
ProtoObjsUI
ProtoPalette
ProtoPaletteBase
ProtoPaletteUI
PruneObjectRefs
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
PStatCollectorA lightweight class that represents a single element that may be timed and/or counted via stats
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)
PStatsCallback
PStatScope
PStatThreadA lightweight class that represents a single thread of execution to PStats
PTADouble
PTAFloat
PTAInt
PTAMat3
PTAMat4
PTAUchar
PTAUshort
PTAVecBase2
PTAVecBase3
PTAVecBase4
Pulse
PushesStateChanges
PyDatagram
PyDatagramIterator
PyObjectTypeDescriptor
PythonCallbackObjectThis is a specialization on CallbackObject to allow a callback to directly call an arbitarary Python function
PythonNodePath
pythonresource
PythonTaskThis class exists to allow association of a Python function with the AsyncTaskManager
PythonThreadThis class is exposed to Python to allow creation of a Panda thread from the Python level
PYZTarget
QNameQName wrapper
QuadBitMaskNative
QuatThis is the base quaternion class
QuatDThis is the base quaternion class
Queue
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
QueuedReturnConnectionListenerData
QueuedReturnDatagram
QueuedReturnNetDatagram
QueuedReturnPointerToConnection
RamfileAn in-memory buffer specifically designed for downloading files to memory
RandomizerA handy class to return random numbers
RandomNumGen
RecaptchaResponse
ReceivesMultipleStateChanges
ReceivesStateChanges
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
RectangleEmitterDescribes a planar square region in which particles are generated
RefCounter
ReferenceCountA base class for all things that want to be reference-counted
ReferrerSearch
RelatedObjectMgr
ReMutex
ReMutexDirectThis class implements a standard reMutex by making direct calls to the underlying implementation layer
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
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
RequestDenied
RescaleNormalAttribSpecifies how polygons are to be drawn
resource
DSearchPath.Results
Results
PandaLoader.Results
RetryCancelDialog
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
RingEmitter
RLock
Rope
RopeNodeThis class draws a visible representation of the NURBS curve stored in its NurbsCurveEvaluator
RotatingLog
RotationTest
Row
Mat3.Row
Mat3D.Row
Mat4.Row
Mat4D.Row
SampleObject
SavedContextThis is the base class for all GSG-specific context objects, such as TextureContext and GeomContext
ScaleInterval
ScaleLerpFunctorClass for Lerping between scales
ScanDirectoryNode
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
SceneGraphExplorer
SceneGraphExplorerItem
SceneGraphLeakDetector
SceneGraphReducerAn interface for simplifying ("flattening") scene graphs by eliminating unneeded nodes and collapsing out unneeded state changes and transforms
SceneGraphUI
SceneGraphUIBase
SceneGraphUIDropTarget
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
ScratchPad
ScriptAttributes
scriptresource
SelectedNodePaths
SelectionQueue
SelectionRay
SelectionSegment
SelectionSphere
SelectiveChildNodeA base class for nodes like LODNode and SequenceNode that select only one visible child at a time
SemaphoreA classic semaphore synchronization primitive
Semaphore
Sequence
SequenceInspector
SequenceInspector
SequenceNodeA node that automatically cycles through rendering each one of its children according to its frame rate
SeqValue
SerialMaskedGen
SerialNumGen
ServerRepository
SfxPlayer
ShadeModelAttribSpecifies whether flat shading (per-polygon) or smooth shading (per-vertex) is in effect
Shader
ShaderAttrib
ShaderContextThe ShaderContext is meant to contain the compiled version of a shader string
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
ShaderPoolThis is the preferred interface for loading shaders for the TextNode system
ShadowCaster
ShadowPlacer
SheetNodeThis class draws a visible representation of the NURBS surface stored in its NurbsSurfaceEvaluator
ShipPilot
ShipPilot2
ShowBase
ShowBoundsEffectApplied to a GeomNode to cause a visible bounding volume to be drawn for this node
ShowIntervalAn interval that calls NodePath.show()
Signature
SimpleAllocatorAn implementation of a very simple block allocator
SimpleAllocatorBlockA single block as returned from SimpleAllocator.alloc()
SimpleLerpFunctorPoint2
SimpleLerpFunctorPoint3
SimpleLerpFunctorPoint4
SimpleLerpFunctorVBase2
SimpleLerpFunctorVBase3
SimpleLerpFunctorVBase4
SimpleLerpFunctorVec2
SimpleLerpFunctorVec3
SimpleLerpFunctorVec4
SimpleLruAn implementation of a very simple LRU algorithm
SimpleLruPageOne atomic piece that may be managed by a SimpleLru chain
SimpleQueryLerpFunctorPoint2
SimpleQueryLerpFunctorPoint3
SimpleQueryLerpFunctorPoint4
SimpleQueryLerpFunctorVBase2
SimpleQueryLerpFunctorVBase3
SimpleQueryLerpFunctorVBase4
SimpleQueryLerpFunctorVec2
SimpleQueryLerpFunctorVec3
SimpleQueryLerpFunctorVec4
Singleton
SingletonError
SkinningReplyTo
SliceInspector
SliceInspector
Slider
SliderTableStores the total set of VertexSliders that the vertices in a particular GeomVertexData object might depend on
SliderWidget
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_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
SocketStreamA base class for iostreams that read and write to a (possibly non-blocking) socket
SocketStreamRecorderRecords any data received from the indicated socket stream
SoundInterval
SparkleParticleRendererPretty sparkly things
SparseArrayThis class records a set of integers, where each integer is either present or not present in the set
SphereSurfaceEmitterDescribes a curved space in which particles are generated
SphereVolumeEmitterDescribes a voluminous spherical region in which particles are generated
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
SpriteParticleRendererExt
Squeezer
SSReaderAn internal class for reading from a socket stream
SSWriterAn internal class for writing to a socket stream
Stack
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
StackTrace
Standalone
StartupError
State
StateChangeNode
StateData
StateInspector
StateVar
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
StdLibFilter
StdoutCapture
StdoutPassthrough
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
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
string
StringStreamA bi-directional stream object that reads and writes data to an internal buffer, which can be retrieved and/or set as a string
Structure
SubframeCall
Actor.SubpartDef
SwimWalker
SwitchNodeA node that renders only one of its children, according to the user's indication
Sync
SystemInformation
SystemInformation
TangentRingEmitterDescribes a planar ring region in which tangent particles are generated, and particles fly off tangential to the ring
Target
TarInfoRoot
TarInfoRootOSX
TaskLeakDetector
TaskLeakDetectorBase
TaskManager
TaskManagerPanel
TaskManagerWidget
TaskProfiler
TaskThread
TaskThreaded
TaskTracker
TestAppShell
TestCachedData
TestInterestAddRemove
TestInterval
TestJob
TexGenAttribComputes texture coordinates for geometry automatically based on vertex position and/or normal
TexMatrixAttribApplies a transform matrix to UV's before they are rendered
TexMemWatcher
TexPlacement
TexProjectorEffectThis effect automatically applies a computed texture matrix to the specified texture stage, according to the relative position of two specified nodes
TexRecord
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
TextGraphicThis defines a special model that has been constructed for the purposes of embedding an arbitrary graphic image within a text paragraph
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
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
TexturePeekerAn instance of this object is returned by Texture.peek()
TexturePoolThis is the preferred interface for loading textures from image files
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
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
TexViewer
Thread
ThreadA thread; that is, a lightweight process
Thread
ThreadBase
ThreeUpShow
TimeManager
TimeManagerAI
Timer
Timer
TimeRange
TimeSlider
TimeVal
TiXmlAttribute
TiXmlAttributeSet
TiXmlBase
TiXmlComment
TiXmlCursor
TiXmlDeclaration
TiXmlDocument
TiXmlElement
TiXmlHandle
TiXmlNode
TiXmlPrinter
TiXmlText
TiXmlUnknown
TiXmlVisitor
ToonEyes
Track
TrackballTrackball acts like Performer in trackball mode
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
Transitions
TransparencyAttribThis controls the enabling of transparency
TreeItem
TreeNode
treeresource
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
TwoDWalker
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
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
TypeFilter
TypeHandleTypeHandle is the identifier used to differentiate C++ class types
TypeRegistryMaintains all the assigned TypeHandles in a given system
UndefinedObject
UniqueIdAllocatorManage a set of ID values from min to max inclusive
UniversalDropTarget
Unpickler
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
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
Valuator
ValuatorGroup
ValuatorGroupPanel
VBase2This is the base class for all two-component vectors and points
VBase2DThis is the base class for all two-component vectors and points
VBase3This is the base class for all three-component vectors and points
VBase3DThis is the base class for all three-component vectors and points
VBase4This is the base class for all three-component vectors and points
VBase4DThis is the base class for all three-component vectors and points
Vec2This is a two-component vector offset
Vec2DThis is a two-component vector offset
Vec3This is a three-component vector distance (as opposed to a three-component point, which represents a particular point in space)
Vec3DThis is a three-component vector distance (as opposed to a three-component point, which represents a particular point in space)
Vec4This is a four-component vector distance
Vec4DThis is a four-component vector distance
Vector2Entry
Vector3Entry
Vector4Entry
VectorEntry
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
VertexDataPageA block of bytes that holds one or more VertexDataBlocks
VertexDataSaveFileA temporary file to hold the vertex data that has been evicted from memory and written to disk
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
VFSImporter
VFSLoader
VFSSharedImporter
VFSSharedLoader
VideoTextureThe base class for a family of animated Textures that take their input from a video source, such as a movie file
Viewport
ViewportManager
ViewportMenu
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
VirtualFileHTTPThis maps a document retrieved from an HTTPClient into the VirtualFileSystem, allowing models etc
VirtualFileListA list of VirtualFiles, as returned by VirtualFile.scan_directory()
VirtualFileMountThe abstract base class for a mount definition used within a VirtualFileSystem
VirtualFileMountHTTPMaps a web page (URL root) into the VirtualFileSystem
VirtualFileMountMultifileMaps a Multifile's contents into the VirtualFileSystem
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
VrpnClientA specific ClientBase that connects to a VRPN server and records information on the connected VRPN devices
Wait
WaitIntervalThis interval does absolutely nothing, and is mainly useful for marking time between other intervals within a sequence
WeakPointerToVoidThis is the specialization of PointerToVoid for weak pointers
WebcamVideoAllows you to open a webcam or other video capture device as a video stream
webNotifyDebug
WebRequest
WebRequestDispatcher
WeightedChoice
WidgetPropertiesDialog
WindowControls
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
WritableConfigurableDefined as a fix to allow creating Configurable and Writable objects
WrtParentInterval
WxAppShell
WxPandaShell
WxSlider
xel
YesNoCancelDialog
YesNoDialog
ZlibArchiveDef build(self, path, lTOC): """Create an archive file of name 'path'
ZlibArchive
zlibresource
ZSpinParticleFactory