| ►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 |
| CConditionalContent | Defines the structure of 3D Tiles content for the 3DTILES_content_conditional extension |
| CConditionalContentItem | Defines the structure of a single content item in 3DTILES_content_conditional |
| 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 |
| CExtension3dTilesBoundingVolumeCylinder | 3D Tiles extension for cylinder region bounding volumes |
| CExtension3dTilesBoundingVolumeS2 | 3D Tiles extension for S2 bounding volumes |
| CExtension3dTilesContentConditional | Defines the structure of the extension object that is stored as the 3DTILES_content_conditional extension in a tileset JSON, and that summarizes the conditions that appear in the contents |
| CExtension3dTilesContentConditionalDimensionsValue | Extension3dTilesContentConditional Dimensions Value |
| CExtension3dTilesEllipsoid | 3DTILES_ellipsoid extension data to define the referenced ellipsoid |
| CExtensionContent3dTilesContentVoxels | Voxel content type |
| CExtensionMetadataEntityMaxarContentGeoJson | Enables loading optional metadata schema for GeoJSON properties |
| CExtensionSchemaMaxarContentGeoJson | External metadata schema that describes the structure and validation rules for properties found in GeoJSON features within 3D Tiles content. This schema defines the expected property names, data types, constraints, and semantics that should be present in the 'properties' object of GeoJSON Feature objects |
| ►CExtensionSchemaMaxarContentGeoJsonGeometryValue | ExtensionSchemaMaxarContentGeoJson Geometry Value |
| CType | Known values for Type of GeoJSON geometry inside the group |
| ►CExtensionSchemaMaxarContentGeoJsonPropertiesValue | ExtensionSchemaMaxarContentGeoJson Properties Value |
| CType | Known values for Expected datatype of the property value in the GeoJSON Feature's 'properties' object |
| CExtensionTilesetMaxarContentGeoJson | Enables loading GeoJSON content in 3D Tiles. This extension is declared at the tileset level to enable the use of GeoJSON content and optional properties metadata schemas in metadata entities |
| 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 |
| CPadding | The padding property specifies how many rows of attribute data in each dimension come from neighboring grids |
| 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 | This class is not meant to be instantiated directly. Use Tileset instead. |
| CTilesetSpec | 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 |
| CConditionalContentItemReader | Reads ConditionalContentItem instances from JSON |
| CConditionalContentReader | Reads ConditionalContent instances from JSON |
| CContentReader | Reads Content instances from JSON |
| CEnumReader | Reads Enum instances from JSON |
| CEnumValueReader | Reads EnumValue instances from JSON |
| CExtension3dTilesBoundingVolumeCylinderReader | Reads Extension3dTilesBoundingVolumeCylinder instances from JSON |
| CExtension3dTilesBoundingVolumeS2Reader | Reads Extension3dTilesBoundingVolumeS2 instances from JSON |
| CExtension3dTilesContentConditionalDimensionsValueReader | Reads Extension3dTilesContentConditionalDimensionsValue instances from JSON |
| CExtension3dTilesContentConditionalReader | Reads Extension3dTilesContentConditional instances from JSON |
| CExtension3dTilesEllipsoidReader | Reads Extension3dTilesEllipsoid instances from JSON |
| CExtensionContent3dTilesContentVoxelsReader | Reads ExtensionContent3dTilesContentVoxels instances from JSON |
| CExtensionMetadataEntityMaxarContentGeoJsonReader | Reads ExtensionMetadataEntityMaxarContentGeoJson instances from JSON |
| CExtensionSchemaMaxarContentGeoJsonGeometryValueReader | Reads ExtensionSchemaMaxarContentGeoJsonGeometryValue instances from JSON |
| CExtensionSchemaMaxarContentGeoJsonPropertiesValueReader | Reads ExtensionSchemaMaxarContentGeoJsonPropertiesValue instances from JSON |
| CExtensionSchemaMaxarContentGeoJsonReader | Reads ExtensionSchemaMaxarContentGeoJson instances from JSON |
| CExtensionTilesetMaxarContentGeoJsonReader | Reads ExtensionTilesetMaxarContentGeoJson instances from JSON |
| CGroupMetadataReader | Reads GroupMetadata instances from JSON |
| CImplicitTilingReader | Reads ImplicitTiling instances from JSON |
| CMetadataEntityReader | Reads MetadataEntity instances from JSON |
| CPaddingReader | Reads Padding 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 |
| CCesiumIonTilesetContentLoaderFactory | A factory for creating a TilesetContentLoader for assets from Cesium ion |
| 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 |
| CGltfModifier | An abstract class that allows modifying a tile's glTF model after it has been loaded |
| CGltfModifierInput | The input to GltfModifier::apply |
| CGltfModifierOutput | The output of GltfModifier::apply |
| CGltfModifierVersionExtension | An extension holding the "version" of a glTF produced by GltfModifier |
| CIModelMeshExportContentLoaderFactory | A factory for creating a TilesetContentLoader from data from the iModel Mesh Export API |
| 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 |
| CITwinCesiumCuratedContentLoaderFactory | A factory for creating a TilesetContentLoader from data from the iTwin Cesium Curated Content API |
| CITwinRealityDataContentLoaderFactory | A factory for creating a TilesetContentLoader from data from the iTwin Reality Management API |
| ►CLoadedConstTileEnumerator | A "virtual collection" that allows enumeration through the loaded tiles in a subtree rooted at a given Tile |
| Cconst_iterator | An iterator over constant Tile instances |
| ►CLoadedTileEnumerator | A "virtual collection" that allows enumeration through the loaded tiles in a subtree rooted at a given Tile. |
| Citerator | An iterator over Tile instances |
| CLoaderCreditResult | Credit information obtained from a TilesetContentLoader |
| 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 |
| CTileLoadRequester | The base class for something that requests loading of specific tiles from a 3D Tiles Tileset |
| CTileLoadResult | Store the result of loading a tile content after invoking TilesetContentLoader::loadTileContent |
| CTileLoadResultAndRenderResources | |
| CTileLoadTask | Represents the need to load a particular Cesium3DTilesSelection::Tile with a particular priority |
| 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 |
| CTileRasterOverlayStatus | Captures the tile overlay status as produced by RasterOverlayCollection::updateTileOverlays |
| CTileRenderContent | A content tag that indicates a tile has a glTF model content and render resources for the model |
| CTileSelectionContext | Per-frame inputs for the tile selection algorithm |
| CTileSelectionState | A description of the selection state of a Tile during the Tileset::updateViewGroup process |
| CTileset | A 3D Tiles tileset, used for streaming massive heterogeneous 3D geospatial datasets |
| CTilesetContentLoader | The loader interface to load the tile content |
| CTilesetContentLoaderFactory | A factory to create a tileset loader |
| CTilesetContentLoaderResult | The result of creating a TilesetContentLoader, including the status, request, and any errors, as well as the root tile, credits, and the loader itself |
| CTilesetContentOptions | Options for configuring the parsing the contents of a Tileset, including construction of its glTF models |
| CTilesetExternals | External interfaces used by a Tileset |
| CTilesetFrameState | Captures information about the current frame during a call to Tileset::updateViewGroup |
| CTilesetLoadFailureDetails | |
| CTilesetMetadata | Holds the metadata associated with a Tileset or an external tileset. This holds all of the fields of Cesium3DTiles::Tileset except for the root tile |
| CTilesetOptions | Additional options for configuring a Tileset |
| CTilesetSharedAssetSystem | Contains assets that are potentially shared across multiple Tilesets |
| ►CTilesetViewGroup | Represents a group of views that collectively select tiles from a particular Tileset |
| CLoadQueueCheckpoint | A checkpoint within this view group's load queue |
| 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::updateViewGroup |
| ►NCesium3DTilesWriter | Classes for writing 3D Tiles |
| CConditionalContentWriter | Writes Cesium3DTiles::ConditionalContent |
| CConditionalContentWriterOptions | Options for how to write a Cesium3DTiles::ConditionalContent |
| CConditionalContentWriterResult | The result of writing a Cesium3DTiles::ConditionalContent with ConditionalContentWriter::writeConditionalContent |
| 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::writeSubtreeJson or SubtreeWriter::writeSubtreeBinary |
| 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 |
| ►CCesiumIonAssetAccessor | An IAssetAccessor that wraps another one and handles Cesium ion token refresh when an asset returns a 401 error |
| CUpdatedToken | The details of the updated token |
| 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 |
| CSharedAssetContext | The default context passed to SharedAssetDepot factory functions |
| 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 |
| ►NCesiumClientCommon | Shared classes for interacting with Cesium ion and iTwin APIs |
| CJwtTokenUtility | |
| COAuth2ClientOptions | Options used to configure the OAuth2 authentication process |
| COAuth2PKCE | Class for authenticating with an API that uses OAuth2 Proof of Key Code Exchange (PKCE) |
| COAuth2TokenResponse | Tokens obtained from a successful OAuth2 authentication operation |
| ►NCesiumCurl | Provides the ability to access HTTP and other network resources using libcurl |
| CCurlAssetAccessor | An implementation of IAssetAccessor that can make network and local requests to a variety of servers using libcurl |
| CCurlAssetAccessorOptions | Options for constructing a CurlAssetAccessor |
| ►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 |
| CBoundingCylinderRegion | A bounding volume defined as a region following the surface of a cylinder between two radius values. Used for creating bounding volumes from 3DTILES_bounding_volume_cylinder |
| CBoundingSphere | A bounding sphere with a center and a radius |
| CConstantAvailability | An availability value that is a constant boolean value |
| CCullingVolume | A culling volume, defined by four planes |
| 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 |
| CBox | Parameters describing a box shape |
| 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. |
| CCapsule | Parameters describing a capsule shape |
| 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 |
| CColorFromAccessor | Visitor that retrieves the color from the given accessor type as a glm::dvec4 |
| CCountFromAccessor | Visitor that retrieves the count of elements in the given accessor type as an int64_t |
| CCylinder | Parameters describing a cylinder shape |
| CEnum | This class is not meant to be instantiated directly. Use Enum instead. |
| ►CEnumSpec | An object defining the values of an enum |
| CValueType | Known values for The type of the integer enum value |
| CEnumValue | An enum value |
| CExtensionBentleyMaterialsPointStyle | Specifies point diameter for CAD-style visualization |
| 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 |
| CExtensionExtImplicitCylinderRegion | Extension of KHR_implicit_shapes.shape to represent an implicit cylinder region in a glTF model |
| CExtensionExtImplicitEllipsoidRegion | Extension of KHR_implicit_shapes.shape to represent an implicit ellipsoid region 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 |
| CExtensionExtMeshPolygon | GlTF extension adding an encoding of polygon primitive topology |
| ►CExtensionExtMeshPrimitiveEdgeVisibility | This class is not meant to be instantiated directly. Use ExtensionExtMeshPrimitiveEdgeVisibility instead. |
| CVisibility | Known values for the visibility specified for a single edge |
| CExtensionExtMeshPrimitiveEdgeVisibilitySpec | GlTF extension encoding the visibility of the edges of a triangles primitive |
| CExtensionExtPrimitiveVoxels | This class is not meant to be instantiated directly. Use ExtensionExtPrimitiveVoxels instead. |
| CExtensionExtPrimitiveVoxelsSpec | EXT_primitive_voxels extension for a primitive in a glTF model to indicate voxel-based volumetric data |
| CExtensionExtStructuralMetadata | Structural metadata about a glTF element |
| ►CExtensionKhrBillboard | KHR_billboard glTF Node Extension |
| CRotationAxisItems | Known values for rotationAxis |
| CExtensionKhrDracoMeshCompression | KHR_draco_mesh_compression glTF Mesh Primitive Extension |
| ►CExtensionKhrGaussianSplatting | Data defining a 3D Gaussian Splat primitive |
| CColorSpace | Known values for The color space of the reconstructed color values |
| CKernel | Known values for The kernel used to generate the Gaussians |
| CProjection | Known values for The projection method for rendering the Gaussians |
| CSortingMethod | Known values for The sorting method for rendering the Gaussians |
| CExtensionKhrGaussianSplattingCompressionSpz2 | Compressed data for SPZ v2 primitive |
| CExtensionKhrImplicitShapes | Top level implicit shapes |
| 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 |
| CExtensionMaterialBentleyMaterialsLineStyle | GlTF extension that specifies line width and a GPU-friendly dash pattern for CAD-style visualization |
| CExtensionMeshPrimitiveBentleyMaterialsLineStyle | Indicates that a mesh primitive supplies the BENTLEY_materials_line_style cumulative distance attribute semantic |
| 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 |
| CExtensionModelKhrLightsPunctual | KHR_lights_punctual glTF Document Extension |
| 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 |
| CExtensionNodeKhrLightsPunctual | KHR_lights_punctual glTF Node Extension |
| 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 | Visitor that retrieves the feature ID from the given accessor type as an int64_t. This should be initialized with the index of the vertex whose feature ID is being queried |
| 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. |
| ►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 | Visitor that retrieves the vertex index from the given accessor type as an int64_t. This should be initialized with the index (within the accessor itself) of the vertex index |
| CIndicesForFaceFromAccessor | Visitor that retrieves the vertex indices from the given accessor type corresponding to a given face index. These indices are returned as an array of int64_ts. This should be initialized with the index of the face, the total number of vertices in the primitive, and the CesiumGltf::MeshPrimitive::Mode of the primitive |
| 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 |
| ►CLight | A directional, point, or spot light |
| CType | Known values for Specifies the light type |
| CLineString | Represents one or more line strings to be drawn as edges of a triangle mesh |
| ►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 |
| CMaxIndexValueFromAccessor | Returns the maximum possible index value for the given IndexAccessorType |
| 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 |
| CNormalFromAccessor | Visitor that retrieves the normal from the given accessor type as a glm::dvec3 |
| CNumIndicesFromAccessor | Visitor that returns the number of indices contained in an IndexAccessorType variant |
| CPadding | The padding around a voxel grid. Specifies how many rows of attribute data come from neighboring grids in each dimension |
| CPositionFromAccessor | Visitor that retrieves the position from the given accessor type as a glm::dvec3 |
| CPropertyArrayCopy | A copy of an array element of a PropertyTableProperty or PropertyTextureProperty |
| CPropertyArrayCopy< bool > | A copy of a bool array element of a PropertyTableProperty or PropertyTextureProperty |
| CPropertyArrayCopy< std::string_view > | A copy of a string array element of a PropertyTableProperty |
| 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 |
| CQuaternionFromAccessor | Visitor that retrieves the quaternion from the given accessor type as a glm::dquat |
| ►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 |
| ►CShape | Parameters describing an implicit shape |
| CType | Known values for Specifies the shape type |
| CSkin | Joints and matrices defining a skin |
| CSphere | Parameters describing a sphere shape |
| CSpotlight | KHR_lights_punctual Light Spot Properties |
| CStatusFromAccessor | Visitor that retrieves the status from the given accessor. Returns an invalid status for a std::monostate (interpreted as a nonexistent accessor) |
| CTexCoordFromAccessor | Visitor that retrieves the texture coordinates from the given accessor type as a glm::dvec2. This should be initialized with the target index |
| 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 |
| CTypeToDimensions | The number of dimensions that this type contains |
| CTypeToDimensions< glm::mat< n, n, T, P > > | The number of dimensions that this type contains. |
| CTypeToDimensions< glm::vec< n, T, P > > | The number of dimensions that this type contains. |
| 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 | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type |
| CTypeToPropertyType< bool > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< double > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< float > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< glm::mat< 2, 2, T, P > > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< glm::mat< 3, 3, T, P > > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< glm::mat< 4, 4, T, P > > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< glm::vec< 2, T, P > > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< glm::vec< 3, T, P > > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< glm::vec< 4, T, P > > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< int16_t > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< int32_t > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< int64_t > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< int8_t > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< std::string_view > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< uint16_t > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< uint32_t > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< uint64_t > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| CTypeToPropertyType< uint8_t > | Infer the best-fitting PropertyType and PropertyComponentType for a C++ type. |
| 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 |
| 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 |
| CBoxReader | Reads Box 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 |
| CCapsuleReader | Reads Capsule instances from JSON |
| CClassPropertyReader | Reads ClassProperty instances from JSON |
| CClassReader | Reads Class instances from JSON |
| CCylinderReader | Reads Cylinder instances from JSON |
| CEnumReader | Reads Enum instances from JSON |
| CEnumValueReader | Reads EnumValue instances from JSON |
| CExtensionBentleyMaterialsPointStyleReader | Reads ExtensionBentleyMaterialsPointStyle 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 |
| CExtensionExtImplicitCylinderRegionReader | Reads ExtensionExtImplicitCylinderRegion instances from JSON |
| CExtensionExtImplicitEllipsoidRegionReader | Reads ExtensionExtImplicitEllipsoidRegion 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 |
| CExtensionExtMeshPolygonReader | Reads ExtensionExtMeshPolygon instances from JSON |
| CExtensionExtMeshPrimitiveEdgeVisibilityReader | Reads ExtensionExtMeshPrimitiveEdgeVisibility instances from JSON |
| CExtensionExtPrimitiveVoxelsReader | Reads ExtensionExtPrimitiveVoxels instances from JSON |
| CExtensionExtStructuralMetadataReader | Reads ExtensionExtStructuralMetadata instances from JSON |
| CExtensionKhrBillboardReader | Reads ExtensionKhrBillboard instances from JSON |
| CExtensionKhrDracoMeshCompressionReader | Reads ExtensionKhrDracoMeshCompression instances from JSON |
| CExtensionKhrGaussianSplattingCompressionSpz2Reader | Reads ExtensionKhrGaussianSplattingCompressionSpz2 instances from JSON |
| CExtensionKhrGaussianSplattingReader | Reads ExtensionKhrGaussianSplatting instances from JSON |
| CExtensionKhrImplicitShapesReader | Reads ExtensionKhrImplicitShapes instances from JSON |
| CExtensionKhrMaterialsUnlitReader | Reads ExtensionKhrMaterialsUnlit instances from JSON |
| CExtensionKhrTextureBasisuReader | Reads ExtensionKhrTextureBasisu instances from JSON |
| CExtensionKhrTextureTransformReader | Reads ExtensionKhrTextureTransform instances from JSON |
| CExtensionMaterialBentleyMaterialsLineStyleReader | Reads ExtensionMaterialBentleyMaterialsLineStyle instances from JSON |
| CExtensionMeshPrimitiveBentleyMaterialsLineStyleReader | Reads ExtensionMeshPrimitiveBentleyMaterialsLineStyle 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 |
| CExtensionModelKhrLightsPunctualReader | Reads ExtensionModelKhrLightsPunctual 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 |
| CExtensionNodeKhrLightsPunctualReader | Reads ExtensionNodeKhrLightsPunctual 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 |
| CImageReader | Reads Image instances from JSON |
| CLightReader | Reads Light instances from JSON |
| CLineStringReader | Reads LineString instances from JSON |
| CMaterialNormalTextureInfoReader | Reads MaterialNormalTextureInfo instances from JSON |
| CMaterialOcclusionTextureInfoReader | Reads MaterialOcclusionTextureInfo instances from JSON |
| CMaterialPBRMetallicRoughnessReader | Reads MaterialPBRMetallicRoughness instances from JSON |
| CMaterialReader | Reads Material instances from JSON |
| CMeshPrimitiveModeOptions | Options for handling values of CesiumGltf::MeshPrimitive::Mode that appear in a glTF mesh primitive. This is useful when specific primitive modes are not supported in a client |
| 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 |
| CPaddingReader | Reads Padding 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 |
| CShapeReader | Reads Shape instances from JSON |
| CSkinReader | Reads Skin instances from JSON |
| CSphereReader | Reads Sphere instances from JSON |
| CSpotlightReader | Reads Spotlight 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 |
| ►NCesiumImage | Classes that support reading, decoding, and manipulating images |
| 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 |
| CImageDecoder | Contains methods for reading and manipulating images |
| CImageManipulation | A collection of utility functions for image manipulation operations |
| CImageReaderResult | The result of reading an image with ImageDecoder::readImage |
| CKtx2TranscodeTargets | For each possible input transmission format, this struct names the ideal target gpu-compressed pixel format to transcode to |
| CPixelRectangle | Specifies a rectangle of pixels in an image |
| CSupportedGpuCompressedPixelFormats | Represents the status of support for all GpuCompressedPixelFormat s on a client platform |
| ►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 |
| CGeocoderAttribution | Attribution information for a query to a geocoder service |
| CGeocoderFeature | A single feature (a location or region) obtained from a geocoder service |
| CGeocoderResult | The result of making a request to a geocoder service |
| CListTokensOptions | Options to be passed to Connection::tokens |
| CLoginToken | A login token for interacting with the Cesium ion REST API, obtained from the OAuth authentication flow |
| 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 |
| ►NCesiumITwinClient | Classes for interacting with the iTwin API |
| CAuthenticationToken | An authentication token obtained from the iTwin OAuth2 flow |
| CCesiumCuratedContentAsset | A single asset obtained from the iTwin Cesium Curated Content API |
| CConnection | Represents a connection to the Bentley iTwin API |
| CGeospatialFeatureCollection | The definition of a collection of geospatial features |
| CGeospatialFeatureCollectionExtents | The extents of a feature collection |
| CIModel | An iModel |
| CIModelMeshExport | An iModel mesh export |
| CITwin | Information on a single iTwin |
| CITwinRealityData | Information on reality data |
| CPagedList | Allows access to a set of resources from a paginated list |
| CQueryParameters | A common set of query parameters used across list operations in the Bentley API |
| CUserProfile | Information on a user |
| ►NCesiumJsonReader | Classes for reading JSON |
| CArrayJsonHandler | IJsonHandler for reading a JSON array into an std::vector |
| CArrayJsonHandler< CesiumUtility::JsonValue, JsonObjectJsonHandler > | Special case of ArrayJsonHandler for handling arrays of arbitrary JSON values |
| 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 |
| CActivatedRasterOverlay | A RasterOverlay that has been activated for use. While a RasterOverlayTileProvider can be used directly to load images, this class provides additional functionality for managing RasterOverlayTile lifecycle and state |
| CAzureMapsRasterOverlay | A RasterOverlay that retrieves imagery from the Azure Maps API |
| CAzureMapsSessionParameters | Session parameters for an Azure Maps overlay |
| CAzureMapsTilesetId | Supported values for AzureMapsSessionParameters::tilesetId. See the official documentation for all standard values. Note that some tileset IDs return vector data, which is currently unsupported |
| CBingMapsRasterOverlay | A RasterOverlay that uses Bing Maps as the source for the imagery data |
| CBingMapsStyle | Styles of Bing Maps overlays |
| CCreateRasterOverlayTileProviderParameters | Parameters passed to RasterOverlay::createTileProvider |
| 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 |
| CGoogleMapTilesExistingSession | Holds the parameters for an existing Google Maps Tiles session |
| CGoogleMapTilesImageFormat | Standard values for GoogleMapTilesNewSessionParameters::imageFormat |
| CGoogleMapTilesLayerType | Standard values for GoogleMapTilesNewSessionParameters::layerTypes |
| CGoogleMapTilesMapType | Standard values for GoogleMapTilesNewSessionParameters::mapType |
| CGoogleMapTilesNewSessionParameters | Holds the parameters for starting a new Google Maps Tiles session |
| CGoogleMapTilesRasterOverlay | A RasterOverlay that retrieves imagery from the Google Maps Tiles API |
| CGoogleMapTilesScale | Standard values for GoogleMapTilesNewSessionParameters::scale |
| 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 |
| CITwinCesiumCuratedContentRasterOverlay | A RasterOverlay that obtains imagery data from the iTwin Cesium Curated Content API |
| 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 |
| CRasterOverlayExternals | External interfaces used by a RasterOverlay |
| 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 |
| CRasterOverlayTileLoadResult | Holds a tile and its corresponding activated raster overlay. Used as the return value of ActivatedRasterOverlay::loadTile |
| 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 |
| CUrlTemplateRasterOverlay | A RasterOverlay accessing images from a templated URL |
| CUrlTemplateRasterOverlayOptions | Options for URL template overlays |
| 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 |
| CColor | Represents an RGBA color value |
| 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 |
| CCreditReferencer | Provides a way to reference a set of credits in a CreditSystem so that the references can easily be released later |
| CCreditSource | Represents a source of credits, such as a tileset or raster overlay, provided to a CreditSystem |
| CCreditsSnapshot | A snapshot of the credits currently active in a CreditSystem |
| CCreditSystem | Creates and manages Credit objects. Avoids repetitions and tracks which credits should be shown and which credits should be removed this frame |
| CDerivedValue | A function object that caches the last result of a derivation function based on its input. This is sometimes called "memoization", but this simple implementation only remembers the result of a single past invocation |
| 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 |
| CSplitOptions | Options that control the behavior of splitOnCharacter |
| ►CTransformIterator | An iterator that wraps another iterator and applies a transformation function to each element as it is accessed |
| Cpointer | A pointer to the type being iterated over |
| CTreeTraversalState | Associates state (arbitrary data) with each node during partial, depth-first traversal of a tree. Then, during a later traversal of a potentially different subset of the same tree, the state previously associated with each node can be looked up |
| CUri | A class for parsing and manipulating Uniform Resource Identifiers (URIs) |
| CUriQuery | A class for parsing and manipulating the query string of a URI |
| ►NCesiumVectorData | Classes for loading vector data such as GeoJSON |
| CColorStyle | Specifies the color of a style type |
| CConstGeoJsonObjectIterator | The const equivalent of GeoJsonObjectIterator |
| CConstGeoJsonObjectTypeIterator | An iterator over all GeoJsonObject objects that contain a value of type ObjectType |
| CConstGeoJsonPrimitiveIterator | Returns all geometry data of a given type from a GeoJsonObject |
| CGeoJsonDocument | A vector document parsed from GeoJSON |
| CGeoJsonFeature | A GeoJsonFeature object represents a spatially bounded "thing." It is a collection of information that is possibly linked to a geometry object |
| CGeoJsonFeatureCollection | A FeatureCollection represents any number of GeoJsonFeature objects |
| CGeoJsonGeometryCollection | A GeometryCollection represents any number of GeoJsonObject objects |
| CGeoJsonLineString | A LineString geometry object |
| CGeoJsonMultiLineString | A MultiLineString geometry object |
| CGeoJsonMultiPoint | A MultiPoint geometry object |
| CGeoJsonMultiPolygon | A 'MultiPolygon' geometry object |
| ►CGeoJsonObject | An object in a GeoJSON document |
| CIteratorProvider | An object providing begin and end methods for creating iterators of the given type for a GeoJsonObject |
| CGeoJsonObjectIterator | Iterates over a GeoJsonObject and all of its children |
| CGeoJsonPoint | A Point geometry object |
| CGeoJsonPolygon | A Polygon geometry object |
| CGltfConverter | Convert GeoJSON documents to glTF |
| CLineStyle | The style used to draw polylines and strokes |
| CPointStyle | The style used to draw a point |
| CPolygonStyle | The style used to draw a Polygon |
| CVectorDocumentAttribution | Attribution that must be included with a vector document |
| CVectorRasterizer | Rasterizes vector primitives into a CesiumImage::ImageAsset |
| CVectorStyle | Style information to use when drawing vector data |
| ►NCesiumVectorOverlays | Raster overlays for displaying vector data |
| CGeoJsonDocumentRasterOverlay | A raster overlay made from rasterizing a CesiumVectorData::GeoJsonDocument |
| CGeoJsonDocumentRasterOverlayOptions | A set of options for configuring a GeoJsonDocumentRasterOverlay |
| CVectorTilesRasterOverlay | A raster overlay made from rasterizing a vector tiles tileset |
| CVectorTilesRasterOverlayOptions | Options for constructing a VectorTilesRasterOverlay |
| ►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 |
| Chash< CesiumUtility::IntrusivePointer< T > > | Hash implementation for CesiumUtility::IntrusivePointer |
1.13.2