Class List

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

[detail level 1234567]

NAsset	Classes which are related to asset loading are mostly stored in this namespace
CAssetBase	Base class for asset wrappers. The data is stored in the private member variable 'data' in form of entt components
CAssetManager	A manager which is used to look up existing assets and their loading state
CLoadResult	Result returned when an asynchronous asset load reaches a terminal state
CMeshPath	Identifies a named mesh-like asset inside an asset file
CPath	Identifies a single asset file on disk
CRecord	Internal storage for one asset entry managed by AssetManager
CRef	Non-owning handle to an asset record managed by AssetManager
NEngine
NAnimation	Animation channel data and evaluation helpers
CAnimationChannel	A single animation channel targeting one joint's transform property
CAnimationEvaluator	Evaluates animation keyframes at a given time
CJointPose	Local-space transform sampled for one joint
NAssets
NAuthored
CAnimationClipAssetRef	Handle to an animation clip.
CAudioAssetRef	Handle to audio clip asset data.
CCubemapTextureAssetRef	Handle to a cubemap texture.
CFontAssetRef	Handle to a font asset.
CGeometryMeshAssetRef	Handle to non-skinned mesh geometry.
CGltfAssetRef	Handle to a glTF container file.
CGltfRenderableAssetRef	Handle to one mesh-bearing node inside a glTF file.
CLightmapTextureAssetRef	Handle to a file-backed sampled 2D texture.
CMaterialAssetRef	Handle to a material payload.
CSkeletalMeshAssetRef	Handle to skinned mesh geometry.
CSkeletonAssetRef	Handle to skeleton metadata.
CSkinAssetRef	Handle to skin binding data.
CTexture2DAssetRef	Handle to a file-backed sampled 2D texture.
NLoaders
CAudioLoader	Loader for audio files using miniaudio's built-in decoders
CGltfLoader	Loads glTF files and converts tinygltf data into engine asset data
CGltfBufferDataView	View into a glTF accessor's backing buffer data
CGltfMaterialData	Material data extracted from a glTF material and engine extensions
CGltfMeshData	Mesh data extracted from a glTF mesh node
CGltfMeshPrimitiveData	Geometry, material, and optional skinning data parsed from one glTF primitive
CGltfTextureData	Optional image payload extracted from tinygltf
CGltfVertexData	Resolved vertex attribute and index views for a glTF primitive
CMaterialExtensions	Parsed material extension bundle for one glTF material
CStaticMeshExtensions	Parsed extension bundle for one mesh or node
CStaticMeshSettings	Static mesh settings parsed from legacy glTF extras
CVulkanSchneeExtension	Parsed VULKAN_SCHNEE_engine_properties extension data
CAnchorPointReference	Syntax-level reference from an owning mesh node to an AnchorPoint node
CCollisionProperties	Collision shape properties imported from Blender
CCompoundChild	Child shape data for compound collision
CDirectionalLightProperties	Directional light component data imported from directionalLightProperties
CLightProperties	Engine-side representation of the Blender light settings exported for an object, including shadow and lightmap behavior
CLightmapProperties	Lightmap metadata imported from lightmapProperties
CMeshProperties	Mesh behavior flags imported from meshProperties
Cmetadata	Legacy object metadata imported from older exporter output
CPointLightProperties	Point light component data imported from pointLightProperties
CVulkanSchneeMaterialExtension	Parsed VULKAN_SCHNEE_materials material extension data
CShaderParameter	Shader input exported from a Vulkan Schnee Blender shader node
CKtx2Loader	Loader for KTX2 texture files (BC6H, BC7, etc.)
NTextures
CExrChannelInfo	Represents channel information from an EXR file header
CExrHeader	Wrapper for EXR file header information with owned data
CExrLoader	Loader for EXR (OpenEXR) image files
CKtx2TextureData	Stores all data loaded from a KTX2 file including mip chain
CTextureHandleRegistry	Central registry for texture handles, providing O(1) descriptor index lookup
CEntry	Registry entry storing texture metadata
CTextureIdentityKey	Path and semantic type pair that uniquely identifies a texture handle
CTextureIdentityKeyHash	Hash functor for TextureIdentityKey
CAnimation	Animation clip loaded from glTF animation data
CAnimationAssetManager	Stores animation clips keyed by their source mesh path
CAssetHandle	Stable typed reference into an asset registry store
CAssetHandleHash	Allows handles to be used as unordered_map/set keys without losing the handle's type safety
CAudio	Holds decoded PCM audio data as an engine asset
CAudioAssetManager	Manages audio assets by filesystem path, providing dedup and lookup
CAudioData	Decoded audio data ready for playback
CAudioFlowHandle	Stable identity of an audio flow: the glTF asset path plus the flow name (unique within the asset). Two handles are equal when both the path and the name match, so the same flow resolves to the same handle regardless of how often it was loaded
CAudioFlowLoader	Imports audio flows from an exported glTF asset
CAudioFlowStore	Registry for audio flows keyed by (glTF path, flow name)
CRecord	One stored flow
CCubemapTexture	Owns Vulkan resources for a sampled cubemap texture
CCubemapTextureData	CPU-side RGBA cubemap image data
CCubemapTextureLoader	Loads cubemap face images from a directory
CExrTextureAsset	Extension of TextureAsset and stores the Exr header information as well as the texture data
CFlowSettingHandle	Stable handle to a named, runtime-controllable setting of a flow
CGltfTextureAsset	Extension of TextureAsset for images loaded from glTF files (PNG/JPG)
CJoint	A single joint in a skeleton hierarchy
CMaterial	Material asset is another wrapper for asset data which is stored in entt. It has the EngineCore::MaterialAsset::type member variable which corresponds to the component used to store the material data
CMaterialAssetManager	Asset manager for materials keyed by source file path and material name
CMesh	The mesh asset stores geometry data and
CMeshAssetManager	Stores mesh data with their primitives
CNullAssetHandle	Explicit null value assignable to any typed asset handle
CRuntimeMaterialLease	Move-only ownership of a material created at runtime
CRuntimeTexture	Runtime-owned Vulkan texture resource
CRuntimeTextureDescriptorLease	Move-only ownership of one runtime texture descriptor slot
CSkin	Skeleton definition loaded from glTF skin data
CSkinAssetManager	Stores skin and skeleton binding data keyed by source mesh path
CTexture	Wrapper for texture data
CTextureAssetManager	Asset manager for texture assets keyed by filesystem path
CTextureHandle	Type-erased texture handle for runtime storage
CTypedTextureHandle	Type-safe texture handle wrapper providing compile-time type safety
NComponents
CArcadeGliderInput	Input values for one arcade glider simulation step
CArcadeGliderState	Persistent state carried between arcade glider simulation steps
CArcadeGliderStep	Output values from one arcade glider simulation step
CArcadeGliderTuning	Stores the config values for the glider. Can be used to change the flight behavior of the glider movement controller
CBoxCollision	Collision component using a box shape
CCamera	A camera component that provides view and projection matrices based on its SceneNode transform. Use setActive() to mark this camera as the active camera for rendering
CCapsuleCollision	Collision component using a capsule shape (cylinder with hemispherical ends)
CCollidableMesh	Mesh component that can create and own collision shapes for its actor
CCollision	Base class for collision shape components
CCallbackSubscription
CDirectionalLight	Runtime directional light component mirrored into ECS for renderer queries
CLogic	Base class for all logic components that can be attached to an actor. Provides access to the scene, tick functionality, and lifecycle events
CMesh	A component which can be attached as many times to an actor as one wants. It makes it possible to render a mesh attached to an object
CPhysicsBody	Component that manages a physics rigid body for an entity
CBodyCallbackSubscription
CScene	A scene component has a transform
CVrCamera	Camera component driven by VR headset tracking
CVrGlider	VR locomotion component that switches between walking, falling, gliding, and stalled flight
CDebugSnapshot	Diagnostics captured from the most recent tick() call
CHandData	Hand position and orientation data relative to head
CVrMovement	Component that handles VR player movement using controller inputs. Writes locomotion to the actor's SceneNode, which the camera reads from
CWidgetComponent	Runtime ImGui widget that can be rendered into a world-space UI texture
CResolution	Requested render-target size for the widget texture
CWorldUiWindowStyle
CWindTrail	Logic component that owns a wind trail emitter scene node
CWorldUiMaterialSettings
CWorldUiSurfaceComponent	Binds a world-space widget texture to a mesh through a runtime material
NCore
CAnchorPoint	Named attachment transform authored as a direct child empty of a glTF mesh node
CAnimationClipStore	Registry store for animation clip handles
CRecord	Stored metadata for one animation clip handle slot
CApplicationContext	The application context is the core class which stores the basic openxr and vulkan objects
CQueueFamily	Queue family indices and queue handles selected for the Vulkan device
CFamily	One Vulkan queue family selection and its queue handle
CAssetManager	Coordinates engine asset loading pipelines and runtime texture descriptor ownership
CAssetRegistry	Groups typed asset registry stores and resolves authored asset references
CAudioClipStore	Registry store for authored audio clip handles
CRecord	Stored metadata for one audio clip handle slot
CAudioDeviceInfo
CAudioEngine	Owns the miniaudio engine and provides the playback API
CPendingPlay	Deferred playback request awaiting its clip's async payload
CPlayingFlow	Active flow graph playback instance
CPlayingSound	Active miniaudio sound instance owned by the audio engine
CSpatializedSound	Active spatialized sound referencing a Steam Audio backend source
CAudioFlowGraph	Shared flow-graph audio runtime built on a miniaudio node graph
CConstexprPath	Fixed-size path string that supports constexpr path composition
CDescriptorIndexAllocator	Use this class to manage a finite amount of memory. The idea is to have an array which stores objects and a vector which has pointers to said objects in the array. The array is sparsely populated using optionals
CGeometryMeshStore	Registry store for non-skinned geometry mesh handles
CRecord	Stored metadata for one geometry mesh handle slot
CGltfRenderableRecord	Imported metadata for one renderable node inside a glTF file
CGltfStore	Registry store for glTF source files and their renderable node handles
CGltfRecord	Stored metadata for one glTF source handle slot
CRenderableRecord	Stored metadata for one glTF renderable handle slot
CITickable	This is the interface which is used to call a tick function on an object. Everything which should be able to tick has to implement this interface
CMaterialData	CPU-side material description consumed by renderer material upload code
CMaterialStore	Registry store for material asset handles
CRecord	Stored metadata for one material handle slot
CPackedVertex	Compact vertex format used by mesh packing code
CPath	Centralized accessors for project and asset paths
CPathHasher	Hash functor for filesystem paths used in unordered containers
CPhysicsEngine	Owns the Bullet dynamics world and dispatches engine collision events
CComponentPairKey
CPendingActorEvent
CPendingComponentEvent
CRuntimeBodySlot
CRuntimeCollisionSlot
CSamplerCache	Cache for reusable Vulkan samplers keyed by address mode
CSceneManager	Manages game objects within a scene, handling registration, ID allocation, and GPU buffer synchronization for meshlet-to-object mappings
CSkinStore	Registry store for skin/skeleton binding handles
CRecord	Stored metadata for one skin handle slot
CSteamAudioBackend	Binaural HRTF spatialization backend built on Steam Audio
CTexture2DStore	Registry store for authored sampled 2D texture handles
CRecord	Stored metadata for one 2D texture handle slot
CTextureStorage	Texture asset entry paired with its descriptor index
CTimerManager	Schedules one-shot callbacks against engine time
CTimerEvent
CTimerHandle	Opaque identifier for a scheduled timer
NDebug
NRendering
CDraw	Static API for immediate-mode debug line drawing
CLineVertex	Vertex data for debug line rendering
NDebugging
CPlog
NEcs	EnTT component data used by engine systems
CActiveCamera	Tag for the active camera in the scene
CAnimationState	Animation playback state for an entity with a skeletal mesh
CAssetImportPipeline	Master asset import pipeline that dispatches asset submissions to the texture, model and audio sub-pipelines and advances them in a fixed order
CAssetLoadingImage	Async glTF image load request tracked by the ECS asset pipeline
CAssetLoadingStatus	Status information for asset loading pipeline
CAssetRequested	Tag applied while an asset request is queued but the runtime asset is not loaded
CAudioAssetPipeline	Async pipeline for loading audio assets (WAV, FLAC, MP3)
CAudioLoadFuture
CBoneTransformsDirty	Tag component indicating bone transforms need GPU upload. Analogous to TransformDirty for world transforms
CBoundingSphere	Bounding sphere used for culling and bounds aggregation
CCameraProperties	Camera properties for projection matrix calculation
CCompletedMeshletGeneration	Complete result of meshlet generation for all primitives of a mesh. This is returned from the background meshlet generation task and queued for processing on the main thread at a safe point
CComputedBoneTransforms	Stores computed bone matrices for GPU upload
CDirectionalLightData	Runtime directional light data mirrored from Components::DirectionalLight. sceneNodeEntity points to the transform used to derive the light direction unless hasDirectionOverride is set
CExrHeaderData	Loaded EXR header data used before full texture payload loading
CExrHeaderFuture	Async EXR header load request tracked by the ECS asset pipeline
CGltfModelFuture	Async glTF model load request tracked by the ECS asset pipeline
CImageData	ECS wrapper for loaded tinygltf image data
CKtx2LoadFuture	Async KTX2 texture load request tracked by the ECS asset pipeline
CLightData	Tag for ECS entities that provide renderer light data
CLodHierarchyResult	Result of LOD hierarchy generation for a mesh primitive. Contains per-cluster and per-group data for all LOD levels
CMaterialDiffuseFlatColor	Flat diffuse color material payload
CMaterialLoadingData	Material payload waiting to be registered as a material asset
CMaterialNormals	Material state for normal visualization
CMesh	ECS wrapper for one glTF mesh object
CMeshComponentRef	References to MeshComponents for ECS-based iteration. Multiple mesh components can share one SceneNode entity
CMeshIndex	Mesh index inside a glTF scene
CMeshletData	Meshlet descriptors and index streams for one primitive
CMeshPrimitive	Runtime mesh primitive data consumed by the renderer
CMeshPrimitiveData	Renderer-facing primitive collection for one mesh asset
CModel	ECS wrapper for a loaded tinygltf model
CModelAssetPipeline	The model asset pipeline loads a gltf scene and loads and loads the mesh and material data. The material data requests the textures it needs
CModelFuture	Async glTF model load future without a path
CModelNode	ECS wrapper for one glTF node object
CPackedTriangle	GPU-ready packed triangle data (matches shader layout). Stores 3 x 8-bit local indices packed into a single uint32_t. Packing: [unused:8][i2:8][i1:8][i0:8] - bits 31-24, 23-16, 15-8, 7-0 Reduces triangle-index bandwidth by 4x versus unpacked format
CParent	Parent entity link for component-owned ECS entities
CPipelineGeometryData	Temporary holder for raw geometry data during pipeline execution
CPointLightData	Runtime point light data mirrored from Components::PointLight. sceneNodeEntity points to the transform used as the light position
CPrimitiveData	CPU geometry for one mesh primitive before renderer upload
CPrimitiveDataLoading	Result of primitive extraction before meshlet generation
CPrimitiveMeshletResult	Result of meshlet generation for a single primitive. Used to transfer data from background thread to main thread safely
CPrimitiveMetaData	Metadata about a primitive being loaded from gltf file
CRawMeshData	Raw mesh geometry data extracted from a glTF file
CRegistryManager	Singleton which holds the entt registry
CRendererDirtyList	Global dirty entity collector for renderer transform uploads
CSceneNodeRef	Scene node reference used to propagate transform dirty flags through children
CSimulatesPhysics	Physics body state for entities synchronized with Bullet
CSkeletalMeshData	Skeletal mesh data component. Similar to StaticMeshData but references skin/animation
CStaticMeshData	Mesh component state for one static mesh reference
CStaticMeshes	Collection of static mesh references attached to one entity
CTextureAssetPipeline	Infrastructure to load images into the ecs
CTick	Tick registration for objects that receive engine tick callbacks
CTransform	Local transform matrix and helpers for translation, rotation, and scale
CTransformDepth	Depth of an entity in the transform hierarchy
CTransformDirty	Tag for dirty transforms (used by scene graph synchronization)
CTransformDirtyRenderer	Legacy tag for transforms that need GPU upload
CTransformOperators	Static helpers for reading and mutating Transform matrices
CMatrixTransformComponent
CUnpackedMeshletData	Pre-packed GPU-ready data for a primitive's meshlets. Generated on background thread during meshlet generation
CVRTrackingInput	VR tracking input populated from OpenXR each frame. Used by the IK system to drive skeletal animation from controller poses
CDevicePose	World-space pose for a tracked XR device
CWorldTransform	Cached world transform matrix written by the scene graph
NEntities
Ndetail
CConstructibleWithSceneEntityFirstNodeRest	Detects component constructors that accept scene, entity, first user argument, node, and remaining args
CConstructibleWithSceneEntityFirstNodeRest< T, First, Rest... >	Specialization for component constructors that place the scene node after the first user argument
CGltfSpawnNode	Planned scene actor for one renderable glTF node
CGltfSpawnPlan	Prepared glTF spawn data reused while creating actors from one glTF asset
CActor	An Actor is similar to an Engine::Entities::Entity. An actor is an Entity with a transform
CDebugCameraActor	Lightweight active camera actor for level debugging and focused scene tests
CEntity	The entity class is the base class of everything which is attached to a scene. If it is part of a scene it is an entity
CEntityContainer	Owns entity lifetime and deferred destruction for a scene or subsystem
CGltfSpawner	Utility class for spawning GLTF meshes into a scene
CNodeFactory	Factory class for creating SceneNodes with proper parent-child relationships. This ensures that nodes are always created with a valid parent
CRat	Test actor that owns a scene component
CRootNode	A subclass of EngineCore::SceneNode which is the root node of a scene graph
CScene	Owns scene entities, actor lifetime, and the scene graph root
CSceneGraph	Represents the entire scene as a graph (specifically, a tree) of SceneNode objects. It manages the hierarchy of nodes and provides access to the root of the scene
CSceneLightingSettings	Scene-specific multipliers for direct and baked environment lighting
CSceneNode	Represents a node in the scene graph, containing information about its position, rotation, and scale relative to its parent. It also holds references to its parent and children nodes
CSkeletalMeshActor	Actor type for skinned/skeletal meshes (characters, animated objects)
CSpawnContext	Scene ownership data passed to actor and component constructors during spawning
CStaticMeshActor	Wrapper for entt component creation which ensures types safety and attaches the correct component with systems to the entity
NExceptions
CAllocation	Used when we allocate memory in finite space (e.g. array) and run out of space
CBufferWrite	A buffer write exception is typically thrown when trying to write to a buffer which does not have enough space for the content written to it
CEnvironment	Is thrown when the environment for the game is not setup properly. So for example if we cant find an openxr runtime this is thrown
CException	Base exception type for engine-specific runtime errors
CInitializationOrder	Initialization Order is called when something is called where we are trying to access uninitialized data
CMissingOpenXrRuntime	When the open xr runtime is not installed this will be thrown
CMissingVulkanFeature	Thrown when the vulkan device is missing features which are required for the engine
CRendering	Thrown when renderer setup or frame rendering fails outside OpenXR-specific paths
CVrHeadsetConnection	Thrown when a VR headset connection fails or is unavailable
CVulkanSetup	Is thrown when trying to create a vulkan object and it fails
CXrRendering	Thrown when OpenXR rendering setup or frame rendering fails
NPhysics
CCollisionEvent	Actor-level collision or overlap event generated by PhysicsEngine
CCollisionHandle	Runtime handle for a registered collision component
CCollisionProfileHandle	Registry handle for a collision profile name
CCollisionProfileRegistry	Registers collision profile names, enum mappings, and pair responses
CProfileData
CPhysicsBodyHandle	Runtime handle for a registered physics body component
CPhysicsQueryFilter	Collision profile filter used by PhysicsEngine scene queries
CRaycastHit	Result data for physics raycasts and sweep tests
CRigidBodyCreateInfo	Parameters used by Engine::Core::PhysicsEngine::createRigidBody()
NRendering
NGpuBuffers
CClusterGroupData	Per-group LOD data representing simplified child clusters
CClusterLodData	Per-cluster LOD data for GPU-driven LOD selection
CClusterSurvivor	Cluster survivor data passed from culling to binning shaders
CDiffuseFlatColorMaterial	GPU-side flat color material
CDiffuseShaderMaterial	GPU-side diffuse textured material
CDispatch	Workgroup counts for an indirect compute dispatch
CDynamicPointLight	GPU-side dynamic point light
CDynamicPointLightBuffer	Fixed-size dynamic point light buffer for shaders
CGpuMeshDescription	GPU-visible meshlet range for one mesh
CInstanceCullingData	Per-instance bounding data used by compute culling
CInstanceData	Per-instance transform and material data referencing shared geometry
CLocalBoundsData	Local-space bounding sphere data for GPU transformation
CLodConfigUBO	LOD configuration UBO for GPU shader selection
CMeshGeometryData	Shared geometry metadata for instanced rendering with LOD support
CMeshletBounds	Bounding sphere for meshlet culling
CMeshPrimitiveRenderData	Per-primitive material and lighting indices for fragment shaders
CMeshUnpackingData	Mesh unpacking metadata for compute shader
CNormalsMaterial	GPU-side material data for normals debug rendering
CObjectCullingCounters	Culling operation counters for GPU buffers
CObjectCullingData	Object culling data for compute shader
CPbrMaterial	GPU-side PBR material with spherical harmonics
CPrimitiveMeshletData	Per-primitive meshlet range for culling shader
CSHProbeData	Spherical harmonics probe data for dynamic lighting
CSingleMeshletGeometryData	Draw metadata for geometry routed through the vertex-shader fast path
CSunLightBuffer	GPU-side single directional sun light
CSunShadowCascadeBuffer	GPU-side cascaded shadow data for the active directional sun
CUnifiedMeshlet	GPU-side meshlet descriptor consumed by mesh shaders
CVisibleLodPrimitive	Visible LOD primitive data for parallel cluster selection
CVisibleMeshletInfo	Visible meshlet result from culling operation
CVisibleMeshletRange	Visible meshlet range per object for dispatch
CCpuMeshData	CPU-side mesh instance data before conversion to renderer GPU buffers
CCpuPrimitiveData	CPU-side render metadata for one mesh primitive
CFrustumPlanes	Per-eye frustum planes passed to compute shader culling
CHeadset	Owns the OpenXR session, XR swapchain, eye transforms, and per-frame XR submission state
CEye	Cached matrices for one eye
CImageBuffer	Engine-owned Vulkan image, memory, and view tuple
CWaitFrameResult	Result from waitForXrFrame() indicating how the main loop should continue
CMaterialPublication	Material snapshot published to one fence-safe frame slot
CMeshGeometryMapping	CPU cache entry that maps a mesh primitive to shared geometry buffer ranges
CPerObjectPrimitiveData	CPU-side staging payload for one primitive's meshlet draw data
CPublishedMaterial	Stable location of one material in a pipeline-specific GPU material buffer
CRenderTarget	Render target wrapper for one OpenXR swapchain image
CWorldUiRenderer	Renders WidgetComponent ImGui content into per-widget textures for world-space UI
CImGuiTexture
CRetiredTarget
CTarget
CTargetFrame
NUI
CTable	Small ImGui table helper with fixed headers, optional column weights, and text clipping
NWorld
CWindField	Procedural wind field used by glider flight, particles, and debug rendering
CWindFieldConfig	Runtime configuration for procedural wind pockets
CWindSample	Wind field result at one world-space point
CDebugger
CEngineKern	Owns the engine runtime and provides access to engine subsystems
CEngineManager	Stores the active engine pointer for systems that cannot receive it directly
CGameModule	Base interface implemented by game-specific engine modules
CGliderConfig	Runtime tuning values for Engine::Components::VrGlider
CImplSubsystems	Impl subsystems are the engine private subsystems which the user should never have to interact with
COpenXrHelper	Conversion and math helpers used by the OpenXR integration
Cposef	A glm based posef struct
CRenderDoc
CSceneBrowserEntry	Scene factory entry exposed to the scene browser
CSubsystems	Subsystems is a singleton which distributed the pointers to most engine systems to the codebase
CVulkanDebugLogger
NEngineCore
CJsonHandler	Static helper for loading JSON files
CTextureLoadData	CPU-side image bytes and dimensions used as texture load input
NInput
CHandPoseInfo	Raw pose data for one tracked OpenXR hand
CInputBindingScope	RAII owner for input provider and callback registrations
CInputManager	Action-based input dispatcher for polled input values and callbacks
CBoolAction	Runtime state for one bool action name
CBoolCallbackEntry	Stored callback registration for a bool action
CCallbackHandle	Opaque handle for a registered input callback
CFloatAction	Runtime state for one float action name
CFloatCallbackEntry	Stored callback registration for a float action
CProviderHandle	Opaque handle for a registered input provider
CVec2Action	Runtime state for one vec2 action name
CVec2CallbackEntry	Stored callback registration for a vec2 action
CTrackedHandPose	World-space pose for one tracked XR hand
CXrInputDef	One action definition for an interaction profile
CXrInputHandler	Creates OpenXR controller actions from the profile registry and samples the input state
CXrActionCache	Cached sampled state for one subaction path of an action
CXrActionInfo	Runtime state for one created OpenXR action
CXrProfileDef	Data-driven definition of one OpenXR interaction profile
CXrRig	Resolves raw XR play-space poses into world-space tracked hand poses
Nstd	STL namespace
Chash< Asset::MeshPath >	Std::hash specialization for Asset::MeshPath
Chash< Asset::Path >	Std::hash specialization for Asset::Path
Chash< Engine::Assets::AssetHandle< Tag > >	Standard-library hash adapter for typed asset handles
Chash< Engine::Assets::AudioFlowHandle >
Chash< EngineCore::TextureLoadData >	Hash specialization for TextureLoadData
CBidirectionalMap	Maintains a one-to-one mapping that can be queried from either side
CSide	Read-only view for one direction of the map
CBoneVertexData	Per-vertex bone influence data for skeletal mesh skinning
CBufferCopyObject	Description of one buffer-to-buffer copy operation
CDebugLabel	RAII wrapper for a Vulkan debug label region
CTracy
CVertex	The fundamental building block of all meshes in this engine
CVulkanFunctions	Function pointers for Vulkan extension entry points used by the engine
CVulkanHelper	Static helpers for common Vulkan allocation, copy, descriptor, and debug operations