gloop-sim 0.0.0-stage → 1.0.0

package/dist/render/springs/segment.js

@@ -0,0 +1,81 @@
+import { BufferAttribute, BufferGeometry, DynamicDrawUsage, Mesh } from "three/webgpu";
+/**
+ * The number of vertices a thick segment expands to.
+ */
+export const VERTICES_PER_SEGMENT = 6;
+const FLOATS_PER_VERTEX = 3;
+const FLOATS_PER_SEGMENT = VERTICES_PER_SEGMENT * FLOATS_PER_VERTEX;
+/**
+ * A dynamic buffer attribute holding `itemSize` floats per vertex for `count`
+ * segments.
+ */
+export function segmentAttribute(count, itemSize) {
+    const attribute = new BufferAttribute(new Float32Array(count * VERTICES_PER_SEGMENT * itemSize), itemSize);
+    attribute.setUsage(DynamicDrawUsage);
+    return attribute;
+}
+/**
+ * A geometry for `count` segments, with a dynamic position attribute that
+ * {@link writeSegment} fills.
+ */
+export function segmentGeometry(count) {
+    const geometry = new BufferGeometry();
+    const positions = segmentAttribute(count, FLOATS_PER_VERTEX);
+    geometry.setAttribute("position", positions);
+    return { geometry, positions };
+}
+/**
+ * A mesh over segment geometry. Frustum culling is off, since the positions are
+ * rewritten every frame and the geometry's bounds are never recomputed.
+ */
+export function segmentMesh(geometry, material) {
+    const mesh = new Mesh(geometry, material);
+    mesh.frustumCulled = false;
+    return mesh;
+}
+/**
+ * The unit vector at a right angle to the segment from `a` to `b`, in the
+ * screen (x, y) plane. Falls back to the x axis when the endpoints coincide.
+ */
+function perpendicular(a, b) {
+    const px = b[1] - a[1];
+    const py = -(b[0] - a[0]);
+    const length = Math.hypot(px, py);
+    if (length < 1e-9) {
+        return [1, 0];
+    }
+    return [px / length, py / length];
+}
+/**
+ * Writes a thick segment between endpoints `a` and `b` into `target`, drawn as
+ * two triangles that lie flat in the screen plane. The width is added at a right
+ * angle to the segment, and `shift` slides the whole quad that same way, for
+ * drawing offset copies. `segment` picks which slice of `target` to fill.
+ */
+export function writeSegment({ target, segment, a, b, halfWidth, shift = 0 }) {
+    const [nx, ny] = perpendicular(a, b);
+    const ox = nx * halfWidth;
+    const oy = ny * halfWidth;
+    const [ax, ay, az] = a;
+    const [bx, by, bz] = b;
+    const x0 = ax + nx * shift;
+    const y0 = ay + ny * shift;
+    const x1 = bx + nx * shift;
+    const y1 = by + ny * shift;
+    const corners = [
+        [x0 - ox, y0 - oy, az],
+        [x1 - ox, y1 - oy, bz],
+        [x1 + ox, y1 + oy, bz],
+        [x0 - ox, y0 - oy, az],
+        [x1 + ox, y1 + oy, bz],
+        [x0 + ox, y0 + oy, az],
+    ];
+    const base = segment * FLOATS_PER_SEGMENT;
+    for (const [vertex, [x, y, z]] of corners.entries()) {
+        const offset = base + vertex * FLOATS_PER_VERTEX;
+        target[offset] = x;
+        target[offset + 1] = y;
+        target[offset + 2] = z;
+    }
+}
+//# sourceMappingURL=segment.js.map

