@galacean/engine-core 0.0.0-experimental-animator-additive.1

package/types/physics/CharacterController.d.ts

@@ -0,0 +1,53 @@
+import { Vector3 } from "@galacean/engine-math";
+import { Collider } from "./Collider";
+import { ControllerNonWalkableMode } from "./enums/ControllerNonWalkableMode";
+import { ColliderShape } from "./shape";
+/**
+ * The character controllers.
+ */
+export declare class CharacterController extends Collider {
+    private _stepOffset;
+    private _nonWalkableMode;
+    private _upDirection;
+    private _slopeLimit;
+    /**
+     * The step offset for the controller.
+     */
+    get stepOffset(): number;
+    set stepOffset(value: number);
+    /**
+     * The value of the non-walkable mode.
+     */
+    get nonWalkableMode(): ControllerNonWalkableMode;
+    set nonWalkableMode(value: ControllerNonWalkableMode);
+    /**
+     * The up direction for the controller.
+     */
+    get upDirection(): Vector3;
+    set upDirection(value: Vector3);
+    /**
+     * The slope limit for the controller.
+     */
+    get slopeLimit(): number;
+    set slopeLimit(value: number);
+    /**
+     * Moves the character using a "collide-and-slide" algorithm.
+     * @param disp - Displacement vector
+     * @param minDist - The minimum travelled distance to consider.
+     * @param elapsedTime - Time elapsed since last call
+     * @return flags - The ControllerCollisionFlag
+     */
+    move(disp: Vector3, minDist: number, elapsedTime: number): number;
+    /**
+     * Add collider shape on this controller.
+     * @param shape - Collider shape
+     * @override
+     */
+    addShape(shape: ColliderShape): void;
+    /**
+     * Remove all shape attached.
+     * @override
+     */
+    clearShapes(): void;
+    private _setUpDirection;
+}

package/types/physics/Collider.d.ts

@@ -0,0 +1,29 @@
+import { BoolUpdateFlag } from "../BoolUpdateFlag";
+import { Component } from "../Component";
+import { ColliderShape } from "./shape/ColliderShape";
+/**
+ * Base class for all colliders.
+ * @decorator `@dependentComponents(Transform)`
+ */
+export declare class Collider extends Component {
+    protected _updateFlag: BoolUpdateFlag;
+    protected _shapes: ColliderShape[];
+    /**
+     * The shapes of this collider.
+     */
+    get shapes(): Readonly<ColliderShape[]>;
+    /**
+     * Add collider shape on this collider.
+     * @param shape - Collider shape
+     */
+    addShape(shape: ColliderShape): void;
+    /**
+     * Remove a collider shape.
+     * @param shape - The collider shape.
+     */
+    removeShape(shape: ColliderShape): void;
+    /**
+     * Remove all shape attached.
+     */
+    clearShapes(): void;
+}

package/types/physics/DynamicCollider.d.ts

