@galacean/engine-physics-lite 1.6.8 → 1.6.9

package/types/LitePhysicsScene.d.ts

@@ -0,0 +1,106 @@
+import { Quaternion, Ray, Vector3 } from "@galacean/engine";
+import { ICharacterController, ICollision, IPhysicsScene } from "@galacean/engine-design";
+import { LiteCollider } from "./LiteCollider";
+import { LitePhysics } from "./LitePhysics";
+/**
+ * A manager is a collection of colliders and constraints which can interact.
+ */
+export declare class LitePhysicsScene implements IPhysicsScene {
+    private static _tempSphere;
+    private static _tempBox;
+    private static _currentHit;
+    private static _hitResult;
+    private readonly _onContactEnter?;
+    private readonly _onContactExit?;
+    private readonly _onContactStay?;
+    private readonly _onTriggerEnter?;
+    private readonly _onTriggerExit?;
+    private readonly _onTriggerStay?;
+    private _staticColliders;
+    private _dynamicColliders;
+    private _sphere;
+    private _box;
+    private _currentEvents;
+    private _eventMap;
+    private _eventPool;
+    private _physics;
+    constructor(physics: LitePhysics, onContactEnter?: (collision: ICollision) => void, onContactExit?: (collision: ICollision) => void, onContactStay?: (collision: ICollision) => void, onTriggerEnter?: (obj1: number, obj2: number) => void, onTriggerExit?: (obj1: number, obj2: number) => void, onTriggerStay?: (obj1: number, obj2: number) => void);
+    overlapBox(center: Vector3, orientation: Quaternion, halfExtents: Vector3, onOverlap: (obj: number) => boolean, outHitResult?: (shapeUniqueID: number) => void): boolean;
+    overlapSphere(center: Vector3, radius: number, onOverlap: (obj: number) => boolean, outHitResult?: (shapeUniqueID: number) => void): boolean;
+    overlapCapsule(center: Vector3, radius: number, height: number, orientation: Quaternion, onOverlap: (obj: number) => boolean, outHitResult?: (shapeUniqueID: number) => void): boolean;
+    /**
+     * {@inheritDoc IPhysicsScene.setGravity }
+     */
+    setGravity(value: Vector3): void;
+    /**
+     * {@inheritDoc IPhysicsScene.addCollider }
+     */
+    addCollider(actor: LiteCollider): void;
+    /**
+     * {@inheritDoc IPhysicsScene.removeCollider }
+     */
+    removeCollider(collider: LiteCollider): void;
+    /**
+     * {@inheritDoc IPhysicsScene.update }
+     */
+    update(deltaTime: number): void;
+    /**
+     * {@inheritDoc IPhysicsScene.raycast }
+     */
+    raycast(ray: Ray, distance: number, onRaycast: (obj: number) => boolean, hit?: (shapeUniqueID: number, distance: number, position: Vector3, normal: Vector3) => void): boolean;
+    /**
+     * {@inheritDoc IPhysicsScene.addCharacterController }
+     */
+    addCharacterController(characterController: ICharacterController): void;
+    /**
+     * {@inheritDoc IPhysicsScene.removeCharacterController }
+     */
+    removeCharacterController(characterController: ICharacterController): void;
+    /**
+     * {@inheritDoc IPhysicsScene.boxCast }
+     */
+    boxCast(center: Vector3, orientation: Quaternion, halfExtents: Vector3, direction: Vector3, distance: number, onSweep: (obj: number) => boolean, outHitResult?: (shapeUniqueID: number, distance: number, position: Vector3, normal: Vector3) => void): boolean;
+    /**
+     * {@inheritDoc IPhysicsScene.sphereCast }
+     */
+    sphereCast(center: Vector3, radius: number, direction: Vector3, distance: number, onSweep: (obj: number) => boolean, outHitResult?: (shapeUniqueID: number, distance: number, position: Vector3, normal: Vector3) => void): boolean;
+    /**
+     * {@inheritDoc IPhysicsScene.capsuleCast }
+     */
+    capsuleCast(center: Vector3, radius: number, height: number, orientation: Quaternion, direction: Vector3, distance: number, onSweep: (obj: number) => boolean, outHitResult?: (shapeUniqueID: number, distance: number, position: Vector3, normal: Vector3) => void): boolean;
+    /**
+     * {@inheritDoc IPhysicsScene.overlapBoxAll }
+     */
+    overlapBoxAll(center: Vector3, orientation: Quaternion, halfExtents: Vector3, onOverlap: (obj: number) => boolean): number[];
+    /**
+     * {@inheritDoc IPhysicsScene.overlapSphereAll }
+     */
+    overlapSphereAll(center: Vector3, radius: number, onOverlap: (obj: number) => boolean): number[];
+    /**
+     * {@inheritDoc IPhysicsScene.overlapCapsuleAll }
+     */
+    overlapCapsuleAll(center: Vector3, radius: number, height: number, orientation: Quaternion, onOverlap: (obj: number) => boolean): number[];
+    /**
+     * {@inheritDoc IPhysicsScene.destroy }
+     */
+    destroy(): void;
+    /**
+     * Calculate the bounding box in world space from boxCollider.
+     * @param boxCollider - The boxCollider to calculate
+     * @param out - The calculated boundingBox
+     */
+    private static _updateWorldBox;
+    /**
+     * Get the sphere info of the given sphere collider in world space.
+     * @param sphereCollider - The given sphere collider
+     * @param out - The calculated boundingSphere
+     */
+    private static _upWorldSphere;
+    private _getTrigger;
+    private _collisionDetection;
+    private _fireEvent;
+    private _boxCollision;
+    private _sphereCollision;
+    private _raycast;
+    private _checkColliderCollide;
+}

