@needle-tools/engine 2.67.12-pre → 2.67.13-pre

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "2.67.12-pre",
+    "version": "2.67.13-pre",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development, and can be deployed anywhere. It is flexible, extensible, and collaboration and XR come naturally.",
     "main": "dist/needle-engine.umd.cjs",
     "module": "lib/needle-engine.js",
@@ -59,8 +59,8 @@
         "flatbuffers": "2.0.4",
         "md5": "^2.3.0",
         "peerjs": "1.3.2",
-        "simplex-noise": "^4.0.1",
         "postprocessing": "^6.30.1",
+        "simplex-noise": "^4.0.1",
         "stats.js": "^0.17.0",
         "three": "npm:@needle-tools/three@^0.146.7",
         "three-mesh-ui": "^6.4.5",
@@ -75,10 +75,9 @@
         "@needle-tools/helper": "^0.4.5",
         "@needle-tools/needle-component-compiler": "1.9.3",
         "@types/three": "0.146.0",
-        "copy-files-from-to": "^3.7.0",
         "esbuild": "^0.15.10",
         "esbuild-node-externals": "^1.5.0",
-        "fs-extra": "^11.1.0",
+        "fs-extra": "^11.1.1",
         "jsdoc-babel": "^0.5.0",
         "jsdoc-to-markdown": "^7.1.1",
         "madge": "^5.0.1",

package/plugins/vite/copyfiles.js

@@ -1,7 +1,6 @@
 
-import { copy } from 'fs-extra'
-import { resolve } from 'path'
-import { existsSync } from 'fs';
+import { resolve, join } from 'path'
+import { existsSync, statSync, mkdirSync, readdirSync, copyFileSync, mkdir } from 'fs';
 
 
 /** copy files on build from assets to dist */
@@ -11,32 +10,60 @@ export const needleCopyFiles = (command, config, userSettings) => {
         return;
     }
 
+    const copyIncludesFromEngine = config?.copyIncludesFromEngine ?? true;
+
     return {
         name: 'needle-copy-files',
         apply: 'build',
         async closeBundle() {
             const baseDir = process.cwd();
+            const pluginName = "needle-copy-files";
 
             const outdirName = "dist";
             const outDir = resolve(baseDir, outdirName);
             if (!existsSync(outDir)) {
-                console.log(`No ${outdirName} folder found, skipping copy files: ${outDir}`);
-                return;
+                mkdirSync(outDir);
+            }
+
+            if (copyIncludesFromEngine !== false) {
+                // copy include from engine
+                const engineIncludeDir = resolve(baseDir, 'node_modules', '@needle-tools', 'engine', 'src', 'include');
+                if (existsSync(engineIncludeDir)) {
+                    console.log(`[${pluginName}] - Copy engine include to ${baseDir}/include`)
+                    const targetDir = resolve(baseDir, 'include');
+                    copyRecursiveSync(engineIncludeDir, targetDir);
+                }
             }
+
             // copy assets dir
             const assetsDir = resolve(baseDir, 'assets');
             if (existsSync(assetsDir)) {
-                console.log(`Copy assets to ${outdirName}/assets`)
+                console.log(`[${pluginName}] - Copy assets to ${outdirName}/assets`)
                 const targetDir = resolve(outDir, 'assets');
-                await copy(assetsDir, targetDir, { overwrite: true });
+                copyRecursiveSync(assetsDir, targetDir);
             }
             // copy include dir
             const includeDir = resolve(baseDir, 'include');
             if (existsSync(includeDir)) {
-                console.log(`Copy include to ${outdirName}/include`)
+                console.log(`[${pluginName}] - Copy include to ${outdirName}/include`)
                 const targetDir = resolve(outDir, 'include');
-                await copy(includeDir, targetDir, { overwrite: true });
+                copyRecursiveSync(includeDir, targetDir);
             }
         }
     }
-}
+}
+
+function copyRecursiveSync(src, dest) {
+    var exists = existsSync(src);
+    var stats = exists && statSync(src);
+    var isDirectory = exists && stats.isDirectory();
+    if (isDirectory) {
+        if (!existsSync(dest))
+            mkdirSync(dest);
+        readdirSync(src).forEach(function (childItemName) {
+            copyRecursiveSync(join(src, childItemName), join(dest, childItemName));
+        });
+    } else {
+        copyFileSync(src, dest);
+    }
+};

package/plugins/vite/reload.js

