@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/surface-model.js

@@ -0,0 +1,289 @@
+import { defineSchema, t } from "@aethervtt/shard-core";
+const VARIATION_PATTERNS = [
+  "mottle",
+  "streaks",
+  "grain",
+  "cells",
+  "stagger",
+  "brushed"
+];
+const VARIATION_FIELDS = {
+  strength: t.f32({
+    default: 1,
+    min: 0,
+    max: 1,
+    description: "0 is off, 1 full. Scales the pigment shift, tone, weathering and roughness."
+  }),
+  seed: t.u32({ description: "Picks the pattern; the same seed is the same surface." }),
+  pattern: t.enum(VARIATION_PATTERNS, {
+    description: "mottle (value noise), streaks (squashed across u: plaster runs), grain (stretched along u: wood), cells (a tone per cell: tiles), stagger (cells with alternate rows offset by half, toned per 2\xD72: bricks), brushed (mottle with a slanted brush mark per cell: stone)."
+  }),
+  scale: t.vec2({
+    default: [1.5, 1.5],
+    min: 1e-3,
+    unit: "m",
+    description: "Patch size along the surface's u and v. Unequal stretches the pattern."
+  }),
+  warp: t.f32({
+    min: 0,
+    max: 2,
+    description: "Domain warp by a second noise, in patches: stone-like breakup of the pattern."
+  }),
+  detail: t.f32({
+    min: 0,
+    max: 1,
+    description: "Blend toward a 3.1\xD7 finer octave."
+  }),
+  bands: t.f32({
+    min: 0,
+    max: 1,
+    description: "0 soft noise \u2026 1 posterized paint bands."
+  }),
+  toneRange: t.f32({
+    default: 0.15,
+    min: 0,
+    max: 1,
+    description: "\xB1 brightness at the patch extremes."
+  }),
+  coolTint: t.vec3({
+    default: [0.92, 0.96, 1.07],
+    min: 0,
+    max: 2,
+    description: "The pigment a low patch moves toward (a multiplier, linear)."
+  }),
+  warmTint: t.vec3({
+    default: [1.08, 1.04, 0.93],
+    min: 0,
+    max: 2,
+    description: "The pigment a high patch moves toward (a multiplier, linear)."
+  }),
+  roughnessRange: t.f32({
+    default: 0.15,
+    min: 0,
+    max: 1,
+    description: "\xB1 roughness from the detail octave."
+  }),
+  weathering: t.f32({
+    min: 0,
+    max: 1,
+    description: "Darkens and roughens where the weather mask is on."
+  }),
+  weatherThreshold: t.vec2({
+    default: [0.66, 0.9],
+    min: 0,
+    max: 1,
+    description: "The weather mask's smoothstep edges, over the detail octave."
+  })
+};
+const VariationUniform = defineSchema("surface/VariationUniform", VARIATION_FIELDS, {
+  description: "A surface variation (0068), as SurfaceMaterial and custom material types hold it."
+});
+const VARIATION_STRUCT = "surface::variation::VariationUniform";
+const PX = 1.5 / 70;
+const preset = (v) => ({ ...VariationUniform.defaults(), ...v });
+const SURFACE_PRESETS = {
+  solid: preset({
+    strength: 0.5,
+    pattern: "mottle",
+    scale: [72 * PX, 72 * PX],
+    detail: 0.2,
+    bands: 1,
+    toneRange: 0.24,
+    roughnessRange: 0.2,
+    weathering: 0.07,
+    weatherThreshold: [0.64, 0.9]
+  }),
+  plaster: preset({
+    strength: 0.5,
+    pattern: "streaks",
+    scale: [128 * PX, 128 * PX],
+    detail: 0.18,
+    bands: 1,
+    toneRange: 0.16,
+    coolTint: [0.9, 0.95, 1.07],
+    warmTint: [1.1, 1.05, 0.93],
+    roughnessRange: 0.16,
+    weathering: 0.11,
+    weatherThreshold: [0.66, 0.88]
+  }),
+  stone: preset({
+    strength: 0.5,
+    pattern: "brushed",
+    scale: [112 * PX, 112 * PX],
+    warp: 0.42,
+    detail: 0.18,
+    bands: 1,
+    toneRange: 0.2,
+    coolTint: [0.88, 0.95, 1.08],
+    warmTint: [1.12, 1.05, 0.92],
+    roughnessRange: 0.22,
+    weathering: 0.12,
+    weatherThreshold: [0.34, 0.76]
+  }),
+  brick: preset({
+    strength: 0.5,
+    pattern: "stagger",
+    scale: [144 * 0.56 * PX, 144 * 0.3 * PX],
+    toneRange: 0.18,
+    coolTint: [0.9, 0.98, 1.08],
+    warmTint: [1.12, 1.02, 0.88],
+    roughnessRange: 0.19,
+    weathering: 0.1,
+    weatherThreshold: [0.7, 0.92]
+  }),
+  timber: preset({
+    strength: 0.5,
+    pattern: "grain",
+    scale: [96 * PX, 96 * PX],
+    detail: 0.16,
+    bands: 1,
+    toneRange: 0.2,
+    coolTint: [0.88, 0.96, 1.1],
+    warmTint: [1.14, 1.04, 0.86],
+    roughnessRange: 0.2,
+    weathering: 0.11
+  }),
+  ground: preset({
+    strength: 0.5,
+    pattern: "mottle",
+    scale: [96 * PX, 96 * PX],
+    detail: 0.24,
+    bands: 1,
+    toneRange: 0.16,
+    coolTint: [0.88, 1.04, 0.9],
+    warmTint: [1.12, 1.02, 0.82],
+    roughnessRange: 0.18,
+    weathering: 0.09,
+    weatherThreshold: [0.28, 0.76]
+  }),
+  metal: preset({
+    strength: 0.5,
+    pattern: "mottle",
+    scale: [112 * PX, 112 * PX],
+    detail: 0.12,
+    bands: 1,
+    toneRange: 0.1,
+    coolTint: [0.9, 0.97, 1.1],
+    warmTint: [1.08, 1.03, 0.94],
+    roughnessRange: 0.12,
+    weathering: 0.06,
+    weatherThreshold: [0.74, 0.94]
+  }),
+  tile: preset({
+    strength: 0.5,
+    pattern: "cells",
+    scale: [0.6, 0.6],
+    detail: 0.18,
+    toneRange: 0.12,
+    coolTint: [0.94, 0.98, 1.06],
+    warmTint: [1.06, 1.02, 0.94],
+    roughnessRange: 0.14,
+    weathering: 0.06,
+    weatherThreshold: [0.72, 0.94]
+  })
+};
+function hash(x) {
+  let h = Math.imul(x, 747796405) + 2891336453 >>> 0;
+  h = Math.imul((h >>> (h >>> 28) + 4 ^ h) >>> 0, 277803737) >>> 0;
+  return (h >>> 22 ^ h) >>> 0;
+}
+function cell(x, z, seed) {
+  const h = hash((x | 0) >>> 0 ^ hash((z | 0) >>> 0 ^ hash(seed >>> 0)));
+  return (h >>> 8) / 16777216;
+}
+function clamp(x, lo, hi) {
+  return x < lo ? lo : x > hi ? hi : x;
+}
+function step(a, b, x) {
+  const t2 = clamp((x - a) / Math.max(b - a, 1e-5), 0, 1);
+  return t2 * t2 * (3 - 2 * t2);
+}
+const mix = (a, b, t2) => a + (b - a) * t2;
+const f = Math.fround;
+function noise(px, pz, seed) {
+  const ix = Math.floor(px);
+  const iz = Math.floor(pz);
+  const fx = px - ix;
+  const fz = pz - iz;
+  const ux = fx * fx * (3 - 2 * fx);
+  const uz = fz * fz * (3 - 2 * fz);
+  const a = cell(ix, iz, seed);
+  const b = cell(ix + 1, iz, seed);
+  const c = cell(ix, iz + 1, seed);
+  const d = cell(ix + 1, iz + 1, seed);
+  return mix(mix(a, b, ux), mix(c, d, ux), uz);
+}
+function bands(v) {
+  return (step(0.18, 0.28, v) + step(0.43, 0.53, v) + step(0.68, 0.78, v)) / 3;
+}
+function brush(px, pz, seed) {
+  const cx = Math.floor(px);
+  const cz = Math.floor(pz);
+  const lx0 = px - cx - 0.5;
+  const lz0 = pz - cz - 0.5;
+  const slant = (cell(cx, cz, seed) - 0.5) * 1.35;
+  const lx = lx0 + lz0 * slant;
+  const lz = lz0 - lx0 * slant * 0.35;
+  const length = 1 - step(0.3, 0.49, Math.abs(lx));
+  const width = 1 - step(0.11, 0.25, Math.abs(lz));
+  return length * width * mix(0.45, 1, cell(cx + 17, cz - 9, seed));
+}
+const add = (seed, k) => seed + k >>> 0;
+function surfaceVariation(v, p, out = { tint: [1, 1, 1], roughness: 0 }) {
+  const seed = v.seed >>> 0;
+  let qx = f(p[0] / Math.max(v.scale[0], 1e-3));
+  let qz = f(p[1] / Math.max(v.scale[1], 1e-3));
+  if (v.warp > 0) {
+    const wx = noise(qx * 0.7 - 6.2, qz * 0.7 + 8.1, add(seed, 7));
+    const wz = noise(qx * 0.7 + 3.7, qz * 0.7 - 2.9, add(seed, 5));
+    qx = f(qx + (wx - 0.5) * v.warp);
+    qz = f(qz + (wz - 0.5) * v.warp);
+  }
+  const d = noise(qx * 3.1 + 9.7, qz * 3.1 - 4.3, add(seed, 11));
+  let base;
+  switch (v.pattern) {
+    case "streaks":
+      base = noise(qx * 1.25, qz * 0.42, add(seed, 19));
+      break;
+    case "grain":
+      base = noise(qx * 0.36, qz * 4.2, add(seed, 23));
+      break;
+    case "cells":
+      base = cell(Math.floor(qx), Math.floor(qz), add(seed, 3));
+      break;
+    case "stagger": {
+      const row = Math.floor(qz);
+      const col = Math.floor(qx + 0.5 * (row - 2 * Math.floor(row / 2)));
+      const group = cell(Math.floor(col / 2), Math.floor(row / 2), add(seed, 13));
+      base = mix(group, cell(col, row, add(seed, 17)), 0.28);
+      break;
+    }
+    case "brushed": {
+      const marks = Math.max(
+        brush(qx * 1.45, qz * 1.45, add(seed, 37)),
+        brush(qx * 1.45 + 0.47, qz * 1.45 + 0.63, add(seed, 41))
+      );
+      base = clamp(noise(qx, qz, add(seed, 31)) + (marks - 0.24) * 0.26, 0, 1);
+      break;
+    }
+    default:
+      base = noise(qx, qz, seed);
+  }
+  const value = clamp(mix(mix(base, bands(base), v.bands), d, v.detail), 0, 1);
+  const s = v.strength;
+  const weather = step(v.weatherThreshold[0], v.weatherThreshold[1], d) * v.weathering;
+  const tone = (value - 0.5) * 2 * v.toneRange;
+  const k = clamp(1 + (tone - weather) * s, 0.62, 1.3);
+  for (let i = 0; i < 3; i++)
+    out.tint[i] = mix(1, mix(v.coolTint[i], v.warmTint[i], value), s) * k;
+  out.roughness = ((d - 0.5) * v.roughnessRange + weather * 0.45) * s;
+  return out;
+}
+export {
+  SURFACE_PRESETS,
+  VARIATION_FIELDS,
+  VARIATION_PATTERNS,
+  VARIATION_STRUCT,
+  VariationUniform,
+  surfaceVariation
+};

