import { getRaycastMesh } from '@needle-tools/gltf-progressive';
import { ArrayCamera, Box3, Layers, Line, Matrix3, Matrix4, Plane, Raycaster, Sphere, Vector2 } from 'three';
import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
import { isDevEnvironment } from './debug/index.js';
import { Gizmos } from './engine_gizmos.js';
import { getTempVector, getWorldPosition } from "./engine_three_utils.js";
import { getParam } from "./engine_utils.js";
const debugPhysics = getParam("debugphysics");
const debugWorker = getParam("debugworker");
const layerMaskHelper = new Layers();
export class RaycastOptions {
    static AllLayers = 0xFFFFFFFF;
    ray;
    cam;
    screenPoint;
    raycaster;
    results;
    targets;
    recursive = true;
    minDistance;
    maxDistance;
    lineThreshold;
    layerMask;
    ignore;
    testObject;
    useAcceleratedRaycast;
    allowSlowRaycastFallback = true;
    screenPointFromOffset(ox, oy) {
        if (this.screenPoint === undefined)
            this.screenPoint = new Vector2();
        this.screenPoint.x = ox / window.innerWidth * 2 - 1;
        this.screenPoint.y = -(oy / window.innerHeight) * 2 + 1;
    }
    /** sets one layer for raycasting (e.g. layer 4, only objects on layer 4 will then be hit) */
    setLayer(layer) {
        layerMaskHelper.set(layer);
        this.layerMask = layerMaskHelper;
    }
    /** sets the layer.mask value directly, use setLayer if you want to set e.g. an individual layer only active. See https://threejs.org/docs/#api/en/core/Layers for more information about layers */
    setMask(mask) {
        if (!this.layerMask)
            this.layerMask = new Layers();
        const lm = this.layerMask;
        if (lm)
            lm.mask = mask;
        else
            this.layerMask = mask;
    }
}
export class SphereIntersection {
    distance;
    point;
    object;
    constructor(object, distance, point) {
        this.object = object;
        this.distance = distance;
        this.point = point;
    }
}
/**
 * Provides physics utilities including raycasting and overlap detection.
 * Access via `this.context.physics` from any component.
 *
 * For physics engine features (rigidbodies, colliders, forces, etc.), use `this.context.physics.engine`.
 * The physics engine is {@link RapierPhysics}, which uses the Rapier physics library for realistic simulation.
 *
 * **Performance - Automatic MeshBVH:**
 * Needle Engine automatically uses [three-mesh-bvh](https://github.com/gkjohnson/three-mesh-bvh) to accelerate raycasting.
 * MeshBVH structures are generated automatically on web workers in the background, making raycasts significantly faster
 * without blocking the main thread. This happens transparently - you don't need to do anything to enable it.
 * While the BVH is being generated, raycasts fall back to standard three.js raycasting (configurable via `allowSlowRaycastFallback`).
 *
 * @example Raycasting from mouse position
 * ```ts
 * const hits = this.context.physics.raycast();
 * if (hits.length > 0) {
 *   console.log("Hit:", hits[0].object.name);
 * }
 * ```
 * @example Raycasting with inline options
 * ```ts
 * const hits = this.context.physics.raycast({
 *   maxDistance: 100, // Only hit objects within 100 units
 *   layerMask: 1, // Only layer 0
 *   ignore: [this.gameObject] // Ignore self
 * });
 * ```
 * @example Physics engine raycast (against colliders only)
 * ```ts
 * const hit = this.context.physics.engine?.raycast(origin, direction);
 * ```
 * @see {@link Rigidbody} for physics simulation component
 * @see {@link Collider} for collision detection component
 * @see {@link RapierPhysics} for physics engine implementation details
 */
