unreal-engine-mcp-server 0.4.6 → 0.5.0

package/wasm/src/dependency_resolver.rs

@@ -0,0 +1,377 @@
+//! Asset dependency resolution module
+//!
+//! This module provides efficient traversal and analysis of
+//! asset dependency graphs.
+
+use serde::{Deserialize, Serialize};
+use std::collections::{HashSet, HashMap, VecDeque};
+use wasm_bindgen::prelude::*;
+use serde_wasm_bindgen as swb;
+
+/// Asset dependency information
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct AssetDependency {
+    pub path: String,
+    pub dependencies: Vec<String>,
+    pub dependents: Vec<String>,
+    pub depth: u32,
+}
+
+/// Dependency graph analysis result
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DependencyAnalysis {
+    pub asset: String,
+    pub dependencies: Vec<AssetDependency>,
+    pub total_dependency_count: usize,
+    pub max_depth: u32,
+    pub circular_dependencies: Vec<Vec<String>>,
+    pub analysis_time_ms: f64,
+}
+
+#[wasm_bindgen]
+pub struct DependencyResolver {
+    /// Maximum depth to prevent infinite recursion
+    max_depth: usize,
+}
+
+#[wasm_bindgen]
+impl DependencyResolver {
+    /// Create a DependencyResolver with default max depth (100)
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> DependencyResolver {
+        console_error_panic_hook::set_once();
+        DependencyResolver { max_depth: 100 }
+    }
+
+    /// Create a DependencyResolver with custom max depth
+    #[wasm_bindgen(js_name = withMaxDepth)]
+    pub fn with_max_depth(max_depth: usize) -> DependencyResolver {
+        console_error_panic_hook::set_once();
+        DependencyResolver { max_depth }
+    }
+
+    /// Analyze dependencies for an asset
+    #[wasm_bindgen(js_name = analyzeDependencies)]
+    pub fn analyze_dependencies(
+        &self,
+        asset_path: &str,
+        dependencies_json: &str,
+        max_depth: Option<usize>,
+    ) -> Result<JsValue, JsValue> {
+        let start = js_sys::Date::now();
+
+        let dependencies_map: HashMap<String, Vec<String>> = serde_json::from_str(dependencies_json)
+            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
+
+        let depth_limit = max_depth.unwrap_or(self.max_depth);
+
+        if !dependencies_map.contains_key(asset_path) {
+            return Err(JsValue::from_str(&format!("Asset not found: {}", asset_path)));
+        }
+
+        let mut visited = HashSet::new();
+        let mut result = Vec::new();
+        let mut stack = VecDeque::new();
+        let mut circular_deps = Vec::new();
+
+        stack.push_back((asset_path.to_string(), 0));
+
+        while let Some((current_path, current_depth)) = stack.pop_front() {
+            if current_depth > depth_limit {
+                continue;
+            }
+
+            if visited.contains(&current_path) {
+                // Found circular dependency
+                circular_deps.push(vec![current_path.clone()]);
+                continue;
+            }
+
+            visited.insert(current_path.clone());
+
+            if let Some(deps) = dependencies_map.get(&current_path) {
+                result.push(AssetDependency {
+                    path: current_path.clone(),
+                    dependencies: deps.clone(),
+                    dependents: self.find_dependents_internal(&current_path, &dependencies_map),
+                    depth: current_depth as u32,
+                });
+
+                for dep in deps {
+                    if !visited.contains(dep) {
+                        stack.push_back((dep.clone(), current_depth + 1));
+                    }
+                }
+            }
+        }
+
+        let analysis_time = js_sys::Date::now() - start;
+
+        let total_dependency_count = result.len();
+
+        let analysis = DependencyAnalysis {
+            asset: asset_path.to_string(),
+            dependencies: result,
+            total_dependency_count,
+            max_depth: depth_limit as u32,
+            circular_dependencies: circular_deps,
+            analysis_time_ms: analysis_time,
+        };
+
+        let js_value = swb::to_value(&analysis)
+            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))?;
+        Ok(js_value)
+    }
+
+    /// Find all dependents of an asset
+    #[wasm_bindgen(js_name = findDependents)]
+    pub fn find_dependents(
+        &self,
+        asset_path: &str,
+        dependencies_json: &str,
+    ) -> Result<JsValue, JsValue> {
+        let dependencies_map: HashMap<String, Vec<String>> = serde_json::from_str(dependencies_json)
+            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
+
+        let dependents = self.find_dependents_internal(asset_path, &dependencies_map);
+
+        let js_value = swb::to_value(&dependents)
+            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))?;
+        Ok(js_value)
+    }
+
+    /// Calculate dependency depth
+    #[wasm_bindgen(js_name = calculateDepth)]
+    pub fn calculate_depth(
+        &self,
+        asset_path: &str,
+        dependencies_json: &str,
+        max_depth: Option<usize>,
+    ) -> Result<u32, JsValue> {
+        let dependencies_map: HashMap<String, Vec<String>> = serde_json::from_str(dependencies_json)
+            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
+
+        let depth_limit = max_depth.unwrap_or(self.max_depth);
+
+        let depth = self.calculate_depth_internal(asset_path, &dependencies_map, depth_limit, &mut HashSet::new());
+
+        Ok(depth)
+    }
+
+    /// Find circular dependencies in the graph
+    #[wasm_bindgen(js_name = findCircularDependencies)]
+    pub fn find_circular_dependencies(
+        &self,
+        dependencies_json: &str,
+        max_depth: Option<usize>,
+    ) -> Result<JsValue, JsValue> {
+        let dependencies_map: HashMap<String, Vec<String>> = serde_json::from_str(dependencies_json)
+            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
+
+        let depth_limit = max_depth.unwrap_or(self.max_depth);
+
+        let circular_deps = self.find_circular_dependencies_internal(&dependencies_map, depth_limit);
+
+        let js_value = swb::to_value(&circular_deps)
+            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))?;
+        Ok(js_value)
+    }
+
+    /// Topological sort of dependencies
+    #[wasm_bindgen(js_name = topologicalSort)]
+    pub fn topological_sort(
+        &self,
+        dependencies_json: &str,
+    ) -> Result<JsValue, JsValue> {
+        let dependencies_map: HashMap<String, Vec<String>> = serde_json::from_str(dependencies_json)
+            .map_err(|e| JsValue::from_str(&format!("JSON parse error: {}", e)))?;
+
+        let sorted = self.topological_sort_internal(&dependencies_map)?;
+
+        let js_value = swb::to_value(&sorted)
+            .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))?;
+        Ok(js_value)
+    }
+}
+
+impl DependencyResolver {
+    fn find_dependents_internal(
+        &self,
+        asset_path: &str,
+        dependencies_map: &HashMap<String, Vec<String>>,
+    ) -> Vec<String> {
+        let mut dependents = Vec::new();
+
+        for (path, deps) in dependencies_map {
+            if deps.contains(&asset_path.to_string()) {
+                dependents.push(path.clone());
+            }
+        }
+
+        dependents
+    }
+
+    fn calculate_depth_internal(
+        &self,
+        asset_path: &str,
+        dependencies_map: &HashMap<String, Vec<String>>,
+        max_depth: usize,
+        visited: &mut HashSet<String>,
+    ) -> u32 {
+        if visited.contains(asset_path) {
+            return 0;
+        }
+
+        if max_depth == 0 {
+            return 0;
+        }
+
+        visited.insert(asset_path.to_string());
+
+        if let Some(deps) = dependencies_map.get(asset_path) {
+            if deps.is_empty() {
+                visited.remove(asset_path);
+                return 0;
+            }
+
+            let mut max_child_depth = 0;
+            for dep in deps {
+                let child_depth = self.calculate_depth_internal(
+                    dep,
+                    dependencies_map,
+                    max_depth - 1,
+                    visited,
+                );
+                max_child_depth = max_child_depth.max(child_depth);
+            }
+
+            visited.remove(asset_path);
+            max_child_depth + 1
+        } else {
+            visited.remove(asset_path);
+            0
+        }
+    }
+
+    fn find_circular_dependencies_internal(
+        &self,
+        dependencies_map: &HashMap<String, Vec<String>>,
+        max_depth: usize,
+    ) -> Vec<Vec<String>> {
+        let mut cycles = Vec::new();
+        let mut visited = HashSet::new();
+        let mut stack = HashSet::new();
+
+        fn dfs(
+            current: &str,
+            dependencies_map: &HashMap<String, Vec<String>>,
+            visited: &mut HashSet<String>,
+            stack: &mut HashSet<String>,
+            cycles: &mut Vec<Vec<String>>,
+            path: &mut Vec<String>,
+            depth: usize,
+            max_depth: usize,
+        ) {
+            if depth > max_depth {
+                return;
+            }
+
+            visited.insert(current.to_string());
+            stack.insert(current.to_string());
+            path.push(current.to_string());
+
+            if let Some(deps) = dependencies_map.get(current) {
+                for dep in deps {
+                    if !visited.contains(dep) {
+                        dfs(
+                            dep,
+                            dependencies_map,
+                            visited,
+                            stack,
+                            cycles,
+                            path,
+                            depth + 1,
+                            max_depth,
+                        );
+                    } else if stack.contains(dep) {
+                        // Found a cycle
+                        let cycle_start = path.iter().position(|p| p == dep);
+                        if let Some(start) = cycle_start {
+                            cycles.push(path[start..].to_vec());
+                        }
+                    }
+                }
+            }
+
+            stack.remove(current);
+            path.pop();
+        }
+
+        for asset in dependencies_map.keys() {
+            if !visited.contains(asset) {
+                let mut path = Vec::new();
+                dfs(
+                    asset,
+                    dependencies_map,
+                    &mut visited,
+                    &mut stack,
+                    &mut cycles,
+                    &mut path,
+                    0,
+                    max_depth,
+                );
+            }
+        }
+
+        cycles
+    }
+
+    fn topological_sort_internal(
+        &self,
+        dependencies_map: &HashMap<String, Vec<String>>,
+    ) -> Result<Vec<String>, JsValue> {
+        let mut in_degree: HashMap<String, usize> = HashMap::new();
+        let mut graph: HashMap<String, Vec<String>> = HashMap::new();
+
+        // Initialize
+        for (asset, deps) in dependencies_map {
+            in_degree.entry(asset.clone()).or_insert(0);
+            for dep in deps {
+                in_degree.entry(dep.clone()).or_insert(0);
+                graph.entry(dep.clone()).or_insert_with(Vec::new).push(asset.clone());
+            }
+        }
+
+        // Kahn's algorithm
+        let mut queue: VecDeque<String> = in_degree
+            .iter()
+            .filter(|(_, &degree)| degree == 0)
+            .map(|(asset, _)| asset.clone())
+            .collect();
+
+        let mut sorted = Vec::new();
+
+        while let Some(asset) = queue.pop_front() {
+            sorted.push(asset.clone());
+
+            if let Some(dependents) = graph.get(&asset) {
+                for dependent in dependents {
+                    if let Some(&mut ref mut degree) = in_degree.get_mut(dependent) {
+                        *degree -= 1;
+                        if *degree == 0 {
+                            queue.push_back(dependent.clone());
+                        }
+                    }
+                }
+            }
+        }
+
+        if sorted.len() != in_degree.len() {
+            return Err(JsValue::from_str("Graph contains cycles - topological sort not possible"));
+        }
+
+        Ok(sorted)
+    }
+}

