@aethervtt/shard-render 0.0.1

package/dist/skin-asset.d.ts

@@ -0,0 +1,26 @@
+import { AssetStore } from '@aethervtt/shard-assets';
+/** Joints one skin can have: the vertex stage indexes joints with 16 bits, budgets assume 256. */
+export declare const MAX_JOINTS = 256;
+export interface SkinAsset {
+    name: string;
+    /** Joint entity paths, relative to the model root (e.g. "Armature/Hips/Spine"). */
+    joints: string[];
+    skeleton?: string;
+    /** Each joint's rest pose (local TRS), for retargeting. */
+    restPose: {
+        translation: number[];
+        rotation: number[];
+        scale: number[];
+    }[];
+    /** 16 floats per joint, column-major. */
+    inverseBindMatrices: Float32Array;
+}
+export declare const Skins: import("@aethervtt/shard-core").ResourceDef<AssetStore<SkinAsset, "Skin">>;
+interface SkinHeader extends Omit<SkinAsset, 'inverseBindMatrices'> {
+    matrices: number;
+}
+/** Skin artifacts: the header as JSON, the inverse bind matrices as bytes. */
+export declare const SkinAssetType: import("@aethervtt/shard-assets").AssetTypeDef<SkinAsset>;
+/** A skin's artifact JSON (with `bytes` holding the inverse bind matrices), for importers. */
+export declare function skinArtifact(skin: Omit<SkinAsset, 'inverseBindMatrices'>): SkinHeader;
+export {};

package/dist/skin-asset.js

@@ -0,0 +1,25 @@
+import { AssetStore, defineAssetType } from "@aethervtt/shard-assets";
+import { defineResource } from "@aethervtt/shard-core";
+const MAX_JOINTS = 256;
+const Skins = defineResource("render/Skins", {
+  description: "Skins (joint paths, inverse bind matrices, rest pose) by guid.",
+  init: () => new AssetStore("Skin")
+});
+const SkinAssetType = defineAssetType("Skin", {
+  store: Skins,
+  load: (artifact) => {
+    const header = artifact.json;
+    const bytes = artifact.bytes.slice();
+    const { matrices, ...rest } = header;
+    return { ...rest, inverseBindMatrices: new Float32Array(bytes.buffer, 0, matrices * 16) };
+  }
+});
+function skinArtifact(skin) {
+  return { ...skin, matrices: skin.joints.length };
+}
+export {
+  MAX_JOINTS,
+  SkinAssetType,
+  Skins,
+  skinArtifact
+};

package/dist/skinning-plugin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Skinning and morph targets (spec 0034): SkinnedMesh and MorphWeights deform the meshes they're on,
+ * and the skeleton overlay draws joints. Without it those meshes draw in their rest pose.
+ */
+export declare const skinningPlugin: import("@aethervtt/shard-runtime").Plugin;

package/dist/skinning-plugin.js

@@ -0,0 +1,16 @@
+import { Last } from "@aethervtt/shard-core";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { DeformPath, prepareInstances } from "./instances.js";
+import { RenderSet } from "./plugin.js";
+import { prepareDeforms, skeletonOverlay } from "./skinning.js";
+const skinningPlugin = definePlugin({
+  name: "render/skinning",
+  provides: [skeletonOverlay],
+  dependencies: ["render/forward"],
+  build(app) {
+    app.insertResource(DeformPath, { installed: true }).addSystems(Last, prepareDeforms.inSet(RenderSet.Prepare).after(prepareInstances));
+  }
+});
+export {
+  skinningPlugin
+};

package/dist/skinning.d.ts

@@ -0,0 +1,19 @@
+import { type Entity } from '@aethervtt/shard-core';
+interface DeformState {
+    /** Frame at which to retry resolving an entity's joints. */
+    retry: Map<Entity, number>;
+    warned: Set<string>;
+    frame: number;
+}
+/**
+ * Writes joint matrices (`inverse(mesh) × joint × inverseBind`, so the instance transform still
+ * applies), a pose-following cull sphere, and the active morph weights of every visible skinned or
+ * morphed instance. Runs after instance slots are assigned, before culling.
+ */
+export declare const prepareDeforms: import("@aethervtt/shard-core").SystemDef<{
+    skinned: import("@aethervtt/shard-core").Query;
+    morphed: import("@aethervtt/shard-core").Query;
+    state: DeformState;
+}>;
+export declare const skeletonOverlay: import("./overlay-registry.js").OverlayDef;
+export {};

