unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/handlers/lighting-handlers.js

@@ -0,0 +1,144 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { normalizeLocation } from './common-handlers.js';
+export async function handleLightingTools(action, args, tools) {
+    const normalizedLocation = normalizeLocation(args.location);
+    switch (action) {
+        case 'spawn_light':
+        case 'create_light': {
+            const lightType = args.lightType ? args.lightType.toLowerCase() : 'point';
+            const commonParams = {
+                name: args.name,
+                location: normalizedLocation || args.location,
+                rotation: args.rotation,
+                intensity: args.intensity,
+                color: args.color,
+                castShadows: args.castShadows
+            };
+            if (lightType === 'directional') {
+                return cleanObject(await tools.lightingTools.createDirectionalLight({
+                    ...commonParams,
+                    temperature: args.temperature,
+                    useAsAtmosphereSunLight: args.useAsAtmosphereSunLight
+                }));
+            }
+            else if (lightType === 'spot') {
+                return cleanObject(await tools.lightingTools.createSpotLight({
+                    ...commonParams,
+                    location: normalizedLocation || [0, 0, 0],
+                    rotation: args.rotation || [0, 0, 0],
+                    innerCone: args.innerCone,
+                    outerCone: args.outerCone,
+                    radius: args.radius
+                }));
+            }
+            else if (lightType === 'rect') {
+                return cleanObject(await tools.lightingTools.createRectLight({
+                    ...commonParams,
+                    location: normalizedLocation || [0, 0, 0],
+                    rotation: args.rotation || [0, 0, 0],
+                    width: args.width,
+                    height: args.height
+                }));
+            }
+            else {
+                return cleanObject(await tools.lightingTools.createPointLight({
+                    ...commonParams,
+                    radius: args.radius,
+                    falloffExponent: args.falloffExponent
+                }));
+            }
+        }
+        case 'create_dynamic_light': {
+            return cleanObject(await tools.lightingTools.createDynamicLight({
+                name: args.name,
+                lightType: args.lightType,
+                location: args.location,
+                rotation: args.rotation,
+                intensity: args.intensity,
+                color: args.color,
+                pulse: args.pulse
+            }));
+        }
+        case 'spawn_sky_light':
+        case 'create_sky_light': {
+            return cleanObject(await tools.lightingTools.createSkyLight({
+                name: args.name,
+                sourceType: args.sourceType,
+                cubemapPath: args.cubemapPath,
+                intensity: args.intensity,
+                recapture: args.recapture
+            }));
+        }
+        case 'ensure_single_sky_light': {
+            return cleanObject(await tools.lightingTools.ensureSingleSkyLight({
+                name: args.name,
+                recapture: args.recapture
+            }));
+        }
+        case 'create_lightmass_volume': {
+            return cleanObject(await tools.lightingTools.createLightmassVolume({
+                name: args.name,
+                location: args.location,
+                size: args.size
+            }));
+        }
+        case 'setup_volumetric_fog': {
+            return cleanObject(await tools.lightingTools.setupVolumetricFog({
+                enabled: args.enabled !== false,
+                density: args.density,
+                scatteringIntensity: args.scatteringIntensity,
+                fogHeight: args.fogHeight
+            }));
+        }
+        case 'setup_global_illumination': {
+            return cleanObject(await tools.lightingTools.setupGlobalIllumination({
+                method: args.method,
+                quality: args.quality,
+                indirectLightingIntensity: args.indirectLightingIntensity,
+                bounces: args.bounces
+            }));
+        }
+        case 'configure_shadows': {
+            return cleanObject(await tools.lightingTools.configureShadows({
+                shadowQuality: args.shadowQuality,
+                cascadedShadows: args.cascadedShadows,
+                shadowDistance: args.shadowDistance,
+                contactShadows: args.contactShadows,
+                rayTracedShadows: args.rayTracedShadows
+            }));
+        }
+        case 'set_exposure': {
+            return cleanObject(await tools.lightingTools.setExposure({
+                method: args.method,
+                compensationValue: args.compensationValue,
+                minBrightness: args.minBrightness,
+                maxBrightness: args.maxBrightness
+            }));
+        }
+        case 'set_ambient_occlusion': {
+            return cleanObject(await tools.lightingTools.setAmbientOcclusion({
+                enabled: args.enabled !== false,
+                intensity: args.intensity,
+                radius: args.radius,
+                quality: args.quality
+            }));
+        }
+        case 'build_lighting': {
+            return cleanObject(await tools.lightingTools.buildLighting({
+                quality: args.quality,
+                buildOnlySelected: args.buildOnlySelected,
+                buildReflectionCaptures: args.buildReflectionCaptures
+            }));
+        }
+        case 'create_lighting_enabled_level': {
+            return cleanObject(await tools.lightingTools.createLightingEnabledLevel({
+                levelName: args.levelName,
+                copyActors: args.copyActors,
+                useTemplate: args.useTemplate
+            }));
+        }
+        default:
+            throw new Error(`Unknown lighting action: ${action}`);
+    }
+}
+//# sourceMappingURL=lighting-handlers.js.map

