@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Physics/physicsImpostor.d.ts

@@ -0,0 +1,390 @@
+/**
+ * Represents a physics imposter
+ * @see https://doc.babylonjs.com/how_to/using_the_physics_engine
+ */
+export class PhysicsImpostor {
+    /**
+     * Initializes the physics imposter
+     * @param object The physics-enabled object used as the physics imposter
+     * @param type The type of the physics imposter. Types are available as static members of this class.
+     * @param _options The options for the physics imposter
+     * @param _scene The Babylon scene
+     */
+    constructor(object: any, type: any, _options: {
+        mass: number;
+    } | undefined, _scene: any);
+    object: any;
+    type: any;
+    _options: {
+        mass: number;
+    };
+    _scene: any;
+    /** @internal */
+    _pluginData: {};
+    _bodyUpdateRequired: boolean;
+    _onBeforePhysicsStepCallbacks: any[];
+    _onAfterPhysicsStepCallbacks: any[];
+    /** @internal */
+    _onPhysicsCollideCallbacks: any[];
+    _deltaPosition: Vector3;
+    _isDisposed: boolean;
+    /**
+     * @internal
+     */
+    soft: boolean;
+    /**
+     * @internal
+     */
+    segments: number;
+    _tmpQuat: Quaternion;
+    _tmpQuat2: Quaternion;
+    /**
+     * this function is executed by the physics engine.
+     */
+    beforeStep: () => void;
+    /**
+     * this function is executed by the physics engine
+     */
+    afterStep: () => void;
+    /**
+     * Legacy collision detection event support
+     */
+    onCollideEvent: any;
+    /**
+     * event and body object due to cannon's event-based architecture.
+     * @param e
+     * @param e.body
+     * @param e.point
+     * @param e.distance
+     * @param e.impulse
+     * @param e.normal
+     */
+    onCollide: (e: any) => void;
+    _physicsEngine: any;
+    _joints: any[] | undefined;
+    /**
+     * Specifies if the physics imposter is disposed
+     */
+    get isDisposed(): boolean;
+    set mass(arg: any);
+    /**
+     * Gets the mass of the physics imposter
+     */
+    get mass(): any;
+    /**
+     * Sets the coefficient of friction
+     */
+    set friction(arg: any);
+    /**
+     * Gets the coefficient of friction
+     */
+    get friction(): any;
+    /**
+     * Sets the coefficient of restitution
+     */
+    set restitution(arg: any);
+    /**
+     * Gets the coefficient of restitution
+     */
+    get restitution(): any;
+    /**
+     * Sets the pressure of a soft body; only supported by the AmmoJSPlugin
+     */
+    set pressure(arg: any);
+    /**
+     * Gets the pressure of a soft body; only supported by the AmmoJSPlugin
+     */
+    get pressure(): any;
+    /**
+     * Sets the stiffness of a soft body; only supported by the AmmoJSPlugin
+     */
+    set stiffness(arg: any);
+    /**
+     * Gets the stiffness of a soft body; only supported by the AmmoJSPlugin
+     */
+    get stiffness(): any;
+    /**
+     * Sets the velocityIterations of a soft body; only supported by the AmmoJSPlugin
+     */
+    set velocityIterations(arg: any);
+    /**
+     * Gets the velocityIterations of a soft body; only supported by the AmmoJSPlugin
+     */
+    get velocityIterations(): any;
+    /**
+     * Sets the positionIterations of a soft body; only supported by the AmmoJSPlugin
+     */
+    set positionIterations(arg: any);
+    /**
+     * Gets the positionIterations of a soft body; only supported by the AmmoJSPlugin
+     */
+    get positionIterations(): any;
+    /**
+     * This function will completely initialize this impostor.
+     * It will create a new body - but only if this mesh has no parent.
+     * If it has, this impostor will not be used other than to define the impostor
+     * of the child mesh.
+     * @internal
+     */
+    _init(): void;
+    /**
+     * Set the physics body. Used mainly by the physics engine/plugin
+     */
+    set physicsBody(arg: any);
+    /**
+     * Gets the body that holds this impostor. Either its own, or its parent.
+     */
+    get physicsBody(): any;
+    _parent: any;
+    _getPhysicsParent(): any;
+    /**
+     * Should a new body be generated.
+     * @returns boolean specifying if body initialization is required
+     */
+    isBodyInitRequired(): boolean;
+    /**
+     * Sets the updated scaling
+     */
+    setScalingUpdated(): void;
+    /**
+     * Force a regeneration of this or the parent's impostor's body.
+     * Use with caution - This will remove all previously-instantiated joints.
+     */
+    forceUpdate(): void;
+    /**
+     * Sets the parent of the physics imposter
+     */
+    set parent(arg: any);
+    /**
+     * Get the parent of the physics imposter
+     * @returns Physics imposter or null
+     */
+    get parent(): any;
+    _physicsBody: any;
+    /**
+     * Resets the update flags
+     */
+    resetUpdateFlags(): void;
+    /**
+     * Gets the object extents
+     * @returns the object extents
+     */
+    getObjectExtents(): any;
+    /**
+     * Gets the object center
+     * @returns The object center
+     */
+    getObjectCenter(): any;
+    /**
+     * Get a specific parameter from the options parameters
+     * @param paramName The object parameter name
+     * @returns The object parameter
+     */
+    getParam(paramName: any): any;
+    /**
+     * Sets a specific parameter in the options given to the physics plugin
+     * @param paramName The parameter name
+     * @param value The value of the parameter
+     */
+    setParam(paramName: any, value: any): void;
+    /**
+     * Specifically change the body's mass. Won't recreate the physics body object
+     * @param mass The mass of the physics imposter
+     */
+    setMass(mass: any): void;
+    /**
+     * Gets the linear velocity
+     * @returns  linear velocity or null
+     */
+    getLinearVelocity(): any;
+    /**
+     * Sets the linear velocity
+     * @param velocity  linear velocity or null
+     */
+    setLinearVelocity(velocity: any): void;
+    /**
+     * Gets the angular velocity
+     * @returns angular velocity or null
+     */
+    getAngularVelocity(): any;
+    /**
+     * Sets the angular velocity
+     * @param velocity The velocity or null
+     */
+    setAngularVelocity(velocity: any): void;
+    /**
+     * Execute a function with the physics plugin native code
+     * Provide a function the will have two variables - the world object and the physics body object
+     * @param func The function to execute with the physics plugin native code
+     */
+    executeNativeFunction(func: any): void;
+    /**
+     * Register a function that will be executed before the physics world is stepping forward
+     * @param func The function to execute before the physics world is stepped forward
+     */
+    registerBeforePhysicsStep(func: any): void;
+    /**
+     * Unregister a function that will be executed before the physics world is stepping forward
+     * @param func The function to execute before the physics world is stepped forward
+     */
+    unregisterBeforePhysicsStep(func: any): void;
+    /**
+     * Register a function that will be executed after the physics step
+     * @param func The function to execute after physics step
+     */
+    registerAfterPhysicsStep(func: any): void;
+    /**
+     * Unregisters a function that will be executed after the physics step
+     * @param func The function to execute after physics step
+     */
+    unregisterAfterPhysicsStep(func: any): void;
+    /**
+     * register a function that will be executed when this impostor collides against a different body
+     * @param collideAgainst Physics imposter, or array of physics imposters to collide against
+     * @param func Callback that is executed on collision
+     */
+    registerOnPhysicsCollide(collideAgainst: any, func: any): void;
+    /**
+     * Unregisters the physics imposter's collision callback
+     * @param collideAgainst The physics object to collide against
+     * @param func Callback to execute on collision
+     */
+    unregisterOnPhysicsCollide(collideAgainst: any, func: any): void;
+    /**
+     * Get the parent rotation
+     * @returns The parent rotation
+     */
+    getParentsRotation(): Quaternion;
+    /**
+     * Apply a force
+     * @param force The force to apply
+     * @param contactPoint The contact point for the force
+     * @returns The physics imposter
+     */
+    applyForce(force: any, contactPoint: any): PhysicsImpostor;
+    /**
+     * Apply an impulse
+     * @param force The impulse force
+     * @param contactPoint The contact point for the impulse force
+     * @returns The physics imposter
+     */
+    applyImpulse(force: any, contactPoint: any): PhysicsImpostor;
+    /**
+     * A help function to create a joint
+     * @param otherImpostor A physics imposter used to create a joint
+     * @param jointType The type of joint
+     * @param jointData The data for the joint
+     * @returns The physics imposter
+     */
+    createJoint(otherImpostor: any, jointType: any, jointData: any): PhysicsImpostor;
+    /**
+     * Add a joint to this impostor with a different impostor
+     * @param otherImpostor A physics imposter used to add a joint
+     * @param joint The joint to add
+     * @returns The physics imposter
+     */
+    addJoint(otherImpostor: any, joint: any): PhysicsImpostor;
+    /**
+     * Add an anchor to a cloth impostor
+     * @param otherImpostor rigid impostor to anchor to
+     * @param width ratio across width from 0 to 1
+     * @param height ratio up height from 0 to 1
+     * @param influence the elasticity between cloth impostor and anchor from 0, very stretchy to 1, little stretch
+     * @param noCollisionBetweenLinkedBodies when true collisions between cloth impostor and anchor are ignored; default false
+     * @returns impostor the soft imposter
+     */
+    addAnchor(otherImpostor: any, width: any, height: any, influence: any, noCollisionBetweenLinkedBodies: any): PhysicsImpostor;
+    /**
+     * Add a hook to a rope impostor
+     * @param otherImpostor rigid impostor to anchor to
+     * @param length ratio across rope from 0 to 1
+     * @param influence the elasticity between rope impostor and anchor from 0, very stretchy to 1, little stretch
+     * @param noCollisionBetweenLinkedBodies when true collisions between soft impostor and anchor are ignored; default false
+     * @returns impostor the rope imposter
+     */
+    addHook(otherImpostor: any, length: any, influence: any, noCollisionBetweenLinkedBodies: any): PhysicsImpostor;
+    /**
+     * Will keep this body still, in a sleep mode.
+     * @returns the physics imposter
+     */
+    sleep(): PhysicsImpostor;
+    /**
+     * Wake the body up.
+     * @returns The physics imposter
+     */
+    wakeUp(): PhysicsImpostor;
+    /**
+     * Clones the physics imposter
+     * @param newObject The physics imposter clones to this physics-enabled object
+     * @returns A nullable physics imposter
+     */
+    clone(newObject: any): PhysicsImpostor | null;
+    /**
+     * Disposes the physics imposter
+     */
+    dispose(): void;
+    /**
+     * Sets the delta position
+     * @param position The delta position amount
+     */
+    setDeltaPosition(position: any): void;
+    /**
+     * Sets the delta rotation
+     * @param rotation The delta rotation amount
+     */
+    setDeltaRotation(rotation: any): void;
+    _deltaRotation: Quaternion | undefined;
+    _deltaRotationConjugated: Quaternion | undefined;
+    /**
+     * Gets the box size of the physics imposter and stores the result in the input parameter
+     * @param result Stores the box size
+     * @returns The physics imposter
+     */
+    getBoxSizeToRef(result: any): PhysicsImpostor;
+    /**
+     * Gets the radius of the physics imposter
+     * @returns Radius of the physics imposter
+     */
+    getRadius(): any;
+    /**
+     * Sync a bone with this impostor
+     * @param bone The bone to sync to the impostor.
+     * @param boneMesh The mesh that the bone is influencing.
+     * @param jointPivot The pivot of the joint / bone in local space.
+     * @param distToJoint Optional distance from the impostor to the joint.
+     * @param adjustRotation Optional quaternion for adjusting the local rotation of the bone.
+     */
+    syncBoneWithImpostor(bone: any, boneMesh: any, jointPivot: any, distToJoint: any, adjustRotation: any): void;
+    /**
+     * Sync impostor to a bone
+     * @param bone The bone that the impostor will be synced to.
+     * @param boneMesh The mesh that the bone is influencing.
+     * @param jointPivot The pivot of the joint / bone in local space.
+     * @param distToJoint Optional distance from the impostor to the joint.
+     * @param adjustRotation Optional quaternion for adjusting the local rotation of the bone.
+     * @param boneAxis Optional vector3 axis the bone is aligned with
+     */
+    syncImpostorWithBone(bone: any, boneMesh: any, jointPivot: any, distToJoint: any, adjustRotation: any, boneAxis: any): void;
+}
+export namespace PhysicsImpostor {
+    const DEFAULT_OBJECT_SIZE: Vector3;
+    const IDENTITY_QUATERNION: Quaternion;
+    const _TmpVecs: Vector3[];
+    const _TmpQuat: Quaternion;
+    const NoImpostor: number;
+    const SphereImpostor: number;
+    const BoxImpostor: number;
+    const PlaneImpostor: number;
+    const MeshImpostor: number;
+    const CapsuleImpostor: number;
+    const CylinderImpostor: number;
+    const ParticleImpostor: number;
+    const HeightmapImpostor: number;
+    const ConvexHullImpostor: number;
+    const CustomImpostor: number;
+    const RopeImpostor: number;
+    const ClothImpostor: number;
+    const SoftbodyImpostor: number;
+}
+import { Vector3 } from "../Maths/math.vector.js";
+import { Quaternion } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Physics/physicsJoint.d.ts

