@aethervtt/shard-render 0.0.1

package/dist/view.js

@@ -0,0 +1,389 @@
+import {
+  affine,
+  defineComponent,
+  defineResource,
+  defineSystem,
+  frustum,
+  mat4,
+  t,
+  vec3
+} from "@aethervtt/shard-core";
+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 { createDrawList } from "./instances.js";
+import {
+  PixelPerfect,
+  PixelPerfectPath,
+  pixelPerfectLayout
+} from "./pixel-perfect.js";
+import { Views, Window } from "./plugin.js";
+import {
+  antialiasingOf,
+  CORE_EFFECTS,
+  createPostSettings,
+  extractPost,
+  PostEffect,
+  PostFeatures,
+  postAliases
+} from "./post.js";
+import { RenderScale, scaledSize } from "./render-scale.js";
+const TONEMAP_CURVES = ["aces", "agx", "pbr-neutral", "reinhard", "none"];
+const DEFAULT_CURVE = "agx";
+const Tonemapping = defineComponent(
+  "render/Tonemapping",
+  {
+    curve: t.enum(TONEMAP_CURVES, {
+      default: DEFAULT_CURVE,
+      description: "How HDR becomes display color. agx: saturated highlights (glows, lava, neon) keep their hue; aces: punchy filmic contrast; pbr-neutral: faithful product colors (Khronos); reinhard: simple, soft; none: clamp only, for measuring."
+    }),
+    dither: t.bool({ default: true, description: "Adds \xB11 LSB noise against banding." })
+  },
+  {
+    description: "Tonemapping for a camera. Without it, cameras use the default curve with dithering."
+  }
+);
+const RenderPath = defineComponent(
+  "render/RenderPath",
+  {
+    mode: t.enum(["forward", "deferred"], {
+      description: "forward: simpler, supports MSAA, fine up to a few hundred lights. deferred: lights each pixel once (heavy overdraw, many lights) and gives G-buffer effects; anti-alias with FXAA or TAA."
+    })
+  },
+  {
+    description: "How a camera shades opaque geometry. Materials work in both; custom-lit and transparent ones always draw forward."
+  }
+);
+const DeferredPath = defineResource("render/DeferredPath", {
+  description: "Present when the deferred path (deferredPlugin) is installed."
+});
+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 })
+});
+const scratchProj = mat4.create();
+const scratchSnap = affine.create();
+const scratchView = affine.create();
+const NO_MSAA_ALIASES = Object.freeze({
+  "scene-color": "hdr",
+  "scene-depth": "depth",
+  ldr: "view-target",
+  display: "view-target"
+});
+const MSAA_ALIASES = Object.freeze({ ldr: "view-target", display: "view-target" });
+const SCALED_NO_MSAA_ALIASES = Object.freeze({
+  "scene-color": "hdr",
+  "scene-depth": "depth",
+  ldr: "display"
+});
+const SCALED_MSAA_ALIASES = Object.freeze({ ldr: "display" });
+function isScaled(cam) {
+  return cam.width !== cam.displayWidth || cam.height !== cam.displayHeight;
+}
+function viewAliases(cam) {
+  if (isScaled(cam)) return cam.msaa > 1 ? SCALED_MSAA_ALIASES : SCALED_NO_MSAA_ALIASES;
+  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;
+  if (fresh === 0) return;
+  reportedEffects.set(world, reported | fresh);
+  const names = Object.entries(PostEffect).filter(([, bit]) => (fresh & bit) !== 0).map(([name]) => name);
+  const plugin = fresh & PostEffect.Fxaa && fresh === PostEffect.Fxaa ? "fxaaPlugin" : "postPlugin";
+  world.tryResource(LogResource)?.log(
+    "warn",
+    `A camera asks for ${names.join(", ")}, but ${plugin} isn't installed; it renders without them`,
+    {
+      code: "render/feature-missing",
+      hint: `Add ${plugin} from '@aethervtt/shard-render' (forwardPlugin includes it).`
+    }
+  );
+}
+const extractCameras = defineSystem({
+  name: "render/extract-cameras",
+  description: "Turns Camera3d entities into render views with matrices, frustums, and exposure.",
+  setup: (world) => ({ q: world.query({ with: [Camera3d, GlobalTransform, Exposure] }) }),
+  run: ({ q }, world) => {
+    const cameras = world.resource(Cameras);
+    const views = world.resource(Views).list;
+    const window = world.tryResource(Window);
+    const targets = world.resource(RenderTargets);
+    const settings = world.resource(ViewSettings);
+    const scale = world.tryResource(RenderScale);
+    if (scale) scale.windowViews = 0;
+    const delta = world.resource(Time).delta;
+    const installed = world.tryResource(PostFeatures)?.effects ?? CORE_EFFECTS;
+    const deferredInstalled = world.hasResource(DeferredPath);
+    const pixelInstalled = world.hasResource(PixelPerfectPath);
+    for (const table of q.tables) {
+      const projection = table.column(Camera3d, "projection");
+      const fovY = table.column(Camera3d, "fovY");
+      const near = table.column(Camera3d, "near");
+      const far = table.column(Camera3d, "far");
+      const orthoHeight = table.column(Camera3d, "orthoHeight");
+      const order = table.column(Camera3d, "order");
+      const clear = table.column(Camera3d, "clearColor");
+      const target = table.column(Camera3d, "target");
+      const active = table.column(Camera3d, "active");
+      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);
+      const pixel = pixelInstalled && table.has(PixelPerfect);
+      const ppu = pixel ? table.column(PixelPerfect, "pixelsPerUnit") : void 0;
+      const snap = pixel ? table.column(PixelPerfect, "snap") : void 0;
+      for (let i = 0; i < table.count; i++) {
+        if (active[i] === 0) {
+          const idle = cameras.get(table.entities[i]);
+          if (idle) idle.frames = 0;
+          continue;
+        }
+        const shown = target[i] ? targets.get(target[i]) : window;
+        if (!shown) continue;
+        let rt = shown;
+        const entity = table.entities[i];
+        let cam = cameras.get(entity);
+        if (!cam) {
+          cam = {
+            entity,
+            view: mat4.create(),
+            proj: mat4.create(),
+            viewProj: mat4.create(),
+            viewProjNoJitter: mat4.create(),
+            invViewProj: mat4.create(),
+            prevViewProj: mat4.create(),
+            position: vec3.create(),
+            forward: vec3.create(0, 0, -1),
+            frustum: frustum.create(),
+            orthographic: false,
+            near: 0.1,
+            far: 0,
+            fovY: 1,
+            orthoHeight: 10,
+            aspect: 1,
+            width: 1,
+            height: 1,
+            displayWidth: 1,
+            displayHeight: 1,
+            pixelRatio: 1,
+            exposure: 1,
+            ev100: 0,
+            clear: { r: 0, g: 0, b: 0, a: 1 },
+            msaa: 1,
+            curve: 1,
+            dither: true,
+            draws: createDrawList(),
+            transparent: createDrawList(),
+            forwardOnly: createDrawList(),
+            deferred: false,
+            gbufferDebug: -1,
+            lodState: new Uint8Array(0),
+            lodCapacity: 0,
+            frozenFrustum: void 0,
+            frozenPosition: void 0,
+            frames: 0,
+            debug: 0,
+            post: createPostSettings(),
+            pixelPerfect: void 0
+          };
+          cameras.set(entity, cam);
+        }
+        cam.orthographic = projection[i] !== 0;
+        let height = orthoHeight[i];
+        cam.pixelPerfect = void 0;
+        if (ppu && cam.orthographic) {
+          const p = pixelPerfectLayout(world, entity, shown, height, ppu[i], snap[i] !== 0);
+          rt = p.target;
+          height = p.height / p.pixelsPerUnit;
+          cam.pixelPerfect = p;
+        }
+        cam.displayWidth = rt.width;
+        cam.displayHeight = rt.height;
+        cam.pixelRatio = rt.pixelRatio ?? 1;
+        cam.width = rt.width;
+        cam.height = rt.height;
+        if (scale && !cam.pixelPerfect && rt.renderScale) {
+          cam.width = scaledSize(rt.width, scale.scale);
+          cam.height = scaledSize(rt.height, scale.scale);
+          scale.windowViews++;
+        }
+        const aspect = cam.width / Math.max(1, cam.height);
+        cam.aspect = aspect;
+        cam.near = near[i];
+        cam.fovY = fovY[i] * Math.PI / 180;
+        cam.orthoHeight = height;
+        if (!cam.orthographic) {
+          mat4.perspectiveReversedZ(scratchProj, cam.fovY, aspect, near[i]);
+          cam.far = 0;
+        } else {
+          const h = height / 2;
+          mat4.orthographicReversedZ(scratchProj, -h * aspect, h * aspect, -h, h, near[i], far[i]);
+          cam.far = far[i];
+        }
+        const wantsDeferred = path ? path[i] === 1 : false;
+        cam.deferred = wantsDeferred && deferredInstalled;
+        if (wantsDeferred && !deferredInstalled) warnMissingDeferred(world);
+        const missing = extractPost(table, i, cam, delta, true, installed);
+        if (missing !== 0) warnMissingEffects(world, missing);
+        const world_ = g.subarray(i * 12, i * 12 + 12);
+        if (cam.pixelPerfect?.snap) {
+          scratchSnap.set(world_);
+          const u = cam.pixelPerfect.pixelsPerUnit;
+          scratchSnap[3] = Math.round(scratchSnap[3] * u) / u;
+          scratchSnap[7] = Math.round(scratchSnap[7] * u) / u;
+          affine.invert(scratchView, scratchSnap);
+        } else {
+          affine.invert(scratchView, world_);
+        }
+        affine.toMat4(cam.view, scratchView);
+        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);
+        const jitter = cam.post.jitter;
+        if (cam.post.effects & PostEffect.Taa) {
+          const k = cam.frames % 8 + 1;
+          jitter[0] = halton(k, 2) - 0.5;
+          jitter[1] = halton(k, 3) - 0.5;
+          const jx = 2 * jitter[0] / cam.width;
+          const jy = -2 * jitter[1] / cam.height;
+          if (cam.orthographic) {
+            scratchProj[12] = scratchProj[12] + jx;
+            scratchProj[13] = scratchProj[13] + jy;
+          } else {
+            scratchProj[8] = scratchProj[8] - jx;
+            scratchProj[9] = scratchProj[9] - jy;
+          }
+        } else {
+          jitter[0] = 0;
+          jitter[1] = 0;
+        }
+        mat4.copy(cam.proj, scratchProj);
+        mat4.multiply(cam.viewProj, scratchProj, cam.view);
+        mat4.invert(cam.invViewProj, cam.viewProj);
+        frustum.fromViewProjection(cam.frustum, cam.viewProj);
+        affine.getTranslationAt(cam.position, g, i * 12);
+        const o = i * 12;
+        const fx = -g[o + 2];
+        const fy = -g[o + 6];
+        const fz = -g[o + 10];
+        const fl = Math.sqrt(fx * fx + fy * fy + fz * fz) || 1;
+        cam.forward[0] = fx / fl;
+        cam.forward[1] = fy / fl;
+        cam.forward[2] = fz / fl;
+        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 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;
+        cam.curve = curve ? curve[i] : TONEMAP_CURVES.indexOf(DEFAULT_CURVE);
+        cam.dither = dither ? dither[i] !== 0 : true;
+        cam.frames++;
+        const view = {
+          name: `camera:${entity}`,
+          target: rt,
+          order: order[i],
+          data: { camera: cam }
+        };
+        if (isScaled(cam)) {
+          view.width = cam.width;
+          view.height = cam.height;
+        }
+        view.aliases = postAliases(cam, viewAliases(cam));
+        views.push(view);
+        if (cam.pixelPerfect) {
+          views.push({
+            name: `pixel-perfect:${entity}`,
+            target: shown,
+            order: order[i] + 0.5,
+            data: { upscale: cam.pixelPerfect }
+          });
+        }
+      }
+    }
+  }
+});
+function translateRight(m, x, y, z) {
+  for (let r = 0; r < 4; r++) m[12 + r] = m[r] * x + m[4 + r] * y + m[8 + r] * z + m[12 + r];
+}
+function shiftCameraHistory(cam, x, y, z) {
+  translateRight(cam.viewProjNoJitter, -x, -y, -z);
+  translateRight(cam.prevViewProj, -x, -y, -z);
+  const fp = cam.frozenPosition;
+  if (fp) {
+    fp[0] = fp[0] + x;
+    fp[1] = fp[1] + y;
+    fp[2] = fp[2] + z;
+  }
+  const ff = cam.frozenFrustum;
+  if (ff) {
+    for (let p = 0; p < ff.length; p += 4) {
+      ff[p + 3] = ff[p + 3] - (ff[p] * x + ff[p + 1] * y + ff[p + 2] * z);
+    }
+  }
+}
+function halton(k, base) {
+  let f = 1;
+  let r = 0;
+  let i = k;
+  while (i > 0) {
+    f /= base;
+    r += f * (i % base);
+    i = Math.floor(i / base);
+  }
+  return r;
+}
+function cameraOf(view) {
+  return view.data.camera;
+}
+export {
+  Cameras,
+  DEFAULT_CURVE,
+  DeferredPath,
+  RenderPath,
+  TONEMAP_CURVES,
+  Tonemapping,
+  ViewSettings,
+  cameraOf,
+  extractCameras,
+  isScaled,
+  shiftCameraHistory,
+  viewAliases
+};