package/dist/tools/handlers/performance-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ITools } from '../../types/tool-interfaces.js';
+export declare function handlePerformanceTools(action: string, args: any, tools: ITools): Promise<any>;
+//# sourceMappingURL=performance-handlers.d.ts.map

package/dist/tools/handlers/performance-handlers.js

@@ -0,0 +1,130 @@
+import { cleanObject } from '../../utils/safe-json.js';
+export async function handlePerformanceTools(action, args, tools) {
+    switch (action) {
+        case 'start_profiling': {
+            return cleanObject(await tools.performanceTools.startProfiling({
+                type: args.type || 'All',
+                duration: args.duration
+            }));
+        }
+        case 'stop_profiling': {
+            return cleanObject(await tools.performanceTools.stopProfiling());
+        }
+        case 'run_benchmark': {
+            return cleanObject(await tools.performanceTools.runBenchmark({
+                duration: args.duration,
+                outputPath: args.outputPath
+            }));
+        }
+        case 'show_fps': {
+            return cleanObject(await tools.performanceTools.showFPS({
+                enabled: args.enabled !== false,
+                verbose: args.verbose
+            }));
+        }
+        case 'show_stats': {
+            return cleanObject(await tools.performanceTools.showStats({
+                category: args.category || args.type || 'Unit',
+                enabled: args.enabled !== false
+            }));
+        }
+        case 'set_scalability': {
+            const category = args.category || 'ViewDistance';
+            const level = typeof args.level === 'number' ? args.level : 3;
+            return cleanObject(await tools.performanceTools.setScalability({
+                category,
+                level
+            }));
+        }
+        case 'set_resolution_scale': {
+            return cleanObject(await tools.performanceTools.setResolutionScale({
+                scale: args.scale
+            }));
+        }
+        case 'set_vsync': {
+            return cleanObject(await tools.performanceTools.setVSync({
+                enabled: args.enabled !== false
+            }));
+        }
+        case 'set_frame_rate_limit': {
+            return cleanObject(await tools.performanceTools.setFrameRateLimit({
+                maxFPS: args.maxFPS
+            }));
+        }
+        case 'enable_gpu_timing': {
+            return cleanObject(await tools.performanceTools.enableGPUTiming({
+                enabled: args.enabled !== false
+            }));
+        }
+        case 'generate_memory_report': {
+            return cleanObject(await tools.performanceTools.generateMemoryReport({
+                detailed: args.detailed,
+                outputPath: args.outputPath
+            }));
+        }
+        case 'configure_texture_streaming': {
+            return cleanObject(await tools.performanceTools.configureTextureStreaming({
+                enabled: args.enabled !== false,
+                poolSize: args.poolSize,
+                boostPlayerLocation: args.boostPlayerLocation
+            }));
+        }
+        case 'configure_lod': {
+            return cleanObject(await tools.performanceTools.configureLOD({
+                forceLOD: args.forceLOD,
+                lodBias: args.lodBias,
+                distanceScale: args.distanceScale
+            }));
+        }
+        case 'apply_baseline_settings': {
+            return cleanObject(await tools.performanceTools.applyBaselinePerformanceSettings({
+                distanceScale: args.distanceScale,
+                skeletalBias: args.skeletalBias,
+                vsync: args.vsync,
+                maxFPS: args.maxFPS,
+                hzb: args.hzb
+            }));
+        }
+        case 'optimize_draw_calls':
+        case 'merge_actors': {
+            const mergeParams = action === 'merge_actors' ? { ...args, mergeActors: true } : args;
+            return cleanObject(await tools.performanceTools.optimizeDrawCalls({
+                enableInstancing: mergeParams.enableInstancing,
+                enableBatching: mergeParams.enableBatching,
+                mergeActors: mergeParams.mergeActors,
+                actors: mergeParams.actors
+            }));
+        }
+        case 'configure_occlusion_culling': {
+            return cleanObject(await tools.performanceTools.configureOcclusionCulling({
+                enabled: args.enabled !== false,
+                method: args.method,
+                freezeRendering: args.freezeRendering
+            }));
+        }
+        case 'optimize_shaders': {
+            return cleanObject(await tools.performanceTools.optimizeShaders({
+                compileOnDemand: args.compileOnDemand,
+                cacheShaders: args.cacheShaders,
+                reducePermutations: args.reducePermutations
+            }));
+        }
+        case 'configure_nanite': {
+            return cleanObject(await tools.performanceTools.configureNanite({
+                enabled: args.enabled !== false,
+                maxPixelsPerEdge: args.maxPixelsPerEdge,
+                streamingPoolSize: args.streamingPoolSize
+            }));
+        }
+        case 'configure_world_partition': {
+            return cleanObject(await tools.performanceTools.configureWorldPartition({
+                enabled: args.enabled !== false,
+                streamingDistance: args.streamingDistance,
+                cellSize: args.cellSize
+            }));
+        }
+        default:
+            throw new Error(`Unknown performance action: ${action}`);
+    }
+}
+//# sourceMappingURL=performance-handlers.js.map