@@ -0,0 +1,161 @@
+import { Quaternion, Vector3 } from "@galacean/engine-math";
+import { Collider } from "./Collider";
+/**
+ * A dynamic collider can act with self-defined movement or physical force.
+ */
+export declare class DynamicCollider extends Collider {
+    private _linearDamping;
+    private _angularDamping;
+    private _linearVelocity;
+    private _angularVelocity;
+    private _mass;
+    private _centerOfMass;
+    private _inertiaTensor;
+    private _maxAngularVelocity;
+    private _maxDepenetrationVelocity;
+    private _solverIterations;
+    private _isKinematic;
+    private _constraints;
+    private _collisionDetectionMode;
+    private _sleepThreshold;
+    /**
+     * The linear damping of the dynamic collider.
+     */
+    get linearDamping(): number;
+    set linearDamping(value: number);
+    /**
+     * The angular damping of the dynamic collider.
+     */
+    get angularDamping(): number;
+    set angularDamping(value: number);
+    /**
+     * The linear velocity vector of the dynamic collider measured in world unit per second.
+     */
+    get linearVelocity(): Vector3;
+    set linearVelocity(value: Vector3);
+    /**
+     * The angular velocity vector of the dynamic collider measured in radians per second.
+     */
+    get angularVelocity(): Vector3;
+    set angularVelocity(value: Vector3);
+    /**
+     * The mass of the dynamic collider.
+     */
+    get mass(): number;
+    set mass(value: number);
+    /**
+     * The center of mass relative to the transform's origin.
+     */
+    get centerOfMass(): Vector3;
+    set centerOfMass(value: Vector3);
+    /**
+     * The diagonal inertia tensor of mass relative to the center of mass.
+     */
+    get inertiaTensor(): Vector3;
+    set inertiaTensor(value: Vector3);
+    /**
+     * The maximum angular velocity of the collider measured in radians per second. (Default 7) range { 0, infinity }.
+     */
+    get maxAngularVelocity(): number;
+    set maxAngularVelocity(value: number);
+    /**
+     * Maximum velocity of a collider when moving out of penetrating state.
+     */
+    get maxDepenetrationVelocity(): number;
+    set maxDepenetrationVelocity(value: number);
+    /**
+     * The mass-normalized energy threshold, below which objects start going to sleep.
+     */
+    get sleepThreshold(): number;
+    set sleepThreshold(value: number);
+    /**
+     * The solverIterations determines how accurately collider joints and collision contacts are resolved.
+     */
+    get solverIterations(): number;
+    set solverIterations(value: number);
+    /**
+     * Controls whether physics affects the dynamic collider.
+     */
+    get isKinematic(): boolean;
+    set isKinematic(value: boolean);
+    /**
+     * The particular rigid dynamic lock flag.
+     */
+    get constraints(): DynamicColliderConstraints;
+    set constraints(value: DynamicColliderConstraints);
+    /**
+     * The colliders' collision detection mode.
+     */
+    get collisionDetectionMode(): CollisionDetectionMode;
+    set collisionDetectionMode(value: CollisionDetectionMode);
+    /**
+     * Apply a force to the DynamicCollider.
+     * @param force - The force make the collider move
+     */
+    applyForce(force: Vector3): void;
+    /**
+     * Apply a torque to the DynamicCollider.
+     * @param torque - The force make the collider rotate
+     */
+    applyTorque(torque: Vector3): void;
+    /**
+     * Moves kinematically controlled dynamic actors through the game world.
+     * @param position - The desired position for the kinematic actor
+     */
+    move(position: Vector3): void;
+    /**
+     * Moves kinematically controlled dynamic actors through the game world.
+     * @param rotation - The desired rotation for the kinematic actor
+     */
+    move(rotation: Quaternion): void;
+    /**
+     * Moves kinematically controlled dynamic actors through the game world.
+     * @param position - The desired position for the kinematic actor
+     * @param rotation - The desired rotation for the kinematic actor
+     */
+    move(position: Vector3, rotation: Quaternion): void;
+    /**
+     * Forces a collider to sleep at least one frame.
+     */
+    sleep(): void;
+    /**
+     * Forces a collider to wake up.
+     */
+    wakeUp(): void;
+    private _setLinearVelocity;
+    private _setAngularVelocity;
+    private _setCenterOfMass;
+    private _setInertiaTensor;
+}
+/**
+ * The collision detection mode constants.
+ */
+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
+}
+/**
+ * Use these flags to constrain motion of dynamic collider.
+ */
+export declare enum DynamicColliderConstraints {
+    /** Not Freeze. */
+    None = 0,
+    /** Freeze motion along the X-axis. */
+    FreezePositionX = 1,
+    /** Freeze motion along the Y-axis. */
+    FreezePositionY = 2,
+    /** Freeze motion along the Z-axis. */
+    FreezePositionZ = 4,
+    /** Freeze rotation along the X-axis. */
+    FreezeRotationX = 8,
+    /** Freeze rotation along the Y-axis. */
+    FreezeRotationY = 16,
+    /** Freeze rotation along the Z-axis. */
+    FreezeRotationZ = 32
+}

package/types/physics/HitResult.d.ts

@@ -0,0 +1,15 @@
+import { Entity } from "../Entity";
+import { Vector3 } from "@galacean/engine-math";
+/**
+ * Structure used to get information back from a raycast or a sweep.
+ */
+export declare class HitResult {
+    /** The entity that was hit. */
+    entity: Entity;
+    /** The distance from the ray's origin to the impact point. */
+    distance: number;
+    /** The impact point in world space where the ray hit the collider. */
+    point: Vector3;
+    /** The normal of the surface the ray hit. */
+    normal: Vector3;
+}

