@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/lights.js

@@ -8,6 +8,9 @@ import {
 import { GpuBuffer } from "@aethervtt/shard-gpu";
 import { GlobalTransform, Transform } from "@aethervtt/shard-transform";
 import { LightPresets } from "./camera.js";
+import { DataStore } from "./data-store.js";
+import { warnFeatureMissing } from "./features.js";
+import { InteriorPath } from "./interior.js";
 const LuminousPowerPresets = {
   candle: 12,
   "bulb-40w": 450,
@@ -33,6 +36,10 @@ const shadowFields = (defaults) => ({
     description: "PCF filter radius in texels beyond the base 3x3 (0 = 3x3). Softer edges."
   })
 });
+const SHADOW_UPDATES = ["always", "on-change"];
+const shadowUpdateField = () => t.enum(SHADOW_UPDATES, {
+  description: "always: shadow maps redraw every frame. on-change: they redraw only when the light or the camera's cascade fit moved, or a shadow caster inside them changed (0055); a still scene draws none."
+});
 const CascadeSettings = t.struct(
   {
     count: t.u8({ default: 4, min: 1, max: 4, description: "Number of cascades." }),
@@ -63,6 +70,7 @@ const DirectionalLight = defineComponent(
       description: "Presets: direct-sun 100000, daylight 10000, overcast 1000, indoor 400, twilight 10, moonlight 0.3."
     }),
     ...shadowFields({ bias: 0.02, normalBias: 1.5 }),
+    shadowUpdate: shadowUpdateField(),
     cascades: CascadeSettings,
     angularDiameter: t.f32({
       default: 0.53,
@@ -96,21 +104,41 @@ const pointFields = {
     min: 0,
     unit: "m",
     description: "Emitter size: softens specular highlights."
+  }),
+  blockedByWalls: t.bool({
+    description: "Occluded by its level's walls and closed doors (0069): structure's interiorLightingPlugin gives it a polar row from the plan, with no shadow-map budget. It lights only its own level. Without the plugin it lights through walls."
   })
 };
+const FALLOFFS = ["physical", "tabletop"];
 const PointLight = defineComponent(
   "render/PointLight",
-  { ...pointFields, ...shadowFields({ bias: 0.02, normalBias: 1 }) },
   {
-    description: "Light emitted equally in all directions, in lumens (intensity lm / 4\u03C0 candela), with physical inverse-square falloff windowed to zero at range.",
+    ...pointFields,
+    ...shadowFields({ bias: 0.02, normalBias: 1 }),
+    shadowUpdate: shadowUpdateField(),
+    falloff: t.enum(FALLOFFS, {
+      description: "physical: inverse square, windowed to zero at range. tabletop (0057): full intensity inside bright, then linear to zero at range (a VTT light's bright and dim radii)."
+    }),
+    bright: t.f32({
+      min: 0,
+      unit: "m",
+      description: "Tabletop falloff: the radius of full intensity. Past it, light fades linearly to zero at range."
+    })
+  },
+  {
+    description: "Light emitted equally in all directions, in lumens (intensity lm / 4\u03C0 candela), with physical inverse-square falloff windowed to zero at range, or tabletop falloff (bright, then dim to range).",
     requires: [Transform]
   }
 );
+function tabletopFalloff(distance, bright, range) {
+  return Math.min(1, Math.max(0, (range - distance) / Math.max(range - bright, 1e-4)));
+}
 const SpotLight = defineComponent(
   "render/SpotLight",
   {
     ...pointFields,
     ...shadowFields({ bias: 0.02, normalBias: 1 }),
+    shadowUpdate: shadowUpdateField(),
     innerAngle: t.f32({
       default: 30,
       min: 0,
@@ -133,22 +161,26 @@ const SpotLight = defineComponent(
 );
 const AmbientLight = defineResource("render/AmbientLight", {
   description: "Uniform fill light, in cd/m\xB2. Used when no environment map lights the view.",
-  init: () => ({ color: [1, 1, 1], brightness: 0 })
+  init: () => ({ color: [1, 1, 1], brightness: 0 }),
+  hostWritable: true
 });
 const LightingSettings = defineResource("render/LightingSettings", {
-  description: "Light and shadow budgets: light buffer size, cluster range, shadow map sizes.",
+  description: "Light and shadow budgets: light buffer size, cluster range, shadow map sizes, and the baseline tier's lights per view.",
+  hostWritable: true,
   init: () => ({
     maxLights: 1024,
     clusterFar: 0,
     cascadeMapSize: 2048,
     shadowMapSize: 1024,
     maxShadowedPoints: 4,
-    maxShadowedSpots: 8
+    maxShadowedSpots: 8,
+    baselineMaxLights: 128
   })
 });
 const LIGHT_FLOATS = 20;
 const LIGHT_KIND = { point: 0, spot: 1 };
 const MAX_DIRECTIONAL = 4;
+const LIGHT_ROW_WORD = { point: 12, spot: 19 };
 class LightStore {
   records = [];
   byEntity = /* @__PURE__ */ new Map();
@@ -162,9 +194,13 @@ class LightStore {
   uploadedBytes = 0;
   buffer;
   /** Directional lights: count + up to 4 × (direction, shadow cascade flag, color × lux, disk radius). */
+  /** Directional lights: `@data(uniform)`, a uniform block on baseline. */
   directional;
   directionalData = new Float32Array(4 + MAX_DIRECTIONAL * 8);
   directionalU32 = new Uint32Array(this.directionalData.buffer);
+  /** What the directional buffer holds, so an unchanged frame writes nothing (0055). */
+  directionalSent = new Float32Array(this.directionalData.length);
+  directionalStale = true;
   /** The first directional light with shadows: entity, and its settings. */
   shadowSun = null;
   directionalCount = 0;
@@ -181,9 +217,9 @@ class LightStore {
       usage: GPUBufferUsage.STORAGE,
       size: capacity * LIGHT_FLOATS * 4
     });
-    this.directional = new GpuBuffer(gpu, {
+    this.directional = new DataStore(gpu, {
       label: "lights/directional",
-      usage: GPUBufferUsage.STORAGE,
+      kind: "uniform",
       size: this.directionalData.byteLength
     });
   }
@@ -217,7 +253,9 @@ class LightStore {
       shadowIndex: -1,
       outerAngle: 0,
       radius: 0,
-      alive: true
+      alive: true,
+      cachedShadow: false,
+      row: -1
     };
     this.records[slot] = r;
     this.byEntity.set(entity, r);
@@ -251,28 +289,39 @@ class LightStore {
     if (this.generation !== this.gpu.generation) {
       this.generation = this.gpu.generation;
       this.dirty.fill(1, 0, this.high);
+      this.directionalStale = true;
     }
     let lights = 0;
     let runStart = -1;
     for (let s = 0; s <= this.high; s++) {
-      const d = s < this.high && this.dirty[s] === 1;
-      if (d) {
+      const d2 = s < this.high && this.dirty[s] === 1;
+      if (d2) {
         this.dirty[s] = 0;
         lights++;
         if (runStart < 0) runStart = s;
       } else if (runStart >= 0) {
-        this.buffer.write(
-          this.data,
-          runStart * LIGHT_FLOATS * 4,
-          runStart * LIGHT_FLOATS,
-          (s - runStart) * LIGHT_FLOATS
-        );
+        if (this.gpu.tier === "full") {
+          this.buffer.write(
+            this.data,
+            runStart * LIGHT_FLOATS * 4,
+            runStart * LIGHT_FLOATS,
+            (s - runStart) * LIGHT_FLOATS
+          );
+        }
         runStart = -1;
       }
     }
     this.uploadedLights = lights;
     this.uploadedBytes = lights * LIGHT_FLOATS * 4;
-    this.directional.write(this.directionalData);
+    const d = this.directionalData;
+    const sent = this.directionalSent;
+    let same = !this.directionalStale;
+    for (let i = 0; same && i < d.length; i++) if (!Object.is(d[i], sent[i])) same = false;
+    if (!same) {
+      this.directional.write(d);
+      sent.set(d);
+      this.directionalStale = false;
+    }
   }
 }
 const Lights = defineResource("render/Lights", {
@@ -281,7 +330,7 @@ const Lights = defineResource("render/Lights", {
 const POINT_KIND = LIGHT_KIND.point;
 const SPOT_KIND = LIGHT_KIND.spot;
 const INV_4PI = 1 / (4 * Math.PI);
-function writeLight(store, r, g, o, color, c, intensity, range, radius, bias, normalBias, softness, inner, outer) {
+function writeLight(store, r, g, o, color, c, intensity, range, radius, bias, normalBias, softness, inner, outer, falloff = 0, bright = 0) {
   const s = r.slot;
   r.x = g[o + 3];
   r.y = g[o + 7];
@@ -318,7 +367,7 @@ function writeLight(store, r, g, o, color, c, intensity, range, radius, bias, no
     r.cosOuter = cosOuter;
     r.outerAngle = outer;
   } else {
-    store.set(s, 12, 0);
+    store.set(s, 12, r.row + 1);
     store.set(s, 13, 1);
     r.cosOuter = -2;
   }
@@ -326,6 +375,16 @@ function writeLight(store, r, g, o, color, c, intensity, range, radius, bias, no
   store.set(s, 15, bias);
   store.set(s, 16, normalBias);
   store.set(s, 17, softness);
+  store.set(s, 18, falloff);
+  store.set(s, 19, r.kind === SPOT_KIND ? r.row + 1 : bright);
+}
+function warnBlockedWithoutPlugin(world) {
+  warnFeatureMissing(
+    world,
+    "A light has blockedByWalls",
+    "interiorPlugin",
+    "it lights through walls"
+  );
 }
 const extractLights = defineSystem({
   name: "render/extract-lights",
@@ -339,6 +398,7 @@ const extractLights = defineSystem({
   run: ({ directional, points, spots, seen }, world, ctx) => {
     const store = world.resource(Lights);
     const since = ctx.lastRunTick;
+    const interior = world.hasResource(InteriorPath);
     seen.clear();
     for (const [def, kind, q] of [
       [PointLight, POINT_KIND, points],
@@ -359,7 +419,11 @@ const extractLights = defineSystem({
         const normalBias = table.column(def, "shadowNormalBias");
         const softness = table.column(def, "shadowSoftness");
         const inner = kind === SPOT_KIND ? table.column(SpotLight, "innerAngle") : void 0;
+        const update = table.column(def, "shadowUpdate");
+        const falloff = kind === POINT_KIND ? table.column(PointLight, "falloff") : void 0;
+        const bright = kind === POINT_KIND ? table.column(PointLight, "bright") : void 0;
         const outer = kind === SPOT_KIND ? table.column(SpotLight, "outerAngle") : void 0;
+        const blocked = table.column(def, "blockedByWalls");
         for (let i = 0; i < n; i++) {
           const entity = table.entities[i];
           seen.add(entity);
@@ -367,7 +431,9 @@ const extractLights = defineSystem({
           const r = store.record(entity, kind);
           if (!r) continue;
           r.shadows = shadows[i] !== 0;
+          r.cachedShadow = update[i] === 1;
           if (existing === r && gChanged[i] <= since && changed[i] <= since) continue;
+          if (blocked[i] !== 0 && !interior) warnBlockedWithoutPlugin(world);
           writeLight(
             store,
             r,
@@ -382,7 +448,9 @@ const extractLights = defineSystem({
             normalBias[i],
             softness[i],
             inner ? inner[i] : 0,
-            outer ? outer[i] : 90
+            outer ? outer[i] : 90,
+            falloff ? falloff[i] : 0,
+            bright ? bright[i] : 0
           );
         }
       }
@@ -426,7 +494,8 @@ const extractLights = defineSystem({
             splitLambda: c.splitLambda,
             bias: table.column(DirectionalLight, "shadowBias")[i],
             normalBias: table.column(DirectionalLight, "shadowNormalBias")[i],
-            softness: table.column(DirectionalLight, "shadowSoftness")[i]
+            softness: table.column(DirectionalLight, "shadowSoftness")[i],
+            cached: table.column(DirectionalLight, "shadowUpdate")[i] === 1
           };
         }
         count++;
@@ -443,6 +512,11 @@ function observeLightRemovals(world) {
     });
   }
 }
+function setLightRow(store, r, row) {
+  if (r.row === row) return;
+  r.row = row;
+  store.set(r.slot, r.kind === SPOT_KIND ? LIGHT_ROW_WORD.spot : LIGHT_ROW_WORD.point, row + 1);
+}
 function setShadowIndex(store, r, index) {
   if (r.shadowIndex === index) return;
   r.shadowIndex = index;
@@ -452,17 +526,22 @@ export {
   AmbientLight,
   CascadeSettings,
   DirectionalLight,
+  FALLOFFS,
   LIGHT_FLOATS,
   LIGHT_KIND,
+  LIGHT_ROW_WORD,
   LightStore,
   LightingSettings,
   Lights,
   LuminousPowerPresets,
   MAX_DIRECTIONAL,
   PointLight,
+  SHADOW_UPDATES,
   SpotLight,
   extractLights,
   lumens,
   observeLightRemovals,
-  setShadowIndex
+  setLightRow,
+  setShadowIndex,
+  tabletopFalloff
 };

package/dist/material-pipelines.d.ts

@@ -1,7 +1,7 @@
-import { type World } from '@aethervtt/shard-core';
+import { ShardError, type World } from '@aethervtt/shard-core';
 import type { GpuContext } from '@aethervtt/shard-gpu';
 import type { ShaderLibrary } from '@aethervtt/shard-shader';
-import type { MaterialAsset } from './assets.js';
+import { MaterialAsset } from './assets.js';
 import { type BlendMode, type MaterialType } from './materials.js';
 /** A small stable number per material type, for sorting and pipeline keys. */
 export declare function typeOrdinal(type: MaterialType): number;
@@ -25,16 +25,49 @@ export declare function registerMaterialModule(library: ShaderLibrary, type: Mat
  */
 export declare class MaterialPipelines {
     private frame;
+    private revision;
     private readonly modules;
     private readonly pipelines;
-    beginFrame(frame: number): void;
+    /**
+     * Types whose shader or pipeline failed (0061), with the type version that failed: their draws
+     * use the standard pipeline through a proxy material until the type is defined again.
+     */
+    private readonly failedTypes;
+    private readonly proxies;
+    /** `revision`: the shader library's; any edit gives failed types another try (0061). */
+    beginFrame(frame: number, revision?: number): void;
     /**
      * The module for a type linked from `root` with its shader's overrides. `slot` distinguishes
      * roots and define sets (a small integer chosen by the caller).
      */
     module(world: World, gpu: GpuContext, type: MaterialType, slot: number, root: string, defines: Readonly<Record<string, boolean>> | undefined): GPUShaderModule | undefined;
+    /**
+     * Whether the type's shader or pipeline failed (0061). Callers then draw its batches with
+     * `proxy(material)` and the standard pipeline, so nothing using it disappears.
+     */
+    failing(type: MaterialType): boolean;
+    /** How many types draw through the standard fallback now. */
+    get failureCount(): number;
+    /** Types drawing through the standard fallback now, with why (for RenderHealth). */
+    failures(): {
+        type: string;
+        error: ShardError;
+    }[];
+    /**
+     * A standard material standing in for one whose type failed: its standard fields when the type
+     * extends standard, else its `baseColor` or `color` if it has one. Kept per material and
+     * refreshed when the material changes.
+     */
+    proxy(material: MaterialAsset): MaterialAsset;
     /** A compiled pipeline under `key` (unique per pass, type, and variant), if there is one. */
     cached(key: number): GPURenderPipeline | undefined;
+    /**
+     * Per (pass, sample count) slot of CPU-culled lists: the batch structure version and device
+     * generation whose pipelines were all asked for and compiled (forward's warmPipelines).
+     */
+    private readonly warm;
+    warmed(slot: number, structure: number, generation: number): boolean;
+    markWarmed(slot: number, structure: number, generation: number): void;
     /** The last pipeline that compiled under each key, with the layout it was made for. */
     private readonly previous;
     /**
@@ -42,5 +75,5 @@ export declare class MaterialPipelines {
      * While a replacement compiles (an edited shader or noise graph), draws keep the previous one
      * for the key if its layout is the same object (the bind groups still fit), instead of vanishing.
      */
-    create(gpu: GpuContext, key: number, descriptor: GPURenderPipelineDescriptor): GPURenderPipeline | undefined;
+    create(gpu: GpuContext, key: number, descriptor: GPURenderPipelineDescriptor, type?: MaterialType): GPURenderPipeline | undefined;
 }

package/dist/material-pipelines.js

@@ -1,9 +1,11 @@
 import { assetServer } from "@aethervtt/shard-assets";
 import { ShardError } from "@aethervtt/shard-core";
 import { LogResource } from "@aethervtt/shard-runtime";
+import { MaterialAsset } from "./assets.js";
 import { MaterialNoise } from "./material-noise.js";
 import { allMaterialTypes, BLEND_MODES } from "./materials.js";
 import { Shaders } from "./plugin.js";
+import { STANDARD_FIELDS } from "./standard-fields.js";
 const ordinals = /* @__PURE__ */ new WeakMap();
 let nextOrdinal = 0;
 function typeOrdinal(type) {
@@ -78,11 +80,25 @@ function watchNoiseGraphs(world, library) {
   });
 }
 const missingNoise = /* @__PURE__ */ new WeakSet();
+const missingPlugin = /* @__PURE__ */ new WeakSet();
 class MaterialPipelines {
   frame = -1;
+  revision = -1;
   modules = /* @__PURE__ */ new Map();
   pipelines = /* @__PURE__ */ new Map();
-  beginFrame(frame) {
+  /**
+   * Types whose shader or pipeline failed (0061), with the type version that failed: their draws
+   * use the standard pipeline through a proxy material until the type is defined again.
+   */
+  failedTypes = /* @__PURE__ */ new Map();
+  proxies = /* @__PURE__ */ new WeakMap();
+  /** `revision`: the shader library's; any edit gives failed types another try (0061). */
+  beginFrame(frame, revision = this.revision) {
+    if (revision !== this.revision) {
+      this.revision = revision;
+      this.failedTypes.clear();
+      this.warm.clear();
+    }
     if (frame === this.frame) return;
     this.frame = frame;
     this.modules.clear();
@@ -93,7 +109,7 @@ class MaterialPipelines {
    * roots and define sets (a small integer chosen by the caller).
    */
   module(world, gpu, type, slot, root, defines) {
-    const key = typeOrdinal(type) * 64 + slot;
+    const key = typeOrdinal(type) * 128 + slot;
     if (this.modules.has(key)) return this.modules.get(key);
     const library = world.resource(Shaders);
     let noise;
@@ -120,20 +136,94 @@ class MaterialPipelines {
         return void 0;
       }
     }
+    if (type.plugin && type.shader && !library.has(type.shader)) {
+      const error = new ShardError(
+        "render/feature-missing",
+        `Material ${type.name} needs ${type.plugin.split(" ")[0]}, which isn't installed`,
+        { hint: `Add ${type.plugin}.` }
+      );
+      if (!missingPlugin.has(type)) {
+        missingPlugin.add(type);
+        world.tryResource(LogResource)?.error(error);
+      }
+      this.failedTypes.set(type, { version: type.version, error });
+      this.modules.set(key, void 0);
+      return void 0;
+    }
     registerMaterialModule(library, type, noise);
-    const module = library.module(gpu, {
+    const request = {
       root,
       defines,
       overrides: type.shader ? [type.shader] : void 0,
       label: type.name === "render/StandardMaterial" ? void 0 : `material ${type.name}`
-    });
+    };
+    const module = library.module(gpu, request);
+    if (!module && type.name !== "render/StandardMaterial") {
+      const error = library.failure(request, gpu);
+      if (error) this.failedTypes.set(type, { version: type.version, error });
+    }
     this.modules.set(key, module);
     return module;
   }
+  /**
+   * Whether the type's shader or pipeline failed (0061). Callers then draw its batches with
+   * `proxy(material)` and the standard pipeline, so nothing using it disappears.
+   */
+  failing(type) {
+    if (this.failedTypes.size === 0) return false;
+    const f = this.failedTypes.get(type);
+    return f !== void 0 && f.version === type.version;
+  }
+  /** How many types draw through the standard fallback now. */
+  get failureCount() {
+    let n = 0;
+    for (const [type, f] of this.failedTypes) if (f.version === type.version) n++;
+    return n;
+  }
+  /** Types drawing through the standard fallback now, with why (for RenderHealth). */
+  failures() {
+    const out = [];
+    for (const [type, f] of this.failedTypes) {
+      if (f.version === type.version) out.push({ type: type.name, error: f.error });
+    }
+    return out;
+  }
+  /**
+   * A standard material standing in for one whose type failed: its standard fields when the type
+   * extends standard, else its `baseColor` or `color` if it has one. Kept per material and
+   * refreshed when the material changes.
+   */
+  proxy(material) {
+    const hit = this.proxies.get(material);
+    if (hit && hit.version === material.version) return hit.proxy;
+    const value = material.value;
+    const init = {};
+    if (material.type.standard) {
+      for (const k of Object.keys(STANDARD_FIELDS)) if (k in value) init[k] = value[k];
+    } else {
+      const color = value.baseColor ?? value.color;
+      if (isColor(color)) init.baseColor = color;
+    }
+    const proxy = hit?.proxy ?? new MaterialAsset(init);
+    if (hit) proxy.set(init);
+    this.proxies.set(material, { version: material.version, proxy });
+    return proxy;
+  }
   /** A compiled pipeline under `key` (unique per pass, type, and variant), if there is one. */
   cached(key) {
     return this.pipelines.get(key);
   }
+  /**
+   * Per (pass, sample count) slot of CPU-culled lists: the batch structure version and device
+   * generation whose pipelines were all asked for and compiled (forward's warmPipelines).
+   */
+  warm = /* @__PURE__ */ new Map();
+  warmed(slot, structure, generation) {
+    return this.warm.get(slot) === structure * 1024 + generation % 1024;
+  }
+  markWarmed(slot, structure, generation) {
+    this.warm.set(slot, structure * 1024 + generation % 1024);
+  }
   /** The last pipeline that compiled under each key, with the layout it was made for. */
   previous = /* @__PURE__ */ new Map();
   /**
@@ -141,8 +231,12 @@ class MaterialPipelines {
    * While a replacement compiles (an edited shader or noise graph), draws keep the previous one
    * for the key if its layout is the same object (the bind groups still fit), instead of vanishing.
    */
-  create(gpu, key, descriptor) {
+  create(gpu, key, descriptor, type) {
     const pipeline = gpu.pipelines.render(descriptor);
+    if (!pipeline && type && type.name !== "render/StandardMaterial") {
+      const error = gpu.pipelines.failure(descriptor);
+      if (error) this.failedTypes.set(type, { version: type.version, error });
+    }
     if (pipeline) {
       this.pipelines.set(key, pipeline);
       this.previous.set(key, { pipeline, layout: descriptor.layout, generation: gpu.generation });
@@ -155,6 +249,9 @@ class MaterialPipelines {
     return void 0;
   }
 }
+function isColor(value) {
+  return (Array.isArray(value) || value instanceof Float32Array) && (value.length === 3 || value.length === 4) && Array.prototype.every.call(value, (c) => typeof c === "number");
+}
 export {
   MaterialPipelines,
   blendState,

package/dist/materials.d.ts

@@ -28,12 +28,27 @@ export interface MaterialTypeOptions<F extends Fields> {
      * layer). Arrays of color textures sample through the sRGB view.
      */
     arrays?: readonly string[];
+    /**
+     * Texture fields that hold color (albedo, an atlas): sampled through the sRGB view, as
+     * `baseColorTexture` is. Other texture fields sample the stored values (the linear view).
+     */
+    colors?: readonly string[];
     /**
      * Standard extensions only: false leaves the standard material's five texture slots (and their
      * samplers) out of the layout, for types that build their own surface and need the room (a stage
      * holds 16 sampled textures). Its shader must then not call `standard_input`.
      */
     standardTextures?: boolean;
+    /**
+     * false: draws of this type aren't pick targets. A pick (GPU or raycast) goes through them to
+     * what's under: a grid's lines over the tiles they're drawn on (0059). Default true.
+     */
+    pickable?: boolean;
+    /**
+     * Where `shader` comes from when a plugin registers it, e.g. `surfacePlugin from
+     * '@aethervtt/shard-render/surface'`: a draw without it logs `render/feature-missing` naming it.
+     */
+    plugin?: string;
     description?: string;
 }
 /** A material type's noise slot: `noise_<name>` calls the graph at `path`. */
@@ -60,6 +75,12 @@ export declare class MaterialType {
     textures: string[];
     /** Texture fields bound as 2D arrays. */
     arrays: Set<string>;
+    /** Texture fields sampled through the sRGB view. */
+    colors: Set<string>;
+    /** Whether picks can hit draws of this type (MaterialTypeOptions.pickable). */
+    pickable: boolean;
+    /** The plugin that registers its shader (MaterialTypeOptions.plugin). */
+    plugin: string | undefined;
     blend: BlendMode | undefined;
     shader: string | undefined;
     /** Noise graphs the module wraps as `noise_<name>`. */
@@ -67,6 +88,8 @@ export declare class MaterialType {
     description: string;
     /** Increments on every redefinition, so GPU state and pipelines rebuild. */
     version: number;
+    /** Its definition as a string: defining the name again with an equal one is a no-op (0052). */
+    signature: string;
     readonly modulePath: string;
     /** WGSL identifier of the uniform (the PascalName). */
     readonly varName: string;