@needle-tools/engine 4.6.0-next.ffc175e → 4.6.1-next.1e3d612

package/src/engine-components/postprocessing/PostProcessingHandler.ts

@@ -1,5 +1,5 @@
 import type { Effect, EffectComposer, Pass, ToneMappingEffect as _TonemappingEffect } from "postprocessing";
-import { HalfFloatType, NoToneMapping } from "three";
+import { Camera as Camera3, HalfFloatType, NoToneMapping, Scene } from "three";
 
 import { showBalloonWarning } from "../../engine/debug/index.js";
 // import { internal_SetSharpeningEffectModule } from "./Effects/Sharpening.js";
@@ -9,13 +9,13 @@ import type { Constructor } from "../../engine/engine_types.js";
 import { DeviceUtilities, getParam } from "../../engine/engine_utils.js";
 import { Camera } from "../Camera.js";
 import { PostProcessingEffect, PostProcessingEffectContext } from "./PostProcessingEffect.js";
+import { orderEffects, PostprocessingEffectData } from "./utils.js";
 
 declare const NEEDLE_USE_POSTPROCESSING: boolean;
 globalThis["NEEDLE_USE_POSTPROCESSING"] = globalThis["NEEDLE_USE_POSTPROCESSING"] !== undefined ? globalThis["NEEDLE_USE_POSTPROCESSING"] : true;
 
 
 const debug = getParam("debugpost");
-const dontMergePasses = getParam("debugpostpasses");
 
 const activeKey = Symbol("needle:postprocessing-handler");
 const autoclearSetting = Symbol("needle:previous-autoclear-state");
