@aethervtt/shard-render 0.0.1

package/dist/atmosphere-model.js

@@ -0,0 +1,370 @@
+function createModel() {
+  return {
+    bottom: 6360,
+    top: 6420,
+    ground: 6360,
+    rayleigh: new Float64Array(3),
+    rayleighInvScale: 1 / 8,
+    mieScattering: 0,
+    mieAbsorption: 0,
+    mieInvScale: 1 / 1.2,
+    mieG: new Float64Array(3),
+    absorption: new Float64Array(3),
+    absorptionCenter: 25,
+    absorptionWidth: 30,
+    albedo: new Float64Array(3),
+    intensity: 1
+  };
+}
+const TRANSMITTANCE_W = 256;
+const TRANSMITTANCE_H = 64;
+const MULTISCATTER_SIZE = 32;
+const TRANSMITTANCE_STEPS = 40;
+const MS_STEPS = 20;
+const MS_DIRS = 8;
+function createMedium() {
+  return {
+    rayleigh: new Float64Array(3),
+    mie: 0,
+    scattering: new Float64Array(3),
+    extinction: new Float64Array(3)
+  };
+}
+function mediumAt(m, h, out) {
+  const hc = Math.max(h, m.ground - m.bottom);
+  const dr = Math.exp(-hc * m.rayleighInvScale);
+  const dm = Math.exp(-hc * m.mieInvScale);
+  const da = Math.max(0, 1 - Math.abs(hc - m.absorptionCenter) / (0.5 * m.absorptionWidth));
+  const mieS = m.mieScattering * dm;
+  const mieE = mieS + m.mieAbsorption * dm;
+  out.mie = mieS;
+  for (let c = 0; c < 3; c++) {
+    const r = m.rayleigh[c] * dr;
+    out.rayleigh[c] = r;
+    out.scattering[c] = r + mieS;
+    out.extinction[c] = r + mieE + m.absorption[c] * da;
+  }
+  return out;
+}
+function raySphere(ox, oy, oz, dx, dy, dz, r, out) {
+  const b = ox * dx + oy * dy + oz * dz;
+  const c = ox * ox + oy * oy + oz * oz - r * r;
+  const disc = b * b - c;
+  if (disc < 0) {
+    out[0] = Number.NaN;
+    out[1] = Number.NaN;
+    return false;
+  }
+  const s = Math.sqrt(disc);
+  out[0] = -b - s;
+  out[1] = -b + s;
+  return true;
+}
+const hit = new Float64Array(2);
+const med = createMedium();
+function transmittanceToTop(m, px, py, pz, dx, dy, dz, out, steps = TRANSMITTANCE_STEPS) {
+  if (raySphere(px, py, pz, dx, dy, dz, m.ground, hit) && hit[0] > 0) {
+    out[0] = out[1] = out[2] = 0;
+    return out;
+  }
+  if (!raySphere(px, py, pz, dx, dy, dz, m.top, hit) || hit[1] <= 0) {
+    out[0] = out[1] = out[2] = 1;
+    return out;
+  }
+  const t0 = Math.max(0, hit[0]);
+  const dt = (hit[1] - t0) / steps;
+  let tr = 0;
+  let tg = 0;
+  let tb = 0;
+  for (let i = 0; i < steps; i++) {
+    const t = t0 + (i + 0.5) * dt;
+    const x = px + dx * t;
+    const y = py + dy * t;
+    const z = pz + dz * t;
+    mediumAt(m, Math.sqrt(x * x + y * y + z * z) - m.bottom, med);
+    tr += med.extinction[0] * dt;
+    tg += med.extinction[1] * dt;
+    tb += med.extinction[2] * dt;
+  }
+  out[0] = Math.exp(-tr);
+  out[1] = Math.exp(-tg);
+  out[2] = Math.exp(-tb);
+  return out;
+}
+function transmittanceUnit(m, r, mu, out) {
+  const rb = m.ground;
+  const rt = m.top;
+  const H = Math.sqrt(Math.max(0, rt * rt - rb * rb));
+  const rho = Math.sqrt(Math.max(0, r * r - rb * rb));
+  const disc = r * r * (mu * mu - 1) + rt * rt;
+  const d = Math.max(0, -r * mu + Math.sqrt(Math.max(disc, 0)));
+  const dMin = rt - r;
+  const dMax = rho + H;
+  out[0] = dMax > dMin ? (d - dMin) / (dMax - dMin) : 0;
+  out[1] = H > 0 ? rho / H : 0;
+  return out;
+}
+function transmittanceRMu(m, xMu, xR, out) {
+  const rb = m.ground;
+  const rt = m.top;
+  const H = Math.sqrt(Math.max(0, rt * rt - rb * rb));
+  const rho = H * xR;
+  const r = Math.sqrt(rho * rho + rb * rb);
+  const dMin = rt - r;
+  const dMax = rho + H;
+  const d = dMin + xMu * (dMax - dMin);
+  const mu = d === 0 ? 1 : (H * H - rho * rho - d * d) / (2 * r * d);
+  out[0] = r;
+  out[1] = Math.min(1, Math.max(-1, mu));
+  return out;
+}
+function sampleLut(lut, x, y, out) {
+  const fx = Math.min(1, Math.max(0, x)) * (lut.width - 1);
+  const fy = Math.min(1, Math.max(0, y)) * (lut.height - 1);
+  const x0 = Math.min(lut.width - 2, Math.floor(fx));
+  const y0 = Math.min(lut.height - 2, Math.floor(fy));
+  const ax = fx - x0;
+  const ay = fy - y0;
+  const d = lut.data;
+  const w = lut.width;
+  for (let c = 0; c < 3; c++) {
+    const a = d[(y0 * w + x0) * 3 + c];
+    const b = d[(y0 * w + x0 + 1) * 3 + c];
+    const e = d[((y0 + 1) * w + x0) * 3 + c];
+    const f = d[((y0 + 1) * w + x0 + 1) * 3 + c];
+    out[c] = (a * (1 - ax) + b * ax) * (1 - ay) + (e * (1 - ax) + f * ax) * ay;
+  }
+  return out;
+}
+const unit = new Float64Array(2);
+const rmu = new Float64Array(2);
+const t3 = new Float64Array(3);
+function transmittanceLut(m) {
+  const w = TRANSMITTANCE_W;
+  const h = TRANSMITTANCE_H;
+  const data = new Float32Array(w * h * 3);
+  for (let j = 0; j < h; j++) {
+    for (let i = 0; i < w; i++) {
+      transmittanceRMu(m, i / (w - 1), j / (h - 1), rmu);
+      const r = rmu[0];
+      const mu = rmu[1];
+      transmittanceToTop(m, 0, r, 0, Math.sqrt(Math.max(0, 1 - mu * mu)), mu, 0, t3);
+      data.set(t3, (j * w + i) * 3);
+    }
+  }
+  return { width: w, height: h, data };
+}
+function lookupTransmittance(m, lut, r, mu, out) {
+  transmittanceUnit(m, r, mu, unit);
+  return sampleLut(lut, unit[0], unit[1], out);
+}
+function sunTransmittance(m, lut, x, y, z, sx, sy, sz, out) {
+  if (raySphere(x, y, z, sx, sy, sz, m.ground, hit) && hit[0] > 0) {
+    out[0] = out[1] = out[2] = 0;
+    return out;
+  }
+  const r = Math.sqrt(x * x + y * y + z * z);
+  return lookupTransmittance(m, lut, r, (x * sx + y * sy + z * sz) / r, out);
+}
+const sunT = new Float64Array(3);
+const msAcc = new Float64Array(6);
+function multiscatterLut(m, tlut) {
+  const n = MULTISCATTER_SIZE;
+  const data = new Float32Array(n * n * 3);
+  const isotropic = 1 / (4 * Math.PI);
+  for (let j = 0; j < n; j++) {
+    const r = m.ground + j / (n - 1) * (m.top - m.ground);
+    const rr = Math.max(r, m.ground + 1e-3);
+    for (let i = 0; i < n; i++) {
+      const cs = i / (n - 1) * 2 - 1;
+      const sx = 0;
+      const sy = cs;
+      const sz = Math.sqrt(Math.max(0, 1 - cs * cs));
+      msAcc.fill(0);
+      for (let a = 0; a < MS_DIRS; a++) {
+        for (let b = 0; b < MS_DIRS; b++) {
+          const ct = 1 - 2 * (a + 0.5) / MS_DIRS;
+          const st = Math.sqrt(Math.max(0, 1 - ct * ct));
+          const phi = 2 * Math.PI * (b + 0.5) / MS_DIRS;
+          const dx = st * Math.cos(phi);
+          const dy = ct;
+          const dz = st * Math.sin(phi);
+          const hitsGround = raySphere(0, rr, 0, dx, dy, dz, m.ground, hit) && hit[0] > 0;
+          const tGround = hit[0];
+          raySphere(0, rr, 0, dx, dy, dz, m.top, hit);
+          const tMax = hitsGround ? tGround : hit[1];
+          const dt = tMax / MS_STEPS;
+          let thr = 1;
+          let thg = 1;
+          let thb = 1;
+          for (let k = 0; k < MS_STEPS; k++) {
+            const t = (k + 0.5) * dt;
+            const x = dx * t;
+            const y = rr + dy * t;
+            const z = dz * t;
+            mediumAt(m, Math.sqrt(x * x + y * y + z * z) - m.bottom, med);
+            sunTransmittance(m, tlut, x, y, z, sx, sy, sz, sunT);
+            for (let c = 0; c < 3; c++) {
+              const ext = Math.max(med.extinction[c], 1e-9);
+              const stepT = Math.exp(-ext * dt);
+              const sc = med.scattering[c];
+              const th = c === 0 ? thr : c === 1 ? thg : thb;
+              msAcc[c] = msAcc[c] + th * (sunT[c] * sc * isotropic * (1 - stepT)) / ext;
+              msAcc[3 + c] = msAcc[3 + c] + th * (sc * (1 - stepT)) / ext;
+              if (c === 0) thr *= stepT;
+              else if (c === 1) thg *= stepT;
+              else thb *= stepT;
+            }
+          }
+          if (hitsGround) {
+            const x = dx * tMax;
+            const y = rr + dy * tMax;
+            const z = dz * tMax;
+            const len = Math.sqrt(x * x + y * y + z * z);
+            const ndl = Math.max(0, (x * sx + y * sy + z * sz) / len);
+            sunTransmittance(m, tlut, x * 1.00001, y * 1.00001, z * 1.00001, sx, sy, sz, sunT);
+            msAcc[0] = msAcc[0] + thr * sunT[0] * ndl * m.albedo[0] / Math.PI;
+            msAcc[1] = msAcc[1] + thg * sunT[1] * ndl * m.albedo[1] / Math.PI;
+            msAcc[2] = msAcc[2] + thb * sunT[2] * ndl * m.albedo[2] / Math.PI;
+          }
+        }
+      }
+      const count = MS_DIRS * MS_DIRS;
+      for (let c = 0; c < 3; c++) {
+        const l2 = msAcc[c] / count;
+        const fms = msAcc[3 + c] / count;
+        data[(j * n + i) * 3 + c] = l2 / Math.max(1 - fms, 1e-4);
+      }
+    }
+  }
+  return { width: n, height: n, data };
+}
+function lookupMultiscatter(m, lut, r, cs, out) {
+  return sampleLut(lut, cs * 0.5 + 0.5, (r - m.ground) / (m.top - m.ground), out);
+}
+const rayleighPhase = (mu) => 3 / (16 * Math.PI) * (1 + mu * mu);
+function miePhase(mu, g) {
+  const g2 = g * g;
+  return 3 / (8 * Math.PI) * ((1 - g2) * (1 + mu * mu)) / ((2 + g2) * (1 + g2 - 2 * g * mu) ** 1.5);
+}
+function createSkySample() {
+  return {
+    radiance: new Float64Array(3),
+    transmittance: new Float64Array(3),
+    hitsGround: false,
+    length: 0
+  };
+}
+const ms3 = new Float64Array(3);
+function integrateSky(m, tlut, mslut, p, d, suns, out, steps = 32, maxT = Number.POSITIVE_INFINITY) {
+  const px = p[0];
+  const py = p[1];
+  const pz = p[2];
+  const dx = d[0];
+  const dy = d[1];
+  const dz = d[2];
+  out.radiance.fill(0);
+  out.transmittance.fill(1);
+  out.hitsGround = false;
+  out.length = 0;
+  if (!raySphere(px, py, pz, dx, dy, dz, m.top, hit) || hit[1] <= 0) return out;
+  const t0 = Math.max(0, hit[0]);
+  let t1 = hit[1];
+  let ground = false;
+  if (raySphere(px, py, pz, dx, dy, dz, m.ground, hit) && hit[0] > 0 && hit[0] < t1) {
+    t1 = hit[0];
+    ground = true;
+  }
+  if (maxT < t1) {
+    t1 = maxT;
+    ground = false;
+  }
+  if (t1 <= t0) return out;
+  out.length = t1 - t0;
+  const T = out.transmittance;
+  const L = out.radiance;
+  const fromSpace = t0 > 0;
+  const bunch = (s) => fromSpace ? 1 - (1 - s) * (1 - s) : s * s;
+  for (let k = 0; k < steps; k++) {
+    const a = t0 + (t1 - t0) * bunch(k / steps);
+    const b = t0 + (t1 - t0) * bunch((k + 1) / steps);
+    const t = t0 + (t1 - t0) * bunch((k + 0.5) / steps);
+    const dt = b - a;
+    const x = px + dx * t;
+    const y = py + dy * t;
+    const z = pz + dz * t;
+    const r = Math.sqrt(x * x + y * y + z * z);
+    mediumAt(m, r - m.bottom, med);
+    for (let c = 0; c < 3; c++) ms3[c] = 0;
+    let sr = 0;
+    let sg = 0;
+    let sb = 0;
+    for (const sun of suns) {
+      const sx = sun.direction[0];
+      const sy = sun.direction[1];
+      const sz = sun.direction[2];
+      const mu = dx * sx + dy * sy + dz * sz;
+      const pr = rayleighPhase(mu);
+      sunTransmittance(m, tlut, x, y, z, sx, sy, sz, sunT);
+      lookupMultiscatter(m, mslut, r, (x * sx + y * sy + z * sz) / r, ms3);
+      for (let c = 0; c < 3; c++) {
+        const e = sun.illuminance[c];
+        const single = (med.rayleigh[c] * pr + med.mie * miePhase(mu, m.mieG[c])) * sunT[c] + ms3[c] * med.scattering[c];
+        const v = single * e;
+        if (c === 0) sr += v;
+        else if (c === 1) sg += v;
+        else sb += v;
+      }
+    }
+    for (let c = 0; c < 3; c++) {
+      const ext = Math.max(med.extinction[c], 1e-9);
+      const stepT = Math.exp(-ext * dt);
+      const S = c === 0 ? sr : c === 1 ? sg : sb;
+      L[c] = L[c] + T[c] * S * (1 - stepT) / ext;
+      T[c] = T[c] * stepT;
+    }
+  }
+  if (ground) {
+    out.hitsGround = true;
+    const x = px + dx * t1;
+    const y = py + dy * t1;
+    const z = pz + dz * t1;
+    const len = Math.sqrt(x * x + y * y + z * z);
+    for (const sun of suns) {
+      const sx = sun.direction[0];
+      const sy = sun.direction[1];
+      const sz = sun.direction[2];
+      const ndl = Math.max(0, (x * sx + y * sy + z * sz) / len);
+      if (ndl <= 0) continue;
+      const k = 1.00001;
+      sunTransmittance(m, tlut, x * k, y * k, z * k, sx, sy, sz, sunT);
+      for (let c = 0; c < 3; c++) {
+        L[c] = L[c] + T[c] * sun.illuminance[c] * sunT[c] * ndl * m.albedo[c] / Math.PI;
+      }
+    }
+    T.fill(0);
+  }
+  for (let c = 0; c < 3; c++) L[c] = L[c] * m.intensity;
+  return out;
+}
+export {
+  MULTISCATTER_SIZE,
+  TRANSMITTANCE_H,
+  TRANSMITTANCE_STEPS,
+  TRANSMITTANCE_W,
+  createMedium,
+  createModel,
+  createSkySample,
+  integrateSky,
+  lookupMultiscatter,
+  lookupTransmittance,
+  mediumAt,
+  miePhase,
+  multiscatterLut,
+  raySphere,
+  rayleighPhase,
+  transmittanceLut,
+  transmittanceRMu,
+  transmittanceToTop,
+  transmittanceUnit
+};