package/dist/render/springs/segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.js","sourceRoot":"","sources":["../../../src/render/springs/segment.ts"],"names":[],"mappings":"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","sourcesContent":["import { BufferAttribute, BufferGeometry, DynamicDrawUsage, type Material, Mesh } from \"three/webgpu\";\n\n/**\n * The number of vertices a thick segment expands to.\n */\nexport const VERTICES_PER_SEGMENT = 6;\n\nconst FLOATS_PER_VERTEX = 3;\nconst FLOATS_PER_SEGMENT = VERTICES_PER_SEGMENT * FLOATS_PER_VERTEX;\n\ntype Point = readonly [number, number, number];\n\n/**\n * A dynamic buffer attribute holding `itemSize` floats per vertex for `count`\n * segments.\n */\nexport function segmentAttribute(count: number, itemSize: number): BufferAttribute {\n  const attribute = new BufferAttribute(new Float32Array(count * VERTICES_PER_SEGMENT * itemSize), itemSize);\n  attribute.setUsage(DynamicDrawUsage);\n  return attribute;\n}\n\n/**\n * A geometry for `count` segments, with a dynamic position attribute that\n * {@link writeSegment} fills.\n */\nexport function segmentGeometry(count: number): { geometry: BufferGeometry; positions: BufferAttribute } {\n  const geometry = new BufferGeometry();\n  const positions = segmentAttribute(count, FLOATS_PER_VERTEX);\n  geometry.setAttribute(\"position\", positions);\n  return { geometry, positions };\n}\n\n/**\n * A mesh over segment geometry. Frustum culling is off, since the positions are\n * rewritten every frame and the geometry's bounds are never recomputed.\n */\nexport function segmentMesh(geometry: BufferGeometry, material: Material): Mesh {\n  const mesh = new Mesh(geometry, material);\n  mesh.frustumCulled = false;\n  return mesh;\n}\n\n/**\n * The unit vector at a right angle to the segment from `a` to `b`, in the\n * screen (x, y) plane. Falls back to the x axis when the endpoints coincide.\n */\nfunction perpendicular(a: Point, b: Point): readonly [number, number] {\n  const px = b[1] - a[1];\n  const py = -(b[0] - a[0]);\n  const length = Math.hypot(px, py);\n  if (length < 1e-9) {\n    return [1, 0];\n  }\n  return [px / length, py / length];\n}\n\ninterface WriteSegmentOptions {\n  target: Float32Array;\n  segment: number;\n  a: Point;\n  b: Point;\n  halfWidth: number;\n  shift?: number;\n}\n\n/**\n * Writes a thick segment between endpoints `a` and `b` into `target`, drawn as\n * two triangles that lie flat in the screen plane. The width is added at a right\n * angle to the segment, and `shift` slides the whole quad that same way, for\n * drawing offset copies. `segment` picks which slice of `target` to fill.\n */\nexport function writeSegment({ target, segment, a, b, halfWidth, shift = 0 }: WriteSegmentOptions): void {\n  const [nx, ny] = perpendicular(a, b);\n  const ox = nx * halfWidth;\n  const oy = ny * halfWidth;\n\n  const [ax, ay, az] = a;\n  const [bx, by, bz] = b;\n  const x0 = ax + nx * shift;\n  const y0 = ay + ny * shift;\n  const x1 = bx + nx * shift;\n  const y1 = by + ny * shift;\n\n  const corners: readonly Point[] = [\n    [x0 - ox, y0 - oy, az],\n    [x1 - ox, y1 - oy, bz],\n    [x1 + ox, y1 + oy, bz],\n    [x0 - ox, y0 - oy, az],\n    [x1 + ox, y1 + oy, bz],\n    [x0 + ox, y0 + oy, az],\n  ];\n\n  const base = segment * FLOATS_PER_SEGMENT;\n  for (const [vertex, [x, y, z]] of corners.entries()) {\n    const offset = base + vertex * FLOATS_PER_VERTEX;\n    target[offset] = x;\n    target[offset + 1] = y;\n    target[offset + 2] = z;\n  }\n}\n"]}

package/dist/render/springs/source.d.ts

@@ -0,0 +1,35 @@
+import { type Signal, type SignalOptions } from "../../render/signal.js";
+import type { Source } from "../../render/sources.js";
+import { type Link, type LinkSpecification } from "../../render/springs/link.js";
+/**
+ * The springs the renderer draws: the link list, the particles treated as
+ * anchors, and the strain derived from each frame.
+ */
+export interface Springs extends Source {
+    /**
+     * Every link to draw, each already classified into a group.
+     */
+    readonly links: readonly Link[];
+    /**
+     * The particle indices treated as anchors.
+     */
+    readonly anchors: ReadonlySet<number>;
+    /**
+     * Each link's unsigned deviation from its rest length for the current frame,
+     * as a fraction of it. The array is live and owned by the source.
+     */
+    strains(): Float32Array;
+}
+/**
+ * Creates springs from a link list, optionally naming which particles are
+ * anchors. Every link that carries no group is tagged `pinned` or `free` from
+ * those anchors.
+ */
+export declare function of({ links, anchors }: {
+    links: readonly LinkSpecification[];
+    anchors?: readonly number[];
+}): Springs;
+/**
+ * A signal over a link's fractional deviation from its rest length.
+ */
+export declare function strain(options: SignalOptions): Signal<Springs>;

package/dist/render/springs/source.js

