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,46 @@
+import { ContactPoint } from "./ContactPoint";
 import { ColliderShape } from "./shape";
+import { ICollision } from "@galacean/engine-design";
 
+/**
+ * Collision information between two shapes when they collide.
+ */
 export class Collision {
+  /** @internal */
+  _nativeCollision: ICollision;
+
+  /** The target shape be collided. */
   shape: ColliderShape;
+
+  /**
+   * Count of contact points.
+   */
+  get contactCount(): number {
+    return this._nativeCollision.contactCount;
+  }
+
+  /**
+   * Get contact points.
+   * @param outContacts - The result of contact points
+   * @returns The actual count of contact points
+   * @remarks To optimize performance, the engine does not modify the length of the array you pass.
+   * You need to obtain the actual number of contact points from the function's return value.
+   */
+  getContacts(outContacts: ContactPoint[]): number {
+    const { shape0Id, shape1Id } = this._nativeCollision;
+    const factor = shape0Id < shape1Id ? 1 : -1;
+
+    const nativeContactPoints = this._nativeCollision.getContacts();
+    const length = nativeContactPoints.size();
+    for (let i = 0; i < length; i++) {
+      const nativeContractPoint = nativeContactPoints.get(i);
+
+      const contact = (outContacts[i] ||= new ContactPoint());
+      contact.position.copyFrom(nativeContractPoint.position);
+      contact.normal.copyFrom(nativeContractPoint.normal).scale(factor);
+      contact.impulse.copyFrom(nativeContractPoint.impulse).scale(factor);
+      contact.separation = nativeContractPoint.separation;
+    }
+    return length;
+  }
 }

packages/core/src/physics/ContactPoint.ts

@@ -0,0 +1,15 @@
+import { Vector3 } from "@galacean/engine-math";
+
+/**
+ * Describes a contact point where the collision occurs.
+ */
+export class ContactPoint {
+  /** The position of the contact point between the shapes, in world space. */
+  readonly position = new 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 = new Vector3();
+  /** The impulse applied at the contact point, in world space. Divide by the simulation time step to get a force value. */
+  readonly impulse = new Vector3();
+  /** The separation of the shapes at the contact point.  A negative separation denotes a penetration. */
+  separation: number;
+}

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/index.ts

@@ -5,6 +5,8 @@ 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";

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,8 @@ 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();
 
   /** @internal */
   @ignoreClone
@@ -80,7 +82,7 @@ export abstract class ColliderShape implements ICustomClone {
   }
 
   /**
-   * The local rotation of this ColliderShape.
+   * The local rotation of this ColliderShape, in radians.
    */
   get rotation(): Vector3 {
     return this._rotation;
@@ -133,6 +135,30 @@ 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 - Location in world space you want to find the closest point to
+   * @param outClosestPoint - The closest point on the shape in world space
+   * @returns The distance between the point and the shape
+   */
+  getClosestPoint(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 res = this._nativeShape.pointDistance(point);
+    const distance = res.w;
+    if (distance > 0) {
+      outClosestPoint.set(res.x, res.y, res.z);
+    } else {
+      outClosestPoint.copyFrom(point);
+    }
+
+    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 @@ export class PlaneColliderShape extends ColliderShape {
     super();
     this._nativeShape = PhysicsScene._nativePhysics.createPlaneColliderShape(this._id, this._material._nativeMaterial);
   }
+
+  override getClosestPoint(point: Vector3, closestPoint: Vector3): number {
+    console.error("PlaneColliderShape is not support getClosestPoint");
+    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(): VectorContactPairPoint;
+}
+
+interface VectorContactPairPoint {
+  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, Vector4 } from "@galacean/engine-math";
 import { IPhysicsMaterial } from "../IPhysicsMaterial";
 
 /**
@@ -41,6 +41,12 @@ export interface IColliderShape {
    */
   setIsTrigger(value: boolean): void;
 
+  /**
+   * Get the distance between a point and the shape.
+   * @param point - The point
+   * @returns The distance information
+   */
+  pointDistance(point: Vector3): Vector4;
   /**
    * Decrements the reference count of a shape and releases it if the new reference count is zero.
    */