babylon-box3d 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "babylon-box3d",
-    "version": "0.2.0",
+    "version": "0.4.0",
     "description": "Box3D physics for Babylon.js: Erin Catto's 3D rigid body engine compiled to WebAssembly plus a physics v2 plugin (Box3DPlugin)",
     "license": "MIT",
     "author": "Andrew Butt",
@@ -29,10 +29,18 @@
             "types": "./lib/esm/box3d.d.ts",
             "default": "./lib/esm/box3d.js"
         },
+        "./wasm/threads": {
+            "types": "./lib/esm-threads/box3d.d.ts",
+            "default": "./lib/esm-threads/box3d.js"
+        },
         "./wasm/node": {
             "types": "./lib/node/box3d.d.ts",
             "default": "./lib/node/box3d.mjs"
         },
+        "./wasm/node-threads": {
+            "types": "./lib/node-threads/box3d.d.ts",
+            "default": "./lib/node-threads/box3d.mjs"
+        },
         "./lib/*": "./lib/*",
         "./umd/*": "./umd/*",
         "./package.json": "./package.json"

package/umd/babylon.box3d.js

@@ -1,4 +1,4 @@
-/* babylon-box3d 0.2.0 | MIT | https://github.com/Pryme8/babylon-box3d */
+/* babylon-box3d 0.4.0 | MIT | https://github.com/Pryme8/babylon-box3d */
 "use strict";
 var BABYLONBOX3D = (() => {
   var __create = Object.create;
@@ -7,6 +7,9 @@ var BABYLONBOX3D = (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
   var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
@@ -122,13 +125,43 @@ var BABYLONBOX3D = (() => {
     }
   });
 
+  // box3d-global:babylon-box3d/wasm
+  var wasm_exports = {};
+  __export(wasm_exports, {
+    default: () => wasm_default
+  });
+  var wasm_default;
+  var init_wasm = __esm({
+    "box3d-global:babylon-box3d/wasm"() {
+      if (typeof Box3D === "undefined") {
+        throw new Error("babylon.box3d.js needs lib/umd/box3d.umd.js loaded first");
+      }
+      wasm_default = Box3D;
+    }
+  });
+
+  // box3d-threads-stub:babylon-box3d/wasm/threads
+  var threads_exports = {};
+  __export(threads_exports, {
+    default: () => threads_default
+  });
+  function threads_default() {
+    throw new Error('babylon.box3d.js is the script tag build and has no threaded module. Install the package and import it, or use LoadBox3D({ threads: "auto" }).');
+  }
+  var init_threads = __esm({
+    "box3d-threads-stub:babylon-box3d/wasm/threads"() {
+    }
+  });
+
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
     BOX3D_HEIGHT_FIELD_HOLE: () => BOX3D_HEIGHT_FIELD_HOLE,
     Box3D: () => wasm_default,
     Box3DPlugin: () => Box3DPlugin,
-    Box3DWheelJoint: () => Box3DWheelJoint
+    Box3DWheelJoint: () => Box3DWheelJoint,
+    CanUseBox3DThreads: () => CanUseBox3DThreads,
+    LoadBox3D: () => LoadBox3D
   });
 
   // src/box3dPlugin.ts
