@needle-tools/engine 3.5.11-beta → 3.5.12-beta

package/src/engine/engine_physics_rapier.ts

@@ -61,6 +61,8 @@ declare type PhysicsBody = {
 
 export class RapierPhysics implements IPhysicsEngine {
 
+    debugRenderColliders: boolean = false;
+
     removeBody(obj: IComponent) {
         if (!obj) return;
         this.validate();
@@ -244,15 +246,12 @@ export class RapierPhysics implements IPhysicsEngine {
 
     private rapierRay = new Ray({ x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 1 });
     private raycastVectorsBuffer = new CircularBuffer(() => new Vector3(), 10);
-    /** Fast raycast against physics colliders
-     * @param origin ray origin in screen or worldspace
-     * @param direction ray direction in worldspace
-     * @param maxDistance max distance to raycast
-     * @param solid if true it will also hit the collider if origin is already inside it
-     */
-    public raycast(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true)
+    public raycast(origin?: Vec2 | Vec3, direction?: Vec3, maxDistance?: number, solid?: boolean)
         : null | { point: Vector3, collider: ICollider } {
 
+        if (maxDistance === undefined) maxDistance = Infinity;
+        if (solid === undefined) solid = true;
+
         const ray = this.getPhysicsRay(this.rapierRay, origin, direction);
         if (!ray) return null;
 
@@ -270,9 +269,12 @@ export class RapierPhysics implements IPhysicsEngine {
         return null;
     }
 
-    public raycastAndGetNormal(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true)
+    public raycastAndGetNormal(origin?: Vec2 | Vec3, direction?: Vec3, maxDistance?: number, solid?: boolean)
         : null | { point: Vector3, normal: Vector3, collider: ICollider } {
 
+        if (maxDistance === undefined) maxDistance = Infinity;
+        if (solid === undefined) solid = true;
+
         const ray = this.getPhysicsRay(this.rapierRay, origin, direction);
         if (!ray) return null;
 
@@ -292,8 +294,13 @@ export class RapierPhysics implements IPhysicsEngine {
         return null;
     }
 
-    private getPhysicsRay(ray: Ray, origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined): Ray | null {
+    private getPhysicsRay(ray: Ray, origin?: Vec2 | Vec3, direction?: Vec3): Ray | null {
         const cam = this.context?.mainCamera;
+        if (origin === undefined) {
+            const pos = this.context?.input.getPointerPosition(0);
+            if (pos) origin = pos;
+            else return null;
+        }
         // if we get origin in 2d space we need to project it to 3d space
         if (origin["z"] === undefined) {
             if (!cam) {
@@ -306,6 +313,7 @@ export class RapierPhysics implements IPhysicsEngine {
             vec3.z = 0;
             // if the origin is in screen space we need to convert it to raycaster space
             if (vec3.x > 1 || vec3.y > 1 || vec3.y < -1 || vec3.x < -1) {
+                if (debugPhysics) console.warn("Converting screenspace to raycast space", vec3)
                 this.context?.input.convertScreenspaceToRaycastSpace(vec3);
             }
             vec3.unproject(cam);
@@ -742,20 +750,27 @@ export class RapierPhysics implements IPhysicsEngine {
     }
 
     private updateDebugRendering(world: World) {
-        if (debugPhysics || debugColliderPlacement || showColliders) {
+        if (debugPhysics || debugColliderPlacement || showColliders || this.debugRenderColliders === true) {
             if (!this.lines) {
                 const material = new LineBasicMaterial({
                     color: 0x227700,
+                    fog: false,
                     // vertexColors: THREE.VertexColors
                 });
                 const geometry = new BufferGeometry();
                 this.lines = new LineSegments(geometry, material);
-                this.context?.scene.add(this.lines);
             }
+            if (this.lines.parent !== this.context?.scene)
+                this.context?.scene.add(this.lines);
             const buffers = world.debugRender();
             this.lines.geometry.setAttribute('position', new BufferAttribute(buffers.vertices, 3));
             this.lines.geometry.setAttribute('color', new BufferAttribute(buffers.colors, 4));
         }
+        else {
+            if (this.lines) {
+                this.context?.scene.remove(this.lines);
+            }
+        }
     }
 
     public postStep() {

package/src/engine/engine_serialization_builtin_serializer.ts

@@ -270,18 +270,18 @@ class EventListSerializer extends TypeSerializer {
                     let fn: CallInfo | undefined;
                     let args = call.argument;
 
-                    // This is the final method we pass to the call info (or undefined if the method couldnt be resolved)
-                    const eventMethod = hasMethod ? this.createEventMethod(target, call.method, args) : undefined;
-
-                    if (call.argument !== undefined) {
+                    if (args !== undefined) {
                         if (typeof args === "object") {
-                            args = objectSerializer.onDeserialize(call.argument, context);
-                            if (!args) args = componentSerializer.onDeserialize(call.argument, context);
+                            // Try to deserialize the call argument to either a object or a component reference
+                            let argRes = objectSerializer.onDeserialize(call.argument, context);
+                            if (!argRes) argRes = componentSerializer.onDeserialize(call.argument, context);
+                            if (argRes) args = argRes;
                         }
-                        fn = new CallInfo(eventMethod, call.enabled);
                     }
-                    else
-                        fn = new CallInfo(eventMethod, call.enabled);
+
+                    // This is the final method we pass to the call info (or undefined if the method couldnt be resolved)
+                    const eventMethod = hasMethod ? this.createEventMethod(target, call.method, args) : undefined;
+                    fn = new CallInfo(eventMethod, call.enabled);
 
 
                     if (!fn.method)

package/src/engine/engine_types.ts

@@ -32,6 +32,7 @@ export interface ITime {
 
 export interface IInput {
     convertScreenspaceToRaycastSpace(vec: Vec2): void;
+    getPointerPosition(i: number): Vec2 | null;
 }
 
 export interface IPhysics {
@@ -375,10 +376,15 @@ export interface IPhysicsEngine {
     clearCaches();
 
     // raycasting
-    /** fast raycast without getting the normal vector */
-    raycast(origin: Vec2 | Vec3, direction: Vec3 | undefined, maxDistance: number, solid: boolean): RaycastResult;
+    /** Fast raycast against physics colliders
+     * @param origin ray origin in screen or worldspace
+     * @param direction ray direction in worldspace
+     * @param maxDistance max distance to raycast
+     * @param solid if true it will also hit the collider if origin is already inside it
+     */
+    raycast(origin?: Vec2 | Vec3, direction?: Vec3, maxDistance?: number, solid?: boolean): RaycastResult;
     /** raycast that also gets the normal vector. If you don't need it use raycast() */
-    raycastAndGetNormal(origin: Vec2 | Vec3, direction: Vec3 | undefined, maxDistance: number, solid: boolean) : RaycastResult;
+    raycastAndGetNormal(origin?: Vec2 | Vec3, direction?: Vec3, maxDistance?: number, solid?: boolean): RaycastResult;
     sphereOverlap(point: Vector3, radius: number): Array<SphereOverlapResult>;
 
     // Collider methods
@@ -403,6 +409,8 @@ export interface IPhysicsEngine {
     removeBody(body: IComponent);
 
     // Joints
-    addFixedJoint(body1: IRigidbody, body2: IRigidbody)
-    addHingeJoint(body1: IRigidbody, body2: IRigidbody, anchor: Vec3, axis: Vec3)
+    addFixedJoint(body1: IRigidbody, body2: IRigidbody);
+    addHingeJoint(body1: IRigidbody, body2: IRigidbody, anchor: Vec3, axis: Vec3);
+
+    debugRenderColliders : boolean;
 }

package/src/engine-components/OrbitControls.ts

@@ -87,7 +87,9 @@ export class OrbitControls extends Behaviour implements ICameraController {
             if (camGo && !this.setFromTargetPosition()) {
                 if (this.debugLog)
                     console.log("NO TARGET");
-                const forward = new Vector3(0, 0, -10).applyMatrix4(camGo.cam.matrixWorld);
+                const worldPosition = getWorldPosition(camGo.cam);
+                const distanceToCenter = worldPosition.length();
+                const forward = new Vector3(0, 0, -distanceToCenter).applyMatrix4(camGo.cam.matrixWorld);
                 this.setTarget(forward, true);
             }
         }

package/src/engine-components/export/usdz/extensions/behavior/Behaviour.ts

@@ -11,6 +11,7 @@ export interface UsdzBehaviour {
     afterSerialize?(ext: BehaviorExtension, context: IContext): void;
 }
 
+/** internal USDZ behaviours extension */
 export class BehaviorExtension implements IUSDExporterExtension {
 
     get extensionName(): string {