okgeometry-api 0.4.4 → 0.4.5

package/wasm/okgeometrycore_bg.js

@@ -289,28 +289,6 @@ export function line_length(x1, y1, z1, x2, y2, z2) {
     return ret;
 }
 
-/**
- * Offset a line segment perpendicular to line direction relative to reference normal.
- * Returns [startX,startY,startZ,endX,endY,endZ]
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} x2
- * @param {number} y2
- * @param {number} z2
- * @param {number} distance
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz
- * @returns {Float64Array}
- */
-export function line_offset(x1, y1, z1, x2, y2, z2, distance, nx, ny, nz) {
-    const ret = wasm.line_offset(x1, y1, z1, x2, y2, z2, distance, nx, ny, nz);
-    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v1;
-}
-
 /**
  * Evaluate a point on a line segment at parameter t ∈ [0,1].
  * Returns [x, y, z].
@@ -394,20 +372,20 @@ export function loft_nurbs_surface(data) {
  * # Parameters
  * * `polyline_data` - Flat array where each polyline is prefixed by its point count:
  *   [count1, x1, y1, z1, x2, y2, z2, ..., count2, x1, y1, z1, ...]
- * * `_segments` - Ignored for polylines (kept for API compat). Points are used directly.
- * * `with_caps` - Whether to create end caps (fan triangulation from center)
+ * * `segments` - Number of segments to sample along each curve
+ * * `with_caps` - Whether to create end caps
  *
  * # Returns
  * Mesh buffers for the lofted surface
  * @param {Float64Array} polyline_data
- * @param {number} _segments
+ * @param {number} segments
  * @param {boolean} with_caps
  * @returns {Float64Array}
  */
