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

package/lib/engine/engine_networking_types.d.ts

@@ -1,14 +1,14 @@
-export declare interface IModel {
-    guid: string;
-    dontSave?: boolean;
-}
-export declare enum SendQueue {
-    OnConnection = 0,
-    OnRoomJoin = 1,
-    Queued = 2,
-    Immediate = 3
-}
-export declare interface INetworkConnection {
-    get isConnected(): boolean;
-    send(key: string, data: IModel | object | boolean | null | string | number, queue: SendQueue): unknown;
-}
+export declare interface IModel {
+    guid: string;
+    dontSave?: boolean;
+}
+export declare enum SendQueue {
+    OnConnection = 0,
+    OnRoomJoin = 1,
+    Queued = 2,
+    Immediate = 3
+}
+export declare interface INetworkConnection {
+    get isConnected(): boolean;
+    send(key: string, data: IModel | object | boolean | null | string | number, queue: SendQueue): unknown;
+}

package/lib/engine/engine_networking_types.js

@@ -1,8 +1,8 @@
-export var SendQueue;
-(function (SendQueue) {
-    SendQueue[SendQueue["OnConnection"] = 0] = "OnConnection";
-    SendQueue[SendQueue["OnRoomJoin"] = 1] = "OnRoomJoin";
-    SendQueue[SendQueue["Queued"] = 2] = "Queued";
-    SendQueue[SendQueue["Immediate"] = 3] = "Immediate";
-})(SendQueue || (SendQueue = {}));
+export var SendQueue;
+(function (SendQueue) {
+    SendQueue[SendQueue["OnConnection"] = 0] = "OnConnection";
+    SendQueue[SendQueue["OnRoomJoin"] = 1] = "OnRoomJoin";
+    SendQueue[SendQueue["Queued"] = 2] = "Queued";
+    SendQueue[SendQueue["Immediate"] = 3] = "Immediate";
+})(SendQueue || (SendQueue = {}));
 //# sourceMappingURL=engine_networking_types.js.map

package/lib/engine/engine_networking_utils.d.ts

@@ -1,2 +1,2 @@
-export declare function isLocalNetwork(hostname?: string): boolean;
-export declare function isHostedOnGlitch(): boolean;
+export declare function isLocalNetwork(hostname?: string): boolean;
+export declare function isHostedOnGlitch(): boolean;

package/lib/engine/engine_networking_utils.js

