Panda3D
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345678]
 C_AttrNotFound
 C_CFGLGlobals
 CActionMgr
 CActor
 CAdaptiveLruPageDynamicListSee the comment in the head of AdaptiveLruPage, below, for an explanation of these two silly little classes
 CAdaptiveLruPageStaticList
 CAIBehaviors
 CAICharacter
 CAINodeThis class is used to assign the nodes on the mesh. It holds all the data necessary to compute A* algorithm. It also maintains a lot of vital information such as the neighbor nodes of each node and also its position on the mesh. Note: The Mesh Generator which is a standalone tool makes use of this class to generate the nodes on the mesh
 CAIWorld
 CAllHitsRayResultCallback
 CAllHitsRayResultCallback
 CAlphabetCounter
 CAnalogNode
 CAnimControlCollectionThis is a named collection of AnimControl pointers. An AnimControl may be added to the collection by name. While an AnimControl is associated, its reference count is maintained; associating a new AnimControl with the same name will decrement the previous control's reference count (and possibly delete it, unbinding its animation)
 CActor.AnimDef
 CAnimInterfaceThis is the fundamental interface for things that have a play/loop/stop type interface for frame-based animation, such as animated characters. This is the base class for AnimControl and other, similar classes
 CAnimMgrBase
 CAsyncTaskCollectionA list of tasks, for instance as returned by some of the AsyncTaskManager query functions. This also serves to define an AsyncTaskSequence
 CAttribNodeRegistryThis global object records NodePaths that are referenced by scene graph attribs, such as ClipPlaneAttribs and LightAttribs
 CAttributeError
 CAudio3DManager
 CAverager
 CBamCacheThis class maintains a cache of Bam and/or Txo objects generated from model files and texture images (as well as possibly other kinds of loadable objects that can be stored in bam file format)
 CBamEnumsThis class exists just to provide scoping for the enums shared by BamReader and BamWriter
 CBaseTypeDescriptor
 CBasicSkelThis is the most basic of the skeleton classes. It stores an integer, and will return it on request
 CBasicStringChar
 CBitArrayA dynamic array with an unlimited number of bits
 CBitMaskPNUint1616
 CBitMaskPNUint3232
 CBitMaskPNUint6464
 CBrowserObject
 CBulletContact
 CBulletHelper
 CBulletinBoard
 CBulletManifoldPoint
 CBulletPersistentManifold
 CBulletRayHit
 CBulletRotationalLimitMotorRotation Limit structure for generic joints
 CBulletSoftBodyConfig
 CBulletSoftBodyMaterial
 CBulletSoftBodyNodeElement
 CBulletSoftBodyWorldInfo
 CBulletTranslationalLimitMotorRotation Limit structure for generic joints
 CBulletVehicleTuning
 CBulletWheelOne wheel of a BulletVehicle. Instances should not be created directly but using the factory method BulletVehicle::create_wheel()
 CBulletWheelRaycastInfo
 CButtonHandleA ButtonHandle represents a single button from any device, including keyboard buttons and mouse buttons (but see KeyboardButton and MouseButton)
 CButtonNode
 CButtonRegistryMaintains all the assigned ButtonHandles in a given system. There should be only one ButtonRegistry class during the lifetime of the application
 CCachedDOData
 CLoader.Callback
 CCartesianGridBase
 CCConnectionRepository
 CCConnectionRepositoryThis class implements the C++ side of the ConnectionRepository object. In particular, it manages the connection to the server once it has been opened (but does not open it directly). It manages reading and writing datagrams on the connection and monitoring for unexpected disconnects as well as handling intentional disconnects
 CCDistributedSmoothNodeBaseThis class defines some basic methods of DistributedSmoothNodeBase which have been moved into C++ as a performance optimization
 CCIntervalManager
 CCIntervalManagerThis object holds a number of currently-playing intervals and is responsible for advancing them each frame as needed
 Cclass_p3d
 Cclass_package
 Cclass_solo
 CCLerpAnimEffectInterval
 CCLerpNodePathInterval
 CServerRepository.Client
 CClosestConvexResultCallback
 CClosestConvexResultCallback
 CClosestRayResultCallback
 CClosestRayResultCallback
 CClusterConfigItem
 CClusterMsgHandler
 CCMetaInterval
 CCollisionHandlerQueue
 CColorInterpolationFunction
 CCommonFilters
 CCompilationEnvironment
 CConcreteStruct
 CConditionVarDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen. A condition variable can be used to "wake up" a thread when some arbitrary condition has changed
 CConditionVarFull
 CConditionVarFullDirectA condition variable, usually used to communicate information about changing state to a thread that is waiting for something to happen. A condition variable can be used to "wake up" a thread when some arbitrary condition has changed
 CConfigFlagsThis class is the base class of both ConfigVariable and ConfigVariableCore. It exists only to provide a convenient name scoping for some enumerated values common to both classes
 CConfigPageA page of ConfigDeclarations that may be loaded or unloaded. Typically this represents a single .prc file that is read from disk at runtime, but it may also represent a list of declarations built up by application code and explicitly loaded
 CConfigVariableManagerA global object that maintains the set of ConfigVariables (actually, ConfigVariableCores) everywhere in the world, and keeps them in sorted order
 CConnection
 CConnectionManagerThe primary interface to the low-level networking layer in this package. A ConnectionManager is used to establish and destroy TCP and UDP connections. Communication on these connections, once established, is handled via ConnectionReader, ConnectionWriter, and ConnectionListener
 CConnectionReaderThis is an abstract base class for a family of classes that listen for activity on a socket and respond to it, for instance by reading a datagram and serving it (or queueing it up for later service)
 CConnectionWriterThis class handles threaded delivery of datagrams to various TCP or UDP sockets
 CContactResultCallback
 CContactResultCallback
 CControlManager
 CCRCache
 CCRDataCache
 CPNMImage::CRowProvides an accessor for reading the contents of one row of the image in-place
 CLMatrix3f::CRow
 CCRowProvides an accessor for reading the contents of one row of the image in-place
 CLMatrix4f::CRow
 CLMatrix3d::CRow
 CLMatrix4d::CRow
 CCubeColourDialog
 CCullBinEnumsProvides scoping for the enumerated type shared by CullBin and CullBinManager
 CCullHandlerThis defines the abstract interface for an object that receives Geoms identified by the CullTraverser. By itself, it's not a particularly useful class; to use it, derive from it and redefine record_object()
 CCullTraverserDataThis collects together the pieces of data that are accumulated for each node while walking the scene graph during the cull traversal
 CCurveFitter
 CDatagram
 CDatagramGeneratorThis class defines the abstract interace to any source of datagrams, whether it be from a file or from the net
 CDatagramIteratorA class to retrieve the individual data elements previously stored in a Datagram. Elements may be retrieved one at a time; it is up to the caller to know the correct type and order of each element
 CDatagramIterator
 CDatagramSinkThis class defines the abstract interface to sending datagrams to any target, whether it be into a file or across the net
 CDataGraphTraverserThis object supervises the traversal of the data graph and the moving of data from one DataNode to its children. The data graph is used to manage data from input devices, etc. See the overview of the data graph in dataNode.h
 CDCDeclarationThis is a common interface for a declaration in a DC file. Currently, this is either a class or a typedef declaration (import declarations are still collected together at the top, and don't inherit from this object). Its only purpose is so that classes and typedefs can be stored in one list together so they can be ordered correctly on output
 CDCFileRepresents the complete list of Distributed Class descriptions as read from a .dc file
 CDCKeywordListThis is a list of keywords (see DCKeyword) that may be set on a particular field
 CDConfigThis class emulates the old dconfig-style interface to our Panda config system. It exists only to provide backward-compatible support, and it is used primarily by Python code. For modern code, use the new ConfigVariable* interface instead of this deprecated interface
 CDCPackDataThis is a block of data that receives the results of DCPacker
 CDCPackerThis class can be used for packing a series of numeric and string data into a binary stream, according to the DC specification
 CDCPackerInterfaceThis defines the internal interface for packing values into a DCField. The various different DC objects inherit from this
 CDecompressorThis manages run-time decompression of a zlib-compressed stream, as a background or foreground task
 CDefault
 CDefaultHandler
 CDelayedCall
 CDelayedFunctor
 CDeltaProfiler
 CDialNode
 CDialog
 CDiff
 CDirectBoundingBox
 CDirectNotify
 CDirectObject
 CDirectObject
 CDisplayConnection
 CDisplayInformationThis class contains various display information
 CDisplayMode
 CDisplaySearchParametersParameters used for searching display capabilities
 CDistributedNode
 CDistributedObject
 CDistributedObjectAI
 CDistributedSmoothNodeBase
 CDJointFeedback
 CDoCollectionManager
 CDocumentSpecA descriptor that refers to a particular version of a document. This includes the URL of the document and its identity tag and last-modified dates
 CDoHierarchy
 CDoubleBitMaskBitMaskNative
 CDoubleBitMaskDoubleBitMaskNative
 CDownloadDbA listing of files within multifiles for management of client-side synchronization with a server-provided set of files
 CDrawableRegionThis is a base class for GraphicsWindow (actually, GraphicsOutput) and DisplayRegion, both of which are conceptually rectangular regions into which drawing commands may be issued. Sometimes you want to deal with a single display region, and sometimes you want to deal with the whole window at once, particularly for issuing clear commands and capturing screenshots
 CDSearchPathThis class stores a list of directories that can be searched, in order, to locate a particular file. It is normally constructed by passing it a traditional searchpath-style string, e.g. a list of directory names delimited by spaces or colons, but it can also be built up explicitly
 CDummyTaskClass
 CDxBody
 CDxGeom
 CDxJoint
 CDxJointGroup
 CDxSpace
 CDxTriMeshData
 CDxWorld
 CEggMaterialCollectionThis is a collection of materials by MRef name. It can extract the materials from an egg file and sort them all together; it can also manage the creation of unique materials and the assignment of unique MRef names
 CEggRenderModeThis class stores miscellaneous rendering properties that is associated with geometry, and which may be set on the geometry primitive level, on the group above it, or indirectly via a texture. It's intended to be a base class for egg objects that can have these properties set
 CEggTextureCollectionThis is a collection of textures by TRef name. It can extract the textures from an egg file and sort them all together; it can also manage the creation of unique textures and the assignment of unique TRef names
 CEggTransformThis represents the <Transform> entry of a group or texture node: a list of component transform operations, applied in order, that describe a net transform matrix
 CElementTree
 CEnum
 CEnumIter
 CEvent
 CEventManager
 CEventParameterAn optional parameter associated with an event. Each event may have zero or more of these. Each parameter stores a pointer to a TypedWritableReferenceCount object, which of course could be pretty much anything. To store a simple value like a double or a string, the EventParameter constructors transparently use the ParamValue template class from paramValue.h
 CEventQueueA queue of pending events. As events are thrown, they are added to this queue; eventually, they will be extracted out again by an EventHandler and processed
 CException
 CPackager.ExcludeFilename
 CExecutionEnvironmentEncapsulates access to the environment variables and command-line arguments at the time of execution. This is encapsulated to support accessing these things during static init time, which seems to be risky at best
 CExtractorThis class automatically extracts the contents of a Multifile to the current directory (or to a specified directory) in the background
 CFactory
 CFakeDelObject
 CFakeObject
 CFFIEnvironment
 CFFIExternalObject
 CFFIInterrogateDatabase
 CFFIMethodArgumentTree
 CFFIMethodArgumentTreeCollection
 Cfile
 CFileDropTarget
 CFileMgr
 CFilenameThe name of a file, such as a texture file or an Egg file. Stores the full pathname, and includes functions for extracting out the directory prefix part and the file extension and stuff
 CFileSpec
 CFilterConfig
 CFlock
 CFontPoolThis is the preferred interface for loading fonts for the TextNode system. It is similar to ModelPool and TexturePool in that it unifies references to the same filename
 CFourState
 CFourStateAI
 CFrame
 CFrameBufferPropertiesA container for the various kinds of properties we might ask to have on a graphics frameBuffer before we create a GSG
 CFrameDelayedCall
 CFrameProfiler
 CFreezer
 Cfunc_closure
 CFunctionSpecification
 CFunctor
 CFunctor
 CGarbageReportScheduler
 CGCTrigger
 CGeomCacheManagerThis is used to keep track of, and limit the size of, the cache of munged vertices, which would otherwise be distributed through all of the GeomVertexData objects in the system
 CGeomEnumsThis class exists just to provide scoping for the various enumerated types used by Geom, GeomVertexData, GeomVertexArrayData, GeomPrimitive, and other related classes
 CGLCanvas
 CGlobalValueSpecification
 CGlobPatternThis class can be used to test for string matches against standard Unix-shell filename globbing conventions. It serves as a portable standin for the Posix fnmatch() call
 CGoldenRectangle
 CGraphicsPipeSelectionThis maintains a list of GraphicsPipes by type that are available for creation. Normally there is one default interactive GraphicsPipe, and possibly other types available as well
 CGraphicsThreadingModelThis represents the user's specification of how a particular frame is handled by the various threads
 CGraphicsWindowInputDeviceThis is a structure representing a single input device that may be associated with a window. Typically this will be a keyboard/mouse pair, and there will be exactly one of these associated with each window, but other variants are possible
 CGridChild
 CGridParent
 CHashValStores a 128-bit value that represents the hashed contents (typically MD5) of a file or buffer
 CPNMImageHeader::HistogramUsed to return a pixel histogram in PNMImage::get_histogram()
 CHistogramUsed to return a pixel histogram in PNMImage::get_histogram()
 CPackager.HostEntry
 CHostInfo
 CHotkeyBreaker
 CHTTPDateA container for an HTTP-legal time/date indication. This can accept a string from an HTTP header and will decode it into a C time_t value; conversely, it can accept a time_t value and encode it for output as a string
 CHTTPEntityTagA container for an "entity tag" from an HTTP server. This is used to identify a particular version of a document or resource, particularly useful for verifying caches
 CIcon
 CIControl
 CIControl
 CIndirection
 CInputStateToken
 CInputStateTokenGroup
 CInspector
 CInspectorClasses
 CInspectorWindow
 CInstalledHostData
 CInstalledPackageData
 CInstaller
 CPackageInfo.InstallStep
 CInterestHandle
 CInterestState
 CInterface
 CConnectionManager::Interface
 CInternalNameCollection
 CIosBaseWe need to expose one method in each class to force it to publish. But we'd like to expose some of these methods anyway, so no problem
 CJobManager
 CKeyboardButtonThis class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard keyboard keys
 CLandingPage
 CLeakDetector
 CLevelLoaderBase
 CLFrustumd
 CLFrustumf
 CLightThe abstract interface to all kinds of lights. The actual light objects also inherit from PandaNode, and can therefore be added to the scene graph at some arbitrary point to define the coordinate system of effect
 CLightMutexDirectThis class implements a lightweight Mutex by making direct calls to the underlying implementation layer. It doesn't perform any debugging operations
 CLightReMutexDirectThis class implements a standard lightReMutex by making direct calls to the underlying implementation layer. It doesn't perform any debugging operations
 CLinkedListNodeThis just stores the pointers to implement a doubly-linked list of some kind of object. There are occasions when a hand-rolled linked list is more appropriate than an STL container
 CLMatrix3dThis is a 3-by-3 transform matrix. It typically will represent either a rotation-and-scale (no translation) matrix in 3-d, or a full affine matrix (rotation, scale, translation) in 2-d, e.g. for a texture matrix
 CLMatrix3fThis is a 3-by-3 transform matrix. It typically will represent either a rotation-and-scale (no translation) matrix in 3-d, or a full affine matrix (rotation, scale, translation) in 2-d, e.g. for a texture matrix
 CLMatrix4dThis is a 4-by-4 transform matrix
 CLMatrix4fThis is a 4-by-4 transform matrix
 CLoaderFileTypeRegistryThis class maintains the set of all known LoaderFileTypes in the universe
 CLoaderOptionsSpecifies parameters that may be passed to the loader
 CLockType
 CLogger
 CLParaboladAn abstract mathematical description of a parabola, particularly useful for describing arcs of projectiles
 CLParabolafAn abstract mathematical description of a parabola, particularly useful for describing arcs of projectiles
 CLVecBase2dThis is the base class for all two-component vectors and points
 CLVecBase2fThis is the base class for all two-component vectors and points
 CLVecBase2iThis is the base class for all two-component vectors and points
 CLVecBase3dThis is the base class for all three-component vectors and points
 CLVecBase3fThis is the base class for all three-component vectors and points
 CLVecBase3iThis is the base class for all three-component vectors and points
 CLVecBase4dThis is the base class for all three-component vectors and points
 CLVecBase4fThis is the base class for all three-component vectors and points
 CLVecBase4iThis is the base class for all three-component vectors and points
 CManifestSpecification
 CMaterialCollection
 CMaterialPoolThe MaterialPool (there is only one in the universe) serves to unify different pointers to the same Material, so we do not (a) waste memory with many different Material objects that are all equivalent, and (b) waste time switching the graphics engine between different Material states that are really the same thing
 CMathNumbers
 CMegaArchetype
 CMegaToplevel
 CMegaWidget
 CMemoryBaseThis class is intended to be the base class of all objects in Panda that might be allocated and deleted via the new and delete operators. It redefines these operators to provide some memory tracking support
 CMemoryBaseThis class is intended to be the base class of all objects in Panda that might be allocated and deleted via the new and delete operators. It redefines these operators to provide some memory tracking support
 CMemoryExplorerItem
 CMemoryHookThis class provides a wrapper around the various possible malloc schemes Panda might employ. It also exists to allow the MemoryUsage class in Panda to insert callback hooks to track the size of allocated pointers
 CMemoryUsagePointersThis is a list of pointers returned by a MemoryUsage object in response to some query
 CMenu
 CMersenne
 CMessageLeakDetectorBase
 CMessenger
 CMethodArgumentSpecification
 CMethodWrapper
 CMiniLog
 CMiniLogSentry
 CMiniTask
 CMiniTaskManager
 CModelPoolThis class unifies all references to the same filename, so that multiple attempts to load the same model will return the same pointer. Note that the default behavior is thus to make instances: use with caution. Use the copy_subgraph() method on Node (or use NodePath::copy_to) to make modifiable copies of the node
 CModifierButtonsThis class monitors the state of a number of individual buttons and tracks whether each button is known to be down or up
 CFreezer.ModuleDef
 CModuleFinder
 CMotionTrailFrame
 CMotionTrailVertex
 CMouseButtonThis class is just used as a convenient namespace for grouping all of these handy functions that return buttons which map to standard mouse buttons
 CMouseDataHolds the data that might be generated by a 2-d pointer input device, such as the mouse in the GraphicsWindow
 CMouseWatcherBaseThis represents a collection of MouseWatcherRegions that may be managed as a group. This is the base class for both MouseWatcherGroup and MouseWatcher, and exists so that we don't have to make MouseWatcher inherit from ReferenceCount more than once
 CMouseWatcherParameterThis is sent along as a parameter to most events generated for a region to indicate the mouse and button state for the event
 CMultitexReducerThis object presents an interface for generating new texture images that represent the combined images from one or more individual textures, reproducing certain kinds of multitexture effects without depending on multitexture support in the hardware
 CMutex
 CMutexDirectThis class implements a standard mutex by making direct calls to the underlying implementation layer. It doesn't perform any debugging operations
 CNetAddress
 CNeverFreeMemoryThis class is used to allocate bytes of memory from a pool that is never intended to be freed. It is particularly useful to support DeletedChain, which allocates memory in just such a fashion
 CNodePathNodePath is the fundamental system for disambiguating instances, and also provides a higher-level interface for manipulating the scene graph
 CNodePathCollectionThis is a set of zero or more NodePaths. It's handy for returning from functions that need to return multiple NodePaths (for instance, NodePaths::get_children)
 CNoDictKey
 CNonlinearImagerThis class object combines the rendered output of a 3-d from one or more linear (e.g. perspective) cameras, as seen through a single, possibly nonlinear camera
 CNotifier
 CNotifyAn object that handles general error reporting to the user. It contains a pointer to an ostream, initially cerr, which can be reset at will to point to different output devices, according to the needs of the application. All output generated within Panda should vector through the Notify ostream
 CNotifyPanel
 CNurbsCurveInterfaceThis abstract class defines the interface only for a Nurbs-style curve, with knots and coordinates in homogeneous space
 CServerRepository.Object
 Cobject
 CObjectGen
 CObjectHandler
 CObjectMgrBase
 CObjectPaletteBase
 CObjectPool
 CObjectRef
 CObjectReport
 COdeJointCollection
 COdeUtil
 COnScreenDebug
 CPatchMaker.Package
 CPackager.Package
 CPackageMerger.PackageEntry
 CPackager.PackageEntry
 CPackageInfo
 CPackageMerger
 CPackager
 CPackageTree
 CPatchMaker.PackageVersion
 CPackager.PackFile
 CPandaSystemThis class is used as a namespace to group several global properties of Panda. Application developers can use this class to query the runtime version or capabilities of the current Panda environment
 CPanel
 CParentMgr
 CActor.PartDef
 CParticleSystemManagerManages a set of individual ParticleSystem objects, so that each individual one doesn't have to be updated and rendered every frame See Also : particleSystemManager.cxx
 CPartSubsetThis class is used to define a subset of part names to apply to the PartBundle::bind_anim() operation. Only those part names within the subset will be included in the bind
 CPatchMaker.Patchfile
 CPatchMaker
 CPackageInstaller.PendingPackage
 CPerlinNoiseThis is the base class for PerlinNoise2 and PerlinNoise3, different dimensions of Perlin noise implementation. The base class just collects the common functionality
 CPfmVizzerThis class aids in the visualization and manipulation of PfmFile objects
 CPGButtonNotifyObjects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
 CPGFrameStyle
 CPGSliderBarNotifyObjects that inherit from this class can receive notify messages when a slider bar moves or otherwise is reconfigured
 CPhasedObject
 CPhysicsManagerPhysics don't get much higher-level than this. Attach as many Physicals (particle systems, etc..) as you want, pick an integrator and go
 CPhysicsObjectCollectionThis is a set of zero or more PhysicsObjects. It's handy for returning from functions that need to return multiple PhysicsObjects
 CPickler
 CPixel
 CPixelSpecContains a single pixel specification used in compute_histogram() and make_histogram(). Note that pixels are stored by integer value, not by floating-point scaled value
 CPNMImageHeader::PixelSpecContains a single pixel specification used in compute_histogram() and make_histogram(). Note that pixels are stored by integer value, not by floating-point scaled value
 CPNMImageHeader::PixelSpecCountAssociates a pixel specification with an appearance count, for use in Histogram, below
 CPixelSpecCountAssociates a pixel specification with an appearance count, for use in Histogram, below
 CPNMFileTypeRegistryThis class maintains the set of all known PNMFileTypes in the universe
 CPNMImageHeaderThis is the base class of PNMImage, PNMReader, and PNMWriter. It encapsulates all the information associated with an image that describes its size, number of channels, etc; that is, all the information about the image except the image data itself. It's the sort of information you typically read from the image file's header
 CPNMPainterThis class provides a number of convenient methods for painting drawings directly into a PNMImage
 CPNMTextGlyphA single glyph in a PNMTextMaker
 CPool
 CProcess
 CProfileSession
 CProfileTimer
 CProgressBar
 CProtoObjs
 CPStatCollectorA lightweight class that represents a single element that may be timed and/or counted via stats
 CPStatsCallback
 CPStatsCallbackThis class allows integration with PStats, particularly in the SIMPLE_THREADS case
 CPStatScope
 CPStatThreadA lightweight class that represents a single thread of execution to PStats. It corresponds one-to-one with Panda's Thread instance
 CPushesStateChanges
 CPyDropTarget
 CQueue
 CQueuedReturnConnectionListenerData
 CQueuedReturnDatagram
 CQueuedReturnNetDatagram
 CQueuedReturnPointerToConnection
 CRamfileAn in-memory buffer specifically designed for downloading files to memory
 CRandomizerA handy class to return random numbers
 CRandomNumGen
 CReceivesMultipleStateChanges
 CReceivesStateChanges
 CRecorderBaseThis is the base class to a number of objects that record particular kinds of user input (like a MouseRecorder) to use in conjunction with a RecorderController to record the user's inputs for a session
 CReMutex
 CReMutexDirectThis class implements a standard reMutex by making direct calls to the underlying implementation layer. It doesn't perform any debugging operations
 CRenderAttribRegistryThis class is used to associate each RenderAttrib with a different slot index at runtime, so we can store a list of RenderAttribs in the RenderState object, and very quickly look them up by type
 CResults
 CDSearchPath::Results
 CLoader::Results
 CRotatingLog
 CPNMImage::RowProvides an accessor for reading or writing the contents of one row of the image in-place
 CLMatrix3d::RowThese helper classes are used to support two-level operator []
 CLMatrix4f::RowThese helper classes are used to support two-level operator []
 CRowThese helper classes are used to support two-level operator []
 CLMatrix3f::RowThese helper classes are used to support two-level operator []
 CLMatrix4d::RowThese helper classes are used to support two-level operator []
 CSamplerStateRepresents a set of settings that indicate how a texture is sampled. This can be used to sample the same texture using different settings in different places
 CScanDirectoryNode
 CSceneGraphAnalyzerA handy class that can scrub over a scene graph and collect interesting statistics on it
 CSceneGraphReducerAn interface for simplifying ("flattening") scene graphs by eliminating unneeded nodes and collapsing out unneeded state changes and transforms
 CScratchPad
 CScriptAttributes
 CSemaphoreA classic semaphore synchronization primitive
 CSemaphore
 CSeqValue
 CSerialNumGen
 CServerRepository
 CSfxPlayer
 CShaderPoolThis is the preferred interface for loading shaders for the TextNode system. It is similar to ModelPool and TexturePool in that it unifies references to the same filename
 CShadowCaster
 CSkinningReplyTo
 CSlider
 CSmoothMoverThis class handles smoothing of sampled motion points over time, e.g. for smoothing the apparent movement of remote avatars, whose positions are sent via occasional telemetry updates
 CSocketAddressA simple place to store and munipulate tcp and port address for communication layer
 CSocketFdset
 CSparseArrayThis class records a set of integers, where each integer is either present or not present in the set
 CSqueezer
 CStack
 CStackedPerlinNoise2Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
 CStackedPerlinNoise3Implements a multi-layer PerlinNoise, with one or more high-frequency noise functions added to a lower-frequency base noise function
 CStackTrace
 CStagedObject
 CStandalone
 CStandardError
 CStats
 CStdoutCapture
 CStreamReaderA class to read sequential binary data directly from an istream. Its interface is similar to DatagramIterator by design; see also StreamWriter
 CStreamWrapperBaseThe base class for both IStreamWrapper and OStreamWrapper, this provides the common locking interface
 CStreamWriterA StreamWriter object is used to write sequential binary data directly to an ostream. Its interface is very similar to Datagram by design; it's primarily intended as a convenience to eliminate the overhead of writing bytes to a Datagram and then writing the Datagram to a stream
 CStructure
 CSubfileInfoThis class records a particular byte sub-range within an existing file on disk. Generally, the filename is understood as a physical file on disk, and not to be looked up via the vfs
 CSubframeCall
 CActor.SubpartDef
 CSync
 CSystemInformation
 CSystemInformation
 CTarInfo
 CTaskLeakDetectorBase
 CTaskManager
 CTaskProfiler
 CTaskThread
 CTaskThreaded
 CTaskTracker
 CTestCase
 CTestLoader
 CTestSuite
 CTexPlacement
 CTexRecord
 CTextAssemblerThis class is not normally used directly by user code, but is used by the TextNode to lay out a block of text and convert it into rows of Geoms according to the TextProperties. However, user code may take advantage of it, if desired, for very low-level text operations
 CTextDropTarget
 CTextEncoderThis class can be used to convert text between multiple representations, e.g. utf-8 to Unicode. You may use it as a static class object, passing the encoding each time, or you may create an instance and use that object, which will record the current encoding and retain the current string
 CTextGraphicThis defines a special model that has been constructed for the purposes of embedding an arbitrary graphic image within a text paragraph
 CTextPropertiesThis defines the set of visual properties that may be assigned to the individual characters of the text. (Properties which affect the overall block of text can only be specified on the TextNode directly)
 CTextPropertiesManagerThis defines all of the TextProperties structures that might be referenced by name from an embedded text string
 CTextTestRunner
 CTextureCollectionManages a list of Texture objects, as returned by TexturePool::find_all_textures()
 CTexturePoolThis is the preferred interface for loading textures from image files. It unifies all references to the same filename, so that multiple models that reference the same textures don't waste texture memory unnecessarily
 CTextureStageCollection
 CTextureStagePoolThe TextureStagePool (there is only one in the universe) serves to unify different pointers to the same TextureStage, mainly to help developers use a common pointer to access things that are loaded from different model files
 CThreadBase
 CTimer
 CTimeVal
 CTiXmlAttributeSet
 CTiXmlBase** TiXmlBase is a base class for every class in TinyXml. It does little except to establish that TinyXml classes can be printed and provide some utility functions
 CTiXmlCursor
 CTiXmlHandle** A TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing. Note that TiXmlHandle is not part of the TinyXml DOM structure. It is a separate utility class
 CTiXmlVisitor** Implements the interface to the "Visitor pattern" (see the Accept() method.) If you call the Accept() method, it requires being passed a TiXmlVisitor class to handle callbacks. For nodes that contain other nodes (Document, Element) you will get called with a VisitEnter/VisitExit pair. Nodes that are always leaves are simply called with Visit()
 CToplevel
 CTouchInfoStores information for a single touch event
 CTrackerNode
 CTransformBlendThis defines a single entry in a TransformBlendTable. It represents a unique combination of VertexTransform pointers and blend amounts
 CTransitions
 CTreeCtrl
 CTreeItem
 CTreeNode
 CTriangulatorThis class can triangulate a convex or concave polygon, even one with holes. It is adapted from an algorithm published as:
 CTrueClockAn interface to whatever real-time clock we might have available in the current environment. There is only one TrueClock in existence, and it constructs itself
 Ctype
 CTypeHandleTypeHandle is the identifier used to differentiate C++ class types. Any C++ classes that inherit from some base class, and must be differentiated at run time, should store a static TypeHandle object that can be queried through a static member function named get_class_type(). Most of the time, it is also desirable to inherit from TypedObject, which provides some virtual functions to return the TypeHandle for a particular instance
 CUnalignedLMatrix4dThis is an "unaligned" LMatrix4. It has no functionality other than to store numbers, and it will pack them in as tightly as possible, avoiding any SSE2 alignment requirements shared by the primary LMatrix4 class
 CUnalignedLMatrix4fThis is an "unaligned" LMatrix4. It has no functionality other than to store numbers, and it will pack them in as tightly as possible, avoiding any SSE2 alignment requirements shared by the primary LMatrix4 class
 CUnalignedLVecBase4dThis is an "unaligned" LVecBase4. It has no functionality other than to store numbers, and it will pack them in as tightly as possible, avoiding any SSE2 alignment requirements shared by the primary LVecBase4 class
 CUnalignedLVecBase4fThis is an "unaligned" LVecBase4. It has no functionality other than to store numbers, and it will pack them in as tightly as possible, avoiding any SSE2 alignment requirements shared by the primary LVecBase4 class
 CUnalignedLVecBase4iThis is an "unaligned" LVecBase4. It has no functionality other than to store numbers, and it will pack them in as tightly as possible, avoiding any SSE2 alignment requirements shared by the primary LVecBase4 class
 CUndefinedObject
 CUniqueIdAllocatorManage a set of ID values from min to max inclusive. The ID numbers that are freed will be allocated (reused) in the same order. I.e. the oldest ID numbers will be allocated
 CUnpickler
 CUpdateSeqThis is a sequence number that increments monotonically. It can be used to track cache updates, or serve as a kind of timestamp for any changing properties
 CURLSpecA container for a URL, e.g. "http://server:port/path"
 CValueError
 CVertexDataBookA collection of VertexDataPages, which can be used to allocate new VertexDataBlock objects
 CVFSImporter
 CVFSLoader
 CVFSSharedImporter
 CVFSSharedLoader
 CViewportManager
 CVirtualFileSystemA hierarchy of directories and files that appears to be one continuous file system, even though the files may originate from several different sources that may not be related to the actual OS's file system
 CVrpnClient
 CwebNotifyDebug
 CWeightedChoice
 CWindow
 CWindowControls
 CWindowPropertiesA container for the various kinds of properties we might ask to have on a graphics window before we open it. This also serves to hold the current properties for a window after it has been opened
 CNodePath
 CScrolledPanel
 CTestCase
 CWaitInterval
 CWxPandaWindow