@needle-tools/engine 4.7.0-next.4ec920e → 4.7.0-next.a507c47

package/plugins/vite/alias.js

@@ -3,14 +3,33 @@ import path from 'path';
 
 const projectDir = process.cwd() + "/";
 
+/**
+ * @typedef {"auto-resolve" | ((res: string, packageName: string, index: number, path: string) => string | null | void)} PackageResolveValue
+ */
+
 /** these are alias callbacks as in the vite.alias dictionary
  * the first argument is the already resoled absolute path (it is only invoked if the path was found in node_modules)
  * the 2,3,4 args are the same as in vite.alias (packageName, index, path);
  */
 /**
- * @type {Record<string, null | ((res: string, packageName: string, index: number, path: string) => string | null | void)>}
+ * @type {Record<string, PackageResolveValue>}
  */
 const packages_to_resolve = {
+    // We are currently overriding "three" resolution to ensure that all dependencies resolve to the same three.js version.
+    // This is hacky, but the alternative is potentially having conflicting three.js versions since some packages are 
+    // stubborn with their peer dependencies or just slow (slower as we) with updating.
+    // NOT adding this allows node.js to correctly resolve `exports` specified in three.js package.json;
+    // since we're overriding resolution here we need to manually resolve the subset of exports that we use.
+    'three/addons': (res, packageName, index, path) => {
+        return "three/examples/jsm";
+    },
+    'three/nodes': (res, packageName, index, path) => {
+        return "three/examples/jsm/nodes/Nodes.js";
+    },
+    'three': (res, packageName, index, _path) => {
+        return path.resolve(projectDir, 'node_modules', 'three');
+    },
+
     // Handle all previous imports where users did import using @needle-engine/src
     '@needle-tools/engine/src': (res, packageName, index, path) => {
         // resolve old engine/src imports UNLESS it's the asap plugin (the asap plugin currently only exists in the src folder)
@@ -31,13 +50,12 @@ const packages_to_resolve = {
         }
     },
 
-    /* 
-    Removed. Three.js is manually resolved below to ensure all dependencies resolve to the same three.js version.
-    'three': null,
-    */
-    'peerjs': null,
-    'websocket-ts': null,
-    'md5': null,
+    // Auto resolve to 'node_modules/<name>' or '@needle-tools/engine/node_modules/<name>'
+    'peerjs': "auto-resolve",
+    'websocket-ts': "auto-resolve",
+    'md5': "auto-resolve",
+    'postprocessing': "auto-resolve",
+    '@dimforge/rapier3d-compat': "auto-resolve",
 }
 
 /**
@@ -67,6 +85,7 @@ export const needleViteAlias = (command, config, userSettings) => {
     }
 
 
+    /** @type {import("vite").Plugin} */
     const aliasPlugin = {
         name: "needle-alias",
         config(config) {
@@ -75,11 +94,9 @@ export const needleViteAlias = (command, config, userSettings) => {
             if (!config.resolve.alias) config.resolve.alias = {};
             const aliasDict = config.resolve.alias;
 
-            addThreeJSResolvers(aliasDict);
-
             for (const name in packages_to_resolve) {
                 if (!aliasDict[name]) {
-                    addPathResolver(name, aliasDict, packages_to_resolve[name]);
+                    addPathResolver(name, aliasDict, packages_to_resolve[name], debug ?? false);
                 }
             }
 
@@ -127,43 +144,36 @@ export const needleViteAlias = (command, config, userSettings) => {
     if (debug) return [debuggingPlugin, aliasPlugin];
     return [aliasPlugin];
 
-    function addThreeJSResolvers(aliasDict) {
-        // We are currently overriding "three" resolution to ensure that all dependencies resolve to the same three.js version.
-        // This is hacky, but the alternative is potentially having conflicting three.js versions since some packages are 
-        // stubborn with their peer dependencies or just slow (slower as we) with updating.
-        // NOT adding this allows node.js to correctly resolve `exports` specified in three.js package.json;
-        // since we're overriding resolution here we need to manually resolve the subset of exports that we use.
-        aliasDict['three/addons'] = (res, packageName, index, path) => {
-            return "three/examples/jsm";
-        };
-        aliasDict['three/nodes'] = (res, packageName, index, path) => {
-            return "three/examples/jsm/nodes/Nodes.js";
-        };
-        aliasDict['three'] = (res, packageName, index, _path) => {
-            return path.resolve(projectDir, 'node_modules', 'three');
-        };
-    }
-
-    function addPathResolver(name, aliasDict, cb) {
+    /**
+     * Adds a path resolver to the alias dictionary.
+     * @param {string} name - The name of the package to resolve.
+     * @param {import("vite").AliasOptions} aliasDict - The alias dictionary to add the resolver to.
+     * @param {PackageResolveValue | null} value - A callback function to override the default resolution behavior.
+     * @param {boolean} debug - Whether to log debug information.
+     * @returns {void}
+     */
+    function addPathResolver(name, aliasDict, value, debug) {
         // If a package at the node_modules path exist we resolve the request there
         // introduced in 89a50718c38940abb99ee16c5e029065e41d7d65
-        const fullpath = path.resolve(projectDir, 'node_modules', name);
-        if (typeof cb !== "function") cb = null;
-        const isDevEnvironment = process.env.NODE_ENV === "development";
+        const callback = typeof value === "function" ? value : null;
+
+        let fullpath = path.resolve(projectDir, 'node_modules', name);
+        if (!existsSync(fullpath)) {
+            fullpath = path.resolve(projectDir, 'node_modules', "@needle-tools/engine", "node_modules", name);
+        }
 
         if (existsSync(fullpath)) {
             aliasDict[name] = (packageName, index, path) => {
-                if (cb !== null && !isDevEnvironment) {
-                    const overrideResult = cb(fullpath, packageName, index, path);
-                    if (overrideResult !== undefined)
+                if (callback !== null) {
+                    const overrideResult = callback(fullpath, packageName, index, path);
+                    if (typeof overrideResult === "string")
                         if (existsSync(overrideResult)) {
-                            console.warn(`[needle-alias] \"${path}\" was requested and resolved to \"${overrideResult}\"`);
+                            if (debug) console.warn(`[needle-alias] \"${path}\" was requested and resolved to \"${overrideResult}\"`);
                             return overrideResult;
                         }
                 }
 
-                if (path != packageName) {
-                    // TODO: we might want to check if the package.json exports contains the path to see if it's valid
+                if (debug && path != packageName) {
                     console.warn(`[needle-alias] \"${path}\" was requested and resolved to \"${fullpath}\"`);
                 }
 

package/plugins/vite/index.js

@@ -66,6 +66,7 @@ export { needleBuildInfo } from "./buildinfo.js";
 import { needleServer } from "./server.js";
 import { needleNPM } from "./npm.js";
 import { needleTransformCode } from "./transform.js";
+import { needleMaterialXLoader } from "./materialx.js";
 export { needleServer } from "./server.js";
 
 
@@ -133,6 +134,7 @@ export const needlePlugins = async (command, config = undefined, userSettings =
         needlePWA(command, config, userSettings),
         needleServer(command, config, userSettings),
         needleNPM(command, config, userSettings),
+        needleMaterialXLoader(command, config, userSettings),
     ];
 
     const asap = await needleAsap(command, config, userSettings);

package/plugins/vite/materialx.js

@@ -0,0 +1,30 @@
+import { existsSync } from 'fs';
+
+const materialx_packagejson_path = "node_modules/@needle-tools/materialx/package.json";
+const materialx_import_chunk =
+    `import { useNeedleMaterialX } from "@needle-tools/materialx/needle";
+useNeedleMaterialX();
+`
+
+/**
+ * Vite plugin to automatically setup the MaterialX loader for Needle Engine.
+ * @param {string} command 
+ * @param {object} config
+ * @param {import('../types/userconfig.js').userSettings} userSettings
+ * @returns {import('vite').Plugin}
+ */
+export const needleMaterialXLoader = (command, config, userSettings) => {
+
+    return {
+        name: 'needle-materialx-loader',
+        transform: (code, id) => {
+            if (id.endsWith("src/main.ts")) {
+                if (userSettings?.loadMaterialX !== false && existsSync(materialx_packagejson_path)) {
+                    console.log("[needle-materialx-loader] Adding MaterialX import to main.ts");
+                    code = materialx_import_chunk + "\n" + code;
+                }
+            }
+            return code;
+        }
+    }
+}

package/plugins/vite/transform.js

@@ -3,6 +3,7 @@
 
 /** 
  * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin[]}
  */
 export const needleTransformCode = (command, config, userSettings) => {
 

package/src/engine-components/postprocessing/Effects/Antialiasing.ts

@@ -1,10 +1,13 @@
 import { MODULES } from "../../../engine/engine_modules.js";
 import { serializable } from "../../../engine/engine_serialization.js";
+import { getParam } from "../../../engine/engine_utils.js";
 import { type EffectProviderResult, PostProcessingEffect } from "../PostProcessingEffect.js";
 import { VolumeParameter } from "../VolumeParameter.js";
 import { registerCustomEffectType } from "../VolumeProfile.js";
 
 
+const debug = getParam("debugpost");
+
 
 export enum QualityLevel {
     LOW = 0,
@@ -32,15 +35,19 @@ export class Antialiasing extends PostProcessingEffect {
 
     onCreateEffect(): EffectProviderResult {
         const effect = new MODULES.POSTPROCESSING.MODULE.SMAAEffect({
-            preset: MODULES.POSTPROCESSING.MODULE.SMAAPreset.HIGH,
+            preset: this.preset?.value ?? MODULES.POSTPROCESSING.MODULE.SMAAPreset.HIGH,
             edgeDetectionMode: MODULES.POSTPROCESSING.MODULE.EdgeDetectionMode.LUMA,
             // Keep predication mode disabled (default) since it looks better
             // predicationMode: MODULES.POSTPROCESSING.MODULE.PredicationMode.DEPTH,
         });
 
         this.preset.onValueChanged = (newValue) => {
+            if(debug) console.log("Antialiasing preset changed to", newValue);
             effect.applyPreset(newValue);
         };
+        // setInterval(()=> {
+        //     effect.applyPreset(Math.floor(Math.random()*3))
+        // }, 1000)
 
         // effect.edgeDetectionMaterial.edgeDetectionThreshold = .01;
 

package/src/engine-components/postprocessing/Effects/ScreenspaceAmbientOcclusionN8.ts

@@ -124,7 +124,7 @@ export class ScreenSpaceAmbientOcclusionN8 extends PostProcessingEffect {
             cam,
             width, height
         ) as N8AOPostPass;
-        ssao.name = "SSAO N8";
+        ssao.name = "SSAO_N8";
 
         const mode = ScreenSpaceAmbientOcclusionN8QualityMode[this.quality];
         ssao.setQualityMode(mode);

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

@@ -162,9 +162,11 @@ 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,
@@ -173,12 +175,23 @@ export class PostProcessingHandler {
                         }
                     }
                     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 {
@@ -403,7 +416,7 @@ export class PostProcessingHandler {
                     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;
@@ -448,7 +461,6 @@ export class PostProcessingHandler {
                 }
                 foundEnabled = true;
             }
-
             pass.renderToScreen = renderToScreen;
 
             if ((pass as any)?.configuration !== undefined) {

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).`);
                             }
                         }
                     }