@needle-tools/engine 3.28.7-beta → 3.28.7-beta.1

package/src/engine/engine_physics.ts

@@ -1,287 +1,287 @@
-import { Box3, Camera, type Intersection, Layers, Mesh, Object3D, Ray, Raycaster, Sphere, Vector2, Vector3 } from 'three'
-import { Context } from './engine_setup.js';
-import { getParam } from "./engine_utils.js"
-import { getWorldPosition } from "./engine_three_utils.js"
-import type { Vec2, Vec3, } from './engine_types.js';
-import type { IPhysicsEngine } from './engine_types.js';
-
-const debugPhysics = getParam("debugphysics");
-const layerMaskHelper: Layers = new Layers();
-
-export declare type RaycastTestObjectReturnType = void | boolean | "continue in children";
-export declare type RaycastTestObjectCallback = (obj: Object3D) => RaycastTestObjectReturnType;
-
-declare interface IRaycastOptions {
-    /** Optionally a custom raycaster can be provided. Other properties will then be set on this raycaster */
-    raycaster?: Raycaster;
-    /** Optional ray that can be used for raycasting  
-     *  @link https://threejs.org/docs/#api/en/math/Ray 
-     * */
-    ray?: Ray;
-    /** The camera to use for the raycaster */
-    cam?: Camera | null;
-    /** Point on screen in raycast space / normalized device coordinates (-1 to 1).   
-     * @link https://threejs.org/docs/#api/en/core/Raycaster.setFromCamera */
-    screenPoint?: Vector2;
-    /** Raycast results array. You can provide an array here to avoid creating a new one (note that if your array already contains items they will be removed) */
-    results?: Array<Intersection>;
-    /** Objects to raycast against. If no target array is provided the whole scene will be raycasted */
-    targets?: Array<Object3D>;
-    recursive?: boolean;
-    /** Set the raycaster near distance:  
-     * The near factor of the raycaster. This value indicates which objects can be discarded based on the distance. This value shouldn't be negative and should be smaller than the far property.  
-     * @link https://threejs.org/docs/#api/en/core/Raycaster.near
-     */
-    minDistance?: number;
-    /** Set the raycaster far distance:  
-     * The far factor of the raycaster. This value indicates which objects can be discarded based on the distance. This value shouldn't be negative and should be larger than the near property.
-     * @link https://threejs.org/docs/#api/en/core/Raycaster.far
-     */
-    maxDistance?: number;
-    /** @link https://threejs.org/docs/#api/en/core/Raycaster.params */
-    lineThreshold?: number;
-    /** raw layer mask, use setLayer to set an individual layer active */
-    layerMask?: Layers | number;
-    ignore?: Object3D[];
-    /** Optional calback function to be called per object before tested for intersections.  
-     * This can be used 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)  
-     * */
-    testObject?: RaycastTestObjectCallback;
-}
-
-export class RaycastOptions implements IRaycastOptions {
-    public static readonly AllLayers = 0xFFFFFFFF;
-
-    ray?: Ray;
-    cam?: Camera | null;
-    screenPoint?: Vector2;
-    raycaster?: Raycaster;
-    results?: Array<Intersection>;
-    targets?: Array<Object3D>;
-    recursive?: boolean = true;
-    minDistance?: number;
-    maxDistance?: number;
-    lineThreshold?: number;
-    layerMask?: Layers | number;
-    ignore?: Object3D[];
-    testObject?: RaycastTestObjectCallback;
-
-    screenPointFromOffset(ox: number, oy: number) {
-        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: number) {
-        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: number) {
-        if (!this.layerMask) this.layerMask = new Layers();
-        const lm = this.layerMask as Layers;
-        if (lm)
-            lm.mask = mask;
-        else this.layerMask = mask;
-    }
-
-}
-
-export class SphereIntersection implements Intersection {
-    distance: number;
-    point: Vector3;
-    object: Object3D;
-    constructor(object: Object3D, distance: number, point: Vector3) {
-        this.object = object;
-        this.distance = distance;
-        this.point = point;
-    }
-}
-
-export class Physics {
-
-    /**@deprecated use this.context.physics.engine.raycast */
-    public raycastPhysicsFast(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true) {
-        return this.context.physics.engine?.raycast(origin, direction, maxDistance, solid) ?? null;
-    }
-
-    /**@deprecated use this.context.physics.engine.raycastAndGetNormal */
-    public raycastPhysicsFastAndGetNormal(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true) {
-        return this.context.physics.engine?.raycastAndGetNormal(origin, direction, maxDistance, solid) ?? null;
-    }
-
-    /**@deprecated use this.context.physics.engine.sphereOverlap */
-    public sphereOverlapPhysics(point: Vector3, radius: number) {
-        return this.context.physics.engine?.sphereOverlap(point, radius) ?? null;
-    }
-
-
-    private readonly context: Context;
-    engine?: IPhysicsEngine;
-
-    constructor(context: Context) {
-        this.context = context;
-    }
-
-    // raycasting
-    private readonly raycaster: Raycaster = new Raycaster();
-    private readonly defaultRaycastOptions: RaycastOptions = new RaycastOptions();
-    private readonly targetBuffer: Array<Object3D> = new Array<Object3D>(1);
-    private readonly defaultThresholds = {
-        Mesh: {},
-        Line: { threshold: 0 },
-        LOD: {},
-        Points: { threshold: 0 },
-        Sprite: {}
-    }
-
-
-    private sphereResults: Array<Intersection> = new Array<Intersection>();
-    private sphereMask: Layers = new Layers();
-    /** 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
-     */
-    public sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit: boolean = true): 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);
-        }
-        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)) {
-            const mesh = obj as Mesh;
-            const geo = mesh.geometry;
-            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: RaycastOptions | null = null): Array<Intersection> {
-        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.
-     */
-    public raycast(options: IRaycastOptions | RaycastOptions | null = null): Array<Intersection> {
-        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)
-            rc.params.Line = { threshold: options.lineThreshold };
-        else rc.params.Line = { threshold: 0 };
-        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 ?? [];
-            }
-            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<Intersection>();
-            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);
-        }
-
-        // console.log(rc)
-        // console.log(targets);
-
-        // shoot
-        results.length = 0;
-        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));
-        }
-        return results;
-    }
-
-    private intersect(raycaster: Raycaster, objects: Object3D[], results: Intersection[], options: IRaycastOptions) {
-        for (const obj of objects) {
-            const testResult = options.testObject?.(obj);
-            if (testResult === false) continue;
-            const checkObject = testResult !== "continue in children";
-            if (checkObject) {
-                raycaster.intersectObject(obj, false, results);
-            }
-
-            if (options.recursive !== false) {
-                this.intersect(raycaster, obj.children, results, options);
-            }
-        }
-        return results;
-    }
-}
+import { Box3, Camera, type Intersection, Layers, Mesh, Object3D, Ray, Raycaster, Sphere, Vector2, Vector3 } from 'three'
+import { Context } from './engine_setup.js';
+import { getParam } from "./engine_utils.js"
+import { getWorldPosition } from "./engine_three_utils.js"
+import type { Vec2, Vec3, } from './engine_types.js';
+import type { IPhysicsEngine } from './engine_types.js';
+
+const debugPhysics = getParam("debugphysics");
+const layerMaskHelper: Layers = new Layers();
+
+export declare type RaycastTestObjectReturnType = void | boolean | "continue in children";
+export declare type RaycastTestObjectCallback = (obj: Object3D) => RaycastTestObjectReturnType;
+
+declare interface IRaycastOptions {
+    /** Optionally a custom raycaster can be provided. Other properties will then be set on this raycaster */
+    raycaster?: Raycaster;
+    /** Optional ray that can be used for raycasting  
+     *  @link https://threejs.org/docs/#api/en/math/Ray 
+     * */
+    ray?: Ray;
+    /** The camera to use for the raycaster */
+    cam?: Camera | null;
+    /** Point on screen in raycast space / normalized device coordinates (-1 to 1).   
+     * @link https://threejs.org/docs/#api/en/core/Raycaster.setFromCamera */
+    screenPoint?: Vector2;
+    /** Raycast results array. You can provide an array here to avoid creating a new one (note that if your array already contains items they will be removed) */
+    results?: Array<Intersection>;
+    /** Objects to raycast against. If no target array is provided the whole scene will be raycasted */
+    targets?: Array<Object3D>;
+    recursive?: boolean;
+    /** Set the raycaster near distance:  
+     * The near factor of the raycaster. This value indicates which objects can be discarded based on the distance. This value shouldn't be negative and should be smaller than the far property.  
+     * @link https://threejs.org/docs/#api/en/core/Raycaster.near
+     */
+    minDistance?: number;
+    /** Set the raycaster far distance:  
+     * The far factor of the raycaster. This value indicates which objects can be discarded based on the distance. This value shouldn't be negative and should be larger than the near property.
+     * @link https://threejs.org/docs/#api/en/core/Raycaster.far
+     */
+    maxDistance?: number;
+    /** @link https://threejs.org/docs/#api/en/core/Raycaster.params */
+    lineThreshold?: number;
+    /** raw layer mask, use setLayer to set an individual layer active */
+    layerMask?: Layers | number;
+    ignore?: Object3D[];
+    /** Optional calback function to be called per object before tested for intersections.  
+     * This can be used 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)  
+     * */
+    testObject?: RaycastTestObjectCallback;
+}
+
+export class RaycastOptions implements IRaycastOptions {
+    public static readonly AllLayers = 0xFFFFFFFF;
+
+    ray?: Ray;
+    cam?: Camera | null;
+    screenPoint?: Vector2;
+    raycaster?: Raycaster;
+    results?: Array<Intersection>;
+    targets?: Array<Object3D>;
+    recursive?: boolean = true;
+    minDistance?: number;
+    maxDistance?: number;
+    lineThreshold?: number;
+    layerMask?: Layers | number;
+    ignore?: Object3D[];
+    testObject?: RaycastTestObjectCallback;
+
+    screenPointFromOffset(ox: number, oy: number) {
+        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: number) {
+        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: number) {
+        if (!this.layerMask) this.layerMask = new Layers();
+        const lm = this.layerMask as Layers;
+        if (lm)
+            lm.mask = mask;
+        else this.layerMask = mask;
+    }
+
+}
+
+export class SphereIntersection implements Intersection {
+    distance: number;
+    point: Vector3;
+    object: Object3D;
+    constructor(object: Object3D, distance: number, point: Vector3) {
+        this.object = object;
+        this.distance = distance;
+        this.point = point;
+    }
+}
+
+export class Physics {
+
+    /**@deprecated use this.context.physics.engine.raycast */
+    public raycastPhysicsFast(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true) {
+        return this.context.physics.engine?.raycast(origin, direction, maxDistance, solid) ?? null;
+    }
+
+    /**@deprecated use this.context.physics.engine.raycastAndGetNormal */
+    public raycastPhysicsFastAndGetNormal(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true) {
+        return this.context.physics.engine?.raycastAndGetNormal(origin, direction, maxDistance, solid) ?? null;
+    }
+
+    /**@deprecated use this.context.physics.engine.sphereOverlap */
+    public sphereOverlapPhysics(point: Vector3, radius: number) {
+        return this.context.physics.engine?.sphereOverlap(point, radius) ?? null;
+    }
+
+
+    private readonly context: Context;
+    engine?: IPhysicsEngine;
+
+    constructor(context: Context) {
+        this.context = context;
+    }
+
+    // raycasting
+    private readonly raycaster: Raycaster = new Raycaster();
+    private readonly defaultRaycastOptions: RaycastOptions = new RaycastOptions();
+    private readonly targetBuffer: Array<Object3D> = new Array<Object3D>(1);
+    private readonly defaultThresholds = {
+        Mesh: {},
+        Line: { threshold: 0 },
+        LOD: {},
+        Points: { threshold: 0 },
+        Sprite: {}
+    }
+
+
+    private sphereResults: Array<Intersection> = new Array<Intersection>();
+    private sphereMask: Layers = new Layers();
+    /** 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
+     */
+    public sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit: boolean = true): 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);
+        }
+        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)) {
+            const mesh = obj as Mesh;
+            const geo = mesh.geometry;
+            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: RaycastOptions | null = null): Array<Intersection> {
+        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.
+     */
+    public raycast(options: IRaycastOptions | RaycastOptions | null = null): Array<Intersection> {
+        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)
+            rc.params.Line = { threshold: options.lineThreshold };
+        else rc.params.Line = { threshold: 0 };
+        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 ?? [];
+            }
+            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<Intersection>();
+            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);
+        }
+
+        // console.log(rc)
+        // console.log(targets);
+
+        // shoot
+        results.length = 0;
+        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));
+        }
+        return results;
+    }
+
+    private intersect(raycaster: Raycaster, objects: Object3D[], results: Intersection[], options: IRaycastOptions) {
+        for (const obj of objects) {
+            const testResult = options.testObject?.(obj);
+            if (testResult === false) continue;
+            const checkObject = testResult !== "continue in children";
+            if (checkObject) {
+                raycaster.intersectObject(obj, false, results);
+            }
+
+            if (options.recursive !== false) {
+                this.intersect(raycaster, obj.children, results, options);
+            }
+        }
+        return results;
+    }
+}

