@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/dist/core/src/mesh/csg.js

@@ -0,0 +1,250 @@
+const EPS = 1e-6;
+function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(a, b) {
+    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function sub(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function add(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function scale(a, s) {
+    return [a[0] * s, a[1] * s, a[2] * s];
+}
+function normalize(a) {
+    const len = Math.sqrt(dot(a, a)) || 1;
+    return [a[0] / len, a[1] / len, a[2] / len];
+}
+function planeFromPoints(a, b, c) {
+    const n = normalize(cross(sub(b, a), sub(c, a)));
+    return { normal: n, w: dot(n, a) };
+}
+function classifyPoint(plane, point) {
+    return dot(plane.normal, point) - plane.w;
+}
+function splitPolygon(plane, polygon, coplanarFront, coplanarBack, front, back) {
+    const types = polygon.vertices.map(v => {
+        const d = classifyPoint(plane, v);
+        if (d < -EPS)
+            return -1;
+        if (d > EPS)
+            return 1;
+        return 0;
+    });
+    const frontCount = types.filter(t => t > 0).length;
+    const backCount = types.filter(t => t < 0).length;
+    if (frontCount === 0 && backCount === 0) {
+        if (dot(plane.normal, polygon.normal) > 0) {
+            coplanarFront.push(polygon);
+        }
+        else {
+            coplanarBack.push(polygon);
+        }
+        return;
+    }
+    if (frontCount === 0) {
+        back.push(polygon);
+        return;
+    }
+    if (backCount === 0) {
+        front.push(polygon);
+        return;
+    }
+    const ff = [];
+    const bb = [];
+    for (let i = 0; i < polygon.vertices.length; i++) {
+        const j = (i + 1) % polygon.vertices.length;
+        const vi = polygon.vertices[i];
+        const vj = polygon.vertices[j];
+        const ti = types[i];
+        const tj = types[j];
+        if (ti !== -1)
+            ff.push(vi);
+        if (ti !== 1)
+            bb.push(vi);
+        if ((ti | tj) === 0)
+            continue;
+        const t = (plane.w - dot(plane.normal, vi)) / dot(plane.normal, sub(vj, vi));
+        if (t > 0 && t < 1) {
+            const mid = add(vi, scale(sub(vj, vi), t));
+            ff.push(mid);
+            bb.push(mid);
+        }
+    }
+    if (ff.length >= 3)
+        front.push({ vertices: ff, normal: polygon.normal, shared: polygon.shared });
+    if (bb.length >= 3)
+        back.push({ vertices: bb, normal: polygon.normal, shared: polygon.shared });
+}
+export class BSPNode {
+    plane = null;
+    front = null;
+    back = null;
+    polygons = [];
+    build(polygons) {
+        if (polygons.length === 0)
+            return;
+        if (!this.plane) {
+            const p = polygons[0];
+            this.plane = planeFromPoints(p.vertices[0], p.vertices[1], p.vertices[2]);
+        }
+        const frontPolys = [];
+        const backPolys = [];
+        polygons.forEach((poly) => {
+            splitPolygon(this.plane, poly, this.polygons, this.polygons, frontPolys, backPolys);
+        });
+        if (frontPolys.length > 0) {
+            if (!this.front)
+                this.front = new BSPNode();
+            this.front.build(frontPolys);
+        }
+        if (backPolys.length > 0) {
+            if (!this.back)
+                this.back = new BSPNode();
+            this.back.build(backPolys);
+        }
+    }
+    clipPolygons(polygons) {
+        if (!this.plane)
+            return polygons;
+        const front = [];
+        const back = [];
+        for (let _i3842 = 0, _it3842 = polygons, _n3842 = _it3842.length; _i3842 < _n3842; _i3842++) {
+            const poly = _it3842[_i3842];
+            splitPolygon(this.plane, poly, front, back, front, back);
+        }
+        ;
+        let frontResult = front;
+        let backResult = back;
+        if (this.front)
+            frontResult = this.front.clipPolygons(front.splice(0));
+        if (this.back)
+            backResult = this.back.clipPolygons(back.splice(0));
+        return frontResult.concat(backResult);
+    }
+    clipTo(bsp) {
+        this.polygons = bsp.clipPolygons(this.polygons);
+        if (this.front)
+            this.front.clipTo(bsp);
+        if (this.back)
+            this.back.clipTo(bsp);
+    }
+    invert() {
+        if (!this.plane)
+            return;
+        this.plane.normal = scale(this.plane.normal, -1);
+        this.plane.w = -this.plane.w;
+        this.polygons.forEach((poly) => {
+            poly.normal = scale(poly.normal, -1);
+            poly.vertices.reverse();
+        });
+        const temp = this.front;
+        this.front = this.back;
+        this.back = temp;
+        if (this.front)
+            this.front.invert();
+        if (this.back)
+            this.back.invert();
+    }
+    allPolygons() {
+        const result = [...this.polygons];
+        if (this.front)
+            result.push(...this.front.allPolygons());
+        if (this.back)
+            result.push(...this.back.allPolygons());
+        return result;
+    }
+}
+function meshToPolygons(mesh) {
+    const stride = mesh.layout.stride / 4;
+    const polygons = [];
+    for (let i = 0; i < mesh.indices.length; i += 3) {
+        const a = mesh.indices[i];
+        const b = mesh.indices[i + 1];
+        const c = mesh.indices[i + 2];
+        const va = [mesh.vertices[a * stride], mesh.vertices[a * stride + 1], mesh.vertices[a * stride + 2]];
+        const vb = [mesh.vertices[b * stride], mesh.vertices[b * stride + 1], mesh.vertices[b * stride + 2]];
+        const vc = [mesh.vertices[c * stride], mesh.vertices[c * stride + 1], mesh.vertices[c * stride + 2]];
+        const normal = normalize(cross(sub(vb, va), sub(vc, va)));
+        polygons.push({ vertices: [va, vb, vc], normal, shared: 0 });
+    }
+    return polygons;
+}
+function polygonsToMesh(polygons, layout) {
+    const stride = layout.stride / 4;
+    const vertices = [];
+    const indices = [];
+    polygons.forEach((poly) => {
+        const baseIdx = vertices.length / stride;
+        poly.vertices.forEach((v) => {
+            vertices.push(v[0], v[1], v[2]);
+            vertices.push(poly.normal[0], poly.normal[1], poly.normal[2]);
+            vertices.push(0, 0);
+            vertices.push(1, 1, 1, 1);
+        });
+        for (let i = 1; i < poly.vertices.length - 1; i++) {
+            indices.push(baseIdx, baseIdx + i, baseIdx + i + 1);
+        }
+    });
+    const vertArr = new Float32Array(vertices);
+    const indexCount = indices.length;
+    const indexArr = indexCount > 65535 ? new Uint32Array(indices) : new Uint16Array(indices);
+    return {
+        vertices: vertArr,
+        indices: indexArr,
+        layout,
+        vertexCount: vertArr.length / stride,
+        indexCount,
+    };
+}
+export function csgUnion(a, b) {
+    const polysA = meshToPolygons(a);
+    const polysB = meshToPolygons(b);
+    const bspA = new BSPNode();
+    bspA.build(polysA);
+    const bspB = new BSPNode();
+    bspB.build(polysB);
+    bspA.clipTo(bspB);
+    bspB.clipTo(bspA);
+    bspB.invert();
+    bspB.clipTo(bspA);
+    bspB.invert();
+    const result = [...bspA.allPolygons(), ...bspB.allPolygons()];
+    return polygonsToMesh(result, a.layout);
+}
+export function csgSubtract(a, b) {
+    const polysA = meshToPolygons(a);
+    const polysB = meshToPolygons(b);
+    const bspA = new BSPNode();
+    bspA.build(polysA);
+    const bspB = new BSPNode();
+    bspB.build(polysB);
+    bspA.invert();
+    bspA.clipTo(bspB);
+    bspB.clipTo(bspA);
+    bspA.invert();
+    bspB.invert();
+    bspB.clipTo(bspA);
+    bspB.invert();
+    const result = [...bspA.allPolygons(), ...bspB.allPolygons()];
+    return polygonsToMesh(result, a.layout);
+}
+export function csgIntersect(a, b) {
+    const polysA = meshToPolygons(a);
+    const polysB = meshToPolygons(b);
+    const bspA = new BSPNode();
+    bspA.build(polysA);
+    const bspB = new BSPNode();
+    bspB.build(polysB);
+    bspA.invert();
+    bspB.clipTo(bspA);
+    bspA.invert();
+    bspB.invert();
+    bspA.clipTo(bspB);
+    bspB.clipTo(bspA);
+    const result = [...bspA.allPolygons(), ...bspB.allPolygons()];
+    return polygonsToMesh(result, a.layout);
+}

package/dist/core/src/mesh/greased-line.js

@@ -0,0 +1,102 @@
+const STRIDE = 12;
+export function createGreasedLine(points, options = {}) {
+    const defaultWidth = options.width ?? 1;
+    const perVertexWidth = options.perVertexWidth ?? false;
+    const perVertexColor = options.perVertexColor ?? false;
+    const dashEnabled = options.dashEnabled ?? false;
+    const dashSize = options.dashSize ?? 1;
+    const gapSize = options.gapSize ?? 0.5;
+    const pointCount = points.length;
+    if (pointCount < 2) {
+        return { vertices: new Float32Array(0), indices: new Uint16Array(0), vertexCount: 0, indexCount: 0, pointCount: 0, hasPerVertexWidth: perVertexWidth, hasPerVertexColor: perVertexColor, hasDash: dashEnabled };
+    }
+    const vertexCount = pointCount * 2;
+    const vertices = new Float32Array(vertexCount * STRIDE);
+    const indexCount = (pointCount - 1) * 6;
+    const indices = indexCount > 65535 ? new Uint32Array(indexCount) : new Uint16Array(indexCount);
+    let dashDist = 0;
+    for (let i = 0; i < pointCount; i++) {
+        const p = points[i];
+        const width = perVertexWidth ? (p.width ?? defaultWidth) : defaultWidth;
+        const color = perVertexColor ? (p.color ?? [1, 1, 1, 1]) : [1, 1, 1, 1];
+        if (i > 0) {
+            const prev = points[i - 1];
+            const dx = p.position[0] - prev.position[0];
+            const dy = p.position[1] - prev.position[1];
+            const dz = p.position[2] - prev.position[2];
+            dashDist += Math.sqrt(dx * dx + dy * dy + dz * dz);
+        }
+        const dashU = dashEnabled ? dashDist / (dashSize + gapSize) : 0;
+        const leftIdx = i * 2;
+        const rightIdx = i * 2 + 1;
+        const leftOff = leftIdx * STRIDE;
+        vertices[leftOff + 0] = p.position[0];
+        vertices[leftOff + 1] = p.position[1];
+        vertices[leftOff + 2] = p.position[2];
+        vertices[leftOff + 3] = -1;
+        vertices[leftOff + 4] = width;
+        vertices[leftOff + 5] = dashU;
+        vertices[leftOff + 6] = 0;
+        vertices[leftOff + 7] = color[0];
+        vertices[leftOff + 8] = color[1];
+        vertices[leftOff + 9] = color[2];
+        vertices[leftOff + 10] = color[3];
+        vertices[leftOff + 11] = i / (pointCount - 1);
+        const rightOff = rightIdx * STRIDE;
+        vertices[rightOff + 0] = p.position[0];
+        vertices[rightOff + 1] = p.position[1];
+        vertices[rightOff + 2] = p.position[2];
+        vertices[rightOff + 3] = 1;
+        vertices[rightOff + 4] = width;
+        vertices[rightOff + 5] = dashU;
+        vertices[rightOff + 6] = 1;
+        vertices[rightOff + 7] = color[0];
+        vertices[rightOff + 8] = color[1];
+        vertices[rightOff + 9] = color[2];
+        vertices[rightOff + 10] = color[3];
+        vertices[rightOff + 11] = i / (pointCount - 1);
+    }
+    let idx = 0;
+    for (let i = 0; i < pointCount - 1; i++) {
+        const a = i * 2;
+        const b = i * 2 + 1;
+        const c = (i + 1) * 2;
+        const d = (i + 1) * 2 + 1;
+        indices[idx++] = a;
+        indices[idx++] = c;
+        indices[idx++] = b;
+        indices[idx++] = b;
+        indices[idx++] = c;
+        indices[idx++] = d;
+    }
+    return {
+        vertices,
+        indices,
+        vertexCount,
+        indexCount,
+        pointCount,
+        hasPerVertexWidth: perVertexWidth,
+        hasPerVertexColor: perVertexColor,
+        hasDash: dashEnabled,
+    };
+}
+export function createGreasedLineMeshData(line) {
+    return {
+        vertices: line.vertices,
+        indices: line.indices,
+        layout: {
+            attributes: [
+                { name: "position", format: "float32x3", offset: 0 },
+                { name: "sideOffset", format: "float32", offset: 12 },
+                { name: "width", format: "float32", offset: 16 },
+                { name: "dashU", format: "float32", offset: 20 },
+                { name: "sideV", format: "float32", offset: 24 },
+                { name: "color", format: "float32x4", offset: 28 },
+                { name: "lineT", format: "float32", offset: 44 },
+            ],
+            stride: STRIDE * 4,
+        },
+        vertexCount: line.vertexCount,
+        indexCount: line.indexCount,
+    };
+}

package/dist/core/src/mesh/mesh.js

@@ -0,0 +1,6 @@
+export function createMesh(name, data) {
+    return { name, data };
+}
+export { MeshBuilder } from "./builder.js";
+export { createGreasedLine, createGreasedLineMeshData } from "./greased-line.js";
+export { cone, cylinder, disc, lathe, ribbon, tessellatedPlane, torus, tube } from "./parametric.js";