brepkit-wasm 2.104.2 → 2.105.1

package/brepkit_wasm.d.ts

@@ -1862,6 +1862,20 @@ export class BrepKernel {
      * regardless of how the solid was constructed (booleans included).
      */
     tessellateSolidGrouped(solid: number, deflection: number, angular_tolerance?: number | null): any;
+    /**
+     * Tessellate a solid with per-face grouping, returned as packed binary
+     * buffers ([`JsGroupedMesh`]) instead of a JSON string.
+     *
+     * Identical geometry to [`tessellate_solid_grouped`](Self::tessellate_solid_grouped),
+     * but the mesh crosses the WASM boundary as `Float32Array`/`Uint32Array`
+     * bulk copies rather than a (potentially multi-megabyte) JSON string that
+     * the caller must `JSON.parse` and re-pack — far cheaper for large meshes.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    tessellateSolidGroupedBinary(solid: number, deflection: number, angular_tolerance?: number | null): JsGroupedMesh;
     /**
      * Tessellate a solid and include per-vertex UV coordinates.
      *
@@ -2049,6 +2063,38 @@ export class JsEdgeLines {
     readonly positions: Float64Array;
 }
 
+/**
+ * A triangle mesh with per-face triangle grouping, exposed to JavaScript.
+ *
+ * The binary counterpart to the JSON `tessellateSolidGrouped`: positions and
+ * normals are packed `Float32Array`s and indices/`faceOffsets` are
+ * `Uint32Array`s, so the whole mesh crosses the WASM boundary as bulk memory
+ * copies instead of a JSON string round-trip. `f32` matches what mesh
+ * consumers (GPU vertex buffers) use, halving the transfer versus `f64`.
+ */
+export class JsGroupedMesh {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Per-face start offsets into `indices`: `faceOffsets[i]` is the start of
+     * face `i`, and the final element equals `indices.length`.
+     */
+    readonly faceOffsets: Uint32Array;
+    /**
+     * Triangle indices (groups of 3).
+     */
+    readonly indices: Uint32Array;
+    /**
+     * Flattened per-vertex normals as `[nx, ny, nz, ...]`.
+     */
+    readonly normals: Float32Array;
+    /**
+     * Flattened vertex positions as `[x, y, z, ...]`.
+     */
+    readonly positions: Float32Array;
+}
+
 /**
  * A triangle mesh exposed to JavaScript.
  *

package/brepkit_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./brepkit_wasm_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    BrepKernel, JsEdgeLines, JsMesh, JsPoint3, JsVec3, setLogLevel
+    BrepKernel, JsEdgeLines, JsGroupedMesh, JsMesh, JsPoint3, JsVec3, setLogLevel
 } from "./brepkit_wasm_bg.js";

package/brepkit_wasm_bg.js

@@ -4163,6 +4163,30 @@ export class BrepKernel {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Tessellate a solid with per-face grouping, returned as packed binary
+     * buffers ([`JsGroupedMesh`]) instead of a JSON string.
+     *
+     * Identical geometry to [`tessellate_solid_grouped`](Self::tessellate_solid_grouped),
+     * but the mesh crosses the WASM boundary as `Float32Array`/`Uint32Array`
+     * bulk copies rather than a (potentially multi-megabyte) JSON string that
+     * the caller must `JSON.parse` and re-pack — far cheaper for large meshes.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     * @param {number} solid
+     * @param {number} deflection
+     * @param {number | null} [angular_tolerance]
+     * @returns {JsGroupedMesh}
+     */
+    tessellateSolidGroupedBinary(solid, deflection, angular_tolerance) {
+        const ret = wasm.brepkernel_tessellateSolidGroupedBinary(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsGroupedMesh.__wrap(ret[0]);
+    }
     /**
      * Tessellate a solid and include per-vertex UV coordinates.
      *
@@ -4520,6 +4544,76 @@ export class JsEdgeLines {
 }
 if (Symbol.dispose) JsEdgeLines.prototype[Symbol.dispose] = JsEdgeLines.prototype.free;
 
+/**
+ * A triangle mesh with per-face triangle grouping, exposed to JavaScript.
+ *
+ * The binary counterpart to the JSON `tessellateSolidGrouped`: positions and
+ * normals are packed `Float32Array`s and indices/`faceOffsets` are
+ * `Uint32Array`s, so the whole mesh crosses the WASM boundary as bulk memory
+ * copies instead of a JSON string round-trip. `f32` matches what mesh
+ * consumers (GPU vertex buffers) use, halving the transfer versus `f64`.
+ */
+export class JsGroupedMesh {
+    static __wrap(ptr) {
+        const obj = Object.create(JsGroupedMesh.prototype);
+        obj.__wbg_ptr = ptr;
+        JsGroupedMeshFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsGroupedMeshFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsgroupedmesh_free(ptr, 0);
+    }
+    /**
+     * Per-face start offsets into `indices`: `faceOffsets[i]` is the start of
+     * face `i`, and the final element equals `indices.length`.
+     * @returns {Uint32Array}
+     */
+    get faceOffsets() {
+        const ret = wasm.jsgroupedmesh_faceOffsets(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Triangle indices (groups of 3).
+     * @returns {Uint32Array}
+     */
+    get indices() {
+        const ret = wasm.jsgroupedmesh_indices(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Flattened per-vertex normals as `[nx, ny, nz, ...]`.
+     * @returns {Float32Array}
+     */
+    get normals() {
+        const ret = wasm.jsgroupedmesh_normals(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Flattened vertex positions as `[x, y, z, ...]`.
+     * @returns {Float32Array}
+     */
+    get positions() {
+        const ret = wasm.jsgroupedmesh_positions(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) JsGroupedMesh.prototype[Symbol.dispose] = JsGroupedMesh.prototype.free;
+
 /**
  * A triangle mesh exposed to JavaScript.
  *
@@ -4804,13 +4898,13 @@ export function __wbg___wbindgen_debug_string_0accd80f45e5faa2(arg0, arg1) {
 export function __wbg___wbindgen_throw_1506f2235d1bdba0(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_error_0730775362fbd448(arg0, arg1) {
+export function __wbg_error_85e019924b3d51f5(arg0, arg1) {
     console.error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_log_5517b1040d2ba68c(arg0, arg1) {
+export function __wbg_log_40a70746064f897c(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_warn_8908697137173682(arg0, arg1) {
+export function __wbg_warn_0f2eb98c4119d263(arg0, arg1) {
     console.warn(getStringFromWasm0(arg0, arg1));
 }
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
@@ -4833,6 +4927,9 @@ const BrepKernelFinalization = (typeof FinalizationRegistry === 'undefined')
 const JsEdgeLinesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsedgelines_free(ptr, 1));
+const JsGroupedMeshFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsgroupedmesh_free(ptr, 1));
 const JsMeshFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsmesh_free(ptr, 1));
@@ -4908,6 +5005,11 @@ function debugString(val) {
     return className;
 }
 
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayF64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
@@ -4931,6 +5033,14 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
 let cachedFloat64ArrayMemory0 = null;
 function getFloat64ArrayMemory0() {
     if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {

package/brepkit_wasm_node.cjs

@@ -4165,6 +4165,30 @@ class BrepKernel {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Tessellate a solid with per-face grouping, returned as packed binary
+     * buffers ([`JsGroupedMesh`]) instead of a JSON string.
+     *
+     * Identical geometry to [`tessellate_solid_grouped`](Self::tessellate_solid_grouped),
+     * but the mesh crosses the WASM boundary as `Float32Array`/`Uint32Array`
+     * bulk copies rather than a (potentially multi-megabyte) JSON string that
+     * the caller must `JSON.parse` and re-pack — far cheaper for large meshes.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     * @param {number} solid
+     * @param {number} deflection
+     * @param {number | null} [angular_tolerance]
+     * @returns {JsGroupedMesh}
+     */
+    tessellateSolidGroupedBinary(solid, deflection, angular_tolerance) {
+        const ret = wasm.brepkernel_tessellateSolidGroupedBinary(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return JsGroupedMesh.__wrap(ret[0]);
+    }
     /**
      * Tessellate a solid and include per-vertex UV coordinates.
      *
@@ -4524,6 +4548,77 @@ class JsEdgeLines {
 if (Symbol.dispose) JsEdgeLines.prototype[Symbol.dispose] = JsEdgeLines.prototype.free;
 exports.JsEdgeLines = JsEdgeLines;
 
+/**
+ * A triangle mesh with per-face triangle grouping, exposed to JavaScript.
+ *
+ * The binary counterpart to the JSON `tessellateSolidGrouped`: positions and
+ * normals are packed `Float32Array`s and indices/`faceOffsets` are
+ * `Uint32Array`s, so the whole mesh crosses the WASM boundary as bulk memory
+ * copies instead of a JSON string round-trip. `f32` matches what mesh
+ * consumers (GPU vertex buffers) use, halving the transfer versus `f64`.
+ */
+class JsGroupedMesh {
+    static __wrap(ptr) {
+        const obj = Object.create(JsGroupedMesh.prototype);
+        obj.__wbg_ptr = ptr;
+        JsGroupedMeshFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsGroupedMeshFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsgroupedmesh_free(ptr, 0);
+    }
+    /**
+     * Per-face start offsets into `indices`: `faceOffsets[i]` is the start of
+     * face `i`, and the final element equals `indices.length`.
+     * @returns {Uint32Array}
+     */
+    get faceOffsets() {
+        const ret = wasm.jsgroupedmesh_faceOffsets(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Triangle indices (groups of 3).
+     * @returns {Uint32Array}
+     */
+    get indices() {
+        const ret = wasm.jsgroupedmesh_indices(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Flattened per-vertex normals as `[nx, ny, nz, ...]`.
+     * @returns {Float32Array}
+     */
+    get normals() {
+        const ret = wasm.jsgroupedmesh_normals(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Flattened vertex positions as `[x, y, z, ...]`.
+     * @returns {Float32Array}
+     */
+    get positions() {
+        const ret = wasm.jsgroupedmesh_positions(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) JsGroupedMesh.prototype[Symbol.dispose] = JsGroupedMesh.prototype.free;
+exports.JsGroupedMesh = JsGroupedMesh;
+
 /**
  * A triangle mesh exposed to JavaScript.
  *
@@ -4815,13 +4910,13 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_error_0730775362fbd448: function(arg0, arg1) {
+        __wbg_error_85e019924b3d51f5: function(arg0, arg1) {
             console.error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_log_5517b1040d2ba68c: function(arg0, arg1) {
+        __wbg_log_40a70746064f897c: function(arg0, arg1) {
             console.log(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_warn_8908697137173682: function(arg0, arg1) {
+        __wbg_warn_0f2eb98c4119d263: function(arg0, arg1) {
             console.warn(getStringFromWasm0(arg0, arg1));
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
@@ -4851,6 +4946,9 @@ const BrepKernelFinalization = (typeof FinalizationRegistry === 'undefined')
 const JsEdgeLinesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsedgelines_free(ptr, 1));
+const JsGroupedMeshFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsgroupedmesh_free(ptr, 1));
 const JsMeshFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsmesh_free(ptr, 1));
@@ -4926,6 +5024,11 @@ function debugString(val) {
     return className;
 }
 
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayF64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
@@ -4949,6 +5052,14 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
 let cachedFloat64ArrayMemory0 = null;
 function getFloat64ArrayMemory0() {
     if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "brepkit-wasm",
   "type": "module",
   "description": "WebAssembly bindings for brepkit — browser-native B-Rep solid modeling",
-  "version": "2.104.2",
+  "version": "2.105.1",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",