Needle Engine 3.47.0-beta

Files changed (7) hide show

src/engine/engine_physics_rapier.ts +28 -7
src/engine/engine_physics.ts +317 -35
src/engine-components/ui/EventSystem.ts +6 -4
src/engine-components/ui/Raycaster.ts +3 -1
src/engine-components/RigidBody.ts +7 -3
src/engine-components/ui/Text.ts +1 -1
src/engine/physics/workers/mesh-bvh/GenerateMeshBVHWorker.js +122 -0

src/engine/engine_physics_rapier.ts CHANGED Viewed

@@ -303,6 +303,11 @@
         filterGroups?: number,
         /** Return false to ignore this collider */
         filterPredicate?: (c: ICollider) => boolean,
+        /** When enabled the hit object's layer will be tested. If layer 2 is enabled the object will be ignored (Layer 2 == IgnoreRaycast)
+         * If not set the raycast will ignore objects in the IgnoreRaycast layer (default: true)
+         * @default undefined
+        */
+        useIgnoreRaycastLayer?: boolean
     })
         : null | { point: Vector3, collider: ICollider } {
@@ -320,9 +325,11 @@
         const hit = this.world?.castRay(ray, maxDistance, solid, options?.queryFilterFlags, options?.filterGroups, undefined, undefined, (c) => {
             const component = c[$componentKey];
             if (options?.filterPredicate) return options.filterPredicate(component);
-            // ignore objects in the IgnoreRaycast=2 layer
-            return !component?.gameObject.layers.isEnabled(2);
+            if (options?.useIgnoreRaycastLayer !== false) {
+                // ignore objects in the IgnoreRaycast=2 layer
+                return !component?.gameObject.layers.isEnabled(2);
+            }
+            return true;
         });
         if (hit) {
             const point = ray.pointAt(hit.toi);
@@ -342,6 +349,11 @@
         filterGroups?: number,
         /** Return false to ignore this collider */
         filterPredicate?: (c: ICollider) => boolean,
+        /** When enabled the hit object's layer will be tested. If layer 2 is enabled the object will be ignored (Layer 2 == IgnoreRaycast)
+         * If not set the raycast will ignore objects in the IgnoreRaycast layer (default: true)
+         * @default undefined
+        */
+        useIgnoreRaycastLayer?: boolean
     })
         : null | { point: Vector3, normal: Vector3, collider: ICollider } {
@@ -359,8 +371,11 @@
         const hit = this.world?.castRayAndGetNormal(ray, maxDistance, solid, options?.queryFilterFlags, options?.filterGroups, undefined, undefined, (c) => {
             const component = c[$componentKey];
             if (options?.filterPredicate) return options.filterPredicate(component);
-            // ignore objects in the IgnoreRaycast=2 layer
-            return !component?.gameObject.layers.isEnabled(2);
+            if (options?.useIgnoreRaycastLayer !== false) {
+                // ignore objects in the IgnoreRaycast=2 layer
+                return !component?.gameObject.layers.isEnabled(2);
+            }
+            return true;
         });
         if (hit) {
             const point = ray.pointAt(hit.toi);
@@ -1165,8 +1180,14 @@
             }
         }
         else if (body instanceof Collider) {
-            const wp = getWorldPosition(obj, this._tempPosition);
-            const wq = getWorldQuaternion(obj, this._tempQuaternion);
+            if (obj.matrixWorldNeedsUpdate) {
+                obj.updateWorldMatrix(true, false);
+            }
+            obj.matrixWorld.decompose(this._tempPosition, this._tempQuaternion, this._tempScale);
+            const wp = this._tempPosition;
+            const wq = this._tempQuaternion;
+            // const wp = getWorldPosition(obj, this._tempPosition);
+            // const wq = getWorldQuaternion(obj, this._tempQuaternion);
             const collider = body[$componentKey] as ICollider;
             this.tryApplyCenter(collider, wp);

src/engine/engine_physics.ts CHANGED Viewed

@@ -1,11 +1,14 @@
 import { getRaycastMesh } from '@needle-tools/gltf-progressive';
-import { ArrayCamera, AxesHelper, Box3, BufferGeometry, Camera, type Intersection, Layers, Line, Matrix3, Matrix4, Mesh, Object3D, PerspectiveCamera, Plane, Ray, Raycaster, Sphere, SphereGeometry, Vector2, Vector3 } from 'three'
+import { ArrayCamera, AxesHelper, Box3, BufferGeometry, Camera, type Intersection, Layers, Line, Matrix3, Matrix4, Mesh, Object3D, PerspectiveCamera, Plane, Ray, Raycaster, SkinnedMesh,Sphere, SphereGeometry, Vector2, Vector3 } from 'three'
 import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
+import type { MeshBVH, MeshBVHOptions, StaticGeometryGenerator } from 'three-mesh-bvh';
+import type { GenerateMeshBVHWorker } from 'three-mesh-bvh/src/workers/GenerateMeshBVHWorker.js';
+import { isDevEnvironment } from './debug/index.js';
 import { Gizmos } from './engine_gizmos.js';
 import { Context } from './engine_setup.js';
 import { getTempVector, getWorldPosition } from "./engine_three_utils.js"
-import type { Vec2, Vec3, } from './engine_types.js';
+import type { ConstructorConcrete, Vec2, Vec3, } from './engine_types.js';
 import type { IPhysicsEngine } from './engine_types.js';
 import { getParam } from "./engine_utils.js"
@@ -62,6 +65,12 @@
      * Return `false` to ignore the object completely or `"continue in children"` to skip the object but continue to traverse its children (if you do raycast with `recursive` enabled)
      * */
     testObject?: RaycastTestObjectCallback;
+    /**
+     * Use MeshBVH for raycasting. This is faster than the default threejs raycaster but uses more memory.
+     * @default undefined
+     */
+    useAcceleratedRaycast?: boolean;
 }
 export class RaycastOptions implements IRaycastOptions {
@@ -80,6 +89,7 @@
     layerMask?: Layers | number;
     ignore?: Object3D[];
     testObject?: RaycastTestObjectCallback;
+    useAcceleratedRaycast?: boolean | undefined;
     screenPointFromOffset(ox: number, oy: number) {
         if (this.screenPoint === undefined) this.screenPoint = new Vector2();
@@ -163,53 +173,26 @@
     private sphereResults: Array<Intersection> = new Array<Intersection>();
     private sphereMask: Layers = new Layers();
+    private readonly sphere: Sphere = new Sphere();
     /** Test overlapping of a sphere with the threejs geometry. This does not use colliders. This does not return an exact intersection point (intersections returned contain the object and the world position of the object that is being hit)
      * For a more accurate test use the physics engine's collider overlap test (see sphereOverlapPhysics)
      * @param spherePos the center of the sphere in world space
      * @param radius the radius of the sphere
      * @param traverseChildsAfterHit if false it will stop after the first hit. If true it will continue to traverse and add all hits to the result array
+     * @param bvh use MeshBVH for raycasting. This is faster than the default threejs raycaster but uses more memory.
+     * @param shouldRaycast optional callback to filter objects. Return `false` to ignore the object completely or `"continue in children"` to skip the object but continue to traverse its children (if you do raycast with `recursive` enabled)
      */
-    public sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit: boolean = true): Array<Intersection> {
+    public sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit: boolean = true, bvh: boolean = false, shouldRaycast: RaycastTestObjectCallback | null = null): Array<Intersection> {
         this.sphereResults.length = 0;
         if (!this.context.scene) return this.sphereResults;
-        const sphere = new Sphere(spherePos, radius);
         const mask = this.sphereMask;
         mask.enableAll();
         mask.disable(2);
         for (const ch of this.context.scene.children) {
-            this.onSphereOverlap(ch, sphere, mask, this.sphereResults, traverseChildsAfterHit);
+            this.intersectSphere(ch, spherePos, radius, mask, this.sphereResults, traverseChildsAfterHit, bvh, shouldRaycast);
         }
         return this.sphereResults.sort((a, b) => a.distance - b.distance);
     }
-    private tempBoundingBox: Box3 = new Box3();
-    private onSphereOverlap(obj: Object3D, sp: Sphere, mask: Layers, results: Array<Intersection>, traverseChildsAfterHit: boolean): void {
-        if (obj.type === "Mesh" && obj.layers.test(mask) && !Gizmos.isGizmo(obj)) {
-            const mesh = obj as Mesh;
-            const geo = mesh.geometry;
-            if (geo) {
-                if (!geo.boundingBox)
-                    geo.computeBoundingBox();
-                if (geo.boundingBox) {
-                    if (mesh.matrixWorldNeedsUpdate) mesh.updateMatrixWorld();
-                    const test = this.tempBoundingBox.copy(geo.boundingBox).applyMatrix4(mesh.matrixWorld);
-                    if (sp.intersectsBox(test)) {
-                        const wp = getWorldPosition(obj);
-                        const dist = wp.distanceTo(sp.center);
-                        const int = new SphereIntersection(obj, dist, wp);
-                        results.push(int);
-                        if (!traverseChildsAfterHit) return;
-                    }
-                }
-            }
-        }
-        if (obj.children) {
-            for (const ch of obj.children) {
-                const len = results.length;
-                this.onSphereOverlap(ch, sp, mask, results, traverseChildsAfterHit);
-                if (len != results.length && !traverseChildsAfterHit) return;
-            }
-        }
-    }
     public raycastFromRay(ray: Ray, options: IRaycastOptions | null = null): Array<Intersection> {
         const opts = options ?? this.defaultRaycastOptions;
@@ -301,7 +284,7 @@
         if (ignorelist !== undefined && ignorelist.length > 0) {
             results = results.filter(r => !ignorelist.includes(r.object));
         }
         Physics._raycasting--;
         if (debugPhysics) {
@@ -349,6 +332,9 @@
                     if (!usePrecise && customRaycast(mesh, raycaster, results)) {
                         // did handle raycast
                     }
+                    else if (options.useAcceleratedRaycast !== false) {
+                        NEMeshBVH.runMeshBVHRaycast(raycaster, mesh, results, this.context);
+                    }
                     else {
                         raycaster.intersectObject(obj, false, results);
                     }
@@ -365,6 +351,75 @@
         }
         return results;
     }
+    private tempBoundingBox: Box3 = new Box3();
+    private intersectSphere(obj: Object3D, spherePos: Vector3, radius: number, mask: Layers, results: Array<Intersection>, traverseChildsAfterHit: boolean, useBvh: boolean, shouldRaycast: RaycastTestObjectCallback | null): void {
+        let canIntersect = obj && (obj as Mesh).isMesh && obj.layers.test(mask) && !Gizmos.isGizmo(obj);
+        canIntersect &&= obj.visible;
+        canIntersect &&= !(obj instanceof Line);
+        canIntersect &&= !(obj instanceof GroundedSkybox);
+        if (shouldRaycast) {
+            const testResult = shouldRaycast(obj);
+            if (testResult === false) {
+                return;
+            }
+            const checkObject = testResult !== "continue in children";
+            if (checkObject) {
+                return;
+            }
+        }
+        if (canIntersect) {
+            const mesh = obj as Mesh;
+            const geo = mesh.geometry;
+            if (geo) {
+                if (useBvh) {
+                    const sphere = this.sphere;
+                    sphere.center.copy(spherePos);
+                    sphere.radius = radius;
+                    const previousResults = results.length;
+                    NEMeshBVH.runMeshBVHRaycast(this.sphere, mesh, results, this.context);
+                    if (previousResults != results.length && !traverseChildsAfterHit) {
+                        return;
+                    }
+                }
+                // Classic sphere intersection test
+                else {
+                    if (!geo.boundingBox)
+                        geo.computeBoundingBox();
+                    if (geo.boundingBox) {
+                        if (mesh.matrixWorldNeedsUpdate) mesh.updateWorldMatrix(false, false);
+                        const test = this.tempBoundingBox.copy(geo.boundingBox).applyMatrix4(mesh.matrixWorld);
+                        const sphere = this.sphere;
+                        sphere.center.copy(spherePos);
+                        sphere.radius = radius;
+                        if (sphere.intersectsBox(test)) {
+                            const wp = getWorldPosition(obj);
+                            const dist = wp.distanceTo(sphere.center);
+                            const int = new SphereIntersection(obj, dist, wp);
+                            results.push(int);
+                            if (!traverseChildsAfterHit) return;
+                        }
+                    }
+                }
+            }
+        }
+        if (obj.children) {
+            for (const ch of obj.children) {
+                const len = results.length;
+                this.intersectSphere(ch, spherePos, radius, mask, results, traverseChildsAfterHit, useBvh, shouldRaycast);
+                if (len != results.length && !traverseChildsAfterHit) return;
+            }
+        }
+    }
 }
 const tempSphere = new Sphere();
