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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "2.67.12-pre",
+    "version": "2.67.14-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/codegen/register_types.js

@@ -1,5 +1,5 @@
 import { TypeStore } from "./../engine_typestore"
-
+
 // Import types
 import { __Ignore } from "../../engine-components/codegen/components";
 import { AlignmentConstraint } from "../../engine-components/AlignmentConstraint";
@@ -179,7 +179,7 @@ import { XRGrabModel } from "../../engine-components/WebXRGrabRendering";
 import { XRGrabRendering } from "../../engine-components/WebXRGrabRendering";
 import { XRRig } from "../../engine-components/WebXRRig";
 import { XRState } from "../../engine-components/XRFlag";
-
+
 // Register types
 TypeStore.add("__Ignore", __Ignore);
 TypeStore.add("AlignmentConstraint", AlignmentConstraint);

package/src/engine/engine_input.ts

@@ -478,6 +478,8 @@ export class Input extends EventTarget {
 
         while (evt.button >= this._pointerPositionDown.length) this._pointerPositionDown.push(new THREE.Vector2());
         this._pointerPositionDown[evt.button].set(evt.clientX, evt.clientY);
+        while (evt.button >= this._pointerPositions.length) this._pointerPositions.push(new THREE.Vector2());
+        this._pointerPositions[evt.button].set(evt.clientX, evt.clientY);
 
         if (evt.button >= this._pointerDownTime.length) this._pointerDownTime.push(0);
         this._pointerDownTime[evt.button] = this.context.time.time;
@@ -552,8 +554,8 @@ export class Input extends EventTarget {
 
         const lf = this._pointerPositionsLastFrame[evt.button];
         lf.copy(this._pointerPositions[evt.button]);
-        const dx = evt.movementX !== undefined ? evt.movementX : evt.clientX - lf.x;
-        const dy = evt.movementY !== undefined ? evt.movementY : evt.clientY - lf.y;
+        const dx = evt.clientX - lf.x;
+        const dy = evt.clientY - lf.y;
         this._pointerPositionsDelta[evt.button].set(dx, dy);
 
         this._pointerPositions[evt.button].x = evt.clientX;

package/src/engine/engine_physics.ts

@@ -263,7 +263,10 @@ export class Physics {
         const ray = this.getPhysicsRay(this.rapierRay, origin, direction);
         if (!ray) return null;
 
-        const hit = this.world?.castRay(ray, maxDistance, solid);
+        const hit = this.world?.castRay(ray, maxDistance, solid, undefined, undefined, undefined, undefined, (c) => {
+            // ignore objects in the IgnoreRaycast=2 layer
+            return !c[$componentKey]?.gameObject.layers.isEnabled(2);
+        });
         if (hit) {
             const point = ray.pointAt(hit.toi);
             const vec = this.raycastVectorsBuffer.get();
@@ -274,6 +277,28 @@ export class Physics {
         return null;
     }
 
+    public raycastPhysicsFastAndGetNormal(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true)
+    : null | { point: Vector3, normal: Vector3, collider: ICollider } {
+
+        const ray = this.getPhysicsRay(this.rapierRay, origin, direction);
+        if (!ray) return null;
+        
+        const hit = this.world?.castRayAndGetNormal(ray, maxDistance, solid, undefined, undefined, undefined, undefined, (c) => {
+            // ignore objects in the IgnoreRaycast=2 layer
+            return !c[$componentKey]?.gameObject.layers.isEnabled(2);
+        });
+        if (hit) {
+            const point = ray.pointAt(hit.toi);
+            const normal = hit.normal;
+            const vec = this.raycastVectorsBuffer.get();
+            const nor = this.raycastVectorsBuffer.get();
+            vec.set(point.x, point.y, point.z);
+            nor.set(normal.x, normal.y, normal.z);
+            return { point: vec, normal: nor, collider: hit.collider[$componentKey] };
+        }
+        return null;
+    }
+
     private getPhysicsRay(ray: RAPIER.Ray, origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined): RAPIER.Ray | null {
         const cam = this.context.mainCamera;
         // if we get origin in 2d space we need to project it to 3d space
@@ -283,11 +308,13 @@ export class Physics {
                 return null;
             }
             const vec3 = this.raycastVectorsBuffer.get();
+            vec3.x = origin.x;
+            vec3.y = origin.y;
+            vec3.z = 0;
             // if the origin is in screen space we need to convert it to raycaster space
-            if (origin.x > 1 || origin.y > 1 || origin.y < -1 || origin.x < -1) {
-                this.context.input.convertScreenspaceToRaycastSpace(origin);
+            if (vec3.x > 1 || vec3.y > 1 || vec3.y < -1 || vec3.x < -1) {
+                this.context.input.convertScreenspaceToRaycastSpace(vec3);
             }
-            vec3.set(origin.x, origin.y, -1);
             vec3.unproject(cam);
             origin = vec3;
         }
@@ -466,9 +493,15 @@ export class Physics {
         if (scale.z < 0)
             scale.z = Math.abs(scale.z);
 
+        // prevent zero scale - seems normals are flipped otherwise
+        if (scale.x == 0) scale.x = 0.0000001;
+        if (scale.y == 0) scale.y = 0.0000001;
+        if (scale.z == 0) scale.z = 0.0000001;
+
         const desc = ColliderDesc.cuboid(scale.x, scale.y, scale.z);
         // const objectLayerMask = collider.gameObject.layers.mask;
         // const mask = objectLayerMask & ~2;
+        // TODO: https://rapier.rs/docs/user_guides/javascript/colliders/#collision-groups-and-solver-groups
         // desc.setCollisionGroups(objectLayerMask);
         this.createCollider(collider, desc, center);
     }
@@ -612,6 +645,10 @@ export class Physics {
         col[$componentKey] = collider;
         collider[$bodyKey] = col;
         col.setActiveEvents(ActiveEvents.COLLISION_EVENTS);
+        
+        // const objectLayerMask = collider.gameObject.layers.mask;
+        // const mask = objectLayerMask & ~2;
+        // col.setCollisionGroups(objectLayerMask);
         this.objects.push(collider);
         this.bodies.push(col);
         return col;

package/src/engine/engine_types.ts

@@ -172,6 +172,7 @@ export declare interface ICamera extends IComponent {
     backgroundColor: RGBAColor | null;
     backgroundBlurriness: number | undefined;
     clearFlags: number;
+    cullingMask: number;
     aspect: number;
     fieldOfView?: number;
     screenPointToRay(x: number, y: number, ray?: Ray): Ray;

package/src/engine/engine_utils.ts

@@ -26,14 +26,10 @@ export class CircularBuffer<T> {
     }
 
     get(): T {
-        let i = this._index++;
-        if (i >= this._cache.length) {
-            if (i >= this._maxSize) {
-                i = this._index = 0;
-            }
-            else {
-                this._cache.push(this._factory());
-            }
+        const i = this._index % this._maxSize;
+        this._index++;
+        if (this._cache.length <= i) {
+            this._cache[i] = this._factory();
         }
         return this._cache[i];
     }

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/CharacterController.ts

@@ -120,7 +120,7 @@ export class CharacterControllerInput extends Behaviour {
         // if (jumpDown) this._jumpDownTime = this.context.time.time;
         // const jumpUp = this.context.input.isKeyUp(" ");
 
-        const step = forward ? 1 : 0 + backward ? -1 : 0;
+        const step = (forward ? 1 : 0) + (backward ? -1 : 0);
         this._currentSpeed.z += step * this.movementSpeed * this.context.time.deltaTime;
 
         // if (!this.controller || this.controller.isGrounded)
@@ -132,7 +132,7 @@ export class CharacterControllerInput extends Behaviour {
         if (this.controller) this.controller.move(this._temp);
         else this.gameObject.position.add(this._temp);
 
-        const rotation = rotateLeft ? 1 : 0 + rotateRight ? -1 : 0;
+        const rotation = (rotateLeft ? 1 : 0) + (rotateRight ? -1 : 0);
         this._currentAngularSpeed.y += Mathf.toRadians(rotation * this.rotationSpeed) * this.context.time.deltaTime;
         if (this.lookForward && Math.abs(this._currentAngularSpeed.y) < .01) {
             const forwardVector = this.context.mainCameraComponent!.forward;

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/WebXR.ts

@@ -390,10 +390,19 @@ export class WebXR extends Behaviour {
         if (this.context.mainCamera) {
             //@ts-ignore
             const cam = xr.getCamera(this.context.mainCamera) as ArrayCamera;
-            for (const c of cam.cameras) {
-                c.layers.enableAll();
+            const cull = this.context.mainCameraComponent?.cullingMask;
+            if(cull !== undefined){
+                for (const c of cam.cameras) {
+                    c.layers.mask = cull;
+                }
+                cam.layers.mask = cull;
+            }
+            else {
+                for (const c of cam.cameras) {
+                    c.layers.enableAll();
+                }
+                cam.layers.enableAll();
             }
-
             this.rig.add(this.context.mainCamera);
             if (this._requestedAR) {
                 this.context.scene.add(this.rig);

package/src/engine-components/WebXRController.ts

@@ -769,7 +769,7 @@ export class WebXRController extends Behaviour {
     public raycast(): Intersection[] {
         const opts = new RaycastOptions();
         opts.layerMask = new Layers();
-        opts.layerMask.set(0);
+        opts.layerMask.enableAll();
         opts.layerMask.disable(2);
         opts.ray = this.getRay();
         const hits = this.context.physics.raycast(opts);

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";