@needle-tools/engine 2.37.0-pre → 2.38.0-pre.1

package/src/engine-components/Joints.ts

@@ -0,0 +1,40 @@
+import { Vector3 } from "three";
+import { serializeable } from "../engine/engine_serialization";
+import { Behaviour } from "./Component";
+import { Rigidbody } from "./RigidBody";
+
+export abstract class Joint extends Behaviour {
+    @serializeable(Rigidbody)
+    connectedBody?: Rigidbody;
+
+    get rigidBody(): Rigidbody | null {
+        return this._rigidBody;
+    }
+    private _rigidBody: Rigidbody | null = null;
+
+
+    @serializeable(Vector3)
+    connectedAnchor?: Vector3;
+
+    onEnable() {
+        if (!this._rigidBody) this._rigidBody = this.gameObject.getComponent(Rigidbody);
+        if (this.rigidBody && this.connectedBody)
+            this.startCoroutine(this.create());
+    }
+
+    private *create() {
+        yield;
+        if (this.rigidBody && this.connectedBody)
+            this.createJoint(this.rigidBody, this.connectedBody);
+    }
+
+    protected abstract createJoint(self: Rigidbody, other: Rigidbody);
+}
+
+export class FixedJoint extends Joint {
+
+    protected createJoint(self: Rigidbody, other: Rigidbody) {
+        if (this.connectedAnchor)
+            this.context.physics.addFixedJoint(self, other, this.connectedAnchor);
+    }
+}

package/src/engine-components/Light.ts

