Support get contact points and get closest point on shape from a point

packages/core/src/physics/CharacterController.ts

@@ -5,7 +5,7 @@ import { Collider } from "./Collider";
 import { PhysicsScene } from "./PhysicsScene";
 import { ControllerNonWalkableMode } from "./enums/ControllerNonWalkableMode";
 import { ColliderShape } from "./shape";
-import { deepClone } from "../clone/CloneManager";
+import { deepClone, ignoreClone } from "../clone/CloneManager";
 
 /**
  * The character controllers.
@@ -166,6 +166,7 @@ export class CharacterController extends Collider {
     (<ICharacterController>this._nativeCollider).getWorldPosition(this.entity.transform.worldPosition);
   }
 
+  @ignoreClone
   private _setUpDirection(): void {
     (<ICharacterController>this._nativeCollider).setUpDirection(this._upDirection);
   }

packages/core/src/physics/Collision.ts

@@ -1,5 +1,58 @@
+import { Vector3 } from "@galacean/engine-math";
 import { ColliderShape } from "./shape";
+import { ICollision } from "@galacean/engine-design";
+
+/**
+ * Describes a contact point where the collision occurs.
+ */
+export interface ContactPoint {
+  /** The position of the contact point between the shapes, in world space. */
+  readonly position: Vector3;
+  /** The normal of the contacting surfaces at the contact point. The normal direction points from the second shape to the first shape. */
+  readonly normal: Vector3;
+  /** The impulse applied at the contact point, in world space. Divide by the simulation time step to get a force value. */
+  readonly impulse: Vector3;
+  /** The separation of the shapes at the contact point.  A negative separation denotes a penetration. */
+  readonly separation: number;
+}
 
 export class Collision {
+  /** @internal */
+  _nativeCollision: ICollision;
+
+  /** The shape be collided. */
   shape: ColliderShape;
+
+  /**
+   * Get count of contact points.
+   */
+  get contactCount(): number {
+    return this._nativeCollision.contactCount;
+  }
+
+  /**
+   * Get contact points.
+   * @param outContacts - The result of contact points
+   * @returns The result of contact points
+   */
+  getContacts(outContacts: ContactPoint[]): ContactPoint[] {
+    const { shape0Id, shape1Id } = this._nativeCollision;
+    const nativeContactPoints = this._nativeCollision.getContacts();
+    for (let i = 0, n = nativeContactPoints.size(); i < n; i++) {
+      const nativeContractPoint = nativeContactPoints.get(i);
+      const { position, normal, impulse, separation } = nativeContractPoint;
+      let factor = 1;
+      if (shape0Id > shape1Id) {
+        factor = -1;
+      }
+      const contact: ContactPoint = {
+        position: new Vector3(position.x, position.y, position.z),
+        normal: new Vector3(normal.x, normal.y, normal.z).scale(factor),
+        impulse: new Vector3(impulse.x, impulse.y, impulse.z).scale(factor),
+        separation: separation
+      };
+      outContacts.push(contact);
+    }
+    return outContacts;
+  }
 }

packages/core/src/physics/PhysicsScene.ts

@@ -1,4 +1,4 @@
-import { ICharacterController, ICollider, IPhysics, IPhysicsScene } from "@galacean/engine-design";
+import { ICharacterController, ICollider, IPhysics, IPhysicsScene, ICollision } from "@galacean/engine-design";
 import { MathUtil, Ray, Vector3 } from "@galacean/engine-math";
 import { Layer } from "../Layer";
 import { Scene } from "../Scene";
