@aura3d/physics 1.4.4 → 1.5.0

package/dist/Collider.d.ts

@@ -22,6 +22,6 @@ export declare class Collider {
     readonly material: ColliderMaterial;
     constructor(id: number, bodyId: number, descriptor: ColliderDescriptor);
     canCollideWith(other: Collider): boolean;
-    bounds(position: Vec3): Bounds;
+    bounds(position: Vec3, rotation?: readonly [number, number, number, number]): Bounds;
 }
 //# sourceMappingURL=Collider.d.ts.map

package/dist/Collider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Collider.d.ts","sourceRoot":"","sources":["../../../../packages/physics/src/Collider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAE9E,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC/C,CAAC;AAEF,qBAAa,QAAQ;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;gBAExB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB;IAgCtE,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAIxC,MAAM,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM;CAG/B"}
+{"version":3,"file":"Collider.d.ts","sourceRoot":"","sources":["../../../../packages/physics/src/Collider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAE9E,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC/C,CAAC;AAEF,qBAAa,QAAQ;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;gBAExB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB;IAgCtE,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAIxC,MAAM,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;CAGrF"}

package/dist/Collider.js

@@ -38,8 +38,8 @@ export class Collider {
     canCollideWith(other) {
         return (this.filter.mask & other.filter.layer) !== 0 && (other.filter.mask & this.filter.layer) !== 0;
     }
-    bounds(position) {
-        return Shape.bounds(this.shape, position);
+    bounds(position, rotation) {
+        return Shape.bounds(this.shape, position, rotation);
     }
 }
 //# sourceMappingURL=Collider.js.map

package/dist/Collider.js.map

@@ -1 +1 @@
-{"version":3,"file":"Collider.js","sourceRoot":"","sources":["../../../../packages/physics/src/Collider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAA6C,MAAM,YAAY,CAAC;AAmB9E,MAAM,OAAO,QAAQ;IACV,EAAE,CAAS;IACX,MAAM,CAAS;IACf,KAAK,CAAe;IACpB,MAAM,CAAU;IAChB,MAAM,CAAkB;IACxB,QAAQ,CAAmB;IAEpC,YAAY,EAAU,EAAE,MAAc,EAAE,UAA8B;QACpE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;QAClE,CAAC;QACD,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,IAAI,KAAK,CAAC;QACzC,IAAI,CAAC,MAAM,GAAG;YACZ,KAAK,EAAE,UAAU,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC;YACpC,IAAI,EAAE,UAAU,CAAC,MAAM,EAAE,IAAI,IAAI,UAAU;SAC5C,CAAC;QACF,IAAI,CAAC,QAAQ,GAAG;YACd,WAAW,EAAE,UAAU,CAAC,QAAQ,EAAE,WAAW,IAAI,CAAC;YAClD,QAAQ,EAAE,UAAU,CAAC,QAAQ,EAAE,QAAQ,IAAI,GAAG;SAC/C,CAAC;QACF,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;QACpF,CAAC;QACD,IACE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;YAC3C,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;YACxC,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,CAAC;YAC7B,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,CAAC,EAC1B,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;IAED,cAAc,CAAC,KAAe;QAC5B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACxG,CAAC;IAED,MAAM,CAAC,QAAc;QACnB,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;CACF"}
+{"version":3,"file":"Collider.js","sourceRoot":"","sources":["../../../../packages/physics/src/Collider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAA6C,MAAM,YAAY,CAAC;AAmB9E,MAAM,OAAO,QAAQ;IACV,EAAE,CAAS;IACX,MAAM,CAAS;IACf,KAAK,CAAe;IACpB,MAAM,CAAU;IAChB,MAAM,CAAkB;IACxB,QAAQ,CAAmB;IAEpC,YAAY,EAAU,EAAE,MAAc,EAAE,UAA8B;QACpE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;QAClE,CAAC;QACD,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,IAAI,KAAK,CAAC;QACzC,IAAI,CAAC,MAAM,GAAG;YACZ,KAAK,EAAE,UAAU,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC;YACpC,IAAI,EAAE,UAAU,CAAC,MAAM,EAAE,IAAI,IAAI,UAAU;SAC5C,CAAC;QACF,IAAI,CAAC,QAAQ,GAAG;YACd,WAAW,EAAE,UAAU,CAAC,QAAQ,EAAE,WAAW,IAAI,CAAC;YAClD,QAAQ,EAAE,UAAU,CAAC,QAAQ,EAAE,QAAQ,IAAI,GAAG;SAC/C,CAAC;QACF,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;QACpF,CAAC;QACD,IACE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;YAC3C,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;YACxC,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,CAAC;YAC7B,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,CAAC,EAC1B,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;IAED,cAAc,CAAC,KAAe;QAC5B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACxG,CAAC;IAED,MAAM,CAAC,QAAc,EAAE,QAAoD;QACzE,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACtD,CAAC;CACF"}

package/dist/CollisionEvents.d.ts

@@ -6,6 +6,7 @@ export type Contact = {
     readonly bodyB: number;
     readonly normal: Vec3;
     readonly penetration: number;
+    readonly point?: Vec3;
     readonly sensor: boolean;
 };
 export type CollisionEventType = "begin" | "stay" | "end";

package/dist/CollisionEvents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CollisionEvents.d.ts","sourceRoot":"","sources":["../../../../packages/physics/src/CollisionEvents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AAE1D,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,MAAM,CAAwB;IAEtC,MAAM,CAAC,eAAe,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,cAAc,EAAE;IAmBtE,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,cAAc,EAAE;IAa7D,KAAK,IAAI,SAAS,cAAc,EAAE;IAMlC,gBAAgB,IAAI,SAAS,OAAO,EAAE;CAGvC"}
+{"version":3,"file":"CollisionEvents.d.ts","sourceRoot":"","sources":["../../../../packages/physics/src/CollisionEvents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AAE1D,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,MAAM,CAAwB;IAEtC,MAAM,CAAC,eAAe,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,cAAc,EAAE;IAmBtE,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,cAAc,EAAE;IAa7D,KAAK,IAAI,SAAS,cAAc,EAAE;IAMlC,gBAAgB,IAAI,SAAS,OAAO,EAAE;CAGvC"}

package/dist/CollisionEvents.js.map

@@ -1 +1 @@
-{"version":3,"file":"CollisionEvents.js","sourceRoot":"","sources":["../../../../packages/physics/src/CollisionEvents.ts"],"names":[],"mappings":"AAoBA,MAAM,UAAU,cAAc,CAAC,SAAiB,EAAE,SAAiB;IACjE,OAAO,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC,CAAC,GAAG,SAAS,IAAI,SAAS,EAAE,CAAC;AAC3F,CAAC;AAED,MAAM,OAAO,mBAAmB;IACtB,gBAAgB,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC9C,MAAM,GAAqB,EAAE,CAAC;IAEtC,MAAM,CAAC,eAAmC;QACxC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAmB,CAAC;QACxC,MAAM,MAAM,GAAqB,EAAE,CAAC;QACpC,KAAK,MAAM,OAAO,IAAI,eAAe,EAAE,CAAC;YACtC,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;YACrE,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QACjG,CAAC;QACD,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACvD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;gBACvB,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,cAAc,CAAC,UAAkB;QAC/B,MAAM,aAAa,GAAqB,EAAE,CAAC;QAC3C,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACvD,IAAI,OAAO,CAAC,SAAS,KAAK,UAAU,IAAI,OAAO,CAAC,SAAS,KAAK,UAAU,EAAE,CAAC;gBACzE,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,KAAc,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;gBACzD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACxB,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC1B,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACxC,CAAC;QACH,CAAC;QACD,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,KAAK;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,gBAAgB;QACd,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC;IACpD,CAAC;CACF"}
+{"version":3,"file":"CollisionEvents.js","sourceRoot":"","sources":["../../../../packages/physics/src/CollisionEvents.ts"],"names":[],"mappings":"AAqBA,MAAM,UAAU,cAAc,CAAC,SAAiB,EAAE,SAAiB;IACjE,OAAO,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC,CAAC,GAAG,SAAS,IAAI,SAAS,EAAE,CAAC;AAC3F,CAAC;AAED,MAAM,OAAO,mBAAmB;IACtB,gBAAgB,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC9C,MAAM,GAAqB,EAAE,CAAC;IAEtC,MAAM,CAAC,eAAmC;QACxC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAmB,CAAC;QACxC,MAAM,MAAM,GAAqB,EAAE,CAAC;QACpC,KAAK,MAAM,OAAO,IAAI,eAAe,EAAE,CAAC;YACtC,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;YACrE,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QACjG,CAAC;QACD,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACvD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;gBACvB,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,cAAc,CAAC,UAAkB;QAC/B,MAAM,aAAa,GAAqB,EAAE,CAAC;QAC3C,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACvD,IAAI,OAAO,CAAC,SAAS,KAAK,UAAU,IAAI,OAAO,CAAC,SAAS,KAAK,UAAU,EAAE,CAAC;gBACzE,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,KAAc,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;gBACzD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACxB,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC1B,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACxC,CAAC;QACH,CAAC;QACD,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,KAAK;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,gBAAgB;QACd,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC;IACpD,CAAC;CACF"}

package/dist/NarrowPhase.d.ts

@@ -0,0 +1,11 @@
+import type { Collider } from "./Collider.js";
+import type { RigidBody } from "./RigidBody.js";
+import { type Vec3 } from "./Shape.js";
+export interface NativeNarrowPhaseContact {
+    readonly normal: Vec3;
+    readonly penetration: number;
+    readonly point: Vec3;
+    readonly algorithm: "obb-sat" | "gjk-epa" | "triangle-mesh" | "heightfield-triangles";
+}
+export declare function buildNativeNarrowPhaseContact(colliderA: Collider, bodyA: RigidBody, colliderB: Collider, bodyB: RigidBody): NativeNarrowPhaseContact | undefined;
+//# sourceMappingURL=NarrowPhase.d.ts.map

package/dist/NarrowPhase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NarrowPhase.d.ts","sourceRoot":"","sources":["../../../../packages/physics/src/NarrowPhase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAYL,KAAK,IAAI,EACV,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,eAAe,GAAG,uBAAuB,CAAC;CACvF;AAoCD,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,QAAQ,EACnB,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,QAAQ,EACnB,KAAK,EAAE,SAAS,GACf,wBAAwB,GAAG,SAAS,CAmCtC"}

package/dist/NarrowPhase.js

@@ -0,0 +1,565 @@
+import { addVec3, dotVec3, lengthVec3, normalizeVec3, rotateVec3ByQuat, scaleVec3, subVec3 } from "./Shape.js";
+const BOX_FACES = [
+    [0, 2, 1], [0, 3, 2],
+    [4, 5, 6], [4, 6, 7],
+    [0, 1, 5], [0, 5, 4],
+    [3, 7, 6], [3, 6, 2],
+    [0, 4, 7], [0, 7, 3],
+    [1, 2, 6], [1, 6, 5]
+];
+const BOX_EDGES = [
+    [0, 1], [1, 2], [2, 3], [3, 0],
+    [4, 5], [5, 6], [6, 7], [7, 4],
+    [0, 4], [1, 5], [2, 6], [3, 7]
+];
+const EPSILON = 1e-8;
+export function buildNativeNarrowPhaseContact(colliderA, bodyA, colliderB, bodyB) {
+    if (colliderA.shape.kind === "box" && colliderB.shape.kind === "box") {
+        const polyA = boxPolyhedron(colliderA.shape.halfExtents, bodyA);
+        const polyB = boxPolyhedron(colliderB.shape.halfExtents, bodyB);
+        const result = satPolyhedra(polyA, polyB);
+        return result ? { ...result, algorithm: "obb-sat" } : undefined;
+    }
+    if (isConvexSolid(colliderA.shape) && isConvexSolid(colliderB.shape)) {
+        const polyA = convexPolyhedron(colliderA.shape, bodyA);
+        const polyB = convexPolyhedron(colliderB.shape, bodyB);
+        const gjkSimplex = gjkIntersection(polyA, polyB);
+        if (!gjkSimplex)
+            return undefined;
+        const epa = epaPenetration(polyA, polyB, gjkSimplex) ?? satPolyhedra(polyA, polyB);
+        return epa ? { ...epa, algorithm: "gjk-epa" } : undefined;
+    }
+    const meshA = isTriangleSurface(colliderA.shape);
+    const meshB = isTriangleSurface(colliderB.shape);
+    if (meshA === meshB)
+        return undefined;
+    const surfaceShape = meshA
+        ? colliderA.shape
+        : colliderB.shape;
+    const surfaceBody = meshA ? bodyA : bodyB;
+    const solidShape = meshA ? colliderB.shape : colliderA.shape;
+    const solidBody = meshA ? bodyB : bodyA;
+    const solidIsA = !meshA;
+    const contact = collideSolidWithSurface(solidShape, solidBody, surfaceShape, surfaceBody);
+    if (!contact)
+        return undefined;
+    return {
+        normal: solidIsA ? contact.normal : scaleVec3(contact.normal, -1),
+        penetration: contact.penetration,
+        point: contact.point,
+        algorithm: surfaceShape.kind === "heightfield" ? "heightfield-triangles" : "triangle-mesh"
+    };
+}
+function isConvexSolid(shape) {
+    return shape.kind === "box" || shape.kind === "convex-hull";
+}
+function isTriangleSurface(shape) {
+    return shape.kind === "mesh" || shape.kind === "heightfield";
+}
+function boxPolyhedron(halfExtents, body) {
+    const [x, y, z] = halfExtents;
+    const local = [
+        [-x, -y, -z], [x, -y, -z], [x, y, -z], [-x, y, -z],
+        [-x, -y, z], [x, -y, z], [x, y, z], [-x, y, z]
+    ];
+    return {
+        vertices: local.map((vertex) => worldPoint(vertex, body)),
+        faces: BOX_FACES,
+        edges: BOX_EDGES,
+        center: [...body.position]
+    };
+}
+function convexPolyhedron(shape, body) {
+    if (shape.kind === "box")
+        return boxPolyhedron(shape.halfExtents, body);
+    const faces = [];
+    for (let offset = 0; offset < shape.indices.length; offset += 3) {
+        faces.push([shape.indices[offset], shape.indices[offset + 1], shape.indices[offset + 2]]);
+    }
+    return {
+        vertices: shape.vertices.map((vertex) => worldPoint(vertex, body)),
+        faces,
+        edges: uniqueEdges(faces),
+        center: worldPoint(centroid(shape.vertices), body)
+    };
+}
+function satPolyhedra(a, b) {
+    const axes = [
+        ...faceAxes(a),
+        ...faceAxes(b)
+    ];
+    const edgesA = edgeDirections(a);
+    const edgesB = edgeDirections(b);
+    for (const edgeA of edgesA) {
+        for (const edgeB of edgesB) {
+            const axis = cross(edgeA, edgeB);
+            if (lengthVec3(axis) > EPSILON)
+                axes.push(normalizeVec3(axis));
+        }
+    }
+    return minimumOverlapContact(a, b, axes);
+}
+function minimumOverlapContact(a, b, axes) {
+    let minimumOverlap = Number.POSITIVE_INFINITY;
+    let minimumAxis = [1, 0, 0];
+    for (const candidate of axes) {
+        if (lengthVec3(candidate) <= EPSILON)
+            continue;
+        const axis = normalizeVec3(candidate);
+        const projectionA = project(a.vertices, axis);
+        const projectionB = project(b.vertices, axis);
+        const overlap = Math.min(projectionA.max, projectionB.max) - Math.max(projectionA.min, projectionB.min);
+        if (overlap <= EPSILON)
+            return undefined;
+        if (overlap < minimumOverlap) {
+            minimumOverlap = overlap;
+            minimumAxis = axis;
+        }
+    }
+    if (!Number.isFinite(minimumOverlap))
+        return undefined;
+    const centerDelta = subVec3(b.center, a.center);
+    const normal = dotVec3(centerDelta, minimumAxis) < 0 ? scaleVec3(minimumAxis, -1) : minimumAxis;
+    const point = opposingSupportContactPoint(a.vertices, b.vertices, normal);
+    return {
+        normal,
+        penetration: minimumOverlap,
+        point
+    };
+}
+function gjkIntersection(a, b) {
+    let direction = subVec3(b.center, a.center);
+    if (lengthVec3(direction) <= EPSILON)
+        direction = [1, 0, 0];
+    const simplex = [minkowskiSupport(a, b, direction)];
+    direction = scaleVec3(simplex[0].point, -1);
+    for (let iteration = 0; iteration < 32; iteration += 1) {
+        if (lengthVec3(direction) <= EPSILON)
+            direction = [1, 0, 0];
+        const next = minkowskiSupport(a, b, direction);
+        if (dotVec3(next.point, direction) < EPSILON)
+            return undefined;
+        simplex.push(next);
+        const update = updateSimplex(simplex);
+        if (update.containsOrigin)
+            return simplex;
+        direction = update.direction;
+    }
+    return undefined;
+}
+function updateSimplex(simplex) {
+    const a = simplex[simplex.length - 1].point;
+    const ao = scaleVec3(a, -1);
+    if (simplex.length === 2) {
+        const b = simplex[0].point;
+        const ab = subVec3(b, a);
+        if (dotVec3(ab, ao) > 0)
+            return { containsOrigin: false, direction: tripleCross(ab, ao, ab) };
+        simplex.splice(0, 1);
+        return { containsOrigin: false, direction: ao };
+    }
+    if (simplex.length === 3) {
+        const b = simplex[1].point;
+        const c = simplex[0].point;
+        const ab = subVec3(b, a);
+        const ac = subVec3(c, a);
+        const abc = cross(ab, ac);
+        if (dotVec3(cross(abc, ac), ao) > 0) {
+            if (dotVec3(ac, ao) > 0) {
+                simplex.splice(1, 1);
+                return { containsOrigin: false, direction: tripleCross(ac, ao, ac) };
+            }
+            simplex.splice(0, 1);
+            return updateSimplex(simplex);
+        }
+        if (dotVec3(cross(ab, abc), ao) > 0) {
+            simplex.splice(0, 1);
+            return updateSimplex(simplex);
+        }
+        if (dotVec3(abc, ao) > 0)
+            return { containsOrigin: false, direction: abc };
+        [simplex[0], simplex[1]] = [simplex[1], simplex[0]];
+        return { containsOrigin: false, direction: scaleVec3(abc, -1) };
+    }
+    const b = simplex[2].point;
+    const c = simplex[1].point;
+    const d = simplex[0].point;
+    const ab = subVec3(b, a);
+    const ac = subVec3(c, a);
+    const ad = subVec3(d, a);
+    const abc = outwardFaceNormal(a, b, c, d);
+    const acd = outwardFaceNormal(a, c, d, b);
+    const adb = outwardFaceNormal(a, d, b, c);
+    if (dotVec3(abc, ao) > 0) {
+        simplex.splice(0, 1);
+        return { containsOrigin: false, direction: abc };
+    }
+    if (dotVec3(acd, ao) > 0) {
+        simplex.splice(2, 1);
+        return { containsOrigin: false, direction: acd };
+    }
+    if (dotVec3(adb, ao) > 0) {
+        simplex.splice(1, 1);
+        return { containsOrigin: false, direction: adb };
+    }
+    return { containsOrigin: true, direction: [0, 0, 0] };
+}
+function epaPenetration(a, b, simplex) {
+    if (simplex.length < 4)
+        return undefined;
+    const vertices = [...simplex.slice(-4)];
+    let faces = [
+        createEpaFace(vertices, [0, 1, 2]),
+        createEpaFace(vertices, [0, 3, 1]),
+        createEpaFace(vertices, [0, 2, 3]),
+        createEpaFace(vertices, [1, 3, 2])
+    ].filter((face) => face !== undefined);
+    for (let iteration = 0; iteration < 48; iteration += 1) {
+        faces.sort((left, right) => left.distance - right.distance);
+        const closest = faces[0];
+        if (!closest)
+            return undefined;
+        const support = minkowskiSupport(a, b, closest.normal);
+        const supportDistance = dotVec3(support.point, closest.normal);
+        if (supportDistance - closest.distance <= 1e-6) {
+            const centerDelta = subVec3(b.center, a.center);
+            const normal = dotVec3(centerDelta, closest.normal) < 0 ? scaleVec3(closest.normal, -1) : closest.normal;
+            return {
+                normal,
+                penetration: Math.max(closest.distance, EPSILON),
+                point: opposingSupportContactPoint(a.vertices, b.vertices, normal)
+            };
+        }
+        const newIndex = vertices.push(support) - 1;
+        const visible = faces.filter((face) => dotVec3(face.normal, subVec3(support.point, vertices[face.indices[0]].point)) > 1e-7);
+        const boundary = boundaryEdges(visible);
+        faces = faces.filter((face) => !visible.includes(face));
+        for (const [from, to] of boundary) {
+            const face = createEpaFace(vertices, [from, to, newIndex]);
+            if (face)
+                faces.push(face);
+        }
+    }
+    return undefined;
+}
+function collideSolidWithSurface(solidShape, solidBody, surfaceShape, surfaceBody) {
+    const triangles = surfaceTriangles(surfaceShape, surfaceBody);
+    let best;
+    for (const triangle of triangles) {
+        const contact = solidShape.kind === "sphere"
+            ? sphereTriangleContact(solidBody.position, solidShape.radius, triangle)
+            : solidShape.kind === "capsule"
+                ? capsuleTriangleContact(solidBody, solidShape.radius, solidShape.halfHeight, triangle)
+                : isConvexSolid(solidShape)
+                    ? polyhedronTriangleContact(convexPolyhedron(solidShape, solidBody), triangle)
+                    : undefined;
+        if (contact && (!best || contact.penetration > best.penetration))
+            best = contact;
+    }
+    return best;
+}
+function capsuleTriangleContact(body, radius, halfHeight, triangle) {
+    const axis = rotateVec3ByQuat([0, halfHeight, 0], body.rotation);
+    const start = subVec3(body.position, axis);
+    const end = addVec3(body.position, axis);
+    const candidates = [
+        { segment: start, triangle: closestPointOnTriangle(start, ...triangle) },
+        { segment: end, triangle: closestPointOnTriangle(end, ...triangle) }
+    ];
+    for (const vertex of triangle) {
+        candidates.push({ segment: closestPointOnSegment(vertex, start, end), triangle: vertex });
+    }
+    const planeNormal = normalizeOr(cross(subVec3(triangle[1], triangle[0]), subVec3(triangle[2], triangle[0])), [0, 1, 0]);
+    const denominator = dotVec3(planeNormal, subVec3(end, start));
+    if (Math.abs(denominator) > EPSILON) {
+        const t = dotVec3(planeNormal, subVec3(triangle[0], start)) / denominator;
+        if (t >= 0 && t <= 1) {
+            const point = addVec3(start, scaleVec3(subVec3(end, start), t));
+            const trianglePoint = closestPointOnTriangle(point, ...triangle);
+            if (lengthVec3(subVec3(point, trianglePoint)) <= 1e-7)
+                candidates.push({ segment: point, triangle: trianglePoint });
+        }
+    }
+    const closest = candidates.reduce((best, candidate) => squaredDistance(candidate.segment, candidate.triangle) < squaredDistance(best.segment, best.triangle) ? candidate : best);
+    const delta = subVec3(closest.triangle, closest.segment);
+    const distance = lengthVec3(delta);
+    if (distance >= radius)
+        return undefined;
+    return {
+        normal: distance > EPSILON ? scaleVec3(delta, 1 / distance) : orientToward(planeNormal, subVec3(centroid(triangle), body.position)),
+        penetration: radius - distance,
+        point: closest.triangle
+    };
+}
+function sphereTriangleContact(center, radius, triangle) {
+    const point = closestPointOnTriangle(center, triangle[0], triangle[1], triangle[2]);
+    const delta = subVec3(point, center);
+    const distance = lengthVec3(delta);
+    if (distance >= radius)
+        return undefined;
+    const triangleNormal = normalizeOr(cross(subVec3(triangle[1], triangle[0]), subVec3(triangle[2], triangle[0])), [0, 1, 0]);
+    return {
+        normal: distance > EPSILON ? scaleVec3(delta, 1 / distance) : orientToward(triangleNormal, subVec3(centroid(triangle), center)),
+        penetration: radius - distance,
+        point
+    };
+}
+function polyhedronTriangleContact(poly, triangle) {
+    const triangleCenter = centroid(triangle);
+    let triangleNormal = normalizeOr(cross(subVec3(triangle[1], triangle[0]), subVec3(triangle[2], triangle[0])), [0, 1, 0]);
+    const plane = dotVec3(triangleNormal, triangle[0]);
+    const distances = poly.vertices.map((vertex) => dotVec3(triangleNormal, vertex) - plane);
+    const centerDistance = dotVec3(triangleNormal, poly.center) - plane;
+    const penetration = centerDistance >= 0 ? -Math.min(...distances) : Math.max(...distances);
+    if (penetration <= EPSILON)
+        return undefined;
+    triangleNormal = centerDistance >= 0 ? scaleVec3(triangleNormal, -1) : triangleNormal;
+    const triangleEdges = [
+        subVec3(triangle[1], triangle[0]),
+        subVec3(triangle[2], triangle[1]),
+        subVec3(triangle[0], triangle[2])
+    ];
+    const axes = [...faceAxes(poly)];
+    for (const triangleEdge of triangleEdges) {
+        axes.push(normalizeOr(cross(triangleEdge, triangleNormal), [1, 0, 0]));
+        for (const polyEdge of edgeDirections(poly)) {
+            const axis = cross(triangleEdge, polyEdge);
+            if (lengthVec3(axis) > EPSILON)
+                axes.push(normalizeVec3(axis));
+        }
+    }
+    for (const axis of axes) {
+        const projectionPoly = project(poly.vertices, axis);
+        const projectionTriangle = project(triangle, axis);
+        if (Math.min(projectionPoly.max, projectionTriangle.max) - Math.max(projectionPoly.min, projectionTriangle.min) < -EPSILON) {
+            return undefined;
+        }
+    }
+    const support = supportVertex(poly.vertices, triangleNormal);
+    const point = closestPointOnTriangle(support, triangle[0], triangle[1], triangle[2]);
+    return {
+        normal: orientToward(triangleNormal, subVec3(triangleCenter, poly.center)),
+        penetration,
+        point
+    };
+}
+function surfaceTriangles(shape, body) {
+    if (shape.kind === "mesh") {
+        const triangles = [];
+        for (let offset = 0; offset < shape.indices.length; offset += 3) {
+            triangles.push([
+                worldPoint(shape.vertices[shape.indices[offset]], body),
+                worldPoint(shape.vertices[shape.indices[offset + 1]], body),
+                worldPoint(shape.vertices[shape.indices[offset + 2]], body)
+            ]);
+        }
+        return triangles;
+    }
+    const triangles = [];
+    const halfWidth = (shape.columns - 1) * shape.cellSize * 0.5;
+    const halfDepth = (shape.rows - 1) * shape.cellSize * 0.5;
+    const sample = (row, column) => worldPoint([
+        column * shape.cellSize - halfWidth,
+        shape.heights[row * shape.columns + column],
+        row * shape.cellSize - halfDepth
+    ], body);
+    for (let row = 0; row < shape.rows - 1; row += 1) {
+        for (let column = 0; column < shape.columns - 1; column += 1) {
+            const a = sample(row, column);
+            const b = sample(row, column + 1);
+            const c = sample(row + 1, column);
+            const d = sample(row + 1, column + 1);
+            triangles.push([a, c, b], [b, c, d]);
+        }
+    }
+    return triangles;
+}
+function faceAxes(poly) {
+    const axes = [];
+    for (const [a, b, c] of poly.faces) {
+        const normal = cross(subVec3(poly.vertices[b], poly.vertices[a]), subVec3(poly.vertices[c], poly.vertices[a]));
+        if (lengthVec3(normal) > EPSILON)
+            axes.push(normalizeVec3(normal));
+    }
+    return uniqueAxes(axes);
+}
+function edgeDirections(poly) {
+    return uniqueAxes(poly.edges.map(([a, b]) => normalizeOr(subVec3(poly.vertices[b], poly.vertices[a]), [1, 0, 0])));
+}
+function uniqueEdges(faces) {
+    const keys = new Set();
+    const edges = [];
+    for (const [a, b, c] of faces) {
+        for (const [left, right] of [[a, b], [b, c], [c, a]]) {
+            const edge = left < right ? [left, right] : [right, left];
+            const key = `${edge[0]}:${edge[1]}`;
+            if (!keys.has(key)) {
+                keys.add(key);
+                edges.push(edge);
+            }
+        }
+    }
+    return edges;
+}
+function uniqueAxes(axes) {
+    const unique = [];
+    for (const axis of axes) {
+        if (!unique.some((candidate) => Math.abs(dotVec3(candidate, axis)) > 0.999999))
+            unique.push(axis);
+    }
+    return unique;
+}
+function minkowskiSupport(a, b, direction) {
+    const pointA = supportVertex(a.vertices, direction);
+    const pointB = supportVertex(b.vertices, scaleVec3(direction, -1));
+    return { point: subVec3(pointA, pointB), pointA, pointB };
+}
+function supportVertex(vertices, direction) {
+    let best = vertices[0];
+    let bestProjection = dotVec3(best, direction);
+    for (let index = 1; index < vertices.length; index += 1) {
+        const projection = dotVec3(vertices[index], direction);
+        if (projection > bestProjection) {
+            best = vertices[index];
+            bestProjection = projection;
+        }
+    }
+    return best;
+}
+function opposingSupportContactPoint(verticesA, verticesB, normal) {
+    const featureA = supportFeature(verticesA, normal);
+    const featureB = supportFeature(verticesB, scaleVec3(normal, -1));
+    const selected = featureA.spread <= featureB.spread ? featureA.point : featureB.point;
+    const middlePlane = (dotVec3(featureA.point, normal) + dotVec3(featureB.point, normal)) * 0.5;
+    return addVec3(selected, scaleVec3(normal, middlePlane - dotVec3(selected, normal)));
+}
+function supportFeature(vertices, direction) {
+    const maximum = Math.max(...vertices.map((vertex) => dotVec3(vertex, direction)));
+    const support = vertices.filter((vertex) => maximum - dotVec3(vertex, direction) <= 1e-7);
+    const point = centroid(support);
+    const spread = support.reduce((sum, vertex) => sum + squaredDistance(vertex, point), 0);
+    return { point, spread };
+}
+function project(vertices, axis) {
+    let min = dotVec3(vertices[0], axis);
+    let max = min;
+    for (let index = 1; index < vertices.length; index += 1) {
+        const value = dotVec3(vertices[index], axis);
+        min = Math.min(min, value);
+        max = Math.max(max, value);
+    }
+    return { min, max };
+}
+function createEpaFace(vertices, indices) {
+    const a = vertices[indices[0]].point;
+    const b = vertices[indices[1]].point;
+    const c = vertices[indices[2]].point;
+    let normal = cross(subVec3(b, a), subVec3(c, a));
+    if (lengthVec3(normal) <= EPSILON)
+        return undefined;
+    normal = normalizeVec3(normal);
+    let distance = dotVec3(normal, a);
+    let orientedIndices = indices;
+    if (distance < 0) {
+        normal = scaleVec3(normal, -1);
+        distance = -distance;
+        orientedIndices = [indices[0], indices[2], indices[1]];
+    }
+    return { indices: orientedIndices, normal, distance };
+}
+function boundaryEdges(faces) {
+    const edges = [];
+    for (const face of faces) {
+        for (const edge of [
+            [face.indices[0], face.indices[1]],
+            [face.indices[1], face.indices[2]],
+            [face.indices[2], face.indices[0]]
+        ]) {
+            const reverse = edges.findIndex((candidate) => candidate[0] === edge[1] && candidate[1] === edge[0]);
+            if (reverse >= 0)
+                edges.splice(reverse, 1);
+            else
+                edges.push(edge);
+        }
+    }
+    return edges;
+}
+function worldPoint(local, body) {
+    return addVec3(body.position, rotateVec3ByQuat(local, body.rotation));
+}
+function centroid(points) {
+    const sum = points.reduce((value, point) => addVec3(value, point), [0, 0, 0]);
+    return scaleVec3(sum, 1 / points.length);
+}
+function cross(a, b) {
+    return [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0]
+    ];
+}
+function tripleCross(a, b, c) {
+    const result = cross(cross(a, b), c);
+    return lengthVec3(result) > EPSILON ? result : perpendicular(c);
+}
+function perpendicular(value) {
+    const reference = Math.abs(value[0]) < Math.abs(value[1]) ? [1, 0, 0] : [0, 1, 0];
+    return normalizeOr(cross(value, reference), [0, 0, 1]);
+}
+function outwardFaceNormal(a, b, c, opposite) {
+    let normal = normalizeOr(cross(subVec3(b, a), subVec3(c, a)), [1, 0, 0]);
+    if (dotVec3(normal, subVec3(opposite, a)) > 0)
+        normal = scaleVec3(normal, -1);
+    return normal;
+}
+function orientToward(normal, direction) {
+    return dotVec3(normal, direction) < 0 ? scaleVec3(normal, -1) : normal;
+}
+function normalizeOr(value, fallback) {
+    return lengthVec3(value) > EPSILON ? normalizeVec3(value) : fallback;
+}
+function closestPointOnTriangle(point, a, b, c) {
+    const ab = subVec3(b, a);
+    const ac = subVec3(c, a);
+    const ap = subVec3(point, a);
+    const d1 = dotVec3(ab, ap);
+    const d2 = dotVec3(ac, ap);
+    if (d1 <= 0 && d2 <= 0)
+        return a;
+    const bp = subVec3(point, b);
+    const d3 = dotVec3(ab, bp);
+    const d4 = dotVec3(ac, bp);
+    if (d3 >= 0 && d4 <= d3)
+        return b;
+    const vc = d1 * d4 - d3 * d2;
+    if (vc <= 0 && d1 >= 0 && d3 <= 0)
+        return addVec3(a, scaleVec3(ab, d1 / (d1 - d3)));
+    const cp = subVec3(point, c);
+    const d5 = dotVec3(ab, cp);
+    const d6 = dotVec3(ac, cp);
+    if (d6 >= 0 && d5 <= d6)
+        return c;
+    const vb = d5 * d2 - d1 * d6;
+    if (vb <= 0 && d2 >= 0 && d6 <= 0)
+        return addVec3(a, scaleVec3(ac, d2 / (d2 - d6)));
+    const va = d3 * d6 - d5 * d4;
+    if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0)
+        return addVec3(b, scaleVec3(subVec3(c, b), (d4 - d3) / ((d4 - d3) + (d5 - d6))));
+    const denominator = 1 / (va + vb + vc);
+    const v = vb * denominator;
+    const w = vc * denominator;
+    return addVec3(a, addVec3(scaleVec3(ab, v), scaleVec3(ac, w)));
+}
+function closestPointOnSegment(point, start, end) {
+    const direction = subVec3(end, start);
+    const denominator = dotVec3(direction, direction);
+    if (denominator <= EPSILON)
+        return start;
+    const t = Math.max(0, Math.min(1, dotVec3(subVec3(point, start), direction) / denominator));
+    return addVec3(start, scaleVec3(direction, t));
+}
+function squaredDistance(a, b) {
+    const delta = subVec3(a, b);
+    return dotVec3(delta, delta);
+}
+//# sourceMappingURL=NarrowPhase.js.map