@needle-tools/engine 4.6.2 → 4.6.4

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

@@ -6,6 +6,7 @@ import { showBalloonWarning } from "../../engine/debug/index.js";
 import { MODULES } from "../../engine/engine_modules.js";
 import { Context } from "../../engine/engine_setup.js";
 import { Graphics } from "../../engine/engine_three_utils.js";
+import { Constructor } from "../../engine/engine_types.js";
 import { getParam } from "../../engine/engine_utils.js";
 import { Camera } from "../Camera.js";
 import { threeToneMappingToEffectMode } from "./Effects/Tonemapping.utils.js";
@@ -161,21 +162,36 @@ export class PostProcessingHandler {
                     const res = component.apply(ctx);
                     if (!res) continue;
 
+                    const name = component.typeName || component.constructor.name;
 
                     if (Array.isArray(res)) {
                         for (const effect of res) {
+                            if (!validateEffect(name, effect)) continue;
                             this._effects.push({
                                 effect,
+                                typeName: component.typeName,
                                 priority: component.order
                             });
                         }
                     }
                     else {
+                        if (!validateEffect(name, res)) continue;
                         this._effects.push({
                             effect: res,
+                            typeName: component.typeName,
                             priority: component.order
                         });
                     }
+
+                    function validateEffect(source: string, effect: Effect | Pass): boolean {
+                        if (!effect) {
+                            return false;
+                        }
+                        if (!(effect instanceof MODULES.POSTPROCESSING.MODULE.Effect || effect instanceof MODULES.POSTPROCESSING.MODULE.Pass)) {
+                            console.warn(`PostprocessingEffect ${source} created neither Effect nor Pass - this might be caused by a bundler error or false import. Below you find some possible solutions:\n- If you create custom effect try creating it like this: 'new NEEDLE_ENGINE_MODULES.POSTPROCESSING.MODULE.Effect(...)' instead of 'new Effect(...)'`);
+                        }
+                        return true;
+                    }
                 }
             }
             else {
@@ -244,7 +260,11 @@ export class PostProcessingHandler {
                 const tonemapping = new MODULES.POSTPROCESSING.MODULE.ToneMappingEffect();
                 tonemapping.name = `ToneMapping (${renderer.toneMapping})`;
                 tonemapping.mode = threeToneMappingToEffectMode(renderer.toneMapping);
-                this._effects.push({ effect: tonemapping, priority: PostProcessingEffectOrder.ToneMapping });
+                this._effects.push({
+                    typeName: "ToneMapping",
+                    effect: tonemapping,
+                    priority: PostProcessingEffectOrder.ToneMapping
+                });
             }
         }
 
@@ -363,7 +383,8 @@ export class PostProcessingHandler {
             const effectsToMerge: Array<Effect> = [];
             let hasConvolutionEffectInArray = false;
 
-            for (const entry of this._effects) {
+            for (let i = 0; i < this._effects.length; i++) {
+                const entry = this._effects[i];
                 const ef = entry.effect;
 
                 if (ef instanceof MODULES.POSTPROCESSING.MODULE.SMAAEffect) {
@@ -373,8 +394,7 @@ export class PostProcessingHandler {
                     this._anyPassHasNormal = true;
                 }
 
-
-                // There can be only one tonemapping effect in the scene, so we can skip all others
+                // There can be only one tonemapping effect in the scene, so we skip all others
                 if (ef instanceof MODULES.POSTPROCESSING.MODULE.ToneMappingEffect && activeTonemappingEffect !== ef) {
                     // If we already have a tonemapping effect, we can skip this one
                     continue;
@@ -383,18 +403,20 @@ export class PostProcessingHandler {
                 // We can also not merge multiple effects of the same type in one pass
                 // So we first need to create a new pass with whatever effects we have so far
                 // TODO: this seems to work fine for some effects (like ColorAdjustments) and only caused issues with multiple Tonemapping effects so far which is handled above
-                // const constructor = ef.constructor as Constructor<Effect | Pass>;
-                // if(effectsToMerge.find(e => e.constructor === constructor)) {
-                //     // this.createPassForMergeableEffects(effectsToMerge, composer, cam, scene);
+                // const constructor = ef.constructor;
+                // if (effectsToMerge.find(e => e.constructor === constructor)) {
+                //     this.createPassForMergeableEffects(effectsToMerge, composer, cam, scene);
                 // }
 
+
+
                 if (ef instanceof MODULES.POSTPROCESSING.MODULE.Effect) {
                     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(", "));
+                            if (debug) console.log("[PostProcessing] → Merging effects [" + effectsToMerge.map(e => e.name).join(", ") + "]");
                             this.createPassForMergeableEffects(effectsToMerge, composer, cam, scene);
                         }
                         hasConvolutionEffectInArray = true;
@@ -415,28 +437,43 @@ export class PostProcessingHandler {
                     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.passes.forEach(p => p.dispose());
             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++) {
+        let foundEnabled = false;
+        for (let i = composer.passes.length - 1; i >= 0; i--) {
             const pass = composer.passes[i];
-            const isLast = i === composer.passes.length - 1;
+            let gammaCorrect = false;
+            let renderToScreen = false;
+            if (pass.enabled) {
+                if (!foundEnabled) {
+                    gammaCorrect = true;
+                    renderToScreen = true;
+                }
+                foundEnabled = true;
+            }
+            pass.renderToScreen = renderToScreen;
+
             if ((pass as any)?.configuration !== undefined) {
-                (pass as any).configuration.gammaCorrection = isLast;
+                (pass as any).configuration.gammaCorrection = gammaCorrect;
             }
             else if ("autosetGamma" in pass) {
                 // Some effects have a autosetGamma property that we can use to set the gamma correction
-                pass.autosetGamma = isLast;
+                pass.autosetGamma = gammaCorrect;
             }
 
+
             this._anyPassHasDepth ||= pass.needsDepthTexture;
+
         }
 
         // DEBUG LAND BELOW

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

@@ -194,7 +194,7 @@ export class Volume extends Behaviour implements IEditorModificationReceiver, IP
                         if (this._postprocessing.multisampling !== 0) {
                             this._postprocessing.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.`);
+                                console.log(`[PostProcessing] multisampling is disabled because it's set to 'auto' on your PostprocessingManager/Volume component that also has an SMAA effect.\n\nIf you need multisampling consider changing 'auto' to a fixed value (e.g. 4).`);
                             }
                         }
                     }

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

@@ -61,6 +61,7 @@ export function getPostProcessingManager(effect: PostProcessingEffect): IPostPro
 export type PostprocessingEffectData = {
     effect: Effect | Pass;
     priority?: number,
+    typeName?: string | null | undefined,
 }
 
 /**