Needle Engine 3.23.0

Files changed (12) hide show

src/engine-components/Animator.ts +13 -1
src/engine-components/AnimatorController.ts +44 -9
src/engine-components/CharacterController.ts +14 -0
src/engine-components/Collider.ts +6 -0
src/engine/engine_physics_rapier.ts +60 -7
src/engine/engine_serialization_core.ts +23 -14
src/engine/engine_types.ts +15 -2
src/engine/extensions/NEEDLE_animator_controller_model.ts +8 -1
src/engine-components/OrbitControls.ts +18 -12
src/engine-components/timeline/PlayableDirector.ts +10 -3
src/engine-components/timeline/TimelineTracks.ts +1 -1
src/engine-components/webxr/WebARSessionRoot.ts +3 -2

src/engine-components/Animator.ts CHANGED Viewed

@@ -41,8 +41,20 @@
             if (!(val instanceof AnimatorController)) {
                 if (debug) console.log("Assign animator controller", val, this);
                 this._animatorController = new AnimatorController(val);
+                if (this.__didAwake)
+                    this._animatorController.bind(this);
             }
-            else this._animatorController = val;
+            else {
+                if (val.animator && val.animator !== this) {
+                    console.warn("AnimatorController can not be bound to multiple animators", val.model?.name)
+                    if (!val.model) {
+                        console.error("AnimatorController has no model");
+                    }
+                    val = new AnimatorController(val.model);
+                }
+                this._animatorController = val;
+                this._animatorController.bind(this);
+            }
         }
         else this._animatorController = null;
     }

src/engine-components/AnimatorController.ts CHANGED Viewed

@@ -5,7 +5,7 @@
 import { deepClone, getParam } from "../engine/engine_utils.js";
 import { Context } from "../engine/engine_setup.js";
 import { TypeStore } from "../engine/engine_typestore.js";
-import { assign } from "../engine/engine_serialization_core.js";
+import { SerializationContext, TypeSerializer, assign } from "../engine/engine_serialization_core.js";
 import { Mathf } from "../engine/engine_math.js";
 import { isAnimationAction } from "../engine/engine_three_utils.js";
 import { isDevEnvironment } from "../engine/debug/index.js";