@@ -426,3 +481,230 @@
     mesh["_computeIntersections"] = originalComputeIntersectionsFn;
     return true;
 }
+declare module 'three' {
+    export interface SkinnedMesh {
+        staticGenerator?: StaticGeometryGenerator;
+        staticGeometry?: BufferGeometry;
+        staticGeometryLastUpdate?: number;
+        bvhNeedsUpdate?: boolean;
+    }
+    export interface Mesh {
+        acceleratedRaycast?: any;
+    }
+}
+module NEMeshBVH {
+    export function runMeshBVHRaycast(method: Raycaster | Sphere, mesh: Mesh, results: Intersection[], context: Pick<Context, "xr">): boolean {
+        if (!mesh.geometry) {
+            return false;
+        }
+        // The code below handles generating the mesh bvh structure that is used for raycasting
+        // We first try to setup workers so it can run off the main thread
+        const geom = mesh.geometry;
+        if ((mesh as SkinnedMesh)?.isSkinnedMesh) {
+            const skinnedMesh = mesh as SkinnedMesh;
+            const skinnedMeshBVHNeedsUpdate = skinnedMesh.bvhNeedsUpdate;
+            if (!skinnedMesh.staticGenerator) {
+                loadMeshBVHLibrary();
+                if (_StaticGeometryGenerator) {
+                    skinnedMesh.staticGenerator = new _StaticGeometryGenerator(mesh);
+                    skinnedMesh.staticGenerator.applyWorldTransforms = false;
+                    skinnedMesh.staticGeometry = skinnedMesh.staticGenerator.generate();
+                    geom.boundsTree = _computeBoundsTree?.call(skinnedMesh.staticGeometry);
+                    skinnedMesh.staticGeometryLastUpdate = performance.now() + Math.random() * 200;
+                    if (skinnedMesh["autoUpdateMeshBVH"] === undefined)
+                        skinnedMesh["autoUpdateMeshBVH"] = false;
+                }
+            }
+            else if (geom.boundsTree && (skinnedMesh["autoUpdateMeshBVH"] === true || skinnedMeshBVHNeedsUpdate === true)) {
+                // automatically refit the tree every 300ms
+                const now = performance.now();
+                const timeSinceLastUpdate = now - skinnedMesh.staticGeometryLastUpdate!;
+                if (skinnedMeshBVHNeedsUpdate || timeSinceLastUpdate > 100) {
+                    skinnedMesh.bvhNeedsUpdate = false;
+                    skinnedMesh.staticGeometryLastUpdate = now;
+                    skinnedMesh.staticGenerator?.generate(skinnedMesh.staticGeometry);
+                    geom.boundsTree.refit();
+                }
+            }
+        }
+        else if (!geom.boundsTree) {
+            // Try to generate the bvh on a worker
+            if (!didSetupWorker) internalSetupWorker();
+            let canUseWorker = true;
+            if (context.xr) { // < in XR for some reason sometimes geometry (controllers) are broken - maybe this is not exclusive to controller geometry
+                canUseWorker = false;
+            }
+            else if (geom[canUseWorkerSymbol] === false) {
+                canUseWorker = false;
+            }
+            else if (geom.getAttribute('position')["isInterleavedBufferAttribute"]
+                || geom.index && geom.index["isInterleavedBufferAttribute"]) {
+                canUseWorker = false;
+            }
+            // if we have a worker use that
+            if (canUseWorker && _GenerateMeshBVHWorker) {
+                if (geom[workerTaskSymbol] === undefined) {
+                    // get available worker
+                    let workerInstance: GenerateMeshBVHWorker | null = null;
+                    // if there are workers available, use one
+                    if (availableWorkers.length > 0) {
+                        const available = availableWorkers.shift();
+                        if (available && !available.running) {
+                            workerInstance = available;
+                        }
+                    }
+                    // if there are no workers available, create a new one
+                    else if (workerInstances.length < 1) {
+                        workerInstance = new _GenerateMeshBVHWorker();
+                        workerInstances.push(workerInstance);
+                    }
+                    if (workerInstance != null && !workerInstance.running) {
+                        geom[workerTaskSymbol] = "queued";
+                        performance.mark("bvh.create.start");
+                        workerInstance.generate(geom)
+                            .then(bvh => {
+                                geom[workerTaskSymbol] = "done";
+                                geom.boundsTree = bvh;
+                            })
+                            .catch(err => {
+                                geom[workerTaskSymbol] = "failed - " + err?.message;
+                                geom[canUseWorkerSymbol] = false;
+                            })
+                            .finally(() => {
+                                availableWorkers.push(workerInstance);
+                                performance.mark("bvh.create.end");
+                                performance.measure("bvh.create (worker)", "bvh.create.start", "bvh.create.end");
+                            });
+                    }
+                    else {
+                        // we don't want to generate the BVH on the main thread unless workers are not supported
+                        // If all workers are currently running we need to run a "slow" raycast
+                        if (debugPhysics) console.warn("No worker available");
+                    }
+                }
+            }
+            // Fallback to sync bvh generation if workers are not available
+            else if (!isRequestingWorker || !canUseWorker) {
+                loadMeshBVHLibrary();
+                if (_MeshBVH) {
+                    performance.mark("bvh.create.start");
+                    geom.boundsTree = new _MeshBVH(geom as BufferGeometry);
+                    performance.mark("bvh.create.end");
+                    performance.measure("bvh.create", "bvh.create.start", "bvh.create.end");
+                }
+            }
+        }
+        if (method instanceof Raycaster) {
+            const raycaster = method;
+            // Skinned meshes work when we disable applyWorldTransform in the generator (see applyWorldTransforms = false above)
+            // We do need to set the accelerated raycast method (bind it once)
+            // We could also override it on the prototype - not sure if it's more performant but then it would always run
+            const raycastMesh = mesh.raycast;
+            if (_acceleratedRaycast && geom.boundsTree) {
+                // bind the raycast to the mesh
+                if (!mesh.acceleratedRaycast) {
+                    mesh.acceleratedRaycast = _acceleratedRaycast.bind(mesh) as any;
+                }
+                mesh.raycast = mesh.acceleratedRaycast;
+            }
+            const prevFirstHitOnly = raycaster.firstHitOnly;
+            raycaster.firstHitOnly = false;
+            raycaster.intersectObject(mesh, false, results);
+            raycaster.firstHitOnly = prevFirstHitOnly;
+            mesh.raycast = raycastMesh;
+            return true;
+        }
+        else if (method instanceof Sphere) {
+            const bvh = geom.boundsTree;
+            if (bvh) {
+                const sphere = method;
+                // Gizmos.DrawWireSphere(sphere.center, sphere.radius, 0xdddd00, 1, false);
+                invMat.copy(mesh.matrixWorld).invert();
+                sphere.applyMatrix4(invMat);
+                const intersects = bvh.intersectsSphere(sphere);
+                if (intersects) {
+                    // console.log(intersects, mesh.name);
+                    const worldpos = getWorldPosition(mesh);
+                    const distance = worldpos.distanceTo(sphere.center);
+                    const intersection = new SphereIntersection(mesh, distance, worldpos);
+                    results.push(intersection);
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    let didLoadMeshBVHLibrary: boolean = false;
+    let _acceleratedRaycast: Function | null = null;
+    let _MeshBVH: ConstructorConcrete<MeshBVH> | null = null;
+    let _StaticGeometryGenerator: ConstructorConcrete<StaticGeometryGenerator> | null = null;
+    let _computeBoundsTree: ((_opt?: MeshBVHOptions) => MeshBVH) | null = null;
+    function loadMeshBVHLibrary() {
+        if (didLoadMeshBVHLibrary) return;
+        didLoadMeshBVHLibrary = true;
+        import("three-mesh-bvh").then(res => {
+            _acceleratedRaycast = res.acceleratedRaycast;
+            _MeshBVH = res.MeshBVH;
+            _StaticGeometryGenerator = res.StaticGeometryGenerator;
+            _computeBoundsTree = res.computeBoundsTree;
+        }).catch(_err => {
+            if (debugPhysics || isDevEnvironment()) {
+                console.warn("Failed to load mesh bvh library");
+            }
+        })
+    }
+    const invMat = new Matrix4();
+    /** True after the worker has been requested for the first time */
+    let didSetupWorker: boolean = false;
+    /** True while the worker is being requested */
+    let isRequestingWorker: boolean = false;
+    let _GenerateMeshBVHWorker: ConstructorConcrete<GenerateMeshBVHWorker> | null = null;
+    const workerTaskSymbol = Symbol("Needle:MeshBVH-Worker");
+    const canUseWorkerSymbol = Symbol("Needle:MeshBVH-CanUseWorker");
+    const workerInstances: GenerateMeshBVHWorker[] = [];
+    const availableWorkers: GenerateMeshBVHWorker[] = [];
+    function internalSetupWorker() {
+        didSetupWorker = true;
+        isRequestingWorker = true;
+        // Using local worker. see https://github.com/gkjohnson/three-mesh-bvh/issues/636#issuecomment-2209571751
+        import("./physics/workers/mesh-bvh/GenerateMeshBVHWorker.js")
+            .then(res => {
+                _GenerateMeshBVHWorker = res.GenerateMeshBVHWorker;
+            })
+            .catch(_err => {
+                if (debugPhysics || isDevEnvironment()) {
+                    console.warn("Failed to setup mesh bvh worker");
+                }
+            })
+            .finally(() => {
+                isRequestingWorker = false;
+            });
+    }
+}

src/engine-components/ui/EventSystem.ts CHANGED Viewed

@@ -806,19 +806,21 @@
                 if (currentFrame === lu.frame) return;
                 lu.frame = currentFrame;
                 let shouldUpdate = this.needsUpdate || currentFrame < 1;
-                if (lu.nextUpdate === context.time.frameCount) shouldUpdate = true;
+                if (lu.nextUpdate <= currentFrame) shouldUpdate = true;
                 // if (this.needsUpdate) lu.nextUpdate = currentFrame + 3;
                 if (shouldUpdate) {
-                    if (debug)
-                        console.log("Update threemeshui");
+                    // console.warn(currentFrame, lu.nextUpdate, this.needsUpdate)
+                    if (debug) console.log("Update threemeshui");
                     this.needsUpdate = false;
+                    lu.nextUpdate = currentFrame + 60;
                     threeMeshUI.update();
                 }
                 return;
             }
         }
-        this.lastUpdateFrame = [{ context, frame: currentFrame, nextUpdate: currentFrame }];
+        this.lastUpdateFrame = [{ context, frame: currentFrame, nextUpdate: currentFrame + 60 }];
         threeMeshUI.update();
+        this.needsUpdate = false;
     }
     static updateState(intersect: Object3D, _selectState: boolean): Object3D | null {

src/engine-components/ui/Raycaster.ts CHANGED Viewed

@@ -44,6 +44,8 @@
         opts ??= new RaycastOptions();
         opts.targets = this.targets;
         opts.results = this.raycastHits;
+        opts.useAcceleratedRaycast = true;
         const orig = opts.testObject;
         if (this.ignoreSkinnedMeshes) {
             opts.testObject = obj => {
@@ -89,6 +91,6 @@
         // draw gizmo around ray origin
         // Gizmos.DrawSphere(rayOrigin, radius, 0x00ff0022);
-        return this.context.physics.sphereOverlap(rayOrigin, radius);
+        return this.context.physics.sphereOverlap(rayOrigin, radius, false, true);
     }
 }

src/engine-components/RigidBody.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { Matrix4, Object3D, Vector3 } from "three";
+import { Matrix4, Object3D, Quaternion, Vector3 } from "three";
 import { CollisionDetectionMode, RigidbodyConstraints } from "../engine/engine_physics.types.js";
 import { serializable } from "../engine/engine_serialization_decorator.js";
@@ -485,9 +485,13 @@
     private captureVelocity() {
         const wp = getWorldPosition(this.gameObject);
-        Rigidbody.tempPosition.copy(wp);
+        this.gameObject.matrixWorld.decompose(Rigidbody.tempPosition, tempQuaternion, tempScale);
         const vel = wp.sub(this._lastPosition);
         this._lastPosition.copy(Rigidbody.tempPosition);
         this._smoothedVelocity.lerp(vel, this.context.time.deltaTime / .1);
     }
-}
+}
+const tempPosition = new Vector3();
+const tempQuaternion = new Quaternion();
+const tempScale = new Vector3();