package/types/physics/PhysicsManager.d.ts

@@ -0,0 +1,95 @@
+import { IPhysics } from "@galacean/engine-design";
+import { Ray, Vector3 } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { Layer } from "../Layer";
+import { HitResult } from "./HitResult";
+/**
+ * A physics manager is a collection of colliders and constraints which can interact.
+ */
+export declare class PhysicsManager {
+    private _engine;
+    private _restTime;
+    private _colliders;
+    private _gravity;
+    private _nativePhysicsManager;
+    private _physicalObjectsMap;
+    private _onContactEnter;
+    private _onContactExit;
+    private _onContactStay;
+    private _onTriggerEnter;
+    private _onTriggerExit;
+    private _onTriggerStay;
+    /** The fixed time step in seconds at which physics are performed. */
+    fixedTimeStep: number;
+    /**
+     * The max allowed time step in seconds one frame.
+     *
+     * @remarks
+     * When the frame rate is low or stutter occurs, the maximum execution time of physics will not exceed this value.
+     * So physics will slow down a bit when performance hitch occurs.
+     */
+    maxAllowedTimeStep: number;
+    /**
+     * The gravity of physics scene.
+     */
+    get gravity(): Vector3;
+    set gravity(value: Vector3);
+    /**
+     * @deprecated
+     * Please use `maxAllowedTimeStep` instead.
+     */
+    get maxSumTimeStep(): number;
+    set maxSumTimeStep(value: number);
+    constructor(engine: Engine);
+    /**
+     * initialize PhysicsManager.
+     * @param physics - Physics Engine
+     */
+    initialize(physics: IPhysics): void;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray, outHitResult: HitResult): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param distance - The max distance the ray should check
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray, distance: number): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param distance - The max distance the ray should check
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray, distance: number, outHitResult: HitResult): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param distance - The max distance the ray should check
+     * @param layerMask - Layer mask that is used to selectively ignore Colliders when casting
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray, distance: number, layerMask: Layer): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param distance - The max distance the ray should check
+     * @param layerMask - Layer mask that is used to selectively ignore Colliders when casting
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns True if the ray intersects with a collider, otherwise false.
+     */
+    raycast(ray: Ray, distance: number, layerMask: Layer, outHitResult: HitResult): boolean;
+    private _setGravity;
+}

package/types/physics/PhysicsMaterial.d.ts

@@ -0,0 +1,37 @@
+import { PhysicsMaterialCombineMode } from "./enums/PhysicsMaterialCombineMode";
+/**
+ * Material class to represent a set of surface properties.
+ */
+export declare class PhysicsMaterial {
+    private _bounciness;
+    private _dynamicFriction;
+    private _staticFriction;
+    private _bounceCombine;
+    private _frictionCombine;
+    constructor();
+    /**
+     * The coefficient of bounciness.
+     */
+    get bounciness(): number;
+    set bounciness(value: number);
+    /**
+     * The DynamicFriction value.
+     */
+    get dynamicFriction(): number;
+    set dynamicFriction(value: number);
+    /**
+     * The coefficient of static friction.
+     */
+    get staticFriction(): number;
+    set staticFriction(value: number);
+    /**
+     * The restitution combine mode.
+     */
+    get bounceCombine(): PhysicsMaterialCombineMode;
+    set bounceCombine(value: PhysicsMaterialCombineMode);
+    /**
+     * The friction combine mode.
+     */
+    get frictionCombine(): PhysicsMaterialCombineMode;
+    set frictionCombine(value: PhysicsMaterialCombineMode);
+}

package/types/physics/StaticCollider.d.ts

@@ -0,0 +1,7 @@
+import { Collider } from "./Collider";
+/**
+ * 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 StaticCollider extends Collider {
+}

package/types/physics/enums/ColliderShapeUpAxis.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The up axis of the collider shape.
+ */
+export declare enum ColliderShapeUpAxis {
+    /** Up axis is X. */
+    X = 0,
+    /** Up axis is Y. */
+    Y = 1,
+    /** Up axis is Z. */
+    Z = 2
+}

