refactor: opt code

Author: luzhuang

packages/core/src/physics/Collision.ts

@@ -5,15 +5,15 @@ import { ICollision } from "@galacean/engine-design";
 /**
  * Describes a contact point where the collision occurs.
  */
-export interface ContractPoint {
+export interface ContactPoint {
   /** The position of the contact point between the shapes, in world space. */
-  position: Vector3;
+  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. */
-  normal: Vector3;
+  readonly normal: Vector3;
   /** The impulse applied at the contact point, in world space. Divide by the simulation time step to get a force value. */
-  impulse: Vector3;
+  readonly impulse: Vector3;
   /** The separation of the shapes at the contact point.  A negative separation denotes a penetration. */
-  separation: number;
+  readonly separation: number;
 }
 
 export class Collision {
@@ -32,22 +32,22 @@ export class Collision {
 
   /**
    * Get contact points.
-   * @param contacts - The result of contact points
+   * @param outContacts - The result of contact points
    * @returns The result of contact points
    */
-  getContacts(contacts: ContractPoint[]): ContractPoint[] {
-    const nativeContractPoints = this._nativeCollision.getContacts();
-    for (let i = 0, n = nativeContractPoints.size(); i < n; i++) {
-      const nativeContractPoint = nativeContractPoints.get(i);
+  getContacts(outContacts: ContactPoint[]): ContactPoint[] {
+    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;
-      const contact: ContractPoint = {
+      const contact: ContactPoint = {
         position: new Vector3(position.x, position.y, position.z),
         normal: new Vector3(normal.x, normal.y, normal.z),
         impulse: new Vector3(impulse.x, impulse.y, impulse.z),
         separation: separation
       };
-      contacts.push(contact);
+      outContacts.push(contact);
     }
-    return contacts;
+    return outContacts;
   }
 }

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

@@ -138,20 +138,20 @@ export abstract class ColliderShape implements ICustomClone {
   /**
    * Get the distance and the closest point on the shape from a point.
    * @param point - The point
-   * @param closestPoint - The closest point on the shape
+   * @param outClosestPoint - The result of the closest point on the shape
    * @returns The distance between the point and the shape
    */
-  getDistanceAndClosestPointFromPoint(point: Vector3, closestPoint: Vector3): number {
+  getDistanceAndClosestPointFromPoint(point: Vector3, outClosestPoint: Vector3): number {
     const tempQuat = ColliderShape._tempWorldRot;
     const tempPos = ColliderShape._tempWorldPos;
     Vector3.add(this._collider.entity.transform.position, this._position, tempPos);
     Quaternion.fromAngle(this._rotation, tempQuat);
     Quaternion.multiply(this._collider.entity.transform.rotationQuaternion, tempQuat, tempQuat);
     const res = this._nativeShape.pointDistance(tempPos, tempQuat, point);
     const distance = res.distance;
-    closestPoint.copyFrom(res.closestPoint);
+    outClosestPoint.copyFrom(res.closestPoint);
     if (distance > 0) {
-      closestPoint.subtract(tempPos);
+      outClosestPoint.subtract(tempPos);
     }
     return Math.sqrt(distance);
   }

packages/design/src/physics/ICollision.ts

@@ -14,10 +14,10 @@ export interface ICollision {
 
 interface PhysXVectorPxContactPairPoint {
   size(): number;
-  get(index: number): IContractPoint;
+  get(index: number): IContactPoint;
 }
 
-interface IContractPoint {
+interface IContactPoint {
   position: {
     x: number;
     y: number;