package/types/LiteStaticCollider.d.ts

@@ -0,0 +1,16 @@
+import { IStaticCollider } from "@galacean/engine-design";
+import { LiteCollider } from "./LiteCollider";
+import { Quaternion, Vector3 } from "@galacean/engine";
+import { LitePhysics } from "./LitePhysics";
+/**
+ * A static collider component that will not move.
+ * @remarks Mostly used for object which always stays at the same place and never moves around.
+ */
+export declare class LiteStaticCollider extends LiteCollider implements IStaticCollider {
+    /**
+     * Initialize static actor.
+     * @param position - The global position
+     * @param rotation - The global rotation
+     */
+    constructor(litePhysics: LitePhysics, position: Vector3, rotation: Quaternion);
+}

package/types/LiteTransform.d.ts

@@ -0,0 +1,118 @@
+import { Matrix, Quaternion, Vector3 } from "@galacean/engine";
+import { LiteCollider } from "./LiteCollider";
+import { LiteUpdateFlag } from "./LiteUpdateFlag";
+import { LiteColliderShape } from "./shape/LiteColliderShape";
+/**
+ * Used to implement transformation related functions.
+ */
+export declare class LiteTransform {
+    private static _tempQuat0;
+    private static _tempMat42;
+    private _position;
+    private _rotation;
+    private _rotationQuaternion;
+    private _scale;
+    private _worldRotationQuaternion;
+    private _localMatrix;
+    private _worldMatrix;
+    private _updateFlagManager;
+    private _isParentDirty;
+    private _parentTransformCache;
+    private _dirtyFlag;
+    private _owner;
+    set owner(value: LiteColliderShape | LiteCollider);
+    /**
+     * Local position.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get position(): Vector3;
+    set position(value: Vector3);
+    /**
+     * Local rotation, defining the rotation by using a unit quaternion.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get rotationQuaternion(): Quaternion;
+    set rotationQuaternion(value: Quaternion);
+    /**
+     * World rotation, defining the rotation by using a unit quaternion.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get worldRotationQuaternion(): Quaternion;
+    set worldRotationQuaternion(value: Quaternion);
+    /**
+     * Local scaling.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get scale(): Vector3;
+    set scale(value: Vector3);
+    /**
+     * Local matrix.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get localMatrix(): Matrix;
+    set localMatrix(value: Matrix);
+    /**
+     * World matrix.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get worldMatrix(): Matrix;
+    set worldMatrix(value: Matrix);
+    /**
+     * Set local position by X, Y, Z value.
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param z - Z coordinate
+     */
+    setPosition(x: number, y: number, z: number): void;
+    /**
+     * Set local rotation by the X, Y, Z, and W components of the quaternion.
+     * @param x - X component of quaternion
+     * @param y - Y component of quaternion
+     * @param z - Z component of quaternion
+     * @param w - W component of quaternion
+     */
+    setRotationQuaternion(x: number, y: number, z: number, w: number): void;
+    /**
+     * Set local scaling by scaling values along X, Y, Z axis.
+     * @param x - Scaling along X axis
+     * @param y - Scaling along Y axis
+     * @param z - Scaling along Z axis
+     */
+    setScale(x: number, y: number, z: number): void;
+    /**
+     * Register world transform change flag.
+     * @returns Change flag
+     */
+    registerWorldChangeFlag(): LiteUpdateFlag;
+    /**
+     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
+     */
+    private _updateWorldPositionFlag;
+    /**
+     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+     * Get worldRotationQuaternion: Will trigger the world rotation (in quaternion) update of itself and all parent entities.
+     * Get worldRotation: Will trigger the world rotation(in euler and quaternion) update of itself and world rotation(in quaternion) update of all parent entities.
+     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
+     */
+    private _updateWorldRotationFlag;
+    /**
+     * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+     * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+     * Get worldScale: Will trigger the scaling update of itself and all parent entities.
+     * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix) to be false.
+     */
+    private _updateWorldScaleFlag;
+    /**
+     * Update all world transform property dirty flag, the principle is the same as above.
+     */
+    private _updateAllWorldFlag;
+    private _getParentTransform;
+    private _isContainDirtyFlags;
+    private _isContainDirtyFlag;
+    private _setDirtyFlagTrue;
+    private _setDirtyFlagFalse;
+    private _worldAssociatedChange;
+}