@@ -0,0 +1,70 @@
+import { assert } from "../../assert.js";
+import { channel as defineChannel } from "../../render/channel.js";
+import { PackedPositions } from "../../render/frame.js";
+import { signal as coreSignal } from "../../render/signal.js";
+import { anchorsFrom, classifyLinks, validateLinks } from "../../render/springs/link.js";
+import { computeStrain, measureLengths } from "../../render/springs/strain.js";
+const UNSET_REST_LENGTH = -1;
+class SimpleSprings {
+    links;
+    anchors;
+    lengths;
+    restLengths;
+    strainBuffer;
+    captured = false;
+    constructor(links, anchors) {
+        this.links = links;
+        this.anchors = anchors;
+        this.lengths = new Float32Array(links.length);
+        this.strainBuffer = new Float32Array(links.length);
+        this.restLengths = new Float32Array(links.length);
+        for (const [index, link] of links.entries()) {
+            this.restLengths[index] = link.restLength ?? UNSET_REST_LENGTH;
+        }
+    }
+    strains() {
+        return this.strainBuffer;
+    }
+    update(_state, frame) {
+        measureLengths({ points: PackedPositions.of(frame.positions), links: this.links, lengths: this.lengths });
+        this.captureRestLengths();
+        computeStrain({ lengths: this.lengths, restLengths: this.restLengths, strain: this.strainBuffer });
+    }
+    captureRestLengths() {
+        if (this.captured) {
+            return;
+        }
+        for (let index = 0; index < this.restLengths.length; index++) {
+            if (this.restLengths[index] === UNSET_REST_LENGTH) {
+                const observed = this.lengths[index];
+                assert(observed !== undefined, `link ${index} length is missing when capturing rest lengths`);
+                this.restLengths[index] = observed;
+            }
+        }
+        this.captured = true;
+    }
+}
+/**
+ * Each link's unsigned deviation from its rest length, as a fraction of it.
+ */
+const strainChannel = defineChannel({
+    name: "strain",
+    values: (source) => source.strains(),
+});
+/**
+ * Creates springs from a link list, optionally naming which particles are
+ * anchors. Every link that carries no group is tagged `pinned` or `free` from
+ * those anchors.
+ */
+export function of({ links, anchors }) {
+    validateLinks(links);
+    const anchorSet = anchorsFrom(anchors);
+    return new SimpleSprings(classifyLinks(links, anchorSet), anchorSet);
+}
+/**
+ * A signal over a link's fractional deviation from its rest length.
+ */
+export function strain(options) {
+    return coreSignal.of(strainChannel, options);
+}
+//# sourceMappingURL=source.js.map

package/dist/render/springs/source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.js","sourceRoot":"","sources":["../../../src/render/springs/source.ts"],"names":[],"mappings":"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","sourcesContent":["import { assert } from \"@/assert.js\";\nimport { type Channel, channel as defineChannel } from \"@/render/channel.js\";\nimport { type Frame, PackedPositions } from \"@/render/frame.js\";\nimport { signal as coreSignal, type Signal, type SignalOptions } from \"@/render/signal.js\";\nimport type { Source } from \"@/render/sources.js\";\nimport { anchorsFrom, classifyLinks, type Link, type LinkSpecification, validateLinks } from \"@/render/springs/link.js\";\nimport { computeStrain, measureLengths } from \"@/render/springs/strain.js\";\n\nconst UNSET_REST_LENGTH = -1;\n\n/**\n * The springs the renderer draws: the link list, the particles treated as\n * anchors, and the strain derived from each frame.\n */\nexport interface Springs extends Source {\n  /**\n   * Every link to draw, each already classified into a group.\n   */\n  readonly links: readonly Link[];\n  /**\n   * The particle indices treated as anchors.\n   */\n  readonly anchors: ReadonlySet<number>;\n  /**\n   * Each link's unsigned deviation from its rest length for the current frame,\n   * as a fraction of it. The array is live and owned by the source.\n   */\n  strains(): Float32Array;\n}\n\nclass SimpleSprings implements Springs {\n  private readonly lengths: Float32Array;\n  private readonly restLengths: Float32Array;\n  private readonly strainBuffer: Float32Array;\n  private captured = false;\n\n  constructor(\n    readonly links: readonly Link[],\n    readonly anchors: ReadonlySet<number>,\n  ) {\n    this.lengths = new Float32Array(links.length);\n    this.strainBuffer = new Float32Array(links.length);\n    this.restLengths = new Float32Array(links.length);\n    for (const [index, link] of links.entries()) {\n      this.restLengths[index] = link.restLength ?? UNSET_REST_LENGTH;\n    }\n  }\n\n  strains(): Float32Array {\n    return this.strainBuffer;\n  }\n\n  update(_state: unknown, frame: Frame): void {\n    measureLengths({ points: PackedPositions.of(frame.positions), links: this.links, lengths: this.lengths });\n    this.captureRestLengths();\n    computeStrain({ lengths: this.lengths, restLengths: this.restLengths, strain: this.strainBuffer });\n  }\n\n  private captureRestLengths(): void {\n    if (this.captured) {\n      return;\n    }\n    for (let index = 0; index < this.restLengths.length; index++) {\n      if (this.restLengths[index] === UNSET_REST_LENGTH) {\n        const observed = this.lengths[index];\n        assert(observed !== undefined, `link ${index} length is missing when capturing rest lengths`);\n        this.restLengths[index] = observed;\n      }\n    }\n    this.captured = true;\n  }\n}\n\n/**\n * Each link's unsigned deviation from its rest length, as a fraction of it.\n */\nconst strainChannel: Channel<Springs> = defineChannel<Springs>({\n  name: \"strain\",\n  values: (source) => source.strains(),\n});\n\n/**\n * Creates springs from a link list, optionally naming which particles are\n * anchors. Every link that carries no group is tagged `pinned` or `free` from\n * those anchors.\n */\nexport function of({ links, anchors }: { links: readonly LinkSpecification[]; anchors?: readonly number[] }): Springs {\n  validateLinks(links);\n  const anchorSet = anchorsFrom(anchors);\n  return new SimpleSprings(classifyLinks(links, anchorSet), anchorSet);\n}\n\n/**\n * A signal over a link's fractional deviation from its rest length.\n */\nexport function strain(options: SignalOptions): Signal<Springs> {\n  return coreSignal.of(strainChannel, options);\n}\n"]}

