unreal-engine-mcp-server 0.4.7 → 0.5.1

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]
+    }
+}

package/wasm/tests/integration.rs

@@ -0,0 +1,109 @@
+//! Integration tests for WASM module
+
+use wasm_bindgen_test::*;
+use unreal_mcp_wasm::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
+
+#[wasm_bindgen_test]
+fn test_property_parser() {
+    let parser = PropertyParser::new();
+
+    let json = r#"{
+        "name": "TestAsset",
+        "value": 42,
+        "location": {
+            "x": 100,
+            "y": 200,
+            "z": 300
+        },
+        "tags": ["tag1", "tag2"]
+    }"#;
+
+    let result = parser.parse_properties(json, None);
+    assert!(result.is_ok());
+}
+
+#[wasm_bindgen_test]
+fn test_vector_operations() {
+    let v1 = Vector::new(1.0, 2.0, 3.0);
+    let v2 = Vector::new(4.0, 5.0, 6.0);
+
+    let sum = v1.add(&v2);
+    assert_eq!(sum.x, 5.0);
+    assert_eq!(sum.y, 7.0);
+    assert_eq!(sum.z, 9.0);
+
+    let dot = v1.dot(&v2);
+    assert_eq!(dot, 32.0);
+
+    let length = v1.length();
+    assert!(length > 0.0);
+}
+
+#[wasm_bindgen_test]
+fn test_transform_calculator() {
+    let calculator = TransformCalculator::new();
+
+    let location = [100.0, 200.0, 300.0];
+    let rotation = [0.0, 90.0, 0.0];
+    let scale = [1.0, 1.0, 1.0];
+
+    let matrix = calculator.compose_transform(&location, &rotation, &scale);
+    assert_eq!(matrix.len(), 9);
+
+    // Verify location is preserved
+    assert_eq!(matrix[0], location[0]);
+    assert_eq!(matrix[1], location[1]);
+    assert_eq!(matrix[2], location[2]);
+}
+
+#[wasm_bindgen_test]
+fn test_dependency_resolver() {
+    let resolver = DependencyResolver::new();
+
+    let json = r#"{
+        "AssetA": ["AssetB", "AssetC"],
+        "AssetB": ["AssetC"],
+        "AssetC": []
+    }"#;
+
+    let result = resolver.analyze_dependencies("AssetA", json, None);
+    assert!(result.is_ok());
+}
+
+#[wasm_bindgen_test]
+fn test_utils() {
+    assert_eq!(Utils::clamp(5.0, 0.0, 10.0), 5.0);
+    assert_eq!(Utils::clamp(-5.0, 0.0, 10.0), 0.0);
+    assert_eq!(Utils::clamp(15.0, 0.0, 10.0), 10.0);
+
+    assert!((Utils::lerp(0.0, 10.0, 0.5) - 5.0).abs() < 0.001);
+
+    let rad = Utils::deg_to_rad(180.0);
+    assert!((rad - std::f32::consts::PI).abs() < 0.001);
+
+    let deg = Utils::rad_to_deg(std::f32::consts::PI);
+    assert!((deg - 180.0).abs() < 0.001);
+}
+
+#[wasm_bindgen_test]
+fn test_metrics() {
+    let mut metrics = Metrics::new();
+
+    metrics.record("test_op".to_string(), 10.0);
+    metrics.record("test_op".to_string(), 20.0);
+    metrics.record("other_op".to_string(), 15.0);
+
+    let avg_test = metrics.average_for("test_op".to_string());
+    assert_eq!(avg_test, 15.0);
+
+    let avg_other = metrics.average_for("other_op".to_string());
+    assert_eq!(avg_other, 15.0);
+
+    let count = metrics.count();
+    assert_eq!(count, 3);
+
+    metrics.clear();
+    assert_eq!(metrics.count(), 0);
+}

package/.github/workflows/smithery-build.yml

@@ -1,29 +0,0 @@
-name: Smithery Build
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-          cache: 'npm'
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Type-check
-        run: npm run type-check
-
-      - name: Smithery build
-        run: npm run smithery:ci

package/dist/prompts/index.d.ts

@@ -1,21 +0,0 @@
-export interface PromptArgument {
-    type: string;
-    description?: string;
-    enum?: string[];
-    default?: unknown;
-    required?: boolean;
-}
-export interface PromptTemplate {
-    name: string;
-    description: string;
-    arguments?: Record<string, PromptArgument>;
-    build: (args: Record<string, unknown>) => Array<{
-        role: 'user' | 'assistant';
-        content: {
-            type: 'text';
-            text: string;
-        };
-    }>;
-}
-export declare const prompts: PromptTemplate[];
-//# sourceMappingURL=index.d.ts.map