package/dist/surface-shaders.d.ts

@@ -0,0 +1,3 @@
+export declare const SURFACE_VARIATION_WGSL: string;
+/** `surface::material` for variation on or off. */
+export declare function surfaceMaterialWgsl(variation: boolean): string;

package/dist/surface-shaders.js

@@ -0,0 +1,160 @@
+import { wgslLayout } from "@aethervtt/shard-shader";
+import { VariationUniform } from "./surface-model.js";
+const VARIATION = `
+import shard::pbr::types::VertexOutput;
+
+${wgslLayout(VariationUniform).wgsl}
+
+/** What a variation does at a point: a base colour multiplier and a roughness offset. */
+struct SurfaceVariation {
+  tint: vec3f,
+  roughness: f32,
+}
+
+fn surface_hash(x: u32) -> u32 {
+  var h = x * 747796405u + 2891336453u;
+  h = ((h >> ((h >> 28u) + 4u)) ^ h) * 277803737u;
+  return (h >> 22u) ^ h;
+}
+
+/** A cell's value in [0, 1): 24 bits of its hash, exact in f32. */
+fn surface_cell(c: vec2i, seed: u32) -> f32 {
+  let h = surface_hash(bitcast<u32>(c.x) ^ surface_hash(bitcast<u32>(c.y) ^ surface_hash(seed)));
+  return f32(h >> 8u) * (1.0 / 16777216.0);
+}
+
+/** smoothstep that tolerates equal edges (a step). */
+fn surface_step(a: f32, b: f32, x: f32) -> f32 {
+  let t = clamp((x - a) / max(b - a, 1e-5), 0.0, 1.0);
+  return t * t * (3.0 - 2.0 * t);
+}
+
+/** Value noise in [0, 1], smooth between integer lattice points. */
+fn surface_noise(p: vec2f, seed: u32) -> f32 {
+  let i = floor(p);
+  let f = p - i;
+  let u = f * f * (3.0 - 2.0 * f);
+  let c = vec2i(i);
+  let a = surface_cell(c, seed);
+  let b = surface_cell(c + vec2i(1, 0), seed);
+  let d = surface_cell(c + vec2i(0, 1), seed);
+  let e = surface_cell(c + vec2i(1, 1), seed);
+  return mix(mix(a, b, u.x), mix(d, e, u.x), u.y);
+}
+
+/** Three soft steps: posterized paint bands. */
+fn surface_bands(v: f32) -> f32 {
+  return (surface_step(0.18, 0.28, v) + surface_step(0.43, 0.53, v) + surface_step(0.68, 0.78, v)) / 3.0;
+}
+
+/** A slanted brush mark in each cell of p. */
+fn surface_brush(p: vec2f, seed: u32) -> f32 {
+  let cell = floor(p);
+  let l0 = p - cell - 0.5;
+  let c = vec2i(cell);
+  let slant = (surface_cell(c, seed) - 0.5) * 1.35;
+  let lx = l0.x + l0.y * slant;
+  let ly = l0.y - l0.x * slant * 0.35;
+  let len = 1.0 - surface_step(0.3, 0.49, abs(lx));
+  let width = 1.0 - surface_step(0.11, 0.25, abs(ly));
+  return len * width * mix(0.45, 1.0, surface_cell(c + vec2i(17, -9), seed));
+}
+
+/**
+ * The surface point a variation is evaluated at, in metres. projection 0 ('uv'): the mesh's UV
+ * (structure's are metres along its faces); 1 ('world'): the world plane the normal is closest to.
+ */
+fn surface_point(in: VertexOutput, projection: u32) -> vec2f {
+  if (projection == 0u) {
+    return in.uv;
+  }
+  let n = abs(in.world_normal);
+  let p = in.world_position;
+  if (n.y >= n.x && n.y >= n.z) {
+    return p.xz;
+  }
+  if (n.x >= n.z) {
+    return vec2f(p.z, -p.y);
+  }
+  return vec2f(p.x, -p.y);
+}
+
+/** The variation at surface point p (metres). */
+fn surface_variation(p: vec2f, v: VariationUniform) -> SurfaceVariation {
+  let seed = v.seed;
+  var q = p / max(v.scale, vec2f(1e-3));
+  if (v.warp > 0.0) {
+    let w = vec2f(
+      surface_noise(q * 0.7 + vec2f(-6.2, 8.1), seed + 7u),
+      surface_noise(q * 0.7 + vec2f(3.7, -2.9), seed + 5u),
+    );
+    q = q + (w - 0.5) * v.warp;
+  }
+  let d = surface_noise(q * 3.1 + vec2f(9.7, -4.3), seed + 11u);
+  var base: f32;
+  switch v.pattern {
+    case 1u: {
+      base = surface_noise(vec2f(q.x * 1.25, q.y * 0.42), seed + 19u);
+    }
+    case 2u: {
+      base = surface_noise(vec2f(q.x * 0.36, q.y * 4.2), seed + 23u);
+    }
+    case 3u: {
+      base = surface_cell(vec2i(floor(q)), seed + 3u);
+    }
+    case 4u: {
+      let row = floor(q.y);
+      let col = floor(q.x + 0.5 * (row - 2.0 * floor(row / 2.0)));
+      let group = surface_cell(vec2i(floor(vec2f(col, row) / 2.0)), seed + 13u);
+      base = mix(group, surface_cell(vec2i(i32(col), i32(row)), seed + 17u), 0.28);
+    }
+    case 5u: {
+      let marks = max(
+        surface_brush(q * 1.45, seed + 37u),
+        surface_brush(q * 1.45 + vec2f(0.47, 0.63), seed + 41u),
+      );
+      base = clamp(surface_noise(q, seed + 31u) + (marks - 0.24) * 0.26, 0.0, 1.0);
+    }
+    default: {
+      base = surface_noise(q, seed);
+    }
+  }
+  let value = clamp(mix(mix(base, surface_bands(base), v.bands), d, v.detail), 0.0, 1.0);
+  let s = v.strength;
+  let weather = surface_step(v.weatherThreshold.x, v.weatherThreshold.y, d) * v.weathering;
+  let tone = (value - 0.5) * 2.0 * v.toneRange;
+  let k = clamp(1.0 + (tone - weather) * s, 0.62, 1.3);
+  var out: SurfaceVariation;
+  out.tint = mix(vec3f(1.0), mix(v.coolTint, v.warmTint, value), s) * k;
+  out.roughness = ((d - 0.5) * v.roughnessRange + weather * 0.45) * s;
+  return out;
+}
+`;
+const MATERIAL_ON = `
+import shard::pbr::types::{ VertexOutput, PbrInput };
+import shard::pbr::standard::standard_input;
+import surface::variation::{ surface_point, surface_variation };
+import material::surface_material::SurfaceMaterial;
+
+override fn pbr_input(in: VertexOutput) -> PbrInput {
+  var p = standard_input(in);
+  let v = surface_variation(surface_point(in, SurfaceMaterial.projection), SurfaceMaterial.variation);
+  p.base_color = p.base_color * v.tint;
+  p.roughness = clamp(p.roughness + v.roughness, 0.045, 1.0);
+  return p;
+}`;
+const MATERIAL_OFF = `
+import shard::pbr::types::{ VertexOutput, PbrInput };
+import shard::pbr::standard::standard_input;
+
+override fn pbr_input(in: VertexOutput) -> PbrInput {
+  return standard_input(in);
+}`;
+const SURFACE_VARIATION_WGSL = VARIATION;
+function surfaceMaterialWgsl(variation) {
+  return variation ? MATERIAL_ON : MATERIAL_OFF;
+}
+export {
+  SURFACE_VARIATION_WGSL,
+  surfaceMaterialWgsl
+};