@@ -0,0 +1,131 @@
+/**
+ * This is a holder class for the physics joint created by the physics plugin
+ * It holds a set of functions to control the underlying joint
+ * @see https://doc.babylonjs.com/how_to/using_the_physics_engine
+ */
+export class PhysicsJoint {
+    /**
+     * Initializes the physics joint
+     * @param type The type of the physics joint
+     * @param jointData The data for the physics joint
+     */
+    constructor(type: any, jointData: any);
+    type: any;
+    jointData: any;
+    /**
+     * Sets the physics joint
+     */
+    set physicsJoint(arg: any);
+    /**
+     * Gets the physics joint
+     */
+    get physicsJoint(): any;
+    _physicsJoint: any;
+    /**
+     * Sets the physics plugin
+     */
+    set physicsPlugin(arg: any);
+    _physicsPlugin: any;
+    /**
+     * Execute a function that is physics-plugin specific.
+     * @param {Function} func the function that will be executed.
+     *                        It accepts two parameters: the physics world and the physics joint
+     */
+    executeNativeFunction(func: Function): void;
+}
+export namespace PhysicsJoint {
+    export const DistanceJoint: number;
+    export const HingeJoint: number;
+    export const BallAndSocketJoint: number;
+    export const WheelJoint: number;
+    export const SliderJoint: number;
+    export const PrismaticJoint: number;
+    export const UniversalJoint: number;
+    import Hinge2Joint = WheelJoint;
+    export { Hinge2Joint };
+    export const PointToPointJoint: number;
+    export const SpringJoint: number;
+    export const LockJoint: number;
+}
+/**
+ * A class representing a physics distance joint
+ * @see https://doc.babylonjs.com/how_to/using_the_physics_engine
+ */
+export class DistanceJoint extends PhysicsJoint {
+    /**
+     *
+     * @param jointData The data for the Distance-Joint
+     */
+    constructor(jointData: any);
+    /**
+     * Update the predefined distance.
+     * @param maxDistance The maximum preferred distance
+     * @param minDistance The minimum preferred distance
+     */
+    updateDistance(maxDistance: any, minDistance: any): void;
+}
+/**
+ * Represents a Motor-Enabled Joint
+ * @see https://doc.babylonjs.com/how_to/using_the_physics_engine
+ */
+export class MotorEnabledJoint extends PhysicsJoint {
+    /**
+     * Set the motor values.
+     * Attention, this function is plugin specific. Engines won't react 100% the same.
+     * @param force the force to apply
+     * @param maxForce max force for this motor.
+     */
+    setMotor(force: any, maxForce: any): void;
+    /**
+     * Set the motor's limits.
+     * Attention, this function is plugin specific. Engines won't react 100% the same.
+     * @param upperLimit The upper limit of the motor
+     * @param lowerLimit The lower limit of the motor
+     */
+    setLimit(upperLimit: any, lowerLimit: any): void;
+}
+/**
+ * This class represents a single physics Hinge-Joint
+ * @see https://doc.babylonjs.com/how_to/using_the_physics_engine
+ */
+export class HingeJoint extends MotorEnabledJoint {
+    /**
+     * Initializes the Hinge-Joint
+     * @param jointData The joint data for the Hinge-Joint
+     */
+    constructor(jointData: any);
+    /**
+     * Set the motor values.
+     * Attention, this function is plugin specific. Engines won't react 100% the same.
+     * @param {number} force the force to apply
+     * @param {number} maxForce max force for this motor.
+     */
+    setMotor(force: number, maxForce: number): void;
+}
+/**
+ * This class represents a dual hinge physics joint (same as wheel joint)
+ * @see https://doc.babylonjs.com/how_to/using_the_physics_engine
+ */
+export class Hinge2Joint extends MotorEnabledJoint {
+    /**
+     * Initializes the Hinge2-Joint
+     * @param jointData The joint data for the Hinge2-Joint
+     */
+    constructor(jointData: any);
+    /**
+     * Set the motor values.
+     * Attention, this function is plugin specific. Engines won't react 100% the same.
+     * @param targetSpeed the speed the motor is to reach
+     * @param maxForce max force for this motor.
+     * @param motorIndex motor's index, 0 or 1.
+     */
+    setMotor(targetSpeed: any, maxForce: any, motorIndex?: number): void;
+    /**
+     * Set the motor limits.
+     * Attention, this function is plugin specific. Engines won't react 100% the same.
+     * @param upperLimit the upper limit
+     * @param lowerLimit lower limit
+     * @param motorIndex the motor's index, 0 or 1.
+     */
+    setLimit(upperLimit: any, lowerLimit: any, motorIndex?: number): void;
+}