@@ -130,6 +130,9 @@ export class Light extends Behaviour implements ILight {
     get shadowNormalBias(): number { return this._shadowNormalBias; }
     private _shadowNormalBias: number = 1;
 
+    /** when enabled this will remove the multiplication when setting the shadow bias settings initially */
+    private _overrideShadowBiasSettings: boolean = false;
+
     @serializeable()
     set shadows(val: LightShadows) {
         this._shadows = val;
@@ -338,7 +341,7 @@ export class Light extends Behaviour implements ILight {
 
         if (this.light !== undefined) {
             this._intensity = this.light.intensity;
-            
+
             if (this.shadows !== LightShadows.None) {
                 this.light.castShadow = true;
             }
@@ -353,8 +356,19 @@ export class Light extends Behaviour implements ILight {
                 this.light.shadow.mapSize.width = 2048;
                 this.light.shadow.mapSize.height = 2048;
             }
-            this.light.shadow.bias = this.shadowBias * 0.00001;
-            this.light.shadow.normalBias = this.shadowNormalBias * .0001;
+
+            if (debug)
+                console.log("Override shadow bias?", this._overrideShadowBiasSettings, this.shadowBias, this.shadowNormalBias);
+
+            // shadow bias settings
+            if (this._overrideShadowBiasSettings === true) {
+                this.light.shadow.bias = this.shadowBias;
+                this.light.shadow.normalBias = this.shadowNormalBias;
+            }
+            else {
+                this.light.shadow.bias = this.shadowBias * 0.00001;
+                this.light.shadow.normalBias = this.shadowNormalBias * .0001;
+            }
 
             // console.log(this.light.shadow, this);
             const cam = this.light.shadow.camera as THREE.OrthographicCamera;

package/src/engine-components/OrbitControls.ts

@@ -213,7 +213,7 @@ export class OrbitControls extends Behaviour {
         if (this.lookAtConstraint?.locked) this.setFromTargetPosition(0, this.lookAtConstraint01);
 
 
-        if (this._controls) {
+        if (this._controls && !this.context.isInXR) {
             if (this.debugLog)
                 this._controls.domElement = this.context.renderer.domElement;
             this._controls.enabled = true;

package/src/engine-components/Renderer.ts

@@ -5,7 +5,7 @@ import { RendererLightmap } from "./RendererLightmap";
 import { Context } from "../engine/engine_setup";
 import { getParam } from "../engine/engine_utils";
 import { serializeable } from "../engine/engine_serialization_decorator";
-import { AxesHelper, Material, Mesh, Object3D, Texture, Vector4 } from "three";
+import { AxesHelper, Material, Mesh, Object3D, SkinnedMesh, Texture, Vector4 } from "three";
 import { NEEDLE_render_objects } from "../engine/extensions/NEEDLE_render_objects";
 import { NEEDLE_deferred_texture } from "../engine/extensions/NEEDLE_deferred_texture";
 import { NEED_UPDATE_INSTANCE_KEY } from "../engine/engine_instancing";
@@ -67,6 +67,7 @@ class SharedMaterialArray implements ISharedMaterials {
                 case "Group":
                     this._targets = [...go.children];
                     break;
+                case "SkinnedMesh":
                 case "Mesh":
                     this._targets.push(go);
                     break;
@@ -155,6 +156,9 @@ export class Renderer extends Behaviour implements IRenderer {
         if (this.gameObject.type === "Mesh") {
             return this.gameObject as unknown as Mesh
         }
+        else if (this.gameObject.type === "SkinnesMesh") {
+            return this.gameObject as unknown as SkinnedMesh;
+        }
         else if (this.gameObject.type === "Group") {
             return this.gameObject.children[0] as unknown as Mesh;
         }

package/src/engine-components/RigidBody.ts

@@ -7,7 +7,7 @@ import { Object3D, Vector3 } from "three";
 import { IRigidbody } from "../engine/engine_types";
 import { CollisionDetectionMode, RigidbodyConstraints } from "../engine/engine_physics.types";
 import { validate } from "../engine/engine_util_decorator";
-import { Context } from "../engine/engine_setup";
+import { Context, FrameEvent } from "../engine/engine_setup";
 
 class TransformWatch {
 
@@ -16,23 +16,48 @@ class TransformWatch {
     }
     positionChanged: boolean = false;
     rotationChanged: boolean = false;
-    position?: Vector3;
-    quaternion?: THREE.Quaternion;
 
-    reset() {
+    position?: { x?: number, y?: number, z?: number };
+    quaternion?: { _x?: number, _y?: number, _z?: number, _w?: number };
+
+    private _positionKeys: string[] = ["x", "y", "z"];
+    private _quaternionKeys: string[] = ["_x", "_y", "_z", "_w"];
+
+    reset(clearPreviousValues: boolean = false) {
         this.positionChanged = false;
         this.rotationChanged = false;
         this.mute = false;
+
+        if (clearPreviousValues) {
+            if (this.position)
+                for (const key of this._positionKeys)
+                    delete this.position[key];
+            if (this.quaternion)
+                for (const key of this._quaternionKeys)
+                    delete this.quaternion[key];
+        }
     }
 
     mute: boolean = false;
 
     applyValues() {
-        if (this.positionChanged) {
-            this.obj.position.copy(this.position!)
+        // only apply the values that actually changed
+        // since we want to still control all the other values via physics 
+        if (this.positionChanged && this.position) {
+            for (const key of this._positionKeys) {
+                const val = this.position[key];
+                if (val !== undefined)
+                    this.obj.position[key] = val;
+            }
         }
         if (this.rotationChanged) {
-            this.obj.quaternion.copy(this.quaternion!)
+            if (this.quaternion) {
+                for (const key of this._quaternionKeys) {
+                    const val = this.quaternion[key];
+                    if (val !== undefined)
+                        this.obj.quaternion[key] = val;
+                }
+            }
         }
     }
 
@@ -52,26 +77,28 @@ class TransformWatch {
             if (!this._positionWatch)
                 this._positionWatch = new Watch(this.obj.position, ["x", "y", "z"]);
             this._positionWatch.apply();
-            this.position = this.obj.position.clone();
+            this.position = {};
+            // this.position = this.obj.position.clone();
             this._positionWatch.subscribeWrite((val, prop) => {
                 if (this.context.physics.isUpdating || this.mute) return;
-                // if (this.position![prop] !== val) {
+                const prev = this.position![prop];
+                if (Math.abs(prev - val) < .00001) return;
                 this.position![prop] = val;
                 this.positionChanged = true;
-                // }
             })
         }
         if (rotation) {
             if (!this._rotationWatch)
                 this._rotationWatch = new Watch(this.obj.quaternion, ["_x", "_y", "_z", "_w"]);
             this._rotationWatch.apply();
-            this.quaternion = this.obj.quaternion.clone();
+            this.quaternion = {};
+            // this.quaternion = this.obj.quaternion.clone();
             this._rotationWatch.subscribeWrite((val, prop) => {
                 if (this.context.physics.isUpdating || this.mute) return;
-                // if (this.quaternion![prop] !== val) {
+                const prev = this.quaternion![prop];
+                if (Math.abs(prev - val) < .00001) return;
                 this.quaternion![prop] = val;
                 this.rotationChanged = true;
-                // }
             })
         }
     }
@@ -188,6 +215,7 @@ export class Rigidbody extends Behaviour implements IRigidbody {
             this._watch = new TransformWatch(this.gameObject, this.context);
         }
         this._watch.start(true, true);
+        this.startCoroutine(this.beforePhysics(), FrameEvent.LateUpdate);
     }
 
     onDisable() {
@@ -203,29 +231,35 @@ export class Rigidbody extends Behaviour implements IRigidbody {
         this._propertiesChanged = true;
     }
 
-    earlyUpdate() {
-        if (this._propertiesChanged) {
-            this._propertiesChanged = false;
-            this.context.physics.updateProperties(this);
+    // need to do this right before updating physics to prevent rendered object glitching through physical bodies
+    *beforePhysics() {
+        while (true) {
+            if (this._propertiesChanged) {
+                this._propertiesChanged = false;
+                this.context.physics.updateProperties(this);
+            }
+            if (this._watch?.isDirty) {
+                this._watch.mute = true;
+                this._watch.applyValues();
+                this.context.physics.updateBody(this, this._watch.positionChanged, this._watch.rotationChanged);
+                this._watch.reset();
+            }
+            this.captureVelocity();
+            yield;
         }
-        if (this._watch?.isDirty) {
-            this._watch.mute = true;
-            this._watch.applyValues();
-            this.context.physics.updateBody(this, this._watch.positionChanged, this._watch.rotationChanged);
-            this._watch.reset();
-        }
-
-        this.captureVelocity();
     }
 
     private get body() {
         return this.context.physics.internal_getRigidbody(this);
     }
 
-    // TODO: we need to differentiate between setting a physics body to a new position and moving it where we also want to affect the velocity
-    // public teleport(){
-    //     this.context.physics.updateBody(this);
-    // }
+    public teleport(pt: { x: number, y: number, z: number }, localspace:boolean = true) {
+        this._watch?.reset(true);
+        if(localspace) this.gameObject.position.set(pt.x, pt.y, pt.z);
+        else this.setWorldPosition(pt.x, pt.y, pt.z);
+        this.resetForcesAndTorques();
+        this.resetVelocities();
+    }
 
     public resetForces() {
         this.body?.resetForces(true);

package/src/engine-components/SmoothFollow.ts

@@ -1,53 +1,56 @@
 import { Camera } from "./Camera";
 import { Behaviour, GameObject } from "./Component";
-import * as utils from "../engine/engine_three_utils";
 import * as THREE from "three";
 import { Mathf } from "../engine/engine_math";
 import { serializeable } from "../engine/engine_serialization_decorator";
 import { Object3D } from "three";
+import { getWorldPosition, getWorldQuaternion } from "../engine/engine_three_utils";
+import { Axes } from "../engine/engine_physics.types";
 
 export class SmoothFollow extends Behaviour {
 
     @serializeable(Object3D)
     target: THREE.Object3D | null = null;
 
+    @serializeable()
     followFactor = .1;
+    @serializeable()
     rotateFactor = .1;
 
-    flipForward:boolean = false;
+    @serializeable()
+    positionAxes : Axes = Axes.All;
 
-    private static _invertForward : THREE.Quaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
-    private _firstUpdate = true;
+    // @serializeable()
+    // rotationAxes : Axes = Axes.All;
 
+    flipForward: boolean = false;
+
+    private static _invertForward: THREE.Quaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+    private _firstUpdate = true;
 
-    onEnable(): void {
-        const cam = GameObject.getComponentInChildren(this.gameObject, Camera) as Camera;
-        if (cam && cam.cam) {
-            cam.gameObject.position.set(0, 0, 0);
-            cam.cam.position.set(0, 0, 0);
-            cam.gameObject.quaternion.identity();
-            cam.cam.quaternion.setFromEuler(new THREE.Euler(0, Math.PI, 0));
-        }
-    }
 
     onBeforeRender(): void {
-        if (this.followFactor <= 0) return;
         this.updateNow(false);
     }
 
     updateNow(hard: boolean) {
         if (!this.target || this.target === this.gameObject) return;
         if (this.followFactor > 0) {
-            const wp = utils.getWorldPosition(this.target);
+            const wp = getWorldPosition(this.target);
             const fpos = this._firstUpdate || hard ? 1 : Mathf.clamp01(this.context.time.deltaTime * this.followFactor);
-            this.worldPosition = this.worldPosition.lerp(wp, fpos);
+            const currentPosition = this.worldPosition;
+            if(this.positionAxes & Axes.X) currentPosition.x = Mathf.lerp(currentPosition.x, wp.x, fpos);
+            if(this.positionAxes & Axes.Y) currentPosition.y = Mathf.lerp(currentPosition.y, wp.y, fpos);
+            if(this.positionAxes & Axes.Z) currentPosition.z = Mathf.lerp(currentPosition.z, wp.z, fpos);
+            this.worldPosition = currentPosition;
         }
         if (this.rotateFactor > 0) {
-            const wr = utils.getWorldQuaternion(this.target);
-            if(this.flipForward){
+            const wr = getWorldQuaternion(this.target);
+            if (this.flipForward) {
                 wr.premultiply(SmoothFollow._invertForward);
             }
             const frot = this._firstUpdate || hard ? 1 : Mathf.clamp01(this.context.time.deltaTime * this.rotateFactor);
+
             this.worldQuaternion = this.worldQuaternion.slerp(wr, frot);
         }
         this._firstUpdate = false;

package/src/engine-components/WebXR.ts

@@ -505,6 +505,7 @@ export class WebAR {
         const context = this.webxr.context;
         this.reticleActive = true;
         this.didPlaceARSessionRoot = false;
+        this.getAROverlayContainer();
 
         const deviceType = navigator.userAgent?.includes("OculusBrowser") ? ControllerType.PhysicalDevice : ControllerType.Touch;
         const controllerCount = deviceType === ControllerType.Touch ? 4 : 2;
@@ -563,10 +564,8 @@ export class WebAR {
         }
         else console.warn("No WebARSessionRoot found in scene")
 
-        if (this.arDomOverlay && this.arOverlayElement) {
-            const el = this.arOverlayElement as INeedleEngineComponent;
-            el.onEnterAR?.call(el, session, this.arOverlayElement);
-        }
+        const eng = this.context.domElement as INeedleEngineComponent;
+        eng?.onEnterAR?.call(eng, session, this.arOverlayElement!);
 
         this.context.mainCameraComponent?.applyClearFlagsIfIsActiveCamera();
     }

package/src/engine-components/codegen/components.ts

@@ -13,10 +13,13 @@ export { AxesHelper } from "../AxesHelper";
 export { BasicIKConstraint } from "../BasicIKConstraint";
 export { BoxHelperComponent } from "../BoxHelperComponent";
 export { Camera } from "../Camera";
+export { CharacterController } from "../CharacterController";
+export { CharacterControllerInput } from "../CharacterController";
 export { Collider } from "../Collider";
 export { SphereCollider } from "../Collider";
 export { BoxCollider } from "../Collider";
 export { MeshCollider } from "../Collider";
+export { CapsuleCollider } from "../Collider";
 export { DeleteBox } from "../DeleteBox";
 export { Deletable } from "../DeleteBox";
 export { DeviceFlag } from "../DeviceFlag";
@@ -35,6 +38,7 @@ export { GridHelper } from "../GridHelper";
 export { GroundProjectedEnv } from "../GroundProjection";
 export { Interactable } from "../Interactable";
 export { UsageMarker } from "../Interactable";
+export { FixedJoint } from "../Joints";
 export { Light } from "../Light";
 export { LODModel } from "../LODGroup";
 export { LODGroup } from "../LODGroup";

package/src/engine-components/dist/CharacterController.js

@@ -0,0 +1,123 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+exports.__esModule = true;
+exports.CharacterControllerInput = exports.CharacterController = void 0;
+var three_1 = require("three");
+var engine_math_1 = require("../engine/engine_math");
+var engine_serialization_1 = require("../engine/engine_serialization");
+var Collider_1 = require("./Collider");
+var Component_1 = require("./Component");
+var RigidBody_1 = require("./RigidBody");
+var CharacterController = /** @class */ (function (_super) {
+    __extends(CharacterController, _super);
+    function CharacterController() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.center = new three_1.Vector3(0, 0, 0);
+        _this.radius = .5;
+        _this.height = 2;
+        return _this;
+    }
+    CharacterController.prototype.onEnable = function () {
+        var rb = this.gameObject.getComponent(RigidBody_1.Rigidbody);
+        var collider = this.gameObject.getComponent(Collider_1.CapsuleCollider);
+        if (!rb)
+            rb = this.gameObject.addNewComponent(RigidBody_1.Rigidbody);
+        if (!collider)
+            collider = this.gameObject.addNewComponent(Collider_1.CapsuleCollider);
+        // rb.isKinematic = true;
+        collider.center.copy(this.center);
+        collider.radius = this.radius;
+        collider.height = this.height;
+        this.gameObject.rotation.x = 0;
+        this.gameObject.rotation.z = 0;
+        rb.lockRotationX = true;
+        rb.lockRotationY = true;
+        rb.lockRotationZ = true;
+    };
+    CharacterController.prototype.move = function (vec) {
+        this.gameObject.position.add(vec);
+    };
+    CharacterController.prototype.onCollisionEnter = function (col) {
+        // console.log(col);
+    };
+    CharacterController.prototype.onCollisionExit = function (col) {
+    };
+    CharacterController.prototype.isGrounded = function () {
+    };
+    __decorate([
+        engine_serialization_1.serializeable(three_1.Vector3)
+    ], CharacterController.prototype, "center");
+    __decorate([
+        engine_serialization_1.serializeable()
+    ], CharacterController.prototype, "radius");
+    __decorate([
+        engine_serialization_1.serializeable()
+    ], CharacterController.prototype, "height");
+    return CharacterController;
+}(Component_1.Behaviour));
+exports.CharacterController = CharacterController;
+var CharacterControllerInput = /** @class */ (function (_super) {
+    __extends(CharacterControllerInput, _super);
+    function CharacterControllerInput() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.movementSpeed = 2;
+        _this.rotationSpeed = 2;
+        _this.jumpHeight = 1;
+        _this._currentSpeed = new three_1.Vector3(0, 0, 0);
+        _this._currentAngularSpeed = new three_1.Vector3(0, 0, 0);
+        _this._temp = new three_1.Vector3(0, 0, 0);
+        return _this;
+    }
+    CharacterControllerInput.prototype.update = function () {
+        var forward = this.context.input.isKeyPressed("w");
+        var backward = this.context.input.isKeyPressed("s");
+        var rotateLeft = this.context.input.isKeyPressed("a");
+        var rotateRight = this.context.input.isKeyPressed("d");
+        var jump = this.context.input.isKeyPressed("space");
+        var step = forward ? 1 : 0 + backward ? -1 : 0;
+        this._currentSpeed.z += step * this.movementSpeed * this.context.time.deltaTime;
+        this._temp.copy(this._currentSpeed);
+        this._temp.applyQuaternion(this.gameObject.quaternion);
+        if (this.controller)
+            this.controller.move(this._temp);
+        else
+            this.gameObject.position.add(this._temp);
+        var rotation = rotateLeft ? 1 : 0 + rotateRight ? -1 : 0;
+        this._currentAngularSpeed.y += engine_math_1.Mathf.toRadians(rotation * this.rotationSpeed) * this.context.time.deltaTime;
+        this.gameObject.rotateY(this._currentAngularSpeed.y);
+        this._currentSpeed.multiplyScalar(1 - this.context.time.deltaTime * 10);
+        this._currentAngularSpeed.y *= 1 - this.context.time.deltaTime * 10;
+    };
+    __decorate([
+        engine_serialization_1.serializeable(CharacterController)
+    ], CharacterControllerInput.prototype, "controller");
+    __decorate([
+        engine_serialization_1.serializeable()
+    ], CharacterControllerInput.prototype, "movementSpeed");
+    __decorate([
+        engine_serialization_1.serializeable()
+    ], CharacterControllerInput.prototype, "rotationSpeed");
+    __decorate([
+        engine_serialization_1.serializeable()
+    ], CharacterControllerInput.prototype, "jumpHeight");
+    return CharacterControllerInput;
+}(Component_1.Behaviour));
+exports.CharacterControllerInput = CharacterControllerInput;