package/wasm/src/lib.rs

@@ -0,0 +1,153 @@
+//! WebAssembly module for performance-critical operations
+//! in the Unreal Engine MCP Server.
+//!
+//! This module provides optimized implementations for:
+//! - Property parsing and serialization
+//! - Transform calculations
+//! - Vector math
+//! - Asset dependency resolution
+
+mod property_parser;
+mod transform_math;
+mod dependency_resolver;
+
+pub use property_parser::PropertyParser;
+pub use transform_math::{TransformCalculator, Vector, Rotator, Transform};
+pub use dependency_resolver::DependencyResolver;
+
+// Re-export wasm-bindgen for convenience
+pub use wasm_bindgen::prelude::*;
+
+/// Initialize the WASM module
+#[wasm_bindgen(start)]
+pub fn main() {
+    // This function is called when the module is loaded
+    console_error_panic_hook::set_once();
+    web_sys::console::log_1(&"WASM module initialized".into());
+}
+
+// Provide console logging in WASM
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = console)]
+    fn log(s: &str);
+
+    #[wasm_bindgen(js_namespace = console)]
+    fn error(s: &str);
+
+    #[wasm_bindgen(js_namespace = console)]
+    fn warn(s: &str);
+}
+
+/// Utility functions
+#[wasm_bindgen]
+pub struct Utils;
+
+#[wasm_bindgen]
+impl Utils {
+    /// Get the current high-resolution time in milliseconds
+    #[wasm_bindgen(js_name = now)]
+    pub fn now() -> f64 {
+        web_sys::window()
+            .and_then(|w| w.performance())
+            .map(|p| p.now())
+            .unwrap_or(0.0)
+    }
+
+    /// Generate a random floating-point number between 0 and 1
+    #[wasm_bindgen(js_name = random)]
+    pub fn random() -> f64 {
+        js_sys::Math::random()
+    }
+
+    /// Clamp a number between min and max
+    #[wasm_bindgen(js_name = clamp)]
+    pub fn clamp(value: f32, min: f32, max: f32) -> f32 {
+        value.max(min).min(max)
+    }
+
+    /// Linear interpolation between two values
+    #[wasm_bindgen(js_name = lerp)]
+    pub fn lerp(a: f32, b: f32, t: f32) -> f32 {
+        a + (b - a) * t
+    }
+
+    /// Convert degrees to radians
+    #[wasm_bindgen(js_name = degToRad)]
+    pub fn deg_to_rad(degrees: f32) -> f32 {
+        degrees * std::f32::consts::PI / 180.0
+    }
+
+    /// Convert radians to degrees
+    #[wasm_bindgen(js_name = radToDeg)]
+    pub fn rad_to_deg(radians: f32) -> f32 {
+        radians * 180.0 / std::f32::consts::PI
+    }
+}
+
+/// Performance metrics for WASM operations
+#[wasm_bindgen]
+pub struct Metrics {
+    operations: Vec<OperationMetric>,
+}
+
+#[derive(Clone)]
+struct OperationMetric {
+    name: String,
+    duration_ms: f64,
+    #[allow(dead_code)]
+    timestamp: f64,
+}
+
+#[wasm_bindgen]
+impl Metrics {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Metrics {
+        Metrics {
+            operations: Vec::new(),
+        }
+    }
+
+    /// Record an operation
+    #[wasm_bindgen(js_name = record)]
+    pub fn record(&mut self, name: String, duration_ms: f64) {
+        let timestamp = js_sys::Date::now();
+        self.operations.push(OperationMetric {
+            name,
+            duration_ms,
+            timestamp,
+        });
+    }
+
+    /// Get average duration for an operation
+    #[wasm_bindgen(js_name = averageFor)]
+    pub fn average_for(&self, name: String) -> f64 {
+        let mut total = 0.0;
+        let mut count = 0.0;
+
+        for op in &self.operations {
+            if op.name == name {
+                total += op.duration_ms;
+                count += 1.0;
+            }
+        }
+
+        if count > 0.0 {
+            total / count
+        } else {
+            0.0
+        }
+    }
+
+    /// Get total number of operations recorded
+    #[wasm_bindgen]
+    pub fn count(&self) -> u32 {
+        self.operations.len() as u32
+    }
+
+    /// Clear all metrics
+    #[wasm_bindgen]
+    pub fn clear(&mut self) {
+        self.operations.clear();
+    }
+}