src/engine-components/ui/Text.ts CHANGED Viewed

@@ -121,7 +121,7 @@
         const overflow = (this.uiObject as any)?._overflow;
         if (overflow) {
             overflow._needsUpdate = true;
-            this.markDirty();
+            // the screenspace canvas does force an update, no need to mark dirty here
         }
     }

src/engine/physics/workers/mesh-bvh/GenerateMeshBVHWorker.js ADDED Viewed

@@ -0,0 +1,122 @@
+import { Box3, BufferAttribute } from 'three';
+import { MeshBVH } from 'three-mesh-bvh';
+// Modified according to https://github.com/gkjohnson/three-mesh-bvh/issues/636#issuecomment-2209571751
+import { WorkerBase } from "three-mesh-bvh/src/workers/utils/WorkerBase.js";
+import generateMeshBVHWorker from "three-mesh-bvh/src/workers/generateMeshBVH.worker.js?worker";
+export class GenerateMeshBVHWorker extends WorkerBase {
+	constructor() {
+		super(new generateMeshBVHWorker());
+		this.name = 'GenerateMeshBVHWorker';
+	}
+	runTask( worker, geometry, options = {} ) {
+		return new Promise( ( resolve, reject ) => {
+			if (
+				geometry.getAttribute( 'position' ).isInterleavedBufferAttribute ||
+				geometry.index && geometry.index.isInterleavedBufferAttribute
+			) {
+				throw new Error( 'GenerateMeshBVHWorker: InterleavedBufferAttribute are not supported for the geometry attributes.' );
+			}
+			worker.onerror = e => {
+				reject( new Error( `GenerateMeshBVHWorker: ${ e.message }` ) );
+			};
+			worker.onmessage = e => {
+				const { data } = e;
+				if ( data.error ) {
+					reject( new Error( data.error ) );
+					worker.onmessage = null;
+				} else if ( data.serialized ) {
+					const { serialized, position } = data;
+					const bvh = MeshBVH.deserialize( serialized, geometry, { setIndex: false } );
+					const boundsOptions = Object.assign( {
+						setBoundingBox: true,
+					}, options );
+					// we need to replace the arrays because they're neutered entirely by the
+					// webworker transfer.
+					geometry.attributes.position.array = position;
+					if ( serialized.index ) {
+						if ( geometry.index ) {
+							geometry.index.array = serialized.index;
+						} else {
+							const newIndex = new BufferAttribute( serialized.index, 1, false );
+							geometry.setIndex( newIndex );
+						}
+					}
+					if ( boundsOptions.setBoundingBox ) {
+						geometry.boundingBox = bvh.getBoundingBox( new Box3() );
+					}
+					if ( options.onProgress ) {
+						options.onProgress( data.progress );
+					}
+					resolve( bvh );
+					worker.onmessage = null;
+				} else if ( options.onProgress ) {
+					options.onProgress( data.progress );
+				}
+			};
+			const index = geometry.index ? geometry.index.array : null;
+			const position = geometry.attributes.position.array;
+			const transferable = [ position ];
+			if ( index ) {
+				transferable.push( index );
+			}
+			worker.postMessage( {
+				index,
+				position,
+				options: {
+					...options,
+					onProgress: null,
+					includedProgressCallback: Boolean( options.onProgress ),
+					groups: [ ... geometry.groups ],
+				},
+			}, transferable.map( arr => arr.buffer ).filter( v => ( typeof SharedArrayBuffer === 'undefined' ) || ! ( v instanceof SharedArrayBuffer ) ) );
+		} );
+	}
+}