package/dist/render/springs/springs.d.ts

@@ -0,0 +1,40 @@
+import { anchors } from "../../render/springs/anchors.js";
+import { construction } from "../../render/springs/construction.js";
+import { impulses } from "../../render/springs/impulses.js";
+import { links } from "../../render/springs/links.js";
+import { palette } from "../../render/springs/palette.js";
+import { preset } from "../../render/springs/preset.js";
+import { of, strain } from "../../render/springs/source.js";
+/**
+ * The spring-network rendering namespace.
+ */
+export declare const springs: {
+    /**
+     * Creates springs over the swarm's particles from a link list.
+     */
+    readonly of: typeof of;
+    /**
+     * A namespace of layers that draw springs, composed onto a scene in
+     * draw order.
+     */
+    readonly layer: {
+        readonly construction: typeof construction;
+        readonly links: typeof links;
+        readonly impulses: typeof impulses;
+        readonly anchors: typeof anchors;
+    };
+    /**
+     * A namespace of signals over springs.
+     */
+    readonly signal: {
+        readonly strain: typeof strain;
+    };
+    /**
+     * A namespace of composable spring-network presets.
+     */
+    readonly preset: typeof preset;
+    /**
+     * A namespace of predefined spring-network color palettes.
+     */
+    readonly palette: typeof palette;
+};

package/dist/render/springs/springs.js

@@ -0,0 +1,34 @@
+import { anchors } from "../../render/springs/anchors.js";
+import { construction } from "../../render/springs/construction.js";
+import { impulses } from "../../render/springs/impulses.js";
+import { links } from "../../render/springs/links.js";
+import { palette } from "../../render/springs/palette.js";
+import { preset } from "../../render/springs/preset.js";
+import { of, strain } from "../../render/springs/source.js";
+/**
+ * The spring-network rendering namespace.
+ */
+export const springs = {
+    /**
+     * Creates springs over the swarm's particles from a link list.
+     */
+    of,
+    /**
+     * A namespace of layers that draw springs, composed onto a scene in
+     * draw order.
+     */
+    layer: { construction, links, impulses, anchors },
+    /**
+     * A namespace of signals over springs.
+     */
+    signal: { strain },
+    /**
+     * A namespace of composable spring-network presets.
+     */
+    preset,
+    /**
+     * A namespace of predefined spring-network color palettes.
+     */
+    palette,
+};
+//# sourceMappingURL=springs.js.map

package/dist/render/springs/springs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"springs.js","sourceRoot":"","sources":["../../../src/render/springs/springs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAExD;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB;;OAEG;IACH,EAAE;IAEF;;;OAGG;IACH,KAAK,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE;IAEjD;;OAEG;IACH,MAAM,EAAE,EAAE,MAAM,EAAE;IAElB;;OAEG;IACH,MAAM;IAEN;;OAEG;IACH,OAAO;CACC,CAAC","sourcesContent":["import { anchors } from \"@/render/springs/anchors.js\";\nimport { construction } from \"@/render/springs/construction.js\";\nimport { impulses } from \"@/render/springs/impulses.js\";\nimport { links } from \"@/render/springs/links.js\";\nimport { palette } from \"@/render/springs/palette.js\";\nimport { preset } from \"@/render/springs/preset.js\";\nimport { of, strain } from \"@/render/springs/source.js\";\n\n/**\n * The spring-network rendering namespace.\n */\nexport const springs = {\n  /**\n   * Creates springs over the swarm's particles from a link list.\n   */\n  of,\n\n  /**\n   * A namespace of layers that draw springs, composed onto a scene in\n   * draw order.\n   */\n  layer: { construction, links, impulses, anchors },\n\n  /**\n   * A namespace of signals over springs.\n   */\n  signal: { strain },\n\n  /**\n   * A namespace of composable spring-network presets.\n   */\n  preset,\n\n  /**\n   * A namespace of predefined spring-network color palettes.\n   */\n  palette,\n} as const;\n"]}

package/dist/render/springs/strain.d.ts

@@ -0,0 +1,21 @@
+import type { PackedPositions } from "../../render/frame.js";
+import type { LinkSpecification } from "../../render/springs/link.js";
+/**
+ * Computes the current length of every link from the particle positions.
+ * `lengths` is written in place and returned.
+ */
+export declare function measureLengths({ points, links, lengths, }: {
+    points: PackedPositions;
+    links: readonly LinkSpecification[];
+    lengths: Float32Array;
+}): Float32Array;
+/**
+ * Computes the raw strain of every link: the unsigned fractional deviation of
+ * its current length from its rest length, `|length - rest| / rest`. A
+ * non-positive rest length yields zero strain rather than dividing by zero.
+ */
+export declare function computeStrain({ lengths, restLengths, strain, }: {
+    lengths: Float32Array;
+    restLengths: Float32Array;
+    strain: Float32Array;
+}): Float32Array;

