Rework WIP unity branch

package.json

@@ -36,6 +36,7 @@
     "start": "pnpm run build:rust && cross-env NODE_ENV=development rspack dev",
     "build": "pnpm run build:rust && cross-env NODE_ENV=production rspack build",
     "build:rust": "wasm-pack build -t web rust",
+    "build:rust-dev": "wasm-pack build --dev -t web rust",
     "build:ZeldaWindWaker": "cd src/ZeldaWindWaker/tools && tsx --experimental-wasm-modules zww_extractor.ts",
     "build:ztp": "cd src/ZeldaTwilightPrincess/tools && tsx ztp_extractor.ts",
     "build:dk64": "cd src/DonkeyKong64/tools && tsx extractor.ts",
@@ -47,7 +48,7 @@
     "build:TheWitness": "cd src/TheWitness/tools && tsx extractor.ts",
     "test:DeBlob2": "cd src/DeBlob2/tools && tsx systest.ts",
     "typecheck": "tsc -w --noEmit",
-    "watch:rust": "onchange rust/**/*.rs -- pnpm run build:rust"
+    "watch:rust": "pnpm run build:rust-dev && onchange rust/src/**/*.rs rust/noclip-macros/src/**/*.rs -- pnpm run build:rust-dev"
   },
   "bin": {
     "nc-bcsvtool": "./src/tools/bcsvtool.ts",

rust/Cargo.toml

@@ -1,3 +1,6 @@
+[workspace]
+members = ["noclip-macros"]
+
 [package]
 name = "noclip-support"
 version = "0.0.0"
@@ -12,6 +15,8 @@ wasm-opt = ['-O', '--enable-bulk-memory']
 
 [package.metadata.wasm-pack.profile.profiling]
 wasm-opt = ['-Os', '--debuginfo']
+demangle-name-section = true
+dwarf-debug-info = true
 
 [profile.release]
 lto = true
@@ -35,4 +40,4 @@ web-sys = { version = "0.3.48", features = ["console"] }
 nalgebra-glm = "0.19.0"
 rand = "0.8.5"
 getrandom = { version = "0.2.15", features = ["js"] }
-
+noclip-macros = { version = "*", path = "./noclip-macros" }

rust/noclip-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "noclip-macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0.89"
+quote = "1.0.37"
+syn = { version = "2.0.87", features = ["extra-traits"] }

rust/noclip-macros/src/lib.rs

@@ -0,0 +1,99 @@
+use syn::Data;
+use quote::quote;
+
+#[proc_macro_derive(FromStructPerField, attributes(from))]
+pub fn derive_from_struct_per_field(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = syn::parse_macro_input!(item as syn::DeriveInput);
+
+    let mut from_structs = Vec::new();
+    for attr in &input.attrs {
+        match &attr.meta {
+            syn::Meta::List(meta_list) => {
+                let tokens: proc_macro::TokenStream = meta_list.tokens.clone().into();
+                from_structs.push(syn::parse_macro_input!(tokens as syn::Path));
+            },
+            _ => unimplemented!(),
+        };
+    }
+
+    let struct_identifier = &input.ident;
+    let mut impls = proc_macro2::TokenStream::new();
+
+    match &input.data {
+        Data::Struct(syn::DataStruct { fields, .. }) => {
+            let mut field_assignments = proc_macro2::TokenStream::new();
+            for field in fields {
+                let identifier = field.ident.as_ref().unwrap();
+                field_assignments.extend(quote!{
+                    #identifier: value.#identifier.into(),
+                });
+            }
+
+            for from_struct in from_structs {
+                impls.extend(quote!{
+                    impl From<#from_struct> for #struct_identifier {
+                        fn from(value: #from_struct) -> #struct_identifier {
+                            #struct_identifier {
+                                #field_assignments
+                            }
+                        }
+                    }
+                });
+            }
+        },
+        _ => unimplemented!(),
+    }
+
+    impls.into()
+}
+
+#[proc_macro_derive(FromEnumPerVariant, attributes(from))]
+pub fn derive_from_enum(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = syn::parse_macro_input!(item as syn::DeriveInput);
+
+    let mut from_enums = Vec::new();
+    for attr in &input.attrs {
+        match &attr.meta {
+            syn::Meta::List(meta_list) => {
+                let tokens: proc_macro::TokenStream = meta_list.tokens.clone().into();
+                from_enums.push(syn::parse_macro_input!(tokens as syn::Path));
+            },
+            _ => unimplemented!(),
+        };
+    }
+
+    let enum_identifier = &input.ident;
+    let mut impls = proc_macro2::TokenStream::new();
+
+    match &input.data {
+        Data::Enum(syn::DataEnum { variants, .. }) => {
+            for from_enum in from_enums {
+                let mut variant_patterns = proc_macro2::TokenStream::new();
+                for variant in variants {
+                    let identifier = &variant.ident;
+                    variant_patterns.extend(quote!{
+                        #from_enum::#identifier => #enum_identifier::#identifier,
+                    });
+                }
+
+                impls.extend(quote!{
+                    impl From<#from_enum> for #enum_identifier {
+                        fn from(value: #from_enum) -> #enum_identifier {
+                            match value {
+                                #variant_patterns
+                            }
+                        }
+                    }
+                });
+            }
+        },
+        _ => unimplemented!(),
+    }
+
+    impls.into()
+}
+
+#[proc_macro_attribute]
+pub fn from(attr: proc_macro::TokenStream, _: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    attr
+}