@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/esm/systems/LightingSystem.js

@@ -1,967 +1,892 @@
-/**
- * @file LightingSystem.ts
- * @description Advanced Lighting System with Lightmap Baking and GI
- * PRO-1.4: Professional Editor Features
- *
- * Features:
- * - Light types (Directional, Point, Spot, Area)
- * - Light probes for indirect lighting
- * - Reflection probes
- * - Lightmap baking (progressive, GPU-accelerated)
- * - Global Illumination preview
- * - Shadow configuration
- * - Light cookies
- * - IES profiles
- */
 function createDirectionalLight(name) {
-    return {
-        id: `light_${Date.now()}`,
-        name,
-        type: 'directional',
-        enabled: true,
-        position: { x: 0, y: 10, z: 0 },
-        rotation: { x: 50, y: -30, z: 0 },
-        scale: { x: 1, y: 1, z: 1 },
-        color: { r: 1, g: 0.96, b: 0.9, a: 1 },
-        intensity: 1,
-        indirectMultiplier: 1,
-        range: Infinity,
-        mode: 'mixed',
-        renderMode: 'auto',
-        spotAngle: 30,
-        outerSpotAngle: 45,
-        areaSize: { width: 1, height: 1 },
-        areaLightType: 'rectangle',
-        shadows: 'soft',
-        shadowStrength: 1,
-        shadowResolution: 2048,
-        shadowBias: 0.05,
-        shadowNormalBias: 0.4,
-        shadowNearPlane: 0.2,
-        shadowSoftness: 1,
-        shadowSoftnessFalloff: 1,
-        cullingMask: 0xffffffff,
-        renderingLayerMask: 0xffffffff,
-        cookieSize: 10,
-        lightmapBakeType: 'mixed',
-        affectsLightmaps: true,
-        affectsSpecular: true,
-    };
+  return {
+    id: `light_${Date.now()}`,
+    name,
+    type: "directional",
+    enabled: true,
+    position: { x: 0, y: 10, z: 0 },
+    rotation: { x: 50, y: -30, z: 0 },
+    scale: { x: 1, y: 1, z: 1 },
+    color: { r: 1, g: 0.96, b: 0.9, a: 1 },
+    intensity: 1,
+    indirectMultiplier: 1,
+    range: Infinity,
+    mode: "mixed",
+    renderMode: "auto",
+    spotAngle: 30,
+    outerSpotAngle: 45,
+    areaSize: { width: 1, height: 1 },
+    areaLightType: "rectangle",
+    shadows: "soft",
+    shadowStrength: 1,
+    shadowResolution: 2048,
+    shadowBias: 0.05,
+    shadowNormalBias: 0.4,
+    shadowNearPlane: 0.2,
+    shadowSoftness: 1,
+    shadowSoftnessFalloff: 1,
+    cullingMask: 4294967295,
+    renderingLayerMask: 4294967295,
+    cookieSize: 10,
+    lightmapBakeType: "mixed",
+    affectsLightmaps: true,
+    affectsSpecular: true
+  };
 }
 function createPointLight(name, position) {
-    return {
-        id: `light_${Date.now()}`,
-        name,
-        type: 'point',
-        enabled: true,
-        position,
-        rotation: { x: 0, y: 0, z: 0 },
-        scale: { x: 1, y: 1, z: 1 },
-        color: { r: 1, g: 1, b: 1, a: 1 },
-        intensity: 1,
-        indirectMultiplier: 1,
-        range: 10,
-        mode: 'realtime',
-        renderMode: 'auto',
-        spotAngle: 30,
-        outerSpotAngle: 45,
-        areaSize: { width: 1, height: 1 },
-        areaLightType: 'rectangle',
-        shadows: 'soft',
-        shadowStrength: 1,
-        shadowResolution: 1024,
-        shadowBias: 0.05,
-        shadowNormalBias: 0.4,
-        shadowNearPlane: 0.2,
-        shadowSoftness: 1,
-        shadowSoftnessFalloff: 1,
-        cullingMask: 0xffffffff,
-        renderingLayerMask: 0xffffffff,
-        cookieSize: 10,
-        lightmapBakeType: 'realtime',
-        affectsLightmaps: false,
-        affectsSpecular: true,
-    };
+  return {
+    id: `light_${Date.now()}`,
+    name,
+    type: "point",
+    enabled: true,
+    position,
+    rotation: { x: 0, y: 0, z: 0 },
+    scale: { x: 1, y: 1, z: 1 },
+    color: { r: 1, g: 1, b: 1, a: 1 },
+    intensity: 1,
+    indirectMultiplier: 1,
+    range: 10,
+    mode: "realtime",
+    renderMode: "auto",
+    spotAngle: 30,
+    outerSpotAngle: 45,
+    areaSize: { width: 1, height: 1 },
+    areaLightType: "rectangle",
+    shadows: "soft",
+    shadowStrength: 1,
+    shadowResolution: 1024,
+    shadowBias: 0.05,
+    shadowNormalBias: 0.4,
+    shadowNearPlane: 0.2,
+    shadowSoftness: 1,
+    shadowSoftnessFalloff: 1,
+    cullingMask: 4294967295,
+    renderingLayerMask: 4294967295,
+    cookieSize: 10,
+    lightmapBakeType: "realtime",
+    affectsLightmaps: false,
+    affectsSpecular: true
+  };
 }
 function createSpotLight(name, position) {
-    return {
-        id: `light_${Date.now()}`,
-        name,
-        type: 'spot',
-        enabled: true,
-        position,
-        rotation: { x: 90, y: 0, z: 0 }, // Pointing down
-        scale: { x: 1, y: 1, z: 1 },
-        color: { r: 1, g: 1, b: 1, a: 1 },
-        intensity: 1,
-        indirectMultiplier: 1,
-        range: 10,
-        mode: 'realtime',
-        renderMode: 'auto',
-        spotAngle: 30,
-        outerSpotAngle: 45,
-        areaSize: { width: 1, height: 1 },
-        areaLightType: 'rectangle',
-        shadows: 'soft',
-        shadowStrength: 1,
-        shadowResolution: 1024,
-        shadowBias: 0.05,
-        shadowNormalBias: 0.4,
-        shadowNearPlane: 0.2,
-        shadowSoftness: 1,
-        shadowSoftnessFalloff: 1,
-        cullingMask: 0xffffffff,
-        renderingLayerMask: 0xffffffff,
-        cookieSize: 10,
-        lightmapBakeType: 'realtime',
-        affectsLightmaps: false,
-        affectsSpecular: true,
-    };
+  return {
+    id: `light_${Date.now()}`,
+    name,
+    type: "spot",
+    enabled: true,
+    position,
+    rotation: { x: 90, y: 0, z: 0 },
+    // Pointing down
+    scale: { x: 1, y: 1, z: 1 },
+    color: { r: 1, g: 1, b: 1, a: 1 },
+    intensity: 1,
+    indirectMultiplier: 1,
+    range: 10,
+    mode: "realtime",
+    renderMode: "auto",
+    spotAngle: 30,
+    outerSpotAngle: 45,
+    areaSize: { width: 1, height: 1 },
+    areaLightType: "rectangle",
+    shadows: "soft",
+    shadowStrength: 1,
+    shadowResolution: 1024,
+    shadowBias: 0.05,
+    shadowNormalBias: 0.4,
+    shadowNearPlane: 0.2,
+    shadowSoftness: 1,
+    shadowSoftnessFalloff: 1,
+    cullingMask: 4294967295,
+    renderingLayerMask: 4294967295,
+    cookieSize: 10,
+    lightmapBakeType: "realtime",
+    affectsLightmaps: false,
+    affectsSpecular: true
+  };
 }
 function createAreaLight(name, position) {
-    return {
-        id: `light_${Date.now()}`,
-        name,
-        type: 'area',
-        enabled: true,
-        position,
-        rotation: { x: 90, y: 0, z: 0 }, // Pointing down
-        scale: { x: 1, y: 1, z: 1 },
-        color: { r: 1, g: 1, b: 1, a: 1 },
-        intensity: 1,
-        indirectMultiplier: 1,
-        range: 10,
-        mode: 'baked',
-        renderMode: 'auto',
-        spotAngle: 30,
-        outerSpotAngle: 45,
-        areaSize: { width: 2, height: 2 },
-        areaLightType: 'rectangle',
-        shadows: 'soft',
-        shadowStrength: 1,
-        shadowResolution: 1024,
-        shadowBias: 0.05,
-        shadowNormalBias: 0.4,
-        shadowNearPlane: 0.2,
-        shadowSoftness: 1,
-        shadowSoftnessFalloff: 1,
-        cullingMask: 0xffffffff,
-        renderingLayerMask: 0xffffffff,
-        cookieSize: 10,
-        lightmapBakeType: 'baked',
-        affectsLightmaps: true,
-        affectsSpecular: false,
-    };
+  return {
+    id: `light_${Date.now()}`,
+    name,
+    type: "area",
+    enabled: true,
+    position,
+    rotation: { x: 90, y: 0, z: 0 },
+    // Pointing down
+    scale: { x: 1, y: 1, z: 1 },
+    color: { r: 1, g: 1, b: 1, a: 1 },
+    intensity: 1,
+    indirectMultiplier: 1,
+    range: 10,
+    mode: "baked",
+    renderMode: "auto",
+    spotAngle: 30,
+    outerSpotAngle: 45,
+    areaSize: { width: 2, height: 2 },
+    areaLightType: "rectangle",
+    shadows: "soft",
+    shadowStrength: 1,
+    shadowResolution: 1024,
+    shadowBias: 0.05,
+    shadowNormalBias: 0.4,
+    shadowNearPlane: 0.2,
+    shadowSoftness: 1,
+    shadowSoftnessFalloff: 1,
+    cullingMask: 4294967295,
+    renderingLayerMask: 4294967295,
+    cookieSize: 10,
+    lightmapBakeType: "baked",
+    affectsLightmaps: true,
+    affectsSpecular: false
+  };
 }
 function createLightProbeGroup(name) {
-    return {
-        id: `lpg_${Date.now()}`,
-        name,
-        probes: [],
-        interpolationMode: 'linear',
-        density: 2, // One probe per 2 units
-        bounds: {
-            min: { x: -10, y: 0, z: -10 },
-            max: { x: 10, y: 5, z: 10 },
-        },
-    };
+  return {
+    id: `lpg_${Date.now()}`,
+    name,
+    probes: [],
+    interpolationMode: "linear",
+    density: 2,
+    // One probe per 2 units
+    bounds: {
+      min: { x: -10, y: 0, z: -10 },
+      max: { x: 10, y: 5, z: 10 }
+    }
+  };
 }
 function createLightProbe(position) {
-    return {
-        id: `lp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-        position,
-        sh: { coefficients: new Float32Array(27) },
-        isValid: false,
-    };
+  return {
+    id: `lp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    position,
+    sh: { coefficients: new Float32Array(27) },
+    isValid: false
+  };
 }
 function createReflectionProbe(name, position) {
-    return {
-        id: `rp_${Date.now()}`,
-        name,
-        position,
-        rotation: { x: 0, y: 0, z: 0 },
-        type: 'baked',
-        refreshMode: 'onAwake',
-        timeSlicing: 'allFacesAtOnce',
-        size: { x: 10, y: 10, z: 10 },
-        center: { x: 0, y: 0, z: 0 },
-        blendDistance: 1,
-        boxProjection: false,
-        resolution: 256,
-        hdr: true,
-        shadowDistance: 100,
-        clearFlags: 'skybox',
-        backgroundColor: { r: 0.2, g: 0.2, b: 0.2, a: 1 },
-        cullingMask: 0xffffffff,
-        nearClip: 0.3,
-        farClip: 1000,
-        intensity: 1,
-        importance: 1,
-        isValid: false,
-    };
+  return {
+    id: `rp_${Date.now()}`,
+    name,
+    position,
+    rotation: { x: 0, y: 0, z: 0 },
+    type: "baked",
+    refreshMode: "onAwake",
+    timeSlicing: "allFacesAtOnce",
+    size: { x: 10, y: 10, z: 10 },
+    center: { x: 0, y: 0, z: 0 },
+    blendDistance: 1,
+    boxProjection: false,
+    resolution: 256,
+    hdr: true,
+    shadowDistance: 100,
+    clearFlags: "skybox",
+    backgroundColor: { r: 0.2, g: 0.2, b: 0.2, a: 1 },
+    cullingMask: 4294967295,
+    nearClip: 0.3,
+    farClip: 1e3,
+    intensity: 1,
+    importance: 1,
+    isValid: false
+  };
 }
 const DEFAULT_LIGHTMAP_SETTINGS = {
-    mode: 'directional',
-    mixedMode: 'bakedIndirect',
-    lightmapper: 'progressiveGPU',
-    prioritizeView: false,
-    multipleImportanceSampling: true,
-    lightmapResolution: 40,
-    lightmapPadding: 2,
-    maxLightmapSize: 2048,
-    compressLightmaps: true,
-    directSamples: 32,
-    indirectSamples: 512,
-    bounces: 3,
-    denoiser: 'openImageDenoise',
-    filteringMode: 'auto',
-    directFilter: 0.5,
-    indirectFilter: 5,
-    ambientOcclusionFilter: 2.5,
-    ambientOcclusion: true,
-    aoMaxDistance: 1,
-    aoIndirectContribution: 1,
-    aoDirectContribution: 0,
-    environmentLighting: 'skybox',
-    skyColor: { r: 0.53, g: 0.81, b: 0.92, a: 1 },
-    equatorColor: { r: 0.96, g: 0.91, b: 0.77, a: 1 },
-    groundColor: { r: 0.37, g: 0.33, b: 0.27, a: 1 },
-    environmentIntensity: 1,
-    albedoBoost: 1,
-    indirectIntensity: 1,
-    extractAO: false,
+  mode: "directional",
+  mixedMode: "bakedIndirect",
+  lightmapper: "progressiveGPU",
+  prioritizeView: false,
+  multipleImportanceSampling: true,
+  lightmapResolution: 40,
+  lightmapPadding: 2,
+  maxLightmapSize: 2048,
+  compressLightmaps: true,
+  directSamples: 32,
+  indirectSamples: 512,
+  bounces: 3,
+  denoiser: "openImageDenoise",
+  filteringMode: "auto",
+  directFilter: 0.5,
+  indirectFilter: 5,
+  ambientOcclusionFilter: 2.5,
+  ambientOcclusion: true,
+  aoMaxDistance: 1,
+  aoIndirectContribution: 1,
+  aoDirectContribution: 0,
+  environmentLighting: "skybox",
+  skyColor: { r: 0.53, g: 0.81, b: 0.92, a: 1 },
+  equatorColor: { r: 0.96, g: 0.91, b: 0.77, a: 1 },
+  groundColor: { r: 0.37, g: 0.33, b: 0.27, a: 1 },
+  environmentIntensity: 1,
+  albedoBoost: 1,
+  indirectIntensity: 1,
+  extractAO: false
 };