package/dist/skinning.js

@@ -0,0 +1,343 @@
+import {
+  affine,
+  ChildOf,
+  defineSystem,
+  ShardError
+} from "@aethervtt/shard-core";
+import { LogResource } from "@aethervtt/shard-runtime";
+import { GlobalTransform } from "@aethervtt/shard-transform";
+import { DEFORM_WORDS } from "./deform.js";
+import { InstanceSlot, Instances, MorphWeights, SkinnedMesh } from "./instances.js";
+import { defineOverlay } from "./overlay-registry.js";
+import { findModelRoot } from "./paths.js";
+import { MAX_JOINTS, Skins } from "./skin-asset.js";
+import { ComputedVisibility } from "./visibility.js";
+function meshOfSlot(store, slot) {
+  const a2 = store.batchOf[slot];
+  if (a2 >= 0) return store.batches[a2].mesh;
+  if (a2 <= -2) return store.batches[store.lodSets[-2 - a2].batches[0]].mesh;
+  return void 0;
+}
+function jointRadii(mesh, skin) {
+  const count = skin.joints.length;
+  const radii = new Float32Array(count).fill(-1);
+  const joints = mesh.joints;
+  const weights = mesh.weights;
+  const p = mesh.positions;
+  const ibm = skin.inverseBindMatrices;
+  for (let v = 0; v < mesh.vertexCount; v++) {
+    let main = 0;
+    for (let k = 1; k < 4; k++) if (weights[v * 4 + k] > weights[v * 4 + main]) main = k;
+    const j = joints[v * 4 + main];
+    if (j >= count) continue;
+    const m = j * 16;
+    const x = p[v * 3];
+    const y = p[v * 3 + 1];
+    const z = p[v * 3 + 2];
+    const lx = ibm[m] * x + ibm[m + 4] * y + ibm[m + 8] * z + ibm[m + 12];
+    const ly = ibm[m + 1] * x + ibm[m + 5] * y + ibm[m + 9] * z + ibm[m + 13];
+    const lz = ibm[m + 2] * x + ibm[m + 6] * y + ibm[m + 10] * z + ibm[m + 14];
+    const r = Math.sqrt(lx * lx + ly * ly + lz * lz);
+    if (r > radii[j]) radii[j] = r;
+  }
+  let pad = 0;
+  for (const target of mesh.targets ?? []) {
+    let reach = 0;
+    const d = target.positions;
+    for (let i = 0; i < d.length; i += 3) {
+      const r = d[i] * d[i] + d[i + 1] * d[i + 1] + d[i + 2] * d[i + 2];
+      if (r > reach) reach = r;
+    }
+    pad += Math.sqrt(reach);
+  }
+  if (pad > 0) {
+    for (let j = 0; j < count; j++) if (radii[j] >= 0) radii[j] = radii[j] + pad;
+  }
+  return radii;
+}
+function resolveJoints(world, entity, skin) {
+  if (skin.joints.length === 0) return void 0;
+  const found = findModelRoot(world, entity, skin.joints[0]);
+  if (!found) return void 0;
+  const out = [];
+  for (const path of skin.joints) {
+    const e = found.paths.get(path);
+    if (e === void 0) return void 0;
+    out.push(e);
+  }
+  return out;
+}
+const a = new Float32Array(12);
+const meshWorld = new Float32Array(12);
+const meshInverse = new Float32Array(12);
+const bounds = new Float32Array(6);
+const topIndex = new Int32Array(8);
+const topWeight = new Float32Array(8);
+const prepareDeforms = defineSystem({
+  name: "render/prepare-deforms",
+  description: "Joint matrices, pose bounds, and morph weights of skinned and morphed meshes, uploaded for the vertex stage.",
+  setup: (world) => ({
+    skinned: world.query({
+      with: [SkinnedMesh, InstanceSlot, GlobalTransform, ComputedVisibility]
+    }),
+    morphed: world.query({
+      with: [MorphWeights, InstanceSlot, ComputedVisibility],
+      without: [SkinnedMesh]
+    }),
+    state: { retry: /* @__PURE__ */ new Map(), warned: /* @__PURE__ */ new Set(), frame: 0 }
+  }),
+  run: ({ skinned, morphed, state }, world) => {
+    const store = world.resource(Instances);
+    const d = store.deform;
+    d.beginFrame();
+    state.frame++;
+    const skins = world.tryResource(Skins);
+    const records = d.records;
+    for (let ti = 0; ti < skinned.tables.length; ti++) {
+      const table = skinned.tables[ti];
+      const n = table.count;
+      if (n === 0) continue;
+      const slots = table.column(InstanceSlot, "slot");
+      const vis = table.column(ComputedVisibility, "visible");
+      const g = table.column(GlobalTransform, "matrix");
+      const skinRefs = table.column(SkinnedMesh, "skin");
+      const jointLists = table.column(SkinnedMesh, "joints");
+      const weights = table.has(MorphWeights) ? table.column(MorphWeights, "weights") : void 0;
+      for (let i = 0; i < n; i++) {
+        const slot = slots[i] - 1;
+        if (slot < 0 || vis[i] === 0) continue;
+        const mesh = meshOfSlot(store, slot);
+        if (!mesh) {
+          d.clear(slot);
+          continue;
+        }
+        const md = d.meshData(mesh);
+        const o = slot * DEFORM_WORDS;
+        writeMeshFields(records, o, md);
+        const skin = skins?.get(skinRefs[i]);
+        let jointCount = 0;
+        if (skin && md.skinBase >= 0) {
+          let joints = jointLists[i];
+          if (joints.length !== skin.joints.length) {
+            const entity = table.entities[i];
+            const at = state.retry.get(entity) ?? 0;
+            if (at <= state.frame) {
+              const resolved = resolveJoints(world, entity, skin);
+              if (resolved) {
+                jointLists[i] = resolved;
+                joints = resolved;
+                state.retry.delete(entity);
+              } else {
+                state.retry.set(entity, state.frame + 60);
+              }
+            }
+          }
+          if (skin.joints.length > MAX_JOINTS) warnTooMany(world, state, skin);
+          else if (joints.length === skin.joints.length) {
+            jointCount = writeJoints(world, d, o, g, i * 12, skin, joints, md, mesh);
+            if (jointCount < 0) {
+              jointLists[i] = [];
+              jointCount = 0;
+            }
+          }
+        }
+        records[o + 5] = jointCount;
+        if (jointCount === 0) d.recordF32[o + 3] = 0;
+        writeMorph(d, o, weights?.[i], md);
+        d.touch(slot);
+      }
+    }
+    for (let ti = 0; ti < morphed.tables.length; ti++) {
+      const table = morphed.tables[ti];
+      const n = table.count;
+      if (n === 0) continue;
+      const slots = table.column(InstanceSlot, "slot");
+      const vis = table.column(ComputedVisibility, "visible");
+      const weights = table.column(MorphWeights, "weights");
+      for (let i = 0; i < n; i++) {
+        const slot = slots[i] - 1;
+        if (slot < 0 || vis[i] === 0) continue;
+        const mesh = meshOfSlot(store, slot);
+        if (!mesh) {
+          d.clear(slot);
+          continue;
+        }
+        const md = d.meshData(mesh);
+        const o = slot * DEFORM_WORDS;
+        writeMeshFields(records, o, md);
+        records[o + 5] = 0;
+        d.recordF32[o + 3] = 0;
+        writeMorph(d, o, weights[i], md);
+        d.touch(slot);
+      }
+    }
+  }
+});
+function writeMeshFields(records, o, md) {
+  records[o + 6] = md.skinBase >= 0 ? md.skinBase : 0;
+  records[o + 7] = md.morphBase >= 0 ? md.morphBase : 0;
+  records[o + 8] = md.vertexCount;
+}
+function warnTooMany(world, state, skin) {
+  if (state.warned.has(skin.name)) return;
+  state.warned.add(skin.name);
+  world.tryResource(LogResource)?.error(
+    new ShardError(
+      "render/too-many-joints",
+      `Skin "${skin.name}" has ${skin.joints.length} joints; skinning supports ${MAX_JOINTS}`,
+      { hint: "Split the mesh, or remove helper bones before exporting. It draws in bind pose." }
+    )
+  );
+}
+function writeJoints(world, d, o, g, go, skin, joints, md, mesh) {
+  const count = joints.length;
+  for (let k = 0; k < 12; k++) meshWorld[k] = g[go + k];
+  if (!affine.invert(meshInverse, meshWorld)) return 0;
+  if (md.radiiFor !== skin) {
+    md.radii = jointRadii(mesh, skin);
+    md.radiiFor = skin;
+  }
+  const radii = md.radii;
+  const base = d.allocPoses(count * 3);
+  const poses = d.poses;
+  const ibm = skin.inverseBindMatrices;
+  const inv = meshInverse;
+  bounds[0] = bounds[1] = bounds[2] = Number.POSITIVE_INFINITY;
+  bounds[3] = bounds[4] = bounds[5] = Number.NEGATIVE_INFINITY;
+  for (let j = 0; j < count; j++) {
+    const entity = joints[j];
+    if (entity === null || entity === void 0 || !world.isAlive(entity)) return -1;
+    const table = world.entityTableUnchecked(entity);
+    if (!table.has(GlobalTransform)) return -1;
+    const jw = table.column(GlobalTransform, "matrix");
+    const jo = world.entityRowUnchecked(entity) * 12;
+    const m = j * 16;
+    const out = (base + j * 3) * 4;
+    for (let r = 0; r < 3; r++) {
+      const j0 = jw[jo + r * 4];
+      const j1 = jw[jo + r * 4 + 1];
+      const j2 = jw[jo + r * 4 + 2];
+      const j3 = jw[jo + r * 4 + 3];
+      for (let c = 0; c < 4; c++) {
+        a[r * 4 + c] = j0 * ibm[m + c * 4] + j1 * ibm[m + c * 4 + 1] + j2 * ibm[m + c * 4 + 2] + j3 * ibm[m + c * 4 + 3];
+      }
+    }
+    for (let r = 0; r < 3; r++) {
+      const i0 = inv[r * 4];
+      const i1 = inv[r * 4 + 1];
+      const i2 = inv[r * 4 + 2];
+      for (let c = 0; c < 4; c++) {
+        poses[out + r * 4 + c] = i0 * a[c] + i1 * a[4 + c] + i2 * a[8 + c] + (c === 3 ? inv[r * 4 + 3] : 0);
+      }
+    }
+    const radius = radii[j];
+    if (radius < 0) continue;
+    const sx = jw[jo] * jw[jo] + jw[jo + 4] * jw[jo + 4] + jw[jo + 8] * jw[jo + 8];
+    const sy = jw[jo + 1] * jw[jo + 1] + jw[jo + 5] * jw[jo + 5] + jw[jo + 9] * jw[jo + 9];
+    const sz = jw[jo + 2] * jw[jo + 2] + jw[jo + 6] * jw[jo + 6] + jw[jo + 10] * jw[jo + 10];
+    const wr = radius * Math.sqrt(Math.max(sx, sy, sz));
+    const px = jw[jo + 3];
+    const py = jw[jo + 7];
+    const pz = jw[jo + 11];
+    if (px - wr < bounds[0]) bounds[0] = px - wr;
+    if (py - wr < bounds[1]) bounds[1] = py - wr;
+    if (pz - wr < bounds[2]) bounds[2] = pz - wr;
+    if (px + wr > bounds[3]) bounds[3] = px + wr;
+    if (py + wr > bounds[4]) bounds[4] = py + wr;
+    if (pz + wr > bounds[5]) bounds[5] = pz + wr;
+  }
+  const f = d.recordF32;
+  d.records[o + 4] = base;
+  if (bounds[0] <= bounds[3]) {
+    const ex = (bounds[3] - bounds[0]) * 0.5;
+    const ey = (bounds[4] - bounds[1]) * 0.5;
+    const ez = (bounds[5] - bounds[2]) * 0.5;
+    f[o] = bounds[0] + ex;
+    f[o + 1] = bounds[1] + ey;
+    f[o + 2] = bounds[2] + ez;
+    f[o + 3] = Math.sqrt(ex * ex + ey * ey + ez * ez);
+  } else {
+    f[o + 3] = 0;
+  }
+  return count;
+}
+function writeMorph(d, o, weights, md) {
+  let active = 0;
+  const n = weights ? Math.min(weights.length, md.targetCount) : 0;
+  for (let t = 0; t < n; t++) {
+    const w = weights[t];
+    const mag = Math.abs(w);
+    if (mag < 1e-5) continue;
+    let k;
+    if (active < 8) k = active++;
+    else if (mag <= Math.abs(topWeight[7])) continue;
+    else k = 7;
+    while (k > 0 && Math.abs(topWeight[k - 1]) < mag) {
+      topWeight[k] = topWeight[k - 1];
+      topIndex[k] = topIndex[k - 1];
+      k--;
+    }
+    topWeight[k] = w;
+    topIndex[k] = t;
+  }
+  d.records[o + 9] = active;
+  if (active === 0) return;
+  const base = d.allocPoses(4);
+  const poses = d.poses;
+  for (let k = 0; k < 8; k++) {
+    poses[base * 4 + k * 2] = k < active ? topIndex[k] : 0;
+    poses[base * 4 + k * 2 + 1] = k < active ? topWeight[k] : 0;
+  }
+  d.records[o + 10] = base;
+}
+const JOINT = [1, 0.85, 0.2, 1];
+const BONE = [0.3, 0.9, 1, 1];
+const pa = new Float32Array(3);
+const pb = new Float32Array(3);
+const pc = new Float32Array(3);
+function positionOf(world, entity, out) {
+  if (!world.isAlive(entity) || !world.has(entity, GlobalTransform)) return false;
+  const m = world.entityTable(entity).column(GlobalTransform, "matrix");
+  const o = world.entityRow(entity) * 12;
+  out[0] = m[o + 3];
+  out[1] = m[o + 7];
+  out[2] = m[o + 11];
+  return true;
+}
+const skeletonOverlay = defineOverlay({
+  name: "skeleton",
+  description: "Skinned meshes\u2019 joints (yellow) and bones to their parent joints (cyan), in the current pose.",
+  draw(world, g, passes) {
+    const q = world.query({ with: [SkinnedMesh] });
+    for (const table of q.tables) {
+      const lists = table.column(SkinnedMesh, "joints");
+      for (let i = 0; i < table.count; i++) {
+        if (!passes(table.entities[i])) continue;
+        const joints = lists[i];
+        const set = new Set(joints);
+        for (const joint of joints) {
+          if (joint === null || !positionOf(world, joint, pa)) continue;
+          for (let axis = 0; axis < 3; axis++) {
+            pb[0] = pa[0];
+            pb[1] = pa[1];
+            pb[2] = pa[2];
+            pc[0] = pa[0];
+            pc[1] = pa[1];
+            pc[2] = pa[2];
+            pb[axis] = pb[axis] - 0.015;
+            pc[axis] = pc[axis] + 0.015;
+            g.line(pb, pc, JOINT);
+          }
+          const parent = world.has(joint, ChildOf) ? world.get(joint, ChildOf).parent : null;
+          if (parent !== null && set.has(parent) && positionOf(world, parent, pb)) {
+            g.line(pb, pa, BONE);
+          }
+        }
+      }
+    }
+  }
+});
+export {
+  prepareDeforms,
+  skeletonOverlay
+};

