@bitbybit-dev/manifold-worker/lib/api/manifold/booleans.js

Bit By Bit Developers Manifold Based CAD Library to Program Geometry Via WebWorker

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
/**
 * Contains various functions for Solid meshes from Manifold library https://github.com/elalish/manifold
 * Thanks Manifold community for developing this kernel
 */
export class ManifoldBooleans {
    constructor(manifoldWorkerManager) {
        this.manifoldWorkerManager = manifoldWorkerManager;
    }
    /**
     * Subtract two manifold shapes
     * @param inputs two shapes
     * @returns subtracted manifold shape
     * @group a to b
     * @shortname subtract
     * @drawable true
     */
    subtract(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.subtract", inputs);
        });
    }
    /**
     * Add two manifold shapes
     * @param inputs two shapes
     * @returns unioned manifold shape
     * @group a to b
     * @shortname add
     * @drawable true
     */
    add(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.add", inputs);
        });
    }
    /**
     * Intersect two manifold shapes
     * @param inputs two shapes
     * @returns intersected manifold shape
     * @group a to b
     * @shortname intersect
     * @drawable true
     */
    intersect(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.intersect", inputs);
        });
    }
    /**
     * Difference of two manifold shapes
     * @param inputs two shapes
     * @returns difference of two manifold shapes
     * @group 2 manifolds
     * @shortname difference 2 manifolds
     * @drawable true
     */
    differenceTwo(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.differenceTwo", inputs);
        });
    }
    /**
     * Union of two manifold shapes
     * @param inputs two shapes
     * @returns union of two manifold shapes
     * @group 2 manifolds
     * @shortname union 2 manifolds
     * @drawable true
     */
    unionTwo(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.unionTwo", inputs);
        });
    }
    /**
     * Intersection of two manifold shapes
     * @param inputs two shapes
     * @returns intersection of two manifold shapes
     * @group 2 manifolds
     * @shortname intersection 2 manifolds
     * @drawable true
     */
    intersectionTwo(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.intersectionTwo", inputs);
        });
    }
    /**
     * Difference of multiple manifold shapes
     * @param inputs multiple shapes
     * @returns difference of two manifold shapes
     * @group multiple
     * @shortname difference manifolds
     * @drawable true
     */
    difference(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.difference", inputs);
        });
    }
    /**
     * Union of multiple manifold shapes
     * @param inputs multiple shapes
     * @returns union of two manifold shapes
     * @group multiple
     * @shortname union manifolds
     * @drawable true
     */
    union(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.union", inputs);
        });
    }
    /**
     * Intersection of multiple manifold shapes
     * @param inputs two shapes
     * @returns intersection of multiple manifold shapes
     * @group multiple
     * @shortname intersection manifolds
     * @drawable true
     */
    intersection(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.intersection", inputs);
        });
    }
    /**
     * Split manifold by another manifold
     * @param inputs manifold to split and manifold cutter
     * @returns split manifold
     * @group split
     * @shortname split
     * @drawable true
     */
    split(inputs) {
        return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.split", inputs);
    }
    /**
     * Split manifold by plane
     * @param inputs manifold and plane
     * @returns split manifold
     * @group split
     * @shortname split by plane
     * @drawable true
     */
    splitByPlane(inputs) {
        return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.splitByPlane", inputs);
    }
    /**
     * Split manifold by plane on various offsets
     * @param inputs manifold, plane and the list of offsets
     * @returns splitted manifolds
     * @group split
     * @shortname split by plane on offsets
     * @drawable true
     */
    splitByPlaneOnOffsets(inputs) {
        return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.splitByPlaneOnOffsets", inputs);
    }
    /**
     * Trim manifold by plane
     * @param inputs manifold and plane
     * @returns trimmed manifold
     * @group trim
     * @shortname trim by plane
     * @drawable true
     */
    trimByPlane(inputs) {
        return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.booleans.trimByPlane", inputs);
    }
}