package/dist/surface.d.ts

@@ -0,0 +1,40 @@
+export { SURFACE_PRESETS, type SurfaceSample, surfaceVariation, VARIATION_FIELDS, VARIATION_PATTERNS, VARIATION_STRUCT, type Variation, type VariationInit, type VariationPattern, VariationUniform, } from './surface-model.js';
+export { SURFACE_VARIATION_WGSL, surfaceMaterialWgsl } from './surface-shaders.js';
+/**
+ * A variation field. Give a custom material type one (`fields: { variation: VariationField }`) and
+ * pass it to `surface::variation::surface_variation` in its shader. Presets are its examples.
+ */
+export declare const VariationField: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+    strength: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    seed: import("@aethervtt/shard-core").FieldType<number, "u32">;
+    pattern: import("@aethervtt/shard-core").FieldType<"brushed" | "cells" | "grain" | "mottle" | "stagger" | "streaks", "u8">;
+    scale: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    warp: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    detail: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    bands: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    toneRange: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    coolTint: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    warmTint: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    roughnessRange: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    weathering: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    weatherThreshold: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+}>, "object">;
+export declare const SURFACE_PROJECTIONS: readonly ['uv', 'world'];
+/**
+ * The standard material plus surface variation. Every preset and every variation shares one
+ * pipeline. Needs `surfacePlugin`.
+ */
+export declare const SurfaceMaterial: import("./materials.js").MaterialType;
+export interface SurfaceSettingsValue {
+    /**
+     * false links SurfaceMaterial without the variation code: it shades exactly as the standard
+     * material, at the same cost. Switching relinks once.
+     */
+    variation: boolean;
+}
+export declare const SurfaceSettings: import("@aethervtt/shard-core").ResourceDef<SurfaceSettingsValue>;
+/**
+ * Surface variation: the `surface::variation` WGSL library and SurfaceMaterial's shader, and
+ * SurfaceSettings (its quality switch).
+ */
+export declare const surfacePlugin: import("@aethervtt/shard-runtime").Plugin;

