Rewrite to fully normalize on entities.

Author: tychedelia

crates/processing_ffi/src/lib.rs

@@ -646,13 +646,6 @@ pub extern "C" fn processing_geometry_layout_add_attribute(layout_id: u64, attr_
     error::check(|| geometry_layout_add_attribute(layout_entity, attr_entity));
 }
 
-#[unsafe(no_mangle)]
-pub extern "C" fn processing_geometry_layout_build(layout_id: u64) {
-    error::clear_error();
-    let entity = Entity::from_bits(layout_id);
-    error::check(|| geometry_layout_build(entity));
-}
-
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_geometry_layout_destroy(layout_id: u64) {
     error::clear_error();
@@ -685,19 +678,6 @@ pub extern "C" fn processing_geometry_create(topology: u8) -> u64 {
         .unwrap_or(0)
 }
 
-#[unsafe(no_mangle)]
-pub extern "C" fn processing_geometry_create_with_attrs(attrs: u32, topology: u8) -> u64 {
-    error::clear_error();
-    let Some(topo) = geometry::Topology::from_u8(topology) else {
-        error::set_error("Invalid topology");
-        return 0;
-    };
-    let attrs = geometry::VertexAttributes::from_bits_truncate(attrs);
-    error::check(|| geometry_create_with_attributes(attrs, topo))
-        .map(|e| e.to_bits())
-        .unwrap_or(0)
-}
-
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_geometry_normal(geo_id: u64, nx: f32, ny: f32, nz: f32) {
     error::clear_error();

crates/processing_render/src/geometry/layout.rs

@@ -1,6 +1,6 @@
-use bevy::{mesh::MeshVertexAttribute, prelude::*};
+use bevy::prelude::*;
 
-use super::{Attribute, BuiltinAttributes};
+use super::BuiltinAttributes;
 
 // bevy requires an attribute id for each unique vertex attribute. we don't really want to
 // expose this to users, so we hash the attribute name to generate a unique id. in theory
@@ -18,18 +18,9 @@ pub const fn hash_attr_name(s: &str) -> u64 {
     hash
 }
 
-/// Describes the layout of vertex attributes within a mesh's vertex buffer.
-#[derive(Component, Clone, Debug)]
+#[derive(Component, Clone, Debug, Default)]
 pub struct VertexLayout {
-    attributes: Vec<VertexAttribute>,
-}
-
-/// Represents a single vertex attribute within a vertex layout, including its type and offset
-/// within the vertex buffer.
-#[derive(Clone, Debug)]
-pub struct VertexAttribute {
-    pub attribute: MeshVertexAttribute,
-    pub offset: u64,
+    attributes: Vec<Entity>,
 }
 
 impl VertexLayout {
@@ -39,171 +30,67 @@ impl VertexLayout {
         }
     }
 
-    pub fn default_layout() -> Self {
-        let attrs = [
-            Mesh::ATTRIBUTE_POSITION,
-            Mesh::ATTRIBUTE_NORMAL,
-            Mesh::ATTRIBUTE_COLOR,
-            Mesh::ATTRIBUTE_UV_0,
-        ];
-
-        let mut offset = 0u64;
-        let mut layout_attrs = Vec::with_capacity(attrs.len());
-
-        for attr in attrs {
-            let size = attr.format.size();
-            layout_attrs.push(VertexAttribute {
-                attribute: attr,
-                offset,
-            });
-            offset += size;
-        }
-
-        Self {
-            attributes: layout_attrs,
-        }
+    pub fn with_attributes(attrs: Vec<Entity>) -> Self {
+        Self { attributes: attrs }
     }
 
-    pub fn attributes(&self) -> &[VertexAttribute] {
+    pub fn attributes(&self) -> &[Entity] {
         &self.attributes
     }
 
-    pub fn has_attribute(&self, attr: &MeshVertexAttribute) -> bool {
-        self.attributes.iter().any(|a| a.attribute.id == attr.id)
+    pub fn push(&mut self, attr: Entity) {
+        self.attributes.push(attr);
     }
-}
-
-impl Default for VertexLayout {
-    fn default() -> Self {
-        Self::default_layout()
-    }
-}
-
-bitflags::bitflags! {
-    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-    pub struct VertexAttributes: u32 {
-        const POSITION = 0x01;
-        const NORMAL = 0x02;
-        const COLOR = 0x04;
-        const UV = 0x08;
-    }
-}
-
-impl VertexAttributes {
-    pub fn to_layout(self) -> VertexLayout {
-        let mut attrs = vec![Mesh::ATTRIBUTE_POSITION];
-
-        if self.contains(VertexAttributes::NORMAL) {
-            attrs.push(Mesh::ATTRIBUTE_NORMAL);
-        }
-        if self.contains(VertexAttributes::COLOR) {
-            attrs.push(Mesh::ATTRIBUTE_COLOR);
-        }
-        if self.contains(VertexAttributes::UV) {
-            attrs.push(Mesh::ATTRIBUTE_UV_0);
-        }
-
-        let mut offset = 0u64;
-        let mut layout_attrs = Vec::with_capacity(attrs.len());
 
-        for attr in attrs {
-            let size = attr.format.size();
-            layout_attrs.push(VertexAttribute {
-                attribute: attr,
-                offset,
-            });
-            offset += size;
-        }
-
-        VertexLayout {
-            attributes: layout_attrs,
-        }
+    pub fn has_attribute(&self, attr_entity: Entity) -> bool {
+        self.attributes.contains(&attr_entity)
     }
 }
 
-#[derive(Component, Clone, Debug, Default)]
-pub struct VertexLayoutBuilder {
-    attributes: Vec<Entity>,
+pub fn create(In(()): In<()>, mut commands: Commands) -> Entity {
+    commands.spawn(VertexLayout::new()).id()
 }
 
-pub fn create(In(()): In<()>, mut commands: Commands) -> Entity {
-    commands.spawn(VertexLayoutBuilder::default()).id()
+pub fn create_default(world: &mut World) -> Entity {
+    let builtins = world.resource::<BuiltinAttributes>();
+    let attrs = vec![builtins.position, builtins.normal, builtins.color, builtins.uv];
+    world.spawn(VertexLayout::with_attributes(attrs)).id()
 }
 
 pub fn add_position(world: &mut World, entity: Entity) {
-    let builtins = world.resource::<BuiltinAttributes>();
-    let position = builtins.position;
-    if let Some(mut builder) = world.get_mut::<VertexLayoutBuilder>(entity) {
-        builder.attributes.push(position);
+    let position = world.resource::<BuiltinAttributes>().position;
+    if let Some(mut layout) = world.get_mut::<VertexLayout>(entity) {
+        layout.push(position);
     }
 }
 
 pub fn add_normal(world: &mut World, entity: Entity) {
-    let builtins = world.resource::<BuiltinAttributes>();
-    let normal = builtins.normal;
-    if let Some(mut builder) = world.get_mut::<VertexLayoutBuilder>(entity) {
-        builder.attributes.push(normal);
+    let normal = world.resource::<BuiltinAttributes>().normal;
+    if let Some(mut layout) = world.get_mut::<VertexLayout>(entity) {
+        layout.push(normal);
     }
 }
 
 pub fn add_color(world: &mut World, entity: Entity) {
-    let builtins = world.resource::<BuiltinAttributes>();
-    let color = builtins.color;
-    if let Some(mut builder) = world.get_mut::<VertexLayoutBuilder>(entity) {
-        builder.attributes.push(color);
+    let color = world.resource::<BuiltinAttributes>().color;
+    if let Some(mut layout) = world.get_mut::<VertexLayout>(entity) {
+        layout.push(color);
     }
 }
 
 pub fn add_uv(world: &mut World, entity: Entity) {
-    let builtins = world.resource::<BuiltinAttributes>();
-    let uv = builtins.uv;
-    if let Some(mut builder) = world.get_mut::<VertexLayoutBuilder>(entity) {
-        builder.attributes.push(uv);
+    let uv = world.resource::<BuiltinAttributes>().uv;
+    if let Some(mut layout) = world.get_mut::<VertexLayout>(entity) {
+        layout.push(uv);
     }
 }
 
 pub fn add_attribute(world: &mut World, layout_entity: Entity, attr_entity: Entity) {
-    if let Some(mut builder) = world.get_mut::<VertexLayoutBuilder>(layout_entity) {
-        builder.attributes.push(attr_entity);
+    if let Some(mut layout) = world.get_mut::<VertexLayout>(layout_entity) {
+        layout.push(attr_entity);
     }
 }
 
 pub fn destroy(In(entity): In<Entity>, mut commands: Commands) {
     commands.entity(entity).despawn();
 }
-
-pub fn build(
-    In(entity): In<Entity>,
-    mut commands: Commands,
-    builders: Query<&VertexLayoutBuilder>,
-    attrs: Query<&Attribute>,
-) -> bool {
-    let Ok(builder) = builders.get(entity) else {
-        return false;
-    };
-
-    let mut offset = 0u64;
-    let mut layout_attrs = Vec::with_capacity(builder.attributes.len());
-
-    for &attr_entity in &builder.attributes {
-        let Ok(attr) = attrs.get(attr_entity) else {
-            return false;
-        };
-        let size = attr.inner.format.size();
-        layout_attrs.push(VertexAttribute {
-            attribute: attr.inner.clone(),
-            offset,
-        });
-        offset += size;
-    }
-
-    let layout = VertexLayout {
-        attributes: layout_attrs,
-    };
-
-    commands
-        .entity(entity)
-        .remove::<VertexLayoutBuilder>()
-        .insert(layout);
-    true
-}