@@ -1,21 +1,21 @@
-const localNetworkResults = new Map();
-export function isLocalNetwork(hostname = globalThis.location?.hostname) {
-    if (localNetworkResults.has(hostname))
-        return localNetworkResults.get(hostname);
-    const isLocalNetwork = /(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|localhost/.test(hostname);
-    localNetworkResults.set(hostname, isLocalNetwork);
-    if (isLocalNetwork === true)
-        return true;
-    return false;
-}
-export function isHostedOnGlitch() {
-    return window.location.hostname.includes("glitch.me");
-}
-// const testUrls = [
-//     "192.254.384.122",
-//     "my-glitch-page.glitch.me",
-//     "a4d35231.my-url.dev"
-// ]
-// for (let url of testUrls)
-//     console.log("Testing url: " + url, isLocalNetwork(url));
+const localNetworkResults = new Map();
+export function isLocalNetwork(hostname = globalThis.location?.hostname) {
+    if (localNetworkResults.has(hostname))
+        return localNetworkResults.get(hostname);
+    const isLocalNetwork = /(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|localhost/.test(hostname);
+    localNetworkResults.set(hostname, isLocalNetwork);
+    if (isLocalNetwork === true)
+        return true;
+    return false;
+}
+export function isHostedOnGlitch() {
+    return window.location.hostname.includes("glitch.me");
+}
+// const testUrls = [
+//     "192.254.384.122",
+//     "my-glitch-page.glitch.me",
+//     "a4d35231.my-url.dev"
+// ]
+// for (let url of testUrls)
+//     console.log("Testing url: " + url, isLocalNetwork(url));
 //# sourceMappingURL=engine_networking_utils.js.map

package/lib/engine/engine_patcher.d.ts

@@ -1,10 +1,10 @@
-export type Prefix = (...args: any[]) => any;
-export type Postfix = (...args: any[]) => any;
-/**
- * Use patcher for patching properties insteadof calling Object.defineProperty individually
- * since this will cause conflicts if multiple patches need to be applied to the same property
- */
-export declare function addPatch<T extends object>(prototype: T, fieldName: string, beforeCallback?: Prefix | null, afterCallback?: Postfix | null): void;
-/** Removes prefix or postfix */
-export declare function removePatch(prototype: object, fieldName: string, prefixOrPostfix: Prefix | Postfix): void;
-export declare const NeedlePatchesKey = "Needle:Patches";
+export type Prefix = (...args: any[]) => any;
+export type Postfix = (...args: any[]) => any;
+/**
+ * Use patcher for patching properties insteadof calling Object.defineProperty individually
+ * since this will cause conflicts if multiple patches need to be applied to the same property
+ */
+export declare function addPatch<T extends object>(prototype: T, fieldName: string, beforeCallback?: Prefix | null, afterCallback?: Postfix | null): void;
+/** Removes prefix or postfix */
+export declare function removePatch(prototype: object, fieldName: string, prefixOrPostfix: Prefix | Postfix): void;
+export declare const NeedlePatchesKey = "Needle:Patches";

package/lib/engine/engine_patcher.js

@@ -1,143 +1,143 @@
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn
-import { getParam } from "./engine_utils.js";
-const debugPatch = getParam("debugpatch");
-/**
- * Use patcher for patching properties insteadof calling Object.defineProperty individually
- * since this will cause conflicts if multiple patches need to be applied to the same property
- */
-export function addPatch(prototype, fieldName, beforeCallback, afterCallback) {
-    const debug = debugPatch === fieldName;
-    // If no callbacks are provided, we don't need to do anything
-    if (!beforeCallback && !afterCallback) {
-        return;
-    }
-    // TODO: we probably want to turn this into a symbol to prevent anyone from overriding it
-    // But when we need to store the symbol per prototype to allow e.g. material disposing to iterate those and dispose all
-    // TODO: making symbols here breaks e.g. progressive textures because they iterate on the property keys
-    const backingField = fieldName + "___needle"; // Symbol(fieldName);// + " (patched)";
-    internalAddPatch(prototype, fieldName, beforeCallback, afterCallback);
-    const desc = Object.getOwnPropertyDescriptor(prototype, fieldName);
-    const existing = prototype[fieldName];
-    if (debug)
-        console.log("Patch", prototype.constructor.name, fieldName, desc, existing);
-    if (desc) {
-        if (debug)
-            console.log("Apply patch with existing descriptor", prototype.constructor.name, fieldName, desc);
-        if (typeof desc.value === "function") {
-            prototype[fieldName] = ensureFunctionWrapped(desc.value, prototype, fieldName);
-        }
-    }
-    else {
-        if (debug)
-            console.log("Create patch with new property", prototype.constructor.name, fieldName, desc);
-        Object.defineProperty(prototype, fieldName, {
-            set: function (value) {
-                if (typeof value === "function") {
-                    // TODO: not sure if this is correct (if the value that is set is a function)
-                    this[backingField] = ensureFunctionWrapped(value, prototype, fieldName);
-                }
-                else {
-                    const prev = this[backingField];
-                    executePrefixes(prototype, fieldName, this, prev, value);
-                    this[backingField] = value;
-                    executePostFixes(prototype, fieldName, this, prev, value);
-                }
-            },
-            get: function () {
-                const value = this[backingField];
-                if (typeof value === "function") {
-                    if (value[backingField]) {
-                        return value[backingField];
-                    }
-                }
-                return value;
-            }
-        });
-    }
-}
-/** Removes prefix or postfix */
-export function removePatch(prototype, fieldName, prefixOrPostfix) {
-    const patches = getPatches(prototype, fieldName);
-    if (patches) {
-        for (let i = patches.length - 1; i >= 0; i--) {
-            const patch = patches[i];
-            // Remove either the prefix or postfix
-            if (patch.prefix === prefixOrPostfix) {
-                patch.prefix = null;
-            }
-            if (patch.postfix === prefixOrPostfix) {
-                patch.postfix = null;
-            }
-            // If the patch is empty, remove it from the list
-            if (!patch.prefix && !patch.postfix) {
-                patches.splice(i, 1);
-            }
-        }
-    }
-}
-const $wrappedFunctionSymbol = Symbol("Needle:Patches:WrappedFunction");
-function ensureFunctionWrapped(originalFunction, prototype, fieldname) {
-    if (originalFunction[$wrappedFunctionSymbol]) {
-        return originalFunction;
-    }
-    const wrappedFunction = function (...args) {
-        executePrefixes(prototype, fieldname, this, ...args);
-        const result = originalFunction.apply(this, args);
-        executePostFixes(prototype, fieldname, this, result, ...args);
-        return result;
-    };
-    wrappedFunction[$wrappedFunctionSymbol] = true;
-    return wrappedFunction;
-}
-export const NeedlePatchesKey = "Needle:Patches";
-function patches() {
-    if (!globalThis[NeedlePatchesKey]) {
-        globalThis[NeedlePatchesKey] = new WeakMap();
-    }
-    return globalThis[NeedlePatchesKey];
-}
-function getPatches(prototype, fieldName) {
-    const patchesMap = patches().get(prototype);
-    if (!patchesMap) {
-        return null;
-    }
-    return patchesMap.get(fieldName);
-    ;
-}
-function internalAddPatch(prototype, fieldName, prefix, postfix) {
-    let patchesMap = patches().get(prototype);
-    if (!patchesMap) {
-        patchesMap = new Map();
-        patches().set(prototype, patchesMap);
-    }
-    let patchList = patchesMap.get(fieldName);
-    if (!patchList) {
-        patchList = [];
-        patchesMap.set(fieldName, patchList);
-    }
-    patchList.push({
-        prefix: prefix,
-        postfix: postfix
-    });
-}
-function executePrefixes(prototype, fieldName, instance, ...args) {
-    if (!instance)
-        return;
-    const patches = getPatches(prototype, fieldName);
-    if (patches) {
-        for (const patchInfo of patches) {
-            patchInfo.prefix?.call(instance, ...args);
-        }
-    }
-}
-function executePostFixes(prototype, fieldName, instance, result, ...args) {
-    if (!instance)
-        return;
-    const patches = getPatches(prototype, fieldName);
-    if (patches) {
-        for (const patchInfo of patches) {
-            patchInfo.postfix?.call(instance, result, ...args);
-        }
-    }
-}
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn
+import { getParam } from "./engine_utils.js";
+const debugPatch = getParam("debugpatch");
+/**
+ * Use patcher for patching properties insteadof calling Object.defineProperty individually
+ * since this will cause conflicts if multiple patches need to be applied to the same property
+ */
+export function addPatch(prototype, fieldName, beforeCallback, afterCallback) {
+    const debug = debugPatch === fieldName;
+    // If no callbacks are provided, we don't need to do anything
+    if (!beforeCallback && !afterCallback) {
+        return;
+    }
+    // TODO: we probably want to turn this into a symbol to prevent anyone from overriding it
+    // But when we need to store the symbol per prototype to allow e.g. material disposing to iterate those and dispose all
+    // TODO: making symbols here breaks e.g. progressive textures because they iterate on the property keys
+    const backingField = fieldName + "___needle"; // Symbol(fieldName);// + " (patched)";
+    internalAddPatch(prototype, fieldName, beforeCallback, afterCallback);
+    const desc = Object.getOwnPropertyDescriptor(prototype, fieldName);
+    const existing = prototype[fieldName];
+    if (debug)
+        console.log("Patch", prototype.constructor.name, fieldName, desc, existing);
+    if (desc) {
+        if (debug)
+            console.log("Apply patch with existing descriptor", prototype.constructor.name, fieldName, desc);
+        if (typeof desc.value === "function") {
+            prototype[fieldName] = ensureFunctionWrapped(desc.value, prototype, fieldName);
+        }
+    }
+    else {
+        if (debug)
+            console.log("Create patch with new property", prototype.constructor.name, fieldName, desc);
+        Object.defineProperty(prototype, fieldName, {
+            set: function (value) {
+                if (typeof value === "function") {
+                    // TODO: not sure if this is correct (if the value that is set is a function)
+                    this[backingField] = ensureFunctionWrapped(value, prototype, fieldName);
+                }
+                else {
+                    const prev = this[backingField];
+                    executePrefixes(prototype, fieldName, this, prev, value);
+                    this[backingField] = value;
+                    executePostFixes(prototype, fieldName, this, prev, value);
+                }
+            },
+            get: function () {
+                const value = this[backingField];
+                if (typeof value === "function") {
+                    if (value[backingField]) {
+                        return value[backingField];
+                    }
+                }
+                return value;
+            }
+        });
+    }
+}
+/** Removes prefix or postfix */
+export function removePatch(prototype, fieldName, prefixOrPostfix) {
+    const patches = getPatches(prototype, fieldName);
+    if (patches) {
+        for (let i = patches.length - 1; i >= 0; i--) {
+            const patch = patches[i];
+            // Remove either the prefix or postfix
+            if (patch.prefix === prefixOrPostfix) {
+                patch.prefix = null;
+            }
+            if (patch.postfix === prefixOrPostfix) {
+                patch.postfix = null;
+            }
+            // If the patch is empty, remove it from the list
+            if (!patch.prefix && !patch.postfix) {
+                patches.splice(i, 1);
+            }
+        }
+    }
+}
+const $wrappedFunctionSymbol = Symbol("Needle:Patches:WrappedFunction");
+function ensureFunctionWrapped(originalFunction, prototype, fieldname) {
+    if (originalFunction[$wrappedFunctionSymbol]) {
+        return originalFunction;
+    }
+    const wrappedFunction = function (...args) {
+        executePrefixes(prototype, fieldname, this, ...args);
+        const result = originalFunction.apply(this, args);
+        executePostFixes(prototype, fieldname, this, result, ...args);
+        return result;
+    };
+    wrappedFunction[$wrappedFunctionSymbol] = true;
+    return wrappedFunction;
+}
+export const NeedlePatchesKey = "Needle:Patches";
+function patches() {
+    if (!globalThis[NeedlePatchesKey]) {
+        globalThis[NeedlePatchesKey] = new WeakMap();
+    }
+    return globalThis[NeedlePatchesKey];
+}
+function getPatches(prototype, fieldName) {
+    const patchesMap = patches().get(prototype);
+    if (!patchesMap) {
+        return null;
+    }
+    return patchesMap.get(fieldName);
+    ;
+}
+function internalAddPatch(prototype, fieldName, prefix, postfix) {
+    let patchesMap = patches().get(prototype);
+    if (!patchesMap) {
+        patchesMap = new Map();
+        patches().set(prototype, patchesMap);
+    }
+    let patchList = patchesMap.get(fieldName);
+    if (!patchList) {
+        patchList = [];
+        patchesMap.set(fieldName, patchList);
+    }
+    patchList.push({
+        prefix: prefix,
+        postfix: postfix
+    });
+}
+function executePrefixes(prototype, fieldName, instance, ...args) {
+    if (!instance)
+        return;
+    const patches = getPatches(prototype, fieldName);
+    if (patches) {
+        for (const patchInfo of patches) {
+            patchInfo.prefix?.call(instance, ...args);
+        }
+    }
+}
+function executePostFixes(prototype, fieldName, instance, result, ...args) {
+    if (!instance)
+        return;
+    const patches = getPatches(prototype, fieldName);
+    if (patches) {
+        for (const patchInfo of patches) {
+            patchInfo.postfix?.call(instance, result, ...args);
+        }
+    }
+}
 //# sourceMappingURL=engine_patcher.js.map

package/lib/engine/engine_physics.d.ts

@@ -1,115 +1,115 @@
-import { Camera, type Intersection, Layers, Object3D, Ray, Raycaster, Vector2, Vector3 } from 'three';
-import { Context } from './engine_setup.js';
-import type { Vec2, Vec3 } from './engine_types.js';
-import type { IPhysicsEngine } from './engine_types.js';
-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 declare class RaycastOptions implements IRaycastOptions {
-    static readonly AllLayers = 4294967295;
-    ray?: Ray;
-    cam?: Camera | null;
-    screenPoint?: Vector2;
-    raycaster?: Raycaster;
-    results?: Array<Intersection>;
-    targets?: Array<Object3D>;
-    recursive?: boolean;
-    minDistance?: number;
-    maxDistance?: number;
-    lineThreshold?: number;
-    layerMask?: Layers | number;
-    ignore?: Object3D[];
-    testObject?: RaycastTestObjectCallback;
-    screenPointFromOffset(ox: number, oy: number): void;
-    /** sets one layer for raycasting (e.g. layer 4, only objects on layer 4 will then be hit) */
-    setLayer(layer: number): void;
-    /** 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): void;
-}
-export declare class SphereIntersection implements Intersection {
-    distance: number;
-    point: Vector3;
-    object: Object3D;
-    constructor(object: Object3D, distance: number, point: Vector3);
-}
-export declare class Physics {
-    /**@deprecated use this.context.physics.engine.raycast */
-    raycastPhysicsFast(origin: Vec2 | Vec3, direction?: Vec3 | undefined, maxDistance?: number, solid?: boolean): {
-        point: Vector3;
-        collider: import("./engine_types.js").ICollider;
-        normal?: Vector3 | undefined;
-    } | null;
-    /**@deprecated use this.context.physics.engine.raycastAndGetNormal */
-    raycastPhysicsFastAndGetNormal(origin: Vec2 | Vec3, direction?: Vec3 | undefined, maxDistance?: number, solid?: boolean): {
-        point: Vector3;
-        collider: import("./engine_types.js").ICollider;
-        normal?: Vector3 | undefined;
-    } | null;
-    /**@deprecated use this.context.physics.engine.sphereOverlap */
-    sphereOverlapPhysics(point: Vector3, radius: number): import("./engine_types.js").SphereOverlapResult[] | null;
-    private readonly context;
-    engine?: IPhysicsEngine;
-    constructor(context: Context);
-    private readonly raycaster;
-    private readonly defaultRaycastOptions;
-    private readonly targetBuffer;
-    private readonly defaultThresholds;
-    private sphereResults;
-    private sphereMask;
-    /** 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
-     */
-    sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit?: boolean): Array<Intersection>;
-    private tempBoundingBox;
-    private onSphereOverlap;
-    raycastFromRay(ray: Ray, options?: RaycastOptions | null): Array<Intersection>;
-    /** 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?: IRaycastOptions | RaycastOptions | null): Array<Intersection>;
-    private intersect;
-}
-export {};
+import { Camera, type Intersection, Layers, Object3D, Ray, Raycaster, Vector2, Vector3 } from 'three';
+import { Context } from './engine_setup.js';
+import type { Vec2, Vec3 } from './engine_types.js';
+import type { IPhysicsEngine } from './engine_types.js';
+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 declare class RaycastOptions implements IRaycastOptions {
+    static readonly AllLayers = 4294967295;
+    ray?: Ray;
+    cam?: Camera | null;
+    screenPoint?: Vector2;
+    raycaster?: Raycaster;
+    results?: Array<Intersection>;
+    targets?: Array<Object3D>;
+    recursive?: boolean;
+    minDistance?: number;
+    maxDistance?: number;
+    lineThreshold?: number;
+    layerMask?: Layers | number;
+    ignore?: Object3D[];
+    testObject?: RaycastTestObjectCallback;
+    screenPointFromOffset(ox: number, oy: number): void;
+    /** sets one layer for raycasting (e.g. layer 4, only objects on layer 4 will then be hit) */
+    setLayer(layer: number): void;
+    /** 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): void;
+}
+export declare class SphereIntersection implements Intersection {
+    distance: number;
+    point: Vector3;
+    object: Object3D;
+    constructor(object: Object3D, distance: number, point: Vector3);
+}
+export declare class Physics {
+    /**@deprecated use this.context.physics.engine.raycast */
+    raycastPhysicsFast(origin: Vec2 | Vec3, direction?: Vec3 | undefined, maxDistance?: number, solid?: boolean): {
+        point: Vector3;
+        collider: import("./engine_types.js").ICollider;
+        normal?: Vector3 | undefined;
+    } | null;
+    /**@deprecated use this.context.physics.engine.raycastAndGetNormal */
+    raycastPhysicsFastAndGetNormal(origin: Vec2 | Vec3, direction?: Vec3 | undefined, maxDistance?: number, solid?: boolean): {
+        point: Vector3;
+        collider: import("./engine_types.js").ICollider;
+        normal?: Vector3 | undefined;
+    } | null;
+    /**@deprecated use this.context.physics.engine.sphereOverlap */
+    sphereOverlapPhysics(point: Vector3, radius: number): import("./engine_types.js").SphereOverlapResult[] | null;
+    private readonly context;
+    engine?: IPhysicsEngine;
+    constructor(context: Context);
+    private readonly raycaster;
+    private readonly defaultRaycastOptions;
+    private readonly targetBuffer;
+    private readonly defaultThresholds;
+    private sphereResults;
+    private sphereMask;
+    /** 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
+     */
+    sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit?: boolean): Array<Intersection>;
+    private tempBoundingBox;
+    private onSphereOverlap;
+    raycastFromRay(ray: Ray, options?: RaycastOptions | null): Array<Intersection>;
+    /** 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?: IRaycastOptions | RaycastOptions | null): Array<Intersection>;
+    private intersect;
+}
+export {};