@galacean/engine-core 1.6.8 → 1.6.9

package/types/physics/DynamicCollider.d.ts

@@ -0,0 +1,192 @@
+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 static _tempVector3;
+    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 _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);
+    /**
+     * 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;
+    /**
+     * 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;
+    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
+}
+/**
+ * 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,18 @@
+import { Vector3 } from "@galacean/engine-math";
+import { Entity } from "../Entity";
+import { ColliderShape } from "./shape";
+/**
+ * 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;
+    /** The shape of the collider that was hit. */
+    shape: ColliderShape;
+}

package/types/physics/PhysicsMaterial.d.ts

@@ -0,0 +1,42 @@
+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;
+    private _destroyed;
+    constructor();
+    /**
+     * The coefficient of bounciness, ranging from 0 to 1.
+     */
+    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);
+    /**
+     * Destroy the material when the material is no be used by any shape.
+     */
+    destroy(): void;
+}

package/types/physics/PhysicsScene.d.ts

@@ -0,0 +1,276 @@
+import { Ray, Vector3, Quaternion } from "@galacean/engine-math";
+import { Layer } from "../Layer";
+import { Scene } from "../Scene";
+import { HitResult } from "./HitResult";
+import { ColliderShape } from "./shape";
+/**
+ * A physics scene is a collection of colliders and constraints which can interact.
+ */
+export declare class PhysicsScene {
+    private static _collision;
+    private static _identityQuaternion;
+    private _scene;
+    private _restTime;
+    private _fixedTimeStep;
+    private _colliders;
+    private _gravity;
+    private _nativePhysicsScene;
+    private _onContactEnter;
+    private _onContactExit;
+    private _onContactStay;
+    private _onTriggerEnter;
+    private _onTriggerExit;
+    private _onTriggerStay;
+    /**
+     * The gravity of physics scene.
+     */
+    get gravity(): Vector3;
+    set gravity(value: Vector3);
+    /**
+     * The fixed time step in seconds at which physics are performed.
+     */
+    get fixedTimeStep(): number;
+    set fixedTimeStep(value: number);
+    constructor(scene: Scene);
+    /**
+     * Get whether two colliders can collide with each other.
+     * @param layer1 - The first collision layer
+     * @param layer2 - The second collision layer
+     * @returns Whether the colliders should collide
+     */
+    getColliderLayerCollision(layer1: Layer, layer2: Layer): boolean;
+    /**
+     * Set whether two colliders can collide with each other.
+     * @param layer1 - The first collision layer
+     * @param layer2 - The second collision layer
+     * @param isCollide - Whether the colliders should collide
+     */
+    setColliderLayerCollision(layer1: Layer, layer2: Layer, isCollide: boolean): 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;
+    /**
+     * Casts a box through the Scene and returns true if there is any hit.
+     * @param center - The center of the box
+     * @param halfExtents - Half the size of the box in each dimension
+     * @param direction - The direction to sweep along
+     * @returns Returns true if the box intersects with any collider, otherwise false
+     */
+    boxCast(center: Vector3, halfExtents: Vector3, direction: Vector3): boolean;
+    /**
+     * Casts a box through the Scene and returns true if there is any hit.
+     * @param center - The center of the box
+     * @param halfExtents - Half the size of the box in each dimension
+     * @param direction - The direction to sweep along
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns true if the box intersects with any collider, otherwise false
+     */
+    boxCast(center: Vector3, halfExtents: Vector3, direction: Vector3, outHitResult: HitResult): boolean;
+    /**
+     * Casts a box through the Scene and returns true if there is any hit.
+     * @param center - The center of the box
+     * @param halfExtents - Half the size of the box in each dimension
+     * @param direction - The direction to sweep along
+     * @param distance - The max distance to sweep
+     * @returns Returns true if the box intersects with any collider, otherwise false
+     */
+    boxCast(center: Vector3, halfExtents: Vector3, direction: Vector3, distance: number): boolean;
+    /**
+     * Casts a box through the Scene and returns true if there is any hit.
+     * @param center - The center of the box
+     * @param halfExtents - Half the size of the box in each dimension
+     * @param direction - The direction to sweep along
+     * @param distance - The max distance to sweep
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns true if the box intersects with any collider, otherwise false
+     */
+    boxCast(center: Vector3, halfExtents: Vector3, direction: Vector3, distance: number, outHitResult: HitResult): boolean;
+    /**
+     * Casts a box through the Scene and returns true if there is any hit.
+     * @param center - The center of the box
+     * @param halfExtents - Half the size of the box in each dimension
+     * @param direction - The direction to sweep along
+     * @param orientation - The rotation of the box. @defaultValue `Quaternion(0, 0, 0, 1)`
+     * @param distance - The max distance to sweep. @defaultValue `Number.MAX_VALUE`
+     * @param layerMask - Layer mask that is used to selectively ignore Colliders when sweeping. @defaultValue `Layer.Everything`
+     * @param outHitResult - Optional HitResult object to store detailed hit information
+     * @returns Returns true if the box intersects with any collider, otherwise false
+     */
+    boxCast(center: Vector3, halfExtents: Vector3, direction: Vector3, orientation: Quaternion, distance: number, layerMask: Layer, outHitResult?: HitResult): boolean;
+    /**
+     * Casts a sphere through the Scene and returns true if there is any hit.
+     * @param center - The center of the sphere
+     * @param radius - The radius of the sphere
+     * @param direction - The direction to sweep along
+     * @returns Returns true if the sphere intersects with any collider, otherwise false
+     */
+    sphereCast(center: Vector3, radius: number, direction: Vector3): boolean;
+    /**
+     * Casts a sphere through the Scene and returns true if there is any hit.
+     * @param center - The center of the sphere
+     * @param radius - The radius of the sphere
+     * @param direction - The direction to sweep along
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns true if the sphere intersects with any collider, otherwise false
+     */
+    sphereCast(center: Vector3, radius: number, direction: Vector3, outHitResult: HitResult): boolean;
+    /**
+     * Casts a sphere through the Scene and returns true if there is any hit.
+     * @param center - The center of the sphere
+     * @param radius - The radius of the sphere
+     * @param direction - The direction to sweep along
+     * @param distance - The max distance to sweep
+     * @returns Returns true if the sphere intersects with any collider, otherwise false
+     */
+    sphereCast(center: Vector3, radius: number, direction: Vector3, distance: number): boolean;
+    /**
+     * Casts a sphere through the Scene and returns true if there is any hit.
+     * @param center - The center of the sphere
+     * @param radius - The radius of the sphere
+     * @param direction - The direction to sweep along
+     * @param distance - The max distance to sweep
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns true if the sphere intersects with any collider, otherwise false
+     */
+    sphereCast(center: Vector3, radius: number, direction: Vector3, distance: number, outHitResult: HitResult): boolean;
+    /**
+     * Casts a sphere through the Scene and returns true if there is any hit.
+     * @param center - The center of the sphere
+     * @param radius - The radius of the sphere
+     * @param direction - The direction to sweep along
+     * @param distance - The max distance to sweep. @defaultValue `Number.MAX_VALUE`
+     * @param layerMask - Layer mask that is used to selectively ignore Colliders when sweeping. @defaultValue `Layer.Everything`
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns true if the sphere intersects with any collider, otherwise false
+     */
+    sphereCast(center: Vector3, radius: number, direction: Vector3, distance: number, layerMask: Layer, outHitResult?: HitResult): boolean;
+    /**
+     * Casts a capsule through the Scene and returns true if there is any hit.
+     * @param center - The center of the capsule
+     * @param radius - The radius of the capsule
+     * @param height - The height of the capsule
+     * @param direction - The direction to sweep along
+     * @returns Returns true if the capsule intersects with any collider, otherwise false
+     */
+    capsuleCast(center: Vector3, radius: number, height: number, direction: Vector3): boolean;
+    /**
+     * Casts a capsule through the Scene and returns true if there is any hit.
+     * @param center - The center of the capsule
+     * @param radius - The radius of the capsule
+     * @param height - The height of the capsule
+     * @param direction - The direction to sweep along
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns true if the capsule intersects with any collider, otherwise false
+     */
+    capsuleCast(center: Vector3, radius: number, height: number, direction: Vector3, outHitResult: HitResult): boolean;
+    /**
+     * Casts a capsule through the Scene and returns true if there is any hit.
+     * @param center - The center of the capsule
+     * @param radius - The radius of the capsule
+     * @param height - The height of the capsule
+     * @param direction - The direction to sweep along
+     * @param distance - The max distance to sweep
+     * @returns Returns true if the capsule intersects with any collider, otherwise false
+     */
+    capsuleCast(center: Vector3, radius: number, height: number, direction: Vector3, distance: number): boolean;
+    /**
+     * Casts a capsule through the Scene and returns true if there is any hit.
+     * @param center - The center of the capsule
+     * @param radius - The radius of the capsule
+     * @param height - The height of the capsule
+     * @param direction - The direction to sweep along
+     * @param distance - The max distance to sweep
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns true if the capsule intersects with any collider, otherwise false
+     */
+    capsuleCast(center: Vector3, radius: number, height: number, direction: Vector3, distance: number, outHitResult: HitResult): boolean;
+    /**
+     * Casts a capsule through the Scene and returns true if there is any hit.
+     * @param center - The center of the capsule
+     * @param radius - The radius of the capsule
+     * @param height - The height of the capsule
+     * @param direction - The direction to sweep along
+     * @param orientation - The rotation of the capsule. @defaultValue `Quaternion(0, 0, 0, 1)`
+     * @param distance - The max distance to sweep. @defaultValue `Number.MAX_VALUE`
+     * @param layerMask - Layer mask that is used to selectively ignore Colliders when sweeping. @defaultValue `Layer.Everything`
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns True if the capsule intersects with any collider, otherwise false
+     */
+    capsuleCast(center: Vector3, radius: number, height: number, direction: Vector3, orientation: Quaternion, distance: number, layerMask: Layer, outHitResult?: HitResult): boolean;
+    /**
+     * Get all colliders that overlap with a box in the scene.
+     * @param center - The center of the box
+     * @param halfExtents - Half the size of the box in each dimension
+     * @param orientation - The rotation of the box. @defaultValue `Quaternion(0, 0, 0, 1)`
+     * @param layerMask - Layer mask that is used to selectively filter colliders. @defaultValue `Layer.Everything`
+     * @param shapes - Array to store overlapping collider shapes. @defaultValue `[]`
+     * @returns The collider shapes overlapping with the box
+     */
+    overlapBoxAll(center: Vector3, halfExtents: Vector3, orientation?: Quaternion, layerMask?: Layer, shapes?: ColliderShape[]): ColliderShape[];
+    /**
+     * Get all colliders that overlap with a sphere in the scene.
+     * @param center - The center of the sphere
+     * @param radius - The radius of the sphere
+     * @param layerMask - Layer mask that is used to selectively filter colliders. @defaultValue `Layer.Everything`
+     * @param shapes - Array to store overlapping collider shapes. @defaultValue `[]`
+     * @returns The collider shapes overlapping with the sphere
+     */
+    overlapSphereAll(center: Vector3, radius: number, layerMask?: Layer, shapes?: ColliderShape[]): ColliderShape[];
+    /**
+     * Get all colliders that overlap with a capsule in the scene.
+     * @param center - The center of the capsule
+     * @param radius - The radius of the capsule
+     * @param height - The height of the capsule
+     * @param orientation - The rotation of the capsule. @defaultValue `Quaternion(0, 0, 0, 1)`
+     * @param layerMask - Layer mask that is used to selectively filter colliders. @defaultValue `Layer.Everything`
+     * @param shapes - Array to store overlapping collider shapes. @defaultValue `[]`
+     * @returns The collider shapes overlapping with the capsule
+     */
+    overlapCapsuleAll(center: Vector3, radius: number, height: number, orientation?: Quaternion, layerMask?: Layer, shapes?: ColliderShape[]): ColliderShape[];
+    private _setGravity;
+    private _createPreFilter;
+    private _createHitCallback;
+    private _clearHitResult;
+}

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/ColliderShapeChangeFlag.d.ts

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

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,12 @@
+export { CharacterController } from "./CharacterController";
+export { Collider } from "./Collider";
+export { CollisionDetectionMode, DynamicCollider, DynamicColliderConstraints } from "./DynamicCollider";
+export { HitResult } from "./HitResult";
+export { PhysicsMaterial } from "./PhysicsMaterial";
+export { PhysicsScene } from "./PhysicsScene";
+export { StaticCollider } from "./StaticCollider";
+export { Collision } from "./Collision";
+export { ContactPoint } from "./ContactPoint";
+export * from "./enums";
+export * from "./joint";
+export * from "./shape";

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

@@ -0,0 +1,4 @@
+import { Joint } from "./Joint";
+export declare class FixedJoint extends Joint {
+    protected _createJoint(): void;
+}