package/dist/render/springs/strain.js

@@ -0,0 +1,39 @@
+import { assert } from "../../assert.js";
+function component(buffer, index) {
+    const value = buffer[index];
+    assert(value !== undefined, `buffer index ${index} is out of range (length ${buffer.length})`);
+    return value;
+}
+function distance(points, i, j) {
+    const dx = points.x(i) - points.x(j);
+    const dy = points.y(i) - points.y(j);
+    const dz = points.z(i) - points.z(j);
+    return Math.hypot(dx, dy, dz);
+}
+/**
+ * Computes the current length of every link from the particle positions.
+ * `lengths` is written in place and returned.
+ */
+export function measureLengths({ points, links, lengths, }) {
+    assert(lengths.length === links.length, `lengths buffer holds ${lengths.length} links, but there are ${links.length}`);
+    for (const [index, link] of links.entries()) {
+        const [i, j] = link.between;
+        lengths[index] = distance(points, i, j);
+    }
+    return lengths;
+}
+/**
+ * Computes the raw strain of every link: the unsigned fractional deviation of
+ * its current length from its rest length, `|length - rest| / rest`. A
+ * non-positive rest length yields zero strain rather than dividing by zero.
+ */
+export function computeStrain({ lengths, restLengths, strain, }) {
+    assert(lengths.length === restLengths.length && lengths.length === strain.length, `strain buffers disagree: ${lengths.length} lengths, ${restLengths.length} rest lengths, ${strain.length} strain`);
+    for (let index = 0; index < lengths.length; index++) {
+        const rest = component(restLengths, index);
+        const length = component(lengths, index);
+        strain[index] = rest > 0 ? Math.abs(length - rest) / rest : 0;
+    }
+    return strain;
+}
+//# sourceMappingURL=strain.js.map

package/dist/render/springs/strain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strain.js","sourceRoot":"","sources":["../../../src/render/springs/strain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAIrC,SAAS,SAAS,CAAC,MAAoB,EAAE,KAAa;IACpD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5B,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE,gBAAgB,KAAK,4BAA4B,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IAC/F,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,QAAQ,CAAC,MAAuB,EAAE,CAAS,EAAE,CAAS;IAC7D,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACrC,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACrC,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACrC,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;AAChC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,EAC7B,MAAM,EACN,KAAK,EACL,OAAO,GAKR;IACC,MAAM,CACJ,OAAO,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,EAC/B,wBAAwB,OAAO,CAAC,MAAM,yBAAyB,KAAK,CAAC,MAAM,EAAE,CAC9E,CAAC;IACF,KAAK,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;QAC5C,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,OAAO,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,EAC5B,OAAO,EACP,WAAW,EACX,MAAM,GAKP;IACC,MAAM,CACJ,OAAO,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EACzE,4BAA4B,OAAO,CAAC,MAAM,aAAa,WAAW,CAAC,MAAM,kBAAkB,MAAM,CAAC,MAAM,SAAS,CAClH,CAAC;IACF,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACpD,MAAM,IAAI,GAAG,SAAS,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QAC3C,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACzC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import { assert } from \"@/assert.js\";\nimport type { PackedPositions } from \"@/render/frame.js\";\nimport type { LinkSpecification } from \"@/render/springs/link.js\";\n\nfunction component(buffer: Float32Array, index: number): number {\n  const value = buffer[index];\n  assert(value !== undefined, `buffer index ${index} is out of range (length ${buffer.length})`);\n  return value;\n}\n\nfunction distance(points: PackedPositions, i: number, j: number): number {\n  const dx = points.x(i) - points.x(j);\n  const dy = points.y(i) - points.y(j);\n  const dz = points.z(i) - points.z(j);\n  return Math.hypot(dx, dy, dz);\n}\n\n/**\n * Computes the current length of every link from the particle positions.\n * `lengths` is written in place and returned.\n */\nexport function measureLengths({\n  points,\n  links,\n  lengths,\n}: {\n  points: PackedPositions;\n  links: readonly LinkSpecification[];\n  lengths: Float32Array;\n}): Float32Array {\n  assert(\n    lengths.length === links.length,\n    `lengths buffer holds ${lengths.length} links, but there are ${links.length}`,\n  );\n  for (const [index, link] of links.entries()) {\n    const [i, j] = link.between;\n    lengths[index] = distance(points, i, j);\n  }\n  return lengths;\n}\n\n/**\n * Computes the raw strain of every link: the unsigned fractional deviation of\n * its current length from its rest length, `|length - rest| / rest`. A\n * non-positive rest length yields zero strain rather than dividing by zero.\n */\nexport function computeStrain({\n  lengths,\n  restLengths,\n  strain,\n}: {\n  lengths: Float32Array;\n  restLengths: Float32Array;\n  strain: Float32Array;\n}): Float32Array {\n  assert(\n    lengths.length === restLengths.length && lengths.length === strain.length,\n    `strain buffers disagree: ${lengths.length} lengths, ${restLengths.length} rest lengths, ${strain.length} strain`,\n  );\n  for (let index = 0; index < lengths.length; index++) {\n    const rest = component(restLengths, index);\n    const length = component(lengths, index);\n    strain[index] = rest > 0 ? Math.abs(length - rest) / rest : 0;\n  }\n  return strain;\n}\n"]}