@@ -27,7 +27,7 @@ export class PostProcessingHandler {
 
     private _composer: EffectComposer | null = null;
     private _lastVolumeComponents?: PostProcessingEffect[];
-    private _effects: Array<Effect | Pass> = [];
+    private readonly _effects: Array<PostprocessingEffectData> = [];
 
     get isActive() {
         return this._isActive;
@@ -44,7 +44,7 @@ export class PostProcessingHandler {
         this.context = context;
     }
 
-    apply(components: PostProcessingEffect[]) : Promise<void> {
+    apply(components: PostProcessingEffect[]): Promise<void> {
         if ("env" in import.meta && import.meta.env.VITE_NEEDLE_USE_POSTPROCESSING === "false") {
             if (debug) console.warn("Postprocessing is disabled via vite env setting");
             else console.debug("Postprocessing is disabled via vite env setting");
@@ -60,7 +60,7 @@ export class PostProcessingHandler {
         return this.onApply(this.context, components);
     }
 
-    unapply() {
+    unapply(dispose: boolean = true) {
         if (debug) console.log("Unapplying postprocessing effects");
         this._isActive = false;
         if (this._lastVolumeComponents) {
@@ -73,21 +73,26 @@ export class PostProcessingHandler {
         const active = context[activeKey] as PostProcessingHandler | null;
         if (active === this) {
             delete context[activeKey];
+
+            // Restore the auto clear setting
+            if (typeof context.renderer[autoclearSetting] === "boolean") {
+                context.renderer.autoClear = context.renderer[autoclearSetting];
+            }
         }
+
+        this._composer?.removeAllPasses();
+        if (dispose) this._composer?.dispose();
+
         if (context.composer === this._composer) {
-            context.composer?.dispose();
             context.composer = null;
         }
-        if (typeof context.renderer[autoclearSetting] === "boolean") {
-            context.renderer.autoClear = context.renderer[autoclearSetting];
-        }
     }
 
     dispose() {
-        this.unapply();
+        this.unapply(true);
 
         for (const effect of this._effects) {
-            effect.dispose();
+            effect.effect.dispose();
         }
         this._effects.length = 0;
         this._composer = null;
@@ -105,6 +110,7 @@ export class PostProcessingHandler {
             // import("./Effects/Sharpening.effect")
         ]);
 
+
         // try {
         //     internal_SetSharpeningEffectModule(modules[2]);
         // }
@@ -141,10 +147,22 @@ export class PostProcessingHandler {
                     // apply or collect effects
                     const res = component.apply(ctx);
                     if (!res) continue;
+
+
                     if (Array.isArray(res)) {
-                        this._effects.push(...res);
+                        for (const effect of res) {
+                            this._effects.push({
+                                effect,
+                                priority: component.priority
+                            });
+                        }
+                    }
+                    else {
+                        this._effects.push({
+                            effect: res,
+                            priority: component.priority
+                        });
                     }
-                    else this._effects.push(res);
                 }
             }
             else {
@@ -157,20 +175,33 @@ export class PostProcessingHandler {
         if (this.context.renderer.toneMapping != NoToneMapping) {
             if (!this._effects.find(e => e instanceof MODULES.POSTPROCESSING.MODULE.ToneMappingEffect)) {
                 const tonemapping = new MODULES.POSTPROCESSING.MODULE.ToneMappingEffect();
-                this._effects.push(tonemapping);
+                this._effects.push({ effect: tonemapping });
             }
         }
 
         this.applyEffects(context);
     }
 
+    private _anyPassHasDepth = false;
+    private _anyPassHasNormal = false;
+    private _hasSmaaEffect = false;
+
+    get anyPassHasDepth() { return this._anyPassHasDepth; }
+    get anyPassHasNormal() { return this._anyPassHasNormal; }
+    get hasSmaaEffect() { return this._hasSmaaEffect; }
+
 
     /** Build composer passes */
     private applyEffects(context: Context) {
+        // Reset state
+        this._anyPassHasDepth = false;
+        this._anyPassHasNormal = false;
+        this._hasSmaaEffect = false;
 
         const effectsOrPasses = this._effects;
-        
-        if (effectsOrPasses.length <= 0) return;
+        if (effectsOrPasses.length <= 0) {
+            return;
+        }
 
         const camera = context.mainCameraComponent as Camera;
         const renderer = context.renderer;
@@ -180,6 +211,10 @@ export class PostProcessingHandler {
         // Store the auto clear setting because the postprocessing composer just disables it
         // and when we disable postprocessing we want to restore the original setting
         // https://github.com/pmndrs/postprocessing/blob/271944b74b543a5b743a62803a167b60cc6bb4ee/src/core/EffectComposer.js#L230C12-L230C12
+        // First we need to get the previously set autoClear setting, if it exists
+        if (typeof renderer[autoclearSetting] === "boolean") {
+            renderer.autoClear = renderer[autoclearSetting];
+        }
         renderer[autoclearSetting] = renderer.autoClear;
 
         // create composer and set active on context
@@ -194,11 +229,14 @@ export class PostProcessingHandler {
         if (context.composer && context.composer !== this._composer) {
             console.warn("There's already an active EffectComposer in your scene: replacing it with a new one. This might cause unexpected behaviour. Make sure to only use one PostprocessingManager/Volume in your scene.");
         }
+
         context.composer = this._composer;
         const composer = context.composer;
         composer.setMainCamera(cam);
         composer.setRenderer(renderer);
         composer.setMainScene(scene);
+        composer.autoRenderToScreen = true; // Must be enabled because it might be disabled during addPass by the composer itself (depending on the effect's settings or order)
+        composer.multisampling = 0;
 
         for (const prev of composer.passes)
             prev.dispose();
@@ -210,64 +248,100 @@ export class PostProcessingHandler {
         screenpass.mainScene = scene;
         composer.addPass(screenpass);
 
-        const automaticEffectsOrdering = true;
-        if (automaticEffectsOrdering && !dontMergePasses) {
-            try {
-                this.orderEffects();
+        try {
+            orderEffects(this._effects);
 
-                const effects: Array<Effect> = [];
+            const effectsToMerge: Array<Effect> = [];
+            let hasConvolutionEffectInArray = false;
 
-                for (const ef of effectsOrPasses) {
-                    if (ef instanceof MODULES.POSTPROCESSING.MODULE.Effect)
-                        effects.push(ef as Effect);
-                    else if (ef instanceof MODULES.POSTPROCESSING.MODULE.Pass) {
-                        composer.addPass(ef as Pass);
-                    }
-                    else {
-                        // seems some effects are not correctly typed, but three can deal with them,
-                        // so we might need to just pass them through
-                        composer.addPass(ef);
-                    }
-                }
+            for (const entry of effectsOrPasses) {
+                const ef = entry.effect;
 
-                // create and apply uber pass
-                if (effects.length > 0) {
-                    const pass = new MODULES.POSTPROCESSING.MODULE.EffectPass(cam, ...effects);
-                    pass.name = effects.map(e => e.name).join(" ");
-                    pass.mainScene = scene;
-                    pass.enabled = true;
-                    composer.addPass(pass);
+                if (ef instanceof MODULES.POSTPROCESSING.MODULE.SMAAEffect) {
+                    this._hasSmaaEffect = true;
+                }
+                else if (ef instanceof MODULES.POSTPROCESSING.MODULE.NormalPass) {
+                    this._anyPassHasNormal = true;
                 }
-            }
-            catch (e) {
-                console.error("Error while applying postprocessing effects", e);
-                composer.removeAllPasses();
-            }
-        }
-        else {
-            // we still want to sort passes, but we do not want to merge them for debugging
-            if (automaticEffectsOrdering)
-                this.orderEffects();
 
-            for (const ef of effectsOrPasses) {
                 if (ef instanceof MODULES.POSTPROCESSING.MODULE.Effect) {
-                    const pass = new MODULES.POSTPROCESSING.MODULE.EffectPass(cam, ef as Effect);
-                    pass.name = ef.name;
-                    composer.addPass(pass);
+                    const attributes = ef.getAttributes();
+                    const convolution = MODULES.POSTPROCESSING.MODULE.EffectAttribute.CONVOLUTION;
+                    if (attributes & convolution) {
+                        if (debug) console.log("[PostProcessing] Convolution effect: " + ef.name);
+                        if (hasConvolutionEffectInArray) {
+                            if (debug) console.log("[PostProcessing] Merging effects with convolution", effectsToMerge.map(e => e.name).join(", "));
+                            this.createPassForMergeableEffects(effectsToMerge, composer, cam, scene);
+                        }
+                        hasConvolutionEffectInArray = true;
+                    }
+                    // Otherwise we can merge it
+                    effectsToMerge.push(ef as Effect);
                 }
-                else if (ef instanceof MODULES.POSTPROCESSING.MODULE.Pass)
+                else if (ef instanceof MODULES.POSTPROCESSING.MODULE.Pass) {
+                    hasConvolutionEffectInArray = false;
+                    this.createPassForMergeableEffects(effectsToMerge, composer, cam, scene);
+                    ef.renderToScreen = false;
                     composer.addPass(ef as Pass);
-                else
+                }
+                else {
                     // seems some effects are not correctly typed, but three can deal with them,
-                    // so we just pass them through
+                    // so we might need to just pass them through
+                    hasConvolutionEffectInArray = false;
+                    this.createPassForMergeableEffects(effectsToMerge, composer, cam, scene);
                     composer.addPass(ef);
+                }
+            }
+
+            this.createPassForMergeableEffects(effectsToMerge, composer, cam, scene);
+        }
+        catch (e) {
+            console.error("Error while applying postprocessing effects", e);
+            composer.removeAllPasses();
+        }
+
+        // The last pass is the one that renders to the screen, so we need to set the gamma correction for it (and enable it for all others)
+        for (let i = 0; i < composer.passes.length; i++) {
+            const pass = composer.passes[i];
+            const isLast = i === composer.passes.length - 1;
+            if ((pass as any)?.configuration !== undefined) {
+                (pass as any).configuration.gammaCorrection = isLast;
+            }
+            else if ("autosetGamma" in pass) {
+                // Some effects have a autosetGamma property that we can use to set the gamma correction
+                pass.autosetGamma = isLast;
             }
+
+            this._anyPassHasDepth ||= pass.needsDepthTexture;
+        }
+
+        // DEBUG LAND BELOW
+        if (debug) console.log("[PostProcessing] Passes →", [...composer.passes], "\n---------------------------------\n• " + composer.passes.map(i => i.name).join("\n• ") + "\n");
+        if (debug) this._onCreateEffectsDebug(this._composer!, cam);
+    }
+
+
+
+    /** Should be called before `composer.addPass()` to create an effect pass with all previously collected effects that can be merged up to that point */
+    private createPassForMergeableEffects(effects: Array<Effect>, composer: EffectComposer, camera: Camera3, scene: Scene) {
+        if (effects.length > 0) {
+            const pass = new MODULES.POSTPROCESSING.MODULE.EffectPass(camera, ...effects);
+            pass.name = effects.map(e => e.name).join(", ");
+            pass.mainScene = scene;
+            pass.enabled = true;
+            pass.renderToScreen = false;
+            composer.addPass(pass);
+            effects.length = 0; // Clear effects after adding them to the pass
         }
+    }
+
 
-        if (debug) {
 
-            console.log("[PostProcessing] Passes →", composer.passes);
+    private _menuEntry: HTMLSelectElement | null = null;
+    private _passIndices: number[] | null = null;
 
+    private _onCreateEffectsDebug(composer: EffectComposer, cam: Camera3) {
+        if (debug === "passes") {
             // DepthEffect for debugging purposes, disabled by default, can be selected in the debug pass select
             const depthEffect = new MODULES.POSTPROCESSING.MODULE.DepthEffect({
                 blendFunction: MODULES.POSTPROCESSING.MODULE.BlendFunction.NORMAL,
@@ -303,7 +377,7 @@ export class PostProcessingHandler {
             if (menu && this._passIndices === null) {
                 if (this._menuEntry)
                     this._menuEntry.remove();
-                
+
                 const select = document.createElement("select");
                 select.multiple = true;
                 const defaultOpt = document.createElement("option");
@@ -327,73 +401,11 @@ export class PostProcessingHandler {
                     else {
                         this._passIndices = indices;
                     }
-
-                    this.applyEffects(context);
+                    this.applyEffects(this.context);
                 });
             }
         }
     }
 
-    private _menuEntry: HTMLSelectElement | null = null;
-    private _passIndices: number[] | null = null;
-
-    private orderEffects() {
-        if (debug) console.log("Before ordering effects", [...this._effects]);
-
-
-
-        // Order of effects for correct results.
-        // Aligned with https://github.com/pmndrs/postprocessing/wiki/Effect-Merging#effect-execution-order
-        // We can not put this into global scope because then the module might not yet be initialized
-        effectsOrder ??= [
-            MODULES.POSTPROCESSING.MODULE.NormalPass,
-            MODULES.POSTPROCESSING.MODULE.DepthDownsamplingPass,
-            MODULES.POSTPROCESSING.MODULE.SMAAEffect,
-            MODULES.POSTPROCESSING.MODULE.SSAOEffect,
-            MODULES.POSTPROCESSING_AO.MODULE.N8AOPostPass,
-            MODULES.POSTPROCESSING.MODULE.TiltShiftEffect,
-            MODULES.POSTPROCESSING.MODULE.DepthOfFieldEffect,
-            MODULES.POSTPROCESSING.MODULE.ChromaticAberrationEffect,
-            MODULES.POSTPROCESSING.MODULE.BloomEffect,
-            MODULES.POSTPROCESSING.MODULE.SelectiveBloomEffect,
-            MODULES.POSTPROCESSING.MODULE.VignetteEffect,
-            MODULES.POSTPROCESSING.MODULE.PixelationEffect,
-            MODULES.POSTPROCESSING.MODULE.ToneMappingEffect,
-            MODULES.POSTPROCESSING.MODULE.HueSaturationEffect,
-            MODULES.POSTPROCESSING.MODULE.BrightnessContrastEffect,
-            // __SHARPENING_MODULE._SharpeningEffect,
-        ];
-
-
-        // TODO: enforce correct order of effects (e.g. DOF before Bloom)
-        const effects = this._effects;
-        effects.sort((a, b) => {
-            // we use find index here because sometimes constructor names are prefixed with `_`
-            // TODO: find a more robust solution that isnt name based (not sure if that exists tho... maybe we must give effect TYPES some priority/index)
-            const aidx = effectsOrder!.findIndex(e => a.constructor.name.endsWith(e.name));
-            const bidx = effectsOrder!.findIndex(e => b.constructor.name.endsWith(e.name));
-            // Unknown effects should be rendered first
-            if (aidx < 0) {
-                if (debug) console.warn("Unknown effect found: ", a.constructor.name);
-                return -1;
-            }
-            else if (bidx < 0) {
-                if (debug) console.warn("Unknown effect found: ", b.constructor.name);
-                return 1;
-            }
-            if (aidx < 0) return 1;
-            if (bidx < 0) return -1;
-            return aidx - bidx;
-        });
-        if (debug) console.log("After ordering effects", [...this._effects]);
-        for (let i = 0; i < effects.length; i++) {
-            const effect = effects[i] as any;
-            if (effect?.configuration?.gammaCorrection !== undefined) {
-                const isLast = i === effects.length - 1;
-                effect.configuration.gammaCorrection = isLast;
-            }
-        }
-    }
 }
 
-let effectsOrder: Array<Constructor<Effect | Pass>> | null = null;

package/src/engine-components/postprocessing/Volume.ts

@@ -1,4 +1,4 @@
-import type { Effect } from "postprocessing";
+import type { Effect, EffectComposer } from "postprocessing";
 
 import { isDevEnvironment, showBalloonMessage } from "../../engine/debug/index.js";
 import { Context } from "../../engine/engine_context.js";
@@ -56,6 +56,9 @@ export class Volume extends Behaviour implements IEditorModificationReceiver, IP
         return this._activeEffects;
     }
 
+    get dirty() { return this._isDirty; }
+    set dirty(value: boolean) { this._isDirty = value; }
+
     @serializeable(VolumeProfile)
     sharedProfile?: VolumeProfile;
 
@@ -184,40 +187,64 @@ export class Volume extends Behaviour implements IEditorModificationReceiver, IP
 
                 this.context.composer.setMainScene(this.context.scene);
 
-                const composer = this.context.composer;
-                if (this.multisampling === "auto") {
-
-                    const timeSinceLastChange = this.context.time.realtimeSinceStartup - this._multisampleAutoChangeTime;
+                const composer = this.context.composer as EffectComposer;
 
-                    if (this.context.time.realtimeSinceStartup - this._componentEnabledTime > 2
-                        && timeSinceLastChange > .5
-                    ) {
-                        const prev = composer.multisampling;
+                if (this.multisampling === "auto") {
 
-                        if (composer.multisampling > 0 && this.context.time.smoothedFps <= 50) {
-                            this._multisampleAutoChangeTime = this.context.time.realtimeSinceStartup;
-                            this._multisampleAutoDecreaseTime = this.context.time.realtimeSinceStartup;
-                            composer.multisampling *= .5;
-                            composer.multisampling = Math.floor(composer.multisampling);
-                            if (debug) console.debug(`[PostProcessing] Reduced multisampling from ${prev} to ${composer.multisampling}`);
+                    // If the postprocessing handler is using depth+normals (e.g. with SMAA) we ALWAYS disable multisampling to avoid ugly edges
+                    if (this._postprocessing && (this._postprocessing.hasSmaaEffect)) {
+                        if (composer.multisampling !== 0) {
+                            composer.multisampling = 0;
+                            if (debug || isDevEnvironment()) {
+                                console.warn(`[PostProcessing] Disabling multisampling you're using SMAA and have set the 'multisampling: auto' on your PostprocessingManager/Volume component. If you need anti-aliasing, consider adding an Antialiasing component or SMAA effect to the PostprocessingManager.`);
+                            }
                         }
-                        // if performance is good for a while try increasing multisampling again
-                        else if (timeSinceLastChange > 1
-                            && this.context.time.smoothedFps >= 59
-                            && composer.multisampling < this.context.renderer.capabilities.maxSamples
-                            && this.context.time.realtimeSinceStartup - this._multisampleAutoDecreaseTime > 10
+                    }
+                    else {
+                        const timeSinceLastChange = this.context.time.realtimeSinceStartup - this._multisampleAutoChangeTime;
+
+                        if (this.context.time.realtimeSinceStartup - this._componentEnabledTime > 2
+                            && timeSinceLastChange > .5
                         ) {
-                            this._multisampleAutoChangeTime = this.context.time.realtimeSinceStartup;
-                            composer.multisampling = composer.multisampling <= 0 ? 1 : composer.multisampling * 2;
-                            composer.multisampling = Math.floor(composer.multisampling);
-                            if (debug) console.debug(`[PostProcessing] Increased multisampling from ${prev} to ${composer.multisampling}`);
+                            const prev = composer.multisampling;
+
+                            if (composer.multisampling > 0 && this.context.time.smoothedFps <= 50) {
+                                this._multisampleAutoChangeTime = this.context.time.realtimeSinceStartup;
+                                this._multisampleAutoDecreaseTime = this.context.time.realtimeSinceStartup;
+                                let newMultiSample = composer.multisampling * .5;
+                                newMultiSample = Math.floor(newMultiSample);
+                                if (newMultiSample != composer.multisampling) {
+                                    composer.multisampling = newMultiSample;
+                                }
+                                if (debug) console.debug(`[PostProcessing] Reduced multisampling from ${prev} to ${composer.multisampling}`);
+                            }
+                            // if performance is good for a while try increasing multisampling again
+                            else if (timeSinceLastChange > 1
+                                && this.context.time.smoothedFps >= 59
+                                && composer.multisampling < this.context.renderer.capabilities.maxSamples
+                                && this.context.time.realtimeSinceStartup - this._multisampleAutoDecreaseTime > 10
+                            ) {
+                                this._multisampleAutoChangeTime = this.context.time.realtimeSinceStartup;
+                                let newMultiSample = composer.multisampling <= 0 ? 1 : composer.multisampling * 2;
+                                newMultiSample = Math.floor(newMultiSample);
+                                if (newMultiSample !== composer.multisampling) {
+                                    composer.multisampling = newMultiSample;
+                                }
+                                if (debug) console.debug(`[PostProcessing] Increased multisampling from ${prev} to ${composer.multisampling}`);
+                            }
                         }
                     }
                 }
                 else {
-                    composer.multisampling = Math.max(0, Math.min(this.multisampling, this.context.renderer.capabilities.maxSamples));
+                    const newMultiSample = Math.max(0, Math.min(this.multisampling, this.context.renderer.capabilities.maxSamples));
+                    if (newMultiSample !== composer.multisampling)
+                        composer.multisampling = newMultiSample;
                 }
 
+                // Fix multisampling for the composer, it ONLY needs to be done for the input buffer
+                // this is super important for performance a negative visual impact
+                composer.outputBuffer.samples = 0;
+
                 // only set the main camera if any pass has a different camera
                 // trying to avoid doing this regularly since it involves doing potentially unnecessary work
                 // https://github.com/pmndrs/postprocessing/blob/3d3df0576b6d49aec9e763262d5a1ff7429fd91a/src/core/EffectComposer.js#L406
@@ -244,7 +271,7 @@ export class Volume extends Behaviour implements IEditorModificationReceiver, IP
     private _isDirty: boolean = false;
 
     private apply() {
-        if (debug) console.log(`Apply PostProcessing "${this.name}"`);
+        if (debug) console.log(`Apply PostProcessing "${this.name || "unnamed"}"`);
 
         if (isDevEnvironment()) {
             if (this._lastApplyTime !== undefined && Date.now() - this._lastApplyTime < 100) {
@@ -256,7 +283,6 @@ export class Volume extends Behaviour implements IEditorModificationReceiver, IP
         }
 
         this._isDirty = false;
-        this.unapply();
 
         this._activeEffects.length = 0;
         // get from profile
@@ -299,16 +325,13 @@ export class Volume extends Behaviour implements IEditorModificationReceiver, IP
                         console.warn(`[PostProcessing] No composer found`);
                     }
                 })
-
+        }
+        else {
+            this._postprocessing?.unapply(false);
         }
 
     }
 
-    private unapply() {
-        this._postprocessing?.unapply();
-    }
-
-
     private _applyPostQueue() {
         if (this._modificationQueue) {
             for (const entry of this._modificationQueue.values()) this.onEditorModification(entry);

package/src/engine-components/postprocessing/index.ts

@@ -1,5 +1,6 @@
 export * from "./PostProcessingEffect.js";
 export * from "./PostProcessingHandler.js"
+export { PostProcessingEffectPriority } from "./utils.js";
 export { PostProcessingManager } from "./Volume.js"
 export * from "./VolumeParameter.js"
-export * from "./VolumeProfile.js";
+export * from "./VolumeProfile.js";