package/src/engine/engine_physics.types.ts

@@ -1,44 +1,44 @@
-
-
-export enum PhysicsMaterialCombine {
-  Average = 0,
-  Multiply = 1,
-  Minimum = 2,
-  Maximum = 3,
-}
-
-export type PhysicsMaterial = {
-  bounceCombine?: PhysicsMaterialCombine;
-  bounciness?: number;
-  frictionCombine?: PhysicsMaterialCombine;
-  dynamicFriction?: number;
-  /**@deprecated not used */
-  staticFriction?:number;
-}
-
-export enum CollisionDetectionMode {
-  Discrete = 0,
-  Continuous = 1,
-}
-
-export enum RigidbodyConstraints {
-  None = 0,
-  FreezePositionX = 2,
-  FreezePositionY = 4,
-  FreezePositionZ = 8,
-  FreezePosition = 14,
-  FreezeRotationX = 16,
-  FreezeRotationY = 32,
-  FreezeRotationZ = 64,
-  FreezeRotation = 112,
-  FreezeAll = 126,
-}
-
-
-export enum Axes {
-  None = 0,
-  X = 2,
-  Y = 4,
-  Z = 8,
-  All = ~0,
+
+
+export enum PhysicsMaterialCombine {
+  Average = 0,
+  Multiply = 1,
+  Minimum = 2,
+  Maximum = 3,
+}
+
+export type PhysicsMaterial = {
+  bounceCombine?: PhysicsMaterialCombine;
+  bounciness?: number;
+  frictionCombine?: PhysicsMaterialCombine;
+  dynamicFriction?: number;
+  /**@deprecated not used */
+  staticFriction?:number;
+}
+
+export enum CollisionDetectionMode {
+  Discrete = 0,
+  Continuous = 1,
+}
+
+export enum RigidbodyConstraints {
+  None = 0,
+  FreezePositionX = 2,
+  FreezePositionY = 4,
+  FreezePositionZ = 8,
+  FreezePosition = 14,
+  FreezeRotationX = 16,
+  FreezeRotationY = 32,
+  FreezeRotationZ = 64,
+  FreezeRotation = 112,
+  FreezeAll = 126,
+}
+
+
+export enum Axes {
+  None = 0,
+  X = 2,
+  Y = 4,
+  Z = 8,
+  All = ~0,
 }