package/dist/render/stage.d.ts

@@ -0,0 +1,96 @@
+import type { Camera } from "../render/camera.js";
+import type { Color } from "../render/color.js";
+import type { Effect } from "../render/effect.js";
+import type { Layer } from "../render/layer.js";
+import type { Source } from "../render/sources.js";
+import type { Swarm } from "../types.js";
+export interface RenderBackend {
+    /**
+     * Discriminates the concrete backend.
+     */
+    readonly kind: "gpu";
+}
+export interface StageOptions {
+    /**
+     * The canvas the stage renders into.
+     */
+    readonly canvas: HTMLCanvasElement;
+    /**
+     * The rendering device.
+     */
+    readonly backend: RenderBackend;
+    /**
+     * The background clear color.
+     */
+    readonly clear?: Color;
+    /**
+     * An upper bound applied to the device pixel ratio.
+     */
+    readonly pixelRatio?: number;
+    /**
+     * The initial camera configuration.
+     */
+    readonly camera?: Camera;
+}
+/**
+ * A composition of layers used for rendering a swarm.
+ */
+export interface Scene {
+    /**
+     * Replaces the scene's layers, in back-to-front draw order. Returns the
+     * same scene for chaining.
+     */
+    layers(layers: readonly Layer<Source>[]): Scene;
+    /**
+     * Releases every GPU resource this scene owns. Does nothing if already
+     * disposed.
+     */
+    dispose(): void;
+}
+/**
+ * A component that can create a {@link Scene} for rendering a swarm. It also
+ * manages other rendering configuration such as the camera and post-processing
+ * effects.
+ */
+export interface Stage {
+    /**
+     * Begins observing a swarm, returning a scene to compose layers onto.
+     */
+    observe(swarm: Swarm): Scene;
+    /**
+     * Replaces the active camera configuration.
+     */
+    camera(camera: Camera): void;
+    /**
+     * Replaces the post-processing effect chain, applied in array order.
+     */
+    effects(effects: readonly Effect[]): void;
+    /**
+     * Sets the depth-fog range, in scene units, over which geometry fades toward
+     * the background void, or `null` to disable fog. Applies to every observed
+     * scene.
+     */
+    fog(range: {
+        readonly near: number;
+        readonly far: number;
+    } | null): void;
+    /**
+     * Samples the observed swarm and draws the scene once, from the most recent
+     * state. Only the first call causes the state to be read, with later ones
+     * drawing the state already read.
+     */
+    render(scene: Scene): Promise<void>;
+    /**
+     * Resizes the drawing buffer to `width` by `height` CSS pixels, honoring the
+     * pixel-ratio cap. When omitted, the stage reads the canvas client size.
+     */
+    resize(size?: {
+        readonly width: number;
+        readonly height: number;
+    }): void;
+    /**
+     * Releases the stage's device, listeners, and remaining resources. Does nothing
+     * if already disposed.
+     */
+    dispose(): void;
+}

package/dist/render/stage.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stage.js.map

package/dist/render/stage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage.js","sourceRoot":"","sources":["../../src/render/stage.ts"],"names":[],"mappings":"","sourcesContent":["import type { Camera } from \"@/render/camera.js\";\nimport type { Color } from \"@/render/color.js\";\nimport type { Effect } from \"@/render/effect.js\";\nimport type { Layer } from \"@/render/layer.js\";\nimport type { Source } from \"@/render/sources.js\";\nimport type { Swarm } from \"@/types.js\";\n\nexport interface RenderBackend {\n  /**\n   * Discriminates the concrete backend.\n   */\n  readonly kind: \"gpu\";\n}\n\nexport interface StageOptions {\n  /**\n   * The canvas the stage renders into.\n   */\n  readonly canvas: HTMLCanvasElement;\n\n  /**\n   * The rendering device.\n   */\n  readonly backend: RenderBackend;\n\n  /**\n   * The background clear color.\n   */\n  readonly clear?: Color;\n\n  /**\n   * An upper bound applied to the device pixel ratio.\n   */\n  readonly pixelRatio?: number;\n\n  /**\n   * The initial camera configuration.\n   */\n  readonly camera?: Camera;\n}\n\n/**\n * A composition of layers used for rendering a swarm.\n */\nexport interface Scene {\n  /**\n   * Replaces the scene's layers, in back-to-front draw order. Returns the\n   * same scene for chaining.\n   */\n  layers(layers: readonly Layer<Source>[]): Scene;\n\n  /**\n   * Releases every GPU resource this scene owns. Does nothing if already\n   * disposed.\n   */\n  dispose(): void;\n}\n\n/**\n * A component that can create a {@link Scene} for rendering a swarm. It also\n * manages other rendering configuration such as the camera and post-processing\n * effects.\n */\nexport interface Stage {\n  /**\n   * Begins observing a swarm, returning a scene to compose layers onto.\n   */\n  observe(swarm: Swarm): Scene;\n\n  /**\n   * Replaces the active camera configuration.\n   */\n  camera(camera: Camera): void;\n\n  /**\n   * Replaces the post-processing effect chain, applied in array order.\n   */\n  effects(effects: readonly Effect[]): void;\n\n  /**\n   * Sets the depth-fog range, in scene units, over which geometry fades toward\n   * the background void, or `null` to disable fog. Applies to every observed\n   * scene.\n   */\n  fog(range: { readonly near: number; readonly far: number } | null): void;\n\n  /**\n   * Samples the observed swarm and draws the scene once, from the most recent\n   * state. Only the first call causes the state to be read, with later ones\n   * drawing the state already read.\n   */\n  render(scene: Scene): Promise<void>;\n\n  /**\n   * Resizes the drawing buffer to `width` by `height` CSS pixels, honoring the\n   * pixel-ratio cap. When omitted, the stage reads the canvas client size.\n   */\n  resize(size?: { readonly width: number; readonly height: number }): void;\n\n  /**\n   * Releases the stage's device, listeners, and remaining resources. Does nothing\n   * if already disposed.\n   */\n  dispose(): void;\n}\n"]}