-export function loft_polylines(polyline_data, _segments, with_caps) {
+export function loft_polylines(polyline_data, segments, with_caps) {
     const ptr0 = passArrayF64ToWasm0(polyline_data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.loft_polylines(ptr0, len0, _segments, with_caps);
+    const ret = wasm.loft_polylines(ptr0, len0, segments, with_caps);
     var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v2;
@@ -554,23 +532,6 @@ export function mesh_boundary_polylines(vertex_count, buffer) {
     return v2;
 }
 
-/**
- * Coplanar connected face groups.
- * Output format:
- * [groupCount, triCount, tri..., centroidX,centroidY,centroidZ, normalX,normalY,normalZ, ...]
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @returns {Float64Array}
- */
-export function mesh_build_coplanar_connected_face_groups(vertex_count, buffer) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_build_coplanar_connected_face_groups(vertex_count, ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -597,37 +558,6 @@ export function mesh_chamfer_all_edges(mesh_type, params, offset) {
     return v3;
 }
 
-/**
- * Compute planar curve normal from ordered points.
- * @param {Float64Array} coords
- * @param {boolean} closed
- * @returns {Float64Array}
- */
-export function mesh_compute_planar_curve_normal(coords, closed) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_compute_planar_curve_normal(ptr0, len0, closed);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Odd/even mesh containment test.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {boolean}
- */
-export function mesh_contains_point(vertex_count, buffer, px, py, pz) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_contains_point(vertex_count, ptr0, len0, px, py, pz);
-    return ret !== 0;
-}
-
 /**
  * Create a box mesh and return buffers
  * Returns [vertices..., indices...]
@@ -699,26 +629,6 @@ export function mesh_create_sphere(radius, segments, rings) {
     return v1;
 }
 
-/**
- * Evaluate a point on a mesh surface at parametric coordinates (u, v).
- * Maps u ∈ [0,1] and v ∈ [0,1] to the mesh's AABB bounding box,
- * then casts a ray perpendicular to the best-fit projection plane.
- * Returns [x, y, z] of the intersection point, or [NaN, NaN, NaN] if no hit.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} u
- * @param {number} v
- * @returns {Float64Array}
- */
-export function mesh_evaluate(vertex_count, buffer, u, v) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_evaluate(vertex_count, ptr0, len0, u, v);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
 /**
  * Export a mesh to OBJ format
  * Takes mesh buffers as input (same format as mesh_to_buffers output)
@@ -742,220 +652,6 @@ export function mesh_export_obj(vertex_count, buffer) {
     }
 }
 
-/**
- * Push/pull a planar face set by moving its coplanar connected region.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @param {number} distance
- * @returns {Float64Array}
- */
-export function mesh_extrude_face(vertex_count, buffer, face_index, distance) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_extrude_face(vertex_count, ptr0, len0, face_index, distance);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Extrude planar curve profile by normal * height.
- * @param {Float64Array} coords
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz
- * @param {number} height
- * @param {boolean} closed
- * @returns {Float64Array}
- */
-export function mesh_extrude_planar_curve(coords, nx, ny, nz, height, closed) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_extrude_planar_curve(ptr0, len0, nx, ny, nz, height, closed);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Find the best matching coplanar connected face group by normal and optional near-point.
- * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @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(vertex_count, buffer, nx, ny, nz, near_x, near_y, near_z, use_near_point) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_find_face_group_by_normal(vertex_count, ptr0, len0, nx, ny, nz, near_x, near_y, near_z, use_near_point);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Find the coplanar connected face group containing triangle_index.
- * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} triangle_index
- * @returns {Float64Array}
- */
-export function mesh_find_face_group_by_triangle_index(vertex_count, buffer, triangle_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_find_face_group_by_triangle_index(vertex_count, ptr0, len0, triangle_index);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Axis-aligned bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @returns {Float64Array}
- */
-export function mesh_get_bounds(vertex_count, buffer) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_bounds(vertex_count, ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Coplanar connected face-group centroid containing a given triangle face index.
- * Output format: [x, y, z] or [] when unavailable.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {Float64Array}
- */
-export function mesh_get_coplanar_face_group_centroid(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_coplanar_face_group_centroid(vertex_count, ptr0, len0, face_index);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Edge-connected coplanar triangle indices as [count, i0, i1, ...].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {Float64Array}
- */
-export function mesh_get_coplanar_face_indices(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_coplanar_face_indices(vertex_count, ptr0, len0, face_index);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Coplanar connected face region projected to a plane basis.
- * Output format:
- * [faceCount, faceIndex0, faceIndex1, ..., uMin, uMax, vMin, vMax]
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @param {number} ox
- * @param {number} oy
- * @param {number} oz
- * @param {number} ux
- * @param {number} uy
- * @param {number} uz
- * @param {number} vx
- * @param {number} vy
- * @param {number} vz
- * @param {number} margin_scale
- * @param {number} min_margin
- * @returns {Float64Array}
- */
-export function mesh_get_coplanar_face_region(vertex_count, buffer, face_index, ox, oy, oz, ux, uy, uz, vx, vy, vz, margin_scale, min_margin) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_coplanar_face_region(vertex_count, ptr0, len0, face_index, ox, oy, oz, ux, uy, uz, vx, vy, vz, margin_scale, min_margin);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Unique undirected triangle edges as [edgeCount, v0a, v0b, v1a, v1b, ...].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @returns {Float64Array}
- */
-export function mesh_get_edge_vertex_pairs(vertex_count, buffer) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_edge_vertex_pairs(vertex_count, ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Face area.
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {number}
- */
-export function mesh_get_face_area(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_face_area(vertex_count, ptr0, len0, face_index);
-    return ret;
-}
-
-/**
- * Face centroid as [x, y, z].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {Float64Array}
- */
-export function mesh_get_face_centroid(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_face_centroid(vertex_count, ptr0, len0, face_index);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Face normal as [x, y, z].
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @param {number} face_index
- * @returns {Float64Array}
- */
-export function mesh_get_face_normal(vertex_count, buffer, face_index) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_get_face_normal(vertex_count, ptr0, len0, face_index);
-    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]
@@ -986,34 +682,6 @@ export function mesh_import_obj(obj_data) {
     return v2;
 }
 
-/**
- * Check if triangulated mesh is a closed volume (no welded boundary edges).
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @returns {boolean}
- */
-export function mesh_is_closed_volume(vertex_count, buffer) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_is_closed_volume(vertex_count, ptr0, len0);
-    return ret !== 0;
-}
-
-/**
- * Merge multiple mesh buffers while preserving per-mesh vertex order and index remapping.
- * Input format: [mesh_count, len1, mesh1..., len2, mesh2..., ...]
- * @param {Float64Array} mesh_data
- * @returns {Float64Array}
- */
-export function mesh_merge(mesh_data) {
-    const ptr0 = passArrayF64ToWasm0(mesh_data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_merge(ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
 /**
  * Intersect two meshes, returning intersection polyline points.
  * Returns: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -1034,23 +702,6 @@ export function mesh_mesh_intersect(va_count, buffer_a, vb_count, buffer_b) {
     return v3;
 }
 
-/**
- * Create a planar patch mesh from boundary points using CDT.
- * Correctly handles concave polygons (unlike fan triangulation).
- * Input: flat coordinate array [x1,y1,z1, x2,y2,z2, ...]
- * Output: mesh buffer [vertexCount, x1,y1,z1,..., i0,i1,i2, ...]
- * @param {Float64Array} coords
- * @returns {Float64Array}
- */
-export function mesh_patch_from_points(coords) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_patch_from_points(ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
 /**
  * Intersect a mesh with a plane, returning polyline points.
  * Input: vertex_count, mesh_buffer..., nx, ny, nz, d
@@ -1072,95 +723,6 @@ export function mesh_plane_intersect(vertex_count, buffer, nx, ny, nz, d) {
     return v2;
 }
 
-/**
- * Shift closed boolean cutter curve and adjust height.
- * Returns [height, epsilon, pointCount, x,y,z,...]
- * @param {Float64Array} coords
- * @param {boolean} closed
- * @param {number} nx
- * @param {number} ny
- * @param {number} nz
- * @param {number} height
- * @returns {Float64Array}
- */
-export function mesh_prepare_boolean_cutter_curve(coords, closed, nx, ny, nz, height) {
-    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_prepare_boolean_cutter_curve(ptr0, len0, closed, nx, ny, nz, height);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Raycast against mesh and return closest hit.
- * Output: [] when no hit, otherwise [pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance]
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @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(vertex_count, buffer, ox, oy, oz, dx, dy, dz, max_distance) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_raycast(vertex_count, ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Raycast against mesh and return all hits sorted by distance.
- * Output: [hitCount, (point, normal, faceIndex, distance)*]
- * @param {number} vertex_count
- * @param {Float64Array} buffer
- * @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(vertex_count, buffer, ox, oy, oz, dx, dy, dz, max_distance) {
-    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_raycast_all(vertex_count, ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
-/**
- * Raycast against many meshes packed as:
- * [meshCount, meshLen0, meshRaw0..., meshLen1, meshRaw1..., ...]
- * Output: [hitCount, meshIndex, pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance, ...]
- * @param {Float64Array} mesh_data
- * @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_many(mesh_data, ox, oy, oz, dx, dy, dz, max_distance) {
-    const ptr0 = passArrayF64ToWasm0(mesh_data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_raycast_many(ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
-}
-
 /**
  * Rotate a mesh around an arbitrary axis and return new buffers
  * Axis is defined by (ax, ay, az), angle in radians

package/wasm/package.json

@@ -9,13 +9,11 @@
   "files": [
     "okgeometrycore_bg.wasm",
     "okgeometrycore.js",
-    "okgeometrycore_bg.js",
     "okgeometrycore.d.ts"
   ],
   "main": "okgeometrycore.js",
   "types": "okgeometrycore.d.ts",
   "sideEffects": [
-    "./okgeometrycore.js",
     "./snippets/*"
   ]
 }