Split TransformedMesh into components

src/legion.rs

@@ -80,18 +80,16 @@ fn render(
     }
 }
 
-#[system]
+#[system(for_each)]
 fn draw_transformed_meshes(
     #[resource] mesh_pass: &pass::RenderPassBox<mesh::MeshPass>,
-    world: &SubWorld,
+    transform: &scene::Transform,
-    query: &mut Query<&scene::TransformedMesh>,
+    mesh: &scene::Mesh,
 ) {
-    let transformed: Vec<_> = query.iter(world).map(|m| m.clone()).collect();
+    mesh_pass.add_transformed_meshes(&[mesh::TransformedMesh {
-    mesh_pass
+        transform: transform.transform,
-        .get_meshes()
+        mesh: mesh.mesh,
-        .write()
+    }]);
-        .transformed
-        .extend_from_slice(transformed.as_slice());
 }
 
 #[system(for_each)]

src/main.rs

@@ -110,8 +110,7 @@ fn main() {
                 let translation = glam::Vec3::new(x as f32, y as f32, z as f32);
                 let transform = glam::Mat4::from_translation(translation);
                 world.push((
-                    cyborg::scene::TransformedMesh {
+                    cyborg::scene::Mesh {
-                        transform,
                         mesh: example_mesh.clone(),
                     },
                     cyborg::scene::Transform { transform },

src/pass/mesh.rs

@@ -1,10 +1,10 @@
 use super::*;
-use crate::scene;
 use crate::shader::{ShaderHandle, ShaderStore};
 use crate::storage::mesh::*;
 use crate::storage::GpuVec;
 use crate::viewport::ViewportInfo;
 use crate::RenderLayouts;
+use parking_lot::RwLock;
 
 #[derive(Clone)]
 pub struct ShaderInfo {
@@ -41,6 +41,12 @@ impl Vertex {
 
 pub type Index = u32;
 
+#[derive(Clone, Debug)]
+pub struct TransformedMesh {
+    pub mesh: MeshHandle,
+    pub transform: glam::Mat4,
+}
+
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 struct SkinningUniform {
@@ -88,7 +94,7 @@ pub struct MeshPass {
     depth_pipeline: wgpu::RenderPipeline,
     opaque_pipeline: wgpu::RenderPipeline,
     target_info: ViewportInfo,
-    meshes: scene::MeshesHandle,
+    transformed_meshes: RwLock<Vec<TransformedMesh>>,
 }
 
 impl MeshPass {
@@ -250,7 +256,7 @@ impl MeshPass {
             depth_pipeline,
             opaque_pipeline,
             target_info,
-            meshes: Default::default(),
+            transformed_meshes: Default::default(),
         }
     }
 
@@ -266,8 +272,8 @@ impl MeshPass {
         self.index_attr_id
     }
 
-    pub fn get_meshes(&self) -> &scene::MeshesHandle {
+    pub fn add_transformed_meshes(&self, meshes: &[TransformedMesh]) {
-        &self.meshes
+        self.transformed_meshes.write().extend_from_slice(meshes);
     }
 }
 
@@ -306,12 +312,14 @@ impl RenderPass for MeshPass {
         data.groups.clear();
         data.skinning_uniforms.clear();
 
-        let mut meshes_lock = self.meshes.write();
+        let mut transformed_meshes_lock = self.transformed_meshes.write();
         let mesh_bindings = self
             .mesh_pool
-            .iter_meshes(self.mesh_layout_id, meshes_lock.transformed.iter(), |i| {
+            .iter_meshes(
-                &i.mesh
+                self.mesh_layout_id,
-            })
+                transformed_meshes_lock.iter(),
+                |i| &i.mesh,
+            )
             .unwrap();
 
         let mut skinned_cursor = 0;
@@ -399,7 +407,7 @@ impl RenderPass for MeshPass {
         data.skinned_vertices.write(&queue);
         data.skinning_uniforms.write(&queue);
 
-        meshes_lock.transformed.clear();
+        transformed_meshes_lock.clear();
     }
 
     fn record_commands(&self, data: PhaseData<&FrameData>, cmds: &mut wgpu::CommandEncoder) {

src/scene.rs

@@ -4,28 +4,17 @@
 //! querying component and resource data framework-agnostically
 
 use crate::storage::mesh::MeshHandle;
-use parking_lot::RwLock;
-use std::sync::Arc;
 
 #[derive(Clone, Debug)]
 pub struct Transform {
     pub transform: glam::Mat4,
 }
 
-// TODO split into separate transform and mesh handle components
 #[derive(Clone, Debug)]
-pub struct TransformedMesh {
+pub struct Mesh {
-    pub transform: glam::Mat4,
     pub mesh: MeshHandle,
 }
 
-#[derive(Default)]
-pub struct Meshes {
-    pub transformed: Vec<TransformedMesh>,
-}
-
-pub type MeshesHandle = Arc<RwLock<Meshes>>;
-
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct DebugVertex {