| ►NCesium3DTiles | Classes for using 3D Tiles |
| CAsset | Metadata about the entire tileset |
| ►CAvailability | An object describing the availability of a set of elements |
| CConstant | Known values for Integer indicating whether all of the elements are available (1) or all are unavailable (0) |
| CBoundingVolume | A bounding volume that encloses a tile or its content. At least one bounding volume property is required. Bounding volumes include box, region, or sphere |
| CBuffer | This class is not meant to be instantiated directly. Use Buffer instead. |
| CBufferCesium | Holds Buffer properties that are specific to the 3D Tiles loader rather than part of the 3D Tiles spec |
| CBufferSpec | A buffer is a binary blob. It is either the binary chunk of the subtree file, or an external buffer referenced by a URI |
| CBufferView | A contiguous subset of a buffer |
| CClass | A class containing a set of properties |
| ►CClassProperty | A single property of a metadata class |
| CComponentType | Known values for The datatype of the element's components. Required for SCALAR, VECN, and MATN types, and disallowed for other types |
| CType | Known values for The element type |
| CClassStatistics | Statistics about entities that conform to a class that was defined in a metadata schema |
| CContent | Metadata about the tile's content and a link to the content |
| ►CEnum | An object defining the values of an enum |
| CValueType | Known values for The type of the integer enum value |
| CEnumValue | An enum value |
| CExtension3dTilesBoundingVolumeS2 | 3D Tiles extension for S2 bounding volumes |
| CFoundMetadataProperty | Holds the details of a found property in a MetadataEntity |
| CGroupMetadata | An object containing metadata about a group |
| ►CImplicitTiling | This object allows a tile to be implicitly subdivided. Tile and content availability and metadata is stored in subtrees which are referenced externally |
| CSubdivisionScheme | Known values for A string describing the subdivision scheme used within the tileset |
| CMetadataEntity | An object containing a reference to a class from a metadata schema, and property values that conform to the properties of that class |
| CMetadataQuery | Convenience functions for querying MetadataEntity instances |
| CProperties | A dictionary object of metadata about per-feature properties |
| CPropertyStatistics | Statistics about property values |
| CPropertyTable | Properties conforming to a class, organized as property values stored in binary columnar arrays |
| ►CPropertyTableProperty | An array of binary property values. This represents one column of a property table, and contains one value of a certain property for each metadata entity |
| CArrayOffsetType | Known values for The type of values in arrayOffsets |
| CStringOffsetType | Known values for The type of values in stringOffsets |
| CSchema | An object defining classes and enums |
| CStatistics | Statistics about entities |
| CSubtree | An object describing the availability of tiles and content in a subtree, as well as availability of children subtrees. May also store metadata for available tiles and content |
| CSubtrees | An object describing the location of subtree files |
| ►CTile | A tile in a 3D Tiles tileset |
| CRefine | Known values for Specifies if additive or replacement refinement is used when traversing the tileset for rendering. This property is required for the root tile of a tileset; it is optional for all other tiles. The default is to inherit from the parent tile |
| CTileset | A 3D Tiles tileset |
| ►NCesium3DTilesContent | Classes that support loading and converting 3D Tiles tile content |
| CAssetFetcher | |
| CAssetFetcherResult | The result of an AssetFetcher::get call |
| CB3dmToGltfConverter | Converts a b3dm (Batched 3D Model) file to a glTF |
| CBinaryToGltfConverter | Converts a binary glTF model (glb) to a CesiumGltf::Model |
| CCmptToGltfConverter | Converts a cmpt (Composite) file into a glTF model |
| CGltfConverterResult | The result of converting a binary content to gltf model |
| CGltfConverters | Creates GltfConverterResult objects from a a binary content |
| CI3dmToGltfConverter | Converts an i3dm (Instanced 3D Model) file to a glTF model |
| CImplicitTilingUtilities | Helper functions for working with 3D Tiles implicit tiling |
| ►COctreeChildren | A lightweight virtual container enumerating the octree IDs of the children of a given octree tile |
| Citerator | An STL-compatible iterator over the children of an octree tile |
| CPntsToGltfConverter | Converts a pnts (Point Cloud) file to a glTF model |
| ►CQuadtreeChildren | A lightweight virtual container enumerating the quadtree IDs of the children of a given quadtree tile |
| Citerator | An STL-compatible iterator over the children of a quadtree tile |
| ►CSubtreeAvailability | Supports querying and modifying the various types of availablity information included in a Cesium3DTiles::Subtree |
| CSubtreeBufferViewAvailability | An AvailabilityView that accesses availability information from a bitstream |
| CSubtreeConstantAvailability | An AvailibilityView that indicates that either all tiles are available or all tiles are unavailable |
| CTileBoundingVolumes | Provides functions for extracting bounding volumes types from the vectors stored in Cesium3DTiles::BoundingVolume |
| CTileTransform | Convenience functions for getting and setting Cesium3DTiles::Tile::transform as a glm::dmat4 |
| ►NCesium3DTilesReader | Classes for reading 3D Tiles |
| CAssetReader | Reads Asset instances from JSON |
| CAvailabilityReader | Reads Availability instances from JSON |
| CBoundingVolumeReader | Reads BoundingVolume instances from JSON |
| CBufferReader | Reads Buffer instances from JSON |
| CBufferViewReader | Reads BufferView instances from JSON |
| CClassPropertyReader | Reads ClassProperty instances from JSON |
| CClassReader | Reads Class instances from JSON |
| CClassStatisticsReader | Reads ClassStatistics instances from JSON |
| CContentReader | Reads Content instances from JSON |
| CEnumReader | Reads Enum instances from JSON |
| CEnumValueReader | Reads EnumValue instances from JSON |
| CExtension3dTilesBoundingVolumeS2Reader | Reads Extension3dTilesBoundingVolumeS2 instances from JSON |
| CGroupMetadataReader | Reads GroupMetadata instances from JSON |
| CImplicitTilingReader | Reads ImplicitTiling instances from JSON |
| CMetadataEntityReader | Reads MetadataEntity instances from JSON |
| CPropertiesReader | Reads Properties instances from JSON |
| CPropertyStatisticsReader | Reads PropertyStatistics instances from JSON |
| CPropertyTablePropertyReader | Reads PropertyTableProperty instances from JSON |
| CPropertyTableReader | Reads PropertyTable instances from JSON |
| CSchemaReader | Reads Schema instances from JSON |
| CStatisticsReader | Reads Statistics instances from JSON |
| CSubtreeFileReader | Reads 3D Tiles subtrees from a binary or JSON subtree file |
| CSubtreeReader | Reads Subtree instances from JSON |
| CSubtreesReader | Reads Subtrees instances from JSON |
| CTileReader | Reads Tile instances from JSON |
| CTilesetReader | Reads Tileset instances from JSON |
| ►NCesium3DTilesSelection | Classes that implement the 3D Tiles standard |
| CCullingVolume | A culling volume, defined by four planes |
| CDebugTileStateDatabase | Helps debug the tile selection algorithm by recording the state of tiles each frame to a SQLite database |
| CEllipsoidTilesetLoader | A loader that will generate a tileset by tesselating the surface of an ellipsoid, producing a simple globe tileset without any terrain features |
| CFogDensityAtHeight | Defines the fog density at a certain height |
| CIPrepareRendererResources | When implemented for a rendering engine, allows renderer resources to be created and destroyed under the control of a Tileset |
| CITileExcluder | An interface that allows tiles to be excluded from loading and rendering when provided in TilesetOptions::excluders |
| CITilesetHeightSampler | An interface to query heights from a tileset that can do so efficiently without necessarily downloading individual tiles |
| CRasterizedPolygonsTileExcluder | When provided to TilesetOptions::excluders, uses the polygons owned by a CesiumRasterOverlays::RasterizedPolygonsOverlay to exclude tiles that are entirely inside any of the polygon from loading. This is useful when the polygons will be used for clipping |
| CRasterMappedTo3DTile | The result of applying a CesiumRasterOverlays::RasterOverlayTile to geometry |
| CRasterOverlayCollection | A collection of CesiumRasterOverlays::RasterOverlay instances that are associated with a Tileset |
| CSampleHeightResult | The result of sampling heights with Tileset::sampleHeightMostDetailed |
| CTile | A tile in a Tileset |
| CTileChildrenResult | Store the result of creating tile's children after invoking TilesetContentLoader::createTileChildren |
| CTileContent | A tile content container that can store and query the content type that is currently being owned by the tile |
| CTileEmptyContent | A content tag that indicates a tile has no content |
| CTileExternalContent | A content tag that indicates a tile content points to an external tileset. When this tile is loaded, all the tiles in the external tileset will become children of this external content tile |
| CTileIdUtilities | Utility functions related to TileID objects |
| CTileLoadInput | Store the parameters that are needed to load a tile |
| CTileLoadResult | Store the result of loading a tile content after invoking TilesetContentLoader::loadTileContent |
| CTileLoadResultAndRenderResources | |
| CTileOcclusionRendererProxy | An interface for client renderers to use to represent tile bounding volumes that should be occlusion tested |
| CTileOcclusionRendererProxyPool | A pool of TileOcclusionRendererProxy objects. Allows quick remapping of tiles to occlusion renderer proxies so new proxies do not have to be created for each new tile requesting occlusion results |
| CTileRenderContent | A content tag that indicates a tile has a glTF model content and render resources for the model |
| CTileSelectionState | A description of the state of a Tile during the rendering process |
| CTileset | A 3D Tiles tileset, used for streaming massive heterogeneous 3D geospatial datasets |
| CTilesetContentLoader | The loader interface to load the tile content |
| CTilesetContentOptions | Options for configuring the parsing of a Tileset's content and construction of Gltf models |
| CTilesetExternals | External interfaces used by a Tileset |
| CTilesetLoadFailureDetails | |
| CTilesetMetadata | Holds the metadata associated with a Tileset or an external tileset |
| CTilesetOptions | Additional options for configuring a Tileset |
| CTilesetSharedAssetSystem | Contains assets that are potentially shared across multiple Tilesets |
| CTileUnknownContent | A content tag that indicates the TilesetContentLoader does not know if a tile's content will point to a mesh content or an external tileset. The content of the tile is only known when the loader loads the tile to inspect the content |
| CViewState | The state of the view that is used during the traversal of a tileset |
| CViewUpdateResult | Reports the results of Tileset::updateView |
| ►NCesium3DTilesWriter | Classes for writing 3D Tiles |
| CSchemaWriter | Writes schemas |
| CSchemaWriterOptions | Options for how to write a schema |
| CSchemaWriterResult | The result of writing a schema with SchemaWriter::writeSchema |
| CSubtreeWriter | Writes subtrees |
| CSubtreeWriterOptions | Options for how to write a subtree |
| CSubtreeWriterResult | The result of writing a subtree with SubtreeWriter::writeSubtree |
| CTilesetWriter | Writes tilesets |
| CTilesetWriterOptions | Options for how to write a tileset |
| CTilesetWriterResult | The result of writing a tileset with TilesetWriter::writeTileset |
| ►NCesiumAsync | Classes that support asynchronous operations |
| ►NCesiumImpl | |
| CParameterizedTaskUnwrapper | |
| CAsyncSystem | A system for managing asynchronous requests and tasks |
| CCacheItem | Cache item retrieved from the cache database |
| CCacheRequest | Cache request retrieved from the cache database |
| CCacheResponse | Cache response retrieved from the cache database |
| CCachingAssetAccessor | A decorator for an IAssetAccessor that caches requests and responses in an ICacheDatabase |
| CCaseInsensitiveCompare | A case-insensitive less-then string comparison |
| CDeleteSqliteConnection | A deleter that can be used with std::unique_ptr to properly destroy a SQLite connection when it is no longer needed |
| CDeleteSqliteStatement | A deleter that can be used with std::unique_ptr to properly destroy a SQLite prepared statement when it is no longer needed |
| CFuture | A value that will be available in the future, as produced by AsyncSystem |
| CGunzipAssetAccessor | A decorator for an IAssetAccessor that automatically unzips gzipped asset responses from the underlying Asset Accessor |
| CIAssetAccessor | Provides asynchronous access to assets, usually files downloaded via HTTP |
| CIAssetRequest | An asynchronous request for an asset, usually a file downloaded via HTTP |
| CIAssetResponse | A completed response for a 3D Tiles asset |
| CICacheDatabase | Provides database storage interface to cache completed request |
| CITaskProcessor | When implemented by a rendering engine, allows tasks to be asynchronously executed in background threads |
| CNetworkAssetDescriptor | A description of an asset that can be loaded from the network using an IAssetAccessor. This includes a URL and any headers to be included in the request |
| CPromise | A promise that can be resolved or rejected by an asynchronous task |
| CPromise< void > | Specialization for promises that resolve to no value |
| CSharedAssetDepot | A depot for CesiumUtility::SharedAsset instances, which are potentially shared between multiple objects |
| CSharedFuture | A value that will be available in the future, as produced by AsyncSystem. Unlike Future, a SharedFuture allows multiple continuations to be attached, and allows SharedFuture::wait to be called multiple times |
| CSqliteCache | Cache storage using SQLITE to store completed response |
| CSqliteHelper | Helper functions for working with SQLite |
| CThreadPool | A thread pool created by AsyncSystem::createThreadPool |
| ►NCesiumGeometry | Basic geometry classes for Cesium |
| CAvailabilityAccessor | Accessor for use with AvailabilityView in order to safely obtain the contents of the view |
| CAvailabilityNode | Availability nodes wrap AvailabilitySubtree objects and link them together to form a downwardly traversable availability tree |
| CAvailabilitySubtree | The subtree data for an AvailabilityNode, containing information on tile, content, and subtree availability |
| CAvailabilityTree | A downwardly-traversable tree of AvailabilityNode objects |
| CAxisAlignedBox | An Axis-Aligned Bounding Box (AABB), where the axes of the box are aligned with the axes of the coordinate system |
| CBoundingSphere | A bounding sphere with a center and a radius |
| CConstantAvailability | An availability value that is a constant boolean value |
| CInterpolatedVertex | A structure describing a vertex that results from interpolating two other vertices |
| CIntersectionTests | Functions for computing the intersection between geometries such as rays, planes, triangles, and ellipsoids |
| COctreeAvailability | An availability tree for an octree, where availability can be stored and computed based on OctreeTileID |
| COctreeTileID | A structure serving as a unique identifier for a node in an octree |
| COctreeTilingScheme | Defines how an AxisAlignedBox is divided into octree tiles |
| COrientedBoundingBox | A bounding volume defined as a closed and convex cuboid with any orientation |
| CPlane | A plane in Hessian Normal Format |
| CQuadtreeAvailability | An availability tree for a quadtree, where availability can be stored and computed based on QuadtreeTileID |
| CQuadtreeRectangleAvailability | Manages information about the availability of tiles in a quadtree |
| CQuadtreeTileID | Uniquely identifies a node in a quadtree |
| CQuadtreeTileRectangularRange | A rectangular range of tiles at a particular level of a quadtree |
| CQuadtreeTilingScheme | Defines how a rectangular region is divided into quadtree tiles |
| CRay | A ray that extends infinitely from the provided origin in the provided direction |
| CRectangle | A 2D rectangle |
| CSubtreeBufferView | An availability value that needs to be obtained using an offset into a buffer |
| CTransforms | Coordinate system matrix constructions helpers |
| CUpsampledQuadtreeNode | A node of a tile hierarchy that was created by upsampling the tile content of a parent node |
| ►NCesiumGeospatial | Classes for geospatial computations in Cesium |
| CBoundingRegion | A bounding volume specified as a longitude/latitude bounding box and a minimum and maximum height |
| CBoundingRegionBuilder | Helper class for creating a BoundingRegion or GlobeRectangle from a set of points |
| CBoundingRegionWithLooseFittingHeights | A BoundingRegion whose heights might be very inaccurate and so distances should be estimated conservatively for level-of-detail computations |
| CCartographic | A position defined by longitude, latitude, and height |
| CCartographicPolygon | A 2D polygon expressed as a list of longitude/latitude coordinates in radians |
| CEarthGravitationalModel1996Grid | Loads and queries heights from an Earth Gravitational Model 1996 (EGM96) grid |
| CEllipsoid | A quadratic surface defined in Cartesian coordinates |
| CEllipsoidTangentPlane | A plane tangent to an Ellipsoid at a certain origin position |
| CGeographicProjection | A map projection where longitude and latitude are mapped using an Ellipsoid |
| CGlobeAnchor | Anchors an object to the globe by defining a transformation from the object's coordinate to the globe-fixed coordinate system (usually Earth-Centered, Earth-Fixed Coordinates (ECEF)) |
| CGlobeRectangle | A two-dimensional, rectangular region on a globe, specified using longitude and latitude coordinates. The region is rectangular in terms of longitude-latitude coordinates, but may be far from rectangular on the actual globe surface |
| CGlobeTransforms | Transforms between globe-related coordinate systems |
| CLocalHorizontalCoordinateSystem | A coordinate system created from a local horizontal plane at a particular origin point on the globe |
| CS2CellBoundingVolume | |
| CS2CellID | A 64-bit unsigned integer that uniquely identifies a cell in the S2 cell decomposition |
| CSimplePlanarEllipsoidCurve | Produces points on an ellipse that lies on a plane that intersects the center of the earth and each of the input coordinates. The height above the surface at each point along the curve will be a linear interpolation between the source and destination heights |
| CWebMercatorProjection | The map projection used by Google Maps, Bing Maps, and most of ArcGIS Online, EPSG:3857 |
| ►NCesiumGltf | Classes for working with glTF models |
| CAccessor | This class is not meant to be instantiated directly. Use Accessor instead. |
| CAccessorSparse | Sparse storage of accessor values that deviate from their initialization value |
| ►CAccessorSparseIndices | An object pointing to a buffer view containing the indices of deviating accessor values. The number of indices is equal to accessor.sparse.count. Indices MUST strictly increase |
| CComponentType | Known values for The indices data type |
| CAccessorSparseValues | An object pointing to a buffer view containing the deviating accessor values. The number of elements is equal to accessor.sparse.count times number of components. The elements have the same component type as the base accessor. The elements are tightly packed. Data MUST be aligned following the same rules as the base accessor |
| ►CAccessorSpec | A typed view into a buffer view that contains raw binary data |
| CComponentType | Known values for The datatype of the accessor's components |
| CType | Known values for Specifies if the accessor's elements are scalars, vectors, or matrices |
| ►CAccessorTypes | Contains types that may optionally be used with AccessorView for various Accessor::componentType values |
| CMAT2 | A 2x2 matrix element for an AccessorView |
| CMAT3 | A 3x3 matrix element for an AccessorView |
| CMAT4 | A 4x4 matrix element for an AccessorView |
| CSCALAR | A scalar element for an AccessorView |
| CVEC2 | A 2D vector element for an AccessorView |
| CVEC3 | A 3D vector element for an AccessorView |
| CVEC4 | A 4D vector element for an AccessorView |
| CAccessorView | A view on the data of one accessor of a glTF asset |
| CAccessorWriter | Provides write access to an AccessorView |
| CAnimation | A keyframe animation |
| CAnimationChannel | An animation channel combines an animation sampler with a target property being animated |
| ►CAnimationChannelTarget | The descriptor of the animated property |
| CPath | Known values for The name of the node's TRS property to animate, or the "weights" of the Morph Targets it instantiates. For the "translation" property, the values that are provided by the sampler are the translation along the X, Y, and Z axes. For the "rotation" property, the values are a quaternion in the order (x, y, z, w), where w is the scalar. For the "scale" property, the values are the scaling factors along the X, Y, and Z axes |
| ►CAnimationSampler | An animation sampler combines timestamps with a sequence of output values and defines an interpolation algorithm |
| CInterpolation | Known values for Interpolation algorithm |
| CAsset | Metadata about the glTF asset |
| CBuffer | This class is not meant to be instantiated directly. Use Buffer instead. |
| CBufferCesium | Holds Buffer properties that are specific to the glTF loader rather than part of the glTF spec |
| CBufferSpec | A buffer points to binary geometry, animation, or skins |
| ►CBufferView | A view into a buffer generally representing a subset of the buffer |
| CTarget | Known values for The hint representing the intended GPU buffer type to use with this buffer view |
| ►CCamera | A camera's projection. A node MAY reference a camera to apply a transform to place the camera in the scene |
| CType | Known values for Specifies if the camera uses a perspective or orthographic projection |
| CCameraOrthographic | An orthographic camera containing properties to create an orthographic projection matrix |
| CCameraPerspective | A perspective camera containing properties to create a perspective projection matrix |
| CCanBeNormalized | Check if a C++ type can be normalized |
| CCanBeNormalized< glm::mat< n, n, T, P > > | Check if a C++ type can be normalized. |
| CCanBeNormalized< glm::vec< n, T, P > > | Check if a C++ type can be normalized. |
| CCanBeNormalized< int16_t > | Check if a C++ type can be normalized. |
| CCanBeNormalized< int32_t > | Check if a C++ type can be normalized. |
| CCanBeNormalized< int64_t > | Check if a C++ type can be normalized. |
| CCanBeNormalized< int8_t > | Check if a C++ type can be normalized. |
| CCanBeNormalized< PropertyArrayView< T > > | Check if a C++ type can be normalized. |
| CCanBeNormalized< T > | Check if a C++ type can be normalized. |
| CCanBeNormalized< uint16_t > | Check if a C++ type can be normalized. |
| CCanBeNormalized< uint32_t > | Check if a C++ type can be normalized. |
| CCanBeNormalized< uint64_t > | Check if a C++ type can be normalized. |
| CCanBeNormalized< uint8_t > | Check if a C++ type can be normalized. |
| CClass | A class containing a set of properties |
| ►CClassProperty | A class property |
| CComponentType | Known values for The datatype of the element's components. Only applicable to SCALAR, VECN, and MATN types |
| CType | Known values for The element type |
| CCountFromAccessor | Visitor that retrieves the count of elements in the given accessor type as an int64_t |
| ►CEnum | An object defining the values of an enum |
| CValueType | Known values for The type of the integer enum value |
| CEnumValue | An enum value |
| CExtensionBufferExtMeshoptCompression | Compressed data for bufferView |
| ►CExtensionBufferViewExtMeshoptCompression | Compressed data for bufferView |
| CFilter | Known values for The compression filter |
| CMode | Known values for The compression mode |
| CExtensionCesiumPrimitiveOutline | GlTF extension for indicating that some edges of a primitive's triangles should be outlined |
| CExtensionCesiumRTC | GlTF CESIUM_RTC extension |
| CExtensionCesiumTileEdges | CESIUM_tile_edges extension for a primitive in a glTF model |
| CExtensionExtInstanceFeatures | An object describing per-instance feature IDs |
| CExtensionExtInstanceFeaturesFeatureId | Feature IDs stored in a GPU mesh instancing attribute |
| CExtensionExtMeshFeatures | An object describing feature IDs for a mesh primitive |
| CExtensionExtMeshGpuInstancing | GlTF extension defines instance attributes for a node with a mesh |
| CExtensionExtStructuralMetadata | Structural metadata about a glTF element |
| CExtensionKhrDracoMeshCompression | KHR_draco_mesh_compression glTF Mesh Primitive Extension |
| CExtensionKhrMaterialsUnlit | GlTF extension that defines the unlit material model |
| CExtensionKhrTextureBasisu | GlTF extension to specify textures using the KTX v2 images with Basis Universal supercompression |
| CExtensionKhrTextureTransform | GlTF extension that enables shifting and scaling UV coordinates on a per-texture basis |
| CExtensionMeshPrimitiveExtStructuralMetadata | Structural metadata about a glTF primitive |
| CExtensionMeshPrimitiveKhrMaterialsVariants | KHR_materials_variants glTF Mesh Primitive Extension |
| CExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue | ExtensionMeshPrimitiveKhrMaterialsVariants Mappings Value |
| CExtensionModelExtStructuralMetadata | GlTF extension that provides structural metadata about vertices, texels, and features in a glTF asset |
| CExtensionModelKhrMaterialsVariants | GlTF extension that defines a material variations for mesh primitives |
| CExtensionModelKhrMaterialsVariantsValue | An object defining a valid material variant |
| CExtensionModelMaxarMeshVariants | GlTF extension that defines mesh variants for nodes |
| CExtensionModelMaxarMeshVariantsValue | An object defining a valid mesh variant |
| CExtensionNodeMaxarMeshVariants | MAXAR_mesh_variants node extension |
| CExtensionNodeMaxarMeshVariantsMappingsValue | ExtensionNodeMaxarMeshVariants Mappings Value |
| CExtensionTextureWebp | GlTF extension to specify textures using the WebP image format |
| CFeatureId | Feature IDs stored in an attribute or texture |
| CFeatureIdFromAccessor | |
| CFeatureIdTexture | A texture containing feature IDs |
| CFeatureIdTextureView | A view on the image data of FeatureIdTexture |
| CImage | This class is not meant to be instantiated directly. Use Image instead. |
| CImageAsset | A 2D image asset, including its pixel data. The image may have mipmaps, and it may be encoded in a GPU compression format |
| CImageAssetMipPosition | The byte range within a buffer where this mip exists |
| ►CImageSpec | Image data used to create a texture. Image MAY be referenced by an URI (or IRI) or a buffer view index |
| CMimeType | Known values for The image's media type. This field MUST be defined when bufferView is defined |
| CIndexFromAccessor | |
| CIndicesForFaceFromAccessor | |
| CInstanceAttributeSemantics | The standard glTF instance attribute semantics from EXT_mesh_gpu_instancing plus additional instance attribute semantics from extensions |
| CIsMetadataArray | Check if a C++ type can be represented as an array |
| CIsMetadataArray< PropertyArrayCopy< T > > | Check if a C++ type can be represented as an array. |
| CIsMetadataArray< PropertyArrayView< T > > | Check if a C++ type can be represented as an array. |
| CIsMetadataArray< T > | Check if a C++ type can be represented as an array. |
| CIsMetadataBoolean | Check if a C++ type can be represented as a boolean property type |
| CIsMetadataBoolean< bool > | Check if a C++ type can be represented as a boolean property type. |
| CIsMetadataBoolean< T > | Check if a C++ type can be represented as a boolean property type. |
| CIsMetadataBooleanArray | Check if a C++ type can be represented as an array of booleans property type |
| CIsMetadataBooleanArray< PropertyArrayView< bool > > | Check if a C++ type can be represented as an array of booleans property type. |
| CIsMetadataBooleanArray< T > | Check if a C++ type can be represented as an array of booleans property type. |
| CIsMetadataFloating | Check if a C++ type can be represented as a floating-point property type |
| CIsMetadataFloating< double > | Check if a C++ type can be represented as a floating-point property type. |
| CIsMetadataFloating< float > | Check if a C++ type can be represented as a floating-point property type. |
| CIsMetadataFloating< T > | Check if a C++ type can be represented as a floating-point property type. |
| CIsMetadataInteger | Check if a C++ type can be represented as an integer property type |
| CIsMetadataInteger< int16_t > | Check if a C++ type can be represented as an integer property type. |
| CIsMetadataInteger< int32_t > | Check if a C++ type can be represented as an integer property type. |
| CIsMetadataInteger< int64_t > | Check if a C++ type can be represented as an integer property type. |
| CIsMetadataInteger< int8_t > | Check if a C++ type can be represented as an integer property type. |
| CIsMetadataInteger< T > | Check if a C++ type can be represented as an integer property type. |
| CIsMetadataInteger< uint16_t > | Check if a C++ type can be represented as an integer property type. |
| CIsMetadataInteger< uint32_t > | Check if a C++ type can be represented as an integer property type. |
| CIsMetadataInteger< uint64_t > | Check if a C++ type can be represented as an integer property type. |
| CIsMetadataInteger< uint8_t > | Check if a C++ type can be represented as an integer property type. |
| CIsMetadataMatN | Check if a C++ type can be represented as a matN type |
| CIsMetadataMatN< glm::mat< n, n, T, P > > | Check if a C++ type can be represented as a matN type. |
| CIsMetadataMatN< T > | Check if a C++ type can be represented as a matN type. |
| CIsMetadataNumeric | Check if a C++ type can be represented as a numeric property, i.e. a scalar / vecN / matN type |
| CIsMetadataNumeric< T > | Check if a C++ type can be represented as a numeric property, i.e. a scalar / vecN / matN type. |
| CIsMetadataNumericArray | Check if a C++ type can be represented as an array of numeric elements property type |
| CIsMetadataNumericArray< PropertyArrayCopy< T > > | Check if a C++ type can be represented as an array of numeric elements property type. |
| CIsMetadataNumericArray< PropertyArrayView< T > > | Check if a C++ type can be represented as an array of numeric elements property type. |
| CIsMetadataNumericArray< T > | Check if a C++ type can be represented as an array of numeric elements property type. |
| CIsMetadataScalar | Check if a C++ type can be represented as a scalar property type |
| CIsMetadataScalar< double > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< float > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< int16_t > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< int32_t > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< int64_t > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< int8_t > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< T > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< uint16_t > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< uint32_t > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< uint64_t > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataScalar< uint8_t > | Check if a C++ type can be represented as a scalar property type. |
| CIsMetadataString | Check if a C++ type can be represented as a string property type |
| CIsMetadataString< std::string_view > | Check if a C++ type can be represented as a string property type. |
| CIsMetadataString< T > | Check if a C++ type can be represented as a string property type. |
| CIsMetadataStringArray | Check if a C++ type can be represented as an array of strings property type |
| CIsMetadataStringArray< PropertyArrayView< std::string_view > > | Check if a C++ type can be represented as an array of strings property type. |
| CIsMetadataStringArray< T > | Check if a C++ type can be represented as an array of strings property type. |
| CIsMetadataVecN | Check if a C++ type can be represented as a vecN type |
| CIsMetadataVecN< glm::vec< n, T, P > > | Check if a C++ type can be represented as a vecN type. |
| CIsMetadataVecN< T > | Check if a C++ type can be represented as a vecN type. |
| CKhrTextureTransform | A utility class that parses KHR_texture_transform parameters and transforms input texture coordinates |
| CKtx2TranscodeTargets | For each possible input transmission format, this struct names the ideal target gpu-compressed pixel format to transcode to |
| ►CMaterial | The material appearance of a primitive |
| CAlphaMode | Known values for The alpha rendering mode of the material |
| CMaterialNormalTextureInfo | Material Normal Texture Info |
| CMaterialOcclusionTextureInfo | Material Occlusion Texture Info |
| CMaterialPBRMetallicRoughness | A set of parameter values that are used to define the metallic-roughness material model from Physically-Based Rendering (PBR) methodology |
| CMesh | A set of primitives to be rendered. Its global transform is defined by a node that references it |
| ►CMeshPrimitive | Geometry to be rendered with the given material |
| CMode | Known values for The topology type of primitives to render |
| CMetadataArrayType | Retrieve the component type of a metadata array |
| CMetadataArrayType< CesiumGltf::PropertyArrayCopy< T > > | Retrieve the component type of a metadata array. |
| CMetadataArrayType< CesiumGltf::PropertyArrayView< T > > | Retrieve the component type of a metadata array. |
| CMetadataConversions | Default conversion between two types. No actual conversion is defined. This returns std::nullopt to indicate the conversion was not successful |
| CMetadataConversions< bool, std::string > | Converts from std::string to a bool |
| CMetadataConversions< bool, std::string_view > | Converts from std::string_view to a bool |
| CMetadataConversions< bool, TFrom, std::enable_if_t< CesiumGltf::IsMetadataScalar< TFrom >::value > > | Converts from a scalar to a bool |
| CMetadataConversions< double, bool > | Converts from a boolean to a double |
| CMetadataConversions< double, float > | Converts from a float to a double |
| CMetadataConversions< double, std::string > | Converts from std::string to a double |
| CMetadataConversions< double, std::string_view > | Converts from std::string_view to a double |
| CMetadataConversions< double, TFrom, std::enable_if_t< CesiumGltf::IsMetadataInteger< TFrom >::value > > | Converts from any integer type to a double |
| CMetadataConversions< float, bool > | Converts from a boolean to a float |
| CMetadataConversions< float, double > | Converts from a double to a float |
| CMetadataConversions< float, std::string > | Converts from a std::string to a float |
| CMetadataConversions< float, std::string_view > | Converts from a std::string_view to a float |
| CMetadataConversions< float, TFrom, std::enable_if_t< CesiumGltf::IsMetadataInteger< TFrom >::value > > | Converts from an integer type to a float |
| CMetadataConversions< std::string, bool > | Converts from a boolean to a string |
| CMetadataConversions< std::string, std::string_view > | Converts from a std::string_view to a std::string |
| CMetadataConversions< std::string, TFrom, std::enable_if_t< IsMetadataScalar< TFrom >::value > > | Converts from a scalar to a string |
| CMetadataConversions< std::string, TFrom, std::enable_if_t< IsMetadataVecN< TFrom >::value||IsMetadataMatN< TFrom >::value > > | Converts from a glm::vecN or glm::matN to a string |
| CMetadataConversions< T, T > | Trivially converts any type to itself |
| CMetadataConversions< TTo, bool, std::enable_if_t< CesiumGltf::IsMetadataInteger< TTo >::value > > | Converts from a boolean to an integer type |
| CMetadataConversions< TTo, bool, std::enable_if_t< IsMetadataMatN< TTo >::value > > | Converts from a boolean to a matN |
| CMetadataConversions< TTo, bool, std::enable_if_t< IsMetadataVecN< TTo >::value > > | Converts from a boolean to a vecN |
| CMetadataConversions< TTo, std::string, std::enable_if_t< CesiumGltf::IsMetadataInteger< TTo >::value &&!std::is_signed_v< TTo > > > | Converts from std::string to an unsigned integer |
| CMetadataConversions< TTo, std::string, std::enable_if_t< CesiumGltf::IsMetadataInteger< TTo >::value &&std::is_signed_v< TTo > > > | Converts from std::string to a signed integer |
| CMetadataConversions< TTo, std::string_view, std::enable_if_t< CesiumGltf::IsMetadataInteger< TTo >::value > > | Converts from std::string_view to an integer |
| CMetadataConversions< TTo, TFrom, std::enable_if_t< CesiumGltf::IsMetadataInteger< TTo >::value &&CesiumGltf::IsMetadataFloating< TFrom >::value > > | Converts from a floating-point type to an integer |
| CMetadataConversions< TTo, TFrom, std::enable_if_t< CesiumGltf::IsMetadataInteger< TTo >::value &&CesiumGltf::IsMetadataInteger< TFrom >::value &&!std::is_same_v< TTo, TFrom > > > | Converts from one integer type to another |
| CMetadataConversions< TTo, TFrom, std::enable_if_t< CesiumGltf::IsMetadataMatN< TTo >::value &&CesiumGltf::IsMetadataMatN< TFrom >::value &&!std::is_same_v< TTo, TFrom > > > | Converts from a matN type to another matN type |
| CMetadataConversions< TTo, TFrom, std::enable_if_t< CesiumGltf::IsMetadataMatN< TTo >::value &&CesiumGltf::IsMetadataScalar< TFrom >::value > > | |
| CMetadataConversions< TTo, TFrom, std::enable_if_t< CesiumGltf::IsMetadataVecN< TTo >::value &&CesiumGltf::IsMetadataScalar< TFrom >::value > > | Converts from a scalar type to a vecN |
| CMetadataConversions< TTo, TFrom, std::enable_if_t< CesiumGltf::IsMetadataVecN< TTo >::value &&CesiumGltf::IsMetadataVecN< TFrom >::value &&!std::is_same_v< TTo, TFrom > > > | Converts from a vecN type to another vecN type |
| CModel | This class is not meant to be instantiated directly. Use Model instead. |
| CModelSpec | The root object for a glTF asset |
| CNamedObject | The base class for objects in a glTF that have a name |
| CNode | A node in the node hierarchy. When the node contains skin, all mesh.primitives MUST contain JOINTS_0 and WEIGHTS_0 attributes. A node MAY have either a matrix or any combination of translation/rotation/scale (TRS) properties. TRS properties are converted to matrices and postmultiplied in the T * R * S order to compose the transformation matrix; first the scale is applied to the vertices, then the rotation, and then the translation. If none are provided, the transform is the identity. When a node is targeted for animation (referenced by an animation.channel.target), matrix MUST NOT be present |
| CPropertyArrayCopy | A copy of an array element of a PropertyTableProperty or PropertyTextureProperty |
| CPropertyArrayView | A view on an array element of a PropertyTableProperty or PropertyTextureProperty |
| CPropertyArrayView< bool > | A view on a bool array element of a PropertyTableProperty or PropertyTextureProperty |
| CPropertyArrayView< std::string_view > | A view on a string array element of a PropertyTableProperty or PropertyTextureProperty |
| CPropertyAttribute | Properties conforming to a class, organized as property values stored in attributes |
| CPropertyAttributeProperty | An attribute containing property values |
| CPropertyAttributePropertyView | A view of the data specified by a PropertyAttributeProperty |
| CPropertyAttributePropertyView< ElementType, false > | A view of the non-normalized data specified by a PropertyAttributeProperty |
| CPropertyAttributePropertyView< ElementType, true > | A view of the normalized data specified by a PropertyAttributeProperty |
| CPropertyAttributePropertyViewStatus | Indicates the status of a property attribute property view |
| CPropertyAttributeView | A view on a PropertyAttribute |
| CPropertyTable | Properties conforming to a class, organized as property values stored in binary columnar arrays |
| ►CPropertyTableProperty | An array of binary property values |
| CArrayOffsetType | Known values for The type of values in arrayOffsets |
| CStringOffsetType | Known values for The type of values in stringOffsets |
| CPropertyTablePropertyView | A view on the data of the PropertyTableProperty that is created by a PropertyTableView |
| CPropertyTablePropertyView< ElementType, false > | A view on the data of the PropertyTableProperty that is created by a PropertyTableView |
| CPropertyTablePropertyView< ElementType, true > | A view on the normalized data of the PropertyTableProperty that is created by a PropertyTableView |
| CPropertyTablePropertyViewStatus | Indicates the status of a property table property view |
| CPropertyTableView | Utility to retrieve the data of PropertyTable |
| CPropertyTexture | Properties conforming to a class, organized as property values stored in textures |
| CPropertyTextureProperty | A texture containing property values |
| CPropertyTexturePropertyView | A view of the data specified by a PropertyTextureProperty |
| CPropertyTexturePropertyView< ElementType, false > | A view of the non-normalized data specified by a PropertyTextureProperty |
| CPropertyTexturePropertyView< ElementType, true > | A view of the normalized data specified by a PropertyTextureProperty |
| CPropertyTexturePropertyViewStatus | Indicates the status of a property texture property view |
| CPropertyTextureView | A view on a PropertyTexture |
| CPropertyView | Represents a metadata property in EXT_structural_metadata |
| CPropertyView< bool > | Represents a boolean metadata property in EXT_structural_metadata |
| CPropertyView< ElementType, false > | Represents a non-normalized metadata property in EXT_structural_metadata |
| CPropertyView< ElementType, true > | Represents a normalized metadata property in EXT_structural_metadata |
| CPropertyView< PropertyArrayView< bool > > | Represents a boolean array metadata property in EXT_structural_metadata |
| CPropertyView< PropertyArrayView< ElementType >, false > | Represents a non-normalized array metadata property in EXT_structural_metadata |
| CPropertyView< PropertyArrayView< ElementType >, true > | Represents a normalized array metadata property in EXT_structural_metadata |
| CPropertyView< PropertyArrayView< std::string_view > > | Represents a string array metadata property in EXT_structural_metadata |
| CPropertyView< std::string_view > | Represents a string metadata property in EXT_structural_metadata |
| CPropertyViewStatus | Indicates the status of a property view |
| ►CSampler | Texture sampler properties for filtering and wrapping modes |
| CMagFilter | Known values for Magnification filter |
| CMinFilter | Known values for Minification filter |
| CWrapS | Known values for S (U) wrapping mode |
| CWrapT | Known values for T (V) wrapping mode |
| CScene | The root nodes of a scene |
| CSchema | An object defining classes and enums |
| CSkin | Joints and matrices defining a skin |
| CStatusFromAccessor | Visitor that retrieves the status from the given accessor. Returns an invalid status for a std::monostate (interpreted as a nonexistent accessor) |
| CSupportedGpuCompressedPixelFormats | Represents the status of support for all GpuCompressedPixelFormats on a client platform |
| CTexCoordFromAccessor | |
| CTexture | A texture and its sampler |
| CTextureInfo | Reference to a texture |
| CTextureView | A view into the texture data of a single texture from a Model |
| CTextureViewOptions | Describes options for constructing a view on a glTF texture |
| CTypeToNormalizedType | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision |
| CTypeToNormalizedType< glm::mat< N, N, T, Q > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< glm::vec< N, T, Q > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< int16_t > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< int32_t > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< int64_t > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< int8_t > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< glm::mat< N, N, T, Q > > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< glm::vec< N, T, Q > > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< int16_t > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< int32_t > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< int64_t > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< int8_t > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< uint16_t > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< uint32_t > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< uint64_t > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< PropertyArrayView< uint8_t > > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< uint16_t > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< uint32_t > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< uint64_t > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToNormalizedType< uint8_t > | Convert an integer numeric type to the corresponding representation as a double type. Doubles are preferred over floats to maintain more precision. |
| CTypeToPropertyType | Convert a C++ type to PropertyType and PropertyComponentType |
| CTypeToPropertyType< bool > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< double > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< float > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< glm::mat< 2, 2, T, P > > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< glm::mat< 3, 3, T, P > > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< glm::mat< 4, 4, T, P > > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< glm::vec< 2, T, P > > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< glm::vec< 3, T, P > > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< glm::vec< 4, T, P > > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< int16_t > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< int32_t > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< int64_t > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< int8_t > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< std::string_view > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< uint16_t > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< uint32_t > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< uint64_t > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CTypeToPropertyType< uint8_t > | Convert a C++ type to PropertyType and PropertyComponentType. |
| CVertexAttributeSemantics | The standard glTF vertex attribute semantics from the specification plus additional vertex attribute semantics from extensions |
| ►NCesiumGltfContent | Classes that support manipulating the content of a glTF |
| ►CGltfUtilities | |
| CIntersectResult | Hit result data for intersectRayGltfModel |
| CRayGltfHit | Data describing a hit from a ray / gltf intersection test |
| CImageManipulation | A collection of utility functions for image manipulation operations |
| CPixelRectangle | Specifies a rectangle of pixels in an image |
| CSkirtMeshMetadata | Metadata obtained from a glTF that describes the skirts present on the mesh |
| ►NCesiumGltfReader | Classes for reading glTF models |
| CAccessorReader | Reads Accessor instances from JSON |
| CAccessorSparseIndicesReader | Reads AccessorSparseIndices instances from JSON |
| CAccessorSparseReader | Reads AccessorSparse instances from JSON |
| CAccessorSparseValuesReader | Reads AccessorSparseValues instances from JSON |
| CAnimationChannelReader | Reads AnimationChannel instances from JSON |
| CAnimationChannelTargetReader | Reads AnimationChannelTarget instances from JSON |
| CAnimationReader | Reads Animation instances from JSON |
| CAnimationSamplerReader | Reads AnimationSampler instances from JSON |
| CAssetReader | Reads Asset instances from JSON |
| CBufferReader | Reads Buffer instances from JSON |
| CBufferViewReader | Reads BufferView instances from JSON |
| CCameraOrthographicReader | Reads CameraOrthographic instances from JSON |
| CCameraPerspectiveReader | Reads CameraPerspective instances from JSON |
| CCameraReader | Reads Camera instances from JSON |
| CClassPropertyReader | Reads ClassProperty instances from JSON |
| CClassReader | Reads Class instances from JSON |
| CEnumReader | Reads Enum instances from JSON |
| CEnumValueReader | Reads EnumValue instances from JSON |
| CExtensionBufferExtMeshoptCompressionReader | Reads ExtensionBufferExtMeshoptCompression instances from JSON |
| CExtensionBufferViewExtMeshoptCompressionReader | Reads ExtensionBufferViewExtMeshoptCompression instances from JSON |
| CExtensionCesiumPrimitiveOutlineReader | Reads ExtensionCesiumPrimitiveOutline instances from JSON |
| CExtensionCesiumRTCReader | Reads ExtensionCesiumRTC instances from JSON |
| CExtensionCesiumTileEdgesReader | Reads ExtensionCesiumTileEdges instances from JSON |
| CExtensionExtInstanceFeaturesFeatureIdReader | Reads ExtensionExtInstanceFeaturesFeatureId instances from JSON |
| CExtensionExtInstanceFeaturesReader | Reads ExtensionExtInstanceFeatures instances from JSON |
| CExtensionExtMeshFeaturesReader | Reads ExtensionExtMeshFeatures instances from JSON |
| CExtensionExtMeshGpuInstancingReader | Reads ExtensionExtMeshGpuInstancing instances from JSON |
| CExtensionExtStructuralMetadataReader | Reads ExtensionExtStructuralMetadata instances from JSON |
| CExtensionKhrDracoMeshCompressionReader | Reads ExtensionKhrDracoMeshCompression instances from JSON |
| CExtensionKhrMaterialsUnlitReader | Reads ExtensionKhrMaterialsUnlit instances from JSON |
| CExtensionKhrTextureBasisuReader | Reads ExtensionKhrTextureBasisu instances from JSON |
| CExtensionKhrTextureTransformReader | Reads ExtensionKhrTextureTransform instances from JSON |
| CExtensionMeshPrimitiveExtStructuralMetadataReader | Reads ExtensionMeshPrimitiveExtStructuralMetadata instances from JSON |
| CExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueReader | Reads ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue instances from JSON |
| CExtensionMeshPrimitiveKhrMaterialsVariantsReader | Reads ExtensionMeshPrimitiveKhrMaterialsVariants instances from JSON |
| CExtensionModelExtStructuralMetadataReader | Reads ExtensionModelExtStructuralMetadata instances from JSON |
| CExtensionModelKhrMaterialsVariantsReader | Reads ExtensionModelKhrMaterialsVariants instances from JSON |
| CExtensionModelKhrMaterialsVariantsValueReader | Reads ExtensionModelKhrMaterialsVariantsValue instances from JSON |
| CExtensionModelMaxarMeshVariantsReader | Reads ExtensionModelMaxarMeshVariants instances from JSON |
| CExtensionModelMaxarMeshVariantsValueReader | Reads ExtensionModelMaxarMeshVariantsValue instances from JSON |
| CExtensionNodeMaxarMeshVariantsMappingsValueReader | Reads ExtensionNodeMaxarMeshVariantsMappingsValue instances from JSON |
| CExtensionNodeMaxarMeshVariantsReader | Reads ExtensionNodeMaxarMeshVariants instances from JSON |
| CExtensionTextureWebpReader | Reads ExtensionTextureWebp instances from JSON |
| CFeatureIdReader | Reads FeatureId instances from JSON |
| CFeatureIdTextureReader | Reads FeatureIdTexture instances from JSON |
| CGltfReader | Reads glTF models and images |
| CGltfReaderOptions | Options for how to read a glTF |
| CGltfReaderResult | The result of reading a glTF model with GltfReader::readGltf |
| CGltfSharedAssetSystem | Contains assets that are potentially shared across multiple glTF models |
| CImageDecoder | Contains methods for reading and manipulating images |
| CImageReader | Reads Image instances from JSON |
| CImageReaderResult | The result of reading an image with ImageDecoder::readImage |
| CMaterialNormalTextureInfoReader | Reads MaterialNormalTextureInfo instances from JSON |
| CMaterialOcclusionTextureInfoReader | Reads MaterialOcclusionTextureInfo instances from JSON |
| CMaterialPBRMetallicRoughnessReader | Reads MaterialPBRMetallicRoughness instances from JSON |
| CMaterialReader | Reads Material instances from JSON |
| CMeshPrimitiveReader | Reads MeshPrimitive instances from JSON |
| CMeshReader | Reads Mesh instances from JSON |
| CModelReader | Reads Model instances from JSON |
| CNetworkImageAssetDescriptor | A description of an image asset that can be loaded from the network using an CesiumAsync::IAssetAccessor. This includes a URL, any headers to be included in the request, and the set of supported GPU texture formats for KTX2 decoding |
| CNetworkSchemaAssetDescriptor | A description of a schema asset that can be loaded from the network using an CesiumAsync::IAssetAccessor. This includes a URL and any headers to be included in the request |
| CNodeReader | Reads Node instances from JSON |
| CPropertyAttributePropertyReader | Reads PropertyAttributeProperty instances from JSON |
| CPropertyAttributeReader | Reads PropertyAttribute instances from JSON |
| CPropertyTablePropertyReader | Reads PropertyTableProperty instances from JSON |
| CPropertyTableReader | Reads PropertyTable instances from JSON |
| CPropertyTexturePropertyReader | Reads PropertyTextureProperty instances from JSON |
| CPropertyTextureReader | Reads PropertyTexture instances from JSON |
| CSamplerReader | Reads Sampler instances from JSON |
| CSceneReader | Reads Scene instances from JSON |
| CSchemaReader | Reads Schema instances from JSON |
| CSkinReader | Reads Skin instances from JSON |
| CTextureInfoReader | Reads TextureInfo instances from JSON |
| CTextureReader | Reads Texture instances from JSON |
| ►NCesiumGltfWriter | Classes for writing glTF models |
| CGltfWriter | Writes glTF |
| CGltfWriterOptions | Options for how to write a glTF |
| CGltfWriterResult | The result of writing a glTF with GltfWriter::writeGltf or GltfWriter::writeGlb |
| CSchemaWriter | Writes schemas |
| CSchemaWriterOptions | Options for how to write a schema |
| CSchemaWriterResult | The result of writing a schema with SchemaWriter::writeSchema |
| ►NCesiumIonClient | Classes for working with Cesium ion clients |
| CApplicationData | Data retrieved from the Cesium ion server via an "appData" request from Cesium ion. This actually represents information about the server itself |
| CAsset | A Cesium ion Asset, such as a 3D Tiles tileset or an imagery layer |
| CAssets | A page of assets obtained from the Cesium ion v1/assets endpoint, including a link to obtain the next page, if one exists |
| CConnection | A connection to Cesium ion that can be used to interact with it via its REST API |
| CDefaultAssets | The default assets |
| CDefaults | The data returned by Cesium ion's v1/defaults service. It includes information about default imagery, terrain and building assets along with quick add assets that can be useful to use within other applications |
| CListTokensOptions | Options to be passed to Connection::tokens |
| CNoValue | A non-value, for use with a valueless Response |
| CProfile | Contains of a Cesium ion user |
| CProfileStorage | Information about the amount of storage available in a user's account |
| CQuickAddAsset | A quick add asset |
| CQuickAddRasterOverlay | A raster overlay available for use with a quick add asset |
| CResponse | A response from Cesium ion |
| CToken | A Cesium ion access token |
| CTokenList | A list of Cesium ion access tokens, as returned by the "List Tokens" service |
| ►NCesiumJsonReader | Classes for reading JSON |
| CArrayJsonHandler | IJsonHandler for reading a JSON array into an std::vector |
| CArrayJsonHandler< double, DoubleJsonHandler > | Special case of ArrayJsonHandler for handling arrays of double values. This will read every scalar value as a double, regardless of whether it's floating point or not. Attempting to read other values will cause a warning |
| CArrayJsonHandler< std::string, StringJsonHandler > | Special case of ArrayJsonHandler for reading arrays of string values. Attempting to read other values will cause a warning |
| CArrayJsonHandler< std::vector< T >, ArrayJsonHandler< T, THandler > > | Special case of ArrayJsonHandler for reading arrays of arrays. Attempting to read other values will cause a warning |
| CArrayJsonHandler< T, IntegerJsonHandler< T > > | Special case of ArrayJsonHandler for handling arrays of integer values. Attempting to read other values will cause a warning |
| CBoolJsonHandler | IJsonHandler for reading bool values |
| CDictionaryJsonHandler | Reads the keys and values of a JSON object into a std::map<std::string, T> or an std::unordered_map<std::string, T> |
| CDoubleJsonHandler | IJsonHandler for reading double values |
| CExtensibleObjectJsonHandler | An IJsonHandler for reading ExtensibleObject types |
| CExtensionsJsonHandler | IJsonHandler for reading extensions, such as those listed in an ExtensibleObject |
| CIExtensionJsonHandler | An interface for JSON handlers that handle extensions on ExtensibleObject types |
| CIgnoreValueJsonHandler | IJsonHandler that does nothing but ignore the next value |
| CIJsonHandler | Base interface for all JSON handlers. Types that need to be deserialized from JSON should implement IJsonHandler or a class that derives from it. As the JSON is parsed, the corresponding read... method to the token that was parsed will be called. These methods can return themselves or a different handler to handle the value |
| CIntegerJsonHandler | IJsonHandler for reading integer values |
| CJsonHandler | A dummy implementation of IJsonHandler that will report a warning and return its parent when any of its read... methods are called |
| CJsonObjectJsonHandler | IJsonHandler for arbitrary CesiumUtility::JsonValue JsonValue objects |
| CJsonReader | Reads JSON |
| CJsonReaderOptions | Holds options for reading statically-typed data structures from JSON |
| CObjectJsonHandler | IJsonHandler for handling JSON objects |
| CReadJsonResult | The result of JsonReader::readJson |
| CSharedAssetJsonHandler | IJsonHandler for SharedAsset values |
| CStringJsonHandler | IJsonHandler for reading string values |
| ►NCesiumJsonWriter | Classes for writing JSON |
| CExtensionWriterContext | A context for writing extensions where known extensions and their handlers can be registered |
| CJsonWriter | Wrapper around rapidjson::Writer for writing objects to JSON |
| CPrettyJsonWriter | Implementation of JsonWriter that "pretty-prints" JSON to the output, formatted with new lines and indentation |
| ►NCesiumQuantizedMeshTerrain | Classes for accessing terrain based on layer.json and quantized-mesh-1.0 |
| CAvailabilityRectangle | A rectangle of tile availability |
| CAvailabilityRectangleReader | Reads AvailabilityRectangle instances from JSON |
| CLayer | A quantized-mesh terrain layer.json |
| CLayerReader | Reads Layer instances from JSON |
| CLayerSpec | A quantized-mesh terrain layer.json |
| CLayerWriter | Writes layer.json |
| CLayerWriterOptions | Options for how to write a layer.json |
| CLayerWriterResult | The result of writing a layer.json with LayerWriter::write |
| CQuantizedMeshLoader | Loads quantized-mesh-1.0 terrain data |
| CQuantizedMeshLoadResult | The results of a QuantizedMeshLoader::load operation, containing either the loaded model, an improved bounding region for the tile, and available quadtree tiles discovered, if the load succeeded - or the request made and the errors that were returned, if the load failed |
| CQuantizedMeshMetadataResult | The metadata of a Quantized Mesh tile, returned by QuantizedMeshLoader::loadMetadata |
| ►NCesiumRasterOverlays | Classes for raster overlays, which allow draping massive 2D textures over a model |
| CBingMapsRasterOverlay | A RasterOverlay that uses Bing Maps as the source for the imagery data |
| CBingMapsStyle | Styles of Bing Maps overlays |
| CDebugColorizeTilesRasterOverlay | A raster overlay that gives each tile to which it is attached a random color with 50% opacity. This is useful for debugging a tileset, to visualize how it is divided into tiles |
| CIonRasterOverlay | A RasterOverlay that obtains imagery data from Cesium ion |
| CIPrepareRasterOverlayRendererResources | An interface between Cesium Native and the application using it, allowing Cesium Native to pass loaded raster overlay data to the implementing application in order for the application to prepare it to be used in its renderer of choice. This could involve creating a texture asset, uploading the texture data to the GPU, or any other similar tasks required |
| CLoadedRasterOverlayImage | Summarizes the result of loading an image of a RasterOverlay |
| CLoadTileImageFromUrlOptions | Options for RasterOverlayTileProvider::loadTileImageFromUrl |
| CQuadtreeRasterOverlayTileProvider | A base class used for raster overlay providers that use a quadtree-based tiling scheme. This includes TileMapServiceRasterOverlay, BingMapsRasterOverlay, and WebMapServiceRasterOverlay |
| CRasterizedPolygonsOverlay | A raster overlay made from rasterizing a set of CartographicPolygon objects. The resulting overlay is monochromatic - white where pixels are inside of the polygons, and black where they are not |
| CRasterOverlay | The base class for a rasterized image that can be draped over a Cesium3DTilesSelection::Tileset. The image may be very, very high resolution, so only small pieces of it are mapped to the Tileset at a time |
| CRasterOverlayDetails | Holds details of the Cesium3DTilesSelection::TileRenderContent that are useful for raster overlays |
| CRasterOverlayLoadFailureDetails | Details on a failure while attempting to load a raster overlay tile |
| CRasterOverlayOptions | Options for loading raster overlays |
| CRasterOverlayTile | Raster image data for a tile in a quadtree |
| CRasterOverlayTileProvider | Provides individual tiles for a RasterOverlay on demand |
| CRasterOverlayUtilities | A collection of utilities useful for operations involving raster overlay tiles |
| CTileMapServiceRasterOverlay | A RasterOverlay based on tile map service imagery |
| CTileMapServiceRasterOverlayOptions | Options for tile map service accesses |
| CTileProviderAndTile | Holds a tile and its corresponding tile provider. Used as the return value of RasterOverlayTileProvider::loadTile |
| CWebMapServiceRasterOverlay | A RasterOverlay accessing images from a Web Map Service (WMS) server |
| CWebMapServiceRasterOverlayOptions | Options for Web Map Service (WMS) overlays |
| CWebMapTileServiceRasterOverlay | A RasterOverlay accessing images from a Web Map Tile Service (WMTS) server |
| CWebMapTileServiceRasterOverlayOptions | Options for WebMapTileServiceRasterOverlay |
| ►NCesiumUtility | Utility classes for Cesium |
| CAttributeCompression | Functions to handle compressed attributes in different formats |
| CCredit | Represents an HTML string that should be shown on screen to attribute third parties for used data, imagery, etc. Acts as a handle into a CreditSystem object that actually holds the credit string |
| CCreditSystem | Creates and manages Credit objects. Avoids repetitions and tracks which credits should be shown and which credits should be removed this frame |
| CDoublyLinkedListAdvanced | A doubly-linked list |
| CDoublyLinkedListPointers | Contains the previous and next pointers for an element in a DoublyLinkedList |
| CErrorList | The container to store the error and warning list when loading a tile or glTF content |
| CExtensibleObject | The base class for objects that have extensions and extras |
| CHash | Contains functions for working with hashes |
| CIDepotOwningAsset | An interface representing the depot that owns a SharedAsset. This interface is an implementation detail of the shared asset system and should not be used directly |
| CIntrusivePointer | A smart pointer that calls addReference and releaseReference on the controlled object |
| CJsonHelpers | A collection of helper functions to make reading JSON simpler |
| CJsonValue | A generic implementation of a value in a JSON structure |
| CMath | Mathematical constants and functions |
| CReferenceCounted | A reference-counted base class, meant to be used with IntrusivePointer |
| CResult | Holds the result of an operation. If the operation succeeds, it will provide a value. It may also provide errors and warnings |
| CResult< CesiumUtility::IntrusivePointer< T > > | Holds the result of an operation. If the operation succeeds, it will provide a value. It may also provide errors and warnings |
| CScopeGuard | A utility that will automatically call the lambda function when exiting a scope |
| CSharedAsset | An asset that is potentially shared between multiple objects, such as an image shared between multiple glTF models. This is intended to be the base class for such assets |
| CStringHelpers | Helper functions for working with strings |
| CUri | A class for building and manipulating Uniform Resource Identifiers (URIs) |
| ►Nstd | STL namespace |
| Chash< CesiumAsync::NetworkAssetDescriptor > | Hash implementation for CesiumAsync::NetworkAssetDescriptor |
| Chash< CesiumGeometry::QuadtreeTileID > | A hash function for CesiumGeometry::QuadtreeTileID objects |
| Chash< CesiumGltfReader::NetworkImageAssetDescriptor > | Hash implementation for CesiumGltfReader::NetworkImageAssetDescriptor |
| Chash< CesiumGltfReader::NetworkSchemaAssetDescriptor > | Hash implementation for CesiumGltfReader::NetworkSchemaAssetDescriptor |
1.12.0