-// ============================================================
-// Lighting System Class
-// ============================================================
 class LightingSystem {
-    constructor() {
-        this.lights = [];
-        this.lightProbeGroups = [];
-        this.reflectionProbes = [];
-        this.lightmaps = [];
-        this.lightmapUVs = [];
-        this.settings = { ...DEFAULT_LIGHTMAP_SETTINGS };
-        this.bakeProgress = {
-            phase: 'idle',
-            progress: 0,
-            totalProgress: 0,
-            currentBounce: 0,
-            totalBounces: 0,
-            samplesRendered: 0,
-            totalSamples: 0,
-            lightmapsCompleted: 0,
-            totalLightmaps: 0,
-            probesCompleted: 0,
-            totalProbes: 0,
-            reflectionProbesCompleted: 0,
-            totalReflectionProbes: 0,
-            elapsedTime: 0,
-            estimatedRemainingTime: 0,
-            message: '',
-        };
-        this.bakeAbort = false;
-        this.bakeCallbacks = [];
-    }
-    // ─── Light Management ──────────────────────────────────
-    addLight(light) {
-        this.lights.push(light);
-    }
-    removeLight(lightId) {
-        this.lights = this.lights.filter((l) => l.id !== lightId);
-    }
-    getLight(lightId) {
-        return this.lights.find((l) => l.id === lightId);
-    }
-    getAllLights() {
-        return [...this.lights];
-    }
-    getRealtimeLights() {
-        return this.lights.filter((l) => l.mode === 'realtime' || l.mode === 'mixed');
-    }
-    getBakedLights() {
-        return this.lights.filter((l) => l.mode === 'baked' || l.mode === 'mixed');
-    }
-    // ─── Light Probe Management ────────────────────────────
-    addLightProbeGroup(group) {
-        this.lightProbeGroups.push(group);
-    }
-    removeLightProbeGroup(groupId) {
-        this.lightProbeGroups = this.lightProbeGroups.filter((g) => g.id !== groupId);
-    }
-    getLightProbeGroup(groupId) {
-        return this.lightProbeGroups.find((g) => g.id === groupId);
-    }
-    getAllLightProbeGroups() {
-        return [...this.lightProbeGroups];
-    }
-    /** Auto-generate probes within bounds */
-    autoGenerateProbes(groupId) {
-        const group = this.getLightProbeGroup(groupId);
-        if (!group) {
-            return;
-        }
-        group.probes = [];
-        const { min, max } = group.bounds;
-        const density = group.density;
-        const stepsX = Math.ceil((max.x - min.x) / density);
-        const stepsY = Math.ceil((max.y - min.y) / density);
-        const stepsZ = Math.ceil((max.z - min.z) / density);
-        for (let y = 0; y <= stepsY; y++) {
-            for (let z = 0; z <= stepsZ; z++) {
-                for (let x = 0; x <= stepsX; x++) {
-                    const pos = {
-                        x: min.x + (x / stepsX) * (max.x - min.x),
-                        y: min.y + (y / stepsY) * (max.y - min.y),
-                        z: min.z + (z / stepsZ) * (max.z - min.z),
-                    };
-                    group.probes.push(createLightProbe(pos));
-                }
-            }
-        }
-    }
-    /** Get interpolated spherical harmonics at a position */
-    sampleLightProbes(position) {
-        // Find contributing probes and interpolate
-        const allProbes = [];
-        for (const group of this.lightProbeGroups) {
-            for (const probe of group.probes) {
-                if (!probe.isValid) {
-                    continue;
-                }
-                const dx = position.x - probe.position.x;
-                const dy = position.y - probe.position.y;
-                const dz = position.z - probe.position.z;
-                const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
-                allProbes.push({ probe, distance: dist });
-            }
-        }
-        if (allProbes.length === 0) {
-            return null;
-        }
-        // Sort by distance
-        allProbes.sort((a, b) => a.distance - b.distance);
-        // Use tetrahedral interpolation (simplified to 4 nearest)
-        const nearest = allProbes.slice(0, 4);
-        const result = new Float32Array(27);
-        // Calculate weights (inverse distance)
-        let totalWeight = 0;
-        const weights = [];
-        for (const { distance } of nearest) {
-            const weight = 1 / (distance + 0.001);
-            weights.push(weight);
-            totalWeight += weight;
-        }
-        // Interpolate SH coefficients
-        for (let i = 0; i < nearest.length; i++) {
-            const weight = weights[i] / totalWeight;
-            const sh = nearest[i].probe.sh.coefficients;
-            for (let j = 0; j < 27; j++) {
-                result[j] += sh[j] * weight;
-            }
-        }
-        return { coefficients: result };
-    }
-    // ─── Reflection Probe Management ───────────────────────
-    addReflectionProbe(probe) {
-        this.reflectionProbes.push(probe);
-    }
-    removeReflectionProbe(probeId) {
-        this.reflectionProbes = this.reflectionProbes.filter((p) => p.id !== probeId);
-    }
-    getReflectionProbe(probeId) {
-        return this.reflectionProbes.find((p) => p.id === probeId);
-    }
-    getAllReflectionProbes() {
-        return [...this.reflectionProbes];
-    }
-    /** Get blended reflection at a position */
-    sampleReflection(position) {
-        // Find overlapping probes sorted by importance
-        const overlapping = [];
-        for (const probe of this.reflectionProbes) {
-            if (!probe.isValid) {
-                continue;
-            }
-            // Check if position is within probe bounds
-            const localPos = {
-                x: position.x - probe.position.x - probe.center.x,
-                y: position.y - probe.position.y - probe.center.y,
-                z: position.z - probe.position.z - probe.center.z,
-            };
-            const halfSize = {
-                x: probe.size.x / 2 + probe.blendDistance,
-                y: probe.size.y / 2 + probe.blendDistance,
-                z: probe.size.z / 2 + probe.blendDistance,
-            };
-            if (Math.abs(localPos.x) <= halfSize.x &&
-                Math.abs(localPos.y) <= halfSize.y &&
-                Math.abs(localPos.z) <= halfSize.z) {
-                overlapping.push(probe);
-            }
+  constructor() {
+    this.lights = [];
+    this.lightProbeGroups = [];
+    this.reflectionProbes = [];
+    this.lightmaps = [];
+    this.lightmapUVs = [];
+    this.settings = { ...DEFAULT_LIGHTMAP_SETTINGS };
+    this.bakeProgress = {
+      phase: "idle",
+      progress: 0,
+      totalProgress: 0,
+      currentBounce: 0,
+      totalBounces: 0,
+      samplesRendered: 0,
+      totalSamples: 0,
+      lightmapsCompleted: 0,
+      totalLightmaps: 0,
+      probesCompleted: 0,
+      totalProbes: 0,
+      reflectionProbesCompleted: 0,
+      totalReflectionProbes: 0,
+      elapsedTime: 0,
+      estimatedRemainingTime: 0,
+      message: ""
+    };
+    this.bakeAbort = false;
+    this.bakeCallbacks = [];
+  }
+  // ─── Light Management ──────────────────────────────────
+  addLight(light) {
+    this.lights.push(light);
+  }
+  removeLight(lightId) {
+    this.lights = this.lights.filter((l) => l.id !== lightId);
+  }
+  getLight(lightId) {
+    return this.lights.find((l) => l.id === lightId);
+  }
+  getAllLights() {
+    return [...this.lights];
+  }
+  getRealtimeLights() {
+    return this.lights.filter((l) => l.mode === "realtime" || l.mode === "mixed");
+  }
+  getBakedLights() {
+    return this.lights.filter((l) => l.mode === "baked" || l.mode === "mixed");
+  }
+  // ─── Light Probe Management ────────────────────────────
+  addLightProbeGroup(group) {
+    this.lightProbeGroups.push(group);
+  }
+  removeLightProbeGroup(groupId) {
+    this.lightProbeGroups = this.lightProbeGroups.filter((g) => g.id !== groupId);
+  }
+  getLightProbeGroup(groupId) {
+    return this.lightProbeGroups.find((g) => g.id === groupId);
+  }
+  getAllLightProbeGroups() {
+    return [...this.lightProbeGroups];
+  }
+  /** Auto-generate probes within bounds */
+  autoGenerateProbes(groupId) {
+    const group = this.getLightProbeGroup(groupId);
+    if (!group) {
+      return;
+    }
+    group.probes = [];
+    const { min, max } = group.bounds;
+    const density = group.density;
+    const stepsX = Math.ceil((max.x - min.x) / density);
+    const stepsY = Math.ceil((max.y - min.y) / density);
+    const stepsZ = Math.ceil((max.z - min.z) / density);
+    for (let y = 0; y <= stepsY; y++) {
+      for (let z = 0; z <= stepsZ; z++) {
+        for (let x = 0; x <= stepsX; x++) {
+          const pos = {
+            x: min.x + x / stepsX * (max.x - min.x),
+            y: min.y + y / stepsY * (max.y - min.y),
+            z: min.z + z / stepsZ * (max.z - min.z)
+          };
+          group.probes.push(createLightProbe(pos));
         }
-        if (overlapping.length === 0) {
-            return null;
+      }
+    }
+  }
+  /** Get interpolated spherical harmonics at a position */
+  sampleLightProbes(position) {
+    const allProbes = [];
+    for (const group of this.lightProbeGroups) {
+      for (const probe of group.probes) {
+        if (!probe.isValid) {
+          continue;
         }
-        // Sort by importance
-        overlapping.sort((a, b) => b.importance - a.importance);
-        // Return highest importance probe (in real implementation, blend between them)
-        return overlapping[0].bakedCubemapId ?? null;
-    }
-    // ─── Settings ──────────────────────────────────────────
-    getSettings() {
-        return { ...this.settings };
-    }
-    setSettings(settings) {
-        this.settings = { ...this.settings, ...settings };
-    }
-    // ─── Lightmap Baking ───────────────────────────────────
-    onBakeProgress(callback) {
-        this.bakeCallbacks.push(callback);
-        return () => {
-            this.bakeCallbacks = this.bakeCallbacks.filter((c) => c !== callback);
-        };
-    }
-    emitProgress() {
-        for (const callback of this.bakeCallbacks) {
-            callback({ ...this.bakeProgress });
+        const dx = position.x - probe.position.x;
+        const dy = position.y - probe.position.y;
+        const dz = position.z - probe.position.z;
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        allProbes.push({ probe, distance: dist });
+      }
+    }
+    if (allProbes.length === 0) {
+      return null;
+    }
+    allProbes.sort((a, b) => a.distance - b.distance);
+    const nearest = allProbes.slice(0, 4);
+    const result = new Float32Array(27);
+    let totalWeight = 0;
+    const weights = [];
+    for (const { distance } of nearest) {
+      const weight = 1 / (distance + 1e-3);
+      weights.push(weight);
+      totalWeight += weight;
+    }
+    for (let i = 0; i < nearest.length; i++) {
+      const weight = weights[i] / totalWeight;
+      const sh = nearest[i].probe.sh.coefficients;
+      for (let j = 0; j < 27; j++) {
+        result[j] += sh[j] * weight;
+      }
+    }
+    return { coefficients: result };
+  }
+  // ─── Reflection Probe Management ───────────────────────
+  addReflectionProbe(probe) {
+    this.reflectionProbes.push(probe);
+  }
+  removeReflectionProbe(probeId) {
+    this.reflectionProbes = this.reflectionProbes.filter((p) => p.id !== probeId);
+  }
+  getReflectionProbe(probeId) {
+    return this.reflectionProbes.find((p) => p.id === probeId);
+  }
+  getAllReflectionProbes() {
+    return [...this.reflectionProbes];
+  }
+  /** Get blended reflection at a position */
+  sampleReflection(position) {
+    const overlapping = [];
+    for (const probe of this.reflectionProbes) {
+      if (!probe.isValid) {
+        continue;
+      }
+      const localPos = {
+        x: position.x - probe.position.x - probe.center.x,
+        y: position.y - probe.position.y - probe.center.y,
+        z: position.z - probe.position.z - probe.center.z
+      };
+      const halfSize = {
+        x: probe.size.x / 2 + probe.blendDistance,
+        y: probe.size.y / 2 + probe.blendDistance,
+        z: probe.size.z / 2 + probe.blendDistance
+      };
+      if (Math.abs(localPos.x) <= halfSize.x && Math.abs(localPos.y) <= halfSize.y && Math.abs(localPos.z) <= halfSize.z) {
+        overlapping.push(probe);
+      }
+    }
+    if (overlapping.length === 0) {
+      return null;
+    }
+    overlapping.sort((a, b) => b.importance - a.importance);
+    return overlapping[0].bakedCubemapId ?? null;
+  }
+  // ─── Settings ──────────────────────────────────────────
+  getSettings() {
+    return { ...this.settings };
+  }
+  setSettings(settings) {
+    this.settings = { ...this.settings, ...settings };
+  }
+  // ─── Lightmap Baking ───────────────────────────────────
+  onBakeProgress(callback) {
+    this.bakeCallbacks.push(callback);
+    return () => {
+      this.bakeCallbacks = this.bakeCallbacks.filter((c) => c !== callback);
+    };
+  }
+  emitProgress() {
+    for (const callback of this.bakeCallbacks) {
+      callback({ ...this.bakeProgress });
+    }
+  }
+  async startBake(entityBounds) {
+    this.bakeAbort = false;
+    const startTime = Date.now();
+    this.bakeProgress = {
+      phase: "preparing",
+      progress: 0,
+      totalProgress: 0,
+      currentBounce: 0,
+      totalBounces: this.settings.bounces,
+      samplesRendered: 0,
+      totalSamples: this.settings.directSamples + this.settings.indirectSamples,
+      lightmapsCompleted: 0,
+      totalLightmaps: 0,
+      probesCompleted: 0,
+      totalProbes: this.countTotalProbes(),
+      reflectionProbesCompleted: 0,
+      totalReflectionProbes: this.reflectionProbes.length,
+      elapsedTime: 0,
+      estimatedRemainingTime: 0,
+      message: "Preparing scene..."
+    };
+    this.emitProgress();
+    try {
+      await this.prepareForBake(entityBounds);
+      if (this.bakeAbort) {
+        throw new Error("Bake cancelled");
+      }
+      this.bakeProgress.phase = "directLighting";
+      this.bakeProgress.message = "Computing direct lighting...";
+      this.emitProgress();
+      await this.bakeDirectLighting();
+      if (this.bakeAbort) {
+        throw new Error("Bake cancelled");
+      }
+      this.bakeProgress.phase = "indirectLighting";
+      this.bakeProgress.message = "Computing indirect lighting...";
+      this.emitProgress();
+      for (let bounce = 0; bounce < this.settings.bounces; bounce++) {
+        this.bakeProgress.currentBounce = bounce + 1;
+        this.bakeProgress.message = `Computing bounce ${bounce + 1}/${this.settings.bounces}...`;
+        this.emitProgress();
+        await this.bakeIndirectBounce(bounce);
+        if (this.bakeAbort) {
+          throw new Error("Bake cancelled");
         }
-    }
-    async startBake(entityBounds) {
-        this.bakeAbort = false;
-        const startTime = Date.now();
-        // Reset progress
-        this.bakeProgress = {
-            phase: 'preparing',
-            progress: 0,
-            totalProgress: 0,
-            currentBounce: 0,
-            totalBounces: this.settings.bounces,
-            samplesRendered: 0,
-            totalSamples: this.settings.directSamples + this.settings.indirectSamples,
-            lightmapsCompleted: 0,
-            totalLightmaps: 0,
-            probesCompleted: 0,
-            totalProbes: this.countTotalProbes(),
-            reflectionProbesCompleted: 0,
-            totalReflectionProbes: this.reflectionProbes.length,
-            elapsedTime: 0,
-            estimatedRemainingTime: 0,
-            message: 'Preparing scene...',
-        };
+      }
+      if (this.settings.denoiser !== "none") {
+        this.bakeProgress.phase = "denoising";
+        this.bakeProgress.message = "Denoising lightmaps...";
         this.emitProgress();
-        try {
-            // Phase 1: Prepare
-            await this.prepareForBake(entityBounds);
-            if (this.bakeAbort) {
-                throw new Error('Bake cancelled');
-            }
-            // Phase 2: Direct Lighting
-            this.bakeProgress.phase = 'directLighting';
-            this.bakeProgress.message = 'Computing direct lighting...';
-            this.emitProgress();
-            await this.bakeDirectLighting();
-            if (this.bakeAbort) {
-                throw new Error('Bake cancelled');
-            }
-            // Phase 3: Indirect Lighting (bounces)
-            this.bakeProgress.phase = 'indirectLighting';
-            this.bakeProgress.message = 'Computing indirect lighting...';
-            this.emitProgress();
-            for (let bounce = 0; bounce < this.settings.bounces; bounce++) {
-                this.bakeProgress.currentBounce = bounce + 1;
-                this.bakeProgress.message = `Computing bounce ${bounce + 1}/${this.settings.bounces}...`;
-                this.emitProgress();
-                await this.bakeIndirectBounce(bounce);
-                if (this.bakeAbort) {
-                    throw new Error('Bake cancelled');
-                }
-            }
-            // Phase 4: Denoising
-            if (this.settings.denoiser !== 'none') {
-                this.bakeProgress.phase = 'denoising';
-                this.bakeProgress.message = 'Denoising lightmaps...';
-                this.emitProgress();
-                await this.denoiseLightmaps();
-                if (this.bakeAbort) {
-                    throw new Error('Bake cancelled');
-                }
-            }
-            // Phase 5: Compositing
-            this.bakeProgress.phase = 'compositing';
-            this.bakeProgress.message = 'Compositing final lightmaps...';
-            this.emitProgress();
-            await this.compositeLightmaps();
-            if (this.bakeAbort) {
-                throw new Error('Bake cancelled');
-            }
-            // Phase 6: Light Probes
-            this.bakeProgress.phase = 'probes';
-            this.bakeProgress.message = 'Baking light probes...';
-            this.emitProgress();
-            await this.bakeLightProbes();
-            if (this.bakeAbort) {
-                throw new Error('Bake cancelled');
-            }
-            // Phase 7: Reflection Probes
-            this.bakeProgress.phase = 'reflections';
-            this.bakeProgress.message = 'Baking reflection probes...';
-            this.emitProgress();
-            await this.bakeReflectionProbes();
-            if (this.bakeAbort) {
-                throw new Error('Bake cancelled');
-            }
-            // Finished
-            this.bakeProgress.phase = 'finished';
-            this.bakeProgress.progress = 1;
-            this.bakeProgress.totalProgress = 1;
-            this.bakeProgress.message = 'Bake completed successfully';
-            this.bakeProgress.elapsedTime = Date.now() - startTime;
-            this.emitProgress();
+        await this.denoiseLightmaps();
+        if (this.bakeAbort) {
+          throw new Error("Bake cancelled");
         }
-        catch (error) {
-            if (this.bakeAbort) {
-                this.bakeProgress.phase = 'cancelled';
-                this.bakeProgress.message = 'Bake cancelled by user';
-            }
-            else {
-                this.bakeProgress.phase = 'error';
-                this.bakeProgress.message = `Bake failed: ${error}`;
+      }
+      this.bakeProgress.phase = "compositing";
+      this.bakeProgress.message = "Compositing final lightmaps...";
+      this.emitProgress();
+      await this.compositeLightmaps();
+      if (this.bakeAbort) {
+        throw new Error("Bake cancelled");
+      }
+      this.bakeProgress.phase = "probes";
+      this.bakeProgress.message = "Baking light probes...";
+      this.emitProgress();
+      await this.bakeLightProbes();
+      if (this.bakeAbort) {
+        throw new Error("Bake cancelled");
+      }
+      this.bakeProgress.phase = "reflections";
+      this.bakeProgress.message = "Baking reflection probes...";
+      this.emitProgress();
+      await this.bakeReflectionProbes();
+      if (this.bakeAbort) {
+        throw new Error("Bake cancelled");
+      }
+      this.bakeProgress.phase = "finished";
+      this.bakeProgress.progress = 1;
+      this.bakeProgress.totalProgress = 1;
+      this.bakeProgress.message = "Bake completed successfully";
+      this.bakeProgress.elapsedTime = Date.now() - startTime;
+      this.emitProgress();
+    } catch (error) {
+      if (this.bakeAbort) {
+        this.bakeProgress.phase = "cancelled";
+        this.bakeProgress.message = "Bake cancelled by user";
+      } else {
+        this.bakeProgress.phase = "error";
+        this.bakeProgress.message = `Bake failed: ${error}`;
+      }
+      this.emitProgress();
+    }
+  }
+  cancelBake() {
+    this.bakeAbort = true;
+  }
+  getBakeProgress() {
+    return { ...this.bakeProgress };
+  }
+  countTotalProbes() {
+    let count = 0;
+    for (const group of this.lightProbeGroups) {
+      count += group.probes.length;
+    }
+    return count;
+  }
+  async prepareForBake(entityBounds) {
+    const totalArea = this.calculateTotalLightmapArea(entityBounds);
+    const texelsPerUnit = this.settings.lightmapResolution;
+    const maxSize = this.settings.maxLightmapSize;
+    const totalTexels = totalArea * texelsPerUnit * texelsPerUnit;
+    const texelsPerLightmap = maxSize * maxSize;
+    this.bakeProgress.totalLightmaps = Math.ceil(totalTexels / texelsPerLightmap);
+    this.lightmapUVs = this.packLightmapUVs(entityBounds);
+    this.lightmaps = [];
+    for (let i = 0; i < this.bakeProgress.totalLightmaps; i++) {
+      this.lightmaps.push({
+        id: `lm_${i}`,
+        colorData: new Uint8Array(maxSize * maxSize * 4),
+        width: maxSize,
+        height: maxSize,
+        isHDR: true
+      });
+      if (this.settings.mode === "directional") {
+        this.lightmaps[i].directionData = new Uint8Array(maxSize * maxSize * 4);
+      }
+      if (this.settings.mixedMode === "shadowmask") {
+        this.lightmaps[i].shadowmaskData = new Uint8Array(maxSize * maxSize * 4);
+      }
+    }
+    await this.sleep(10);
+  }
+  calculateTotalLightmapArea(entityBounds) {
+    let area = 0;
+    for (const bounds of entityBounds.values()) {
+      const dx = bounds.max.x - bounds.min.x;
+      const dy = bounds.max.y - bounds.min.y;
+      const dz = bounds.max.z - bounds.min.z;
+      area += 2 * (dx * dy + dy * dz + dx * dz);
+    }
+    return area;
+  }
+  packLightmapUVs(entityBounds) {
+    const uvs = [];
+    let currentLightmap = 0;
+    let currentU = 0;
+    let currentV = 0;
+    let rowHeight = 0;
+    const maxSize = this.settings.maxLightmapSize;
+    const padding = this.settings.lightmapPadding;
+    for (const [entityId, bounds] of entityBounds) {
+      const dx = bounds.max.x - bounds.min.x;
+      const dy = bounds.max.y - bounds.min.y;
+      const texelsX = Math.ceil(dx * this.settings.lightmapResolution) + padding * 2;
+      const texelsY = Math.ceil(dy * this.settings.lightmapResolution) + padding * 2;
+      if (currentU + texelsX > maxSize) {
+        currentU = 0;
+        currentV += rowHeight + padding;
+        rowHeight = 0;
+      }
+      if (currentV + texelsY > maxSize) {
+        currentLightmap++;
+        currentU = 0;
+        currentV = 0;
+        rowHeight = 0;
+      }
+      uvs.push({
+        entityId,
+        lightmapIndex: currentLightmap,
+        uvOffset: { x: currentU / maxSize, y: currentV / maxSize },
+        uvScale: { x: texelsX / maxSize, y: texelsY / maxSize }
+      });
+      currentU += texelsX + padding;
+      rowHeight = Math.max(rowHeight, texelsY);
+    }
+    return uvs;
+  }
+  async bakeDirectLighting() {
+    const bakedLights = this.getBakedLights();
+    const totalSamples = this.settings.directSamples;
+    for (let sample = 0; sample < totalSamples; sample++) {
+      for (const lightmap of this.lightmaps) {
+        for (let y = 0; y < lightmap.height; y++) {
+          for (let x = 0; x < lightmap.width; x++) {
+            let r = 0, g = 0, b = 0;
+            for (const light of bakedLights) {
+              const contribution = this.calculateDirectLighting(x, y, lightmap, light, sample);
+              r += contribution.r;
+              g += contribution.g;
+              b += contribution.b;
             }
-            this.emitProgress();
+            const idx = (y * lightmap.width + x) * 4;
+            lightmap.colorData[idx] = Math.min(255, lightmap.colorData[idx] + r);
+            lightmap.colorData[idx + 1] = Math.min(255, lightmap.colorData[idx + 1] + g);
+            lightmap.colorData[idx + 2] = Math.min(255, lightmap.colorData[idx + 2] + b);
+            lightmap.colorData[idx + 3] = 255;
+          }
         }
-    }
-    cancelBake() {
-        this.bakeAbort = true;
-    }
-    getBakeProgress() {
-        return { ...this.bakeProgress };
-    }
-    countTotalProbes() {
-        let count = 0;
-        for (const group of this.lightProbeGroups) {
-            count += group.probes.length;
-        }
-        return count;
-    }
-    async prepareForBake(entityBounds) {
-        // Calculate how many lightmaps we need
-        const totalArea = this.calculateTotalLightmapArea(entityBounds);
-        const texelsPerUnit = this.settings.lightmapResolution;
-        const maxSize = this.settings.maxLightmapSize;
-        const totalTexels = totalArea * texelsPerUnit * texelsPerUnit;
-        const texelsPerLightmap = maxSize * maxSize;
-        this.bakeProgress.totalLightmaps = Math.ceil(totalTexels / texelsPerLightmap);
-        // Assign UV coordinates to entities
-        this.lightmapUVs = this.packLightmapUVs(entityBounds);
-        // Initialize lightmaps
-        this.lightmaps = [];
-        for (let i = 0; i < this.bakeProgress.totalLightmaps; i++) {
-            this.lightmaps.push({
-                id: `lm_${i}`,
-                colorData: new Uint8Array(maxSize * maxSize * 4),
-                width: maxSize,
-                height: maxSize,
-                isHDR: true,
-            });
-            if (this.settings.mode === 'directional') {
-                this.lightmaps[i].directionData = new Uint8Array(maxSize * maxSize * 4);
-            }
-            if (this.settings.mixedMode === 'shadowmask') {
-                this.lightmaps[i].shadowmaskData = new Uint8Array(maxSize * maxSize * 4);
-            }
+      }
+      this.bakeProgress.samplesRendered = sample + 1;
+      this.bakeProgress.progress = (sample + 1) / totalSamples;
+      this.emitProgress();
+      if (sample % 4 === 0) {
+        await this.sleep(1);
+      }
+    }
+  }
+  calculateDirectLighting(x, y, lightmap, light, _sample) {
+    const intensity = light.intensity;
+    const falloff = 1;
+    return {
+      r: light.color.r * intensity * falloff * 2,
+      // Scaled for 8-bit accumulation
+      g: light.color.g * intensity * falloff * 2,
+      b: light.color.b * intensity * falloff * 2,
+      a: 1
+    };
+  }
+  async bakeIndirectBounce(bounceIndex) {
+    const totalSamples = this.settings.indirectSamples / this.settings.bounces;
+    for (let sample = 0; sample < totalSamples; sample++) {
+      for (const lightmap of this.lightmaps) {
+        for (let y = 0; y < lightmap.height; y++) {
+          for (let x = 0; x < lightmap.width; x++) {
+            const indirect = this.sampleIndirectLighting(x, y, lightmap, sample, bounceIndex);
+            const idx = (y * lightmap.width + x) * 4;
+            lightmap.colorData[idx] = Math.min(255, lightmap.colorData[idx] + indirect.r);
+            lightmap.colorData[idx + 1] = Math.min(255, lightmap.colorData[idx + 1] + indirect.g);
+            lightmap.colorData[idx + 2] = Math.min(255, lightmap.colorData[idx + 2] + indirect.b);
+          }
         }
-        await this.sleep(10); // Yield to UI
-    }
-    calculateTotalLightmapArea(entityBounds) {
-        let area = 0;
-        for (const bounds of entityBounds.values()) {
-            // Calculate surface area of bounds
-            const dx = bounds.max.x - bounds.min.x;
-            const dy = bounds.max.y - bounds.min.y;
-            const dz = bounds.max.z - bounds.min.z;
-            // Approximate surface area
-            area += 2 * (dx * dy + dy * dz + dx * dz);
+      }
+      const baseProgress = bounceIndex / this.settings.bounces;
+      const bounceProgress = (sample + 1) / totalSamples / this.settings.bounces;
+      this.bakeProgress.progress = baseProgress + bounceProgress;
+      this.emitProgress();
+      if (sample % 8 === 0) {
+        await this.sleep(1);
+      }
+    }
+  }
+  sampleIndirectLighting(x, y, lightmap, sample, bounce) {
+    const falloff = 1 / (bounce + 1);
+    return {
+      r: Math.random() * 5 * falloff,
+      g: Math.random() * 5 * falloff,
+      b: Math.random() * 5 * falloff,
+      a: 1
+    };
+  }
+  async denoiseLightmaps() {
+    for (let i = 0; i < this.lightmaps.length; i++) {
+      const lightmap = this.lightmaps[i];
+      await this.applyBoxBlur(lightmap.colorData, lightmap.width, lightmap.height, 1);
+      this.bakeProgress.lightmapsCompleted = i + 1;
+      this.bakeProgress.progress = (i + 1) / this.lightmaps.length;
+      this.emitProgress();
+    }
+  }
+  async applyBoxBlur(data, width, height, radius) {
+    const temp = new Uint8Array(data.length);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        let r = 0, g = 0, b = 0, count = 0;
+        for (let dx = -radius; dx <= radius; dx++) {
+          const nx = x + dx;
+          if (nx >= 0 && nx < width) {
+            const idx2 = (y * width + nx) * 4;
+            r += data[idx2];
+            g += data[idx2 + 1];
+            b += data[idx2 + 2];
+            count++;
+          }
         }
-        return area;
-    }
-    packLightmapUVs(entityBounds) {
-        const uvs = [];
-        // Simple packing: assign sequentially (in production, use proper rect packing)
-        let currentLightmap = 0;
-        let currentU = 0;
-        let currentV = 0;
-        let rowHeight = 0;
-        const maxSize = this.settings.maxLightmapSize;
-        const padding = this.settings.lightmapPadding;
-        for (const [entityId, bounds] of entityBounds) {
-            const dx = bounds.max.x - bounds.min.x;
-            const dy = bounds.max.y - bounds.min.y;
-            const texelsX = Math.ceil(dx * this.settings.lightmapResolution) + padding * 2;
-            const texelsY = Math.ceil(dy * this.settings.lightmapResolution) + padding * 2;
-            // Check if fits in current row
-            if (currentU + texelsX > maxSize) {
-                // Move to next row
-                currentU = 0;
-                currentV += rowHeight + padding;
-                rowHeight = 0;
-            }
-            // Check if fits in current lightmap
-            if (currentV + texelsY > maxSize) {
-                // Move to next lightmap
-                currentLightmap++;
-                currentU = 0;
-                currentV = 0;
-                rowHeight = 0;
-            }
-            uvs.push({
-                entityId,
-                lightmapIndex: currentLightmap,
-                uvOffset: { x: currentU / maxSize, y: currentV / maxSize },
-                uvScale: { x: texelsX / maxSize, y: texelsY / maxSize },
-            });
-            currentU += texelsX + padding;
-            rowHeight = Math.max(rowHeight, texelsY);
+        const idx = (y * width + x) * 4;
+        temp[idx] = r / count;
+        temp[idx + 1] = g / count;
+        temp[idx + 2] = b / count;
+        temp[idx + 3] = 255;
+      }
+    }
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        let r = 0, g = 0, b = 0, count = 0;
+        for (let dy = -radius; dy <= radius; dy++) {
+          const ny = y + dy;
+          if (ny >= 0 && ny < height) {
+            const idx2 = (ny * width + x) * 4;
+            r += temp[idx2];
+            g += temp[idx2 + 1];
+            b += temp[idx2 + 2];
+            count++;
+          }
         }
-        return uvs;
-    }
-    async bakeDirectLighting() {
-        const bakedLights = this.getBakedLights();
-        const totalSamples = this.settings.directSamples;
-        for (let sample = 0; sample < totalSamples; sample++) {
-            // For each lightmap texel, trace rays to lights
-            for (const lightmap of this.lightmaps) {
-                for (let y = 0; y < lightmap.height; y++) {
-                    for (let x = 0; x < lightmap.width; x++) {
-                        // Accumulate direct lighting from all baked lights
-                        let r = 0, g = 0, b = 0;
-                        for (const light of bakedLights) {
-                            const contribution = this.calculateDirectLighting(x, y, lightmap, light, sample);
-                            r += contribution.r;
-                            g += contribution.g;
-                            b += contribution.b;
-                        }
-                        // Accumulate in lightmap
-                        const idx = (y * lightmap.width + x) * 4;
-                        lightmap.colorData[idx] = Math.min(255, lightmap.colorData[idx] + r);
-                        lightmap.colorData[idx + 1] = Math.min(255, lightmap.colorData[idx + 1] + g);
-                        lightmap.colorData[idx + 2] = Math.min(255, lightmap.colorData[idx + 2] + b);
-                        lightmap.colorData[idx + 3] = 255;
-                    }
-                }
-            }
-            this.bakeProgress.samplesRendered = sample + 1;
-            this.bakeProgress.progress = (sample + 1) / totalSamples;
-            this.emitProgress();
-            if (sample % 4 === 0) {
-                await this.sleep(1); // Yield to UI periodically
-            }
+        const idx = (y * width + x) * 4;
+        data[idx] = r / count;
+        data[idx + 1] = g / count;
+        data[idx + 2] = b / count;
+      }
+    }
+  }
+  async compositeLightmaps() {
+    for (let i = 0; i < this.lightmaps.length; i++) {
+      const lightmap = this.lightmaps[i];
+      for (let j = 0; j < lightmap.colorData.length; j += 4) {
+        lightmap.colorData[j] = Math.pow(lightmap.colorData[j] / 255, 1 / 2.2) * 255;
+        lightmap.colorData[j + 1] = Math.pow(lightmap.colorData[j + 1] / 255, 1 / 2.2) * 255;
+        lightmap.colorData[j + 2] = Math.pow(lightmap.colorData[j + 2] / 255, 1 / 2.2) * 255;
+      }
+      this.bakeProgress.progress = (i + 1) / this.lightmaps.length;
+      this.emitProgress();
+      await this.sleep(1);
+    }
+  }
+  async bakeLightProbes() {
+    let probeIndex = 0;
+    for (const group of this.lightProbeGroups) {
+      for (const probe of group.probes) {
+        probe.sh = await this.computeSphericalHarmonics(probe.position);
+        probe.isValid = true;
+        probeIndex++;
+        this.bakeProgress.probesCompleted = probeIndex;
+        this.bakeProgress.progress = probeIndex / this.bakeProgress.totalProbes;
+        this.emitProgress();
+        if (probeIndex % 10 === 0) {
+          await this.sleep(1);
         }
-    }
-    calculateDirectLighting(x, y, lightmap, light, _sample) {
-        // Simplified direct lighting calculation
-        // In production, this would involve ray tracing
-        const intensity = light.intensity;
-        const falloff = 1; // Would calculate based on distance for point/spot lights
+      }
+    }
+  }
+  async computeSphericalHarmonics(position) {
+    const coefficients = new Float32Array(27);
+    const samples = 64;
+    for (let i = 0; i < samples; i++) {
+      const theta = Math.acos(1 - 2 * Math.random());
+      const phi = Math.random() * Math.PI * 2;
+      const dir = {
+        x: Math.sin(theta) * Math.cos(phi),
+        y: Math.cos(theta),
+        z: Math.sin(theta) * Math.sin(phi)
+      };
+      const lighting = this.sampleEnvironmentLighting(position, dir);
+      const y0 = 0.282095;
+      coefficients[0] += lighting.r * y0;
+      coefficients[1] += lighting.g * y0;
+      coefficients[2] += lighting.b * y0;
+      const y1 = 0.488603;
+      coefficients[3] += lighting.r * y1 * dir.y;
+      coefficients[4] += lighting.g * y1 * dir.y;
+      coefficients[5] += lighting.b * y1 * dir.y;
+      coefficients[6] += lighting.r * y1 * dir.z;
+      coefficients[7] += lighting.g * y1 * dir.z;
+      coefficients[8] += lighting.b * y1 * dir.z;
+      coefficients[9] += lighting.r * y1 * dir.x;
+      coefficients[10] += lighting.g * y1 * dir.x;
+      coefficients[11] += lighting.b * y1 * dir.x;
+    }
+    const scale = 4 * Math.PI / samples;
+    for (let i = 0; i < 27; i++) {
+      coefficients[i] *= scale;
+    }
+    return { coefficients };
+  }
+  sampleEnvironmentLighting(position, direction) {
+    const settings = this.settings;
+    if (settings.environmentLighting === "color") {
+      return settings.skyColor;
+    }
+    if (settings.environmentLighting === "gradient") {
+      const t = direction.y * 0.5 + 0.5;
+      if (t > 0.5) {
+        const st = (t - 0.5) * 2;
         return {
-            r: light.color.r * intensity * falloff * 2, // Scaled for 8-bit accumulation
-            g: light.color.g * intensity * falloff * 2,
-            b: light.color.b * intensity * falloff * 2,
-            a: 1,
+          r: settings.equatorColor.r + (settings.skyColor.r - settings.equatorColor.r) * st,
+          g: settings.equatorColor.g + (settings.skyColor.g - settings.equatorColor.g) * st,
+          b: settings.equatorColor.b + (settings.skyColor.b - settings.equatorColor.b) * st,
+          a: 1
         };
-    }
-    async bakeIndirectBounce(bounceIndex) {
-        const totalSamples = this.settings.indirectSamples / this.settings.bounces;
-        for (let sample = 0; sample < totalSamples; sample++) {
-            // For each lightmap texel, sample hemisphere for indirect light
-            for (const lightmap of this.lightmaps) {
-                for (let y = 0; y < lightmap.height; y++) {
-                    for (let x = 0; x < lightmap.width; x++) {
-                        const indirect = this.sampleIndirectLighting(x, y, lightmap, sample, bounceIndex);
-                        const idx = (y * lightmap.width + x) * 4;
-                        lightmap.colorData[idx] = Math.min(255, lightmap.colorData[idx] + indirect.r);
-                        lightmap.colorData[idx + 1] = Math.min(255, lightmap.colorData[idx + 1] + indirect.g);
-                        lightmap.colorData[idx + 2] = Math.min(255, lightmap.colorData[idx + 2] + indirect.b);
-                    }
-                }
-            }
-            const baseProgress = bounceIndex / this.settings.bounces;
-            const bounceProgress = (sample + 1) / totalSamples / this.settings.bounces;
-            this.bakeProgress.progress = baseProgress + bounceProgress;
-            this.emitProgress();
-            if (sample % 8 === 0) {
-                await this.sleep(1);
-            }
-        }
-    }
-    sampleIndirectLighting(x, y, lightmap, sample, bounce) {
-        // Simplified indirect lighting
-        // In production, this would involve path tracing / radiosity
-        const falloff = 1 / (bounce + 1);
+      } else {
+        const st = t * 2;
         return {
-            r: Math.random() * 5 * falloff,
-            g: Math.random() * 5 * falloff,
-            b: Math.random() * 5 * falloff,
-            a: 1,
+          r: settings.groundColor.r + (settings.equatorColor.r - settings.groundColor.r) * st,
+          g: settings.groundColor.g + (settings.equatorColor.g - settings.groundColor.g) * st,
+          b: settings.groundColor.b + (settings.equatorColor.b - settings.groundColor.b) * st,
+          a: 1
         };
-    }
-    async denoiseLightmaps() {
-        // Simplified denoising (in production, use OIDN or similar)
-        for (let i = 0; i < this.lightmaps.length; i++) {
-            const lightmap = this.lightmaps[i];
-            await this.applyBoxBlur(lightmap.colorData, lightmap.width, lightmap.height, 1);
-            this.bakeProgress.lightmapsCompleted = i + 1;
-            this.bakeProgress.progress = (i + 1) / this.lightmaps.length;
-            this.emitProgress();
-        }
-    }
-    async applyBoxBlur(data, width, height, radius) {
-        const temp = new Uint8Array(data.length);
-        // Horizontal pass
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                let r = 0, g = 0, b = 0, count = 0;
-                for (let dx = -radius; dx <= radius; dx++) {
-                    const nx = x + dx;
-                    if (nx >= 0 && nx < width) {
-                        const idx = (y * width + nx) * 4;
-                        r += data[idx];
-                        g += data[idx + 1];
-                        b += data[idx + 2];
-                        count++;
-                    }
-                }
-                const idx = (y * width + x) * 4;
-                temp[idx] = r / count;
-                temp[idx + 1] = g / count;
-                temp[idx + 2] = b / count;
-                temp[idx + 3] = 255;
-            }
-        }
-        // Vertical pass
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                let r = 0, g = 0, b = 0, count = 0;
-                for (let dy = -radius; dy <= radius; dy++) {
-                    const ny = y + dy;
-                    if (ny >= 0 && ny < height) {
-                        const idx = (ny * width + x) * 4;
-                        r += temp[idx];
-                        g += temp[idx + 1];
-                        b += temp[idx + 2];
-                        count++;
-                    }
-                }
-                const idx = (y * width + x) * 4;
-                data[idx] = r / count;
-                data[idx + 1] = g / count;
-                data[idx + 2] = b / count;
-            }
-        }
-    }
-    async compositeLightmaps() {
-        // Final compositing (gamma correction, AO, etc.)
-        for (let i = 0; i < this.lightmaps.length; i++) {
-            const lightmap = this.lightmaps[i];
-            // Apply gamma
-            for (let j = 0; j < lightmap.colorData.length; j += 4) {
-                lightmap.colorData[j] = Math.pow(lightmap.colorData[j] / 255, 1 / 2.2) * 255;
-                lightmap.colorData[j + 1] = Math.pow(lightmap.colorData[j + 1] / 255, 1 / 2.2) * 255;
-                lightmap.colorData[j + 2] = Math.pow(lightmap.colorData[j + 2] / 255, 1 / 2.2) * 255;
-            }
-            this.bakeProgress.progress = (i + 1) / this.lightmaps.length;
-            this.emitProgress();
-            await this.sleep(1);
-        }
-    }
-    async bakeLightProbes() {
-        let probeIndex = 0;
-        for (const group of this.lightProbeGroups) {
-            for (const probe of group.probes) {
-                // Bake spherical harmonics for this probe
-                probe.sh = await this.computeSphericalHarmonics(probe.position);
-                probe.isValid = true;
-                probeIndex++;
-                this.bakeProgress.probesCompleted = probeIndex;
-                this.bakeProgress.progress = probeIndex / this.bakeProgress.totalProbes;
-                this.emitProgress();
-                if (probeIndex % 10 === 0) {
-                    await this.sleep(1);
-                }
-            }
-        }
-    }
-    async computeSphericalHarmonics(position) {
-        const coefficients = new Float32Array(27);
-        // Sample environment in all directions and project onto SH basis
-        const samples = 64;
-        for (let i = 0; i < samples; i++) {
-            // Generate uniform direction
-            const theta = Math.acos(1 - 2 * Math.random());
-            const phi = Math.random() * Math.PI * 2;
-            const dir = {
-                x: Math.sin(theta) * Math.cos(phi),
-                y: Math.cos(theta),
-                z: Math.sin(theta) * Math.sin(phi),
-            };
-            // Sample lighting in this direction
-            const lighting = this.sampleEnvironmentLighting(position, dir);
-            // Project onto SH bands
-            // L0 (constant)
-            const y0 = 0.282095;
-            coefficients[0] += lighting.r * y0;
-            coefficients[1] += lighting.g * y0;
-            coefficients[2] += lighting.b * y0;
-            // L1 (linear)
-            const y1 = 0.488603;
-            coefficients[3] += lighting.r * y1 * dir.y;
-            coefficients[4] += lighting.g * y1 * dir.y;
-            coefficients[5] += lighting.b * y1 * dir.y;
-            coefficients[6] += lighting.r * y1 * dir.z;
-            coefficients[7] += lighting.g * y1 * dir.z;
-            coefficients[8] += lighting.b * y1 * dir.z;
-            coefficients[9] += lighting.r * y1 * dir.x;
-            coefficients[10] += lighting.g * y1 * dir.x;
-            coefficients[11] += lighting.b * y1 * dir.x;
-            // L2 (quadratic) - simplified
-            // ... additional coefficients
-        }
-        // Normalize
-        const scale = (4 * Math.PI) / samples;
-        for (let i = 0; i < 27; i++) {
-            coefficients[i] *= scale;
-        }
-        return { coefficients };
-    }
-    sampleEnvironmentLighting(position, direction) {
-        // Sample from environment settings
-        const settings = this.settings;
-        if (settings.environmentLighting === 'color') {
-            return settings.skyColor;
-        }
-        if (settings.environmentLighting === 'gradient') {
-            // Interpolate based on direction
-            const t = direction.y * 0.5 + 0.5;
-            if (t > 0.5) {
-                // Sky to equator
-                const st = (t - 0.5) * 2;
-                return {
-                    r: settings.equatorColor.r + (settings.skyColor.r - settings.equatorColor.r) * st,
-                    g: settings.equatorColor.g + (settings.skyColor.g - settings.equatorColor.g) * st,
-                    b: settings.equatorColor.b + (settings.skyColor.b - settings.equatorColor.b) * st,
-                    a: 1,
-                };
-            }
-            else {
-                // Equator to ground
-                const st = t * 2;
-                return {
-                    r: settings.groundColor.r + (settings.equatorColor.r - settings.groundColor.r) * st,
-                    g: settings.groundColor.g + (settings.equatorColor.g - settings.groundColor.g) * st,
-                    b: settings.groundColor.b + (settings.equatorColor.b - settings.groundColor.b) * st,
-                    a: 1,
-                };
-            }
-        }
-        // Skybox mode - sample from skybox texture
-        return settings.skyColor;
-    }
-    async bakeReflectionProbes() {
-        for (let i = 0; i < this.reflectionProbes.length; i++) {
-            const probe = this.reflectionProbes[i];
-            if (probe.type === 'baked') {
-                // Render cubemap for this probe
-                probe.bakedCubemapId = await this.renderCubemap(probe);
-                probe.isValid = true;
-            }
-            this.bakeProgress.reflectionProbesCompleted = i + 1;
-            this.bakeProgress.progress = (i + 1) / this.reflectionProbes.length;
-            this.emitProgress();
-            await this.sleep(10);
-        }
-    }
-    async renderCubemap(probe) {
-        // In production, this would render 6 faces of a cubemap
-        // Return a reference to the generated texture
-        return `cubemap_${probe.id}`;
-    }
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    // ─── GI Preview ────────────────────────────────────────
-    enableGIPreview(_enable) {
-        // Toggle real-time GI preview in viewport
-        // This would update rendering settings
-    }
-    // ─── Lightmap Access ───────────────────────────────────
-    getLightmaps() {
-        return [...this.lightmaps];
-    }
-    getLightmapUVs() {
-        return [...this.lightmapUVs];
-    }
-    // ─── Serialization ─────────────────────────────────────
-    serialize() {
-        return JSON.stringify({
-            lights: this.lights,
-            lightProbeGroups: this.lightProbeGroups.map((g) => ({
-                ...g,
-                probes: g.probes.map((p) => ({
-                    ...p,
-                    sh: { coefficients: Array.from(p.sh.coefficients) },
-                })),
-            })),
-            reflectionProbes: this.reflectionProbes,
-            settings: this.settings,
-            lightmaps: this.lightmaps.map((lm) => ({
-                ...lm,
-                colorData: Array.from(lm.colorData),
-                directionData: lm.directionData ? Array.from(lm.directionData) : undefined,
-                shadowmaskData: lm.shadowmaskData ? Array.from(lm.shadowmaskData) : undefined,
-            })),
-            lightmapUVs: this.lightmapUVs,
-        });
-    }
-    static deserialize(json) {
-        const data = JSON.parse(json);
-        const system = new LightingSystem();
-        system.lights = data.lights;
-        system.lightProbeGroups = data.lightProbeGroups.map((g) => ({
-            ...g,
-            probes: g.probes.map((p) => ({
-                ...p,
-                sh: { coefficients: new Float32Array(p.sh.coefficients) },
-            })),
-        }));
-        system.reflectionProbes = data.reflectionProbes;
-        system.settings = data.settings;
-        system.lightmaps = data.lightmaps.map((lm) => ({
-            ...lm,
-            colorData: new Uint8Array(lm.colorData),
-            directionData: lm.directionData ? new Uint8Array(lm.directionData) : undefined,
-            shadowmaskData: lm.shadowmaskData ? new Uint8Array(lm.shadowmaskData) : undefined,
-        }));
-        system.lightmapUVs = data.lightmapUVs;
-        return system;
-    }
+      }
+    }
+    return settings.skyColor;
+  }
+  async bakeReflectionProbes() {
+    for (let i = 0; i < this.reflectionProbes.length; i++) {
+      const probe = this.reflectionProbes[i];
+      if (probe.type === "baked") {
+        probe.bakedCubemapId = await this.renderCubemap(probe);
+        probe.isValid = true;
+      }
+      this.bakeProgress.reflectionProbesCompleted = i + 1;
+      this.bakeProgress.progress = (i + 1) / this.reflectionProbes.length;
+      this.emitProgress();
+      await this.sleep(10);
+    }
+  }
+  async renderCubemap(probe) {
+    return `cubemap_${probe.id}`;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // ─── GI Preview ────────────────────────────────────────
+  enableGIPreview(_enable) {
+  }
+  // ─── Lightmap Access ───────────────────────────────────
+  getLightmaps() {
+    return [...this.lightmaps];
+  }
+  getLightmapUVs() {
+    return [...this.lightmapUVs];
+  }
+  // ─── Serialization ─────────────────────────────────────
+  serialize() {
+    return JSON.stringify({
+      lights: this.lights,
+      lightProbeGroups: this.lightProbeGroups.map((g) => ({
+        ...g,
+        probes: g.probes.map((p) => ({
+          ...p,
+          sh: { coefficients: Array.from(p.sh.coefficients) }
+        }))
+      })),
+      reflectionProbes: this.reflectionProbes,
+      settings: this.settings,
+      lightmaps: this.lightmaps.map((lm) => ({
+        ...lm,
+        colorData: Array.from(lm.colorData),
+        directionData: lm.directionData ? Array.from(lm.directionData) : void 0,
+        shadowmaskData: lm.shadowmaskData ? Array.from(lm.shadowmaskData) : void 0
+      })),
+      lightmapUVs: this.lightmapUVs
+    });
+  }
+  static deserialize(json) {
+    const data = JSON.parse(json);
+    const system = new LightingSystem();
+    system.lights = data.lights;
+    system.lightProbeGroups = data.lightProbeGroups.map((g) => ({
+      ...g,
+      probes: g.probes.map((p) => ({
+        ...p,
+        sh: { coefficients: new Float32Array(p.sh.coefficients) }
+      }))
+    }));
+    system.reflectionProbes = data.reflectionProbes;
+    system.settings = data.settings;
+    system.lightmaps = data.lightmaps.map((lm) => ({
+      ...lm,
+      colorData: new Uint8Array(lm.colorData),
+      directionData: lm.directionData ? new Uint8Array(lm.directionData) : void 0,
+      shadowmaskData: lm.shadowmaskData ? new Uint8Array(lm.shadowmaskData) : void 0
+    }));
+    system.lightmapUVs = data.lightmapUVs;
+    return system;
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createLightingSystem() {
-    return new LightingSystem();
+  return new LightingSystem();
 }
 function createDefaultLightingSetup() {
-    const system = new LightingSystem();
-    // Add a directional light (sun)
-    system.addLight(createDirectionalLight('Directional Light'));
-    // Add a light probe group
-    const probeGroup = createLightProbeGroup('Default Probes');
-    system.addLightProbeGroup(probeGroup);
-    system.autoGenerateProbes(probeGroup.id);
-    // Add a reflection probe
-    system.addReflectionProbe(createReflectionProbe('Reflection Probe', { x: 0, y: 2, z: 0 }));
-    return system;
+  const system = new LightingSystem();
+  system.addLight(createDirectionalLight("Directional Light"));
+  const probeGroup = createLightProbeGroup("Default Probes");
+  system.addLightProbeGroup(probeGroup);
+  system.autoGenerateProbes(probeGroup.id);
+  system.addReflectionProbe(createReflectionProbe("Reflection Probe", { x: 0, y: 2, z: 0 }));
+  return system;
 }
-
-export { DEFAULT_LIGHTMAP_SETTINGS, LightingSystem, createAreaLight, createDefaultLightingSetup, createDirectionalLight, createLightProbe, createLightProbeGroup, createLightingSystem, createPointLight, createReflectionProbe, createSpotLight };
+export {
+  DEFAULT_LIGHTMAP_SETTINGS,
+  LightingSystem,
+  createAreaLight,
+  createDefaultLightingSetup,
+  createDirectionalLight,
+  createLightProbe,
+  createLightProbeGroup,
+  createLightingSystem,
+  createPointLight,
+  createReflectionProbe,
+  createSpotLight
+};