@aethervtt/shard-render 0.0.1

package/dist/fxaa.d.ts

@@ -0,0 +1,2 @@
+/** FXAA for cameras with `Antialiasing { mode: 'fxaa' }`. */
+export declare const fxaaPlugin: import("@aethervtt/shard-runtime").Plugin;

package/dist/fxaa.js

@@ -0,0 +1,65 @@
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { RenderPhase } from "./graph.js";
+import { Graph, Shaders } from "./plugin.js";
+import { hasEffect, PostEffect, PostFeatures } from "./post.js";
+import { idOf, PostCache, sampler, tex } from "./post-common.js";
+import { FXAA_SHADERS } from "./post-shaders.js";
+import { registerShaders } from "./shaders.js";
+function fxaaNode() {
+  const cache = new PostCache();
+  let layout;
+  let layoutGen = -1;
+  return {
+    kind: "render",
+    phase: RenderPhase.Display,
+    enabled: hasEffect(PostEffect.Fxaa),
+    reads: ["ldr"],
+    writes: ["display"],
+    color: [{ resource: "display", clear: { r: 0, g: 0, b: 0, a: 1 } }],
+    run: (ctx) => {
+      const gpu = ctx.gpu;
+      if (!layout || layoutGen !== gpu.generation) {
+        layoutGen = gpu.generation;
+        layout = gpu.layouts.bindGroupLayout({ label: "fxaa", entries: [tex(0), sampler(1)] });
+      }
+      const input = ctx.texture("ldr");
+      const format = ctx.texture("display").format;
+      const pipeline = cache.render(
+        ctx,
+        `fxaa/${format}`,
+        "shard::post::fxaa",
+        "fs",
+        [layout],
+        [{ format }],
+        {
+          SRGB_TARGET: format.endsWith("-srgb")
+        }
+      );
+      if (!pipeline) return;
+      const group = cache.group(gpu, `${ctx.view.name}/fxaa`, `${idOf(input)}`, layout, () => [
+        { binding: 0, resource: input.createView() },
+        { binding: 1, resource: cache.sampler(gpu) }
+      ]);
+      const pass = ctx.renderPass;
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, group);
+      pass.draw(3);
+    }
+  };
+}
+const fxaaPlugin = definePlugin({
+  name: "render/fxaa",
+  dependencies: ["render/forward"],
+  build(app) {
+    app.world.initResource(PostFeatures).effects |= PostEffect.Fxaa;
+  },
+  ready(app) {
+    registerShaders(app.world.resource(Shaders), FXAA_SHADERS);
+    const graph = app.world.resource(Graph);
+    graph.declare({ name: "fxaa-in", format: "view" });
+    graph.addNode("post/fxaa", fxaaNode());
+  }
+});
+export {
+  fxaaPlugin
+};

package/dist/gizmo-font.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The label font for gizmos: printable ASCII from Inter Regular at 13 px (SIL Open Font License
+ * 1.1, © The Inter Project Authors), rasterized into a 192×96 atlas of 12×16 cells, 16 per row,
+ * 4 bits of coverage per texel. Built in so labels work in every project and headless, with no font
+ * asset to load.
+ */
+export declare const LABEL_FONT: {
+    readonly width: 192;
+    readonly height: 96;
+    readonly cellWidth: 12;
+    readonly cellHeight: 16;
+    readonly columns: 16;
+    /** Pixels from the cell top to the baseline. */
+    readonly baseline: 12;
+    /** Advance in pixels of each character from ' ' (32) to '~' (126). */
+    readonly advances: readonly [3.5, 3.5, 6, 8, 8.5, 13, 8.5, 4, 4.5, 4.5, 6.5, 8.5, 3.5, 6, 3.5, 4.5, 8, 5.5, 8, 8, 8.5, 8, 8, 7.5, 8, 8, 3.5, 4, 8.5, 8.5, 8.5, 6.5, 12.5, 9, 8.5, 9.5, 9.5, 8, 7.5, 9.5, 9.5, 3.5, 7.5, 8.5, 7.5, 11.5, 10, 10, 8.5, 10, 8.5, 8.5, 8.5, 9.5, 9, 13, 9, 9, 8, 4.5, 4.5, 4.5, 6, 6, 4, 7.5, 8, 7.5, 8, 7.5, 5, 8, 7.5, 3, 3, 7, 3, 11.5, 7.5, 8, 8, 8, 5, 7, 4.5, 7.5, 7.5, 10.5, 7, 7.5, 7, 5.5, 4.5, 5.5, 8.5];
+};
+/** The atlas as one byte of coverage per texel (r8unorm), unpacked on first use. */
+export declare function labelAtlas(): Uint8Array;
+/** Width in pixels of a label's text ('?' stands in for characters outside ASCII). */
+export declare function labelWidth(text: string): number;

