@ludic-labs/assembly 0.0.0-stage → 0.4.0

package/dist/compat.js

@@ -0,0 +1,153 @@
+import { requireValue } from "./required.js";
+import { sub, cross, dot, normalize } from "./math.js";
+export { fromLegacyRig } from "./legacy.js";
+export const linear = (v) => ((v /= 255) <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4);
+export class MeshBuilder {
+    mesh = { positions: [], normals: [], colors: [], indices: [] };
+    joint = 0;
+    constructor(jointPivots) {
+        if (jointPivots) {
+            this.mesh.joints = [];
+            this.mesh.rigPivots = jointPivots;
+        }
+    }
+    face(points, color, center) {
+        let normal = normalize(cross(sub(requireValue(points[1]), requireValue(points[0])), sub(requireValue(points[2]), requireValue(points[0]))));
+        if (dot(normal, sub(requireValue(points[0]), center)) < 0) {
+            points = [...points].reverse();
+            normal = normalize(cross(sub(requireValue(points[1]), requireValue(points[0])), sub(requireValue(points[2]), requireValue(points[0]))));
+        }
+        const first = this.mesh.positions.length / 3;
+        for (const p of points) {
+            this.mesh.positions.push(...p);
+            this.mesh.joints?.push(this.joint);
+            this.mesh.normals.push(...normal);
+            this.mesh.colors.push(linear((color >> 16) & 255), linear((color >> 8) & 255), linear(color & 255));
+        }
+        for (let n = 1; n < points.length - 1; n++)
+            this.mesh.indices.push(first, first + n, first + n + 1);
+    }
+    box(x, y, z, w, h, d, color, bevel = 0.018) {
+        const r = Math.min(bevel, w / 4, h / 4, d / 4), c = [x, y + h / 2, z];
+        const outline = [
+            [-w / 2 + r, -d / 2],
+            [w / 2 - r, -d / 2],
+            [w / 2, -d / 2 + r],
+            [w / 2, d / 2 - r],
+            [w / 2 - r, d / 2],
+            [-w / 2 + r, d / 2],
+            [-w / 2, d / 2 - r],
+            [-w / 2, -d / 2 + r],
+        ];
+        const ring = (at, inset) => outline.map(([a, b]) => [
+            x + requireValue(a) * (1 - (inset * 2) / w),
+            y + at,
+            z + requireValue(b) * (1 - (inset * 2) / d),
+        ]);
+        const rings = [ring(0, r), ring(r, 0), ring(h - r, 0), ring(h, r)];
+        this.face(requireValue(rings[0]), color, c);
+        this.face(requireValue(rings[3]), color, c);
+        for (let n = 0; n < 3; n++)
+            for (let j = 0; j < 8; j++)
+                this.face([
+                    requireValue(requireValue(rings[n])[j]),
+                    requireValue(requireValue(rings[n])[(j + 1) % 8]),
+                    requireValue(requireValue(rings[n + 1])[(j + 1) % 8]),
+                    requireValue(requireValue(rings[n + 1])[j]),
+                ], color, c);
+        return this;
+    }
+    beam(a, b, width, color) {
+        const up = normalize(sub(b, a)), right = normalize(cross(Math.abs(up[2]) < 0.9 ? [0, 0, 1] : [1, 0, 0], up)), forward = cross(right, up);
+        const part = new MeshBuilder().box(0, 0, 0, width, Math.hypot(...sub(b, a)), width, color, width / 5).mesh;
+        const first = this.mesh.positions.length / 3;
+        for (let n = 0; n < part.positions.length; n += 3) {
+            for (const [input, output, translate] of [
+                [part.positions, this.mesh.positions, true],
+                [part.normals, this.mesh.normals, false],
+            ])
+                for (let c = 0; c < 3; c++)
+                    output.push((translate ? requireValue(a[c]) : 0) +
+                        requireValue(right[c]) * requireValue(input[n]) +
+                        requireValue(up[c]) * requireValue(input[n + 1]) +
+                        requireValue(forward[c]) * requireValue(input[n + 2]));
+        }
+        this.mesh.colors.push(...part.colors);
+        this.mesh.joints?.push(...Array(part.positions.length / 3).fill(this.joint));
+        this.mesh.indices.push(...part.indices.map((i) => i + first));
+        return this;
+    }
+    /** A round shaft in any direction; the asset supplies its physical endpoints. */
+    tube(a, b, radius, color) {
+        const up = normalize(sub(b, a)), right = normalize(cross(Math.abs(up[2]) < 0.9 ? [0, 0, 1] : [1, 0, 0], up)), forward = cross(right, up), part = new MeshBuilder().cylinder(0, 0, 0, radius, Math.hypot(...sub(b, a)), color).mesh, first = this.mesh.positions.length / 3;
+        for (let n = 0; n < part.positions.length; n += 3)
+            for (const [input, output, translate] of [
+                [part.positions, this.mesh.positions, true],
+                [part.normals, this.mesh.normals, false],
+            ])
+                for (let c = 0; c < 3; c++)
+                    output.push((translate ? requireValue(a[c]) : 0) +
+                        requireValue(right[c]) * requireValue(input[n]) +
+                        requireValue(up[c]) * requireValue(input[n + 1]) +
+                        requireValue(forward[c]) * requireValue(input[n + 2]));
+        this.mesh.colors.push(...part.colors);
+        this.mesh.joints?.push(...Array(part.positions.length / 3).fill(this.joint));
+        this.mesh.indices.push(...part.indices.map((i) => i + first));
+        return this;
+    }
+    funnel(x, y, z, bottomRadius, topRadius, height, color) {
+        const bottom = [], top = [], center = [x, y + height / 2, z];
+        for (let n = 0; n < 16; n++) {
+            const a = (n * Math.PI) / 8;
+            bottom.push([x + Math.cos(a) * bottomRadius, y, z + Math.sin(a) * bottomRadius]);
+            top.push([x + Math.cos(a) * topRadius, y + height, z + Math.sin(a) * topRadius]);
+        }
+        this.face(bottom, color, center);
+        this.face(top, color, center);
+        for (let n = 0; n < 16; n++)
+            this.face([
+                requireValue(bottom[n]),
+                requireValue(bottom[(n + 1) % 16]),
+                requireValue(top[(n + 1) % 16]),
+                requireValue(top[n]),
+            ], color, center);
+        return this;
+    }
+    /** Coil in the YZ plane. Small cross-section segments keep distant details economical. */
+    coil(x, y, z, radius, thickness, color) {
+        const point = (a, b) => [
+            x + Math.sin(b) * thickness,
+            y + Math.cos(a) * (radius + Math.cos(b) * thickness),
+            z + Math.sin(a) * (radius + Math.cos(b) * thickness),
+        ];
+        for (let n = 0; n < 16; n++)
+            for (let k = 0; k < 6; k++) {
+                const a = (n * Math.PI) / 8, b = (k * Math.PI) / 3, nextA = a + Math.PI / 8, nextB = b + Math.PI / 3, mid = (a + nextA) / 2;
+                this.face([point(a, b), point(nextA, b), point(nextA, nextB), point(a, nextB)], color, [
+                    x,
+                    y + Math.cos(mid) * radius,
+                    z + Math.sin(mid) * radius,
+                ]);
+            }
+        return this;
+    }
+    cylinder(x, y, z, r, h, color) {
+        const c = [x, y + h / 2, z];
+        const bottom = [], top = [];
+        for (let n = 0; n < 16; n++) {
+            const a = (n * Math.PI) / 8;
+            bottom.push([x + Math.cos(a) * r, y, z + Math.sin(a) * r]);
+            top.push([x + Math.cos(a) * r, y + h, z + Math.sin(a) * r]);
+        }
+        this.face(bottom, color, c);
+        this.face(top, color, c);
+        for (let n = 0; n < 16; n++)
+            this.face([
+                requireValue(bottom[n]),
+                requireValue(bottom[(n + 1) % 16]),
+                requireValue(top[(n + 1) % 16]),
+                requireValue(top[n]),
+            ], color, c);
+        return this;
+    }
+}

