Merge branch 'particle-billboard-batch-key'

Author: DoubleStyx

crates/renderide/src/passes/world_mesh_forward/material_batch.rs

@@ -500,7 +500,7 @@ impl<'a> MaterialDrawResolver<'a> {
         {
             bits = remap_variant_bits_for_billboard(source_stem, bits);
         }
-        if crate::particles::is_generated_billboard_mesh_asset_id(item.mesh_asset_id) {
+        if batch_key.uses_render_buffer_billboard {
             Some(ensure_render_buffer_billboard_variant_bits(bits))
         } else {
             source_bits.map(|_| bits)
@@ -692,6 +692,35 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn render_buffer_billboard_draws_split_material_batch_boundaries() {
+        let mut ordinary = dummy_world_mesh_draw_item(DummyDrawItemSpec {
+            material_asset_id: 42,
+            property_block: None,
+            skinned: false,
+            sorting_order: 0,
+            mesh_asset_id: 7,
+            node_id: 1,
+            slot_index: 0,
+            collect_order: 0,
+            alpha_blended: false,
+        });
+        ordinary.batch_key.pipeline = embedded_pipeline("billboardunlit_default");
+        ordinary.batch_key.shader_asset_id = 42;
+
+        let mut render_buffer = ordinary.clone();
+        render_buffer.mesh_asset_id = crate::particles::billboard_render_buffer_mesh_asset_id(3)
+            .expect("valid render-buffer billboard id");
+        render_buffer.batch_key.uses_render_buffer_billboard = true;
+
+        let draws = vec![ordinary, render_buffer];
+        let mut boundaries = Vec::new();
+
+        collect_material_batch_boundaries_into(&draws, &mut boundaries);
+
+        assert_eq!(boundaries, vec![(0, 0), (1, 1)]);
+    }
+
     /// A draw batch snapshot that stayed Null still requires empty group 1 even if routing changes.
     #[test]
     fn stale_draw_batch_pipeline_requires_empty_group1_even_if_current_route_is_embedded() {

crates/renderide/src/world_mesh/draw_prep/tests.rs

@@ -134,6 +134,7 @@ fn property_block_splits_batch_keys() {
         pipeline: RasterPipelineKind::Null,
         shader_asset_id: -1,
         shader_specialization: MaterialShaderSpecializationKey::disabled(),
+        uses_render_buffer_billboard: false,
         material_asset_id: 1,
         property_block_slot0: None,
         skinned: false,
@@ -165,6 +166,7 @@ fn property_block_splits_batch_keys() {
         pipeline: RasterPipelineKind::Null,
         shader_asset_id: -1,
         shader_specialization: MaterialShaderSpecializationKey::disabled(),
+        uses_render_buffer_billboard: false,
         material_asset_id: 1,
         property_block_slot0: Some(99),
         skinned: false,

crates/renderide/src/world_mesh/materials/key.rs

@@ -19,6 +19,8 @@ pub struct MaterialDrawBatchKey {
     pub shader_asset_id: i32,
     /// Renderer-local shader specialization constants for material keyword branches.
     pub shader_specialization: MaterialShaderSpecializationKey,
+    /// Whether Billboard/Unlit embedded binds must force generated render-buffer variant bits.
+    pub uses_render_buffer_billboard: bool,
     /// Material asset id for this renderer material slot (or `-1` when missing).
     pub material_asset_id: i32,
     /// Per-slot property block id when present; `None` is distinct from `Some` for batching.
@@ -208,4 +210,17 @@ mod tests {
         key.render_queue = UNITY_TRANSPARENT_RENDER_QUEUE_MIN;
         assert!(!key.pass_routing().alpha_test);
     }
+
+    #[test]
+    fn render_buffer_billboard_splits_batch_identity() {
+        let mut ordinary = key(false);
+        let mut render_buffer = ordinary.clone();
+        render_buffer.uses_render_buffer_billboard = true;
+
+        assert_ne!(ordinary, render_buffer);
+        assert!(ordinary < render_buffer || render_buffer < ordinary);
+
+        ordinary.uses_render_buffer_billboard = true;
+        assert_eq!(ordinary, render_buffer);
+    }
 }

crates/renderide/src/world_mesh/materials/resolve.rs

@@ -353,6 +353,7 @@ pub(crate) fn apply_render_buffer_mesh_pipeline_override(
     if !crate::particles::is_generated_billboard_mesh_asset_id(mesh_asset_id) {
         return;
     }
+    batch_key.uses_render_buffer_billboard = true;
     if let RasterPipelineKind::EmbeddedStem(stem) = &batch_key.pipeline
         && stem.as_ref().starts_with("billboardunlit")
     {
@@ -424,6 +425,7 @@ fn batch_key_from_resolved(
         pipeline: r.pipeline.clone(),
         shader_asset_id: r.shader_asset_id,
         shader_specialization: r.shader_specialization,
+        uses_render_buffer_billboard: false,
         material_asset_id,
         property_block_slot0: property_block_id,
         skinned,
@@ -787,13 +789,52 @@ mod ui_rect_clip_tests {
             panic!("expected embedded billboard pipeline");
         };
         assert_eq!(stem.as_ref(), "billboardunlit_default");
+        assert!(key.uses_render_buffer_billboard);
         assert!(key.embedded_needs_uv0);
         assert!(key.embedded_needs_color);
         assert!(key.embedded_needs_tangent);
         assert!(key.embedded_raw_tangent_payload);
         assert!(key.embedded_raw_normal_payload);
     }
 
+    #[test]
+    fn generated_billboard_mesh_marks_existing_billboard_pipeline_as_render_buffer() {
+        let mut store = MaterialPropertyStore::new();
+        store.set_shader_asset_for_material(7, 99);
+        let dict = MaterialDictionary::new(&store);
+        let mut router = MaterialRouter::new(RasterPipelineKind::Null);
+        router.set_shader_pipeline(
+            99,
+            RasterPipelineKind::EmbeddedStem(Arc::from("billboardunlit_default")),
+        );
+        let ids = MaterialPipelinePropertyIds::new(&PropertyIdRegistry::new());
+        let resolved =
+            resolve_material_batch(7, None, &dict, &router, &ids, ShaderPermutation::default());
+        let mut key = batch_key_from_resolved(
+            7,
+            None,
+            false,
+            RasterFrontFace::Clockwise,
+            RasterPrimitiveTopology::TriangleList,
+            &resolved,
+        );
+        let mesh_asset_id = crate::particles::billboard_render_buffer_mesh_asset_id(3).unwrap();
+
+        assert!(!key.uses_render_buffer_billboard);
+
+        apply_render_buffer_mesh_pipeline_override(
+            &mut key,
+            mesh_asset_id,
+            ShaderPermutation::default(),
+        );
+
+        assert!(key.uses_render_buffer_billboard);
+        assert_eq!(
+            key.shader_specialization,
+            MaterialShaderSpecializationKey::disabled()
+        );
+    }
+
     #[test]
     fn generated_billboard_mesh_preserves_transparent_material_class() {
         let registry = PropertyIdRegistry::new();
@@ -946,5 +987,6 @@ mod ui_rect_clip_tests {
         );
 
         assert_eq!(key.pipeline, original);
+        assert!(!key.uses_render_buffer_billboard);
     }
 }

crates/renderide/src/world_mesh/test_fixtures.rs

@@ -66,6 +66,7 @@ pub fn dummy_world_mesh_draw_item(spec: DummyDrawItemSpec) -> WorldMeshDrawItem
         pipeline: RasterPipelineKind::Null,
         shader_asset_id: -1,
         shader_specialization: MaterialShaderSpecializationKey::disabled(),
+        uses_render_buffer_billboard: false,
         material_asset_id: mid,
         property_block_slot0: pb,
         skinned,