Crate astrelis_assets 

Astrelis Assets - Type-safe asset management system

This crate provides a comprehensive asset management system with:

• Typed handles with generational IDs for O(1) access and use-after-free protection
• Multiple asset sources (disk, memory, raw bytes)
• Pluggable asset loaders
• Async/background loading
• Hot-reload support (disk and memory)
• GPU resource integration hooks
• Event system for change detection

Architecture Overview

┌─────────────────────────────────────────────────────────────────┐
│                        AssetServer                               │
│  - Coordinates all asset operations                             │
│  - Manages type-erased storage                                  │
│  - Dispatches to loaders                                        │
└───────────────────────────┬─────────────────────────────────────┘
                            │
         ┌──────────────────┼──────────────────┐
         ▼                  ▼                  ▼
  ┌─────────────┐   ┌─────────────┐   ┌─────────────┐
  │ Assets<Tex> │   │Assets<Shader│   │Assets<Audio>│
  │  SparseSet  │   │  SparseSet  │   │  SparseSet  │
  └──────┬──────┘   └──────┬──────┘   └──────┬──────┘
         │                 │                 │
         ▼                 ▼                 ▼
  ┌─────────────┐   ┌─────────────┐   ┌─────────────┐
  │AssetEntry<T>│   │AssetEntry<T>│   │AssetEntry<T>│
  │ - state     │   │ - state     │   │ - state     │
  │ - version   │   │ - version   │   │ - version   │
  │ - refcount  │   │ - refcount  │   │ - refcount  │
  └─────────────┘   └─────────────┘   └─────────────┘

Quick Start

use astrelis_assets::prelude::*;

// Create the asset server
let mut server = AssetServer::new();

// Register a loader for textures
server.register_loader::<Texture>(TextureLoader::new());

// Load an asset from disk
let handle: Handle<Texture> = server.load("textures/player.png");

// Check if ready and use
if let Some(texture) = server.get(&handle) {
    // Use the texture...
}

// Poll for events
for event in server.drain_events() {
    match event {
        AssetEvent::Created { handle, .. } => { /* ... */ }
        AssetEvent::Modified { handle, .. } => { /* ... */ }
        AssetEvent::Removed { handle, .. } => { /* ... */ }
    }
}

Re-exports

pub use error::*;

pub use event::*;

pub use handle::*;

pub use loader::*;

pub use server::*;

pub use source::*;

pub use state::*;

pub use storage::*;

Modules

error

Error types for the asset system.

event

Asset events for change detection.

handle

Asset handles - typed references to assets.

hot_reload

Hot reload support for assets during development.

io

Platform-abstracted I/O for asset loading.

loader

Asset loader traits and infrastructure.

prelude

Prelude module for convenient imports

server

Asset server - the main coordinator for asset operations.

source

Asset sources - where assets come from.

state

Asset state machine and version tracking.

storage

Per-type asset storage with reference counting.

Traits

Asset

Marker trait for types that can be managed as assets.