@bitbybit-dev/manifold-worker/lib/api/manifold/transforms.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 ManifoldTransforms {
    constructor(manifoldWorkerManager) {
        this.manifoldWorkerManager = manifoldWorkerManager;
    }
    /**
     * Scales a manifold shape with 3D vector
     * @param inputs manifold and scale vector
     * @returns Scaled manifold shape
     * @group transforms
     * @shortname scale 3d
     * @drawable true
     */
    scale3D(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.scale3D", inputs);
        });
    }
    /**
     * Scales a manifold shape with single factor
     * @param inputs manifold and scale factor
     * @returns Scaled manifold shape
     * @group transforms
     * @shortname scale uniform
     * @drawable true
     */
    scale(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.scale", inputs);
        });
    }
    /**
     * Mirrors a manifold shape over a plane defined by a normal vector
     * @param inputs manifold and normal vector
     * @returns Mirrored manifold shape
     * @group transforms
     * @shortname mirror
     * @drawable true
     */
    mirror(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.mirror", inputs);
        });
    }
    /**
    * Translates a manifold shape along the vector
    * @param inputs manifold and trnaslation vector
    * @returns Translated manifold shape
    * @group transforms
    * @shortname translate
    * @drawable true
    */
    translate(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.translate", inputs);
        });
    }
    /**
    * Translates a manifold shape along by multiple vectors
    * @param inputs manifold and trnaslation vectors
    * @returns Translated manifold shapes
    * @group multiple
    * @shortname translate by vectors
    * @drawable true
    */
    translateByVectors(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.translateByVectors", inputs);
        });
    }
    /**
     * Translates a manifold shape along x, y, z
     * @param inputs manifold and trnaslation coordinates
     * @returns Translated manifold shape
     * @group transforms
     * @shortname translate xyz
     * @drawable true
     */
    translateXYZ(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.translateXYZ", inputs);
        });
    }
    /**
     * Rotates a manifold shape along the vector containing euler angles
     * @param inputs manifold and rotation vector
     * @returns Rotated manifold shape
     * @group transforms
     * @shortname rotate
     * @drawable true
     */
    rotate(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.rotate", inputs);
        });
    }
    /**
     * Rotates a manifold shape along the x y z euler angles
     * @param inputs manifold and rotation eulers
     * @returns Rotated manifold shape
     * @group transforms
     * @shortname rotate xyz
     * @drawable true
     */
    rotateXYZ(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.rotateXYZ", inputs);
        });
    }
    /**
     * Transforms a manifold shape by using the 4x4 transformation matrix
     * @param inputs manifold and transformation matrix
     * @returns Transformed manifold shape
     * @group matrix
     * @shortname transform
     * @drawable true
     */
    transform(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.transform", inputs);
        });
    }
    /**
     * Transforms a manifold shape by using the 4x4 transformation matrixes
     * @param inputs manifold and transformation matrixes
     * @returns Transformed manifold shape
     * @group matrix
     * @shortname transforms
     * @drawable true
     */
    transforms(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.transforms", inputs);
        });
    }
    /**
     * Move the vertices of this Manifold (creating a new one) according to any
     * arbitrary input function. It is easy to create a function that warps a
     * geometrically valid object into one which overlaps, but that is not checked
     * here, so it is up to the user to choose their function with discretion.
     * @param inputs manifold and warp function
     * @returns Warped manifold shape
     * @group transforms
     * @shortname warp
     * @drawable true
     */
    warp(inputs) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.manifoldWorkerManager.genericCallToWorkerPromise("manifold.transforms.warp", inputs);
        });
    }
}