@directivegames/genesys.js 3.1.24

package/src/csg/ManifoldWrapper.ts

@@ -0,0 +1,704 @@
+/**
+ * ManifoldWrapper - lazy loader and utility layer for the Manifold WASM library.
+ *
+ * Detailed explanation:
+ * - Loads the heavy WebAssembly module only when constructive solid geometry is needed.
+ * - Exposes helper classes like `ActiveManifold` to build shapes and perform boolean operations.
+ * - Converts between Manifold meshes and Three.js geometry for rendering.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Call `init()` before creating manifolds to ensure the WASM module is loaded.
+ * - Use `ActiveManifold` instances to compose shapes and then convert them to `BufferGeometry`.
+ * - Keep the wrapper unloaded in scenes that do not require CSG to save startup time.
+ */
+import Module from 'manifold-3d';
+import * as THREE from 'three';
+
+import { DEPENDENCIES } from '../dependencies.js';
+
+import type { Manifold, ManifoldToplevel } from 'manifold-3d';
+
+export class ActiveManifold {
+  private manifold: Manifold;
+  private materialId: number;
+  private material: THREE.Material | null;
+  private id2matIndex: Map<number, number> = new Map();
+  private materials: THREE.Material[] = [];
+  private static idCounter: number = 1; // Static counter for generating unique IDs
+
+  constructor(manifold: Manifold) {
+    this.manifold = manifold;
+    this.materialId = 0;
+    this.material = null;
+    this.materials = []; // Empty materials array initially
+    this.id2matIndex.set(this.materialId, 0);
+  }
+
+  /**
+   * Create a duplicate of this manifold
+   * This allows reusing the same shape multiple times with different transformations
+   * @returns A new ActiveManifold instance with the same geometry and materials
+   */
+  duplicate(): ActiveManifold {
+    // Get the mesh and create a new manifold from it
+    const mesh = this.manifold.getMesh();
+    const duplicatedManifold = new ActiveManifold(
+      new this.manifold.constructor.prototype.constructor(mesh)
+    );
+
+    // Copy materials
+    duplicatedManifold.materialId = this.materialId;
+    duplicatedManifold.material = this.material;
+    duplicatedManifold.materials = [...this.materials];
+
+    // Copy the material index mapping
+    this.id2matIndex.forEach((value, key) => {
+      duplicatedManifold.id2matIndex.set(key, value);
+    });
+
+    return duplicatedManifold;
+  }
+
+  // Generate unique IDs for materials
+  private static getNextIds(count: number): number[] {
+    const ids: number[] = [];
+    for (let i = 0; i < count; i++) {
+      ids.push(ActiveManifold.idCounter++);
+    }
+    return ids;
+  }
+
+  /**
+   * Translate the manifold
+   * @param translation - The translation to translate the manifold by
+   * @returns The manifold with the new translation
+   */
+  translate(translation: THREE.Vector3): ActiveManifold {
+    this.manifold = this.manifold.translate(translation.x, translation.y, translation.z);
+    return this;
+  }
+
+  /**
+   * Rotate the manifold
+   * @param rotation - The rotation to rotate the manifold by
+   * @returns The manifold with the new rotation
+   */
+  rotate(rotation: THREE.Vector3): ActiveManifold {
+    this.manifold = this.manifold.rotate(rotation.x, rotation.y, rotation.z);
+    return this;
+  }
+
+  /**
+   * Set the material ID for the manifold. After you're finished with boolean operations
+   * you can assign materials to each material ID.
+   * @param materialId - The material ID to set
+   * @returns The manifold with the new material ID
+   */
+  setMaterialId(materialId: number): ActiveManifold {
+    this.materialId = materialId;
+    return this;
+  }
+
+  /**
+   * Assign materials to the manifold.
+   * @param materials - The materials to assign
+   * @returns The manifold with the new materials
+   */
+  assignMaterials(materials: THREE.Material[]): ActiveManifold {
+    this.materials = materials;
+    return this;
+  }
+
+  /**
+   * Set the material for the manifold
+   * @param material - The material to set
+   * @returns The manifold with the new material
+   */
+  setMaterial(material: THREE.Material): ActiveManifold {
+    this.material = material;
+
+    // If materials array is empty, initialize it
+    if (this.materials.length === 0) {
+      this.materials = [material];
+    } else {
+      this.materials[0] = material;
+    }
+    return this;
+  }
+
+  /**
+   * Add two manifolds together
+   * @param other - The other manifold to add
+   * @returns The result of the addition
+   */
+  add(other: ActiveManifold) {
+    // Combine materials from both manifolds
+    const combinedMaterials = [...this.materials];
+    const idOffset = combinedMaterials.length;
+
+    // Add other's materials to our materials array
+    other.materials.forEach((mat) => {
+      combinedMaterials.push(mat);
+    });
+
+    // Generate IDs for all materials
+    const ids = ActiveManifold.getNextIds(combinedMaterials.length);
+
+    // Build a mapping to get back from ID to material index
+    const newId2matIndex = new Map();
+    ids.forEach((id, idx) => newId2matIndex.set(id, idx));
+
+    // Create copies with property IDs set
+    const thisMesh = this.manifold.getMesh();
+    const otherMesh = other.manifold.getMesh();
+
+    // Set property ID for first mesh - handling the case with multiple material groups
+    const runOriginalID1 = new Uint32Array(thisMesh.numRun);
+    if (thisMesh.runOriginalID && this.id2matIndex.size > 1) {
+      // If the first mesh already has material groups, preserve their mapping to new IDs
+      for (let i = 0; i < thisMesh.numRun; i++) {
+        const originalId = thisMesh.runOriginalID[i];
+        const materialIndex = this.id2matIndex.get(originalId) ?? 0;
+        runOriginalID1[i] = ids[materialIndex];
+      }
+    } else {
+      // Otherwise assign the first ID to all runs
+      for (let i = 0; i < thisMesh.numRun; i++) {
+        runOriginalID1[i] = ids[0];
+      }
+    }
+    thisMesh.runOriginalID = runOriginalID1;
+
+    // Set property ID for second mesh - handling the case with multiple material groups
+    const runOriginalID2 = new Uint32Array(otherMesh.numRun);
+    if (otherMesh.runOriginalID && other.id2matIndex.size > 1) {
+      // If the second mesh already has material groups, preserve their mapping to new IDs
+      for (let i = 0; i < otherMesh.numRun; i++) {
+        const originalId = otherMesh.runOriginalID[i];
+        const materialIndex = other.id2matIndex.get(originalId) ?? 0;
+        runOriginalID2[i] = ids[idOffset + materialIndex];
+      }
+    } else {
+      // Otherwise assign the ID at idOffset to all runs
+      for (let i = 0; i < otherMesh.numRun; i++) {
+        runOriginalID2[i] = ids[idOffset];
+      }
+    }
+    otherMesh.runOriginalID = runOriginalID2;
+
+    // Reconstruct manifolds with updated meshes using the module's Manifold class
+    const mesh1 = new this.manifold.constructor.prototype.constructor(thisMesh);
+    const mesh2 = new this.manifold.constructor.prototype.constructor(otherMesh);
+
+    // Perform the operation
+    const result = mesh1.add(mesh2);
+
+    // Create new ActiveManifold with the result and combined materials
+    const resultManifold = new ActiveManifold(result);
+    resultManifold.materialId = ids[0];
+    resultManifold.materials = combinedMaterials;
+    resultManifold.id2matIndex = newId2matIndex;
+
+    return resultManifold;
+  }
+
+  /**
+   * Subtract two manifolds
+   * @param other - The other manifold to subtract
+   * @returns The result of the subtraction
+   */
+  subtract(other: ActiveManifold) {
+    // For subtraction, we'll keep the materials from this manifold
+    // but need to setup proper IDs
+    const ids = ActiveManifold.getNextIds(this.materials.length);
+
+    // Build a mapping to get back from ID to material index
+    const newId2matIndex = new Map();
+    ids.forEach((id, idx) => newId2matIndex.set(id, idx));
+
+    // Create a copy with property ID set
+    const thisMesh = this.manifold.getMesh();
+
+    // Set property ID for the mesh
+    const runOriginalID = new Uint32Array(thisMesh.numRun);
+    if (thisMesh.runOriginalID && this.id2matIndex.size > 1) {
+      // If the mesh already has material groups, preserve their mapping to new IDs
+      for (let i = 0; i < thisMesh.numRun; i++) {
+        const originalId = thisMesh.runOriginalID[i];
+        const materialIndex = this.id2matIndex.get(originalId) ?? 0;
+        runOriginalID[i] = ids[materialIndex];
+      }
+    } else {
+      // Otherwise assign the first ID to all runs
+      for (let i = 0; i < thisMesh.numRun; i++) {
+        runOriginalID[i] = ids[0];
+      }
+    }
+    thisMesh.runOriginalID = runOriginalID;
+
+    // Reconstruct manifold with updated mesh using the module's Manifold class
+    const mesh1 = new this.manifold.constructor.prototype.constructor(thisMesh);
+
+    // Perform the operation (other's materials don't matter in subtraction)
+    const result = mesh1.subtract(other.manifold);
+
+    // Create new ActiveManifold with the result and our materials
+    const resultManifold = new ActiveManifold(result);
+    resultManifold.materialId = ids[0];
+    resultManifold.materials = [...this.materials];
+    resultManifold.id2matIndex = newId2matIndex;
+
+    return resultManifold;
+  }
+
+  /**
+   * Intersect two manifolds
+   * @param other - The other manifold to intersect with
+   * @returns The result of the intersection
+   */
+  intersect(other: ActiveManifold) {
+    // For intersection, we'll keep the materials from this manifold
+    // but need to setup proper IDs
+    const ids = ActiveManifold.getNextIds(this.materials.length);
+
+    // Build a mapping to get back from ID to material index
+    const newId2matIndex = new Map();
+    ids.forEach((id, idx) => newId2matIndex.set(id, idx));
+
+    // Create a copy with property ID set
+    const thisMesh = this.manifold.getMesh();
+
+    // Set property ID for the mesh
+    const runOriginalID = new Uint32Array(thisMesh.numRun);
+    if (thisMesh.runOriginalID && this.id2matIndex.size > 1) {
+      // If the mesh already has material groups, preserve their mapping to new IDs
+      for (let i = 0; i < thisMesh.numRun; i++) {
+        const originalId = thisMesh.runOriginalID[i];
+        const materialIndex = this.id2matIndex.get(originalId) ?? 0;
+        runOriginalID[i] = ids[materialIndex];
+      }
+    } else {
+      // Otherwise assign the first ID to all runs
+      for (let i = 0; i < thisMesh.numRun; i++) {
+        runOriginalID[i] = ids[0];
+      }
+    }
+    thisMesh.runOriginalID = runOriginalID;
+
+    // Reconstruct manifold with updated mesh using the module's Manifold class
+    const mesh1 = new this.manifold.constructor.prototype.constructor(thisMesh);
+
+    // Perform the operation (intersection)
+    const result = mesh1.intersect(other.manifold);
+
+    // Create new ActiveManifold with the result and our materials
+    const resultManifold = new ActiveManifold(result);
+    resultManifold.materialId = ids[0];
+    resultManifold.materials = [...this.materials];
+    resultManifold.id2matIndex = newId2matIndex;
+
+    return resultManifold;
+  }
+
+  /**
+   * Convert the manifold to a Three.js mesh
+   * @param material - The material to use for the mesh (if not provided, a default material will be used)
+   * @returns The Three.js mesh
+   */
+  toMesh(
+    material: THREE.Material = new THREE.MeshStandardMaterial({ color: 0x999999 }),
+  ): THREE.Mesh {
+    // If no custom materials are assigned and no material is passed, use a default material
+    if (this.materials.length === 0) {
+      const geometry = ManifoldWrapper.manifoldMeshToBufferGeometry(this.manifold.getMesh());
+      return new THREE.Mesh(geometry, material);
+    } else if (this.materials.length === 1 && this.material) {
+      // Simple case - just one material already assigned
+      const geometry = ManifoldWrapper.manifoldMeshToBufferGeometry(this.manifold.getMesh());
+      return new THREE.Mesh(geometry, this.material);
+    } else {
+      // Multiple materials case
+      const mesh = this.manifold.getMesh();
+      const geometry = new THREE.BufferGeometry();
+
+      // Assign buffers
+      geometry.setAttribute(
+        'position',
+        new THREE.BufferAttribute(mesh.vertProperties, 3),
+      );
+      geometry.setIndex(
+        new THREE.BufferAttribute(mesh.triVerts, 1),
+      );
+
+      // Create a merged materials array with the supplied material as the default
+      const mergedMaterials = [material, ...this.materials];
+      let materialGroupCreated = false;
+
+      // Create material groups
+      if (mesh.runOriginalID && mesh.runIndex) {
+        // Process each run
+        for (let run = 0; run < mesh.numRun; run++) {
+          const id = mesh.runOriginalID[run];
+          // Use materialIndex + 1 to account for the supplied material at index 0
+          const materialIndex = this.id2matIndex.has(id) ? this.id2matIndex.get(id)! + 1 : 0;
+
+          // Calculate the start and end for this run
+          const start = mesh.runIndex[run];
+          const end = (run < mesh.numRun - 1) ? mesh.runIndex[run + 1] : mesh.triVerts.length;
+
+          // Add this group with the corresponding material index
+          if (end > start) {
+            geometry.addGroup(start, end - start, materialIndex);
+            materialGroupCreated = true;
+          }
+        }
+      }
+
+      // If no material groups were created, use the default material for the entire mesh
+      if (!materialGroupCreated) {
+        // Use the entire mesh with the default material
+        geometry.addGroup(0, mesh.triVerts.length, 0);
+      }
+
+      return new THREE.Mesh(geometry, mergedMaterials);
+    }
+  }
+
+  /**
+   * Dispose of WASM resources to prevent memory leaks
+   * Should be called when the ActiveManifold is no longer needed
+   */
+  dispose(): void {
+    if (this.manifold && typeof this.manifold.delete === 'function') {
+      this.manifold.delete();
+    }
+  }
+}
+
+/**
+ * Wrapper around the Manifold WASM module.
+ * Manifold is a 3D CSG library that allows for the creation of complex 3D shapes using boolean operations.
+ * This wrapper provides a more convenient API for using Manifold in a Three.js application.
+ *
+ * Since the WASM module is expensive to load, it is conditionally loaded based on world options.
+ *
+ * The instance is stored in the world instance and can be accessed via the world.getManifold() method.
+ */
+export class ManifoldWrapper {
+  private wasm: ManifoldToplevel | null = null;
+  private modulePromise: Promise<ManifoldToplevel> | null = null;
+
+  /**
+   * Initialize Manifold WASM module and store it in the instance
+   * @returns Initialized Manifold module or null if initialization fails
+   */
+  async initManifold(): Promise<ManifoldToplevel> {
+    if (this.wasm) return this.wasm;
+
+    if (!this.modulePromise) {
+      const url = `https://unpkg.com/manifold-3d@${DEPENDENCIES['manifold-3d']}/manifold.wasm`;
+      console.log(`Initializing Manifold from ${url}`);
+      this.modulePromise = Module({
+        locateFile: () => url,
+      }).then((wasm) => {
+        wasm.setup();
+        this.wasm = wasm;
+        console.log('Manifold initialized successfully');
+
+
+        return wasm;
+      });
+    }
+
+    return this.modulePromise;
+  }
+
+  /**
+   * Get the Manifold WASM module
+   * @returns The Manifold WASM module
+   */
+  getModule(): ManifoldToplevel {
+    if (!this.wasm) {
+      throw new Error('Manifold module not initialized. Call initManifold() first.');
+    }
+    return this.wasm;
+  }
+
+  // Accessors for cleaner syntax
+  get Manifold() {
+    return this.getModule().Manifold;
+  }
+
+  get Mesh() {
+    return this.getModule().Mesh;
+  }
+
+  cube(dimensions: THREE.Vector3, centered = true): ActiveManifold {
+    const manifold = new ActiveManifold(this.Manifold.cube([dimensions.x, dimensions.y, dimensions.z], centered));
+    return manifold;
+  }
+
+  /**
+   * Create a cylinder using Manifold
+   * @param height - Height of the cylinder
+   * @param radiusBottom - Radius at the bottom of the cylinder
+   * @param radiusTop - Radius at the top of the cylinder
+   * @param segments - Number of segments around the cylinder (default: 32)
+   * @param centered - Whether the cylinder should be centered (default: true)
+   * @returns The manifold object representing the cylinder
+   */
+  cylinder(height: number, radiusBottom: number, radiusTop: number, segments: number = 32, centered: boolean = true): ActiveManifold {
+    const manifold = new ActiveManifold(this.Manifold.cylinder(height, radiusBottom, radiusTop, segments, centered)).rotate(new THREE.Vector3(90, 0, 0));
+    return manifold;
+  }
+
+  /**
+   * Create a cone using Manifold
+   * @param radius - Base radius of the cone
+   * @param height - Height of the cone
+   * @param segments - Number of segments (default: 32)
+   * @param smoothness - Determines polygon count/smoothness (default: 1)
+   * @param centered - Whether the cone should be centered (default: true)
+   * @returns The manifold object representing the cone
+   */
+  cone(radius: number, height: number, segments: number = 32, smoothness: number = 1, centered: boolean = true): ActiveManifold {
+    // A cone is just a cylinder with top radius of 0
+    const manifold = new ActiveManifold(this.Manifold.cylinder(height, radius, 0, segments, centered)).rotate(new THREE.Vector3(-90, 0, 0));
+    return manifold;
+  }
+
+  /**
+   * Create a sphere using Manifold
+   * @param radius - Radius of the sphere
+   * @param segments - Number of segments (default: 32)
+   * @returns The manifold object representing the sphere
+   */
+  sphere(radius: number, segments: number = 32): ActiveManifold {
+    const manifold = new ActiveManifold(this.Manifold.sphere(radius, segments));
+    return manifold;
+  }
+
+  /**
+   * Create a hollow cube using Manifold
+   * @param dimensions - Dimensions of the cube
+   * @param wallThickness - Thickness of the walls
+   * @param openCeiling - Whether the ceiling should be open (default: true)
+   * @param centered - Whether the cube should be centered (default: true)
+   * @returns The manifold object representing the hollow cube
+   */
+  hollowCube(dimensions: THREE.Vector3, wallThickness: number, openCeiling = true, centered = true): ActiveManifold {
+    const base = this.cube(dimensions, centered);
+
+    // Inner dimensions for the hollow part
+    const innerDimensions = new THREE.Vector3(
+      dimensions.x - 2 * wallThickness,
+      dimensions.y - wallThickness, // Only subtract from bottom if keeping ceiling
+      dimensions.z - 2 * wallThickness
+    );
+
+    // Create hollow inner cube
+    let hollow = this.cube(innerDimensions, centered);
+
+    // Position for the inner hollow cube
+    let yOffset = wallThickness / 2; // Shift up by half wall thickness
+
+    // If openCeiling is true, extend the hollow cube upward to punch through the ceiling
+    if (openCeiling) {
+      // Extend the hollow cube upward
+      innerDimensions.y = dimensions.y + wallThickness; // Extend beyond the top
+      hollow = this.cube(innerDimensions, centered);
+
+      // Calculate offset to align the bottom of the hollow with the inner floor
+      yOffset = wallThickness;
+    }
+
+    // Translate the hollow cube
+    hollow = hollow.translate(new THREE.Vector3(0, yOffset, 0));
+
+    // Subtract hollow from base
+    return base.subtract(hollow);
+  }
+
+  /**
+   * Create a wedge (ramp) shape using CSG operations
+   * @param width - Width of the ramp (X-axis)
+   * @param height - Height of the ramp (Y-axis)
+   * @param length - Length of the ramp (Z-axis)
+   * @returns The manifold object representing the ramp
+   */
+  ramp(width: number, height: number, length: number, alignWithGround = true): ActiveManifold {
+
+    const CENTERED = true;
+
+    // Create a box with the correct orientation [width, height, length]
+    const baseBox = this.Manifold.cube([width, height, length], CENTERED);
+
+    // Create a cutting wedge that's large enough
+    const cutterMultiplier = height;
+    var cutter = this.Manifold.cube([width*cutterMultiplier, height*cutterMultiplier, length*cutterMultiplier], CENTERED);
+
+    // Translate the cutter to the correct position
+    cutter = cutter.translate([0, height / 2 * cutterMultiplier, 0]);
+
+    // Calculate angle as tan^-1(height / length)
+    const angle = Math.atan(height/ length);
+    const angleDeg = angle * (180 / Math.PI);
+    // Rotate the cutter around the X axis by the angle
+    cutter = cutter.rotate(angleDeg, 0, 0);
+
+    // Subtract the transformed cutter from the base box,a
+    var result = baseBox.subtract(cutter);
+    if (alignWithGround) {
+      result = result.translate([0, height/2, 0]);
+    }
+    return new ActiveManifold(result);
+  }
+
+
+  /**
+   * Convert a Three.js mesh to a Manifold mesh
+   * @param mesh - The Three.js mesh to convert
+   * @returns The Manifold mesh or null if conversion fails
+   */
+  meshToManifold(mesh: THREE.Mesh): any {
+    if (!this.wasm) {
+      console.error('Cannot convert mesh to Manifold: WASM not initialized. Call initManifold() first.');
+      return null;
+    }
+
+    try {
+      const geometry = mesh.geometry;
+      if (!geometry.isBufferGeometry) {
+        console.error('Geometry is not a BufferGeometry');
+        return null;
+      }
+
+      const vertProperties = geometry.attributes.position.array as Float32Array;
+
+      const triVerts = geometry.index != null
+        ? geometry.index.array as Uint32Array
+        : new Uint32Array(vertProperties.length / 3).map((_, idx) => idx);
+
+      // Create a mesh without material groups first
+      let manifoldMesh = new this.Mesh({
+        numProp: 3,
+        vertProperties,
+        triVerts,
+      });
+
+      // If the mesh has material groups, set up run indices and IDs
+      if (geometry.groups && geometry.groups.length > 0) {
+        // Reserve IDs for the materials
+        const firstID = this.Manifold.reserveIDs(geometry.groups.length);
+
+        // Create starts array from groups
+        const starts = geometry.groups.map(group => group.start);
+
+        // Create IDs for each group
+        const originalIDs = geometry.groups.map((_, idx) => firstID + idx);
+
+        // Sort the indices by start
+        const indices = Array.from(starts.keys());
+        indices.sort((a, b) => starts[a] - starts[b]);
+
+        // Create runIndex and runOriginalID arrays
+        const runIndex = new Uint32Array(indices.map(i => starts[i]));
+        const runOriginalID = new Uint32Array(indices.map(i => originalIDs[i]));
+
+        // Update the mesh with material information
+        manifoldMesh = new this.Mesh({
+          numProp: 3,
+          vertProperties,
+          triVerts,
+          runIndex,
+          runOriginalID
+        });
+      }
+
+      manifoldMesh.merge();
+
+      return new this.Manifold(manifoldMesh);
+    } catch (error) {
+      console.error('Error converting mesh to Manifold:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Convert a Manifold mesh to a Three.js BufferGeometry
+   * @param manifoldMesh - The Manifold mesh to convert
+   * @returns Three.js BufferGeometry
+   */
+  static manifoldMeshToBufferGeometry(manifoldMesh: any): THREE.BufferGeometry {
+    const geometry = new THREE.BufferGeometry();
+
+    geometry.setAttribute(
+      'position',
+      new THREE.BufferAttribute(manifoldMesh.vertProperties, 3),
+    );
+
+    geometry.setIndex(
+      new THREE.BufferAttribute(manifoldMesh.triVerts, 1),
+    );
+
+    // Add material groups if runOriginalID and runIndex are present
+    if (manifoldMesh.runOriginalID && manifoldMesh.runIndex) {
+      let id = manifoldMesh.runOriginalID[0];
+      let start = manifoldMesh.runIndex[0];
+
+      for (let run = 0; run < manifoldMesh.numRun; ++run) {
+        const nextID = manifoldMesh.runOriginalID[run + 1];
+        if (nextID !== id) {
+          const end = manifoldMesh.runIndex[run + 1];
+          // Material index will be resolved in the calling context
+          geometry.addGroup(start, end - start, 0);
+          id = nextID;
+          start = end;
+        }
+      }
+    }
+
+    return geometry;
+  }
+
+  /**
+   * Create a Three.js mesh from a Manifold result
+   * @param manifoldResult - The result from a Manifold operation (can be ActiveManifold or raw Manifold)
+   * @param material - The material to use for the mesh
+   * @returns Three.js Mesh
+   */
+  manifoldToMesh(
+    manifoldResult: any,
+    material: THREE.Material = new THREE.MeshStandardMaterial({ color: 0x00ff00, wireframe: true }),
+  ): THREE.Mesh {
+    // Check if manifoldResult is an ActiveManifold
+    if (manifoldResult.toMesh) {
+      return manifoldResult.toMesh(material);
+    }
+
+    // If it's a raw Manifold object
+    if (manifoldResult.getMesh) {
+      const geometry = ManifoldWrapper.manifoldMeshToBufferGeometry(manifoldResult.getMesh());
+      return new THREE.Mesh(geometry, material);
+    }
+
+    // If it's already a Manifold mesh
+    const geometry = ManifoldWrapper.manifoldMeshToBufferGeometry(manifoldResult);
+    return new THREE.Mesh(geometry, material);
+  }
+
+  /**
+   * Dispose of WASM resources to prevent memory leaks
+   * Should be called when the ManifoldWrapper is no longer needed
+   */
+  dispose(): void {
+    // Note: Manifold WASM modules don't typically require explicit cleanup
+    // but we set references to null to help garbage collection
+    this.wasm = null;
+    this.modulePromise = null;
+    console.log('ManifoldWrapper disposed');
+  }
+
+}
+
+