@@ -124,7 +124,9 @@
     setFloat(name: string | number, val: number) {
         const key = typeof name === "string" ? "name" : "hash";
-        return this.model?.parameters?.filter(p => p[key] === name).forEach(p => p.value = val);
+        const filtered = this.model?.parameters?.filter(p => p[key] === name);
+        filtered.forEach(p => p.value = val);
+        return filtered?.length > 0;
     }
     getFloat(name: string | number): number {
@@ -197,7 +199,8 @@
     // }
     bind(animator: Animator) {
-        if (this.animator !== animator) {
+        if (!animator) console.error("AnimatorController.bind: animator is null");
+        else if (this.animator !== animator) {
             this.animator = animator;
             this._mixer = new AnimationMixer(this.animator.gameObject);
             this.createActions(this.animator);
@@ -292,9 +295,6 @@
     }
     private evaluateTransitions() {
-        const currentLayer = 0;
         let didEnterStateThisFrame = false;
         if (!this._activeState) {
             this.setStartTransition();
@@ -370,6 +370,16 @@
         // action.time += this.context.time.deltaTime
         // console.log(action?.time, action?.getEffectiveWeight())
+        // update timescale
+        if (action) {
+            let speedFactor = state.speed ?? 1;
+            if (state.speedParameter)
+                speedFactor *= this.getFloat(state.speedParameter);
+            if (speedFactor !== undefined) {
+                action.timeScale = speedFactor * this._speed;
+            }
+        }
         let didTriggerLooping = false;
         if (state.motion.isLooping && action) {
             // we dont use the three loop state here because it prevents the transition check above
@@ -472,11 +482,22 @@
         if (action) {
             offsetNormalized = Math.max(0, Math.min(1, offsetNormalized));
+            if (state.cycleOffsetParameter) {
+                const val = this.getFloat(state.cycleOffsetParameter);
+                if (typeof val === "number") {
+                    offsetNormalized += val;
+                    offsetNormalized %= 1;
+                }
+                else if (debug) console.warn("AnimatorController cycle offset parameter is not a number", state.cycleOffsetParameter);
+            }
+            else if (typeof state.cycleOffset === "number") {
+                offsetNormalized += state.cycleOffset
+                offsetNormalized %= 1;
+            }
             if (action.isRunning())
                 action.stop();
             action.reset();
-            action.timeScale = this._speed;
-            if (state.speed !== undefined) action.timeScale *= state.speed;
             action.enabled = true;
             const duration = state.motion.clip!.duration;
             action.time = offsetNormalized * duration;
@@ -982,4 +1003,18 @@
         }
         return null;
     }
-}
+}
+class AnimatorControllerSerializator extends TypeSerializer {
+    onSerialize(_: any, _context: SerializationContext) {
+    }
+    onDeserialize(data: AnimatorControllerModel & { __type?: string }, context: SerializationContext) {
+        if (context.type === AnimatorController && data.__type === "AnimatorController")
+            return new AnimatorController(data);
+        return undefined;
+    }
+}
+new AnimatorControllerSerializator(AnimatorController);

src/engine-components/CharacterController.ts CHANGED Viewed

@@ -85,6 +85,20 @@
     }
     get isGrounded(): boolean { return this._activeGroundCollisions.size > 0; }
+    private _contactVelocity: Vector3 = new Vector3();
+    get contactVelocity(): Vector3 {
+        this._contactVelocity.set(0, 0, 0);
+        for (const col of this._activeGroundCollisions) {
+            const vel = this.context.physics.engine?.getLinearVelocity(col.collider);
+            if (!vel) continue;
+            // const friction = col.collider.sharedMaterial?.dynamicFriction || 1;
+            this._contactVelocity.x += vel.x;
+            this._contactVelocity.y += vel.y;
+            this._contactVelocity.z += vel.z;
+        }
+        return this._contactVelocity;
+    }
 }
 export class CharacterControllerInput extends Behaviour {

src/engine-components/Collider.ts CHANGED Viewed

@@ -53,6 +53,12 @@
     updateProperties = () => {
         this.context.physics.engine?.updateProperties(this);
     }
+    /** Requests an update of the physics material in the physics engine */
+    updatePhysicsMaterial(){
+        this.context.physics.engine?.updatePhysicsMaterial(this);
+    }
 }

src/engine/engine_physics_rapier.ts CHANGED Viewed

@@ -18,7 +18,7 @@
 import { foreachComponent } from './engine_gameobject.js';
 import { ActiveCollisionTypes, ActiveEvents, CoefficientCombineRule, Ball, Collider, ColliderDesc, EventQueue, JointData, QueryFilterFlags, RigidBody, RigidBodyType, ShapeColliderTOI, World, Ray, ShapeType, Cuboid } from '@dimforge/rapier3d-compat';
-import { CollisionDetectionMode, PhysicsMaterialCombine } from '../engine/engine_physics.types.js';
+import { CollisionDetectionMode, PhysicsMaterial, PhysicsMaterialCombine } from '../engine/engine_physics.types.js';
 import { Gizmos } from './engine_gizmos.js';
 import { Mathf } from './engine_math.js';
 import { SphereOverlapResult } from './engine_types.js';
@@ -149,6 +149,8 @@
             const body = col[$bodyKey];
             if (body) {
                 this.internalUpdateColliderProperties(col, body);
+                if(col.sharedMaterial)
+                    this.updatePhysicsMaterial(col);
             }
         }
         else {
@@ -169,9 +171,9 @@
         const body = this.internal_getRigidbody(rigidbody);
         body?.applyImpulse(force, wakeup)
     }
-    getLinearVelocity(rigidbody: IRigidbody): Vec3 | null {
+    getLinearVelocity(comp: IRigidbody | ICollider): Vec3 | null {
         this.validate();
-        const body = this.internal_getRigidbody(rigidbody);
+        const body = this.internal_getRigidbody(comp);
         if (body) {
             const vel = body.linvel();
             return vel;
@@ -557,7 +559,7 @@
         // Prevent negative scales
         scale.x = Math.abs(scale.x);
         scale.y = Math.abs(scale.y);
-        const desc = ColliderDesc.capsule(height * .5 * scale.y - radius, radius * scale.x);
+        const desc = ColliderDesc.capsule(height * .5 * radius * scale.y, radius * scale.x);
         this.createCollider(collider, desc, center);
     }
@@ -614,6 +616,55 @@
         }
     }