package/types/physics/enums/ControllerCollisionFlag.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The up axis of the collider shape.
+ */
+export declare enum ControllerCollisionFlag {
+    /** Character is colliding to the sides. */
+    Sides = 1,
+    /** Character has collision above. */
+    Up = 2,
+    /** Character has collision below. */
+    Down = 4
+}

package/types/physics/enums/ControllerNonWalkableMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The up axis of the collider shape.
+ */
+export declare enum ControllerNonWalkableMode {
+    /** Stops character from climbing up non-walkable slopes, but doesn't move it otherwise. */
+    PreventClimbing = 0,
+    /** Stops character from climbing up non-walkable slopes, and forces it to slide down those slopes. */
+    PreventClimbingAndForceSliding = 1
+}

package/types/physics/enums/HingeJointFlag.d.ts

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

package/types/physics/enums/PhysicsMaterialCombineMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Describes how physics materials of the colliding objects are combined.
+ */
+export declare enum PhysicsMaterialCombineMode {
+    /** 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
+}

package/types/physics/enums/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./PhysicsMaterialCombineMode";
+export * from "./ColliderShapeUpAxis";
+export * from "./ControllerCollisionFlag";
+export * from "./ControllerNonWalkableMode";

package/types/physics/index.d.ts

@@ -0,0 +1,10 @@
+export { HitResult } from "./HitResult";
+export { PhysicsManager } from "./PhysicsManager";
+export { PhysicsMaterial } from "./PhysicsMaterial";
+export { CharacterController } from "./CharacterController";
+export * from "./shape";
+export * from "./joint";
+export * from "./enums";
+export { Collider } from "./Collider";
+export { StaticCollider } from "./StaticCollider";
+export { DynamicCollider, CollisionDetectionMode, DynamicColliderConstraints } from "./DynamicCollider";

package/types/physics/joint/FixedJoint.d.ts

@@ -0,0 +1,3 @@
+import { Joint } from "./Joint";
+export declare class FixedJoint extends Joint {
+}

package/types/physics/joint/HingeJoint.d.ts

@@ -0,0 +1,57 @@
+import { Joint } from "./Joint";
+import { Vector3 } from "@galacean/engine-math";
+import { JointMotor } from "./JointMotor";
+import { JointLimits } from "./JointLimits";
+/**
+ * A joint which behaves in a similar way to a hinge or axle.
+ */
+export declare class HingeJoint extends Joint {
+    private _axis;
+    private _hingeFlags;
+    private _useSpring;
+    private _jointMonitor;
+    private _limits;
+    /**
+     * The anchor rotation.
+     */
+    get axis(): Vector3;
+    set axis(value: Vector3);
+    /**
+     * The swing offset.
+     */
+    get swingOffset(): Vector3;
+    set swingOffset(value: Vector3);
+    /**
+     * The current angle in degrees of the joint relative to its rest position.
+     */
+    get angle(): number;
+    /**
+     * The angular velocity of the joint in degrees per second.
+     */
+    get velocity(): Readonly<Vector3>;
+    /**
+     * Enables the joint's limits. Disabled by default.
+     */
+    get useLimits(): boolean;
+    set useLimits(value: boolean);
+    /**
+     * Enables the joint's motor. Disabled by default.
+     */
+    get useMotor(): boolean;
+    set useMotor(value: boolean);
+    /**
+     * Enables the joint's spring. Disabled by default.
+     */
+    get useSpring(): boolean;
+    set useSpring(value: boolean);
+    /**
+     * The motor will apply a force up to a maximum force to achieve the target velocity in degrees per second.
+     */
+    get motor(): JointMotor;
+    set motor(value: JointMotor);
+    /**
+     * Limit of angular rotation (in degrees) on the hinge joint.
+     */
+    get limits(): JointLimits;
+    set limits(value: JointLimits);
+}

package/types/physics/joint/Joint.d.ts

@@ -0,0 +1,58 @@
+import { IJoint } from "@galacean/engine-design";
+import { Vector3 } from "@galacean/engine-math";
+import { Component } from "../../Component";
+import { Collider } from "../Collider";
+import { Entity } from "../../Entity";
+/**
+ * A base class providing common functionality for joints.
+ * @decorator `@dependentComponents(Collider)`
+ */
+export declare class Joint extends Component {
+    protected _connectedCollider: JointCollider;
+    protected _collider: JointCollider;
+    protected _nativeJoint: IJoint;
+    private _force;
+    private _torque;
+    /**
+     * The connected collider.
+     */
+    get connectedCollider(): Collider;
+    set connectedCollider(value: Collider);
+    /**
+     * The connected anchor position.
+     * @remarks If connectedCollider is set, this anchor is relative offset, or the anchor is world position.
+     */
+    get connectedAnchor(): Vector3;
+    set connectedAnchor(value: Vector3);
+    /**
+     *  The scale to apply to the inverse mass of collider 0 for resolving this constraint.
+     */
+    get connectedMassScale(): number;
+    set connectedMassScale(value: number);
+    /**
+     * The scale to apply to the inverse inertia of collider0 for resolving this constraint.
+     */
+    get connectedInertiaScale(): number;
+    set connectedInertiaScale(value: number);
+    /**
+     * The scale to apply to the inverse mass of collider 1 for resolving this constraint.
+     */
+    get massScale(): number;
+    set massScale(value: number);
+    /**
+     * The scale to apply to the inverse inertia of collider1 for resolving this constraint.
+     */
+    get inertiaScale(): number;
+    set inertiaScale(value: number);
+    /**
+     * The maximum force the joint can apply before breaking.
+     */
+    get breakForce(): number;
+    set breakForce(value: number);
+    /**
+     * The maximum torque the joint can apply before breaking.
+     */
+    get breakTorque(): number;
+    set breakTorque(value: number);
+    constructor(entity: Entity);
+}

package/types/physics/joint/JointLimits.d.ts

@@ -0,0 +1,15 @@
+/**
+ * JointLimits is used to limit the joints angle.
+ */
+export declare class JointLimits {
+    /** The upper angular limit (in degrees) of the joint. */
+    max: number;
+    /** The lower angular limit (in degrees) of the joint. */
+    min: number;
+    /** Distance inside the limit value at which the limit will be considered to be active by the solver. */
+    contactDistance: number;
+    /** The spring forces used to reach the target position. */
+    stiffness: number;
+    /** The damper force uses to dampen the spring. */
+    damping: number;
+}

package/types/physics/joint/JointMotor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The JointMotor is used to motorize a joint.
+ */
+export declare class JointMotor {
+    /** The motor will apply a force up to force to achieve targetVelocity. */
+    targetVelocity: number;
+    /** The force limit.*/
+    forceLimit: number;
+    /** Gear ration for the motor */
+    gearRation: number;
+    /** If freeSpin is enabled the motor will only accelerate but never slow down. */
+    freeSpin: boolean;
+}

package/types/physics/joint/SpringJoint.d.ts

@@ -0,0 +1,42 @@
+import { Joint } from "./Joint";
+import { Vector3 } from "@galacean/engine-math";
+/**
+ * A joint that maintains an upper or lower bound (or both) on the distance between two points on different objects.
+ */
+export declare class SpringJoint extends Joint {
+    private _minDistance;
+    private _maxDistance;
+    private _tolerance;
+    private _stiffness;
+    private _damping;
+    /**
+     * The swing offset.
+     */
+    get swingOffset(): Vector3;
+    set swingOffset(value: Vector3);
+    /**
+     * The minimum distance.
+     */
+    get minDistance(): number;
+    set minDistance(value: number);
+    /**
+     * The maximum distance.
+     */
+    get maxDistance(): number;
+    set maxDistance(value: number);
+    /**
+     * The distance beyond the allowed range at which the joint becomes active.
+     */
+    get tolerance(): number;
+    set tolerance(value: number);
+    /**
+     * The spring strength of the joint.
+     */
+    get stiffness(): number;
+    set stiffness(value: number);
+    /**
+     * The degree of damping of the joint spring of the joint.
+     */
+    get damping(): number;
+    set damping(value: number);
+}

package/types/physics/joint/index.d.ts

@@ -0,0 +1,6 @@
+export { Joint } from "./Joint";
+export { FixedJoint } from "./FixedJoint";
+export { HingeJoint } from "./HingeJoint";
+export { SpringJoint } from "./SpringJoint";
+export { JointLimits } from "./JointLimits";
+export { JointMotor } from "./JointMotor";