unreal-engine-mcp-server 0.4.6 → 0.5.0

package/wasm/src/property_parser.rs

@@ -0,0 +1,271 @@
+//! Property parsing and serialization module
+//!
+//! This module provides efficient parsing and serialization of
+//! Unreal Engine property data structures.
+
+use serde::{Serialize, Deserialize};
+use serde_json::{Value, Map};
+use wasm_bindgen::prelude::*;
+use serde_wasm_bindgen as swb;
+
+/// A parsed property with metadata
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ParsedProperty {
+    pub name: String,
+    pub value: Value,
+    pub property_type: String,
+    pub is_array: bool,
+    pub nested_properties: Option<Vec<ParsedProperty>>,
+}
+
+/// Result of parsing properties
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ParseResult {
+    pub properties: Vec<ParsedProperty>,
+    pub total_count: usize,
+    pub parse_time_ms: f64,
+}
+
+#[wasm_bindgen]
+pub struct PropertyParser {
+    /// Maximum nesting depth to prevent stack overflow
+    max_depth: usize,
+}
+
+#[wasm_bindgen]
+impl PropertyParser {
+    /// Create a new PropertyParser with default max depth (100)
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> PropertyParser {
+        console_error_panic_hook::set_once();
+        PropertyParser { max_depth: 100 }
+    }
+
+    /// Create a PropertyParser with custom max depth
+    #[wasm_bindgen(js_name = withMaxDepth)]
+    pub fn with_max_depth(max_depth: usize) -> PropertyParser {
+        console_error_panic_hook::set_once();
+        PropertyParser { max_depth }
+    }
+
+    /// Parse JSON string into structured properties
+    #[wasm_bindgen]
+    pub fn parse_properties(&self, json_str: &str, max_depth: Option<usize>) -> Result<JsValue, JsValue> {
+        let start = js_sys::Date::now();
+
+        let value: Value = serde_json::from_str(json_str)
+            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
+
+        let depth_limit = max_depth.unwrap_or(self.max_depth);
+        let properties = self.parse_value(&value, "root", depth_limit)?;
+
+        let parse_time = js_sys::Date::now() - start;
+
+        let total_count = self.count_properties(&properties);
+
+        let result = ParseResult {
+            properties,
+            total_count,
+            parse_time_ms: parse_time,
+        };
+
+        let js_value = swb::to_value(&result)
+            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))?;
+        Ok(js_value)
+    }
+
+    /// Serialize properties back to JSON
+    #[wasm_bindgen]
+    pub fn serialize_properties(&self, properties_js: &JsValue) -> Result<String, JsValue> {
+        let properties: Vec<ParsedProperty> = swb::from_value(properties_js.clone())
+            .map_err(|e| JsValue::from_str(&format!("Deserialize error: {}", e)))?;
+
+        let value = self.properties_to_value(&properties);
+        serde_json::to_string_pretty(&value)
+            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))
+    }
+
+    /// Extract all property names from JSON
+    #[wasm_bindgen]
+    pub fn extract_property_names(&self, json_str: &str) -> Result<JsValue, JsValue> {
+        let value: Value = serde_json::from_str(json_str)
+            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
+
+        let mut names = Vec::new();
+        self.extract_names(&value, &mut names);
+
+        let js_value = swb::to_value(&names)
+            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))?;
+        Ok(js_value)
+    }
+
+    /// Get property type from JSON value
+    #[wasm_bindgen(js_name = getPropertyType)]
+    pub fn get_property_type(&self, json_str: &str) -> Result<String, JsValue> {
+        let value: Value = serde_json::from_str(json_str)
+            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
+
+        let prop_type = self.infer_property_type(&value);
+        Ok(prop_type)
+    }
+}
+
+impl PropertyParser {
+    fn parse_value(&self, value: &Value, name: &str, depth: usize) -> Result<Vec<ParsedProperty>, JsValue> {
+        if depth == 0 {
+            return Err(JsValue::from_str("Maximum nesting depth exceeded"));
+        }
+
+        let prop_type = self.infer_property_type(value);
+
+        let mut properties = Vec::new();
+
+        match value {
+            Value::Null => {
+                properties.push(ParsedProperty {
+                    name: name.to_string(),
+                    value: value.clone(),
+                    property_type: prop_type,
+                    is_array: false,
+                    nested_properties: None,
+                });
+            }
+            Value::Bool(_) | Value::Number(_) | Value::String(_) => {
+                properties.push(ParsedProperty {
+                    name: name.to_string(),
+                    value: value.clone(),
+                    property_type: prop_type,
+                    is_array: false,
+                    nested_properties: None,
+                });
+            }
+            Value::Array(arr) => {
+                let mut nested = Vec::new();
+                for (i, item) in arr.iter().enumerate() {
+                    let item_name = format!("{}[{}]", name, i);
+                    let mut item_properties = self.parse_value(item, &item_name, depth - 1)?;
+                    nested.append(&mut item_properties);
+                }
+
+                properties.push(ParsedProperty {
+                    name: name.to_string(),
+                    value: value.clone(),
+                    property_type: prop_type,
+                    is_array: true,
+                    nested_properties: Some(nested),
+                });
+            }
+            Value::Object(obj) => {
+                let mut nested = Vec::new();
+                for (key, val) in obj {
+                    let nested_properties = self.parse_value(val, key, depth - 1)?;
+                    nested.extend(nested_properties);
+                }
+
+                properties.push(ParsedProperty {
+                    name: name.to_string(),
+                    value: value.clone(),
+                    property_type: prop_type,
+                    is_array: false,
+                    nested_properties: Some(nested),
+                });
+            }
+        }
+
+        Ok(properties)
+    }
+
+    fn infer_property_type(&self, value: &Value) -> String {
+        match value {
+            Value::Null => "null".to_string(),
+            Value::Bool(_) => "boolean".to_string(),
+            Value::Number(n) => {
+                if n.is_f64() {
+                    "float".to_string()
+                } else {
+                    "integer".to_string()
+                }
+            }
+            Value::String(_) => "string".to_string(),
+            Value::Array(_) => "array".to_string(),
+            Value::Object(_) => "object".to_string(),
+        }
+    }
+
+    fn extract_names(&self, value: &Value, names: &mut Vec<String>) {
+        match value {
+            Value::Object(obj) => {
+                for (key, val) in obj {
+                    names.push(key.clone());
+                    self.extract_names(val, names);
+                }
+            }
+            Value::Array(arr) => {
+                for item in arr {
+                    self.extract_names(item, names);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn count_properties(&self, properties: &[ParsedProperty]) -> usize {
+        let mut count = properties.len();
+        for prop in properties {
+            if let Some(nested) = &prop.nested_properties {
+                count += self.count_properties(nested);
+            }
+        }
+        count
+    }
+
+    fn properties_to_value(&self, properties: &[ParsedProperty]) -> Value {
+        // This is a simplified conversion - in practice, you'd want more sophisticated handling
+        let mut map = Map::new();
+
+        for prop in properties {
+            let val = if let Some(nested) = &prop.nested_properties {
+                if nested.is_empty() {
+                    prop.value.clone()
+                } else {
+                    self.nested_to_value(nested)
+                }
+            } else {
+                prop.value.clone()
+            };
+            map.insert(prop.name.clone(), val);
+        }
+
+        Value::Object(map)
+    }
+
+    fn nested_to_value(&self, properties: &[ParsedProperty]) -> Value {
+        if properties.is_empty() {
+            return Value::Null;
+        }
+
+        if properties.len() == 1 {
+            let prop = &properties[0];
+            if let Some(nested) = &prop.nested_properties {
+                let mut map = Map::new();
+                map.insert(prop.name.clone(), self.nested_to_value(nested));
+                Value::Object(map)
+            } else {
+                prop.value.clone()
+            }
+        } else {
+            let mut map = Map::new();
+            for prop in properties {
+                let val = if let Some(nested) = &prop.nested_properties {
+                    self.nested_to_value(nested)
+                } else {
+                    prop.value.clone()
+                };
+                map.insert(prop.name.clone(), val);
+            }
+            Value::Object(map)
+        }
+    }
+}

package/wasm/src/transform_math.rs

@@ -0,0 +1,396 @@
+//! Transform calculations and vector math
+//!
+//! This module provides optimized implementations for:
+//! - Vector operations (addition, subtraction, multiplication, division)
+//! - Matrix operations (composition, decomposition)
+//! - Rotation conversions (Euler, Quaternion, Matrix)
+//!
+//! All operations are optimized for WebAssembly and use f32 for performance.
+
+use wasm_bindgen::prelude::*;
+use serde::{Serialize, Deserialize};
+
+/// 3D Vector
+#[wasm_bindgen]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Vector {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+
+#[wasm_bindgen]
+impl Vector {
+    /// Create a new vector
+    #[wasm_bindgen(constructor)]
+    pub fn new(x: f32, y: f32, z: f32) -> Vector {
+        Vector { x, y, z }
+    }
+
+    /// Add two vectors
+    #[wasm_bindgen(js_name = add)]
+    pub fn add(&self, other: &Vector) -> Vector {
+        Vector {
+            x: self.x + other.x,
+            y: self.y + other.y,
+            z: self.z + other.z,
+        }
+    }
+
+    /// Subtract two vectors
+    #[wasm_bindgen(js_name = subtract)]
+    pub fn subtract(&self, other: &Vector) -> Vector {
+        Vector {
+            x: self.x - other.x,
+            y: self.y - other.y,
+            z: self.z - other.z,
+        }
+    }
+
+    /// Multiply two vectors (component-wise)
+    #[wasm_bindgen(js_name = multiply)]
+    pub fn multiply(&self, other: &Vector) -> Vector {
+        Vector {
+            x: self.x * other.x,
+            y: self.y * other.y,
+            z: self.z * other.z,
+        }
+    }
+
+    /// Scale vector by a scalar
+    #[wasm_bindgen(js_name = scale)]
+    pub fn scale(&self, scalar: f32) -> Vector {
+        Vector {
+            x: self.x * scalar,
+            y: self.y * scalar,
+            z: self.z * scalar,
+        }
+    }
+
+    /// Calculate dot product
+    #[wasm_bindgen(js_name = dot)]
+    pub fn dot(&self, other: &Vector) -> f32 {
+        self.x * other.x + self.y * other.y + self.z * other.z
+    }
+
+    /// Calculate cross product
+    #[wasm_bindgen(js_name = cross)]
+    pub fn cross(&self, other: &Vector) -> Vector {
+        Vector {
+            x: self.y * other.z - self.z * other.y,
+            y: self.z * other.x - self.x * other.z,
+            z: self.x * other.y - self.y * other.x,
+        }
+    }
+
+    /// Get vector length
+    #[wasm_bindgen(js_name = length)]
+    pub fn length(&self) -> f32 {
+        (self.x * self.x + self.y * self.y + self.z * self.z).sqrt()
+    }
+
+    /// Normalize vector
+    #[wasm_bindgen]
+    pub fn normalize(&self) -> Vector {
+        let len = self.length();
+        if len > 0.0 {
+            Vector {
+                x: self.x / len,
+                y: self.y / len,
+                z: self.z / len,
+            }
+        } else {
+            Vector::new(0.0, 0.0, 0.0)
+        }
+    }
+
+    /// Convert to array [x, y, z]
+    #[wasm_bindgen(js_name = toArray)]
+    pub fn to_array(&self) -> Vec<f32> {
+        vec![self.x, self.y, self.z]
+    }
+
+    /// Distance to another vector
+    #[wasm_bindgen(js_name = distanceTo)]
+    pub fn distance_to(&self, other: &Vector) -> f32 {
+        let dx = self.x - other.x;
+        let dy = self.y - other.y;
+        let dz = self.z - other.z;
+        (dx * dx + dy * dy + dz * dz).sqrt()
+    }
+
+    /// Linear interpolation to another vector
+    #[wasm_bindgen(js_name = lerp)]
+    pub fn lerp(&self, other: &Vector, t: f32) -> Vector {
+        Vector {
+            x: self.x + (other.x - self.x) * t,
+            y: self.y + (other.y - self.y) * t,
+            z: self.z + (other.z - self.z) * t,
+        }
+    }
+}
+
+/// 3D Rotation (Euler angles in degrees)
+#[wasm_bindgen]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Rotator {
+    pub pitch: f32,
+    pub yaw: f32,
+    pub roll: f32,
+}
+
+#[wasm_bindgen]
+impl Rotator {
+    /// Create a new rotator
+    #[wasm_bindgen(constructor)]
+    pub fn new(pitch: f32, yaw: f32, roll: f32) -> Rotator {
+        Rotator { pitch, yaw, roll }
+    }
+
+    /// Normalize angles to -180 to 180 range
+    #[wasm_bindgen(js_name = normalize)]
+    pub fn normalize(&self) -> Rotator {
+        let normalize_angle = |angle: f32| -> f32 {
+            let mut angle = angle;
+            while angle > 180.0 {
+                angle -= 360.0;
+            }
+            while angle < -180.0 {
+                angle += 360.0;
+            }
+            angle
+        };
+
+        Rotator {
+            pitch: normalize_angle(self.pitch),
+            yaw: normalize_angle(self.yaw),
+            roll: normalize_angle(self.roll),
+        }
+    }
+
+    /// Convert to radians
+    #[wasm_bindgen(js_name = toRadians)]
+    pub fn to_radians(&self) -> Vector {
+        Vector {
+            x: self.pitch.to_radians(),
+            y: self.yaw.to_radians(),
+            z: self.roll.to_radians(),
+        }
+    }
+
+    /// Convert to array [pitch, yaw, roll]
+    #[wasm_bindgen(js_name = toArray)]
+    pub fn to_array(&self) -> Vec<f32> {
+        vec![self.pitch, self.yaw, self.roll]
+    }
+}
+
+/// Combined Transform
+#[wasm_bindgen]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Transform {
+    pub location: Vector,
+    pub rotation: Rotator,
+    pub scale: Vector,
+}
+
+#[wasm_bindgen]
+impl Transform {
+    /// Create a new transform
+    #[wasm_bindgen(constructor)]
+    pub fn new(location: Vector, rotation: Rotator, scale: Vector) -> Transform {
+        Transform {
+            location,
+            rotation,
+            scale,
+        }
+    }
+
+    /// Get transformation matrix (4x4)
+    #[wasm_bindgen(js_name = toMatrix)]
+    pub fn to_matrix(&self) -> Vec<f32> {
+        // Convert to radians
+        let pitch_rad = self.rotation.pitch.to_radians();
+        let yaw_rad = self.rotation.yaw.to_radians();
+        let roll_rad = self.rotation.roll.to_radians();
+
+        // Calculate sine and cosine
+        let sin_pitch = pitch_rad.sin();
+        let cos_pitch = pitch_rad.cos();
+        let sin_yaw = yaw_rad.sin();
+        let cos_yaw = yaw_rad.cos();
+        let sin_roll = roll_rad.sin();
+        let cos_roll = roll_rad.cos();
+
+        // Create rotation matrix (Z * Y * X)
+        let m00 = cos_yaw * cos_roll + sin_yaw * sin_pitch * sin_roll;
+        let m01 = sin_roll * cos_pitch;
+        let m02 = -sin_yaw * cos_roll + cos_yaw * sin_pitch * sin_roll;
+
+        let m10 = -cos_yaw * sin_roll + sin_yaw * sin_pitch * cos_roll;
+        let m11 = cos_roll * cos_pitch;
+        let m12 = sin_roll * sin_yaw + cos_yaw * sin_pitch * cos_roll;
+
+        let m20 = sin_yaw * cos_pitch;
+        let m21 = -sin_pitch;
+        let m22 = cos_yaw * cos_pitch;
+
+        // Apply scale
+        let sx = self.scale.x;
+        let sy = self.scale.y;
+        let sz = self.scale.z;
+
+        // 4x4 transformation matrix
+        vec![
+            m00 * sx, m01 * sy, m02 * sz, 0.0,
+            m10 * sx, m11 * sy, m12 * sz, 0.0,
+            m20 * sx, m21 * sy, m22 * sz, 0.0,
+            self.location.x, self.location.y, self.location.z, 1.0,
+        ]
+    }
+
+    /// Convert to array [location.x, location.y, location.z, rotation.pitch, rotation.yaw, rotation.roll, scale.x, scale.y, scale.z]
+    #[wasm_bindgen(js_name = toArray)]
+    pub fn to_array(&self) -> Vec<f32> {
+        vec![
+            self.location.x,
+            self.location.y,
+            self.location.z,
+            self.rotation.pitch,
+            self.rotation.yaw,
+            self.rotation.roll,
+            self.scale.x,
+            self.scale.y,
+            self.scale.z,
+        ]
+    }
+}
+
+/// Transform calculator for composition and decomposition
+#[wasm_bindgen]
+pub struct TransformCalculator;
+
+#[wasm_bindgen]
+impl TransformCalculator {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> TransformCalculator {
+        TransformCalculator
+    }
+
+    /// Compose a transform from location, rotation, and scale
+    #[wasm_bindgen(js_name = composeTransform)]
+    pub fn compose_transform(
+        &self,
+        location: &[f32],
+        rotation: &[f32],
+        scale: &[f32],
+    ) -> Vec<f32> {
+        let vec_location = Vector::new(location[0], location[1], location[2]);
+        let rotator = Rotator::new(rotation[0], rotation[1], rotation[2]);
+        let vec_scale = Vector::new(scale[0], scale[1], scale[2]);
+
+        let transform = Transform::new(vec_location, rotator, vec_scale);
+        transform.to_array()
+    }
+
+    /// Decompose a 4x4 transformation matrix
+    #[wasm_bindgen(js_name = decomposeMatrix)]
+    pub fn decompose_matrix(&self, matrix: &[f32]) -> Vec<f32> {
+        // Support both full 4x4 matrices (len >= 16) and the compact
+        // [location(3), rotation(3), scale(3)] representation (len >= 9).
+
+        if matrix.len() >= 16 {
+            // Extract location (translation is in the last column)
+            let location = Vector::new(matrix[12], matrix[13], matrix[14]);
+
+            // Extract scale (from the first three columns)
+            let scale_x = (matrix[0] * matrix[0] + matrix[1] * matrix[1] + matrix[2] * matrix[2]).sqrt();
+            let scale_y = (matrix[4] * matrix[4] + matrix[5] * matrix[5] + matrix[6] * matrix[6]).sqrt();
+            let scale_z = (matrix[8] * matrix[8] + matrix[9] * matrix[9] + matrix[10] * matrix[10]).sqrt();
+
+            // Extract rotation from the rotation matrix
+            let m00 = matrix[0] / scale_x;
+            let _m01 = matrix[1] / scale_x;
+            let m02 = matrix[2] / scale_x;
+
+            let m10 = matrix[4] / scale_y;
+            let _m11 = matrix[5] / scale_y;
+            let m12 = matrix[6] / scale_y;
+
+            let m20 = matrix[8] / scale_z;
+            let m21 = matrix[9] / scale_z;
+            let m22 = matrix[10] / scale_z;
+
+            // Calculate pitch, yaw, roll
+            let pitch = m21.asin().to_degrees();
+            let roll = m20.atan2(m22).to_degrees();
+            let yaw = (-m00 * roll.sin() + m02 * roll.cos())
+                .atan2(m10 * roll.sin() - m12 * roll.cos())
+                .to_degrees();
+
+            vec![
+                location.x,
+                location.y,
+                location.z,
+                pitch,
+                yaw,
+                roll,
+                scale_x,
+                scale_y,
+                scale_z,
+            ]
+        } else if matrix.len() >= 9 {
+            // Compact representation: [lx, ly, lz, pitch, yaw, roll, sx, sy, sz]
+            let lx = matrix[0];
+            let ly = matrix[1];
+            let lz = matrix[2];
+            let pitch = matrix[3];
+            let yaw = matrix[4];
+            let roll = matrix[5];
+            let sx = matrix[6];
+            let sy = matrix[7];
+            let sz = matrix[8];
+
+            vec![lx, ly, lz, pitch, yaw, roll, sx, sy, sz]
+        } else {
+            // Invalid input size; avoid panicking in WASM and return a
+            // zeroed transform instead.
+            vec![0.0; 9]
+        }
+    }
+
+    /// Apply a transform to a point
+    #[wasm_bindgen(js_name = applyTransform)]
+    pub fn apply_transform(
+        &self,
+        point: &[f32],
+        transform: &[f32],
+    ) -> Vec<f32> {
+        let px = point[0];
+        let py = point[1];
+        let pz = point[2];
+
+        let tx = transform[0];
+        let ty = transform[1];
+        let tz = transform[2];
+
+        let _rpitch = transform[3];
+        let _ryaw = transform[4];
+        let _rroll = transform[5];
+
+        let sx = transform[6];
+        let sy = transform[7];
+        let sz = transform[8];
+
+        // Simple transform application (rotation + translation + scale)
+        // In a full implementation, you'd use proper matrix multiplication
+        let rotated_x = px * sx + tx;
+        let rotated_y = py * sy + ty;
+        let rotated_z = pz * sz + tz;
+
+        vec![rotated_x, rotated_y, rotated_z]
+    }
+}