import { Quaternion, Vector3 } from "@galacean/engine-math";
import { Collider } from "./Collider";
import { ColliderShape } from "./shape/ColliderShape";
/**
 * A dynamic collider can act with self-defined movement or physical force.
 */
export declare class DynamicCollider extends Collider {
    private static _tempVector3;
    private static _tempVector3_1;
    private static _tempVector3_2;
    private static _tempQuat;
    private _linearDamping;
    private _angularDamping;
    private _linearVelocity;
    private _angularVelocity;
    private _mass;
    private _centerOfMass;
    private _inertiaTensor;
    private _maxAngularVelocity;
    private _maxDepenetrationVelocity;
    private _solverIterations;
    private _useGravity;
    private _isKinematic;
    private _constraints;
    private _collisionDetectionMode;
    private _kinematicTransformSyncMode;
    private _sleepThreshold;
    private _automaticCenterOfMass;
    private _automaticInertiaTensor;
    /**
     * 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 degrees per second.
     */
    get angularVelocity(): Vector3;
    set angularVelocity(value: Vector3);
    /**
     * The mass of the dynamic collider.
     */
    get mass(): number;
    set mass(value: number);
    /**
     * Whether or not to calculate the center of mass automatically, if true, the center of mass will be calculated based on the associated shapes.
     * @remarks Affected by the position, rotation of the shapes.
     */
    get automaticCenterOfMass(): boolean;
    set automaticCenterOfMass(value: boolean);
    /**
     * The center of mass relative to the transform's origin.
     * @remarks The center of mass is automatically calculated, if you want to set it manually, please set automaticCenterOfMass to false.
     */
    get centerOfMass(): Vector3;
    set centerOfMass(value: Vector3);
    /**
     * Whether or not to calculate the inertia tensor automatically, if true, the inertia tensor will be calculated based on the associated shapes and mass.
     * @remarks Affected by the position, rotation of the shapes and the mass of the collider.
     */
    get automaticInertiaTensor(): boolean;
    set automaticInertiaTensor(value: boolean);
    /**
     * The diagonal inertia tensor of mass relative to the center of mass.
     * @remarks The inertia tensor is automatically calculated, if you want to set it manually, please set automaticInertiaTensor to false.
     */
    get inertiaTensor(): Vector3;
    set inertiaTensor(value: Vector3);
    /**
     * The maximum angular velocity of the collider measured in degrees per second.
     */
    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 gravity affects the dynamic collider.
     */
    get useGravity(): boolean;
    set useGravity(value: boolean);
    /**
     * 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);
    /**
     * Controls how entity transform changes are synchronized to a kinematic native actor.
     *
     * @remarks
     * `Target` routes transform changes through {@link move}, so PhysX treats the
     * actor as moving between frames and can generate swept contacts. `Teleport`
     * writes the native pose directly and does not imply velocity.
     */
    get kinematicTransformSyncMode(): DynamicColliderKinematicTransformSyncMode;
    set kinematicTransformSyncMode(value: DynamicColliderKinematicTransformSyncMode);
    /**
     * 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;
    /**
     * Apply a force to the DynamicCollider at a given position in world space.
     * The force generates both linear acceleration through the center of mass and angular
     * acceleration about it (torque = (position - centerOfMass) × force).
     * @param force - The force to apply, in world space
     * @param position - The position where the force is applied, in world space
     */
    applyForceAtPosition(force: Vector3, position: Vector3): void;
    /**
     * Moves the kinematic collider to the specified position.
     * @remarks Only available when {@link isKinematic} is true.
     * Unlike setting the transform directly (teleport), this method affects dynamic colliders along the movement path.
     * @param position - The desired position for the kinematic collider
     */
    move(position: Vector3): void;
    /**
     * Moves the kinematic collider to the specified rotation.
     * @remarks Only available when {@link isKinematic} is true.
     * Unlike setting the transform directly (teleport), this method affects dynamic colliders along the movement path.
     * @param rotation - The desired rotation for the kinematic collider
     */
    move(rotation: Quaternion): void;
    /**
     * Moves the kinematic collider to the specified position and rotation.
     * @remarks Only available when {@link isKinematic} is true.
     * Unlike setting the transform directly (teleport), this method affects dynamic colliders along the movement path.
     * @param position - The desired position for the kinematic collider
     * @param rotation - The desired rotation for the kinematic collider
     */
    move(position: Vector3, rotation: Quaternion): void;
    /**
     * Forces a collider to sleep at least one frame.
     */
    sleep(): void;
    /**
     * Returns whether the collider is sleeping.
     * @returns True if the collider is sleeping, false otherwise.
     */
    isSleeping(): boolean;
    /**
     * Forces a collider to wake up.
     */
    wakeUp(): void;
    /**
     * @inheritdoc
     */
    addShape(shape: ColliderShape): void;
    protected _syncNative(): void;
    private _setMassAndUpdateInertia;
    private _setLinearVelocity;
    private _setAngularVelocity;
    private _handleCenterOfMassChanged;
    private _handleInertiaTensorChanged;
}
/**
 * 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
}
/**
 * Kinematic transform synchronization mode.
 */
export declare enum DynamicColliderKinematicTransformSyncMode {
    /** Synchronize transform changes through PhysX setKinematicTarget. */
    Target = 0,
    /** Synchronize transform changes by directly teleporting the native actor. */
    Teleport = 1
}
/**
 * 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
}
