@directivegames/genesys.js 3.1.24

package/dist/src/render/EdgeOutlineEffect.js

@@ -0,0 +1,389 @@
+import * as THREE from 'three';
+import { SceneComponent } from '../components/SceneComponent.js';
+/** An edge outline effect based on toon shaders. */
+export class EdgeOutlineEffect {
+    constructor(renderer, parameters = {}) {
+        Object.defineProperty(this, "enabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "renderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "originalMaterials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "originalOnBeforeRenders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "removeThresholdCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 60
+        });
+        Object.defineProperty(this, "defaultThickness", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaultColor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaultAlpha", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaultKeepAlive", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "selection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "setOutlineMaterial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (object) => {
+                if (!this.isCompatible(object))
+                    return;
+                if (Array.isArray(object.material)) {
+                    for (let i = 0; i < object.material.length; i++) {
+                        object.material[i] = this.getOutlineMaterial(object.material[i]);
+                    }
+                }
+                else {
+                    object.material = this.getOutlineMaterial(object.material);
+                }
+                this.originalOnBeforeRenders[object.uuid] = object.onBeforeRender;
+                object.onBeforeRender = this.onBeforeRender;
+            }
+        });
+        Object.defineProperty(this, "restoreOriginalMaterial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (object) => {
+                if (!this.isCompatible(object))
+                    return;
+                if (Array.isArray(object.material)) {
+                    for (let i = 0; i < object.material.length; i++) {
+                        object.material[i] = this.originalMaterials[object.material[i].uuid];
+                    }
+                }
+                else {
+                    object.material = this.originalMaterials[object.material.uuid];
+                }
+                object.onBeforeRender = this.originalOnBeforeRenders[object.uuid];
+            }
+        });
+        Object.defineProperty(this, "onBeforeRender", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (_renderer, _scene, _camera, _geometry, material) => {
+                const originalMaterial = this.originalMaterials[material.uuid];
+                if (!originalMaterial)
+                    return;
+                this.updateUniforms(material, originalMaterial);
+            }
+        });
+        this.renderer = renderer;
+        this.defaultThickness = parameters.defaultThickness ?? 5.0; // In pixels
+        this.defaultColor = new THREE.Color().fromArray(parameters.defaultColor ?? [1, 1, 1]);
+        this.defaultAlpha = parameters.defaultAlpha ?? 1.0;
+        this.defaultKeepAlive = parameters.defaultKeepAlive ?? false;
+    }
+    createMaterial() {
+        const uniformsOutline = {
+            outlineThickness: { value: this.defaultThickness },
+            outlineColor: { value: this.defaultColor.clone() },
+            outlineAlpha: { value: this.defaultAlpha },
+            viewport: { value: new THREE.Vector2(1024, 1024) }
+        };
+        const vertexShader = [
+            '#include <common>',
+            '#include <uv_pars_vertex>',
+            '#include <displacementmap_pars_vertex>',
+            '#include <morphtarget_pars_vertex>',
+            '#include <skinning_pars_vertex>',
+            '#include <logdepthbuf_pars_vertex>',
+            '#include <clipping_planes_pars_vertex>',
+            'uniform float outlineThickness;',
+            'uniform vec2 viewport;',
+            'vec4 calculateOutline( vec4 pos, vec3 normal, vec4 skinned ) {',
+            '  // Calculate screen-space thickness',
+            '  float aspect = viewport.x / viewport.y;',
+            '  vec2 aspectVec = vec2(aspect, 1.0);',
+            '  float thickness = outlineThickness / viewport.y;',
+            '  ',
+            '  vec4 pos2 = projectionMatrix * modelViewMatrix * vec4( skinned.xyz + normal, 1.0 );',
+            '  ',
+            '  // Calculate screen-space normal direction',
+            '  vec2 dir = normalize((pos.xy / pos.w - pos2.xy / pos2.w) * aspectVec);',
+            '  ',
+            '  // Apply screen-space offset',
+            '  vec2 offset = dir * thickness * pos.w;',
+            '  offset /= aspectVec;',
+            '  ',
+            '  return vec4(pos.xy + offset, pos.zw);',
+            '}',
+            'void main() {',
+            '  #include <uv_vertex>',
+            '  #include <beginnormal_vertex>',
+            '  #include <morphnormal_vertex>',
+            '  #include <skinbase_vertex>',
+            '  #include <skinnormal_vertex>',
+            '  #include <begin_vertex>',
+            '  #include <morphtarget_vertex>',
+            '  #include <skinning_vertex>',
+            '  #include <displacementmap_vertex>',
+            '  #include <project_vertex>',
+            '  vec3 outlineNormal = - objectNormal;',
+            '  gl_Position = calculateOutline( gl_Position, outlineNormal, vec4( transformed, 1.0 ) );',
+            '  #include <logdepthbuf_vertex>',
+            '  #include <clipping_planes_vertex>',
+            '}',
+        ].join('\n');
+        const fragmentShader = [
+            '#include <common>',
+            '#include <logdepthbuf_pars_fragment>',
+            '#include <clipping_planes_pars_fragment>',
+            'uniform vec3 outlineColor;',
+            'uniform float outlineAlpha;',
+            'void main() {',
+            '  #include <clipping_planes_fragment>',
+            '  #include <logdepthbuf_fragment>',
+            '  // Output color directly without tone mapping or color space conversion',
+            '  gl_FragColor = vec4( outlineColor, outlineAlpha );',
+            '  #include <premultiplied_alpha_fragment>',
+            '}'
+        ].join('\n');
+        return new THREE.ShaderMaterial({
+            name: 'EdgeOutlineEffect',
+            uniforms: THREE.UniformsUtils.merge([
+                THREE.UniformsLib['displacementmap'],
+                uniformsOutline
+            ]),
+            vertexShader,
+            fragmentShader,
+            side: THREE.BackSide,
+            toneMapped: false,
+            fog: false,
+            depthWrite: false,
+            depthTest: true // Default to depth test enabled, can be overridden per-render
+        });
+    }
+    getOutlineMaterialFromCache(originalMaterial) {
+        let data = this.cache[originalMaterial.uuid];
+        if (!data) {
+            data = {
+                material: this.createMaterial(),
+                used: true,
+                keepAlive: this.defaultKeepAlive,
+                count: 0
+            };
+            this.cache[originalMaterial.uuid] = data;
+        }
+        data.used = true;
+        return data.material;
+    }
+    getOutlineMaterial(originalMaterial) {
+        const outlineMaterial = this.getOutlineMaterialFromCache(originalMaterial);
+        this.originalMaterials[outlineMaterial.uuid] = originalMaterial;
+        this.updateOutlineMaterial(outlineMaterial, originalMaterial);
+        return outlineMaterial;
+    }
+    isCompatible(object) {
+        const geometry = object.geometry;
+        const hasNormals = geometry?.attributes?.normal !== undefined;
+        return object.isMesh === true && object.material !== undefined && hasNormals === true;
+    }
+    updateUniforms(material, originalMaterial) {
+        const outlineParameters = originalMaterial.userData?.outlineParameters;
+        material.uniforms.outlineAlpha.value = originalMaterial.opacity;
+        if (outlineParameters) {
+            if (outlineParameters.thickness !== undefined)
+                material.uniforms.outlineThickness.value = outlineParameters.thickness;
+            if (outlineParameters.color !== undefined)
+                material.uniforms.outlineColor.value.fromArray(outlineParameters.color);
+            if (outlineParameters.alpha !== undefined)
+                material.uniforms.outlineAlpha.value = outlineParameters.alpha;
+        }
+        if (originalMaterial.displacementMap) {
+            material.uniforms.displacementMap.value = originalMaterial.displacementMap;
+            material.uniforms.displacementScale.value = originalMaterial.displacementScale;
+            material.uniforms.displacementBias.value = originalMaterial.displacementBias;
+        }
+    }
+    updateOutlineMaterial(material, originalMaterial) {
+        if (material.name === 'invisible')
+            return;
+        const outlineParameters = originalMaterial.userData?.outlineParameters;
+        material.fog = false;
+        material.toneMapped = false;
+        material.premultipliedAlpha = originalMaterial.premultipliedAlpha;
+        const matAny = material;
+        matAny.displacementMap = originalMaterial.displacementMap;
+        if (outlineParameters) {
+            if (originalMaterial.visible === false) {
+                material.visible = false;
+            }
+            else {
+                material.visible = outlineParameters.visible ?? true;
+            }
+            material.transparent = (outlineParameters.alpha !== undefined && outlineParameters.alpha < 1.0) ? true : originalMaterial.transparent;
+            if (outlineParameters.keepAlive !== undefined)
+                this.cache[originalMaterial.uuid].keepAlive = outlineParameters.keepAlive;
+        }
+        else {
+            material.transparent = originalMaterial.transparent;
+            material.visible = originalMaterial.visible;
+        }
+        if (originalMaterial.wireframe === true || originalMaterial.depthTest === false)
+            material.visible = false;
+        if (originalMaterial.clippingPlanes) {
+            material.clipping = true;
+            material.clippingPlanes = originalMaterial.clippingPlanes;
+            material.clipIntersection = originalMaterial.clipIntersection;
+            material.clipShadows = originalMaterial.clipShadows;
+        }
+        material.version = originalMaterial.version;
+    }
+    cleanupCache() {
+        let keys = Object.keys(this.originalMaterials);
+        for (let i = 0; i < keys.length; i++) {
+            delete this.originalMaterials[keys[i]];
+        }
+        keys = Object.keys(this.originalOnBeforeRenders);
+        for (let i = 0; i < keys.length; i++) {
+            delete this.originalOnBeforeRenders[keys[i]];
+        }
+        keys = Object.keys(this.cache);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (this.cache[key].used === false) {
+                this.cache[key].count++;
+                if (this.cache[key].keepAlive === false && this.cache[key].count > this.removeThresholdCount) {
+                    delete this.cache[key];
+                }
+            }
+            else {
+                this.cache[key].used = false;
+                this.cache[key].count = 0;
+            }
+        }
+    }
+    renderOutline(scene, camera) {
+        // Early exit if no objects are selected or camera is undefined
+        if (this.selection.size === 0 || !camera) {
+            return;
+        }
+        const currentAutoClear = this.renderer.autoClear;
+        const currentToneMapping = this.renderer.toneMapping;
+        const currentToneMappingExposure = this.renderer.toneMappingExposure;
+        // Don't clear color or depth; we rely on an existing depth buffer
+        this.renderer.autoClear = false;
+        this.renderer.toneMapping = THREE.NoToneMapping;
+        this.renderer.toneMappingExposure = 1.0;
+        // Get current viewport size
+        const size = this.renderer.getDrawingBufferSize(new THREE.Vector2());
+        // Render outline (backside only) for each selected object on top of existing scene
+        this.selection.forEach(object => {
+            object.traverse(this.setOutlineMaterial);
+            // Update viewport uniform for all materials
+            object.traverse((child) => {
+                if (child.material) {
+                    const materials = Array.isArray(child.material) ? child.material : [child.material];
+                    materials.forEach((mat) => {
+                        if (mat.uniforms?.viewport) {
+                            mat.uniforms.viewport.value.set(size.x, size.y);
+                        }
+                    });
+                }
+            });
+            this.renderer.render(object, camera);
+            object.traverse(this.restoreOriginalMaterial);
+        });
+        this.cleanupCache();
+        this.renderer.autoClear = currentAutoClear;
+        this.renderer.toneMapping = currentToneMapping;
+        this.renderer.toneMappingExposure = currentToneMappingExposure;
+    }
+    addSelectedActors(actors) {
+        for (const actor of actors) {
+            this.addSelectedActor(actor);
+        }
+        return this;
+    }
+    addSelectedActor(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;
+    }
+    removeSelectedActors(actors) {
+        for (const actor of actors) {
+            this.removeSelectedActor(actor);
+        }
+        return this;
+    }
+    removeSelectedActor(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;
+    }
+    clearSelection() {
+        this.selection.clear();
+    }
+    dispose() {
+        this.clearSelection();
+        for (const key in this.cache) {
+            this.cache[key].material.dispose();
+        }
+        this.cache = {};
+        this.originalMaterials = {};
+        this.originalOnBeforeRenders = {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EdgeOutlineEffect.js","sourceRoot":"","sources":["../../../src/render/EdgeOutlineEffect.ts"],"names":[],"mappings":"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"}

package/dist/src/render/PostProcessManager.d.ts

@@ -0,0 +1,274 @@
+import { SMAAPreset, ToneMappingMode } from 'postprocessing';
+import * as THREE from 'three';
+export { ToneMappingMode, SMAAPreset };
+import { EdgeOutlineEffect } from './EdgeOutlineEffect.js';
+import type { Effect } from 'postprocessing';
+export type { EdgeOutlineEffectOptions } from './EdgeOutlineEffect.js';
+export declare enum PostProcessPass {
+    ObjectOutline = "objectOutline",
+    EdgeOutline = "edgeOutline",
+    Bloom = "bloom",
+    SMAA = "smaa",
+    ToneMapping = "toneMapping"
+}
+export interface BaseEffectConfig {
+    type: PostProcessPass;
+    enabled?: boolean;
+}
+/** Configuration for the Bloom post-process effect. */
+export interface BloomEffectConfig extends BaseEffectConfig {
+    type: PostProcessPass.Bloom;
+    /** Bloom intensity (strength of the bloom effect). */
+    intensity?: number;
+    /** Luminance threshold for bloom (minimum brightness to bloom). */
+    luminanceThreshold?: number;
+    /** Luminance smoothing (softness of the threshold). */
+    luminanceSmoothing?: number;
+    /** Whether to use mipmap blur for bloom. */
+    mipmapBlur?: boolean;
+    /** Blur radius for mipmap blur. */
+    radius?: number;
+    /** Number of MIP levels for blur. */
+    levels?: number;
+    /** If true, background is ignored for bloom. */
+    ignoreBackground?: boolean;
+}
+export interface ObjectOutlineEffectConfig extends BaseEffectConfig {
+    type: PostProcessPass.ObjectOutline;
+    /** Edge thickness in pixels (1.0 = 1px, 2.0 = 2px, etc.) */
+    edgeThickness?: number;
+    /** Edge brightness multiplier (typically 50-100 for bright outlines due to tone mapping) */
+    edgeIntensity?: number;
+    /** Edge color in hex format (e.g., 0xffffff for white) */
+    visibleEdgeColor?: number;
+}
+export interface EdgeOutlineEffectConfig extends BaseEffectConfig {
+    type: PostProcessPass.EdgeOutline;
+    thickness?: number;
+    color?: number;
+    alpha?: number;
+}
+export interface SMAAEffectConfig extends BaseEffectConfig {
+    type: PostProcessPass.SMAA;
+    preset?: SMAAPreset;
+}
+export interface ToneMappingEffectConfig extends BaseEffectConfig {
+    type: PostProcessPass.ToneMapping;
+    mode?: ToneMappingMode;
+    exposure?: number;
+    /** Resolution of the luminance texture. Must be a power of two. Only affects adaptive tone mapping. */
+    resolution?: number;
+    /** White point for Reinhard2 operators. */
+    whitePoint?: number;
+    /** Middle grey factor for Reinhard2 operators. */
+    middleGrey?: number;
+    /** Minimum luminance. Prevents very high exposure in dark scenes. Only affects adaptive tone mapping. */
+    minLuminance?: number;
+    /** Average luminance. Used for non-adaptive Reinhard operator. */
+    averageLuminance?: number;
+    /** Luminance adaptation rate. Only affects adaptive tone mapping. */
+    adaptationRate?: number;
+}
+export type EffectConfig = BloomEffectConfig | ObjectOutlineEffectConfig | EdgeOutlineEffectConfig | SMAAEffectConfig | ToneMappingEffectConfig;
+export interface PostProcessConfiguration {
+    effects: EffectConfig[];
+}
+export declare const DEFAULT_CONFIGS: {
+    objectOutline: ObjectOutlineEffectConfig;
+    edgeOutline: EdgeOutlineEffectConfig;
+    bloom: BloomEffectConfig;
+    smaa: SMAAEffectConfig;
+    toneMapping: ToneMappingEffectConfig;
+};
+/**
+ * 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 declare class PostProcessManager {
+    private lastRenderer;
+    private lastScene;
+    private lastCamera;
+    private lastWindowSize;
+    private composer;
+    private effects;
+    private useCameraVisibilityLayers;
+    private configuration;
+    private effectsInitialized;
+    private postProcessingEnabled;
+    readonly hiddenObjects: Set<THREE.Object3D>;
+    private edgeOutlineEffect;
+    private renderPass;
+    private hasCompletedFirstRender;
+    private layerFilteredObjects;
+    private layersDirty;
+    private tempHiddenObjects;
+    private cameraLayersMask;
+    private edgeOutlineEnabledCache;
+    private cachedHasAnyEnabledPasses;
+    private boundOriginalRender;
+    private depthPrepassMaterial;
+    constructor(config?: PostProcessConfiguration);
+    private initializeDefaults;
+    /** Apply tone mapping exposure to renderer */
+    private applyToneMappingExposure;
+    /** Apply tone mapping mode and exposure to renderer (used when post-processing is disabled) */
+    private applyToneMappingToRenderer;
+    /** Configure specific effect settings */
+    configureEffect<T extends EffectConfig>(passType: PostProcessPass, config: Partial<T>): void;
+    /** Get current configuration for an effect */
+    getEffectConfig(passType: PostProcessPass): EffectConfig | null;
+    /** Set multiple effect configurations at once */
+    configure(config: PostProcessConfiguration): void;
+    /** Set post-processing configuration (merges with defaults) */
+    setConfiguration(config: PostProcessConfiguration): void;
+    /** Update post-processing configuration (merges with current) */
+    updateConfiguration(config: PostProcessConfiguration): void;
+    /** Get all current configurations */
+    getAllConfigurations(): PostProcessConfiguration;
+    renderScene(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, windowSize: {
+        width: number;
+        height: number;
+    }): void;
+    enablePasses(...passes: PostProcessPass[]): void;
+    disablePasses(...passes: PostProcessPass[]): void;
+    getEffectFromPass<T extends Effect>(pass: PostProcessPass, type: new (...args: any[]) => T): T | null;
+    isPassEnabled(pass: PostProcessPass): boolean;
+    /** Sets whether the RenderPass should use camera visibility layers */
+    setUseCameraVisibilityLayers(enabled: boolean): void;
+    /** Gets whether the RenderPass uses camera visibility layers */
+    getUseCameraVisibilityLayers(): boolean;
+    /** Update cached layer-filtered objects (only called when dirty) */
+    private updateLayerFilteredObjects;
+    /** Mark layer cache as dirty (call when scene graph changes) */
+    invalidateLayerCache(): void;
+    /** Update cached enabled states to avoid Map lookups in hot path */
+    private updateEnabledStatesCache;
+    /** Sets whether post-processing is enabled globally */
+    setPostProcessingEnabled(enabled: boolean): void;
+    /** Gets whether post-processing is enabled globally */
+    getPostProcessingEnabled(): boolean;
+    /** Get the EdgeOutline effect instance */
+    getEdgeOutlineEffect(): EdgeOutlineEffect | null;
+    /** Render a depth-only prepass into the current framebuffer without affecting color */
+    private renderDepthPrepass;
+    destroy(): void;
+    /** Initialize the effect composer and all effects once */
+    private initializeComposer;
+    /** Initialize the EdgeOutline effect */
+    private initializeEdgeOutline;
+    /** Convert hex color to RGB array */
+    private hexToRgbArray;
+    /** Enable/disable effect passes based on configuration */
+    private syncPassEnabled;
+    /** Update renderToScreen flags to ensure the last enabled pass renders to screen */
+    private updateRenderToScreen;
+    /** Check if any passes are enabled */
+    private hasAnyEnabledPasses;
+    /** Create the render pass once */
+    private createRenderPass;
+    /** Create all effects once and add them to the composer */
+    private createAllEffects;
+    /** Update an effect's configuration without recreating it */
+    private updateEffectConfig;
+    private createEffectFromConfig;
+    /** Apply configuration to an existing effect without recreating it */
+    private applyConfigToEffect;
+    private clearResources;
+}