| CSdfSchemaBase::_SpecDefiner | Class that defines fields for a spec type |
| CSdfSchemaBase::_ValueTypeRegistrar | A helper for registering value types |
| CHdSceneIndexObserver::AddedPrimEntry | A notice indicating a prim of a given type was added to the scene |
| ►CApp | Creates a command line program, with very few defaults |
| COption_group | Extension of App to better manage groups of options |
| CAppFriend | This class is simply to allow tests access to App's protected functions |
| ►CArAsset | Interface for accessing the contents of an asset |
| CArFilesystemAsset | ArAsset implementation for asset represented by a file on a filesystem |
| CArInMemoryAsset | ArAsset implementation that stores asset content in a heap-allocated buffer managed by this object |
| CHioOpenVDBArAssetInterface | Interface for an ArAsset subclass that enables direct access to OpenVDB grids |
| CArAssetInfo | Contains information about a resolved asset |
| CArchIntervalTimer | A simple timer class for measuring an interval of time using the ArchTickTimer facilities |
| CArchMallocHook | Override default malloc() functionality |
| CArDefaultResolverContext | Resolver context object that specifies a search path to use during asset resolution |
| CArIsContextObject< T > | Metafunction to determine whether the templated object type is a valid context object |
| CArPackageResolver | Interface for resolving assets within package assets |
| CArResolvedPath | Represents a resolved asset path |
| ►CArResolver | Interface for the asset resolution system |
| CArDefaultResolver | Default asset resolution implementation used when no plugin implementation is provided |
| CArResolverContext | An asset resolver context allows clients to provide additional data to the resolver for use during resolution |
| CArResolverContextBinder | Helper object for managing the binding and unbinding of ArResolverContext objects with the asset resolver |
| CArResolverScopedCache | Helper object for managing asset resolver cache scopes |
| CArThreadLocalScopedCache< CachedType > | Utility class for custom resolver implementations |
| CArTimestamp | Represents a timestamp for an asset |
| ►CArWritableAsset | Interface for writing data to an asset |
| CArFilesystemWritableAsset | ArWritableAsset implementation for asset represented by a file on a filesystem |
| CHioGlslfxConfig::Attribute | A class representing an attribute |
| CTfMallocTag::Auto | Scoped (i.e |
| ►CSdfNotice::BaseLayersDidChange | Base class for LayersDidChange and LayersDidChangeSentPerLayer |
| CSdfNotice::LayersDidChange | Global notice sent to indicate that layer contents have changed |
| CSdfNotice::LayersDidChangeSentPerLayer | Notice sent per-layer indicating all layers whose contents have changed within a single round of change processing |
| CTfType::Bases< Args > | A type-list of C++ base types |
| CUsdShadeCoordSysAPI::Binding | A coordinate system binding |
| CGlfTexture::Binding | A texture has one or more bindings which describe how the different aspects of the texture should be bound in order to allow shader access |
| CTfNotice::Block | Blocks sending of all notices in current thread |
| ►Cbucket_entry_hash< StoreHash > | Helper class that stores a truncated hash if StoreHash is true and nothing otherwise |
| Cbucket_entry< ValueType, StoreHash > | Each bucket entry has: |
| CUsdImagingModelSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdBasisCurvesSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdBasisCurvesTopologySchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdCameraSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdCapsuleSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdConeSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdCubeSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdCylinderSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdDependencySchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdDisplayFilterSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdExtComputationInputComputationSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdExtComputationOutputSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdExtComputationPrimvarSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdExtComputationSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdExtentSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdGeomSubsetSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdInstanceCategoriesSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdInstancedBySchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdInstancerTopologySchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdInstanceSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdLegacyDisplayStyleSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdMaterialConnectionSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdMaterialNetworkSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdMaterialNodeSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdMeshSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdMeshTopologySchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdPrimvarSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdPurposeSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdRenderBufferSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdRenderSettingsSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdSampleFilterSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdSelectionSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdSphereSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdSubdivisionTagsSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdVisibilitySchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdVolumeFieldSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdXformSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CHdarSystemSchema::Builder | Utility class for setting sparse sets of child data source fields to be filled as arguments into BuildRetained |
| CPcpNamespaceEdits::CacheSite | Cache site that must respond to a namespace edit |
| CTfMallocTag::CallTree::CallSite | Record of the bytes allocated under each different tag |
| CTfMallocTag::CallStackInfo | This struct is used to represent a call stack taken for an allocation that was billed under a specific malloc tag |
| CTfMallocTag::CallTree | Summary data structure for malloc statistics |
| CCameraUtilFraming | Framing information |
| CCameraUtilScreenWindowParameters | Given a camera object, compute parameters suitable for setting up RenderMan |
| CUsdShadeMaterialBindingAPI::CollectionBinding | This struct is used to represent a collection-based material binding, which contains two objects - a collection and a bound material |
| CUsdPhysicsCollisionGroup::CollisionGroupTable | Utility structure generated by ComputeCollisionGroupTable(); contains a table describing which pairs of collision groups have collisions enabled/disabled by the filtering rules |
| ►CConfig | This class provides a converter for configuration files |
| ►CConfigBase | This converter works with INI/TOML files; to write INI files use ConfigINI |
| CConfigINI | ConfigINI generates a "standard" INI compliant output |
| CConfigItem | Holds values to load into Options |
| CTraceEventContainer::const_iterator | Bidirectional iterator of TraceEvents |
| CUsdUtilsTimeCodeRange::const_iterator | A forward iterator into a UsdUtilsTimeCodeRange |
| CTraceCollector::DefaultCategory | Default Trace category which corresponds to events stored for TRACE_ macros |
| ►CTfDiagnosticMgr::Delegate | One may set a delegate with the TfDiagnosticMgr which will be called to respond to errors and diagnostics |
| CUsdUtilsCoalescingDiagnosticDelegate | A class which collects warnings and statuses from the Tf diagnostic manager system in a thread safe manner |
| CUsdUtilsConditionalAbortDiagnosticDelegate | A class that allows client application to instantiate a diagnostic delegate that can be used to abort operations for a non fatal USD error or warning based on immutable include exclude rules defined for this instance |
| CSdfLayer::DetachedLayerRules | Object used to specify detached layers |
| CUsdShadeMaterialBindingAPI::DirectBinding | This class represents a direct material binding |
| CHdSceneIndexObserver::DirtiedPrimEntry | A notice indicating a prim was invalidated |
| Celement_type< T, Enable > | Handy helper to access the element_type generically |
| Celement_value_type< T > | Combination of the element type and value type - remove pointer (including smart pointers) and get the value_type of the container |
| CSdfSchemaBase::EmptyTag | Construct an SdfSchemaBase but does not populate it with standard fields and types |
| CUsdPrimRange::EndSentinel | This class lets us represent past-the-end without the full weight of an iterator |
| CSdfChangeList::Entry | Entry of changes at a single path in namespace |
| ►Cexception | STL class |
| ►Cruntime_error | STL class |
| ►CError | All errors derive from this one |
| ►CConstructionError | Construction errors (not in parsing) |
| CBadNameString | Thrown on construction of a bad name |
| CIncorrectConstruction | Thrown when an option is set to conflicting values (non-vector and multi args, for example) |
| COptionAlreadyAdded | Thrown when an option already exists |
| COptionNotFound | Thrown when counting a non-existent option |
| ►CParseError | Anything that can error in Parse |
| CArgumentMismatch | Thrown when the wrong number of arguments has been received |
| CConfigError | Thrown when extra values are found in an INI file |
| CConversionError | Thrown when conversion call back fails, such as when an int fails to coerce to a string |
| CExcludesError | Thrown when an excludes option is present |
| CExtrasError | Thrown when too many positionals or options are found |
| CFileError | Thrown when parsing an INI file and it is missing |
| CHorribleError | This is just a safety check to verify selection and parsing match - you should not ever see it Strings are directly added to this error, but again, it should never be seen |
| CInvalidError | Thrown when validation fails before parsing |
| CRequiredError | Thrown when a required option is missing |
| CRequiresError | Thrown when a requires option is missing |
| CRuntimeError | Does not output a diagnostic in CLI11_PARSE, but allows main() to return with a specific error code |
| ►CSuccess | This is a successful completion on parsing, supposed to exit |
| CCallForAllHelp | Usually something like –help-all on command line |
| CCallForHelp | -h or –help on command line |
| CCallForVersion | -v or –version on command line |
| CValidationError | Thrown when validation of results fails |
| ►CTfBaseException | The base class for exceptions supported by the Tf exceptions facilities |
| CUsdExpiredPrimAccessError | Usd throws this exception when code attempts to access an invalid (i.e |
| ►CTfType::FactoryBase | Base class of all factory types |
| CHgiFactoryBase | Hgi factory for plugin system |
| CHioFieldTextureDataFactoryBase | A base class to make HioFieldTextureData objects, implemented by plugins |
| CSdfSchemaBase::FieldDefinition | Class defining various attributes for a field |
| CUsdZipFile::FileInfo | Information for a file in the zip archive |
| CUsdPrimCompositionQuery::Filter | Aggregate filter for filtering composition arcs by the previously defined criteria |
| ►CFormatterBase | This is the minimum requirements to run a formatter |
| CFormatter | This is the default Formatter for CLI11 |
| CFormatterLambda | This is a specialty override for lambda functions |
| CGarchGLDebugWindow | Platform specific minimum GL widget for unit tests |
| ►CGeomUtilMeshGeneratorBase | This class provides common implementation for the different mesh generator classes in GeomUtil |
| CGeomUtilCapsuleMeshGenerator | This class provides an implementation for generating topology and point positions on a capsule |
| CGeomUtilConeMeshGenerator | This class provides an implementation for generating topology and point positions on a cone of a given radius and height |
| CGeomUtilCuboidMeshGenerator | This class provides an implementation for generating topology and point positions on a rectangular cuboid given the dimensions along the X, Y and Z axes |
| CGeomUtilCylinderMeshGenerator | This class provides an implementation for generating topology and point positions on a cylinder with a given radius and height |
| CGeomUtilSphereMeshGenerator | This class provides an implementation for generating topology and point positions on a sphere with a given radius |
| CGfBBox3d | Basic type: arbitrarily oriented 3D bounding box |
| CGfCamera | Object-based representation of a camera |
| CGfDualQuatd | Basic type: a real part quaternion and a dual part quaternion |
| CGfDualQuatf | Basic type: a real part quaternion and a dual part quaternion |
| CGfDualQuath | Basic type: a real part quaternion and a dual part quaternion |
| CGfFrustum | Basic type: View frustum |
| CGfInterval | A basic mathematical interval class |
| CGfIsArithmetic< T > | A metafunction which is equivalent to std::arithmetic but also includes any specializations from GfIsFloatingPoint (like GfHalf) |
| CGfIsFloatingPoint< T > | A metafunction which is equivalent to std::is_floating_point but allows for additional specialization for types like GfHalf |
| CGfIsGfDualQuat< T > | A metafunction with a static const bool member 'value' that is true for GfDualQuat types and false for all other types |
| CGfIsGfMatrix< T > | A metafunction with a static const bool member 'value' that is true for GfMatrix types, like GfMatrix3d, GfMatrix4f, etc and false for all other types |
| CGfIsGfQuat< T > | A metafunction with a static const bool member 'value' that is true for GfQuat types and false for all other types |
| CGfIsGfRange< T > | A metafunction with a static const bool member 'value' that is true for GfRange types and false for all other types |
| CGfIsGfVec< T > | A metafunction with a static const bool member 'value' that is true for GfVec types, like GfVec2i, GfVec4d, etc and false for all other types |
| CGfLine | Basic type: 3D line |
| CGfLine2d | Basic type: 2D line |
| CGfLineSeg | Basic type: 3D line segment |
| CGfLineSeg2d | Basic type: 2D line segment |
| CGfMatrix2d | Stores a 2x2 matrix of double elements |
| CGfMatrix2f | Stores a 2x2 matrix of float elements |
| CGfMatrix3d | Stores a 3x3 matrix of double elements |
| CGfMatrix3f | Stores a 3x3 matrix of float elements |
| CGfMatrix4d | Stores a 4x4 matrix of double elements |
| CGfMatrix4f | Stores a 4x4 matrix of float elements |
| CGfMatrixData< T, Rows, Columns > | A class template used by GfMatrixXX to store values |
| CGfMatrixData< double, 2, 2 > | |
| CGfMatrixData< double, 3, 3 > | |
| CGfMatrixData< double, 4, 4 > | |
| CGfMatrixData< float, 2, 2 > | |
| CGfMatrixData< float, 3, 3 > | |
| CGfMatrixData< float, 4, 4 > | |
| CGfMultiInterval | GfMultiInterval represents a subset of the real number line as an ordered set of non-intersecting GfIntervals |
| CGfPlane | Basic type: 3-dimensional plane |
| CGfQuatd | Basic type: a quaternion, a complex number with a real coefficient and three imaginary coefficients, stored as a 3-vector |
| CGfQuaternion | Basic type: complex number with scalar real part and vector imaginary part |
| CGfQuatf | Basic type: a quaternion, a complex number with a real coefficient and three imaginary coefficients, stored as a 3-vector |
| CGfQuath | Basic type: a quaternion, a complex number with a real coefficient and three imaginary coefficients, stored as a 3-vector |
| CGfRange1d | Basic type: 1-dimensional floating point range |
| CGfRange1f | Basic type: 1-dimensional floating point range |
| CGfRange2d | Basic type: 2-dimensional floating point range |
| CGfRange2f | Basic type: 2-dimensional floating point range |
| CGfRange3d | Basic type: 3-dimensional floating point range |
| CGfRange3f | Basic type: 3-dimensional floating point range |
| CGfRay | Basic type: Ray used for intersection testing |
| CGfRect2i | A 2D rectangle with integer coordinates |
| CGfRotation | Basic type: 3-space rotation specification |
| CGfSize2 | Two-dimensional array of sizes |
| CGfSize3 | Three-dimensional array of sizes |
| CGfTransform | Basic type: Compound linear transformation |
| CGfVec2d | Basic type for a vector of 2 double components |
| CGfVec2f | Basic type for a vector of 2 float components |
| CGfVec2h | Basic type for a vector of 2 GfHalf components |
| CGfVec2i | Basic type for a vector of 2 int components |
| CGfVec3d | Basic type for a vector of 3 double components |
| CGfVec3f | Basic type for a vector of 3 float components |
| CGfVec3h | Basic type for a vector of 3 GfHalf components |
| CGfVec3i | Basic type for a vector of 3 int components |
| CGfVec4d | Basic type for a vector of 4 double components |
| CGfVec4f | Basic type for a vector of 4 float components |
| CGfVec4h | Basic type for a vector of 4 GfHalf components |
| CGfVec4i | Basic type for a vector of 4 int components |
| CGlfContextCaps | This class is intended to be a cache of the capabilites (resource limits and features) of the underlying GL context |
| CGlfDebugGroup | Represents a GL debug group in Glf |
| ►CGlfGLContext | Provides window system independent access to GL contexts |
| CGlfTestGLContext | Testing support class for GlfGLContext |
| CGlfGLContextRegistrationInterface | Interface for registering a GlfGLContext system |
| ►CGlfGLContextScopeHolder | Helper class to make a GL context current |
| CGlfAnyGLContextScopeHolder | Helper class to make the shared GL context current if there is no valid current context, or when the current context isn't sharing with the shared context |
| CGlfSharedGLContextScopeHolder | Helper class to make the shared GL context current |
| CGlfGLQueryObject | Represents a GL query object in Glf |
| CUsdCollectionMembershipQuery::Hash | Hash functor |
| CUsdShadeInput::Hash | Hash functor |
| CPcpInstanceKey::Hash | Hash functor |
| CPcpNodeRef::Hash | Hash functor |
| CSdfLayerOffset::Hash | Hash functor for hash maps and sets |
| CTfToken::HashFunctor | Functor to use for hash maps from tokens to other things |
| CTraceDynamicKey::HashFunctor | A Hash functor which uses the cached hash which may be used to store keys in a TfHashMap |
| CTraceKey::HashFunctor | A Hash functor which may be used to store keys in a TfHashMap |
| CHdBufferSpec::HashFunctor | Functor to use for unordered sets, maps |
| ►CHdAggregationStrategy | Aggregation strategy base class |
| CHdStInterleavedMemoryManager | Interleaved memory manager (base class) |
| CHdStVBOMemoryManager | VBO memory manager |
| CHdStVBOSimpleMemoryManager | VBO simple memory manager |
| CHdAovDescriptor | A bundle of state describing an AOV ("Arbitrary Output Variable") display channel |
| CHdAssetStUvTextureObject | A uv texture loading the asset identified by the texture identifier |
| CHdBasisCurvesReprDesc | Descriptor to configure a drawItem for a repr |
| CHdBasisCurvesTopology | Topology data for basisCurves |
| CHdBinding | Bindings are used for buffers or textures, it simple associates a binding type with a binding location |
| CHdBindingRequest | BindingRequest allows externally allocated buffers to be bound at render time |
| ►CHdBprim | Bprim (buffer prim) is a base class of managing a blob of data that is used to communicate between the scene delegate and render |
| ►CHdField | Hydra schema for a USD field primitive |
| CHdStField | Represents a Field Buffer Prim |
| CHdRenderBuffer | A render buffer is a handle to a data resource that can be rendered into, such as a 2d image for a draw target or auxiliary rendering output |
| CHdRenderSettings | Abstract hydra prim backing render settings scene description |
| ►CHdBufferArray | Similar to a VAO, this object is a bundle of coherent buffers |
| CHdStDispatchBuffer | A VBO of a simple array of unsigned integers |
| CHdStInterleavedMemoryManager::_StripedInterleavedBuffer | Striped buffer |
| CHdStVBOMemoryManager::_StripedBufferArray | Striped buffer array |
| CHdStVBOSimpleMemoryManager::_SimpleBufferArray | Simple buffer array (non-aggregated) |
| ►CHdBufferArrayRange | Interface class for representing range (subset) locator of HdBufferArray |
| ►CHdStBufferArrayRange | Interface class for representing range (subset) locator of HdBufferArray |
| CHdStInterleavedMemoryManager::_StripedInterleavedBufferRange | Specialized buffer array range |
| CHdStVBOMemoryManager::_StripedBufferArrayRange | Specialized buffer array range |
| CHdStVBOSimpleMemoryManager::_SimpleBufferArrayRange | Specialized buffer array range for SimpleBufferArray |
| CHdBufferArrayRangeContainer | A resizable container of HdBufferArrayRanges |
| CHdBufferArrayRegistry | Manages the pool of buffer arrays |
| CHdBufferArrayUsageHint | The union provides a set of flags that provide hints to the memory management system about the properties of a Buffer Array Range (BAR), so it can efficiently organize that memory |
| ►CHdBufferSource | A transient buffer of data that has not yet been committed |
| CHdComputedBufferSource | A abstract base class for cpu computation followed by buffer transfer to the GPU |
| CHdExtCompPrimvarBufferSource | Hd Buffer Source that binds a primvar to a Ext Computation output |
| ►CHdNullBufferSource | A abstract base class for pure cpu computation |
| CHdExtCompCpuComputation | A Buffer Source that represents a CPU implementation of a ExtComputation |
| CHdStExtCompGpuPrimvarBufferSource | A buffer source mapped to an output of an ExtComp CPU computation |
| CHdVtBufferSource | An implementation of HdBufferSource where the source data value is a VtValue |
| CHdBufferSpec | Describes each named resource of buffer array |
| CHdChangeTracker | Tracks changes from the HdSceneDelegate, providing invalidation cues to the render engine |
| CHdCommandArgDescriptor | A bundle of state describing an argument to a command |
| CHdCommandDescriptor | A bundle of state describing a "command" |
| ►CHdComputation | An interface class for GPU computation |
| CHdStCopyComputationGPU | A GPU computation which transfers a vbo range specified by src and name to the given range |
| CHdStExtCompGpuComputation | A Computation that represents a GPU implementation of a ExtComputation |
| ►CHdDataSourceBase | Represents an object which can produce scene data |
| CHdBlockDataSource | A datasource representing the absence of a datasource |
| ►CHdContainerDataSource | A datasource representing structured (named, hierarchical) data, for example a geometric primitive or a sub-object like a material definition |
| CHdDataSourceLegacyPrim | This is an HdContainerDataSource which represents a prim-level data source for adapting HdSceneDelegate calls into the forms defined by HdSchemas during emulation of legacy scene delegates |
| CHdLazyContainerDataSource | A container data source lazily evaluating the given thunk to forward all calls to the container data source computed by the thunk |
| CHdMapContainerDataSource | Applies function to all data sources in a container data source (non-recursively) |
| CHdOverlayContainerDataSource | Lazily composes two or more container source hierarchies Earlier entries on the containers array have stronger opinion strength for overlapping child names |
| CHdRetainedContainerDataSource | A retained container data source is a data source whose data are available locally, meaning that they are fully stored and contained within the data source |
| CUsdImagingDataSourceBasisCurves | A container data source representing data unique to basis curves |
| CUsdImagingDataSourceBasisCurvesTopology | A container data source representing basis curves topology information |
| CUsdImagingDataSourceCamera | A container data source representing camera info |
| CUsdImagingDataSourceExtent | Data source representing local prim extent |
| CUsdImagingDataSourceFieldAsset | A container data source representing volumeField info |
| CUsdImagingDataSourceMaterial | A data source mapping to HdMaterialSchema from an UsdShadeMaterial prim |
| CUsdImagingDataSourceMesh | A container data source representing data unique to meshes |
| CUsdImagingDataSourceMeshTopology | A container data source representing mesh topology |
| CUsdImagingDataSourceModel | Data source representing model API for a USD prim |
| CUsdImagingDataSourcePointInstancerTopology | A data source representing a point instancer's instance topology |
| ►CUsdImagingDataSourcePrim | Data source representing a basic USD prim |
| CUsdImagingDataSourceCameraPrim | A prim data source representing UsdCamera |
| CUsdImagingDataSourceFieldAssetPrim | A prim data source representing UsdVolOpenVDBAsset or UsdVolField3DAsset |
| ►CUsdImagingDataSourceGprim | Data source representing a USD gprim |
| CUsdImagingDataSourceBasisCurvesPrim | A prim data source representing a UsdGeomBasisCurves prim |
| CUsdImagingDataSourceMeshPrim | A prim data source representing UsdGeomMesh |
| CUsdImagingDataSourcePointsPrim | A prim data source representing a UsdGeomPoints prim |
| CUsdImagingDataSourceVolumePrim | A prim data source representing a UsdVolVolume prim |
| CUsdImagingDataSourcePrimOrigin | Data source to access the underlying UsdPrim |
| CUsdImagingDataSourcePrimvar | A data source representing a primvar |
| CUsdImagingDataSourcePrimvars | Data source representing USD primvars |
| CUsdImagingDataSourcePurpose | Data source representing prim purpose for a USD imageable |
| CUsdImagingDataSourceSchemaBased< UsdSchemaType, Translator > | A container data source created from a Usd schema which accesses the attributes on the underlying Usd prim performing translation between the Usd attribute name, the key in the container data source and the data source locator |
| CUsdImagingDataSourceStage | Returns a dataSource that contains UsdStage level data |
| CUsdImagingDataSourceSubdivisionTags | A container data source representing subdivision tags |
| CUsdImagingDataSourceVisibility | Data source representing prim visibility for a USD imageable |
| CUsdImagingDataSourceVolumeFieldBindings | A container data source representing volume field binding information |
| CUsdImagingDataSourceXform | Data source representing a container that stores a USD Xformable |
| CHdExtComputationCallbackDataSource | This is a data source which holds a legacy ext computation |
| ►CHdSampledDataSource | A datasource representing time-sampled values |
| CHdRetainedSampledDataSource | A retained data source for sampled data |
| ►CHdTypedSampledDataSource< T > | A datasource representing a concretely-typed sampled value |
| CHdRetainedTypedSampledDataSource< T > | Similar to HdRetainedSampledDataSource but provides strongly typed semantics |
| CUsdImagingDataSourceExtentCoordinate | Data source representing either the minimum or maximum of the local prim extent |
| CUsdImagingDataSourcePointInstancerMask | A data source representing a point instancer's instance mask |
| CUsdImagingDataSourceRelationship | A data source that represents a USD relationship |
| CUsdImagingDataSourceXformMatrix | Data source representing a generic transform value accessor for a USD Xformable |
| CUsdImagingDataSourceXformResetXformStack | Data source representing the "reset xform stack" flag for a USD xformable |
| ►CHdVectorDataSource | A datasource representing indexed data |
| CHdRetainedSmallVectorDataSource | A retained data source version of HdVectorDataSource |
| CHdDataSourceLocator | Represents an object that can identify the location of a data source |
| CHdDataSourceLocatorSet | Represents a set of data source locators closed under descendancy |
| CHdDirtyBitsTranslator | A set of optimized functions for translating between dirty bits and datasource locators for different prim types |
| CHdDirtyList | Used for faster iteration of dirty Rprims by the render index |
| CHdDisplayStyle | Describes how the geometry of a prim should be displayed |
| CHdDrawingCoord | A tiny set of integers, which provides an indirection mapping from the conceptual space of an HdRprim's resources (topological, primvar & instancing) to the index within HdBufferArrayRangeContainer, where the resource is stored |
| CHdDrawItem | A draw item is a light-weight representation of an HdRprim's resources and material to be used for rendering |
| CHdDriver | HdDriver represents a device object, commonly a render device, that is owned by the application and passed to HdRenderIndex |
| CHdEmbreeBufferSampler | A utility class that knows how to sample an element from a type-tagged buffer (like HdVtBufferSource) |
| CHdEmbreeConfig | This class is a singleton, holding configuration parameters for HdEmbree |
| CHdEmbreeInstanceContext | A small bit of state attached to each bit of instanced geometry in embree, for the benefit of HdEmbreeRenderer::_TraceRay |
| ►CHdEmbreePrimvarSampler | An abstract base class that knows how to sample a primvar signal given a ray hit coordinate: an <element, u, v> tuple |
| CHdEmbreeConstantSampler | This class implements the HdEmbreePrimvarSampler interface for primvars with "constant" interpolation mode |
| CHdEmbreeSubdivVertexSampler | This class implements the HdEmbreePrimvarSampler interface for primvars on subdiv meshes with "vertex" interpolation mode |
| CHdEmbreeTriangleFaceVaryingSampler | This class implements the HdEmbreePrimvarSampler interface for primvars on triangle meshes with "face-varying" interpolation modes |
| CHdEmbreeTriangleVertexSampler | This class implements the HdEmbreePrimvarSampler interface for primvars on triangle meshes with "vertex" or "varying" interpolation modes |
| CHdEmbreeUniformSampler | This class implements the HdEmbreePrimvarSampler interface for primvars with "uniform" interpolation mode |
| CHdEmbreePrototypeContext | A small bit of state attached to each bit of prototype geometry in embree, for the benefit of HdEmbreeRenderer::_TraceRay |
| CHdEmbreeRenderDelegate | Render delegates provide renderer-specific functionality to the render index, the main hydra state management structure |
| CHdEmbreeRenderer | HdEmbreeRenderer implements a renderer on top of Embree's raycasting abilities |
| CHdEmbreeRTCBufferAllocator | Utility class to track which embree user vertex buffers are currently in use |
| CHdEmbreeTypeHelper | A utility class that helps map between C++ types and Hd type tags |
| CHdEngine | The application-facing entry point top-level entry point for accessing Hydra |
| ►CHdExtComputationContext | Interface class that defines the execution environment for the client to run a computation |
| CHdExtComputationContextInternal | Hydra implementation of the HdExtComputationContext public interface |
| CHdExtComputationInputDescriptor | Describes an input to an ExtComputation that takes data from the output of another ExtComputation |
| CHdExtComputationOutputDescriptor | Describes an output of an ExtComputation |
| CHdGeomSubset | Describes a subset of a piece of geometry as a set of indices |
| CHdGpGenerativeProcedural | HdGpGenerativeProcedural is the base class for procedurals which have full access to an input scene in order to create and update a hierarchy of child prims within a hydra scene index |
| CHdGpSceneIndexPlugin | HdGpSceneIndexPlugin provides HdSceneIndexPluginRegistry access to instantiate HdGpGenerativeProceduralResolvingSceneIndex either directly or automatically via RegisterSceneIndexForRenderer |
| CHdInstance< VALUE > | This class is used as an interface to a shared instance in HdInstanceRegistry |
| ►CHdInstancer | This class exists to facilitate point cloud style instancing |
| CHdEmbreeInstancer | HdEmbree implements instancing by adding prototype geometry to the BVH multiple times within HdEmbreeMesh::Sync() |
| CHdStInstancer | HdSt implements instancing by drawing each proto multiple times with a single draw call |
| CHdInstanceRegistry< VALUE > | HdInstanceRegistry is a dictionary container of HdInstance |
| CHdInstanceRegistry< HdBufferArrayRangeSharedPtr > | |
| CHdInstanceRegistry< HdStGLSLProgramSharedPtr > | |
| CHdInstanceRegistry< HgiComputePipelineSharedPtr > | |
| CHdInstanceRegistry< HgiGraphicsPipelineSharedPtr > | |
| CHdInstanceRegistry< HgiResourceBindingsSharedPtr > | |
| CHdInstanceRegistry< HioGlslfxSharedPtr > | |
| CHdMaterialConnection2 | HdMaterialNetwork2 |
| CHdMaterialNetwork | Describes a material network composed of nodes, primvars, and relationships between the nodes and terminals of those nodes |
| CHdMaterialNetwork2 | Container of nodes and top-level terminal connections |
| ►CHdMaterialNetworkInterface | Abstract interface for querying and mutating a material network |
| CHdDataSourceMaterialNetworkInterface | Implements HdMaterialNetworkInterface for reading from and overriding values within data sources |
| CHdMaterialNetwork2Interface | Implements HdMaterialNetworkInterface interface backed by an HdMaterialNetwork2 – which is useful for implementing material filtering functions without being tied to the legacy data model |
| CHdMaterialNetworkMap | Describes a map from network type to network |
| CHdMaterialNode | Describes a material node which is made of a path, an identifier and a list of parameters |
| CHdMaterialNode2 | Describes an instance of a node within a network A node contains a (shader) type identifier, parameter values, and connections to upstream nodes |
| CHdMaterialRelationship | Describes a connection between two nodes in a material |
| CHdMeshEdgeIndexTable | Mesh edges are described as a pair of adjacent vertices encoded as GfVec2i |
| CHdMeshReprDesc | Descriptor to configure the drawItem(s) for a repr |
| CHdMeshTopology | Topology data for meshes |
| CHdMeshTriQuadBuilder | Helper class for emitting a buffer of quad indices, optionally splitting each quad into two triangles |
| CHdMeshUtil | A collection of utility algorithms for generating triangulation and quadrangulation of an input topology |
| CHdParsedAovToken | Represents an AOV token which has been parsed to extract the prefix (in the case of "primvars:"/"lpe:"/etc.) |
| CHdPerfLog | Performance counter monitoring |
| CHdPluginRenderDelegateUniqueHandle | A (movable) handle for a render delegate that was created using a a plugin |
| CHdPointsReprDesc | Descriptor to configure a drawItem for a repr |
| ►CHdPrimvarDescriptor | Describes a primvar |
| CHdExtComputationPrimvarDescriptor | Extends HdPrimvarDescriptor to describe a primvar that takes data from the output of an ExtComputation |
| CHdPrman_DependencyForwardingSceneIndexPlugin | Plugin adds a dependency forwarding scene index to the Prman render delegate to resolve any dependencies introduced by other scene indices |
| ►CHdPrman_GprimBase | A common base class for HdPrman_Gprim types |
| CHdPrman_Gprim< BASE > | A mix-in template that adds shared gprim behavior to support various HdRprim types |
| CHdPrman_Gprim< HdBasisCurves > | |
| CHdPrman_Gprim< HdMesh > | |
| CHdPrman_Gprim< HdPoints > | |
| CHdPrman_Gprim< HdRprim > | |
| CHdPrman_Gprim< HdVolume > | |
| CHdPrman_OutputFilterInvalidatingSceneIndexPlugin | Plugin adds a filtering scene index to the Prman render delegate to dirty the Sample and Display Filters connected to the Render Settings Prim when changed |
| CHdPrman_Xcpt | Defines an XcptHander for hdPrman |
| CHdQuadInfo | A helper class for quadrangulation computation |
| CHdRenderBufferDescriptor | Describes the allocation structure of a render buffer bprim |
| CHdRendererPluginHandle | A handle for HdRendererPlugin also storing the plugin id |
| CHdRenderIndex | The Hydra render index is a flattened representation of the client scene graph, which may be composed of several self-contained scene graphs, each of which provides a HdSceneDelegate adapter for data access |
| ►CHdRenderParam | The HdRenderParam is an opaque (to core Hydra) handle, to an object that is obtained from the render delegate and passed to each prim during Sync processing |
| CHdEmbreeRenderParam | The render delegate can create an object of type HdRenderParam, to pass to each prim during Sync() |
| CHdStRenderParam | The render delegate can create an object of type HdRenderParam, to pass to each prim during Sync() |
| ►CHdRenderPass | An abstract class representing a single render iteration over a set of prims (the HdRprimCollection), for the camera/viewport parameters in HdRenderPassState |
| CHdEmbreeRenderPass | HdRenderPass represents a single render iteration, rendering a view of the scene (the HdRprimCollection) for a specific viewer (the camera/viewport parameters in HdRenderPassState) to the current draw target |
| CHdRenderPassAovBinding | A renderpass AOV represents a binding of some output of the rendering process to an output buffer |
| ►CHdRenderPassState | A set of rendering parameters used among render passes |
| CHdStRenderPassState | A set of rendering parameters used among render passes |
| CHdRenderSettingDescriptor | HdRenderSettingDescriptor represents a render setting that a render delegate wants to export (e.g |
| CHdRenderSettingsParams | XXX Empty for now, but will be filled up in a follow-up change to mirror UsdRenderSpec |
| CHdRenderThread | HdRenderThread is a utility that specific render delegates can choose to use depending on their needs |
| CHdRepr | An HdRepr refers to a (single) topological representation of an rprim, and owns the draw item(s) that visually represent it |
| CHdReprSelector | Describes one or more authored display representations for an rprim |
| ►CHdResource | Base class for all GPU resource objects |
| ►CHdBufferResource | A specific type of HdResource (GPU resource) representing a buffer object |
| CHdStBufferResource | A specific type of HdBufferResource (GPU resource) representing an HgiBufferHandle |
| ►CHdResourceRegistry | A central registry for resources |
| CHdStResourceRegistry | A central registry of all GPU resources |
| CHdRetainedTypedMultisampleDataSource | Similar to HdRetainedTypedSampledDataSource but is capable of holding on to multiple samples at once |
| ►CHdRprim | The render engine state for a given rprim from the scene graph |
| ►CHdBasisCurves | Hydra Schema for a collection of curves using a particular basis |
| CHdPrman_Gprim< HdBasisCurves > | |
| CHdStBasisCurves | A collection of curves using a particular basis |
| ►CHdMesh | Hydra Schema for a subdivision surface or poly-mesh object |
| CHdEmbreeMesh | An HdEmbree representation of a subdivision surface or poly-mesh object |
| CHdPrman_Gprim< HdMesh > | |
| CHdStMesh | A subdivision surface or poly-mesh object |
| ►CHdPoints | Hydra Schema for a point cloud |
| CHdPrman_Gprim< HdPoints > | |
| CHdStPoints | Points |
| CHdPrman_Gprim< HdRprim > | |
| ►CHdVolume | Hd schema for a renderable volume primitive |
| CHdPrman_Gprim< HdVolume > | |
| CHdStVolume | Represents a Volume Prim |
| CHdRprimCollection | A named, semantic collection of objects |
| CHdSamplerParameters | Collection of standard parameters such as wrap modes to sample a texture |
| ►CHdSceneDelegate | Adapter class providing data exchange with the client scene graph |
| CHdSceneIndexAdapterSceneDelegate | Scene delegate which observes notices from an HdSceneIndex and applies them to an HdRenderIndex |
| CHdUnitTestDelegate | A simple delegate class for unit test driver |
| CHdxFreeCameraSceneDelegate | A simple scene delegate adding a camera prim to the given render index |
| CUsdImagingDelegate | The primary translation layer between the Hydra (Hd) core and the Usd scene graph |
| CHdSceneIndexPrim | Small struct representing a 'prim' in the Hydra scene index |
| ►CHdSchema | Schema classes represent a structured view of the inherently unstructured container data source passed into the constructor |
| CHdarSystemSchema | The HdarSystemSchema specifies a container that will hold "system" data that is relevant to asset resolution |
| CHdSystemSchema | The HdSystemSchema specifies a container that will hold "system" data |
| CHdSelection | HdSelection holds a collection of selected items per selection mode |
| ►CHdSprim | Sprim (state prim) is a base class of managing state for non-drawable scene entity (e.g |
| ►CHdCamera | Hydra schema for a camera that pulls the params (see above) during Sync |
| CHdPrmanCamera | A representation for cameras that pulls on camera parameters used by Riley cameras |
| ►CHdCoordSys | HdCoordSys representes a coordinate system as a Hydra state prim |
| CHdPrmanCoordSys | A representation for coordinate systems |
| ►CHdExtComputation | Hydra Representation of a Client defined computation |
| CHdStExtComputation | Specialization of HdExtComputation which manages inputs as GPU resources |
| ►CHdLight | A light model, used in conjunction with HdRenderPass |
| CHdPrmanLight | A representation for lights |
| CHdStLight | A light model for use in Storm |
| ►CHdMaterial | Hydra Schema for a material object |
| CHdPrmanMaterial | A representation for materials (including displacement) in prman |
| CHdPrmanLightFilter | A representation for light filters |
| CHdStDrawTarget | Represents an render to texture render pass |
| CHdStBufferArrayRangeContainer | A resizable container of HdBufferArrayRanges |
| CHdStBufferRelocator | A utility class to perform batched buffer copy |
| CHdStCommandBuffer | A buffer of commands (HdStDrawItem or HdComputeItem objects) to be executed |
| CHdStDrawItemInstance | A container to store instance state for a drawitem |
| CHdStDrawTargetRenderPassState | Represents common non-gl context specific render pass state for a draw target |
| CHdStDynamicUvTextureImplementation | Allows external clients to specify how a UV texture is loaded from, e.g., a file and how it is committed to the GPU |
| CHdStExtCompGpuComputationResource | A resource that represents the persistent GPU resources of an ExtComputation |
| CHdStGLSLFXShader | A simple specialization of HdSt_MaterialNetworkShader used to load the built-in fallback material network |
| CHdStGLSLProgram | An instance of a glsl program |
| CHdStHgiConversions | Converts from Hd types to Hgi types |
| CHdStMaterialNetwork | Helps HdStMaterial process a Hydra material network into shader source code and parameters values |
| CHdStRenderDelegate | HdStRenderDelegate |
| ►CHdStSamplerObject | A base class encapsulating a GPU sampler object |
| CHdStFieldSamplerObject | A sampler suitable for HdStFieldTextureObject |
| CHdStPtexSamplerObject | Ptex doesn't bind samplers, so this class is just holding a sampler to resolve handles for bindless textures |
| CHdStUdimSamplerObject | A sampler suitable for Udim textures (wraps one GPU sampler for the texels texture) |
| CHdStUvSamplerObject | A sampler suitable for HdStUvTextureObject |
| ►CHdStShaderCode | A base class representing the implementation (code) of a shader, used in conjunction with HdRenderPass |
| ►CHdStLightingShader | A lighting shader base class |
| CHdStSimpleLightingShader | A shader that supports simple lighting functionality |
| CHdStRenderPassShader | A shader that supports common renderPass functionality |
| CHdStStagingBuffer | Provides a staging buffer for CPU writes of triple-buffered resources |
| ►CHdStSubtextureIdentifier | Base class for additional information to identify a texture in a file that can contain several textures (e.g., frames in a movie or grids in an OpenVDB file) |
| CHdStAssetUvSubtextureIdentifier | Specifies whether a UV texture should be loaded flipped vertically, whether it should be loaded with pre-multiplied alpha values, and the color space in which the texture is encoded |
| CHdStDynamicUvSubtextureIdentifier | Used as a tag that the Storm texture system returns a HdStDynamicUvTextureObject that is populated by a client rather than by the Storm texture system |
| ►CHdStFieldBaseSubtextureIdentifier | Base class for information identifying a grid in a volume field file |
| CHdStField3DAssetSubtextureIdentifier | Identifies the grid in a Field3DAsset file |
| CHdStOpenVDBAssetSubtextureIdentifier | Identifies a grid in an OpenVDB file |
| CHdStPtexSubtextureIdentifier | Specifies whether a Ptex texture should be loaded with pre-multiplied alpha values |
| CHdStUdimSubtextureIdentifier | Specifies whether a Udim texture should be loaded with pre-multiplied alpha values and the color space in which the texture is encoded |
| CHdStTextureCpuData | Represents CPU data that can be stored in a HdStUvTextureObject, mostly, likely during the load phase to be committed to the GPU |
| CHdStTextureHandle | Represents a texture and sampler that will be allocated and loaded from a texture file during commit, possibly a texture sampler handle and a memory request |
| CHdStTextureIdentifier | Class to identify a texture file or a texture within the texture file (e.g., a frame in a movie) |
| ►CHdStTextureObject | Base class for a texture object |
| CHdStFieldTextureObject | A uvw texture with a bounding box describing how to transform it |
| CHdStPtexTextureObject | A Ptex texture |
| CHdStUdimTextureObject | A UDIM texture |
| ►CHdStUvTextureObject | A base class for uv textures |
| CHdStDynamicUvTextureObject | A uv texture that is managed but not populated by the Storm texture system |
| CHdStTextureUtils | Helpers for loading textures |
| CHdStTypedSamplerObject | A template alias such that, e.g., HdStUvSamplerObject can be accessed as HdStTypedSamplerObject<HdTextureType::Uv> |
| CHdStTypedTextureObject | A template alias such that, e.g., HdStUvTextureObject can be accessed as HdStTypedTextureObject<HdTextureType::Uv> |
| CHdSyncRequestVector | The SceneDelegate is requested to synchronize prims as the result of executing a specific render pass, the following data structure is passed back to the delegate to drive synchronization |
| ►CHdTimeSampleArray< TYPE, CAPACITY > | An array of a value sampled over time, in struct-of-arrays layout |
| CHdIndexedTimeSampleArray< TYPE, CAPACITY > | An array of a value and its indices sampled over time, in struct-of-arrays layout |
| CHdTimeSampleArray< GfMatrix4d, HDPRMAN_MAX_TIME_SAMPLES > | |
| CHdTupleType | HdTupleType represents zero, one, or more values of the same HdType |
| CHdVec4f_2_10_10_10_REV | HdVec4f_2_10_10_10_REV is a compact representation of a GfVec4f |
| ►CHdVectorSchema | Vector schema classes represent a view of a vector data source which is returning untyped data sources |
| CHdSchemaBasedVectorSchema< Schema > | Base class for vector schema classes that represent a view of a vector data source containing container data sources conforming to a given HdSchema |
| CHdSchemaBasedVectorSchema< HdSelectionSchema > | |
| CHdTypedVectorSchema< T > | Base class for vector schema classes that represent a view of a vector data source containing data source of a given type |
| CHdVolumeFieldDescriptor | Description of a single field related to a volume primitive |
| CHdxAovInputTaskParams | AovInput parameters |
| CHdxBoundingBoxTaskParams | BoundingBoxTask parameters |
| CHdxColorChannelTaskParams | ColorChannelTask parameters |
| CHdxColorCorrectionTaskParams | ColorCorrectionTask parameters |
| CHdxColorizeSelectionTaskParams | Input parameters for HdxColorizeSelectionTask |
| CHdxFullscreenShader | This class is a utility for rendering deep raytracer or aov output (color/depth) to a hgi texture |
| CHdxHgiConversions | Converts from Hd types to Hgi types |
| CHdxInstancerContext | Information about an instancer instancing a picked object (or an instancer instancing such an instancer and so on) |
| CHdxOitBufferAccessor | Class for OIT render tasks to access the OIT buffers |
| CHdxOitResolveTask | A task for resolving previous passes to pixels |
| CHdxOitResolveTaskParams | OIT resolve task params |
| CHdxPickFromRenderBufferTaskParams | Pick task params |
| CHdxPickHit | Picking hit structure |
| CHdxPickResult | A utility class for resolving ID buffers into hits |
| CHdxPickTask | A task for running picking queries against the current scene |
| CHdxPickTaskContextParams | Pick task context params |
| CHdxPickTaskParams | Pick task params |
| CHdxPresentTaskParams | PresentTask parameters |
| CHdxPrimOriginInfo | A helper to extract information about the picked prim that allows modern applications to identify a prim and, e.g., obtain the scene path such as the path of the corresponding UsdPrim |
| CHdxRenderSetupTask | A task for setting up render pass state (camera, renderpass shader, GL states) |
| CHdxRenderTaskParams | RenderTask parameters (renderpass state) |
| CHdxSelectionTask | The SelectionTask is responsible for setting up render pass global buffers for selection and depositing those buffers into the task context for down stream consumption |
| CHdxSelectionTracker | HdxSelectionTracker takes HdSelection and generates a GPU buffer to be used |
| CHdxShadowTask | A task for generating shadow maps |
| ►CHdxTask | Base class for (some) tasks in Hdx that provides common progressive rendering and Hgi functionality |
| CHdxAovInputTask | A task for taking input AOV data comming from a render buffer that was filled by render tasks and converting it to a HgiTexture |
| CHdxBoundingBoxTask | A task for rendering bounding boxes |
| CHdxColorChannelTask | A task for choosing a color channel for display |
| CHdxColorCorrectionTask | A task for performing color correction (and optionally color grading) on a color buffer to transform its color for display |
| CHdxColorizeSelectionTask | A task for taking ID buffer data and turning it into a "selection overlay" that can be composited on top of hydra's color output |
| CHdxPickFromRenderBufferTask | A task for running picking queries against pre-existing id buffers |
| CHdxPresentTask | A task for taking the final result of the aovs and compositing it over the currently bound framebuffer |
| ►CHdxRenderTask | A task for rendering geometry to pixels |
| CHdxOitRenderTask | A task for rendering transparent geometry into OIT buffers |
| CHdxOitVolumeRenderTask | A task for rendering transparent geometry into OIT buffers |
| CHdxSkydomeTask | If we have a domelight present in the lighting context the SkydomeTask will render the associated environment map as a Skydome |
| CHdxVisualizeAovTask | A task for visualizing non-color AOVs such as depth, normals, primId |
| CHdxVisualizeAovTaskParams | aovName: The name of the aov to visualize |
| ►CHfPluginBase | Base class for all hydra plugin classes |
| CHdGpGenerativeProceduralPlugin | HdGpGenerativeProceduralPlugin represents an HdGpGenerativeProcedural for plug-in discovery via HdGpGenerativeProceduralPluginRegistry |
| ►CHdRendererPlugin | This class defines a renderer plugin interface for Hydra |
| CHdEmbreeRendererPlugin | A registered child of HdRendererPlugin, this is the class that gets loaded when a hydra application asks to draw with a certain renderer |
| CHfPluginDesc | Common structure used to report registered plugins in one of the plugin registries |
| CHfPluginRegistry | Base class for registering Hydra plugins using the plug mechanism |
| ►CHgi | Hydra Graphics Interface |
| CHgiGL | OpenGL implementation of the Hydra Graphics Interface |
| CHgiAttachmentDesc | Describes the properties of a framebuffer attachment |
| ►CHgiBuffer | Represents a graphics platform independent GPU buffer resource (base class) |
| CHgiGLBuffer | Represents an OpenGL GPU buffer resource |
| CHgiBufferBindDesc | Describes the binding information of a buffer (or array of buffers) |
| CHgiBufferCpuToGpuOp | Describes the properties needed to copy buffer data from CPU to GPU |
| CHgiBufferDesc | Describes the properties needed to create a GPU buffer |
| CHgiBufferGpuToCpuOp | Describes the properties needed to copy buffer data from GPU to CPU |
| CHgiBufferGpuToGpuOp | Describes the properties needed to copy buffer data from GPU to GPU |
| CHgiBufferToTextureOp | Describes the properties needed to copy GPU buffer data into a GPU texture |
| ►CHgiCapabilities | Reports the capabilities of the Hgi device |
| CHgiGLCapabilities | Reports the capabilities of the HgiGL device |
| ►CHgiCmds | Graphics commands are recorded in 'cmds' objects which are later submitted to hgi |
| ►CHgiBlitCmds | A graphics API independent abstraction of resource copy commands |
| CHgiGLBlitCmds | OpenGL implementation of HgiBlitCmds |
| ►CHgiComputeCmds | A graphics API independent abstraction of compute commands |
| CHgiGLComputeCmds | OpenGL implementation of HgiComputeCmds |
| ►CHgiGraphicsCmds | A graphics API independent abstraction of graphics commands |
| CHgiGLGraphicsCmds | OpenGL implementation of HgiGraphicsCmds |
| CHgiIndirectCommandEncoder | The indirect command encoder is used to record the drawing primitives for a batch and capture the resource bindings so that it can be executed efficently in a later stage of rendering |
| CHgiComponentMapping | Describes color component mapping |
| CHgiComputeCmdsDesc | Describes the properties to construct a HgiComputeCmds |
| ►CHgiComputePipeline | Represents a graphics platform independent GPU compute pipeline resource |
| CHgiGLComputePipeline | OpenGL implementation of HgiComputePipeline |
| CHgiComputePipelineDesc | Describes the properties needed to create a GPU compute pipeline |
| CHgiComputeShaderConstantsDesc | A small, but fast buffer of uniform data for shaders |
| CHgiDepthStencilState | Properties to configure depth and stencil test |
| CHgiGLContextArena | Represents an arena for the HgiGL instance to manage container object resources that are tied to the current GL context (and can't be shared) |
| CHgiGLDevice | OpenGL implementation of GPU device |
| CHgiGLGarbageCollector | Handles garbage collection of opengl objects by delaying their destruction until those objects are no longer used |
| CHgiGLOps | A collection of functions used by cmds objects to do deferred cmd recording |
| CHgiGLPipeline | OpenGL implementation of HgiGraphicsPipeline |
| CHgiGraphicsCmdsDesc | Describes the properties to begin a HgiGraphicsCmds |
| CHgiGraphicsPipeline | Represents a graphics platform independent GPU graphics pipeline resource |
| CHgiGraphicsPipelineDesc | Describes the properties needed to create a GPU pipeline |
| CHgiGraphicsShaderConstantsDesc | A small, but fast buffer of uniform data for shaders |
| CHgiHandle< T > | Handle that contains a hgi object and unique id |
| CHgiHandle< class HgiSampler > | |
| CHgiHandle< class HgiShaderProgram > | |
| CHgiHandle< class HgiTexture > | |
| CHgiHandle< HgiBuffer > | |
| CHgiHandle< HgiGraphicsPipeline > | |
| CHgiHandle< HgiResourceBindings > | |
| CHgiInterop | Hydra Graphics Interface Interop |
| CHgiMipInfo | HgiMipInfo describes size and other info for a mip level |
| CHgiMultiSampleState | Properties to configure multi sampling |
| CHgiRasterizationState | Properties to configure the rasterization state |
| ►CHgiResourceBindings | Represents a collection of buffers, texture and vertex attributes that will be used by an cmds object (and pipeline) |
| CHgiGLResourceBindings | OpenGL implementation of HgiResourceBindings |
| CHgiResourceBindingsDesc | Describes a set of resources that are bound to the GPU during encoding |
| ►CHgiSampler | Represents a graphics platform independent GPU sampler resource that perform texture sampling operations |
| CHgiGLSampler | OpenGL implementation of HgiSampler |
| CHgiSamplerDesc | Describes the properties needed to create a GPU sampler |
| ►CHgiShaderFunction | Represents one shader stage function (code snippet) |
| CHgiGLShaderFunction | OpenGL implementation of HgiShaderFunction |
| CHgiShaderFunctionBufferDesc | Describes a buffer to be passed into a shader |
| CHgiShaderFunctionComputeDesc | Describes a compute function's description |
| CHgiShaderFunctionDesc | Describes the properties needed to create a GPU shader function |
| CHgiShaderFunctionFragmentDesc | Describes a fragment function's description |
| CHgiShaderFunctionGeometryDesc | Describes a geometry function's description |
| CHgiShaderFunctionParamBlockDesc | Describes an interstage param block between shader stages |
| CHgiShaderFunctionParamDesc | Describes a param passed into a shader or between shader stages |
| CHgiShaderFunctionTessellationDesc | Describes a tessellation function's description |
| CHgiShaderFunctionTextureDesc | Describes a texture to be passed into a shader |
| CHgiShaderGenerator | Base class for shader function generation Given a descriptor, converts glslfx domain language to concrete shader languages |
| ►CHgiShaderProgram | Represents a collection of shader functions |
| CHgiGLShaderProgram | OpenGL implementation of HgiShaderProgram |
| CHgiShaderProgramDesc | Describes the properties needed to create a GPU shader program |
| CHgiShaderSection | A base class for a Shader Section |
| CHgiStencilState | stencilFailOp: The operation executed when the stencil test fails |
| CHgiTessellationState | Properties to configure tessellation |
| ►CHgiTexture | Represents a graphics platform independent GPU texture resource |
| CHgiGLTexture | Represents a OpenGL GPU texture resource |
| CHgiTextureBindDesc | Describes the binding information of a texture (or array of textures) |
| CHgiTextureCpuToGpuOp | Describes the properties needed to copy texture data from CPU to GPU |
| CHgiTextureDesc | Describes the properties needed to create a GPU texture |
| CHgiTextureGpuToCpuOp | Describes the properties needed to copy texture data from GPU to CPU |
| CHgiTextureToBufferOp | Describes the properties needed to copy GPU texture data into a GPU buffer |
| CHgiTextureView | Represents a graphics platform independent GPU texture view resource |
| CHgiTextureViewDesc | Describes the properties needed to create a GPU texture view from an existing GPU texture object |
| CHgiVertexAttributeDesc | Describes one attribute of a vertex |
| CHgiVertexBufferBinding | Describes a buffer to be bound during encoding |
| CHgiVertexBufferDesc | Describes the attributes of a vertex buffer |
| CHioFieldTextureData | An interface class for reading volume files having a transformation |
| CHioGlslfx | A class representing the config and shader source of a glslfx file |
| CHioGlslfxConfig | A class representing the configuration of a glslfx file |
| CHioImage | A base class for reading and writing texture image data |
| CUsdStageCache::Id | A lightweight identifier that may be used to identify a particular cached stage within a UsdStageCache |
| CSdfReference::IdentityEqual | Struct that defines equality of SdfReferences based on their identity (the asset path and prim path) |
| CSdfReference::IdentityLessThan | Struct that defines a strict weak ordering of SdfReferences based on their identity (the asset path and prim path) |
| CPxOsdMeshTopologyValidation::Invalidation | A tuple containing a code describing an invalidation and a descriptive message |
| Cis_bool< T > | Check to see if something is bool (fail check by default) |
| Cis_bool< bool > | Check to see if something is bool (true if actually a bool) |
| Cis_complex< T > | Check for complex |
| Cis_copyable_ptr< T > | Check to see if something is copyable pointer |
| Cis_istreamable< T, S > | Check for input streamability |
| Cis_mutable_container< T, conditional_t< false, void_t< typename T::value_type, decltype(std::declval< T >().end()), decltype(std::declval< T >().clear()), decltype(std::declval< T >().insert(std::declval< decltype(std::declval< T >().end())>(), std::declval< const typename T::value_type & >()))>, void > > | Type trait to test if a type is a mutable container meaning it has a value_type, it has an iterator, a clear, and end methods and an insert function |
| Cis_readable_container< T, conditional_t< false, void_t< decltype(std::declval< T >().end()), decltype(std::declval< T >().begin())>, void > > | Type trait to test if a type is a container meaning it has a value_type, it has an iterator, a clear, and an end methods and an insert function |
| Cis_shared_ptr< T > | Check to see if something is a shared pointer |
| Cis_shared_ptr< const std::shared_ptr< T > > | Check to see if something is a shared pointer (True if really a shared pointer) |
| Cis_shared_ptr< std::shared_ptr< T > > | Check to see if something is a shared pointer (True if really a shared pointer) |
| CIsMemberType< T > | This can be specialized to override the type deduction for IsMember |
| CIsMemberType< const char * > | The main custom type needed here is const char * should be a string |
| CUsdPrimRange::iterator | A forward iterator into a UsdPrimRange |
| CUsdZipFile::Iterator | Iterator for traversing and inspecting the contents of the zip archive |
| CTraceConcurrentList< T >::iterator | This class provides forward iterator support to iterate over all the items |
| CJsParseError | A struct containing information about a JSON parsing error |
| CJsValue | A discriminated union type for JSON values |
| CJsValueTypeConverter< ValueType, MapType, UseInt64 > | A helper class that can convert recursive JsValue structures to identical structures using a different container type |
| CJsWriter | This class provides an interface to writing json values directly to a stream |
| CTfNotice::Key | Handle-object returned by TfNotice::Register() |
| CPcpNamespaceEdits::LayerStackSite | Layer stack site that must respond to a namespace edit |
| Cmake_void< Ts > | A copy of std::void_t from C++17 (helper for C++11 and C++14) |
| CUsdPhysicsRigidBodyAPI::MassInformation | Mass information for a collision, used in ComputeMassProperties MassInformationFn callback |
| CMatfiltVstructConditionalEvaluator | Parses and evaluates a single expression of "virtual struct conditional
grammar" |
| Cmod_growth_policy< GrowthFactor > | Grow the hash table by GrowthFactor::num / GrowthFactor::den and use a modulo to map a hash to a bucket |
| CHdStShaderCode::NamedTextureHandle | Information necessary to bind textures and create accessor for the texture |
| CNdrDiscoveryUri | Struct for holding a URI and its resolved URI for a file discovered by NdrFsHelpersDiscoverFiles |
| ►CNdrNode | Represents an abstract node |
| CSdrShaderNode | A specialized version of NdrNode which holds shading information |
| CNdrNodeDiscoveryResult | Represents the raw data of a node, and some other bits of metadata, that were determined via a NdrDiscoveryPlugin |
| ►CNdrProperty | Represents a property (input or output) that is part of a NdrNode instance |
| CSdrShaderProperty | A specialized version of NdrProperty which holds shading information |
| CUsdShadeNodeGraph::NodeGraphEqualFn | Equality comparator for UsdShadeNodeGraph objects |
| CUsdShadeNodeGraph::NodeGraphHasher | Hash functor for UsdShadeNodeGraph objects |
| CSdfPathTable< MappedType >::NodeHandle | A handle owning a path table node that may be used to "reserve" a stable memory location for key & mapped object |
| CUsdviewqHydraObserver::NoticeEntry | Aggregate of HdSceneIndexObserver entry types for easier binding to python |
| CUsdGeomXformCommonAPI::Ops | Return type for CreateXformOps() |
| COptionBase< CRTP > | This is the CRTP base class for Option and OptionDefaults |
| COptionBase< Option > | |
| ►COptionBase< OptionDefaults > | |
| COptionDefaults | This is a version of OptionBase that only supports setting values, for defaults |
| CHdPrimOriginSchema::OriginPath | Wraps an SdfPath so that it is not affected by the prefixing scene index |
| Cpair_adaptor< T, _ > | Adaptor for set-like structure: This just wraps a normal container in a few utilities that do almost nothing |
| Cpair_adaptor< T, conditional_t< false, void_t< typename T::value_type::first_type, typename T::value_type::second_type >, void > > | Adaptor for map-like structure (true version, must have key_type and mapped_type) |
| CHioGlslfxConfig::Parameter | A class representing a parameter |
| CTfMallocTag::CallTree::PathNode | Node in the call tree structure |
| CUsdNotice::ObjectsChanged::PathRange | An iterable range of paths to objects that have changed |
| CPcpArc | Represents an arc connecting two nodes in the prim index |
| CPcpCache | PcpCache is the context required to make requests of the Pcp composition algorithm and cache the results |
| CPcpCacheChanges | Types of changes per cache |
| CPcpChanges | Describes Pcp changes |
| CPcpCulledDependency | Description of a dependency that has been culled from the corresponding prim index |
| CPcpDependency | Description of a dependency |
| CPcpDynamicFileFormatContext | Context object for the current state of a prim index that is being built that allows implementations of PcpDynamicFileFormatInterface to compose field values when generating dynamic file format arguments |
| CPcpDynamicFileFormatDependencyData | Contains the necessary information for storing a prim index's dependency on dynamic file format arguments and determining if a field change affects the prim index |
| CPcpDynamicFileFormatInterface | Interface mixin that can be included by SdfFileFormat subclasses to enable dynamic file format argument generation for a file format plugin |
| ►CPcpErrorBase | Base class for all error types |
| CPcpErrorArcCycle | Arcs between PcpNodes that form a cycle |
| CPcpErrorArcPermissionDenied | Arcs that were not made between PcpNodes because of permission restrictions |
| CPcpErrorCapacityExceeded | Exceeded the capacity for composition arcs at a single site |
| CPcpErrorInvalidPrimPath | Invalid prim paths used by references or payloads |
| CPcpErrorInvalidReferenceOffset | References or payloads that use invalid layer offsets |
| CPcpErrorInvalidSublayerOffset | Sublayers that use invalid layer offsets |
| CPcpErrorInvalidSublayerOwnership | Sibling layers that have the same owner |
| CPcpErrorInvalidSublayerPath | Asset paths that could not be both resolved and loaded |
| CPcpErrorOpinionAtRelocationSource | Opinions were found at a relocation source path |
| CPcpErrorPrimPermissionDenied | Layers with illegal opinions about private prims |
| CPcpErrorPropertyPermissionDenied | Layers with illegal opinions about private properties |
| CPcpErrorSublayerCycle | Layers that recursively sublayer themselves |
| ►CPcpErrorTargetPathBase | Base class for composition errors related to target or connection paths |
| CPcpErrorInvalidExternalTargetPath | Invalid target or connection path in some scope that points to an object outside of that scope |
| CPcpErrorInvalidInstanceTargetPath | Invalid target or connection path authored in an inherited class that points to an instance of that class |
| CPcpErrorInvalidTargetPath | Invalid target or connection path |
| CPcpErrorTargetPermissionDenied | Paths with illegal opinions about private targets |
| CPcpErrorUnresolvedPrimPath | Asset paths that could not be both resolved and loaded |
| CPcpErrorInconsistentAttributeType | Attributes that have specs with conflicting definitions |
| CPcpErrorInconsistentAttributeVariability | Attributes that have specs with conflicting variability |
| CPcpErrorInconsistentPropertyType | Properties that have specs with conflicting definitions |
| CPcpErrorInvalidAssetPath | Invalid asset paths used by references or payloads |
| CPcpErrorMutedAssetPath | Muted asset paths used by references or payloads |
| CPcpInstanceKey | A PcpInstanceKey identifies instanceable prim indexes that share the same set of opinions |
| CPcpIteratorTraits< Iterator > | Traits class for retrieving useful characteristics about one of the Pcp iterator types above |
| CPcpLayerPrefetchRequest | PcpLayerPrefetchRequest represents a request to pre-fetch and retain a set of layers in memory |
| CPcpLayerStackChanges | Types of changes per layer stack |
| CPcpLayerStackIdentifier | Arguments used to identify a layer stack |
| CPcpLayerStackIdentifierStr | A "string"-based version of PcpLayerStackIdentifier |
| CPcpLayerStackSite | A site specifies a path in a layer stack of scene description |
| CPcpLifeboat | Structure used to temporarily retain layers and layerStacks within a code block |
| CPcpMapExpression | An expression that yields a PcpMapFunction value |
| CPcpMapFunction | A function that maps values from one namespace (and time domain) to another |
| CPcpNamespaceEdits | Sites that must respond to a namespace edit |
| CPcpNodeIterator | Object used to iterate over nodes in the prim index graph in strong-to-weak order |
| CPcpNodeRef | PcpNode represents a node in an expression tree for compositing scene description |
| CPcpNodeReverseIterator | Object used to iterate over nodes in the prim index graph in weak-to-strong order |
| CPcpPrimIndex | PcpPrimIndex is an index of the all sites of scene description that contribute opinions to a specific prim, under composition semantics |
| CPcpPrimIndexInputs | Inputs for the prim indexing procedure |
| CPcpPrimIndexOutputs | Outputs of the prim indexing procedure |
| CPcpPrimIterator | Object used to iterate over prim specs in the prim index graph in strong-to-weak order |
| CPcpPrimReverseIterator | Object used to iterate over prim specs in the prim index graph in weak-to-strong order |
| CPcpPropertyIndex | PcpPropertyIndex is an index of all sites in scene description that contribute opinions to a specific property, under composition semantics |
| CPcpPropertyIterator | Object used to iterate over property specs in a property index in strong-to-weak order |
| CPcpPropertyReverseIterator | Object used to iterate over property specs in a property index in weak-to-strong order |
| CPcpSite | A site specifies a path in a layer stack of scene description |
| CPcpSiteStr | A "string-based" version of PcpSite |
| CPcpSiteTrackerSegment | Used to keep track of which sites have been visited and through what type of arcs |
| CPcpSourceArcInfo | Information about the source of the target of an arc |
| CPcpTargetIndex | A PcpTargetIndex represents the results of indexing the target paths of a relationship or attribute |
| CPlugNotice | Notifications sent by the Plug library |
| CPlugStaticInterface< Interface > | Provides access to an interface into a plugin |
| CUsdGeomHermiteCurves::PointAndTangentArrays | Represents points and tangents of the same size |
| Cpower_of_two_growth_policy< GrowthFactor > | Grow the hash table by a factor of GrowthFactor keeping the bucket count to a power of two |
| Cprime_growth_policy | Grow the hash table by using prime numbers as bucket count |
| CUsdRenderSpec::Product | Specification of a product. See UsdRenderProduct |
| CUsdGeomImageable::PurposeInfo | Value type containing information about a prim's computed effective purpose as well as storing whether the prim's purpose value can be inherited by namespace children if necessary |
| CPxOsdMeshTopology | Topology data for meshes |
| CPxOsdMeshTopologyValidation | Utility to help validate an OpenSubdiv Mesh topology |
| CPxOsdSubdivTags | Tags for non-hierarchial subdiv surfaces |
| CHdSceneIndexObserver::RemovedPrimEntry | A notice indicating a prim subtree was removed from the scene |
| CUsdRenderSpec::RenderVar | Specification of a render variable (aka AOV). See UsdRenderVar |
| CHdStShaderCode::ResourceContext | The context available in implementations of AddResourcesFromTextures |
| Crobin_hash< ValueType, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > | Internal common class used by robin_map and robin_set |
| Crobin_hash< Key, KeySelect, void, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > | |
| Crobin_hash< std::pair< Key, T >, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > | |
| Crobin_hash< ValueType, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy >::robin_iterator< IsConst > | The 'operator*()' and 'operator->()' methods return a const reference and const pointer respectively to the stored value type |
| Crobin_map< Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > | Implementation of a hash map using open-addressing and the robin hood hashing algorithm with backward shift deletion |
| Crobin_set< Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy > | Implementation of a hash set using open-addressing and the robin hood hashing algorithm with backward shift deletion |
| CUsdSchemaRegistry::SchemaInfo | Structure that holds the information about a schema that is registered with the schema registry |
| CTfBigRWMutex::ScopedLock | Scoped lock utility class |
| CTfSpinRWMutex::ScopedLock | Scoped lock utility class |
| ►CSdfAbstractDataConstValue | A type-erased container for a const field value in an SdfAbstractData |
| CSdfAbstractDataConstTypedValue< T > | The fully-typed container for a field value in an SdfAbstractData |
| CSdfAbstractDataConstTypedValue< std::string > | |
| CSdfAbstractDataSpecVisitor | Base class for objects used to visit specs in an SdfAbstractData object |
| ►CSdfAbstractDataValue | A type-erased container for a field value in an SdfAbstractData |
| CSdfAbstractDataTypedValue< T > | The fully-typed container for a field value in an SdfAbstractData |
| CSdfAdaptedChildrenViewCreator< _View, _Adapter > | Helper class to convert a given view of type _View to an adapted view using _Adapter as the adapter class |
| CSdfAllowed | Indicates if an operation is allowed and, if not, why not |
| CSdfAssetPath | Contains an asset path and an optional resolved path |
| CSdfBatchNamespaceEdit | A description of an arbitrarily complex namespace edit |
| CSdfChangeBlock | DANGER DANGER DANGER |
| CSdfChangeList | A list of scene description modifications, organized by the namespace paths where the changes occur |
| CSdfChildrenView< _ChildPolicy, _Predicate, _Adapter > | Provides a view onto an object's children |
| CSdfChildrenViewTrivialAdapter< T > | Special case adapter that does no conversions |
| CSdfChildrenViewTrivialPredicate< T > | Special case predicate that always passes |
| CSdfCleanupEnabler | An RAII class which, when an instance is alive, enables scheduling of automatic cleanup of SdfLayers |
| CSdfCopySpecsValueEdit | Value containing an editing operation for SdfCopySpecs |
| ►CSdfGenericSpecViewPredicate | Predicate for viewing properties |
| CSdfAttributeViewPredicate | Predicate for viewing attributes |
| CSdfRelationshipViewPredicate | Predicate for viewing relationships |
| CSdfHandle< T > | SdfHandle is a smart ptr that calls IsDormant() on the pointed-to object as an extra expiration check so that dormant objects appear to be expired |
| CSdfIdentityMapEditProxyValuePolicy< T > | A value policy for SdfMapEditProxy that does nothing |
| CSdfLayerHints | Contains hints about layer contents that may be used to accelerate certain composition operations |
| CSdfLayerOffset | Represents a time offset and scale between layers |
| CSdfListEditorProxy< _TypePolicy > | Represents a set of list editing operations |
| CSdfListOp< T > | Value type representing a list-edit operation |
| CSdfListProxy< _TypePolicy > | Represents a single list of list editing operations |
| CSdfMapEditProxy< T, _ValuePolicy > | A proxy for editing map-like values |
| CSdfNameKeyPolicy | Key policy for std::string names |
| CSdfNamespaceEdit | A single namespace edit |
| CSdfNamespaceEditDetail | Detailed information about a namespace edit |
| CSdfNameTokenKeyPolicy | Key policy for TfToken names |
| CSdfNotice | Wrapper class for Sdf notices |
| CSdfOpaqueValue | In-memory representation of the value of an opaque attribute |
| CSdfPath | A path value used to locate objects in layers or scenegraphs |
| CSdfPathAncestorsRange | Range representing a path and ancestors, and providing methods for iterating over them |
| CSdfPathKeyPolicy | Key policy for SdfPath; converts all SdfPaths to absolute |
| CSdfPathTable< MappedType > | A mapping from SdfPath to MappedType, somewhat similar to map<SdfPath, MappedType> and TfHashMap<SdfPath, MappedType>, but with key differences |
| CSdfPathTable< _PrimCacheEntry > | |
| CSdfPathTable< _PrimEntry > | |
| CSdfPathTable< HdSceneIndexPrim > | |
| CSdfPathTable< PcpPrimIndex > | |
| CSdfPathTable< PcpPropertyIndex > | |
| CSdfPayload | Represents a payload and all its meta data |
| CSdfPayloadTypePolicy | List editor type policy for SdfPayload |
| CSdfPyWrapListOp< T > | Helper class for wrapping SdfListOp objects for Python |
| CSdfReference | Represents a reference and all its meta data |
| CSdfReferenceTypePolicy | List editor type policy for SdfReference |
| CSdfRelocatesMapProxyValuePolicy | Map edit proxy value policy for relocates maps |
| CSdfSite | An SdfSite is a simple representation of a location in a layer where opinions may possibly be found |
| ►CSdfSpec | Base class for all Sdf spec classes |
| CSdfPrimSpec | Represents a prim description in an SdfLayer object |
| ►CSdfPropertySpec | Base class for SdfAttributeSpec and SdfRelationshipSpec |
| CSdfAttributeSpec | A subclass of SdfPropertySpec that holds typed data |
| CSdfRelationshipSpec | A property that contains a reference to one or more SdfPrimSpec instances |
| CSdfVariantSetSpec | Represents a coherent set of alternate representations for part of a scene |
| CSdfVariantSpec | Represents a single variant in a variant set |
| CSdfSpecTypeRegistration | Provides functions to register spec types with the runtime typing system used to cast between C++ spec types |
| CSdfSubLayerTypePolicy | List editor type policy for sublayers |
| CSdfTimeCode | Value type that represents a time code |
| CSdfTupleDimensions | Represents the shape of a value type (or that of an element in an array) |
| CSdfUnregisteredValue | Stores a representation of the value for an unregistered metadata field encountered during text layer parsing |
| CSdfValueBlock | A special value type that can be used to explicitly author an opinion for an attribute's default value or time sample value that represents having no value |
| CSdfValueTypeName | Represents a value type name, i.e |
| CSdfValueTypeNameHash | Functor for hashing a SdfValueTypeName |
| CSdfSchemaBase::SpecDefinition | Class representing fields and other information for a spec type |
| CHioImage::StorageSpec | Describes the memory layout and storage of a texture image |
| CTraceStaticKeyData::StringLiteral | This is a helper class for the constructors of TraceStaticKeyData |
| Csubtype_count< T > | Set of overloads to get the type size of an object |
| Csubtype_count_min< T > | Forward declare the subtype_count_min structure |
| CHioGlslfxConfig::Texture | A class representing a texture |
| CTfAnyUniquePtr | A simple type-erased container that provides only destruction, moves and immutable, untyped access to the held value |
| CTfAnyWeakPtr | Provides the ability to hold an arbitrary TfWeakPtr in a non-type-specific manner in order to observe whether it has expired or not |
| CTfAtomicOfstreamWrapper | A class that wraps a file output stream, providing improved tolerance for write failures |
| CTfBigRWMutex | This class implements a readers-writer mutex and provides a scoped lock utility |
| CTfCopyIfNotReference< T > | TfCopyIfNotReference<T>::Apply(v) is used to return a pointer to the value v |
| CTfCStrHashWrapper | A structure that wraps a char pointer, indicating intent that it should be hashed as a c-style null terminated string |
| CTfDebug | Enum-based debugging messages |
| CTfDeclarePtrs< T > | Templated struct used for type definition macros |
| CTfDeleter | Function object for deleting any pointer |
| CTfDenseHashMap< Key, Data, HashFn, EqualKey, Threshold > | This is a space efficient container that mimics the TfHashMap API that uses a vector for storage when the size of the map is small |
| CTfDenseHashMap< int, _CounterValue, TfHash > | |
| CTfDenseHashMap< SdfPath, _DensePathSet, TfHash > | |
| CTfDenseHashMap< SdfPath, HdDataSourceLocatorSet, TfHash > | |
| CTfDenseHashMap< SdfPath, size_t, SdfPath::Hash > | |
| CTfDenseHashMap< SdfPath, TfToken, TfHash > | |
| CTfDenseHashMap< TfToken, _Entry, TfToken::HashFunctor, std::equal_to< TfToken >, 8 > | |
| CTfDenseHashMap< TfToken, size_t, TfHash > | |
| CTfDenseHashSet< Element, HashFn, EqualElement, Threshold > | This is a space efficient container that mimics the TfHashSet API that uses a vector for storage when the size of the set is small |
| CTfDenseHashSet< SdfPath, SdfPath::Hash > | |
| ►CTfDiagnosticBase | Represents the base class of an object representing a diagnostic message |
| CTfError | Represents an object that contains error information |
| CTfStatus | Represents an object that contains information about a status message |
| CTfWarning | Represents an object that contains information about a warning |
| CTfDictionaryLessThan | Provides dictionary ordering binary predicate function on strings |
| CTfEnum | An enum class that records both enum type and enum value |
| CTfEqualCString | A function object that compares two c-strings for equality |
| CTfErrorMark | Class used to record the end of the error-list |
| CTfErrorTransport | A facility for transporting errors from thread to thread |
| CTfFunctionRef< Sig > | This class provides a non-owning reference to a type-erased callable object with a specified signature |
| CTfGet< N > | Function object for retrieving the N'th element of a std::pair or std::tuple |
| CTfHash | A user-extensible hashing mechanism for use with runtime hash tables |
| CTfHashCharPtr | A hash function object that hashes the address of a char pointer |
| CTfHashCString | A hash function object that hashes null-terminated c-string content |
| CTfIterator< T, Reverse > | A simple iterator adapter for STL containers |
| CTfMallocTag | Top-down memory tagging system |
| ►CTfNotice | The base class for objects used to notify interested parties (listeners) when events have occurred |
| ►CArNotice::ResolverNotice | Base class for all ArResolver-related notices |
| CArNotice::ResolverChanged | Notice sent when asset paths may resolve to a different path than before due to a change in the resolver |
| ►CPlugNotice::Base | Base class for all Plug notices |
| CPlugNotice::DidRegisterPlugins | Notice sent after new plugins have been registered with the Plug registry |
| ►CSdfNotice::Base | Base notification class for scene |
| ►CSdfNotice::LayerDidReplaceContent | Sent after a menv layer has been loaded from a file |
| CSdfNotice::LayerDidReloadContent | Sent after a layer is reloaded |
| CSdfNotice::LayerDidSaveLayerToFile | Sent after a layer is saved to file |
| CSdfNotice::LayerDirtinessChanged | Similar behavior to LayersDidChange, but only gets sent if a change in the dirty status of a layer occurs |
| CSdfNotice::LayerIdentifierDidChange | Sent when the identifier of a layer has changed |
| CSdfNotice::LayerInfoDidChange | Sent when the (scene spec) info of a layer have changed |
| CSdfNotice::LayerMutenessChanged | Sent after a layer has been added or removed from the set of muted layers |
| CSdfNotice::LayersDidChange | Global notice sent to indicate that layer contents have changed |
| CSdfNotice::LayersDidChangeSentPerLayer | Notice sent per-layer indicating all layers whose contents have changed within a single round of change processing |
| CTfDebugSymbolEnableChangedNotice | Sent when a debug symbol has been enabled or disabled |
| CTfDebugSymbolsChangedNotice | Sent when the list of available debug symbol names has changed |
| CTfPyModuleWasLoaded | A TfNotice that is sent when a script module is loaded |
| CTfTypeWasDeclaredNotice | TfNotice sent after a TfType is declared |
| CTraceCollectionAvailable | A TfNotice that is sent when the TraceCollector creates a TraceCollection |
| ►CUsdNotice::StageNotice | Base class for UsdStage notices |
| CUsdNotice::LayerMutingChanged | Notice sent after a set of layers have been newly muted or unmuted |
| CUsdNotice::ObjectsChanged | Notice sent in response to authored changes that affect UsdObjects |
| CUsdNotice::StageContentsChanged | Ultra-conservative notice sent when the given UsdStage's contents have changed in any way |
| CUsdNotice::StageEditTargetChanged | Notice sent when a stage's EditTarget has changed |
| CTfPatternMatcher | Class for matching regular expressions |
| CTfPointerAndBits< T > | This class stores a T * and a small integer in the space of a T * |
| CTfPointerAndBits< _Entry > | |
| CTfPointerAndBits< const _Rep > | |
| CTfPointerAndBits< const _TypeInfo > | |
| CTfPyArg | Class representing a function argument |
| CTfPyCall< Return > | Provide a way to call a Python callable |
| CTfPyKwArg | Wrapper object for a keyword-argument pair in a call to TfPyInvoke* |
| CTfPyLock | Convenience class for accessing the Python Global Interpreter Lock |
| CTfPyMapToDictionary | A boost::python result converter generator which converts standard library maps to dictionaries |
| CTfPyMethodResult | A reimplementation of boost::python::detail::method_result |
| ►CTfPyObjWrapper | Boost Python object wrapper |
| CTfPyOverride | A reimplementation of boost::python::override |
| CTfPyPairToTuple | A boost::python result converter generator which converts standard library pairs to tuples |
| CTfPyRaiseOnError< Base > | A boost.python call policy class which, when applied to a wrapped function, will create an error mark before calling the function, and check that error mark after the function has completed |
| CTfPySequenceToList | A boost::python result converter generator which converts standard library sequences to lists |
| CTfPySequenceToListRefPtrFactory | A boost::python result converter generator which converts standard library sequences to lists of python owned objects |
| CTfPySequenceToSet | A boost::python result converter generator which converts standard library sequences to sets |
| CTfPySequenceToTuple | A boost::python result converter generator which converts standard library sequences to tuples |
| CTfPyTraceInfo | Structure passed to python trace functions |
| CTfPyWrapEnum< T, IsScopedEnum > | Used to wrap enum types for script |
| ►CTfRefBase | Enable a concrete base class for use with TfRefPtr |
| CGarchGLPlatformDebugContext | Platform specific context (e.g |
| CGlfDrawTarget | A class representing a GL render target with mutliple image attachments |
| CGlfDrawTarget::AttachmentsContainer | Weak/Ref-based container for the the map of texture attachments |
| CGlfTexture | Represents a texture object in Glf |
| CGlfUniformBlock | Manages a GL uniform buffer object |
| ►CHdSceneIndexBase | Abstract interface to scene data |
| ►CHdFilteringSceneIndexBase | An abstract base class for scene indexes that have one or more input scene indexes which serve as a basis for their own scene |
| CHdMergingSceneIndex | Merges multiple scenes together |
| ►CHdSingleInputFilteringSceneIndexBase | An abstract base class for a filtering scene index that observes a single input scene index |
| CHdFlatteningSceneIndex | A scene index that observes an input scene index and produces a comparable scene in which inherited state is represented at leaf prims |
| CHdGpGenerativeProceduralResolvingSceneIndex | HdGpGenerativeProceduralResolvingSceneIndex is a scene index which evaluates prims representing generative procedurals within its incoming scene and outputs their resulting prims its own observers |
| ►CHdMaterialFilteringSceneIndexBase | Base class for implementing scene indices which read from and write to only material network data sources |
| CHdsiTerminalsResolvingSceneIndex | SceneIndex that "resolves" terminals by renaming them from their context specific names (i.e |
| CHdPrefixingSceneIndex | A prefixing scene index is one in which the input scene contains data sources whose paths are all prefixed with a given prefix |
| CHdSiExtComputationPrimvarPruningSceneIndex | Hydra ExtComputations provide a simple computation framework allowing primvars to be computed using CPU or GPU kernels |
| CHdsiImplicitSurfaceSceneIndex | The implicit surface scene index can be "configured" to either generate the mesh for a given implicit primitive (for renderers that don't natively support it) or overload the transform to account for a different "spine" axis (relevant for cones, capsules and cylinders) for those that do |
| CHdsiMaterialBindingResolvingSceneIndex | Scene Index that resolves materialBindings that have multiple purposes into a single purpose |
| CHdsiMaterialPrimvarTransferSceneIndex | Transfers primvars present on the locally bound material |
| CHdsiPinnedCurveExpandingSceneIndex | Pinned curves are a special case of non-periodic cubic curves (relevant only for BSpline and CatmullRom basis) where the authored intent is for each curve to begin and end at its first and last control points respectively |
| CUsdImagingDrawModeSceneIndex | A scene index replacing geometry based on the draw mode |
| CUsdImagingRerootingSceneIndex | UsdImagingRerootingSceneIndex |
| CUsdImagingSelectionSceneIndex | A simple scene index adding HdSelectionsSchema to all prims selected with AddSelection |
| CUsdImagingNiPrototypePropagatingSceneIndex | A scene index implementing USD native instancing |
| CUsdImagingPiPrototypePropagatingSceneIndex | A scene index translating USD point instancers into Hydra instancers |
| ►CHdRetainedSceneIndex | Concrete scene container which can be externally populated and dirtied |
| CHdLegacyPrimSceneIndex | Extends HdRetainedSceneIndex to instantiate and dirty HdDataSourceLegacyPrim data sources |
| ►CNdrDiscoveryPlugin | Interface for discovery plugins |
| C_NdrFilesystemDiscoveryPlugin | Discovers nodes on the filesystem |
| CNdrDiscoveryPluginContext | A context for discovery |
| CPcpLayerStack | Represents a stack of layers that contribute opinions to composition |
| CPlugPlugin | Defines an interface to registered plugins |
| ►CSdfAbstractData | Interface for scene description data storage |
| CSdfData | SdfData provides concrete scene description data storage |
| ►CSdfFileFormat | Base class for file format implementations |
| ►CSdfTextFileFormat | Sdf text file format |
| CUsdUsdaFileFormat | File format used by textual USD files |
| CUsdUsdcFileFormat | File format for binary Usd files |
| CUsdUsdFileFormat | File format for USD files |
| CUsdUsdzFileFormat | File format for package .usdz files |
| CSdfLayer | A scene description container that can combine with other such containers to form simple component assets, and successively larger aggregates |
| ►CSdfLayerStateDelegateBase | Maintains authoring state information for an associated layer |
| CSdfSimpleLayerStateDelegate | A layer state delegate that simply records whether any changes have been made to a layer |
| CSdfLayerTree | A SdfLayerTree is an immutable tree structure representing a sublayer stack and its recursive structure |
| CTfSimpleRefBase | Enable a concrete base class for use with TfRefPtr that inhibits the "unique changed" facility of TfRefPtr |
| CTraceAggregateNode | A representation of a call tree |
| CTraceAggregateTree | A representation of a call tree |
| CTraceEventNode | TraceEventNode is used to represents call tree of a trace |
| CTraceEventTree | This class contains a timeline call tree and a map of counters to their values over time |
| ►CTraceReporterBase | This class is a base class for report implementations |
| CTraceReporter | This class converts streams of TraceEvent objects into call trees which can then be used as a data source to a GUI or written out to a file |
| CUsdStage | The outermost container for scene description, which owns and presents composed prims as a scenegraph, following the composition recipe recursively described in its associated "root layer" |
| CTfRefCount | Reference counter class |
| CTfRefPtr< T > | Reference-counted smart pointer utility class |
| CTfRefPtr< GlfDrawTarget::AttachmentsContainer > | |
| CTfRefPtr< SdfLayer > | |
| CTfRefPtr< SdfLayerTree > | |
| CTfRegistryManager | Manage initialization of registries |
| CTfRegTest | TfRegTest is a singleton class, which is used to register functions with either type bool bool and taking no arguments |
| CTfSafeOutputFile | Opens a file for output, either for update "r+" or to completely replace "w+" |
| CTfScoped< T > | Execute code on exiting scope |
| CTfScopedAutoVar | Reset variable on exiting scope |
| CTfScopeDescription | This class is used to provide high-level descriptions about scopes of execution that could possibly block, or to provide relevant information about high-level action that would be useful in a crash report |
| CTfScopedVar< T > | Reset variable on exiting scope |
| CTfSingleton< T > | Manage a single instance of an object (see |
| ►CTfSingleton< HdSceneIndexNameRegistry > | |
| CHdSceneIndexNameRegistry | A registry containing named instances of Hydra indexes |
| ►CTfSingleton< HioImageRegistry > | |
| CHioImageRegistry | Manages plugin registration and loading for HioImage subclasses |
| ►CTfSingleton< UsdImagingAdapterRegistry > | |
| CUsdImagingAdapterRegistry | Registry of PrimAdapter plug-ins |
| CTfSizeofType< T > | Metafunction returning sizeof(T) for a type T (or 0 if T is a void type) |
| CTfSkipCallerFrames | This structure is used to indicate that some number of caller frames should be skipped when capturing exception stack traces at the throw point |
| CTfSmallVector< T, N > | This is a small-vector class with local storage optimization, the local storage can be specified via a template parameter, and expresses the number of entries the container can store locally |
| CTfSmallVector< _APISchemaEntry, 8 > | |
| CTfSmallVector< _SamplePair, 6 > | |
| CTfSmallVector< AddedPrimEntry, 16 > | |
| CTfSmallVector< DirtiedPrimEntry, 16 > | |
| CTfSmallVector< float, CAPACITY > | |
| CTfSmallVector< GfMatrix4d, CAPACITY > | |
| CTfSmallVector< HdContainerDataSourceHandle, 8 > | |
| CTfSmallVector< HdDataSourceBaseHandle, 32 > | |
| CTfSmallVector< HdDataSourceLocator, 4 > | |
| CTfSmallVector< HdDataSourceLocator, 8 > | |
| CTfSmallVector< RemovedPrimEntry, 16 > | |
| CTfSmallVector< std::pair< SdfPath, Entry >, 1 > | |
| CTfSmallVector< std::pair< TfToken, InfoChange >, 3 > | |
| CTfSmallVector< TfToken, 6 > | |
| CTfSmallVector< TYPE, CAPACITY > | |
| CTfSmallVector< VtIntArray, CAPACITY > | |
| CTfSpan< T > | Represents a range of contiguous elements |
| CTfSpinRWMutex | This class implements a readers-writer spin lock that emphasizes throughput when there is light contention or moderate contention dominated by readers |
| CTfStacked< Derived, PerThread, Holder > | A TfStacked is used where a class needs to keep a stack of the objects currently in existence |
| CTfStackedAccess | Classes that derive TfStacked may befriend TfStackedAccess if they wish to customize aspects TfStacked's behavior |
| CTfStaticData< T, Factory > | Create or return a previously created object instance of global data |
| CTfStaticData< _NodeMap > | |
| CTfStopwatch | Low-cost, high-resolution timer datatype |
| CTfStreamDouble | A type which offers streaming for doubles in a canonical format that can safely roundtrip with the minimal number of digits |
| CTfStreamFloat | A type which offers streaming for floats in a canonical format that can safely roundtrip with the minimal number of digits |
| CTfTemplateString | TfTemplateString provides simple string substitutions based on named placeholders |
| CTfToken | Token for efficient comparison, assignment, and hashing of known strings |
| CTfTokenFastArbitraryLessThan | Fast but non-lexicographical (in fact, arbitrary) less-than comparison for TfTokens |
| CTfType | TfType represents a dynamic runtime type |
| CTfTypeFunctions< T, ENABLE > | Implements assorted functions based on compile-time type information |
| CTfTypeInfoMap< VALUE > | A map whose key is a const std::type_info&, or a string alias |
| CTfTypePythonClass | A boost.python visitor that associates the Python class object created by the wrapping with the TfType of the C++ type being wrapped |
| ►CTfWeakBase | Enable a concrete base class for use with TfWeakPtr |
| CGarchGLPlatformDebugContext | Platform specific context (e.g |
| CGlfDrawTarget | A class representing a GL render target with mutliple image attachments |
| CGlfDrawTarget::AttachmentsContainer | Weak/Ref-based container for the the map of texture attachments |
| CGlfTexture | Represents a texture object in Glf |
| CGlfUniformBlock | Manages a GL uniform buffer object |
| CHdSceneIndexBase | Abstract interface to scene data |
| ►CHdSceneIndexObserver | Observer of scene data |
| CHdSceneIndexAdapterSceneDelegate | Scene delegate which observes notices from an HdSceneIndex and applies them to an HdRenderIndex |
| CHdxSelectionSceneIndexObserver | Queries each prim of the given scene index for the HdSelectionsSchema to compute a HdSelection |
| CHgiGLTexture | Represents a OpenGL GPU texture resource |
| CKindRegistry | A singleton that holds known kinds and information about them |
| CNdrDiscoveryPlugin | Interface for discovery plugins |
| CNdrDiscoveryPluginContext | A context for discovery |
| ►CNdrParserPlugin | Interface for parser plugins |
| CUsdShadeShaderDefParserPlugin | Parses shader definitions represented using USD scene description using the schemas provided by UsdShade |
| ►CNdrRegistry | The registry provides access to node information |
| CSdrRegistry | The shading-specialized version of NdrRegistry |
| CPcpLayerStack | Represents a stack of layers that contribute opinions to composition |
| CPlugPlugin | Defines an interface to registered plugins |
| CPlugRegistry | Defines an interface for registering plugins |
| CSdfAbstractData | Interface for scene description data storage |
| CSdfFileFormat | Base class for file format implementations |
| CSdfLayer | A scene description container that can combine with other such containers to form simple component assets, and successively larger aggregates |
| CSdfLayerStateDelegateBase | Maintains authoring state information for an associated layer |
| CSdfLayerTree | A SdfLayerTree is an immutable tree structure representing a sublayer stack and its recursive structure |
| ►CSdfSchemaBase | Generic class that provides information about scene description fields but doesn't actually provide any fields |
| CSdfSchema | Class that provides information about the various scene description fields |
| CTfDiagnosticMgr | Singleton class through which all errors and diagnostics pass |
| CTfNotice::Probe | Probe interface class which may be implemented and then registered via InsertProbe to introspect about notices as they are sent and delivered |
| CTfRefPtrTracker | Provides tracking of TfRefPtr objects to particular objects |
| CTfScriptModuleLoader | Provides low-level facilities for shared libraries with script bindings to register themselves with their dependences, and provides a mechanism whereby those script modules will be loaded when necessary |
| CTraceAggregateNode | A representation of a call tree |
| CTraceAggregateTree | A representation of a call tree |
| CTraceCollector | This is a singleton class that records TraceEvent instances and populates TraceCollection instances |
| CTraceEventTree | This class contains a timeline call tree and a map of counters to their values over time |
| CTraceReporterBase | This class is a base class for report implementations |
| CTraceReporterDataSourceCollector | This class is an implementation of TraceReporterDataSourceBase which retrieves TraceCollections from the TraceCollector singleton |
| CUsdImagingDelegate | The primary translation layer between the Hydra (Hd) core and the Usd scene graph |
| CUsdSchemaRegistry | Singleton registry that provides access to schema type information and the prim definitions for registered Usd "IsA" and applied API schema types |
| CUsdStage | The outermost container for scene description, which owns and presents composed prims as a scenegraph, following the composition recipe recursively described in its associated "root layer" |
| CTfWeakPtr< T > | Pointer storage with deletion detection |
| CTfWeakPtr< _DelivererBase > | |
| CTfWeakPtrFacadeAccess | This access class is befriended by TfWeakPtrFacade -derived classes to grant TfWeakPtrFacade access to specific internal functions provided by the derived classes |
| CUsdMediaAssetPreviewsAPI::Thumbnails | Thumbnails is a value type that serves as schema to aid in serialization and deserialization of thumbnail images in the assetInfo["thumbnails"] dictionary |
| CTfRefPtrTracker::Trace | A track trace |
| CTraceAuto | A class which records a begin event when it is constructed, and a matching end event when it is destructed |
| CTraceCategory | This singleton class provides a way to mark TraceEvent instances with category Ids which can be used to filter them |
| CTraceCollection | This class owns lists of TraceEvent instances per thread, and allows read access to them |
| CTraceConcurrentList< T > | This class supports thread safe insertion and iteration over a list of items |
| CTraceConcurrentList< _PerThreadData > | |
| CTraceCounterHolder | Holds on to a counter key, as well as the global collector for fast lookup |
| CTraceDataBuffer | This class stores copies of data that are associated with TraceEvent instances |
| CTraceDynamicKey | This class stores data used to create dynamic keys which can be referenced in TraceEvent instances |
| CTraceEvent | This represents an event recorded by a TraceCollector |
| CTraceEventContainer | Holds TraceEvent instances |
| CTraceEventData | This class holds data that can be stored in TraceEvents |
| CTraceEventList | This class represents an ordered collection of TraceEvents and the TraceDynamicKeys and data that the events reference |
| CTraceKey | A wrapper around a TraceStaticKeyData pointer that is stored in TraceEvent instances |
| ►CTraceReporterDataSourceBase | This class is a base class for TraceReporterBase data sources |
| CTraceReporterDataSourceCollection | This class is an implementation of TraceReporterDataSourceBase which provides access to a set number of TraceCollection instances |
| CTraceReporterDataSourceCollector | This class is an implementation of TraceReporterDataSourceBase which retrieves TraceCollections from the TraceCollector singleton |
| CTraceScopeAuto | A class which records a timestamp when it is created and a scope event when it is destructed |
| CTraceSerialization | This class contains methods to read and write TraceCollection |
| CTraceStaticKeyData | This class holds data necessary to create keys for TraceEvent instances |
| CTraceStringHash | This class provides a function to compute compile time hashes for string literals |
| CTraceThreadId | This class represents an identifier for a thread |
| Ctype_count< T, Enable > | This will only trigger for actual void type |
| Ctype_count< T, typename std::enable_if< is_complex< T >::value >::type > | Type size for complex since it sometimes looks like a wrapper |
| Ctype_count< T, typename std::enable_if< is_mutable_container< T >::value >::type > | Type size of types that are wrappers,except complex and tuples(which can also be wrappers sometimes) |
| Ctype_count< T, typename std::enable_if< is_wrapper< T >::value &&!is_complex< T >::value &&!is_tuple_like< T >::value &&!is_mutable_container< T >::value >::type > | Type size of types that are wrappers,except containers complex and tuples(which can also be wrappers sometimes) |
| Ctype_count< T, typename std::enable_if<!is_wrapper< T >::value &&!is_tuple_like< T >::value &&!is_complex< T >::value &&!std::is_void< T >::value >::type > | Type size for regular object types that do not look like a tuple |
| Ctype_count_base< T, Enable > | This will only trigger for actual void type |
| Ctype_count_base< T, typename std::enable_if< is_mutable_container< T >::value >::type > | Type count base for containers is the type_count_base of the individual element |
| Ctype_count_base< T, typename std::enable_if< is_tuple_like< T >::value &&!is_mutable_container< T >::value >::type > | Base tuple size |
| Ctype_count_base< T, typename std::enable_if<!is_tuple_like< T >::value &&!is_mutable_container< T >::value &&!std::is_void< T >::value >::type > | Type size for regular object types that do not look like a tuple |
| CUsdAppUtilsFrameRecorder | A utility class for recording images of USD stages |
| CUsdAttributeQuery | Object for efficiently making repeated queries for attribute values |
| CUsdCollectionMembershipQuery | Represents a flattened view of a collection |
| CUsdCrateInfo | A class for introspecting the underlying qualities of .usdc 'crate' files, for diagnostic purposes |
| CUsdEditContext | A utility class to temporarily modify a stage's current EditTarget during an execution scope |
| CUsdEditTarget | Defines a mapping from scene graph paths to Sdf spec paths in a SdfLayer where edits should be directed, or up to where to perform partial composition |
| CUsdGeomBBoxCache | Caches bounds by recursively computing and aggregating bounds of children in world space and aggregating the result back into local space |
| CUsdGeomConstraintTarget | Schema wrapper for UsdAttribute for authoring and introspecting attributes that are constraint targets |
| CUsdGeomLinearUnits | Container class for static double-precision symbols representing common units of measure expressed in meters |
| CUsdGeomPrimvar | Schema wrapper for UsdAttribute for authoring and introspecting attributes that are primvars |
| CUsdGeomTokensType | UsdGeomTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdGeomXformCache | A caching mechanism for transform matrices |
| CUsdGeomXformOp | Schema wrapper for UsdAttribute for authoring and computing transformation operations, as consumed by UsdGeomXformable schema |
| CUsdHydraTokensType | UsdHydraTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdImagingAPISchemaAdapter | Base class for all API schema adapters |
| CUsdImagingDataSourceAttribute< T > | A data source that represents a USD Attribute |
| CUsdImagingDataSourcePointInstancer | A data source representing the UsdGeom PointInstancer prim |
| CUsdImagingDataSourceStageGlobals | This class is used as a context object with global stage information, that gets passed down to datasources to help them answer scene queries |
| CUsdImagingGLEngine | The UsdImagingGLEngine is the main entry point API for rendering USD scenes |
| CUsdImagingGLRenderParams | Used as an arguments class for various methods in UsdImagingGLEngine |
| CUsdImagingIndexProxy | This proxy class exposes a subset of the private Delegate API to PrimAdapters |
| CUsdImagingInstancerContext | Object used by instancer prim adapters to pass along context about the instancer and instance prim to prototype prim adapters |
| ►CUsdImagingPrimAdapter | Base class for all PrimAdapters |
| CUsdImagingCameraAdapter | Delegate support for UsdGeomCamera |
| CUsdImagingDisplayFilterAdapter | Delegate support for Display Filter Prims |
| CUsdImagingDrawModeAdapter | Delegate support for the drawMode attribute on UsdGeomModelAPI |
| ►CUsdImagingFieldAdapter | Base class for all USD fields |
| CUsdImagingField3DAssetAdapter | Adapter class for fields of type Field3DAsset |
| CUsdImagingOpenVDBAssetAdapter | Adapter class for fields of type OpenVDBAsset |
| ►CUsdImagingGprimAdapter | Delegate support for UsdGeomGrims |
| CUsdImagingBasisCurvesAdapter | Delegate support for UsdGeomBasisCurves |
| CUsdImagingCapsuleAdapter | Delegate support for UsdGeomCapsule |
| CUsdImagingConeAdapter | Delegate support for UsdGeomCone |
| CUsdImagingCubeAdapter | Delegate support for UsdGeomCube |
| CUsdImagingCylinderAdapter | Delegate support for UsdGeomCylinder |
| CUsdImagingHermiteCurvesAdapter | Delegate support for UsdGeomHermiteCurves |
| CUsdImagingMeshAdapter | Delegate support for UsdGeomMesh |
| CUsdImagingNurbsCurvesAdapter | Delegate support for UsdGeomNurbsCurves |
| CUsdImagingNurbsPatchAdapter | Delegate support for UsdGeomNurbsPatch |
| CUsdImagingPlaneAdapter | Delegate support for UsdGeomPlane |
| CUsdImagingPointsAdapter | Delegate support for UsdGeomPoints |
| CUsdImagingSphereAdapter | Delegate support for UsdGeomSphere |
| CUsdImagingVolumeAdapter | Delegate support for UsdVolVolume |
| CUsdImagingInstanceAdapter | Delegate support for instanced prims |
| ►CUsdImagingLightAdapter | Base class for all lights |
| CUsdImagingCylinderLightAdapter | Adapter class for lights of type CylinderLight |
| CUsdImagingDiskLightAdapter | Adapter class for lights of type DiskLight |
| CUsdImagingDistantLightAdapter | Adapter class for lights of type DistantLight |
| CUsdImagingDomeLightAdapter | Adapter class for lights of type DomeLight |
| CUsdImagingGeometryLightAdapter | Adapter class for lights of type GeometryLight |
| CUsdImagingPluginLightAdapter | Adapter class for lights of type PluginLight |
| CUsdImagingPortalLightAdapter | Adapter class for lights of type PortalLight |
| CUsdImagingRectLightAdapter | Adapter class for lights of type RectLight |
| CUsdImagingSphereLightAdapter | Adapter class for lights of type SphereLight |
| ►CUsdImagingLightFilterAdapter | Base class for all light filters |
| CUsdImagingPluginLightFilterAdapter | Adapter class for lights of type PluginLightFilter |
| CUsdRiImagingPxrBarnLightFilterAdapter | Adapter class for lights of type PxrBarnLightFilter |
| CUsdRiImagingPxrIntMultLightFilterAdapter | Adapter class for lights of type PxrIntMultLightFilter |
| CUsdRiImagingPxrRodLightFilterAdapter | Adapter class for lights of type PxrRodLightFilter |
| CUsdImagingMaterialAdapter | Provides information that can be used to generate a material |
| CUsdImagingPointInstancerAdapter | Delegate support for UsdGeomPointInstancer |
| CUsdImagingRenderSettingsAdapter | Delegate support for UsdRenderSettings |
| ►CUsdImagingRepresentedByAncestorPrimAdapter | Base class for all prim adapters which only want to indicate that an ancestor prim is responsible for them |
| CUsdImagingShaderAdapter | Delegates invalidation responsibility of a Shader prim to an ancestor Material prim |
| CUsdImagingSampleFilterAdapter | Delegate support for Sample Filter Prims |
| CUsdImagingPrimvarDescCache | A cache for primvar descriptors |
| CUsdImagingSkeletonAdapter | Support for drawing bones of a UsdSkelSkeleton |
| CUsdImagingSkelRootAdapter | The SkelRoot adapter exists for two reasons: (a) Registering the SkeletonAdapter to handle processing of any skinned prim under a SkelRoot prim |
| CUsdInherits | A proxy class for applying listOp edits to the inherit paths list for a prim |
| CUsdLinearInterpolationTraits< T > | Traits class describing whether a particular C++ value type supports linear interpolation |
| CUsdLuxTokensType | UsdLuxTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdMediaTokensType | UsdMediaTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdMtlxUsdTypeInfo | Result of UsdMtlxGetUsdType() |
| CUsdNotice | Container class for Usd notices |
| ►CUsdObject | Base class for Usd scenegraph objects, providing common API |
| CUsdPrim | UsdPrim is the sole persistent scenegraph object on a UsdStage, and is the embodiment of a "Prim" as described in the Universal Scene Description Composition Compendium |
| ►CUsdProperty | Base class for UsdAttribute and UsdRelationship scenegraph objects |
| CUsdAttribute | Scenegraph object for authoring and retrieving numeric, string, and array valued data, sampled over time |
| CUsdRelationship | A UsdRelationship creates dependencies between scenegraph objects by allowing a prim to target other prims, attributes, or relationships |
| CUsdPayloads | UsdPayloads provides an interface to authoring and introspecting payloads |
| CUsdPhysicsMassProperties | Mass properties computation class |
| CUsdPhysicsMassUnits | Container class for static double-precision symbols representing common mass units of measure expressed in kilograms |
| CUsdPhysicsTokensType | UsdPhysicsTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdPrimCompositionQuery | Object for making optionally filtered composition queries about a prim |
| CUsdPrimCompositionQueryArc | This represents a composition arc that is returned by a UsdPrimCompositionQuery |
| CUsdPrimDefinition | Class representing the builtin definition of a prim given the schemas registered in the schema registry |
| CUsdPrimRange | An forward-iterable range that traverses a subtree of prims rooted at a given prim in depth-first order |
| CUsdPrimSiblingIterator | Forward traversal iterator of sibling UsdPrim s |
| CUsdPrimSiblingRange | Forward iterator range of sibling UsdPrim s |
| CUsdPrimSubtreeIterator | Forward traversal iterator of sibling UsdPrim s |
| CUsdPrimSubtreeRange | Forward iterator range of sibling UsdPrim s |
| CUsdPrimTypeInfo | Class that holds the full type information for a prim |
| CUsdProcTokensType | UsdProcTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdReferences | UsdReferences provides an interface to authoring and introspecting references in Usd |
| CUsdRenderSpec | A self-contained specification of render settings |
| CUsdRenderTokensType | UsdRenderTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdResolveInfo | Container for information about the source of an attribute's value, i.e |
| CUsdResolveTarget | Defines a subrange of nodes and layers within a prim's prim index to consider when performing value resolution for the prim's attributes |
| CUsdRiTokensType | UsdRiTokens provides static, efficient TfTokens for use in all public USD API |
| ►CUsdSchemaBase | The base class for all schema types in Usd |
| ►CUsdAPISchemaBase | The base class for all API schemas |
| CUsdClipsAPI | UsdClipsAPI is an API schema that provides an interface to a prim's clip metadata |
| CUsdCollectionAPI | This is a general purpose API schema, used to describe a collection of heterogeneous objects within the scene |
| CUsdGeomModelAPI | UsdGeomModelAPI extends the generic UsdModelAPI schema with geometry specific concepts such as cached extents for the entire model, constraint targets, and geometry-inspired extensions to the payload lofting process |
| CUsdGeomMotionAPI | UsdGeomMotionAPI encodes data that can live on any prim that may affect computations involving: |
| CUsdGeomPrimvarsAPI | UsdGeomPrimvarsAPI encodes geometric "primitive variables", as UsdGeomPrimvar, which interpolate across a primitive's topology, can override shader inputs, and inherit down namespace |
| CUsdGeomVisibilityAPI | UsdGeomVisibilityAPI introduces properties that can be used to author visibility opinions |
| CUsdGeomXformCommonAPI | This class provides API for authoring and retrieving a standard set of component transformations which include a scale, a rotation, a scale-rotate pivot and a translation |
| CUsdHydraGenerativeProceduralAPI | This API extends and configures the core UsdProcGenerativeProcedural schema defined within usdProc for use with hydra generative procedurals as defined within hdGp |
| CUsdLuxLightAPI | API schema that imparts the quality of being a light onto a prim |
| CUsdLuxLightListAPI | API schema to support discovery and publishing of lights in a scene |
| CUsdLuxListAPI | |
| CUsdLuxMeshLightAPI | This is the preferred API schema to apply to Mesh type prims when adding light behaviors to a mesh |
| CUsdLuxShadowAPI | Controls to refine a light's shadow behavior |
| CUsdLuxShapingAPI | Controls for shaping a light's emission |
| CUsdLuxVolumeLightAPI | This is the preferred API schema to apply to Volume type prims when adding light behaviors to a volume |
| CUsdMediaAssetPreviewsAPI | AssetPreviewsAPI is the interface for authoring and accessing precomputed, lightweight previews of assets |
| CUsdModelAPI | UsdModelAPI is an API schema that provides an interface to a prim's model qualities, if it does, in fact, represent the root prim of a model |
| CUsdPhysicsArticulationRootAPI | PhysicsArticulationRootAPI can be applied to a scene graph node, and marks the subtree rooted here for inclusion in one or more reduced coordinate articulations |
| CUsdPhysicsCollisionAPI | Applies collision attributes to a UsdGeomXformable prim |
| CUsdPhysicsDriveAPI | The PhysicsDriveAPI when applied to any joint primitive will drive the joint towards a given target |
| CUsdPhysicsFilteredPairsAPI | API to describe fine-grained filtering |
| CUsdPhysicsLimitAPI | The PhysicsLimitAPI can be applied to a PhysicsJoint and will restrict the movement along an axis |
| CUsdPhysicsMassAPI | Defines explicit mass properties (mass, density, inertia etc.) |
| CUsdPhysicsMaterialAPI | Adds simulation material properties to a Material |
| CUsdPhysicsMeshCollisionAPI | Attributes to control how a Mesh is made into a collider |
| CUsdPhysicsRigidBodyAPI | Applies physics body attributes to any UsdGeomXformable prim and marks that prim to be driven by a simulation |
| CUsdRiMaterialAPI | |
| CUsdRiSplineAPI | |
| CUsdRiStatementsAPI | Container namespace schema for all renderman statements |
| CUsdShadeConnectableAPI | UsdShadeConnectableAPI is an API schema that provides a common interface for creating outputs and making connections between shading parameters and outputs |
| CUsdShadeCoordSysAPI | UsdShadeCoordSysAPI provides a way to designate, name, and discover coordinate systems |
| CUsdShadeMaterialBindingAPI | UsdShadeMaterialBindingAPI is an API schema that provides an interface for binding materials to prims or collections of prims (represented by UsdCollectionAPI objects) |
| CUsdShadeNodeDefAPI | UsdShadeNodeDefAPI is an API schema that provides attributes for a prim to select a corresponding Shader Node Definition ("Sdr Node"), as well as to look up a runtime entry for that shader node in the form of an SdrShaderNode |
| CUsdSkelBindingAPI | Provides API for authoring and extracting all the skinning-related data that lives in the "geometry hierarchy" of prims and models that want to be skeletally deformed |
| CUsdUINodeGraphNodeAPI | This api helps storing information about nodes in node graphs |
| CUsdUISceneGraphPrimAPI | Utility schema for display properties of a prim |
| ►CUsdTyped | The base class for all typed schemas (those that can impart a typeName to a UsdPrim), and therefore the base class for all instantiable and "IsA" schemas |
| ►CUsdGeomImageable | Base class for all prims that may require rendering or visualization of some sort |
| CUsdGeomScope | Scope is the simplest grouping primitive, and does not carry the baggage of transformability |
| ►CUsdGeomXformable | Base class for all transformable prims, which allows arbitrary sequences of component affine transformations to be encoded |
| ►CUsdGeomBoundable | Boundable introduces the ability for a prim to persistently cache a rectilinear, local-space, extent |
| ►CUsdGeomGprim | Base class for all geometric primitives |
| CUsdGeomCapsule | Defines a primitive capsule, i.e |
| CUsdGeomCone | Defines a primitive cone, centered at the origin, whose spine is along the specified axis, with the apex of the cone pointing in the direction of the positive axis |
| CUsdGeomCube | Defines a primitive rectilinear cube centered at the origin |
| CUsdGeomCylinder | Defines a primitive cylinder with closed ends, centered at the origin, whose spine is along the specified axis |
| CUsdGeomPlane | Defines a primitive plane, centered at the origin, and is defined by a cardinal axis, width, and length |
| ►CUsdGeomPointBased | Base class for all UsdGeomGprims that possess points, providing common attributes such as normals and velocities |
| ►CUsdGeomCurves | Base class for UsdGeomBasisCurves, UsdGeomNurbsCurves, and UsdGeomHermiteCurves |
| CUsdGeomBasisCurves | BasisCurves are a batched curve representation analogous to the classic RIB definition via Basis and Curves statements |
| CUsdGeomHermiteCurves | This schema specifies a cubic hermite interpolated curve batch as sometimes used for defining guides for animation |
| CUsdGeomNurbsCurves | This schema is analagous to NURBS Curves in packages like Maya and Houdini, often used for interchange of rigging and modeling curves |
| CUsdGeomMesh | Encodes a mesh with optional subdivision properties and features |
| CUsdGeomNurbsPatch | Encodes a rational or polynomial non-uniform B-spline surface, with optional trim curves |
| CUsdGeomPoints | Points are analogous to the RiPoints spec |
| CUsdGeomSphere | Defines a primitive sphere centered at the origin |
| CUsdVolVolume | A renderable volume primitive |
| CUsdGeomPointInstancer | Encodes vectorized instancing of multiple, potentially animated, prototypes (object/instance masters), which can be arbitrary prims/subtrees on a UsdStage |
| ►CUsdLuxBoundableLightBase | Base class for intrinsic lights that are boundable |
| CUsdLuxCylinderLight | Light emitted outward from a cylinder |
| CUsdLuxDiskLight | Light emitted from one side of a circular disk |
| CUsdLuxPortalLight | A rectangular portal in the local XY plane that guides sampling of a dome light |
| CUsdLuxRectLight | Light emitted from one side of a rectangle |
| CUsdLuxSphereLight | Light emitted outward from a sphere |
| CUsdProcGenerativeProcedural | Represents an abstract generative procedural prim which delivers its input parameters via properties (including relationships) within the "primvars:" namespace |
| CUsdSkelRoot | Boundable prim type used to identify a scope beneath which skeletally-posed primitives are defined |
| CUsdSkelSkeleton | Describes a skeleton |
| CUsdGeomCamera | Transformable camera |
| CUsdGeomXform | Concrete prim schema for a transform, which implements Xformable |
| ►CUsdLuxLightFilter | A light filter modifies the effect of a light |
| CUsdLuxPluginLightFilter | Light filter that provides properties that allow it to identify an external SdrShadingNode definition, through UsdShadeNodeDefAPI, that can be provided to render delegates without the need to provide a schema definition for the light filter's type |
| ►CUsdLuxNonboundableLightBase | Base class for intrinsic lights that are not boundable |
| CUsdLuxDistantLight | Light emitted from a distant source along the -Z axis |
| CUsdLuxDomeLight | Light emitted inward from a distant external environment, such as a sky or IBL light probe |
| CUsdLuxGeometryLight | |
| CUsdLuxPluginLight | Light that provides properties that allow it to identify an external SdrShadingNode definition, through UsdShadeNodeDefAPI, that can be provided to render delegates without the need to provide a schema definition for the light's type |
| CUsdMediaSpatialAudio | The SpatialAudio primitive defines basic properties for encoding playback of an audio file or stream within a USD Stage |
| ►CUsdVolFieldBase | Base class for field primitives |
| ►CUsdVolFieldAsset | Base class for field primitives defined by an external file |
| CUsdVolField3DAsset | Field3D field primitive |
| CUsdVolOpenVDBAsset | OpenVDB field primitive |
| ►CUsdPhysicsJoint | A joint constrains the movement of rigid bodies |
| CUsdPhysicsDistanceJoint | Predefined distance joint type (Distance between rigid bodies may be limited to given minimum or maximum distance.) |
| CUsdPhysicsFixedJoint | Predefined fixed joint type (All degrees of freedom are removed.) |
| CUsdPhysicsPrismaticJoint | Predefined prismatic joint type (translation along prismatic joint axis is permitted.) |
| CUsdPhysicsRevoluteJoint | Predefined revolute joint type (rotation along revolute joint axis is permitted.) |
| CUsdPhysicsSphericalJoint | Predefined spherical joint type (Removes linear degrees of freedom, cone limit may restrict the motion in a given range.) It allows two limit values, which when equal create a circular, else an elliptic cone limit around the limit axis |
| CUsdGeomSubset | Encodes a subset of a piece of geometry (i.e |
| CUsdPhysicsCollisionGroup | Defines a collision group for coarse filtering |
| CUsdPhysicsScene | General physics simulation properties, required for simulation |
| CUsdRenderDenoisePass | A RenderDenoisePass generates renders via a denoising process |
| CUsdRenderPass | A RenderPass prim encapsulates the necessary information to generate multipass renders |
| ►CUsdRenderSettingsBase | Abstract base class that defines render settings that can be specified on either a RenderSettings prim or a RenderProduct prim |
| CUsdRenderProduct | A UsdRenderProduct describes an image or other file-like artifact produced by a render |
| CUsdRenderSettings | A UsdRenderSettings prim specifies global settings for a render process, including an enumeration of the RenderProducts that should result, and the UsdGeomImageable purposes that should be rendered |
| CUsdRenderVar | A UsdRenderVar describes a custom data variable for a render to produce |
| ►CUsdShadeNodeGraph | A node-graph is a container for shading nodes, as well as other node-graphs |
| CUsdShadeMaterial | A Material provides a container into which multiple "render targets" can add data that defines a "shading material" for a renderer |
| CUsdShadeShader | Base class for all USD shaders |
| ►CUsdSkelAnimation | Describes a skel animation, where joint animation is stored in a vectorized form |
| CUsdSkelPackedJointAnimation | Deprecated |
| CUsdSkelBlendShape | Describes a target blend shape, possibly containing inbetween shapes |
| CUsdUIBackdrop | Provides a 'group-box' for the purpose of node graph organization |
| CUsdShadeConnectableAPIBehavior | UsdShadeConnectableAPIBehavior defines the compatibilty and behavior UsdShadeConnectableAPIof when applied to a particular prim type |
| CUsdShadeConnectionSourceInfo | A compact struct to represent a bundle of information about an upstream source attribute |
| CUsdShadeInput | This class encapsulates a shader or node-graph input, which is a connectable attribute representing a typed value |
| CUsdShadeOutput | This class encapsulates a shader or node-graph output, which is a connectable attribute representing a typed, externally computed value |
| CUsdShadeShaderDefUtils | This class contains a set of utility functions used for populating the shader registry with shaders definitions specified using UsdShade schemas |
| CUsdShadeTokensType | UsdShadeTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdShadeUtils | This class contains a set of utility functions used when authoring and querying shading networks |
| CUsdSkelAnimMap | Helper class for remapping vectorized animation data from one ordering of tokens to another |
| CUsdSkelAnimQuery | Class providing efficient queries of primitives that provide skel animation |
| CUsdSkelBakeSkinningParms | Parameters for configuring UsdSkelBakeSkinning |
| CUsdSkelBinding | Helper object that describes the binding of a skeleton to a set of skinnable objects |
| CUsdSkelBlendShapeQuery | Helper class used to resolve blend shape weights, including inbetweens |
| CUsdSkelCache | Thread-safe cache for accessing query objects for evaluating skeletal data |
| CUsdSkelInbetweenShape | Schema wrapper for UsdAttribute for authoring and introspecting attributes that serve as inbetween shapes of a UsdSkelBlendShape |
| CUsdSkelSkeletonQuery | Primary interface to reading bound skeleton data |
| CUsdSkelSkinningQuery | Object used for querying resolved bindings for skinning |
| CUsdSkelTokensType | UsdSkelTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdSkelTopology | Object holding information describing skeleton topology |
| CUsdSpecializes | A proxy class for applying listOp edits to the specializes list for a prim |
| CUsdStageCache | A strongly concurrency safe collection of UsdStageRefPtr s, enabling sharing across multiple clients and threads |
| CUsdStageCacheContext | A context object that lets the UsdStage::Open() API read from or read from and write to a UsdStageCache instance during a scope of execution |
| CUsdStageLoadRules | This class represents rules that govern payload inclusion on UsdStages |
| CUsdStagePopulationMask | This class represents a mask that may be applied to a UsdStage to limit the set of UsdPrim s it populates |
| CUsdTimeCode | Represent a time value, which may be either numeric, holding a double value, or a sentinel value UsdTimeCode::Default() |
| CUsdTokensType | UsdTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdUITokensType | UsdUITokens provides static, efficient TfTokens for use in all public USD API |
| CUsdUtilsCoalescingDiagnosticDelegateItem | An item used in coalesced results, containing a shared component: the file/function/line number, and a set of unshared components: the call context and commentary |
| CUsdUtilsCoalescingDiagnosticDelegateSharedItem | The shared component in a coalesced result This type can be thought of as the key by which we coalesce our diagnostics |
| CUsdUtilsCoalescingDiagnosticDelegateUnsharedItem | The unshared component in a coalesced result |
| CUsdUtilsConditionalAbortDiagnosticDelegateErrorFilters | A class which represents the inclusion exclusion filters on which errors will be matched stringFilters: matching and filtering will be done on explicit string of the error/warning codePathFilters: matching and filtering will be done on errors/warnings coming from a specific usd code path |
| CUsdUtilsRegisteredVariantSet | Class that holds information about variantSets that are registered with the pipeline |
| CUsdUtilsSparseAttrValueWriter | A utility class for authoring time-varying attribute values with simple run-length encoding, by skipping any redundant time-samples |
| CUsdUtilsSparseValueWriter | Utility class that manages sparse authoring of a set of UsdAttributes |
| CUsdUtilsStageCache | Simple interface for handling a singleton usd stage cache for use by all USD clients |
| CUsdUtilsTimeCodeRange | Represents a range of UsdTimeCode values as start and end time codes and a stride value |
| CUsdVariantSet | A UsdVariantSet represents a single VariantSet in USD (e.g |
| CUsdVariantSets | UsdVariantSets represents the collection of VariantSets that are present on a UsdPrim |
| CUsdviewqHydraObserver | Abstracts pieces necessary for implementing a Hydra Scene Browser in a manner convenient for exposing to python |
| CUsdviewqUtils | Performance enhancing utilities for usdview |
| CUsdVolTokensType | UsdVolTokens provides static, efficient TfTokens for use in all public USD API |
| CUsdZipFile | Class for reading a zip file |
| CUsdZipFileWriter | Class for writing a zip file |
| ►CValidator | Some validators that are provided |
| ►CAsNumberWithUnit | Multiply a number by a factor using given mapping |
| CAsSizeValue | Converts a human-readable size string (with unit literal) to uin64_t size |
| CBound | Produce a bounded range (factory). Min and max are inclusive |
| CCheckedTransformer | Translate named items to other or a value set |
| CCustomValidator | Class wrapping some of the accessors of Validator |
| CExistingDirectoryValidator | Check for an existing directory (returns error message if check fails) |
| CExistingFileValidator | Check for an existing file (returns error message if check fails) |
| CExistingPathValidator | Check for an existing path |
| CIPV4Validator | Validate the given string is a legal ipv4 address |
| CNonexistentPathValidator | Check for an non-existing path |
| CFileOnDefaultPath | Modify a path if the file is a particular default location, can be used as Check or transform with the error return optionally disabled |
| CIsMember | Verify items are in a set |
| CRange | Produce a range (factory). Min and max are inclusive |
| CTransformer | Translate named items to other or a value set |
| CTypeValidator< DesiredType > | Validate the input as a particular type |
| CPcpMapExpression::Variable | A Variable is a mutable memory cell that holds a value |
| ►CTraceCollection::Visitor | This interface provides a way to access data a TraceCollection |
| CTraceCounterAccumulator | This class accumulates counter values from TraceCollection instances |
| CHdStMaterial::VolumeMaterialData | For volumes, the corresponding draw items do not use the HdStShaderCode produced by HdStMaterial |
| CVtArray< ELEM > | Represents an arbitrary dimensional rectangular container class |
| CVtArray< GfVec3f > | |
| CVtArray< TfToken > | |
| CVtArray< UsdSkelSkinningQuery > | |
| CVtDictionary | A map with string keys and VtValue values |
| CVtIsArray< T > | Array concept. By default, types are not arrays |
| CVtValue | Provides a container which may hold any type, and provides introspection and iteration over array types |
| CWorkDispatcher | A work dispatcher runs concurrent tasks |
| CWorkSingularTask | A WorkSingularTask runs a task in a WorkDispatcher, but never concurrently with itself |
| Cwrapped_type< T, def, Enable > | Template to get the underlying value type if it exists or use a default |
| Cwrapped_type< T, def, typename std::enable_if< is_wrapper< T >::value >::type > | Type size for regular object types that do not look like a tuple |
| CUsdGeomXformable::XformQuery | Helper class that caches the ordered vector of UsGeomXformOps that contribute to the local transformation of an xformable prim |
1.8.15