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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "2.67.13-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",

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/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/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);