package/types/LiteUpdateFlag.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Used to update tags.
+ */
+export declare class LiteUpdateFlag {
+    private _flags;
+    /** Flag. */
+    flag: boolean;
+    constructor(_flags?: LiteUpdateFlag[]);
+    /**
+     * Destroy.
+     */
+    destroy(): void;
+}

package/types/LiteUpdateFlagManager.d.ts

@@ -0,0 +1 @@
+export {};

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export { LitePhysics } from "./LitePhysics";
+export declare const version = "__buildVersion";

package/types/shape/LiteBoxColliderShape.d.ts

@@ -0,0 +1,38 @@
+import { Vector3, Vector4 } from "@galacean/engine";
+import { IBoxColliderShape } from "@galacean/engine-design";
+import { LitePhysicsMaterial } from "../LitePhysicsMaterial";
+import { LiteColliderShape } from "./LiteColliderShape";
+/**
+ * Box collider shape in Lite.
+ */
+export declare class LiteBoxColliderShape extends LiteColliderShape implements IBoxColliderShape {
+    private static _tempBox;
+    private static _tempMatrix;
+    private static _tempInvMatrix;
+    private _halfSize;
+    private _sizeScale;
+    /**
+     * Init Box Shape.
+     * @param uniqueID - UniqueID mark Shape.
+     * @param size - Size of Shape.
+     * @param material - Material of PhysXCollider.
+     */
+    constructor(uniqueID: number, size: Vector3, material: LitePhysicsMaterial);
+    /**
+     * {@inheritDoc IColliderShape.setPosition }
+     */
+    setPosition(position: Vector3): void;
+    /**
+     * {@inheritDoc IColliderShape.setWorldScale }
+     */
+    setWorldScale(scale: Vector3): void;
+    /**
+     * {@inheritDoc IBoxColliderShape.setSize }
+     */
+    setSize(value: Vector3): void;
+    /**
+     * {@inheritDoc IColliderShape.pointDistance }
+     */
+    pointDistance(point: Vector3): Vector4;
+    private _setBondingBox;
+}

