@luminocity/lemonate-engine 15.2.2 → 15.2.3

package/dist/subsystems/Physics.js

@@ -1,1079 +0,0 @@
-// -----------------------------------------------------------------------------------------------------------
-//  __         ______     __    __     ______     __   __     ______     ______   ______
-// /\ \       /\  ___\   /\ "-./  \   /\  __ \   /\ "-.\ \   /\  __ \   /\__  _\ /\  ___\
-// \ \ \____  \ \  __\   \ \ \-./\ \  \ \ \/\ \  \ \ \-.  \  \ \  __ \  \/_/\ \/ \ \  __\
-//  \ \_____\  \ \_____\  \ \_\ \ \_\  \ \_____\  \ \_\\"\_\  \ \_\ \_\    \ \_\  \ \_____\
-//   \/_____/   \/_____/   \/_/  \/_/   \/_____/   \/_/ \/_/   \/_/\/_/     \/_/   \/_____/
-//
-//
-// Copyright 2023- Luminocity AG
-//
-// "The legend never dies." - Apex Legends (2019)
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
-// and associated documentation files (the “Software”), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
-// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or substantial
-// portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
-// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// -----------------------------------------------------------------------------------------------------------
-import PhysicsWorkerUrl from "../../temp/physicsworker";
-import { InvalidArgumentException, InvalidStateException, EventEmitter, } from "@luminocity/lemonate-gateway";
-import tools from "../Tools.js";
-import { SgVehicle } from "../scenegraph/SgVehicle";
-import { BufferAttribute, BufferGeometry, LineBasicMaterial, LineSegments } from "three";
-import { SgPhysicsSubItem } from "../scenegraph/SgPhysicsSubItem.js";
-export var PhysicsConstraint;
-(function (PhysicsConstraint) {
-    PhysicsConstraint["PointToPoint"] = "pointToPoint";
-    PhysicsConstraint["Hinge"] = "hinge";
-    PhysicsConstraint["Slider"] = "slider";
-    PhysicsConstraint["ConeTwist"] = "coneTwist";
-})(PhysicsConstraint || (PhysicsConstraint = {}));
-export var PhysicsDebugMode;
-(function (PhysicsDebugMode) {
-    PhysicsDebugMode[PhysicsDebugMode["Off"] = 0] = "Off";
-    PhysicsDebugMode[PhysicsDebugMode["Wireframe"] = 1] = "Wireframe";
-    PhysicsDebugMode[PhysicsDebugMode["Slider"] = 2] = "Slider";
-    PhysicsDebugMode[PhysicsDebugMode["Raycast"] = 3] = "Raycast";
-})(PhysicsDebugMode || (PhysicsDebugMode = {}));
-export var RaycastType;
-(function (RaycastType) {
-    RaycastType["AllHits"] = "AllHits";
-    RaycastType["Closest"] = "Closest";
-})(RaycastType || (RaycastType = {}));
-const DefaultBufferSize = 3 * 1000000;
-const CONSTRAINT_TYPES = [
-    "pointToPoint",
-    "hinge",
-    "slider",
-    "coneTwist",
-];
-export class Physics extends EventEmitter {
-    engine;
-    worker;
-    bodyMap = new Map();
-    constraintMap = new Map();
-    vehiclesMap = new Map();
-    workerPromises = new Map();
-    collisionMatrix = [];
-    ready = false;
-    running = false;
-    framesCalculated = 0;
-    waitForFramesAndStop = 0;
-    softBodyRequired = true;
-    debugInfo;
-    debugMode = PhysicsDebugMode.Off;
-    raycastDebugInfo = [];
-    // Those arrays will store information about the last detected collisions
-    lastPhysicsData;
-    lastCollisions;
-    lastCollidedObjects;
-    // Debug geometry
-    debugVertices;
-    debugColors;
-    debugGeometry;
-    debugMaterial;
-    debugMesh;
-    constructor(engine) {
-        super();
-        this.engine = engine;
-        // Set the default collision matrix which is layer 0 collides with itself but nothing else.
-        this.setCollisionMatrix([[0]]);
-    }
-    async init() {
-        const promise = new Promise((resolve, reject) => {
-            this.$on("ready", () => {
-                this.setPhysicsDebugMode(this.debugMode);
-                resolve();
-            });
-            this.$on("fatal", () => {
-                reject("Fatal error in physics worker!");
-            });
-        });
-        function dataURItoBlob(dataURI) {
-            const mime = dataURI.split(',')[0].split(':')[1].split(';')[0];
-            const binary = atob(dataURI.split(',')[1]);
-            const array = [];
-            for (let i = 0; i < binary.length; i++) {
-                array.push(binary.charCodeAt(i));
-            }
-            return new Blob([new Uint8Array(array)], { type: mime });
-        }
-        const workerObjectUrl = URL.createObjectURL(dataURItoBlob(PhysicsWorkerUrl));
-        this.worker = new Worker(workerObjectUrl);
-        URL.revokeObjectURL(workerObjectUrl);
-        this.worker.onmessage = async (event) => {
-            const data = event.data;
-            switch (data.type) {
-                case "ready":
-                    this.ready = true;
-                    await this.$emit("ready");
-                    break;
-                case "fatal": {
-                    await this.$emit("fatal");
-                    break;
-                }
-                case "data": {
-                    if (this.running) {
-                        await this._update(data.data);
-                    }
-                    break;
-                }
-                case "debug": {
-                    if (this.running && this.debugMode) {
-                        this.debugInfo = data.data;
-                    }
-                    break;
-                }
-                case "raycastResult": {
-                    const p = this.workerPromises.get(data.id);
-                    if (p) {
-                        this.workerPromises.delete(data.id);
-                        p.resolve(data.data);
-                        if (this.debugMode === PhysicsDebugMode.Raycast) {
-                            this.debugInfo = null;
-                            const hits = this._extractHits(data.data);
-                            this._addRaycastDebugInfo(p.startVectors, p.endVectors, hits);
-                        }
-                    }
-                    break;
-                }
-                case "convexSweepTestResult": {
-                    const p = this.workerPromises.get(data.id);
-                    if (p) {
-                        this.workerPromises.delete(data.id);
-                        p.resolve(data.data);
-                    }
-                    break;
-                }
-            }
-        };
-        return promise;
-    }
-    // returns a flat array of hits from all possible raycast results
-    _extractHits(input) {
-        const hits = [];
-        function arrayExtract(value) {
-            if (Array.isArray(value)) {
-                for (const item of value) {
-                    arrayExtract(item);
-                }
-            }
-            else if (typeof value === 'object' && value !== null) {
-                if ('hit' in value) {
-                    if (value.hit) {
-                        hits.push(value);
-                    }
-                }
-                else {
-                    for (const key in value) {
-                        arrayExtract(value[key]);
-                    }
-                }
-            }
-        }
-        arrayExtract(input);
-        return hits;
-    }
-    _addRaycastDebugInfo(startVectors, endVectors, data) {
-        if (!data)
-            return;
-        startVectors.forEach((vec, i) => {
-            const hit = data[i];
-            if (hit) {
-                this.raycastDebugInfo.push({
-                    startVector: vec,
-                    point: hit.point,
-                    normal: hit.normal,
-                    hit: true
-                });
-            }
-            else {
-                this.raycastDebugInfo.push({
-                    startVector: vec,
-                    point: endVectors[i],
-                    hit: false
-                });
-            }
-        });
-    }
-    setWaitFramesAndStop(count) {
-        this.waitForFramesAndStop = count;
-    }
-    async waitForStop() {
-        return new Promise((resolve, reject) => {
-            if (!this.running)
-                resolve();
-            setInterval(() => {
-                if (!this.running)
-                    resolve();
-            }, 20);
-        });
-    }
-    setPhysicsDebugMode(mode) {
-        this.debugMode = mode;
-        if (this.worker) {
-            // clear the old information
-            this.debugInfo = null;
-            // in case we switched to raycasts debug mode, we post the "Off" mode to physics since this one
-            // we handle directly in this class, not in physics itself
-            if (mode === PhysicsDebugMode.Raycast)
-                mode = PhysicsDebugMode.Off;
-            this.worker.postMessage({
-                type: "setDebugMode",
-                data: mode,
-            });
-        }
-    }
-    getDebugMode() {
-        return this.debugMode;
-    }
-    setCollisionMatrix(collisionMatrix) {
-        if (!Array.isArray(collisionMatrix)) {
-            console.error("Collision matrix must be an array.");
-            return;
-        }
-        const matrix = [];
-        const layerCount = this.engine.renderer.getLayers().length;
-        for (let i = 0; i < layerCount; i++) {
-            matrix.push(new Array(layerCount).fill(0, 0, layerCount));
-        }
-        for (const [i, value] of collisionMatrix.entries()) {
-            if (!Array.isArray(value)) {
-                console.error("Collision matrix must be an array of arrays, containing integers");
-            }
-            else {
-                for (const j of value) {
-                    if (i < layerCount && j >= 0 && j < layerCount) {
-                        matrix[i][j] = 1;
-                        matrix[j][i] = 1;
-                    }
-                }
-            }
-        }
-        this.collisionMatrix = matrix;
-        this.engine.mainSceneGraphCollection.forEachItem((item) => {
-            if (item.isPhysicsItem()) {
-                item.readdToPhysics();
-            }
-        });
-    }
-    getCollisionMaskAndGroupForLayer(indices) {
-        let group = 0;
-        let mask = 0;
-        // every object allows to be hit by the raycasting group (0)
-        mask |= 1 << 0;
-        // offset layers and masks by one since the first layer is reserved for raycasting
-        for (const i of indices) {
-            group |= 1 << i + 1;
-            for (const [j, on] of this.collisionMatrix[i].entries()) {
-                if (on)
-                    mask |= 1 << j + 1;
-            }
-        }
-        return { group, mask };
-    }
-    _sendBodyMessage(id, message, data) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (this.bodyMap.has(id)) {
-            data = data || {};
-            data.id = id;
-            this.worker.postMessage({
-                type: message,
-                data: data,
-            });
-        }
-        else {
-            console.error("[PHYSICS] Body to send message to not found!");
-        }
-    }
-    _sendVehicleMessage(id, message, data) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (this.vehiclesMap.has(id)) {
-            data.id = id;
-            this.worker.postMessage({
-                type: message,
-                data: data,
-            });
-        }
-        else {
-            console.error("[PHYSICS] Vehicle to send message to not found!");
-        }
-    }
-    reset() {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        this.worker.postMessage({
-            type: "reset",
-            data: this.softBodyRequired,
-        });
-    }
-    start() {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        this.running = true;
-        this.framesCalculated = 0;
-        this.worker.postMessage({
-            type: "start",
-        });
-    }
-    stop() {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        this.worker.postMessage({
-            type: "stop",
-        });
-        this.running = false;
-        this.lastPhysicsData = null;
-    }
-    pause() {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        this.worker.postMessage({
-            type: "pause",
-        });
-    }
-    resume() {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        this.worker.postMessage({
-            type: "resume",
-        });
-    }
-    userPause() {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        this.worker.postMessage({
-            type: "userPause",
-        });
-    }
-    userResume() {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        this.worker.postMessage({
-            type: "userResume",
-        });
-    }
-    clearDebugInfo() {
-        this.debugInfo = null;
-        this.raycastDebugInfo = [];
-    }
-    clear() {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        this.worker.postMessage({
-            type: "clear",
-        });
-    }
-    setGravity(vector) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        this.worker.postMessage({
-            type: "setGravity",
-            data: vector,
-        });
-    }
-    _cloneData(data) {
-        // We have to filter out any proxies that might be in the data, otherwise
-        // we'll get an error because proxies cannot be sent to a worker. To do that
-        // we just JSON-clone everything except if it is a Float32Array because they will break
-        // by doing that.
-        const clonedData = {};
-        for (const key in data) {
-            const val = data[key];
-            if (!val || val instanceof Float32Array || val instanceof Uint16Array) {
-                clonedData[key] = val;
-            }
-            else {
-                clonedData[key] = JSON.parse(JSON.stringify(val));
-            }
-        }
-        return clonedData;
-    }
-    _prepareAndCloneData(data, owner, Type) {
-        Type = Type || SgPhysicsSubItem;
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (!(owner instanceof Type))
-            throw new InvalidStateException("Cannot add object to physics, owner is not a physics enabled item.");
-        data = this._cloneData(data);
-        const cm = this.getCollisionMaskAndGroupForLayer(owner.getLayerIndices());
-        data.mask = cm.mask;
-        data.group = cm.group;
-        data.id = tools.createGUID();
-        data.ownerId = owner.getId();
-        return {
-            owner: owner,
-            data: data
-        };
-    }
-    /**
-     * Add a rigid body to the physics engine
-     * @param owner the owning sgphysicsitem
-     * @param data the physics data of the object
-     * @return {*|null}
-     */
-    addRigidBody(owner, data) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        const body = this._prepareAndCloneData(data, owner);
-        try {
-            this.worker.postMessage({
-                type: "addRigidBody",
-                data: body.data,
-            });
-            this.bodyMap.set(body.data.id, body);
-        }
-        catch (err) {
-            console.error(err);
-        }
-        return body.data.id;
-    }
-    removeRigidBody(id) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (this.bodyMap.has(id)) {
-            this.bodyMap.delete(id);
-            this.worker.postMessage({
-                type: "removeRigidBody",
-                data: id
-            });
-        }
-    }
-    /**
-     * Add a ghost object to physics engine
-     * @param owner
-     * @param data
-     * @return {*|null}
-     */
-    addGhostObject(owner, data) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        const body = this._prepareAndCloneData(data, owner);
-        try {
-            this.worker.postMessage({
-                type: "addGhostObject",
-                data: body.data,
-            });
-            this.bodyMap.set(body.data.id, body);
-        }
-        catch (err) {
-            console.error(err);
-        }
-        return body.data.id;
-    }
-    removeGhostObject(id) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (this.bodyMap.has(id)) {
-            this.bodyMap.delete(id);
-            this.worker.postMessage({
-                type: "removeGhostObject",
-                data: id,
-            });
-        }
-    }
-    addVehicle(owner, data) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        const body = this._prepareAndCloneData(data, owner, SgVehicle);
-        try {
-            this.worker.postMessage({
-                type: "addVehicle",
-                data: body.data,
-            });
-            this.vehiclesMap.set(body.data.id, body);
-        }
-        catch (err) {
-            console.error(err);
-        }
-        return body.data.id;
-    }
-    removeVehicle(id) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (this.vehiclesMap.has(id)) {
-            this.vehiclesMap.delete(id);
-            this.worker.postMessage({
-                type: "removeVehicle",
-                data: id,
-            });
-        }
-    }
-    /**
-     * Steer a vehicle. Wheels should be an array of { index, value } objects
-     * @param object
-     * @param wheels
-     */
-    steerVehicle(id, wheels) {
-        this._sendVehicleMessage(id, "steerVehicle", {
-            wheels: wheels,
-        });
-    }
-    /**
-     * Brake a vehicle. Wheels should be an array of { index, value } objects
-     * @param object
-     * @param wheels
-     */
-    brakeVehicle(id, wheels) {
-        this._sendVehicleMessage(id, "brakeVehicle", {
-            wheels: wheels,
-        });
-    }
-    /**
-     * Accelerate a vehicle. Wheels should be an array of { index, value } objects
-     * @param object
-     * @param wheels
-     */
-    accelerateVehicle(id, wheels) {
-        this._sendVehicleMessage(id, "accelerateVehicle", {
-            wheels: wheels,
-        });
-    }
-    /**
-     * Add a softbody to physics engine
-     * @param owner the owning sgphysicsitem
-     * @param data
-     * @return {string}
-     */
-    addSoftBody(owner, data) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        const body = this._prepareAndCloneData(data, owner);
-        try {
-            this.worker.postMessage({
-                type: "addSoftBody",
-                data: body.data
-            });
-            this.bodyMap.set(body.data.id, body);
-        }
-        catch (err) {
-            console.error(err);
-        }
-        return body.data.id;
-    }
-    removeSoftBody(id) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (this.bodyMap.has(id)) {
-            this.bodyMap.delete(id);
-            this.worker.postMessage({
-                type: "removeSoftBody",
-                data: id,
-            });
-        }
-    }
-    resetBody(id) {
-        this._sendBodyMessage(id, "resetBody");
-    }
-    getMaskFromLayerNames(filterLayers) {
-        if (filterLayers === null || filterLayers === undefined) {
-            return -1; // will match all layers
-        }
-        let mask = 0;
-        const layerNames = this.engine.renderer.getLayers();
-        layerNames.forEach((name, index) => {
-            if (filterLayers.includes(name)) {
-                mask |= 1 << index + 1; // offset by one since the first layer is reserved for raycasting
-            }
-        });
-        if (mask === 0) {
-            console.warn("No layers matched the raycasting filter. Matching all layers.");
-            return -1;
-        }
-        return mask;
-    }
-    /**
-     * Send a ray cast
-     * @param startVector Start vector
-     * @param endVector End vector
-     * @param raycastType Type of raycast. Needs to be "Closest" or "AllHits"
-     * @param filterLayers Optional array of layer names to filter results. If null, no filtering is applied.
-     * @return Promise<object> returns a promise that resolves into a ray cast result object, containing point, normal and object handle
-     */
-    raycast(startVector, endVector, raycastType, filterLayers) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        const id = tools.createGUID();
-        let promiseResolve;
-        let promiseReject;
-        const promise = new Promise((resolve, reject) => {
-            promiseResolve = resolve;
-            promiseReject = reject;
-            this.worker.postMessage({
-                type: "raycast",
-                data: {
-                    id: id,
-                    startVector: startVector,
-                    endVector: endVector,
-                    type: raycastType,
-                    mask: this.getMaskFromLayerNames(filterLayers),
-                },
-            });
-        });
-        this.workerPromises.set(id, {
-            promise: promise,
-            resolve: promiseResolve,
-            reject: promiseReject,
-            startVectors: [startVector],
-            endVectors: [endVector]
-        });
-        return promise;
-    }
-    /**
-     * Send many ray casts
-     * @param startVectors Array of start vectors
-     * @param endVectors Array of end vectors
-     * @param raycastType Type of raycast. Needs to be "Closest" or "AllHits"
-     * @param filterLayers Optional array of layer names to filter results. If null, no filtering is applied.
-     * @return Promise<array> returns a promise that resolves into an array of ray cast result objects, containing point, normal and object handle
-     */
-    raycastMany(startVectors, endVectors, raycastType, filterLayers) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        const id = tools.createGUID();
-        let promiseResolve;
-        let promiseReject;
-        const promise = new Promise((resolve, reject) => {
-            promiseResolve = resolve;
-            promiseReject = reject;
-            this.worker.postMessage({
-                type: "raycastMany",
-                data: {
-                    id: id,
-                    startVectors: startVectors,
-                    endVectors: endVectors,
-                    type: raycastType,
-                    mask: this.getMaskFromLayerNames(filterLayers),
-                },
-            });
-        });
-        this.workerPromises.set(id, {
-            promise: promise,
-            resolve: promiseResolve,
-            reject: promiseReject,
-            startVectors: startVectors,
-            endVectors: endVectors
-        });
-        return promise;
-    }
-    /**
-     * Send a convex sweep test
-     * @param startVector Start vector
-     * @param endVector End vector
-     * @param shape Shape object, containing at least .type with the type of shape to use. Possible values: "Sphere". Sphere also requires .radius
-     * @param filterLayers Optional array of layer names to filter results. If null, no filtering is applied.
-     * @return Promise<object> returns a promise that resolves into a ray cast result object, containing point, normal and object handle
-     */
-    convexSweepTest(startVector, endVector, shape, filterLayers) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        const id = tools.createGUID();
-        let promiseResolve;
-        let promiseReject;
-        const promise = new Promise((resolve, reject) => {
-            promiseResolve = resolve;
-            promiseReject = reject;
-            this.worker.postMessage({
-                type: "convexSweepTest",
-                data: {
-                    id: id,
-                    startVector: startVector,
-                    endVector: endVector,
-                    shape: shape,
-                    mask: this.getMaskFromLayerNames(filterLayers),
-                },
-            });
-        });
-        this.workerPromises.set(id, {
-            promise: promise,
-            resolve: promiseResolve,
-            reject: promiseReject,
-            startVectors: [startVector],
-            endVectors: [endVector]
-        });
-        return promise;
-    }
-    /**
-     * Send many convex sweep tests
-     * @param startVectors Array of start vectors
-     * @param endVectors Array of end vectors
-     * @param shape Shape object, containing at least .type with the type of shape to use. Possible values: "Sphere". Sphere also requires .radius
-     * @param filterLayers Optional array of layer names to filter results. If null, no filtering is applied.
-     * @return Promise<array> returns a promise that resolves into an array of ray cast result objects, containing point, normal and object handle
-     */
-    convexSweepTestMany(startVectors, endVectors, shape, filterLayers) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        const id = tools.createGUID();
-        let promiseResolve;
-        let promiseReject;
-        const promise = new Promise((resolve, reject) => {
-            promiseResolve = resolve;
-            promiseReject = reject;
-            this.worker.postMessage({
-                type: "convexSweepTestMany",
-                data: {
-                    id: id,
-                    startVectors: startVectors,
-                    endVectors: endVectors,
-                    shape: shape,
-                    mask: this.getMaskFromLayerNames(filterLayers),
-                },
-            });
-        });
-        this.workerPromises.set(id, {
-            promise: promise,
-            resolve: promiseResolve,
-            reject: promiseReject,
-            startVectors: startVectors,
-            endVectors: endVectors
-        });
-        return promise;
-    }
-    watchCollisions(id, enabled) {
-        this._sendBodyMessage(id, "watchCollisions", {
-            value: enabled,
-        });
-    }
-    reportContactPoints(id, enabled) {
-        this._sendBodyMessage(id, "reportContactPoints", {
-            value: enabled,
-        });
-    }
-    filterPotentialCollisions(id, enabled) {
-        this._sendBodyMessage(id, "filterPotentialCollisions", {
-            value: enabled,
-        });
-    }
-    watchLinearVelocity(id, enabled) {
-        this._sendBodyMessage(id, "watchLinearVelocity", {
-            value: enabled,
-        });
-    }
-    watchAngularVelocity(id, enabled) {
-        this._sendBodyMessage(id, "watchAngularVelocity", {
-            value: enabled,
-        });
-    }
-    setRestitution(id, value) {
-        this._sendBodyMessage(id, "setRestitution", {
-            value: value,
-        });
-    }
-    setFriction(id, value) {
-        this._sendBodyMessage(id, "setFriction", {
-            value: value,
-        });
-    }
-    setSpinningFriction(id, value) {
-        this._sendBodyMessage(id, "setSpinningFriction", {
-            value: value,
-        });
-    }
-    setRollingFriction(id, value) {
-        this._sendBodyMessage(id, "setRollingFriction", {
-            value: value,
-        });
-    }
-    setLinearDamping(id, value) {
-        this._sendBodyMessage(id, "setLinearDamping", {
-            value: value,
-        });
-    }
-    setAngularDamping(id, value) {
-        this._sendBodyMessage(id, "setAngularDamping", {
-            value: value,
-        });
-    }
-    setPosition(id, position) {
-        this._sendBodyMessage(id, "setPosition", {
-            value: position,
-        });
-    }
-    setRotation(id, rotation) {
-        this._sendBodyMessage(id, "setRotation", {
-            value: rotation,
-        });
-    }
-    updateTransform(id, transform) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (this.bodyMap.has(id)) {
-            const body = this.bodyMap.get(id);
-            transform = transform || body.owner.getWorldTransform();
-            if (transform) {
-                this.worker.postMessage({
-                    type: "setTransform",
-                    data: {
-                        id: id,
-                        position: transform.position,
-                        rotation: transform.rotation,
-                        scale: transform.scale,
-                    },
-                });
-            }
-        }
-    }
-    disableDeactivation(id) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (this.bodyMap.has(id)) {
-            this.worker.postMessage({
-                type: "disableDeactivation",
-                data: id,
-            });
-        }
-    }
-    setLinearVelocity(id, vector) {
-        this._sendBodyMessage(id, "setLinearVelocity", {
-            vector: vector,
-        });
-    }
-    setLinearFactor(id, vector) {
-        this._sendBodyMessage(id, "setLinearFactor", {
-            vector: vector,
-        });
-    }
-    setAngularVelocity(id, vector) {
-        this._sendBodyMessage(id, "setAngularVelocity", {
-            vector: vector,
-        });
-    }
-    setAngularFactor(id, vector) {
-        this._sendBodyMessage(id, "setAngularFactor", {
-            vector: vector,
-        });
-    }
-    clearForces(id) {
-        this._sendBodyMessage(id, "clearForces");
-    }
-    applyForce(id, vector, relPos) {
-        this._sendBodyMessage(id, "applyForce", {
-            vector: vector,
-            relPos: relPos,
-        });
-    }
-    applyImpulse(id, vector, relPos) {
-        this._sendBodyMessage(id, "applyImpulse", {
-            vector: vector,
-            relPos: relPos,
-        });
-    }
-    applyPushImpulse(id, vector, relPos) {
-        this._sendBodyMessage(id, "applyPushImpulse", {
-            vector: vector,
-            relPos: relPos,
-        });
-    }
-    applyCentralImpulse(id, vector) {
-        this._sendBodyMessage(id, "applyCentralImpulse", {
-            vector: vector
-        });
-    }
-    applyCentralPushImpulse(id, vector) {
-        this._sendBodyMessage(id, "applyCentralPushImpulse", {
-            vector: vector,
-        });
-    }
-    applyTorque(id, vector) {
-        this._sendBodyMessage(id, "applyTorque", {
-            vector: vector,
-        });
-    }
-    addConstraint(type, params) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (!CONSTRAINT_TYPES.includes(type))
-            throw new InvalidArgumentException(`Invalid constraint type '${type}'. Allowed are ${CONSTRAINT_TYPES.join(",")}`);
-        const data = {
-            id: tools.createGUID(),
-            jointType: type,
-            body1: params.bodyId1,
-            body2: params.bodyId2,
-            disableCollisions: params.disableCollisions || false,
-        };
-        switch (type) {
-            case "pointToPoint":
-                data.pivot1 = params.point1;
-                data.pivot2 = params.point2;
-                break;
-            case "hinge":
-                data.pivot1 = params.point1;
-                data.pivot2 = params.point2;
-                data.axis1 = params.axis1;
-                data.axis2 = params.axis2;
-                data.useReferenceFrameA = params.useReferenceFrameA;
-                break;
-            case "slider":
-                data.quat1 = params.quat1;
-                data.quat2 = params.quat2;
-                data.trans1 = params.trans1;
-                data.trans2 = params.trans2;
-                data.useLinearReferenceFrameA = params.useLinearReferenceFrameA;
-                break;
-            case "coneTwist":
-                data.quat1 = params.quat1;
-                data.quat2 = params.quat2;
-                data.trans1 = params.trans1;
-                data.trans2 = params.trans2;
-                break;
-            default:
-                throw new InvalidArgumentException(`Unsupported constraint type '${type}'`);
-        }
-        this.constraintMap.set(data.id, data);
-        this.worker.postMessage({
-            type: "addConstraint",
-            data: data,
-        });
-        return data.id;
-    }
-    removeConstraint(id) {
-        if (!this.ready || !this.worker)
-            throw new InvalidStateException("Physics engine not ready");
-        if (this.constraintMap.has(id)) {
-            this.constraintMap.delete(id);
-            this.worker.postMessage({
-                type: "removeConstraint",
-                data: id,
-            });
-        }
-    }
-    resolveOwnerId(id) {
-        const body = this.bodyMap.get(id);
-        if (!body)
-            return null;
-        return body.owner.getId();
-    }
-    processPhysicsUpdate() {
-        try {
-            if (!this.lastPhysicsData || !this.running) {
-                return;
-            }
-            let data = this.lastPhysicsData;
-            this.lastPhysicsData = null;
-            for (const object of data.objects) {
-                const body = this.bodyMap.get(object.id);
-                if (body)
-                    body.owner._physicsUpdate(object, data.timing);
-            }
-            for (const object of data.vehicles) {
-                const vehicle = this.vehiclesMap.get(object.id);
-                if (vehicle)
-                    vehicle.owner._physicsUpdate(object, data.timing);
-            }
-            if (Array.isArray(data.collisions) && data.collisions.length > 0) {
-                const objects = [];
-                for (const collision of data.collisions) {
-                    const ownerId1 = this.resolveOwnerId(collision.object1.id);
-                    const ownerId2 = this.resolveOwnerId(collision.object2.id);
-                    objects.push({ object1: ownerId1, object2: ownerId2, contactPoints: collision.contactPoints });
-                }
-                this.lastCollisions = data.collisions;
-                this.lastCollidedObjects = objects;
-                this.engine.player.pushEvent({
-                    type: "physicsCollisions",
-                    data: this.lastCollidedObjects,
-                });
-            }
-        }
-        catch (err) {
-            console.error(err);
-        }
-    }
-    initDebugDrawing(scene) {
-        this.debugVertices = new Float32Array(DefaultBufferSize);
-        this.debugColors = new Float32Array(DefaultBufferSize);
-        this.debugGeometry = new BufferGeometry();
-        this.debugGeometry.setAttribute("position", new BufferAttribute(this.debugVertices, 3));
-        this.debugGeometry.setAttribute("color", new BufferAttribute(this.debugColors, 3));
-        this.debugMaterial = new LineBasicMaterial({ vertexColors: true });
-        this.debugMesh = new LineSegments(this.debugGeometry, this.debugMaterial);
-        this.debugMesh.name = "PhysicsDebugMesh";
-        this.debugMesh.frustumCulled = false;
-        scene.add(this.debugMesh);
-    }
-    renderDebugInfo() {
-        if (!this.debugVertices || !this.debugColors || !this.debugGeometry || !this.debugMesh)
-            return;
-        if (this.debugInfo || this.raycastDebugInfo.length) {
-            let ti = 0;
-            if (this.debugInfo) {
-                const vertices = this.debugInfo.vertices;
-                const colors = this.debugInfo.colors;
-                if (vertices.length) {
-                    for (let i = 0; i < vertices.length; i++) {
-                        this.debugVertices[ti] = vertices[i];
-                        this.debugColors[ti] = colors[i];
-                        ti++;
-                    }
-                }
-            }
-            for (const entry of this.raycastDebugInfo) {
-                this.debugVertices[ti] = entry.startVector.x;
-                this.debugVertices[ti + 1] = entry.startVector.y;
-                this.debugVertices[ti + 2] = entry.startVector.z;
-                this.debugVertices[ti + 3] = entry.point.x;
-                this.debugVertices[ti + 4] = entry.point.y;
-                this.debugVertices[ti + 5] = entry.point.z;
-                if (entry.hit) {
-                    this.debugColors[ti] = 0;
-                    this.debugColors[ti + 1] = 1;
-                    this.debugColors[ti + 2] = 0;
-                    this.debugColors[ti + 3] = 0;
-                    this.debugColors[ti + 4] = 1;
-                    this.debugColors[ti + 5] = 0;
-                }
-                else {
-                    this.debugColors[ti] = 1;
-                    this.debugColors[ti + 1] = 0;
-                    this.debugColors[ti + 2] = 0;
-                    this.debugColors[ti + 3] = 1;
-                    this.debugColors[ti + 4] = 0;
-                    this.debugColors[ti + 5] = 0;
-                }
-                ti += 6;
-            }
-            this.raycastDebugInfo = [];
-            this.debugGeometry.attributes.position.needsUpdate = true;
-            this.debugGeometry.attributes.color.needsUpdate = true;
-            this.debugGeometry.setDrawRange(0, ti / 3);
-            this.debugMesh.visible = true;
-        }
-        else {
-            this.debugMesh.visible = false;
-        }
-    }
-    async _update(data) {
-        if (!this.running)
-            return;
-        if (this.lastPhysicsData) {
-            // we already have physics data. just overwriting the old would be an issue since they have not yet
-            // been processed. This is fine for object and vehicle updates, collision updates however will need to
-            // be accumulated or we're losing collision events!
-            data.collisions = [...this.lastPhysicsData.collisions, ...data.collisions];
-        }
-        this.lastPhysicsData = data;
-        if (this.waitForFramesAndStop) {
-            // if we're instructed to just run X frames of physics simulation and then stop, just do the update here, otherwise
-            // the renderer will call it
-            await this.processPhysicsUpdate();
-            this.framesCalculated++;
-            if (this.framesCalculated === this.waitForFramesAndStop) {
-                this.stop();
-            }
-        }
-    }
-}
-//# sourceMappingURL=Physics.js.map