Class List

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

[detail level 12345]

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
CPath
NEcs	Data structs for the Entity Component System
CActiveCamera	Tag for the active camera in the scene
CAssetLoadingImage
CAssetLoadingStatus	Status information for asset loading pipeline
CAssetRequested	Is a tag for asset loading. When an asset has been rquested for loading but isnt yet created this tag is applied to the entity which will possess the Ecs::StaticMeshData
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
CEntityNullError
CExrHeaderData
CExrHeaderFuture
CGltfModelFuture
CImageData
CLightingProperties
CLocalTransform
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
CMeshProperties
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
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
CPrimitiveUvData
CRawMeshData	Raw mesh geometry data extracted from gltf file Contains unprocessed vertices and indices
CRegistryManager	Singleton which holds the entt registry
CRenderingAsset
CRenderingAssetManager
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
CStaticMeshData
CStaticMeshes
CTextureAssetPipeline	Infrastructure to load images into the ecs
CTick	Tag for everything which wants to receive tick events
CTransformDepth
CTransformDirty	Tag for dirty transforms (used by scene graph synchronization)
CTransformDirtyRenderer	Tag for transforms that need GPU upload. Separate from TransformDirty because the renderer clears this after upload, while TransformDirty is cleared during scene graph sync. This allows transforms changed in tick/events to be properly uploaded
CTransformOperators
CMatrixTransformComponent
CUnpackedMeshletData	Pre-packed GPU-ready data for a primitive's meshlets. Generated on background thread during meshlet generation
CVertexData
CVulkanSchneeExtension
CWorldTransform
NEngineCore	Log category system implementation
CActor	An Actor is similar to an EngineCore::Entity. An actor is an Entity with a transform
CAllocationException	Used when we allocate memory in finite space (e.g. array) and run out of space
CApplicationContext	The application context is the core class which stores the basic openxr and vulkan objects
CQueueFamily
CFamily
CAssetManager
CMaterialData	Storage for material data on the cpu side
CBoxCollisionComponent	Collision component using a box shape
CBufferWriteException	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
CCameraComponent	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
CCapsuleCollisionComponent	Collision component using a capsule shape (cylinder with hemispherical ends)
CClusterGroupData	Per-group LOD data representing a simplified version of child clusters. Groups are created by merging and simplifying clusters from the finer LOD level
CClusterLodData	Per-cluster LOD data for GPU-driven LOD selection. Each cluster maps to exactly one meshlet and contains hierarchical LOD information
CClusterLodGenerator	Generates LOD hierarchy for meshes using meshoptimizer
CLodLevelData	Generate a single LOD level by simplifying geometry
CClusterSurvivor	Cluster survivor data passed from culling to binning shaders. Contains the LOD selection result including dither factor for transitions
CCollisionComponent	Base class for collision shape components
CComputePass	The compute pass stores all resources which belong to a compute pipeline
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
CConstexprPath
CCpuMeshData	CPU side data for per object data. This will get divided up into multiple gpu buffers
CCpuPrimitiveData	Cpu primitive data. Stores data which corresponds to a primitive
CDataBuffer
CDefaultJsonGenerator
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
CDescriptorSetLayoutBuilder
CDescriptorSetUpdater	The Descriptor set updater is used to create a list of descriptor set writes which are executed with update()
CDiffuseFlatColorMaterialData	Material data for an Object which displays a flat color
CDiffuseShaderMaterialData	Diffuse shader
CDispatch	Alignment at 4 bytes
CDispatcherComputePass
CDispatcherComputePipelineSpecializationData
CData
CDynamicMaterialUniformData
CDynamicTexturesMaterialData	Dynamic textures material with PBR and lightmap support
CEmptyScene
CEngine
CEngineManager	Singleton which stores a pointer to the engine object
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
CEnvironmentException	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
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
CExrTextureAsset	Extension of TextureAsset and stores the Exr header information as well as the texture data
CFactory
CFrustumPlanes	Frustum planes for frustum culling in the first compute shader stage
CGameModule
CGlmSerialize
CQuaternionSerial
CVectorSerial
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
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
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
CGltfSpawner	Utility class for spawning GLTF meshes into a scene
CGltfTextureAsset	Extension of TextureAsset for images loaded from glTF files (PNG/JPG)
CGpuDiffuseFlatColorMaterial	GPU-side layout for flat color material Matches GLSL struct in triangle_flat.frag
CGpuDiffuseShaderMaterial	GPU-side layout for diffuse shader material Used for basic textured materials
CGpuMeshDescription	Describes a mesh on the gpu. Where it is in the memory and how many meshlets it consists of
CGpuNormalsMaterial	GPU-side layout for normals debug material
CGpuPbrMaterial	GPU-side layout for PBR material with spherical harmonics Used by MovableDiffuseShader, L0/L1/L2 shaders, and DynamicTextures
CGraphicsPipeline
CHeadset
CEye
CImageBuffer
CWaitFrameResult	Result from waitForXrFrame indicating what the main loop should do
CHiZViewProjectionData	View-projection data for Hi-Z occlusion culling Contains matrices and screen info needed to project bounding spheres to screen space
CInputInterface
CInstanceCullingData	Instance culling data - replaces ObjectCullingData for instancing. Contains world-space bounding sphere and references to instance/geometry data
CInstanceData	Per-instance data - one per visible MeshComponent. References shared geometry via meshGeometryId
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
CJsonArchive
CJsonHandler
CL0ShaderMaterialData
CL1ShaderMaterialData	L1 Spherical Harmoics shader
CL2ShaderMaterialData
CLayoutBinding
CLayoutBindingsBuilder
CLocalBoundsData	Local-space bounding sphere data - uploaded once, never changes
CLodConfigUBO	LOD configuration for GPU shader selection. Updated per-frame with camera and screen information
CLodGenerationConfig	Configuration for LOD hierarchy generation
CLogCategory	Represents a single log category with verbosity control
CLogCategoryManager	Global registry for log categories with runtime verbosity control
CLogicComponent	Base class for all logic components that can be attached to an actor. Provides access to the scene, tick functionality, and lifecycle events
CMaterial
CMaterialAsset	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
CMaterialData
CMaterialDataStorage	The material data storage is designed to have all material data at a compact layout
CMaterialNameTrait
CMaterialNameTrait< DiffuseFlatColorMaterialData >
CMaterialNameTrait< DiffuseShaderMaterialData >
CMaterialNameTrait< DynamicTexturesMaterialData >
CMaterialNameTrait< L0ShaderMaterialData >
CMaterialNameTrait< L1ShaderMaterialData >
CMaterialNameTrait< L2ShaderMaterialData >
CMaterialNameTrait< MovableDiffuseShaderMaterialData >
CMaterialNameTrait< NormalMaterialData >
CMaterialNameTrait< StaticLightmapMaterialData >
CMaterialShader
CMesh
CMeshAsset	The mesh asset stores geometry data and
CMeshAssetManager	Stores mesh data with their primitives
CMeshComponent	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
CMeshGeometryData	Shared geometry metadata - one per unique MeshAsset primitive. Allows multiple instances to reference the same geometry data
CMeshGeometryMapping	Mapping from MeshAsset primitive to shared geometry buffer location. Used by RenderingDataManager to track deduplicated geometry
CMeshletBounds	Used in meshlet culling
CMeshLoader
CMeshLoaderGltf
CMeshPrimitive
CMeshletBoundsHelper
CMeshPrimitiveRenderData
CMeshShaderSpecializationData	Specialization data for mesh shaders - provides screen resolution for small triangle culling
CData
CMeshUnpackingData	Data for the metadata buffer which handles the unpacking of meshes into their meshlets
CMirrorView	This class houses the components needed to display a vr image on the desktop
CRenderResult	Values that represent mirror view render results
CMissingOpenXrRuntimeException	When the open xr runtime is not installed this will be thrown
CModelAsset	The model asset is used to bind together all files of one gtlf model. The idea is that textures, materials etc are bundled in one model
CModelAssetManager
CMovableDiffuseShaderMaterialData	Moveable diffuse shader with PBR and lightmap support
CNodeFactory	Factory class for creating SceneNodes with proper parent-child relationships. This ensures that nodes are always created with a valid parent
CNormalMaterialData	Material data for an object which displays its normals
CObjectCullingCounters
CObjectCullingData	Data for object culling
COpenXrHelper
Cposef	A glm based posef struct
CPackedVertex
CPath
CPathHasher
CPerObjectData	Stores all data which is unique to each object
CPerObjectPrimitiveData
CPhysicsBodyComponent	Component that manages a physics rigid body for an entity
CPhysicsEngine	The physics engine manages creating and destroying physics objects for the physics simulation
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
CPrimitiveMeshletData	Data for the primitive culling shader to assemble and pass on to the unpacking shader
CPushConstants
CQueueSubmitBuilder	Fluent builder for queue submissions with timeline and binary semaphores
CRat
CRegistrar
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
CRenderingDataManager	The rendering data manager is supposed to hold all methods to update the contents of the buffers which are uploaded to the gpu. This could be culling data for example
CGeometryCacheKey	Key for geometry cache - uniquely identifies a primitive within a mesh. Uses MeshAsset pointer and primitive index since the same MeshAsset can have multiple primitives
CGeometryCacheKeyHash
CRenderingPass
CRenderList	The render list stores all actors to render this frame
CRenderProcess	The render process class consolidates all the resources that needs to be duplicated for each frame that can be rendered to in parallel. The renderer owns a render process for each frame that can be processed at the same time, and each render process holds their own uniform buffer, command buffer, semaphores and memory fence. With this duplication, the application can be sure that one frame does not modify a resource that is still in use by another simultaneous frame
CHiZPyramid
CStaticFragmentUniformData	Stores the time for time based shader effects
CTextureWriteContainer
CViewMatrixUniformData	This struct holds the data for the view projection matrix which will be passed to every rendered object
CRenderTarget	A render target which contains all resources to access the rendered image
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
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 actors
CSceneComponent	A scene component has a transform
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
CSceneManager	Manages game objects within a scene, handling registration, ID allocation, and GPU buffer synchronization for meshlet-to-object mappings
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
CSerializable
CSHProbeData	SH Probe data structure for dynamic lighting Contains L0-L2 RGB spherical harmonic coefficients
CSingleMeshletGeometryData	GPU data for single-meshlet geometry using vertex shader path. One entry per unique single-meshlet geometry, referenced by instances. Used for VkDrawIndexedIndirectCommand generation in culling shader
CSphereCollisionComponent	Collision component using a sphere shape
CStaticLightmapMaterialData	Static lightmap material with PBR support
CStaticMeshActor	Wrapper for entt component creation which ensures types safety and attaches the correct component with systmes to the entity
CTestComponent
CTexture
CTextureAsset	Wrapper for texture data
CTextureAssetManager
CTextureHandle	Type-erased texture handle for runtime storage
CTextureHandleRegistry	Central registry for texture handles, providing O(1) descriptor index lookup
CEntry	Registry entry storing texture metadata
CTextureLoadData
CTextureLoader
CTextureStorage
CTicker
CTimelineSynchronizer	Centralized timeline semaphore management for the rendering pipeline
CTransform
CMatrixTransformComponent
Cserial
CTypedTextureHandle	Type-safe texture handle wrapper providing compile-time type safety
CUnifiedGeometryManager
CUnifiedMeshlet	Information about the wereabouts of a meshlet in memory on the gpu
CUniformBufferObject
CUniqueTestComponent
CUuidManager
CUuidSingleton
CVisibleMeshletInfo	Struct for the result buffer of the culling operation. Stores which objects have passed the culling test
CVisibleMeshletRange
CVrHeadsetConnectionException
CVrMovementComponent	Component that handles VR player movement using controller inputs
CVulkanBuffer	RAII wrapper for Vulkan buffer and device memory
CVulkanStagedBuffer
CPendingDeletion	Old buffers waiting to be deleted after all frames complete
CVulkanStagedBufferSyncObjects
CWindow
CXrErrorCodes
NInput
CActionProfileBase	The base profile for controller support of any device
CActionProfiles
CActionProfileOculusTouchController	Input mapping implementation for oculus touch devices
CActionProfileSimpleController	The minimal input mapping implementation provided by open xr which should be supported on any openxr compatible device
CHandPoseInfo
CXrInputHandler
NMath	Stores mathematical operations like calculating bounding spheres over a list of points
CBoundingSphere	A helper class which is used to generate a bounding sphere for a list of points. In most cases these are vertex positions of a mesh
NPhysics	Namespace for all physics only components. This could be shapes for the pyhsics engine
CCollisionShape
CSphereCollision
Nplog
CLogFormatClion
CTxtFormatterImpl
Nstd	STL namespace
Chash< Asset::Path >
Chash< EngineCore::TextureLoadData >
NVulkan	Used for vulkan specific helpers like something to chain pNexts together
CBarrierBundle
CChainBuilder
CBaseChain
Chas_pNext
Chas_pNext< T, std::void_t< decltype(std::declval< T >().pNext)> >
CBidirectionalMap
CSide
CBufferCopyObject
CComputeShader
CDebugLabel	An RAII-style wrapper for Vulkan debug labels
CFileHandler
CLodSettings	LOD (Level of Detail) system settings. Controls the Nanite-style per-cluster LOD selection behavior
CMeshShader
CNamedThreadPool	Tracy-named thread pool using BS_tracy::tracy_thread_pool
CRenderDoc
CShader
CVertex	The fundamental building block of all meshes in this engine
CVertexShader
CVulkanFunctions
CVulkanHelper	Stores lots of different functions which shorten the amount of code which needs to be written for default vulkan operations