@aethervtt/shard-render 0.0.1

package/dist/noise.js

@@ -0,0 +1,286 @@
+import { AssetServerResource, assetServer } from "@aethervtt/shard-assets";
+import { ShardError } from "@aethervtt/shard-core";
+import { GpuBuffer } from "@aethervtt/shard-gpu";
+import {
+  NoiseGraphs,
+  noiseOrigins,
+  normalizeGrid,
+  patchOrigin,
+  patchPoints,
+  registerNoiseGraph
+} from "@aethervtt/shard-noise";
+import { definePlugin, LogResource, Time } from "@aethervtt/shard-runtime";
+import { MaterialNoise } from "./material-noise.js";
+import { Shaders } from "./plugin.js";
+const states = /* @__PURE__ */ new WeakMap();
+const loading = /* @__PURE__ */ new WeakMap();
+function materialNoise(world, library, type) {
+  let state = states.get(type);
+  if (!state || state.slots.length !== type.noise.length) {
+    state = {
+      slots: type.noise.map(() => ({ ref: void 0, graph: void 0, version: -1 })),
+      source: "",
+      key: ""
+    };
+    states.set(type, state);
+  }
+  const store = world.tryResource(NoiseGraphs);
+  let changed = false;
+  for (let i = 0; i < type.noise.length; i++) {
+    const slot = type.noise[i];
+    const s = state.slots[i];
+    s.ref ??= world.tryResource(AssetServerResource) ? assetServer(world).resolve(slot.path) : void 0;
+    if (!s.ref) {
+      reportMissing(world, type, slot.path);
+      return void 0;
+    }
+    const graph = store?.get(s.ref);
+    if (!graph) {
+      startLoad(world, slot.path);
+      return void 0;
+    }
+    if (graph !== s.graph || graph.version !== s.version) {
+      s.graph = graph;
+      s.version = graph.version;
+      changed = true;
+    }
+    registerNoiseGraph(library, graph, slot.path);
+  }
+  if (changed || state.key === "") {
+    let source = "";
+    let key = "";
+    for (let i = 0; i < type.noise.length; i++) {
+      const graph = state.slots[i].graph;
+      const pos = graph.program.dimensions === 4 ? "vec4f" : "vec3f";
+      const name = type.noise[i].name;
+      source += `/** ${type.noise[i].path} */
+fn noise_${name}(p: ${pos}, seed: u32) -> f32 {
+  return ${graph.module}::${graph.fn}(p, seed);
+}
+`;
+      key += `${graph.hash}:${graph.module};`;
+    }
+    state.source = source;
+    state.key = key;
+  }
+  return state;
+}
+const reported = /* @__PURE__ */ new WeakMap();
+function reportMissing(world, type, path) {
+  let seen = reported.get(world);
+  if (!seen) {
+    seen = /* @__PURE__ */ new Set();
+    reported.set(world, seen);
+  }
+  const key = `${type.name}:${path}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  world.tryResource(LogResource)?.error(
+    new ShardError(
+      "render/noise-graph-missing",
+      `Material ${type.name} uses "${path}", which isn't an asset`,
+      {
+        path,
+        hint: 'noise paths name *.noise.json assets, e.g. { detail: "assets/noise/rock.noise.json" }.'
+      }
+    )
+  );
+}
+function startLoad(world, path) {
+  let set = loading.get(world);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    loading.set(world, set);
+  }
+  if (set.has(path)) return;
+  set.add(path);
+  const pending = set;
+  assetServer(world).load(path).catch((err) => world.tryResource(LogResource)?.error(err)).finally(() => pending.delete(path));
+}
+const WORKGROUP = 64;
+class NoiseCompute {
+  gpu;
+  domain;
+  graph;
+  params;
+  origins;
+  points;
+  scratch = new ArrayBuffer(48);
+  f32 = new Float32Array(this.scratch);
+  u32 = new Uint32Array(this.scratch);
+  local = new Float32Array(0);
+  records = new Int32Array(0);
+  origin64 = new Float64Array(4);
+  bindGroups = /* @__PURE__ */ new WeakMap();
+  constructor(gpu, graph, domain) {
+    this.gpu = gpu;
+    this.graph = graph;
+    this.domain = domain;
+    const usage = GPUBufferUsage.STORAGE;
+    this.params = new GpuBuffer(gpu, {
+      label: "noise/params",
+      usage: GPUBufferUsage.UNIFORM,
+      size: 48
+    });
+    this.origins = new GpuBuffer(gpu, { label: "noise/origins", usage, size: 256 });
+    this.points = new GpuBuffer(gpu, { label: "noise/points", usage, size: 16 });
+  }
+  /** The root module path of this domain's compute shader for the graph. */
+  get modulePath() {
+    return `${this.graph.module}::compute_${this.domain === "grid2d" ? "grid" : "patch"}`;
+  }
+  /** The compute shader: one invocation per sample, calling `noise_<name>_at`. */
+  shaderSource() {
+    const g = this.graph;
+    const n = g.name;
+    const point = this.domain === "grid2d" ? "let local = vec3f(params.corner + vec2f(f32(i % params.width), f32(i / params.width)) * params.step, 0.0);" : "let local = vec3f(points[i * 3u], points[i * 3u + 1u], points[i * 3u + 2u]);";
+    return `import ${g.module}::{ noise_${n}_at, NoiseOrigins_${n} };
+
+struct NoiseComputeParams {
+  seed: u32,
+  count: u32,
+  width: u32,
+  _pad: u32,
+  /** Grid: the first sample, relative to the grid center, and the spacing. */
+  corner: vec2f,
+  step: vec2f,
+}
+
+@group(0) @binding(0) var<uniform> params: NoiseComputeParams;
+@group(0) @binding(1) var<storage, read> origins: NoiseOrigins_${n};
+@group(0) @binding(2) var<storage, read_write> out: array<f32>;
+${this.domain === "sphere-patch" ? "@group(0) @binding(3) var<storage, read> points: array<f32>;\n" : ""}
+@compute @workgroup_size(${WORKGROUP})
+fn main(@builtin(global_invocation_id) id: vec3u) {
+  let i = id.x;
+  if (i >= params.count) { return; }
+  ${point}
+  var o = origins;
+  out[i] = noise_${n}_at(&o, local, params.seed);
+}
+`;
+  }
+  pipeline(library) {
+    registerNoiseGraph(library, this.graph);
+    const path = this.modulePath;
+    const source = this.shaderSource();
+    library.register(path, source, `noise compute ${this.graph.module}`);
+    const module = library.module(this.gpu, { root: path, label: `noise ${this.graph.name}` });
+    if (!module) return void 0;
+    return this.gpu.pipelines.compute({
+      label: `noise/${this.graph.name}/${this.domain}`,
+      layout: "auto",
+      compute: { module, entryPoint: "main" }
+    });
+  }
+  /**
+   * Writes this request's parameters and records a dispatch into `pass`. Returns false while the
+   * shader compiles (nothing is recorded).
+   */
+  encode(library, pass, request) {
+    const pipeline = this.pipeline(library);
+    if (!pipeline) return false;
+    const origin = this.origin64;
+    let count;
+    let width;
+    const f = this.f32;
+    const u = this.u32;
+    if (this.domain === "grid2d") {
+      const g = normalizeGrid(request.area);
+      const [nx, ny] = g.resolution;
+      count = nx * ny;
+      width = nx;
+      origin[0] = g.origin[0] + g.size[0] / 2;
+      origin[1] = g.origin[1] + g.size[1] / 2;
+      origin[2] = g.z ?? 0;
+      f[4] = -g.size[0] / 2;
+      f[5] = -g.size[1] / 2;
+      f[6] = nx > 1 ? g.size[0] / (nx - 1) : 0;
+      f[7] = ny > 1 ? g.size[1] / (ny - 1) : 0;
+    } else {
+      const p = request.area;
+      count = p.resolution * p.resolution;
+      width = p.resolution;
+      patchOrigin(p, origin);
+      if (this.local.length < count * 3) this.local = new Float32Array(count * 3);
+      patchPoints(p, origin, 0, p.resolution, this.local);
+      this.points.ensureCapacity(count * 12);
+      this.points.write(this.local.subarray(0, count * 3));
+    }
+    const records = this.graph.program.zeroOrigins.length;
+    if (this.records.length !== records) this.records = new Int32Array(Math.max(8, records));
+    noiseOrigins(this.graph, origin, this.records.subarray(0, records));
+    this.origins.ensureCapacity(this.records.byteLength);
+    this.origins.write(this.records);
+    u[0] = request.seed >>> 0;
+    u[1] = count;
+    u[2] = width;
+    this.params.write(f);
+    const group = this.bindGroup(pipeline, request.out);
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, group);
+    pass.dispatchWorkgroups(Math.ceil(count / WORKGROUP));
+    return true;
+  }
+  bindGroup(pipeline, out) {
+    const key = `${this.params.version}:${this.origins.version}:${this.points.version}:${this.graph.hash}`;
+    const cached = this.bindGroups.get(out);
+    if (cached && cached.key === key) return cached.group;
+    const group = this.gpu.device.createBindGroup({
+      label: `noise/${this.graph.name}`,
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: this.params.buffer } },
+        { binding: 1, resource: { buffer: this.origins.buffer } },
+        { binding: 2, resource: { buffer: out } },
+        // Grids compute their points in the shader; `auto` layouts drop the unused binding.
+        ...this.domain === "sphere-patch" ? [{ binding: 3, resource: { buffer: this.points.buffer } }] : []
+      ]
+    });
+    this.bindGroups.set(out, { key, group });
+    return group;
+  }
+  destroy() {
+    this.params.destroy();
+    this.origins.destroy();
+    this.points.destroy();
+  }
+}
+function noiseComputeNode(options) {
+  let compute;
+  let frame = -1;
+  return {
+    kind: "raw",
+    phase: 0,
+    sideEffects: true,
+    run(ctx) {
+      const library = ctx.world.resource(Shaders);
+      const time = ctx.world.resource(Time).frame;
+      if (time === frame) return;
+      frame = time;
+      const request = options.next();
+      if (!request) return;
+      if (!compute || compute.gpu !== ctx.gpu)
+        compute = new NoiseCompute(ctx.gpu, options.graph, options.domain);
+      compute.graph = options.graph;
+      const pass = ctx.encoder.beginComputePass({ label: `noise/${options.graph.name}` });
+      const ok = compute.encode(library, pass, request);
+      pass.end();
+      if (ok && options.done) ctx.afterSubmit(() => options.done(request));
+    }
+  };
+}
+const materialNoisePlugin = definePlugin({
+  name: "render/noise",
+  dependencies: ["render"],
+  provides: [MaterialNoise],
+  build(app) {
+    app.insertResource(MaterialNoise, { wrappers: materialNoise });
+  }
+});
+export {
+  NoiseCompute,
+  materialNoise,
+  materialNoisePlugin,
+  noiseComputeNode
+};

