Struct ResourceManager 

pub struct ResourceManager {
    pub vertex_layout_cache: HashMap<VertexLayoutSignature, u64, FxBuildHasher>,
    pub system_textures: SystemTextures,
    /* private fields */
}

Fields

vertex_layout_cache: HashMap<VertexLayoutSignature, u64, FxBuildHasher>

Vertex layout cache: Signature -> ID

system_textures: SystemTextures

Global system fallback textures and Group 3 bind-group infrastructure.

See SystemTextures for the full list of data-semantic fallback textures and the screen bind-group layout / samplers.

Implementations

impl ResourceManager

pub fn prepare_skeleton(&mut self, skeleton: &Skeleton)

Upload skeleton data (current and previous frame joints) to GPU.

pub fn register_internal_texture_direct(&mut self, id: u64, view: TextureView)

Register an internally generated texture (e.g. Render Target)

These textures do not need CPU upload, have no version control, and their lifetime is managed by the caller. Typically called before a RenderPass executes.

Suitable for: Pass-private resources where the Pass itself holds and maintains ID stability. Highest performance, no hash lookup.

pub fn register_internal_texture_by_name( &mut self, name: &str, view: TextureView, ) -> u64

Suitable for: Cross-pass shared resources (e.g. “SceneColor”). Internally maintains a Name -> ID mapping.

pub fn register_internal_texture(&mut self, view: TextureView) -> u64

pub fn release_internal_texture(&mut self, id: u64)

pub fn get_texture_view<'a>(&'a self, source: &TextureSource) -> &'a TextureView

Unified helper method for retrieving TextureView

Prioritizes Asset-converted textures, then registered internal textures, finally returns Dummy

pub fn prepare_mesh( &mut self, assets: &AssetServer, mesh: &mut Mesh, skeleton: Option<&Skeleton>, ) -> Option<BindGroupContext>

Prepare basic resources for a Mesh

Uses an “Ensure -> Collect IDs -> Check Fingerprint -> Rebind” pattern

pub fn get_or_create_layout( &mut self, entries: &[BindGroupLayoutEntry], ) -> (BindGroupLayout, u64)

pub fn create_bind_group( &self, layout: &BindGroupLayout, builder: &ResourceBuilder<'_>, ) -> (BindGroup, u64)

pub fn prepare_global( &mut self, assets: &AssetServer, scene: &Scene, render_state: &RenderState, ) -> u32

Prepare global binding resources

Uses an “Ensure -> Collect IDs -> Check Fingerprint -> Rebind” pattern

pub fn get_global_state( &self, render_state_id: u32, scene_id: u32, ) -> Option<&GpuGlobalState>

impl ResourceManager

pub fn write_buffer_internal( device: &Device, queue: &Queue, gpu_buffers: &mut SlotMap<GpuBufferHandle, GpuBuffer>, buffer_index: &mut HashMap<u64, GpuBufferHandle, FxBuildHasher>, frame_index: u64, buffer_ref: &BufferRef, data: &[u8], ) -> (GpuBufferHandle, EnsureResult)

Upload data for the buffer identified by buffer_ref, creating or resizing the GPU-side buffer as needed.

This is a static method that borrows only the fields it touches, allowing callers to hold references to other ResourceManager members concurrently (e.g. model_allocator).

pub fn ensure_buffer<T>( &mut self, cpu_buffer: &CpuBuffer<T>, ) -> (GpuBufferHandle, EnsureResult)

where T: GpuData,

Ensure the GPU buffer for a [CpuBuffer] exists and contains the latest data.

Uses the CpuBuffer’s internal atomic handle cache for an O(1) fast path on subsequent calls (no hash lookup required).

pub fn ensure_buffer_ref( &mut self, buffer_ref: &BufferRef, data: &[u8], ) -> (GpuBufferHandle, EnsureResult)

Ensure a GPU buffer from a BufferRef and raw byte data.

Used by generic interfaces (e.g. MaterialTrait) that don’t hold a CpuBuffer.

pub fn ensure_buffer_id<T>(&mut self, cpu_buffer: &CpuBuffer<T>) -> u64

where T: GpuData,

Convenience wrapper returning only the physical resource ID.

pub fn prepare_attribute(&mut self, attr: &Attribute) -> EnsureResult

Ensure the GPU buffer for a geometry attribute is created and current.

pub fn prepare_index(&mut self, indices: &IndexAttribute) -> EnsureResult

pub fn prepare_uniform_slot_data( &mut self, slot_id: u64, data: &[u8], label: &str, ) -> EnsureResult

Ensure a uniform slot buffer exists, creating it on first access and uploading new data on subsequent calls when content differs.

pub fn get_gpu_buffer_by_cpu_id(&self, cpu_id: u64) -> Option<&GpuBuffer>

Look up a [GpuBuffer] by the CPU-side buffer ID.

This goes through the buffer_index reverse map and is slightly slower than a direct gpu_buffers.get(handle).

impl ResourceManager

pub fn resolve_gpu_environment( &mut self, assets: &AssetServer, environment: &Environment, ) -> f32

Resolve (or create) the GpuEnvironment for the current scene environment.

This must be called before prepare_global so that the uniform buffer can be populated with the correct env_map_max_mip_level, and so that real resource IDs are available for BindGroup creation.

All GPU textures (cube, PMREM) are created here; IBLComputePass only writes into them — it never creates or removes cache entries.

Returns the resolved env_map_max_mip_level (0.0 if no env map).

pub fn ensure_brdf_lut(&mut self) -> u64

Ensure the global BRDF LUT texture exists.

Creates the texture on first call and sets needs_brdf_compute. Returns the resource ID of the BRDF LUT view.

pub fn get_env_map_max_mip_level(&self, source: Option<TextureSource>) -> f32

Get the env_map_max_mip_level for a given environment source.

impl ResourceManager

pub fn get_geometry(&self, handle: GeometryHandle) -> Option<&GpuGeometry>

pub fn get_or_create_vertex_layout_id( &mut self, layout: &GeneratedVertexLayout, ) -> u64

impl ResourceManager

pub fn get_material(&self, handle: MaterialHandle) -> Option<&GpuMaterial>

impl ResourceManager

pub fn prepare_texture( &mut self, assets: &AssetServer, handle: TextureHandle, ) -> ResourceState

Prepare GPU resources for a Texture asset.

Performs a two-level query: first retrieves the Texture config (always immediately available after AssetServer::load_texture), then checks whether the underlying Image has finished decoding. If the image is not yet ready, no binding is created and the material system falls back to a placeholder texture.

Version tracking ensures GPU resources are only rebuilt when the underlying data actually changes.

pub fn get_texture_binding( &self, handle: TextureHandle, ) -> Option<&TextureBinding>

pub fn get_image(&self, image_handle: ImageHandle) -> Option<&GpuImage>

impl ResourceManager

pub fn new( device: Device, queue: Queue, anisotropy_clamp: u16, ) -> ResourceManager

pub fn next_frame(&mut self)

pub fn frame_index(&self) -> u64

pub fn flush_model_buffers(&mut self)

pub fn allocate_model_uniform(&mut self, data: DynamicModelUniforms) -> u32

Allocate a Model Uniform slot, returning the byte offset

pub fn model_buffer_id(&self) -> u64

Get the current Model Buffer ID for cache validation

pub fn get_cached_bind_group( &self, cached_bind_group_id: u64, ) -> Option<&BindGroupContext>

Quickly retrieve BindGroup data by cached ID

pub fn prune(&mut self, ttl_frames: u64)