Namespaces
namespace	Authored
namespace	Gltf
namespace	Loaders
namespace	Materials
	Compatibility aliases for material data names used by older material code.
namespace	Textures

Classes
class	Animation
	Animation clip loaded from glTF animation data. More...
class	AnimationAssetManager
	Stores animation clips keyed by their source mesh path. More...
struct	AssetHandle
	Stable typed reference into an asset registry store. More...
struct	AssetHandleHash
	Allows handles to be used as unordered_map/set keys without losing the handle's type safety. More...
class	Audio
	Holds decoded PCM audio data as an engine asset. More...
class	AudioAssetManager
	Manages audio assets by filesystem path, providing dedup and lookup. More...
struct	AudioData
	Decoded audio data ready for playback. More...
struct	AudioFlowHandle
	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. More...
class	AudioFlowLoader
	Imports audio flows from an exported glTF asset. More...
class	AudioFlowStore
	Registry for audio flows keyed by (glTF path, flow name). More...
class	CubemapTexture
	Owns Vulkan resources for a sampled cubemap texture. More...
struct	CubemapTextureData
	CPU-side RGBA cubemap image data. More...
class	CubemapTextureLoader
	Loads cubemap face images from a directory. More...
class	ExrTextureAsset
	Extension of TextureAsset and stores the Exr header information as well as the texture data. More...
struct	FlowSettingHandle
	Stable handle to a named, runtime-controllable setting of a flow. More...
class	GltfTextureAsset
	Extension of TextureAsset for images loaded from glTF files (PNG/JPG) More...
struct	Joint
	A single joint in a skeleton hierarchy. More...
class	Material
	the 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 More...
class	MaterialAssetManager
	Asset manager for materials keyed by source file path and material name. More...
class	Mesh
	The mesh asset stores geometry data and. More...
class	MeshAssetManager
	Stores mesh data with their primitives. More...
struct	NullAssetHandle
	Explicit null value assignable to any typed asset handle. More...
class	RuntimeMaterialLease
	Move-only ownership of a material created at runtime. More...
class	RuntimeTexture
	Runtime-owned Vulkan texture resource. More...
class	RuntimeTextureDescriptorLease
	Move-only ownership of one runtime texture descriptor slot. More...
class	Skin
	Skeleton definition loaded from glTF skin data. More...
class	SkinAssetManager
	Stores skin and skeleton binding data keyed by source mesh path. More...
class	Texture
	Wrapper for texture data. More...
class	TextureAssetManager
	Asset manager for texture assets keyed by filesystem path. More...
class	TextureHandle
	Type-erased texture handle for runtime storage. More...
class	TypedTextureHandle
	Type-safe texture handle wrapper providing compile-time type safety. More...

Typedefs
using	AnimationAssetRef = Asset::Ref<Asset::MeshPath, Animation>
	Asset reference to an animation loaded from a mesh asset path.
using	SkinAssetRef = Asset::Ref<Asset::MeshPath, Skin>
	Asset reference to skin binding data loaded from a mesh asset path.
using	GltfHandle = AssetHandle<GltfHandleTag>
	Handle to a glTF container file.
using	GltfRenderableHandle = AssetHandle<GltfRenderableHandleTag>
	Handle to one mesh-bearing node inside a glTF file.
using	GeometryMeshHandle = AssetHandle<GeometryMeshHandleTag>
	Handle to non-skinned mesh geometry.
using	MaterialHandle = AssetHandle<MaterialHandleTag>
	Handle to a material payload.
using	Texture2DHandle = AssetHandle<Texture2DHandleTag>
	Handle to a file-backed sampled 2D texture.
using	CubemapTextureHandle = AssetHandle<CubemapTextureHandleTag>
	Handle to a cubemap texture.
using	RenderTargetTextureHandle = AssetHandle<RenderTargetTextureHandleTag>
	Handle to a renderer-created texture that render passes write into.
using	FontAtlasTextureHandle = AssetHandle<FontAtlasTextureHandleTag>
	Handle to the generated texture atlas backing a font.
using	AudioClipHandle = AssetHandle<AudioClipHandleTag>
	Handle to audio clip asset data.
using	SkeletalMeshHandle = AssetHandle<SkeletalMeshHandleTag>
	Handle to skinned mesh geometry.
using	AnimationClipHandle = AssetHandle<AnimationClipHandleTag>
	Handle to an animation clip.
using	SkinHandle = AssetHandle<SkinHandleTag>
	Handle to skin binding data.
using	SkeletonHandle = AssetHandle<SkeletonHandleTag>
	Handle to skeleton metadata.
using	FontHandle = AssetHandle<FontHandleTag>
	Handle to a font asset.
using	AudioAssetRef = Asset::Ref<Asset::Path, Audio>
	Asset reference to decoded audio data loaded from a filesystem path.
using	MaterialAssetRef = Asset::Ref<Asset::MeshPath, Material>
	Asset reference to material data loaded from a mesh asset path.