package/dist/overlay-registry.d.ts

@@ -0,0 +1,18 @@
+import type { Entity, World } from '@aethervtt/shard-core';
+import type { GizmoStore } from './gizmos.js';
+export declare const OVERLAYS: readonly ['bounds', 'lights', 'cameras', 'cascades', 'normals', 'axes', 'labels'];
+export type Overlay = (typeof OVERLAYS)[number];
+/** An overlay another package draws (physics colliders, the navmesh, UI rects). */
+export interface OverlayDef {
+    name: string;
+    description: string;
+    /** Draws into gizmos. `passes(entity)` applies the overlay filter (components and path). */
+    draw(world: World, g: GizmoStore, passes: (entity: Entity) => boolean): void;
+}
+/** Registers an overlay, so `debug.overlays` and `render.capture` can turn it on by name. */
+export declare function defineOverlay(def: OverlayDef): OverlayDef;
+/** The registered overlays by name, read-only (no copy: drawOverlays reads it every frame). */
+export declare function registeredOverlays(): ReadonlyMap<string, OverlayDef>;
+export declare function allOverlays(): OverlayDef[];
+/** Every overlay name: the built-in ones, then registered ones. */
+export declare function overlayNames(): string[];

package/dist/overlay-registry.js

@@ -0,0 +1,30 @@
+const OVERLAYS = [
+  "bounds",
+  "lights",
+  "cameras",
+  "cascades",
+  "normals",
+  "axes",
+  "labels"
+];
+const extraOverlays = /* @__PURE__ */ new Map();
+function defineOverlay(def) {
+  extraOverlays.set(def.name, def);
+  return def;
+}
+function registeredOverlays() {
+  return extraOverlays;
+}
+function allOverlays() {
+  return [...extraOverlays.values()];
+}
+function overlayNames() {
+  return [...OVERLAYS, ...extraOverlays.keys()];
+}
+export {
+  OVERLAYS,
+  allOverlays,
+  defineOverlay,
+  overlayNames,
+  registeredOverlays
+};

