Implement preview workflow

Author: Sieluna

crates/bevy_asset_preview/Cargo.toml

@@ -4,8 +4,8 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-bevy.workspace = true
-image = "0.25"
+bevy = { workspace = true, features = ["webp"] }
+image = { version = "0.25", features = ["webp"] }
 
 [dev-dependencies]
 tempfile = "3"

crates/bevy_asset_preview/src/asset/saver.rs

@@ -83,7 +83,15 @@ pub fn save_image<'a>(
 
     let task_pool = IoTaskPool::get();
     let target_path_clone = target_path.clone();
-    let target_path_for_writer = target_path.path().to_path_buf();
+    // Ensure the file extension is .webp for WebP format
+    let mut target_path_for_writer = target_path.path().to_path_buf();
+    if let Some(ext) = target_path_for_writer.extension() {
+        if ext.to_str() != Some("webp") {
+            target_path_for_writer.set_extension("webp");
+        }
+    } else {
+        target_path_for_writer.set_extension("webp");
+    }
 
     task_pool.spawn(async move {
         // Create directory first
@@ -97,12 +105,12 @@ pub fn save_image<'a>(
 
         // Encode PNG directly to memory
         let mut cursor = Cursor::new(Vec::new());
-        match rgba_image.write_to(&mut cursor, image::ImageFormat::Png) {
+        match rgba_image.write_to(&mut cursor, image::ImageFormat::WebP) {
             Ok(_) => {
-                let png_bytes = cursor.into_inner();
+                let webp_bytes = cursor.into_inner();
                 // Write via AssetWriter (atomic operation)
                 match writer
-                    .write_bytes(&target_path_for_writer, &png_bytes)
+                    .write_bytes(&target_path_for_writer, &webp_bytes)
                     .await
                 {
                     Ok(_) => {
@@ -118,7 +126,7 @@ pub fn save_image<'a>(
                 }
             }
             Err(e) => {
-                let error = format!("Failed to encode image to PNG: {:?}", e);
+                let error = format!("Failed to encode image to WebP: {:?}", e);
                 bevy::log::error!("{}", error);
                 Err(error)
             }

crates/bevy_asset_preview/src/lib.rs

@@ -1,7 +1,9 @@
 mod asset;
+mod preview;
 mod ui;
 
 pub use asset::*;
+pub use preview::*;
 pub use ui::*;
 
 use bevy::prelude::*;
@@ -13,10 +15,41 @@ use bevy::prelude::*;
 /// So long as the assets are unchanged, the previews will be cached and will not need to be re-rendered.
 /// In theory this can be done passively in the background, and the previews will be ready when the user needs them.
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum AssetPreviewType {
+    Image,
+    GLTF,
+    Scene,
+    Other,
+}
+
 pub struct AssetPreviewPlugin;
 
 impl Plugin for AssetPreviewPlugin {
-    fn build(&self, _app: &mut App) {
+    fn build(&self, app: &mut App) {
+        // Initialize resources
+        app.init_resource::<AssetLoader>();
+        app.init_resource::<PreviewCache>();
+
+        // Register events
+        app.add_event::<asset::AssetLoadCompleted>();
+        app.add_event::<asset::AssetLoadFailed>();
+        app.add_event::<asset::AssetHotReloaded>();
+
+        // Register systems
+        // Process preview requests and submit to loader
+        app.add_systems(Update, ui::preview_handler);
+
+        // Process load queue (starts new load tasks)
+        app.add_systems(Update, asset::process_load_queue);
+
+        // Handle asset events (completion, failures, hot reloads)
+        app.add_systems(Update, asset::handle_asset_events);
 
+        // Handle preview load completion and update UI
+        app.add_systems(
+            Update,
+            ui::handle_preview_load_completed.after(asset::handle_asset_events),
+        );
     }
 }

crates/bevy_asset_preview/src/preview/cache.rs

@@ -0,0 +1,105 @@
+use bevy::{
+    asset::{AssetId, AssetPath},
+    image::Image,
+    platform::collections::HashMap,
+    prelude::{Handle, Resource},
+};
+
+/// Cache entry for a preview image.
+#[derive(Clone, Debug)]
+pub struct PreviewCacheEntry {
+    /// The preview image handle.
+    pub image_handle: Handle<Image>,
+    /// The asset ID that this preview is for.
+    pub asset_id: AssetId<Image>,
+    /// Timestamp when the preview was generated (for cache invalidation).
+    pub timestamp: u64,
+}
+
+/// Cache for preview images to avoid re-rendering unchanged assets.
+#[derive(Resource, Default)]
+pub struct PreviewCache {
+    /// Maps asset path to cache entry.
+    path_cache: HashMap<AssetPath<'static>, PreviewCacheEntry>,
+    /// Maps asset ID to cache entry.
+    id_cache: HashMap<AssetId<Image>, PreviewCacheEntry>,
+}
+
+impl PreviewCache {
+    /// Creates a new empty cache.
+    pub fn new() -> Self {
+        Self {
+            path_cache: HashMap::new(),
+            id_cache: HashMap::new(),
+        }
+    }
+
+    /// Gets a cached preview by asset path.
+    pub fn get_by_path<'a>(&self, path: &AssetPath<'a>) -> Option<&PreviewCacheEntry> {
+        // Convert to owned path for lookup
+        let owned_path: AssetPath<'static> = path.clone().into_owned();
+        self.path_cache.get(&owned_path)
+    }
+
+    /// Gets a cached preview by asset ID.
+    pub fn get_by_id(&self, asset_id: AssetId<Image>) -> Option<&PreviewCacheEntry> {
+        self.id_cache.get(&asset_id)
+    }
+
+    /// Inserts a preview into the cache.
+    pub fn insert<'a>(
+        &mut self,
+        path: impl Into<AssetPath<'a>>,
+        asset_id: AssetId<Image>,
+        image_handle: Handle<Image>,
+        timestamp: u64,
+    ) {
+        let path: AssetPath<'static> = path.into().into_owned();
+        let entry = PreviewCacheEntry {
+            image_handle,
+            asset_id,
+            timestamp,
+        };
+        self.path_cache.insert(path.clone(), entry.clone());
+        self.id_cache.insert(asset_id, entry);
+    }
+
+    /// Removes a preview from the cache by path.
+    pub fn remove_by_path<'a>(&mut self, path: &AssetPath<'a>) -> Option<PreviewCacheEntry> {
+        // Convert to owned path for lookup
+        let owned_path: AssetPath<'static> = path.clone().into_owned();
+        if let Some(entry) = self.path_cache.remove(&owned_path) {
+            self.id_cache.remove(&entry.asset_id);
+            Some(entry)
+        } else {
+            None
+        }
+    }
+
+    /// Removes a preview from the cache by asset ID.
+    pub fn remove_by_id(&mut self, asset_id: AssetId<Image>) -> Option<PreviewCacheEntry> {
+        if let Some(entry) = self.id_cache.remove(&asset_id) {
+            // Find and remove from path cache
+            self.path_cache.retain(|_, e| e.asset_id != asset_id);
+            Some(entry)
+        } else {
+            None
+        }
+    }
+
+    /// Clears all cached previews.
+    pub fn clear(&mut self) {
+        self.path_cache.clear();
+        self.id_cache.clear();
+    }
+
+    /// Returns the number of cached previews.
+    pub fn len(&self) -> usize {
+        self.path_cache.len()
+    }
+
+    /// Checks if the cache is empty.
+    pub fn is_empty(&self) -> bool {
+        self.path_cache.is_empty()
+    }
+}

crates/bevy_asset_preview/src/preview/mod.rs

@@ -0,0 +1,54 @@
+mod cache;
+mod systems;
+
+use bevy::{asset::RenderAssetUsages, image::Image};
+pub use cache::{PreviewCache, PreviewCacheEntry};
+pub use systems::{
+    PendingPreviewRequest, PreviewFailed, PreviewReady, PreviewTaskManager,
+    handle_image_preview_events, request_image_preview,
+};
+
+/// Maximum preview size for 2D images (256x256).
+const MAX_PREVIEW_SIZE: u32 = 256;
+
+/// Resizes an image to preview size if it's larger than the maximum.
+/// Returns a new compressed image, or None if the image is already small enough.
+pub fn compress_image_for_preview(image: &Image) -> Option<Image> {
+    let width = image.width();
+    let height = image.height();
+
+    // If image is already small enough, return None (use original)
+    if width <= MAX_PREVIEW_SIZE && height <= MAX_PREVIEW_SIZE {
+        return None;
+    }
+
+    // Calculate new size maintaining aspect ratio
+    let (new_width, new_height) = if width > height {
+        (
+            MAX_PREVIEW_SIZE,
+            (height as f32 * MAX_PREVIEW_SIZE as f32 / width as f32) as u32,
+        )
+    } else {
+        (
+            (width as f32 * MAX_PREVIEW_SIZE as f32 / height as f32) as u32,
+            MAX_PREVIEW_SIZE,
+        )
+    };
+
+    // Convert to dynamic image for resizing
+    let dynamic_image = match image.clone().try_into_dynamic() {
+        Ok(img) => img,
+        Err(_) => return None,
+    };
+
+    // Resize using high-quality filter
+    let resized =
+        dynamic_image.resize_exact(new_width, new_height, image::imageops::FilterType::Lanczos3);
+
+    // Convert back to Image
+    Some(Image::from_dynamic(
+        resized,
+        true, // is_srgb
+        RenderAssetUsages::RENDER_WORLD,
+    ))
+}