okgeometry-api 1.0.0 → 1.1.0

package/dist/wasm-base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,028yDAA028yD,CAAC"}
+{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,sz8tDAAsz8tD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Geometry engine API for AEC applications — NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",

package/src/Mesh.ts

@@ -18,20 +18,20 @@ import {
   runMeshBooleanInWorkerPool,
 } from "./mesh-boolean.pool.js";
 import { MeshBooleanExecutionError } from "./mesh-boolean.protocol.js";
-import type {
-  MeshBooleanAsyncOptions,
-  MeshBooleanLimits,
-  MeshBooleanOptions,
-} from "./mesh-boolean.protocol.js";
-import * as wasm from "../wasm/okgeometrycore_bg.js";
-import { mesh_topology_metrics } from "../wasm/okgeometrycore.js";
+import type {
+  MeshBooleanAsyncOptions,
+  MeshBooleanLimits,
+  MeshBooleanOptions,
+} from "./mesh-boolean.protocol.js";
+import * as wasm from "../wasm/okgeometrycore_bg.js";
+import { mesh_topology_metrics } from "../wasm/okgeometrycore.js";
 
 export { MeshBooleanExecutionError };
-export type {
-  MeshBooleanAsyncOptions,
-  MeshBooleanLimits,
-  MeshBooleanOptions,
-  MeshBooleanErrorCode,
+export type {
+  MeshBooleanAsyncOptions,
+  MeshBooleanLimits,
+  MeshBooleanOptions,
+  MeshBooleanErrorCode,
   MeshBooleanErrorPayload,
   MeshBooleanProgressEvent,
 } from "./mesh-boolean.protocol.js";
@@ -71,33 +71,33 @@ interface RawMeshBounds {
  *
  * Buffer format: [vertexCount, x1,y1,z1, ..., i1,i2,i3, ...]
  */
-export class Mesh {
-  private _buffer: Float64Array;
-  private _vertexCount: number;
-  private _trustedBooleanInput: boolean;
-
-  private static readonly DEFAULT_BOOLEAN_LIMITS: MeshBooleanLimits = {
-    maxInputFacesPerMesh: 120_000,
-    maxCombinedInputFaces: 180_000,
-    maxFaceProduct: 500_000_000,
-  };
-  private static readonly TOPOLOGY_METRICS_CACHE_FACE_THRESHOLD = 20_000;
-
-  // Lazy caches
-  private _positionBuffer: Float32Array | null = null;
-  private _indexBuffer: Uint32Array | null = null;
-  private _vertices: Point[] | null = null;
-  private _faces: number[][] | null = null;
-  private _edgeVertexPairs: Array<[number, number]> | null = null;
-  private _topologyMetricsCache: { boundaryEdges: number; nonManifoldEdges: number } | null = null;
-  private _isClosedVolumeCache: boolean | null = null;
-  private _rawBoundsCache: RawMeshBounds | null | undefined = undefined;
-
-  private constructor(buffer: Float64Array, trustedBooleanInput = false) {
-    this._buffer = buffer;
-    this._vertexCount = buffer.length > 0 ? buffer[0] : 0;
-    this._trustedBooleanInput = trustedBooleanInput;
-  }
+export class Mesh {
+  private _buffer: Float64Array;
+  private _vertexCount: number;
+  private _trustedBooleanInput: boolean;
+
+  private static readonly DEFAULT_BOOLEAN_LIMITS: MeshBooleanLimits = {
+    maxInputFacesPerMesh: 120_000,
+    maxCombinedInputFaces: 180_000,
+    maxFaceProduct: 500_000_000,
+  };
+  private static readonly TOPOLOGY_METRICS_CACHE_FACE_THRESHOLD = 20_000;
+
+  // Lazy caches
+  private _positionBuffer: Float32Array | null = null;
+  private _indexBuffer: Uint32Array | null = null;
+  private _vertices: Point[] | null = null;
+  private _faces: number[][] | null = null;
+  private _edgeVertexPairs: Array<[number, number]> | null = null;
+  private _topologyMetricsCache: { boundaryEdges: number; nonManifoldEdges: number } | null = null;
+  private _isClosedVolumeCache: boolean | null = null;
+  private _rawBoundsCache: RawMeshBounds | null | undefined = undefined;
+
+  private constructor(buffer: Float64Array, trustedBooleanInput = false) {
+    this._buffer = buffer;
+    this._vertexCount = buffer.length > 0 ? buffer[0] : 0;
+    this._trustedBooleanInput = trustedBooleanInput;
+  }
 
   /**
    * Configure default size for the shared boolean worker pool.
@@ -124,14 +124,14 @@ export class Mesh {
     };
   }
 
-  private static computeRawBounds(mesh: Mesh): RawMeshBounds | null {
-    if (mesh._rawBoundsCache !== undefined) return mesh._rawBoundsCache;
-    if (mesh._vertexCount <= 0) {
-      mesh._rawBoundsCache = null;
-      return null;
-    }
-
-    const data = mesh._buffer;
+  private static computeRawBounds(mesh: Mesh): RawMeshBounds | null {
+    if (mesh._rawBoundsCache !== undefined) return mesh._rawBoundsCache;
+    if (mesh._vertexCount <= 0) {
+      mesh._rawBoundsCache = null;
+      return null;
+    }
+
+    const data = mesh._buffer;
     const limit = 1 + mesh._vertexCount * 3;
 
     let minX = data[1];
@@ -153,44 +153,44 @@ export class Mesh {
       if (z > maxZ) maxZ = z;
     }
 
-    const bounds = { minX, minY, minZ, maxX, maxY, maxZ };
-    mesh._rawBoundsCache = bounds;
-    return bounds;
-  }
-
-  private static boundsOverlap(a: RawMeshBounds | null, b: RawMeshBounds | null, eps = 1e-9): boolean {
-    if (!a || !b) return false;
-    return a.minX <= b.maxX + eps
-      && a.maxX + eps >= b.minX
-      && a.minY <= b.maxY + eps
-      && a.maxY + eps >= b.minY
-      && a.minZ <= b.maxZ + eps
-      && a.maxZ + eps >= b.minZ;
-  }
-
-  private static boundsDiag(bounds: RawMeshBounds | null): number {
-    if (!bounds) return 1;
-    const dx = bounds.maxX - bounds.minX;
-    const dy = bounds.maxY - bounds.minY;
-    const dz = bounds.maxZ - bounds.minZ;
-    const diag = Math.hypot(dx, dy, dz);
-    return Number.isFinite(diag) && diag > 0 ? diag : 1;
-  }
-
-  private static booleanContactTolerance(a: RawMeshBounds | null, b: RawMeshBounds | null): number {
-    const scale = Math.max(Mesh.boundsDiag(a), Mesh.boundsDiag(b));
-    return Math.min(1e-4, Math.max(1e-9, scale * 1e-6));
-  }
-
-  private static cloneMesh(mesh: Mesh): Mesh {
-    return Mesh.fromBuffer(new Float64Array(mesh._buffer), {
-      trustedBooleanInput: mesh._trustedBooleanInput,
-    });
-  }
-
-  private static emptyMesh(): Mesh {
-    return Mesh.fromTrustedBuffer(new Float64Array(0));
-  }
+    const bounds = { minX, minY, minZ, maxX, maxY, maxZ };
+    mesh._rawBoundsCache = bounds;
+    return bounds;
+  }
+
+  private static boundsOverlap(a: RawMeshBounds | null, b: RawMeshBounds | null, eps = 1e-9): boolean {
+    if (!a || !b) return false;
+    return a.minX <= b.maxX + eps
+      && a.maxX + eps >= b.minX
+      && a.minY <= b.maxY + eps
+      && a.maxY + eps >= b.minY
+      && a.minZ <= b.maxZ + eps
+      && a.maxZ + eps >= b.minZ;
+  }
+
+  private static boundsDiag(bounds: RawMeshBounds | null): number {
+    if (!bounds) return 1;
+    const dx = bounds.maxX - bounds.minX;
+    const dy = bounds.maxY - bounds.minY;
+    const dz = bounds.maxZ - bounds.minZ;
+    const diag = Math.hypot(dx, dy, dz);
+    return Number.isFinite(diag) && diag > 0 ? diag : 1;
+  }
+
+  private static booleanContactTolerance(a: RawMeshBounds | null, b: RawMeshBounds | null): number {
+    const scale = Math.max(Mesh.boundsDiag(a), Mesh.boundsDiag(b));
+    return Math.min(1e-4, Math.max(1e-9, scale * 1e-6));
+  }
+
+  private static cloneMesh(mesh: Mesh): Mesh {
+    return Mesh.fromBuffer(new Float64Array(mesh._buffer), {
+      trustedBooleanInput: mesh._trustedBooleanInput,
+    });
+  }
+
+  private static emptyMesh(): Mesh {
+    return Mesh.fromTrustedBuffer(new Float64Array(0));
+  }
 
   // ── GPU-ready buffers ──────────────────────────────────────────
 
@@ -230,12 +230,12 @@ export class Mesh {
     return this._vertexCount;
   }
 
-  /** Number of triangular faces in this mesh */
-  get faceCount(): number {
-    const start = 1 + this._vertexCount * 3;
-    if (this._buffer.length <= start) return 0;
-    return Math.floor((this._buffer.length - start) / 3);
-  }
+  /** Number of triangular faces in this mesh */
+  get faceCount(): number {
+    const start = 1 + this._vertexCount * 3;
+    if (this._buffer.length <= start) return 0;
+    return Math.floor((this._buffer.length - start) / 3);
+  }
 
   // ── High-level accessors (lazy) ────────────────────────────────
 
@@ -284,20 +284,20 @@ export class Mesh {
    * @param buffer - Float64Array in mesh buffer format
    * @returns New Mesh instance
    */
-  static fromBuffer(
-    buffer: Float64Array,
-    options?: { trustedBooleanInput?: boolean },
-  ): Mesh {
-    return new Mesh(buffer, options?.trustedBooleanInput ?? false);
-  }
-
-  private static fromTrustedBuffer(buffer: Float64Array): Mesh {
-    return new Mesh(buffer, true);
-  }
-
-  get trustedBooleanInput(): boolean {
-    return this._trustedBooleanInput;
-  }
+  static fromBuffer(
+    buffer: Float64Array,
+    options?: { trustedBooleanInput?: boolean },
+  ): Mesh {
+    return new Mesh(buffer, options?.trustedBooleanInput ?? false);
+  }
+
+  private static fromTrustedBuffer(buffer: Float64Array): Mesh {
+    return new Mesh(buffer, true);
+  }
+
+  get trustedBooleanInput(): boolean {
+    return this._trustedBooleanInput;
+  }
 
   /**
    * Build an axis-aligned rectangle on a plane basis from opposite corners.
@@ -580,11 +580,11 @@ export class Mesh {
    * @param pts - Ordered boundary points defining a closed polygon (minimum 3)
    * @returns New Mesh triangulating the polygon interior
    */
-  static patchFromPoints(pts: Point[]): Mesh {
-    ensureInit();
-    const coords = pointsToCoords(pts);
-    const buf = wasm.mesh_patch_from_points(coords);
-    return Mesh.fromTrustedBuffer(buf);
+  static patchFromPoints(pts: Point[]): Mesh {
+    ensureInit();
+    const coords = pointsToCoords(pts);
+    const buf = wasm.mesh_patch_from_points(coords);
+    return Mesh.fromTrustedBuffer(buf);
   }
 
   /**
@@ -739,7 +739,7 @@ export class Mesh {
       height,
       closed,
     );
-    return Mesh.fromTrustedBuffer(buf);
+    return Mesh.fromTrustedBuffer(buf);
   }
 
   /**
@@ -862,7 +862,7 @@ export class Mesh {
   private static mergeMeshes(meshes: Mesh[]): Mesh {
     ensureInit();
     const packed = Mesh.packMeshes(meshes);
-    return Mesh.fromTrustedBuffer(wasm.mesh_merge(packed));
+    return Mesh.fromTrustedBuffer(wasm.mesh_merge(packed));
   }
 
   /**
@@ -1014,16 +1014,16 @@ export class Mesh {
     } else {
       if (faceCountA === 0) return Mesh.emptyMesh();
       if (faceCountB === 0) return Mesh.cloneMesh(this);
-    }
-
-    const boundsA = Mesh.computeRawBounds(this);
-    const boundsB = Mesh.computeRawBounds(other);
-    const contactTol = Mesh.booleanContactTolerance(boundsA, boundsB);
-    if (!Mesh.boundsOverlap(boundsA, boundsB, contactTol)) {
-      if (operation === "union") return Mesh.mergeMeshes([this, other]);
-      if (operation === "intersection") return Mesh.emptyMesh();
-      return Mesh.cloneMesh(this);
-    }
+    }
+
+    const boundsA = Mesh.computeRawBounds(this);
+    const boundsB = Mesh.computeRawBounds(other);
+    const contactTol = Mesh.booleanContactTolerance(boundsA, boundsB);
+    if (!Mesh.boundsOverlap(boundsA, boundsB, contactTol)) {
+      if (operation === "union") return Mesh.mergeMeshes([this, other]);
+      if (operation === "intersection") return Mesh.emptyMesh();
+      return Mesh.cloneMesh(this);
+    }
 
     if (!options?.allowUnsafe) {
       const limits = Mesh.resolveBooleanLimits(options?.limits);
@@ -1051,24 +1051,24 @@ export class Mesh {
     if (!Number.isFinite(vertexCount) || vertexCount < 0) {
       throw new Error(`Boolean ${operation} failed and returned a corrupt mesh buffer.`);
     }
-    return Mesh.fromTrustedBuffer(result);
-  }
-
-  static encodeBooleanOperationToken(
-    operation: "union" | "subtraction" | "intersection",
-    a: Mesh,
-    b: Mesh,
-    options?: MeshBooleanOptions,
-  ): string {
-    const tokens: string[] = [operation];
-    if (a._trustedBooleanInput && b._trustedBooleanInput) {
-      tokens.push("trustedInput");
-    }
-    if (options?.debugForceFaceID) {
-      tokens.push("forceFaceID");
-    }
-    return tokens.join("@");
-  }
+    return Mesh.fromTrustedBuffer(result);
+  }
+
+  static encodeBooleanOperationToken(
+    operation: "union" | "subtraction" | "intersection",
+    a: Mesh,
+    b: Mesh,
+    options?: MeshBooleanOptions,
+  ): string {
+    const tokens: string[] = [operation];
+    if (a._trustedBooleanInput && b._trustedBooleanInput) {
+      tokens.push("trustedInput");
+    }
+    if (options?.debugForceFaceID) {
+      tokens.push("forceFaceID");
+    }
+    return tokens.join("@");
+  }
 
   // ── Booleans ───────────────────────────────────────────────────
 
@@ -1078,9 +1078,9 @@ export class Mesh {
    * @param options - Optional safety overrides
    * @returns New mesh containing volume of both inputs
    */
-  union(other: Mesh, options?: MeshBooleanOptions): Mesh {
-    ensureInit();
-    const operationToken = Mesh.encodeBooleanOperationToken("union", this, other, options);
+  union(other: Mesh, options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const operationToken = Mesh.encodeBooleanOperationToken("union", this, other, options);
     return this.runBoolean(
       other,
       "union",
@@ -1101,9 +1101,9 @@ export class Mesh {
    * @param options - Optional safety overrides
    * @returns New mesh with other's volume removed from this
    */
-  subtract(other: Mesh, options?: MeshBooleanOptions): Mesh {
-    ensureInit();
-    const operationToken = Mesh.encodeBooleanOperationToken("subtraction", this, other, options);
+  subtract(other: Mesh, options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const operationToken = Mesh.encodeBooleanOperationToken("subtraction", this, other, options);
     return this.runBoolean(
       other,
       "subtraction",
@@ -1124,9 +1124,9 @@ export class Mesh {
    * @param options - Optional safety overrides
    * @returns New mesh containing only the overlapping volume
    */
-  intersect(other: Mesh, options?: MeshBooleanOptions): Mesh {
-    ensureInit();
-    const operationToken = Mesh.encodeBooleanOperationToken("intersection", this, other, options);
+  intersect(other: Mesh, options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const operationToken = Mesh.encodeBooleanOperationToken("intersection", this, other, options);
     return this.runBoolean(
       other,
       "intersection",
@@ -1146,15 +1146,15 @@ export class Mesh {
    * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
    */
   async unionAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
-    const result = await runMeshBooleanInWorkerPool(
-      "union",
-      this._buffer,
-      other._buffer,
-      this._trustedBooleanInput,
-      other._trustedBooleanInput,
-      options,
-    );
-    return Mesh.fromTrustedBuffer(result);
+    const result = await runMeshBooleanInWorkerPool(
+      "union",
+      this._buffer,
+      other._buffer,
+      this._trustedBooleanInput,
+      other._trustedBooleanInput,
+      options,
+    );
+    return Mesh.fromTrustedBuffer(result);
   }
 
   /**
@@ -1162,15 +1162,15 @@ export class Mesh {
    * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
    */
   async subtractAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
-    const result = await runMeshBooleanInWorkerPool(
-      "subtraction",
-      this._buffer,
-      other._buffer,
-      this._trustedBooleanInput,
-      other._trustedBooleanInput,
-      options,
-    );
-    return Mesh.fromTrustedBuffer(result);
+    const result = await runMeshBooleanInWorkerPool(
+      "subtraction",
+      this._buffer,
+      other._buffer,
+      this._trustedBooleanInput,
+      other._trustedBooleanInput,
+      options,
+    );
+    return Mesh.fromTrustedBuffer(result);
   }
 
   /**
@@ -1178,15 +1178,15 @@ export class Mesh {
    * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
    */
   async intersectAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
-    const result = await runMeshBooleanInWorkerPool(
-      "intersection",
-      this._buffer,
-      other._buffer,
-      this._trustedBooleanInput,
-      other._trustedBooleanInput,
-      options,
-    );
-    return Mesh.fromTrustedBuffer(result);
+    const result = await runMeshBooleanInWorkerPool(
+      "intersection",
+      this._buffer,
+      other._buffer,
+      this._trustedBooleanInput,
+      other._trustedBooleanInput,
+      options,
+    );
+    return Mesh.fromTrustedBuffer(result);
   }
 
   // ── Intersection queries ───────────────────────────────────────
@@ -1464,68 +1464,68 @@ export class Mesh {
   extrudeFace(faceIndex: number, distance: number): Mesh {
     ensureInit();
     if (!Number.isFinite(faceIndex) || faceIndex < 0) {
-      return Mesh.fromBuffer(new Float64Array(this._buffer), {
-        trustedBooleanInput: this._trustedBooleanInput,
-      });
-    }
-    return Mesh.fromTrustedBuffer(
-      wasm.mesh_extrude_face(this._vertexCount, this._buffer, Math.floor(faceIndex), distance),
-    );
-  }
-
-  /**
-   * Check if this triangulated mesh represents a closed volume.
-   * Returns true when no welded topological boundary edges are found.
-   */
-  isClosedVolume(): boolean {
-    if (this._isClosedVolumeCache !== null) {
-      return this._isClosedVolumeCache;
-    }
-    if (this._topologyMetricsCache) {
-      const closedFromMetrics = this._topologyMetricsCache.boundaryEdges === 0;
-      this._isClosedVolumeCache = closedFromMetrics;
-      return closedFromMetrics;
-    }
-
-    ensureInit();
-    if (this.faceCount >= Mesh.TOPOLOGY_METRICS_CACHE_FACE_THRESHOLD) {
-      const metrics = this.topologyMetrics();
-      const closedFromMetrics = metrics.boundaryEdges === 0;
-      this._isClosedVolumeCache = closedFromMetrics;
-      return closedFromMetrics;
-    }
-
-    const closed = wasm.mesh_is_closed_volume(this._vertexCount, this._buffer);
-    this._isClosedVolumeCache = closed;
-    return closed;
-  }
-
-  /**
-   * Return welded-edge topology metrics for this triangulated mesh.
-   * `boundaryEdges`: edges referenced by exactly one triangle.
-   * `nonManifoldEdges`: edges referenced by more than two triangles.
-   */
-  topologyMetrics(): { boundaryEdges: number; nonManifoldEdges: number } {
-    if (this._topologyMetricsCache) {
-      return {
-        boundaryEdges: this._topologyMetricsCache.boundaryEdges,
-        nonManifoldEdges: this._topologyMetricsCache.nonManifoldEdges,
-      };
-    }
-
-    ensureInit();
-    const metrics = mesh_topology_metrics(this._vertexCount, this._buffer);
-    const boundaryEdges = Math.floor(metrics[0] ?? 0);
-    const nonManifoldEdges = Math.floor(metrics[1] ?? 0);
-    this._topologyMetricsCache = { boundaryEdges, nonManifoldEdges };
-    if (this._isClosedVolumeCache === null) {
-      this._isClosedVolumeCache = boundaryEdges === 0;
-    }
-    return {
-      boundaryEdges,
-      nonManifoldEdges,
-    };
-  }
+      return Mesh.fromBuffer(new Float64Array(this._buffer), {
+        trustedBooleanInput: this._trustedBooleanInput,
+      });
+    }
+    return Mesh.fromTrustedBuffer(
+      wasm.mesh_extrude_face(this._vertexCount, this._buffer, Math.floor(faceIndex), distance),
+    );
+  }
+
+  /**
+   * Check if this triangulated mesh represents a closed volume.
+   * Returns true when no welded topological boundary edges are found.
+   */
+  isClosedVolume(): boolean {
+    if (this._isClosedVolumeCache !== null) {
+      return this._isClosedVolumeCache;
+    }
+    if (this._topologyMetricsCache) {
+      const closedFromMetrics = this._topologyMetricsCache.boundaryEdges === 0;
+      this._isClosedVolumeCache = closedFromMetrics;
+      return closedFromMetrics;
+    }
+
+    ensureInit();
+    if (this.faceCount >= Mesh.TOPOLOGY_METRICS_CACHE_FACE_THRESHOLD) {
+      const metrics = this.topologyMetrics();
+      const closedFromMetrics = metrics.boundaryEdges === 0;
+      this._isClosedVolumeCache = closedFromMetrics;
+      return closedFromMetrics;
+    }
+
+    const closed = wasm.mesh_is_closed_volume(this._vertexCount, this._buffer);
+    this._isClosedVolumeCache = closed;
+    return closed;
+  }
+
+  /**
+   * Return welded-edge topology metrics for this triangulated mesh.
+   * `boundaryEdges`: edges referenced by exactly one triangle.
+   * `nonManifoldEdges`: edges referenced by more than two triangles.
+   */
+  topologyMetrics(): { boundaryEdges: number; nonManifoldEdges: number } {
+    if (this._topologyMetricsCache) {
+      return {
+        boundaryEdges: this._topologyMetricsCache.boundaryEdges,
+        nonManifoldEdges: this._topologyMetricsCache.nonManifoldEdges,
+      };
+    }
+
+    ensureInit();
+    const metrics = mesh_topology_metrics(this._vertexCount, this._buffer);
+    const boundaryEdges = Math.floor(metrics[0] ?? 0);
+    const nonManifoldEdges = Math.floor(metrics[1] ?? 0);
+    this._topologyMetricsCache = { boundaryEdges, nonManifoldEdges };
+    if (this._isClosedVolumeCache === null) {
+      this._isClosedVolumeCache = boundaryEdges === 0;
+    }
+    return {
+      boundaryEdges,
+      nonManifoldEdges,
+    };
+  }
 
   /**
    * Odd/even point containment test against a closed mesh.