Struct AssetServer 

pub struct AssetServer {
    pub geometries: Arc<AssetStorage<GeometryHandle, Geometry>>,
    pub materials: Arc<AssetStorage<MaterialHandle, Material>>,
    pub images: Arc<AssetStorage<ImageHandle, Image>>,
    pub textures: Arc<AssetStorage<TextureHandle, Texture>>,
    pub prefabs: Arc<AssetStorage<PrefabHandle, Arc<Prefab>>>,
    pub sss_registry: Arc<RwLock<RawRwLock, SssRegistry>>,
    pub default_white_texture: TextureHandle,
    pub default_black_texture: TextureHandle,
    pub default_normal_texture: TextureHandle,
    /* private fields */
}

Central asset manager for the engine.

AssetServer is lightweight and Clone-friendly — all inner state lives behind Arc. Cloning the server gives access to the same storage, channels, and default resources.

Fire-and-Forget Loading

The primary loading API (load_texture, load_hdr_texture, etc.) returns a handle immediately and schedules the actual I/O + decode on a background task. Call process_loading_events once per frame (the engine does this automatically) to promote completed loads into the storage.

Until the data arrives the handle’s slot is Loading, so AssetStorage::get returns None. The render pipeline is designed to fall back to default placeholder textures in this case.

UUID-Based Deduplication

Every fire-and-forget load generates a deterministic UUID v5 from the resource URI and its loading parameters (color space, mipmap, etc.). Requesting the same resource twice returns the same handle without spawning a redundant background task.

Fields

geometries: Arc<AssetStorage<GeometryHandle, Geometry>>

materials: Arc<AssetStorage<MaterialHandle, Material>>

images: Arc<AssetStorage<ImageHandle, Image>>

textures: Arc<AssetStorage<TextureHandle, Texture>>

prefabs: Arc<AssetStorage<PrefabHandle, Arc<Prefab>>>

sss_registry: Arc<RwLock<RawRwLock, SssRegistry>>

default_white_texture: TextureHandle

1×1 white RGBA texture, used as fallback for albedo maps.

default_black_texture: TextureHandle

1×1 black RGBA texture, used as fallback for emission / AO maps.

default_normal_texture: TextureHandle

1×1 flat normal map ([128, 128, 255, 255]).

Implementations

impl AssetServer

pub fn new() -> AssetServer

pub fn load_texture( &self, source: impl AssetSource, color_space: ColorSpace, generate_mipmaps: bool, ) -> TextureHandle

Loads a 2D texture, returning a handle immediately.

The underlying Image is loaded asynchronously and deduplicated by URI alone. The Texture descriptor is created synchronously with the requested colour-space and mipmap settings, and is immediately available for material binding.

Until the Image data arrives the render pipeline substitutes a default placeholder texture.

pub fn load_hdr_texture(&self, source: impl AssetSource) -> TextureHandle

Loads an HDR environment map, returning a handle immediately.

Deduplicated by URI.

pub fn load_lut_texture(&self, source: impl AssetSource) -> TextureHandle

Loads a 3D LUT from a .cube or .bin file, returning a handle immediately.

Deduplicated by URI.

pub fn load_cube_texture( &self, sources: [impl AssetSource; 6], color_space: ColorSpace, generate_mipmaps: bool, ) -> TextureHandle

Loads a cube map texture from 6 face images, returning a handle immediately.

The six underlying face images are combined into a single Image asset, loaded asynchronously and deduplicated by the composite URI of all six faces.

pub fn load_gltf(&self, source: impl AssetSource) -> PrefabHandle

Loads a glTF/GLB model, returning a PrefabHandle immediately.

The handle can be polled via AssetStorage::get on prefabs to check when loading completes. Completed loads are promoted automatically by process_loading_events.

Deduplicated by URI — loading the same model twice returns the same handle without spawning a redundant parsing task.

pub fn process_loading_events(&self)

Processes all completed background loads (images and prefabs), promoting Loading slots to Loaded (or Failed).

This is called automatically by [Engine::update] each frame.

pub fn load_texture_blocking( &self, source: impl AssetSource, color_space: ColorSpace, generate_mipmaps: bool, ) -> Result<TextureHandle, Error>

