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, .. } => { /* ... */ }
    }
}