@directivegames/genesys.js 3.1.24

package/dist/games/postprocess-demo.js

@@ -0,0 +1,829 @@
+import * as dat from 'dat.gui';
+import * as ENGINE from 'genesys.js';
+import { ObjectOutlineEffect } from 'genesys.js';
+import * as THREE from 'three';
+/**
+ * PostprocessDemo - Demonstrates post-processing effects with sphere meshes loaded from world data
+ *
+ * Features:
+ * - World loading: Scene objects are loaded from serialized world data instead of direct creation
+ * - 1 GLTF sphere with material file loading from dev/materials and shaders folders
+ * - 1 primitive sphere with customizable material properties
+ * - 1 billboard sprite with texture loading capabilities
+ * - Material file system supporting various material types (PBR, shader-based, matcap)
+ * - Option to disable material override and use original GLB materials
+ * - GUI controls for toggling mesh visibility and material properties
+ * - Post-processing effects: Bloom, SMAA anti-aliasing, Tone mapping
+ * - Outline effects: PostProcess Outline (selection-based) and Edge Outline (shader-based)
+ * - Environment controls: skybox intensity and background blur
+ * - Error handling with fallback to direct object creation
+ * - Debug tools for inspecting actor and material states
+ */
+export class PostprocessDemo extends ENGINE.BaseGameLoop {
+    constructor(container) {
+        super(container);
+        Object.defineProperty(this, "gui", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "skyboxComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "gltfMesh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "primitiveMesh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "billboardActor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "groundActor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "damagedHelmet", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "shipWreck", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "currentMaterialFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: '@engine/assets/dev/materials/MetalGoldPaint.json'
+        });
+        Object.defineProperty(this, "pawn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "verticalMovement", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // -1 for down (Q), 1 for up (E), 0 for none
+        Object.defineProperty(this, "verticalSpeed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        }); // units per second
+        this.gui = new dat.GUI({ width: 400 });
+    }
+    async preStart() {
+        // Create default lighting and player
+        ENGINE.GameBuilder.createDefaultLighting(this.world, false);
+        this.groundActor = ENGINE.GameBuilder.createDefaultGround(this.world);
+        // Create skybox with HDR environment
+        this.skyboxComponent = ENGINE.GameBuilder.createDefaultSkybox(this.world, {
+            ...ENGINE.SkyboxComponent.DEFAULT_OPTIONS,
+            envMapIntensity: 1.2,
+        });
+        // Create player/camera
+        const { pawn } = ENGINE.GameBuilder.createDefaultPawn(this.world);
+        this.pawn = pawn;
+        pawn.rootComponent.setWorldPosition(ENGINE.MathHelpers.makeVector({ forward: -8, right: 0, up: 3 }));
+        // Increase camera movement speed
+        if (pawn.movementComponent instanceof ENGINE.CharacterMovementComponent) {
+            pawn.movementComponent.options.maxSpeed = 50; // Increased from default 5
+        }
+        // Setup E/Q vertical movement
+        this.setupVerticalMovement();
+        // Enable camera visibility layers to match editor behavior
+        this.world.postProcessManager.setUseCameraVisibilityLayers(true);
+        // Setup GUI controls (will be populated after world loading)
+        this.setupGUIControls();
+        // Load world data after a short delay to ensure world is fully initialized
+        setTimeout(() => {
+            this.createSceneObjects();
+        }, 100);
+    }
+    async createSceneObjects() {
+        this.createObjectsDirectly();
+    }
+    createObjectsDirectly() {
+        console.log('🏗️ Creating objects directly (fallback method)...');
+        const sphereHeight = 3; // Slightly higher to ensure visibility
+        // Create primitive sphere directly
+        this.primitiveMesh = new ENGINE.Actor({
+            name: 'primitiveSphere',
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.SphereGeometry(1.5, 32, 16),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x4a90e2,
+                    roughness: 0.1,
+                    metalness: 0.9,
+                    emissive: 0x001122,
+                    emissiveIntensity: 0.2
+                })
+            }),
+            position: new THREE.Vector3(4, sphereHeight, 0)
+        });
+        this.world.addActor(this.primitiveMesh);
+        // Create GLTF actor directly
+        this.gltfMesh = new ENGINE.Actor({
+            name: 'gltfMesh',
+            rootComponent: new ENGINE.GLTFMeshComponent({
+                modelUrl: '@engine/assets/models/SM_ChamferCube.glb',
+                scale: new THREE.Vector3(2, 2, 2)
+            }),
+            position: new THREE.Vector3(-2, sphereHeight, 0)
+        });
+        this.world.addActor(this.gltfMesh);
+        // Create billboard actor directly
+        this.billboardActor = new ENGINE.Actor({
+            name: 'billboardSprite',
+            rootComponent: new ENGINE.BillboardComponent({
+                imageUrl: '@engine/assets/dev/textures/T_Checker_01.png',
+                depthTest: true,
+                depthWrite: true,
+                transparent: true
+            }),
+            position: new THREE.Vector3(4, sphereHeight + 3, 0), // Above primitive sphere
+            scale: new THREE.Vector3(3, 3, 1) // Make it same size as sphere (radius 1.5 * 2 = 3)
+        });
+        this.world.addActor(this.billboardActor);
+        // Create damaged helmet actor directly
+        this.damagedHelmet = new ENGINE.Actor({
+            name: 'damagedHelmet',
+            rootComponent: new ENGINE.GLTFMeshComponent({
+                modelUrl: '@engine/assets/dev/models/DamagedHelmet.glb',
+                scale: new THREE.Vector3(1.5, 1.5, 1.5)
+            }),
+            position: new THREE.Vector3(0, sphereHeight + 1, -4)
+        });
+        this.world.addActor(this.damagedHelmet);
+        // Create ship wreck actor directly
+        this.shipWreck = new ENGINE.Actor({
+            name: 'shipWreck',
+            rootComponent: new ENGINE.GLTFMeshComponent({
+                modelUrl: '@engine/assets/models/demo/LowPoly/low_poly_ship_wreck.glb',
+                scale: new THREE.Vector3(1, 1, 1)
+            }),
+            position: new THREE.Vector3(-4, sphereHeight, 4)
+        });
+        this.world.addActor(this.shipWreck);
+        // Apply material to GLTF actor
+        this.applyMaterialToGLTFActor();
+        console.log('✅ Objects created directly at positions:');
+        console.log('🎯 Primitive sphere:', this.primitiveMesh.getWorldPosition());
+        console.log('🎯 GLTF mesh:', this.gltfMesh.getWorldPosition());
+        console.log('🎯 Billboard:', this.billboardActor.getWorldPosition());
+        console.log('🎯 Damaged Helmet:', this.damagedHelmet.getWorldPosition());
+        console.log('🎯 Ship Wreck:', this.shipWreck.getWorldPosition());
+    }
+    applyMaterialToGLTFActor() {
+        if (this.gltfMesh) {
+            const gltfComponent = this.gltfMesh.rootComponent;
+            console.log('🎨 Applying material to GLTF actor:', this.currentMaterialFile);
+            gltfComponent.setMaterial(this.currentMaterialFile);
+        }
+    }
+    setupGUIControls() {
+        // Mesh visibility controls
+        const meshSettings = {
+            showGLTFMesh: true,
+            showPrimitive: true,
+            showBillboard: true,
+            showDamagedHelmet: true,
+            showShipWreck: true,
+            showGround: true
+        };
+        const meshFolder = this.gui.addFolder('🎭 Mesh Controls');
+        meshFolder.open();
+        meshFolder.add(meshSettings, 'showGLTFMesh').name('Show GLTF (Material File)').onChange((value) => {
+            if (this.gltfMesh) {
+                this.gltfMesh.setHidden(!value);
+                console.log('🎭 GLTF Sphere visibility:', value);
+            }
+        });
+        meshFolder.add(meshSettings, 'showPrimitive').name('Show Primitive Sphere').onChange((value) => {
+            if (this.primitiveMesh) {
+                this.primitiveMesh.setHidden(!value);
+                console.log('🎭 Primitive sphere visibility:', value);
+            }
+        });
+        meshFolder.add(meshSettings, 'showBillboard').name('Show Billboard Sprite').onChange((value) => {
+            if (this.billboardActor) {
+                this.billboardActor.setHidden(!value);
+                console.log('🎭 Billboard sprite visibility:', value);
+            }
+        });
+        meshFolder.add(meshSettings, 'showDamagedHelmet').name('Show Damaged Helmet').onChange((value) => {
+            if (this.damagedHelmet) {
+                this.damagedHelmet.setHidden(!value);
+                console.log('🎭 Damaged Helmet visibility:', value);
+            }
+        });
+        meshFolder.add(meshSettings, 'showShipWreck').name('Show Ship Wreck').onChange((value) => {
+            if (this.shipWreck) {
+                this.shipWreck.setHidden(!value);
+                console.log('🎭 Ship Wreck visibility:', value);
+            }
+        });
+        meshFolder.add(meshSettings, 'showGround').name('Show Ground').onChange((value) => {
+            if (this.groundActor) {
+                this.groundActor.setHidden(!value);
+                console.log('🎭 Ground visibility:', value);
+            }
+        });
+        // Material controls
+        const materialSettings = {
+            materialFile: 'dev/materials/MetalGoldPaint.json',
+            billboardTexture: '@engine/assets/dev/textures/T_Checker_01.png',
+            primitiveColor: [74, 144, 226],
+            primitiveRoughness: 0.1,
+            primitiveMetalness: 0.9,
+            primitiveEmissiveIntensity: 0.2
+        };
+        const materialFolder = this.gui.addFolder('🎨 Material Controls');
+        materialFolder.open();
+        // Material file controls for GLTF Sphere
+        const materialFileFolder = materialFolder.addFolder('GLTF Sphere Material File');
+        materialFileFolder.open();
+        // Available material files from different folders
+        const availableMaterialFiles = [
+            // Dev materials (PBR with textures) - Vibrant and varied
+            'dev/materials/GroundSand005.json',
+            'dev/materials/MetalGoldPaint.json',
+            'dev/materials/TerrazzoSlab.json',
+            'dev/materials/MosaicPennyTiles.json',
+            'dev/materials/PoolTiles.json',
+            'dev/materials/CorrodedMetal.json',
+            'dev/materials/BoucleFabric.json',
+            // Shader materials (procedural/simple)
+            'shaders/M_Chrome.material.json',
+            'shaders/M_Emissive_Blue.material.json',
+            'shaders/M_Glossy_Grey.material.json',
+            'shaders/M_Matte_White.material.json',
+            'shaders/matcap/M_Matcap_Blue.material.json',
+            'shaders/matcap/M_Matcap_White.material.json',
+            // Option to disable material override
+            'None (Original GLB Material)'
+        ];
+        materialFileFolder.add(materialSettings, 'materialFile', availableMaterialFiles).name('Material File').onChange((value) => {
+            this.updateMaterialFile(value);
+        });
+        // Billboard texture controls
+        const billboardFolder = materialFolder.addFolder('Billboard Sprite Texture');
+        billboardFolder.open();
+        // Available texture files
+        const availableTextures = [
+            'Empty (No Texture)',
+            '@engine/assets/dev/textures/T_Checker_01.png',
+            'dev/T_Checker_02.png',
+            'dev/T_Grid_01.png',
+            'dev/T_Noise_01.png',
+            'dev/T_UV_Test.png',
+            'dev/T_White.png',
+            'dev/T_Black.png',
+            'dev/T_Red.png',
+            'dev/T_Green.png',
+            'dev/T_Blue.png',
+            'textures/grass.png',
+            'textures/rock.png',
+            'textures/sand.png',
+            'textures/snow.png'
+        ];
+        billboardFolder.add(materialSettings, 'billboardTexture', availableTextures).name('Texture').onChange((value) => {
+            this.updateBillboardTexture(value);
+        });
+        // Billboard size and material controls
+        const billboardSettings = {
+            size: 3.0,
+            depthTest: true,
+            depthWrite: true,
+            transparent: true
+        };
+        billboardFolder.add(billboardSettings, 'size', 0.5, 10.0, 0.1).name('Size').onChange((value) => {
+            if (this.billboardActor) {
+                this.billboardActor.setWorldScale(new THREE.Vector3(value, value, 1));
+                console.log('📏 Billboard size updated:', value);
+            }
+        });
+        billboardFolder.add(billboardSettings, 'depthTest').name('Depth Test').onChange((value) => {
+            if (this.billboardActor) {
+                const billboardComponent = this.billboardActor.rootComponent;
+                const spriteMaterial = billboardComponent.spriteMaterial;
+                if (spriteMaterial) {
+                    spriteMaterial.depthTest = value;
+                    spriteMaterial.needsUpdate = true;
+                    console.log('🔍 Billboard depth test:', value);
+                }
+            }
+        });
+        billboardFolder.add(billboardSettings, 'depthWrite').name('Depth Write').onChange((value) => {
+            if (this.billboardActor) {
+                const billboardComponent = this.billboardActor.rootComponent;
+                const spriteMaterial = billboardComponent.spriteMaterial;
+                if (spriteMaterial) {
+                    spriteMaterial.depthWrite = value;
+                    spriteMaterial.needsUpdate = true;
+                    console.log('✍️ Billboard depth write:', value);
+                }
+            }
+        });
+        billboardFolder.add(billboardSettings, 'transparent').name('Transparent').onChange((value) => {
+            if (this.billboardActor) {
+                const billboardComponent = this.billboardActor.rootComponent;
+                const spriteMaterial = billboardComponent.spriteMaterial;
+                if (spriteMaterial) {
+                    spriteMaterial.transparent = value;
+                    spriteMaterial.needsUpdate = true;
+                    console.log('👻 Billboard transparent:', value);
+                }
+            }
+        });
+        // Primitive material controls
+        const primitiveFolder = materialFolder.addFolder('Primitive Material');
+        primitiveFolder.open();
+        primitiveFolder.addColor(materialSettings, 'primitiveColor').name('Color').onChange((value) => {
+            if (this.primitiveMesh) {
+                try {
+                    const meshComponent = this.primitiveMesh.rootComponent;
+                    const mesh = meshComponent.getMesh();
+                    if (mesh && mesh.material instanceof THREE.MeshStandardMaterial) {
+                        mesh.material.color.setRGB(value[0] / 255, value[1] / 255, value[2] / 255);
+                        console.log('🎨 Updated primitive color:', value);
+                    }
+                    else {
+                        console.warn('⚠️ Primitive mesh material not found or wrong type');
+                    }
+                }
+                catch (error) {
+                    console.error('❌ Error updating primitive color:', error);
+                }
+            }
+        });
+        primitiveFolder.add(materialSettings, 'primitiveRoughness', 0, 1, 0.01).name('Roughness').onChange((value) => {
+            if (this.primitiveMesh) {
+                try {
+                    const meshComponent = this.primitiveMesh.rootComponent;
+                    const mesh = meshComponent.getMesh();
+                    if (mesh && mesh.material instanceof THREE.MeshStandardMaterial) {
+                        mesh.material.roughness = value;
+                        console.log('🎨 Updated primitive roughness:', value);
+                    }
+                    else {
+                        console.warn('⚠️ Primitive mesh material not found or wrong type');
+                    }
+                }
+                catch (error) {
+                    console.error('❌ Error updating primitive roughness:', error);
+                }
+            }
+        });
+        primitiveFolder.add(materialSettings, 'primitiveMetalness', 0, 1, 0.01).name('Metalness').onChange((value) => {
+            if (this.primitiveMesh) {
+                try {
+                    const meshComponent = this.primitiveMesh.rootComponent;
+                    const mesh = meshComponent.getMesh();
+                    if (mesh && mesh.material instanceof THREE.MeshStandardMaterial) {
+                        mesh.material.metalness = value;
+                        console.log('🎨 Updated primitive metalness:', value);
+                    }
+                    else {
+                        console.warn('⚠️ Primitive mesh material not found or wrong type');
+                    }
+                }
+                catch (error) {
+                    console.error('❌ Error updating primitive metalness:', error);
+                }
+            }
+        });
+        primitiveFolder.add(materialSettings, 'primitiveEmissiveIntensity', 0, 1, 0.01).name('Emissive Intensity').onChange((value) => {
+            if (this.primitiveMesh) {
+                try {
+                    const meshComponent = this.primitiveMesh.rootComponent;
+                    const mesh = meshComponent.getMesh();
+                    if (mesh && mesh.material instanceof THREE.MeshStandardMaterial) {
+                        mesh.material.emissiveIntensity = value;
+                        console.log('🎨 Updated primitive emissive intensity:', value);
+                    }
+                    else {
+                        console.warn('⚠️ Primitive mesh material not found or wrong type');
+                    }
+                }
+                catch (error) {
+                    console.error('❌ Error updating primitive emissive intensity:', error);
+                }
+            }
+        });
+        // Outline effects controls
+        this.setupOutlineControls();
+        // Postprocess controls
+        this.setupPostprocessControls();
+        // Add debug button to check current state
+        const debugFolder = this.gui.addFolder('🔍 Debug');
+        debugFolder.add({ checkState: () => this.debugCurrentState() }, 'checkState').name('Check Current State');
+    }
+    debugCurrentState() {
+        console.log('🔍 === DEBUG: Current State ===');
+        console.log('Actors:', {
+            gltfMesh: !!this.gltfMesh,
+            primitiveMesh: !!this.primitiveMesh,
+            billboardActor: !!this.billboardActor,
+            damagedHelmet: !!this.damagedHelmet,
+            shipWreck: !!this.shipWreck
+        });
+        console.log('Materials:', {
+            currentMaterialFile: this.currentMaterialFile
+        });
+        if (this.gltfMesh) {
+            const gltfComponent = this.gltfMesh.rootComponent;
+            const model = gltfComponent.getModel();
+            console.log('GLTF Mesh:', {
+                hasModel: !!model,
+                modelLoaded: gltfComponent.isModelLoaded()
+            });
+            if (model) {
+                model.traverse((child) => {
+                    if (child instanceof THREE.Mesh) {
+                        console.log('GLTF Mesh Material:', {
+                            name: child.name,
+                            materialType: child.material.constructor.name,
+                            isStandardMaterial: child.material instanceof THREE.MeshStandardMaterial,
+                            materialId: child.material.id
+                        });
+                    }
+                });
+            }
+        }
+        if (this.primitiveMesh) {
+            const meshComponent = this.primitiveMesh.rootComponent;
+            const mesh = meshComponent.getMesh();
+            if (mesh && mesh.material instanceof THREE.MeshStandardMaterial) {
+                console.log('Primitive Material Properties:', {
+                    color: mesh.material.color.getHex(),
+                    roughness: mesh.material.roughness,
+                    metalness: mesh.material.metalness,
+                    emissiveIntensity: mesh.material.emissiveIntensity
+                });
+            }
+        }
+        if (this.billboardActor) {
+            const billboardComponent = this.billboardActor.rootComponent;
+            console.log('Billboard Component:', {
+                componentType: billboardComponent.constructor.name,
+                hasSprite: !!billboardComponent.sprite,
+                position: this.billboardActor.getWorldPosition()
+            });
+        }
+        console.log('🔍 === END DEBUG ===');
+    }
+    setupOutlineControls() {
+        const outlineSettings = {
+            // outlineType: 'None',
+            outlineType: 'PostProcess Outline',
+            // PostProcess outline settings
+            postprocessEdgeThickeness: 1,
+            postprocessEdgeIntensity: 100,
+            postprocessVisibleEdgeColor: [255, 255, 255],
+            // Edge outline settings
+            edgeThickness: 5,
+            edgeColor: [255, 255, 255],
+            edgeAlpha: 1.0
+        };
+        const outlineFolder = this.gui.addFolder('🔲 Outline Effects');
+        outlineFolder.open();
+        // Outline type selector
+        const outlineTypes = ['None', 'PostProcess Outline', 'Edge Outline'];
+        outlineFolder.add(outlineSettings, 'outlineType', outlineTypes).name('Outline Type').onChange((value) => {
+            const postProcessManager = this.world.postProcessManager;
+            // Disable all outline types first and clear selections
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.ObjectOutline, { enabled: false });
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.EdgeOutline, { enabled: false });
+            // Clear both outline selections
+            const outlineEffect = postProcessManager.getEffectFromPass(ENGINE.PostProcessPass.ObjectOutline, ObjectOutlineEffect);
+            if (outlineEffect) {
+                outlineEffect.selection.clear();
+            }
+            postProcessManager.getEdgeOutlineEffect()?.clearSelection();
+            // Enable the selected type and add all objects
+            if (value === 'PostProcess Outline') {
+                postProcessManager.configureEffect(ENGINE.PostProcessPass.ObjectOutline, { enabled: true });
+                if (outlineEffect) {
+                    const actors = [this.gltfMesh, this.primitiveMesh, this.billboardActor, this.damagedHelmet, this.shipWreck, this.groundActor].filter((a) => a !== null);
+                    outlineEffect.addSelectedActors(actors);
+                }
+                console.log('🔲 PostProcess Outline enabled with all objects.');
+            }
+            else if (value === 'Edge Outline') {
+                postProcessManager.configureEffect(ENGINE.PostProcessPass.EdgeOutline, {
+                    enabled: true,
+                    thickness: outlineSettings.edgeThickness,
+                    color: (outlineSettings.edgeColor[0] << 16) | (outlineSettings.edgeColor[1] << 8) | outlineSettings.edgeColor[2],
+                    alpha: outlineSettings.edgeAlpha
+                });
+                // Add all objects to Edge Outline
+                const actors = [this.gltfMesh, this.primitiveMesh, this.billboardActor, this.damagedHelmet, this.shipWreck, this.groundActor].filter((a) => a !== null);
+                if (actors.length > 0) {
+                    postProcessManager.getEdgeOutlineEffect()?.addSelectedActors(actors);
+                }
+                console.log('🔲 Edge Outline enabled with all objects.');
+            }
+            else {
+                console.log('🔲 All outlines disabled.');
+            }
+        });
+        // PostProcess Outline Settings
+        const postProcessFolder = outlineFolder.addFolder('PostProcess Outline Settings');
+        postProcessFolder.open();
+        postProcessFolder.add(outlineSettings, 'postprocessEdgeThickeness', 0, 10, 0.01).name('Edge Thickness').onChange((value) => {
+            this.world.postProcessManager.configureEffect(ENGINE.PostProcessPass.ObjectOutline, { edgeThickness: value });
+        });
+        postProcessFolder.add(outlineSettings, 'postprocessEdgeIntensity', 0, 200, 1).name('Edge Intensity').onChange((value) => {
+            this.world.postProcessManager.configureEffect(ENGINE.PostProcessPass.ObjectOutline, { edgeIntensity: value });
+        });
+        postProcessFolder.addColor(outlineSettings, 'postprocessVisibleEdgeColor').name('Visible Edge Color').onChange((value) => {
+            const color = (value[0] << 16) | (value[1] << 8) | value[2];
+            this.world.postProcessManager.configureEffect(ENGINE.PostProcessPass.ObjectOutline, { visibleEdgeColor: color });
+        });
+        // Edge Outline Settings
+        const edgeFolder = outlineFolder.addFolder('Edge Outline Settings');
+        edgeFolder.open();
+        edgeFolder.add(outlineSettings, 'edgeThickness', 0, 10, 0.1).name('Thickness').onChange((value) => {
+            this.world.postProcessManager.configureEffect(ENGINE.PostProcessPass.EdgeOutline, { thickness: value });
+            console.log('🔲 Edge outline thickness updated:', value);
+        });
+        edgeFolder.addColor(outlineSettings, 'edgeColor').name('Color').onChange((value) => {
+            const color = (value[0] << 16) | (value[1] << 8) | value[2];
+            this.world.postProcessManager.configureEffect(ENGINE.PostProcessPass.EdgeOutline, { color });
+            console.log('🔲 Edge outline color updated:', value);
+        });
+        edgeFolder.add(outlineSettings, 'edgeAlpha', 0, 1, 0.01).name('Alpha').onChange((value) => {
+            this.world.postProcessManager.configureEffect(ENGINE.PostProcessPass.EdgeOutline, { alpha: value });
+            console.log('🔲 Edge outline alpha updated:', value);
+        });
+        console.log('🔲 Outline controls initialized!');
+        // Apply initial outline type after a short delay to ensure PostProcessManager is ready
+        setTimeout(() => {
+            if (outlineSettings.outlineType !== 'None') {
+                const postProcessManager = this.world.postProcessManager;
+                const outlineEffect = postProcessManager.getEffectFromPass(ENGINE.PostProcessPass.ObjectOutline, ObjectOutlineEffect);
+                if (outlineSettings.outlineType === 'PostProcess Outline') {
+                    postProcessManager.configureEffect(ENGINE.PostProcessPass.ObjectOutline, { enabled: true });
+                    // Add all objects to PostProcess outline
+                    if (outlineEffect && this.gltfMesh && this.primitiveMesh && this.billboardActor && this.damagedHelmet && this.shipWreck && this.groundActor) {
+                        outlineEffect.addSelectedActor(this.gltfMesh);
+                        outlineEffect.addSelectedActor(this.primitiveMesh);
+                        outlineEffect.addSelectedActor(this.billboardActor);
+                        outlineEffect.addSelectedActor(this.damagedHelmet);
+                        outlineEffect.addSelectedActor(this.shipWreck);
+                        outlineEffect.addSelectedActor(this.groundActor);
+                    }
+                    console.log('🔲 Initial PostProcess Outline enabled with all objects.');
+                }
+                else if (outlineSettings.outlineType === 'Edge Outline') {
+                    postProcessManager.configureEffect(ENGINE.PostProcessPass.EdgeOutline, {
+                        enabled: true,
+                        thickness: outlineSettings.edgeThickness,
+                        color: (outlineSettings.edgeColor[0] << 16) | (outlineSettings.edgeColor[1] << 8) | outlineSettings.edgeColor[2],
+                        alpha: outlineSettings.edgeAlpha
+                    });
+                    // Add all objects to Edge Outline
+                    const actors = [this.gltfMesh, this.primitiveMesh, this.billboardActor, this.damagedHelmet, this.shipWreck, this.groundActor].filter((a) => a !== null);
+                    if (actors.length > 0) {
+                        postProcessManager.getEdgeOutlineEffect()?.addSelectedActors(actors);
+                    }
+                    console.log('🔲 Initial Edge Outline enabled with all objects.');
+                }
+            }
+        }, 1000); // Small delay to ensure PostProcessManager is fully initialized
+    }
+    setupPostprocessControls() {
+        const postProcessManager = this.world.postProcessManager;
+        // Get current configurations
+        const bloomConfig = postProcessManager.getEffectConfig(ENGINE.PostProcessPass.Bloom);
+        const smaaConfig = postProcessManager.getEffectConfig(ENGINE.PostProcessPass.SMAA);
+        const toneMappingConfig = postProcessManager.getEffectConfig(ENGINE.PostProcessPass.ToneMapping);
+        const postProcessSettings = {
+            // Master toggle
+            enablePostProcessing: postProcessManager.getPostProcessingEnabled(),
+            // Bloom settings
+            enableBloom: bloomConfig?.enabled ?? false,
+            bloomIntensity: bloomConfig?.intensity ?? 2.0,
+            bloomThreshold: bloomConfig?.luminanceThreshold ?? 1.0,
+            bloomSmoothing: bloomConfig?.luminanceSmoothing ?? 0.2,
+            bloomRadius: bloomConfig?.radius ?? 0.85,
+            bloomLevels: bloomConfig?.levels ?? 8,
+            // Anti-aliasing settings
+            enableSMAA: smaaConfig?.enabled ?? false,
+            // Tone mapping settings
+            enableToneMapping: toneMappingConfig?.enabled ?? true,
+            toneMappingExposure: toneMappingConfig?.exposure ?? 0.25
+        };
+        const postProcessFolder = this.gui.addFolder('✨ Post-Processing Effects');
+        postProcessFolder.open();
+        // Master toggle for all post-processing
+        postProcessFolder.add(postProcessSettings, 'enablePostProcessing').name('🎛️ Enable Post-Processing').onChange((value) => {
+            postProcessManager.setPostProcessingEnabled(value);
+            console.log('🎛️ Post-processing enabled:', value);
+        });
+        // Bloom controls
+        const bloomFolder = postProcessFolder.addFolder('🌟 Bloom Effect');
+        bloomFolder.open();
+        bloomFolder.add(postProcessSettings, 'enableBloom').name('Enable Bloom').onChange((value) => {
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.Bloom, { enabled: value });
+            console.log('🌟 Bloom enabled:', value);
+        });
+        bloomFolder.add(postProcessSettings, 'bloomIntensity', 0.0, 10.0, 0.1).name('Intensity').onChange((value) => {
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.Bloom, { intensity: value });
+        });
+        bloomFolder.add(postProcessSettings, 'bloomThreshold', 0.0, 2.0, 0.01).name('Threshold').onChange((value) => {
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.Bloom, { luminanceThreshold: value });
+        });
+        bloomFolder.add(postProcessSettings, 'bloomSmoothing', 0.0, 1.0, 0.01).name('Smoothing').onChange((value) => {
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.Bloom, { luminanceSmoothing: value });
+        });
+        bloomFolder.add(postProcessSettings, 'bloomRadius', 0.0, 1.0, 0.01).name('Radius').onChange((value) => {
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.Bloom, { radius: value });
+        });
+        bloomFolder.add(postProcessSettings, 'bloomLevels', 1, 9, 1).name('Levels').onChange((value) => {
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.Bloom, { levels: value });
+        });
+        // Anti-aliasing controls
+        postProcessFolder.add(postProcessSettings, 'enableSMAA').name('🔧 Enable SMAA Anti-aliasing').onChange((value) => {
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.SMAA, { enabled: value });
+            console.log('🔧 SMAA enabled:', value);
+        });
+        // Tone mapping controls
+        const toneMappingFolder = postProcessFolder.addFolder('🎞️ Tone Mapping');
+        toneMappingFolder.open();
+        toneMappingFolder.add(postProcessSettings, 'enableToneMapping').name('Enable Tone Mapping').onChange((value) => {
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.ToneMapping, { enabled: value });
+            console.log('🎞️ Tone mapping enabled:', value);
+        });
+        const toneMappingModes = {
+            'Linear': ENGINE.ToneMappingMode.LINEAR,
+            'Reinhard': ENGINE.ToneMappingMode.REINHARD,
+            'Reinhard2': ENGINE.ToneMappingMode.REINHARD2,
+            'Reinhard2 Adaptive': ENGINE.ToneMappingMode.REINHARD2_ADAPTIVE,
+            'Uncharted2': ENGINE.ToneMappingMode.UNCHARTED2,
+            'Cineon': ENGINE.ToneMappingMode.CINEON,
+            'ACES Filmic': ENGINE.ToneMappingMode.ACES_FILMIC,
+            'AGX': ENGINE.ToneMappingMode.AGX,
+            'Neutral': ENGINE.ToneMappingMode.NEUTRAL,
+        };
+        const toneMappingModeSettings = { mode: 'Linear' };
+        toneMappingFolder.add(toneMappingModeSettings, 'mode', Object.keys(toneMappingModes)).name('Mode').onChange((value) => {
+            const mode = toneMappingModes[value];
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.ToneMapping, { mode });
+            console.log('🎞️ Tone mapping mode:', value, mode);
+        });
+        toneMappingFolder.add(postProcessSettings, 'toneMappingExposure', 0.1, 3.0, 0.05).name('Exposure').onChange((value) => {
+            postProcessManager.configureEffect(ENGINE.PostProcessPass.ToneMapping, { exposure: value });
+        });
+        // Environment controls
+        const envSettings = {
+            envMapIntensity: 1,
+            backgroundBlurriness: 0.0
+        };
+        const envFolder = this.gui.addFolder('🌍 Environment');
+        envFolder.open();
+        envFolder.add(envSettings, 'envMapIntensity', 0.0, 3.0, 0.1).name('Environment Intensity').onChange((value) => {
+            if (this.skyboxComponent) {
+                // Update skybox environment intensity by recreating the skybox with new intensity
+                const currentOptions = this.skyboxComponent.options;
+                if ('textureUrl' in currentOptions) {
+                    this.skyboxComponent.createTextureSkybox({
+                        ...currentOptions,
+                        envMapIntensity: value
+                    });
+                }
+                else {
+                    this.skyboxComponent.createProceduralSkybox({
+                        ...currentOptions,
+                        envMapIntensity: value
+                    });
+                }
+            }
+        });
+        envFolder.add(envSettings, 'backgroundBlurriness', 0.0, 1.0, 0.01).name('Background Blur').onChange((value) => {
+            this.world.scene.backgroundBlurriness = value;
+        });
+        console.log('✨ Post-processing controls initialized!');
+    }
+    async updateMaterialFile(materialFileName) {
+        console.log('🎨 Updating material file to:', materialFileName);
+        if (this.gltfMesh) {
+            const gltfComponent = this.gltfMesh.rootComponent;
+            try {
+                // Handle "None" option to use original GLB materials
+                if (materialFileName === 'None (Original GLB Material)') {
+                    // Reset to original GLB materials by setting material to empty string
+                    gltfComponent.setMaterial('');
+                    this.currentMaterialFile = '';
+                    console.log('✅ Reset to original GLB materials');
+                    return;
+                }
+                // Build the full material path
+                const materialPath = `/assets/${materialFileName}`;
+                this.currentMaterialFile = materialPath;
+                // Load the new material via ResourceManager
+                const newMaterial = await ENGINE.resourceManager.loadGenericMaterial(materialPath);
+                if (newMaterial) {
+                    // Apply the material to the GLTF component
+                    gltfComponent.setMaterial(newMaterial);
+                    console.log('✅ Material file updated successfully:', materialFileName);
+                }
+                else {
+                    console.error('❌ Failed to load material file:', materialFileName);
+                }
+            }
+            catch (error) {
+                console.error('❌ Error loading material file:', error);
+            }
+        }
+    }
+    async updateBillboardTexture(textureFileName) {
+        console.log('🖼️ Updating billboard texture to:', textureFileName);
+        if (this.billboardActor) {
+            const billboardComponent = this.billboardActor.rootComponent;
+            try {
+                // Handle "Empty" option to remove texture
+                if (textureFileName === 'Empty (No Texture)') {
+                    await billboardComponent.loadSprite('');
+                    console.log('✅ Billboard texture cleared');
+                    return;
+                }
+                // Build the full texture path
+                const texturePath = `/assets/${textureFileName}`;
+                // Load the new texture
+                await billboardComponent.loadSprite(texturePath);
+                console.log('✅ Billboard texture updated successfully:', textureFileName);
+            }
+            catch (error) {
+                console.error('❌ Error loading billboard texture:', error);
+            }
+        }
+    }
+    setupVerticalMovement() {
+        if (!this.pawn)
+            return;
+        // Intercept E/Q keys before PlayerController handles them
+        this.pawn.onKeyDown.add((e) => {
+            const key = e.key.toLowerCase();
+            if (key === 'e') {
+                this.verticalMovement = 1; // Move up
+                return true; // Handled
+            }
+            else if (key === 'q') {
+                this.verticalMovement = -1; // Move down
+                return true; // Handled
+            }
+            return false;
+        });
+        this.pawn.onKeyUp.add((e) => {
+            const key = e.key.toLowerCase();
+            if (key === 'e' || key === 'q') {
+                this.verticalMovement = 0;
+                return true; // Handled
+            }
+            return false;
+        });
+    }
+    tick(tickTime) {
+        // Apply vertical movement
+        if (this.pawn && this.verticalMovement !== 0) {
+            const deltaTime = tickTime.deltaTimeMS / 1000;
+            const verticalDelta = new THREE.Vector3(0, this.verticalMovement * this.verticalSpeed * deltaTime, 0);
+            this.pawn.rootComponent.addWorldPosition(verticalDelta);
+        }
+        // Tick the world first
+        this.world.tick(tickTime.deltaTimeMS / 1000);
+        // Render the world (PostProcessManager handles all effects including EdgeOutline)
+        this.renderer.render(this.world);
+    }
+    destroy() {
+        this.gui.destroy();
+        super.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"postprocess-demo.js","sourceRoot":"","sources":["../../games/postprocess-demo.ts"],"names":[],"mappings":"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"}