@needle-tools/engine 3.4.0-alpha → 3.5.1-alpha

package/lib/engine/engine_physics.d.ts

@@ -1,8 +1,7 @@
-import { Camera, Intersection, Layers, Mesh, Object3D, Ray, Raycaster, Vector2, Vector3 } from 'three';
+import { Camera, Intersection, Layers, Object3D, Ray, Raycaster, Vector2, Vector3 } from 'three';
 import { Context } from './engine_setup';
-import { IComponent, ICollider, IRigidbody, Vec3, Vec2 } from './engine_types';
-import RAPIER, { RigidBody } from '@dimforge/rapier3d-compat';
-export type Rapier = typeof RAPIER;
+import { Vec2, Vec3 } from './engine_types';
+import { IPhysicsEngine } from './engine_types';
 export declare class RaycastOptions {
     ray: Ray | undefined;
     cam: Camera | undefined | null;
@@ -30,12 +29,24 @@ export declare class SphereIntersection implements Intersection {
     object: Object3D;
     constructor(object: Object3D, distance: number, point: Vector3);
 }
-export declare class SphereOverlapResult {
-    object: Object3D;
-    collider: ICollider;
-    constructor(object: Object3D, collider: ICollider);
-}
 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").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").ICollider;
+        normal?: Vector3 | undefined;
+    } | null;
+    /**@deprecated use this.context.physics.engine.sphereOverlap */
+    sphereOverlapPhysics(point: Vector3, radius: number): import("./engine_types").SphereOverlapResult[] | null;
+    private readonly context;
+    engine?: IPhysicsEngine;
+    constructor(context: Context);
     private readonly raycaster;
     private readonly defaultRaycastOptions;
     private readonly targetBuffer;
@@ -59,88 +70,4 @@ export declare class Physics {
      * @param options raycast options. If null, default options will be used.
      */
     raycast(options?: RaycastOptions | null): Array<Intersection>;
-    private rapierRay;
-    private raycastVectorsBuffer;
-    /** Fast raycast against physics colliders
-     * @param origin ray origin in screen or worldspace
-     * @param direction ray direction in worldspace
-     * @param maxDistance max distance to raycast
-     * @param solid if true it will also hit the collider if origin is already inside it
-     */
-    raycastPhysicsFast(origin: Vec2 | Vec3, direction?: Vec3 | undefined, maxDistance?: number, solid?: boolean): null | {
-        point: Vector3;
-        collider: ICollider;
-    };
-    raycastPhysicsFastAndGetNormal(origin: Vec2 | Vec3, direction?: Vec3 | undefined, maxDistance?: number, solid?: boolean): null | {
-        point: Vector3;
-        normal: Vector3;
-        collider: ICollider;
-    };
-    private getPhysicsRay;
-    private rapierSphere;
-    private rapierColliderArray;
-    private readonly rapierIdentityRotation;
-    private readonly rapierForwardVector;
-    /** Precice sphere overlap detection using rapier against colliders
-     * @param point center of the sphere in worldspace
-     * @param radius radius of the sphere
-     * @returns array of colliders that overlap with the sphere. Note: they currently only contain the collider and the gameobject
-     */
-    sphereOverlapPhysics(point: Vector3, radius: number): Array<SphereOverlapResult>;
-    enabled: boolean;
-    private _tempPosition;
-    private _tempQuaternion;
-    private _tempScale;
-    private _tempMatrix;
-    private static _didLoadPhysicsEngine;
-    private _isUpdatingPhysicsWorld;
-    get isUpdating(): boolean;
-    private context;
-    private world?;
-    private _hasCreatedWorld;
-    private eventQueue?;
-    private collisionHandler?;
-    private objects;
-    private bodies;
-    private _meshCache;
-    constructor(context: Context);
-    createWorld(): Promise<void>;
-    private _gravity;
-    get gravity(): Vec3;
-    set gravity(value: Vec3);
-    clearCaches(): void;
-    addBoxCollider(collider: ICollider, center: Vector3, size: Vector3): void;
-    addSphereCollider(collider: ICollider, center: Vector3, radius: number): void;
-    addCapsuleCollider(collider: ICollider, center: Vector3, height: number, radius: number): void;
-    addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean, scale: Vector3): void;
-    private createCollider;
-    private getRigidbody;
-    removeBody(obj: IComponent): void;
-    updateBody(comp: ICollider | IRigidbody, translation: boolean, rotation: boolean): void;
-    updateProperties(rigidbody: IRigidbody): void;
-    internal_getRigidbody(rb: IRigidbody): RigidBody | null;
-    private internalUpdateProperties;
-    private lines?;
-    step(dt?: number): void;
-    private updateDebugRendering;
-    postStep(): void;
-    /** sync rendered objects with physics world (except for colliders without rigidbody) */
-    private syncObjects;
-    private syncPhysicsBody;
-    private static _matricesBuffer;
-    private getRigidbodyRelativeMatrix;
-    private static centerConnectionPos;
-    private static centerConnectionRot;
-    addFixedJoint(body1: IRigidbody, body2: IRigidbody): void;
-    /** The joint prevents any relative movement between two rigid-bodies, except for relative rotations along one axis. This is typically used to simulate wheels, fans, etc. They are characterized by one local anchor as well as one local axis on each rigid-body. */
-    addHingeJoint(body1: IRigidbody, body2: IRigidbody, anchor: {
-        x: number;
-        y: number;
-        z: number;
-    }, axis: {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
-    private calculateJointRelativeMatrices;
 }