@directivegames/genesys.js 3.1.24

package/dist/src/csg/ManifoldWrapper.js

@@ -0,0 +1,629 @@
+/**
+ * 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';
+export class ActiveManifold {
+    constructor(manifold) {
+        Object.defineProperty(this, "manifold", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "materialId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "material", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "id2matIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "materials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        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() {
+        // 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
+    static getNextIds(count) {
+        const ids = [];
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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) {
+        // 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) {
+        // 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) {
+        // 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 = new THREE.MeshStandardMaterial({ color: 0x999999 })) {
+        // 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() {
+        if (this.manifold && typeof this.manifold.delete === 'function') {
+            this.manifold.delete();
+        }
+    }
+}
+Object.defineProperty(ActiveManifold, "idCounter", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 1
+}); // Static counter for generating unique IDs
+/**
+ * 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 {
+    constructor() {
+        Object.defineProperty(this, "wasm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "modulePromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    /**
+     * Initialize Manifold WASM module and store it in the instance
+     * @returns Initialized Manifold module or null if initialization fails
+     */
+    async initManifold() {
+        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() {
+        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, centered = true) {
+        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, radiusBottom, radiusTop, segments = 32, centered = true) {
+        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, height, segments = 32, smoothness = 1, centered = true) {
+        // 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, segments = 32) {
+        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, wallThickness, openCeiling = true, centered = true) {
+        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, height, length, alignWithGround = true) {
+        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) {
+        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;
+            const triVerts = geometry.index != null
+                ? geometry.index.array
+                : 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) {
+        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, material = new THREE.MeshStandardMaterial({ color: 0x00ff00, wireframe: true })) {
+        // 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() {
+        // 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');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ManifoldWrapper.js","sourceRoot":"","sources":["../../../src/csg/ManifoldWrapper.ts"],"names":[],"mappings":"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"}