okgeometry-api 1.9.0 → 1.11.0

package/src/wasm-bindings.d.ts

@@ -474,11 +474,21 @@ export function mesh_evaluate(vertex_count: number, buffer: Float64Array, u: num
 
 /**
  * Export a mesh to OBJ format
- * Takes mesh buffers as input (same format as mesh_to_buffers output)
- * Returns OBJ string
+ * Takes the standard mesh buffer (`[vertexCount, ...positions, ...indices]`,
+ * same format as `mesh_to_buffers` / `Mesh.rawBuffer`) and returns OBJ text.
  */
 export function mesh_export_obj(vertex_count: number, buffer: Float64Array): string;
 
+/**
+ * Export a mesh (standard buffer format) to ASCII STL text.
+ */
+export function mesh_export_stl_ascii(vertex_count: number, buffer: Float64Array, name: string): string;
+
+/**
+ * Export a mesh (standard buffer format) to binary STL bytes.
+ */
+export function mesh_export_stl_binary(vertex_count: number, buffer: Float64Array): Uint8Array;
+
 /**
  * Push/pull a planar face set by moving its coplanar connected region.
  */
@@ -564,6 +574,17 @@ export function mesh_get_stats(vertex_count: number, buffer: Float64Array): Floa
  */
 export function mesh_import_obj(obj_data: string): Float64Array;
 
+/**
+ * Import STL data (binary or ASCII, auto-detected) and return the standard
+ * mesh buffer (`[vertexCount, ...positions, ...indices]`). STL stores an
+ * unindexed triangle soup, so coincident vertices are welded.
+ *
+ * `weld_tolerance`: absolute distance under which vertices merge; `<= 0`
+ * selects an automatic tolerance from the bounding box. Returns an empty
+ * buffer on parse failure.
+ */
+export function mesh_import_stl(data: Uint8Array, weld_tolerance: number): Float64Array;
+
 /**
  * Check if triangulated mesh is a closed volume (no welded boundary edges).
  */
@@ -649,6 +670,15 @@ export function mesh_rotate(vertex_count: number, buffer: Float64Array, ax: numb
  */
 export function mesh_scale(vertex_count: number, buffer: Float64Array, sx: number, sy: number, sz: number): Float64Array;
 
+/**
+ * Split a closed solid (mesh A) by a surface (mesh B) into BOTH capped solids.
+ * `outside` = the solid on the negative side of the surface, `inside` = the
+ * positive side; each is capped by the portion of the surface inside the
+ * solid, welded into a watertight result. Same packed layout as the other
+ * split exports.
+ */
+export function mesh_solid_split_by_surface(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
+
 export function mesh_solid_split_plane(vertex_count: number, buffer: Float64Array, nx: number, ny: number, nz: number, d: number, operation: string): Float64Array;
 
 /**
@@ -1018,6 +1048,8 @@ export interface InitOutput {
     readonly mesh_create_sphere: (a: number, b: number, c: number) => [number, number];
     readonly mesh_evaluate: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_export_obj: (a: number, b: number, c: number) => [number, number];
+    readonly mesh_export_stl_ascii: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly mesh_export_stl_binary: (a: number, b: number, c: number) => [number, number];
     readonly mesh_extrude_face: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_extrude_planar_curve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly mesh_find_face_group_by_normal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
@@ -1033,6 +1065,7 @@ export interface InitOutput {
     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_import_stl: (a: number, b: number, c: number) => [number, number];
     readonly mesh_is_closed_volume: (a: number, b: number, c: number) => number;
     readonly mesh_manifold_port_import_roundtrip_debug: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_manifold_port_import_stage_hashes_debug: (a: number, b: number, c: number, d: number) => [number, number];
@@ -1048,6 +1081,7 @@ export interface InitOutput {
     readonly mesh_raycast_many: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
     readonly mesh_rotate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly mesh_scale: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly mesh_solid_split_by_surface: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_solid_split_plane: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
     readonly mesh_surface_difference_all: (a: number, b: number, c: number, d: number) => [number, number];
     readonly mesh_surface_split: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];

package/src/wasm-bindings.js

@@ -1688,8 +1688,8 @@ export function mesh_evaluate(vertex_count, buffer, u, v) {
 
 /**
  * Export a mesh to OBJ format
- * Takes mesh buffers as input (same format as mesh_to_buffers output)
- * Returns OBJ string
+ * Takes the standard mesh buffer (`[vertexCount, ...positions, ...indices]`,
+ * same format as `mesh_to_buffers` / `Mesh.rawBuffer`) and returns OBJ text.
  * @param {number} vertex_count
  * @param {Float64Array} buffer
  * @returns {string}
@@ -1709,6 +1709,45 @@ export function mesh_export_obj(vertex_count, buffer) {
     }
 }
 
+/**
+ * Export a mesh (standard buffer format) to ASCII STL text.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {string} name
+ * @returns {string}
+ */
+export function mesh_export_stl_ascii(vertex_count, buffer, name) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.mesh_export_stl_ascii(vertex_count, ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Export a mesh (standard buffer format) to binary STL bytes.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Uint8Array}
+ */
+export function mesh_export_stl_binary(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_export_stl_binary(vertex_count, ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
 /**
  * Push/pull a planar face set by moving its coplanar connected region.
  * @param {number} vertex_count
@@ -1974,6 +2013,27 @@ export function mesh_import_obj(obj_data) {
     return v2;
 }
 
+/**
+ * Import STL data (binary or ASCII, auto-detected) and return the standard
+ * mesh buffer (`[vertexCount, ...positions, ...indices]`). STL stores an
+ * unindexed triangle soup, so coincident vertices are welded.
+ *
+ * `weld_tolerance`: absolute distance under which vertices merge; `<= 0`
+ * selects an automatic tolerance from the bounding box. Returns an empty
+ * buffer on parse failure.
+ * @param {Uint8Array} data
+ * @param {number} weld_tolerance
+ * @returns {Float64Array}
+ */
+export function mesh_import_stl(data, weld_tolerance) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_import_stl(ptr0, len0, weld_tolerance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Check if triangulated mesh is a closed volume (no welded boundary edges).
  * @param {number} vertex_count
@@ -2272,6 +2332,32 @@ export function mesh_scale(vertex_count, buffer, sx, sy, sz) {
     return v2;
 }
 
+/**
+ * Split a closed solid (mesh A) by a surface (mesh B) into BOTH capped solids.
+ * `outside` = the solid on the negative side of the surface, `inside` = the
+ * positive side; each is capped by the portion of the surface inside the
+ * solid, welded into a watertight result. Same packed layout as the other
+ * split exports.
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} operation
+ * @returns {Float64Array}
+ */
+export function mesh_solid_split_by_surface(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
+    const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_solid_split_by_surface(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2);
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
 /**
  * @param {number} vertex_count
  * @param {Float64Array} buffer
@@ -3150,6 +3236,11 @@ function getArrayF64FromWasm0(ptr, len) {
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedFloat32ArrayMemory0 = null;
 function getFloat32ArrayMemory0() {
     if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
@@ -3179,6 +3270,13 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArrayF64ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 8, 8) >>> 0;
     getFloat64ArrayMemory0().set(arg, ptr / 8);