using	MeshAssetRef = Asset::Ref<Asset::MeshPath, Mesh>
	Asset reference to mesh geometry loaded from a mesh asset path.
using	TextureAssetRef = Asset::Ref<Asset::Path, Texture>
	Asset reference to a texture loaded from a filesystem path.

Enumerations
enum class	TextureType : uint8_t { BaseColor , Normal , MetallicRoughness , Emissive , Lightmap , Unknown }
	Represents the semantic type of a texture, determining its Vulkan format. More...

Functions
constexpr VkFormat	getVkFormat (TextureType type, int bits, int components)
	Get the correct VkFormat based on texture type and image properties.
constexpr bool	requiresLinearFormat (TextureType type)
	Check if a texture type requires linear (non-SRGB) format.

Variables
constexpr NullAssetHandle	Null {}
	Null value assignable to any typed asset handle.

Typedef Documentation

◆ AnimationAssetRef

using Engine::Assets::AnimationAssetRef = Asset::Ref<Asset::MeshPath, Animation>

Asset reference to an animation loaded from a mesh asset path.

Definition at line 13 of file AnimationAssetRef.h.

◆ AnimationClipHandle

using Engine::Assets::AnimationClipHandle = AssetHandle<AnimationClipHandleTag>

Handle to an animation clip.

Animation clips describe keyed motion and must be bound against skeleton metadata before fast evaluation. The handle is separate from SkeletonHandle so the same clip can be reused or rejected based on the target skeleton.

Definition at line 199 of file AssetHandles.h.

◆ AudioAssetRef

using Engine::Assets::AudioAssetRef = Asset::Ref<Asset::Path, Audio>

Asset reference to decoded audio data loaded from a filesystem path.

Definition at line 15 of file AudioAssetRef.h.

◆ AudioClipHandle

using Engine::Assets::AudioClipHandle = AssetHandle<AudioClipHandleTag>

Handle to audio clip asset data.

This refers to decoded or streamable clip data loaded from an authored path. It is not a playback-instance handle; starting playback should return a separate handle for the active sound if the caller needs to stop or modify that instance.

Definition at line 181 of file AssetHandles.h.

◆ CubemapTextureHandle

using Engine::Assets::CubemapTextureHandle = AssetHandle<CubemapTextureHandleTag>

Handle to a cubemap texture.

Cubemaps use different loading, dimensionality, descriptors, and shader expectations than ordinary 2D textures, so keeping a separate handle type prevents accidental assignment to a material slot that expects a flat sampled texture.

Definition at line 154 of file AssetHandles.h.

◆ FontAtlasTextureHandle

using Engine::Assets::FontAtlasTextureHandle = AssetHandle<FontAtlasTextureHandleTag>

Handle to the generated texture atlas backing a font.

Font atlases are produced and owned by font/UI systems rather than authored as standalone texture files. Keeping them separate from Texture2DHandle makes atlas regeneration and glyph ownership visible at the type level.

Definition at line 172 of file AssetHandles.h.

◆ FontHandle

using Engine::Assets::FontHandle = AssetHandle<FontHandleTag>

Handle to a font asset.

The font owns face configuration, glyph metrics, and its atlas relationship. Code that only samples glyph pixels should use the atlas texture handle; code that lays out text needs the font handle.

Definition at line 226 of file AssetHandles.h.

◆ GeometryMeshHandle

using Engine::Assets::GeometryMeshHandle = AssetHandle<GeometryMeshHandleTag>

Handle to non-skinned mesh geometry.

This identifies the geometry payload: vertices, indices, primitives, bounds, and generated meshlet data. It deliberately does not carry authored node transform or material bindings; keep the GltfRenderableHandle when those node-level details matter.

Definition at line 126 of file AssetHandles.h.

◆ GltfHandle

using Engine::Assets::GltfHandle = AssetHandle<GltfHandleTag>

Handle to a glTF container file.

Loading this handle imports metadata for the file and creates handles for its renderable nodes, geometry meshes, and primitive materials. Use it when you mean "this source file and everything it declares". Do not use it as a drawable object; ask GltfStore for a GltfRenderableHandle when you need a specific node.

Definition at line 107 of file AssetHandles.h.

◆ GltfRenderableHandle

using Engine::Assets::GltfRenderableHandle = AssetHandle<GltfRenderableHandleTag>

Handle to one mesh-bearing node inside a glTF file.

This is the handle to use for spawning or component setup because it preserves node-level data: node name, node index, authored transform, static/lightmap metadata, geometry handle, and per-primitive material handles. Multiple renderables can reference the same geometry while still having different transforms or material bindings.

Definition at line 117 of file AssetHandles.h.

◆ MaterialAssetRef

using Engine::Assets::MaterialAssetRef = Asset::Ref<Asset::MeshPath, Material>

Asset reference to material data loaded from a mesh asset path.

Definition at line 13 of file MaterialAssetRef.h.

◆ MaterialHandle

using Engine::Assets::MaterialHandle = AssetHandle<MaterialHandleTag>

Handle to a material payload.