@@ -412,6 +445,7 @@ var BABYLONBOX3D = (() => {
     "_bx_DestroyBody",
     "_bx_DestroyJoint",
     "_bx_DestroyWorld",
+    "_bx_GetMaxWorkers",
     "_bx_GetRejectedSlotCount",
     "_bx_Joint_EnableLimit",
     "_bx_Joint_EnableMotor",
@@ -467,6 +501,7 @@ var BABYLONBOX3D = (() => {
     "_bx_World_GetMoveEvents",
     "_bx_World_GetSensorEvents",
     "_bx_World_GetStats",
+    "_bx_World_GetWorkerCount",
     "_bx_World_SetGravity",
     "_bx_World_SetMaximumLinearSpeed",
     "_bx_World_Step"
@@ -476,13 +511,16 @@ var BABYLONBOX3D = (() => {
      * Creates a Box3D plugin.
      * @param _useDeltaForWorldStep step the world with the frame delta (true) or a fixed time step (false)
      * @param box3dModule the resolved Box3D WASM module (await Box3DModule())
+     * @param options worker count and sub steps, see IBox3DPluginOptions
      */
-    constructor(_useDeltaForWorldStep = true, box3dModule) {
+    constructor(_useDeltaForWorldStep = true, box3dModule, options) {
       this._useDeltaForWorldStep = _useDeltaForWorldStep;
       /** Name of the plugin */
       this.name = "Box3DPlugin";
       /** Number of solver sub steps per world step. Box3D recommends 4. */
       this.subStepCount = 4;
+      /** Workers box3d puts on a world step, counting the calling thread. 1 unless the threaded module asked for more. */
+      this.workerCount = 1;
       /** Wall clock time of the last world step in milliseconds (JavaScript side, includes the event sync). */
       this.lastStepTimeMs = 0;
       this._worldSlot = 0;
@@ -518,10 +556,40 @@ var BABYLONBOX3D = (() => {
       }
       this._b3 = box3dModule;
       this.world = box3dModule;
-      this._worldSlot = this._b3._bx_CreateWorld(0, -9.81, 0);
+      if (options?.subStepCount !== void 0) {
+        this.subStepCount = Math.max(1, Math.round(options.subStepCount));
+      }
+      this._worldSlot = this._b3._bx_CreateWorld(0, -9.81, 0, this._resolveWorkerCount(options?.workerCount));
       if (!this._worldSlot) {
         throw new Error("Box3D: could not create a world (max worlds reached?)");
       }
+      this.workerCount = Math.max(1, this._b3._bx_World_GetWorkerCount(this._worldSlot));
+    }
+    /**
+     * Turns the requested worker count into one this module can honour. Only the threaded build reports more than one,
+     * and asking a single threaded build for workers is quiet enough to look like it worked, so say so once.
+     * @param requested the constructor option
+     * @returns the count to create the world with
+     */
+    _resolveWorkerCount(requested) {
+      const supported = Math.max(1, this._b3._bx_GetMaxWorkers());
+      if (requested === void 0) {
+        return 1;
+      }
+      let wanted;
+      if (requested === "auto") {
+        const cores = typeof navigator !== "undefined" && navigator.hardwareConcurrency || 4;
+        wanted = Math.max(1, Math.floor(cores / 2));
+      } else {
+        wanted = Math.max(1, Math.round(requested));
+      }
+      if (wanted > 1 && supported === 1) {
+        this._warnOnce(
+          "single-threaded-module",
+          `${wanted} workers were requested, but this Box3D module was built without threads, so the step stays on the calling thread. Load the threaded build (LoadBox3D({ threads: true }), or babylon-box3d/wasm/threads) from a cross origin isolated page: it needs SharedArrayBuffer, which browsers only allow with the COOP and COEP headers set.`
+        );
+      }
+      return Math.min(wanted, supported);
     }
     // ----------------------------------------------------------------------------------------
     // helpers
@@ -1344,7 +1412,6 @@ var BABYLONBOX3D = (() => {
           const b = options.pointB ?? import_math_vector.Vector3.UpReadOnly;
           const axis = b.subtract(a);
           const height = axis.length();
-          const mid = a.add(b).scaleInPlace(0.5);
           const q = this._tmpQuat[0];
           if (height > 1e-6) {
             axis.scaleInPlace(1 / height);
@@ -1352,11 +1419,15 @@ var BABYLONBOX3D = (() => {
           } else {
             q.set(0, 0, 0, 1);
           }
-          this._registerShape(shape, b3._bx_ShapeDesc_CreateCylinder(height, options.radius ?? 0, 16, mid.x, mid.y, mid.z, q.x, q.y, q.z, q.w), type);
+          this._registerShape(shape, b3._bx_ShapeDesc_CreateCylinder(height, options.radius ?? 0, 16, a.x, a.y, a.z, q.x, q.y, q.z, q.w), type);
           break;
         }
         case import_IPhysicsEnginePlugin.PhysicsShapeType.CONVEX_HULL:
         case import_IPhysicsEnginePlugin.PhysicsShapeType.MESH: {
+          if (!options.mesh && options.positions) {
+            this._initShapeFromPositions(shape, type, options.positions, options.positionIndices);
+            break;
+          }
           const mesh = options.mesh;
           if (!mesh) {
             throw new Error("No mesh provided to create physics shape.");
@@ -1438,6 +1509,37 @@ var BABYLONBOX3D = (() => {
           throw new Error("Unsupported Shape Type.");
       }
     }
+    _initShapeFromPositions(shape, type, positions, indices) {
+      const b3 = this._b3;
+      if (positions.length % 3 !== 0) {
+        throw new Error(`positions needs x, y, z triplets, got ${positions.length} numbers`);
+      }
+      const vertexCount = positions.length / 3;
+      if (type === import_IPhysicsEnginePlugin.PhysicsShapeType.CONVEX_HULL) {
+        this._registerShape(
+          shape,
+          this._withFloatBuffer(positions, (ptr) => b3._bx_ShapeDesc_CreateHull(ptr, vertexCount)),
+          type
+        );
+        return;
+      }
+      if (!indices || indices.length % 3 !== 0) {
+        throw new Error("a MESH shape from positions needs positionIndices, three per triangle");
+      }
+      for (let i = 0; i < indices.length; i++) {
+        if (indices[i] < 0 || indices[i] >= vertexCount || !Number.isInteger(indices[i])) {
+          throw new Error(`positionIndices[${i}] is ${indices[i]}, but there are ${vertexCount} points`);
+        }
+      }
+      this._registerShape(
+        shape,
+        this._withFloatBuffer(
+          positions,
+          (vptr) => this._withIntBuffer(indices, (iptr) => b3._bx_ShapeDesc_CreateMesh(vptr, vertexCount, iptr, indices.length / 3, 1, 1, 1, 0, 0))
+        ),
+        type
+      );
+    }
     // Re-instantiates the shape on every body that uses it (or uses a container holding it). Only needed for geometry
     // and child changes; filters, materials and density are applied in place, see _syncShapeUsers.
     _refreshShapeUsers(data, visited = /* @__PURE__ */ new Set()) {
@@ -2592,11 +2694,32 @@ var BABYLONBOX3D = (() => {
     }
   };
 
-  // box3d-global:babylon-box3d/wasm
-  if (typeof Box3D === "undefined") {
-    throw new Error("babylon.box3d.js needs lib/umd/box3d.umd.js loaded first");
+  // src/index.ts
+  init_wasm();
+
+  // src/loadBox3D.ts
+  function CanUseBox3DThreads() {
+    if (typeof SharedArrayBuffer === "undefined") {
+      return false;
+    }
+    const isolated = globalThis.crossOriginIsolated;
+    return isolated === void 0 || isolated;
+  }
+  async function LoadBox3D(options = {}) {
+    const { threads = false, ...moduleOptions } = options;
+    const wantsThreads = threads === "auto" ? CanUseBox3DThreads() : threads;
+    if (wantsThreads) {
+      if (threads === true && !CanUseBox3DThreads()) {
+        throw new Error(
+          'babylon-box3d: the threaded build needs SharedArrayBuffer, which this page does not have. Serve it with the Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp headers, or use LoadBox3D({ threads: "auto" }) to fall back to the single threaded build.'
+        );
+      }
+      const threaded = await Promise.resolve().then(() => (init_threads(), threads_exports));
+      return threaded.default(moduleOptions);
+    }
+    const plain = await Promise.resolve().then(() => (init_wasm(), wasm_exports));
+    return plain.default(moduleOptions);
   }
-  var wasm_default = Box3D;
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=babylon.box3d.js.map