package/dist/surface.js

@@ -0,0 +1,86 @@
+import { defineResource, defineSystem, PostUpdate, t } from "@aethervtt/shard-core";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { defineMaterial } from "./materials.js";
+import { Shaders } from "./plugin.js";
+import {
+  SURFACE_PRESETS,
+  VARIATION_FIELDS,
+  VARIATION_STRUCT
+} from "./surface-model.js";
+import { SURFACE_VARIATION_WGSL, surfaceMaterialWgsl } from "./surface-shaders.js";
+import {
+  SURFACE_PRESETS as SURFACE_PRESETS2,
+  surfaceVariation,
+  VARIATION_FIELDS as VARIATION_FIELDS2,
+  VARIATION_PATTERNS,
+  VARIATION_STRUCT as VARIATION_STRUCT2,
+  VariationUniform
+} from "./surface-model.js";
+import { SURFACE_VARIATION_WGSL as SURFACE_VARIATION_WGSL2, surfaceMaterialWgsl as surfaceMaterialWgsl2 } from "./surface-shaders.js";
+const VariationField = t.struct(VARIATION_FIELDS, {
+  wgsl: VARIATION_STRUCT,
+  description: `Surface variation (0068): shaped noise that tints the base colour and shifts roughness. The examples are SURFACE_PRESETS: ${Object.keys(SURFACE_PRESETS).join(", ")}.`,
+  examples: Object.values(SURFACE_PRESETS)
+});
+const SURFACE_PROJECTIONS = ["uv", "world"];
+const SurfaceMaterial = defineMaterial("render/SurfaceMaterial", {
+  extends: "standard",
+  fields: {
+    variation: VariationField,
+    projection: t.enum(SURFACE_PROJECTIONS, {
+      description: "Where the variation is evaluated: uv (the mesh's UV, metres on structure, continuous around arcs) or world (the world plane the surface's normal is closest to, for meshes without metre UVs)."
+    })
+  },
+  shader: "surface::material",
+  plugin: "surfacePlugin from '@aethervtt/shard-render/surface'",
+  description: "The standard material with surface variation (0068): shaped noise in surface space tints the base colour and shifts roughness, breaking up a repeat without new textures."
+});
+const SurfaceSettings = defineResource("render/SurfaceSettings", {
+  description: "Surface variation quality: variation false shades SurfaceMaterial as the standard material. Write with patchResource.",
+  init: () => ({ variation: true }),
+  hostWritable: true
+});
+const linked = /* @__PURE__ */ new WeakMap();
+const applySurfaceSettings = defineSystem({
+  name: "render/surface-settings",
+  description: "Relinks SurfaceMaterial with or without variation when SurfaceSettings changes.",
+  run: (_, world) => {
+    const library = world.resource(Shaders);
+    const on = world.resource(SurfaceSettings).variation;
+    if (linked.get(library) === on) return;
+    linked.set(library, on);
+    library.register("surface::material", surfaceMaterialWgsl(on), "engine:surface::material");
+  }
+});
+const surfacePlugin = definePlugin({
+  name: "render/surface",
+  dependencies: ["render"],
+  provides: [SurfaceMaterial, SurfaceSettings],
+  build(app) {
+    app.world.initResource(SurfaceSettings);
+    app.addSystems(PostUpdate, applySurfaceSettings);
+  },
+  ready(app) {
+    const world = app.world;
+    const library = world.resource(Shaders);
+    library.register("surface::variation", SURFACE_VARIATION_WGSL, "engine:surface::variation");
+    const on = world.resource(SurfaceSettings).variation;
+    linked.set(library, on);
+    library.register("surface::material", surfaceMaterialWgsl(on), "engine:surface::material");
+  }
+});
+export {
+  SURFACE_PRESETS2 as SURFACE_PRESETS,
+  SURFACE_PROJECTIONS,
+  SURFACE_VARIATION_WGSL2 as SURFACE_VARIATION_WGSL,
+  SurfaceMaterial,
+  SurfaceSettings,
+  VARIATION_FIELDS2 as VARIATION_FIELDS,
+  VARIATION_PATTERNS,
+  VARIATION_STRUCT2 as VARIATION_STRUCT,
+  VariationField,
+  VariationUniform,
+  surfaceMaterialWgsl2 as surfaceMaterialWgsl,
+  surfacePlugin,
+  surfaceVariation
+};

