@galacean/engine-physics-physx 0.9.0-beta.80

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@galacean/engine-physics-physx",
+  "version": "0.9.0-beta.80",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "license": "MIT",
+  "main": "dist/main.js",
+  "module": "dist/module.js",
+  "debug": "src/index.ts",
+  "browser": "dist/browser.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "libs/**/*",
+    "types/**/*"
+  ],
+  "devDependencies": {
+    "@galacean/engine": "0.9.0-beta.80",
+    "@galacean/engine-design": "0.9.0-beta.80"
+  },
+  "peerDependencies": {
+    "@galacean/engine": "0.9.0-beta.80"
+  },
+  "scripts": {
+    "b:types": "tsc"
+  }
+}

package/types/DisorderedArray.d.ts

@@ -0,0 +1,18 @@
+/**
+ * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
+ */
+export declare class DisorderedArray<T> {
+    _elements: T[];
+    length: number;
+    constructor(count?: number);
+    add(element: T): void;
+    delete(element: T): void;
+    get(index: number): T;
+    /**
+     *
+     * @param index
+     * @returns The replaced item is used to reset its index.
+     */
+    deleteByIndex(index: number): T;
+    garbageCollection(): void;
+}

package/types/PhysXCharacterController.d.ts

@@ -0,0 +1,48 @@
+import { ICharacterController } from "@galacean/engine-design";
+import { Vector3 } from "@galacean/engine";
+import { PhysXColliderShape } from "./shape/PhysXColliderShape";
+/**
+ * Base class for character controllers.
+ */
+export declare class PhysXCharacterController implements ICharacterController {
+    /**
+     * {@inheritDoc ICharacterController.move }
+     */
+    move(disp: Vector3, minDist: number, elapsedTime: number): number;
+    /**
+     * {@inheritDoc ICharacterController.setWorldPosition }
+     */
+    setWorldPosition(position: Vector3): void;
+    /**
+     * {@inheritDoc ICharacterController.getWorldPosition }
+     */
+    getWorldPosition(position: Vector3): void;
+    /**
+     * {@inheritDoc ICharacterController.setStepOffset }
+     */
+    setStepOffset(offset: number): void;
+    /**
+     * {@inheritDoc ICharacterController.setNonWalkableMode }
+     */
+    setNonWalkableMode(flag: number): void;
+    /**
+     * {@inheritDoc ICharacterController.setUpDirection }
+     */
+    setUpDirection(up: Vector3): void;
+    /**
+     * {@inheritDoc ICharacterController.setSlopeLimit }
+     */
+    setSlopeLimit(slopeLimit: number): void;
+    /**
+     * {@inheritDoc ICharacterController.addShape }
+     */
+    addShape(shape: PhysXColliderShape): void;
+    /**
+     * {@inheritDoc ICharacterController.removeShape }
+     */
+    removeShape(shape: PhysXColliderShape): void;
+    /**
+     * {@inheritDoc ICharacterController.destroy }
+     */
+    destroy(): void;
+}

package/types/PhysXCollider.d.ts

@@ -0,0 +1,29 @@
+import { ICollider } from "@galacean/engine-design";
+import { Quaternion, Vector3 } from "@galacean/engine";
+import { PhysXColliderShape } from "./shape/PhysXColliderShape";
+/**
+ * Abstract class of physical collider.
+ */
+export declare abstract class PhysXCollider implements ICollider {
+    private static _tempTransform;
+    /**
+     * {@inheritDoc ICollider.addShape }
+     */
+    addShape(shape: PhysXColliderShape): void;
+    /**
+     * {@inheritDoc ICollider.removeShape }
+     */
+    removeShape(shape: PhysXColliderShape): void;
+    /**
+     * {@inheritDoc ICollider.setWorldTransform }
+     */
+    setWorldTransform(position: Vector3, rotation: Quaternion): void;
+    /**
+     * {@inheritDoc ICollider.getWorldTransform }
+     */
+    getWorldTransform(outPosition: Vector3, outRotation: Quaternion): void;
+    /**
+     * {@inheritDoc ICollider.destroy }
+     */
+    destroy(): void;
+}

package/types/PhysXDynamicCollider.d.ts

