unreal-engine-mcp-server 0.5.21 → 0.5.30

package/dist/tools/lighting.js

@@ -1,856 +0,0 @@
-import { ensureVector3 } from '../utils/validation.js';
-import { Logger } from '../utils/logger.js';
-const log = new Logger('LightingTools');
-export class LightingTools {
-    bridge;
-    automationBridge;
-    constructor(bridge, automationBridge) {
-        this.bridge = bridge;
-        this.automationBridge = automationBridge;
-    }
-    setAutomationBridge(automationBridge) { this.automationBridge = automationBridge; }
-    normalizeName(value, defaultName) {
-        if (typeof value === 'string') {
-            const trimmed = value.trim();
-            if (trimmed.length > 0) {
-                return trimmed;
-            }
-        }
-        if (typeof defaultName === 'string') {
-            const trimmedDefault = defaultName.trim();
-            if (trimmedDefault.length > 0) {
-                return trimmedDefault;
-            }
-        }
-        return `Light_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
-    }
-    async listLightTypes() {
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge required to list light types');
-        }
-        const response = await this.automationBridge.sendAutomationRequest('list_light_types', {});
-        return response;
-    }
-    async spawnLightViaAutomation(lightClass, params) {
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge not available. Cannot spawn lights without plugin support.');
-        }
-        try {
-            const payload = {
-                lightClass,
-                name: params.name,
-            };
-            if (params.location) {
-                payload.location = Array.isArray(params.location)
-                    ? { x: params.location[0], y: params.location[1], z: params.location[2] }
-                    : params.location;
-            }
-            if (params.rotation) {
-                if (Array.isArray(params.rotation)) {
-                    const rotArray = params.rotation;
-                    payload.rotation = { pitch: rotArray[0], yaw: rotArray[1], roll: rotArray[2] };
-                }
-                else {
-                    payload.rotation = params.rotation;
-                }
-            }
-            if (params.properties) {
-                payload.properties = params.properties;
-            }
-            const response = await this.automationBridge.sendAutomationRequest('spawn_light', payload, {
-                timeoutMs: 60000
-            });
-            if (response.success === false) {
-                throw new Error(response.error || response.message || 'Failed to spawn light');
-            }
-            return response;
-        }
-        catch (error) {
-            throw new Error(`Failed to spawn ${lightClass}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async createDirectionalLight(params) {
-        const name = this.normalizeName(params.name);
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge required for light spawning');
-        }
-        if (params.intensity !== undefined) {
-            if (typeof params.intensity !== 'number' || !isFinite(params.intensity)) {
-                throw new Error(`Invalid intensity value: ${params.intensity}`);
-            }
-            if (params.intensity < 0) {
-                throw new Error('Invalid intensity: must be non-negative');
-            }
-        }
-        if (params.temperature !== undefined) {
-            if (typeof params.temperature !== 'number' || !isFinite(params.temperature)) {
-                throw new Error(`Invalid temperature value: ${params.temperature}`);
-            }
-        }
-        if (params.color !== undefined) {
-            if (!Array.isArray(params.color) || params.color.length !== 3) {
-                throw new Error('Invalid color: must be an array [r,g,b]');
-            }
-            for (const c of params.color) {
-                if (typeof c !== 'number' || !isFinite(c)) {
-                    throw new Error('Invalid color component: must be finite numbers');
-                }
-            }
-        }
-        if (params.rotation !== undefined) {
-            if (Array.isArray(params.rotation)) {
-                if (params.rotation.length !== 3) {
-                    throw new Error('Invalid rotation: must be an array [pitch,yaw,roll]');
-                }
-                for (const r of params.rotation) {
-                    if (typeof r !== 'number' || !isFinite(r)) {
-                        throw new Error('Invalid rotation component: must be finite numbers');
-                    }
-                }
-            }
-        }
-        const rot = params.rotation || [0, 0, 0];
-        const properties = params.properties || {};
-        if (params.intensity !== undefined) {
-            properties.intensity = params.intensity;
-        }
-        if (params.color) {
-            properties.color = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
-        }
-        if (params.castShadows !== undefined) {
-            properties.castShadows = params.castShadows;
-        }
-        if (params.temperature !== undefined) {
-            properties.temperature = params.temperature;
-        }
-        if (params.useAsAtmosphereSunLight !== undefined) {
-            properties.useAsAtmosphereSunLight = params.useAsAtmosphereSunLight;
-        }
-        try {
-            await this.spawnLightViaAutomation('DirectionalLight', {
-                name,
-                location: [0, 0, 500],
-                rotation: rot,
-                properties
-            });
-            return { success: true, message: `Directional light '${name}' spawned` };
-        }
-        catch (e) {
-            return { success: false, error: `Failed to create directional light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
-        }
-    }
-    async createPointLight(params) {
-        const name = this.normalizeName(params.name);
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge required for light spawning');
-        }
-        let location = [0, 0, 0];
-        if (params.location !== undefined) {
-            try {
-                location = ensureVector3(params.location, 'location');
-            }
-            catch (e) {
-                throw new Error(`Invalid location: ${e instanceof Error ? e.message : String(e)}`);
-            }
-        }
-        if (params.intensity !== undefined) {
-            if (typeof params.intensity !== 'number' || !isFinite(params.intensity)) {
-                throw new Error(`Invalid intensity value: ${params.intensity}`);
-            }
-            if (params.intensity < 0) {
-                throw new Error('Invalid intensity: must be non-negative');
-            }
-        }
-        if (params.radius !== undefined) {
-            if (typeof params.radius !== 'number' || !isFinite(params.radius)) {
-                throw new Error(`Invalid radius value: ${params.radius}`);
-            }
-            if (params.radius < 0) {
-                throw new Error('Invalid radius: must be non-negative');
-            }
-        }
-        if (params.falloffExponent !== undefined) {
-            if (typeof params.falloffExponent !== 'number' || !isFinite(params.falloffExponent)) {
-                throw new Error(`Invalid falloffExponent value: ${params.falloffExponent}`);
-            }
-        }
-        if (params.color !== undefined) {
-            if (!Array.isArray(params.color) || params.color.length !== 3) {
-                throw new Error('Invalid color: must be an array [r,g,b]');
-            }
-            for (const c of params.color) {
-                if (typeof c !== 'number' || !isFinite(c)) {
-                    throw new Error('Invalid color component: must be finite numbers');
-                }
-            }
-        }
-        const properties = {};
-        if (params.intensity !== undefined) {
-            properties.intensity = params.intensity;
-        }
-        if (params.radius !== undefined) {
-            properties.attenuationRadius = params.radius;
-        }
-        if (params.color) {
-            properties.color = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
-        }
-        if (params.castShadows !== undefined) {
-            properties.castShadows = params.castShadows;
-        }
-        if (params.falloffExponent !== undefined) {
-            properties.lightFalloffExponent = params.falloffExponent;
-        }
-        try {
-            await this.spawnLightViaAutomation('PointLight', {
-                name,
-                location,
-                rotation: params.rotation,
-                properties
-            });
-            return { success: true, message: `Point light '${name}' spawned at ${location.join(', ')}` };
-        }
-        catch (e) {
-            return { success: false, error: `Failed to create point light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
-        }
-    }
-    async createSpotLight(params) {
-        const name = this.normalizeName(params.name);
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge required for light spawning');
-        }
-        if (!params.location || !Array.isArray(params.location) || params.location.length !== 3) {
-            throw new Error('Invalid location: must be an array [x,y,z]');
-        }
-        for (const l of params.location) {
-            if (typeof l !== 'number' || !isFinite(l)) {
-                throw new Error('Invalid location component: must be finite numbers');
-            }
-        }
-        if (!params.rotation) {
-            throw new Error('Rotation is required');
-        }
-        if (Array.isArray(params.rotation)) {
-            if (params.rotation.length !== 3) {
-                throw new Error('Invalid rotation: must be an array [pitch,yaw,roll]');
-            }
-            for (const r of params.rotation) {
-                if (typeof r !== 'number' || !isFinite(r)) {
-                    throw new Error('Invalid rotation component: must be finite numbers');
-                }
-            }
-        }
-        if (params.intensity !== undefined) {
-            if (typeof params.intensity !== 'number' || !isFinite(params.intensity)) {
-                throw new Error(`Invalid intensity value: ${params.intensity}`);
-            }
-            if (params.intensity < 0) {
-                throw new Error('Invalid intensity: must be non-negative');
-            }
-        }
-        if (params.innerCone !== undefined) {
-            if (typeof params.innerCone !== 'number' || !isFinite(params.innerCone)) {
-                throw new Error(`Invalid innerCone value: ${params.innerCone}`);
-            }
-            if (params.innerCone < 0 || params.innerCone > 180) {
-                throw new Error('Invalid innerCone: must be between 0 and 180 degrees');
-            }
-        }
-        if (params.outerCone !== undefined) {
-            if (typeof params.outerCone !== 'number' || !isFinite(params.outerCone)) {
-                throw new Error(`Invalid outerCone value: ${params.outerCone}`);
-            }
-            if (params.outerCone < 0 || params.outerCone > 180) {
-                throw new Error('Invalid outerCone: must be between 0 and 180 degrees');
-            }
-        }
-        if (params.radius !== undefined) {
-            if (typeof params.radius !== 'number' || !isFinite(params.radius)) {
-                throw new Error(`Invalid radius value: ${params.radius}`);
-            }
-            if (params.radius < 0) {
-                throw new Error('Invalid radius: must be non-negative');
-            }
-        }
-        if (params.color !== undefined) {
-            if (!Array.isArray(params.color) || params.color.length !== 3) {
-                throw new Error('Invalid color: must be an array [r,g,b]');
-            }
-            for (const c of params.color) {
-                if (typeof c !== 'number' || !isFinite(c)) {
-                    throw new Error('Invalid color component: must be finite numbers');
-                }
-            }
-        }
-        const properties = {};
-        if (params.intensity !== undefined) {
-            properties.intensity = params.intensity;
-        }
-        if (params.innerCone !== undefined) {
-            properties.innerConeAngle = params.innerCone;
-        }
-        if (params.outerCone !== undefined) {
-            properties.outerConeAngle = params.outerCone;
-        }
-        if (params.radius !== undefined) {
-            properties.attenuationRadius = params.radius;
-        }
-        if (params.color) {
-            properties.color = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
-        }
-        if (params.castShadows !== undefined) {
-            properties.castShadows = params.castShadows;
-        }
-        try {
-            await this.spawnLightViaAutomation('SpotLight', {
-                name,
-                location: params.location,
-                rotation: params.rotation,
-                properties
-            });
-            return { success: true, message: `Spot light '${name}' spawned at ${params.location.join(', ')}` };
-        }
-        catch (e) {
-            return { success: false, error: `Failed to create spot light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
-        }
-    }
-    async createRectLight(params) {
-        const name = this.normalizeName(params.name);
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge required for light spawning');
-        }
-        if (!params.location || !Array.isArray(params.location) || params.location.length !== 3) {
-            throw new Error('Invalid location: must be an array [x,y,z]');
-        }
-        for (const l of params.location) {
-            if (typeof l !== 'number' || !isFinite(l)) {
-                throw new Error('Invalid location component: must be finite numbers');
-            }
-        }
-        if (!params.rotation) {
-            throw new Error('Rotation is required');
-        }
-        if (Array.isArray(params.rotation)) {
-            if (params.rotation.length !== 3) {
-                throw new Error('Invalid rotation: must be an array [pitch,yaw,roll]');
-            }
-            for (const r of params.rotation) {
-                if (typeof r !== 'number' || !isFinite(r)) {
-                    throw new Error('Invalid rotation component: must be finite numbers');
-                }
-            }
-        }
-        if (params.width !== undefined) {
-            if (typeof params.width !== 'number' || !isFinite(params.width)) {
-                throw new Error(`Invalid width value: ${params.width}`);
-            }
-            if (params.width <= 0) {
-                throw new Error('Invalid width: must be positive');
-            }
-        }
-        if (params.height !== undefined) {
-            if (typeof params.height !== 'number' || !isFinite(params.height)) {
-                throw new Error(`Invalid height value: ${params.height}`);
-            }
-            if (params.height <= 0) {
-                throw new Error('Invalid height: must be positive');
-            }
-        }
-        if (params.intensity !== undefined) {
-            if (typeof params.intensity !== 'number' || !isFinite(params.intensity)) {
-                throw new Error(`Invalid intensity value: ${params.intensity}`);
-            }
-            if (params.intensity < 0) {
-                throw new Error('Invalid intensity: must be non-negative');
-            }
-        }
-        if (params.color !== undefined) {
-            if (!Array.isArray(params.color) || params.color.length !== 3) {
-                throw new Error('Invalid color: must be an array [r,g,b]');
-            }
-            for (const c of params.color) {
-                if (typeof c !== 'number' || !isFinite(c)) {
-                    throw new Error('Invalid color component: must be finite numbers');
-                }
-            }
-        }
-        const properties = {};
-        if (params.intensity !== undefined) {
-            properties.intensity = params.intensity;
-        }
-        if (params.color) {
-            properties.color = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
-        }
-        if (params.width !== undefined) {
-            properties.sourceWidth = params.width;
-        }
-        if (params.height !== undefined) {
-            properties.sourceHeight = params.height;
-        }
-        try {
-            await this.spawnLightViaAutomation('RectLight', {
-                name,
-                location: params.location,
-                rotation: params.rotation,
-                properties
-            });
-            return { success: true, message: `Rect light '${name}' spawned at ${params.location.join(', ')}` };
-        }
-        catch (e) {
-            return { success: false, error: `Failed to create rect light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
-        }
-    }
-    async createDynamicLight(params) {
-        try {
-            const name = typeof params.name === 'string' && params.name.trim().length > 0 ? params.name.trim() : `DynamicLight_${Date.now() % 10000}`;
-            const lightTypeRaw = typeof params.lightType === 'string' && params.lightType.trim().length > 0 ? params.lightType.trim() : 'Point';
-            const location = Array.isArray(params.location) ? { x: params.location[0], y: params.location[1], z: params.location[2] } : (params.location || { x: 0, y: 0, z: 100 });
-            const toArray3 = (loc) => {
-                if (Array.isArray(loc)) {
-                    return [Number(loc[0]) || 0, Number(loc[1]) || 0, Number(loc[2]) || 0];
-                }
-                const locObj = loc;
-                return [Number(locObj?.x) || 0, Number(locObj?.y) || 0, Number(locObj?.z) || 0];
-            };
-            const locArr = toArray3(location);
-            const typeNorm = (lightTypeRaw || 'Point').toLowerCase();
-            const extractColorArray = (color) => {
-                if (Array.isArray(color) && color.length >= 3) {
-                    return [color[0], color[1], color[2]];
-                }
-                if (color && typeof color === 'object') {
-                    const c = color;
-                    if (typeof c.r === 'number' && typeof c.g === 'number' && typeof c.b === 'number') {
-                        return [c.r, c.g, c.b];
-                    }
-                }
-                return undefined;
-            };
-            const colorArr = extractColorArray(params.color);
-            switch (typeNorm) {
-                case 'directional':
-                case 'directionallight':
-                    return await this.createDirectionalLight({ name, intensity: params.intensity, color: colorArr, rotation: params.rotation });
-                case 'spot':
-                case 'spotlight':
-                    return await this.createSpotLight({ name, location: locArr, rotation: (params.rotation ?? [0, 0, 0]), intensity: params.intensity, innerCone: undefined, outerCone: undefined, color: colorArr });
-                case 'rect':
-                case 'rectlight':
-                    return await this.createRectLight({ name, location: locArr, rotation: (params.rotation ?? [0, 0, 0]), width: undefined, height: undefined, intensity: params.intensity, color: colorArr });
-                case 'point':
-                default:
-                    return await this.createPointLight({ name, location: locArr, intensity: params.intensity, radius: undefined, color: colorArr, castShadows: undefined });
-            }
-        }
-        catch (err) {
-            return { success: false, error: `Failed to create dynamic light: ${err}` };
-        }
-    }
-    async createSkyLight(params) {
-        const name = this.normalizeName(params.name);
-        if (params.sourceType === 'SpecifiedCubemap' && (!params.cubemapPath || params.cubemapPath.trim().length === 0)) {
-            const message = 'cubemapPath is required when sourceType is SpecifiedCubemap';
-            return { success: false, error: message, message };
-        }
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge required for sky light creation');
-        }
-        try {
-            const properties = {};
-            if (params.intensity !== undefined)
-                properties.Intensity = params.intensity;
-            if (params.castShadows !== undefined)
-                properties.CastShadows = params.castShadows;
-            if (params.realTimeCapture !== undefined)
-                properties.RealTimeCapture = params.realTimeCapture;
-            if (params.color)
-                properties.LightColor = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
-            const payload = {
-                name,
-                sourceType: params.sourceType || 'CapturedScene',
-                location: params.location,
-                rotation: params.rotation,
-                properties
-            };
-            if (params.cubemapPath) {
-                payload.cubemapPath = params.cubemapPath;
-            }
-            if (params.intensity !== undefined) {
-                payload.intensity = params.intensity;
-            }
-            if (params.recapture) {
-                payload.recapture = params.recapture;
-            }
-            const response = await this.automationBridge.sendAutomationRequest('spawn_sky_light', payload, {
-                timeoutMs: 60000
-            });
-            if (response.success === false) {
-                return {
-                    success: false,
-                    error: response.error || response.message || 'Failed to create sky light'
-                };
-            }
-            return {
-                success: true,
-                message: response.message || 'Sky light created',
-                ...(response.result || {})
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to create sky light: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    async ensureSingleSkyLight(params) {
-        const defaultName = 'MCP_Test_Sky';
-        const name = this.normalizeName(params?.name, defaultName);
-        const recapture = !!params?.recapture;
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge required for sky light management');
-        }
-        try {
-            const response = await this.automationBridge.sendAutomationRequest('ensure_single_sky_light', {
-                name,
-                recapture
-            }, {
-                timeoutMs: 60000
-            });
-            if (response.success === false) {
-                return {
-                    success: false,
-                    error: response.error || response.message || 'Failed to ensure single sky light'
-                };
-            }
-            const resultObj = (response.result ?? {});
-            return {
-                success: true,
-                message: response.message || `Ensured single SkyLight (removed ${resultObj.removed ?? 0})`,
-                ...resultObj
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to ensure single sky light: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    async setupGlobalIllumination(params) {
-        if (!params.method) {
-            return {
-                success: false,
-                error: 'MISSING_REQUIRED_PARAM',
-                message: "'method' parameter is required for setup_global_illumination"
-            };
-        }
-        if (this.automationBridge) {
-            try {
-                const response = await this.automationBridge.sendAutomationRequest('setup_global_illumination', {
-                    method: params.method,
-                    quality: params.quality,
-                    indirectLightingIntensity: params.indirectLightingIntensity,
-                    bounces: params.bounces
-                });
-                if (response.success) {
-                    return { success: true, message: 'Global illumination configured via bridge', ...(response.result || {}) };
-                }
-                return {
-                    success: false,
-                    error: response.error || 'BRIDGE_ERROR',
-                    message: response.message || 'Failed to configure global illumination via bridge'
-                };
-            }
-            catch (e) {
-                log.debug(`Bridge error for setup_global_illumination, falling back to console: ${e}`);
-            }
-        }
-        const commands = [];
-        switch (params.method) {
-            case 'Lightmass':
-                commands.push('r.DynamicGlobalIlluminationMethod 0');
-                break;
-            case 'LumenGI':
-                commands.push('r.DynamicGlobalIlluminationMethod 1');
-                break;
-            case 'ScreenSpace':
-                commands.push('r.DynamicGlobalIlluminationMethod 2');
-                break;
-            case 'None':
-                commands.push('r.DynamicGlobalIlluminationMethod 3');
-                break;
-        }
-        if (params.quality) {
-            const qualityMap = { 'Low': 0, 'Medium': 1, 'High': 2, 'Epic': 3 };
-            const qualityValue = qualityMap[params.quality] ?? 1;
-            commands.push(`r.Lumen.Quality ${qualityValue}`);
-        }
-        if (params.indirectLightingIntensity !== undefined) {
-            commands.push(`r.IndirectLightingIntensity ${params.indirectLightingIntensity}`);
-        }
-        if (params.bounces !== undefined) {
-            commands.push(`r.Lumen.MaxReflectionBounces ${params.bounces}`);
-        }
-        if (commands.length > 0) {
-            await this.bridge.executeBatchConsoleCommands(commands);
-        }
-        return { success: true, message: 'Global illumination configured (console)' };
-    }
-    async configureShadows(params) {
-        if (this.automationBridge) {
-            try {
-                const response = await this.automationBridge.sendAutomationRequest('configure_shadows', {
-                    shadowQuality: params.shadowQuality,
-                    cascadedShadows: params.cascadedShadows,
-                    shadowDistance: params.shadowDistance,
-                    contactShadows: params.contactShadows,
-                    rayTracedShadows: params.rayTracedShadows,
-                    virtualShadowMaps: params.rayTracedShadows
-                });
-                if (response.success)
-                    return { success: true, message: 'Shadow settings configured via bridge', ...(response.result || {}) };
-            }
-            catch (_e) {
-            }
-        }
-        const commands = [];
-        if (params.shadowQuality) {
-            const qualityMap = { 'Low': 0, 'Medium': 1, 'High': 2, 'Epic': 3 };
-            const qualityValue = qualityMap[params.shadowQuality] ?? 1;
-            commands.push(`r.ShadowQuality ${qualityValue}`);
-        }
-        if (params.cascadedShadows !== undefined) {
-            commands.push(`r.Shadow.CSM.MaxCascades ${params.cascadedShadows ? 4 : 1}`);
-        }
-        if (params.shadowDistance !== undefined) {
-            commands.push(`r.Shadow.DistanceScale ${params.shadowDistance}`);
-        }
-        if (params.contactShadows !== undefined) {
-            commands.push(`r.ContactShadows ${params.contactShadows ? 1 : 0}`);
-        }
-        if (params.rayTracedShadows !== undefined) {
-            commands.push(`r.RayTracing.Shadows ${params.rayTracedShadows ? 1 : 0}`);
-        }
-        if (commands.length > 0) {
-            await this.bridge.executeBatchConsoleCommands(commands);
-        }
-        return { success: true, message: 'Shadow settings configured (console)' };
-    }
-    async buildLighting(params) {
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge required for lighting build');
-        }
-        try {
-            const response = await this.automationBridge.sendAutomationRequest('bake_lightmap', {
-                quality: params.quality || 'High',
-                buildOnlySelected: params.buildOnlySelected || false,
-                buildReflectionCaptures: params.buildReflectionCaptures !== false,
-                levelPath: params.levelPath
-            }, {
-                timeoutMs: 300000
-            });
-            if (response.success === false) {
-                return {
-                    success: false,
-                    error: response.error || response.message || 'Failed to build lighting'
-                };
-            }
-            return {
-                success: true,
-                message: response.message || 'Lighting build started',
-                ...(response.result || {})
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to build lighting: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    async createLightingEnabledLevel(params) {
-        let path = params?.path;
-        if (!path && params?.levelName) {
-            path = `/Game/Maps/${params.levelName}`;
-        }
-        const levelName = params?.levelName || 'LightingEnabledLevel';
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge not available. Level creation requires plugin support.');
-        }
-        if (!path) {
-            path = `/Game/Maps/${levelName}`;
-        }
-        try {
-            const response = await this.automationBridge.sendAutomationRequest('create_lighting_enabled_level', {
-                path,
-                levelName,
-                copyActors: params?.copyActors === true,
-                useTemplate: params?.useTemplate === true,
-            }, {
-                timeoutMs: 120000
-            });
-            if (response.success === false) {
-                return {
-                    success: false,
-                    error: response.error || response.message || 'Failed to create level'
-                };
-            }
-            return {
-                success: true,
-                message: response.message || `Created new level "${levelName}" with lighting enabled`,
-                ...(response.result || {})
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to create lighting-enabled level: ${error}`
-            };
-        }
-    }
-    async createLightmassVolume(params) {
-        const name = this.normalizeName(params.name);
-        if (!this.automationBridge) {
-            throw new Error('Automation Bridge not available. Lightmass volume creation requires plugin support.');
-        }
-        const toVector3 = (val, defaultVal) => {
-            if (Array.isArray(val) && val.length >= 3) {
-                return [Number(val[0]) || 0, Number(val[1]) || 0, Number(val[2]) || 0];
-            }
-            if (val && typeof val === 'object') {
-                const obj = val;
-                return [Number(obj.x) || 0, Number(obj.y) || 0, Number(obj.z) || 0];
-            }
-            return defaultVal;
-        };
-        const locArr = toVector3(params.location, [0, 0, 0]);
-        const sizeArr = toVector3(params.size, [1000, 1000, 1000]);
-        try {
-            const response = await this.automationBridge.sendAutomationRequest('create_lightmass_volume', {
-                name,
-                location: { x: locArr[0], y: locArr[1], z: locArr[2] },
-                size: { x: sizeArr[0], y: sizeArr[1], z: sizeArr[2] }
-            }, {
-                timeoutMs: 60000
-            });
-            if (response.success === false) {
-                return {
-                    success: false,
-                    error: response.error || response.message || 'Failed to create lightmass volume'
-                };
-            }
-            return {
-                success: true,
-                message: `LightmassImportanceVolume '${name}' created`,
-                ...(response.result || {})
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to create lightmass volume: ${error}`
-            };
-        }
-    }
-    async setExposure(params) {
-        if (this.automationBridge) {
-            try {
-                const response = await this.automationBridge.sendAutomationRequest('set_exposure', {
-                    method: params.method,
-                    compensationValue: params.compensationValue,
-                    minBrightness: params.minBrightness,
-                    maxBrightness: params.maxBrightness
-                });
-                if (response.success)
-                    return { success: true, message: 'Exposure settings updated via bridge', ...(response.result || {}) };
-            }
-            catch (_e) {
-            }
-        }
-        const commands = [];
-        commands.push(`r.EyeAdaptation.ExposureMethod ${params.method === 'Manual' ? 0 : 1}`);
-        if (params.compensationValue !== undefined) {
-            commands.push(`r.EyeAdaptation.ExposureCompensation ${params.compensationValue}`);
-        }
-        if (params.minBrightness !== undefined) {
-            commands.push(`r.EyeAdaptation.MinBrightness ${params.minBrightness}`);
-        }
-        if (params.maxBrightness !== undefined) {
-            commands.push(`r.EyeAdaptation.MaxBrightness ${params.maxBrightness}`);
-        }
-        if (commands.length > 0) {
-            await this.bridge.executeBatchConsoleCommands(commands);
-        }
-        return { success: true, message: 'Exposure settings updated (console)' };
-    }
-    async setAmbientOcclusion(params) {
-        if (this.automationBridge) {
-            try {
-                const response = await this.automationBridge.sendAutomationRequest('set_ambient_occlusion', {
-                    enabled: params.enabled,
-                    intensity: params.intensity,
-                    radius: params.radius,
-                    quality: params.quality
-                });
-                if (response.success)
-                    return { success: true, message: 'Ambient occlusion configured via bridge', ...(response.result || {}) };
-            }
-            catch (_e) {
-            }
-        }
-        const commands = [];
-        commands.push(`r.AmbientOcclusion.Enabled ${params.enabled ? 1 : 0}`);
-        if (params.intensity !== undefined) {
-            commands.push(`r.AmbientOcclusion.Intensity ${params.intensity}`);
-        }
-        if (params.radius !== undefined) {
-            commands.push(`r.AmbientOcclusion.Radius ${params.radius}`);
-        }
-        if (params.quality) {
-            const qualityMap = { 'Low': 0, 'Medium': 1, 'High': 2 };
-            const qualityValue = qualityMap[params.quality] ?? 1;
-            commands.push(`r.AmbientOcclusion.Quality ${qualityValue}`);
-        }
-        if (commands.length > 0) {
-            await this.bridge.executeBatchConsoleCommands(commands);
-        }
-        return { success: true, message: 'Ambient occlusion configured (console)' };
-    }
-    async setupVolumetricFog(params) {
-        await this.bridge.executeConsoleCommand(`r.VolumetricFog ${params.enabled ? 1 : 0}`);
-        if (!this.automationBridge) {
-            return {
-                success: true,
-                message: 'Volumetric fog console setting applied (plugin required for fog actor adjustment)'
-            };
-        }
-        try {
-            const response = await this.automationBridge.sendAutomationRequest('setup_volumetric_fog', {
-                enabled: params.enabled,
-                density: params.density,
-                scatteringIntensity: params.scatteringIntensity,
-                fogHeight: params.fogHeight
-            }, {
-                timeoutMs: 60000
-            });
-            if (response.success === false) {
-                return {
-                    success: false,
-                    error: response.error || response.message || 'Failed to configure volumetric fog'
-                };
-            }
-            return {
-                success: true,
-                message: 'Volumetric fog configured',
-                ...(response.result || {})
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to setup volumetric fog: ${error}`
-            };
-        }
-    }
-}
-//# sourceMappingURL=lighting.js.map