@aethervtt/shard-render 0.0.1 → 0.1.0

package/dist/forward.js

@@ -1,4 +1,11 @@
-import { defineResource, defineSystem, Last, PostUpdate } from "@aethervtt/shard-core";
+import { assetServer } from "@aethervtt/shard-assets";
+import {
+  defineResource,
+  defineSystem,
+  Last,
+  PostUpdate,
+  PreUpdate
+} from "@aethervtt/shard-core";
 import { GpuBuffer } from "@aethervtt/shard-gpu";
 import { definePlugin, LogResource, Time } from "@aethervtt/shard-runtime";
 import { setTextureCapabilities, Textures } from "@aethervtt/shard-texture";
@@ -23,11 +30,15 @@ import {
   MAX_LIGHTS_PER_CLUSTER,
   ViewLightList
 } from "./clusters.js";
-import { Culler, cullTransparent, GpuCuller } from "./culling.js";
+import { Culler, cullGround, cullTransparent, GpuCuller } from "./culling.js";
+import { Cutaway, CutawayPath, CutawayView } from "./cutaway.js";
+import { DataStore, dataEntry } from "./data-store.js";
 import { addDisplayNodes } from "./display-nodes.js";
 import { Environments, environmentParams } from "./environment-state.js";
+import { addRenderFeatures } from "./features.js";
 import { GpuAssets, GpuAssetsResource } from "./gpu-assets.js";
 import { RenderPhase } from "./graph.js";
