revert wired-math refactor

crates/unavi-scripting/src/execution.rs

@@ -1,7 +1,7 @@
 use bevy::{prelude::*, tasks::block_on};
 use wasm_bridge::{component::ResourceAny, AsContextMut};
 
-use crate::{host::wired_gltf::handler::NodeId, load::LoadedScript};
+use crate::load::LoadedScript;
 
 use super::load::Scripts;
 
@@ -53,7 +53,6 @@ pub fn update_scripts(
     mut to_update: Query<(Entity, &ScriptResource)>,
     scripts: NonSendMut<Scripts>,
     time: Res<Time>,
-    mut nodes: Query<(&mut Transform, &NodeId)>,
 ) {
     let now = time.elapsed_seconds();
     let delta = now - *last_update;
@@ -75,33 +74,6 @@ pub fn update_scripts(
                 .call_update(store.as_context_mut(), res.0, delta)
                 .await?;
 
-            let state = store.data();
-
-            for res in state.nodes.iter() {
-                let node = state.table.get(res)?;
-                let transform = state.table.get(&node.transform)?;
-
-                if transform.clean(&state.table)? {
-                    let rep = res.rep();
-
-                    let translation = state.table.get(&transform.translation)?;
-                    let rotation = state.table.get(&transform.rotation)?;
-                    let scale = state.table.get(&transform.scale)?;
-
-                    if let Some(mut target) =
-                        nodes
-                            .iter_mut()
-                            .find_map(|(t, id)| if id.0 == rep { Some(t) } else { None })
-                    {
-                        target.translation.clone_from(&translation.data);
-                        target.rotation.clone_from(&rotation.data);
-                        target.scale.clone_from(&scale.data);
-                    } else {
-                        warn!("Node {} not found", rep)
-                    };
-                }
-            }
-
             Ok(())
         });
 

crates/unavi-scripting/src/host/mod.rs

@@ -5,11 +5,9 @@ use super::state::StoreState;
 
 pub mod wired_gltf;
 mod wired_log;
-mod wired_math;
 
 pub fn add_host_script_apis(linker: &mut Linker<StoreState>) -> Result<()> {
     wired_log::add_to_host(linker)?;
-    wired_math::add_to_host(linker)?;
     wired_gltf::add_to_host(linker)?;
     Ok(())
 }

crates/unavi-scripting/src/host/wired_gltf/bindgen.rs

@@ -1,10 +1,5 @@
-use bevy::{
-    math::{Quat, Vec3},
-    utils::HashSet,
-};
-use wasm_bridge::component::{Resource, ResourceTable, ResourceTableError};
-
-use crate::host::wired_math::{quat::QuatRes, transform::Transform, vec3::Vec3Res};
+use bevy::utils::HashSet;
+use wired::math::types::{Quat, Transform, Vec3};
 
 use self::wired::gltf::material::Color;
 
@@ -16,9 +11,6 @@ wasm_bridge::component::bindgen!({
         "wired:gltf/mesh/mesh": Mesh,
         "wired:gltf/mesh/primitive": Primitive,
         "wired:gltf/node/node": Node,
-        "wired:math/types/vec3": crate::host::wired_math::vec3::Vec3Res,
-        "wired:math/types/quat": crate::host::wired_math::quat::QuatRes,
-        "wired:math/types/transform": crate::host::wired_math::transform::Transform,
     }
 });
 
@@ -50,32 +42,46 @@ pub struct Primitive {
     pub material: Option<u32>,
 }
 
+#[derive(Default)]
 pub struct Node {
     pub children: HashSet<u32>,
     pub mesh: Option<u32>,
     pub name: String,
     pub parent: Option<u32>,
-    pub transform: Resource<Transform>,
+    pub transform: Transform,
 }
 