package/dist/standard-fields.d.ts

@@ -0,0 +1,67 @@
+export declare const TextureSlot: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+    texture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Texture"> | null, "object">;
+    uv: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    offset: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    scale: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    wrap: import("@aethervtt/shard-core").FieldType<"clamp" | "mirror" | "repeat", "u8">;
+    filter: import("@aethervtt/shard-core").FieldType<"linear" | "nearest", "u8">;
+}>, "object">;
+export declare const TEXTURE_SLOTS: readonly ['baseColorTexture', 'metallicRoughnessTexture', 'normalTexture', 'occlusionTexture', 'emissiveTexture'];
+export declare const STANDARD_FIELDS: {
+    baseColor: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    metallic: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    roughness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    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">;
+    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">;
+    occlusionStrength: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    baseColorTexture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        texture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Texture"> | null, "object">;
+        uv: import("@aethervtt/shard-core").FieldType<number, "u8">;
+        offset: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        scale: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        wrap: import("@aethervtt/shard-core").FieldType<"clamp" | "mirror" | "repeat", "u8">;
+        filter: import("@aethervtt/shard-core").FieldType<"linear" | "nearest", "u8">;
+    }>, "object">;
+    metallicRoughnessTexture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        texture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Texture"> | null, "object">;
+        uv: import("@aethervtt/shard-core").FieldType<number, "u8">;
+        offset: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        scale: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        wrap: import("@aethervtt/shard-core").FieldType<"clamp" | "mirror" | "repeat", "u8">;
+        filter: import("@aethervtt/shard-core").FieldType<"linear" | "nearest", "u8">;
+    }>, "object">;
+    normalTexture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        texture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Texture"> | null, "object">;
+        uv: import("@aethervtt/shard-core").FieldType<number, "u8">;
+        offset: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        scale: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        wrap: import("@aethervtt/shard-core").FieldType<"clamp" | "mirror" | "repeat", "u8">;
+        filter: import("@aethervtt/shard-core").FieldType<"linear" | "nearest", "u8">;
+    }>, "object">;
+    occlusionTexture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        texture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Texture"> | null, "object">;
+        uv: import("@aethervtt/shard-core").FieldType<number, "u8">;
+        offset: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        scale: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        wrap: import("@aethervtt/shard-core").FieldType<"clamp" | "mirror" | "repeat", "u8">;
+        filter: import("@aethervtt/shard-core").FieldType<"linear" | "nearest", "u8">;
+    }>, "object">;
+    emissiveTexture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        texture: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Texture"> | null, "object">;
+        uv: import("@aethervtt/shard-core").FieldType<number, "u8">;
+        offset: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        scale: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+        rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        wrap: import("@aethervtt/shard-core").FieldType<"clamp" | "mirror" | "repeat", "u8">;
+        filter: import("@aethervtt/shard-core").FieldType<"linear" | "nearest", "u8">;
+    }>, "object">;
+};

