@directivegames/genesys.js 3.1.24

package/dist/games/deprecated/lightmapping-demo.js

@@ -0,0 +1,1344 @@
+/**
+ * Lightmapping System Demo
+ *
+ * This is the main demo showcasing the complete lightmapping system including:
+ * - Loading existing Genesys scene files with automatic lightmap loading
+ * - Interactive lightmap baking with automatic light detection
+ * - Export/import lightmap data to/from files
+ * - Various visualization modes for debugging and testing
+ * - Integration with the core engine's automatic lightmap system
+ */
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { TransformControls } from 'three/examples/jsm/controls/TransformControls.js';
+import { Pane } from 'tweakpane';
+export class LightmappingDemo extends ENGINE.BaseGameLoop {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lightmapManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pane", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Store reference to directional light actor and transform controls
+        Object.defineProperty(this, "directionalLightActor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Track current scene path for filename generation
+        Object.defineProperty(this, "currentScenePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "transformControls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Tweakpane controls and parameters
+        Object.defineProperty(this, "lightmapParams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                // Basic settings
+                resolution: 512,
+                casts: 32,
+                progressiveSamples: 128,
+                lightSize: 0.5,
+                // Lighting toggles
+                directLightEnabled: true,
+                indirectLightEnabled: false,
+                ambientLightEnabled: false,
+                // Advanced settings
+                ambientDistance: 10.0,
+                filterMode: 'Linear',
+                // Atlas options (matching LightmapAtlasOptions interface)
+                padding: 2,
+                dilate: true,
+                // Manager options
+                progressiveBaking: true,
+                autoApply: true,
+                // Export options (only includeSceneHash is actually used)
+                includeSceneHash: true,
+                // Render mode for visualization
+                renderMode: 'standard'
+            }
+        });
+        // Store original material maps for restoration
+        Object.defineProperty(this, "originalMaterialMaps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // File input for scene loading
+        Object.defineProperty(this, "fileInput", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "debugTextureActors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    async preStart() {
+        // Load default scene
+        await this.loadDefaultScene();
+    }
+    postStart() {
+        // Get the lightmap manager from the world (it's created automatically by the engine)
+        this.lightmapManager = this.world.getLightmapManager();
+        this.createTweakPane();
+        this.createFileInput();
+        // Set up transform controls after the world is fully initialized
+        this.setupTransformControls();
+    }
+    async loadDefaultScene() {
+        this.clearExistingScene();
+        await this.createDefaultScene();
+        this.updateStatus('✓ Default scene created');
+        return;
+    }
+    /**
+     * Clears all existing actors and debug objects from the scene
+     */
+    clearExistingScene() {
+        // Clean up transform controls and light helpers FIRST
+        this.cleanupTransformControlsAndHelpers();
+        // Clear debug textures
+        this.clearDebugTextures();
+        // Clear original material maps
+        this.originalMaterialMaps.clear();
+        // Remove all existing actors
+        const existingActors = this.world.getActors();
+        this.world.removeActors(...existingActors);
+        // Clear current scene path
+        this.currentScenePath = null;
+        // Reset directional light actor reference since scene is cleared
+        this.directionalLightActor = null;
+        // Reset light helper visibility state for new scene
+        // This property is no longer needed as we use userData on the light component
+    }
+    /**
+     * Cleans up transform controls and light helpers before scene changes
+     */
+    cleanupTransformControlsAndHelpers() {
+        // Disable and dispose of transform controls first
+        if (this.transformControls) {
+            console.log('Cleaning up transform controls...');
+            // Disable the controls to prevent any ongoing interactions
+            this.transformControls.enabled = false;
+            // Detach from any object
+            this.transformControls.detach();
+            // Remove event listeners by disposing
+            this.transformControls.dispose();
+            // Remove the helper from the scene
+            const helper = this.transformControls.getHelper();
+            if (helper && helper.parent) {
+                helper.parent.remove(helper);
+            }
+            // Clear the reference
+            this.transformControls = null;
+            console.log('Transform controls cleaned up');
+        }
+        // Hide all light helpers in the current scene before clearing
+        const lightActors = this.world.getActorsByPredicate(actor => actor.getComponents(ENGINE.DirectionalLightComponent).length > 0 ||
+            actor.getComponents(ENGINE.PointLightComponent).length > 0 ||
+            actor.getComponents(ENGINE.SpotLightComponent).length > 0);
+        for (const actor of lightActors) {
+            // Handle DirectionalLightComponent
+            const directionalLights = actor.getComponents(ENGINE.DirectionalLightComponent);
+            for (const light of directionalLights) {
+                if (light.userData.helperVisible === true) {
+                    try {
+                        console.log('Hiding directional light helper before scene clear');
+                        light.showHelper(false);
+                        delete light.userData.helperVisible;
+                    }
+                    catch (error) {
+                        console.warn('Error hiding directional light helper:', error);
+                    }
+                }
+            }
+            // Handle PointLightComponent
+            const pointLights = actor.getComponents(ENGINE.PointLightComponent);
+            for (const light of pointLights) {
+                if (light.userData.helperVisible === true) {
+                    try {
+                        console.log('Hiding point light helper before scene clear');
+                        light.showHelper(false);
+                        delete light.userData.helperVisible;
+                    }
+                    catch (error) {
+                        console.warn('Error hiding point light helper:', error);
+                    }
+                }
+            }
+            // Handle SpotLightComponent
+            const spotLights = actor.getComponents(ENGINE.SpotLightComponent);
+            for (const light of spotLights) {
+                if (light.userData.helperVisible === true) {
+                    try {
+                        console.log('Hiding spot light helper before scene clear');
+                        light.showHelper(false);
+                        delete light.userData.helperVisible;
+                    }
+                    catch (error) {
+                        console.warn('Error hiding spot light helper:', error);
+                    }
+                }
+            }
+        }
+        // Clear the directional light actor reference
+        this.directionalLightActor = null;
+        console.log('Light helpers cleaned up and references cleared');
+    }
+    /**
+     * Creates a simple fallback scene if no scene file is available
+     */
+    async createDefaultScene() {
+        const { pawn } = ENGINE.GameBuilder.createDefaultPawn(this.world, new THREE.Vector3(0, 8, 5));
+        pawn.getCamera()?.lookAt(0, 0, 0);
+        // Create ground plane (STATIC - will be included in lightmapping)
+        const ground = new ENGINE.Actor({
+            position: new THREE.Vector3(0, 0, 0),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.PlaneGeometry(20, 20),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0xffffff,
+                    roughness: 0.8,
+                    metalness: 0.1
+                }),
+                physicsOptions: {
+                    enabled: true,
+                    motionType: ENGINE.PhysicsMotionType.Static, // STATIC: Included in lightmaps
+                    collisionProfile: 'WorldStatic'
+                }
+            })
+        });
+        ground.rootComponent.rotation.x = -Math.PI / 2;
+        // Enable shadows for ground
+        const groundMeshComp = ground.rootComponent;
+        groundMeshComp.receiveShadow = true;
+        ground.addActorTag('ground');
+        this.world.addActors(ground);
+        // Create static cubes to cast shadows (STATIC - will be included in lightmapping)
+        const staticCubePositions = [
+            { x: -2, z: -1 },
+            { x: 2, z: 3 },
+            { x: -1, z: 4 },
+            { x: 0, z: 0 },
+            { x: 4, z: -2 }
+        ];
+        const staticCubeGeometries = [
+            { width: 1, height: 2, depth: 1 },
+            { width: 1, height: 2, depth: 2 },
+            { width: 2, height: 2, depth: 1 },
+            { width: 2, height: 2, depth: 2 },
+            { width: 1, height: 1, depth: 1 },
+        ];
+        const staticCubeColor = 0x0000ff; // blue
+        for (let i = 0; i < staticCubePositions.length; i++) {
+            const staticCube = new ENGINE.Actor({
+                position: new THREE.Vector3(staticCubePositions[i].x, 1, staticCubePositions[i].z),
+                rootComponent: new ENGINE.MeshComponent({
+                    geometry: new THREE.BoxGeometry(staticCubeGeometries[i].width, staticCubeGeometries[i].height, staticCubeGeometries[i].depth),
+                    material: new THREE.MeshStandardMaterial({
+                        color: new THREE.Color(staticCubeColor),
+                        roughness: 0.6,
+                        metalness: 0.2
+                    }),
+                    physicsOptions: {
+                        enabled: true,
+                        motionType: ENGINE.PhysicsMotionType.Static, // STATIC: Included in lightmaps
+                        collisionProfile: 'WorldStatic'
+                    }
+                })
+            });
+            staticCube.addActorTag('staticCube_' + i);
+            // Enable shadows
+            const staticMeshComp = staticCube.rootComponent;
+            staticMeshComp.castShadow = true;
+            staticMeshComp.receiveShadow = true;
+            this.world.addActors(staticCube);
+        }
+        // Create dynamic cubes (DYNAMIC - will be EXCLUDED from lightmapping)
+        const dynamicCubePositions = [
+            { x: 3, z: -3 },
+            { x: -2, z: 1 }
+        ];
+        const dynamicCubeColors = [
+            0xf9ca24, // Yellow
+            0x6c5ce7 // Purple
+        ];
+        for (let i = 0; i < 2; i++) {
+            const dynamicCube = new ENGINE.Actor({
+                position: new THREE.Vector3(dynamicCubePositions[i].x, 1, dynamicCubePositions[i].z),
+                rootComponent: new ENGINE.MeshComponent({
+                    geometry: new THREE.BoxGeometry(1, 2, 1),
+                    material: new THREE.MeshStandardMaterial({
+                        color: new THREE.Color(dynamicCubeColors[i]),
+                        roughness: 0.6,
+                        metalness: 0.2,
+                        emissive: new THREE.Color(dynamicCubeColors[i]).multiplyScalar(0.1) // Slight glow to indicate they're dynamic
+                    }),
+                    physicsOptions: {
+                        enabled: true,
+                        motionType: ENGINE.PhysicsMotionType.Dynamic, // DYNAMIC: Excluded from lightmaps
+                        collisionProfile: 'WorldDynamic'
+                    }
+                })
+            });
+            // Enable shadows
+            const dynamicMeshComp = dynamicCube.rootComponent;
+            dynamicMeshComp.castShadow = true;
+            dynamicMeshComp.receiveShadow = true;
+            dynamicCube.addActorTag('dynamicCube_' + i);
+            this.world.addActors(dynamicCube);
+        }
+        // Create a kinematic moving platform (KINEMATIC - will be EXCLUDED from lightmapping)
+        const movingPlatform = new ENGINE.Actor({
+            position: new THREE.Vector3(0, 0.5, -8),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(3, 0.5, 2),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x00ff88,
+                    roughness: 0.4,
+                    metalness: 0.8,
+                    emissive: new THREE.Color(0x00ff88).multiplyScalar(0.05) // Slight glow to indicate it's kinematic
+                }),
+                physicsOptions: {
+                    enabled: true,
+                    motionType: ENGINE.PhysicsMotionType.KinematicPositionBased, // KINEMATIC: Excluded from lightmaps
+                    collisionProfile: 'WorldStatic'
+                }
+            })
+        });
+        // Enable shadows
+        const platformMeshComp = movingPlatform.rootComponent;
+        platformMeshComp.castShadow = true;
+        platformMeshComp.receiveShadow = true;
+        movingPlatform.addActorTag('movingPlatform');
+        this.world.addActors(movingPlatform);
+        // Add a directional light (sun) - white, high intensity, from above at angle
+        this.directionalLightActor = new ENGINE.Actor({
+            position: new THREE.Vector3(8, 12, 3),
+            rootComponent: new ENGINE.DirectionalLightComponent({
+                color: 0xffffff,
+                intensity: 50.0,
+                castShadow: true
+            })
+        });
+        const directionalLight = this.directionalLightActor.rootComponent;
+        directionalLight.lookAt(0, 0, 0);
+        this.directionalLightActor.addActorTag('directionalLight');
+        this.world.addActors(this.directionalLightActor);
+        // Add ambient light for overall illumination
+        const ambientLightActor = new ENGINE.Actor({
+            rootComponent: new ENGINE.AmbientLightComponent({
+                color: 0xffffff,
+                intensity: 5
+            })
+        });
+        ambientLightActor.addActorTag('ambientLight');
+        this.world.addActors(ambientLightActor);
+        // Add a yellow point light to shine on the last static cube
+        const pointLightActor = new ENGINE.Actor({
+            position: new THREE.Vector3(4, 3, -2), // Above the last static cube at (4, -2)
+            rootComponent: new ENGINE.PointLightComponent({
+                color: 0xffff55, // Slightly yellow
+                intensity: 100,
+                distance: 15,
+                decay: 2,
+                castShadow: true
+            })
+        });
+        pointLightActor.addActorTag('pointLight');
+        this.world.addActors(pointLightActor);
+        console.log('📍 Default scene created with static/dynamic mesh examples:');
+        console.log('  🔹 Static meshes (included in lightmaps): blue cubes');
+        console.log('  🔸 Dynamic meshes (excluded from lightmaps): yellow and purple cubes');
+        console.log('  🔷 Kinematic meshes (excluded from lightmaps): Moving platform (green)');
+    }
+    /**
+     * Sets up transform controls for the directional light
+     */
+    setupTransformControls() {
+        // Use the reattach method which handles finding the light and setting up controls
+        this.reattachTransformControls();
+    }
+    /**
+     * Handles interaction state changes for transform controls
+     */
+    handleTransformControlsInteraction(isDragging) {
+        // Get the player controller to disable input when dragging
+        const playerController = this.world.getFirstActor(ENGINE.PlayerController);
+        if (playerController) {
+            // When dragging, we want to prevent player camera movement
+            // This is handled automatically by the transform controls blocking pointer events
+            // The engine's input system will respect this
+        }
+    }
+    /**
+     * Updates the directional light's direction to point towards the origin
+     */
+    updateDirectionalLightDirection() {
+        if (!this.directionalLightActor)
+            return;
+        try {
+            const directionalLightComponents = this.directionalLightActor.getComponents(ENGINE.DirectionalLightComponent);
+            if (directionalLightComponents.length > 0) {
+                const directionalLight = directionalLightComponents[0];
+                // Get the current world position of the light
+                const lightPosition = this.directionalLightActor.getWorldPosition();
+                // Make the light look at the origin (0, 0, 0)
+                directionalLight.lookAt(0, 0, 0);
+                // Update the light's target for shadow mapping using the public API
+                directionalLight.setTarget(new THREE.Vector3(0, 0, 0));
+                // Log the new position for debugging
+                console.log(`🔆 Directional light moved to: (${lightPosition.x.toFixed(2)}, ${lightPosition.y.toFixed(2)}, ${lightPosition.z.toFixed(2)}) - Bake lightmaps to see changes!`);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to update directional light direction:', error);
+        }
+    }
+    /**
+     * Creates a hidden file input for scene loading
+     */
+    createFileInput() {
+        this.fileInput = document.createElement('input');
+        this.fileInput.type = 'file';
+        this.fileInput.accept = '.genesys-scene,.json';
+        this.fileInput.style.display = 'none';
+        document.body.appendChild(this.fileInput);
+        this.fileInput.addEventListener('change', async (event) => {
+            const file = event.target.files?.[0];
+            if (file) {
+                await this.loadSceneFromFile(file);
+            }
+        });
+    }
+    /**
+     * Loads a scene from a selected file
+     */
+    async loadSceneFromFile(file) {
+        try {
+            this.updateStatus('Loading scene file...');
+            const text = await file.text();
+            const sceneData = JSON.parse(text);
+            // Clear existing scene completely
+            this.clearExistingScene();
+            // Load the new scene data using proper method
+            await this.loadWorldData(sceneData);
+            // Update current scene path
+            this.currentScenePath = ENGINE.AssetPath.fromString(`/scenes/${file.name}`);
+            // Create camera controller if none exists
+            if (!this.world.getFirstActor(ENGINE.PlayerController)) {
+                ENGINE.GameBuilder.createDefaultPawn(this.world, new THREE.Vector3(0, 1, 0));
+            }
+            // Reattach transform controls to the new scene's directional light
+            this.reattachTransformControls();
+            // For user-uploaded files, attempt to auto-load lightmaps
+            await this.tryLoadLightmapsForUserFile(file.name);
+        }
+        catch (error) {
+            this.updateStatus(`✗ Failed to load scene: ${error}`);
+            console.error('Failed to load scene file:', error);
+        }
+    }
+    /**
+     * Attempts to load lightmaps for a user-uploaded file
+     */
+    async tryLoadLightmapsForUserFile(sceneName) {
+        // Extract base name without extension
+        const baseName = sceneName.replace(/\.[^.]+$/, '');
+        // For user files, we can't automatically find the lightmap files
+        // since they're not in a known file system location
+        // Just report that the scene was loaded without lightmaps
+        this.updateStatus(`✓ Loaded scene: ${sceneName} (use Import Lightmaps button to load lightmaps manually)`);
+    }
+    /**
+     * Checks and reports lightmap loading status after scene loading
+     */
+    checkLightmapStatus(sceneName) {
+        const lightmapManager = this.world.getLightmapManager();
+        if (lightmapManager && lightmapManager.hasLightmapData()) {
+            this.updateStatus(`✓ Loaded scene: ${sceneName} (lightmaps automatically applied)`);
+        }
+        else {
+            this.updateStatus(`✓ Loaded scene: ${sceneName} (no lightmaps found)`);
+        }
+    }
+    /**
+     * Reattaches transform controls to the directional light in the current scene
+     */
+    reattachTransformControls() {
+        // Clean up existing transform controls first using the dedicated cleanup method
+        this.cleanupTransformControlsAndHelpers();
+        // Find the directional light in the current scene
+        const foundActor = this.world.getActorsByPredicate(actor => actor.getComponents(ENGINE.DirectionalLightComponent).length > 0)[0];
+        if (!foundActor) {
+            console.log('No directional light found in scene to attach transform controls.');
+            return;
+        }
+        // Update our reference to the new directional light
+        this.directionalLightActor = foundActor;
+        // Get the camera from the world for the transform controls
+        const camera = this.world.getActiveCamera();
+        if (!camera) {
+            console.log('No camera found for transform controls');
+            return;
+        }
+        // Create transform controls
+        this.transformControls = new TransformControls(camera, this.renderer.renderer.domElement);
+        // Attach to the directional light's root component
+        this.transformControls.attach(this.directionalLightActor.rootComponent);
+        // Add to the scene (cast to Object3D)
+        this.world.scene.add(this.transformControls.getHelper());
+        // Set initial mode to translate
+        this.transformControls.setMode('translate');
+        // Make the controls visible and slightly larger
+        this.transformControls.setSize(1.5);
+        // Show the directional light helper for better visualization with error handling
+        try {
+            const directionalLightComponents = this.directionalLightActor.getComponents(ENGINE.DirectionalLightComponent);
+            if (directionalLightComponents.length > 0) {
+                const directionalLight = directionalLightComponents[0];
+                directionalLight.showHelper(true);
+                // Mark helper as visible in userData for toggle button
+                directionalLight.userData.helperVisible = true;
+                console.log('Directional light helper shown');
+            }
+            else {
+                console.warn('No DirectionalLightComponent found in the actor');
+            }
+        }
+        catch (error) {
+            console.error('Error showing directional light helper:', error);
+        }
+        // Add event listeners
+        this.transformControls.addEventListener('dragging-changed', (event) => {
+            // Disable camera controls when dragging the transform control
+            const isDragging = event.value;
+            this.handleTransformControlsInteraction(isDragging);
+            // Update light direction when dragging ends
+            if (!isDragging) {
+                this.updateDirectionalLightDirection();
+            }
+        });
+        this.transformControls.addEventListener('change', () => {
+            // Update the light's direction in real-time during dragging
+            this.updateDirectionalLightDirection();
+        });
+        this.transformControls.addEventListener('objectChange', () => {
+            // Additional update when the object transformation changes
+            this.updateDirectionalLightDirection();
+        });
+        console.log('Transform controls reattached to new directional light successfully');
+    }
+    createTweakPane() {
+        this.pane = new Pane({ title: 'Lightmapping Demo' });
+        // Scene controls
+        const sceneFolder = this.pane.addFolder({ title: 'Scene', expanded: true });
+        const loadSceneButton = sceneFolder.addButton({ title: 'Load Default Scene File' });
+        loadSceneButton.on('click', async () => {
+            // Load the default fps-new.genesys-scene file directly
+            try {
+                const defaultScenePath = ENGINE.AssetPath.fromString('@engine/assets/dev/fps-new.genesys-scene');
+                this.clearExistingScene();
+                this.currentScenePath = defaultScenePath;
+                await this.loadWorldDataFromPath(defaultScenePath);
+                if (!this.world.getFirstActor(ENGINE.PlayerController)) {
+                    ENGINE.GameBuilder.createDefaultPawn(this.world, new THREE.Vector3(0, 2, 0));
+                }
+                this.reattachTransformControls();
+                this.checkLightmapStatus('fps-new.genesys-scene');
+            }
+            catch (error) {
+                console.error('Failed to load scene file:', error);
+                this.updateStatus('❌ Failed to load scene file');
+            }
+        });
+        const loadCustomSceneButton = sceneFolder.addButton({ title: 'Load Custom Scene File' });
+        loadCustomSceneButton.on('click', () => {
+            this.fileInput?.click();
+        });
+        const reloadButton = sceneFolder.addButton({ title: 'Reload Default Scene' });
+        reloadButton.on('click', () => {
+            this.loadDefaultScene();
+        });
+        // Basic lightmap settings
+        const basicFolder = this.pane.addFolder({ title: 'Basic Settings', expanded: true });
+        basicFolder.addBinding(this.lightmapParams, 'resolution', {
+            min: 128,
+            max: 2048,
+            step: 128,
+            label: 'Resolution'
+        });
+        basicFolder.addBinding(this.lightmapParams, 'casts', {
+            min: 1,
+            max: 128,
+            step: 1,
+            label: 'Ray Casts'
+        });
+        basicFolder.addBinding(this.lightmapParams, 'progressiveSamples', {
+            min: 1,
+            max: 1000,
+            label: 'Samples'
+        });
+        basicFolder.addBinding(this.lightmapParams, 'lightSize', {
+            min: 0.1,
+            max: 2.0,
+            step: 0.1,
+            label: 'Light Size'
+        });
+        // Render mode control
+        const renderModeControl = basicFolder.addBinding(this.lightmapParams, 'renderMode', {
+            options: {
+                'Standard': 'standard',
+                'Positions': 'positions',
+                'Normals': 'normals',
+                'UV Debug': 'uv',
+                'Lightmap Only': 'lightmap',
+                'Beauty (Lightmap + Textures)': 'beauty'
+            },
+            label: 'Render Mode'
+        });
+        renderModeControl.on('change', () => {
+            this.onRenderModeChange();
+        });
+        // Lighting options
+        const lightingFolder = this.pane.addFolder({ title: 'Lighting Options', expanded: true });
+        lightingFolder.addBinding(this.lightmapParams, 'directLightEnabled', {
+            label: 'Direct Light'
+        });
+        lightingFolder.addBinding(this.lightmapParams, 'indirectLightEnabled', {
+            label: 'Indirect Light'
+        });
+        lightingFolder.addBinding(this.lightmapParams, 'ambientLightEnabled', {
+            label: 'Ambient/AO'
+        });
+        lightingFolder.addBinding(this.lightmapParams, 'ambientDistance', {
+            min: 1.0,
+            max: 50.0,
+            step: 0.5,
+            label: 'AO Distance'
+        });
+        // Advanced settings
+        const advancedFolder = this.pane.addFolder({ title: 'Advanced Settings', expanded: false });
+        advancedFolder.addBinding(this.lightmapParams, 'filterMode', {
+            options: {
+                Linear: 'Linear',
+                Nearest: 'Nearest'
+            },
+            label: 'Filter Mode'
+        });
+        advancedFolder.addBinding(this.lightmapParams, 'padding', {
+            min: 0,
+            max: 10,
+            step: 1,
+            label: 'Atlas Padding'
+        });
+        advancedFolder.addBinding(this.lightmapParams, 'dilate', {
+            label: 'Atlas Dilation'
+        });
+        // Manager options
+        const managerFolder = this.pane.addFolder({ title: 'Baking Options', expanded: false });
+        managerFolder.addBinding(this.lightmapParams, 'progressiveBaking', {
+            label: 'Progressive Baking'
+        });
+        managerFolder.addBinding(this.lightmapParams, 'autoApply', {
+            label: 'Auto Apply'
+        });
+        // Action buttons
+        const actionsFolder = this.pane.addFolder({ title: 'Actions', expanded: true });
+        const bakeButton = actionsFolder.addButton({ title: 'Bake Lightmaps' });
+        bakeButton.on('click', () => {
+            this.bakeLightmaps();
+        });
+        const removeButton = actionsFolder.addButton({ title: 'Remove Lightmaps' });
+        removeButton.on('click', () => {
+            this.removeLightmaps();
+        });
+        // Export/Import controls
+        const exportImportFolder = this.pane.addFolder({ title: 'Export/Import', expanded: true });
+        exportImportFolder.addBinding(this.lightmapParams, 'includeSceneHash', {
+            label: 'Include Scene Hash'
+        });
+        const exportButton = exportImportFolder.addButton({ title: 'Export Lightmaps (Files)' });
+        exportButton.on('click', () => {
+            this.exportLightmaps();
+        });
+        const exportDataButton = exportImportFolder.addButton({ title: 'Export Data (Custom)' });
+        exportDataButton.on('click', () => {
+            this.exportLightmapData();
+        });
+        const importButton = exportImportFolder.addButton({ title: 'Import Lightmaps' });
+        importButton.on('click', () => {
+            this.openImportDialog();
+        });
+        // Transform controls
+        const transformFolder = this.pane.addFolder({ title: 'Transform Controls', expanded: true });
+        const translateButton = transformFolder.addButton({ title: 'Translate Mode' });
+        translateButton.on('click', () => {
+            if (this.transformControls && this.transformControls.enabled) {
+                this.transformControls.setMode('translate');
+            }
+            else {
+                console.log('Transform controls not available. Try refreshing controls first.');
+            }
+        });
+        const rotateButton = transformFolder.addButton({ title: 'Rotate Mode' });
+        rotateButton.on('click', () => {
+            if (this.transformControls && this.transformControls.enabled) {
+                this.transformControls.setMode('rotate');
+            }
+            else {
+                console.log('Transform controls not available. Try refreshing controls first.');
+            }
+        });
+        const scaleButton = transformFolder.addButton({ title: 'Scale Mode' });
+        scaleButton.on('click', () => {
+            if (this.transformControls && this.transformControls.enabled) {
+                this.transformControls.setMode('scale');
+            }
+            else {
+                console.log('Transform controls not available. Try refreshing controls first.');
+            }
+        });
+        const toggleControlsButton = transformFolder.addButton({ title: 'Toggle Controls' });
+        toggleControlsButton.on('click', () => {
+            if (this.transformControls) {
+                this.transformControls.enabled = !this.transformControls.enabled;
+                console.log(`Transform controls ${this.transformControls.enabled ? 'enabled' : 'disabled'}`);
+            }
+            else {
+                console.log('Transform controls not available. Try refreshing controls first.');
+            }
+        });
+        const refreshControlsButton = transformFolder.addButton({ title: 'Refresh Controls' });
+        refreshControlsButton.on('click', () => {
+            this.reattachTransformControls();
+        });
+        const toggleLightHelperButton = transformFolder.addButton({ title: 'Toggle Light Helper' });
+        toggleLightHelperButton.on('click', () => {
+            // Find the current directional light in the scene dynamically
+            const foundActor = this.world.getActorsByPredicate(actor => actor.getComponents(ENGINE.DirectionalLightComponent).length > 0)[0];
+            if (foundActor) {
+                try {
+                    const directionalLightComponents = foundActor.getComponents(ENGINE.DirectionalLightComponent);
+                    if (directionalLightComponents.length > 0) {
+                        const directionalLight = directionalLightComponents[0];
+                        // Use userData to track toggle state per light component
+                        const isHelperVisible = directionalLight.userData.helperVisible === true;
+                        if (isHelperVisible) {
+                            directionalLight.showHelper(false);
+                            directionalLight.userData.helperVisible = false;
+                            console.log('Light helper hidden');
+                        }
+                        else {
+                            directionalLight.showHelper(true);
+                            directionalLight.userData.helperVisible = true;
+                            console.log('Light helper shown');
+                        }
+                    }
+                    else {
+                        console.warn('No DirectionalLightComponent found in the actor');
+                    }
+                }
+                catch (error) {
+                    console.error('Error toggling light helper:', error);
+                }
+            }
+            else {
+                console.log('No directional light found to toggle helper');
+            }
+        });
+        // Status display
+        this.pane.addBlade({ view: 'separator' });
+        const statusElement = document.createElement('div');
+        statusElement.style.padding = '8px';
+        statusElement.style.fontSize = '12px';
+        statusElement.style.color = '#888';
+        statusElement.style.backgroundColor = '#1a1a1a';
+        statusElement.style.borderRadius = '4px';
+        statusElement.innerHTML = 'Status: Ready<br/>💡 Move the directional light using transform controls, then bake to see the lighting changes!<br/>📍 The light position is captured at the moment baking starts.<br/>🔸 Static meshes (blue/red/teal cubes) will be included in lightmaps<br/>🔹 Dynamic meshes (yellow/purple cubes) will be excluded from lightmaps<br/>🔷 Kinematic meshes (green platform) will be excluded from lightmaps<br/>📦 Use "Export Data (Custom)" to see custom handling examples!';
+        exportImportFolder.element.appendChild(statusElement);
+        // Store reference for updates
+        this.statusElement = statusElement;
+    }
+    /**
+     * Bakes lightmaps for the scene using the current settings
+     */
+    async bakeLightmaps() {
+        try {
+            this.updateStatus('Baking lightmaps...');
+            await this.lightmapManager.bakeLightmaps({
+                resolution: this.lightmapParams.resolution,
+                casts: this.lightmapParams.casts,
+                progressiveSamples: this.lightmapParams.progressiveSamples,
+                directLightEnabled: this.lightmapParams.directLightEnabled,
+                indirectLightEnabled: this.lightmapParams.indirectLightEnabled,
+                ambientLightEnabled: this.lightmapParams.ambientLightEnabled,
+                ambientDistance: this.lightmapParams.ambientDistance,
+                filterMode: this.lightmapParams.filterMode === 'Linear' ? THREE.LinearFilter : THREE.NearestFilter,
+                atlasOptions: {
+                    resolution: this.lightmapParams.resolution,
+                    padding: this.lightmapParams.padding,
+                    dilate: this.lightmapParams.dilate
+                }
+            }, (stage, progress, message) => {
+                this.updateStatus(`${stage}: ${progress.toFixed(1)}% - ${message ?? ''}`);
+            });
+            this.updateStatus('✓ Lightmaps baked successfully! Ready to export.');
+        }
+        catch (error) {
+            this.updateStatus(`✗ Lightmap baking failed: ${error}`);
+            console.error('Lightmap baking failed:', error);
+        }
+    }
+    removeLightmaps() {
+        this.lightmapManager.removeLightmaps();
+        // Light management is now handled automatically by LightmapManager.removeLightmaps()
+        this.updateStatus('Lightmaps removed. Dynamic lighting restored.');
+    }
+    /**
+     * Exports the current lightmaps to files
+     */
+    async exportLightmaps() {
+        try {
+            if (!this.lightmapManager.hasLightmapData()) {
+                this.updateStatus('No lightmap data to export. Bake lightmaps first.');
+                return;
+            }
+            this.updateStatus('Exporting lightmaps...');
+            // Get base filename from current scene path or use default
+            const baseFileName = this.currentScenePath ?
+                this.currentScenePath.initialPath.replace(/\.[^/.]+$/, '').replace(/^\/+/, '') :
+                'lightmap-demo';
+            // Get the lightmap data using the pure manager API
+            const result = await this.lightmapManager.exportLightmapData(baseFileName, {
+                includeSceneHash: this.lightmapParams.includeSceneHash,
+            });
+            // Handle file downloads in the demo
+            this.downloadBlob(result.textureBlob, result.textureFileName);
+            const metadataBlob = new Blob([result.metadataJson], { type: 'application/json' });
+            this.downloadBlob(metadataBlob, result.metadataFileName);
+            this.updateStatus(`✓ Lightmaps exported: ${result.metadataFileName} and ${result.textureFileName}`);
+        }
+        catch (error) {
+            this.updateStatus(`✗ Export failed: ${error}`);
+            console.error('Failed to export lightmaps:', error);
+        }
+    }
+    /**
+     * Exports lightmap data for custom handling (demonstrates the new exportLightmapData API)
+     */
+    async exportLightmapData() {
+        try {
+            if (!this.lightmapManager.hasLightmapData()) {
+                this.updateStatus('No lightmap data to export. Bake lightmaps first.');
+                return;
+            }
+            this.updateStatus('Exporting lightmap data for custom handling...');
+            // Get base filename from current scene path or use default
+            const baseFileName = this.currentScenePath ?
+                this.currentScenePath.initialPath.replace(/\.[^/.]+$/, '').replace(/^\/+/, '') :
+                'lightmap-demo';
+            // Use the new exportLightmapData method to get data instead of directly creating files
+            const result = await this.lightmapManager.exportLightmapData(baseFileName, {
+                includeSceneHash: this.lightmapParams.includeSceneHash,
+            });
+            // Demonstrate different ways to handle the data:
+            console.log('📦 Lightmap data exported for custom handling:');
+            console.log(`  Metadata size: ${(result.metadataJson.length / 1024).toFixed(2)} KB`);
+            console.log(`  Texture size: ${(result.textureBlob.size / 1024 / 1024).toFixed(2)} MB`);
+            console.log(`  Suggested filenames: ${result.metadataFileName}, ${result.textureFileName}`);
+            // Example 1: Save to browser's IndexedDB for offline use
+            await this.saveToIndexedDB(result);
+            // Example 2: Create downloadable files manually (same result as exportLightmap)
+            this.downloadLightmapData(result);
+            // Example 3: Send to a server (simulated)
+            await this.simulateServerUpload(result);
+            this.updateStatus('✓ Lightmap data exported with custom handling examples (check console for details)');
+        }
+        catch (error) {
+            this.updateStatus(`✗ Export data failed: ${error}`);
+            console.error('Failed to export lightmap data:', error);
+        }
+    }
+    /**
+     * Example: Save lightmap data to IndexedDB for offline use
+     */
+    async saveToIndexedDB(lightmapData) {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open('LightmapStorage', 1);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                const db = request.result;
+                const transaction = db.transaction(['lightmaps'], 'readwrite');
+                const store = transaction.objectStore('lightmaps');
+                const lightmapRecord = {
+                    id: Date.now(),
+                    metadata: lightmapData.metadataJson,
+                    texture: lightmapData.textureBlob,
+                    metadataFileName: lightmapData.metadataFileName,
+                    textureFileName: lightmapData.textureFileName,
+                    timestamp: new Date().toISOString()
+                };
+                store.add(lightmapRecord);
+                transaction.oncomplete = () => {
+                    console.log('💾 Lightmap data saved to IndexedDB for offline use');
+                    resolve();
+                };
+                transaction.onerror = () => reject(transaction.error);
+            };
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains('lightmaps')) {
+                    db.createObjectStore('lightmaps', { keyPath: 'id' });
+                }
+            };
+        });
+    }
+    /**
+     * Example: Manually create downloadable files from the data
+     */
+    downloadLightmapData(lightmapData) {
+        // Create metadata blob and download
+        const metadataBlob = new Blob([lightmapData.metadataJson], { type: 'application/json' });
+        this.downloadBlob(metadataBlob, lightmapData.metadataFileName);
+        // Download texture blob
+        this.downloadBlob(lightmapData.textureBlob, lightmapData.textureFileName);
+        console.log('📁 Lightmap files downloaded manually from data');
+    }
+    /**
+     * Helper method to download a blob as a file
+     */
+    downloadBlob(blob, filename) {
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        a.style.display = 'none';
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    }
+    /**
+     * Example: Simulate sending lightmap data to a server
+     */
+    async simulateServerUpload(lightmapData) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                console.log('🌐 Simulated server upload:');
+                console.log(`  Would POST metadata (${(lightmapData.metadataJson.length / 1024).toFixed(2)} KB) to /api/lightmaps/metadata`);
+                console.log(`  Would POST texture (${(lightmapData.textureBlob.size / 1024 / 1024).toFixed(2)} MB) to /api/lightmaps/texture`);
+                console.log('  Server could store these in cloud storage, database, etc.');
+                resolve();
+            }, 500); // Simulate network delay
+        });
+    }
+    /**
+     * Opens a file dialog to select lightmap files to import
+     */
+    openImportDialog() {
+        // Create file input element for lightmap files
+        const fileInput = document.createElement('input');
+        fileInput.type = 'file';
+        fileInput.accept = '.lightmap.json';
+        fileInput.multiple = false;
+        fileInput.style.display = 'none';
+        // Handle file selection
+        fileInput.addEventListener('change', (event) => {
+            const target = event.target;
+            const file = target.files?.[0];
+            if (file) {
+                this.importLightmapsFromFile(file);
+            }
+            // Clean up
+            document.body.removeChild(fileInput);
+        });
+        // Add to DOM and trigger click
+        document.body.appendChild(fileInput);
+        fileInput.click();
+    }
+    /**
+     * Imports lightmaps from a selected file
+     */
+    async importLightmapsFromFile(file) {
+        try {
+            this.updateStatus('📂 Loading lightmap file...');
+            // Read the lightmap JSON file
+            const lightmapText = await file.text();
+            const lightmapData = JSON.parse(lightmapText);
+            // Extract the binary filename from the lightmap data
+            const binaryFileName = lightmapData.lightmap?.textureFile;
+            if (!binaryFileName) {
+                throw new Error('Lightmap file does not contain texture file reference');
+            }
+            // Prompt user to select the binary file
+            this.updateStatus('📂 Please select the corresponding binary texture file...');
+            const binaryFile = await this.selectBinaryFile(binaryFileName);
+            if (!binaryFile) {
+                this.updateStatus('❌ Binary file selection cancelled');
+                return;
+            }
+            // Read binary file as ArrayBuffer
+            const textureData = await binaryFile.arrayBuffer();
+            // Import using the new API
+            await this.lightmapManager.importLightmap(lightmapData, textureData);
+            this.updateStatus('✓ Lightmaps imported successfully! (full precision preserved)');
+        }
+        catch (error) {
+            this.updateStatus(`✗ Import failed: ${error}`);
+            console.error('Failed to import lightmaps:', error);
+        }
+    }
+    /**
+     * Prompts user to select the binary texture file
+     */
+    async selectBinaryFile(expectedFileName) {
+        return new Promise((resolve) => {
+            const fileInput = document.createElement('input');
+            fileInput.type = 'file';
+            fileInput.accept = '.lightmap';
+            fileInput.style.display = 'none';
+            // Add instruction text
+            const instruction = document.createElement('div');
+            instruction.textContent = `Please select: ${expectedFileName}`;
+            instruction.style.cssText = 'position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%); background: white; padding: 20px; border: 2px solid #ccc; border-radius: 8px; z-index: 10000; font-family: Arial; box-shadow: 0 4px 8px rgba(0,0,0,0.2);';
+            fileInput.addEventListener('change', (event) => {
+                const target = event.target;
+                const file = target.files?.[0] ?? null;
+                // Clean up - remove event listener first
+                document.removeEventListener('click', handleCancel);
+                // Remove elements if they still exist
+                if (document.body.contains(fileInput)) {
+                    document.body.removeChild(fileInput);
+                }
+                if (document.body.contains(instruction)) {
+                    document.body.removeChild(instruction);
+                }
+                resolve(file);
+            });
+            // Cancel if user clicks outside
+            const handleCancel = (event) => {
+                if (event.target === instruction)
+                    return;
+                document.removeEventListener('click', handleCancel);
+                // Remove elements if they still exist
+                if (document.body.contains(fileInput)) {
+                    document.body.removeChild(fileInput);
+                }
+                if (document.body.contains(instruction)) {
+                    document.body.removeChild(instruction);
+                }
+                resolve(null);
+            };
+            setTimeout(() => {
+                document.addEventListener('click', handleCancel);
+            }, 100);
+            // Add to DOM and trigger click
+            document.body.appendChild(instruction);
+            document.body.appendChild(fileInput);
+            fileInput.click();
+        });
+    }
+    /**
+     * Updates the status display in the UI
+     */
+    updateStatus(message) {
+        const statusElement = this.statusElement;
+        if (statusElement) {
+            statusElement.innerHTML = `Status: ${message}`;
+        }
+    }
+    createDebugTextures() {
+        // Clear existing debug textures
+        this.clearDebugTextures();
+        if (!this.lightmapManager || !this.lightmapManager.hasLightmapData()) {
+            return;
+        }
+        // Get the baked lightmap texture
+        const lightmapTexture = this.lightmapManager.getLastBakedTexture();
+        if (lightmapTexture) {
+            this.createDebugTexture(lightmapTexture, new THREE.Vector3(-30, 10, 0), 'Final Lightmap');
+        }
+        // Try to get atlas textures from the baker if possible
+        const baker = this.lightmapManager.getBaker();
+        if (baker) {
+            const atlasResult = baker.getAtlasResult();
+            if (atlasResult?.positionTexture) {
+                this.createDebugTexture(atlasResult.positionTexture, new THREE.Vector3(-30, 30, 0), 'Position Atlas');
+            }
+            if (atlasResult?.normalTexture) {
+                this.createDebugTexture(atlasResult.normalTexture, new THREE.Vector3(-30, 50, 0), 'Normal Atlas');
+            }
+        }
+    }
+    createDebugTexture(texture, position, label) {
+        // Check if this is an HDR texture (FloatType) and needs special handling
+        const isHDR = texture.type === THREE.FloatType;
+        let material;
+        if (isHDR) {
+            // Use a custom shader material for HDR textures with tone mapping
+            material = new THREE.ShaderMaterial({
+                uniforms: {
+                    tDiffuse: { value: texture },
+                    exposure: { value: 1.0 }
+                },
+                vertexShader: `
+          varying vec2 vUv;
+          void main() {
+            vUv = uv;
+            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+          }
+        `,
+                fragmentShader: `
+          uniform sampler2D tDiffuse;
+          uniform float exposure;
+          varying vec2 vUv;
+          
+          // Simple tone mapping function
+          vec3 toneMap(vec3 color, float exposure) {
+            color *= exposure;
+            return color / (color + 1.0); // Reinhard tone mapping
+          }
+          
+          void main() {
+            vec4 texel = texture2D(tDiffuse, vUv);
+            vec3 color = toneMap(texel.rgb, exposure);
+            gl_FragColor = vec4(color, texel.a);
+          }
+        `,
+                side: THREE.DoubleSide
+            });
+        }
+        else {
+            material = new THREE.MeshBasicMaterial({
+                map: texture,
+                side: THREE.DoubleSide
+            });
+        }
+        const debugTexture = new THREE.Mesh(new THREE.PlaneGeometry(20, 20), material);
+        const debugActor = new ENGINE.Actor({
+            rootComponent: new ENGINE.MeshComponent({
+                mesh: debugTexture
+            })
+        });
+        debugActor.setWorldPosition(position);
+        this.world.addActors(debugActor);
+        this.debugTextureActors.push(debugActor);
+    }
+    clearDebugTextures() {
+        this.world.removeActors(...this.debugTextureActors);
+        this.debugTextureActors = [];
+    }
+    /**
+     * Stores original material maps before applying debug textures
+     */
+    storeOriginalMaterials() {
+        const actors = this.world.getActors();
+        for (const actor of actors) {
+            const meshes = this.getMeshesFromActor(actor);
+            for (const mesh of meshes) {
+                if (mesh.material) {
+                    const material = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+                    if (material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshLambertMaterial) {
+                        if (!this.originalMaterialMaps.has(material)) {
+                            this.originalMaterialMaps.set(material, material.map);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Creates a UV debug texture for visualization
+     */
+    createUVDebugTexture() {
+        const size = 512;
+        const canvas = document.createElement('canvas');
+        canvas.width = size;
+        canvas.height = size;
+        const ctx = canvas.getContext('2d');
+        // Create a UV grid pattern
+        ctx.fillStyle = '#000000';
+        ctx.fillRect(0, 0, size, size);
+        // Draw grid lines
+        ctx.strokeStyle = '#ffffff';
+        ctx.lineWidth = 2;
+        const gridSize = size / 8;
+        for (let i = 0; i <= 8; i++) {
+            const pos = i * gridSize;
+            // Vertical lines
+            ctx.beginPath();
+            ctx.moveTo(pos, 0);
+            ctx.lineTo(pos, size);
+            ctx.stroke();
+            // Horizontal lines
+            ctx.beginPath();
+            ctx.moveTo(0, pos);
+            ctx.lineTo(size, pos);
+            ctx.stroke();
+        }
+        // Add corner colors for UV orientation
+        ctx.fillStyle = '#ff0000'; // Red = (1,1)
+        ctx.fillRect(size - gridSize / 2, 0, gridSize / 2, gridSize / 2);
+        ctx.fillStyle = '#00ff00'; // Green = (0,1)
+        ctx.fillRect(0, 0, gridSize / 2, gridSize / 2);
+        ctx.fillStyle = '#0000ff'; // Blue = (0,0)
+        ctx.fillRect(0, size - gridSize / 2, gridSize / 2, gridSize / 2);
+        ctx.fillStyle = '#ffff00'; // Yellow = (1,0)
+        ctx.fillRect(size - gridSize / 2, size - gridSize / 2, gridSize / 2, gridSize / 2);
+        const texture = new THREE.CanvasTexture(canvas);
+        texture.flipY = false;
+        texture.wrapS = THREE.RepeatWrapping;
+        texture.wrapT = THREE.RepeatWrapping;
+        return texture;
+    }
+    /**
+     * Handles render mode changes to switch between different visualizations
+     */
+    onRenderModeChange() {
+        // Store original materials if not already done
+        this.storeOriginalMaterials();
+        const actors = this.world.getActors();
+        for (const actor of actors) {
+            const meshes = this.getMeshesFromActor(actor);
+            for (const mesh of meshes) {
+                if (mesh.material) {
+                    const material = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+                    if (material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshLambertMaterial) {
+                        // Reset material state
+                        material.map = null;
+                        material.lightMap = null;
+                        switch (this.lightmapParams.renderMode) {
+                            case 'standard':
+                                // Restore original textures and remove lightmap
+                                const originalMap = this.originalMaterialMaps.get(material);
+                                material.map = originalMap ?? null;
+                                material.lightMap = null;
+                                break;
+                            case 'positions':
+                                // Show position atlas texture
+                                if (this.lightmapManager && this.lightmapManager.getBaker()?.getAtlasResult()?.positionTexture) {
+                                    material.lightMap = this.lightmapManager.getBaker().getAtlasResult().positionTexture;
+                                    if (material.lightMap) {
+                                        material.lightMap.channel = 2;
+                                    }
+                                }
+                                break;
+                            case 'normals':
+                                // Show normal atlas texture
+                                if (this.lightmapManager && this.lightmapManager.getBaker()?.getAtlasResult()?.normalTexture) {
+                                    material.lightMap = this.lightmapManager.getBaker().getAtlasResult().normalTexture;
+                                    if (material.lightMap) {
+                                        material.lightMap.channel = 2;
+                                    }
+                                }
+                                break;
+                            case 'uv':
+                                // Show UV debug texture
+                                material.lightMap = this.createUVDebugTexture();
+                                material.lightMap.channel = 2;
+                                break;
+                            case 'lightmap':
+                                // Show lightmap only
+                                if (this.lightmapManager && this.lightmapManager.getLastBakedTexture()) {
+                                    material.lightMap = this.lightmapManager.getLastBakedTexture();
+                                    if (material.lightMap) {
+                                        material.lightMap.channel = 2;
+                                    }
+                                }
+                                break;
+                            case 'beauty':
+                                // Show lightmap + original textures
+                                const originalMapBeauty = this.originalMaterialMaps.get(material);
+                                material.map = originalMapBeauty ?? null;
+                                if (this.lightmapManager && this.lightmapManager.getLastBakedTexture()) {
+                                    material.lightMap = this.lightmapManager.getLastBakedTexture();
+                                    if (material.lightMap) {
+                                        material.lightMap.channel = 2;
+                                    }
+                                }
+                                break;
+                        }
+                        // Update material properties
+                        if (material.lightMap) {
+                            material.lightMap.needsUpdate = true;
+                            material.lightMap.channel = 2;
+                        }
+                        material.lightMapIntensity = 1.0;
+                        material.needsUpdate = true;
+                    }
+                }
+            }
+        }
+        // Manage runtime lighting based on render mode
+        if (this.lightmapParams.renderMode === 'standard') {
+            // Restore dynamic lighting
+            this.lightmapManager?.manageRuntimeLighting(false);
+        }
+        else {
+            // Hide runtime lights for debug modes
+            this.lightmapManager?.manageRuntimeLighting(true);
+        }
+        this.updateStatus(`Render mode: ${this.lightmapParams.renderMode}`);
+    }
+    /**
+     * Helper method to get meshes from an actor (reused logic)
+     */
+    getMeshesFromActor(actor) {
+        const meshes = [];
+        if (actor instanceof ENGINE.GLTFMeshActor) {
+            const gltfMesh = actor.rootComponent;
+            if (gltfMesh) {
+                meshes.push(...gltfMesh.getAllMeshes());
+            }
+        }
+        else {
+            const rootComponent = actor.rootComponent;
+            if (rootComponent instanceof ENGINE.MeshComponent) {
+                const mesh = rootComponent.getMesh();
+                if (mesh) {
+                    meshes.push(mesh);
+                }
+            }
+        }
+        return meshes;
+    }
+    destroy() {
+        // Clean up file input
+        if (this.fileInput) {
+            this.fileInput.remove();
+            this.fileInput = null;
+        }
+        // Clean up transform controls and light helpers
+        this.cleanupTransformControlsAndHelpers();
+        this.pane.dispose();
+        this.lightmapManager?.dispose();
+        super.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lightmapping-demo.js","sourceRoot":"","sources":["../../../games/deprecated/lightmapping-demo.ts"],"names":[],"mappings":"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"}