@@ -0,0 +1,101 @@
+import { IDynamicCollider } from "@galacean/engine-design";
+import { Quaternion, Vector3 } from "@galacean/engine";
+import { PhysXCollider } from "./PhysXCollider";
+/**
+ * The collision detection mode constants used for PhysXDynamicCollider.collisionDetectionMode.
+ * */
+export declare enum CollisionDetectionMode {
+    /** Continuous collision detection is off for this dynamic collider. */
+    Discrete = 0,
+    /** Continuous collision detection is on for colliding with static mesh geometry. */
+    Continuous = 1,
+    /** Continuous collision detection is on for colliding with static and dynamic geometry. */
+    ContinuousDynamic = 2,
+    /** Speculative continuous collision detection is on for static and dynamic geometries */
+    ContinuousSpeculative = 3
+}
+/**
+ * A dynamic collider can act with self-defined movement or physical force
+ */
+export declare class PhysXDynamicCollider extends PhysXCollider implements IDynamicCollider {
+    private static _tempTranslation;
+    private static _tempRotation;
+    constructor(position: Vector3, rotation: Quaternion);
+    /**
+     * {@inheritDoc IDynamicCollider.setLinearDamping }
+     */
+    setLinearDamping(value: number): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setAngularDamping }
+     */
+    setAngularDamping(value: number): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setLinearVelocity }
+     */
+    setLinearVelocity(value: Vector3): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setAngularVelocity }
+     */
+    setAngularVelocity(value: Vector3): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setMass }
+     */
+    setMass(value: number): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setCenterOfMass }
+     */
+    setCenterOfMass(position: Vector3): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setInertiaTensor }
+     */
+    setInertiaTensor(value: Vector3): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setMaxAngularVelocity }
+     */
+    setMaxAngularVelocity(value: number): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setMaxDepenetrationVelocity }
+     */
+    setMaxDepenetrationVelocity(value: number): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setSleepThreshold }
+     * @default 1e-5f * PxTolerancesScale::speed * PxTolerancesScale::speed
+     */
+    setSleepThreshold(value: number): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setSolverIterations }
+     */
+    setSolverIterations(value: number): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setCollisionDetectionMode }
+     */
+    setCollisionDetectionMode(value: number): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setIsKinematic }
+     */
+    setIsKinematic(value: boolean): void;
+    /**
+     * {@inheritDoc IDynamicCollider.setConstraints }
+     */
+    setConstraints(flags: number): void;
+    /**
+     * {@inheritDoc IDynamicCollider.addForce }
+     */
+    addForce(force: Vector3): void;
+    /**
+     * {@inheritDoc IDynamicCollider.addTorque }
+     */
+    addTorque(torque: Vector3): void;
+    /**
+     * {@inheritDoc IDynamicCollider.move }
+     */
+    move(positionOrRotation: Vector3 | Quaternion, rotation?: Quaternion): void;
+    /**
+     * {@inheritDoc IDynamicCollider.sleep }
+     */
+    sleep(): void;
+    /**
+     * {@inheritDoc IDynamicCollider.wakeUp }
+     */
+    wakeUp(): void;
+}

package/types/PhysXPhysics.d.ts