package/dist/gizmo-font.js

@@ -0,0 +1,132 @@
+const LABEL_FONT = {
+  width: 192,
+  height: 96,
+  cellWidth: 12,
+  cellHeight: 16,
+  columns: 16,
+  /** Pixels from the cell top to the baseline. */
+  baseline: 12,
+  /** Advance in pixels of each character from ' ' (32) to '~' (126). */
+  advances: [
+    3.5,
+    3.5,
+    6,
+    8,
+    8.5,
+    13,
+    8.5,
+    4,
+    4.5,
+    4.5,
+    6.5,
+    8.5,
+    3.5,
+    6,
+    3.5,
+    4.5,
+    8,
+    5.5,
+    8,
+    8,
+    8.5,
+    8,
+    8,
+    7.5,
+    8,
+    8,
+    3.5,
+    4,
+    8.5,
+    8.5,
+    8.5,
+    6.5,
+    12.5,
+    9,
+    8.5,
+    9.5,
+    9.5,
+    8,
+    7.5,
+    9.5,
+    9.5,
+    3.5,
+    7.5,
+    8.5,
+    7.5,
+    11.5,
+    10,
+    10,
+    8.5,
+    10,
+    8.5,
+    8.5,
+    8.5,
+    9.5,
+    9,
+    13,
+    9,
+    9,
+    8,
+    4.5,
+    4.5,
+    4.5,
+    6,
+    6,
+    4,
+    7.5,
+    8,
+    7.5,
+    8,
+    7.5,
+    5,
+    8,
+    7.5,
+    3,
+    3,
+    7,
+    3,
+    11.5,
+    7.5,
+    8,
+    8,
+    8,
+    5,
+    7,
+    4.5,
+    7.5,
+    7.5,
+    10.5,
+    7,
+    7.5,
+    7,
+    5.5,
+    4.5,
+    5.5,
+    8.5
+  ]
+};
+const PACKED = "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";
+let atlas;
+function labelAtlas() {
+  if (atlas) return atlas;
+  const bytes = Uint8Array.from(atob(PACKED), (c) => c.charCodeAt(0));
+  atlas = new Uint8Array(bytes.length * 2);
+  for (let i = 0; i < bytes.length; i++) {
+    atlas[i * 2] = (bytes[i] >> 4) * 17;
+    atlas[i * 2 + 1] = (bytes[i] & 15) * 17;
+  }
+  return atlas;
+}
+function labelWidth(text) {
+  let w = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    w += LABEL_FONT.advances[c >= 32 && c < 127 ? c - 32 : 31];
+  }
+  return w;
+}
+export {
+  LABEL_FONT,
+  labelAtlas,
+  labelWidth
+};

package/dist/gizmos-plugin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Debug drawing (spec 0027): the Gizmos lines, shapes, and labels gameplay draws each frame, and the
+ * overlays (`debug.overlays`) that other packages register. Picking is pickingPlugin.
+ */
+export declare const gizmosPlugin: import("@aethervtt/shard-runtime").Plugin;

package/dist/gizmos-plugin.js

@@ -0,0 +1,34 @@
+import { First, Last } from "@aethervtt/shard-core";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { OriginShift } from "@aethervtt/shard-transform";
+import { GIZMO_SHADERS } from "./debug-shaders.js";
+import { upload } from "./forward.js";
+import { beginGizmos, GizmoGpuResource, Gizmos, gizmoNode, uploadGizmos } from "./gizmos.js";
+import { DebugOverlays, drawOverlays, gridsOverlay } from "./overlays.js";
+import { Graph, RenderSet, Shaders } from "./plugin.js";
+import { registerShaders } from "./shaders.js";
+const gizmosPlugin = definePlugin({
+  name: "render/gizmos",
+  dependencies: ["render/forward"],
+  provides: [GizmoGpuResource, Gizmos, DebugOverlays, gridsOverlay],
+  build(app) {
+    const w = app.world;
+    w.initResource(Gizmos);
+    w.initResource(DebugOverlays);
+    w.observe(OriginShift, ({ world, data }) => {
+      world.tryResource(Gizmos)?.shiftOrigin(data.offset[0], data.offset[1], data.offset[2]);
+    });
+    app.addSystems(
+      Last,
+      drawOverlays.inSet(RenderSet.Upload).after(upload),
+      uploadGizmos.inSet(RenderSet.Upload).after(drawOverlays)
+    ).addSystems(First, beginGizmos);
+  },
+  ready(app) {
+    registerShaders(app.world.resource(Shaders), GIZMO_SHADERS);
+    app.world.resource(Graph).addNode("gizmos", gizmoNode(app.world));
+  }
+});
+export {
+  gizmosPlugin
+};