Loads a 2D texture synchronously, blocking the calling thread.

Delegates to the fire-and-forget entry point for full UUID deduplication, then blocks until the underlying Image is ready.

Prefer load_texture for non-blocking loads.

pub fn load_cube_texture_blocking( &self, sources: [impl AssetSource; 6], color_space: ColorSpace, generate_mipmaps: bool, ) -> Result<TextureHandle, Error>

Loads a cube map synchronously, blocking the calling thread.

Delegates to the fire-and-forget entry point for full UUID deduplication, then blocks until the underlying Image is ready.

pub fn load_hdr_texture_blocking( &self, source: impl AssetSource, ) -> Result<TextureHandle, Error>

Loads an HDR texture synchronously, blocking the calling thread.

pub fn load_lut_texture_blocking( &self, source: impl AssetSource, ) -> Result<TextureHandle, Error>

Loads a 3D LUT synchronously, blocking the calling thread.

pub async fn load_texture_async( &self, source: impl AssetSource, color_space: ColorSpace, generate_mipmaps: bool, ) -> Result<TextureHandle, Error>

Asynchronously loads a 2D texture and waits for the underlying Image to finish decoding.

Internally delegates to the fire-and-forget load_texture and then polls until the image data is available, ensuring full UUID-based deduplication.

pub async fn load_cube_texture_async( &self, sources: [impl AssetSource; 6], color_space: ColorSpace, generate_mipmaps: bool, ) -> Result<TextureHandle, Error>

Asynchronously loads a cube map and waits for the underlying combined Image to finish decoding.

Delegates to the fire-and-forget load_cube_texture.

pub async fn load_hdr_texture_async( &self, source: impl AssetSource, ) -> Result<TextureHandle, Error>

Asynchronously loads an HDR environment map and waits for the underlying Image to finish decoding.

Delegates to the fire-and-forget load_hdr_texture.

pub async fn load_texture_from_bytes_async( &self, name: &str, bytes: Vec<u8>, color_space: ColorSpace, generate_mipmaps: bool, ) -> Result<TextureHandle, Error>

Loads a 2D texture from raw bytes.

Bytes-based loads cannot be URI-deduplicated, but still honour the decoupled Image / Texture architecture.

pub async fn load_hdr_texture_from_bytes_async( &self, name: &str, bytes: Vec<u8>, ) -> Result<TextureHandle, Error>

Loads an HDR environment map from raw bytes.

pub async fn load_lut_texture_async( &self, source: impl AssetSource, ) -> Result<TextureHandle, Error>

Asynchronously loads a 3D LUT from a .cube file and waits for the underlying Image to finish decoding.

Delegates to the fire-and-forget load_lut_texture.

pub async fn load_lut_texture_from_bytes_async( &self, name: &str, bytes: Vec<u8>, ) -> Result<TextureHandle, Error>

Loads a 3D LUT from raw bytes.

pub fn checkerboard(&self, size: u32, squares: u32) -> TextureHandle

Creates a simple checkerboard texture (useful for testing).

pub fn invalidate_texture(&self, type_tag: &str, uri: &str, params: &str)

Invalidates a cached texture so a fresh reload can be dispatched.

Use this when the underlying file has been replaced on disk (same URI but different content). The next call to [load_texture] with the same parameters will trigger a new background I/O task.

pub fn reload_texture( &self, source: impl AssetSource, color_space: ColorSpace, generate_mipmaps: bool, ) -> TextureHandle

Convenience wrapper: invalidate and immediately re-dispatch a 2D texture load. Returns the (same or new) handle.

pub fn invalidate_all_textures(&self)

Invalidates all UUID-cached textures, forcing a full reload on subsequent load requests.

pub fn invalidate_prefab(&self, uri: &str)

Invalidates a cached prefab so a fresh reload can be dispatched.

Trait Implementations

impl Clone for AssetServer

fn clone(&self) -> AssetServer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for AssetServer

fn default() -> AssetServer

Returns the “default value” for a type.

impl GeometryQuery for AssetServer

fn get_geometry_bbox(&self, handle: GeometryHandle) -> Option<BoundingBox>