package/dist/standard-fields.js

@@ -0,0 +1,73 @@
+import { t } from "@aethervtt/shard-core";
+function textureSlot(description) {
+  return t.struct(
+    {
+      texture: t.handle("Texture", {
+        description: 'The texture, e.g. { "path": "assets/rock.png" }.'
+      }),
+      uv: t.u8({ max: 1, description: "UV set: 0 or 1." }),
+      offset: t.vec2({ description: "UV offset." }),
+      scale: t.vec2({ default: [1, 1], description: "UV scale." }),
+      rotation: t.f32({ unit: "rad", description: "UV rotation." }),
+      wrap: t.enum(["repeat", "clamp", "mirror"], { description: "Addressing outside [0, 1]." }),
+      filter: t.enum(["linear", "nearest"], { description: "Texel filtering." })
+    },
+    { description }
+  );
+}
+const TextureSlot = textureSlot(
+  "A texture slot: which texture, which UVs, and how to sample it."
+);
+const TEXTURE_SLOTS = [
+  "baseColorTexture",
+  "metallicRoughnessTexture",
+  "normalTexture",
+  "occlusionTexture",
+  "emissiveTexture"
+];
+const STANDARD_FIELDS = {
+  baseColor: t.color({
+    default: [0.8, 0.8, 0.8, 1],
+    description: "Albedo (linear), alpha in w."
+  }),
+  metallic: t.f32({ min: 0, max: 1, description: "0 for dielectrics, 1 for metals." }),
+  roughness: t.f32({ default: 0.5, min: 0, max: 1, description: "Microsurface roughness." }),
+  emissive: t.color({
+    default: [1, 1, 1, 1],
+    description: "Emitted color (linear), scaled by emissiveLuminance."
+  }),
+  emissiveLuminance: t.f32({
+    min: 0,
+    unit: "cd/m\xB2",
+    description: "Emitted luminance. 0 = not emissive."
+  }),
+  doubleSided: t.bool({ description: "Draw back faces too (no culling)." }),
+  alphaMode: t.enum(["opaque", "mask", "alpha", "additive", "premultiplied"], {
+    description: "opaque ignores alpha; mask discards pixels below alphaCutoff; alpha blends (transparent, drawn after opaque, sorted back to front); additive adds light (glows); premultiplied expects color already multiplied by alpha."
+  }),
+  alphaCutoff: t.f32({
+    default: 0.5,
+    min: 0,
+    max: 1,
+    description: 'Alpha threshold for alphaMode "mask".'
+  }),
+  normalScale: t.f32({ default: 1, description: "Strength of the normal map." }),
+  occlusionStrength: t.f32({
+    default: 1,
+    min: 0,
+    max: 1,
+    description: "Strength of the occlusion map."
+  }),
+  baseColorTexture: textureSlot("Albedo (sRGB), multiplied with baseColor."),
+  metallicRoughnessTexture: textureSlot(
+    "G = roughness, B = metallic (linear), multiplied with the factors."
+  ),
+  normalTexture: textureSlot("Tangent-space normal map."),
+  occlusionTexture: textureSlot("Ambient occlusion in R (linear)."),
+  emissiveTexture: textureSlot("Emission color (sRGB), multiplied with emissive.")
+};
+export {
+  STANDARD_FIELDS,
+  TEXTURE_SLOTS,
+  TextureSlot
+};