package/dist/types/node_modules/@babylonjs/core/Physics/physicsRaycastResult.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Holds the data for the raycast result
+ * @see https://doc.babylonjs.com/how_to/using_the_physics_engine
+ */
+export class PhysicsRaycastResult {
+    _hasHit: boolean;
+    _hitDistance: number;
+    _hitNormalWorld: Vector3;
+    _hitPointWorld: Vector3;
+    _rayFromWorld: Vector3;
+    _rayToWorld: Vector3;
+    /**
+     * Gets if there was a hit
+     */
+    get hasHit(): boolean;
+    /**
+     * Gets the distance from the hit
+     */
+    get hitDistance(): number;
+    /**
+     * Gets the hit normal/direction in the world
+     */
+    get hitNormalWorld(): Vector3;
+    /**
+     * Gets the hit point in the world
+     */
+    get hitPointWorld(): Vector3;
+    /**
+     * Gets the ray "start point" of the ray in the world
+     */
+    get rayFromWorld(): Vector3;
+    /**
+     * Gets the ray "end point" of the ray in the world
+     */
+    get rayToWorld(): Vector3;
+    /**
+     * Sets the hit data (normal & point in world space)
+     * @param hitNormalWorld defines the normal in world space
+     * @param hitPointWorld defines the point in world space
+     */
+    setHitData(hitNormalWorld: any, hitPointWorld: any): void;
+    /**
+     * Sets the distance from the start point to the hit point
+     * @param distance
+     */
+    setHitDistance(distance: any): void;
+    /**
+     * Calculates the distance manually
+     */
+    calculateHitDistance(): void;
+    /**
+     * Resets all the values to default
+     * @param from The from point on world space
+     * @param to The to point on world space
+     */
+    reset(from?: Vector3, to?: Vector3): void;
+}
+import { Vector3 } from "../Maths/math.vector.js";