package/dist/compiler.d.ts

@@ -0,0 +1,18 @@
+import type { Axis, CompileOptions, CompiledAsset, Diagnostic, Vec3 } from "./types.js";
+import { AssetCompileError } from "./diagnostics.js";
+export { AssetCompileError };
+export declare const SCHEMA: "asset-assembly/0.1";
+/** Characters: joints, mirrored sides, slots, identities, states and limbs. */
+export declare const SCHEMA_V2: "asset-assembly/0.2";
+/** Schema 0.2 plus rotations, arrays, sided round shapes, spheres, cones, wedges, lathes and extrusions. */
+export declare const SCHEMA_V3: "asset-assembly/0.3";
+export declare const AXES: Record<Axis, Vec3>;
+export declare const ANCHORS: readonly ["center", "top-center", "bottom-center", "left-center", "right-center", "front-center", "back-center"];
+/** Largest number of instances one array may create. */
+export declare const MAX_ARRAY_COUNT = 256;
+export declare function compileAsset(input: unknown, options?: CompileOptions): CompiledAsset;
+/**
+ * Returns [] when the description compiles. For schema 0.2 without an explicit identity, the base
+ * description and every declared identity are compiled; diagnostics carry the identity they came from.
+ */
+export declare function validateAsset(input: unknown, options?: CompileOptions): Diagnostic[];