@@ -0,0 +1,69 @@
+import { IBoxColliderShape, ICapsuleColliderShape, ICharacterController, IDynamicCollider, IFixedJoint, IHingeJoint, IPhysicsManager, IPhysicsMaterial, IPlaneColliderShape, ISphereColliderShape, ISpringJoint, IStaticCollider } from "@galacean/engine-design";
+import { Quaternion, Vector3 } from "@galacean/engine";
+import { PhysXRuntimeMode } from "./enum/PhysXRuntimeMode";
+import { PhysXCollider } from "./PhysXCollider";
+import { PhysXPhysicsMaterial } from "./PhysXPhysicsMaterial";
+/**
+ * PhysX object creation.
+ */
+export declare class PhysXPhysics {
+    /**
+     * Initialize PhysXPhysics.
+     * @param runtimeMode - Runtime mode
+     * @returns Promise object
+     */
+    static initialize(runtimeMode?: PhysXRuntimeMode): Promise<void>;
+    /**
+     * Destroy PhysXPhysics.
+     */
+    static destroy(): void;
+    /**
+     * {@inheritDoc IPhysics.createPhysicsManager }
+     */
+    static createPhysicsManager(onContactBegin?: (obj1: number, obj2: number) => void, onContactEnd?: (obj1: number, obj2: number) => void, onContactStay?: (obj1: number, obj2: number) => void, onTriggerBegin?: (obj1: number, obj2: number) => void, onTriggerEnd?: (obj1: number, obj2: number) => void, onTriggerStay?: (obj1: number, obj2: number) => void): IPhysicsManager;
+    /**
+     * {@inheritDoc IPhysics.createStaticCollider }
+     */
+    static createStaticCollider(position: Vector3, rotation: Quaternion): IStaticCollider;
+    /**
+     * {@inheritDoc IPhysics.createDynamicCollider }
+     */
+    static createDynamicCollider(position: Vector3, rotation: Quaternion): IDynamicCollider;
+    /**
+     * {@inheritDoc IPhysics.createCharacterController }
+     */
+    static createCharacterController(): ICharacterController;
+    /**
+     * {@inheritDoc IPhysics.createPhysicsMaterial }
+     */
+    static createPhysicsMaterial(staticFriction: number, dynamicFriction: number, bounciness: number, frictionCombine: number, bounceCombine: number): IPhysicsMaterial;
+    /**
+     * {@inheritDoc IPhysics.createBoxColliderShape }
+     */
+    static createBoxColliderShape(uniqueID: number, size: Vector3, material: PhysXPhysicsMaterial): IBoxColliderShape;
+    /**
+     * {@inheritDoc IPhysics.createSphereColliderShape }
+     */
+    static createSphereColliderShape(uniqueID: number, radius: number, material: PhysXPhysicsMaterial): ISphereColliderShape;
+    /**
+     * {@inheritDoc IPhysics.createPlaneColliderShape }
+     */
+    static createPlaneColliderShape(uniqueID: number, material: PhysXPhysicsMaterial): IPlaneColliderShape;
+    /**
+     * {@inheritDoc IPhysics.createCapsuleColliderShape }
+     */
+    static createCapsuleColliderShape(uniqueID: number, radius: number, height: number, material: PhysXPhysicsMaterial): ICapsuleColliderShape;
+    /**
+     * {@inheritDoc IPhysics.createFixedJoint }
+     */
+    static createFixedJoint(collider: PhysXCollider): IFixedJoint;
+    /**
+     * {@inheritDoc IPhysics.createHingeJoint }
+     */
+    static createHingeJoint(collider: PhysXCollider): IHingeJoint;
+    /**
+     * {@inheritDoc IPhysics.createSpringJoint }
+     */
+    static createSpringJoint(collider: PhysXCollider): ISpringJoint;
+    private static _init;
+}

package/types/PhysXPhysicsManager.d.ts

@@ -0,0 +1,66 @@
+import { IPhysicsManager } from "@galacean/engine-design";
+import { Ray, Vector3 } from "@galacean/engine";
+import { PhysXCharacterController } from "./PhysXCharacterController";
+import { PhysXCollider } from "./PhysXCollider";
+import { PhysXColliderShape } from "./shape/PhysXColliderShape";
+/**
+ * A manager is a collection of colliders and constraints which can interact.
+ */
+export declare class PhysXPhysicsManager implements IPhysicsManager {
+    private static _tempPosition;
+    private static _tempNormal;
+    private static _pxRaycastHit;
+    private static _pxFilterData;
+    static _init(): void;
+    private _pxScene;
+    private readonly _onContactEnter?;
+    private readonly _onContactExit?;
+    private readonly _onContactStay?;
+    private readonly _onTriggerEnter?;
+    private readonly _onTriggerExit?;
+    private readonly _onTriggerStay?;
+    private _currentEvents;
+    private _eventMap;
+    private _eventPool;
+    constructor(onContactEnter?: (obj1: number, obj2: number) => void, onContactExit?: (obj1: number, obj2: number) => void, onContactStay?: (obj1: number, obj2: number) => void, onTriggerEnter?: (obj1: number, obj2: number) => void, onTriggerExit?: (obj1: number, obj2: number) => void, onTriggerStay?: (obj1: number, obj2: number) => void);
+    /**
+     * {@inheritDoc IPhysicsManager.setGravity }
+     */
+    setGravity(value: Vector3): void;
+    /**
+     * {@inheritDoc IPhysicsManager.addColliderShape }
+     */
+    addColliderShape(colliderShape: PhysXColliderShape): void;
+    /**
+     * {@inheritDoc IPhysicsManager.removeColliderShape }
+     */
+    removeColliderShape(colliderShape: PhysXColliderShape): void;
+    /**
+     * {@inheritDoc IPhysicsManager.addCollider }
+     */
+    addCollider(collider: PhysXCollider): void;
+    /**
+     * {@inheritDoc IPhysicsManager.removeCollider }
+     */
+    removeCollider(collider: PhysXCollider): void;
+    /**
+     * {@inheritDoc IPhysicsManager.addCharacterController }
+     */
+    addCharacterController(characterController: PhysXCharacterController): void;
+    /**
+     * {@inheritDoc IPhysicsManager.removeCharacterController }
+     */
+    removeCharacterController(characterController: PhysXCharacterController): void;
+    /**
+     * {@inheritDoc IPhysicsManager.update }
+     */
+    update(elapsedTime: number): void;
+    /**
+     * {@inheritDoc IPhysicsManager.raycast }
+     */
+    raycast(ray: Ray, distance: number, onRaycast: (obj: number) => boolean, hit?: (shapeUniqueID: number, distance: number, position: Vector3, normal: Vector3) => void): boolean;
+    private _simulate;
+    private _fetchResults;
+    private _getTrigger;
+    private _fireEvent;
+}