@@ -43,7 +43,8 @@ export const needleReload = (command, config, userSettings) => {
             else if (!config.server.watch.ignored) config.server.watch.ignored = [];
             for (const pattern of ignorePatterns)
                 config.server.watch.ignored.push(pattern);
-            setTimeout(() => console.log("Updated server ignore patterns: ", config.server.watch.ignored), 100);
+            if(config?.debug === true || userSettings?.debug === true)
+                setTimeout(() => console.log("Updated server ignore patterns: ", config.server.watch.ignored), 100);
         },
         handleHotUpdate(args) {
             args.buildDirectory = buildDirectory;

package/src/engine-components/Animation.ts

@@ -145,7 +145,7 @@ export class Animation extends Behaviour {
         return false;
     }
 
-    play(clipOrNumber: AnimationClip | number | string | undefined, options?: PlayOptions): Promise<AnimationAction> | void {
+    play(clipOrNumber: AnimationClip | number | string | undefined = 0, options?: PlayOptions): Promise<AnimationAction> | void {
         if (debug) console.log("PLAY", clipOrNumber)
         this.init();
         if (!this.mixer) {
@@ -171,8 +171,8 @@ export class Animation extends Behaviour {
         if (!options) options = {};
         if (!options.minMaxOffsetNormalized) options.minMaxOffsetNormalized = this.minMaxOffsetNormalized;
         if (!options.minMaxSpeed) options.minMaxSpeed = this.minMaxSpeed;
-        if (!options.loop) options.loop = this.loop;
-        if (!options.clampWhenFinished) options.clampWhenFinished = this.clampWhenFinished;
+        if (options.loop === undefined) options.loop = this.loop;
+        if (options.clampWhenFinished === undefined) options.clampWhenFinished = this.clampWhenFinished;
         for (const act of this.actions) {
             if (act.getClip() === clip) {
                 return this.internalOnPlay(act, options);

package/src/engine-components/Renderer.ts

@@ -639,7 +639,7 @@ export class Renderer extends Behaviour implements IRenderer {
         }
     }
 
-    private applySettings(go: THREE.Object3D) {
+    applySettings(go: THREE.Object3D) {
         go.receiveShadow = this.receiveShadows;
         if (this.shadowCastingMode == ShadowCastingMode.On) {
             go.castShadow = true;
@@ -734,15 +734,16 @@ class InstancingHandler {
     public setup(renderer: Renderer, obj: THREE.Object3D, context: Context, handlesArray: InstanceHandle[] | null, args: InstancingSetupArgs, level: number = 0)
         : InstanceHandle[] | null {
 
+        // make sure setting casting settings are applied so when we add the mesh to the InstancedMesh we can ask for the correct cast shadow setting
+        renderer.applySettings(obj);
         const res = this.tryCreateOrAddInstance(obj, context, args);
         if (res) {
             renderer.loadProgressiveTextures(res.instancer.material);
             if (handlesArray === null) handlesArray = [];
             handlesArray.push(res);
-            return handlesArray;
         }
 
-        if (level <= 0 && obj.type !== "Mesh") {
+        else if (level <= 0 && obj.type !== "Mesh") {
             const nextLevel = level + 1;
             for (const ch of obj.children) {
                 handlesArray = this.setup(renderer, ch, context, handlesArray, args, nextLevel);
@@ -799,10 +800,8 @@ class InstancingHandler {
         let previousMatrix: THREE.Matrix4 = obj.matrixWorld.clone();
         const matrixChangeWrapper = (a: Matrix4, b: Matrix4) => {
             const newMatrixWorld = original(a, b);
-            // console.warn("MULT", obj.matrixWorldNeedsUpdate);
             if (obj[NEED_UPDATE_INSTANCE_KEY] || previousMatrix.equals(newMatrixWorld) === false) {
                 previousMatrix.copy(newMatrixWorld)
-                // handle.setMatrix(newMatrixWorld);
                 obj[NEED_UPDATE_INSTANCE_KEY] = true;
             }
             return newMatrixWorld;
@@ -865,6 +864,13 @@ class InstanceHandle {
 
 class InstancedMeshRenderer {
 
+    set castShadow(val: boolean) {
+        this.inst.castShadow = val;
+    }
+    set receiveShadow(val: boolean) {
+        this.inst.receiveShadow = val;
+    }
+
     public name: string = "";
     public geo: THREE.BufferGeometry;
     public material: THREE.Material;
@@ -915,6 +921,14 @@ class InstancedMeshRenderer {
             return null;
         }
         const handle = new InstanceHandle(-1, obj, this);
+
+        if (obj.castShadow === true && this.inst.castShadow === false) {
+            this.inst.castShadow = true;
+        }
+        if (obj.receiveShadow === true && this.inst.receiveShadow === false) {
+            this.inst.receiveShadow = true;
+        }
+
         this.add(handle);
         return handle;
     }

package/src/engine-components/api.ts

@@ -0,0 +1 @@
+export * from "./ui/PointerEvents"

package/src/needle-engine.ts

@@ -11,6 +11,7 @@ export { GameObject, Behaviour } from "./engine-components/Component";
 export { serializable, serializeable } from "./engine/engine_serialization_decorator";
 export { Collision } from "./engine/engine_types";
 export * from "./engine/api";
+export * from "./engine-components/api";
 export * from "./engine-components/codegen/components";
 export * from "./engine-components/js-extensions/Object3D";