package/dist/gizmos.d.ts

@@ -0,0 +1,156 @@
+import { type World } from '@aethervtt/shard-core';
+import { GpuBuffer } from '@aethervtt/shard-gpu';
+import { type NodeDescriptor } from './graph.js';
+/**
+ * Immediate-mode debug drawing. Any system calls `world.resource(Gizmos).line(…)` and the line
+ * shows for this frame (or for `duration` seconds). Calls append to typed arrays: nothing is
+ * allocated per call once the arrays have grown to the frame's count.
+ */
+export interface GizmoOptions {
+    /** Seconds to keep drawing it (0: this frame only). */
+    duration?: number;
+    /** Hide behind geometry (drawn dimmed where occluded). Default true for shapes, false for labels. */
+    depthTest?: boolean;
+    /** Line width in pixels. Default 1.5. */
+    width?: number;
+}
+/** Line records: a (3), b (3), color (rgba8), meta (bit 0: no depth test, bits 8+: width × 8). */
+export declare const GIZMO_LINE_FLOATS = 8;
+/** Linear RGBA (0–1) to rgba8. */
+export declare function packGizmoColor(c: ArrayLike<number>): number;
+/** Lines and labels of one lifetime (this frame, or timed). */
+declare class GizmoList {
+    lines: Float32Array<ArrayBuffer>;
+    lineBits: Uint32Array<ArrayBuffer>;
+    lineCount: number;
+    /** Timed lists: when each line stops drawing (Time.elapsed). */
+    lineExpiry: Float64Array<ArrayBuffer>;
+    labelPos: Float32Array<ArrayBuffer>;
+    labelColor: Uint32Array<ArrayBuffer>;
+    labelMeta: Uint32Array<ArrayBuffer>;
+    labelText: string[];
+    labelExpiry: Float64Array<ArrayBuffer>;
+    labelCount: number;
+    /** Appends a line; returns its index. */
+    line(ax: number, ay: number, az: number, bx: number, by: number, bz: number, color: number, meta: number): number;
+    label(x: number, y: number, z: number, text: string, color: number, meta: number, expiry: number): void;
+    /** Drops entries whose expiry has passed, keeping the order of the rest. */
+    expire(now: number): void;
+    clear(): void;
+    /** Adds an offset to every line end and label anchor (a floating-origin shift). */
+    shift(x: number, y: number, z: number): void;
+}
+export declare class GizmoStore {
+    /** Drawn this frame; cleared at the start of the next. */
+    readonly frame: GizmoList;
+    /** Drawn with a duration; kept until they expire. */
+    readonly timed: GizmoList;
+    /**
+     * Built-in overlays (overlays.ts), redrawn by their system each render. Their own list, so a
+     * render without a full frame (a capture of a paused game) doesn't draw them twice.
+     */
+    readonly overlay: GizmoList;
+    /** Where frame-lifetime drawings go: `frame`, or `overlay` while overlays draw. */
+    private current;
+    /** Routes drawings to the overlay list until `endOverlays`, clearing it first. */
+    beginOverlays(): void;
+    endOverlays(): void;
+    /** Time.elapsed at the start of this frame. */
+    now: number;
+    /** Every list, in draw order. */
+    readonly lists: readonly GizmoList[];
+    private lr;
+    private lg;
+    private lb;
+    private la;
+    private lp;
+    private pack;
+    private meta;
+    private list;
+    /** Timed lines from `first` on get their expiry. */
+    private expire;
+    /** A segment from a to b. Colors are linear RGBA from 0 to 1. */
+    line(a: ArrayLike<number>, b: ArrayLike<number>, color: ArrayLike<number>, options?: GizmoOptions): void;
+    /** A line with an arrowhead at `to`. */
+    arrow(from: ArrayLike<number>, to: ArrayLike<number>, color: ArrayLike<number>, options?: GizmoOptions): void;
+    /** A box: center, full size, rotation (quaternion, default none). */
+    box(center: ArrayLike<number>, size: ArrayLike<number>, rotation: ArrayLike<number> | null, color: ArrayLike<number>, options?: GizmoOptions): void;
+    /** A box from 8 corners in `corners` (bit 0: +x, bit 1: +y, bit 2: +z). */
+    private edges;
+    /**
+     * The edges of a box given as a local AABB (`[minX, minY, minZ, maxX, maxY, maxZ]`) through an
+     * affine transform (three rows of four, at `offset`): an oriented bounding box.
+     */
+    bounds(aabb: ArrayLike<number>, rows: ArrayLike<number>, offset: number, color: ArrayLike<number>, options?: GizmoOptions): void;
+    /** Three great circles. */
+    sphere(center: ArrayLike<number>, radius: number, color: ArrayLike<number>, options?: GizmoOptions): void;
+    /** A circle around axis 0 (x), 1 (y), or 2 (z). */
+    circle(center: ArrayLike<number>, radius: number, axis: number, color: ArrayLike<number>, options?: GizmoOptions): void;
+    /**
+     * A view frustum from its view-projection (reversed-Z). An infinite far plane draws at 20×
+     * the near distance.
+     */
+    frustum(viewProj: ArrayLike<number>, color: ArrayLike<number>, options?: GizmoOptions): void;
+    /** A square grid of `cells` × `cells` cells, `spacing` apart, facing `normal`. */
+    grid(center: ArrayLike<number>, normal: ArrayLike<number>, cells: number, spacing: number, color: ArrayLike<number>, options?: GizmoOptions): void;
+    /** Text just above a world position, facing the screen at a fixed pixel size, on a dark backing. */
+    label(position: ArrayLike<number>, text: string, color: ArrayLike<number>, options?: GizmoOptions): void;
+    /**
+     * The floating origin moved (spec 0040): retained (timed) drawings, and this frame's drawings made
+     * before the shift, move by `offset` so they stay put in the world. Overlays redraw each render.
+     */
+    shiftOrigin(x: number, y: number, z: number): void;
+    /** Lines and labels this frame, including timed ones still showing. */
+    get lineCount(): number;
+    get labelCount(): number;
+    /** What's drawn, as data (`debug.gizmos`): up to `limit` lines, and every label. */
+    describe(limit?: number): {
+        lineCount: number;
+        labelCount: number;
+        lines: {
+            from: number[];
+            to: number[];
+            color: number[];
+            depthTest: boolean;
+            width: number;
+        }[];
+        labels: {
+            position: number[];
+            text: string;
+            color: number[];
+            depthTest: boolean;
+        }[];
+    };
+}
+export declare const Gizmos: import("@aethervtt/shard-core").ResourceDef<GizmoStore>;
+/** Clears last frame's gizmos and drops expired timed ones (First). */
+export declare const beginGizmos: import("@aethervtt/shard-core").SystemDef<undefined>;
+interface GizmoGpu {
+    generation: number;
+    lines: GpuBuffer;
+    glyphs: GpuBuffer;
+    atlas: GPUTexture;
+    layouts: {
+        view: GPUBindGroupLayout;
+        data: GPUBindGroupLayout;
+    };
+    pipelines: Map<string, GPURenderPipeline>;
+    groups: Map<string, {
+        key: string;
+        group: GPUBindGroup;
+    }>;
+    glyphData: Float32Array;
+    glyphBits: Uint32Array;
+    glyphCount: number;
+}
+export declare const GizmoGpuResource: import("@aethervtt/shard-core").ResourceDef<{
+    gpu: GizmoGpu | undefined;
+}>;
+/** Uploads this frame's lines and label glyphs (Last, after overlays draw). */
+export declare const uploadGizmos: import("@aethervtt/shard-core").SystemDef<undefined>;
+/**
+ * Gizmo lines, then labels, over the resolved HDR image: after transparent geometry, particles,
+ * and the resolve, before post-processing and the tonemap.
+ */
+export declare function gizmoNode(world: World): NodeDescriptor;
+export {};