+import { clearHealthIssue, MaterialFallbacks, raiseHealthIssue } from "./health.js";
 import {
   DeformPath,
   InstanceData,
@@ -44,10 +55,14 @@ import {
   NotShadowReceiver,
   observeInstanceRemovals,
   prepareInstances,
+  ShadowWhenHidden,
   SkinnedMesh,
   VisibilityRange
 } from "./instances.js";
+import { INTERIOR_BINDINGS, InteriorPath } from "./interior.js";
 import { observeOriginShifts } from "./large-world.js";
+import { GroundLayer, RenderLayers } from "./layers.js";
+import { expireLensFields, Lens, LensFields, LensPath } from "./lens.js";
 import {
   AmbientLight,
   DirectionalLight,
@@ -69,8 +84,9 @@ import {
   variantCull
 } from "./material-pipelines.js";
 import { isTransparent } from "./materials.js";
+import { Outline, OutlinePath, observeOutlinesWithoutPass } from "./outline.js";
 import { PixelPerfect, PixelPerfectPath, PixelTargets } from "./pixel-perfect.js";
-import { Gpu, Graph, RenderSet, Shaders, Views } from "./plugin.js";
+import { Gpu, Graph, RenderDescribers, RenderSet, Shaders, Views } from "./plugin.js";
 import {
   Antialiasing,
   AutoExposure,
@@ -84,6 +100,13 @@ import {
   Vignette
 } from "./post.js";
 import { RenderScale } from "./render-scale.js";
+import {
+  describeScreenEffects,
+  expireScreenEffects,
+  runScreenEffects,
+  ScreenEffectHandlers,
+  ScreenEffects
+} from "./screen-effects.js";
 import { ViewUniform, viewLayout } from "./shaders.js";
 import {
   assignLocalShadows,
@@ -92,15 +115,20 @@ import {
   fitCascades,
   fitLocalShadows,
   LocalShadows,
+  markShadowDrawn,
   packShadowData,
   SHADOW_DATA_FLOATS,
   ShadowPassUniforms,
   ShadowsResource,
+  shadowRedraw,
   shadowViewLayout
 } from "./shadows.js";
 import { SkinAssetType, Skins } from "./skin-asset.js";
 import { GpuMemory, RenderCounters, RenderStats } from "./stats.js";
+import { bindingDimension } from "./tier.js";
+import { addShaderVariantSource, materialVariants, ShaderVariantSources } from "./variants.js";
 import {
+  CameraMoved,
   Cameras,
   cameraOf,
   DeferredPath,
@@ -109,6 +137,12 @@ import {
   Tonemapping,
   ViewSettings
 } from "./view.js";
+import {
+  HiddenSetsResource,
+  NO_HIDDEN,
+  observeViewVisibilityWithoutPlugin,
+  ViewVisibility
+} from "./view-visibility.js";
 import { ComputedVisibility, computeVisibility, Visibility } from "./visibility.js";
 const ForwardStateResource = defineResource("render/ForwardState");
 const State = ForwardStateResource;
@@ -161,7 +195,8 @@ const cameraCull = {
   lodScale: 1,
   orthographic: false,
   lodState: void 0,
-  updateLod: true
+  updateLod: true,
+  layers: 4294967295
 };
 const shadowCull = {
   planes: null,
@@ -170,19 +205,23 @@ const shadowCull = {
   lodScale: 1,
   orthographic: false,
   lodState: void 0,
-  updateLod: false
+  updateLod: false,
+  layers: 4294967295
 };
 function cameraParams(cam, out) {
   out.planes = cam.frozenFrustum ?? cam.frustum;
   out.eye = cam.frozenPosition ?? cam.position;
   out.orthographic = cam.orthographic;
+  out.layers = cam.layers;
+  out.hidden = cam.hidden?.bits;
+  out.hiddenBase = cam.hidden ? cam.hidden.base : NO_HIDDEN;
   out.lodScale = cam.orthographic ? 2 / cam.orthoHeight : 1 / Math.tan(cam.fovY / 2);
   if (cam.lodState.length < cam.lodCapacity)
     cam.lodState = new Uint8Array(cam.lodCapacity).fill(LOD_UNSET);
   out.lodState = cam.lodState;
   return out;
 }
-const queue = defineSystem({
+const forwardQueue = defineSystem({
   name: "render/forward-queue",
   description: "Culls instances per camera and shadow view (on the GPU when it can), clusters lights, and writes view uniforms.",
   run: (_, world) => {
@@ -197,7 +236,8 @@ const queue = defineSystem({
     stats.clear();
     state.frame++;
     ensureLayouts(gpu, state, world.resource(GpuAssetsResource), store);
-    state.pipelines.beginFrame(state.frame);
+    chooseInterior(gpu, world, state);
+    state.pipelines.beginFrame(state.frame, world.resource(Shaders).revision);
     shadows.uniforms.reset();
     culler.beginFrame();
     const gpuCull = culler.active;
@@ -219,8 +259,19 @@ const queue = defineSystem({
       if (gpuCull) {
         culler.add(store, cam.draws, params, culler.lodCamera(cam.entity), forwardOnly);
         cullTransparent(store, cam.transparent, params, cam.forward);
+        cullGround(store, cam.ground, params, cam.overlay);
       } else {
-        store.cullCpu(cam.draws, params, void 0, cam.transparent, cam.forward, forwardOnly);
+        store.cullCpu(
+          cam.draws,
+          params,
+          void 0,
+          cam.transparent,
+          cam.forward,
+          forwardOnly,
+          false,
+          cam.ground,
+          cam.overlay
+        );
       }
       store.orderNearFirst(cam.draws, cam.position);
       if (view.order < mainOrder) {
@@ -228,14 +279,18 @@ const queue = defineSystem({
         mainOrder = view.order;
       }
     }
-    const shadowParams = (cam, planes) => {
+    const shadowParams = (cam, planes, own) => {
       cameraParams(cam, shadowCull);
       shadowCull.planes = planes;
       shadowCull.updateLod = false;
+      if (!own || !cam.hidden?.shadows) {
+        shadowCull.hidden = void 0;
+        shadowCull.hiddenBase = NO_HIDDEN;
+      }
       return shadowCull;
     };
-    const cullShadow = (cam, draws, planes, box) => {
-      const params = shadowParams(cam, planes);
+    const cullShadow = (cam, draws, planes, box, own = false) => {
+      const params = shadowParams(cam, planes, own);
       if (gpuCull) {
         culler.add(store, draws, params, culler.lodCamera(cam.entity));
         if (box) store.casterBounds(box);
@@ -246,16 +301,19 @@ const queue = defineSystem({
     };
     const local = shadows.local;
     fitLocalShadows(local, settings.shadowMapSize);
+    store.checkMeshVersions();
     if (main) {
       for (let i = 0; i < local.spots.length; i++) {
         const view = local.spotViews[i];
         cullShadow(main, view.draws, view.frustum);
         view.offset = shadows.uniforms.push(view.viewProj);
+        view.redraw = shadowRedraw(view, local.spots[i]?.cachedShadow ?? false, store);
       }
       for (let i = 0; i < local.points.length * 6; i++) {
         const view = local.pointViews[i];
         cullShadow(main, view.draws, view.frustum);
         view.offset = shadows.uniforms.push(view.viewProj);
+        view.redraw = shadowRedraw(view, local.points[i / 6 | 0]?.cachedShadow ?? false, store);
       }
     }
     for (const view of world.resource(Views).list) {
@@ -264,7 +322,20 @@ const queue = defineSystem({
       const pv = viewGpu(gpu, state, view.name);
       pv.ao = void 0;
       pv.lightList.build(cam, lights.records, lights.high);
-      pv.clusters.upload(pv.lightList, cam, settings.clusterFar);
+      if (pv.clusters) pv.clusters.upload(pv.lightList, cam, settings.clusterFar);
+      else {
+        const b = pv.baseline;
+        state.baseline.binBaselineLights(
+          b,
+          pv.lightList,
+          lights.data,
+          cam,
+          settings.clusterFar,
+          settings.baselineMaxLights
+        );
+        if (b.dropped !== b.reported)
+          reportLightBudget(world, view.name, b, settings.baselineMaxLights);
+      }
       const sun = lights.shadowSun;
       if (sun) {
         fitCascades(
@@ -272,11 +343,12 @@ const queue = defineSystem({
           cam,
           sun,
           settings.cascadeMapSize,
-          (v, planes, box) => cullShadow(cam, v.draws, planes, box)
+          (v, planes, box) => cullShadow(cam, v.draws, planes, box, true)
         );
         for (let i = 0; i < pv.cascades.count; i++) {
           const v = pv.cascades.views[i];
           v.offset = shadows.uniforms.push(v.viewProj);
+          v.redraw = shadowRedraw(v, sun.cached, store);
         }
       } else {
         pv.cascades.count = 0;
@@ -302,8 +374,8 @@ const queue = defineSystem({
         st.visible += cam.forwardOnly.visible;
         st.drawCalls += cam.forwardOnly.cullView >= 0 ? culler.drawCounts.get(cam.forwardOnly) ?? 0 : cam.forwardOnly.length;
       }
-      st.visible += cam.transparent.visible;
-      st.drawCalls += cam.transparent.length;
+      st.visible += cam.transparent.visible + cam.ground.visible;
+      st.drawCalls += cam.transparent.length + cam.ground.length;
       stats.set(view.name, st);
     }
   }
@@ -318,10 +390,11 @@ function viewGpu(gpu, state, name) {
         size: viewLayout.size
       }),
       lightList: new ViewLightList(),
-      clusters: new ClusterBuffers(gpu, name),
-      shadowData: new GpuBuffer(gpu, {
+      clusters: state.baseline ? void 0 : new ClusterBuffers(gpu, name),
+      baseline: state.baseline?.baselineViewLights(gpu, name),
+      shadowData: new DataStore(gpu, {
         label: `${name}/shadows`,
-        usage: GPUBufferUsage.STORAGE,
+        kind: "uniform",
         size: SHADOW_DATA_FLOATS * 4
       }),
       cascades: new Cascades(),
@@ -351,6 +424,14 @@ const ambientScratch = new Float32Array(3);
 const envScratch = new Float32Array(4);
 const jitterScratch = new Float32Array(4);
 const noTransmittance = new Float32Array(16).fill(1);
+const pixelScaleScratch = new Float32Array(4);
+function viewPixelScale(cam, out) {
+  out[0] = cam.pixelRatio * cam.width / Math.max(1, cam.displayWidth);
+  out[1] = cam.orthographic ? cam.orthoHeight / Math.max(1, cam.height) : 2 * Math.tan(cam.fovY / 2) / Math.max(1, cam.height);
+  out[2] = cam.orthographic ? 1 : 0;
+  out[3] = 0;
+  return out;
+}
 function writeViewUniform(world, state, pv, cam, ambient, clusterFar) {
   environmentParams(world.resource(Environments), cam, envScratch);
   const [near, far] = clusterRange(cam, clusterFar);
@@ -381,7 +462,8 @@ function writeViewUniform(world, state, pv, cam, ambient, clusterFar) {
     viewProjNoJitter: cam.viewProjNoJitter,
     prevViewProj: cam.prevViewProj,
     jitter: jitterScratch,
-    sunTransmittance: world.tryResource(Atmospheres)?.cameras.get(cam.entity)?.sunTransmittance ?? noTransmittance
+    sunTransmittance: world.tryResource(Atmospheres)?.cameras.get(cam.entity)?.sunTransmittance ?? noTransmittance,
+    pixelScale: viewPixelScale(cam, pixelScaleScratch)
   });
   pv.uniform.write(new Float32Array(state.viewBytes.buffer, 0, viewLayout.size / 4));
 }
@@ -392,7 +474,7 @@ const upload = defineSystem({
     const store = world.resource(Instances);
     const culler = world.resource(Culler);
     if (culler.active) {
-      culler.prepare(store);
+      culler.prepare(store, world.tryResource(HiddenSetsResource));
       store.gpuVisible = culler.visible;
     }
     store.finishFrame();
@@ -408,15 +490,33 @@ const VERTEX_BUFFERS = [
   { arrayStride: 16, attributes: [{ shaderLocation: 4, offset: 0, format: "float32x4" }] }
 ];
 const FORWARD_DEFINES = [
-  { PREMULTIPLY: false, MASK: false },
-  { PREMULTIPLY: true, MASK: false },
-  { PREMULTIPLY: false, MASK: true },
-  { PREMULTIPLY: true, MASK: true }
+  { PREMULTIPLY: false, MASK: false, OPAQUE: false },
+  { PREMULTIPLY: true, MASK: false, OPAQUE: false },
+  { PREMULTIPLY: false, MASK: true, OPAQUE: false },
+  { PREMULTIPLY: true, MASK: true, OPAQUE: false },
+  { PREMULTIPLY: false, MASK: false, OPAQUE: true },
+  { PREMULTIPLY: true, MASK: false, OPAQUE: true },
+  { PREMULTIPLY: false, MASK: true, OPAQUE: true },
+  { PREMULTIPLY: true, MASK: true, OPAQUE: true }
 ];
-function materialLayout(gpu, state, assets, type, store) {
+const CUT_KEY = 2 ** 40;
+const INTERIOR_KEY = 2 ** 41;
+const CUTAWAY_DEFINES = FORWARD_DEFINES.map((d) => ({ ...d, CUTAWAY: true }));
+const INTERIOR_DEFINES = [
+  void 0,
+  { SKY_VISIBILITY: true },
+  { BLOCKED_LIGHTS: true },
+  { SKY_VISIBILITY: true, BLOCKED_LIGHTS: true }
+];
+const LIT_DEFINES = INTERIOR_DEFINES.map(
+  (extra) => [FORWARD_DEFINES, CUTAWAY_DEFINES].map(
+    (set) => extra ? set.map((d) => ({ ...d, ...extra })) : set
+  )
+);
+function materialLayout(gpu, state, assets, type, store, cut) {
   return gpu.layouts.pipelineLayout({
-    label: `forward/${type.name}`,
-    bindGroupLayouts: [state.layouts.view, assets.layoutOf(type), store.layout]
+    label: cut ? `forward/${type.name}/cutaway` : `forward/${type.name}`,
+    bindGroupLayouts: cut ? [state.layouts.view, assets.layoutOf(type), store.layout, cut] : [state.layouts.view, assets.layoutOf(type), store.layout]
   });
 }
 const PASS_OPAQUE = 0;
@@ -424,6 +524,11 @@ const PASS_TRANSPARENT = 1;
 const PASS_GBUFFER = 3;
 const PASS_PREPASS = 5;
 const PASS_PICK = 7;
+const PASS_GROUND = 9;
+const PASS_PICK_GROUND = 11;
+const PASS_DEPTH = 13;
+const GROUND_DEPTH_BIAS = 8;
+const GROUND_SLOPE_BIAS = 2;
 const PICK_TARGETS = [
   { format: "r32uint" },
   { format: "rgba32float" }
@@ -439,6 +544,9 @@ function drawMaterials(ctx, state, pv, cam, draws, pass) {
   const args = ctx.world.resource(Culler).args.buffer;
   renderPass.setBindGroup(0, viewBindGroup(gpu, ctx.world, pv, cam));
   renderPass.setBindGroup(2, instances);
+  const cutaway = ctx.world.tryResource(CutawayPath);
+  const cutGroup = cutaway?.bindGroup(gpu, cam.entity);
+  if (cutGroup) renderPass.setBindGroup(3, cutGroup);
   let current;
   let boundMaterial;
   let boundPositions;
@@ -447,52 +555,15 @@ function drawMaterials(ctx, state, pv, cam, draws, pass) {
   let switches = 0;
   for (let d = 0; d < draws.length; d++) {
     const item = draws.items[d];
-    const material = item.batch.material;
-    const type = material.type;
-    const variant = materialVariant(material);
-    const blend = variantBlend(variant);
-    const gbuffer = pass === PASS_GBUFFER;
-    const prepass = pass === PASS_PREPASS;
-    const pick = pass === PASS_PICK;
-    if (gbuffer && !type.standard) continue;
-    const msaa = gbuffer || prepass || pick ? 1 : cam.msaa;
-    const key = ((pass * 1024 + typeOrdinal(type)) * 16 + variant) * 8 + msaa;
-    let pipeline = state.pipelines.cached(key);
+    const own = item.batch.material;
+    if (!inPass(own.type, pass)) continue;
+    const cut = cutGroup !== void 0 && item.batch.cutaway > 0 && cutaway.cuts(cam.entity, item.batch.index) ? cutaway : void 0;
+    const fallback = state.pipelines.failing(own.type);
+    const material = fallback ? state.pipelines.proxy(own) : own;
+    const pipeline = materialPipeline(ctx, state, cam, store, assets, material, pass, true, cut);
     if (!pipeline) {
-      const premultiply = blend === "premultiplied";
-      const mask = blend === "mask";
-      const slot = pick ? 40 : prepass ? 32 + (type.standard ? 0 : 4) + (mask ? 2 : 0) : (gbuffer ? 16 : type.standard ? 0 : 4) + (premultiply ? 1 : 0) + (mask ? 2 : 0);
-      const module = state.pipelines.module(
-        ctx.world,
-        gpu,
-        type,
-        slot,
-        pick ? "shard::pick" : prepass ? type.standard ? "shard::prepass" : "shard::prepass::plain" : gbuffer ? "shard::pbr::gbuffer_pass" : type.standard ? "shard::pbr::forward" : "shard::unlit::forward",
-        FORWARD_DEFINES[slot & 3]
-      );
-      if (!module) {
-        gpu.pipelines.skipped++;
-        continue;
-      }
-      const transparent = isTransparent(blend) && !pick;
-      pipeline = state.pipelines.create(gpu, key, {
-        label: `${pick ? "pick" : prepass ? "prepass" : gbuffer ? "gbuffer" : "forward"}/${type.name}/${blend}/x${msaa}/${variantCull(variant)}`,
-        layout: materialLayout(gpu, state, assets, type, store),
-        vertex: { module, entryPoint: "vs", buffers: VERTEX_BUFFERS },
-        fragment: {
-          module,
-          entryPoint: "fs",
-          targets: pick ? PICK_TARGETS : prepass ? PREPASS_TARGETS : gbuffer ? state.gbufferTargets : [{ format: "rgba16float", blend: blendState(blend) }]
-        },
-        primitive: { topology: "triangle-list", cullMode: variantCull(variant), frontFace: "ccw" },
-        depthStencil: {
-          format: "depth32float",
-          depthWriteEnabled: !transparent,
-          depthCompare: transparent ? "greater-equal" : "greater"
-        },
-        multisample: { count: msaa }
-      });
-      if (!pipeline) continue;
+      if (!fallback && state.pipelines.failing(own.type)) d--;
+      continue;
     }
     const mat = assets.material(ctx.world, material);
     if (!mat?.bindGroup) continue;
@@ -529,14 +600,127 @@ function drawMaterials(ctx, state, pv, cam, draws, pass) {
       renderPass.draw(gm.count, item.count, 0, item.first);
     }
   }
+  if (draws.cullView < 0) warmPipelines(ctx, state, cam, store, assets, pass, cutGroup && cutaway);
   return switches;
 }
+function inPass(type, pass) {
+  if (pass === PASS_GBUFFER) return type.standard;
+  if (pass === PASS_PICK || pass === PASS_PICK_GROUND) return type.pickable;
+  return true;
+}
+function materialPipeline(ctx, state, cam, store, assets, material, pass, draw, cut) {
+  const gpu = ctx.gpu;
+  const type = material.type;
+  const variant = materialVariant(material);
+  const blend = variantBlend(variant);
+  const gbuffer = pass === PASS_GBUFFER;
+  const depthOnly = pass === PASS_DEPTH;
+  const prepass = pass === PASS_PREPASS || depthOnly;
+  const pick = pass === PASS_PICK || pass === PASS_PICK_GROUND;
+  const ground = pass === PASS_GROUND || pass === PASS_PICK_GROUND;
+  const msaa = gbuffer || prepass || pick ? 1 : cam.msaa;
+  const mode = gbuffer || prepass || pick ? 0 : state.interiorMode;
+  const key = ((pass * 1024 + typeOrdinal(type)) * 16 + variant) * 8 + msaa + (cut ? CUT_KEY : 0) + mode * INTERIOR_KEY;
+  let pipeline = state.pipelines.cached(key);
+  if (!pipeline) {
+    const premultiply = blend === "premultiplied";
+    const mask = blend === "mask";
+    const opaque = !gbuffer && !prepass && !pick && !isTransparent(blend);
+    const slot = (cut ? 64 : 0) + (pick ? 40 : prepass ? 32 + (type.standard ? 0 : 4) + (mask ? 2 : 0) : (gbuffer ? 16 : opaque ? 48 : 0) + (type.standard ? 0 : 4) + (premultiply ? 1 : 0) + (mask ? 2 : 0));
+    const module = state.pipelines.module(
+      ctx.world,
+      gpu,
+      type,
+      slot,
+      pick ? "shard::pick" : prepass ? type.standard ? "shard::prepass" : "shard::prepass::plain" : gbuffer ? "shard::pbr::gbuffer_pass" : type.standard ? "shard::pbr::forward" : "shard::unlit::forward",
+      // Only what the slot tells apart: the prepass and picking don't premultiply.
+      LIT_DEFINES[mode][cut ? 1 : 0][pick ? 0 : prepass ? mask ? 2 : 0 : (premultiply ? 1 : 0) | (mask ? 2 : 0) | (opaque ? 4 : 0)]
+    );
+    if (!module) {
+      if (draw && !state.pipelines.failing(type)) gpu.pipelines.skipped++;
+      return void 0;
+    }
+    const transparent = isTransparent(blend) && !pick;
+    pipeline = state.pipelines.create(
+      gpu,
+      key,
+      {
+        label: `${pick ? "pick" : prepass ? "prepass" : gbuffer ? "gbuffer" : ground ? "ground" : "forward"}/${type.name}/${blend}/x${msaa}/${variantCull(variant)}${cut ? "/cutaway" : ""}`,
+        layout: materialLayout(gpu, state, assets, type, store, cut?.layout(gpu)),
+        vertex: { module, entryPoint: "vs", buffers: VERTEX_BUFFERS },
+        fragment: {
+          module,
+          entryPoint: depthOnly ? "fs_depth" : "fs",
+          targets: pick ? PICK_TARGETS : depthOnly ? [] : prepass ? PREPASS_TARGETS : gbuffer ? state.gbufferTargets : [{ format: "rgba16float", blend: blendState(blend) }]
+        },
+        primitive: {
+          topology: "triangle-list",
+          cullMode: variantCull(variant),
+          frontFace: "ccw"
+        },
+        depthStencil: {
+          format: "depth32float",
+          // Ground bands never write depth (so they never fight); picking them writes it, so the
+          // nearest band wins at equal depth.
+          depthWriteEnabled: pick || !transparent && !ground,
+          depthCompare: transparent || ground ? "greater-equal" : "greater",
+          // Ground bands lie on their floor: a few ULPs and a slope term keep them in front of it
+          // at any angle (reversed Z: toward the camera). Bands don't write depth, so they never
+          // fight each other; the order does that.
+          depthBias: ground ? GROUND_DEPTH_BIAS : 0,
+          depthBiasSlopeScale: ground ? GROUND_SLOPE_BIAS : 0
+        },
+        multisample: { count: msaa }
+      },
+      type
+    );
+    if (!pipeline) return void 0;
+  }
+  return pipeline;
+}
+function warmPipelines(ctx, state, cam, store, assets, pass, cut) {
+  const slot = pass * 8 + cam.msaa + (cut ? CUT_KEY : 0) + state.interiorMode * INTERIOR_KEY;
+  if (state.pipelines.warmed(slot, store.structureVersion, ctx.gpu.generation)) return;
+  const ground = pass === PASS_GROUND || pass === PASS_PICK_GROUND;
+  const batches = store.batches;
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    if (batch.count === 0 || batch.ground !== ground) continue;
+    if (pass === PASS_TRANSPARENT ? !batch.transparent : batch.transparent && pass !== PASS_PICK) {
+      continue;
+    }
+    if (pass === PASS_OPAQUE && cam.deferred && batch.deferrable) continue;
+    const own = batch.material;
+    if (!inPass(own.type, pass)) continue;
+    const material = state.pipelines.failing(own.type) ? state.pipelines.proxy(own) : own;
+    materialPipeline(ctx, state, cam, store, assets, material, pass, false);
+    if (cut && batch.cutaway > 0)
+      materialPipeline(ctx, state, cam, store, assets, material, pass, false, cut);
+    assets.material(ctx.world, material);
+  }
+  if (ctx.gpu.pipelines.pending === 0) {
+    state.pipelines.markWarmed(slot, store.structureVersion, ctx.gpu.generation);
+  }
+}
 function recordSwitches(ctx, switches) {
   const stats = ctx.world.resource(RenderStats).get(ctx.view.name);
   if (stats) stats.pipelineSwitches = Math.max(stats.pipelineSwitches ?? 0, switches);
 }
 const isCamera = (view) => cameraOf(view) !== void 0;
 const msaaOf = (view) => cameraOf(view)?.msaa ?? 1;
+function reportLightBudget(world, view, b, max) {
+  b.reported = b.dropped;
+  if (b.dropped === 0) {
+    clearHealthIssue(world, "render/light-budget", view);
+    return;
+  }
+  raiseHealthIssue(world, {
+    code: "render/light-budget",
+    severity: "degraded",
+    ref: view,
+    message: `${b.inView} point and spot lights are in view, over the baseline tier's ${Math.min(max, 128)}: the ${b.dropped} farthest aren't shaded`
+  });
+}
 function whiteTexture(gpu, state) {
   if (!state.white || state.white.generation !== gpu.generation) {
     const texture = gpu.device.createTexture({
@@ -557,7 +741,8 @@ function emptyShadow(gpu, state) {
         label: "shadows/empty",
         size: [1, 1, 1],
         format: "depth32float",
-        usage: GPUTextureUsage.TEXTURE_BINDING
+        usage: GPUTextureUsage.TEXTURE_BINDING,
+        ...bindingDimension(gpu, "2d-array")
       }),
       generation: gpu.generation
     };
@@ -604,29 +789,35 @@ function viewBindGroup(gpu, world, pv, cam) {
   const source = baked?.sourceView ?? envs.emptyView;
   const sh = baked?.sh ?? envs.emptySh;
   const ao = pv.ao ?? whiteTexture(gpu, state);
-  const key = `${idOf(ao)}/${gpu.generation}/${pv.uniform.version}/${lights.buffer.version}/${pv.clusters.clusters.version}/${lights.directional.version}/${pv.shadowData.version}/${idOf(cascades)}/${idOf(spots)}/${idOf(points)}/${baked ? idOf(baked.source) : 0}/${sh.version}/${state.globals.version}`;
+  const b = pv.baseline;
+  const lightsVersion = b ? b.lights.version : lights.buffer.version;
+  const clustersVersion = b ? b.bits.version : pv.clusters.clusters.version;
+  const interior = state.interiorMode !== 0 ? world.tryResource(InteriorPath) : void 0;
+  const key = `${idOf(ao)}/${gpu.generation}/${pv.uniform.version}/${lightsVersion}/${clustersVersion}/${lights.directional.version}/${pv.shadowData.version}/${idOf(cascades)}/${idOf(spots)}/${idOf(points)}/${baked ? idOf(baked.source) : 0}/${sh.version}/${state.globals.version}${interior ? `/${state.interiorMode}/${interior.version}` : ""}`;
   if (!pv.bindGroup || pv.bound !== key) {
+    const entries = [
+      { binding: 0, resource: { buffer: pv.uniform.buffer } },
+      { binding: 1, resource: b ? b.lights.resource() : { buffer: lights.buffer.buffer } },
+      { binding: 2, resource: b ? b.bits.resource() : { buffer: pv.clusters.clusters.buffer } },
+      { binding: 3, resource: lights.directional.resource() },
+      { binding: 4, resource: pv.shadowData.resource() },
+      { binding: 5, resource: cascades.createView({ dimension: "2d-array" }) },
+      { binding: 6, resource: spots.createView({ dimension: "2d-array" }) },
+      { binding: 7, resource: points.createView({ dimension: "2d-array" }) },
+      { binding: 8, resource: state.shadowSampler },
+      { binding: 9, resource: specular },
+      { binding: 10, resource: envs.lut.createView() },
+      { binding: 11, resource: envs.sampler },
+      { binding: 12, resource: sh.resource() },
+      { binding: 13, resource: source },
+      { binding: 14, resource: { buffer: state.globals.buffer } },
+      { binding: 15, resource: ao.createView() }
+    ];
+    if (interior) entries.push(...interior.entries(gpu));
     pv.bindGroup = gpu.device.createBindGroup({
       label: "forward/view",
       layout: state.layouts.view,
-      entries: [
-        { binding: 0, resource: { buffer: pv.uniform.buffer } },
-        { binding: 1, resource: { buffer: lights.buffer.buffer } },
-        { binding: 2, resource: { buffer: pv.clusters.clusters.buffer } },
-        { binding: 3, resource: { buffer: lights.directional.buffer } },
-        { binding: 4, resource: { buffer: pv.shadowData.buffer } },
-        { binding: 5, resource: cascades.createView({ dimension: "2d-array" }) },
-        { binding: 6, resource: spots.createView({ dimension: "2d-array" }) },
-        { binding: 7, resource: points.createView({ dimension: "2d-array" }) },
-        { binding: 8, resource: state.shadowSampler },
-        { binding: 9, resource: specular },
-        { binding: 10, resource: envs.lut.createView() },
-        { binding: 11, resource: envs.sampler },
-        { binding: 12, resource: { buffer: sh.buffer } },
-        { binding: 13, resource: source },
-        { binding: 14, resource: { buffer: state.globals.buffer } },
-        { binding: 15, resource: ao.createView() }
-      ]
+      entries
     });
     pv.bound = key;
   }
@@ -649,6 +840,40 @@ function forwardNode(state) {
     }
   };
 }
+function groundNode(state) {
+  return {
+    kind: "render",
+    phase: RenderPhase.Ground,
+    enabled: (view) => (cameraOf(view)?.ground.length ?? 0) > 0,
+    reads: ["clusters", "shadow-cascades", "shadow-local", "environment", "culled", "ssao"],
+    writes: ["scene-color", "hdr"],
+    color: (view) => sceneColor(view),
+    depth: { resource: "scene-depth", readOnly: true },
+    run: (ctx) => {
+      const cam = cameraOf(ctx.view);
+      const pv = state.views.get(ctx.view.name);
+      if (!pv) return;
+      drawMaterials(ctx, state, pv, cam, cam.ground, PASS_GROUND);
+    }
+  };
+}
+function overlayNode(state) {
+  return {
+    kind: "render",
+    phase: RenderPhase.Overlay3d,
+    enabled: (view) => (cameraOf(view)?.overlay.length ?? 0) > 0,
+    reads: ["clusters", "shadow-cascades", "shadow-local", "environment", "culled", "ssao"],
+    writes: ["scene-color", "hdr"],
+    color: (view) => sceneColor(view),
+    depth: { resource: "scene-depth", readOnly: true },
+    run: (ctx) => {
+      const cam = cameraOf(ctx.view);
+      const pv = state.views.get(ctx.view.name);
+      if (!pv) return;
+      drawMaterials(ctx, state, pv, cam, cam.overlay, PASS_GROUND);
+    }
+  };
+}
 function transparentNode(state) {
   return {
     kind: "render",
@@ -670,11 +895,12 @@ function clusterNode(state) {
   return {
     kind: "raw",
     phase: RenderPhase.Setup,
-    enabled: isCamera,
+    // Baseline bins on the CPU (baseline/lights.ts): no compute.
+    enabled: (view) => isCamera(view) && !state.baseline,
     writes: ["clusters"],
     run: (ctx) => {
       const pv = state.views.get(ctx.view.name);
-      if (!pv) return;
+      if (!pv?.clusters) return;
       const gpu = ctx.gpu;
       const module = ctx.world.resource(Shaders).module(gpu, { root: "shard::lighting::cluster" });
       if (!module) {
@@ -732,6 +958,18 @@ function clusterNode(state) {
     }
   };
 }
+let skippedBefore = 0;
+function beginShadowView(ctx, view) {
+  if (!view.redraw && view.drawn) return false;
+  skippedBefore = ctx.gpu.pipelines.skipped;
+  ctx.world.resource(RenderStats).current.shadowMapsRendered++;
+  return true;
+}
+function endShadowView(ctx, view) {
+  if (ctx.gpu.pipelines.skipped === skippedBefore)
+    markShadowDrawn(view, ctx.world.resource(Instances));
+  else view.drawn = false;
+}
 function cascadeNode(state) {
   return {
     kind: "raw",
@@ -745,16 +983,19 @@ function cascadeNode(state) {
       const size = ctx.world.resource(LightingSettings).cascadeMapSize;
       const texture = pv.cascades.ensureTexture(ctx.gpu, size, ctx.view.name);
       for (let i = 0; i < pv.cascades.count; i++) {
+        const view = pv.cascades.views[i];
+        if (!beginShadowView(ctx, view)) continue;
         drawShadowCasters(
           ctx,
           texture.createView({ dimension: "2d", baseArrayLayer: i, arrayLayerCount: 1 }),
-          pv.cascades.views[i],
-          pv.cascades.views[i].offset,
+          view,
+          view.offset,
           shadows.uniforms,
           state.pipelines,
           state.layouts.shadowView,
           `shadows/cascade${i}`
         );
+        endShadowView(ctx, view);
       }
     }
   };
@@ -776,6 +1017,7 @@ function localShadowNode(state) {
       const layer = (texture, i) => texture.createView({ dimension: "2d", baseArrayLayer: i, arrayLayerCount: 1 });
       for (let i = 0; i < local.spots.length; i++) {
         const view = local.spotViews[i];
+        if (!beginShadowView(ctx, view)) continue;
         drawShadowCasters(
           ctx,
           layer(local.spotTexture, i),
@@ -786,9 +1028,11 @@ function localShadowNode(state) {
           state.layouts.shadowView,
           `shadows/spot${i}`
         );
+        endShadowView(ctx, view);
       }
       for (let i = 0; i < local.points.length * 6; i++) {
         const view = local.pointViews[i];
+        if (!beginShadowView(ctx, view)) continue;
         drawShadowCasters(
           ctx,
           layer(local.pointTexture, i),
@@ -799,6 +1043,7 @@ function localShadowNode(state) {
           state.layouts.shadowView,
           `shadows/point${i}`
         );
+        endShadowView(ctx, view);
       }
     }
   };
@@ -907,13 +1152,31 @@ function sceneColor(view, clear) {
   if (clear === void 0) return msaa ? MSAA_LOAD : PLAIN_LOAD;
   return [{ resource: "scene-color", clear, resolve: msaa ? "hdr" : void 0 }];
 }
-function depthResolveNode() {
+function depthPrepassNode(state) {
+  return {
+    kind: "render",
+    phase: RenderPhase.Prepass,
+    enabled: (view) => state.baseline !== void 0 && msaaOf(view) > 1,
+    reads: ["culled"],
+    writes: ["depth"],
+    depth: { resource: "depth", clear: 0 },
+    run: (ctx) => {
+      const pv = state.views.get(ctx.view.name);
+      const cam = cameraOf(ctx.view);
+      if (!pv || !cam) return;
+      drawMaterials(ctx, state, pv, cam, cam.draws, PASS_DEPTH);
+      if (cam.deferred) drawMaterials(ctx, state, pv, cam, cam.forwardOnly, PASS_DEPTH);
+    }
+  };
+}
+function depthResolveNode(state) {
   let bindGroups = /* @__PURE__ */ new WeakMap();
   let generation = -1;
   return {
     kind: "render",
     phase: RenderPhase.Resolve,
-    enabled: (view) => msaaOf(view) > 1,
+    // Baseline draws `depth` in its own prepass instead (depthPrepassNode).
+    enabled: (view) => state.baseline === void 0 && msaaOf(view) > 1,
     reads: ["scene-depth"],
     writes: ["depth"],
     depth: { resource: "depth", clear: 0 },
@@ -961,39 +1224,36 @@ function depthResolveNode() {
     }
   };
 }
-function createLayouts(gpu, assets, store) {
+function viewEntries(gpu) {
   const F = GPUShaderStage.FRAGMENT;
-  const storage = (binding) => ({
-    binding,
-    visibility: F,
-    buffer: { type: "read-only-storage" }
-  });
   const depthArray = (binding) => ({
     binding,
     visibility: F,
     texture: { sampleType: "depth", viewDimension: "2d-array" }
   });
-  const view = gpu.layouts.bindGroupLayout({
-    label: "forward/view",
-    entries: [
-      { binding: 0, visibility: GPUShaderStage.VERTEX | F, buffer: { type: "uniform" } },
-      storage(1),
-      storage(2),
-      storage(3),
-      storage(4),
-      depthArray(5),
-      depthArray(6),
-      depthArray(7),
-      { binding: 8, visibility: F, sampler: { type: "comparison" } },
-      { binding: 9, visibility: F, texture: { sampleType: "float", viewDimension: "cube" } },
-      { binding: 10, visibility: F, texture: { sampleType: "float" } },
-      { binding: 11, visibility: F, sampler: { type: "filtering" } },
-      storage(12),
-      { binding: 13, visibility: F, texture: { sampleType: "float", viewDimension: "cube" } },
-      { binding: 14, visibility: GPUShaderStage.VERTEX | F, buffer: { type: "uniform" } },
-      { binding: 15, visibility: F, texture: { sampleType: "float" } }
-    ]
-  });
+  return [
+    { binding: 0, visibility: GPUShaderStage.VERTEX | F, buffer: { type: "uniform" } },
+    // Storage on the full tier; on baseline (0064) lights, directional lights, shadow data and SH
+    // are uniform blocks and the cluster bits a data texture.
+    dataEntry(gpu, 1, F, "uniform"),
+    dataEntry(gpu, 2, F, "texture"),
+    dataEntry(gpu, 3, F, "uniform"),
+    dataEntry(gpu, 4, F, "uniform"),
+    depthArray(5),
+    depthArray(6),
+    depthArray(7),
+    { binding: 8, visibility: F, sampler: { type: "comparison" } },
+    { binding: 9, visibility: F, texture: { sampleType: "float", viewDimension: "cube" } },
+    { binding: 10, visibility: F, texture: { sampleType: "float" } },
+    { binding: 11, visibility: F, sampler: { type: "filtering" } },
+    dataEntry(gpu, 12, F, "uniform"),
+    { binding: 13, visibility: F, texture: { sampleType: "float", viewDimension: "cube" } },
+    { binding: 14, visibility: GPUShaderStage.VERTEX | F, buffer: { type: "uniform" } },
+    { binding: 15, visibility: F, texture: { sampleType: "float" } }
+  ];
+}
+function createLayouts(gpu, assets, store) {
+  const view = gpu.layouts.bindGroupLayout({ label: "forward/view", entries: viewEntries(gpu) });
   const C = GPUShaderStage.COMPUTE;
   const cluster = gpu.layouts.bindGroupLayout({
     label: "light-clusters",
@@ -1008,6 +1268,8 @@ function createLayouts(gpu, assets, store) {
   const shadowView = shadowViewLayout(gpu);
   return {
     view,
+    viewBase: view,
+    viewInterior: void 0,
     pipeline: gpu.layouts.pipelineLayout({
       label: "forward",
       bindGroupLayouts: [view, assets.materialLayout, store.layout]
@@ -1024,6 +1286,29 @@ function createLayouts(gpu, assets, store) {
     })
   };
 }
+function interiorViewLayout(gpu, state) {
+  const layouts = state.layouts;
+  if (layouts.viewInterior) return layouts.viewInterior;
+  const F = GPUShaderStage.FRAGMENT;
+  layouts.viewInterior = gpu.layouts.bindGroupLayout({
+    label: "forward/view/interior",
+    entries: [
+      ...viewEntries(gpu),
+      {
+        binding: INTERIOR_BINDINGS.data,
+        visibility: F,
+        texture: { sampleType: "uint", viewDimension: "2d-array" }
+      },
+      { binding: INTERIOR_BINDINGS.table, visibility: F, buffer: { type: "uniform" } }
+    ]
+  });
+  return layouts.viewInterior;
+}
+function chooseInterior(gpu, world, state) {
+  const mode = world.tryResource(InteriorPath)?.mode ?? 0;
+  state.interiorMode = mode;
+  state.layouts.view = mode !== 0 ? interiorViewLayout(gpu, state) : state.layouts.viewBase;
+}
 function ensureLayouts(gpu, state, assets, store) {
   if (state.layoutGeneration === gpu.generation) return;
   state.layoutGeneration = gpu.generation;
@@ -1039,6 +1324,7 @@ function forwardCorePlugin(options = {}) {
     provides: [
       // core
       Environments,
+      MaterialFallbacks,
       DeferredPath,
       DeformPath,
       PostFeatures,
@@ -1065,6 +1351,7 @@ function forwardCorePlugin(options = {}) {
       MorphWeights,
       NotShadowCaster,
       NotShadowReceiver,
+      ShadowWhenHidden,
       SkinnedMesh,
       VisibilityRange,
       AmbientLight,
@@ -1075,6 +1362,14 @@ function forwardCorePlugin(options = {}) {
       SpotLight,
       ComputedVisibility,
       Visibility,
+      // per-view visibility and cutaways (0070)
+      ViewVisibility,
+      HiddenSetsResource,
+      Cutaway,
+      CutawayView,
+      CutawayPath,
+      // interior lighting (0069)
+      InteriorPath,
       Cameras,
       RenderPath,
       Tonemapping,
@@ -1087,6 +1382,12 @@ function forwardCorePlugin(options = {}) {
       SkinAssetType,
       Skins,
       RenderScale,
+      // tabletop (0057)
+      GroundLayer,
+      RenderLayers,
+      Outline,
+      OutlinePath,
+      CameraMoved,
       // shadows
       ShadowsResource,
       // post
@@ -1102,11 +1403,21 @@ function forwardCorePlugin(options = {}) {
       // pixel-perfect
       PixelPerfect,
       PixelPerfectPath,
-      PixelTargets
+      PixelTargets,
+      // lens fields
+      Lens,
+      LensFields,
+      LensPath,
+      // screen effects
+      ScreenEffects,
+      ScreenEffectHandlers,
+      // shard shaders bake (0064)
+      ShaderVariantSources
     ],
     dependencies: ["render", "core/transform"],
     build(app) {
       const w = app.world;
+      addShaderVariantSource(w, materialVariants);
       w.initResource(Meshes);
       w.initResource(Skins);
       w.initResource(Materials);
@@ -1119,98 +1430,185 @@ function forwardCorePlugin(options = {}) {
       w.initResource(Environments);
       w.initResource(ViewSettings).msaa = options.msaa ?? 4;
       Object.assign(w.initResource(RenderScale), options.renderScale);
+      w.initResource(LensFields);
+      w.initResource(ScreenEffects);
+      w.initResource(ScreenEffectHandlers);
+      w.initResource(RenderDescribers).set("screenEffects", describeScreenEffects);
       observeInstanceRemovals(w);
+      observeOutlinesWithoutPass(w);
+      observeViewVisibilityWithoutPlugin(w);
       observeLightRemovals(w);
       observeOriginShifts(w);
-      app.addSystems(PostUpdate, computeVisibility.after(TransformSystems), applyPhysicalCameras).addSystems(
+      app.addSystems(PreUpdate, runScreenEffects).addSystems(PostUpdate, computeVisibility.after(TransformSystems), applyPhysicalCameras).addSystems(
         Last,
+        expireLensFields.inSet(RenderSet.Begin),
+        expireScreenEffects.inSet(RenderSet.Begin),
         extractCameras.inSet(RenderSet.Extract),
         extractLights.inSet(RenderSet.Extract),
         prepareInstances.inSet(RenderSet.Prepare),
         prepareLights.inSet(RenderSet.Prepare),
-        queue.inSet(RenderSet.Queue),
+        forwardQueue.inSet(RenderSet.Queue),
         upload.inSet(RenderSet.Upload)
       );
     },
-    ready(app) {
+    async ready(app) {
       const gpu = app.world.resource(Gpu);
-      setTextureCapabilities({
-        bc: gpu.features.has("texture-compression-bc"),
-        astc: gpu.features.has("texture-compression-astc"),
-        etc2: gpu.features.has("texture-compression-etc2")
-      });
-      const assets = new GpuAssets(gpu, app.world.initResource(GpuMemory));
-      const store = new InstanceStore(gpu);
-      app.insertResource(GpuAssetsResource, assets);
-      app.insertResource(Instances, store);
-      app.insertResource(Culler, new GpuCuller(gpu));
-      app.insertResource(
-        Lights,
-        new LightStore(gpu, app.world.resource(LightingSettings).maxLights)
-      );
-      app.insertResource(ShadowsResource, {
-        local: new LocalShadows(),
-        uniforms: new ShadowPassUniforms(gpu)
+      const [baseline, baselineTextures] = gpu.tier === "baseline" ? await Promise.all([import("./baseline/lights.js"), import("./baseline/textures.js")]) : [void 0, void 0];
+      app.scoped(() => {
+        setTextureCapabilities({
+          bc: gpu.features.has("texture-compression-bc"),
+          astc: gpu.features.has("texture-compression-astc"),
+          etc2: gpu.features.has("texture-compression-etc2")
+        });
+        const assets = new GpuAssets(gpu, app.world.initResource(GpuMemory));
+        if (baselineTextures) {
+          assets.baseline = baselineTextures;
+          app.world.initResource(RenderDescribers).set("twins", () => assets.describeTwins());
+        }
+        assets.counts = app.world.initResource(RenderStats).current;
+        const store = new InstanceStore(gpu);
+        app.insertResource(GpuAssetsResource, assets);
+        unwatch.set(app, assets.watch(assetServer(app.world)));
+        app.world.owners.addDescriber("gpu", (owner) => {
+          const server = assetServer(app.world);
+          const total = { buffers: 0, textures: 0, bytes: 0 };
+          for (const path of server.leasesOf(owner)) {
+            const item = server.item(path);
+            const o = assets.objectsOf(item);
+            total.buffers += o.buffers;
+            total.textures += o.textures;
+            total.bytes += o.bytes;
+          }
+          return total;
+        });
+        app.insertResource(Instances, store);
+        app.insertResource(Culler, new GpuCuller(gpu));
+        app.insertResource(
+          Lights,
+          new LightStore(gpu, app.world.resource(LightingSettings).maxLights)
+        );
+        app.insertResource(ShadowsResource, {
+          local: new LocalShadows(),
+          uniforms: new ShadowPassUniforms(gpu)
+        });
+        const state = {
+          views: /* @__PURE__ */ new Map(),
+          viewBytes: new DataView(new ArrayBuffer(viewLayout.size)),
+          shadowFloats: new Float32Array(SHADOW_DATA_FLOATS),
+          layouts: createLayouts(gpu, assets, store),
+          layoutGeneration: gpu.generation,
+          emptyShadow: void 0,
+          white: void 0,
+          shadowSampler: void 0,
+          frame: 0,
+          warned: { budget: "", overflow: "" },
+          globals: new GpuBuffer(gpu, {
+            label: "globals",
+            usage: GPUBufferUsage.UNIFORM,
+            size: 16
+          }),
+          globalsData: new Float32Array(4),
+          pipelines: new MaterialPipelines(),
+          baseline,
+          cullerActive: false,
+          interiorMode: 0,
+          gbufferTargets: [
+            { format: "rgba8unorm-srgb" },
+            { format: "rgba16float" },
+            { format: gbufferEmissiveFormat(gpu) }
+          ]
+        };
+        app.insertResource(MaterialFallbacks, {
+          count: () => state.pipelines.failureCount,
+          list: () => state.pipelines.failures()
+        });
+        store.batchKey = (b) => typeOrdinal(b.material.type) * 16 + materialVariant(b.material);
+        app.insertResource(State, state);
+        const graph = app.world.resource(Graph);
+        graph.declare({ name: "scene-color", format: "rgba16float", sampleCount: msaaOf });
+        graph.declare({ name: "scene-depth", format: "depth32float", sampleCount: msaaOf });
+        graph.declare({ name: "hdr", format: "rgba16float" });
+        graph.declare({ name: "depth", format: "depth32float" });
+        graph.declare({ name: "ldr", format: "view" });
+        addRenderFeatures(app.world, {
+          name: "render/forward",
+          description: "Opaque, ground and transparent mesh passes, and the MSAA depth resolve.",
+          nodes: [
+            "forward-opaque",
+            "forward-ground",
+            "forward-transparent",
+            "forward-overlay",
+            "depth-resolve",
+            "depth-prepass"
+          ],
+          baseline: {
+            strategy: "Instances, visibility and deform data in data textures; MSAA depth from a single-sample depth prepass"
+          }
+        });
+        addRenderFeatures(app.world, {
+          name: "render/culling",
+          description: "GPU frustum, range and LOD culling with indirect draws.",
+          nodes: ["instance-cull"],
+          baseline: { strategy: "CPU culling and direct draws" }
+        });
+        addRenderFeatures(app.world, {
+          name: "render/light-clusters",
+          description: "Clustered light binning (Forward+).",
+          nodes: ["light-clusters"],
+          baseline: { strategy: "CPU binning into a 128-light bitmask texture" }
+        });
+        addRenderFeatures(app.world, {
+          name: "render/shadows",
+          description: "Cascaded directional shadows, and spot and point shadow layers.",
+          nodes: ["shadows/cascades", "shadows/local"],
+          baseline: { strategy: "The same render passes" }
+        });
+        graph.addNode("instance-cull", cullNode(state));
+        graph.addNode("light-clusters", clusterNode(state));
+        graph.addNode("shadows/cascades", cascadeNode(state));
+        graph.addNode("shadows/local", localShadowNode(state));
+        graph.addNode("forward-opaque", forwardNode(state));
+        graph.addNode("forward-ground", groundNode(state));
+        graph.addNode("forward-overlay", overlayNode(state));
+        graph.addNode("forward-transparent", transparentNode(state));
+        graph.addNode("depth-resolve", depthResolveNode(state));
+        graph.addNode("depth-prepass", depthPrepassNode(state));
+        addDisplayNodes(app.world);
       });
-      const state = {
-        views: /* @__PURE__ */ new Map(),
-        viewBytes: new DataView(new ArrayBuffer(viewLayout.size)),
-        shadowFloats: new Float32Array(SHADOW_DATA_FLOATS),
-        layouts: createLayouts(gpu, assets, store),
-        layoutGeneration: gpu.generation,
-        emptyShadow: void 0,
-        white: void 0,
-        shadowSampler: void 0,
-        frame: 0,
-        warned: { budget: "", overflow: "" },
-        globals: new GpuBuffer(gpu, { label: "globals", usage: GPUBufferUsage.UNIFORM, size: 16 }),
-        globalsData: new Float32Array(4),
-        pipelines: new MaterialPipelines(),
-        cullerActive: false,
-        gbufferTargets: [
-          { format: "rgba8unorm-srgb" },
-          { format: "rgba16float" },
-          { format: gbufferEmissiveFormat(gpu) }
-        ]
-      };
-      store.batchKey = (b) => typeOrdinal(b.material.type) * 16 + materialVariant(b.material);
-      app.insertResource(State, state);
-      const graph = app.world.resource(Graph);
-      graph.declare({ name: "scene-color", format: "rgba16float", sampleCount: msaaOf });
-      graph.declare({ name: "scene-depth", format: "depth32float", sampleCount: msaaOf });
-      graph.declare({ name: "hdr", format: "rgba16float" });
-      graph.declare({ name: "depth", format: "depth32float" });
-      graph.declare({ name: "ldr", format: "view" });
-      graph.addNode("instance-cull", cullNode(state));
-      graph.addNode("light-clusters", clusterNode(state));
-      graph.addNode("shadows/cascades", cascadeNode(state));
-      graph.addNode("shadows/local", localShadowNode(state));
-      graph.addNode("forward-opaque", forwardNode(state));
-      graph.addNode("forward-transparent", transparentNode(state));
-      graph.addNode("depth-resolve", depthResolveNode());
-      addDisplayNodes(app.world);
+    },
+    dispose(app) {
+      unwatch.get(app)?.();
+      unwatch.delete(app);
     }
   });
 }
+const unwatch = /* @__PURE__ */ new WeakMap();
 function gbufferEmissiveFormat(gpu) {
   return gpu.features.has("rg11b10ufloat-renderable") ? "rg11b10ufloat" : "rgba16float";
 }
 export {
   ForwardStateResource,
+  INTERIOR_DEFINES,
   Mesh3d,
   MeshMaterial,
+  PASS_DEPTH,
   PASS_GBUFFER,
+  PASS_GROUND,
   PASS_OPAQUE,
   PASS_PICK,
+  PASS_PICK_GROUND,
   PASS_PREPASS,
   PASS_TRANSPARENT,
   PICK_TARGETS,
+  VERTEX_BUFFERS,
   drawMaterials,
   forwardCorePlugin,
+  forwardQueue,
   gbufferEmissiveFormat,
   isCamera,
   sceneColor,
   skyNode,
   upload,
-  viewBindGroup
+  viewBindGroup,
+  viewPixelScale
 };