package/dist/target.d.ts

@@ -1,5 +1,5 @@
 import type { GpuContext } from '@aethervtt/shard-gpu';
-/** Where a view renders: the window's swapchain or an offscreen texture. */
+/** Where a view renders: a surface (a canvas, 0052) or an offscreen texture. */
 export interface RenderTarget {
     readonly label: string;
     readonly format: GPUTextureFormat;
@@ -15,18 +15,6 @@ export interface RenderTarget {
     /** The texture to render into this frame. */
     texture(): GPUTexture;
 }
-/** The canvas swapchain. Resizes with the canvas. */
-export declare class WindowTarget implements RenderTarget {
-    readonly label = "window";
-    readonly renderScale = true;
-    private readonly gpu;
-    constructor(gpu: GpuContext);
-    get format(): GPUTextureFormat;
-    get width(): number;
-    get pixelRatio(): number;
-    get height(): number;
-    texture(): GPUTexture;
-}
 export interface OffscreenTargetOptions {
     label: string;
     width: number;

package/dist/target.js

@@ -1,27 +1,3 @@
-class WindowTarget {
-  label = "window";
-  renderScale = true;
-  gpu;
-  constructor(gpu) {
-    this.gpu = gpu;
-  }
-  get format() {
-    return this.gpu.format;
-  }
-  get width() {
-    return this.gpu.canvas?.width ?? 1;
-  }
-  get pixelRatio() {
-    return this.gpu.pixelRatio;
-  }
-  get height() {
-    return this.gpu.canvas?.height ?? 1;
-  }
-  texture() {
-    this.gpu.resize();
-    return this.gpu.context.getCurrentTexture();
-  }
-}
 class OffscreenTarget {
   label;
   format;
@@ -65,6 +41,5 @@ class OffscreenTarget {
   }
 }
 export {
-  OffscreenTarget,
-  WindowTarget
+  OffscreenTarget
 };

package/dist/testing.d.ts

@@ -1,5 +1,6 @@
 import type { App } from '@aethervtt/shard-runtime';
 import type { CapturedImage } from './graph.js';
+export { expectScenario, measureScenario, type ScenarioOptions, type ScenarioRun, type ScenarioSlice, } from './scenario.js';
 /** Renders frames until shaders and pipelines are compiled and nothing is skipped. */
 export declare function settle(app: App, frames?: number): Promise<void>;
 /** Settles, then captures a view. */
@@ -32,3 +33,13 @@ export declare function compareGolden(dir: string, name: string, image: {
     height: number;
     data: Uint8Array;
 }): GoldenResult;
+/**
+ * Watches a device for what the baseline tier (0064) must never ask for: compute passes, and
+ * storage buffers visible to the vertex or fragment stage. Counts from now on.
+ */
+export declare function watchBaseline(gpu: import('@aethervtt/shard-gpu').GpuContext): {
+    computePasses: number;
+    renderStorage: string[];
+};
+/** Mean absolute difference of two images' bytes. */
+export declare function meanDifference(a: ArrayLike<number>, b: ArrayLike<number>): number;