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

package/src/engine/engine_addressables.ts

@@ -5,7 +5,7 @@ import { Context } from "./engine_setup";
 import { Group, Object3D, Scene } from "three";
 import { processNewScripts } from "./engine_mainloop_utils";
 import { InstantiateEvent, registerPrefabProvider, syncInstantiate } from "./engine_networking_instantiate";
-import { download } from "./engine_web_api";
+import { download, hash } from "./engine_web_api";
 import { getLoader } from "./engine_gltf";
 import { SourceIdentifier } from "./engine_types";
 import { destroy, instantiate, InstantiateOptions } from "./engine_gameobject";
@@ -51,11 +51,11 @@ export class AssetReference {
 
     static getOrCreate(sourceId: SourceIdentifier, uri: string, context: Context): AssetReference {
         const fullPath = getPath(sourceId, uri);
-        if(debug) console.log("GetOrCreate Addressable from", sourceId, uri, "FinalPath=", fullPath);
+        if (debug) console.log("GetOrCreate Addressable from", sourceId, uri, "FinalPath=", fullPath);
         const addressables = context.addressables;
         const existing = addressables.findAssetReference(fullPath);
         if (existing) return existing;
-        const ref = new AssetReference(fullPath);
+        const ref = new AssetReference(fullPath, context.hash);
         addressables.registerAssetReference(ref);
         return ref;
     }
@@ -63,6 +63,7 @@ export class AssetReference {
     get asset(): any {
         return this._glbRoot ?? this._asset;
     }
+
     protected set asset(val: any) {
         this._asset = val;
     }
@@ -70,7 +71,7 @@ export class AssetReference {
     private _loading?: PromiseLike<any>;
 
     get uri(): string {
-        return this._uri!;
+        return this._uri;
     }
 
     get rawAsset(): any { return this._asset; }
@@ -80,11 +81,20 @@ export class AssetReference {
     private _uri: string;
     private _progressListeners: ProgressCallback[] = [];
 
+    private _hash?: string;
+    private _hashedUri: string;
+
     private _isLoadingRawBinary: boolean = false;
     private _rawBinary?: ArrayBuffer | null;
 
-    constructor(uri: string) {
+    constructor(uri: string, hash?: string) {
         this._uri = uri;
+        this._hash = hash;
+        if (uri.includes("?v="))
+            this._hashedUri = uri;
+        else
+            this._hashedUri = hash ? uri + "?v=" + hash : uri;
+
         registerPrefabProvider(this._uri, this.onResolvePrefab.bind(this));
     }
 
@@ -120,8 +130,8 @@ export class AssetReference {
         if (this._isLoadingRawBinary) return null;
         if (this._rawBinary !== undefined) return this._rawBinary;
         this._isLoadingRawBinary = true;
-        if (debug) console.log("Preload", this.uri);
-        const res = await download(this.uri, p => {
+        if (debug) console.log("Preload", this._hashedUri);
+        const res = await download(this._hashedUri, p => {
             this.raiseProgressEvent(p);
         });
         this._rawBinary = res?.buffer ?? null;
@@ -148,7 +158,7 @@ export class AssetReference {
         }
         else {
             if (debug) console.log("Load async", this.uri);
-            this._loading = getLoader().loadSync(context, this.uri, null, true, prog => {
+            this._loading = getLoader().loadSync(context, this._hashedUri, null, true, prog => {
                 this.raiseProgressEvent(prog);
             });
         }

package/src/engine/engine_element.ts

@@ -133,7 +133,8 @@ export class EngineElement extends HTMLElement implements INeedleEngineComponent
         if (srcAttributeValue) src = srcAttributeValue;
 
         const alias = this.getAttribute("alias");
-        this._context = new Context({ name: src, domElement: this, alias: alias });
+        const hash = this.getAttribute("hash");
+        this._context = new Context({ name: src, domElement: this, alias: alias, hash: hash ?? undefined });
         this._watcher = new EngineElementSourceFileWatcher(this.getAttribute("id") ?? alias ?? "", this._context);
 
         if (src && src.length > 0) {
@@ -234,7 +235,7 @@ export class EngineElement extends HTMLElement implements INeedleEngineComponent
     }
 
     static get observedAttributes() {
-        return ["src", "loadstart", "progress", "loadfinished", "dracoDecoderPath", "dracoDecoderType", "ktx2DecoderPath"];
+        return ["hash", "src", "loadstart", "progress", "loadfinished", "dracoDecoderPath", "dracoDecoderType", "ktx2DecoderPath"];
     }
 
     attributeChangedCallback(name: string, _oldValue: string, newValue: string) {

package/src/engine/engine_element_overlay.ts

@@ -73,11 +73,12 @@ export class AROverlayHandler {
             return element;
         }
         if (element.children) {
-            // @ts-ignore
-            for (const ch of element.children) {
+            for (let i = 0; i < element.children.length; i++) {
+                const ch = element.children[i] as HTMLElement;
                 if (!ch || !ch.classList) continue;
-                if (ch.classList.contains(arContainerClassName))
+                if (ch.classList.contains(arContainerClassName)) {
                     return ch;
+                }
             }
         }
 

package/src/engine/engine_input.ts

@@ -147,6 +147,10 @@ export class Input extends EventTarget {
         if (i >= this._mouseWheelChanged.length) return false;
         return this._mouseWheelChanged[i];
     }
+    getMouseWheelDeltaY(i: number = 0): number {
+        if (i >= this._mouseWheelDeltaY.length) return 0;
+        return this._mouseWheelDeltaY[i];
+    }
     getPointerEvent(i: number): Event | undefined {
         if (i >= this._pointerEvent.length) return undefined;
         return this._pointerEvent[i] ?? undefined;
@@ -169,6 +173,7 @@ export class Input extends EventTarget {
     private _pointerIds: number[] = [];
     private _pointerTypes: string[] = [""];
     private _mouseWheelChanged: boolean[] = [false];
+    private _mouseWheelDeltaY: number[] = [0];
     private _pointerEvent: Event[] = [];
 
     getKeyDown(): string | null {
@@ -269,11 +274,12 @@ export class Input extends EventTarget {
             this._pointerClick[i] = false;
         for (let i = 0; i < this._pointerDoubleClick.length; i++)
             this._pointerDoubleClick[i] = false;
-        for (const pt of this._pointerPositionsDelta) {
+        for (const pt of this._pointerPositionsDelta)
             pt.set(0, 0);
-        }
         for (let i = 0; i < this._mouseWheelChanged.length; i++)
             this._mouseWheelChanged[i] = false;
+        for (let i = 0; i < this._mouseWheelDeltaY.length; i++)
+            this._mouseWheelDeltaY[i] = 0;
     }
 
 
@@ -307,9 +313,12 @@ export class Input extends EventTarget {
         this.onDispatchEvent(InputEvents.KeyUp, new KeyEventArgs(evt));
     }
 
-    private onMouseWheel(_evt) {
+    private onMouseWheel(evt: WheelEvent) {
+        if (this._mouseWheelDeltaY.length <= 0) this._mouseWheelDeltaY.push(0);
         if (this._mouseWheelChanged.length <= 0) this._mouseWheelChanged.push(false);
         this._mouseWheelChanged[0] = true;
+        const current = this._mouseWheelDeltaY[0];
+        this._mouseWheelDeltaY[0] = current + evt.deltaY;
     }
 
     private onTouchMove(_evt) {

package/src/engine/engine_physics.ts

@@ -1,23 +1,20 @@
-import { BasicDepthPacking, Box3, BufferAttribute, BufferGeometry, Camera, Intersection, Layers, LineBasicMaterial, LineSegments, Matrix4, Mesh, NormalAnimationBlendMode, Object3D, Quaternion, Ray, Raycaster, Sphere, Vector2, Vector3 } from 'three'
+import { BasicDepthPacking, Box3, BufferAttribute, BufferGeometry, Camera, Intersection, Layers, LineBasicMaterial, LineSegments, Matrix4, Mesh, NormalAnimationBlendMode, NumberKeyframeTrack, Object3D, Quaternion, Ray, Raycaster, Sphere, Vector2, Vector3 } from 'three'
 import { Context } from './engine_setup';
 import { getParam } from "./engine_utils"
-import { getWorldPosition, getWorldQuaternion, getWorldScale, setWorldPosition, setWorldPositionXYZ, setWorldQuaternionXYZW } from "./engine_three_utils"
+import { getWorldPosition, getWorldQuaternion, getWorldScale, setWorldPositionXYZ, setWorldQuaternionXYZW } from "./engine_three_utils"
 import {
     IComponent,
-    IGameObject,
     ICollider,
     IRigidbody,
     Collision,
-    ICollisionContext,
     ContactPoint,
     Vec3
 } from './engine_types';
 import { InstancingUtil } from './engine_instancing';
 import { foreachComponent } from './engine_gameobject';
 
-import RAPIER, { ActiveEvents, Collider, ColliderDesc, EventQueue, RigidBody, TempContactManifold, World } from '@dimforge/rapier3d-compat';
-import { CollisionDetectionMode, RigidbodyConstraints } from '../engine/engine_physics.types';
-import { showBalloonWarning } from './debug/debug';
+import RAPIER, { ActiveEvents, Collider, ColliderDesc, EventQueue, JointData, RigidBody, RigidBodyType, World } from '@dimforge/rapier3d-compat';
+import { CollisionDetectionMode } from '../engine/engine_physics.types';
 export type Rapier = typeof RAPIER;
 
 
@@ -33,6 +30,8 @@ declare type PhysicsBody = {
 
 const $componentKey = Symbol("needle component");
 const $bodyKey = Symbol("physics body");
+const $colliderRigidbody = Symbol("rigidbody");
+// const $removed = Symbol("removed");
 
 export class RaycastOptions {
     ray: Ray | undefined = undefined;
@@ -209,6 +208,7 @@ export class Physics {
 
     private _tempPosition: Vector3 = new Vector3();
     private _tempQuaternion: Quaternion = new Quaternion();
+    private _tempScale: Vector3 = new Vector3();
     private _tempMatrix: Matrix4 = new Matrix4();
 
     private static _didLoadPhysicsEngine: boolean = false;
@@ -224,13 +224,10 @@ export class Physics {
     private collisionHandler?: PhysicsCollisionHandler;
 
 
-    // private rigidbodies: Array<IRigidbody | null> = [];
     private objects: IComponent[] = [];
     private bodies: PhysicsBody[] = [];
-    // private rigidbodiesLookup: Map<IRigidbody, RigidBody> = new Map<IRigidbody, RigidBody>();
-    // private kinematicColliders: Array<IComponent> = [];
-    // private rigidbodyLookup: Map<IRigidbody, IComponent[]> = new Map<IRigidbody, IComponent[]>();
-    // private objectLookup: Map<Object3D, IRigidbody> = new Map<Object3D, IRigidbody>();
+
+    private _meshCache: Map<string, Float32Array> = new Map<string, Float32Array>();
 
 
     constructor(context: Context) {
@@ -251,6 +248,10 @@ export class Physics {
         this.world = new World(gravity);
     }
 
+    clearCaches() {
+        this._meshCache.clear();
+    }
+
     addBoxCollider(collider: ICollider, center: Vector3, size: Vector3) {
         const obj = collider.gameObject;
         const scale = getWorldScale(obj, this._tempPosition).multiply(size);
@@ -266,6 +267,14 @@ export class Physics {
         this.createCollider(collider, desc, center);
     }
 
+    addCapsuleCollider(collider: ICollider, center: Vector3, height: number, radius: number) {
+        const obj = collider.gameObject;
+        const scale = getWorldScale(obj, this._tempPosition);
+        if (debugPhysics) console.log("capsule scale", scale, height, radius);
+        const desc = ColliderDesc.capsule(height * .5 * scale.y - radius, radius * scale.x);
+        this.createCollider(collider, desc, center);
+    }
+
     addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean) {
         const geo = mesh.geometry;
         if (!geo) {
@@ -281,15 +290,22 @@ export class Physics {
         // scaling seems not supported yet https://github.com/dimforge/rapier/issues/243
         const scale = getWorldScale(mesh, this._tempPosition)
         if (Math.abs(scale.x - 1) > 0.0001 || Math.abs(scale.y - 1) > 0.0001 || Math.abs(scale.z - 1) > 0.0001) {
-            console.warn("Your model is using scaled mesh colliders which is not optimal for performance", mesh.name, Object.assign({}, scale), mesh);
-            // showBalloonWarning("Your model is using scaled mesh colliders which is not optimal for performance: " + mesh.name + ", consider using unscaled objects");
-            const scaledPositions = new Float32Array(positions.length);
-            for (let i = 0; i < positions.length; i += 3) {
-                scaledPositions[i] = positions[i] * scale.x;
-                scaledPositions[i + 1] = positions[i + 1] * scale.y;
-                scaledPositions[i + 2] = positions[i + 2] * scale.z;
+            const key = geo.uuid + "_" + scale.x + "_" + scale.y + "_" + scale.z + "_" + convex;
+            if (this._meshCache.has(key)) {
+                positions = this._meshCache.get(key)!;
+            }
+            else {
+                console.warn("Your model is using scaled mesh colliders which is not optimal for performance", mesh.name, Object.assign({}, scale), mesh);
+                // showBalloonWarning("Your model is using scaled mesh colliders which is not optimal for performance: " + mesh.name + ", consider using unscaled objects");
+                const scaledPositions = new Float32Array(positions.length);
+                for (let i = 0; i < positions.length; i += 3) {
+                    scaledPositions[i] = positions[i] * scale.x;
+                    scaledPositions[i + 1] = positions[i + 1] * scale.y;
+                    scaledPositions[i + 2] = positions[i + 2] * scale.z;
+                }
+                positions = scaledPositions;
+                this._meshCache.set(key, scaledPositions);
             }
-            positions = scaledPositions;
         }
 
         const desc = convex ? ColliderDesc.convexMesh(positions) : ColliderDesc.trimesh(positions, indices);
@@ -308,9 +324,10 @@ export class Physics {
             useExplicitMassProperties
         } = this.getRigidbody(collider, this._tempMatrix);
 
-        matrix.decompose(this._tempPosition, this._tempQuaternion, new Vector3());
+        matrix.decompose(this._tempPosition, this._tempQuaternion, this._tempScale);
+        getWorldScale(collider.gameObject, this._tempScale);
         if (center)
-            this._tempPosition.add(center);
+            this._tempPosition.add(center).multiply(this._tempScale);
         desc.setTranslation(this._tempPosition.x, this._tempPosition.y, this._tempPosition.z);
         desc.setRotation(this._tempQuaternion);
 
@@ -373,13 +390,15 @@ export class Physics {
 
         }
 
+        collider[$colliderRigidbody] = rigidBody;
+
         return { rigidBody: rigidBody, useExplicitMassProperties: useExplicitMassProperties };
     }
 
     removeBody(obj: IComponent) {
         const body = obj[$bodyKey];
         obj[$bodyKey] = null;
-        if (body) {
+        if (body && this.world) {
             const index = this.objects.findIndex(o => o === obj);
             if (index >= 0) {
                 const body = this.bodies[index];
@@ -387,20 +406,37 @@ export class Physics {
                 this.objects.splice(index, 1);
 
                 if (body instanceof Collider) {
-                    this.world?.removeCollider(body as Collider, true);
+                    const collider = body as Collider;
+                    this.world?.removeCollider(collider, true);
+
+                    // remove the rigidbody if it doesnt have colliders anymore
+                    const rb = collider.parent();
+                    if (rb && rb.numColliders() <= 0) {
+                        this.world?.removeRigidBody(rb);
+                    }
                 }
                 else if (body instanceof RigidBody) {
-                    this.world?.removeRigidBody(body as RigidBody);
+                    // TODO: running this code below causes a crash in rapier
+                    // const rb = body as RigidBody;
+                    // console.log("colliders", rb.numColliders())
+                    // for (let i = 0; i < rb.numColliders(); i++) {
+                    //     const col = rb.collider(i);
+                    //     this.world?.removeCollider(col, true);
+                    // }
+                    // console.log("colliders", rb.numColliders(), rb)
+                    // console.log(rb.handle, rb.userData);
+                    // if (rb.userData === undefined)
+                    //     this.world?.removeRigidBody(rb);
                 }
 
                 // check if we need to remove the rigidbody too
-                const col = obj as ICollider;
-                if (col.isCollider && col.attachedRigidbody) {
-                    const rb = col.attachedRigidbody[$bodyKey];
-                    if (rb && rb.numColliders() <= 0 && rb.world() === this.world) {
-                        this.world?.removeRigidBody(rb);
-                    }
-                }
+                // const col = obj as ICollider;
+                // if (col.isCollider && col.attachedRigidbody) {
+                //     const rb = col.attachedRigidbody[$bodyKey] as RigidBody;
+                //     if (rb && rb.numColliders() <= 0) {
+                //         // this.world?.removeRigidBody(rb);
+                //     }
+                // }
             }
         }
     }
@@ -526,10 +562,22 @@ export class Physics {
                 continue;
             }
 
+
             // sync
             const pos = body.translation();
-            setWorldPositionXYZ(obj.gameObject, pos.x, pos.y, pos.z);
             const rot = body.rotation();
+            // make sure to keep the collider offset
+            const center = obj["center"] as Vector3;
+            if (center && center.isVector3) {
+                this._tempQuaternion.set(rot.x, rot.y, rot.z, rot.w);
+                const offset = this._tempPosition.copy(center).applyQuaternion(this._tempQuaternion);
+                const scale = getWorldScale(obj.gameObject);
+                offset.multiply(scale);
+                pos.x -= offset.x;
+                pos.y -= offset.y;
+                pos.z -= offset.z;
+            }
+            setWorldPositionXYZ(obj.gameObject, pos.x, pos.y, pos.z);
             setWorldQuaternionXYZW(obj.gameObject, rot.x, rot.y, rot.z, rot.w);
         }
     }
@@ -542,13 +590,27 @@ export class Physics {
 
         const worldPosition = getWorldPosition(obj, this._tempPosition);
         const worldQuaternion = getWorldQuaternion(obj, this._tempQuaternion);
+        const type = body.bodyType();
+        switch (type) {
+            case RigidBodyType.Fixed:
+            case RigidBodyType.KinematicPositionBased:
+            case RigidBodyType.KinematicVelocityBased:
+                if (translation)
+                    body.setNextKinematicTranslation(worldPosition);
+                if (rotation)
+                    body.setNextKinematicRotation(worldQuaternion);
+                break;
+            default:
+                if (translation)
+                    body.setTranslation(worldPosition, false);
+                if (rotation)
+                    body.setRotation(worldQuaternion, false);
+                break;
+
+        }
+        body.wakeUp();
         // physicsBody.setBodyType(RAPIER.RigidBodyType.Fixed);
-        if (translation)
-            body.setTranslation(worldPosition, false);
-        if (rotation)
-            body.setRotation(worldQuaternion, false);
         // physicsBody.setLinvel(vel, false);
-        body.wakeUp();
 
         // update velocity
         // const pos = physicsBody.translation();
@@ -596,30 +658,29 @@ export class Physics {
         return mat;
     }
 
+    private static centerConnectionPos = { x: 0, y: 0, z: 0 };
+    private static centerConnectionRot = { x: 0, y: 0, z: 0, w: 1 };
 
-}
-
-
-export interface IColliderProvider {
-    getCollider(obj: Object3D): ICollider;
-}
-
-let colliderProvider: IColliderProvider | null = null;
-export function registerColliderProvider(prov: IColliderProvider) {
-    colliderProvider = prov;
-}
-
-class CollisionContext implements ICollisionContext {
-
-    getCollider(obj: Object3D<Event>): ICollider {
-        return colliderProvider!.getCollider(obj);
+    addFixedJoint(body1: IRigidbody, body2: IRigidbody, rel: { x: number, y: number, z: number }) {
+        if (!this.world) {
+            console.error("Physics world not initialized");
+            return;
+        }
+        const b1 = body1[$bodyKey] as RigidBody;
+        const b2 = body2[$bodyKey] as RigidBody;
+        const rot = body1.worldQuaternion.multiply(body2.worldQuaternion.invert());
+        const params = JointData.fixed(
+            Physics.centerConnectionPos, Physics.centerConnectionRot,
+            rel, rot
+        );
+        const joint = this.world.createImpulseJoint(params, b1, b2, true);
+        console.log("ADD JOINT", joint)
     }
 
 }
 
 
 
-
 /** responsible of processing collision events for the component system */
 class PhysicsCollisionHandler {
 
@@ -642,7 +703,8 @@ class PhysicsCollisionHandler {
             const col2 = this.world!.getCollider(handle2);
             const colliderComponent1 = col1[$componentKey];
             const colliderComponent2 = col2[$componentKey];
-            // console.log("EVT", colliderComponent1.name, colliderComponent2.name, started);
+            if (debugCollisions)
+                console.log("EVT", colliderComponent1.name, colliderComponent2.name, started, col1, col2);
             if (colliderComponent1 && colliderComponent2) {
                 if (started) {
                     this.onCollisionStarted(colliderComponent1, col1, colliderComponent2, col2);
@@ -710,7 +772,7 @@ class PhysicsCollisionHandler {
         for (const active of this.activeTriggers) {
             const c = active.component;
             if (c.activeAndEnabled && c.onTriggerStay) {
-                const arg = active.collider;
+                const arg = active.otherCollider;
                 c.onTriggerStay(arg);
             }
         }

package/src/engine/engine_physics.types.ts

@@ -16,4 +16,13 @@ export enum RigidbodyConstraints {
   FreezeRotationZ = 64,
   FreezeRotation = 112,
   FreezeAll = 126,
+}
+
+
+export enum Axes {
+  None = 0,
+  X = 2,
+  Y = 4,
+  Z = 8,
+  All = ~0,
 }