-impl Node {
-    pub fn try_new(table: &mut ResourceTable) -> Result<Self, ResourceTableError> {
-        let rotation = table.push(QuatRes::new(Quat::default()))?;
-        let scale = table.push(Vec3Res::new(Vec3::splat(1.0)))?;
-        let translation = table.push(Vec3Res::new(Vec3::default()))?;
+impl Default for Transform {
+    fn default() -> Self {
+        Self {
+            rotation: Quat::default(),
+            scale: Vec3 {
+                x: 1.0,
+                y: 1.0,
+                z: 1.0,
+            },
+            translation: Vec3::default(),
+        }
+    }
+}
 
-        let transform = table.push(Transform {
-            translation,
-            rotation,
-            scale,
-        })?;
+impl Default for Quat {
+    fn default() -> Self {
+        Self {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0,
+            w: 1.0,
+        }
+    }
+}
 
-        Ok(Self {
-            children: HashSet::default(),
-            mesh: None,
-            name: String::default(),
-            parent: None,
-            transform,
-        })
+impl Default for Vec3 {
+    fn default() -> Self {
+        Self {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0,
+        }
     }
 }

crates/unavi-scripting/src/host/wired_gltf/node.rs

@@ -102,9 +102,41 @@ impl HostNode for StoreState {
         Ok(())
     }
 
-    fn transform(&mut self, self_: Resource<Node>) -> wasm_bridge::Result<Resource<Transform>> {
+    fn transform(&mut self, self_: Resource<Node>) -> wasm_bridge::Result<Transform> {
         let node = self.table.get(&self_)?;
-        Ok(Resource::new_own(node.transform.rep()))
+        Ok(node.transform)
+    }
+    fn set_transform(
+        &mut self,
+        self_: Resource<Node>,
+        value: Transform,
+    ) -> wasm_bridge::Result<()> {
+        let node = self.table.get_mut(&self_)?;
+        node.transform = value;
+
+        self.sender.send(WiredGltfAction::SetNodeTransform {
+            id: self_.rep(),
+            transform: bevy::prelude::Transform {
+                translation: bevy::prelude::Vec3::new(
+                    node.transform.translation.x,
+                    node.transform.translation.y,
+                    node.transform.translation.z,
+                ),
+                rotation: bevy::prelude::Quat::from_xyzw(
+                    node.transform.rotation.x,
+                    node.transform.rotation.y,
+                    node.transform.rotation.z,
+                    node.transform.rotation.w,
+                ),
+                scale: bevy::prelude::Vec3::new(
+                    node.transform.scale.x,
+                    node.transform.scale.y,
+                    node.transform.scale.z,
+                ),
+            },
+        })?;
+
+        Ok(())
     }
 
     fn drop(&mut self, _rep: Resource<Node>) -> wasm_bridge::Result<()> {
@@ -122,7 +154,7 @@ impl Host for StoreState {
     }
 
     fn create_node(&mut self) -> wasm_bridge::Result<Resource<Node>> {
-        let node = Node::try_new(&mut self.table)?;
+        let node = Node::default();
         let resource = self.table.push(node)?;
         let node_rep = resource.rep();
         self.nodes.push(resource);

crates/unavi-scripting/src/host/wired_math/quat.rs

@@ -10,17 +10,22 @@ use super::wired::math::types::HostQuat;
 pub struct QuatRes {
     pub data: Quat,
     pub dirty: Cell<bool>,
-    ref_count: usize,
+    ref_count: Cell<usize>,
 }
 
 impl QuatRes {
     pub fn new(data: Quat) -> Self {
         Self {
             data,
             dirty: Cell::new(true),
-            ref_count: 1,
+            ref_count: Cell::new(1),
         }
     }
+
+    pub fn new_own(&self, rep: u32) -> Resource<Self> {
+        self.ref_count.set(self.ref_count.get() + 1);
+        Resource::new_own(rep)
+    }
 }
 
 impl HostQuat for StoreState {
@@ -131,8 +136,43 @@ impl HostQuat for StoreState {
         Ok(())
     }
 
-    fn drop(&mut self, _rep: Resource<QuatRes>) -> wasm_bridge::Result<()> {
-        // TODO: reference count resources, remove from table on drop if 0
+    fn drop(&mut self, rep: Resource<QuatRes>) -> wasm_bridge::Result<()> {
+        let res = self.table.get(&rep)?;
+        res.ref_count.set(res.ref_count.get() - 1);
+
+        if res.ref_count.get() == 0 {
+            self.table.delete(rep)?;
+        }
+
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use tracing_test::traced_test;
+    use wasm_bridge::component::ResourceTable;
+
+    #[test]
+    #[traced_test]
+    fn test_drop() {
+        let mut table = ResourceTable::default();
+
+        let res = table.push(QuatRes::new(Quat::default())).unwrap();
+        let rep = res.rep();
+
+        let quat = table.get(&res).unwrap();
+        let res_2 = quat.new_own(rep);
+
+        let found = table.get(&res_2);
+        assert!(found.is_ok());
+
+        assert_eq!(quat.ref_count.get(), 0);
+
+        let dummy = Resource::<QuatRes>::new_own(rep);
+        let found = table.get(&dummy);
+        assert!(found.is_err());
+    }
+}

crates/unavi-scripting/src/host/wired_math/transform.rs

@@ -70,7 +70,8 @@ impl HostTransform for StoreState {
 
     fn rotation(&mut self, self_: Resource<Transform>) -> wasm_bridge::Result<Resource<QuatRes>> {
         let res = self.table.get(&self_)?;
-        Ok(Resource::new_own(res.rotation.rep()))
+        let rotation = self.table.get(&res.rotation)?;
+        Ok(rotation.new_own(res.rotation.rep()))
     }
     fn scale(&mut self, self_: Resource<Transform>) -> wasm_bridge::Result<Resource<Vec3Res>> {
         let res = self.table.get(&self_)?;