package/dist/render/view.d.ts

@@ -0,0 +1,63 @@
+import { backend } from "../render/backend/gpu.js";
+import { camera } from "../render/camera.js";
+import { type Channel, type ChannelOptions } from "../render/channel.js";
+import { color } from "../render/color.js";
+import { effect } from "../render/effect.js";
+import { layer } from "../render/layer.js";
+import { ramp } from "../render/ramp.js";
+import { Sampler, type SamplerOptions } from "../render/sampler.js";
+import { signal } from "../render/signal.js";
+import { type Source, sources } from "../render/sources.js";
+import type { Stage, StageOptions } from "../render/stage.js";
+export declare const view: {
+    /**
+     * Creates a stage that allows a swarm to be rendered.
+     */
+    readonly stage: (options: StageOptions) => Promise<Stage>;
+    /**
+     * Creates a sampler reading one swarm's state into buffers a renderer can
+     * draw from.
+     */
+    readonly sampler: (options: SamplerOptions) => Sampler;
+    /**
+     * Defines a channel, that, when used together with a {@link Signal} and {@link Ramp},
+     * provides values for rendering options (e.g. color, size, or opacity) for each element
+     * that is rendered.
+     */
+    readonly channel: <S extends Source>(options: ChannelOptions<S>) => Channel<S>;
+    /**
+     * A namespace for predefined sources.
+     */
+    readonly sources: typeof sources;
+    /**
+     * Rendering backends.
+     */
+    readonly backend: typeof backend;
+    /**
+     * A namespace for predefined components that render data from
+     * sources. The layers are composed onto a scene in draw order.
+     */
+    readonly layer: typeof layer;
+    /**
+     * A namespace for predefined signal components. Signals map values
+     * derived from source data to a normalized range.
+     */
+    readonly signal: typeof signal;
+    /**
+     * A namespace for predefined ramp components. Ramps define mappings
+     * from signal values to rendering options (e.g. color, size, or opacity).
+     */
+    readonly ramp: typeof ramp;
+    /**
+     * A namespace for predefined camera configurations.
+     */
+    readonly camera: typeof camera;
+    /**
+     * A namespace for predefined post-processing effects.
+     */
+    readonly effect: typeof effect;
+    /**
+     * A namespace of functions for manipulating colors.
+     */
+    readonly color: typeof color;
+};

package/dist/render/view.js

@@ -0,0 +1,63 @@
+import { backend, createStage } from "../render/backend/gpu.js";
+import { camera } from "../render/camera.js";
+import { channel } from "../render/channel.js";
+import { color } from "../render/color.js";
+import { effect } from "../render/effect.js";
+import { layer } from "../render/layer.js";
+import { ramp } from "../render/ramp.js";
+import { Sampler } from "../render/sampler.js";
+import { signal } from "../render/signal.js";
+import { sources } from "../render/sources.js";
+export const view = {
+    /**
+     * Creates a stage that allows a swarm to be rendered.
+     */
+    stage: (options) => createStage(options),
+    /**
+     * Creates a sampler reading one swarm's state into buffers a renderer can
+     * draw from.
+     */
+    sampler: (options) => new Sampler(options),
+    /**
+     * Defines a channel, that, when used together with a {@link Signal} and {@link Ramp},
+     * provides values for rendering options (e.g. color, size, or opacity) for each element
+     * that is rendered.
+     */
+    channel: (options) => channel(options),
+    /**
+     * A namespace for predefined sources.
+     */
+    sources,
+    /**
+     * Rendering backends.
+     */
+    backend,
+    /**
+     * A namespace for predefined components that render data from
+     * sources. The layers are composed onto a scene in draw order.
+     */
+    layer,
+    /**
+     * A namespace for predefined signal components. Signals map values
+     * derived from source data to a normalized range.
+     */
+    signal,
+    /**
+     * A namespace for predefined ramp components. Ramps define mappings
+     * from signal values to rendering options (e.g. color, size, or opacity).
+     */
+    ramp,
+    /**
+     * A namespace for predefined camera configurations.
+     */
+    camera,
+    /**
+     * A namespace for predefined post-processing effects.
+     */
+    effect,
+    /**
+     * A namespace of functions for manipulating colors.
+     */
+    color,
+};
+//# sourceMappingURL=view.js.map