+    updatePhysicsMaterial(col: ICollider) {
+        if (!col) return;
+        const physicsMaterial = col.sharedMaterial;
+        const rapier_collider = col[$bodyKey] as Collider;
+        if (!rapier_collider) return;
+        if (physicsMaterial) {
+            if (physicsMaterial.bounciness !== undefined)
+                rapier_collider.setRestitution(physicsMaterial.bounciness);
+            if (physicsMaterial.bounceCombine !== undefined) {
+                switch (physicsMaterial.bounceCombine) {
+                    case PhysicsMaterialCombine.Average:
+                        rapier_collider.setRestitutionCombineRule(CoefficientCombineRule.Average);
+                        break;
+                    case PhysicsMaterialCombine.Maximum:
+                        rapier_collider.setRestitutionCombineRule(CoefficientCombineRule.Max);
+                        break;
+                    case PhysicsMaterialCombine.Minimum:
+                        rapier_collider.setRestitutionCombineRule(CoefficientCombineRule.Min);
+                        break;
+                    case PhysicsMaterialCombine.Multiply:
+                        rapier_collider.setRestitutionCombineRule(CoefficientCombineRule.Multiply);
+                        break;
+                }
+            }
+            if (physicsMaterial.dynamicFriction !== undefined)
+                rapier_collider.setFriction(physicsMaterial.dynamicFriction);
+            if (physicsMaterial.frictionCombine !== undefined) {
+                switch (physicsMaterial.frictionCombine) {
+                    case PhysicsMaterialCombine.Average:
+                        rapier_collider.setFrictionCombineRule(CoefficientCombineRule.Average);
+                        break;
+                    case PhysicsMaterialCombine.Maximum:
+                        rapier_collider.setFrictionCombineRule(CoefficientCombineRule.Max);
+                        break;
+                    case PhysicsMaterialCombine.Minimum:
+                        rapier_collider.setFrictionCombineRule(CoefficientCombineRule.Min);
+                        break;
+                    case PhysicsMaterialCombine.Multiply:
+                        rapier_collider.setFrictionCombineRule(CoefficientCombineRule.Multiply);
+                        break;
+                }
+            }
+        }
+    }
     /** Get the rapier body for a Needle component */
     getBody(obj: ICollider | IRigidbody): null | any {
         if (!obj) return null;
@@ -651,7 +702,7 @@
         // TODO: we might want to update this if the material changes
         const physicsMaterial = collider.sharedMaterial;
         if (physicsMaterial) {
             if (physicsMaterial.bounciness !== undefined)
                 desc.setRestitution(physicsMaterial.bounciness);
@@ -761,7 +812,8 @@
         return { rigidBody: rigidBody, useExplicitMassProperties: useExplicitMassProperties };
     }
-    private internal_getRigidbody(rb: IRigidbody): RigidBody | null {
+    private internal_getRigidbody(rb: IRigidbody | ICollider): RigidBody | null {
+        if ((rb as ICollider).isCollider === true) return rb[$colliderRigidbody] as RigidBody;
         return rb[$bodyKey] as RigidBody;
     }
@@ -1172,7 +1224,8 @@
                                 if (pt) {
                                     const dist = manifold.contactDist(i);
                                     const friction = manifold.solverContactFriction(i);
-                                    const contact = new ContactPoint(pt, dist, normal, impulse, friction);
+                                    const tangentVelocity = manifold.solverContactTangentVelocity(i);
+                                    const contact = new ContactPoint(pt, dist, normal, impulse, friction, tangentVelocity);
                                     contacts.push(contact);
                                     if (debugCollisions) {
                                         Gizmos.DrawDirection(pt, normal, 0xff0000, 3, true);

src/engine/engine_serialization_core.ts CHANGED Viewed

@@ -501,6 +501,13 @@
     // e.g. when @serializable(Texture) and the texture is already resolved via json pointer from gltf
     // then we dont need to do anything else
     if (!typeIsFunction && currentValue instanceof type) return currentValue;
+    // try to resolve the serializer for a type only once
+    if (!typeContext) {
+        typeContext = {
+            serializer: helper.getSerializerForConstructor(type)
+        }
+    }
     // if the value was already resolved via the persistent asset extension dont try to override that again
     if (currentValue && typeof currentValue === "object" && isPersistentAsset(currentValue)) {
@@ -517,12 +524,21 @@
         if (currentValue && type !== undefined) {
             try {
-                // we create a concrete instance for a persistent asset here
-                // hence we want to have the same instance across all usages of this asset
-                const instance = new type();
-                if (debugExtension)
-                    console.log("Create concrete instance for persistent asset", currentValue, "instance:", instance);
-                assign(instance, currentValue);
+                let instance = null;
+                // It's still possible that the type has an explicit serializer
+                // e.g. AnimatorController (or if a user registers a serializer for an arbitrary type and then marks a persistent asset with @serializable)
+                // we have this for @serializable(AnimatorController)
+                if (typeContext.serializer) {
+                    instance = typeContext.serializer.onDeserialize(data, context);
+                }
+                if (!instance) {
+                    // we create a concrete instance for a persistent asset here
+                    // hence we want to have the same instance across all usages of this asset
+                    instance = new type();
+                    if (debugExtension)
+                        console.log("Create concrete instance for persistent asset", currentValue, "instance:", instance);
+                    assign(instance, currentValue);
+                }
                 // save it so if another component references the same persistent asset it will automatically use the concrete instance
                 currentValue["__concreteInstance"] = instance;
                 currentValue = instance;
@@ -534,13 +550,6 @@
         return currentValue;
     }
-    // try to resolve the serializer for a type only once
-    if (!typeContext) {
-        typeContext = {
-            serializer: helper.getSerializerForConstructor(type)
-        }
-    }
     // if the type is an array resolve each entries recursively
     if (Array.isArray(data)) {
         const newArr: any[] = [];
@@ -554,7 +563,7 @@
         return newArr;
     }
-    const ser = typeContext.serializer;
+    const ser = typeContext?.serializer;
     if (ser) {
         return ser.onDeserialize(data, context);
     }

src/engine/engine_types.ts CHANGED Viewed

@@ -244,6 +244,8 @@
     attachedRigidbody: IRigidbody | null;
     isTrigger: boolean;
     sharedMaterial?: PhysicsMaterial;
+    updateProperties(): void;
+    updatePhysicsMaterial(): void;
 }
 export declare interface ISphereCollider extends ICollider {
@@ -309,6 +311,7 @@
     private readonly _point: Vec3;
     private readonly _normal: Vec3;
+    private readonly _tangentVelocity: Vec3;
     readonly distance: number;
     readonly impulse: number;
@@ -326,12 +329,19 @@
         return target.set(this._normal.x, this._normal.y, this._normal.z);
     }
-    constructor(point: Vec3, dist: number, normal: Vec3, impulse: number, friction: number) {
+    /** */
+    get tangentVelocity() {
+        const target = contactsVectorBuffer.get();
+        return target.set(this._tangentVelocity.x, this._tangentVelocity.y, this._tangentVelocity.z);
+    }
+    constructor(point: Vec3, dist: number, normal: Vec3, impulse: number, friction: number, tangentVelocity: Vec3) {
         this._point = point;
         this.distance = dist;
         this._normal = normal;
         this.impulse = impulse;
         this.friction = friction;
+        this._tangentVelocity = tangentVelocity;
     }
 }
@@ -437,6 +447,8 @@
     addCapsuleCollider(collider: ICollider, center: Vector3, radius: number, height: number);
     addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean, scale: Vector3);
+    updatePhysicsMaterial(collider:ICollider);
     // Rigidbody methods
     wakeup(rb: IRigidbody);
     updateProperties(rb: IRigidbody | ICollider);
@@ -444,7 +456,8 @@
     resetTorques(rb: IRigidbody, wakeup: boolean);
     addForce(rb: IRigidbody, vec: Vec3, wakeup: boolean);
     applyImpulse(rb: IRigidbody, vec: Vec3, wakeup: boolean);
-    getLinearVelocity(rb: IRigidbody): Vec3 | null;
+    /** Returns the linear velocity of a rigidbody or the rigidbody of a collider */
+    getLinearVelocity(rb: IRigidbody | ICollider): Vec3 | null;
     getAngularVelocity(rb: IRigidbody): Vec3 | null;
     setAngularVelocity(rb: IRigidbody, vec: Vec3, wakeup: boolean);
     setLinearVelocity(rb: IRigidbody, vec: Vec3, wakeup: boolean);

src/engine/extensions/NEEDLE_animator_controller_model.ts CHANGED Viewed

@@ -32,10 +32,17 @@
 export declare type State = {
     name: string,
     hash: number;
-    speed?: number;
     motion: Motion,
     transitions: Transition[],
     behaviours: StateMachineBehaviourModel[],
+    /** The base speed of the animation */
+    speed?: number;
+    /** Set to a animator controller float parameter name to multiply this ontop of the speed value */
+    speedParameter?: string;
+    /** Cycle offset normalized 0-1, used when starting a animation */
+    cycleOffset?: number;
+    /** If set to a parameter then this is used instead of the CycleOffset value to offset the animation start time */
+    cycleOffsetParameter?: string;
 }
 export declare type StateMachineBehaviourModel = {

src/engine-components/OrbitControls.ts CHANGED Viewed

@@ -43,16 +43,16 @@
         this.controls?.addEventListener("start", callback as any);
     }
+    /** When enabled the scene will be automatically fitted into the camera view in onEnable */
     @serializable()
+    autoFit: boolean = false;
+    @serializable()
     enableRotate: boolean = true;
     @serializable()
     autoRotate: boolean = false;
     @serializable()
     autoRotateSpeed: number = 1.0;
-    /** When enabled the scene will be automatically fitted into the camera view in onEnable */
     @serializable()
-    autoFit: boolean = false;
-    @serializable()
     enableKeys: boolean = true;
     @serializable()
     enableDamping: boolean = true;
@@ -70,7 +70,11 @@
     lookAtConstraint: LookAtConstraint | null = null;
     @serializable()
     lookAtConstraint01: number = 1;
+    /** If true user input interrupts the camera from animating to a target */
     @serializable()
+    allowInterrupt: boolean = true;
+    @serializable()
     middleClickToFocus: boolean = true;
     @serializable()
     doubleClickToFocus: boolean = true;
@@ -81,6 +85,8 @@
     useSlerp: boolean = true;
     debugLog: boolean = false;
+    /** The speed at which the camera target and the camera will be lerping to their destinations (if set via script or user input) */
     targetLerpSpeed = 5;
     /** When enabled OrbitControls will automatically raycast find a look at target in start */
@@ -253,10 +259,10 @@
         if (!this._controls) return;
         if (this._cameraObject !== this.context.mainCamera) return;
-        if (this.context.input.getPointerDown(0) || this.context.input.getPointerDown(1) || this.context.input.getPointerDown(2)) {
+        if (this.context.input.getPointerDown(1) || this.context.input.getPointerDown(2) || this.context.input.mouseWheelChanged || (this.context.input.getPointerPressed(0) && this.context.input.getPointerPositionDelta(0)?.length() || 0 > .1)) {
             this._inputs += 1;
         }
-        if (this._inputs > 0) {
+        if (this._inputs > 0 && this.allowInterrupt) {
             // if a user has disabled rotation but enabled auto rotate we don't want to change it when we receive input
             if (this.enableRotate) {
                 this.autoRotate = false;
@@ -271,10 +277,6 @@
         if (focusAtPointer) {
             this.setTargetFromRaycast();
         }
-        else if (this.context.input.getPointerDown(0) || this.context.input.mouseWheelChanged) {
-            this._lerpToTargetPosition = false;
-            this._lerpCameraToTarget = false;
-        }
         if (this._lerpToTargetPosition || this._lerpCameraToTarget) {
             const step = this.context.time.deltaTime * this.targetLerpSpeed;
@@ -293,7 +295,9 @@
                 else {
                     this._cameraObject?.position.lerp(this._cameraTargetPosition, step);
                 }
-                if (this._cameraObject.position.distanceTo(this._cameraTargetPosition) < .0001) {
+                const minDist = this.autoRotate ? .02 : .001;
+                const dist = this._cameraObject.position.distanceTo(this._cameraTargetPosition);
+                if (dist < minDist) {
                     this._lerpCameraToTarget = false;
                 }
             }
@@ -307,7 +311,6 @@
             }
         }
-        if (!freeCam && this.lookAtConstraint?.locked) this.setFromTargetPosition(0, this.lookAtConstraint01);
         if (this._controls) {
             if (this.debugLog)
@@ -328,9 +331,12 @@
             }
             //@ts-ignore
             // this._controls.zoomToCursor = this.zoomToCursor;
-            if (!this.context.isInXR)
+            if (!this.context.isInXR) {
+                if (!freeCam && this.lookAtConstraint?.locked) this.setFromTargetPosition(0, this.lookAtConstraint01);
                 this._controls.update();
+            }
         }
     }
     /** Moves the camera to position smoothly. @deprecated use `setCameraTargetPosition` */

src/engine-components/timeline/PlayableDirector.ts CHANGED Viewed

@@ -183,7 +183,11 @@
                 await delay(200);
         }
         this.invokeStateChangedMethodsOnTracks();
-        this._internalUpdateRoutine = this.startCoroutine(this.internalUpdate(), FrameEvent.OnBeforeRender);
+        // Update timeline in LateUpdate to give other scripts time to react to the updated state
+        // e.g. if we animate OrbitControls look at target we want those changes to be applied in onBeforeRender
+        // if we use onBeforeRender here it will be called *after* the regular onBeforeRender events
+        // which is too late
+        this._internalUpdateRoutine = this.startCoroutine(this.internalUpdate(), FrameEvent.LateUpdate);
     }
     pause() {
@@ -478,7 +482,7 @@
         this._signalTracks.length = 0;
         if (!this.playableAsset) return;
-        const audioListener: AudioListener | null = GameObject.findObjectOfType(AudioListener, this.context);
+        let audioListener: AudioListener | null = GameObject.findObjectOfType(AudioListener, this.context);
         for (const track of this.playableAsset!.tracks) {
             const type = track.type;
             const registered = PlayableDirector.createTrackFunctions[type];
@@ -557,7 +561,10 @@
                 audio.director = this;
                 audio.track = track;
                 this._audioTracks.push(audio);
-                if (!audioListener) continue;
+                if (!audioListener) {
+                    // If the scene doesnt have an AudioListener we add one to the main camera
+                    audioListener = this.context.mainCameraComponent?.gameObject.addNewComponent(AudioListener)!;
+                }
                 audio.listener = audioListener.listener;
                 for (let i = 0; i < track.clips.length; i++) {
                     const clipModel = track.clips[i];

src/engine-components/timeline/TimelineTracks.ts CHANGED Viewed

@@ -648,7 +648,7 @@
             }
             if (AudioSource.userInteractionRegistered === false) continue;
             if (audio === null || !audio.buffer) continue;
-            audio.playbackRate = this.director.context.time.timeScale;
+            audio.playbackRate = this.director.context.time.timeScale * this.director.speed;
             audio.loop = model.asset.loop;
             if (time >= model.start && time <= model.end && time < this.director.duration) {
                 if (this.director.isPlaying == false) {

src/engine-components/webxr/WebARSessionRoot.ts CHANGED Viewed

@@ -4,6 +4,7 @@
 import { InstancingUtil } from "../../engine/engine_instancing.js";
 import { serializable } from "../../engine/engine_serialization_decorator.js";
 import { Context } from "../../engine/engine_context.js";
+import { isQuest } from "../../engine/engine_utils.js";
 // https://github.com/takahirox/takahirox.github.io/blob/master/js.mmdeditor/examples/js/controls/DeviceOrientationControls.js
@@ -99,8 +100,8 @@
                 if (this.webAR) this.webAR.setReticleActive(false);
                 this.placeAt(rig, poseMatrix);
-                if (hit && pose)
-                    this.onCreatePlacementAnchor(hit, pose);
+                if (hit && pose && !isQuest()) // TODO anchors seem to behave differently with an XRRig
+                   this.onCreatePlacementAnchor(hit, pose);
                 return true;
             }