@directivegames/genesys.js 3.1.24

package/dist/src/render/PostProcessManager.js

@@ -0,0 +1,932 @@
+import { BlendFunction, EffectComposer, RenderPass, SelectiveBloomEffect, SMAAEffect, SMAAPreset, ToneMappingEffect, ToneMappingMode } from 'postprocessing';
+import * as THREE from 'three';
+// Re-export for convenience
+export { ToneMappingMode, SMAAPreset };
+import { SceneComponent } from '../components/SceneComponent.js';
+import { EdgeOutlineEffect } from './EdgeOutlineEffect.js';
+import { EffectPassWrapper } from './postprocessing/EffectPassWrapper.js';
+import { ObjectOutlineEffect } from './postprocessing/ObjectOutlineEffect.js';
+export var PostProcessPass;
+(function (PostProcessPass) {
+    PostProcessPass["ObjectOutline"] = "objectOutline";
+    PostProcessPass["EdgeOutline"] = "edgeOutline";
+    PostProcessPass["Bloom"] = "bloom";
+    PostProcessPass["SMAA"] = "smaa";
+    PostProcessPass["ToneMapping"] = "toneMapping";
+})(PostProcessPass || (PostProcessPass = {}));
+// Default configurations for each effect type
+export const DEFAULT_CONFIGS = {
+    [PostProcessPass.ObjectOutline]: {
+        enabled: false,
+        type: PostProcessPass.ObjectOutline,
+        edgeThickness: 1.0,
+        edgeIntensity: 100.0, // High value needed to compensate for tone mapping
+        visibleEdgeColor: 0xffffff,
+    },
+    [PostProcessPass.EdgeOutline]: {
+        enabled: false,
+        type: PostProcessPass.EdgeOutline,
+        thickness: 0.05,
+        color: 0xffffff,
+        alpha: 1.0,
+    },
+    [PostProcessPass.Bloom]: {
+        enabled: false,
+        type: PostProcessPass.Bloom,
+        intensity: 2.0,
+        luminanceThreshold: 1,
+        luminanceSmoothing: 0.2,
+        mipmapBlur: true,
+        radius: 0.85,
+        levels: 8,
+        ignoreBackground: true,
+    },
+    [PostProcessPass.SMAA]: {
+        enabled: false,
+        type: PostProcessPass.SMAA,
+        preset: SMAAPreset.HIGH,
+    },
+    [PostProcessPass.ToneMapping]: {
+        enabled: true,
+        type: PostProcessPass.ToneMapping,
+        mode: ToneMappingMode.LINEAR,
+        exposure: 0.25,
+        resolution: 256,
+        whitePoint: 4.0,
+        middleGrey: 0.6,
+        minLuminance: 0.01,
+        averageLuminance: 1.0,
+        adaptationRate: 1.0,
+    },
+};
+/**
+ * PostProcessManager handles post-processing effects for rendering.
+ *
+ * Provides methods to configure various post-processing effects like bloom, tone mapping,
+ * SMAA anti-aliasing, and outline effects. Supports both complete configuration replacement
+ * and incremental updates. Also allows globally enabling/disabling all post-processing.
+ *
+ * @example
+ * ```typescript
+ * // Basic setup with bloom and tone mapping
+ * const config: PostProcessConfiguration = {
+ *   effects: [
+ *     {
+ *       type: PostProcessPass.Bloom,
+ *       enabled: true,
+ *       intensity: 1.5,
+ *       luminanceThreshold: 0.4
+ *     },
+ *     {
+ *       type: PostProcessPass.ToneMapping,
+ *       enabled: true,
+ *       mode: ToneMappingMode.ACES_FILMIC,
+ *       exposure: 1.2
+ *     }
+ *   ]
+ * };
+ *
+ * // Set complete configuration (resets to defaults first)
+ * postProcessManager.setConfiguration(config);
+ *
+ * // Update specific effects (merges with current)
+ * postProcessManager.updateConfiguration({
+ *   effects: [
+ *     { type: PostProcessPass.Bloom, intensity: 2.0 }
+ *   ]
+ * });
+ *
+ * // Configure individual effects
+ * postProcessManager.configureEffect(PostProcessPass.Bloom, {
+ *   enabled: true,
+ *   intensity: 1.8,
+ *   luminanceThreshold: 0.3
+ * });
+ *
+ * // Enable/disable passes
+ * postProcessManager.enablePasses(PostProcessPass.Bloom, PostProcessPass.SMAA);
+ * postProcessManager.disablePasses(PostProcessPass.ObjectOutline);
+ *
+ * // Globally enable/disable all post-processing
+ * postProcessManager.setPostProcessingEnabled(false); // Disables all post-processing
+ * postProcessManager.setPostProcessingEnabled(true);  // Re-enables post-processing
+ *
+ * // Get current configuration
+ * const currentConfig = postProcessManager.getAllConfigurations();
+ * ```
+ *
+ * ## Method Differences
+ *
+ * ### setConfiguration()
+ * - Resets to DEFAULT_CONFIG first
+ * - Then applies provided configuration
+ * - Result: Clean slate with only specified effects
+ * - **Use case**: Loading saved worlds, switching presets
+ *
+ * ### updateConfiguration()
+ * - Merges with current configuration
+ * - Preserves existing effects
+ * - Updates/adds only specified effects
+ * - **Use case**: Settings panels, gameplay adjustments
+ *
+ * ### configure()
+ * - Same as updateConfiguration()
+ * - Kept for backward compatibility
+ *
+ * ## Usage Examples
+ *
+ * ```typescript
+ * // Loading a saved world (complete replacement with defaults as base)
+ * postProcessManager.setConfiguration(savedConfig);
+ *
+ * // Player toggles bloom in settings (incremental update)
+ * postProcessManager.updateConfiguration({
+ *   effects: [{ type: PostProcessPass.Bloom, enabled: !bloomEnabled }]
+ * });
+ *
+ * // Switching to cinematic preset (complete replacement)
+ * postProcessManager.setConfiguration(cinematicPreset);
+ *
+ * // Adjusting exposure during gameplay (incremental update)
+ * postProcessManager.updateConfiguration({
+ *   effects: [{ type: PostProcessPass.ToneMapping, exposure: newExposure }]
+ * });
+ *
+ * // Fine-tuning individual effect properties
+ * postProcessManager.configureEffect(PostProcessPass.Bloom, {
+ *   intensity: 1.2,
+ *   luminanceThreshold: 0.5,
+ *   radius: 0.9
+ * });
+ * ```
+ */
+export class PostProcessManager {
+    constructor(config) {
+        Object.defineProperty(this, "lastRenderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lastScene", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lastCamera", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lastWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "composer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "effects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "useCameraVisibilityLayers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "configuration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "effectsInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "postProcessingEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "hiddenObjects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "edgeOutlineEffect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "renderPass", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "hasCompletedFirstRender", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "layerFilteredObjects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "layersDirty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "tempHiddenObjects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "cameraLayersMask", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "edgeOutlineEnabledCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "cachedHasAnyEnabledPasses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "boundOriginalRender", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "depthPrepassMaterial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.initializeDefaults(config);
+    }
+    initializeDefaults(config) {
+        for (const [passType, defaultConfig] of Object.entries(DEFAULT_CONFIGS)) {
+            let finalConfig = { ...defaultConfig };
+            // If user provided config, find and merge the matching effect config
+            if (config?.effects) {
+                const userConfig = config.effects.find(effect => effect.type === passType);
+                if (userConfig) {
+                    finalConfig = { ...defaultConfig, ...userConfig };
+                }
+            }
+            this.configuration.set(passType, finalConfig);
+        }
+    }
+    /** Apply tone mapping exposure to renderer */
+    applyToneMappingExposure() {
+        const toneMappingConfig = this.configuration.get(PostProcessPass.ToneMapping);
+        if (toneMappingConfig?.exposure !== undefined && this.lastRenderer) {
+            this.lastRenderer.toneMappingExposure = toneMappingConfig.exposure;
+        }
+    }
+    /** Apply tone mapping mode and exposure to renderer (used when post-processing is disabled) */
+    applyToneMappingToRenderer() {
+        if (!this.lastRenderer)
+            return;
+        const toneMappingConfig = this.configuration.get(PostProcessPass.ToneMapping);
+        // If tone mapping is disabled, use NoToneMapping
+        if (!toneMappingConfig?.enabled) {
+            this.lastRenderer.toneMapping = THREE.NoToneMapping;
+            return;
+        }
+        // Map ToneMappingMode to THREE.ToneMapping
+        const mode = toneMappingConfig.mode ?? DEFAULT_CONFIGS[PostProcessPass.ToneMapping].mode;
+        const modeMap = {
+            [ToneMappingMode.LINEAR]: THREE.LinearToneMapping,
+            [ToneMappingMode.REINHARD]: THREE.ReinhardToneMapping,
+            [ToneMappingMode.CINEON]: THREE.CineonToneMapping,
+            [ToneMappingMode.ACES_FILMIC]: THREE.ACESFilmicToneMapping,
+            [ToneMappingMode.AGX]: THREE.AgXToneMapping,
+            [ToneMappingMode.NEUTRAL]: THREE.NeutralToneMapping,
+            // Note: Custom modes like REINHARD2, REINHARD2_ADAPTIVE, UNCHARTED2 are not supported by THREE.js
+            // They fall back to LINEAR
+            [ToneMappingMode.REINHARD2]: THREE.LinearToneMapping,
+            [ToneMappingMode.REINHARD2_ADAPTIVE]: THREE.LinearToneMapping,
+            [ToneMappingMode.UNCHARTED2]: THREE.LinearToneMapping,
+            [ToneMappingMode.OPTIMIZED_CINEON]: THREE.CineonToneMapping,
+        };
+        this.lastRenderer.toneMapping = modeMap[mode] ?? THREE.LinearToneMapping;
+        this.lastRenderer.toneMappingExposure = toneMappingConfig.exposure ?? DEFAULT_CONFIGS[PostProcessPass.ToneMapping].exposure;
+    }
+    /** Configure specific effect settings */
+    configureEffect(passType, config) {
+        const currentConfig = this.configuration.get(passType);
+        if (!currentConfig) {
+            console.warn(`Effect ${passType} not found`);
+            return;
+        }
+        // Merge with current configuration
+        const updatedConfig = { ...currentConfig, ...config };
+        this.configuration.set(passType, updatedConfig);
+        // Update cached enabled states
+        this.updateEnabledStatesCache();
+        // If we have effects initialized, update the specific effect and sync
+        if (this.effectsInitialized) {
+            this.updateEffectConfig(passType);
+            this.syncPassEnabled();
+            // Apply tone mapping exposure if this is a tone mapping config change
+            if (passType === PostProcessPass.ToneMapping) {
+                this.applyToneMappingExposure();
+            }
+            // Recreate EdgeOutline effect if config changed
+            if (passType === PostProcessPass.EdgeOutline) {
+                this.initializeEdgeOutline();
+            }
+        }
+    }
+    /** Get current configuration for an effect */
+    getEffectConfig(passType) {
+        return this.configuration.get(passType) ?? null;
+    }
+    /** Set multiple effect configurations at once */
+    configure(config) {
+        for (const effectConfig of config.effects) {
+            this.configureEffect(effectConfig.type, effectConfig);
+        }
+    }
+    /** Set post-processing configuration (merges with defaults) */
+    setConfiguration(config) {
+        // Reset to defaults first
+        this.initializeDefaults();
+        // Then apply the provided config
+        this.configure(config);
+    }
+    /** Update post-processing configuration (merges with current) */
+    updateConfiguration(config) {
+        this.configure(config);
+    }
+    /** Get all current configurations */
+    getAllConfigurations() {
+        return {
+            effects: Array.from(this.configuration.values())
+        };
+    }
+    renderScene(renderer, scene, camera, windowSize) {
+        this.lastWindowSize ??= windowSize;
+        const rendererChanged = this.lastRenderer !== renderer;
+        const sceneChanged = this.lastScene !== scene;
+        const cameraChanged = this.lastCamera !== camera;
+        if (rendererChanged || sceneChanged || cameraChanged) {
+            this.lastCamera = camera;
+            this.lastScene = scene;
+            this.lastRenderer = renderer;
+            // Mark layers dirty on camera or scene change
+            if (sceneChanged || cameraChanged) {
+                this.layersDirty = true;
+            }
+            if (rendererChanged) {
+                if (this.effectsInitialized && this.composer) {
+                    // Update renderer on existing composer
+                    this.composer.setRenderer(renderer);
+                }
+                else {
+                    // Initialize composer and effects on first renderer
+                    this.initializeComposer();
+                }
+            }
+            if (sceneChanged && this.composer) {
+                this.composer.setMainScene(scene);
+            }
+            if (cameraChanged && this.composer) {
+                this.composer.setMainCamera(camera);
+                if (this.renderPass) {
+                    this.renderPass.camera = this.lastCamera;
+                }
+            }
+        }
+        // Check if camera layers changed (without changing camera instance)
+        if (this.useCameraVisibilityLayers && this.lastCamera?.layers && this.cameraLayersMask !== this.lastCamera.layers.mask) {
+            this.layersDirty = true;
+        }
+        if ((this.lastWindowSize.width !== windowSize.width || this.lastWindowSize.height !== windowSize.height) && this.composer) {
+            this.lastWindowSize = windowSize;
+            this.composer.setSize(this.lastWindowSize.width, this.lastWindowSize.height);
+        }
+        if (this.postProcessingEnabled && this.cachedHasAnyEnabledPasses && this.composer) {
+            // When using post-processing, disable renderer tone mapping (handled by post-processing effects)
+            renderer.toneMapping = THREE.NoToneMapping;
+            this.composer.render();
+            // Render EdgeOutline on top of the post-processed scene
+            if (this.edgeOutlineEnabledCache && this.edgeOutlineEffect && this.edgeOutlineEffect.selection.size > 0) {
+                // First, build a depth buffer for the current scene without affecting color
+                this.renderDepthPrepass(renderer, scene, camera);
+                // Then render the outline using the existing depth
+                this.edgeOutlineEffect.renderOutline(scene, camera);
+            }
+            this.hasCompletedFirstRender = true;
+        }
+        else {
+            // Apply tone mapping to renderer when post-processing is off
+            this.applyToneMappingToRenderer();
+            renderer.render(scene, camera);
+            // Render EdgeOutline effect if enabled (when NOT using post-processing)
+            if (this.edgeOutlineEnabledCache && this.edgeOutlineEffect) {
+                // Build depth buffer before rendering outline to ensure consistent behavior
+                this.renderDepthPrepass(renderer, scene, camera);
+                this.edgeOutlineEffect.renderOutline(scene, camera);
+            }
+            this.hasCompletedFirstRender = true;
+        }
+    }
+    enablePasses(...passes) {
+        for (const pass of passes) {
+            const config = this.configuration.get(pass);
+            if (config) {
+                config.enabled = true;
+            }
+        }
+        this.updateEnabledStatesCache();
+        this.syncPassEnabled();
+    }
+    disablePasses(...passes) {
+        for (const pass of passes) {
+            const config = this.configuration.get(pass);
+            if (config) {
+                config.enabled = false;
+            }
+        }
+        this.updateEnabledStatesCache();
+        this.syncPassEnabled();
+    }
+    getEffectFromPass(pass, type) {
+        const wrapper = this.effects.get(pass);
+        const effect = wrapper?.getEffect(type);
+        return effect;
+    }
+    isPassEnabled(pass) {
+        const config = this.configuration.get(pass);
+        return config?.enabled ?? false;
+    }
+    /** Sets whether the RenderPass should use camera visibility layers */
+    setUseCameraVisibilityLayers(enabled) {
+        if (this.useCameraVisibilityLayers !== enabled) {
+            this.useCameraVisibilityLayers = enabled;
+            this.layersDirty = true;
+        }
+    }
+    /** Gets whether the RenderPass uses camera visibility layers */
+    getUseCameraVisibilityLayers() {
+        return this.useCameraVisibilityLayers;
+    }
+    /** Update cached layer-filtered objects (only called when dirty) */
+    updateLayerFilteredObjects() {
+        if (!this.layersDirty)
+            return;
+        this.layerFilteredObjects.clear();
+        if (this.useCameraVisibilityLayers && this.lastCamera?.layers && this.lastScene) {
+            this.cameraLayersMask = this.lastCamera.layers.mask;
+            this.lastScene.traverse(object => {
+                if (object.layers && !object.layers.test(this.lastCamera.layers)) {
+                    this.layerFilteredObjects.add(object);
+                }
+            });
+        }
+        this.layersDirty = false;
+    }
+    /** Mark layer cache as dirty (call when scene graph changes) */
+    invalidateLayerCache() {
+        this.layersDirty = true;
+    }
+    /** Update cached enabled states to avoid Map lookups in hot path */
+    updateEnabledStatesCache() {
+        const edgeOutlineConfig = this.configuration.get(PostProcessPass.EdgeOutline);
+        this.edgeOutlineEnabledCache = edgeOutlineConfig?.enabled ?? false;
+        // Update hasAnyEnabledPasses cache (exclude EdgeOutline as it's not an EffectPass in the composer)
+        this.cachedHasAnyEnabledPasses = false;
+        for (const [passType, config] of this.configuration.entries()) {
+            if (config.enabled && passType !== PostProcessPass.EdgeOutline) {
+                this.cachedHasAnyEnabledPasses = true;
+                break;
+            }
+        }
+    }
+    /** Sets whether post-processing is enabled globally */
+    setPostProcessingEnabled(enabled) {
+        this.postProcessingEnabled = enabled;
+    }
+    /** Gets whether post-processing is enabled globally */
+    getPostProcessingEnabled() {
+        return this.postProcessingEnabled;
+    }
+    /** Get the EdgeOutline effect instance */
+    getEdgeOutlineEffect() {
+        return this.edgeOutlineEffect;
+    }
+    /** Render a depth-only prepass into the current framebuffer without affecting color */
+    renderDepthPrepass(renderer, scene, camera) {
+        const gl = renderer.getContext();
+        const prevAutoClear = renderer.autoClear;
+        // Disable color writes completely - only write to depth buffer
+        gl.colorMask(false, false, false, false);
+        // Clear depth buffer and render scene to populate depth
+        renderer.autoClear = false;
+        renderer.clearDepth();
+        renderer.render(scene, camera);
+        // Restore color writes
+        gl.colorMask(true, true, true, true);
+        renderer.autoClear = prevAutoClear;
+    }
+    destroy() {
+        this.hiddenObjects.clear();
+        this.layerFilteredObjects.clear();
+        this.tempHiddenObjects.length = 0;
+        this.boundOriginalRender = null;
+        this.clearResources();
+        if (this.edgeOutlineEffect) {
+            this.edgeOutlineEffect.dispose();
+            this.edgeOutlineEffect = null;
+        }
+        this.renderPass = null;
+        this.hasCompletedFirstRender = false;
+        this.lastCamera = null;
+        this.lastScene = null;
+        this.lastWindowSize = null;
+        this.lastRenderer = null;
+        this.effects.clear();
+        this.configuration.clear();
+    }
+    //====================================================================================================
+    /** Initialize the effect composer and all effects once */
+    initializeComposer() {
+        if (!this.lastRenderer || !this.lastScene || !this.lastCamera || this.effectsInitialized)
+            return;
+        const isWebGL2 = this.lastRenderer.capabilities.isWebGL2;
+        const supportHalfFloat = isWebGL2 && this.lastRenderer.extensions.has('EXT_color_buffer_float');
+        const maxSamples = this.lastRenderer.capabilities.maxSamples;
+        console.log('[PostProcessManager]: initializeComposer', { isWebGL2, supportHalfFloat, maxSamples });
+        this.composer = new EffectComposer(this.lastRenderer, {
+            frameBufferType: supportHalfFloat ? THREE.HalfFloatType : undefined,
+            multisampling: isWebGL2 ? Math.min(4, maxSamples) : 0, // TODO: expose MSAA settings?
+        });
+        // Update cached enabled states
+        this.updateEnabledStatesCache();
+        // Create render pass
+        this.createRenderPass();
+        // Create all effects upfront
+        this.createAllEffects();
+        // Initial sync of passes
+        this.syncPassEnabled();
+        // Apply tone mapping exposure
+        this.applyToneMappingExposure();
+        // Initialize EdgeOutline effect
+        this.initializeEdgeOutline();
+        this.effectsInitialized = true;
+    }
+    /** Initialize the EdgeOutline effect */
+    initializeEdgeOutline() {
+        if (!this.lastRenderer)
+            return;
+        const edgeOutlineConfig = this.configuration.get(PostProcessPass.EdgeOutline);
+        if (edgeOutlineConfig) {
+            // Preserve the current selection if recreating
+            const currentSelection = this.edgeOutlineEffect ? Array.from(this.edgeOutlineEffect.selection) : [];
+            // Dispose of existing effect if any
+            if (this.edgeOutlineEffect) {
+                this.edgeOutlineEffect.dispose();
+            }
+            // Create new EdgeOutline effect
+            this.edgeOutlineEffect = new EdgeOutlineEffect(this.lastRenderer, {
+                defaultThickness: edgeOutlineConfig.thickness ?? DEFAULT_CONFIGS[PostProcessPass.EdgeOutline].thickness,
+                defaultColor: this.hexToRgbArray(edgeOutlineConfig.color ?? DEFAULT_CONFIGS[PostProcessPass.EdgeOutline].color),
+                defaultAlpha: edgeOutlineConfig.alpha ?? DEFAULT_CONFIGS[PostProcessPass.EdgeOutline].alpha,
+            });
+            // Restore the selection
+            for (const object of currentSelection) {
+                this.edgeOutlineEffect.selection.add(object);
+            }
+        }
+    }
+    /** Convert hex color to RGB array */
+    hexToRgbArray(hex) {
+        return [
+            ((hex >> 16) & 255) / 255,
+            ((hex >> 8) & 255) / 255,
+            (hex & 255) / 255
+        ];
+    }
+    /** Enable/disable effect passes based on configuration */
+    syncPassEnabled() {
+        if (!this.composer)
+            return;
+        for (const [passType, wrapper] of this.effects) {
+            const config = this.configuration.get(passType);
+            if (config?.enabled) {
+                wrapper.enableEffect();
+            }
+            else {
+                wrapper.disableEffect();
+            }
+        }
+        // Update renderToScreen flags after changing pass states
+        this.updateRenderToScreen();
+    }
+    /** Update renderToScreen flags to ensure the last enabled pass renders to screen */
+    updateRenderToScreen() {
+        if (!this.composer)
+            return;
+        let lastEnabledPass = null;
+        // Find the last enabled pass
+        for (const pass of this.composer.passes) {
+            if (pass.enabled) {
+                lastEnabledPass = pass;
+            }
+        }
+        // Set renderToScreen only on the last enabled pass
+        for (const pass of this.composer.passes) {
+            pass.renderToScreen = pass === lastEnabledPass;
+        }
+    }
+    /** Check if any passes are enabled */
+    hasAnyEnabledPasses() {
+        for (const config of this.configuration.values()) {
+            if (config.enabled) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Create the render pass once */
+    createRenderPass() {
+        if (!this.composer || !this.lastScene || !this.lastCamera) {
+            console.warn('[PostProcessManager]: Cannot create render pass - missing composer, scene, or camera');
+            return;
+        }
+        this.renderPass = new RenderPass(this.lastScene, this.lastCamera);
+        // Bind original render once for better performance
+        this.boundOriginalRender = this.renderPass.render.bind(this.renderPass);
+        // Override render method to respect camera layers and hidden objects
+        this.renderPass.render = (renderer, writeBuffer, readBuffer, deltaTime, maskActive) => {
+            // Early exit if scene or camera not ready
+            if (!this.lastScene || !this.lastCamera) {
+                console.warn('[PostProcessManager]: Skipping render - scene or camera not ready');
+                return;
+            }
+            // Clear temp array instead of allocating new one
+            this.tempHiddenObjects.length = 0;
+            // Handle camera layer visibility - use cached filtered objects
+            if (this.useCameraVisibilityLayers) {
+                // Update cache if dirty
+                this.updateLayerFilteredObjects();
+                // Hide cached filtered objects
+                for (const object of this.layerFilteredObjects) {
+                    if (object?.visible) {
+                        object.visible = false;
+                        this.tempHiddenObjects.push(object);
+                    }
+                }
+            }
+            // Handle explicitly hidden objects
+            for (const object of this.hiddenObjects) {
+                if (object?.visible) {
+                    object.visible = false;
+                    this.tempHiddenObjects.push(object);
+                }
+            }
+            // Call bound original render - no .call() overhead
+            this.boundOriginalRender(renderer, writeBuffer, readBuffer, deltaTime, maskActive);
+            // Restore visibility of hidden objects
+            for (const object of this.tempHiddenObjects) {
+                if (object) {
+                    object.visible = true;
+                }
+            }
+        };
+        this.composer.addPass(this.renderPass);
+    }
+    /** Create all effects once and add them to the composer */
+    createAllEffects() {
+        if (!this.composer || !this.lastCamera)
+            return;
+        for (const [passType, config] of this.configuration) {
+            const effects = this.createEffectFromConfig(config);
+            if (effects.length > 0) {
+                const wrapper = new EffectPassWrapper(this.lastCamera, effects);
+                this.effects.set(passType, wrapper);
+                this.composer.addPass(wrapper.getPass());
+            }
+        }
+    }
+    /** Update an effect's configuration without recreating it */
+    updateEffectConfig(passType) {
+        const config = this.configuration.get(passType);
+        if (!config)
+            return;
+        const wrapper = this.effects.get(passType);
+        if (!wrapper)
+            return;
+        // Update effect properties based on configuration
+        this.applyConfigToEffect(passType, config, wrapper);
+    }
+    createEffectFromConfig(config) {
+        switch (config.type) {
+            case PostProcessPass.ObjectOutline: {
+                const outlineConfig = config;
+                return [new ObjectOutlineEffect(this.lastScene, this.lastCamera, {
+                        blendFunction: BlendFunction.ALPHA,
+                        edgeThickness: outlineConfig.edgeThickness ?? DEFAULT_CONFIGS[PostProcessPass.ObjectOutline].edgeThickness,
+                        edgeIntensity: outlineConfig.edgeIntensity ?? DEFAULT_CONFIGS[PostProcessPass.ObjectOutline].edgeIntensity,
+                        visibleEdgeColor: outlineConfig.visibleEdgeColor ?? DEFAULT_CONFIGS[PostProcessPass.ObjectOutline].visibleEdgeColor,
+                    })];
+            }
+            case PostProcessPass.Bloom: {
+                const bloomConfig = config;
+                const effect = new SelectiveBloomEffect(this.lastScene, this.lastCamera, {
+                    intensity: bloomConfig.intensity ?? DEFAULT_CONFIGS[PostProcessPass.Bloom].intensity,
+                    luminanceThreshold: bloomConfig.luminanceThreshold ?? DEFAULT_CONFIGS[PostProcessPass.Bloom].luminanceThreshold,
+                    luminanceSmoothing: bloomConfig.luminanceSmoothing ?? DEFAULT_CONFIGS[PostProcessPass.Bloom].luminanceSmoothing,
+                    mipmapBlur: bloomConfig.mipmapBlur ?? DEFAULT_CONFIGS[PostProcessPass.Bloom].mipmapBlur,
+                    radius: bloomConfig.radius ?? DEFAULT_CONFIGS[PostProcessPass.Bloom].radius,
+                    levels: bloomConfig.levels ?? DEFAULT_CONFIGS[PostProcessPass.Bloom].levels,
+                });
+                effect.inverted = true; // Use inverted true to apply to all objects
+                effect.ignoreBackground = bloomConfig.ignoreBackground ?? DEFAULT_CONFIGS[PostProcessPass.Bloom].ignoreBackground;
+                return [effect];
+            }
+            case PostProcessPass.SMAA: {
+                const smaaConfig = config;
+                return [new SMAAEffect({
+                        preset: smaaConfig.preset ?? DEFAULT_CONFIGS[PostProcessPass.SMAA].preset,
+                    })];
+            }
+            case PostProcessPass.ToneMapping: {
+                const toneMappingConfig = config;
+                const defaults = DEFAULT_CONFIGS[PostProcessPass.ToneMapping];
+                // Apply exposure to renderer if specified
+                if (toneMappingConfig.exposure !== undefined && this.lastRenderer) {
+                    this.lastRenderer.toneMappingExposure = toneMappingConfig.exposure;
+                }
+                return [new ToneMappingEffect({
+                        mode: toneMappingConfig.mode ?? defaults.mode,
+                        resolution: toneMappingConfig.resolution ?? defaults.resolution,
+                        whitePoint: toneMappingConfig.whitePoint ?? defaults.whitePoint,
+                        middleGrey: toneMappingConfig.middleGrey ?? defaults.middleGrey,
+                        minLuminance: toneMappingConfig.minLuminance ?? defaults.minLuminance,
+                        averageLuminance: toneMappingConfig.averageLuminance ?? defaults.averageLuminance,
+                        adaptationRate: toneMappingConfig.adaptationRate ?? defaults.adaptationRate,
+                    })];
+            }
+            default:
+                console.warn(`Unknown effect type: ${config.type}`);
+                return [];
+        }
+    }
+    /** Apply configuration to an existing effect without recreating it */
+    applyConfigToEffect(passType, config, wrapper) {
+        switch (passType) {
+            case PostProcessPass.ObjectOutline: {
+                const outlineConfig = config;
+                const outlineEffect = wrapper.getEffect(ObjectOutlineEffect);
+                if (outlineEffect) {
+                    // Update outline effect properties
+                    outlineEffect.edgeThickness = outlineConfig.edgeThickness ?? DEFAULT_CONFIGS[PostProcessPass.ObjectOutline].edgeThickness;
+                    outlineEffect.edgeIntensity = outlineConfig.edgeIntensity ?? DEFAULT_CONFIGS[PostProcessPass.ObjectOutline].edgeIntensity;
+                    outlineEffect.visibleEdgeColor = outlineConfig.visibleEdgeColor ?? DEFAULT_CONFIGS[PostProcessPass.ObjectOutline].visibleEdgeColor;
+                }
+                break;
+            }
+            case PostProcessPass.Bloom: {
+                const bloomConfig = config;
+                const bloomEffect = wrapper.getEffect(SelectiveBloomEffect);
+                if (bloomEffect) {
+                    // Update selective bloom effect properties
+                    bloomEffect.intensity = bloomConfig.intensity ?? DEFAULT_CONFIGS[PostProcessPass.Bloom].intensity;
+                    bloomEffect.inverted = true; // Use inverted true to apply to all objects
+                    bloomEffect.ignoreBackground = bloomConfig.ignoreBackground ?? DEFAULT_CONFIGS[PostProcessPass.Bloom].ignoreBackground;
+                    // Update luminance properties
+                    if (bloomConfig.luminanceThreshold !== undefined) {
+                        bloomEffect.luminanceMaterial.threshold = bloomConfig.luminanceThreshold;
+                    }
+                    if (bloomConfig.luminanceSmoothing !== undefined) {
+                        bloomEffect.luminanceMaterial.smoothing = bloomConfig.luminanceSmoothing;
+                    }
+                    // Update mipmap blur properties
+                    if (bloomConfig.mipmapBlur !== undefined) {
+                        bloomEffect.mipmapBlurPass.enabled = bloomConfig.mipmapBlur;
+                    }
+                    if (bloomConfig.radius !== undefined) {
+                        bloomEffect.mipmapBlurPass.radius = bloomConfig.radius;
+                    }
+                    if (bloomConfig.levels !== undefined) {
+                        bloomEffect.mipmapBlurPass.levels = bloomConfig.levels;
+                    }
+                }
+                break;
+            }
+            case PostProcessPass.ToneMapping: {
+                const toneMappingConfig = config;
+                const defaults = DEFAULT_CONFIGS[PostProcessPass.ToneMapping];
+                const toneMappingEffect = wrapper.getEffect(ToneMappingEffect);
+                if (toneMappingEffect) {
+                    // Update tone mapping effect properties
+                    toneMappingEffect.mode = toneMappingConfig.mode ?? defaults.mode;
+                    // Cast to any to access setter properties that may not be defined in TypeScript
+                    const effect = toneMappingEffect;
+                    // Update white point and middle grey for Reinhard2 operators
+                    if (toneMappingConfig.whitePoint !== undefined) {
+                        effect.whitePoint = toneMappingConfig.whitePoint;
+                    }
+                    if (toneMappingConfig.middleGrey !== undefined) {
+                        effect.middleGrey = toneMappingConfig.middleGrey;
+                    }
+                    if (toneMappingConfig.averageLuminance !== undefined) {
+                        effect.averageLuminance = toneMappingConfig.averageLuminance;
+                    }
+                    // Update resolution for adaptive tone mapping
+                    if (toneMappingConfig.resolution !== undefined) {
+                        effect.resolution = toneMappingConfig.resolution;
+                    }
+                    // Update adaptive luminance properties if available
+                    if (effect.adaptiveLuminanceMaterial) {
+                        if (toneMappingConfig.minLuminance !== undefined) {
+                            effect.adaptiveLuminanceMaterial.minLuminance = toneMappingConfig.minLuminance;
+                        }
+                        if (toneMappingConfig.adaptationRate !== undefined) {
+                            effect.adaptiveLuminanceMaterial.adaptationRate = toneMappingConfig.adaptationRate;
+                        }
+                    }
+                }
+                break;
+            }
+            case PostProcessPass.SMAA: {
+                const smaaConfig = config;
+                const smaaEffect = wrapper.getEffect(SMAAEffect);
+                if (smaaEffect && smaaConfig.preset !== undefined) {
+                    smaaEffect.applyPreset(smaaConfig.preset);
+                }
+                break;
+            }
+        }
+    }
+    clearResources() {
+        if (this.composer) {
+            this.composer.dispose();
+            this.composer = null;
+        }
+        for (const [_, effect] of this.effects) {
+            effect.dispose();
+        }
+        this.effects.clear();
+        this.effectsInitialized = false;
+    }
+}
+ObjectOutlineEffect.prototype.addSelectedActor = function (actor) {
+    const sceneObjects = actor.getComponents(SceneComponent);
+    for (const sceneObject of sceneObjects) {
+        sceneObject.traverse((child) => {
+            if (child instanceof THREE.Mesh) {
+                this.selection.add(child);
+            }
+        });
+    }
+    return this;
+};
+ObjectOutlineEffect.prototype.removeSelectedActor = function (actor) {
+    const sceneObjects = actor.getComponents(SceneComponent);
+    for (const sceneObject of sceneObjects) {
+        sceneObject.traverse((child) => {
+            if (child instanceof THREE.Mesh) {
+                this.selection.delete(child);
+            }
+        });
+    }
+    ;
+    return this;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PostProcessManager.js","sourceRoot":"","sources":["../../../src/render/PostProcessManager.ts"],"names":[],"mappings":"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"}