package/dist/overlays.d.ts

@@ -0,0 +1,35 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import type { Mesh } from '@aethervtt/shard-mesh';
+import { type InstanceStore } from './instances.js';
+import { type Overlay } from './overlay-registry.js';
+export { allOverlays, defineOverlay, OVERLAYS, type Overlay, type OverlayDef, overlayNames, } from './overlay-registry.js';
+export declare function isOverlayOn(o: DebugOverlaysValue, name: string): boolean;
+export interface OverlayFilter {
+    /** Only entities with every one of these components (by name, e.g. "render/PointLight"). */
+    components: string[];
+    /** Only entities whose scene path starts with this. */
+    path: string;
+}
+export interface DebugOverlaysValue extends Record<Overlay, boolean> {
+    /** Registered overlays (`defineOverlay`) that are on. */
+    extra: Record<string, boolean>;
+    filter: OverlayFilter;
+    /**
+     * An entity's name for labels and the path filter. The default reads the scene path
+     * (`scene/SceneMember`) when the scene package is installed.
+     */
+    name: (world: World, entity: Entity) => string | undefined;
+}
+export declare const DebugOverlays: import("@aethervtt/shard-core").ResourceDef<DebugOverlaysValue>;
+/** Turns overlays on or off; `filter` limits them (see OverlayFilter). */
+export declare function setOverlays(world: World, on: Partial<Record<string, boolean>>, filter?: Partial<OverlayFilter>): DebugOverlaysValue;
+/** The mesh a slot draws (LOD sets: their most detailed level). */
+export declare function slotMesh(store: InstanceStore, slot: number): Mesh | undefined;
+/** Draws the enabled overlays into Gizmos (Last, before gizmos upload). */
+export declare const drawOverlays: import("@aethervtt/shard-core").SystemDef<undefined>;
+/**
+ * `grids`: the origin cell's bounds and the edges of its 26 neighbors, in the origin grid. The
+ * origin frame is the origin grid's own frame with the origin cell's centre at (0, 0, 0), so the
+ * origin cell spans ±cellSize/2 on each axis.
+ */
+export declare const gridsOverlay: import("./overlay-registry.js").OverlayDef;