Meshlet GLTF processor

Cargo.toml

@@ -1022,21 +1022,13 @@ wasm = false
 name = "meshlet"
 path = "examples/3d/meshlet.rs"
 doc-scrape-examples = true
-required-features = ["meshlet"]
+required-features = ["meshlet_processor", "asset_processor"]
 
 [package.metadata.example.meshlet]
 name = "Meshlet"
 description = "Meshlet rendering for dense high-poly scenes (experimental)"
 category = "3D Rendering"
 wasm = false
-setup = [
-  [
-    "curl",
-    "-o",
-    "assets/models/bunny.meshlet_mesh",
-    "https://raw.githubusercontent.com/JMS55/bevy_meshlet_asset/bd869887bc5c9c6e74e353f657d342bef84bacd8/bunny.meshlet_mesh",
-  ],
-]
 
 [[example]]
 name = "lightmaps"

assets/models/bunny.gltf.meta

@@ -0,0 +1,10 @@
+(
+    meta_format_version: "1.0",
+    asset: Process(
+        processor: "MeshletMeshProcessor",
+        settings: (
+            loader_settings: (),
+            saver_settings: (),
+        ),
+    ),
+)

crates/bevy_asset/src/lib.rs

@@ -283,6 +283,14 @@ pub trait AssetApp {
     fn register_asset_loader<L: AssetLoader>(&mut self, loader: L) -> &mut Self;
     /// Registers the given `processor` in the [`App`]'s [`AssetProcessor`].
     fn register_asset_processor<P: Process>(&mut self, processor: P) -> &mut Self;
+    /// Registers the given `processor` in the [`App`]'s [`AssetProcessor`] along with an extra alias.
+    ///
+    /// This alias can be used in meta files to refer to this asset processor without using the full type name.
+    fn register_asset_processor_with_alias<P: Process>(
+        &mut self,
+        processor: P,
+        alias: &'static str,
+    ) -> &mut Self;
     /// Registers the given [`AssetSourceBuilder`] with the given `id`.
     ///
     /// Note that asset sources must be registered before adding [`AssetPlugin`] to your application,
@@ -331,6 +339,17 @@ impl AssetApp for App {
         self
     }
 
+    fn register_asset_processor_with_alias<P: Process>(
+        &mut self,
+        processor: P,
+        alias: &'static str,
+    ) -> &mut Self {
+        if let Some(asset_processor) = self.world().get_resource::<AssetProcessor>() {
+            asset_processor.register_processor_with_alias(processor, alias);
+        }
+        self
+    }
+
     fn register_asset_source(
         &mut self,
         id: impl Into<AssetSourceId<'static>>,

crates/bevy_asset/src/processor/mod.rs

@@ -49,7 +49,7 @@ use crate::io::{AssetReader, AssetWriter};
 /// [`AssetProcessor`] can be run in the background while a Bevy App is running. Changes to assets will be automatically detected and hot-reloaded.
 ///
 /// Assets will only be re-processed if they have been changed. A hash of each asset source is stored in the metadata of the processed version of the
-/// asset, which is used to determine if the asset source has actually changed.  
+/// asset, which is used to determine if the asset source has actually changed.
 ///
 /// A [`ProcessorTransactionLog`] is produced, which uses "write-ahead logging" to make the [`AssetProcessor`] crash and failure resistant. If a failed/unfinished
 /// transaction from a previous run is detected, the affected asset(s) will be re-processed.
@@ -489,6 +489,16 @@ impl AssetProcessor {
         process_plans.insert(std::any::type_name::<P>(), Arc::new(processor));
     }
 
+    /// Register a new asset processor with an alias.
+    pub fn register_processor_with_alias<P: Process>(&self, processor: P, alias: &'static str) {
+        let mut process_plans = self.data.processors.write();
+        #[cfg(feature = "trace")]
+        let processor = InstrumentedAssetProcessor(processor);
+        let processor = Arc::new(processor);
+        process_plans.insert(alias, processor.clone());
+        process_plans.insert(std::any::type_name::<P>(), processor);
+    }
+
     /// Set the default processor for the given `extension`. Make sure `P` is registered with [`AssetProcessor::register_processor`].
     pub fn set_default_processor<P: Process>(&self, extension: &str) {
         let mut default_processors = self.data.default_processors.write();

crates/bevy_gltf/Cargo.toml

@@ -12,6 +12,10 @@ keywords = ["bevy"]
 dds = ["bevy_render/dds"]
 pbr_transmission_textures = ["bevy_pbr/pbr_transmission_textures"]
 pbr_multi_layer_material_textures = []
+# Enables the meshlet renderer for dense high-poly scenes (experimental)
+meshlet = ["bevy_pbr/meshlet"]
+# Enables processing meshes into meshlet meshes
+meshlet_processor = ["meshlet", "bevy_pbr/meshlet_processor"]
 
 [dependencies]
 # bevy

crates/bevy_gltf/src/lib.rs

@@ -15,6 +15,8 @@ use bevy_animation::AnimationClip;
 use bevy_utils::HashMap;
 
 mod loader;
+#[cfg(feature = "meshlet")]
+mod meshlet_saver;
 mod vertex_attributes;
 pub use loader::*;
 
@@ -55,26 +57,44 @@ impl GltfPlugin {
 impl Plugin for GltfPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<GltfExtras>()
+            .init_asset::<RawGltf>()
             .init_asset::<Gltf>()
             .init_asset::<GltfNode>()
             .init_asset::<GltfPrimitive>()
             .init_asset::<GltfMesh>()
             .preregister_asset_loader::<GltfLoader>(&["gltf", "glb"]);
+
+        #[cfg(feature = "meshlet")]
+        app.register_asset_processor_with_alias::<bevy_asset::processor::LoadAndSave<RawGltfLoader, meshlet_saver::MeshletMeshGltfSaver>>(
+                meshlet_saver::MeshletMeshGltfSaver.into(),
+                "MeshletMeshProcessor"
+            );
     }
 
     fn finish(&self, app: &mut App) {
         let supported_compressed_formats = match app.world().get_resource::<RenderDevice>() {
             Some(render_device) => CompressedImageFormats::from_features(render_device.features()),
             None => CompressedImageFormats::NONE,
         };
+
+        app.register_asset_loader(RawGltfLoader);
         app.register_asset_loader(GltfLoader {
             supported_compressed_formats,
             custom_vertex_attributes: self.custom_vertex_attributes.clone(),
         });
     }
 }
 
-/// Representation of a loaded glTF file.
+/// Underlying JSON Representation of a loaded glTF file.
+#[derive(Asset, Debug, TypePath)]
+pub struct RawGltf {
+    /// The JSON section of a glTF file.
+    pub gltf: gltf::Gltf,
+    /// The buffers of a glTF file, whether from the GLB BIN section, or from external bin files.
+    pub buffer_data: Vec<Vec<u8>>,
+}
+
+/// Bevy representation of a loaded glTF file.
 #[derive(Asset, Debug, TypePath)]
 pub struct Gltf {
     /// All scenes loaded from the glTF file.
@@ -140,6 +160,11 @@ pub struct GltfMesh {
 pub struct GltfPrimitive {
     /// Topology to be rendered.
     pub mesh: Handle<Mesh>,
+    /// Meshlet topology to be rendered.
+    ///
+    /// If this is Some, then `mesh` is [`Handle::default()`].
+    #[cfg(feature = "meshlet")]
+    pub meshlet_mesh: Option<Handle<bevy_pbr::experimental::meshlet::MeshletMesh>>,
     /// Material to apply to the `mesh`.
     pub material: Option<Handle<StandardMaterial>>,
     /// Additional data.