okgeometry-api 0.5.0 → 0.5.2

package/src/Ray.ts

@@ -0,0 +1,90 @@
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import * as wasm from "../wasm/okgeometrycore_bg.js";
+
+/**
+ * 3D ray defined by origin and direction.
+ * Parametric form: point(t) = origin + t * direction
+ */
+export class Ray {
+  constructor(
+    public readonly origin: Point,
+    public readonly direction: Vec3
+  ) {}
+
+  /**
+   * Create a ray from origin and direction, normalizing the direction.
+   * Returns null if direction is zero-length.
+   */
+  static fromOriginDirection(origin: Point, direction: Vec3): Ray | null {
+    const normalized = direction.normalize();
+    if (normalized.length() < 1e-10) return null;
+    return new Ray(origin, normalized);
+  }
+
+  /**
+   * Get point along the ray at parameter t.
+   * Returns origin + t * direction
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.ray_point_at(
+      this.origin.x, this.origin.y, this.origin.z,
+      this.direction.x, this.direction.y, this.direction.z,
+      t
+    );
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Find the parameter t for the closest point on the ray to a given point.
+   * The closest point is at: origin + t * direction
+   * Note: t can be negative if the closest point is "behind" the ray origin,
+   * but closestPoint() clamps t >= 0.
+   */
+  closestPointParameter(point: Point): number {
+    ensureInit();
+    return wasm.ray_closest_point_parameter(
+      this.origin.x, this.origin.y, this.origin.z,
+      this.direction.x, this.direction.y, this.direction.z,
+      point.x, point.y, point.z
+    );
+  }
+
+  /**
+   * Find the closest point on the ray to a given point.
+   * The result is clamped to the ray (t >= 0), so if the closest
+   * point would be "behind" the origin, returns the origin.
+   */
+  closestPoint(point: Point): Point {
+    ensureInit();
+    const r = wasm.ray_closest_point(
+      this.origin.x, this.origin.y, this.origin.z,
+      this.direction.x, this.direction.y, this.direction.z,
+      point.x, point.y, point.z
+    );
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Compute the distance from this ray to a point.
+   * This is the perpendicular distance from the ray to the point,
+   * clamped so that the closest point is on the ray (t >= 0).
+   */
+  distanceToPoint(point: Point): number {
+    ensureInit();
+    return wasm.ray_distance_to_point(
+      this.origin.x, this.origin.y, this.origin.z,
+      this.direction.x, this.direction.y, this.direction.z,
+      point.x, point.y, point.z
+    );
+  }
+
+  /**
+   * Translate the ray by an offset vector.
+   */
+  translate(offset: Vec3): Ray {
+    return new Ray(this.origin.add(offset), this.direction);
+  }
+}

package/src/Vec3.ts

@@ -0,0 +1,159 @@
+/**
+ * Immutable 3D vector for representing directions and offsets.
+ * All operations return new Vec3 instances.
+ */
+export class Vec3 {
+  constructor(
+    public readonly x: number,
+    public readonly y: number,
+    public readonly z: number
+  ) {}
+
+  /**
+   * Add another vector to this one.
+   * @param v - Vector to add
+   * @returns New vector representing the sum
+   */
+  add(v: Vec3): Vec3 {
+    return new Vec3(this.x + v.x, this.y + v.y, this.z + v.z);
+  }
+
+  /**
+   * Subtract another vector from this one.
+   * @param v - Vector to subtract
+   * @returns New vector representing the difference
+   */
+  sub(v: Vec3): Vec3 {
+    return new Vec3(this.x - v.x, this.y - v.y, this.z - v.z);
+  }
+
+  /**
+   * Scale this vector by a scalar value.
+   * @param s - Scalar multiplier
+   * @returns New scaled vector
+   */
+  scale(s: number): Vec3 {
+    return new Vec3(this.x * s, this.y * s, this.z * s);
+  }
+
+  /**
+   * Compute the dot product with another vector.
+   * @param v - Vector to dot with
+   * @returns Scalar dot product value
+   */
+  dot(v: Vec3): number {
+    return this.x * v.x + this.y * v.y + this.z * v.z;
+  }
+
+  /**
+   * Compute the cross product with another vector.
+   * @param v - Vector to cross with
+   * @returns New vector perpendicular to both inputs
+   */
+  cross(v: Vec3): Vec3 {
+    return new Vec3(
+      this.y * v.z - this.z * v.y,
+      this.z * v.x - this.x * v.z,
+      this.x * v.y - this.y * v.x
+    );
+  }
+
+  /**
+   * Get the magnitude (length) of this vector.
+   * @returns Euclidean length
+   */
+  length(): number {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+
+  /**
+   * Get a unit vector in the same direction.
+   * Returns zero vector if length is zero.
+   * @returns Normalized unit vector
+   */
+  normalize(): Vec3 {
+    const len = this.length();
+    if (len === 0) return new Vec3(0, 0, 0);
+    return this.scale(1 / len);
+  }
+
+  /**
+   * Compute the distance to another vector.
+   * @param v - Target vector
+   * @returns Euclidean distance between vectors
+   */
+  distance(v: Vec3): number {
+    return this.sub(v).length();
+  }
+
+  /**
+   * Linear interpolation between this vector and another.
+   * @param v - Target vector
+   * @param t - Parameter in [0, 1] (0 = this, 1 = v)
+   * @returns Interpolated vector
+   */
+  lerp(v: Vec3, t: number): Vec3 {
+    return new Vec3(
+      this.x + (v.x - this.x) * t,
+      this.y + (v.y - this.y) * t,
+      this.z + (v.z - this.z) * t
+    );
+  }
+
+  /**
+   * Get the negation of this vector.
+   * @returns Vector pointing in opposite direction
+   */
+  negate(): Vec3 {
+    return new Vec3(-this.x, -this.y, -this.z);
+  }
+
+  /**
+   * Create a copy of this vector.
+   * @returns New vector with same components
+   */
+  clone(): Vec3 {
+    return new Vec3(this.x, this.y, this.z);
+  }
+
+  /**
+   * Check equality with another vector within tolerance.
+   * @param v - Vector to compare
+   * @param eps - Tolerance (default 1e-10)
+   * @returns True if vectors are approximately equal
+   */
+  equals(v: Vec3, eps = 1e-10): boolean {
+    return (
+      Math.abs(this.x - v.x) < eps &&
+      Math.abs(this.y - v.y) < eps &&
+      Math.abs(this.z - v.z) < eps
+    );
+  }
+
+  /**
+   * Convert to array format.
+   * @returns Tuple [x, y, z]
+   */
+  toArray(): [number, number, number] {
+    return [this.x, this.y, this.z];
+  }
+
+  /**
+   * Create a Vec3 from a plain object or JSON.
+   * @param json - Object with x, y, z properties
+   * @returns New Vec3 instance
+   */
+  static fromJSON(json: any): Vec3 {
+    if (json instanceof Vec3) return json;
+    return new Vec3(json.x ?? 0, json.y ?? 0, json.z ?? 0);
+  }
+
+  /** Zero vector (0, 0, 0) */
+  static readonly ZERO = new Vec3(0, 0, 0);
+  /** Unit X axis (1, 0, 0) */
+  static readonly X = new Vec3(1, 0, 0);
+  /** Unit Y axis (0, 1, 0) */
+  static readonly Y = new Vec3(0, 1, 0);
+  /** Unit Z axis (0, 0, 1) */
+  static readonly Z = new Vec3(0, 0, 1);
+}

package/src/engine.ts

@@ -0,0 +1,92 @@
+import { WASM_B64 } from "./wasm-base64.js";
+import * as bg from "../wasm/okgeometrycore_bg.js";
+
+let initialized = false;
+let wasmExports: Record<string, unknown> | null = null;
+
+const engineGlobal = globalThis as typeof globalThis & {
+  __okgeometry_boolean_should_cancel?: () => boolean;
+};
+
+if (typeof engineGlobal.__okgeometry_boolean_should_cancel !== "function") {
+  engineGlobal.__okgeometry_boolean_should_cancel = () => false;
+}
+
+function buildWasmImports(requiredNames: string[] = []): Record<string, unknown> {
+  const bgAny = bg as Record<string, unknown>;
+  const importModule: Record<string, unknown> = { ...bgAny };
+  const cancelKey = Object.keys(importModule).find(k => k.startsWith("__wbg___okgeometry_boolean_should_cancel_"));
+  const cancelFn = () => {
+    try {
+      return !!engineGlobal.__okgeometry_boolean_should_cancel?.();
+    } catch {
+      return false;
+    }
+  };
+  if (cancelKey) {
+    importModule[cancelKey] = cancelFn;
+  } else {
+    // Fallback to current known symbol in generated bindings.
+    importModule.__wbg___okgeometry_boolean_should_cancel_3e76652b5286d323 = cancelFn;
+  }
+
+  // Fill hash-suffixed imports that may not be exported by generated glue in this runtime.
+  for (const name of requiredNames) {
+    const existing = importModule[name];
+    if (typeof existing === "function") {
+      continue;
+    }
+    if (name.startsWith("__wbg___okgeometry_boolean_should_cancel_")) {
+      importModule[name] = cancelFn;
+      continue;
+    }
+    if (name.startsWith("__wbg_now_")) {
+      importModule[name] = () => Date.now();
+      continue;
+    }
+    if (name.startsWith("__wbg___wbindgen_throw_")) {
+      importModule[name] = () => {
+        throw new Error("WASM trap: __wbindgen_throw");
+      };
+      continue;
+    }
+    if (name === "__wbindgen_init_externref_table") {
+      importModule[name] = () => {};
+      continue;
+    }
+  }
+
+  return importModule;
+}
+
+export async function init(): Promise<void> {
+  if (initialized) return;
+  const raw = atob(WASM_B64);
+  const bytes = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) bytes[i] = raw.charCodeAt(i);
+
+  const wasmModule = await WebAssembly.compile(bytes.buffer);
+  const requiredNames = WebAssembly.Module.imports(wasmModule)
+    .filter((imp) => imp.module === "./okgeometrycore_bg.js")
+    .map((imp) => imp.name);
+  const importModule = buildWasmImports(requiredNames);
+  const instance = await WebAssembly.instantiate(wasmModule, {
+    "./okgeometrycore_bg.js": importModule as any,
+  });
+  wasmExports = instance.exports as Record<string, unknown>;
+
+  (bg as any).__wbg_set_wasm(instance.exports);
+  (instance.exports as any).__wbindgen_start();
+
+  initialized = true;
+}
+
+export function ensureInit(): void {
+  if (!initialized) {
+    throw new Error("OkGeometry WASM not initialized. Call `await init()` before using geometry operations.");
+  }
+}
+
+export function isInitialized(): boolean {
+  return initialized;
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+// Core initialization
+export { init, isInitialized } from "./engine.js";
+
+// Shared types and utilities
+export type {
+  SweepableCurve,
+  LoftableCurve,
+  RotationAxis,
+  CurveSegment,
+} from "./types.js";
+export { CurveTypeCode, SegmentTypeCode } from "./types.js";
+export {
+  pointsToCoords,
+  coordsToPoints,
+  parsePolylineBuffer,
+  parseIntersectionPoints,
+} from "./BufferCodec.js";
+
+// Primitive types
+export { Vec3 } from "./Vec3.js";
+export { Point } from "./Point.js";
+export { Plane } from "./Plane.js";
+export { Ray } from "./Ray.js";
+
+// Curve types
+export { Line } from "./Line.js";
+export { Circle } from "./Circle.js";
+export { Arc } from "./Arc.js";
+export { Polyline } from "./Polyline.js";
+export { Polygon } from "./Polygon.js";
+export { PolyCurve } from "./PolyCurve.js";
+export { NurbsCurve } from "./NurbsCurve.js";
+export { NurbsSurface } from "./NurbsSurface.js";
+
+// Mesh and operations
+export { Mesh, MeshBooleanExecutionError } from "./Mesh.js";
+export type {
+  MeshBooleanLimits,
+  MeshBooleanOptions,
+  MeshBooleanAsyncOptions,
+  MeshBooleanErrorCode,
+  MeshBooleanErrorPayload,
+  MeshBooleanProgressEvent,
+} from "./Mesh.js";
+export { intersect } from "./Geometry.js";