okgeometry-api 1.26.1 → 1.28.0

package/src/wasm-bindings.js

@@ -2086,6 +2086,18 @@ export function mesh_boundary_edge_segments(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_boundary_edge_segments`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_boundary_edge_segments_h(id) {
+    const ret = wasm.mesh_boundary_edge_segments_h(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Extract boundary (perimeter) edges from a mesh as polylines.
  * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -2143,6 +2155,19 @@ export function mesh_build_render_buffers(vertex_count, buffer, crease_angle_deg
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_build_render_buffers`.
+ * @param {number} id
+ * @param {number} crease_angle_deg
+ * @returns {Float32Array}
+ */
+export function mesh_build_render_buffers_h(id, crease_angle_deg) {
+    const ret = wasm.mesh_build_render_buffers_h(id, crease_angle_deg);
+    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -2489,6 +2514,18 @@ export function mesh_feature_edge_chains(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_feature_edge_chains`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_feature_edge_chains_h(id) {
+    const ret = wasm.mesh_feature_edge_chains_h(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Find the best matching coplanar connected face group by normal and optional near-point.
  * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
@@ -2512,6 +2549,25 @@ export function mesh_find_face_group_by_normal(vertex_count, buffer, nx, ny, nz,
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_find_face_group_by_normal`.
+ * @param {number} id
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} near_x
+ * @param {number} near_y
+ * @param {number} near_z
+ * @param {boolean} use_near_point
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_normal_h(id, nx, ny, nz, near_x, near_y, near_z, use_near_point) {
+    const ret = wasm.mesh_find_face_group_by_normal_h(id, nx, ny, nz, near_x, near_y, near_z, use_near_point);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Find the coplanar connected face group containing triangle_index.
  * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
@@ -2529,6 +2585,19 @@ export function mesh_find_face_group_by_triangle_index(vertex_count, buffer, tri
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_find_face_group_by_triangle_index`.
+ * @param {number} id
+ * @param {number} triangle_index
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_triangle_index_h(id, triangle_index) {
+    const ret = wasm.mesh_find_face_group_by_triangle_index_h(id, triangle_index);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Axis-aligned bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
  * @param {number} vertex_count
@@ -2561,6 +2630,19 @@ export function mesh_get_coplanar_face_group_centroid(vertex_count, buffer, face
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_coplanar_face_group_centroid`.
+ * @param {number} id
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_group_centroid_h(id, face_index) {
+    const ret = wasm.mesh_get_coplanar_face_group_centroid_h(id, face_index);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Edge-connected coplanar triangle indices as [count, i0, i1, ...].
  * @param {number} vertex_count
@@ -2577,6 +2659,19 @@ export function mesh_get_coplanar_face_indices(vertex_count, buffer, face_index)
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_coplanar_face_indices`.
+ * @param {number} id
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_indices_h(id, face_index) {
+    const ret = wasm.mesh_get_coplanar_face_indices_h(id, face_index);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Coplanar connected face region projected to a plane basis.
  * Output format:
@@ -2621,6 +2716,18 @@ export function mesh_get_edge_vertex_pairs(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_edge_vertex_pairs`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_get_edge_vertex_pairs_h(id) {
+    const ret = wasm.mesh_get_edge_vertex_pairs_h(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Face area.
  * @param {number} vertex_count
@@ -2659,6 +2766,19 @@ export function mesh_get_face_boundary_loops(vertex_count, buffer, face_index) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_face_boundary_loops`.
+ * @param {number} id
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_boundary_loops_h(id, face_index) {
+    const ret = wasm.mesh_get_face_boundary_loops_h(id, face_index);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Face centroid as [x, y, z].
  * @param {number} vertex_count
@@ -2712,6 +2832,20 @@ export function mesh_get_smooth_face_group(vertex_count, buffer, face_index, max
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_get_smooth_face_group`.
+ * @param {number} id
+ * @param {number} face_index
+ * @param {number} max_angle_deg
+ * @returns {Float64Array}
+ */
+export function mesh_get_smooth_face_group_h(id, face_index, max_angle_deg) {
+    const ret = wasm.mesh_get_smooth_face_group_h(id, face_index, max_angle_deg);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -3079,6 +3213,44 @@ export function mesh_raycast_all(vertex_count, buffer, ox, oy, oz, dx, dy, dz, m
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_raycast_all` — reuses the stored mesh's cached BVH.
+ * @param {number} id
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_all_h(id, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ret = wasm.mesh_raycast_all_h(id, ox, oy, oz, dx, dy, dz, max_distance);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Handle variant of `mesh_raycast` — reuses the stored mesh's cached BVH.
+ * @param {number} id
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_h(id, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ret = wasm.mesh_raycast_h(id, ox, oy, oz, dx, dy, dz, max_distance);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Raycast against many meshes packed as:
  * [meshCount, meshLen0, meshRaw0..., meshLen1, meshRaw1..., ...]
@@ -3144,6 +3316,18 @@ export function mesh_repair_diagnostics(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Handle variant of `mesh_repair_diagnostics`.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function mesh_repair_diagnostics_h(id) {
+    const ret = wasm.mesh_repair_diagnostics_h(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Rotate a mesh around an arbitrary axis and return new buffers
  * Axis is defined by (ax, ay, az), angle in radians
@@ -3316,6 +3500,47 @@ export function mesh_split_polyline(vertex_count, buffer, points, closed) {
     return v3;
 }
 
+/**
+ * Store a mesh buffer `[vertexCount, x,y,z..., i0,i1,i2...]` WASM-side.
+ * Returns a non-zero id, or 0 on invalid input.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {number}
+ */
+export function mesh_store(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_store(vertex_count, ptr0, len0);
+    return ret >>> 0;
+}
+
+/**
+ * Approximate bytes held by stored mesh raw buffers (diagnostics/tests).
+ * Excludes lazy raycast caches.
+ * @returns {number}
+ */
+export function mesh_store_bytes() {
+    const ret = wasm.mesh_store_bytes();
+    return ret;
+}
+
+/**
+ * Number of stored meshes (diagnostics/tests).
+ * @returns {number}
+ */
+export function mesh_store_count() {
+    const ret = wasm.mesh_store_count();
+    return ret >>> 0;
+}
+
+/**
+ * Release a stored mesh and free its memory (idempotent).
+ * @param {number} id
+ */
+export function mesh_store_free(id) {
+    wasm.mesh_store_free(id);
+}
+
 /**
  * Trim an OPEN host surface by all closed cutter meshes in one WASM call.
  *
@@ -3385,6 +3610,34 @@ export function mesh_surface_split_plane(vertex_count, buffer, nx, ny, nz, d, op
     return v3;
 }
 
+/**
+ * Thicken (solidify) a triangle mesh into a solid: open sheets gain boundary
+ * walls, closed meshes become hollow shells. `bottom_offset`/`top_offset`
+ * are signed displacements along the (angle-weighted) vertex normal;
+ * centered = (-d/2, +d/2), up = (0, d), down = (-d, 0). `flags` bit 1 =
+ * disable even thickness (miter compensation); bit 2 = skip the input
+ * proximity weld (trusted indexed connectivity, e.g. kernel-produced
+ * meshes). `miter_limit <= 0` uses the default (4.0). Returns the standard
+ * mesh buffer
+ * [vertexCount, positions..., indices...]; empty on failure (see
+ * `geometry_last_error`).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} bottom_offset
+ * @param {number} top_offset
+ * @param {number} flags
+ * @param {number} miter_limit
+ * @returns {Float64Array}
+ */
+export function mesh_thicken(vertex_count, buffer, bottom_offset, top_offset, flags, miter_limit) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_thicken(vertex_count, ptr0, len0, bottom_offset, top_offset, flags, miter_limit);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Return welded-edge topology metrics for a triangulated mesh buffer:
  * `[boundary_edges, non_manifold_edges]`.
@@ -4029,6 +4282,34 @@ export function nurbs_surface_tessellate_render(data, tolerance, max_segments_pe
     return v2;
 }
 
+/**
+ * Thicken a NURBS surface into an exact watertight BREP solid: the shells are
+ * exact parameterization-preserving offsets and the walls are exact ruled
+ * surfaces between corresponding boundary curves. Handles closed directions
+ * (seam edges) and degenerate boundaries (poles). `tolerance <= 0` uses the
+ * offset default (1e-4). Returns the BREP JSON, or `{"error": ...}` on
+ * failure.
+ * @param {Float64Array} data
+ * @param {number} bottom_offset
+ * @param {number} top_offset
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function nurbs_surface_thicken_brep(data, bottom_offset, top_offset, tolerance) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.nurbs_surface_thicken_brep(ptr0, len0, bottom_offset, top_offset, tolerance);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Offset a polycurve made of line and arc segments.
  * Input format: [segment_count, type, ...data, ...]
@@ -4583,6 +4864,32 @@ export function thicken_polycurve(segment_data, distance, both_sides, nx, ny, nz
     return v2;
 }
 
+/**
+ * Thicken a polycurve into region boundary loops, supporting CLOSED inputs
+ * (annulus semantics): open inputs return one closed ribbon loop; closed
+ * inputs return the surviving offset loops on both sides (or source + one
+ * side when `both_sides` is false). Segment data format matches
+ * `thicken_polycurve`; output is a packed polycurve set
+ * [curve_count, curve_len, curve_data..., ...]. Empty on failure (see
+ * `geometry_last_error`).
+ * @param {Float64Array} segment_data
+ * @param {number} distance
+ * @param {boolean} both_sides
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} join_style_code
+ * @returns {Float64Array}
+ */
+export function thicken_polycurve_loops(segment_data, distance, both_sides, nx, ny, nz, join_style_code) {
+    const ptr0 = passArrayF64ToWasm0(segment_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.thicken_polycurve_loops(ptr0, len0, distance, both_sides, nx, ny, nz, join_style_code);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Get version info
  * @returns {string}

package/src/workerHelpers-threaded.js

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2022 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Note: we use `wasm_bindgen_worker_`-prefixed message types to make sure
+// we can handle bundling into other files, which might happen to have their
+// own `postMessage`/`onmessage` communication channels.
+//
+// If we didn't take that into the account, we could send much simpler signals
+// like just `0` or whatever, but the code would be less resilient.
+
+function waitForMsgType(target, type) {
+  return new Promise(resolve => {
+    target.addEventListener('message', function onMsg({ data }) {
+      if (data?.type !== type) return;
+      target.removeEventListener('message', onMsg);
+      resolve(data);
+    });
+  });
+}
+
+waitForMsgType(self, 'wasm_bindgen_worker_init').then(async ({ init, receiver }) => {
+  // # Note 1
+  // Our JS should have been generated in
+  // `[out-dir]/snippets/wasm-bindgen-rayon-[hash]/workerHelpers.js`,
+  // resolve the main module via `../../..`.
+  //
+  // This might need updating if the generated structure changes on wasm-bindgen
+  // side ever in the future, but works well with bundlers today. The whole
+  // point of this crate, after all, is to abstract away unstable features
+  // and temporary bugs so that you don't need to deal with them in your code.
+  //
+  // # Note 2
+  // This could be a regular import, but then some bundlers complain about
+  // circular deps.
+  //
+  // Dynamic import could be cheap if this file was inlined into the parent,
+  // which would require us just using `../../..` in `new Worker` below,
+  // but that doesn't work because wasm-pack unconditionally adds
+  // "sideEffects":false (see below).
+  //
+  // OTOH, even though it can't be inlined, it should be still reasonably
+  // cheap since the requested file is already in cache (it was loaded by
+  // the main thread).
+  const pkg = await import('./wasm-bindings-threaded.js');
+  await pkg.default(init);
+  postMessage({ type: 'wasm_bindgen_worker_ready' });
+  pkg.wbg_rayon_start_worker(receiver);
+});
+
+// Note: this is never used, but necessary to prevent a bug in Firefox
+// (https://bugzilla.mozilla.org/show_bug.cgi?id=1702191) where it collects
+// Web Workers that have a shared WebAssembly memory with the main thread,
+// but are not explicitly rooted via a `Worker` instance.
+//
+// By storing them in a variable, we can keep `Worker` objects around and
+// prevent them from getting GC-d.
+let _workers;
+
+export async function startWorkers(module, memory, builder) {
+  if (builder.numThreads() === 0) {
+    throw new Error(`num_threads must be > 0.`);
+  }
+
+  const workerInit = {
+    type: 'wasm_bindgen_worker_init',
+    init: { module_or_path: module, memory },
+    receiver: builder.receiver()
+  };
+
+  _workers = await Promise.all(
+    Array.from({ length: builder.numThreads() }, async () => {
+      // Self-spawn into a new Worker.
+      //
+      // TODO: while `new URL('...', import.meta.url) becomes a semi-standard
+      // way to get asset URLs relative to the module across various bundlers
+      // and browser, ideally we should switch to `import.meta.resolve`
+      // once it becomes a standard.
+      //
+      // Note: we could use `../../..` as the URL here to inline workerHelpers.js
+      // into the parent entry instead of creating another split point -
+      // this would be preferable from optimization perspective -
+      // however, Webpack then eliminates all message handler code
+      // because wasm-pack produces "sideEffects":false in package.json
+      // unconditionally.
+      //
+      // The only way to work around that is to have side effect code
+      // in an entry point such as Worker file itself.
+      const worker = new Worker(new URL('./workerHelpers-threaded.js', import.meta.url), {
+        type: 'module'
+      });
+      worker.postMessage(workerInit);
+      await waitForMsgType(worker, 'wasm_bindgen_worker_ready');
+      return worker;
+    })
+  );
+  builder.build();
+}