package/types/PhysXPhysicsMaterial.d.ts

@@ -0,0 +1,45 @@
+import { IPhysicsMaterial } from "@galacean/engine-design";
+/**
+ * Physics material describes how to handle colliding objects (friction, bounciness).
+ */
+export declare class PhysXPhysicsMaterial implements IPhysicsMaterial {
+    constructor(staticFriction: number, dynamicFriction: number, bounciness: number, frictionCombine: CombineMode, bounceCombine: CombineMode);
+    /**
+     * {@inheritDoc IPhysicsMaterial.setBounciness }
+     */
+    setBounciness(value: number): void;
+    /**
+     * {@inheritDoc IPhysicsMaterial.setDynamicFriction }
+     */
+    setDynamicFriction(value: number): void;
+    /**
+     * {@inheritDoc IPhysicsMaterial.setStaticFriction }
+     */
+    setStaticFriction(value: number): void;
+    /**
+     * {@inheritDoc IPhysicsMaterial.setBounceCombine }
+     */
+    setBounceCombine(value: CombineMode): void;
+    /**
+     * {@inheritDoc IPhysicsMaterial.setFrictionCombine }
+     */
+    setFrictionCombine(value: CombineMode): void;
+    /**
+     * {@inheritDoc IPhysicsMaterial.destroy }
+     */
+    destroy(): void;
+}
+/**
+ * Describes how physics materials of the colliding objects are combined.
+ */
+declare enum CombineMode {
+    /** Averages the friction/bounce of the two colliding materials. */
+    Average = 0,
+    /** Uses the smaller friction/bounce of the two colliding materials. */
+    Minimum = 1,
+    /** Multiplies the friction/bounce of the two colliding materials. */
+    Multiply = 2,
+    /** Uses the larger friction/bounce of the two colliding materials. */
+    Maximum = 3
+}
+export {};

package/types/PhysXStaticCollider.d.ts

@@ -0,0 +1,15 @@
+import { IStaticCollider } from "@galacean/engine-design";
+import { PhysXCollider } from "./PhysXCollider";
+import { Quaternion, Vector3 } from "@galacean/engine";
+/**
+ * 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 PhysXStaticCollider extends PhysXCollider implements IStaticCollider {
+    /**
+     * Initialize PhysX static actor.
+     * @param position - The global position
+     * @param rotation - The global rotation
+     */
+    constructor(position: Vector3, rotation: Quaternion);
+}

package/types/StaticInterfaceImplement.d.ts

@@ -0,0 +1,5 @@
+/**
+ *  Static interface implement decorator.
+ *  https://stackoverflow.com/questions/13955157/how-to-define-static-property-in-typescript-interface
+ */
+export declare function StaticInterfaceImplement<T>(): <U extends T>(constructor: U) => void;

package/types/enum/PhysXRuntimeMode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PhysX runtime mode.
+ */
+export declare enum PhysXRuntimeMode {
+    /** Use webAssembly mode first, if WebAssembly mode is not supported, roll back to JavaScript mode.  */
+    Auto = 0,
+    /** WebAssembly mode. */
+    WebAssembly = 1,
+    /** JavaScript mode. */
+    JavaScript = 2
+}

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export { PhysXPhysics } from "./PhysXPhysics";
+export { PhysXRuntimeMode } from "./enum/PhysXRuntimeMode";

package/types/joint/PhysXFixedJoint.d.ts

@@ -0,0 +1,9 @@
+import { PhysXJoint } from "./PhysXJoint";
+import { IFixedJoint } from "@galacean/engine-design";
+import { PhysXCollider } from "../PhysXCollider";
+/**
+ * A fixed joint permits no relative movement between two colliders. ie the bodies are glued together.
+ */
+export declare class PhysXFixedJoint extends PhysXJoint implements IFixedJoint {
+    constructor(collider: PhysXCollider);
+}