package/types/shape/LiteColliderShape.d.ts

@@ -0,0 +1,56 @@
+import { Quaternion, Ray, Vector3, Vector4 } from "@galacean/engine";
+import { IColliderShape, IPhysicsMaterial } from "@galacean/engine-design";
+import { LiteHitResult } from "../LiteHitResult";
+/**
+ * Abstract class for collider shapes.
+ */
+export declare abstract class LiteColliderShape implements IColliderShape {
+    protected static _tempPos: Vector3;
+    protected static _tempRot: Quaternion;
+    protected static _tempScale: Vector3;
+    protected static _tempPoint: Vector3;
+    protected static _tempVector4: Vector4;
+    private static _ray;
+    private _rotation;
+    protected constructor();
+    /**
+     * {@inheritDoc IColliderShape.setRotation }
+     */
+    setRotation(rotation: Vector3): void;
+    /**
+     * {@inheritDoc IColliderShape.setPosition }
+     */
+    setPosition(position: Vector3): void;
+    /**
+     * {@inheritDoc IColliderShape.setWorldScale }
+     */
+    setWorldScale(scale: Vector3): void;
+    /**
+     * {@inheritDoc IColliderShape.setContactOffset }
+     */
+    setContactOffset(offset: number): void;
+    /**
+     * {@inheritDoc IColliderShape.setMaterial }
+     */
+    setMaterial(material: IPhysicsMaterial): void;
+    /**
+     * {@inheritDoc IColliderShape.setUniqueID }
+     */
+    setUniqueID(id: number): void;
+    /**
+     * {@inheritDoc IColliderShape.setIsTrigger }
+     */
+    setIsTrigger(value: boolean): void;
+    /**
+     * {@inheritDoc IColliderShape.pointDistance }
+     */
+    abstract pointDistance(point: Vector3): Vector4;
+    /**
+     * {@inheritDoc IColliderShape.destroy }
+     */
+    destroy(): void;
+    protected _updateHitResult(ray: Ray, rayDistance: number, outHit: LiteHitResult, origin: Vector3, isWorldRay?: boolean): void;
+    protected _getLocalRay(ray: Ray): Ray;
+    private _getInvModelMatrix;
+    private _setLocalPose;
+}

package/types/shape/LiteSphereColliderShape.d.ts

@@ -0,0 +1,32 @@
+import { ISphereColliderShape } from "@galacean/engine-design";
+import { LiteColliderShape } from "./LiteColliderShape";
+import { Vector3, Vector4 } from "@galacean/engine";
+import { LitePhysicsMaterial } from "../LitePhysicsMaterial";
+/**
+ * Sphere collider shape in Lite.
+ */
+export declare class LiteSphereColliderShape extends LiteColliderShape implements ISphereColliderShape {
+    private static _tempSphere;
+    private _radius;
+    private _maxScale;
+    get worldRadius(): number;
+    /**
+     * Init sphere shape.
+     * @param uniqueID - UniqueID mark collider
+     * @param radius - Size of SphereCollider
+     * @param material - Material of PhysXCollider
+     */
+    constructor(uniqueID: number, radius: number, material: LitePhysicsMaterial);
+    /**
+     * {@inheritDoc ISphereColliderShape.setRadius }
+     */
+    setRadius(value: number): void;
+    /**
+     * {@inheritDoc IColliderShape.setWorldScale }
+     */
+    setWorldScale(scale: Vector3): void;
+    /**
+     * {@inheritDoc IColliderShape.pointDistance }
+     */
+    pointDistance(point: Vector3): Vector4;
+}