@@ -28,14 +28,16 @@ export class PhysicsScene {
   private _gravity: Vector3 = new Vector3(0, -9.81, 0);
   private _nativePhysicsScene: IPhysicsScene;
 
-  private _onContactEnter = (obj1: number, obj2: number) => {
+  private _onContactEnter = (nativeCollision: ICollision) => {
     const physicalObjectsMap = Engine._physicalObjectsMap;
-    const shape1 = physicalObjectsMap[obj1];
-    const shape2 = physicalObjectsMap[obj2];
+    const { shape0Id, shape1Id } = nativeCollision;
+    const shape1 = physicalObjectsMap[shape0Id];
+    const shape2 = physicalObjectsMap[shape1Id];
+    const collision = PhysicsScene._collision;
+    collision._nativeCollision = nativeCollision;
 
     shape1.collider.entity._scripts.forEach(
       (element: Script) => {
-        let collision = PhysicsScene._collision;
         collision.shape = shape2;
         element.onCollisionEnter(collision);
       },
@@ -46,7 +48,6 @@ export class PhysicsScene {
 
     shape2.collider.entity._scripts.forEach(
       (element: Script) => {
-        let collision = PhysicsScene._collision;
         collision.shape = shape1;
         element.onCollisionEnter(collision);
       },
@@ -56,14 +57,16 @@ export class PhysicsScene {
     );
   };
 
-  private _onContactExit = (obj1: number, obj2: number) => {
+  private _onContactExit = (nativeCollision: ICollision) => {
     const physicalObjectsMap = Engine._physicalObjectsMap;
-    const shape1 = physicalObjectsMap[obj1];
-    const shape2 = physicalObjectsMap[obj2];
+    const { shape0Id, shape1Id } = nativeCollision;
+    const shape1 = physicalObjectsMap[shape0Id];
+    const shape2 = physicalObjectsMap[shape1Id];
+    const collision = PhysicsScene._collision;
+    collision._nativeCollision = nativeCollision;
 
     shape1.collider.entity._scripts.forEach(
       (element: Script) => {
-        let collision = PhysicsScene._collision;
         collision.shape = shape2;
         element.onCollisionExit(collision);
       },
@@ -74,7 +77,6 @@ export class PhysicsScene {
 
     shape2.collider.entity._scripts.forEach(
       (element: Script) => {
-        let collision = PhysicsScene._collision;
         collision.shape = shape1;
         element.onCollisionExit(collision);
       },
@@ -83,14 +85,16 @@ export class PhysicsScene {
       }
     );
   };
-  private _onContactStay = (obj1: number, obj2: number) => {
+  private _onContactStay = (nativeCollision: ICollision) => {
     const physicalObjectsMap = Engine._physicalObjectsMap;
-    const shape1 = physicalObjectsMap[obj1];
-    const shape2 = physicalObjectsMap[obj2];
+    const { shape0Id, shape1Id } = nativeCollision;
+    const shape1 = physicalObjectsMap[shape0Id];
+    const shape2 = physicalObjectsMap[shape1Id];
+    const collision = PhysicsScene._collision;
+    collision._nativeCollision = nativeCollision;
 
     shape1.collider.entity._scripts.forEach(
       (element: Script) => {
-        let collision = PhysicsScene._collision;
         collision.shape = shape2;
         element.onCollisionStay(collision);
       },
@@ -101,7 +105,6 @@ export class PhysicsScene {
 
     shape2.collider.entity._scripts.forEach(
       (element: Script) => {
-        let collision = PhysicsScene._collision;
         collision.shape = shape1;
         element.onCollisionStay(collision);
       },

packages/core/src/physics/shape/ColliderShape.ts

@@ -1,6 +1,6 @@
 import { IColliderShape } from "@galacean/engine-design";
 import { PhysicsMaterial } from "../PhysicsMaterial";
-import { Vector3 } from "@galacean/engine-math";
+import { MathUtil, Matrix, Quaternion, Vector3 } from "@galacean/engine-math";
 import { Collider } from "../Collider";
 import { deepClone, ignoreClone } from "../../clone/CloneManager";
 import { ICustomClone } from "../../clone/ComponentCloner";
@@ -11,6 +11,9 @@ import { Engine } from "../../Engine";
  */
 export abstract class ColliderShape implements ICustomClone {
   private static _idGenerator: number = 0;
+  private static _tempWorldPos: Vector3 = new Vector3();
+  private static _tempWorldRot: Quaternion = new Quaternion();
+  private static _tempMatrix: Matrix = new Matrix();
 
   /** @internal */
   @ignoreClone
@@ -133,6 +136,50 @@ export abstract class ColliderShape implements ICustomClone {
     Engine._physicalObjectsMap[this._id] = this;
   }
 
+  /**
+   * Get the distance and the closest point on the shape from a point.
+   * @param point - The point
+   * @param outClosestPoint - The result of the closest point on the shape
+   * @returns The distance between the point and the shape
+   */
+  getDistanceAndClosestPointFromPoint(point: Vector3, outClosestPoint: Vector3): number {
+    const collider = this._collider;
+    if (collider.enabled === false || collider.entity._isActiveInHierarchy === false) {
+      console.warn("The collider is not active in scene.");
+      return -1;
+    }
+    const tempQuat = ColliderShape._tempWorldRot;
+    const tempPos = ColliderShape._tempWorldPos;
+    Vector3.transformCoordinate(this._position, collider.entity.transform.worldMatrix, tempPos);
+
+    const rotation = this._rotation;
+    Quaternion.rotationEuler(
+      MathUtil.degreeToRadian(rotation.x),
+      MathUtil.degreeToRadian(rotation.y),
+      MathUtil.degreeToRadian(rotation.z),
+      tempQuat
+    );
+    Quaternion.multiply(this._collider.entity.transform.rotationQuaternion, tempQuat, tempQuat);
+
+    const res = this._nativeShape.pointDistance(tempPos, tempQuat, point);
+    const distance = res.distance;
+    if (distance > 0) {
+      outClosestPoint.copyFrom(res.closestPoint);
+    } else {
+      outClosestPoint.copyFrom(point);
+    }
+
+    const m = ColliderShape._tempMatrix;
+    Matrix.invert(collider.entity.transform.worldMatrix, m);
+    Vector3.transformCoordinate(outClosestPoint, m, outClosestPoint);
+
+    outClosestPoint.subtract(this._position);
+
+    Quaternion.invert(tempQuat, tempQuat);
+    Vector3.transformByQuat(outClosestPoint, tempQuat, outClosestPoint);
+    return Math.sqrt(distance);
+  }
+
   /**
    * @internal
    */

packages/core/src/physics/shape/PlaneColliderShape.ts

@@ -1,3 +1,4 @@
+import { Vector3 } from "@galacean/engine-math";
 import { PhysicsScene } from "../PhysicsScene";
 import { ColliderShape } from "./ColliderShape";
 
@@ -9,4 +10,9 @@
     super();
     this._nativeShape = PhysicsScene._nativePhysics.createPlaneColliderShape(this._id, this._material._nativeMaterial);
   }
+
+  override getDistanceAndClosestPointFromPoint(point: Vector3, closestPoint: Vector3): number {
+    console.error("PlaneColliderShape is not support getDistanceAndClosestPointFromPoint");
+    return -1;
+  }
 }

packages/design/src/physics/ICollision.ts

@@ -0,0 +1,37 @@
+/**
+ * Interface of collision.
+ */
+export interface ICollision {
+  /** The unique id of the first collider. */
+  shape0Id: number;
+  /** The unique id of the second collider. */
+  shape1Id: number;
+  /** Count of contact points. */
+  contactCount: number;
+  /** Get contact points. */
+  getContacts(): PhysXVectorPxContactPairPoint;
+}
+
+interface PhysXVectorPxContactPairPoint {
+  size(): number;
+  get(index: number): IContactPoint;
+}
+
+interface IContactPoint {
+  position: {
+    x: number;
+    y: number;
+    z: number;
+  };
+  normal: {
+    x: number;
+    y: number;
+    z: number;
+  };
+  impulse: {
+    x: number;
+    y: number;
+    z: number;
+  };
+  separation: number;
+}

packages/design/src/physics/IPhysics.ts

@@ -8,6 +8,7 @@ import { IPhysicsScene } from "./IPhysicsScene";
 import { IStaticCollider } from "./IStaticCollider";
 import { IFixedJoint, IHingeJoint, ISpringJoint } from "./joints";
 import { IBoxColliderShape, ICapsuleColliderShape, IPlaneColliderShape, ISphereColliderShape } from "./shape";
+import { ICollision } from "./ICollision";
 
 /**
  * The interface of physics creation.
@@ -36,9 +37,9 @@ export interface IPhysics {
    */
   createPhysicsScene(
     physicsManager: IPhysicsManager,
-    onContactEnter?: (obj1: number, obj2: number) => void,
-    onContactExit?: (obj1: number, obj2: number) => void,
-    onContactStay?: (obj1: number, obj2: number) => void,
+    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

packages/design/src/physics/index.ts

@@ -6,5 +6,6 @@ export type { IPhysicsMaterial } from "./IPhysicsMaterial";
 export type { IPhysicsScene } from "./IPhysicsScene";
 export type { IPhysicsManager } from "./IPhysicsManager";
 export type { IStaticCollider } from "./IStaticCollider";
+export type { ICollision } from "./ICollision";
 export * from "./joints/index";
 export * from "./shape/index";

packages/design/src/physics/shape/IColliderShape.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from "@galacean/engine-math";
+import { Quaternion, Vector3 } from "@galacean/engine-math";
 import { IPhysicsMaterial } from "../IPhysicsMaterial";
 
 /**
@@ -41,8 +41,31 @@ export interface IColliderShape {
    */
   setIsTrigger(value: boolean): void;
 
+  /**
+   * Get the distance between a point and the shape.
+   * @param position - The position in world space
+   * @param rotation - The rotation in world space
+   * @param point - The point
+   * @returns The distance information
+   */
+  pointDistance(position: Vector3, rotation: Quaternion, point: Vector3): IPointDistanceInfo;
   /**
    * Decrements the reference count of a shape and releases it if the new reference count is zero.
    */
   destroy(): void;
 }
+
+/**
+ * Distance information of a point to the shape.
+ */
+export interface IPointDistanceInfo {
+  /**
+   * The distance between the point and the shape.
+   */
+  distance: number;
+
+  /**
+   * The closest point on the shape.
+   */
+  closestPoint: Vector3;
+}

packages/design/src/physics/shape/index.ts

@@ -1,4 +1,4 @@
-export type { IColliderShape } from "./IColliderShape";
+export type { IColliderShape, IPointDistanceInfo } from "./IColliderShape";
 export type { IBoxColliderShape } from "./IBoxColliderShape";
 export type { ICapsuleColliderShape } from "./ICapsuleColliderShape";
 export type { ISphereColliderShape } from "./ISphereColliderShape";