@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/view-visibility-plugin.js

@@ -0,0 +1,267 @@
+import {
+  ChildOf,
+  Children,
+  defineSystem,
+  Last
+} from "@aethervtt/shard-core";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { Camera3d } from "./camera.js";
+import { addRenderFeatures } from "./features.js";
+import { InstanceSlot, Instances, prepareInstances } from "./instances.js";
+import { RenderDescribers, RenderSet } from "./plugin.js";
+import { Cameras } from "./view.js";
+import { HiddenSetsResource, ViewVisibility } from "./view-visibility.js";
+class HiddenSets {
+  /** Words per set: one bit per instance slot of the store's capacity. */
+  words = 0;
+  data = new Uint32Array(0);
+  sets = /* @__PURE__ */ new Map();
+  /** Free set indices, reused before growing. */
+  free = [];
+  count = 0;
+  dirty = new Uint8Array(0);
+  dirtyLo = Number.POSITIVE_INFINITY;
+  dirtyHi = -1;
+  /** Every word uploads next time (a new layout, buffer, region or device). */
+  all = true;
+  /** Where the last upload went: a buffer version (it bumps when replaced) and byte offset. */
+  target;
+  targetVersion = -1;
+  targetOffset = -1;
+  /** Bytes uploaded by the last `upload`. */
+  uploadedBytes = 0;
+  /** Resolves since start (tests: a still frame resolves nothing). */
+  resolves = 0;
+  /** The set of `camera`, made on first use. */
+  setOf(camera) {
+    let set = this.sets.get(camera);
+    if (set) return set;
+    const index = this.free.pop() ?? this.count++;
+    if (index * this.words + this.words > this.data.length) this.layout(this.words, index + 1);
+    const base = index * this.words;
+    set = {
+      camera,
+      base,
+      bits: this.data.subarray(base, base + this.words),
+      slots: 0,
+      hide: [],
+      shadows: false,
+      frame: -1
+    };
+    this.sets.set(camera, set);
+    return set;
+  }
+  /** Frees a set: its words clear (and upload, so a reused index starts empty). */
+  drop(set) {
+    for (let w = 0; w < set.bits.length; w++) if (set.bits[w] !== 0) this.write(set.base + w, 0);
+    this.sets.delete(set.camera);
+    this.free.push(set.base / Math.max(1, this.words));
+  }
+  /** Makes room for `capacity` slots per set; a new width re-lays every set and uploads all. */
+  ensureSlots(capacity) {
+    const words = Math.ceil(capacity / 32);
+    if (words > this.words) this.layout(words, this.count);
+  }
+  layout(words, sets) {
+    const data = new Uint32Array(words * Math.max(1, sets * 2));
+    for (const set of this.sets.values()) {
+      const index = set.base / Math.max(1, this.words);
+      data.set(set.bits, index * words);
+      set.base = index * words;
+    }
+    this.data = data;
+    for (const set of this.sets.values()) set.bits = data.subarray(set.base, set.base + words);
+    this.words = words;
+    this.dirty = new Uint8Array(data.length);
+    this.all = true;
+  }
+  write(word, value) {
+    if (this.data[word] === value) return;
+    this.data[word] = value;
+    if (this.dirty[word]) return;
+    this.dirty[word] = 1;
+    if (word < this.dirtyLo) this.dirtyLo = word;
+    if (word > this.dirtyHi) this.dirtyHi = word;
+  }
+  /**
+   * Writes a set's new bits (from `next`, `words` long), marking only words that differ. Returns
+   * whether any did.
+   */
+  assign(set, next2) {
+    let changed = false;
+    for (let w = 0; w < set.bits.length; w++) {
+      const value = next2[w];
+      if (set.bits[w] !== value) {
+        this.write(set.base + w, value);
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  /**
+   * Uploads changed words in runs to `buffer` at `byteOffset`; everything when that's not where
+   * the last upload went, or the buffer was replaced (grown, or a new device).
+   */
+  upload(buffer, byteOffset) {
+    buffer.ensureCapacity(byteOffset + this.data.byteLength);
+    void buffer.buffer;
+    if (buffer !== this.target || buffer.version !== this.targetVersion || byteOffset !== this.targetOffset) {
+      this.target = buffer;
+      this.targetVersion = buffer.version;
+      this.targetOffset = byteOffset;
+      this.all = true;
+    }
+    let bytes = 0;
+    if (this.all) {
+      this.all = false;
+      this.dirty.fill(0);
+      this.dirtyLo = Number.POSITIVE_INFINITY;
+      this.dirtyHi = -1;
+      if (this.data.length === 0) return 0;
+      buffer.write(this.data, byteOffset);
+      this.uploadedBytes = this.data.byteLength;
+      return this.uploadedBytes;
+    }
+    let start = -1;
+    for (let w = this.dirtyLo; w <= this.dirtyHi + 1; w++) {
+      if (w <= this.dirtyHi && this.dirty[w] === 1) {
+        this.dirty[w] = 0;
+        if (start < 0) start = w;
+      } else if (start >= 0) {
+        buffer.write(this.data, byteOffset + start * 4, start, w - start);
+        bytes += (w - start) * 4;
+        start = -1;
+      }
+    }
+    this.dirtyLo = Number.POSITIVE_INFINITY;
+    this.dirtyHi = -1;
+    this.uploadedBytes = bytes;
+    return bytes;
+  }
+}
+let next = new Uint32Array(0);
+const stack = [];
+function resolve(world, roots, out) {
+  out.fill(0);
+  let slots = 0;
+  stack.length = 0;
+  for (const e of roots) if (e !== null && e !== void 0) stack.push(e);
+  while (stack.length > 0) {
+    const e = stack.pop();
+    if (!world.isAlive(e)) continue;
+    const table = world.entityTable(e);
+    const row = world.entityRow(e);
+    if (table.has(InstanceSlot)) {
+      const slot = table.column(InstanceSlot, "slot")[row] - 1;
+      if (slot >= 0 && (out[slot >>> 5] & 1 << (slot & 31)) === 0) {
+        out[slot >>> 5] = out[slot >>> 5] | 1 << (slot & 31);
+        slots++;
+      }
+    }
+    if (table.has(Children)) {
+      const children = table.column(Children, "entities")[row];
+      if (children) {
+        for (const c of children) if (c !== null) stack.push(c);
+      }
+    }
+  }
+  return slots;
+}
+const resolveViewVisibility = defineSystem({
+  name: "render/resolve-view-visibility",
+  description: "Resolves cameras' ViewVisibility lists to hidden slot bitsets (0070).",
+  setup: (world) => ({
+    q: world.query({ with: [Camera3d, ViewVisibility] }),
+    hierarchy: world.query({ with: [ChildOf] }),
+    epoch: -1,
+    frame: 0
+  }),
+  run: (state, world, ctx) => {
+    const sets = world.tryResource(HiddenSetsResource);
+    if (!sets) return;
+    const cameras = world.resource(Cameras);
+    const store = world.resource(Instances);
+    const frame = ++state.frame;
+    let listed = 0;
+    for (const table of state.q.tables) listed += table.count;
+    if (listed === 0 && sets.sets.size === 0) return;
+    sets.ensureSlots(store.capacity);
+    if (next.length < sets.words) next = new Uint32Array(sets.words);
+    const since = ctx.lastRunTick;
+    let moved = store.slotEpoch !== state.epoch;
+    state.epoch = store.slotEpoch;
+    if (!moved) {
+      for (const table of state.hierarchy.tables) {
+        if (table.lastStructural > since || table.lastChanged(ChildOf) > since) {
+          moved = true;
+          break;
+        }
+      }
+    }
+    for (const table of state.q.tables) {
+      const hide = table.column(ViewVisibility, "hide");
+      const shadows = table.column(ViewVisibility, "shadows");
+      const changed = table.changedTicks(ViewVisibility);
+      for (let i = 0; i < table.count; i++) {
+        const camera = table.entities[i];
+        const fresh = !sets.sets.has(camera);
+        const set = sets.setOf(camera);
+        set.frame = frame;
+        const cam = cameras.get(camera);
+        if (cam) cam.hidden = set;
+        const hideShadows = shadows[i] === 1;
+        if (!fresh && !moved && changed[i] <= since && set.shadows === hideShadows) continue;
+        const list = hide[i] ?? [];
+        const words = next.subarray(0, sets.words);
+        set.slots = resolve(world, list, words);
+        set.hide = list.filter((e) => e !== null);
+        sets.resolves++;
+        if (sets.assign(set, words) && hideShadows || set.shadows !== hideShadows)
+          store.shadowEpoch++;
+        set.shadows = hideShadows;
+      }
+    }
+    if (sets.sets.size > listed) {
+      for (const set of sets.sets.values()) {
+        if (set.frame === frame) continue;
+        const cam = cameras.get(set.camera);
+        if (cam?.hidden === set) cam.hidden = void 0;
+        if (set.shadows) store.shadowEpoch++;
+        sets.drop(set);
+      }
+    }
+  }
+});
+function describeViewVisibility(world) {
+  const out = {};
+  for (const set of world.tryResource(HiddenSetsResource)?.sets.values() ?? [])
+    out[`camera:${set.camera}`] = {
+      hide: [...set.hide],
+      slots: set.slots,
+      shadows: set.shadows ? "hide" : "keep"
+    };
+  return out;
+}
+const viewVisibilityPlugin = definePlugin({
+  name: "render/view-visibility",
+  dependencies: ["render/forward"],
+  build(app) {
+    app.insertResource(HiddenSetsResource, new HiddenSets());
+    app.addSystems(Last, resolveViewVisibility.inSet(RenderSet.Prepare).after(prepareInstances));
+  },
+  ready(app) {
+    app.world.initResource(RenderDescribers).set("viewVisibility", describeViewVisibility);
+    addRenderFeatures(app.world, {
+      name: "render/view-visibility",
+      description: "Cameras' hidden lists (ViewVisibility).",
+      nodes: [],
+      baseline: { strategy: "CPU culls read the same bits" }
+    });
+  }
+});
+export {
+  HiddenSets,
+  describeViewVisibility,
+  resolveViewVisibility,
+  viewVisibilityPlugin
+};

package/dist/view-visibility.d.ts

@@ -0,0 +1,28 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import type { HiddenSets } from './view-visibility-plugin.js';
+export declare const VIEW_SHADOWS: readonly ['keep', 'hide'];
+export declare const ViewVisibility: import("@aethervtt/shard-core").ComponentDef<{
+    readonly hide: import("@aethervtt/shard-core").FieldType<(number | null)[], "object">;
+    readonly shadows: import("@aethervtt/shard-core").FieldType<"hide" | "keep", "u8">;
+}>;
+/** `hiddenBase` of a view with no hidden set. */
+export declare const NO_HIDDEN = 4294967295;
+/** One camera's hidden set: a bit per instance slot, in its range of `HiddenSets.data`. */
+export interface HiddenSet {
+    camera: Entity;
+    /** Its first word in `HiddenSets.data` (and the GPU buffer). */
+    base: number;
+    /** Its words: bit `s & 31` of word `s >> 5` is slot `s`. */
+    bits: Uint32Array;
+    /** Slots it resolves to. */
+    slots: number;
+    /** The entities listed, as last resolved. */
+    hide: Entity[];
+    /** Its camera's cascades leave the slots out too. */
+    shadows: boolean;
+    /** The frame it was last seen on (sets of cameras that lose the component are freed). */
+    frame: number;
+}
+export declare const HiddenSetsResource: import("@aethervtt/shard-core").ResourceDef<HiddenSets>;
+/** Warns once per world about a ViewVisibility without its plugin (render/feature-missing). */
+export declare function observeViewVisibilityWithoutPlugin(world: World): void;

package/dist/view-visibility.js

@@ -0,0 +1,46 @@
+import {
+  defineComponent,
+  defineResource,
+  onAdd,
+  t
+} from "@aethervtt/shard-core";
+import { Camera3d } from "./camera.js";
+import { warnFeatureMissing } from "./features.js";
+const VIEW_SHADOWS = ["keep", "hide"];
+const ViewVisibility = defineComponent(
+  "render/ViewVisibility",
+  {
+    hide: t.list(t.entity, {
+      description: "Entities this camera doesn't draw, with their descendants."
+    }),
+    shadows: t.enum(VIEW_SHADOWS, {
+      description: "keep: they still cast into this camera's shadows (a body its own camera doesn't draw). hide: its cascades leave them out too. Spot and point shadow maps are shared by every camera and always keep them."
+    })
+  },
+  {
+    description: "Hides entities from one camera (0070): other cameras still draw them. For a first-person body, split-screen markers, or a game master previewing a player view.",
+    requires: [Camera3d]
+  }
+);
+const NO_HIDDEN = 4294967295;
+const HiddenSetsResource = defineResource("render/HiddenSets", {
+  description: "Each camera's hidden slots (ViewVisibility, 0070), as the culls read them."
+});
+function observeViewVisibilityWithoutPlugin(world) {
+  world.observe(onAdd(ViewVisibility), ({ world: w }) => {
+    if (!w.hasResource(HiddenSetsResource))
+      warnFeatureMissing(
+        w,
+        "A camera has ViewVisibility",
+        "viewVisibilityPlugin",
+        "it hides nothing"
+      );
+  });
+}
+export {
+  HiddenSetsResource,
+  NO_HIDDEN,
+  VIEW_SHADOWS,
+  ViewVisibility,
+  observeViewVisibilityWithoutPlugin
+};

package/dist/view.d.ts

@@ -3,6 +3,7 @@ import type { RenderView } from './graph.js';
 import { type DrawList } from './instances.js';
 import { type PixelPerfectLayout } from './pixel-perfect.js';
 import { type PostSettings } from './post.js';
+import type { HiddenSet } from './view-visibility.js';
 export declare const TONEMAP_CURVES: readonly ['aces', 'agx', 'pbr-neutral', 'reinhard', 'none'];
 export type TonemapCurve = (typeof TONEMAP_CURVES)[number];
 /** The curve for cameras without a Tonemapping component. */
@@ -56,9 +57,17 @@ export interface CameraData {
     /** Scene luminance → pre-exposed HDR. */
     exposure: number;
     ev100: number;
-    /** Linear clear color, as displayed before the tonemap curve. */
+    /** Linear clear color, as displayed before the tonemap curve, premultiplied by its alpha. */
     clear: GPUColor;
+    /**
+     * Clears to an alpha below 1 (0052): the passes carry alpha to the target, the sky and the
+     * environment background aren't drawn, and light raises alpha, so the view composites over
+     * whatever is under its surface.
+     */
+    alphaOutput: boolean;
     msaa: number;
+    /** MSAA was asked for, but the device can't multisample HDR targets (0064): `msaa` is 1. */
+    msaaCapped: boolean;
     curve: number;
     dither: boolean;
     /** Culled draws of this camera, rebuilt each frame. */
@@ -67,6 +76,14 @@ export interface CameraData {
     transparent: DrawList;
     /** Deferred views: opaque draws the G-buffer can't take (custom lighting), drawn forward. */
     forwardOnly: DrawList;
+    /** Ground draws (0057): coplanar bands in (band, order) order, after opaque geometry. */
+    ground: DrawList;
+    /** Ground draws from the overlay band up: after transparent objects and projected fog (0058). */
+    overlay: DrawList;
+    /** Render layers this camera draws (Camera3d.layers). */
+    layers: number;
+    /** Slots it doesn't draw (ViewVisibility, 0070), while it has the component. */
+    hidden: HiddenSet | undefined;
     /** Renders through the G-buffer (RenderPath deferred). */
     deferred: boolean;
     /** G-buffer channel to show for a capture (-1: none), also forcing a G-buffer in forward views. */
@@ -85,7 +102,18 @@ export interface CameraData {
     post: PostSettings;
     /** Set for PixelPerfect cameras: the low-resolution target and how it scales up. */
     pixelPerfect: PixelPerfectLayout | undefined;
+    /** The display size and pixel ratio the last CameraMoved was sent for. */
+    movedWidth: number;
+    movedHeight: number;
+    movedRatio: number;
 }
+/**
+ * Sent after extraction, once per camera whose projection moved this frame (its unjittered view-
+ * projection, display size or pixel ratio changed), and on its first frame (0057).
+ */
+export declare const CameraMoved: import("@aethervtt/shard-core").EventDef<{
+    camera: Entity;
+}>;
 export declare const Cameras: import("@aethervtt/shard-core").ResourceDef<Map<number, CameraData>>;
 /** Global render settings the camera extraction applies to every view. */
 export interface ViewSettingsValue {

package/dist/view.js

@@ -1,6 +1,7 @@
 import {
   affine,
   defineComponent,
+  defineEvent,
   defineResource,
   defineSystem,
   frustum,
@@ -12,13 +13,15 @@ import { LogResource, Time } from "@aethervtt/shard-runtime";
 import { GlobalTransform } from "@aethervtt/shard-transform";
 import { RenderTargets } from "./assets.js";
 import { Camera3d, Exposure, exposureScale } from "./camera.js";
+import { warnFeatureMissing } from "./features.js";
 import { createDrawList } from "./instances.js";
+import { Lens, LensPath } from "./lens.js";
 import {
   PixelPerfect,
   PixelPerfectPath,
   pixelPerfectLayout
 } from "./pixel-perfect.js";
-import { Views, Window } from "./plugin.js";
+import { Gpu, Views, Window } from "./plugin.js";
 import {
   antialiasingOf,
   CORE_EFFECTS,
@@ -58,13 +61,21 @@ const RenderPath = defineComponent(
 const DeferredPath = defineResource("render/DeferredPath", {
   description: "Present when the deferred path (deferredPlugin) is installed."
 });
+const CameraMoved = defineEvent("render/CameraMoved", {
+  description: "A camera moved or its view resized: DOM overlays following the scene reposition."
+});
+function sameMatrix(a, b) {
+  for (let i = 0; i < 16; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
 const Cameras = defineResource("render/Cameras", {
   description: "Per-camera render data by entity, extracted each frame.",
   init: () => /* @__PURE__ */ new Map()
 });
 const ViewSettings = defineResource("render/ViewSettings", {
   description: "Render settings shared by all views: the default MSAA sample count, and the display density past which it is skipped.",
-  init: () => ({ msaa: 4, msaaMaxPixelRatio: 1.5 })
+  init: () => ({ msaa: 4, msaaMaxPixelRatio: 1.5 }),
+  hostWritable: true
 });
 const scratchProj = mat4.create();
 const scratchSnap = affine.create();
@@ -90,32 +101,6 @@ function viewAliases(cam) {
   return cam.msaa > 1 ? MSAA_ALIASES : NO_MSAA_ALIASES;
 }
 const reportedEffects = /* @__PURE__ */ new WeakMap();
-const reportedDeferred = /* @__PURE__ */ new WeakSet();
-function warnMissingDeferred(world) {
-  if (reportedDeferred.has(world)) return;
-  reportedDeferred.add(world);
-  world.tryResource(LogResource)?.log(
-    "warn",
-    "A camera asks for RenderPath deferred, but deferredPlugin isn't installed; it renders forward",
-    {
-      code: "render/feature-missing",
-      hint: "Add deferredPlugin from '@aethervtt/shard-render' (forwardPlugin includes it)."
-    }
-  );
-}
-const reportedPixel = /* @__PURE__ */ new WeakSet();
-function warnMissingPixelPerfect(world) {
-  if (reportedPixel.has(world)) return;
-  reportedPixel.add(world);
-  world.tryResource(LogResource)?.log(
-    "warn",
-    "A camera has PixelPerfect, but pixelPerfectPlugin isn't installed; it renders at full resolution",
-    {
-      code: "render/feature-missing",
-      hint: "Add pixelPerfectPlugin from '@aethervtt/shard-render' (forwardPlugin includes it)."
-    }
-  );
-}
 function warnMissingEffects(world, missing) {
   const reported = reportedEffects.get(world) ?? 0;
   const fresh = missing & ~reported;
@@ -148,6 +133,8 @@ const extractCameras = defineSystem({
     const installed = world.tryResource(PostFeatures)?.effects ?? CORE_EFFECTS;
     const deferredInstalled = world.hasResource(DeferredPath);
     const pixelInstalled = world.hasResource(PixelPerfectPath);
+    const lensInstalled = world.hasResource(LensPath);
+    const maxSamples = world.resource(Gpu).capabilities.hdrSampleCount;
     for (const table of q.tables) {
       const projection = table.column(Camera3d, "projection");
       const fovY = table.column(Camera3d, "fovY");
@@ -158,13 +145,22 @@ const extractCameras = defineSystem({
       const clear = table.column(Camera3d, "clearColor");
       const target = table.column(Camera3d, "target");
       const active = table.column(Camera3d, "active");
+      const layers = table.column(Camera3d, "layers");
       const g = table.column(GlobalTransform, "matrix");
       const ev = table.column(Exposure, "ev100");
       const path = table.has(RenderPath) ? table.column(RenderPath, "mode") : void 0;
       const hasTonemap = table.has(Tonemapping);
       const curve = hasTonemap ? table.column(Tonemapping, "curve") : void 0;
       const dither = hasTonemap ? table.column(Tonemapping, "dither") : void 0;
-      if (table.has(PixelPerfect) && !pixelInstalled) warnMissingPixelPerfect(world);
+      if (table.has(PixelPerfect) && !pixelInstalled)
+        warnFeatureMissing(
+          world,
+          "A camera has PixelPerfect",
+          "pixelPerfectPlugin",
+          "it renders at full resolution"
+        );
+      if (table.has(Lens) && !lensInstalled)
+        warnFeatureMissing(world, "A camera has Lens", "lensPlugin", "it renders unbent");
       const pixel = pixelInstalled && table.has(PixelPerfect);
       const ppu = pixel ? table.column(PixelPerfect, "pixelsPerUnit") : void 0;
       const snap = pixel ? table.column(PixelPerfect, "snap") : void 0;
@@ -205,12 +201,18 @@ const extractCameras = defineSystem({
             exposure: 1,
             ev100: 0,
             clear: { r: 0, g: 0, b: 0, a: 1 },
+            alphaOutput: false,
             msaa: 1,
+            msaaCapped: false,
             curve: 1,
             dither: true,
             draws: createDrawList(),
             transparent: createDrawList(),
             forwardOnly: createDrawList(),
+            ground: createDrawList(),
+            overlay: createDrawList(),
+            layers: 4294967295,
+            hidden: void 0,
             deferred: false,
             gbufferDebug: -1,
             lodState: new Uint8Array(0),
@@ -220,11 +222,15 @@ const extractCameras = defineSystem({
             frames: 0,
             debug: 0,
             post: createPostSettings(),
-            pixelPerfect: void 0
+            pixelPerfect: void 0,
+            movedWidth: 0,
+            movedHeight: 0,
+            movedRatio: 0
           };
           cameras.set(entity, cam);
         }
         cam.orthographic = projection[i] !== 0;
+        cam.layers = layers[i];
         let height = orthoHeight[i];
         cam.pixelPerfect = void 0;
         if (ppu && cam.orthographic) {
@@ -258,7 +264,13 @@ const extractCameras = defineSystem({
         }
         const wantsDeferred = path ? path[i] === 1 : false;
         cam.deferred = wantsDeferred && deferredInstalled;
-        if (wantsDeferred && !deferredInstalled) warnMissingDeferred(world);
+        if (wantsDeferred && !deferredInstalled)
+          warnFeatureMissing(
+            world,
+            "A camera asks for RenderPath deferred",
+            "deferredPlugin",
+            "it renders forward"
+          );
         const missing = extractPost(table, i, cam, delta, true, installed);
         if (missing !== 0) warnMissingEffects(world, missing);
         const world_ = g.subarray(i * 12, i * 12 + 12);
@@ -275,6 +287,12 @@ const extractCameras = defineSystem({
         if (cam.frames > 0) mat4.copy(cam.prevViewProj, cam.viewProjNoJitter);
         mat4.multiply(cam.viewProjNoJitter, scratchProj, cam.view);
         if (cam.frames === 0) mat4.copy(cam.prevViewProj, cam.viewProjNoJitter);
+        if (cam.frames === 0 || !sameMatrix(cam.viewProjNoJitter, cam.prevViewProj) || cam.displayWidth !== cam.movedWidth || cam.displayHeight !== cam.movedHeight || cam.pixelRatio !== cam.movedRatio) {
+          cam.movedWidth = cam.displayWidth;
+          cam.movedHeight = cam.displayHeight;
+          cam.movedRatio = cam.pixelRatio;
+          world.send(CameraMoved, { camera: entity });
+        }
         const jitter = cam.post.jitter;
         if (cam.post.effects & PostEffect.Taa) {
           const k = cam.frames % 8 + 1;
@@ -309,10 +327,14 @@ const extractCameras = defineSystem({
         cam.ev100 = ev[i];
         cam.exposure = exposureScale(ev[i]);
         const c = i * 4;
-        cam.clear = { r: clear[c], g: clear[c + 1], b: clear[c + 2], a: clear[c + 3] };
+        const ca = Math.min(1, Math.max(0, clear[c + 3]));
+        cam.clear = { r: clear[c] * ca, g: clear[c + 1] * ca, b: clear[c + 2] * ca, a: ca };
+        cam.alphaOutput = ca < 1;
         const aa = antialiasingOf(table, i);
         const dense = settings.msaaMaxPixelRatio > 0 && cam.pixelRatio >= settings.msaaMaxPixelRatio;
-        cam.msaa = cam.deferred ? 1 : aa < 0 ? dense ? 1 : settings.msaa : aa === 3 ? 4 : 1;
+        const msaa = cam.deferred ? 1 : aa < 0 ? dense ? 1 : settings.msaa : aa === 3 ? 4 : 1;
+        cam.msaa = Math.min(msaa, maxSamples);
+        cam.msaaCapped = cam.msaa < msaa;
         cam.curve = curve ? curve[i] : TONEMAP_CURVES.indexOf(DEFAULT_CURVE);
         cam.dither = dither ? dither[i] !== 0 : true;
         cam.frames++;
@@ -333,7 +355,7 @@ const extractCameras = defineSystem({
             name: `pixel-perfect:${entity}`,
             target: shown,
             order: order[i] + 0.5,
-            data: { upscale: cam.pixelPerfect }
+            data: { upscale: cam.pixelPerfect, alphaOutput: cam.alphaOutput }
           });
         }
       }
@@ -374,6 +396,7 @@ function cameraOf(view) {
   return view.data.camera;
 }
 export {
+  CameraMoved,
   Cameras,
   DEFAULT_CURVE,
   DeferredPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aethervtt/shard-render",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -9,6 +9,14 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./crowd": {
+      "types": "./dist/crowd.d.ts",
+      "default": "./dist/crowd.js"
+    },
+    "./post-scene": {
+      "types": "./dist/post-scene.d.ts",
+      "default": "./dist/post-scene.js"
+    },
     "./testing": {
       "types": "./dist/testing.d.ts",
       "default": "./dist/testing.js"
@@ -16,6 +24,10 @@
     "./noise": {
       "types": "./dist/noise.d.ts",
       "default": "./dist/noise.js"
+    },
+    "./surface": {
+      "types": "./dist/surface.d.ts",
+      "default": "./dist/surface.js"
     }
   },
   "files": [
@@ -24,15 +36,15 @@
     "README.md"
   ],
   "dependencies": {
-    "@aethervtt/shard-assets": "0.0.1",
-    "@aethervtt/shard-core": "0.0.1",
-    "@aethervtt/shard-gpu": "0.0.1",
-    "@aethervtt/shard-mesh": "0.0.1",
-    "@aethervtt/shard-noise": "0.0.1",
-    "@aethervtt/shard-runtime": "0.0.1",
-    "@aethervtt/shard-shader": "0.0.1",
-    "@aethervtt/shard-texture": "0.0.1",
-    "@aethervtt/shard-transform": "0.0.1"
+    "@aethervtt/shard-assets": "0.2.0",
+    "@aethervtt/shard-core": "0.2.0",
+    "@aethervtt/shard-gpu": "0.2.0",
+    "@aethervtt/shard-mesh": "0.2.0",
+    "@aethervtt/shard-noise": "0.2.0",
+    "@aethervtt/shard-runtime": "0.2.0",
+    "@aethervtt/shard-shader": "0.2.0",
+    "@aethervtt/shard-texture": "0.2.0",
+    "@aethervtt/shard-transform": "0.2.0"
   },
   "repository": {
     "type": "git",
@@ -44,6 +56,6 @@
     "provenance": true
   },
   "shard": {
-    "buildSha": "d6c5c6aef4675575c878b02cf2c8f738b4190229"
+    "buildSha": "32c22a3944ed23f5d1baa90bf7cc9fae724f5fd8"
   }
 }