package/types/joint/PhysXHingeJoint.d.ts

@@ -0,0 +1,53 @@
+import { PhysXCollider } from "../PhysXCollider";
+import { PhysXJoint } from "./PhysXJoint";
+import { IHingeJoint } from "@galacean/engine-design";
+import { Vector3 } from "@galacean/engine";
+/**
+ * A joint which behaves in a similar way to a hinge or axle.
+ */
+export declare class PhysXHingeJoint extends PhysXJoint implements IHingeJoint {
+    private _axisRotationQuaternion;
+    private _swingOffset;
+    private _velocity;
+    constructor(collider: PhysXCollider);
+    /**
+     * {@inheritDoc IHingeJoint.setAxis }
+     */
+    setAxis(value: Vector3): void;
+    /**
+     * {@inheritDoc IHingeJoint.setSwingOffset }
+     */
+    setSwingOffset(value: Vector3): void;
+    /**
+     * {@inheritDoc IHingeJoint.getAngle }
+     */
+    getAngle(): number;
+    /**
+     * {@inheritDoc IHingeJoint.getVelocity }
+     */
+    getVelocity(): Readonly<Vector3>;
+    /**
+     * {@inheritDoc IHingeJoint.setHardLimitCone }
+     */
+    setHardLimit(lowerLimit: number, upperLimit: number, contactDist: number): void;
+    /**
+     * {@inheritDoc IHingeJoint.setHardLimitCone }
+     */
+    setSoftLimit(lowerLimit: number, upperLimit: number, stiffness: number, damping: number): void;
+    /**
+     * {@inheritDoc IHingeJoint.setDriveVelocity }
+     */
+    setDriveVelocity(velocity: number): void;
+    /**
+     * {@inheritDoc IHingeJoint.setDriveForceLimit }
+     */
+    setDriveForceLimit(limit: number): void;
+    /**
+     * {@inheritDoc IHingeJoint.setDriveGearRatio }
+     */
+    setDriveGearRatio(ratio: number): void;
+    /**
+     * {@inheritDoc IHingeJoint.setHingeJointFlag }
+     */
+    setHingeJointFlag(flag: number, value: boolean): void;
+}

package/types/joint/PhysXJoint.d.ts

@@ -0,0 +1,55 @@
+import { IJoint } from "@galacean/engine-design";
+import { PhysXCollider } from "../PhysXCollider";
+import { Quaternion, Vector3 } from "@galacean/engine";
+/**
+ * a base interface providing common functionality for PhysX joints
+ */
+export declare class PhysXJoint implements IJoint {
+    protected static _xAxis: Vector3;
+    protected static _defaultVec: Vector3;
+    protected static _defaultQuat: Quaternion;
+    protected _pxJoint: any;
+    protected _collider: PhysXCollider;
+    private _connectedAnchor;
+    private _breakForce;
+    private _breakTorque;
+    /**
+     * {@inheritDoc IJoint.setConnectedCollider }
+     */
+    setConnectedCollider(value: PhysXCollider): void;
+    /**
+     * {@inheritDoc IJoint.setConnectedAnchor }
+     */
+    setConnectedAnchor(value: Vector3): void;
+    /**
+     * {@inheritDoc IJoint.setConnectedMassScale }
+     */
+    setConnectedMassScale(value: number): void;
+    /**
+     * {@inheritDoc IJoint.setConnectedInertiaScale }
+     */
+    setConnectedInertiaScale(value: number): void;
+    /**
+     * {@inheritDoc IJoint.setMassScale }
+     */
+    setMassScale(value: number): void;
+    /**
+     * {@inheritDoc IJoint.setInertiaScale }
+     */
+    setInertiaScale(value: number): void;
+    /**
+     * {@inheritDoc IJoint.setBreakForce }
+     */
+    setBreakForce(value: number): void;
+    /**
+     * {@inheritDoc IJoint.setBreakTorque }
+     */
+    setBreakTorque(value: number): void;
+    /**
+     * Set the joint local pose for an actor.
+     * @param actor 0 for the first actor, 1 for the second actor.
+     * @param position the local position for the actor this joint
+     * @param rotation the local rotation for the actor this joint
+     */
+    protected _setLocalPose(actor: number, position: Vector3, rotation: Quaternion): void;
+}

