okgeometry-api 1.2.1 → 1.5.0

package/src/wasm-bindings.d.ts

@@ -12,6 +12,21 @@ export function arc_length(radius: number, start_angle: number, end_angle: numbe
  */
 export function arc_point_at(cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, radius: number, start_angle: number, end_angle: number, t: number): Float64Array;
 
+/**
+ * Build a NURBS curve from raw control points with kernel-managed knots and weights.
+ *
+ * * `degree` - Requested degree (clamped to the valid range for the point count)
+ * * `coords` - Flat control points [x,y,z, x,y,z, ...]. For closed curves the
+ *   first point must NOT be repeated at the end.
+ * * `closed` - When true, builds a periodic (C^{degree-1}) closed loop;
+ *   otherwise a clamped curve interpolating the first/last control points.
+ *
+ * Returns the encoded curve [degree, num_cp, cp_xyz..., weights..., knots...]
+ * (the same format consumed by `sample_nurbs_curve` / `evaluate_nurbs_curve_at`),
+ * or an empty buffer on failure.
+ */
+export function build_nurbs_curve(degree: number, coords: Float64Array, closed: boolean): Float64Array;
+
 /**
  * Chamfer corners of a polyline by cutting each corner with a straight segment.
  * Input: flat coords [x1,y1,z1, ...], distance from corner to cut.
@@ -145,6 +160,23 @@ export function loft_nurbs_surface(data: Float64Array): Float64Array;
  */
 export function loft_polylines(polyline_data: Float64Array, _segments: number, with_caps: boolean): Float64Array;
 
+/**
+ * Loft between raw profile polylines with kernel-managed compatibility
+ * (resampling to a common count, seam alignment, direction matching).
+ *
+ * # Parameters
+ * * `profile_data` - Flat array where each profile is prefixed by its point count:
+ *   [count1, x1, y1, z1, ..., count2, x1, y1, z1, ...]
+ * * `closed` - Whether profiles are closed loops (input must NOT repeat the
+ *   first point). Closed profiles loft into a tube, open profiles into a sheet.
+ * * `with_caps` - Cap the first/last profiles (closed profiles only) to produce
+ *   a watertight solid ready for booleans.
+ *
+ * # Returns
+ * Mesh buffers for the lofted surface (empty on failure)
+ */
+export function loft_profiles(profile_data: Float64Array, closed: boolean, with_caps: boolean): Float64Array;
+
 /**
  * Make multiple NURBS curves compatible (same knot vectors, same CP count).
  * Input: [curve_count, curve1_data..., curve2_data..., ...]
@@ -159,6 +191,16 @@ export function make_nurbs_curves_compatible(curves_data: Float64Array): Float64
  */
 export function mesh_apply_matrix(vertex_count: number, buffer: Float64Array, matrix: Float64Array): Float64Array;
 
+/**
+ * Subtract all cutter meshes from the host in one WASM call.
+ *
+ * `packed` layout matches `mesh_boolean_union_all`; the FIRST mesh is the
+ * host and every following mesh is a cutter.
+ * `flags`: `""` or `"trustedInput"`.
+ * Returns a standard result mesh buffer, or an empty vector on failure.
+ */
+export function mesh_boolean_difference_all(packed: Float64Array, flags: string): Float64Array;
+
 /**
  * Perform boolean intersection on two meshes
  */
@@ -236,6 +278,15 @@ export function mesh_boolean_subtraction(vertex_count_a: number, buffer_a: Float
  */
 export function mesh_boolean_union(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array): Float64Array;
 
+/**
+ * Union all meshes in the packed buffer into a single mesh in one WASM call.
+ *
+ * `packed` layout: `[meshCount, (bufferLen, [vertexCount, positions..., indices...])...]`.
+ * `flags`: `""` or `"trustedInput"`.
+ * Returns a standard result mesh buffer, or an empty vector on failure.
+ */
+export function mesh_boolean_union_all(packed: Float64Array, flags: string): Float64Array;
+
 /**
  * Extract boundary (perimeter) edges from a mesh as polylines.
  * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -249,6 +300,19 @@ export function mesh_boundary_polylines(vertex_count: number, buffer: Float64Arr
  */
 export function mesh_build_coplanar_connected_face_groups(vertex_count: number, buffer: Float64Array): Float64Array;
 
+/**
+ * Display-ready render buffers: creased (split) vertex normals plus feature
+ * edges, computed in one pass. Replaces THREE's toCreasedNormals +
+ * EdgesGeometry in app layers (orders of magnitude faster on large meshes).
+ *
+ * Output (f32-packed):
+ * [vertexCount, positions (vertexCount*3), normals (vertexCount*3),
+ *  edgeSegmentCount, edgePositions (edgeSegmentCount*6)]
+ * Vertices are non-indexed in input triangle order, so raycast face indices
+ * against the source mesh stay valid.
+ */
+export function mesh_build_render_buffers(vertex_count: number, buffer: Float64Array, crease_angle_deg: number): Float32Array;
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -378,6 +442,15 @@ export function mesh_get_face_centroid(vertex_count: number, buffer: Float64Arra
  */
 export function mesh_get_face_normal(vertex_count: number, buffer: Float64Array, face_index: number): Float64Array;
 
+/**
+ * Edge-connected smooth face group (dihedral angle below `max_angle_deg`).
+ * Output format: [count, isPlanar (0|1), tri0, tri1, ...]
+ * `isPlanar` is 1 when every triangle normal in the group aligns with the
+ * seed triangle's normal (i.e. the group is a flat face), 0 for curved
+ * regions such as cylinder walls or lofted patches.
+ */
+export function mesh_get_smooth_face_group(vertex_count: number, buffer: Float64Array, face_index: number, max_angle_deg: number): Float64Array;
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -664,6 +737,7 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly arc_length: (a: number, b: number, c: number) => number;
     readonly arc_point_at: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly build_nurbs_curve: (a: number, b: number, c: number, d: number) => [number, number];
     readonly chamfer_polycurve: (a: number, b: number, c: number) => [number, number];
     readonly circle_length: (a: number) => number;
     readonly circle_point_at: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
@@ -684,8 +758,10 @@ export interface InitOutput {
     readonly loft_circles: (a: number, b: number, c: number, d: number) => [number, number];
     readonly loft_nurbs_surface: (a: number, b: number) => [number, number];
     readonly loft_polylines: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly loft_profiles: (a: number, b: number, c: number, d: number) => [number, number];
     readonly make_nurbs_curves_compatible: (a: number, b: number) => [number, number];
     readonly mesh_apply_matrix: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly mesh_boolean_difference_all: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_boolean_intersection: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_boolean_kernel_mesh_debug: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_boolean_last_debug_marker: () => number;
@@ -710,8 +786,10 @@ export interface InitOutput {
     readonly mesh_boolean_split: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_boolean_subtraction: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_boolean_union: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly mesh_boolean_union_all: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_boundary_polylines: (a: number, b: number, c: number) => [number, number];
     readonly mesh_build_coplanar_connected_face_groups: (a: number, b: number, c: number) => [number, number];
+    readonly mesh_build_render_buffers: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_chamfer_all_edges: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_compute_planar_curve_normal: (a: number, b: number, c: number) => [number, number];
     readonly mesh_contains_point: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
@@ -734,6 +812,7 @@ export interface InitOutput {
     readonly mesh_get_face_area: (a: number, b: number, c: number, d: number) => number;
     readonly mesh_get_face_centroid: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_get_face_normal: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly mesh_get_smooth_face_group: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_get_stats: (a: number, b: number, c: number) => [number, number];
     readonly mesh_import_obj: (a: number, b: number) => [number, number];
     readonly mesh_is_closed_volume: (a: number, b: number, c: number) => number;

package/src/wasm-bindings.js

@@ -34,6 +34,32 @@ export function arc_point_at(cx, cy, cz, nx, ny, nz, radius, start_angle, end_an
     return v1;
 }
 
+/**
+ * Build a NURBS curve from raw control points with kernel-managed knots and weights.
+ *
+ * * `degree` - Requested degree (clamped to the valid range for the point count)
+ * * `coords` - Flat control points [x,y,z, x,y,z, ...]. For closed curves the
+ *   first point must NOT be repeated at the end.
+ * * `closed` - When true, builds a periodic (C^{degree-1}) closed loop;
+ *   otherwise a clamped curve interpolating the first/last control points.
+ *
+ * Returns the encoded curve [degree, num_cp, cp_xyz..., weights..., knots...]
+ * (the same format consumed by `sample_nurbs_curve` / `evaluate_nurbs_curve_at`),
+ * or an empty buffer on failure.
+ * @param {number} degree
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function build_nurbs_curve(degree, coords, closed) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.build_nurbs_curve(degree, ptr0, len0, closed);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Chamfer corners of a polyline by cutting each corner with a straight segment.
  * Input: flat coords [x1,y1,z1, ...], distance from corner to cut.
@@ -415,6 +441,34 @@ export function loft_polylines(polyline_data, _segments, with_caps) {
     return v2;
 }
 
+/**
+ * Loft between raw profile polylines with kernel-managed compatibility
+ * (resampling to a common count, seam alignment, direction matching).
+ *
+ * # Parameters
+ * * `profile_data` - Flat array where each profile is prefixed by its point count:
+ *   [count1, x1, y1, z1, ..., count2, x1, y1, z1, ...]
+ * * `closed` - Whether profiles are closed loops (input must NOT repeat the
+ *   first point). Closed profiles loft into a tube, open profiles into a sheet.
+ * * `with_caps` - Cap the first/last profiles (closed profiles only) to produce
+ *   a watertight solid ready for booleans.
+ *
+ * # Returns
+ * Mesh buffers for the lofted surface (empty on failure)
+ * @param {Float64Array} profile_data
+ * @param {boolean} closed
+ * @param {boolean} with_caps
+ * @returns {Float64Array}
+ */
+export function loft_profiles(profile_data, closed, with_caps) {
+    const ptr0 = passArrayF64ToWasm0(profile_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.loft_profiles(ptr0, len0, closed, with_caps);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Make multiple NURBS curves compatible (same knot vectors, same CP count).
  * Input: [curve_count, curve1_data..., curve2_data..., ...]
@@ -451,6 +505,28 @@ export function mesh_apply_matrix(vertex_count, buffer, matrix) {
     return v3;
 }
 
+/**
+ * Subtract all cutter meshes from the host in one WASM call.
+ *
+ * `packed` layout matches `mesh_boolean_union_all`; the FIRST mesh is the
+ * host and every following mesh is a cutter.
+ * `flags`: `""` or `"trustedInput"`.
+ * Returns a standard result mesh buffer, or an empty vector on failure.
+ * @param {Float64Array} packed
+ * @param {string} flags
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_difference_all(packed, flags) {
+    const ptr0 = passArrayF64ToWasm0(packed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(flags, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_boolean_difference_all(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Perform boolean intersection on two meshes
  * @param {number} vertex_count_a
@@ -1051,6 +1127,27 @@ export function mesh_boolean_union(vertex_count_a, buffer_a, vertex_count_b, buf
     return v3;
 }
 
+/**
+ * Union all meshes in the packed buffer into a single mesh in one WASM call.
+ *
+ * `packed` layout: `[meshCount, (bufferLen, [vertexCount, positions..., indices...])...]`.
+ * `flags`: `""` or `"trustedInput"`.
+ * Returns a standard result mesh buffer, or an empty vector on failure.
+ * @param {Float64Array} packed
+ * @param {string} flags
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_union_all(packed, flags) {
+    const ptr0 = passArrayF64ToWasm0(packed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(flags, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_boolean_union_all(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Extract boundary (perimeter) edges from a mesh as polylines.
  * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -1084,6 +1181,30 @@ export function mesh_build_coplanar_connected_face_groups(vertex_count, buffer)
     return v2;
 }
 
+/**
+ * Display-ready render buffers: creased (split) vertex normals plus feature
+ * edges, computed in one pass. Replaces THREE's toCreasedNormals +
+ * EdgesGeometry in app layers (orders of magnitude faster on large meshes).
+ *
+ * Output (f32-packed):
+ * [vertexCount, positions (vertexCount*3), normals (vertexCount*3),
+ *  edgeSegmentCount, edgePositions (edgeSegmentCount*6)]
+ * Vertices are non-indexed in input triangle order, so raycast face indices
+ * against the source mesh stay valid.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} crease_angle_deg
+ * @returns {Float32Array}
+ */
+export function mesh_build_render_buffers(vertex_count, buffer, crease_angle_deg) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_build_render_buffers(vertex_count, ptr0, len0, crease_angle_deg);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -1469,6 +1590,27 @@ export function mesh_get_face_normal(vertex_count, buffer, face_index) {
     return v2;
 }
 
+/**
+ * Edge-connected smooth face group (dihedral angle below `max_angle_deg`).
+ * Output format: [count, isPlanar (0|1), tri0, tri1, ...]
+ * `isPlanar` is 1 when every triangle normal in the group aligns with the
+ * seed triangle's normal (i.e. the group is a flat face), 0 for curved
+ * regions such as cylinder walls or lofted patches.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @param {number} max_angle_deg
+ * @returns {Float64Array}
+ */
+export function mesh_get_smooth_face_group(vertex_count, buffer, face_index, max_angle_deg) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_smooth_face_group(vertex_count, ptr0, len0, face_index, max_angle_deg);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -2386,11 +2528,24 @@ function __wbg_get_imports() {
     };
 }
 
+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);
 }
 
+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) {
@@ -2489,6 +2644,7 @@ let wasmModule, wasm;
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     wasmModule = module;
+    cachedFloat32ArrayMemory0 = null;
     cachedFloat64ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();