Panda3D

- Main Page
- Packages
- Classes

- Class List
- Class Index
- Class Hierarchy
- Class Members

# Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

_AttrNotFound |
_BoundedSemaphore |
_CFGLGlobals |
_Condition |
_DummyThread |
_ElementInterface | Internal 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 |
AdaptiveLru | A basic LRU-type algorithm, except that it is adaptive and attempts to avoid evicting pages that have been used more frequently (even if less recently) than other pages
AdaptiveLruPage | One atomic piece that may be managed by a AdaptiveLru chain
AdaptiveLruPageDynamicList |
AdaptiveLruPageStaticList |
AIBehaviors |
AICharacter |
AINode | This class is used to assign the nodes on the mesh
aiWebServer |
AIWorld |
AllHitsRayResultCallback |
AlphabetCounter |
AlphaTestAttrib | Enables or disables writing of pixel to framebuffer based on its alpha value relative to a reference alpha value
AlreadyInTransition |
AmbientLight | A light source that seems to illuminate all points in space at once
AnalogNode | This is the primary interface to analog controls like sliders and joysticks associated with a ClientBase
AnfaPhasedObject |
AngleDial |
AngularEulerIntegrator |
AngularForce | Pure virtual parent of all quat-based forces
AngularIntegrator | Pure virtual base class for physical modeling
AngularVectorForce | Simple directed torque force, the angular equivalent of simple vector force
AnimateVerticesRequest | This class object manages a single asynchronous request to animate vertices on a GeomVertexData object
AnimBundle | This is the root of an AnimChannel hierarchy
AnimBundleNode | This is a node that contains a pointer to an AnimBundle
AnimChannelBase | Parent class for all animation channels
AnimChannelMatrix |
AnimChannelMatrixDynamic | An animation channel that accepts a matrix each frame from some dynamic input provided by code
AnimChannelMatrixXfmTable | An animation channel that issues a matrix each frame, read from a table such as might have been read from an egg file
AnimChannelScalar |
AnimChannelScalarDynamic | An animation channel that accepts a scalar each frame from some dynamic input provided by code
AnimChannelScalarTable | An animation channel that issues a scalar each frame, read from a table such as might have been read from an egg file
AnimControl | Controls the timing of a character animation
AnimControlCollection | This is a named collection of AnimControl pointers
AnimControlInterval |
AnimControlUI |
Actor.AnimDef |
AnimFileDrop |
AnimGroup | This is the base class for AnimChannel and AnimBundle
AnimInterface | This 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 |
AnimPreloadTable | This table records data about a list of animations for a particular model, such as number of frames and frame rate
AntialiasAttrib | Specifies whether or how to enable antialiasing, if supported by the backend renderer
AppRunner |
AppShell |
ArcEmitter |
Archive |
Archive |
archiveresource |
ArchiveTarget |
ArgumentEater |
ArgumentError |
ArgumentError |
ArgumentError |
ARToolKit | ARToolKit is a software library for building Augmented Reality (AR) applications
AsyncRequest |
AsyncTask | This class represents a concrete task performed by an AsyncManager
AsyncTaskBase | The abstract base class for AsyncTask
AsyncTaskChain | The AsyncTaskChain is a subset of the AsyncTaskManager
AsyncTaskCollection | A list of tasks, for instance as returned by some of the AsyncTaskManager query functions
AsyncTaskManager | A class to manage a loose queue of isolated tasks, which can be performed either synchronously (in the foreground thread) or asynchronously (by a background thread)
AsyncTaskPause | A special kind of task that simple returns DS_pause, to pause for a specified number of seconds and then finish
AsyncTaskSequence | A special kind of task that serves as a list of tasks internally
AsyncTestCase |
AsyncTestLoader |
AsyncTestSuite |
AsyncTextTestRunner |
AttribNodeRegistry | This global object records NodePaths that are referenced by scene graph attribs, such as ClipPlaneAttribs and LightAttribs
AttrSetter |
Audio3DManager |
AudioManager |
AudioSound |
AudioVolumeAttrib | Applies a scale to audio volume for positional sounds in the scene graph
AuxBitplaneAttrib | Modern frame buffers can have 'aux' bitplanes, which are additional bitplanes above and beyond the standard depth and color
AuxSceneData | This is a base class for a generic data structure that can be attached per-instance to the camera, to store per-instance data that must be preserved over multiple frames
Averager |
BamCache | This class maintains a cache of Bam and/or Txo objects generated from model files and texture images (as well as possibly other kinds of loadable objects that can be stored in bam file format)
BamCacheRecord | An instance of this class is written to the front of a Bam or Txo file to make the file a cached instance of some other loadable resource
BamEnums | This class exists just to provide scoping for the enums shared by BamReader and BamWriter
BamFile | The principle public interface to reading and writing Bam disk files
BamReader | This is the fundamental interface for extracting binary objects from a Bam file, as generated by a BamWriter
BamWriter | This is the fundamental interface for writing binary objects to a Bam file, to be extracted later by a BamReader
BaseForce | Pure virtual base class for all forces that could POSSIBLY exist
BaseIntegrator | Pure virtual integrator class that holds cached matrix information that really should be common to any possible child implementation
BaseParticleEmitter | Describes a physical region in space in which particles are randomly generated
BaseParticleFactory | Pure Virtual base class for creating particles
BaseParticleRenderer | Pure virtual particle renderer base class
BaseTypeDescriptor |
BattleWalker |
BillboardEffect | Indicates that geometry at this node should automatically rotate to face the camera, or any other arbitrary node
binaryresource |
BindAnimRequest | This class object manages an asynchronous load-and-bind animation request, as issued through PartBundle.load_bind_anim()
BitArray | A dynamic array with an unlimited number of bits
BitMask16 |
BitMask32 |
BitMask64 |
BoundedSemaphore |
BoundingBox | An axis-aligned bounding box; that is, a minimum and maximum coordinate triple
BoundingHexahedron | This defines a bounding convex hexahedron
BoundingLine | This funny bounding volume is an infinite line with no thickness and extending to infinity in both directions
BoundingPlane | This funny bounding volume is an infinite plane that divides space into two regions: the part behind the normal, which is "inside" the bounding volume, and the part in front of the normal, which is "outside" the bounding volume
BoundingSphere | This defines a bounding sphere, consisting of a center and a radius
BoundingVolume | This is an abstract class for any volume in any sense which can be said to define the locality of reference of a node in a graph, along with all of its descendants
BoxEmitter | Describes a voluminous box region in which particles are generated
bp |
BpDb |
BpMan |
BrowserObject |
MovieVideoCursor.Buffer |
Buffer |
BufferContext | This is a base class for those kinds of SavedContexts that occupy an easily-measured (and substantial) number of bytes in the video card's frame buffer memory or AGP memory
Buffered_DatagramConnection |
BufferedDistancePhasedNode |
BufferViewer |
BulletAllHitsRayResult |
BulletBaseCharacterControllerNode |
BulletBodyNode |
BulletBoxShape |
BulletCapsuleShape |
BulletCharacterControllerNode |
BulletClosestHitRayResult |
BulletClosestHitSweepResult |
BulletConeShape |
BulletConeTwistConstraint |
BulletConstraint |
BulletContact |
BulletContactResult |
BulletConvexHullShape |
BulletConvexPointCloudShape |
BulletCylinderShape |
BulletDebugNode |
BulletGenericConstraint |
BulletGhostNode |
BulletHeightfieldShape |
BulletHelper |
BulletHingeConstraint | The hinge constraint lets two bodies rotate around a given axis while adhering to specified limits
BulletinBoard |
BulletinBoardWatcher |
BulletManifoldPoint |
BulletMultiSphereShape |
BulletPersistentManifold |
BulletPlaneShape |
BulletRayHit |
BulletRigidBodyNode |
BulletShape |
BulletSliderConstraint |
BulletSoftBodyConfig |
BulletSoftBodyMaterial |
BulletSoftBodyNode |
BulletSoftBodyNodeElement |
BulletSoftBodyShape |
BulletSoftBodyWorldInfo |
BulletSphereShape |
BulletSphericalConstraint | A constraint between two rigid bodies, each with a pivot point
BulletTriangleMesh |
BulletTriangleMeshShape |
BulletVehicle |
BulletVehicleTuning | Simulates a raycast vehicle which casts a ray per wheel at the ground as a cheap replacement for complex suspension simulation
BulletWheel | One wheel of a BulletVehicle
BulletWorld |
ButtonHandle | A ButtonHandle represents a single button from any device, including keyboard buttons and mouse buttons (but see KeyboardButton and MouseButton)
ButtonNode | This is the primary interface to on/off button devices associated with a ClientBase
ButtonRegistry | Maintains all the assigned ButtonHandles in a given system
ButtonThrower | Throws Panda Events for button down/up events generated within the data graph
CachedDOData |
CachedTypedWritableReferenceCount | This is a special extension to ReferenceCount that includes dual reference counts: the standard reference count number, which includes all references to the object, and a separate number (the cache reference count) that counts the number of references to the object just within its cache alone
Loader.Callback |
CallbackData | This is a generic data block that is passed along to a CallbackObject when a callback is made
CallbackGraphicsWindow | This special window object doesn't represent a window in its own right, but instead hooks into some third-party API for creating and rendering to windows via callbacks
CallbackNode | A special node that can issue arbitrary callbacks to user code, either during the cull or draw traversals
CallbackObject | This is a generic object that can be assigned to a callback at various points in the rendering process
Camera | A node that can be positioned around in the scene graph to represent a point of view for rendering a scene
CArchive |
CArchive |
CardMaker | This class generates 2-d "cards", that is, rectangular polygons, particularly useful for showing textures etc
CartesianGridBase |
CConnectionRepository | This class implements the C++ side of the ConnectionRepository object
CConstrainHprInterval | A constraint interval that will constrain the orientation of one node to the orientation of another
CConstrainPosHprInterval | A constraint interval that will constrain the position and orientation of one node to the position and orientation of another
CConstrainPosInterval | A constraint interval that will constrain the position of one node to the position of another
CConstraintInterval | The base class for a family of intervals that constrain some property to a value over time
CConstrainTransformInterval | A constraint interval that will constrain the transform of one node to the transform of another
CDistributedSmoothNodeBase | This class defines some basic methods of DistributedSmoothNodeBase which have been moved into C++ as a performance optimization
Multifile.CertRecord |
CertRecord |
char |
Character | An animated character, with skeleton-morph animation and either soft-skinned or hard-skinned vertices
CharacterJoint | This represents one joint of the character's animation, containing an animating transform matrix
CharacterJointBundle | The collection of all the joints and sliders in the character
CharacterJointEffect | This effect will be added automatically to a node by CharacterJoint.add_net_transform() and CharacterJoint.add_local_transform()
CharacterSlider | This is a morph slider within the character
CharacterVertexSlider | This is a specialization on VertexSlider that returns the slider value associated with a particular CharacterSlider object
CheckContainers |
CInterval | The base class for timeline components
CIntervalManager | This 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 |
CLerpAnimEffectInterval | This interval lerps between different amounts of control effects for various AnimControls that might be playing on an actor
CLerpInterval | The base class for a family of intervals that linearly interpolate one or more numeric values over time
CLerpNodePathInterval | An interval that lerps one or more properties (like pos, hpr, etc.) on a NodePath over time
ServerRepository.Client |
ClientBase | An abstract base class for a family of client device interfaces--including trackers, buttons, dials, and other analog inputs
ClientRepository |
ClientRepositoryBase |
ClipPlaneAttrib | This functions similarly to a LightAttrib
ClockDelta |
ClockObject | A ClockObject keeps track of elapsed real time and discrete time
ClosestConvexResultCallback |
ClosestRayResultCallback |
ClusterClient |
ClusterClientSync |
ClusterConfigItem |
ClusterMsgHandler |
ClusterServer |
CMetaInterval |
CodeDatabase |
CodeInspector |
CodeInspector |
CollectTarget |
CollisionBox | A cuboid collision volume or object
CollisionEntry | Defines a single collision event
CollisionFloorMesh | This object represents a solid made entirely of triangles, which will only be tested again z axis aligned rays
CollisionHandler | The abstract interface to a number of classes that decide what to do when a collision is detected
CollisionHandlerEvent | A specialized kind of CollisionHandler that throws an event for each collision detected
CollisionHandlerFloor | A specialized kind of CollisionHandler that sets the Z height of the collider to a fixed linear offset from the highest detected collision point each frame
CollisionHandlerFluidPusher | A CollisionHandlerPusher that makes use of timing and spatial information from fluid collisions to improve collision response
CollisionHandlerGravity | A specialized kind of CollisionHandler that sets the Z height of the collider to a fixed linear offset from the highest detected collision point each frame
CollisionHandlerHighestEvent | A specialized kind of CollisionHandler that throws an event for each collision detected
CollisionHandlerPhysical | The abstract base class for a number of CollisionHandlers that have some physical effect on their moving bodies: they need to update the nodes' positions based on the effects of the collision
CollisionHandlerPusher | A specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
CollisionHandlerQueue | A special kind of CollisionHandler that does nothing except remember the CollisionEntries detected the last pass
CollisionInvSphere | An inverted sphere: this is a sphere whose collision surface is the inside surface of the sphere
CollisionLine | An infinite line, similar to a CollisionRay, except that it extends in both directions
CollisionNode | A node in the scene graph that can hold any number of CollisionSolids
CollisionParabola | This defines a parabolic arc, or subset of an arc, similar to the path of a projectile or falling object
CollisionPlane |
CollisionPolygon |
CollisionRay | An infinite ray, with a specific origin and direction
CollisionRecorder | This class is used to help debug the work the collisions system is doing
CollisionSegment | A finite line segment, with two specific endpoints but no thickness
CollisionSolid | The abstract base class for all things that can collide with other things in the world, and all the things they can collide with (except geometry)
CollisionSphere | A spherical collision volume or object
CollisionTraverser | This class manages the traversal through the scene graph to detect collisions
CollisionTube | This implements a solid roughly in cylindrical shape
CollisionVisualizer | This class is used to help debug the work the collisions system is doing
ColorAttrib | Indicates what color should be applied to renderable geometry
ColorBlendAttrib | This specifies how colors are blended into the frame buffer, for special effects
ColorEntry |
ColorInterpolationFunction | Abstract class from which all other functions should inherit
ColorInterpolationFunctionConstant | Defines a constant color over the lifetime of the segment
ColorInterpolationFunctionLinear | Defines a linear interpolation over the lifetime of the segment
ColorInterpolationFunctionSinusoid | Defines a sinusoidal blending between two colors
ColorInterpolationFunctionStepwave | Defines a discrete cyclical transition between two colors
ColorInterpolationManager | High level class for color interpolation
ColorInterpolationSegment | A single unit of interpolation
ColorPicker |
ColorScaleAttrib | Applies a scale to colors in the scene graph and on vertices
ColorWriteAttrib | Enables or disables writing to the color buffer
CommonFilters |
CompassEffect | A CompassEffect causes a node to inherit its rotation (or pos or scale, if specified) from some other reference node in the graph, or more often from the root
CompilationEnvironment |
ComplexInspector |
ComplexInspector |
ConcreteStruct |
Condition |
ConditionVar |
ConditionVarDirect | A condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
ConditionVarFull |
ConditionVarFullDirect | A condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen
ConfigDeclaration | A single declaration of a config variable, typically defined as one line in a .prc file, e.g
ConfigFlags | This class is the base class of both ConfigVariable and ConfigVariableCore
ConfigPage | A page of ConfigDeclarations that may be loaded or unloaded
ConfigPageManager | A global object that maintains the set of ConfigPages everywhere in the world, and keeps them in sorted order
ConfigVariable | This is a generic, untyped ConfigVariable
ConfigVariableBase | This class is the base class for both ConfigVariableList and ConfigVariable (and hence for all of the ConfigVariableBool, ConfigVaribleString, etc
ConfigVariableBool | This is a convenience class to specialize ConfigVariable as a boolean type
ConfigVariableCore | The internal definition of a ConfigVariable
ConfigVariableDouble | This is a convenience class to specialize ConfigVariable as a floating-point type
ConfigVariableFilename | This is a convenience class to specialize ConfigVariable as a Filename type
ConfigVariableInt | This is a convenience class to specialize ConfigVariable as an integer type
ConfigVariableInt64 | This is a convenience class to specialize ConfigVariable as a 64-bit integer type
ConfigVariableList | This class is similar to ConfigVariable, but it reports its value as a list of strings
ConfigVariableManager | A global object that maintains the set of ConfigVariables (actually, ConfigVariableCores) everywhere in the world, and keeps them in sorted order
ConfigVariableSearchPath | This is similar to a ConfigVariableList, but it returns its list as a DSearchPath, as a list of directories
ConfigVariableString | This is a convenience class to specialize ConfigVariable as a string type
Connection | Represents a single TCP or UDP socket for input or output
ConnectionListener | This is a special kind of ConnectionReader that waits for activity on a rendezvous port and accepts a TCP connection (instead of attempting to read a datagram from the rendezvous port)
ConnectionManager | The primary interface to the low-level networking layer in this package
ConnectionReader | This is an abstract base class for a family of classes that listen for activity on a socket and respond to it, for instance by reading a datagram and serving it (or queueing it up for later service)
ConnectionRepository |
ConnectionWriter | This class handles threaded delivery of datagrams to various TCP or UDP sockets
ConstTypeDescriptor |
ContactResultCallback |
ContainerLeakDetector |
ContainerReport |
ControlManager |
CopyOnWriteObject | This base class provides basic reference counting, but also can be used with a CopyOnWritePointer to provide get_read_pointer() and get_write_pointer()
CountedResource |
CppMemoryUsage |
CPTA_double |
CPTA_float |
CPTA_int |
CPTA_LMatrix3d |
CPTA_LMatrix3f |
CPTA_LMatrix4d |
CPTA_LMatrix4f |
CPTA_LVecBase2d |
CPTA_LVecBase2f |
CPTA_LVecBase3d |
CPTA_LVecBase3f |
CPTA_LVecBase4d |
CPTA_LVecBase4f |
CPTA_uchar |
CPTA_ushort |
CRCache |
CRDataCache |
Mat3.CRow |
CRow |
Mat4.CRow |
Mat3D.CRow |
Mat4D.CRow |
CTOC |
CTOC |
CubicCurveseg | A CubicCurveseg is any curve that can be completely described by four 4-valued basis vectors, one for each dimension in three-space, and one for the homogeneous coordinate
CullBinAttrib | Assigns geometry to a particular bin by name
CullBinEnums | Provides scoping for the enumerated type shared by CullBin and CullBinManager
CullBinManager | This is a global object that maintains the collection of named CullBins in the world
CullFaceAttrib | Indicates which faces should be culled based on their vertex ordering
CullHandler |
CullResult | This stores the result of a BinCullHandler traversal: an ordered collection of CullBins, each of which holds a number of Geoms and RenderStates to be rendered in some defined order
CullTraverser | This object performs a depth-first traversal of the scene graph, with optional view-frustum culling, collecting CullState and searching for GeomNodes
CullTraverserData | This 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 |
CylindricalLens | A cylindrical lens
Datagram | An ordered list of data elements, formatted in memory for transmission over a socket or writing to a data file
DatagramGenerator | This class defines the abstract interace to any source of datagrams, whether it be from a file or from the net
DatagramGeneratorNet | This class provides datagrams one-at-a-time as read directly from the net, via a TCP connection
DatagramInputFile | This class can be used to read a binary file that consists of an arbitrary header followed by a number of datagrams
DatagramIterator | A class to retrieve the individual data elements previously stored in a Datagram
DatagramSink | This class defines the abstract interface to sending datagrams to any target, whether it be into a file or across the net
DatagramSinkNet | This class accepts datagrams one-at-a-time and sends them over the net, via a TCP connection
DataGraphTraverser | This object supervises the traversal of the data graph and the moving of data from one DataNode to its children
DataNode | The fundamental type of node for the data graph
dataresource |
DCArrayParameter | This represents an array of some other kind of object, meaning this parameter type accepts an arbitrary (or possibly fixed) number of nested fields, all of which are of the same type
DCAtomicField |
DCClass | Defines a particular DistributedClass as read from an input .dc file
DCClassParameter | This represents a class (or struct) object used as a parameter itself
DCDeclaration | This is a common interface for a declaration in a DC file
DCField | A single field of a Distributed Class, either atomic or molecular
DCFile | Represents the complete list of Distributed Class descriptions as read from a .dc file
DCKeyword | This represents a single keyword declaration in the dc file
DCKeywordList | This is a list of keywords (see DCKeyword) that may be set on a particular field
DCMolecularField | A single molecular field of a Distributed Class, as read from a .dc file
DConfig | This class emulates the old dconfig-style interface to our Panda config system
DCPackData | This is a block of data that receives the results of DCPacker
DCPacker | This class can be used for packing a series of numeric and string data into a binary stream, according to the DC specification
DCPackerInterface | This defines the internal interface for packing values into a DCField
DCParameter | Represents the type specification for a single parameter within a field specification
DCSimpleParameter | This is the most fundamental kind of parameter type: a single number or string, one of the DCSubatomicType elements
DCSwitch | This represents a switch statement, which can appear inside a class body and represents two or more alternative unpacking schemes based on the first field read
DCSwitchParameter | This represents a switch object used as a parameter itself, which packs the appropriate fields of the switch into the message
DCTypedef | This represents a single typedef declaration in the dc file
DecalEffect | Applied to a GeomNode to indicate that the children of this GeomNode are coplanar and should be drawn as decals (eliminating Z-fighting)
Decompressor | This manages run-time decompression of a zlib-compressed stream, as a background or foreground task
Default |
DelayedCall |
DelayedFunctor |
DeltaProfiler |
DepthOffsetAttrib | This is a special kind of attribute that instructs the graphics driver to apply an offset or bias to the generated depth values for rendered polygons, before they are written to the depth buffer
DepthTestAttrib | Enables or disables writing to the depth buffer
DepthWriteAttrib | Enables or disables writing to the depth buffer
DerivedPOD |
DerivedTypeDescriptor |
DestructiveScratchPad |
DevWalker |
Dial |
DialNode | This 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 |
DirectionalLight | A 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 |
DiscEmitter | Describes a planar disc region from which particles are generated
DisplayConnection |
DisplayInformation | This class contains various display information
DisplayRegion | A rectangular subregion within a window for rendering into
DisplayRegionBase | An abstract base class for DisplayRegion, mainly so we can store DisplayRegion pointers in a Camera
DisplayRegionContext |
DisplayRegionCullCallbackData | This specialization on CallbackData is passed when the callback is initiated from the cull traversal, for a DisplayRegion
DisplayRegionDrawCallbackData | This specialization on CallbackData is passed when the callback is initiated from the draw traversal, for a DisplayRegion
DisplayRegionList |
DisplaySearchParameters | Parameters 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 |
DocumentSpec | A descriptor that refers to a particular version of a document
DoHierarchy |
DoInterestManager |
DoubleBitMaskNative |
DownloadDb | A listing of files within multifiles for management of client-side synchronization with a server-provided set of files
DrawableRegion | This is a base class for GraphicsWindow (actually, GraphicsOutput) and DisplayRegion, both of which are conceptually rectangular regions into which drawing commands may be issued
DriveInterface | This is a TFormer, similar to Trackball, that moves around a transform matrix in response to mouse input
DSearchPath | This 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 |
DynamicTextFont | A DynamicTextFont is a special TextFont object that rasterizes its glyphs from a standard font file (e.g
DynamicTextPage | A single "page" of a DynamicTextFont
EaseInBlendType |
EaseInOutBlendType |
EaseOutBlendType |
EditHotKeyDialog |
EggAnimData |
EggAnimPreload | This corresponds to an <AnimPreload> entry
EggAttributes | The set of attributes that may be applied to vertices as well as polygons, such as surface normal and color
EggBin | A type of group node that holds related subnodes
EggBinMaker | This is a handy class for collecting related nodes together
EggCacher |
EggComment | A comment that appears in an egg file within a <Comment> entry
EggCompositePrimitive | The base class for primitives such as triangle strips and triangle fans, which include several component triangles, each of which might have its own color and/or normal
EggCoordinateSystem | The <CoordinateSystem> entry at the top of an egg file
EggCurve | A parametric curve of some kind
EggData | This is the primary interface into all the egg data, and the root of the egg file structure
EggExternalReference | Defines a reference to another egg file which should be inserted at this point
EggFilenameNode | This is an egg node that contains a filename
EggGroup | The main glue of the egg hierarchy, this corresponds to the <Group>, <Instance>, and <Joint> type nodes
EggGroupNode | A base class for nodes in the hierarchy that are not leaf nodes
EggGroupUniquifier | This is a specialization of EggNameUniquifier to generate unique names for EggGroup nodes
EggLine | A line segment, or a series of connected line segments, defined by a <Line> entry
EggMaterial |
EggMaterialCollection | This is a collection of materials by MRef name
EggNamedObject | This is a fairly low-level base class--any egg object that has a name
EggNameUniquifier | This is a handy class for guaranteeing unique node names in an egg hierarchy
EggNode | A base class for things that may be directly added into the egg hierarchy
EggNurbsCurve | A parametric NURBS curve
EggNurbsSurface | A parametric NURBS surface
EggObject | The highest-level base class in the egg directory
EggPoint | A single point, or a collection of points as defined by a single <PointLight> entry
EggPolygon | A single polygon
EggPolysetMaker | A specialization on EggBinMaker for making polysets that share the same basic rendering characteristic
EggPoolUniquifier | This is a specialization of EggNameUniquifier to generate unique names for textures, materials, and vertex pools prior to writing out an egg file
EggPrimitive | A base class for any of a number of kinds of geometry primitives: polygons, point lights, nurbs patches, parametrics curves, etc
EggRenderMode | This class stores miscellaneous rendering properties that is associated with geometry, and which may be set on the geometry primitive level, on the group above it, or indirectly via a texture
EggSAnimData | Corresponding 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
EggSurface | A parametric surface of some kind
EggSwitchCondition | This corresponds to a <SwitchCondition> entry within a group
EggSwitchConditionDistance | A SwitchCondition that switches the levels-of-detail based on distance from the camera's eyepoint
EggTable | This corresponds to a
EggTexture | Defines a texture map that may be applied to geometry
EggTextureCollection | This is a collection of textures by TRef name
EggTransform | This represents the <Transform> entry of a group or texture node: a list of component transform operations, applied in order, that describe a net transform matrix
EggTriangleFan | A connected fan of triangles
EggTriangleStrip | A connected strip of triangles
EggUserData | This is a base class for a user-defined data type to extend egg structures in processing code
EggVertex | Any one-, two-, three-, or four-component vertex, possibly with attributes such as a normal
EggVertexAux | The set of named auxiliary data that may or may not be assigned to a vertex
EggVertexPool | A collection of vertices
EggVertexUV | The set of UV's that may or may not be assigned to a vertex
EggXfmAnimData | Corresponding to an <Xfm$Anim> entry, this stores a two-dimensional table with up to nine columns, one for each component of a transformation
EggXfmSAnim | This 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
ElementTree | ElementTree wrapper class
EmbeddedPandaWindow |
EnterExit |
EntryScale |
EntryScaleGroup |
Enum |
EnumIter |
EnumTypeDescriptor |
error |
Event |
Event | A named event, possibly with parameters
EventArgument |
EventGroup |
EventHandler | A class to monitor events from the C++ side of things
EventInterval |
EventManager |
EventParameter | An optional parameter associated with an event
EventPulse |
EventQueue | A queue of pending events
EventsCallbackData |
CallbackGraphicsWindow.EventsCallbackData |
EventStorePandaNode | A class object for storing specifically objects of type PandaNode
EventStoreTypedRefCount | A class object for storing specifically objects of type TypedReferenceCount, which is different than TypedWritableReferenceCount
EventStoreValueBase | A non-template base class of EventStoreValue (below), which serves mainly to define the placeholder for the virtual output function
ExcelHandler |
Packager.ExcludeFilename |
ExclusiveObjectPool |
ExecutionEnvironment | Encapsulates access to the environment variables and command-line arguments at the time of execution
ExeTarget | Iconfile = 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 |
ExternalThread | The special "external thread" class
ExtFilter |
Extractor | This class automatically extracts the contents of a Multifile to the current directory (or to a specified directory) in the background
Factory |
FadeLODNode | A Level-of-Detail node with alpha based switching
ObjectRef.FailedEval |
FakeDelObject |
FakeObject |
FallTest |
FFIEnvironment |
FFIExternalObject |
FFIInterrogateDatabase |
FFIMethodArgumentTree |
FFIMethodArgumentTreeCollection |
FfmpegAudio | A stream that generates a sequence of audio samples
FfmpegAudioCursor | A stream that generates a sequence of audio samples
FfmpegVideo |
FfmpegVideoCursor |
file |
FileFilter |
FileMgr |
Filename | The name of a file, such as a texture file or an Egg file
FileReference | Keeps a reference-counted pointer to a file on disk
FileSpec |
FileSpec |
FileStream | Implements a C++ stream object suitable for reading from and/or writing to files on disk
FilterConfig |
FilterManager |
FilterProperties | Stores a configuration for a set of audio DSP filters
FindContainers |
FiniteBoundingVolume | A special kind of GeometricBoundingVolume that is known to be finite
FisheyeLens | A fisheye lens
FisheyeMaker | This class is similar to CardMaker, but instead of generating ordinary cards, it generates a circular rose that represents the projection of a 3-D scene through a fisheye lens
Fixture |
Floater |
FloaterGroup |
FloaterWidget |
Flock | This class is used to define the flock attributes and the AI characters which are part of the flock
Fog | Specifies how atmospheric fog effects are applied to geometry
FogAttrib | Applies a Fog to the geometry at and below this node
FontPool | This is the preferred interface for loading fonts for the TextNode system
ForceGroup |
ForceNode | A force that lives in the scene graph and is therefore subject to local coordinate systems
FourState |
FourStateAI |
FPTObjsNamed |
FPTObjsOfType |
FrameBufferProperties | A container for the various kinds of properties we might ask to have on a graphics frameBuffer before we create a GSG
FrameDelayedCall |
FrameProfiler |
FrameRateMeter | This is a special TextNode that automatically updates itself with the current frame rate
FreetypeFont | This is a common base class for both DynamicTextFont and PNMTextMaker
Freezer |
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 |
Geom | A container for geometry primitives
GeomCacheManager | This is used to keep track of, and limit the size of, the cache of munged vertices, which would otherwise be distributed through all of the GeomVertexData objects in the system
GeomContext | This is a special class object that holds all the information returned by a particular GSG to indicate the geom's internal context identifier
GeomDrawCallbackData | This specialization on CallbackData is passed when the callback is initiated from deep within the draw traversal, for a particular Geom
GeomEnums | This class exists just to provide scoping for the various enumerated types used by Geom, GeomVertexData, GeomVertexArrayData, GeomPrimitive, and other related classes
GeometricBoundingVolume | This is another abstract class, for a general class of bounding volumes that actually enclose points in 3-d space, such as BSP's and bounding spheres
GeoMipTerrain | GeoMipTerrain, meaning Panda3D GeoMipMapping, can convert a heightfield image into a 3D terrain, consisting of several GeomNodes
GeomLines | Defines a series of disconnected line segments
GeomLinestrips | Defines a series of line strips
GeomNode | A node that holds Geom objects, renderable pieces of geometry
GeomParticleRenderer |
GeomPoints | Defines a series of disconnected points
GeomPrimitive | This is an abstract base class for a family of classes that represent the fundamental geometry primitives that may be stored in a Geom
GeomTextGlyph | This is a specialization on Geom for containing a primitive intended to represent a DynamicTextGlyph
GeomTriangles | Defines a series of disconnected triangles
GeomTrifans | Defines a series of triangle fans
GeomTristrips | Defines a series of triangle strips
GeomVertexAnimationSpec | This object describes how the vertex animation, if any, represented in a GeomVertexData is encoded
GeomVertexArrayData | This is the data for one array of a GeomVertexData structure
GeomVertexArrayDataHandle | This data object is returned by GeomVertexArrayData.get_handle() or modify_handle()
GeomVertexArrayFormat | This describes the structure of a single array within a Geom data
GeomVertexColumn | This defines how a single column is interleaved within a vertex array stored within a Geom
GeomVertexData | This defines the actual numeric vertex data stored in a Geom, in the structure defined by a particular GeomVertexFormat object
GeomVertexFormat | This class defines the physical layout of the vertex data stored within a Geom
GeomVertexReader | This object provides a high-level interface for quickly reading a sequence of numeric values from a vertex table
GeomVertexRewriter | This object provides the functionality of both a GeomVertexReader and a GeomVertexWriter, combined together into one convenient package
GeomVertexWriter | This object provides a high-level interface for quickly writing a sequence of numeric values from a vertex table
GhostWalker |
GlobalForceGroup |
GlobalFunctionSpecification |
GlobalValueSpecification |
GlobPattern | This class can be used to test for string matches against standard Unix-shell filename globbing conventions
GoldenRectangle |
GraphEditorUI |
GraphEditorWindow |
GraphicsBuffer | An offscreen buffer for rendering into
GraphicsDevice | An abstract device object that is part of Graphics Pipe
GraphicsEngine | This class is the main interface to controlling the render process
GraphicsOutput | This is a base class for the various different classes that represent the result of a frame of rendering
GraphicsOutputBase | An abstract base class for GraphicsOutput, for all the usual reasons
GraphicsPipe | An object to create GraphicsOutputs that share a particular 3-D API
GraphicsPipeSelection | This maintains a list of GraphicsPipes by type that are available for creation
GraphicsStateGuardian | Encapsulates all the communication with a particular instance of a given rendering backend
GraphicsStateGuardianBase | This is a base class for the GraphicsStateGuardian class, which is itself a base class for the various GSG's for different platforms
GraphicsThreadingModel | This represents the user's specification of how a particular frame is handled by the various threads
GraphicsWindow | A window, fullscreen or on a desktop, into which a graphics device sends its output for interactive display
GraphicsWindowInputDevice | This is a structure representing a single input device that may be associated with a window
GraphicsWindowProcCallbackData | This specialization on CallbackData is passed when the callback is initiated from from an implementation of the GraphicsWindowProc class, such as PythonGraphicsWindowProc
GravityWalker |
GridChild |
GridParent |
GridSizeUI |
GRPICONDIR |
GRPICONDIRENTRY |
HashVal | Stores a 128-bit value that represents the hashed contents (typically MD5) of a file or buffer
HeightfieldTesselator | Converts a height field in the form of a greyscale image into a scene consisting of a number of GeomNodes
HermiteCurve | A parametric curve defined by a sequence of control vertices, each with an in and out tangent
HideInterval | An interval that calls NodePath.hide()
HierarchyException |
PNMImageHeader.Histogram |
Histogram |
Packager.HostEntry |
HostInfo |
HotkeyBreaker |
HotKeyPanel |
HotKeyUI |
HprInterval |
HprScaleInterval |
HTMLStringToElements |
HTMLTree |
HTTPChannel | A single channel of communication from an HTTPClient
HTTPClient | Handles contacting an HTTP server and retrieving a document
HTTPCookie | A cookie sent from an HTTP server to be stored on the client and returned when the path and/or domain matches
HTTPDate | A container for an HTTP-legal time/date indication
HTTPEntityTag | A container for an "entity tag" from an HTTP server
HTTPEnum | This class is just used as a namespace wrapper for some of the enumerated types used by various classes within the HTTPClient family
Icon |
ICONDIRENTRY |
ICONDIRHEADER |
IconFile |
IDecompressStream | An input stream object that uses zlib to decompress (inflate) the input from another source stream on-the-fly
IDecryptStream | An input stream object that uses OpenSSL to decrypt the input from another source stream on-the-fly
IFileStream | Implements a C++ stream object suitable for reading from files on disk
ifstream |
IgnoreInterval |
Importer |
IndexBufferContext | This is a special class object that holds all the information returned by a particular GSG to indicate the vertex data array's internal context identifier
IndirectInterval |
Indirection |
InkblotVideo | A cellular automaton that generates an amusing pattern of swirling colors
InkblotVideoCursor | A cellular automaton that generates an amusing pattern of swirling colors
InputState |
InputStateForceToken |
InputStateToken |
InputStateTokenGroup |
InputStateWatchToken |
Inspector |
Inspector | Classes
InspectorWindow |
InstalledHostData |
InstalledPackageData |
Installer |
PackageInfo.InstallStep |
InstallTarget |
InstanceInspector |
InstanceInspector |
InstanceMethodInspector |
InstanceMethodInspector |
int |
InterestHandle |
InterestState |
InterestWatcher |
InternalName | Encodes a string name in a hash table, mapping it to a pointer
InternalNameCollection |
InterrogateDatabase |
InterrogateDerivation |
InterrogateEnumValue |
InterrogateFunction |
InterrogateParameter |
InterrogateTokenizer | Interrogate Database Tokenizer
InterrogateType |
InterrogateWrapper |
IntersectionBoundingVolume | This special bounding volume is the intersection of all of its constituent bounding volumes
Interval |
IntervalManager |
InvalidResource |
ios |
ios_base |
iostream |
ISocketStream | This is a base class for istreams implemented in Panda that read from a (possibly non-blocking) socket
istream |
IStreamWrapper | This class provides a locking wrapper around an arbitrary istream pointer
ISubStream | An istream object that presents a subwindow into another istream
Job |
JobManager |
JointVertexTransform | This is a specialization on VertexTransform that returns the transform necessary to move vertices as if they were assigned to the indicated joint
KeyboardButton | This class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard keyboard keys
LandingPage |
LayerEditorUI |
LazySortTest |
LeakDetector |
Lens | A base class for any number of different kinds of lenses, linear and otherwise
LensNode | A node that contains a Lens
LerpAnimInterval |
LerpBlendType |
LerpColorInterval |
LerpColorScaleInterval |
LerpFunc |
LerpFuncNS |
LerpFunctionInterval |
LerpFunctionNoStateInterval |
LerpHprInterval |
LerpHprScaleInterval |
LerpNodePathInterval |
LerpPosHprInterval |
LerpPosHprScaleInterval |
LerpPosHprScaleShearInterval |
LerpPosInterval | It 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 |
LFrustumd |
LFrustumf |
Light | The abstract interface to all kinds of lights
LightAttrib | Indicates which set of lights should be considered "on" to illuminate geometry at this level and below
LightLensNode | A derivative of Light and of Camera
LightMutex |
LightMutexDirect | This class implements a lightweight Mutex by making direct calls to the underlying implementation layer
LightNode | A derivative of Light and of PandaNode
LightRampAttrib | A Light Ramp is any unary operator that takes a rendered pixel as input, and adjusts the brightness of that pixel
LightReMutex |
LightReMutexDirect | This class implements a standard lightReMutex by making direct calls to the underlying implementation layer
LinearControlForce | Simple directed vector force
LinearCylinderVortexForce | Defines a cylinder inside of which all forces are tangential to the theta of the particle wrt the z-axis in local coord
LinearDistanceForce | Pure virtual class for sinks and sources
LinearEulerIntegrator |
LinearForce |
LinearFrictionForce | Friction-based drag force
LinearIntegrator | Pure virtual base class for physical modeling
LinearJitterForce |
LinearNoiseForce | Repeating noise force vector
LinearRandomForce | Pure virtual, parent to noiseForce and jitterForce
LinearSinkForce | Attractor force
LinearSourceForce | Repellant force
LinearUserDefinedForce | Programmable force that takes an evaluator fn
LinearVectorForce | Simple directed vector force
LineEmitter | Describes a linear region in which particles are generated
LineNodePath |
LineParticleRenderer | Renders a line from last position to current position -- good for rain, sparks, etc
LineSegs | Encapsulates creation of a series of connected or disconnected line segments or points, for drawing paths or rays
LineStream | This is a special ostream that writes to a memory buffer, like ostrstream
LinkedListNode | This just stores the pointers to implement a doubly-linked list of some kind of object
Loader |
LoaderFileType | This is the base class for a family of scene-graph file types that the Loader supports
LoaderFileTypeRegistry | This class maintains the set of all known LoaderFileTypes in the universe
LoaderOptions | Specifies parameters that may be passed to the loader
Lock |
Lock |
LockType |
LODNode | A Level-of-Detail node
Logger |
LOrientationd | This is a unit quaternion representing an orientation
LOrientationf | This is a unit quaternion representing an orientation
LParabolad | An abstract mathematical description of a parabola, particularly useful for describing arcs of projectiles
LParabolaf | An abstract mathematical description of a parabola, particularly useful for describing arcs of projectiles
LPlaned | An abstract mathematical description of a plane
LPlanef | An abstract mathematical description of a plane
LRotationd | This is a unit quaternion representing a rotation
LRotationf | This is a unit quaternion representing a rotation
lTOC |
MainThread |
MainThread | The special "main thread" class
ManifestSpecification |
Mat3 | This is a 3-by-3 transform matrix
Mat3D | This is a 3-by-3 transform matrix
Mat4 | This is a 4-by-4 transform matrix
Mat4D | This is a 4-by-4 transform matrix
Material | Defines the way an object appears in the presence of lighting
MaterialAttrib | Indicates which, if any, material should be applied to geometry
MaterialCollection |
MaterialPool | The MaterialPool (there is only one in the universe) serves to unify different pointers to the same Material, so we do not (a) waste memory with many different Material objects that are all equivalent, and (b) waste time switching the graphics engine between different Material states that are really the same thing
MathNumbers |
MatrixLens | A completely generic linear lens
MayaConverter |
MemoryBase | This class is intended to be the base class of all objects in Panda that might be allocated and deleted via the new and delete operators
MemoryExplorer |
MemoryExplorerItem |
MemoryHook | This class provides a wrapper around the various possible malloc schemes Panda might employ
MEMORYSTATUS |
MemoryUsage | This class is used strictly for debugging purposes, specifically for tracking memory leaks of reference-counted objects: it keeps a record of every such object currently allocated
MemoryUsagePointers | This is a list of pointers returned by a MemoryUsage object in response to some query
Mersenne |
MeshDrawer | Mesh drawer creates a single geom object that can be shaped with different draw commands
MeshDrawer2D | This 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 |
MicrophoneAudio | Class MicrophoneAudio provides the means to read raw audio samples from a microphone
MiniLog |
MiniLogSentry |
MiniTask |
MiniTaskManager |
MkImporter |
ModelFlattenRequest | This class object manages a single asynchronous request to flatten a model
ModelLoadRequest | A class object that manages a single asynchronous model load request
ModelNode | This node is placed at key points within the scene graph to indicate the roots of "models": subtrees that are conceptually to be treated as a single unit, like a car or a room, for instance
ModelPool | This 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 |
ModelRoot | A node of this type is created automatically at the root of each model file that is loaded
ModFilter |
ModifierButtons | This 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 |
MouseAndKeyboard | Reads the mouse and/or keyboard data sent from a GraphicsWindow, and transmits it down the data graph
MouseButton | This class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard mouse buttons
MouseData | Holds the data that might be generated by a 2-d pointer input device, such as the mouse in the GraphicsWindow
MouseInterfaceNode | This is the base class for some classes that monitor the mouse and keyboard input and perform some action due to their state
MouseRecorder | This object records any data generated by a particular MouseAndKeyboard node on the datagraph for a session for eventual playback via a DataGraphPlayback (and a PlaybackController)
MouseResource |
MouseSubregion | The MouseSubregion object scales the mouse inputs from within a rectangular region of the screen, as if they were the full-screen inputs
MouseWatcher | This TFormer maintains a list of rectangular regions on the screen that are considered special mouse regions; typically these will be click buttons
MouseWatcherGroup | This represents a collection of MouseWatcherRegions that may be managed as a group
MouseWatcherParameter | This is sent along as a parameter to most events generated for a region to indicate the mouse and button state for the event
MouseWatcherRegion | This is the class that defines a rectangular region on the screen for the MouseWatcher
MovieAudio | A MovieAudio is actually any source that provides a sequence of audio samples
MovieAudioCursor | A MovieAudio is actually any source that provides a sequence of audio samples
MovieTexture | A texture that fetches video frames from an underlying object of class Movie
MovieVideo | A MovieVideo is actually any source that provides a sequence of video frames
MovieVideoCursor | A MovieVideo is actually any source that provides a sequence of video frames
MovingPartACMatrixSwitchType |
MovingPartACScalarSwitchType |
MovingPartBase | This is the base class for a single animatable piece that may be bound to one channel (or more, if blending is in effect)
MovingPartMatrix | This is a particular kind of MovingPart that accepts a matrix each frame
MovingPartScalar | This is a particular kind of MovingPart that accepts a scalar each frame
Multifile | A file that contains a set of files
MultiplexStream | This is a special ostream that forwards the data that is written to it to any number of other sources, for instance other ostreams, or explicitly to a disk file or to system logging utilities
MultitexReducer | This object presents an interface for generating new texture images that represent the combined images from one or more individual textures, reproducing certain kinds of multitexture effects without depending on multitexture support in the hardware
Mutex |
MutexDirect | This class implements a standard mutex by making direct calls to the underlying implementation layer
Namable | A base class for all things which can have a name
NativeWindowHandle | This subclass of WindowHandle exists to allow simple creation of a WindowHandle of the appropriate type to the current OS
NetAddress |
NetDatagram | A specific kind of Datagram, especially for sending across or receiving from a network
NetMessenger |
NeverFreeMemory | This class is used to allocate bytes of memory from a pool that is never intended to be freed
NewStyle |
NoBlendType |
NodeCachedReferenceCount | This class further specializes CachedTypedWritableReferenceCount to also add a node_ref_count, for the purposes of counting the number of times the object is referenced by a "node", presumably a PandaNode
NodeCullCallbackData | This kind of CallbackData is passed to the CallbackObject added to CallbackNode:set_cull_callback()
NodePath | NodePath is the fundamental system for disambiguating instances, and also provides a higher-level interface for manipulating the scene graph
NodePathCollection | This is a set of zero or more NodePaths
NodeReferenceCount | This class specializes ReferenceCount to add an additional counter, called node_ref_count, for the purposes of counting the number of times the object is referenced by a "node", whatever that may mean in context
NodeVertexTransform | This VertexTransform gets its matrix from the Transform stored on a node
NoDictKey |
NonlinearImager | This class object combines the rendered output of a 3-d from one or more linear (e.g
NonPhysicsWalker |
Notifier |
Notify | An object that handles general error reporting to the user
NotifyCategory | A particular category of error messages
NotifyPanel |
NurbsCurve | A Nonuniform Rational B-Spline
NurbsCurveEvaluator | This class is an abstraction for evaluating NURBS curves
NurbsCurveInterface | This abstract class defines the interface only for a Nurbs-style curve, with knots and coordinates in homogeneous space
NurbsCurveResult | The result of a NurbsCurveEvaluator
NurbsSurfaceEvaluator | This class is an abstraction for evaluating NURBS surfaces
NurbsSurfaceResult | The 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 |
OccluderEffect | This functions similarly to a LightAttrib or ClipPlaneAttrib
OccluderNode | A node in the scene graph that can hold an occluder polygon, which must be a rectangle
OCompressStream | An input stream object that uses zlib to compress (deflate) data to another destination stream on-the-fly
OdeAMotorJoint |
OdeBallJoint |
OdeBody |
OdeBoxGeom |
OdeCappedCylinderGeom |
OdeCollisionEntry | A 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 |
OEncryptStream | An input stream object that uses OpenSSL to encrypt data to another destination stream on-the-fly
OFileStream | Implements a C++ stream object suitable for writing to files on disk
ofstream |
OkCancelDialog |
OkDialog |
OldClientRepository |
OmniBoundingVolume | This is a special kind of GeometricBoundingVolume that fills all of space
OnScreenDebug |
OnscreenGeom |
OnscreenImage |
OnscreenText |
OpenCVTexture | A 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
OpenGLPandaWindow |
OrthographicLens | An orthographic lens
WindowHandle.OSHandle |
OSHandle |
OSocketStream | A base class for ostreams that write to a (possibly non-blocking) socket
OSphereLens | A OSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
ostream |
OStreamWrapper | This class provides a locking wrapper around an arbitrary ostream pointer
OSubStream | An ostream object that presents a subwindow into another ostream
OutsideOfPackageError |
PatchMaker.Package |
Packager.Package |
PackageArchive |
PackageArchiveImporter | Base 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 |
PandaLoader | A convenient class for loading models from disk, in bam or egg format (or any of a number of other formats implemented by a LoaderFileType, such as ptloader)
PandaModuleFinder |
PandaNode | A basic node of the scene graph or data graph
PandaSystem | This class is used as a namespace to group several global properties of Panda
PandaTextDropTarget |
Parallel |
ParallelEndTogether |
ParametricCurve | A virtual base class for parametric curves
ParametricCurveCollection | This is a set of zero or more ParametricCurves, which may or may not be related
ParamObj |
ParamObjTest |
ParamObj.ParamSet |
ParamObjTest.ParamSet |
ParasiteBuffer | This is a special GraphicsOutput type that acts a lot like a GraphicsBuffer, effectively allowing rendering to an offscreen buffer, except it does not create any framebuffer space for itself
ParentInterval |
ParentMgr |
ParseTreeInfo |
PartBundle | This is the root of a MovingPart hierarchy
PartBundleHandle | This is a trivial class returned by PartBundleNode.get_bundle()
PartBundleNode | This is a node that contains a pointer to an PartBundle
Actor.PartDef |
PartGroup | This is the base class for PartRoot and MovingPart
ParticleEffect |
ParticleFloorTest |
ParticleInterval |
ParticlePanel |
Particles |
ParticleSystem | Contains and manages a particle system
ParticleSystemManager | Manages a set of individual ParticleSystem objects, so that each individual one doesn't have to be updated and rendered every frame See Also : particleSystemManager.cxx
PartSubset | This class is used to define a subset of part names to apply to the PartBundle.bind_anim() operation
Patcher | Applies a patch synchronously
PatchMaker.Patchfile |
Patchfile |
PatchMaker |
PatternFilter |
PackageInstaller.PendingPackage |
PercentStats |
PerlinNoise | This is the base class for PerlinNoise2 and PerlinNoise3, different dimensions of Perlin noise implementation
PerlinNoise2 | This class provides an implementation of Perlin noise for 2 variables
PerlinNoise3 | This class provides an implementation of Perlin noise for 3 variables
PerspectiveLens | A perspective-type lens: a normal camera
PfmFile | Defines a pfm file, a 2-d table of floating-point numbers, either 3-component or 1-component
PGButton | This is a particular kind of PGItem that is specialized to behave like a normal button object
PGButtonNotify | Objects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
PGEntry | This is a particular kind of PGItem that handles simple one-line or short multi-line text entries, of the sort where the user can type any string
PGFrameStyle |
PGItem | This is the base class for all the various kinds of gui widget objects
PGMouseWatcherBackground | This is a special kind of MouseWatcherRegion that doesn't have a rectangle and is never active, but just quietly listens for keypresses and sends them to all the PGItems with background focus
PGMouseWatcherParameter | This specialization on MouseWatcherParameter allows us to tag on additional elements to events for the gui system, and also inherits from TypedWritableReferenceCount so we can attach this thing to an event
PGScrollFrame | This is a special kind of frame that pretends to be much larger than it actually is
PGSliderBar | This is a particular kind of PGItem that draws a little bar with a slider that moves from left to right indicating a value between the ranges
PGSliderBarNotify | Objects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
PGTop | The "top" node of the new Panda GUI system
PGVirtualFrame | This represents a frame that is rendered as a window onto another (possibly much larger) canvas
PGWaitBar | This is a particular kind of PGItem that draws a little bar that fills from left to right to indicate a slow process gradually completing, like a traditional "wait, loading" bar
PhasedObject |
Physical | Defines a set of physically modeled attributes
PhysicalNode |
PhysicsCollisionHandler | A specialized kind of CollisionHandler that simply pushes back on things that attempt to move into solid walls
PhysicsManager | Physics don't get much higher-level than this
PhysicsObject | A body on which physics will be applied
PhysicsObjectCollection | This is a set of zero or more PhysicsObjects
PhysicsWalker |
Pickler |
PiecewiseCurve | A PiecewiseCurve is a curve made up of several curve segments, connected in a head-to-tail fashion
PipeOcclusionCullTraverser | This specialization of CullTraverser uses the graphics pipe itself to perform occlusion culling
pixel |
PixelSpec |
PNMImageHeader.PixelSpec |
PixelSpecCount |
PNMImageHeader.PixelSpecCount |
PkgFilter |
pkgresource |
Placer |
PlaneNode | A node that contains a plane
PNMBrush | This class is used to control the shape and color of the drawing operations performed by a PNMPainter object
PNMFileType | This is the base class of a family of classes that represent particular image file types that PNMImage supports
PNMFileTypeRegistry | This class maintains the set of all known PNMFileTypes in the universe
PNMImage | The name of this class derives from the fact that we originally implemented it as a layer on top of the "pnm library", based on netpbm, which was built to implement pbm, pgm, and pbm files, and is the underlying support of a number of public-domain image file converters
PNMImageHeader | This is the base class of PNMImage, PNMReader, and PNMWriter
PNMPainter | This class provides a number of convenient methods for painting drawings directly into a PNMImage
PNMTextGlyph | A single glyph in a PNMTextMaker
PNMTextMaker | This object uses the Freetype library to generate text directly into an image
POD |
PODtest |
Point2 | This is a two-component point in space
Point2D | This is a two-component point in space
Point3 | This is a three-component point in space (as opposed to a three-component vector, which represents a direction and a distance)
Point3D | This is a three-component point in space (as opposed to a three-component vector, which represents a direction and a distance)
Point4 | This is a four-component point in space
Point4D | This is a four-component point in space
PointEmitter | Describes a planar ring region in which particles are generated
PointerEventList | Records a set of pointer events that happened recently
PointerToArrayBasedouble |
PointerToArrayBasefloat |
PointerToArrayBaseint |
PointerToArrayBaseMat3 |
PointerToArrayBaseMat3D |
PointerToArrayBaseUnalignedLMatrix4d |
PointerToArrayBaseUnalignedLMatrix4f |
PointerToArrayBaseUnalignedLVecBase4d |
PointerToArrayBaseUnalignedLVecBase4f |
PointerToArrayBaseVBase2 |
PointerToArrayBaseVBase2D |
PointerToArrayBaseVBase3 |
PointerToArrayBaseVBase3D |
PointerToBaseConnection |
PointerToBaseReferenceCountedVectordouble |
PointerToBaseReferenceCountedVectorfloat |
PointerToBaseReferenceCountedVectorint |
PointerToBaseReferenceCountedVectorMat3 |
PointerToBaseReferenceCountedVectorMat3D |
PointerToBaseReferenceCountedVectorUnalignedLMatrix4d |
PointerToBaseReferenceCountedVectorUnalignedLMatrix4f |
PointerToBaseReferenceCountedVectorUnalignedLVecBase4d |
PointerToBaseReferenceCountedVectorUnalignedLVecBase4f |
PointerToBaseReferenceCountedVectorVBase2 |
PointerToBaseReferenceCountedVectorVBase2D |
PointerToBaseReferenceCountedVectorVBase3 |
PointerToBaseReferenceCountedVectorVBase3D |
PointerToConnection |
PointerToVoid | This is the non-template part of the base class for PointerTo and ConstPointerTo
PointerTypeDescriptor |
PointLight | A light originating from a single point in space, and shining in all directions
PointParticleFactory | Creates point particles to user specs
PointParticleRenderer | Simple point/point particle renderer
PolylightEffect | A PolylightEffect can be used on a node to define a LightGroup for that node
PolylightNode | A PolylightNode
Pool |
PortalNode | A node in the scene graph that can hold a Portal Polygon, which is a rectangle
PosHprInterval |
PosHprScaleInterval |
PosInterval |
PreparedGraphicsObjects | A table of objects that are saved within the graphics context for reference by handle later
PrimitiveTypeDescriptor |
PriorityCallbacks |
Process |
ProfileSession |
ProfileTimer |
ProgressBar |
ProjectileInterval |
ProjectionScreen | A ProjectionScreen implements a simple system for projective texturing
PropertiesCallbackData |
CallbackGraphicsWindow.PropertiesCallbackData |
ProtoDropTarget |
ProtoObjs |
ProtoObjsUI |
ProtoPalette |
ProtoPaletteBase |
ProtoPaletteUI |
PruneObjectRefs |
PSphereLens | A PSphereLens is a special nonlinear lens that doesn't correspond to any real physical lenses
PStatClient | Manages the communications to report statistics via a network connection to a remote PStatServer
PStatCollector | A lightweight class that represents a single element that may be timed and/or counted via stats
PStatCollectorForward | This class serves as a cheap forward reference to a PStatCollector, so that classes that are defined before the pstats module may access the PStatCollector
PStatCollectorForwardBase | This class serves as a cheap forward reference to a PStatCollector, which is defined in the pstatclient module (and is not directly accessible here in the express module)
PStatsCallback |
PStatScope |
PStatThread | A lightweight class that represents a single thread of execution to PStats
PTA_double |
PTA_float |
PTA_int |
PTA_LMatrix3d |
PTA_LMatrix3f |
PTA_LMatrix4d |
PTA_LMatrix4f |
PTA_LVecBase2d |
PTA_LVecBase2f |
PTA_LVecBase3d |
PTA_LVecBase3f |
PTA_LVecBase4d |
PTA_LVecBase4f |
PTA_uchar |
PTA_ushort |
Pulse |
PushesStateChanges |
PyDatagram |
PyDatagramIterator |
PyObjectTypeDescriptor |
PythonCallbackObject | This is a specialization on CallbackObject to allow a callback to directly call an arbitarary Python function
PythonNodePath |
pythonresource |
PythonTask | This class exists to allow association of a Python function with the AsyncTaskManager
PythonThread | This class is exposed to Python to allow creation of a Panda thread from the Python level
PYZTarget |
QName | QName wrapper
QuadBitMaskNative |
Quat | This is the base quaternion class
QuatD | This is the base quaternion class
Queue |
QueuedConnectionListener | This flavor of ConnectionListener will queue up all of the TCP connections it established for later detection by the client code
QueuedConnectionManager | This flavor of ConnectionManager will queue up all of the reset-connection messages from the ConnectionReaders and ConnectionWriters and report them to the client on demand
QueuedConnectionReader | This flavor of ConnectionReader will read from its sockets and queue up all of the datagrams read for later receipt by the client code
QueuedReturnConnectionListenerData |
QueuedReturnDatagram |
QueuedReturnNetDatagram |
QueuedReturnPointerToConnection |
Ramfile | An in-memory buffer specifically designed for downloading files to memory
Randomizer | A handy class to return random numbers
RandomNumGen |
RecaptchaResponse |
ReceivesMultipleStateChanges |
ReceivesStateChanges |
RecentConnectionReader | This flavor of ConnectionReader will read from its sockets and retain only the single most recent datagram for inspection by client code
RecorderBase | This is the base class to a number of objects that record particular kinds of user input (like a MouseRecorder) to use in conjunction with a RecorderController to record the user's inputs for a session
RecorderController | This object manages the process of recording the user's runtime inputs to a bam file so that the session can be recreated later
RectangleEmitter | Describes a planar square region in which particles are generated
RefCounter |
ReferenceCount | A base class for all things that want to be reference-counted
ReferrerSearch |
RelatedObjectMgr |
ReMutex |
ReMutexDirect | This class implements a standard reMutex by making direct calls to the underlying implementation layer
RenderAttrib | This is the base class for a number of render attributes (other than transform) that may be set on scene graph nodes to control the appearance of geometry
RenderAttribRegistry | This class is used to associate each RenderAttrib with a different slot index at runtime, so we can store a list of RenderAttribs in the RenderState object, and very quickly look them up by type
RenderCallbackData |
CallbackGraphicsWindow.RenderCallbackData |
RenderEffect | This is the base class for a number of special render effects that may be set on scene graph nodes to change the way they render
RenderEffects | This represents a unique collection of RenderEffect objects that correspond to a particular renderable state
RenderModeAttrib | Specifies how polygons are to be drawn
RenderState | This represents a unique collection of RenderAttrib objects that correspond to a particular renderable state
RequestDenied |
RescaleNormalAttrib | Specifies how polygons are to be drawn
resource |
DSearchPath.Results |
Results |
PandaLoader.Results |
RetryCancelDialog |
RigidBodyCombiner | This is a special node that combines multiple independently-moving rigid nodes into one Geom internally (or as few Geoms as possible), for the purposes of improving rendering performance
RingEmitter |
RLock |
Rope |
RopeNode | This class draws a visible representation of the NURBS curve stored in its NurbsCurveEvaluator
RotatingLog |
RotationTest |
Mat3D.Row |
Mat4.Row |
Mat4D.Row |
Mat3.Row |
Row |
SampleObject |
SavedContext | This is the base class for all GSG-specific context objects, such as TextureContext and GeomContext
ScaleInterval |
ScanDirectoryNode |
SceneGraphAnalyzer | A handy class that can scrub over a scene graph and collect interesting statistics on it
SceneGraphAnalyzerMeter | This is a special TextNode that automatically updates itself with output from a SceneGraphAnalyzer instance
SceneGraphExplorer |
SceneGraphExplorerItem |
SceneGraphLeakDetector |
SceneGraphReducer | An interface for simplifying ("flattening") scene graphs by eliminating unneeded nodes and collapsing out unneeded state changes and transforms
SceneGraphUI |
SceneGraphUIBase |
SceneGraphUIDropTarget |
SceneSetup | This object holds the camera position, etc., and other general setup information for rendering a particular scene
ScissorAttrib | This restricts rendering to within a rectangular region of the scene, without otherwise affecting the viewport or lens properties
ScissorEffect | This provides a higher-level wrapper around ScissorAttrib
ScratchPad |
ScriptAttributes |
scriptresource |
SelectedNodePaths |
SelectionQueue |
SelectionRay |
SelectionSegment |
SelectionSphere |
SelectiveChildNode | A base class for nodes like LODNode and SequenceNode that select only one visible child at a time
Semaphore | A classic semaphore synchronization primitive
Semaphore |
Sequence |
SequenceInspector |
SequenceInspector |
SequenceNode | A node that automatically cycles through rendering each one of its children according to its frame rate
SeqValue |
SerialMaskedGen |
SerialNumGen |
ServerRepository |
SfxPlayer |
ShadeModelAttrib | Specifies whether flat shading (per-polygon) or smooth shading (per-vertex) is in effect
Shader |
ShaderAttrib |
ShaderContext | The ShaderContext is meant to contain the compiled version of a shader string
ShaderGenerator | The ShaderGenerator is a device that effectively replaces the classic fixed function pipeline with a 'next-gen' fixed function pipeline
ShaderInput | This is a small container class that can hold any one of the value types that can be passed as input to a shader
ShaderPool | This is the preferred interface for loading shaders for the TextNode system
ShadowCaster |
ShadowPlacer |
SheetNode | This class draws a visible representation of the NURBS surface stored in its NurbsSurfaceEvaluator
ShowBase |
ShowBoundsEffect | Applied to a GeomNode to cause a visible bounding volume to be drawn for this node
ShowInterval | An interval that calls NodePath.show()
Signature |
SimpleAllocator | An implementation of a very simple block allocator
SimpleAllocatorBlock | A single block as returned from SimpleAllocator.alloc()
SimpleLru | An implementation of a very simple LRU algorithm
SimpleLruPage | One atomic piece that may be managed by a SimpleLru chain
Singleton |
SingletonError |
SkinningReplyTo |
SliceInspector |
SliceInspector |
Slider |
SliderTable | Stores the total set of VertexSliders that the vertices in a particular GeomVertexData object might depend on
SliderWidget |
SmoothGridChild |
SmoothMover | This class handles smoothing of sampled motion points over time, e.g
Socket_Address | A simple place to store and munipulate tcp and port address for communication layer
Socket_fdset |
Socket_IP | Base functionality for a INET domain Socket this call should be the starting point for all other unix domain sockets
Socket_TCP | Base functionality for a TCP connected socket This class is pretty useless by itself but it does hide some of the platform differences from machine to machine
Socket_TCP_Listen | Base functionality for a TCP rendezvous socket
Socket_UDP | Base functionality for a combination UDP Reader and Writer
Socket_UDP_Incoming | Base functionality for a UDP Reader
Socket_UDP_Outgoing | Base functionality for a UDP Sending Socket
SocketStream | A base class for iostreams that read and write to a (possibly non-blocking) socket
SocketStreamRecorder | Records any data received from the indicated socket stream
SoundInterval |
SparkleParticleRenderer | Pretty sparkly things
SparseArray | This class records a set of integers, where each integer is either present or not present in the set
SphereSurfaceEmitter | Describes a curved space in which particles are generated
SphereVolumeEmitter | Describes a voluminous spherical region in which particles are generated
Spotlight | A light originating from a single point in space, and shining in a particular direction, with a cone-shaped falloff
SpriteAnim | Helper class used by SpriteParticleRenderer to keep track of its textures and their respective UVs and source types
SpriteParticleRenderer | Renders a particle system with high-speed nasty trick sprites
SpriteParticleRendererExt |
Squeezer |
SSReader | An internal class for reading from a socket stream
SSWriter | An internal class for writing to a socket stream
Stack |
StackedPerlinNoise2 | Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
StackedPerlinNoise3 | Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
StackTrace |
StagedObject |
Standalone |
StartupError |
State |
StateChangeNode |
StateData |
StateInspector |
StateVar |
StaticTextFont | A StaticTextFont is loaded up from a model that was previously generated via egg-mkfont, and contains all of its glyphs already generated and available for use
StdLibFilter |
StdoutCapture |
StdoutPassthrough |
StencilAttrib | A StencilAttrib is a collection of all stencil render states
StencilRenderStates | An abstract cross-platform class for setting stencil buffer render states
StereoDisplayRegion | This is a special DisplayRegion wrapper that actually includes a pair of DisplayRegions internally: the left and right eyes
StreamReader | A class to read sequential binary data directly from an istream
StreamWrapper | This class provides a locking wrapper around a combination ostream/istream pointer
StreamWrapperBase | The base class for both IStreamWrapper and OStreamWrapper, this provides the common locking interface
StreamWriter | A StreamWriter object is used to write sequential binary data directly to an ostream
string |
StringStream | A bi-directional stream object that reads and writes data to an internal buffer, which can be retrieved and/or set as a string
Structure |
SubfileInfo | This class records a particular byte sub-range within an existing file on disk
SubframeCall |
Actor.SubpartDef |
SubStream | Combined ISubStream and OSubStream for bidirectional I/O
SwimWalker |
SwitchNode | A node that renders only one of its children, according to the user's indication
Sync |
SystemInformation |
SystemInformation |
TangentRingEmitter | Describes 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 |
TemporaryFile | This is a special kind of FileReference class that automatically deletes the file in question when it is deleted
TestAppShell |
TestCachedData |
TestInterestAddRemove |
TestInterval |
TestJob |
TexGenAttrib | Computes texture coordinates for geometry automatically based on vertex position and/or normal
TexMatrixAttrib | Applies a transform matrix to UV's before they are rendered
TexMemWatcher |
TexPlacement |
TexProjectorEffect | This effect automatically applies a computed texture matrix to the specified texture stage, according to the relative position of two specified nodes
TexRecord |
TextAssembler | This class is not normally used directly by user code, but is used by the TextNode to lay out a block of text and convert it into rows of Geoms according to the TextProperties
TextEncoder | This class can be used to convert text between multiple representations, e.g
TextFont | An encapsulation of a font; i.e
TextGraphic | This defines a special model that has been constructed for the purposes of embedding an arbitrary graphic image within a text paragraph
TextNode | The primary interface to this module
TextProperties | This defines the set of visual properties that may be assigned to the individual characters of the text
TextPropertiesManager | This defines all of the TextProperties structures that might be referenced by name from an embedded text string
Texture | Represents a texture object, which is typically a single 2-d image but may also represent a 1-d or 3-d texture image, or the six 2-d faces of a cube map texture
TextureAttrib | Indicates the set of TextureStages and their associated Textures that should be applied to (or removed from) a node
TextureCollection | Manages a list of Texture objects, as returned by TexturePool.find_all_textures()
TextureContext | This is a special class object that holds all the information returned by a particular GSG to indicate the texture's internal context identifier
TexturePeeker | An instance of this object is returned by Texture.peek()
TexturePool | This is the preferred interface for loading textures from image files
TextureReloadRequest | This loader request will call Texture.get_ram_image() in a sub-thread, to force the texture's image to be re-read from disk
TextureStage | Defines the properties of a named stage of the multitexture pipeline
TextureStageCollection |
TextureStagePool | The TextureStagePool (there is only one in the universe) serves to unify different pointers to the same TextureStage, mainly to help developers use a common pointer to access things that are loaded from different model files
TexViewer |
Thread | A thread; that is, a lightweight process
Thread |
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 |
TouchInfo | Stores information for a single touch event
Track |
Trackball | Trackball acts like Performer in trackball mode
TrackerNode | This is the primary interface to a Tracker object associated with a ClientBase
Transform2SG | Input: Transform (matrix)
TransformBlend | This defines a single entry in a TransformBlendTable
TransformBlendTable | This structure collects together the different combinations of transforms and blend amounts used by a GeomVertexData, to facilitate computing dynamic vertices on the CPU at runtime
TransformState | Indicates a coordinate-system transform on vertices
TransformTable | Stores the total set of VertexTransforms that the vertices in a particular GeomVertexData object might depend on
Transitions |
TransparencyAttrib | This controls the enabling of transparency
TreeItem |
TreeNode |
treeresource |
Triangulator | This class can triangulate a convex or concave polygon, even one with holes
TrueClock | An interface to whatever real-time clock we might have available in the current environment
TwoDWalker |
TypedObject | This is an abstract class that all classes which use TypeHandle, and also provide virtual functions to support polymorphism, should inherit from
TypedReferenceCount | A base class for things which need to inherit from both TypedObject and from ReferenceCount
TypedWritable | Base class for objects that can be written to and read from Bam files
TypedWritableReferenceCount | A base class for things which need to inherit from both TypedWritable and from ReferenceCount
TypeFilter |
TypeHandle | TypeHandle is the identifier used to differentiate C++ class types
TypeRegistry | Maintains all the assigned TypeHandles in a given system
UnalignedLMatrix4d | This is an "unaligned" LMatrix4
UnalignedLMatrix4f | This is an "unaligned" LMatrix4
UnalignedLVecBase4d | This is an "unaligned" LVecBase4
UnalignedLVecBase4f | This is an "unaligned" LVecBase4
UndefinedObject |
UnionBoundingVolume | This special bounding volume is the union of all of its constituent bounding volumes
UniqueIdAllocator | Manage a set of ID values from min to max inclusive
UniversalDropTarget |
Unpickler |
UpdateSeq | This is a sequence number that increments monotonically
URLSpec | A container for a URL, e.g
UserDataAudio | A UserDataAudio is a way for the user to manually supply raw audio samples
UserDataAudioCursor | A UserDataAudioCursor is a means to manually supply a sequence of raw audio samples
UserVertexSlider | This is a specialization on VertexSlider that allows the user to specify any arbitrary slider valie he likes
UserVertexTransform | This is a specialization on VertexTransform that allows the user to specify any arbitrary transform matrix he likes
UvScrollNode | This node is placed at key points within the scene graph to animate uvs
Valuator |
ValuatorGroup |
ValuatorGroupPanel |
VBase2 | This is the base class for all two-component vectors and points
VBase2D | This is the base class for all two-component vectors and points
VBase3 | This is the base class for all three-component vectors and points
VBase3D | This is the base class for all three-component vectors and points
VBase4 | This is the base class for all three-component vectors and points
VBase4D | This is the base class for all three-component vectors and points
Vec2 | This is a two-component vector offset
Vec2D | This is a two-component vector offset
Vec3 | This is a three-component vector distance (as opposed to a three-component point, which represents a particular point in space)
Vec3D | This is a three-component vector distance (as opposed to a three-component point, which represents a particular point in space)
Vec4 | This is a four-component vector distance
Vec4D | This is a four-component vector distance
Vector2Entry |
Vector3Entry |
Vector4Entry |
VectorEntry |
VertexBufferContext | This is a special class object that holds all the information returned by a particular GSG to indicate the vertex data array's internal context identifier
VertexDataBlock | A block of bytes that stores the actual raw vertex data referenced by a GeomVertexArrayData object
VertexDataBook | A collection of VertexDataPages, which can be used to allocate new VertexDataBlock objects
VertexDataPage | A block of bytes that holds one or more VertexDataBlocks
VertexDataSaveFile | A temporary file to hold the vertex data that has been evicted from memory and written to disk
VertexSlider | This is an abstract base class that retains some slider value, which is a linear value that typically ranges from 0.0 to 1.0, and is used to control the animation of morphs (blend shapes)
VertexTransform | This is an abstract base class that holds a pointer to some transform, computed in some arbitrary way, that is to be applied to vertices during rendering
VFSImporter |
VFSLoader |
VFSSharedImporter |
VFSSharedLoader |
VideoTexture | The base class for a family of animated Textures that take their input from a video source, such as a movie file
Viewport |
ViewportManager |
ViewportMenu |
VirtualFile | The abstract base class for a file or directory within the VirtualFileSystem
VirtualFileComposite | A composite directory within the VirtualFileSystem: this maps to more than one directory on different mount points
VirtualFileHTTP | This maps a document retrieved from an HTTPClient into the VirtualFileSystem, allowing models etc
VirtualFileList | A list of VirtualFiles, as returned by VirtualFile.scan_directory()
VirtualFileMount | The abstract base class for a mount definition used within a VirtualFileSystem
VirtualFileMountHTTP | Maps a web page (URL root) into the VirtualFileSystem
VirtualFileMountMultifile | Maps a Multifile's contents into the VirtualFileSystem
VirtualFileMountRamdisk | Simulates an actual directory on disk with in-memory storage
VirtualFileMountSystem | Maps an actual OS directory into the VirtualFileSystem
VirtualFileSimple | A simple file or directory within the VirtualFileSystem: this maps to exactly one file on one mount point
VirtualFileSystem | A hierarchy of directories and files that appears to be one continuous file system, even though the files may originate from several different sources that may not be related to the actual OS's file system
VirtualMouse | Poses as a MouseAndKeyboard object in the datagraph, but accepts input from user calls, rather than reading the actual mouse and keyboard from an input device
VrpnClient | A specific ClientBase that connects to a VRPN server and records information on the connected VRPN devices
Wait |
WaitInterval | This interval does absolutely nothing, and is mainly useful for marking time between other intervals within a sequence
WeakPointerToVoid | This is the specialization of PointerToVoid for weak pointers
WebcamVideo | Allows you to open a webcam or other video capture device as a video stream
webNotifyDebug |
WebRequest |
WebRequestDispatcher |
WeightedChoice |
WidgetPropertiesDialog |
CallbackGraphicsWindow.WindowCallbackData |
WindowCallbackData |
WindowControls |
WindowHandle | This object represents a window on the desktop, not necessarily a Panda window
WindowProperties | A container for the various kinds of properties we might ask to have on a graphics window before we open it
WritableConfigurable | Defined as a fix to allow creating Configurable and Writable objects
WrtParentInterval |
WxAppShell |
WxPandaShell |
WxSlider |
YesNoCancelDialog |
YesNoDialog |
ZlibArchive | Def build(self, path, lTOC): """Create an archive file of name 'path'
ZlibArchive |
zlibresource |
ZSpinParticleFactory |

All Classes Namespaces Functions Variables Enumerations Enumerator Properties