@directivegames/genesys.js 3.1.24

package/dist/src/csg/CSGUtils.js

@@ -0,0 +1,805 @@
+/**
+ * GitHub Repo : https://github.com/Sean-Bradley/THREE-CSGMesh
+ * License : MIT
+ *
+ * Original work copyright (c) 2011 Evan Wallace (http://madebyevan.com/), under the MIT license.
+ * THREE.js rework by thrax
+ *
+ * # class CSG
+ * Holds a binary space partition tree representing a 3D solid. Two solids can
+ * be combined using the `union()`, `subtract()`, and `intersect()` methods.
+ *
+ * Differences Copyright 2020-2022 Sean Bradley : https://sbcode.net/threejs/
+ * - Started with CSGMesh.js and csg-lib.js from https://github.com/manthrax/THREE-CSGMesh
+ * - Converted to TypeScript by adding type annotations to all variables
+ * - Converted var to const and let
+ * - Some Refactoring
+ * - support for three r141
+ * - updated for three r150
+ */
+/**
+ * CSGUtils provides boolean operations on meshes through a port of the CSG
+ * library adapted for Three.js. While originally derived from external sources,
+ * this version integrates tightly with the engine and exposes utilities for
+ * converting between BufferGeometry and manifold representations. Use these
+ * helpers when performing complex modeling tasks such as subtracting volumes or
+ * generating procedural shapes in game logic.
+ */
+/**
+ * CSGUtils - collection of functions for constructive solid geometry operations.
+ *
+ * Detailed explanation:
+ * - Wraps polygon boolean operations allowing union, subtract, and intersect on meshes.
+ * - Converts between Three.js `BufferGeometry` and internal manifold structures.
+ * - Provides a simplified API adapted from external libraries but tuned for this engine.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Use when you need runtime mesh boolean operations or procedural mesh generation.
+ * - Keep in mind that complex geometry may incur performance costs.
+ * - Review the returned geometry for manifold validity before using in physics or rendering.
+ */
+import * as THREE from 'three';
+// # class CSG
+// Holds a binary space partition tree representing a 3D solid. Two solids can
+// be combined using the `union()`, `subtract()`, and `intersect()` methods.
+class CSGUtils {
+    constructor() {
+        Object.defineProperty(this, "polygons", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.polygons = [];
+    }
+    clone() {
+        let csg = new CSGUtils();
+        csg.polygons = this.polygons.map((p) => p.clone());
+        return csg;
+    }
+    toPolygons() {
+        return this.polygons;
+    }
+    union(csg) {
+        let a = new Node(this.clone().polygons);
+        let b = new Node(csg.clone().polygons);
+        a.clipTo(b);
+        b.clipTo(a);
+        b.invert();
+        b.clipTo(a);
+        b.invert();
+        a.build(b.allPolygons());
+        return CSGUtils.fromPolygons(a.allPolygons());
+    }
+    subtract(csg) {
+        let a = new Node(this.clone().polygons);
+        let b = new Node(csg.clone().polygons);
+        a.invert();
+        a.clipTo(b);
+        b.clipTo(a);
+        b.invert();
+        b.clipTo(a);
+        b.invert();
+        a.build(b.allPolygons());
+        a.invert();
+        return CSGUtils.fromPolygons(a.allPolygons());
+    }
+    intersect(csg) {
+        let a = new Node(this.clone().polygons);
+        let b = new Node(csg.clone().polygons);
+        a.invert();
+        b.clipTo(a);
+        b.invert();
+        a.clipTo(b);
+        b.clipTo(a);
+        a.build(b.allPolygons());
+        a.invert();
+        return CSGUtils.fromPolygons(a.allPolygons());
+    }
+    // Return a new CSG solid with solid and empty space switched. This solid is
+    // not modified.
+    inverse() {
+        let csg = this.clone();
+        csg.polygons.forEach((p) => p.flip());
+        return csg;
+    }
+}
+// Construct a CSG solid from a list of `Polygon` instances.
+Object.defineProperty(CSGUtils, "fromPolygons", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: function (polygons) {
+        let csg = new CSGUtils();
+        csg.polygons = polygons;
+        return csg;
+    }
+});
+Object.defineProperty(CSGUtils, "fromGeometry", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: function (geom, objectIndex) {
+        let polys = [];
+        let posattr = geom.attributes.position;
+        let normalattr = geom.attributes.normal;
+        let uvattr = geom.attributes.uv;
+        let colorattr = geom.attributes.color;
+        let index;
+        if (geom.index)
+            index = geom.index.array;
+        else {
+            index = new Array((posattr.array.length / posattr.itemSize) | 0);
+            for (let i = 0; i < index.length; i++)
+                index[i] = i;
+        }
+        let triCount = (index.length / 3) | 0;
+        polys = new Array(triCount);
+        for (let i = 0, pli = 0, l = index.length; i < l; i += 3, pli++) {
+            let vertices = new Array(3);
+            for (let j = 0; j < 3; j++) {
+                let vi = index[i + j];
+                let vp = vi * 3;
+                let vt = vi * 2;
+                let x = posattr.array[vp];
+                let y = posattr.array[vp + 1];
+                let z = posattr.array[vp + 2];
+                let nx = normalattr.array[vp];
+                let ny = normalattr.array[vp + 1];
+                let nz = normalattr.array[vp + 2];
+                //let u = uvattr.array[vt]
+                //let v = uvattr.array[vt + 1]
+                vertices[j] = new Vertex({
+                    x: x,
+                    y: y,
+                    z: z,
+                }, {
+                    x: nx,
+                    y: ny,
+                    z: nz,
+                }, uvattr &&
+                    {
+                        x: uvattr.array[vt],
+                        y: uvattr.array[vt + 1],
+                        z: 0,
+                    }, colorattr &&
+                    {
+                        x: colorattr.array[vt],
+                        y: colorattr.array[vt + 1],
+                        z: colorattr.array[vt + 2],
+                    });
+            }
+            polys[pli] = new Polygon(vertices, objectIndex);
+        }
+        return CSGUtils.fromPolygons(polys);
+    }
+});
+Object.defineProperty(CSGUtils, "ttvv0", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new THREE.Vector3()
+});
+Object.defineProperty(CSGUtils, "tmpm3", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new THREE.Matrix3()
+});
+Object.defineProperty(CSGUtils, "fromMesh", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: function (mesh, objectIndex) {
+        let csg = CSGUtils.fromGeometry(mesh.geometry, objectIndex);
+        CSGUtils.tmpm3.getNormalMatrix(mesh.matrix);
+        for (let i = 0; i < csg.polygons.length; i++) {
+            let p = csg.polygons[i];
+            for (let j = 0; j < p.vertices.length; j++) {
+                let v = p.vertices[j];
+                v.pos.copy(CSGUtils.ttvv0
+                    .copy(new THREE.Vector3(v.pos.x, v.pos.y, v.pos.z))
+                    .applyMatrix4(mesh.matrix));
+                v.normal.copy(CSGUtils.ttvv0
+                    .copy(new THREE.Vector3(v.normal.x, v.normal.y, v.normal.z))
+                    .applyMatrix3(CSGUtils.tmpm3));
+            }
+        }
+        return csg;
+    }
+});
+Object.defineProperty(CSGUtils, "nbuf3", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (ct) => {
+        return {
+            top: 0,
+            array: new Float32Array(ct),
+            write: function (v) {
+                this.array[this.top++] = v.x;
+                this.array[this.top++] = v.y;
+                this.array[this.top++] = v.z;
+            },
+        };
+    }
+});
+Object.defineProperty(CSGUtils, "nbuf2", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (ct) => {
+        return {
+            top: 0,
+            array: new Float32Array(ct),
+            write: function (v) {
+                this.array[this.top++] = v.x;
+                this.array[this.top++] = v.y;
+            },
+        };
+    }
+});
+Object.defineProperty(CSGUtils, "toGeometry", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: function (csg) {
+        let ps = csg.polygons;
+        let geom;
+        let g2;
+        let triCount = 0;
+        ps.forEach((p) => (triCount += p.vertices.length - 2));
+        geom = new THREE.BufferGeometry();
+        let vertices = CSGUtils.nbuf3(triCount * 3 * 3);
+        let normals = CSGUtils.nbuf3(triCount * 3 * 3);
+        let uvs;
+        let colors;
+        const grps = {};
+        ps.forEach((p) => {
+            let pvs = p.vertices;
+            let pvlen = pvs.length;
+            if (p.shared !== undefined) {
+                if (!grps[p.shared])
+                    grps[p.shared] = [];
+            }
+            if (pvlen) {
+                if (pvs[0].color !== undefined) {
+                    colors ??= CSGUtils.nbuf3(triCount * 3 * 3);
+                }
+                if (pvs[0].uv !== undefined) {
+                    uvs ??= CSGUtils.nbuf2(triCount * 2 * 3);
+                }
+            }
+            for (let j = 3; j <= pvlen; j++) {
+                p.shared !== undefined &&
+                    grps[p.shared].push(vertices.top / 3, vertices.top / 3 + 1, vertices.top / 3 + 2);
+                vertices.write(pvs[0].pos);
+                vertices.write(pvs[j - 2].pos);
+                vertices.write(pvs[j - 1].pos);
+                normals.write(pvs[0].normal);
+                normals.write(pvs[j - 2].normal);
+                normals.write(pvs[j - 1].normal);
+                uvs &&
+                    pvs[0].uv &&
+                    (uvs.write(pvs[0].uv) ??
+                        uvs.write(pvs[j - 2].uv) ??
+                        uvs.write(pvs[j - 1].uv));
+                colors &&
+                    (colors.write(pvs[0].color) ??
+                        colors.write(pvs[j - 2].color) ??
+                        colors.write(pvs[j - 1].color));
+            }
+        });
+        geom.setAttribute('position', new THREE.BufferAttribute(vertices.array, 3));
+        geom.setAttribute('normal', new THREE.BufferAttribute(normals.array, 3));
+        uvs && geom.setAttribute('uv', new THREE.BufferAttribute(uvs.array, 2));
+        colors &&
+            geom.setAttribute('color', new THREE.BufferAttribute(colors.array, 3));
+        if (Object.keys(grps).length) {
+            let index = [];
+            let gbase = 0;
+            for (let gi = 0; gi < Object.keys(grps).length; gi++) {
+                const key = Number(Object.keys(grps)[gi]);
+                geom.addGroup(gbase, grps[key].length, gi);
+                gbase += grps[key].length;
+                index = index.concat(grps[key]);
+            }
+            geom.setIndex(index);
+        }
+        g2 = geom;
+        return geom;
+    }
+});
+Object.defineProperty(CSGUtils, "toMesh", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: function (csg, toMatrix, toMaterial) {
+        let geom = CSGUtils.toGeometry(csg);
+        let inv = new THREE.Matrix4().copy(toMatrix).invert();
+        geom.applyMatrix4(inv);
+        geom.computeBoundingSphere();
+        geom.computeBoundingBox();
+        let m = new THREE.Mesh(geom, toMaterial);
+        m.matrix.copy(toMatrix);
+        m.matrix.decompose(m.position, m.quaternion, m.scale);
+        m.rotation.setFromQuaternion(m.quaternion);
+        m.updateMatrixWorld();
+        m.castShadow = m.receiveShadow = true;
+        return m;
+    }
+});
+// # class Vector
+// Represents a 3D vector.
+//
+// Example usage:
+//
+//     new CSG.Vector(1, 2, 3);
+class Vector {
+    constructor(x = 0, y = 0, z = 0) {
+        Object.defineProperty(this, "x", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "y", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "z", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        return this;
+    }
+    clone() {
+        return new Vector(this.x, this.y, this.z);
+    }
+    negate() {
+        this.x *= -1;
+        this.y *= -1;
+        this.z *= -1;
+        return this;
+    }
+    add(a) {
+        this.x += a.x;
+        this.y += a.y;
+        this.z += a.z;
+        return this;
+    }
+    sub(a) {
+        this.x -= a.x;
+        this.y -= a.y;
+        this.z -= a.z;
+        return this;
+    }
+    times(a) {
+        this.x *= a;
+        this.y *= a;
+        this.z *= a;
+        return this;
+    }
+    dividedBy(a) {
+        this.x /= a;
+        this.y /= a;
+        this.z /= a;
+        return this;
+    }
+    lerp(a, t) {
+        return this.add(Vector.tv0.copy(a).sub(this).times(t));
+    }
+    unit() {
+        return this.dividedBy(this.length());
+    }
+    length() {
+        return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2);
+    }
+    normalize() {
+        return this.unit();
+    }
+    cross(b) {
+        let a = this;
+        const ax = a.x, ay = a.y, az = a.z;
+        const bx = b.x, by = b.y, bz = b.z;
+        this.x = ay * bz - az * by;
+        this.y = az * bx - ax * bz;
+        this.z = ax * by - ay * bx;
+        return this;
+    }
+    dot(b) {
+        return this.x * b.x + this.y * b.y + this.z * b.z;
+    }
+}
+//Temporaries used to avoid internal allocation..
+Object.defineProperty(Vector, "tv0", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Vector()
+});
+Object.defineProperty(Vector, "tv1", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Vector()
+});
+// # class Vertex
+// Represents a vertex of a polygon. Use your own vertex class instead of this
+// one to provide additional features like texture coordinates and vertex
+// colors. Custom vertex classes need to provide a `pos` property and `clone()`,
+// `flip()`, and `interpolate()` methods that behave analogous to the ones
+// defined by `CSG.Vertex`. This class provides `normal` so convenience
+// functions like `CSG.sphere()` can return a smooth vertex normal, but `normal`
+// is not used anywhere else.
+class Vertex {
+    constructor(pos, normal, uv, color) {
+        Object.defineProperty(this, "pos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "normal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "uv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "color", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.pos = new Vector().copy(pos);
+        this.normal = new Vector().copy(normal);
+        uv && (this.uv = new Vector().copy(uv)) && (this.uv.z = 0);
+        color && (this.color = new Vector().copy(color));
+    }
+    clone() {
+        return new Vertex(this.pos, this.normal, this.uv, this.color);
+    }
+    // Invert all orientation-specific data (e.g. vertex normal). Called when the
+    // orientation of a polygon is flipped.
+    flip() {
+        this.normal.negate();
+    }
+    // Create a new vertex between this vertex and `other` by linearly
+    // interpolating all properties using a parameter of `t`. Subclasses should
+    // override this to interpolate additional properties.
+    interpolate(other, t) {
+        return new Vertex(this.pos.clone().lerp(other.pos, t), this.normal.clone().lerp(other.normal, t), this.uv && other.uv && this.uv.clone().lerp(other.uv, t), this.color && other.color && this.color.clone().lerp(other.color, t));
+    }
+}
+// # class Plane
+// Represents a plane in 3D space.
+class Plane {
+    constructor(normal, w) {
+        Object.defineProperty(this, "normal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "w", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.normal = normal;
+        this.w = w;
+    }
+    clone() {
+        return new Plane(this.normal.clone(), this.w);
+    }
+    flip() {
+        this.normal.negate();
+        this.w = -this.w;
+    }
+    // Split `polygon` by this plane if needed, then put the polygon or polygon
+    // fragments in the appropriate lists. Coplanar polygons go into either
+    // `coplanarFront` or `coplanarBack` depending on their orientation with
+    // respect to this plane. Polygons in front or in back of this plane go into
+    // either `front` or `back`.
+    splitPolygon(polygon, coplanarFront, coplanarBack, front, back) {
+        const COPLANAR = 0;
+        const FRONT = 1;
+        const BACK = 2;
+        const SPANNING = 3;
+        // Classify each point as well as the entire polygon into one of the above
+        // four classes.
+        let polygonType = 0;
+        let types = [];
+        for (let i = 0; i < polygon.vertices.length; i++) {
+            let t = this.normal.dot(polygon.vertices[i].pos) - this.w;
+            let type = t < -Plane.EPSILON ? BACK : t > Plane.EPSILON ? FRONT : COPLANAR;
+            polygonType |= type;
+            types.push(type);
+        }
+        // Put the polygon in the correct list, splitting it when necessary.
+        switch (polygonType) {
+            case COPLANAR:
+                ;
+                (this.normal.dot(polygon.plane.normal) > 0
+                    ? coplanarFront
+                    : coplanarBack).push(polygon);
+                break;
+            case FRONT:
+                front.push(polygon);
+                break;
+            case BACK:
+                back.push(polygon);
+                break;
+            case SPANNING:
+                let f = [], b = [];
+                for (let i = 0; i < polygon.vertices.length; i++) {
+                    let j = (i + 1) % polygon.vertices.length;
+                    let ti = types[i], tj = types[j];
+                    let vi = polygon.vertices[i], vj = polygon.vertices[j];
+                    if (ti != BACK)
+                        f.push(vi);
+                    if (ti != FRONT)
+                        b.push(ti != BACK ? vi.clone() : vi);
+                    if ((ti | tj) == SPANNING) {
+                        let t = (this.w - this.normal.dot(vi.pos)) /
+                            this.normal.dot(Vector.tv0.copy(vj.pos).sub(vi.pos));
+                        let v = vi.interpolate(vj, t);
+                        f.push(v);
+                        b.push(v.clone());
+                    }
+                }
+                if (f.length >= 3)
+                    front.push(new Polygon(f, polygon.shared));
+                if (b.length >= 3)
+                    back.push(new Polygon(b, polygon.shared));
+                break;
+        }
+    }
+}
+// `Plane.EPSILON` is the tolerance used by `splitPolygon()` to decide if a
+// point is on the plane.
+Object.defineProperty(Plane, "EPSILON", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 1e-5
+});
+Object.defineProperty(Plane, "fromPoints", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: function (a, b, c) {
+        let n = Vector.tv0
+            .copy(b)
+            .sub(a)
+            .cross(Vector.tv1.copy(c).sub(a))
+            .normalize();
+        return new Plane(n.clone(), n.dot(a));
+    }
+});
+// # class Polygon
+// Represents a convex polygon. The vertices used to initialize a polygon must
+// be coplanar and form a convex loop. They do not have to be `Vertex`
+// instances but they must behave similarly (duck typing can be used for
+// customization).
+//
+// Each convex polygon has a `shared` property, which is shared between all
+// polygons that are clones of each other or were split from the same polygon.
+// This can be used to define per-polygon properties (such as surface color).
+class Polygon {
+    constructor(vertices, shared) {
+        Object.defineProperty(this, "vertices", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "shared", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "plane", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.vertices = vertices;
+        this.shared = shared;
+        this.plane = Plane.fromPoints(vertices[0].pos, vertices[1].pos, vertices[2].pos);
+    }
+    clone() {
+        return new Polygon(this.vertices.map((v) => v.clone()), this.shared);
+    }
+    flip() {
+        this.vertices.reverse().forEach((v) => v.flip());
+        this.plane.flip();
+    }
+}
+// # class Node
+// Holds a node in a BSP tree. A BSP tree is built from a collection of polygons
+// by picking a polygon to split along. That polygon (and all other coplanar
+// polygons) are added directly to that node and the other polygons are added to
+// the front and/or back subtrees. This is not a leafy BSP tree since there is
+// no distinction between internal and leaf nodes.
+class Node {
+    constructor(polygons) {
+        Object.defineProperty(this, "plane", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "front", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "back", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "polygons", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.polygons = [];
+        if (polygons)
+            this.build(polygons);
+    }
+    clone() {
+        let node = new Node();
+        node.plane = this.plane && this.plane.clone();
+        node.front = this.front && this.front.clone();
+        node.back = this.back && this.back.clone();
+        node.polygons = this.polygons.map((p) => p.clone());
+        return node;
+    }
+    // Convert solid space to empty space and empty space to solid space.
+    invert() {
+        for (let i = 0; i < this.polygons.length; i++)
+            this.polygons[i].flip();
+        this.plane && this.plane.flip();
+        this.front && this.front.invert();
+        this.back && this.back.invert();
+        let temp = this.front;
+        this.front = this.back;
+        this.back = temp;
+    }
+    // Recursively remove all polygons in `polygons` that are inside this BSP
+    // tree.
+    clipPolygons(polygons) {
+        if (!this.plane)
+            return polygons.slice();
+        let front = [], back = [];
+        for (let i = 0; i < polygons.length; i++) {
+            this.plane.splitPolygon(polygons[i], front, back, front, back);
+        }
+        if (this.front)
+            front = this.front.clipPolygons(front);
+        if (this.back)
+            back = this.back.clipPolygons(back);
+        else
+            back = [];
+        //return front;
+        return front.concat(back);
+    }
+    // Remove all polygons in this BSP tree that are inside the other BSP tree
+    // `bsp`.
+    clipTo(bsp) {
+        this.polygons = bsp.clipPolygons(this.polygons);
+        if (this.front)
+            this.front.clipTo(bsp);
+        if (this.back)
+            this.back.clipTo(bsp);
+    }
+    // Return a list of all polygons in this BSP tree.
+    allPolygons() {
+        let polygons = this.polygons.slice();
+        if (this.front)
+            polygons = polygons.concat(this.front.allPolygons());
+        if (this.back)
+            polygons = polygons.concat(this.back.allPolygons());
+        return polygons;
+    }
+    // Build a BSP tree out of `polygons`. When called on an existing tree, the
+    // new polygons are filtered down to the bottom of the tree and become new
+    // nodes there. Each set of polygons is partitioned using the first polygon
+    // (no heuristic is used to pick a good split).
+    build(polygons) {
+        if (!polygons.length)
+            return;
+        this.plane ??= polygons[0].plane.clone();
+        let front = [], back = [];
+        for (let i = 0; i < polygons.length; i++) {
+            this.plane.splitPolygon(polygons[i], this.polygons, this.polygons, front, back);
+        }
+        if (front.length) {
+            this.front ??= new Node();
+            this.front.build(front);
+        }
+        if (back.length) {
+            this.back ??= new Node();
+            this.back.build(back);
+        }
+    }
+}
+Object.defineProperty(Node, "fromJSON", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: function (json) {
+        return CSGUtils.fromPolygons(json.polygons.map((p) => new Polygon(p.vertices.map((v) => new Vertex(v.pos, v.normal, v.uv)), p.shared)));
+    }
+});
+export { CSGUtils as CSG, Vertex, Vector, Polygon, Plane };
+// Return a new CSG solid representing space in either this solid or in the
+// solid `csg`. Neither this solid nor the solid `csg` are modified.
+//
+//     A.union(B)
+//
+//     +-------+            +-------+
+//     |       |            |       |
+//     |   A   |            |       |
+//     |    +--+----+   =   |       +----+
+//     +----+--+    |       +----+       |
+//          |   B   |            |       |
+//          |       |            |       |
+//          +-------+            +-------+
+//
+// Return a new CSG solid representing space in this solid but not in the
+// solid `csg`. Neither this solid nor the solid `csg` are modified.
+//
+//     A.subtract(B)
+//
+//     +-------+            +-------+
+//     |       |            |       |
+//     |   A   |            |       |
+//     |    +--+----+   =   |    +--+
+//     +----+--+    |       +----+
+//          |   B   |
+//          |       |
+//          +-------+
+//
+// Return a new CSG solid representing space both this solid and in the
+// solid `csg`. Neither this solid nor the solid `csg` are modified.
+//
+//     A.intersect(B)
+//
+//     +-------+
+//     |       |
+//     |   A   |
+//     |    +--+----+   =   +--+
+//     +----+--+    |       +--+
+//          |   B   |
+//          |       |
+//          +-------+
+//
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CSGUtils.js","sourceRoot":"","sources":["../../../src/csg/CSGUtils.ts"],"names":[],"mappings":"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"}