package/dist/atmosphere-nodes.d.ts

@@ -0,0 +1,55 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import { GpuBuffer, type GpuContext } from '@aethervtt/shard-gpu';
+import { type AtmosphereRecord } from './atmosphere.js';
+/** Atmospheres whose LUTs stay on the GPU at once (layers of the LUT arrays). */
+export declare const LUT_LAYERS = 8;
+/** Per camera: its uniform, sky-view LUT, and aerial-perspective froxels. */
+interface CameraGpu {
+    uniform: GpuBuffer;
+    data: Float32Array;
+    skyView: GPUTexture | undefined;
+    scatter: GPUTexture | undefined;
+    transmittance: GPUTexture | undefined;
+    /** The frame the sky-view and froxels were last computed. */
+    computed: number;
+    generation: number;
+    seen: number;
+}
+export declare class AtmosphereGpu {
+    generation: number;
+    transmittance: GPUTexture;
+    multiscatter: GPUTexture;
+    transmittanceArray: GPUTextureView;
+    multiscatterArray: GPUTextureView;
+    clamp: GPUSampler;
+    repeat: GPUSampler;
+    /** The record in each layer, and the frame it was last listed. */
+    readonly owners: (AtmosphereRecord | undefined)[];
+    readonly used: Int32Array<ArrayBuffer>;
+    readonly params: GpuBuffer[];
+    readonly cameras: Map<number, CameraGpu>;
+    /** LUT recomputations so far (describe, and tests that nothing recomputes per frame). */
+    lutComputes: number;
+    lutFrame: number;
+    frame: number;
+    readonly pipelines: Map<string, GPUComputePipeline | GPURenderPipeline>;
+    layouts: Record<string, GPUBindGroupLayout> | undefined;
+    private readonly groups;
+    ensure(gpu: GpuContext): void;
+    /** A layer for a record: its own, a free one, or the least recently used. */
+    assign(rec: AtmosphereRecord): void;
+    camera(gpu: GpuContext, entity: Entity): CameraGpu;
+    group(gpu: GpuContext, slot: string, key: string, layout: GPUBindGroupLayout, entries: () => GPUBindGroupEntry[]): GPUBindGroup;
+}
+export declare const AtmosphereGpuResource: import("@aethervtt/shard-core").ResourceDef<AtmosphereGpu>;
+/**
+ * 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.
+ */
+export declare const uploadAtmospheres: import("@aethervtt/shard-core").SystemDef<undefined>;
+/**
+ * The LUT pass and per-view sky-view/froxel pass (registered before the environment prefilter,
+ * which bakes atmospheres into IBL), the sky pass, and the aerial-perspective composite.
+ */
+export declare function addAtmosphereNodes(world: World): void;
+export {};