@aethervtt/shard-render 0.0.1 → 0.1.0

package/dist/assets.d.ts

@@ -12,6 +12,7 @@ export declare const StandardMaterial: import("@aethervtt/shard-core").Component
     emissive: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
     emissiveLuminance: import("@aethervtt/shard-core").FieldType<number, "f32">;
     doubleSided: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    deferUntilReady: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
     alphaMode: import("@aethervtt/shard-core").FieldType<"additive" | "alpha" | "mask" | "opaque" | "premultiplied", "u8">;
     alphaCutoff: import("@aethervtt/shard-core").FieldType<number, "f32">;
     normalScale: import("@aethervtt/shard-core").FieldType<number, "f32">;
@@ -94,6 +95,8 @@ export declare const Materials: import("@aethervtt/shard-core").ResourceDef<Asse
 export declare const RenderTargets: import("@aethervtt/shard-core").ResourceDef<AssetStore<RenderTarget, "RenderTarget">>;
 /** Meshes load from binary artifacts (`encodeMesh`); a reload updates the mesh in place. */
 export declare const MeshAsset: import("@aethervtt/shard-assets").AssetTypeDef<Mesh>;
+/** What a mesh that failed to load shows (0061): a 1 m beveled box, drawn with the missing material. */
+export declare function missingMesh(): Mesh;
 /** Materials load from material JSON (any type); a reload bumps the material's version. */
 export declare const MaterialAssetType: import("@aethervtt/shard-assets").AssetTypeDef<MaterialAsset>;
 /**

package/dist/assets.js

@@ -5,7 +5,7 @@ import {
   defineSchema,
   ShardError
 } from "@aethervtt/shard-core";
-import { decodeMesh } from "@aethervtt/shard-mesh";
+import { bevelBox, decodeMesh } from "@aethervtt/shard-mesh";
 import {
   allMaterialTypes,
   findMaterialType,
@@ -103,8 +103,20 @@ const RenderTargets = defineResource(
 const MeshAsset = defineAssetType("Mesh", {
   store: Meshes,
   load: (artifact) => decodeMesh(artifact.bytes),
-  update: (existing, next) => existing.update(next.data())
+  update: (existing, next) => existing.update(next.data()),
+  fallback: () => missingMesh(),
+  cost: (mesh) => ({ triangles: Math.floor(mesh.drawCount / 3), bytes: meshBytes(mesh) })
 });
+function missingMesh() {
+  const mesh = bevelBox({ x: 1, y: 1, z: 1 });
+  mesh.missing = true;
+  return mesh;
+}
+function meshBytes(mesh) {
+  let bytes = mesh.positions.byteLength + (mesh.indices?.byteLength ?? 0);
+  for (const a of [mesh.normals, mesh.uvs, mesh.uvs1, mesh.tangents]) bytes += a?.byteLength ?? 0;
+  return bytes;
+}
 const MaterialAssetType = defineAssetType("Material", {
   store: Materials,
   // Texture paths resolve to guids here, so the renderer can look them up directly.
@@ -115,6 +127,8 @@ const MaterialAssetType = defineAssetType("Material", {
     };
     const errors = validateMaterial(artifact.json, { resolveAsset });
     if (errors.length > 0) {
+      const color = readableBaseColor(artifact.json);
+      if (color) readableColors.set(ctx.guid, color);
       const first = errors[0];
       throw new ShardError("assets/load-failed", `${ctx.path}: ${first.message}`, {
         path: first.path,
@@ -127,8 +141,34 @@ const MaterialAssetType = defineAssetType("Material", {
   update: (existing, next) => {
     existing.type = next.type;
     existing.set(next.value);
+  },
+  references: (material) => handlesIn(material.value),
+  // A material that failed to load draws as the standard one, in its own base color if readable.
+  fallback: ({ guid }) => {
+    const baseColor = readableColors.get(guid);
+    readableColors.delete(guid);
+    return new MaterialAsset(baseColor ? { baseColor } : {});
   }
 });
+function* handlesIn(value) {
+  if (value === null || typeof value !== "object" || ArrayBuffer.isView(value)) return;
+  if (Array.isArray(value)) {
+    for (const v of value) yield* handlesIn(v);
+    return;
+  }
+  if (typeof value.guid === "string") yield value;
+  for (const v of Object.values(value)) yield* handlesIn(v);
+}
+const readableColors = /* @__PURE__ */ new Map();
+function readableBaseColor(json) {
+  const raw = json?.baseColor;
+  if (raw === void 0) return void 0;
+  try {
+    return [...StandardMaterial.deserialize({ baseColor: raw }).baseColor];
+  } catch {
+    return void 0;
+  }
+}
 const MaterialImporter = defineImporter({
   name: "data/material",
   version: 2,
@@ -209,5 +249,6 @@ export {
   materialFields,
   materialFromJson,
   materialTypeOf,
+  missingMesh,
   validateMaterial
 };

package/dist/atmosphere-nodes.d.ts

@@ -12,6 +12,11 @@ interface CameraGpu {
     transmittance: GPUTexture | undefined;
     /** The frame the sky-view and froxels were last computed. */
     computed: number;
+    /**
+     * Whether this frame's uniform holds the atmospheres (it's zeros until their LUTs exist): a bake
+     * waits for it, or the LUTs computed this frame would bake a black sky.
+     */
+    packed: boolean;
     generation: number;
     seen: number;
 }
@@ -34,6 +39,8 @@ export declare class AtmosphereGpu {
     frame: number;
     readonly pipelines: Map<string, GPUComputePipeline | GPURenderPipeline>;
     layouts: Record<string, GPUBindGroupLayout> | undefined;
+    /** The baseline tier's passes (0064): fragment passes, loaded only on a baseline device. */
+    baseline: typeof import('./baseline/atmosphere.js') | undefined;
     private readonly groups;
     ensure(gpu: GpuContext): void;
     /** A layer for a record: its own, a free one, or the least recently used. */
@@ -42,6 +49,8 @@ export declare class AtmosphereGpu {
     group(gpu: GpuContext, slot: string, key: string, layout: GPUBindGroupLayout, entries: () => GPUBindGroupEntry[]): GPUBindGroup;
 }
 export declare const AtmosphereGpuResource: import("@aethervtt/shard-core").ResourceDef<AtmosphereGpu>;
+/** Writes a record's parameters (and the camera's origin in it) at `o`. */
+export declare function packParams(rec: AtmosphereRecord, out: Float32Array, o: number, origin: Float64Array | undefined, oi: number): void;
 /**
  * Gives every listed atmosphere a LUT layer and uploads each camera's AtmosphereView uniform, and
  * its sky-view and froxel textures at the right sizes.

package/dist/atmosphere-nodes.js

@@ -6,10 +6,12 @@ import {
   Environments,
   environmentBakers
 } from "./environment.js";
+import { addRenderFeatures } from "./features.js";
 import { ForwardStateResource, sceneColor } from "./forward.js";
 import { RenderPhase } from "./graph.js";
 import { Gpu, Graph, Shaders, Views } from "./plugin.js";
 import { hasEffect, PostEffect } from "./post.js";
+import { bindingDimension, depthReadEntry } from "./tier.js";
 import { cameraOf } from "./view.js";
 const LUT_LAYERS = 8;
 const PARAMS_FLOATS = 32;
@@ -39,22 +41,26 @@ class AtmosphereGpu {
   frame = 0;
   pipelines = /* @__PURE__ */ new Map();
   layouts;
+  /** The baseline tier's passes (0064): fragment passes, loaded only on a baseline device. */
+  baseline;
   groups = /* @__PURE__ */ new Map();
   ensure(gpu) {
     if (this.generation === gpu.generation) return;
     this.generation = gpu.generation;
-    const usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_SRC;
+    const usage = GPUTextureUsage.TEXTURE_BINDING | written(gpu) | GPUTextureUsage.COPY_SRC;
     this.transmittance = gpu.device.createTexture({
       label: "atmosphere/transmittance",
       size: [TRANSMITTANCE_W, TRANSMITTANCE_H, LUT_LAYERS],
       format: "rgba16float",
-      usage
+      usage,
+      ...bindingDimension(gpu, "2d-array")
     });
     this.multiscatter = gpu.device.createTexture({
       label: "atmosphere/multiscatter",
       size: [MULTISCATTER_SIZE, MULTISCATTER_SIZE, LUT_LAYERS],
       format: "rgba16float",
-      usage
+      usage,
+      ...bindingDimension(gpu, "2d-array")
     });
     this.transmittanceArray = this.transmittance.createView({ dimension: "2d-array" });
     this.multiscatterArray = this.multiscatter.createView({ dimension: "2d-array" });
@@ -124,6 +130,7 @@ class AtmosphereGpu {
         scatter: void 0,
         transmittance: void 0,
         computed: -1,
+        packed: false,
         generation: gpu.generation,
         seen: 0
       };
@@ -141,6 +148,9 @@ class AtmosphereGpu {
     return g.group;
   }
 }
+function written(gpu) {
+  return gpu.tier === "full" ? GPUTextureUsage.STORAGE_BINDING : GPUTextureUsage.RENDER_ATTACHMENT;
+}
 const AtmosphereGpuResource = defineResource("render/AtmosphereGpu", {
   description: "Atmosphere LUTs, per-camera sky-view LUTs and froxels, and their pipelines.",
   init: () => new AtmosphereGpu()
@@ -194,6 +204,7 @@ function relativeInverse(cam, out) {
 }
 function packView(ca, cam, c, out) {
   out.fill(0);
+  c.packed = false;
   for (const rec of ca.list) if (rec.layerVersion < 0) return;
   const n = Math.min(ca.list.length, 4);
   for (let i = 0; i < n; i++) packParams(ca.list[i], out, i * PARAMS_FLOATS, ca.origins, i * 4);
@@ -219,6 +230,7 @@ function packView(ca, cam, c, out) {
   out[O_CAMERA + 1] = cam.position[1];
   out[O_CAMERA + 2] = cam.position[2];
   out[O_CAMERA + 3] = cam.exposure;
+  c.packed = true;
 }
 const uploadAtmospheres = defineSystem({
   name: "render/atmosphere-upload",
@@ -259,7 +271,7 @@ function ensureViewTextures(gpu, c, ca) {
       label: "atmosphere/sky-view",
       size: [sw, sh],
       format: "rgba16float",
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING
+      usage: GPUTextureUsage.TEXTURE_BINDING | written(gpu)
     });
   }
   const [fx, fy, fz] = ca.froxels;
@@ -271,7 +283,7 @@ function ensureViewTextures(gpu, c, ca) {
       size: [fx, fy, fz],
       dimension: "3d",
       format: "rgba16float",
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING
+      usage: GPUTextureUsage.TEXTURE_BINDING | written(gpu)
     };
     c.scatter = gpu.device.createTexture(desc);
     c.transmittance = gpu.device.createTexture({
@@ -309,7 +321,7 @@ function layouts(gpu, s) {
       viewDimension
     }
   });
-  s.layouts = {
+  const computeLayouts = gpu.tier === "full" ? {
     transmittance: gpu.layouts.bindGroupLayout({
       label: "atmosphere/transmittance",
       entries: [uniform(0, C), storage(1, "2d")]
@@ -335,13 +347,22 @@ function layouts(gpu, s) {
     }),
     bake: gpu.layouts.bindGroupLayout({
       label: "atmosphere/bake",
-      entries: [uniform(0, C), array(1, C), array(2, C), filtering(3, C), storage(4, "2d-array")]
-    }),
+      entries: [
+        uniform(0, C),
+        array(1, C),
+        array(2, C),
+        filtering(3, C),
+        storage(4, "2d-array")
+      ]
+    })
+  } : {};
+  s.layouts = {
+    ...computeLayouts,
     composite: gpu.layouts.bindGroupLayout({
       label: "atmosphere/composite",
       entries: [
         { binding: 0, visibility: F, texture: { sampleType: "unfilterable-float" } },
-        { binding: 1, visibility: F, texture: { sampleType: "depth" } },
+        depthReadEntry(gpu, 1, F),
         uniform(2, F),
         array(3, F),
         array(4, F),
@@ -404,6 +425,10 @@ function lutNode() {
         s.lutFrame = s.frame;
         return;
       }
+      if (s.baseline) {
+        if (s.baseline.runLuts(ctx, s)) s.lutFrame = s.frame;
+        return;
+      }
       const t = compute(ctx, s, "transmittance", "shard::atmosphere::transmittance_lut");
       const m = compute(ctx, s, "multiscatter", "shard::atmosphere::multiscatter_lut");
       if (!t || !m) return;
@@ -471,6 +496,16 @@ function viewNode() {
       const c = s.cameras.get(cam.entity);
       if (!c?.skyView || !c.scatter || !c.transmittance) return;
       if (ca.primary.layerVersion !== ca.primary.version) return;
+      if (s.baseline) {
+        const view = {
+          uniform: c.uniform,
+          skyView: c.skyView,
+          scatter: c.scatter,
+          transmittance: c.transmittance
+        };
+        if (s.baseline.runView(ctx, s, ca, view)) c.computed = s.frame;
+        return;
+      }
       const sky = compute(ctx, s, "skyView", "shard::atmosphere::sky_view");
       const aerial = compute(ctx, s, "aerial", "shard::atmosphere::aerial");
       if (!sky || !aerial) return;
@@ -534,19 +569,17 @@ function idOf(o) {
   }
   return id;
 }
-let empty;
 function emptyTextures(gpu) {
-  if (!empty || empty.generation !== gpu.generation) {
+  return gpu.shared("atmosphere/empty", (device) => {
     const usage = GPUTextureUsage.TEXTURE_BINDING;
-    empty = {
-      generation: gpu.generation,
-      d2: gpu.device.createTexture({
+    return {
+      d2: device.createTexture({
         label: "atmosphere/empty",
         size: [1, 1],
         format: "rgba16float",
         usage
       }),
-      d3: gpu.device.createTexture({
+      d3: device.createTexture({
         label: "atmosphere/empty-3d",
         size: [1, 1, 1],
         dimension: "3d",
@@ -554,8 +587,7 @@ function emptyTextures(gpu) {
         usage
       })
     };
-  }
-  return empty;
+  });
 }
 function skyNode() {
   const bgData = new Float32Array(8);
@@ -741,7 +773,7 @@ function bakeAtmosphere(ctx, pass, env, level0) {
   const primary = ca?.primary;
   if (!ca || !primary || primary.layerVersion !== primary.version) return false;
   const c = s.cameras.get(ca.camera);
-  if (!c) return false;
+  if (!c?.packed) return false;
   const pipeline = compute(ctx, s, "bake", "shard::atmosphere::bake");
   if (!pipeline) return false;
   const gpu = ctx.gpu;
@@ -766,6 +798,12 @@ function addAtmosphereNodes(world) {
   const graph = world.resource(Graph);
   world.initResource(AtmosphereGpuResource);
   environmentBakers.set("atmosphere", bakeAtmosphere);
+  addRenderFeatures(world, {
+    name: "render/atmosphere",
+    description: "Atmosphere scattering LUTs, sky-view and aerial-perspective froxels, sky, composite.",
+    nodes: ["atmosphere/luts", "atmosphere/view", "atmosphere/sky", "post/atmosphere"],
+    baseline: { strategy: "LUTs, sky-view and froxel slices as fragment passes" }
+  });
   graph.addNode("atmosphere/luts", lutNode());
   graph.addNode("atmosphere/view", viewNode());
   graph.addNode("atmosphere/sky", skyNode());
@@ -776,5 +814,6 @@ export {
   AtmosphereGpuResource,
   LUT_LAYERS,
   addAtmosphereNodes,
+  packParams,
   uploadAtmospheres
 };

package/dist/atmosphere-plugin.js

@@ -11,7 +11,7 @@ import { AtmosphereGpuResource, addAtmosphereNodes, uploadAtmospheres } from "./
 import { ATMOSPHERE_SHADERS } from "./atmosphere-shaders.js";
 import { Atmospheres } from "./atmosphere-state.js";
 import { extractLights } from "./lights.js";
-import { RenderDescribers, RenderSet, Shaders } from "./plugin.js";
+import { Gpu, RenderDescribers, RenderSet, Shaders } from "./plugin.js";
 import { registerShaders } from "./shaders.js";
 import { extractCameras } from "./view.js";
 const atmospherePlugin = definePlugin({
@@ -28,13 +28,19 @@ const atmospherePlugin = definePlugin({
     );
     app.addMethod(...atmosphereMethods);
   },
-  ready(app) {
+  async ready(app) {
+    const baseline = app.world.resource(Gpu).tier === "baseline" ? await import("./baseline/atmosphere.js") : void 0;
     registerShaders(app.world.resource(Shaders), ATMOSPHERE_SHADERS);
+    if (baseline) registerShaders(app.world.resource(Shaders), baseline.BASELINE_ATMOSPHERE_SHADERS);
     app.world.initResource(RenderDescribers).set(
       "atmosphere",
       (world) => describeAtmospheres(world, world.tryResource(ProfilerResource)?.all())
     );
     addAtmosphereNodes(app.world);
+    if (baseline) {
+      app.world.resource(AtmosphereGpuResource).baseline = baseline;
+      baseline.installAtmosphereBaseline();
+    }
   }
 });
 export {

package/dist/baseline/atmosphere.d.ts

@@ -0,0 +1,16 @@
+import { GpuBuffer } from '@aethervtt/shard-gpu';
+import { type AtmosphereGpu } from '../atmosphere-nodes.js';
+import type { CameraAtmosphere } from '../atmosphere-state.js';
+import type { NodeContext } from '../graph.js';
+export declare const BASELINE_ATMOSPHERE_SHADERS: Record<string, string>;
+/** The transmittance and multiple-scattering LUTs of every layer whose atmosphere changed. */
+export declare function runLuts(ctx: NodeContext, s: AtmosphereGpu): boolean;
+/** A camera's sky-view LUT and (with aerial perspective) its froxels, slice by slice. */
+export declare function runView(ctx: NodeContext, s: AtmosphereGpu, ca: CameraAtmosphere, c: {
+    uniform: GpuBuffer;
+    skyView: GPUTexture;
+    scatter: GPUTexture;
+    transmittance: GPUTexture;
+}): boolean;
+/** Registers the environment baker: atmosphere environments bake by fragment passes too. */
+export declare function installAtmosphereBaseline(): void;