package/dist/visibility.d.ts

@@ -0,0 +1,10 @@
+export declare const ComputedVisibility: import("@aethervtt/shard-core").ComponentDef<{
+    readonly visible: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}>;
+export declare const Visibility: import("@aethervtt/shard-core").ComponentDef<{
+    readonly mode: import("@aethervtt/shard-core").FieldType<"hidden" | "inherit" | "visible", "u8">;
+}>;
+/** Roots take their own mode; children resolve 'inherit' from the parent, depth-first. */
+export declare const computeVisibility: import("@aethervtt/shard-core").SystemDef<{
+    roots: import("@aethervtt/shard-core").Query;
+}>;

package/dist/visibility.js

@@ -0,0 +1,84 @@
+import {
+  ChildOf,
+  Children,
+  defineComponent,
+  defineSystem,
+  t
+} from "@aethervtt/shard-core";
+const ComputedVisibility = defineComponent(
+  "render/ComputedVisibility",
+  {
+    visible: t.bool({
+      default: true,
+      readonly: true,
+      description: "Final visibility after inheritance."
+    })
+  },
+  {
+    description: "Computed from Visibility and the parent chain each frame. Do not write.",
+    serialize: false
+  }
+);
+const Visibility = defineComponent(
+  "render/Visibility",
+  {
+    mode: t.enum(["inherit", "visible", "hidden"], {
+      description: "'inherit' follows the parent; 'visible' shows even under a hidden parent; 'hidden' hides this and inheriting children."
+    })
+  },
+  {
+    description: "Whether this entity (and inheriting children) is drawn.",
+    requires: [ComputedVisibility]
+  }
+);
+const MODE_VISIBLE = 1;
+const MODE_HIDDEN = 2;
+const computeVisibility = defineSystem({
+  name: "render/compute-visibility",
+  description: "Resolves Visibility modes through the hierarchy into ComputedVisibility.",
+  setup: (world) => ({ roots: world.query({ with: [Visibility], without: [ChildOf] }) }),
+  run: ({ roots }, world) => {
+    for (const table of roots.tables) {
+      const modes = table.column(Visibility, "mode");
+      const out = table.column(ComputedVisibility, "visible");
+      const children = table.has(Children) ? table.column(Children, "entities") : void 0;
+      for (let i = 0; i < table.count; i++) {
+        const visible = modes[i] !== MODE_HIDDEN;
+        const value = visible ? 1 : 0;
+        if (out[i] !== value) {
+          out[i] = value;
+          table.markChanged(ComputedVisibility, i);
+        }
+        const list = children?.[i];
+        if (list) walk(world, list, visible);
+      }
+    }
+  }
+});
+function walk(world, list, parentVisible) {
+  for (let k = 0; k < list.length; k++) {
+    const child = list[k];
+    if (child === null || child === void 0) continue;
+    const table = world.entityTableUnchecked(child);
+    const row = world.entityRowUnchecked(child);
+    let visible = parentVisible;
+    if (table.has(Visibility)) {
+      const mode = table.column(Visibility, "mode")[row];
+      visible = mode === MODE_HIDDEN ? false : mode === MODE_VISIBLE ? true : parentVisible;
+      const out = table.column(ComputedVisibility, "visible");
+      if (out[row] !== (visible ? 1 : 0)) {
+        out[row] = visible ? 1 : 0;
+        table.markChanged(ComputedVisibility, row);
+      }
+    }
+    if (table.has(Children)) {
+      const grandchildren = table.column(Children, "entities")[row];
+      if (grandchildren) walk(world, grandchildren, visible);
+    }
+  }
+}
+export {
+  ComputedVisibility,
+  Visibility,
+  computeVisibility
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@aethervtt/shard-render",
+  "version": "0.0.1",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    },
+    "./noise": {
+      "types": "./dist/noise.d.ts",
+      "default": "./dist/noise.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "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"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/render"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "d6c5c6aef4675575c878b02cf2c8f738b4190229"
+  }
+}