package/dist/render/view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.js","sourceRoot":"","sources":["../../src/render/view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAqC,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,OAAO,EAAuB,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAe,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAG3D,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB;;OAEG;IACH,KAAK,EAAE,CAAC,OAAqB,EAAkB,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC;IAEtE;;;OAGG;IACH,OAAO,EAAE,CAAC,OAAuB,EAAW,EAAE,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC;IAEnE;;;;OAIG;IACH,OAAO,EAAE,CAAmB,OAA0B,EAAc,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;IAEvF;;OAEG;IACH,OAAO;IAEP;;OAEG;IACH,OAAO;IAEP;;;OAGG;IACH,KAAK;IAEL;;;OAGG;IACH,MAAM;IAEN;;;OAGG;IACH,IAAI;IAEJ;;OAEG;IACH,MAAM;IAEN;;OAEG;IACH,MAAM;IAEN;;OAEG;IACH,KAAK;CACG,CAAC","sourcesContent":["import { backend, createStage } from \"@/render/backend/gpu.js\";\nimport { camera } from \"@/render/camera.js\";\nimport { type Channel, type ChannelOptions, channel } from \"@/render/channel.js\";\nimport { color } from \"@/render/color.js\";\nimport { effect } from \"@/render/effect.js\";\nimport { layer } from \"@/render/layer.js\";\nimport { ramp } from \"@/render/ramp.js\";\nimport { Sampler, type SamplerOptions } from \"@/render/sampler.js\";\nimport { signal } from \"@/render/signal.js\";\nimport { type Source, sources } from \"@/render/sources.js\";\nimport type { Stage, StageOptions } from \"@/render/stage.js\";\n\nexport const view = {\n  /**\n   * Creates a stage that allows a swarm to be rendered.\n   */\n  stage: (options: StageOptions): Promise<Stage> => createStage(options),\n\n  /**\n   * Creates a sampler reading one swarm's state into buffers a renderer can\n   * draw from.\n   */\n  sampler: (options: SamplerOptions): Sampler => new Sampler(options),\n\n  /**\n   * Defines a channel, that, when used together with a {@link Signal} and {@link Ramp},\n   * provides values for rendering options (e.g. color, size, or opacity) for each element\n   * that is rendered.\n   */\n  channel: <S extends Source>(options: ChannelOptions<S>): Channel<S> => channel(options),\n\n  /**\n   * A namespace for predefined sources.\n   */\n  sources,\n\n  /**\n   * Rendering backends.\n   */\n  backend,\n\n  /**\n   * A namespace for predefined components that render data from\n   * sources. The layers are composed onto a scene in draw order.\n   */\n  layer,\n\n  /**\n   * A namespace for predefined signal components. Signals map values\n   * derived from source data to a normalized range.\n   */\n  signal,\n\n  /**\n   * A namespace for predefined ramp components. Ramps define mappings\n   * from signal values to rendering options (e.g. color, size, or opacity).\n   */\n  ramp,\n\n  /**\n   * A namespace for predefined camera configurations.\n   */\n  camera,\n\n  /**\n   * A namespace for predefined post-processing effects.\n   */\n  effect,\n\n  /**\n   * A namespace of functions for manipulating colors.\n   */\n  color,\n} as const;\n"]}

package/dist/swarm.d.ts

@@ -0,0 +1,5 @@
+import type { Swarm, SwarmOptions } from "./types.js";
+/**
+ * Creates a swarm using the specified options.
+ */
+export declare function swarm(options: SwarmOptions): Promise<Swarm>;

package/dist/swarm.js

@@ -0,0 +1,24 @@
+import { assert } from "./assert.js";
+/**
+ * Creates a swarm using the specified options.
+ */
+export async function swarm(options) {
+    options.model.validate?.({ particleCount: options.particleCount });
+    const executable = await options.backend.compile({
+        particles: options.initializer.initialize(options.particleCount),
+        model: options.model,
+        integrator: options.integrator,
+    });
+    let time = 0;
+    return {
+        advance({ time: seconds }) {
+            assert(Number.isFinite(seconds) && seconds >= 0, `cannot advance by ${seconds} seconds`);
+            executable.step(seconds);
+            time += seconds;
+        },
+        async snapshot() {
+            return { time, particles: await executable.snapshot() };
+        },
+    };
+}
+//# sourceMappingURL=swarm.js.map