unreal-engine-mcp-server 0.2.1

package/dist/tools/performance.d.ts

@@ -0,0 +1,163 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+export declare class PerformanceTools {
+    private bridge;
+    constructor(bridge: UnrealBridge);
+    private _executeCommand;
+    startProfiling(params: {
+        type: 'CPU' | 'GPU' | 'Memory' | 'RenderThread' | 'GameThread' | 'All';
+        duration?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    stopProfiling(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    showFPS(params: {
+        enabled: boolean;
+        verbose?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        fpsVisible: boolean;
+        command: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        fpsVisible: boolean;
+        message?: undefined;
+        command?: undefined;
+    }>;
+    showStats(params: {
+        category: 'Unit' | 'FPS' | 'Memory' | 'Game' | 'Slate' | 'Engine' | 'RHI' | 'Streaming' | 'SceneRendering' | 'Physics' | 'Navigation' | 'Particles' | 'Audio';
+        enabled: boolean;
+    }): Promise<any>;
+    setScalability(params: {
+        category: 'ViewDistance' | 'AntiAliasing' | 'PostProcessing' | 'PostProcess' | 'Shadows' | 'GlobalIllumination' | 'Reflections' | 'Textures' | 'Effects' | 'Foliage' | 'Shading';
+        level: 0 | 1 | 2 | 3 | 4;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        verified: any;
+        readback: any;
+        method: any;
+    } | {
+        success: boolean;
+        message: string;
+        method: string;
+        verified?: undefined;
+        readback?: undefined;
+    }>;
+    setResolutionScale(params: {
+        scale: number;
+    }): Promise<{
+        success: boolean;
+        error: string;
+        message?: undefined;
+        actualScale?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        actualScale: number;
+        error?: undefined;
+    }>;
+    setVSync(params: {
+        enabled: boolean;
+    }): Promise<any>;
+    setFrameRateLimit(params: {
+        maxFPS: number;
+    }): Promise<any>;
+    enableGPUTiming(params: {
+        enabled: boolean;
+    }): Promise<any>;
+    generateMemoryReport(params: {
+        detailed?: boolean;
+        outputPath?: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    configureTextureStreaming(params: {
+        enabled: boolean;
+        poolSize?: number;
+        boostPlayerLocation?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    configureLOD(params: {
+        forceLOD?: number;
+        lodBias?: number;
+        distanceScale?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    applyBaselinePerformanceSettings(params?: {
+        distanceScale?: number;
+        skeletalBias?: number;
+        vsync?: boolean;
+        maxFPS?: number;
+        hzb?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        params: {
+            distanceScale: number;
+            skeletalBias: number;
+            vsync: boolean;
+            maxFPS: number;
+            hzb: boolean;
+        };
+    }>;
+    optimizeDrawCalls(params: {
+        enableInstancing?: boolean;
+        enableBatching?: boolean;
+        mergeActors?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    configureOcclusionCulling(params: {
+        enabled: boolean;
+        method?: 'Hardware' | 'Software' | 'Hierarchical';
+        freezeRendering?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    optimizeShaders(params: {
+        compileOnDemand?: boolean;
+        cacheShaders?: boolean;
+        reducePermutations?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    configureNanite(params: {
+        enabled: boolean;
+        maxPixelsPerEdge?: number;
+        streamingPoolSize?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    configureWorldPartition(params: {
+        enabled: boolean;
+        streamingDistance?: number;
+        cellSize?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    runBenchmark(params: {
+        duration?: number;
+        outputPath?: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+//# sourceMappingURL=performance.d.ts.map

package/dist/tools/performance.js

@@ -0,0 +1,412 @@
+export class PerformanceTools {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    // Execute console command
+    async _executeCommand(command) {
+        return this.bridge.httpCall('/remote/object/call', 'PUT', {
+            objectPath: '/Script/Engine.Default__KismetSystemLibrary',
+            functionName: 'ExecuteConsoleCommand',
+            parameters: {
+                WorldContextObject: null,
+                Command: command,
+                SpecificPlayer: null
+            },
+            generateTransaction: false
+        });
+    }
+    // Start profiling
+    async startProfiling(params) {
+        const commands = [];
+        switch (params.type) {
+            case 'CPU':
+                commands.push('stat startfile');
+                break;
+            case 'GPU':
+                commands.push('profilegpu');
+                break;
+            case 'Memory':
+                commands.push('stat memory');
+                break;
+            case 'RenderThread':
+                commands.push('stat renderthread');
+                break;
+            case 'GameThread':
+                commands.push('stat game');
+                break;
+            case 'All':
+                commands.push('stat startfile');
+                commands.push('profilegpu');
+                commands.push('stat memory');
+                break;
+        }
+        if (params.duration) {
+            commands.push(`stat stopfile ${params.duration}`);
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: `${params.type} profiling started` };
+    }
+    // Stop profiling
+    async stopProfiling() {
+        const commands = [
+            'stat stopfile',
+            'stat none'
+        ];
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'Profiling stopped' };
+    }
+    // Show FPS
+    async showFPS(params) {
+        const startTime = Date.now();
+        console.log('[PerformanceTools] Starting showFPS with params:', params);
+        try {
+            // Use stat fps as requested - shows FPS counter
+            // For more detailed timing info, use 'stat unit' instead
+            const command = params.enabled
+                ? (params.verbose ? 'stat unit' : 'stat fps')
+                : 'stat none';
+            console.log(`[PerformanceTools] Executing command: ${command}`);
+            await this.bridge.executeConsoleCommand(command);
+            console.log(`[PerformanceTools] Command completed in ${Date.now() - startTime}ms`);
+            return {
+                success: true,
+                message: params.enabled ? 'FPS display enabled' : 'FPS display disabled',
+                fpsVisible: params.enabled,
+                command: command
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to ${params.enabled ? 'enable' : 'disable'} FPS display: ${error}`,
+                fpsVisible: false
+            };
+        }
+    }
+    // Show performance stats
+    async showStats(params) {
+        const command = params.enabled
+            ? `stat ${params.category.toLowerCase()}`
+            : 'stat none';
+        return this.bridge.executeConsoleCommand(command);
+    }
+    // Set scalability settings using console commands
+    async setScalability(params) {
+        // Map incoming category to the base name expected by "sg.<Base>Quality"
+        // Note: Several CVars use singular form (Shadow/Texture/Reflection)
+        const categoryBaseMap = {
+            ViewDistance: 'ViewDistance',
+            AntiAliasing: 'AntiAliasing',
+            PostProcessing: 'PostProcess',
+            PostProcess: 'PostProcess',
+            Shadows: 'Shadow',
+            GlobalIllumination: 'GlobalIllumination',
+            Reflections: 'Reflection',
+            Textures: 'Texture',
+            Effects: 'Effects',
+            Foliage: 'Foliage',
+            Shading: 'Shading',
+        };
+        const base = categoryBaseMap[params.category] || params.category;
+        // Use direct console command to set with highest priority (SetByConsole)
+        // This avoids conflicts with the scalability system
+        const setCommand = `sg.${base}Quality ${params.level}`;
+        // Apply the console command directly
+        await this.bridge.executeConsoleCommand(setCommand);
+        // Skip GameUserSettings entirely to avoid any scalability triggers
+        // Console command already applied with correct priority
+        /* eslint-disable no-useless-escape */
+        const py = `
+import unreal, json
+result = {'success': True, 'category': '${base}', 'requested': ${params.level}, 'actual': ${params.level}, 'method': 'ConsoleOnly'}
+
+# Simply verify the console variable was set correctly
+try:
+    # Try to read the console variable directly to verify it was set
+    # This doesn't trigger any scalability system
+    import sys
+    from io import StringIO
+    
+    # Capture console output
+    old_stdout = sys.stdout
+    sys.stdout = StringIO()
+    
+    # Execute console command to query the value
+    try:
+        unreal.SystemLibrary.execute_console_command(None, 'sg.${base}Quality', None)
+    except:
+        pass
+    
+    # Get the output
+    console_output = sys.stdout.getvalue()
+    sys.stdout = old_stdout
+    
+    # Parse the output to get the actual value
+    if 'sg.${base}Quality' in console_output:
+        # Extract the value from output like 'sg.ShadowQuality = "3"'
+        import re
+        match = re.search(r'sg\.${base}Quality\\s*=\\s*"(\\d+)"', console_output)
+        if match:
+            result['actual'] = int(match.group(1))
+            result['verified'] = True
+    
+    result['method'] = 'ConsoleOnly'
+except Exception as e:
+    # Even on error, the console command was applied
+    result['method'] = 'ConsoleOnly'
+    result['note'] = str(e)
+
+print('RESULT:' + json.dumps(result))
+`.trim();
+        /* eslint-enable no-useless-escape */
+        // Always try to apply through Python for consistency
+        try {
+            const pyResp = await this.bridge.executePython(py);
+            let out = '';
+            if (pyResp?.LogOutput && Array.isArray(pyResp.LogOutput)) {
+                out = pyResp.LogOutput.map((l) => l.Output || '').join('');
+            }
+            else if (typeof pyResp === 'string') {
+                out = pyResp;
+            }
+            else {
+                out = JSON.stringify(pyResp);
+            }
+            const m = out.match(/RESULT:({.*})/);
+            if (m) {
+                try {
+                    const parsed = JSON.parse(m[1]);
+                    const verified = parsed.success && (parsed.actual === params.level);
+                    return {
+                        success: true,
+                        message: `${params.category} quality set to level ${params.level}`,
+                        verified,
+                        readback: parsed.actual,
+                        method: parsed.method || 'Unknown'
+                    };
+                }
+                catch {
+                    // Fall through to simple success
+                }
+            }
+        }
+        catch {
+            // Ignore Python errors and fall through
+        }
+        // If Python fails, the console command was still applied
+        return {
+            success: true,
+            message: `${params.category} quality set to level ${params.level}`,
+            method: 'CVarOnly'
+        };
+    }
+    // Set resolution scale
+    async setResolutionScale(params) {
+        // Validate input
+        if (params.scale === undefined || params.scale === null || isNaN(params.scale)) {
+            return { success: false, error: 'Invalid scale parameter' };
+        }
+        // Clamp scale between 10% (0.1) and 200% (2.0) - Unreal Engine limits
+        // Note: r.ScreenPercentage takes values from 10 to 200, not 0.5 to 2.0
+        const clampedScale = Math.max(0.1, Math.min(2.0, params.scale));
+        const percentage = Math.round(clampedScale * 100);
+        // Ensure percentage is within Unreal's valid range
+        const finalPercentage = Math.max(10, Math.min(200, percentage));
+        const command = `r.ScreenPercentage ${finalPercentage}`;
+        try {
+            await this.bridge.executeConsoleCommand(command);
+            return {
+                success: true,
+                message: `Resolution scale set to ${finalPercentage}%`,
+                actualScale: finalPercentage / 100
+            };
+        }
+        catch (e) {
+            return { success: false, error: `Failed to set resolution scale: ${e}` };
+        }
+    }
+    // Enable/disable vsync
+    async setVSync(params) {
+        const command = `r.VSync ${params.enabled ? 1 : 0}`;
+        return this.bridge.executeConsoleCommand(command);
+    }
+    // Set frame rate limit
+    async setFrameRateLimit(params) {
+        const command = `t.MaxFPS ${params.maxFPS}`;
+        return this.bridge.executeConsoleCommand(command);
+    }
+    // Enable GPU timing
+    async enableGPUTiming(params) {
+        const command = `r.GPUStatsEnabled ${params.enabled ? 1 : 0}`;
+        return this.bridge.executeConsoleCommand(command);
+    }
+    // Memory report
+    async generateMemoryReport(params) {
+        const commands = [];
+        if (params.detailed) {
+            commands.push('memreport -full');
+        }
+        else {
+            commands.push('memreport');
+        }
+        if (params.outputPath) {
+            commands.push(`obj savepackage ${params.outputPath}`);
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'Memory report generated' };
+    }
+    // Texture streaming
+    async configureTextureStreaming(params) {
+        const commands = [];
+        commands.push(`r.TextureStreaming ${params.enabled ? 1 : 0}`);
+        if (params.poolSize !== undefined) {
+            commands.push(`r.Streaming.PoolSize ${params.poolSize}`);
+        }
+        if (params.boostPlayerLocation !== undefined) {
+            commands.push(`r.Streaming.UseFixedPoolSize ${params.boostPlayerLocation ? 1 : 0}`);
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'Texture streaming configured' };
+    }
+    // LOD settings
+    async configureLOD(params) {
+        const commands = [];
+        if (params.forceLOD !== undefined) {
+            commands.push(`r.ForceLOD ${params.forceLOD}`);
+        }
+        if (params.lodBias !== undefined) {
+            // Skeletal mesh LOD bias is an integer bias value
+            commands.push(`r.SkeletalMeshLODBias ${params.lodBias}`);
+        }
+        if (params.distanceScale !== undefined) {
+            // Apply distance scale to both static and skeletal meshes
+            commands.push(`r.StaticMeshLODDistanceScale ${params.distanceScale}`);
+            commands.push(`r.SkeletalMeshLODDistanceScale ${params.distanceScale}`);
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'LOD settings configured' };
+    }
+    // Apply a baseline performance profile (explicit CVar enforcement)
+    async applyBaselinePerformanceSettings(params) {
+        const p = {
+            distanceScale: params?.distanceScale ?? 1.0,
+            skeletalBias: params?.skeletalBias ?? 0,
+            vsync: params?.vsync ?? false,
+            maxFPS: params?.maxFPS ?? 60,
+            hzb: params?.hzb ?? true,
+        };
+        const commands = [
+            `r.StaticMeshLODDistanceScale ${p.distanceScale}`,
+            `r.SkeletalMeshLODDistanceScale ${p.distanceScale}`,
+            `r.SkeletalMeshLODBias ${p.skeletalBias}`,
+            `r.HZBOcclusion ${p.hzb ? 1 : 0}`,
+            `r.VSync ${p.vsync ? 1 : 0}`,
+            `t.MaxFPS ${p.maxFPS}`,
+        ];
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'Baseline performance settings applied', params: p };
+    }
+    // Draw call optimization
+    async optimizeDrawCalls(params) {
+        const commands = [];
+        if (params.enableInstancing !== undefined) {
+            commands.push(`r.MeshDrawCommands.DynamicInstancing ${params.enableInstancing ? 1 : 0}`);
+        }
+        // Avoid using r.RHICmdBypass; it's a low-level debug toggle and not suitable for general batching control
+        if (params.mergeActors) {
+            commands.push('MergeActors');
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'Draw call optimization configured' };
+    }
+    // Occlusion culling
+    async configureOcclusionCulling(params) {
+        const commands = [];
+        // Enable/disable HZB occlusion (boolean)
+        commands.push(`r.HZBOcclusion ${params.enabled ? 1 : 0}`);
+        // Optional freeze rendering toggle
+        if (params.freezeRendering !== undefined) {
+            commands.push(`FreezeRendering ${params.freezeRendering ? 1 : 0}`);
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'Occlusion culling configured' };
+    }
+    // Shader compilation
+    async optimizeShaders(params) {
+        const commands = [];
+        if (params.compileOnDemand !== undefined) {
+            commands.push(`r.ShaderDevelopmentMode ${params.compileOnDemand ? 1 : 0}`);
+        }
+        if (params.cacheShaders !== undefined) {
+            commands.push(`r.ShaderPipelineCache.Enabled ${params.cacheShaders ? 1 : 0}`);
+        }
+        if (params.reducePermutations) {
+            commands.push('RecompileShaders changed');
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'Shader optimization configured' };
+    }
+    // Nanite settings
+    async configureNanite(params) {
+        const commands = [];
+        commands.push(`r.Nanite ${params.enabled ? 1 : 0}`);
+        if (params.maxPixelsPerEdge !== undefined) {
+            commands.push(`r.Nanite.MaxPixelsPerEdge ${params.maxPixelsPerEdge}`);
+        }
+        if (params.streamingPoolSize !== undefined) {
+            commands.push(`r.Nanite.StreamingPoolSize ${params.streamingPoolSize}`);
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'Nanite configured' };
+    }
+    // World Partition streaming
+    async configureWorldPartition(params) {
+        const commands = [];
+        commands.push(`wp.Runtime.EnableStreaming ${params.enabled ? 1 : 0}`);
+        if (params.streamingDistance !== undefined) {
+            commands.push(`wp.Runtime.StreamingDistance ${params.streamingDistance}`);
+        }
+        if (params.cellSize !== undefined) {
+            commands.push(`wp.Runtime.CellSize ${params.cellSize}`);
+        }
+        for (const cmd of commands) {
+            await this.bridge.executeConsoleCommand(cmd);
+        }
+        return { success: true, message: 'World Partition configured' };
+    }
+    // Benchmark
+    async runBenchmark(params) {
+        const duration = params.duration || 60;
+        // Start recording and GPU profiling
+        await this.bridge.executeConsoleCommand('stat startfile');
+        await this.bridge.executeConsoleCommand('profilegpu');
+        // Wait for the requested duration
+        await new Promise(resolve => setTimeout(resolve, duration * 1000));
+        // Stop recording and clear stats
+        await this.bridge.executeConsoleCommand('stat stopfile');
+        await this.bridge.executeConsoleCommand('stat none');
+        return { success: true, message: `Benchmark completed for ${duration} seconds` };
+    }
+}
+//# sourceMappingURL=performance.js.map