@needle-tools/engine 2.36.0-pre → 2.37.0-pre

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [2.37.0-pre] - 2022-10-28
+- Add: rapier physics backend and overall improved physics system like constraint support, fixed physics collider updates and synchronization between rendering and physics world or animation of physical bodies 
+- Remove: cannon-es
+- Add basic mesh collider support
+- Add ``@validate`` decorator and ``onValidate`` event method that can be used to automatically get callbacks when marked properties are being written to (for example internally this is used on the Rigidbody to update the physics body when values on the Rigidbody component are being updated)
+- Change: assign nested gltf layers
+- Change: reworked Rigidbody api
+- Fix: allow Draco and KRTX compression on custom hand models
+- Fix: applying Unity layers to threejs objects
+- Fix: BoxHelper stopped working with SpatialTrigger
+- Fix: AR reticle showing up in wrong position with transformed WebARSessionRoot
+
 ## [2.36.0-pre] - 2022-10-26
 - Add: Expose WebXR hand model path
 - Add: Animation component can now be configured with random time scale and offset

package/dist/needle-engine.d.ts

@@ -23,10 +23,28 @@ declare module "engine-components/js-extensions/RGBAColor" {
         multiply(color: Color): this;
     }
 }
+declare module "engine/engine_physics.types" {
+    export enum CollisionDetectionMode {
+        Discrete = 0,
+        Continuous = 1
+    }
+    export enum RigidbodyConstraints {
+        None = 0,
+        FreezePositionX = 2,
+        FreezePositionY = 4,
+        FreezePositionZ = 8,
+        FreezePosition = 14,
+        FreezeRotationX = 16,
+        FreezeRotationY = 32,
+        FreezeRotationZ = 64,
+        FreezeRotation = 112,
+        FreezeAll = 126
+    }
+}
 declare module "engine/engine_types" {
-    import { Camera, Color, Material, Object3D, Vector3 } from "three";
-    import { Body, ContactEquation } from "cannon-es";
+    import { Camera, Color, Material, Object3D, Vector3, Quaternion } from "three";
     import { RGBAColor } from "engine-components/js-extensions/RGBAColor";
+    import { CollisionDetectionMode, RigidbodyConstraints } from "engine/engine_physics.types";
     /** used to find data registered via gltf files e.g. find lightmaps for a Renderer component that were shipped inside a gltf */
     export type SourceIdentifier = string;
     export type Constructor<T> = abstract new (...args: any[]) => T;
@@ -68,6 +86,8 @@ declare module "engine/engine_types" {
         onEnable(): any;
         onDisable(): any;
         onDestroy(): any;
+        /** called for properties decorated with the @validate decorator */
+        onValidate?(property?: string): any;
         start?(): void;
         earlyUpdate?(): void;
         update?(): void;
@@ -76,14 +96,13 @@ declare module "engine/engine_types" {
         onAfterRender?(): void;
         onCollisionEnter?(col: Collision): any;
         onCollisionExit?(col: Collision): any;
-        onCollisionExitRaw?(col: Collision): any;
         onCollisionStay?(col: Collision): any;
-        onTriggerEnter?(col: Collision): any;
-        onTriggerStay?(col: Collision): any;
-        onTriggerExit?(col: Collision): any;
-        __internalHandleCollision(col: Collision, isTriggerCollision: boolean): any;
-        __internalHandleExitCollisionEvent(obj: Object3D, isTriggerCollision: boolean): any;
+        onTriggerEnter?(col: ICollider): any;
+        onTriggerStay?(col: ICollider): any;
+        onTriggerExit?(col: ICollider): any;
         get forward(): Vector3;
+        get worldPosition(): Vector3;
+        get worldQuaternion(): Quaternion;
     }
     export interface ICamera extends IComponent {
         applyClearFlagsIfIsActiveCamera(): unknown;
@@ -114,33 +133,51 @@ declare module "engine/engine_types" {
         isTrigger: boolean;
     }
     export interface IRigidbody extends IComponent {
-        initialize(): void;
-        body: any;
+        constraints: RigidbodyConstraints;
+        isKinematic: boolean;
+        mass: number;
+        drag: number;
+        angularDrag: number;
+        useGravity: boolean;
+        collisionDetectionMode: CollisionDetectionMode;
+        lockPositionX: boolean;
+        lockPositionY: boolean;
+        lockPositionZ: boolean;
+        lockRotationX: boolean;
+        lockRotationY: boolean;
+        lockRotationZ: boolean;
     }
     export const $physicsKey: unique symbol;
-    export type CannonCollision = {
-        body: Body;
-        contact: ContactEquation;
-        target: Body;
-        type: string;
-    };
     export type ICollisionContext = {
         getCollider(obj: Object3D): ICollider;
     };
+    export type Vec3 = {
+        x: number;
+        y: number;
+        z: number;
+    };
+    export type Vec2 = {
+        x: number;
+        y: number;
+    };
+    export class ContactPoint {
+        readonly localPoint: Vec3;
+        readonly distance: number;
+        readonly normal: Vec3;
+        constructor(localPt: Vec3, dist: number, normal: Vec3);
+    }
     export class Collision {
-        get __internalCollision(): CannonCollision;
-        get __internalInvertedSourceReceiver(): boolean;
-        private readonly invert;
-        private readonly collision;
-        private readonly targetBody;
-        private readonly context;
+        private readonly contacts;
+        constructor(obj: Object3D, otherCollider: ICollider, contacts: ContactPoint[]);
         readonly me: Object3D;
-        private _normal?;
-        get normal(): Vector3;
-        private _collider?;
+        private _collider;
+        /** the collider the collision happened with */
         get collider(): ICollider;
+        /** the object the collision happened with */
+        private _gameObject;
         get gameObject(): Object3D;
-        constructor(obj: Object3D, collision: CannonCollision, context: ICollisionContext, invert?: boolean);
+        /** the rigidbody we hit, null if none attached */
+        get rigidBody(): IRigidbody | null;
     }
 }
 declare module "engine/engine_utils" {
@@ -164,7 +201,7 @@ declare module "engine/engine_utils" {
     export function deepClone(obj: any, predicate?: deepClonePredicate): any;
     export function delay(milliseconds: number): Promise<void>;
     export function getPath(source: SourceIdentifier | undefined, uri: string): string;
-    export type WriteCallback = (data: any) => void;
+    export type WriteCallback = (data: any, prop: string) => void;
     export interface IWatch {
         subscribeWrite(callback: WriteCallback): any;
         apply(): any;
@@ -254,6 +291,7 @@ declare module "engine/debug/debug" {
     import { LogType } from "engine/debug/debug_overlay";
     export { LogType };
     export function showBalloonMessage(text: string, logType?: LogType): void;
+    export function showBalloonWarning(text: string): void;
 }
 declare module "engine/engine_serialization_core" {
     import { GLTF } from "three/examples/jsm/loaders/GLTFLoader";
@@ -323,6 +361,9 @@ declare module "engine/engine_serialization_core" {
     }
     export function serializeObject(obj: ISerializable, context: SerializationContext): object | null;
     export function deserializeObject(obj: ISerializable, serializedData: object, context: SerializationContext): boolean;
+    /** set to true while assigning properties during instantiation.
+     * Used for validate decorator to not invoke callbacks on components that are currently in the process of being built */
+    export const $isAssigningProperties: unique symbol;
     /** Object.assign behaviour but check if property is writeable (e.g. getter only properties are skipped) */
     export function assign(target: any, source: any): void;
 }
@@ -685,19 +726,11 @@ declare module "engine/engine_gameobject" {
     export function instantiate(instance: GameObject | Object3D | null, opts?: InstantiateOptions | null): GameObject | null;
 }
 declare module "engine/engine_physics" {
-    import { Body, Constraint } from 'cannon-es';
-    import { Camera, Intersection, Layers, Object3D, Ray, Raycaster, Vector2, Vector3 } from 'three';
+    import { Camera, Intersection, Layers, Mesh, Object3D, Ray, Raycaster, Vector2, Vector3 } from 'three';
     import { Context } from "engine/engine_setup";
-    import { IGameObject as GameObject, ICollider, IRigidbody as Rigidbody } from "engine/engine_types";
-    import { Shape } from 'cannon-es';
-    export class BodyOptions {
-        mass: number;
-        kinematic: boolean;
-        physicsEvents: boolean;
-        drag: number;
-        angularDrag: number;
-        sleepThreshold: number;
-    }
+    import { IComponent, ICollider, IRigidbody } from "engine/engine_types";
+    import RAPIER, { RigidBody } from '@dimforge/rapier3d-compat';
+    export type Rapier = typeof RAPIER;
     export class RaycastOptions {
         ray: Ray | undefined;
         cam: Camera | undefined | null;
@@ -733,41 +766,40 @@ declare module "engine/engine_physics" {
         private onSphereOverlap;
         raycastFromRay(ray: Ray, options?: RaycastOptions | null): Array<Intersection>;
         raycast(options?: RaycastOptions | null): Array<Intersection>;
-        get isUpdating(): boolean;
+        private _tempPosition;
+        private _tempQuaternion;
+        private _tempMatrix;
+        private static _didLoadPhysicsEngine;
         private _isUpdatingPhysicsWorld;
+        get isUpdating(): boolean;
         private context;
-        private world;
+        private world?;
+        private _hasCreatedWorld;
+        private eventQueue?;
+        private collisionHandler?;
         private objects;
-        private tempPosition;
-        private tempQuaternion;
+        private bodies;
         constructor(context: Context);
-        addPreStepListener(listener: (evt: any) => void): void;
-        addPostStepListener(listener: (evt: any) => void): void;
-        addConstraint(constraint: Constraint): void;
-        setGravity(vec: Vector3): void;
-        multiplyGravity(vec: Vector3): void;
-        addBody(go: GameObject, body: Body): void;
-        removeBody(go: GameObject, body: Body, removeCompletely?: boolean): void;
-        removeShape(obj: Object3D, shape: Shape): void;
-        createBody(obj: Object3D, settings: BodyOptions): Body;
-        addBoxCollider(obj: Object3D, trigger: boolean, center: Vector3, size: Vector3, rb: Rigidbody | null): Shape;
-        addSphereCollider(obj: Object3D, center: Vector3, radius: number, rb: Rigidbody | null): Shape;
-        addMeshCollider(_obj: Object3D): void;
-        private isAlreadyRegistered;
-        private readonly tempMat1;
-        private readonly tempMat2;
-        private addShape;
-        step(deltaTime: number): void;
-        private temp;
-        private tempQuat;
+        createWorld(): Promise<void>;
+        addBoxCollider(collider: ICollider, center: Vector3, size: Vector3): void;
+        addSphereCollider(collider: ICollider, center: Vector3, radius: number): void;
+        addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean): void;
+        private createCollider;
+        private getRigidbody;
+        removeBody(obj: IComponent): void;
+        updateBody(comp: ICollider | IRigidbody, translation: boolean, rotation: boolean): void;
+        updateProperties(rigidbody: IRigidbody): void;
+        internal_getRigidbody(rb: IRigidbody): RigidBody | null;
+        private internalUpdateProperties;
+        private lines?;
+        step(_deltaTime?: number): void;
+        private updateDebugRendering;
         postStep(): void;
-        private internalCreateBody;
-        private registerCollisionEvents;
-        private unregisterCollisionEvents;
-        private onBeginContact;
-        private readonly collisionContext;
-        private raiseCollisionEvents;
-        private onEndContact;
+        /** sync rendered objects with physics world (except for colliders without rigidbody) */
+        private syncObjects;
+        private syncPhysicsBody;
+        private static _matricesBuffer;
+        private getRigidbodyRelativeMatrix;
     }
     export interface IColliderProvider {
         getCollider(obj: Object3D): ICollider;
@@ -1150,7 +1182,7 @@ declare module "engine-components/Component" {
     import * as THREE from "three";
     import { Context, FrameEvent } from "engine/engine_setup";
     import { Object3D } from "three";
-    import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, Collision } from "engine/engine_types";
+    import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, Collision, ICollider } from "engine/engine_types";
     import { InstantiateOptions, HideFlags } from "engine/engine_gameobject";
     abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGameObject {
         guid: string | undefined;
@@ -1226,6 +1258,7 @@ declare module "engine-components/Component" {
         onEnable(): void;
         onDisable(): void;
         onDestroy(): void;
+        onValidate?(prop?: string): void;
         start?(): void;
         earlyUpdate?(): void;
         update?(): void;
@@ -1234,11 +1267,10 @@ declare module "engine-components/Component" {
         onAfterRender?(): void;
         onCollisionEnter?(col: Collision): any;
         onCollisionExit?(col: Collision): any;
-        onCollisionExitRaw?(col: Collision): any;
         onCollisionStay?(col: Collision): any;
-        onTriggerEnter?(col: Collision): any;
-        onTriggerStay?(col: Collision): any;
-        onTriggerExit?(col: Collision): any;
+        onTriggerEnter?(col: ICollider): any;
+        onTriggerStay?(col: ICollider): any;
+        onTriggerExit?(col: ICollider): any;
         startCoroutine(routine: Generator, evt?: FrameEvent): Generator;
         stopCoroutine(routine: Generator, evt?: FrameEvent): void;
         get destroyed(): boolean;
@@ -1249,6 +1281,7 @@ declare module "engine-components/Component" {
         protected __isEnabled: boolean | undefined;
         private __destroyed;
         get __internalDidAwakeAndStart(): boolean;
+        constructor();
         __internalNewInstanceCreated(): void;
         __internalAwake(): void;
         __internalStart(): void;
@@ -1257,16 +1290,6 @@ declare module "engine-components/Component" {
         __internalDestroy(): void;
         get enabled(): boolean;
         set enabled(val: boolean);
-        constructor();
-        private _collisionExitRoutine;
-        private _collisions;
-        private _triggerExitRoutine;
-        private _triggerCollisions;
-        get collisionsCount(): number;
-        private __internalResetsCachedPhysicsData;
-        __internalHandleCollision(col: Collision, isTriggerCollision: boolean): void;
-        __internalHandleExitCollisionEvent(obj: Object3D, isTriggerCollision: boolean): void;
-        private __waitForCollisionExit;
         private static _worldPositionBuffer;
         private static _worldQuaternionBuffer;
         private static _worldEulerBuffer;
@@ -2006,7 +2029,8 @@ declare module "engine-components/Animator" {
 declare module "engine-components/Animation" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from 'three';
-    import { AnimationAction, AnimationClip, Vector2 } from "three";
+    import { AnimationAction, AnimationClip } from "three";
+    import { Vec2 } from "engine/engine_types";
     export class PlayOptions {
         fadeDuration?: number;
         loop?: boolean;
@@ -2014,14 +2038,14 @@ declare module "engine-components/Animation" {
         startTime?: number;
         endTime?: number;
         clampWhenFinished?: boolean;
-        minMaxSpeed?: Vector2;
-        minMaxOffsetNormalized?: Vector2;
+        minMaxSpeed?: Vec2;
+        minMaxOffsetNormalized?: Vec2;
     }
     export class Animation extends Behaviour {
         playAutomatically: boolean;
         randomStartTime: boolean;
-        minMaxSpeed?: Vector2;
-        minMaxOffsetNormalized?: Vector2;
+        minMaxSpeed?: Vec2;
+        minMaxOffsetNormalized?: Vec2;
         private _tempAnimationClipBeforeGameObjectExisted;
         get clip(): AnimationClip | null;
         set clip(val: AnimationClip | null);
@@ -2313,6 +2337,13 @@ declare module "engine/engine_element" {
         private onBeforeBeginLoading;
     }
 }
+declare module "engine/engine_util_decorator" {
+    import { IComponent } from "engine/engine_types";
+    type setter = (v: any) => void;
+    type getter = () => any;
+    /** create accessor callbacks for a field */
+    export const validate: (set?: setter, get?: getter) => (target: IComponent | any, propertyKey: string, descriptor?: undefined) => void;
+}
 declare module "engine/api" {
     export { InstancingUtil } from "engine/engine_instancing";
     export * from "engine/engine_gameobject";
@@ -2320,6 +2351,7 @@ declare module "engine/api" {
     export { AssetReference } from "engine/engine_addressables";
     export { FrameEvent } from "engine/engine_setup";
     export * from "engine/debug/debug";
+    export { validate } from "engine/engine_util_decorator";
 }
 declare module "engine-components/AlignmentConstraint" {
     import { Behaviour } from "engine-components/Component";
@@ -2529,65 +2561,79 @@ declare module "engine-components/BoxHelperComponent" {
 }
 declare module "engine-components/RigidBody" {
     import { Behaviour } from "engine-components/Component";
-    import * as CANNON from 'cannon-es';
     import * as THREE from 'three';
     import { Vector3 } from "three";
     import { IRigidbody } from "engine/engine_types";
+    import { CollisionDetectionMode, RigidbodyConstraints } from "engine/engine_physics.types";
     export class Rigidbody extends Behaviour implements IRigidbody {
         mass: number;
-        set isKinematic(kinematic: boolean);
-        get isKinematic(): boolean;
-        private _isKinematic;
+        useGravity: boolean;
+        constraints: RigidbodyConstraints;
+        isKinematic: boolean;
         drag: number;
         angularDrag: number;
         detectCollisions: boolean;
         sleepThreshold: number;
-        get body(): CANNON.Body | null;
+        collisionDetectionMode: CollisionDetectionMode;
+        get lockPositionX(): boolean;
+        get lockPositionY(): boolean;
+        get lockPositionZ(): boolean;
+        get lockRotationX(): boolean;
+        get lockRotationY(): boolean;
+        get lockRotationZ(): boolean;
+        set lockPositionX(v: boolean);
+        set lockPositionY(v: boolean);
+        set lockPositionZ(v: boolean);
+        set lockRotationX(v: boolean);
+        set lockRotationY(v: boolean);
+        set lockRotationZ(v: boolean);
+        private _propertiesChanged;
         private static tempPosition;
-        private _body;
-        private currentVelocity;
+        private _currentVelocity;
         private _smoothedVelocity;
-        private lastWorldPosition;
-        private _ignoreChange;
-        private _dirty;
-        private _positionWatch?;
-        private _matrixWatch?;
-        private _setMatrix;
-        constructor();
+        private _smoothedVelocityGetter;
+        private _lastPosition;
+        private _watch?;
         awake(): void;
         onEnable(): void;
         onDisable(): void;
         onDestroy(): void;
-        onBeforeRender(): void;
-        initialize(): void;
+        onValidate(): void;
+        earlyUpdate(): void;
+        private get body();
+        resetForces(): void;
+        resetTorques(): void;
+        resetVelocities(): void;
+        resetForcesAndTorques(): void;
         wakeUp(): void;
-        applyForce(vec: THREE.Vector3, rel?: THREE.Vector3): void;
+        applyForce(vec: Vector3, _rel?: THREE.Vector3): void;
+        applyImpulse(vec: Vector3): void;
         setForce(x: number, y: number, z: number): void;
-        getVelocity(): THREE.Vector3;
-        setVelocity(x: number | Vector3, y: number, z: number): void;
-        getTorque(): THREE.Vector3;
+        getVelocity(): Vector3;
+        setVelocity(x: number | Vector3, y?: number, z?: number): void;
+        setAngularVelocity(x: number | Vector3, y?: number, z?: number): void;
         setTorque(x: number | Vector3, y: number, z: number): void;
-        get smoothedVelocity(): THREE.Vector3;
-        setAngularVelocity(x: number, y: number, z: number): void;
-        private static copyVector3;
-        setBodyFromGameObject(velocity?: THREE.Vector3 | null | {
+        get smoothedVelocity(): Vector3;
+        /**d
+         * @deprecated not used anymore
+         */
+        setBodyFromGameObject(_velocity?: THREE.Vector3 | null | {
             x: number;
             y: number;
             z: number;
         }): void;
-        private updateVelocity;
+        private captureVelocity;
     }
 }
 declare module "engine-components/Collider" {
     import { Behaviour } from "engine-components/Component";
     import { Rigidbody } from "engine-components/RigidBody";
-    import { Shape } from "cannon-es";
+    import { Mesh } from "three";
     import { ICollider } from "engine/engine_types";
     export class Collider extends Behaviour implements ICollider {
         get isCollider(): any;
         attachedRigidbody: Rigidbody | null;
         isTrigger: boolean;
-        protected _shape: Shape | null;
         awake(): void;
         start(): void;
         onEnable(): void;
@@ -2603,6 +2649,12 @@ declare module "engine-components/Collider" {
         center: THREE.Vector3;
         onEnable(): void;
     }
+    export class MeshCollider extends Collider {
+        sharedMesh?: Mesh;
+        convex: boolean;
+        awake(): void;
+        onEnable(): void;
+    }
 }
 declare module "engine-components/ui/PointerEvents" {
     export interface IInputEventArgs {
@@ -3554,6 +3606,7 @@ declare module "engine-components/WebXR" {
         get webxr(): WebXR;
         private _webxr;
         private reticle;
+        private reticleParent;
         private hitTestSource;
         private reticleActive;
         private previousBackground;
@@ -3882,13 +3935,6 @@ declare module "engine-components/LODGroup" {
         distanceFactor(factor: number): void;
     }
 }
-declare module "engine-components/NavMesh" {
-    import { Behaviour } from "engine-components/Component";
-    export class NavMesh extends Behaviour {
-    }
-    export class NavMeshAgent extends Behaviour {
-    }
-}
 declare module "engine-components/NestedGltf" {
     import { Behaviour } from "engine-components/Component";
     import { AssetReference, ProgressCallback } from "engine/engine_addressables";
@@ -4323,6 +4369,7 @@ declare module "engine-components/SpectatorCamera" {
         /** list of other users that are following me */
         get followers(): string[];
         stopSpectating(): void;
+        private get localId();
         /** player view to follow */
         set target(target: PlayerView | undefined);
         get target(): PlayerView | undefined;
@@ -4347,21 +4394,6 @@ declare module "engine-components/SpectatorCamera" {
         private resetAvatarFlags;
     }
 }
-declare module "engine-components/SpringJoint" {
-    import { Behaviour } from "engine-components/Component";
-    import { Rigidbody } from "engine-components/RigidBody";
-    import { Vector3 } from "three";
-    export class SpringJoint extends Behaviour {
-        anchor: Vector3 | null;
-        connectedBody: Rigidbody | null;
-        connectedAnchor: Vector3 | null;
-        spring: number;
-        damper: number;
-        private rb;
-        awake(): void;
-        update(): void;
-    }
-}
 declare module "engine-components/SpriteRenderer" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
@@ -5303,6 +5335,7 @@ declare module "engine-components/codegen/components" {
     export { Collider } from "engine-components/Collider";
     export { SphereCollider } from "engine-components/Collider";
     export { BoxCollider } from "engine-components/Collider";
+    export { MeshCollider } from "engine-components/Collider";
     export { DeleteBox } from "engine-components/DeleteBox";
     export { Deletable } from "engine-components/DeleteBox";
     export { DeviceFlag } from "engine-components/DeviceFlag";
@@ -5325,8 +5358,6 @@ declare module "engine-components/codegen/components" {
     export { LODModel } from "engine-components/LODGroup";
     export { LODGroup } from "engine-components/LODGroup";
     export { LookAtConstraint } from "engine-components/LookAtConstraint";
-    export { NavMesh } from "engine-components/NavMesh";
-    export { NavMeshAgent } from "engine-components/NavMesh";
     export { NestedGltf } from "engine-components/NestedGltf";
     export { Networking } from "engine-components/Networking";
     export { OffsetConstraint } from "engine-components/OffsetConstraint";
@@ -5351,7 +5382,6 @@ declare module "engine-components/codegen/components" {
     export { SpatialTriggerReceiver } from "engine-components/SpatialTrigger";
     export { SpatialTrigger } from "engine-components/SpatialTrigger";
     export { SpectatorCamera } from "engine-components/SpectatorCamera";
-    export { SpringJoint } from "engine-components/SpringJoint";
     export { Sprite } from "engine-components/SpriteRenderer";
     export { SpriteRenderer } from "engine-components/SpriteRenderer";
     export { SyncedCamera } from "engine-components/SyncedCamera";