package/dist/tools/handlers/pipeline-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ITools } from '../../types/tool-interfaces.js';
+export declare function handlePipelineTools(action: string, args: any, tools: ITools): Promise<any>;
+//# sourceMappingURL=pipeline-handlers.d.ts.map

package/dist/tools/handlers/pipeline-handlers.js

@@ -0,0 +1,110 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { executeAutomationRequest } from './common-handlers.js';
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+export async function handlePipelineTools(action, args, tools) {
+    switch (action) {
+        case 'run_ubt': {
+            const target = args.target;
+            const platform = args.platform || 'Win64';
+            const configuration = args.configuration || 'Development';
+            const extraArgs = args.arguments || '';
+            if (!target) {
+                return { success: false, error: 'MISSING_TARGET', message: 'Target is required for run_ubt' };
+            }
+            let ubtPath = 'UnrealBuildTool';
+            const enginePath = process.env.UE_ENGINE_PATH || process.env.UNREAL_ENGINE_PATH;
+            if (enginePath) {
+                const possiblePath = path.join(enginePath, 'Engine', 'Binaries', 'DotNET', 'UnrealBuildTool', 'UnrealBuildTool.exe');
+                if (fs.existsSync(possiblePath)) {
+                    ubtPath = possiblePath;
+                }
+            }
+            let projectPath = process.env.UE_PROJECT_PATH;
+            if (!projectPath && args.projectPath) {
+                projectPath = args.projectPath;
+            }
+            if (!projectPath) {
+                return { success: false, error: 'MISSING_PROJECT_PATH', message: 'UE_PROJECT_PATH environment variable is not set and no projectPath argument was provided.' };
+            }
+            let uprojectFile = projectPath;
+            if (!uprojectFile.endsWith('.uproject')) {
+                try {
+                    const files = fs.readdirSync(projectPath);
+                    const found = files.find(f => f.endsWith('.uproject'));
+                    if (found) {
+                        uprojectFile = path.join(projectPath, found);
+                    }
+                }
+                catch (_e) {
+                    return { success: false, error: 'INVALID_PROJECT_PATH', message: `Could not read project directory: ${projectPath}` };
+                }
+            }
+            const cmdArgs = [
+                target,
+                platform,
+                configuration,
+                `-Project="${uprojectFile}"`,
+                extraArgs
+            ].filter(Boolean);
+            return new Promise((resolve) => {
+                const child = spawn(ubtPath, cmdArgs, { shell: true });
+                const MAX_OUTPUT_SIZE = 20 * 1024;
+                let stdout = '';
+                let stderr = '';
+                child.stdout.on('data', (data) => {
+                    const str = data.toString();
+                    process.stderr.write(str);
+                    stdout += str;
+                    if (stdout.length > MAX_OUTPUT_SIZE) {
+                        stdout = stdout.substring(stdout.length - MAX_OUTPUT_SIZE);
+                    }
+                });
+                child.stderr.on('data', (data) => {
+                    const str = data.toString();
+                    process.stderr.write(str);
+                    stderr += str;
+                    if (stderr.length > MAX_OUTPUT_SIZE) {
+                        stderr = stderr.substring(stderr.length - MAX_OUTPUT_SIZE);
+                    }
+                });
+                child.on('close', (code) => {
+                    const truncatedNote = (stdout.length >= MAX_OUTPUT_SIZE || stderr.length >= MAX_OUTPUT_SIZE)
+                        ? '\n[Output truncated for response payload]'
+                        : '';
+                    if (code === 0) {
+                        resolve({
+                            success: true,
+                            message: 'UnrealBuildTool finished successfully',
+                            output: stdout + truncatedNote,
+                            command: `${ubtPath} ${cmdArgs.join(' ')}`
+                        });
+                    }
+                    else {
+                        resolve({
+                            success: false,
+                            error: 'UBT_FAILED',
+                            message: `UnrealBuildTool failed with code ${code}`,
+                            output: stdout + truncatedNote,
+                            errorOutput: stderr + truncatedNote,
+                            command: `${ubtPath} ${cmdArgs.join(' ')}`
+                        });
+                    }
+                });
+                child.on('error', (err) => {
+                    resolve({
+                        success: false,
+                        error: 'SPAWN_FAILED',
+                        message: `Failed to spawn UnrealBuildTool: ${err.message}`,
+                        command: `${ubtPath} ${cmdArgs.join(' ')}`
+                    });
+                });
+            });
+        }
+        default:
+            const res = await executeAutomationRequest(tools, 'manage_pipeline', { ...args, subAction: action }, 'Automation bridge not available for manage_pipeline');
+            return cleanObject(res);
+    }
+}
+//# sourceMappingURL=pipeline-handlers.js.map

package/dist/tools/handlers/sequence-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ITools } from '../../types/tool-interfaces.js';
+export declare function handleSequenceTools(action: string, args: any, tools: ITools): Promise<any>;
+//# sourceMappingURL=sequence-handlers.d.ts.map