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
CAudioAssetRef
CCubemapTextureAssetRef
CFontAssetRef
CGeometryMeshAssetRef
CGltfAssetRef
CGltfRenderableAssetRef
CLightmapTextureAssetRef
CMaterialAssetRef
CSkeletalMeshAssetRef
CSkeletonAssetRef
CSkinAssetRef
CTexture2DAssetRef
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	Stores the material data which is relevant for our current set of shaders
CGltfMeshData	Mesh data extracted from a glTF mesh node
CGltfMeshPrimitiveData	Stores intermediate data from loading the asset from disk. These are the vertices, indices and material data
CGltfTextureData	Optional image payload extracted from tinygltf
CGltfVertexData	Resolved vertex attribute and index views for a glTF primitive
CMaterialExtensions	Stores all material extensions. So if another extension for some kind of specific material attribute is needed we can add it here
CStaticMeshExtensions	Parses all extensions and extracts recognized extensions
CStaticMeshSettings	Static mesh settings parsed from legacy glTF extras
CVulkanSchneeExtension	The vulkan schnee extension for gltf files stores all data related to the engines core functionality
CCollisionProperties	Stores collision shape properties imported from Blender
CCompoundChild
CDirectionalLightProperties
CLightProperties	Stores all properties related to lighting information
CLightmapProperties
CMeshProperties	Stores the mesh information like if it is a static object and if it simulates physics
Cmetadata
CPointLightProperties
CVulkanSchneeMaterialExtension	Extracts all material data from the gltf file. All data during runtime will be read from an object of this type
CShaderParameter	Represents a single shader parameter that can be either connected or a direct value
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
CAnimation	Animation clip loaded from glTF animation data
CAnimationAssetManager
CAssetHandle
CAssetHandleHash
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
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
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
CRuntimeTexture	Runtime-owned Vulkan texture resource
CSkin	Skeleton definition loaded from glTF skin data
CSkinAssetManager
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
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
CScene	A scene component has a transform
CVrCamera	Camera component driven by VR headset tracking
CVrGlider	VR gliding component using hand positions for flight control
CDebugSnapshot	Debug state captured from the most recent VR glider tick
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
CResolution
CWindTrail	Logic component that owns a wind trail emitter scene node
NCore	Manages IBL (Image-Based Lighting) resources for specular reflections
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
CAssetRegistry
CAudioClipStore
CRecord
CAudioEngine	Owns the miniaudio engine and provides the playback API
CPlayingSound	Active miniaudio sound instance owned by the audio engine
CRegisteredAudio	Audio asset registered for playback by path
CConstexprPath
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
CRecord
CGltfRenderableRecord
CGltfStore
CGltfRecord
CRenderableRecord
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	Unified material data structure containing all possible material properties
CMaterialStore
CRecord
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	The physics engine manages creating and destroying physics objects for the physics simulation
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
CTexture2DStore
CRecord
CTextureStorage	Texture asset entry paired with its descriptor index
CTimerManager
CTimerEvent
CTimerHandle
NDebug
NRendering
CDraw	Static API for immediate-mode debug line drawing
CLineVertex	Vertex data for debug line rendering
NEcs
CActiveCamera	Tag for the active camera in the scene
CAnimationState	Animation playback state for an entity with a skeletal mesh
CAssetLoadingImage	Async glTF image load request tracked by the ECS asset pipeline
CAssetLoadingStatus	Status information for asset loading pipeline
CAssetRequested	Is a tag for asset loading. When an asset has been requested for loading but isn't yet created this tag is applied to the entity which will possess the Ecs::StaticMeshData
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	A bounding sphere for an entity. Used for frustum culling
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
CMaterialLoadingData	Material payload waiting to be registered as a material asset
CMaterialNormals
CMesh
CMeshComponentRef	References to MeshComponents for ECS-based iteration. Multiple mesh components can share one SceneNode entity
CMeshIndex	The index of the mesh inside the scene. Used to query the mesh index of a scene
CMeshletData
CMeshPrimitive
CMeshPrimitiveData
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
CModelNode
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 This provides 4x bandwidth reduction vs unpacked format
CParent	Stores parent relationships
CPipelineGeometryData	Temporary holder for raw geometry data during pipeline execution This is used to pass data between pipeline stages
CPointLightData	Runtime point light data mirrored from Components::PointLight. sceneNodeEntity points to the transform used as the light position
CPrimitiveData
CPrimitiveDataLoading
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 gltf file Contains unprocessed vertices and indices
CRegistryManager	Singleton which holds the entt registry
CRendererDirtyList	Global dirty entity collector for renderer transform uploads
CSceneNodeRef	A struct which allows the engine to find out which SceneNode needs to propagate a dirty flag down the hierarchy
CSimulatesPhysics	Tag for EnTT which tags entities which should simulate physics
CSkeletalMeshData	Skeletal mesh data component. Similar to StaticMeshData but references skin/animation
CStaticMeshData
CStaticMeshes	Collection of static mesh references attached to one entity
CTextureAssetPipeline	Infrastructure to load images into the ecs
CTick	Tag for everything which wants to receive tick events
CTransform
CTransformDepth
CTransformDirty	Tag for dirty transforms (used by scene graph synchronization)
CTransformDirtyRenderer	Tag for transforms that need GPU upload
CTransformOperators
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
NEntities
Ndetail
CConstructibleWithSceneEntityFirstNodeRest
CConstructibleWithSceneEntityFirstNodeRest< T, First, Rest... >
CGltfSpawnNode
CGltfSpawnPlan
CActor	An Actor is similar to an Engine::Entities::Entity. An actor is an Entity with a transform
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
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	A scene is the overarching structure which can spawn, contain and destroy actors or entities
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
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
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
CRaycastHit	Result data for physics raycasts and sweep tests
CRigidBodyCreateInfo	Rigid body create info is used to create a rigid body. It delivers all informations like the initial transform where the simulation should start or the mass of the object
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	Compute dispatch dimensions
CDynamicPointLight	GPU-side dynamic point light. positionRadius.xyz = world position, w = influence radius. colorIntensity.rgb = light color, w = intensity
CDynamicPointLightBuffer	Fixed-size dynamic point light buffer for shaders
CGpuMeshDescription	GPU-side mesh location and meshlet count
CInstanceCullingData	Instance culling data for compute shader
CInstanceData	Per-instance 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	Used in meshlet culling
CMeshPrimitiveRenderData	Per-primitive render data for GPU shader access
CMeshUnpackingData	Mesh unpacking metadata for compute shader
CNormalsMaterial	GPU-side normals debug material
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	GPU data for single-meshlet vertex-shader path
CSunLightBuffer	GPU-side single directional sun light. directionEnabled.xyz = direction the light travels in world space, w = enabled. colorIntensity.rgb = light color, w = intensity
CSunShadowCascadeBuffer	GPU-side cascaded shadow data for the active directional sun
CUnifiedMeshlet	GPU-side meshlet memory location and counts
CVisibleLodPrimitive	Visible LOD primitive data for parallel cluster selection
CVisibleMeshletInfo	Visible meshlet result from culling operation
CVisibleMeshletRange	Visible meshlet range per object for dispatch
CComputePipeline	A wrapper for vulkan pipeline resources. In this case a typesafe compute pipeline
CComputePipelineSpecializationData	Wrapper for shader specialization data for compute pipelines. This usually only stores the thread count as that can depend on the hardware the engine is running on
CData
CCpuMeshData	CPU-side mesh data with per-object transform and primitives
CCpuPrimitiveData	CPU-side primitive data
CDispatcherComputePipelineSpecializationData	Specialization constants for dispatcher compute shaders
CData	Raw specialization constant payload passed to Vulkan
CDynamicMaterialUniformData
CFrustumPlanes	Frustum planes for compute shader culling
CGraphicsPipeline
CHeadset
CEye
CImageBuffer
CWaitFrameResult	Result from waitForXrFrame indicating what the main loop should do
CImageBasedLightingResources
CMeshGeometryMapping	CPU-side mapping from MeshAsset to shared geometry buffer
CMeshShaderSpecializationData	Specialization data for mesh shaders - provides screen resolution for small triangle culling
CData
CPerObjectPrimitiveData	CPU-side per-object meshlet, vertex, and index data
CPipelineConfig	Static configuration for a graphics pipeline Defines which shaders to use for a given PipelineNames enum
CPipelineMaterialPayload
CPipelineSpecializationData	Base class which defines the interface for pipeline specialization data. This can be thread count. Max object count etc
CRenderer	The renderer is the main class for rendering. It owns all data which is used any time in any frame. For per frame data take a look at
CMeshConstants	A texture index push constant
CTaskConstants	Used to tell the pipeline which objects are shaded with which shader
CTonemapPushConstants
CRenderTarget	A render target which contains all resources to access the rendered image
CSunShadowResources
CWorldUiRenderer
CTarget
CTargetFrame
NUI
CWidget
NWorld
CWindField	This is the base class for a wind field. (An area in which a vector field pushes the player glider component)
CWindFieldConfig	Holds the parameters of a wind field which can be configured through imgui
CWindSample	A wind sample is the wind force at one point in the wind field
CEngineKern
CEngineManager	Singleton which stores a pointer to the engine object
CGameModule
CGliderConfig	Configuration parameters for the VR glider system (distances in meters, speeds in m/s, time in seconds)
COpenXrHelper
Cposef	A glm based posef struct
CSceneBrowserEntry
NEngineCore
CDefaultJsonGenerator
CFactory
CJsonHandler
CRegistrar
CSerializable
CTextureLoadData
NInput
CActionProfileBase	The base profile for controller support of any device
CActionProfiles
CActionProfileOculusTouchController	Input mapping implementation for oculus touch devices
CActionProfileSimpleController	Minimal input mapping supported on any OpenXR compatible device
CHandPoseInfo
CInputManager	Action-based input dispatcher for polling providers and invoking callbacks
CBoolAction
CBoolCallbackEntry
CCallbackHandle	Opaque handle for a registered input callback
CFloatAction
CFloatCallbackEntry
CVec2Action
CVec2CallbackEntry
CTrackedHandPose	World-space pose for one tracked XR hand
CXrInputHandler	Handles OpenXR input actions and controller state
CXrRig	Resolves raw XR play-space poses into world-space tracked hand poses
Nstd	STL namespace
Chash< Asset::MeshPath >
Chash< Asset::Path >
Chash< Engine::Assets::AssetHandle< Tag > >
Chash< EngineCore::TextureLoadData >
NVulkan
CBuffer	RAII wrapper for Vulkan buffer and device memory
CStagedBuffer	Device buffer with double-buffered CPU-visible staging buffers for uploads
CPendingDeletion	Old buffers waiting to be deleted after all frames complete
CStagedBufferSyncObjects	Synchronization and copy metadata returned by staged buffer uploads
CBidirectionalMap	Maintains a one-to-one mapping that can be queried from either side
CSide
CBoneVertexData	Per-vertex bone influence data for skeletal mesh skinning
CBufferCopyObject	Description of one buffer copy operation
CDebugLabel	An RAII-style wrapper for Vulkan debug labels
CNamedThreadPool	Tracy-named thread pool using BS_tracy::tracy_thread_pool
CVertex	The fundamental building block of all meshes in this engine
CVulkanFunctions
CVulkanHelper	Stores lots of different functions which shorten the amount of code which needs to be written for default vulkan operations