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
CPath
CRecord
CRef
NEngine
NAnimation
CAnimationChannel	A single animation channel targeting one joint's transform property
CAnimationEvaluator	Evaluates animation keyframes at a given time
CJointPose
NAssets
NLoaders
CAudioLoader	Loader for audio files using miniaudio's built-in decoders
CGltfLoader
CGltfBufferDataView
CGltfMaterialData	Stores the material data which is relevant for our current set of shaders
CGltfMeshData
CGltfMeshPrimitiveData	Stores intermediate data from loading the asset from disk. These are the vertices, indices and material data
CGltfTextureData
CGltfVertexData
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
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
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
CCubemapTextureData
CCubemapTextureLoader
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
CMesh	The mesh asset stores geometry data and
CMeshAssetManager	Stores mesh data with their primitives
CRuntimeTexture
CSkin	Skeleton definition loaded from glTF skin data
CTexture	Wrapper for texture data
CTextureAssetManager
CTextureHandle	Type-erased texture handle for runtime storage
CTypedTextureHandle	Type-safe texture handle wrapper providing compile-time type safety
NComponents
CArcadeGliderInput
CArcadeGliderState
CArcadeGliderStep
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
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
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
CWindTrail
NCore	Core audio subsystem owning the miniaudio engine and managing playback
CApplicationContext	The application context is the core class which stores the basic openxr and vulkan objects
CQueueFamily
CFamily
CAssetManager
CAudioEngine	Owns the miniaudio engine and provides the playback API
CPlayingSound
CRegisteredAudio
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
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
CPackedVertex
CPath
CPathHasher
CPhysicsEngine	The physics engine manages creating and destroying physics objects for the physics simulation
CSamplerCache
CSceneManager	Manages game objects within a scene, handling registration, ID allocation, and GPU buffer synchronization for meshlet-to-object mappings
CTextureStorage
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
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
CExrHeaderFuture
CGltfModelFuture
CImageData
CKtx2LoadFuture
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
CMaterialNormals
CMesh
CMeshComponentRef	Reference to a MeshComponent for ECS-based iteration. Allows efficient querying of all mesh components without iterating all actors
CMeshIndex	The index of the mesh inside the scene. Used to query the mesh index of a scene
CMeshletData
CMeshPrimitive
CMeshPrimitiveData
CModel
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
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
CWorldTransform
NEntities
Ndetail
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
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)
CStaticMeshActor	Wrapper for entt component creation which ensures types safety and attaches the correct component with systmes 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
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
CVrHeadsetConnection
CVulkanSetup	Is thrown when trying to create a vulkan object and it fails
CXrRendering
NPhysics
CRaycastHit
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
CData
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
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
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
CBoolAction
CBoolCallbackEntry
CCallbackHandle
CFloatAction
CFloatCallbackEntry
CVec2Action
CVec2CallbackEntry
CTrackedHandPose
CXrInputHandler	Handles OpenXR input actions and controller state
CXrRig
Nstd	STL namespace
Chash< Asset::Path >
Chash< EngineCore::TextureLoadData >
NVulkan
CBuffer	RAII wrapper for Vulkan buffer and device memory
CStagedBuffer
CPendingDeletion	Old buffers waiting to be deleted after all frames complete
CStagedBufferSyncObjects
CBidirectionalMap
CSide
CBoneVertexData	Per-vertex bone influence data for skeletal mesh skinning
CBufferCopyObject
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