package/types/joint/PhysXSpringJoint.d.ts

@@ -0,0 +1,35 @@
+import { PhysXJoint } from "./PhysXJoint";
+import { ISpringJoint } from "@galacean/engine-design";
+import { PhysXCollider } from "../PhysXCollider";
+import { Vector3 } from "@galacean/engine";
+/**
+ * a joint that maintains an upper or lower bound (or both) on the distance between two points on different objects
+ */
+export declare class PhysXSpringJoint extends PhysXJoint implements ISpringJoint {
+    private _swingOffset;
+    constructor(collider: PhysXCollider);
+    /**
+     * {@inheritDoc ISpringJoint.setSwingOffset }
+     */
+    setSwingOffset(value: Vector3): void;
+    /**
+     * {@inheritDoc ISpringJoint.setMinDistance }
+     */
+    setMinDistance(distance: number): void;
+    /**
+     * {@inheritDoc ISpringJoint.setMaxDistance }
+     */
+    setMaxDistance(distance: number): void;
+    /**
+     * {@inheritDoc ISpringJoint.setTolerance }
+     */
+    setTolerance(tolerance: number): void;
+    /**
+     * {@inheritDoc ISpringJoint.setStiffness }
+     */
+    setStiffness(stiffness: number): void;
+    /**
+     * {@inheritDoc ISpringJoint.setDamping }
+     */
+    setDamping(damping: number): void;
+}

package/types/shape/PhysXBoxColliderShape.d.ts

@@ -0,0 +1,25 @@
+import { IBoxColliderShape } from "@galacean/engine-design";
+import { Vector3 } from "@galacean/engine";
+import { PhysXPhysicsMaterial } from "../PhysXPhysicsMaterial";
+import { PhysXColliderShape } from "./PhysXColliderShape";
+/**
+ * Box collider shape in PhysX.
+ */
+export declare class PhysXBoxColliderShape extends PhysXColliderShape implements IBoxColliderShape {
+    private static _tempHalfExtents;
+    /**
+     * Init Box Shape and alloc PhysX objects.
+     * @param uniqueID - UniqueID mark Shape.
+     * @param size - Size of Shape.
+     * @param material - Material of PhysXCollider.
+     */
+    constructor(uniqueID: number, size: Vector3, material: PhysXPhysicsMaterial);
+    /**
+     * {@inheritDoc IBoxColliderShape.setSize }
+     */
+    setSize(value: Vector3): void;
+    /**
+     * {@inheritDoc IColliderShape.setWorldScale }
+     */
+    setWorldScale(scale: Vector3): void;
+}

package/types/shape/PhysXCapsuleColliderShape.d.ts

@@ -0,0 +1,46 @@
+import { ICapsuleColliderShape } from "@galacean/engine-design";
+import { Vector3 } from "@galacean/engine";
+import { PhysXPhysicsMaterial } from "../PhysXPhysicsMaterial";
+import { PhysXColliderShape } from "./PhysXColliderShape";
+/**
+ * Capsule collider shape in PhysX.
+ */
+export declare class PhysXCapsuleColliderShape extends PhysXColliderShape implements ICapsuleColliderShape {
+    private _upAxis;
+    /**
+     * Init PhysXCollider and alloc PhysX objects.
+     * @param uniqueID - UniqueID mark collider
+     * @param radius - Radius of CapsuleCollider
+     * @param height - Height of CapsuleCollider
+     * @param material - Material of PhysXCollider
+     */
+    constructor(uniqueID: number, radius: number, height: number, material: PhysXPhysicsMaterial);
+    /**
+     * {@inheritDoc ICapsuleColliderShape.setRadius }
+     */
+    setRadius(value: number): void;
+    /**
+     * {@inheritDoc ICapsuleColliderShape.setHeight }
+     */
+    setHeight(value: number): void;
+    /**
+     * {@inheritDoc ICapsuleColliderShape.setUpAxis }
+     */
+    setUpAxis(upAxis: ColliderShapeUpAxis): void;
+    /**
+     * {@inheritDoc IColliderShape.setWorldScale }
+     */
+    setWorldScale(scale: Vector3): void;
+}
+/**
+ * The up axis of the collider shape.
+ */
+declare enum ColliderShapeUpAxis {
+    /** Up axis is X. */
+    X = 0,
+    /** Up axis is Y. */
+    Y = 1,
+    /** Up axis is Z. */
+    Z = 2
+}
+export {};