Materials are resolved separately from geometry so a mesh component can override primitive materials without changing the geometry handle. Lightmapped glTF nodes can produce per-node material handles even when they originate from the same authored glTF material.

Definition at line 135 of file AssetHandles.h.

◆ MeshAssetRef

using Engine::Assets::MeshAssetRef = Asset::Ref<Asset::MeshPath, Mesh>

Asset reference to mesh geometry loaded from a mesh asset path.

Definition at line 13 of file MeshAssetRef.h.

◆ RenderTargetTextureHandle

using Engine::Assets::RenderTargetTextureHandle = AssetHandle<RenderTargetTextureHandleTag>

Handle to a renderer-created texture that render passes write into.

Render targets have layout, synchronization, lifetime, and per-frame ownership concerns that file-backed textures do not have. Passing one where a Texture2DHandle is expected should be an explicit conversion to a sampled view, not an accidental type match.

Definition at line 163 of file AssetHandles.h.

◆ SkeletalMeshHandle

using Engine::Assets::SkeletalMeshHandle = AssetHandle<SkeletalMeshHandleTag>

Handle to skinned mesh geometry.

Skinned meshes need vertex skinning attributes and bindings to skeleton/skin data, so they are intentionally distinct from GeometryMeshHandle. Static mesh code should not be able to accept one by accident.

Definition at line 190 of file AssetHandles.h.

◆ SkeletonHandle

using Engine::Assets::SkeletonHandle = AssetHandle<SkeletonHandleTag>

Handle to skeleton metadata.

Skeleton data is the joint hierarchy, rest pose, and joint names used by skins and animation clips. Keeping it separate from SkinHandle avoids coupling reusable animation/skeleton data to one mesh's bind-pose data.

Definition at line 217 of file AssetHandles.h.

◆ SkinAssetRef

using Engine::Assets::SkinAssetRef = Asset::Ref<Asset::MeshPath, Skin>

Asset reference to skin binding data loaded from a mesh asset path.

Definition at line 13 of file SkinAssetRef.h.

◆ SkinHandle

using Engine::Assets::SkinHandle = AssetHandle<SkinHandleTag>

Handle to skin binding data.

A skin connects mesh vertices to skeleton joints and stores data such as inverse bind matrices. It is separate from SkeletonHandle because multiple skins can reference the same skeleton with different mesh bindings.

Definition at line 208 of file AssetHandles.h.

◆ Texture2DHandle

using Engine::Assets::Texture2DHandle = AssetHandle<Texture2DHandleTag>

Handle to a file-backed sampled 2D texture.

This is the asset-registry handle for authored texture references. The store also records the texture usage and bridges to the current TextureHandleRegistry descriptor handle used by material upload. The same source path should not be treated as different semantic texture types without an explicit store policy.

Definition at line 145 of file AssetHandles.h.

◆ TextureAssetRef

using Engine::Assets::TextureAssetRef = Asset::Ref<Asset::Path, Texture>

Asset reference to a texture loaded from a filesystem path.

Definition at line 15 of file TextureAssetRef.h.

Enumeration Type Documentation

◆ TextureType

enum class Engine::Assets::TextureType : uint8_t

strong

Represents the semantic type of a texture, determining its Vulkan format.

Different texture types require different VkFormats for correct rendering:

Color textures (BaseColor, Emissive) need SRGB formats for gamma-correct rendering
Linear data textures (Normal, MetallicRoughness) need UNORM formats
HDR textures (Lightmap) need floating-point formats

Enumerator
BaseColor	Color data with gamma (SRGB format for 8-bit)
Normal	Linear data for normal maps (UNORM format for 8-bit)
MetallicRoughness	Linear data for PBR parameters (UNORM format for 8-bit)
Emissive	Color data with gamma (SRGB format for 8-bit)
Lightmap	HDR baked lighting data (SFLOAT format)
Unknown	Fallback type, uses SRGB as default.

Definition at line 15 of file TextureType.h.

Function Documentation

◆ getVkFormat()

VkFormat Engine::Assets::getVkFormat	(	TextureType	type,
		int	bits,
		int	components )

constexpr

Get the correct VkFormat based on texture type and image properties.

This function centralizes format selection logic, ensuring that:

Normal maps use LINEAR formats (VK_FORMAT_R8G8B8A8_UNORM)
Color textures use SRGB formats (VK_FORMAT_R8G8B8A8_SRGB)
HDR textures use floating-point formats

Parameters

type	The semantic type of the texture
bits	Bits per component (8, 16, or 32)
components	Number of color components (1-4)

Returns: The appropriate VkFormat for the texture

Definition at line 37 of file TextureType.h.

References BaseColor, Emissive, Lightmap, MetallicRoughness, Normal, and Unknown.

◆ requiresLinearFormat()

bool Engine::Assets::requiresLinearFormat ( TextureType type )

constexpr

Check if a texture type requires linear (non-SRGB) format.

Parameters

type	The texture type to check

Returns: true if the texture should use LINEAR/UNORM format, false for SRGB

Definition at line 129 of file TextureType.h.