export class Physics {
    static _raycasting = 0;
    /**
     * Returns true if raycasting is currently in progress
     */
    static get raycasting() {
        return this._raycasting > 0;
    }
    /**@deprecated use `this.context.physics.engine.raycast` {@link IPhysicsEngine.raycast} */
    raycastPhysicsFast(origin, direction = undefined, maxDistance = Infinity, solid = true) {
        return this.context.physics.engine?.raycast(origin, direction, { maxDistance, solid }) ?? null;
    }
    /**@deprecated use `this.context.physics.engine.raycastAndGetNormal` {@link IPhysicsEngine.raycastAndGetNormal} */
    raycastPhysicsFastAndGetNormal(origin, direction = undefined, maxDistance = Infinity, solid = true) {
        return this.context.physics.engine?.raycastAndGetNormal(origin, direction, { maxDistance, solid }) ?? null;
    }
    /**@deprecated use this.context.physics.engine.sphereOverlap */
    sphereOverlapPhysics(point, radius) {
        return this.context.physics.engine?.sphereOverlap(point, radius) ?? null;
    }
    context;
    engine;
    constructor(context) {
        this.context = context;
    }
    // raycasting
    raycaster = new Raycaster();
    defaultRaycastOptions = new RaycastOptions();
    targetBuffer = new Array(1);
    defaultThresholds = {
        Mesh: {},
        Line: { threshold: -1 },
        LOD: {},
        Points: { threshold: 0 },
        Sprite: {}
    };
    sphereResults = new Array();
    sphereMask = new Layers();
    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)
     */
    sphereOverlap(spherePos, radius, traverseChildsAfterHit = true, bvh = false, shouldRaycast = null) {
        this.sphereResults.length = 0;
        if (!this.context.scene)
            return this.sphereResults;
        const mask = this.sphereMask;
        mask.enableAll();
        mask.disable(2);
        for (const ch of this.context.scene.children) {
            this.intersectSphere(ch, spherePos, radius, mask, this.sphereResults, traverseChildsAfterHit, bvh, shouldRaycast);
        }
        return this.sphereResults.sort((a, b) => a.distance - b.distance);
    }
    raycastFromRay(ray, options = null) {
        const opts = options ?? this.defaultRaycastOptions;
        opts.ray = ray;
        const res = this.raycast(opts);
        // reset the default options ray
        if (opts === this.defaultRaycastOptions)
            opts.ray = undefined;
        return res;
    }
    /** raycast against rendered three objects. This might be very slow depending on your scene complexity.
     * We recommend setting objects to IgnoreRaycast layer (2) when you don't need them to be raycasted.
     * Raycasting SkinnedMeshes is specially expensive.
     * Use raycastPhysics for raycasting against physic colliders only. Depending on your scenario this might be faster.
     * @param options raycast options. If null, default options will be used.
     */
    raycast(options = null) {
        if (debugPhysics) {
            performance.mark('raycast.start');
        }
        if (!options)
            options = this.defaultRaycastOptions;
        const mp = options.screenPoint ?? this.context.input.mousePositionRC;
        const rc = options.raycaster ?? this.raycaster;
        rc.near = options.minDistance ?? 0;
        rc.far = options.maxDistance ?? Infinity;
        rc.params = this.defaultThresholds;
        if (options.lineThreshold === undefined)
            options.lineThreshold = -1;
        rc.params.Line = { threshold: options.lineThreshold };
        if (options.ray) {
            rc.ray.copy(options.ray);
        }
        else {
            const cam = options.cam ?? this.context.mainCamera;
            if (!cam) {
                if (debugPhysics)
                    console.error("Can not perform raycast - no main camera found");
                if (this.defaultRaycastOptions.results)
                    this.defaultRaycastOptions.results.length = 0;
                return this.defaultRaycastOptions.results ?? [];
            }
            const xrCam = this.context.xrCamera;
            if (this.context.isInXR && xrCam instanceof ArrayCamera && xrCam.cameras.length > 0) {
                rc.setFromCamera(mp, xrCam.cameras[0]);
            }
            else {
                rc.setFromCamera(mp, cam);
            }
        }
        let targets = options.targets;
        if (!targets) {
            targets = this.targetBuffer;
            targets.length = 1;
            targets[0] = this.context.scene;
        }
        let results = options.results;
        if (this.defaultRaycastOptions.results)
            this.defaultRaycastOptions.results.length = 0;
        if (!results) {
            if (!this.defaultRaycastOptions.results)
                this.defaultRaycastOptions.results = new Array();
            results = this.defaultRaycastOptions.results;
        }
        // layermask
        // https://github.com/mrdoob/js/blob/master/src/core/Layers.js
        if (options.layerMask !== undefined) {
            if (options.layerMask instanceof Layers)
                rc.layers.mask = options.layerMask.mask;
            else
                rc.layers.mask = options.layerMask;
        }
        else {
            rc.layers.enableAll();
            rc.layers.disable(2);
        }
        if (debugPhysics) {
            // Gizmos.DrawRay(rc.ray.origin, rc.ray.direction, 0xff0000, .2);
            console.time("raycast");
        }
        // shoot
        results.length = 0;
        Physics._raycasting++;
        this.intersect(this.raycaster, targets, results, options);
        results.sort((a, b) => a.distance - b.distance);
        // TODO: instead of doing this we should temporerly set these objects to layer 2 during raycasting
        const ignorelist = options.ignore;
        if (ignorelist !== undefined && ignorelist.length > 0) {
            results = results.filter(r => !ignorelist.includes(r.object));
        }
        Physics._raycasting--;
        if (debugPhysics) {
            console.timeEnd("raycast");
            console.warn("#" + this.context.time.frame + ", hits:", (results?.length ? [...results] : "nothing"));
            performance.mark('raycast.end');
            performance.measure('raycast', 'raycast.start', 'raycast.end');
        }
        return results;
    }
    intersect(raycaster, objects, results, options) {
        for (const obj of objects) {
            // handle case where null or undefined object is in the scene
            if (!obj)
                continue;
            // dont raycast invisible objects
            if (obj.visible === false)
                continue;
            if (Gizmos.isGizmo(obj))
                continue;
            // dont raycast object if it's a line and the line threshold is < 0
            if (options.lineThreshold !== undefined && options.lineThreshold < 0) {
                if (obj instanceof Line) {
                    continue;
                }
            }
            let shouldIntersectObject = true;
            const mesh = obj;
            const geo = mesh.geometry;
            if (obj.raycastAllowed === false) {
                shouldIntersectObject = false;
            }
            // We need to run this first because of "EventSystem.testObject" implementation
            if (shouldIntersectObject && options.testObject) {
                const testResult = options.testObject?.(obj);
                if (testResult === false) {
                    continue;
                }
                else if (testResult === "continue in children") {
                    shouldIntersectObject = false;
                }
            }
            else if (shouldIntersectObject) {
                if (!geo) {
                    shouldIntersectObject = false;
                }
                // check if the geometry is valid
                else if (!canRaycastGeometry(geo)) {
                    shouldIntersectObject = false;
                }
            }
            if (shouldIntersectObject) {
                const lastResultsCount = results.length;
                const preference = obj.raycastPreference || "lod";
                let usePrecise = preference !== "bounds";
                if (options.precise === false)
                    usePrecise = false;
                if (geo)
                    usePrecise ||= geo.getAttribute("position")?.array?.length < 64;
                if (mesh instanceof GroundedSkybox) {
                    usePrecise = false;
                }
                if (preference === "lod") {
                    const raycastMesh = getRaycastMesh(obj);
                    if (raycastMesh)
                        mesh.geometry = raycastMesh;
                }
                if (!usePrecise && boundsRaycast(mesh, raycaster, results)) {
                    // did handle raycast
                }
                else if (options.useAcceleratedRaycast !== false) {
                    NEMeshBVH.runMeshBVHRaycast(raycaster, mesh, results, this.context, options);
                }
                else {
                    raycaster.intersectObject(mesh, false, results);
                }
                // Restore
                mesh.geometry = geo;
                // Debug
                if (debugPhysics && results.length != lastResultsCount) {
                    const latestResult = results[results.length - 1];
                    Gizmos.DrawWireSphere(latestResult.point, .1, 0x770000, 1, false);
                    Gizmos.DrawWireMesh({ mesh: obj, depthTest: false, duration: .2, color: 0x770000 });
                }
            }
            if (options.recursive !== false) {
                this.intersect(raycaster, obj.children, results, options);
            }
        }
        return results;
    }
    tempBoundingBox = new Box3();
    intersectSphere(obj, spherePos, radius, mask, results, traverseChildsAfterHit, useBvh, shouldRaycast) {
        let shouldIntersectObject = obj && obj.isMesh && obj.layers.test(mask) && !Gizmos.isGizmo(obj);
        shouldIntersectObject &&= obj.visible;
        shouldIntersectObject &&= !(obj instanceof Line);
        shouldIntersectObject &&= !(obj instanceof GroundedSkybox);
        const mesh = obj;
        const geo = mesh.geometry;
        if (shouldIntersectObject && shouldRaycast) {
            const testResult = shouldRaycast(obj);
            if (testResult === false) {
                return;
            }
            else if (testResult === "continue in children") {
                shouldIntersectObject = false;
            }
        }
        // check if geometry exists
        if (!geo) {
            shouldIntersectObject = false;
        }
        // check if the geometry is valid
        else if (!canRaycastGeometry(geo)) {
            shouldIntersectObject = false;
        }
        if (shouldIntersectObject) {
            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;
            }
        }
    }
}
/**
 * See https://linear.app/needle/issue/NE-5524
 * @returns true if the geometry can be raycasted
 */
