okgeometry-api 1.17.1 → 1.19.0

package/src/wasm-bindings.d.ts

@@ -1308,6 +1308,104 @@ export function ray_point_at(ox: number, oy: number, oz: number, dx: number, dy:
  */
 export function sample_nurbs_curve(data: Float64Array, samples: number): Float64Array;
 
+/**
+ * Begin a stroke. `brush` and `falloff` are stable enum codes
+ * (see okgeometry-api SculptBrush / SculptFalloff). Flags: bit 0 = invert,
+ * bit 1 = front faces only. `symmetry`: bit 0 = X, bit 1 = Y, bit 2 = Z.
+ */
+export function sculpt_session_begin_stroke(id: number, brush: number, radius: number, strength: number, falloff: number, flags: number, plane_offset: number, symmetry: number): number;
+
+/**
+ * Create a sculpt session from a standard mesh buffer
+ * `[vertexCount, x,y,z..., i0,i1,i2...]`. Returns the session id, or 0 on
+ * invalid input.
+ */
+export function sculpt_session_create(vertex_count: number, buffer: Float64Array): number;
+
+/**
+ * Apply one dab. Returns the render patch `[index, x,y,z, nx,ny,nz]` per
+ * changed vertex (f32), empty when nothing changed.
+ */
+export function sculpt_session_dab(id: number, cx: number, cy: number, cz: number, vx: number, vy: number, vz: number, dragx: number, dragy: number, dragz: number, pressure: number): Float32Array;
+
+/**
+ * Finish the active stroke (pushes one undo entry).
+ */
+export function sculpt_session_end_stroke(id: number): void;
+
+/**
+ * Smooth face group around a seed triangle (dihedral flood fill, same
+ * semantics as the mesh-level query push-pull uses). Returns the group's
+ * triangle indices; empty when the session/seed is invalid.
+ */
+export function sculpt_session_face_group(id: number, seed_triangle: number, max_angle_deg: number): Uint32Array;
+
+/**
+ * Session stats: `[vertexCount, triangleCount, averageEdgeLength, undoDepth,
+ * redoDepth]`; empty if the session does not exist.
+ */
+export function sculpt_session_info(id: number): Float64Array;
+
+/**
+ * Fill the sculpt mask with one value (0 clears). Undoable; returns the
+ * render patch (stride 8) of changed vertices.
+ */
+export function sculpt_session_mask_fill(id: number, value: number): Float32Array;
+
+/**
+ * Invert the sculpt mask. Undoable; returns the render patch (stride 8).
+ */
+export function sculpt_session_mask_invert(id: number): Float32Array;
+
+/**
+ * Current mesh as a standard f64 buffer (for committing back to a document).
+ */
+export function sculpt_session_mesh_buffer(id: number): Float64Array;
+
+/**
+ * Raycast the CURRENT (deforming) surface. Returns
+ * `[px,py,pz, nx,ny,nz, distance, triangleIndex]` or empty on miss.
+ */
+export function sculpt_session_raycast(id: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number): Float64Array;
+
+/**
+ * Redo the last undone stroke. Same contract as `sculpt_session_undo`.
+ */
+export function sculpt_session_redo(id: number): Float32Array;
+
+/**
+ * Release a sculpt session and free its memory.
+ */
+export function sculpt_session_release(id: number): void;
+
+/**
+ * Full render snapshot as f32:
+ * `[vertexCount, triangleCount, positions..., normals..., mask..., indices...]`.
+ */
+export function sculpt_session_render_data(id: number): Float32Array;
+
+/**
+ * Uniform 1:4 shape-preserving subdivision (adds sculptable detail).
+ * Clears session undo history. Returns 1 on success, 0 when refused
+ * (session missing or the result would exceed the safety cap). Callers must
+ * refetch `sculpt_session_render_data` afterwards.
+ */
+export function sculpt_session_subdivide(id: number): number;
+
+/**
+ * Locally refine the given triangles 1:4 with crack-free conforming
+ * neighbor splits (red-green refinement). Returns 1 on success, 0 when
+ * refused (bad input or safety cap). Clears session undo history; callers
+ * must refetch `sculpt_session_render_data` afterwards.
+ */
+export function sculpt_session_subdivide_faces(id: number, triangles: Uint32Array): number;
+
+/**
+ * Undo the last stroke. Returns the render patch restoring the previous
+ * positions; empty when there is nothing to undo.
+ */
+export function sculpt_session_undo(id: number): Float32Array;
+
 /**
  * Sweep a profile curve along a path curve using exact curve evaluation.
  * profile_data/path_data: encoded curve (see decode_curve)
@@ -1536,6 +1634,22 @@ export interface InitOutput {
     readonly ray_closest_point_parameter: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
     readonly ray_point_at: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly sample_nurbs_curve: (a: number, b: number, c: number) => [number, number];
+    readonly sculpt_session_begin_stroke: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly sculpt_session_create: (a: number, b: number, c: number) => number;
+    readonly sculpt_session_dab: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
+    readonly sculpt_session_end_stroke: (a: number) => void;
+    readonly sculpt_session_face_group: (a: number, b: number, c: number) => [number, number];
+    readonly sculpt_session_info: (a: number) => [number, number];
+    readonly sculpt_session_mask_fill: (a: number, b: number) => [number, number];
+    readonly sculpt_session_mask_invert: (a: number) => [number, number];
+    readonly sculpt_session_mesh_buffer: (a: number) => [number, number];
+    readonly sculpt_session_raycast: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly sculpt_session_redo: (a: number) => [number, number];
+    readonly sculpt_session_release: (a: number) => void;
+    readonly sculpt_session_render_data: (a: number) => [number, number];
+    readonly sculpt_session_subdivide: (a: number) => number;
+    readonly sculpt_session_subdivide_faces: (a: number, b: number, c: number) => number;
+    readonly sculpt_session_undo: (a: number) => [number, number];
     readonly sweep_curves: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly sweep_polylines: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly tessellate_nurbs_surface: (a: number, b: number) => [number, number];

package/src/wasm-bindings.js

@@ -3886,6 +3886,232 @@ export function sample_nurbs_curve(data, samples) {
     return v2;
 }
 
+/**
+ * Begin a stroke. `brush` and `falloff` are stable enum codes
+ * (see okgeometry-api SculptBrush / SculptFalloff). Flags: bit 0 = invert,
+ * bit 1 = front faces only. `symmetry`: bit 0 = X, bit 1 = Y, bit 2 = Z.
+ * @param {number} id
+ * @param {number} brush
+ * @param {number} radius
+ * @param {number} strength
+ * @param {number} falloff
+ * @param {number} flags
+ * @param {number} plane_offset
+ * @param {number} symmetry
+ * @returns {number}
+ */
+export function sculpt_session_begin_stroke(id, brush, radius, strength, falloff, flags, plane_offset, symmetry) {
+    const ret = wasm.sculpt_session_begin_stroke(id, brush, radius, strength, falloff, flags, plane_offset, symmetry);
+    return ret >>> 0;
+}
+
+/**
+ * Create a sculpt session from a standard mesh buffer
+ * `[vertexCount, x,y,z..., i0,i1,i2...]`. Returns the session id, or 0 on
+ * invalid input.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {number}
+ */
+export function sculpt_session_create(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sculpt_session_create(vertex_count, ptr0, len0);
+    return ret >>> 0;
+}
+
+/**
+ * Apply one dab. Returns the render patch `[index, x,y,z, nx,ny,nz]` per
+ * changed vertex (f32), empty when nothing changed.
+ * @param {number} id
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} dragx
+ * @param {number} dragy
+ * @param {number} dragz
+ * @param {number} pressure
+ * @returns {Float32Array}
+ */
+export function sculpt_session_dab(id, cx, cy, cz, vx, vy, vz, dragx, dragy, dragz, pressure) {
+    const ret = wasm.sculpt_session_dab(id, cx, cy, cz, vx, vy, vz, dragx, dragy, dragz, pressure);
+    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * Finish the active stroke (pushes one undo entry).
+ * @param {number} id
+ */
+export function sculpt_session_end_stroke(id) {
+    wasm.sculpt_session_end_stroke(id);
+}
+
+/**
+ * Smooth face group around a seed triangle (dihedral flood fill, same
+ * semantics as the mesh-level query push-pull uses). Returns the group's
+ * triangle indices; empty when the session/seed is invalid.
+ * @param {number} id
+ * @param {number} seed_triangle
+ * @param {number} max_angle_deg
+ * @returns {Uint32Array}
+ */
+export function sculpt_session_face_group(id, seed_triangle, max_angle_deg) {
+    const ret = wasm.sculpt_session_face_group(id, seed_triangle, max_angle_deg);
+    var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * Session stats: `[vertexCount, triangleCount, averageEdgeLength, undoDepth,
+ * redoDepth]`; empty if the session does not exist.
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function sculpt_session_info(id) {
+    const ret = wasm.sculpt_session_info(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Fill the sculpt mask with one value (0 clears). Undoable; returns the
+ * render patch (stride 8) of changed vertices.
+ * @param {number} id
+ * @param {number} value
+ * @returns {Float32Array}
+ */
+export function sculpt_session_mask_fill(id, value) {
+    const ret = wasm.sculpt_session_mask_fill(id, value);
+    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * Invert the sculpt mask. Undoable; returns the render patch (stride 8).
+ * @param {number} id
+ * @returns {Float32Array}
+ */
+export function sculpt_session_mask_invert(id) {
+    const ret = wasm.sculpt_session_mask_invert(id);
+    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * Current mesh as a standard f64 buffer (for committing back to a document).
+ * @param {number} id
+ * @returns {Float64Array}
+ */
+export function sculpt_session_mesh_buffer(id) {
+    const ret = wasm.sculpt_session_mesh_buffer(id);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Raycast the CURRENT (deforming) surface. Returns
+ * `[px,py,pz, nx,ny,nz, distance, triangleIndex]` or empty on miss.
+ * @param {number} id
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @returns {Float64Array}
+ */
+export function sculpt_session_raycast(id, ox, oy, oz, dx, dy, dz) {
+    const ret = wasm.sculpt_session_raycast(id, ox, oy, oz, dx, dy, dz);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Redo the last undone stroke. Same contract as `sculpt_session_undo`.
+ * @param {number} id
+ * @returns {Float32Array}
+ */
+export function sculpt_session_redo(id) {
+    const ret = wasm.sculpt_session_redo(id);
+    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * Release a sculpt session and free its memory.
+ * @param {number} id
+ */
+export function sculpt_session_release(id) {
+    wasm.sculpt_session_release(id);
+}
+
+/**
+ * Full render snapshot as f32:
+ * `[vertexCount, triangleCount, positions..., normals..., mask..., indices...]`.
+ * @param {number} id
+ * @returns {Float32Array}
+ */
+export function sculpt_session_render_data(id) {
+    const ret = wasm.sculpt_session_render_data(id);
+    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * Uniform 1:4 shape-preserving subdivision (adds sculptable detail).
+ * Clears session undo history. Returns 1 on success, 0 when refused
+ * (session missing or the result would exceed the safety cap). Callers must
+ * refetch `sculpt_session_render_data` afterwards.
+ * @param {number} id
+ * @returns {number}
+ */
+export function sculpt_session_subdivide(id) {
+    const ret = wasm.sculpt_session_subdivide(id);
+    return ret >>> 0;
+}
+
+/**
+ * Locally refine the given triangles 1:4 with crack-free conforming
+ * neighbor splits (red-green refinement). Returns 1 on success, 0 when
+ * refused (bad input or safety cap). Clears session undo history; callers
+ * must refetch `sculpt_session_render_data` afterwards.
+ * @param {number} id
+ * @param {Uint32Array} triangles
+ * @returns {number}
+ */
+export function sculpt_session_subdivide_faces(id, triangles) {
+    const ptr0 = passArray32ToWasm0(triangles, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sculpt_session_subdivide_faces(id, ptr0, len0);
+    return ret >>> 0;
+}
+
+/**
+ * Undo the last stroke. Returns the render patch restoring the previous
+ * positions; empty when there is nothing to undo.
+ * @param {number} id
+ * @returns {Float32Array}
+ */
+export function sculpt_session_undo(id) {
+    const ret = wasm.sculpt_session_undo(id);
+    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
 /**
  * Sweep a profile curve along a path curve using exact curve evaluation.
  * profile_data/path_data: encoded curve (see decode_curve)
@@ -4047,6 +4273,11 @@ function getArrayF64FromWasm0(ptr, len) {
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -4073,6 +4304,14 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -4081,6 +4320,13 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -4167,6 +4413,7 @@ function __wbg_finalize_init(instance, module) {
     wasmModule = module;
     cachedFloat32ArrayMemory0 = null;
     cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();
     return wasm;