package/dist/standard.d.ts

@@ -0,0 +1,7 @@
+import { type Plugin } from '@aethervtt/shard-runtime';
+import { type ForwardPluginOptions } from './forward.js';
+/**
+ * The whole 3D renderer: `forwardCorePlugin` and every render feature. Apps that want a smaller
+ * build install `forwardCorePlugin` and only the features they use (spec 0056).
+ */
+export declare function forwardPlugin(options?: ForwardPluginOptions): Plugin;

package/dist/standard.js

@@ -0,0 +1,37 @@
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { atmospherePlugin } from "./atmosphere-plugin.js";
+import { deferredPlugin } from "./deferred-plugin.js";
+import { renderDescribePlugin } from "./describe-plugin.js";
+import { dynamicResolutionPlugin } from "./dynamic-resolution.js";
+import { environmentPlugin } from "./environment-plugin.js";
+import { forwardCorePlugin } from "./forward.js";
+import { fxaaPlugin } from "./fxaa.js";
+import { gizmosPlugin } from "./gizmos-plugin.js";
+import { pickingPlugin } from "./picking-plugin.js";
+import { pixelPerfectPlugin } from "./pixel-perfect-plugin.js";
+import { postPlugin } from "./post-plugin.js";
+import { skinningPlugin } from "./skinning-plugin.js";
+function forwardPlugin(options = {}) {
+  return definePlugin({
+    name: "render/standard",
+    build(app) {
+      app.addPlugin(
+        forwardCorePlugin(options),
+        environmentPlugin,
+        atmospherePlugin,
+        postPlugin,
+        fxaaPlugin,
+        gizmosPlugin,
+        pickingPlugin,
+        deferredPlugin,
+        skinningPlugin,
+        pixelPerfectPlugin,
+        dynamicResolutionPlugin,
+        renderDescribePlugin
+      );
+    }
+  });
+}
+export {
+  forwardPlugin
+};

package/dist/stats.d.ts

@@ -0,0 +1,25 @@
+export interface ViewStats {
+    visible: number;
+    culled: number;
+    hidden: number;
+    /** Meshes skipped because their mesh or material isn't loaded yet (or failed). */
+    pending: number;
+    drawCalls: number;
+    /** Pipeline changes in the opaque pass (sorting keeps these near the number of material types). */
+    pipelineSwitches?: number;
+}
+export declare const RenderStats: import("@aethervtt/shard-core").ResourceDef<Map<string, ViewStats>>;
+export interface GpuMemoryData {
+    /** Textures uploaded by the forward renderer. */
+    textures: number;
+    /** Bytes of GPU memory those textures use (all mip levels). */
+    textureBytes: number;
+}
+export declare const GpuMemory: import("@aethervtt/shard-core").ResourceDef<GpuMemoryData>;
+export interface RenderCountersData {
+    /** Times a TAA history started over (new view, resize, device loss). Never on origin shifts. */
+    taaResets: number;
+    /** Floating-origin shifts the renderer followed (spec 0040): history moved, not reset. */
+    originShifts: number;
+}
+export declare const RenderCounters: import("@aethervtt/shard-core").ResourceDef<RenderCountersData>;