function canRaycastGeometry(geo) {
    // if the geometry has an index buffer but no indices, we can't raycast
    if (geo.index && geo.index.array.length < 3)
        return false;
    // we might want to test if the geometry has a position buffer
    return true;
}
const tempSphere = new Sphere();
const tempPlane = new Plane();
const normalUpMatrix = new Matrix3();
/**
 * @returns false if custom raycasting can not run, otherwise true
 */
function boundsRaycast(mesh, raycaster, results) {
    const originalComputeIntersectionsFn = mesh["_computeIntersections"];
    if (!originalComputeIntersectionsFn) {
        return false;
    }
    // compute custom intersection, check if a custom method already exists
    let computeCustomIntersectionFn = mesh["_computeIntersections:Needle"];
    if (!computeCustomIntersectionFn) {
        // create and bind a custom method once to the mesh object
        // TODO: maybe we want to add this to the prototype instead
        computeCustomIntersectionFn = mesh["_computeIntersections:Needle"] = function (raycaster, intersects, _rayLocalSpace) {
            const self = this;
            const boundingSphere = self.geometry.boundingSphere;
            if (boundingSphere) {
                if (self instanceof GroundedSkybox) {
                    tempPlane.setFromNormalAndCoplanarPoint(getTempVector(0, 1, 0), getTempVector(0, -self.position.y, 0));
                    tempPlane.applyMatrix4(self.matrixWorld, normalUpMatrix);
                    const point = raycaster.ray.intersectPlane(tempPlane, getTempVector());
                    if (point) {
                        tempSphere.copy(boundingSphere);
                        tempSphere.applyMatrix4(self.matrixWorld);
                        const dir = getTempVector(point).sub(raycaster.ray.origin);
                        const distance = dir.length();
                        const groundProjectionFloorRadius = tempSphere.radius * .5;
                        if (distance < groundProjectionFloorRadius) // make sure we're inside the sphere
                            intersects.push({ distance: distance, point, object: self, normal: tempPlane.normal.clone() });
                    }
                    return;
                }
                tempSphere.copy(boundingSphere);
                tempSphere.applyMatrix4(self.matrixWorld);
                const point = raycaster.ray.intersectSphere(tempSphere, getTempVector());
                if (point) {
                    const dir = getTempVector(point).sub(raycaster.ray.origin);
                    const distance = dir.length();
                    // Ignore hits when we're inside the sphere
                    if (distance > tempSphere.radius) {
                        const normal = dir.clone().normalize();
                        intersects.push({ distance: distance, point, object: self, normal });
                    }
                }
            }
        };
    }
    mesh["_computeIntersections"] = computeCustomIntersectionFn;
    raycaster.intersectObject(mesh, false, results);
    mesh["_computeIntersections"] = originalComputeIntersectionsFn;
    return true;
}
var NEMeshBVH;
(function (NEMeshBVH) {
    let failedToCreateMeshBVHWorker = 0;
    function runMeshBVHRaycast(method, mesh, results, context, options) {
        if (!mesh.geometry) {
            return false;
        }
        // Completely prevent raycasting on object that has no position
        if (!mesh.geometry.hasAttribute('position')) {
            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?.isSkinnedMesh) {
            const skinnedMesh = mesh;
            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;
                    skinnedMesh.bvhNeedsUpdate = true;
                }
            }
            else if (geom.boundsTree && ((skinnedMesh.autoUpdateMeshBvhInterval !== undefined && skinnedMesh.autoUpdateMeshBvhInterval >= 0) || skinnedMeshBVHNeedsUpdate === true)) {
                // automatically refit the tree every 300ms
                const now = performance.now();
                const timeSinceLastUpdate = now - skinnedMesh.staticGeometryLastUpdate;
                const interval = skinnedMesh.autoUpdateMeshBvhInterval ?? 100;
                if (skinnedMeshBVHNeedsUpdate || timeSinceLastUpdate > interval) {
                    if (debugPhysics)
                        console.warn(`Physics: updating skinned mesh bvh for ${mesh.name} after ${timeSinceLastUpdate.toFixed(2)}ms`);
                    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;
            }
            else if (failedToCreateMeshBVHWorker > 10) {
                // if we failed to create a worker multiple times, don't try again
                canUseWorker = false;
            }
            // if we have a worker use that
            if (canUseWorker && _GenerateMeshBVHWorker) {
                if (geom[workerTaskSymbol] === undefined) {
                    // get available worker
                    let workerInstance = 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
                    if (!workerInstance && workerInstances.length < 3) {
                        try {
                            if (debugWorker) {
                                console.warn("[GenerateMeshBVHWorker] Creating worker with import.meta.url:", import.meta.url);
                            }
                            workerInstance = new _GenerateMeshBVHWorker();
                            workerInstances.push(workerInstance);
                        }
                        catch (err) {
                            const isSecurityError = err instanceof DOMException && err.name === "SecurityError";
                            if (isSecurityError) {
                                console.warn("Failed to create MeshBVH worker, falling back to main thread generation. This can happen when running from file://, if the browser does not support workers or if the browser is blocking workers for other reasons.");
                                console.debug(err);
                                failedToCreateMeshBVHWorker += 10;
                            }
                            else {
                                console.error("Failed to create MeshBVH worker. Please see below for more details:");
                                console.log(err);
                            }
                            failedToCreateMeshBVHWorker++;
                        }
                    }
                    if (workerInstance != null && !workerInstance.running) {
                        const name = mesh.name;
                        if (debugPhysics)
                            console.log("<<<< worker start", name, workerInstance);
                        geom[workerTaskSymbol] = "queued";
                        performance.mark("bvh.create.start");
                        // If we don't clone the buffer geometry here we will get a "Transferable ArrayBuffer" error
                        // see https://linear.app/needle/issue/NE-5602
                        // Additionally normal raycasts stop working if we don't clone the geometry
                        const copy = geom.clone();
                        try {
                            workerInstance.generate(copy)
                                .then(bvh => {
                                geom[workerTaskSymbol] = "done";
                                geom.boundsTree = bvh;
                            })
                                .catch(err => {
                                geom[workerTaskSymbol] = "failed - " + err?.message;
                                geom[canUseWorkerSymbol] = false;
                                if (debugPhysics)
                                    console.error("Failed to generate mesh bvh on worker", err);
                            })
                                .finally(() => {
                                if (debugPhysics)
                                    console.log(">>>>> worker done", name, { hasBoundsTre: geom.boundsTree != undefined });
                                availableWorkers.push(workerInstance);
                                copy.dispose();
                                performance.mark("bvh.create.end");
                                performance.measure("bvh.create (worker)", "bvh.create.start", "bvh.create.end");
                            });
                        }
                        catch (err) {
                            console.error("Failed to generate mesh bvh on worker", err);
                        }
                    }
                    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);
                    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 (geom.boundsTree) {
                loadMeshBVHLibrary();
                if (_acceleratedRaycast) {
                    // bind the raycast to the mesh
                    if (!mesh.acceleratedRaycast) {
                        mesh.acceleratedRaycast = _acceleratedRaycast.bind(mesh);
                        if (debugPhysics)
                            console.debug(`Physics: bind acceleratedRaycast fn to \"${mesh.name}\"`);
                    }
                    mesh.raycast = mesh.acceleratedRaycast;
                }
            }
            else {
                if (debugPhysics)
                    console.warn("No bounds tree found for mesh", mesh.name, { workerTask: geom[workerTaskSymbol], hasAcceleratedRaycast: _acceleratedRaycast != null });
                if (options.allowSlowRaycastFallback === false) {
                    const vertices = geom.getAttribute("position")?.array?.length ?? 0;
                    if (vertices > 2000) {
                        if (debugPhysics)
                            console.warn("Skipping raycast because no bounds tree is available and allowSlowRaycastFallback is false");
                        return false;
                    }
                }
            }
            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;
    }
    NEMeshBVH.runMeshBVHRaycast = runMeshBVHRaycast;
    let didLoadMeshBVHLibrary = false;
    let _acceleratedRaycast = null;
    let _MeshBVH = null;
    let _StaticGeometryGenerator = null;
    let _computeBoundsTree = 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.error("Failed to load BVH library...", _err.message);
            }
        });
    }
    const invMat = new Matrix4();
    /** True after the worker has been requested for the first time */
    let didSetupWorker = false;
    /** True while the worker is being requested */
    let isRequestingWorker = false;
    let _GenerateMeshBVHWorker = null;
    const workerTaskSymbol = Symbol("Needle:MeshBVH-Worker");
    const canUseWorkerSymbol = Symbol("Needle:MeshBVH-CanUseWorker");
    const workerInstances = [];
    const availableWorkers = [];
    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");
            }
            else {
                console.debug("Failed to setup mesh bvh worker", _err);
            }
        })
            .finally(() => {
            isRequestingWorker = false;
        });
    }
})(NEMeshBVH || (NEMeshBVH = {}));
//# sourceMappingURL=engine_physics.js.map