@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/baseline/environment.js

@@ -0,0 +1,368 @@
+import { GpuBuffer } from "@aethervtt/shard-gpu";
+import { fragmentKernel } from "@aethervtt/shard-shader/fragment-kernel";
+import { ENVIRONMENT_SHADERS } from "../environment-shaders.js";
+import { LUT_SIZE, SPECULAR_MIPS, SPECULAR_SIZE } from "../environment-state.js";
+import { GpuAssetsResource } from "../gpu-assets.js";
+import { Shaders } from "../plugin.js";
+const SLOT = 256;
+const fragment = (root) => fragmentKernel(ENVIRONMENT_SHADERS[root], "main", root).source;
+const BASELINE_ENVIRONMENT_SHADERS = {
+  "shard::env::from_equirect::fragment": fragment("shard::env::from_equirect"),
+  "shard::env::from_cube::fragment": fragment("shard::env::from_cube"),
+  "shard::env::specular::fragment": fragment("shard::env::specular"),
+  "shard::env::brdf_lut::fragment": fragment("shard::env::brdf_lut"),
+  "shard::env::baseline::downsample": `
+import shard::env::common::cube_dir;
+
+/** The face's size and the face (as fragment kernels read their target). */
+@group(0) @binding(0) var<uniform> shard_target: vec4u;
+/** The level above, alone. */
+@group(0) @binding(1) var src: texture_cube<f32>;
+@group(0) @binding(2) var src_sampler: sampler;
+
+@fragment fn main(@builtin(position) p: vec4f) -> @location(0) vec4f {
+  // The centre of this texel is the corner its 2\xD72 block shares: bilinear weighs them equally.
+  let uv = (floor(p.xy) + 0.5) / f32(shard_target.x);
+  let c = textureSampleLevel(src, src_sampler, cube_dir(shard_target.w, uv), 0.0);
+  return vec4f(c.rgb, 1.0);
+}`,
+  "shard::env::baseline::sh": `
+import shard::env::common::{ PI, cube_dir, sh_basis };
+
+/** The level's size. */
+@group(0) @binding(0) var<uniform> shard_target: vec4u;
+/** The 32\xB2 level (or the smallest there is), alone. */
+@group(0) @binding(1) var src: texture_cube<f32>;
+@group(0) @binding(2) var src_sampler: sampler;
+
+/** Coefficient k (the fragment's x) of the SH9 irradiance, as the compute kernel writes it. */
+@fragment fn main(@builtin(position) p: vec4f) -> @location(0) vec4f {
+  let k = u32(p.x);
+  let n = shard_target.x;
+  var c = vec3f(0.0);
+  var total = 0.0;
+  for (var face = 0u; face < 6u; face++) {
+    for (var y = 0u; y < n; y++) {
+      for (var x = 0u; x < n; x++) {
+        let uv = (vec2f(f32(x), f32(y)) + 0.5) / f32(n);
+        let st = uv * 2.0 - 1.0;
+        // Solid angle of the texel.
+        let w = 4.0 / (f32(n * n) * pow(1.0 + dot(st, st), 1.5));
+        let d = cube_dir(face, uv);
+        let radiance = textureSampleLevel(src, src_sampler, d, 0.0).rgb;
+        c += radiance * sh_basis(d)[k] * w;
+        total += w;
+      }
+    }
+  }
+  // Normalize the solid angles to exactly 4\u03C0, then apply the cosine lobe (\xC2_l / \u03C0).
+  let band = array<f32, 9>(1.0, 2.0 / 3.0, 2.0 / 3.0, 2.0 / 3.0, 0.25, 0.25, 0.25, 0.25, 0.25);
+  return vec4f(c * (4.0 * PI / total) * band[k], 0.0);
+}`
+};
+const baselineBakers = /* @__PURE__ */ new Map();
+const ROOTS = {
+  equirect: "shard::env::from_equirect::fragment",
+  cube: "shard::env::from_cube::fragment",
+  downsample: "shard::env::baseline::downsample",
+  sh: "shard::env::baseline::sh",
+  specular: "shard::env::specular::fragment",
+  lut: "shard::env::brdf_lut::fragment"
+};
+const kernels = /* @__PURE__ */ new WeakMap();
+function kernelsOf(gpu) {
+  let k = kernels.get(gpu);
+  if (k && k.generation === gpu.generation) return k;
+  const F = GPUShaderStage.FRAGMENT;
+  const target = (binding) => ({
+    binding,
+    visibility: F,
+    buffer: { type: "uniform", hasDynamicOffset: true }
+  });
+  const cube = (binding) => ({
+    binding,
+    visibility: F,
+    texture: { sampleType: "float", viewDimension: "cube" }
+  });
+  const sampler = (binding) => ({
+    binding,
+    visibility: F,
+    sampler: { type: "filtering" }
+  });
+  const layout = (label, entries) => gpu.layouts.bindGroupLayout({ label: `env/baseline/${label}`, entries });
+  k = {
+    generation: gpu.generation,
+    layouts: {
+      equirect: layout("equirect", [
+        { binding: 0, visibility: F, texture: { sampleType: "float" } },
+        sampler(1),
+        target(2)
+      ]),
+      cube: layout("cube", [cube(0), sampler(1), target(2)]),
+      downsample: layout("downsample", [target(0), cube(1), sampler(2)]),
+      sh: layout("sh", [target(0), cube(1), sampler(2)]),
+      specular: layout("specular", [
+        cube(0),
+        sampler(1),
+        target(2),
+        { binding: 3, visibility: F, buffer: { type: "uniform" } }
+      ]),
+      lut: layout("lut", [target(0)])
+    },
+    pipelines: {},
+    shTarget: gpu.withOwner(
+      "gpu",
+      () => gpu.device.createTexture({
+        label: "environment/sh-target",
+        size: [9, 1],
+        format: "rgba32float",
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC
+      })
+    )
+  };
+  kernels.set(gpu, k);
+  return k;
+}
+function pipeline(world, gpu, k, name) {
+  const cached = k.pipelines[name];
+  if (cached) return cached;
+  const shaders = world.resource(Shaders);
+  const fs = shaders.module(gpu, { root: ROOTS[name] });
+  const vs = shaders.module(gpu, { root: "shard::fullscreen" });
+  if (!fs || !vs) return void 0;
+  const made = gpu.pipelines.render({
+    label: `env/baseline/${name}`,
+    layout: gpu.layouts.pipelineLayout({
+      label: `env/baseline/${name}`,
+      bindGroupLayouts: [k.layouts[name]]
+    }),
+    vertex: { module: vs, entryPoint: "vs" },
+    fragment: {
+      module: fs,
+      entryPoint: "main",
+      targets: [{ format: name === "sh" ? "rgba32float" : "rgba16float" }]
+    }
+  });
+  if (made) k.pipelines[name] = made;
+  return made;
+}
+function faceView(texture, face, mip) {
+  return texture.createView({
+    dimension: "2d",
+    baseArrayLayer: face,
+    arrayLayerCount: 1,
+    baseMipLevel: mip,
+    mipLevelCount: 1
+  });
+}
+class Targets {
+  data;
+  count = 0;
+  constructor(slots) {
+    this.data = new Uint32Array(slots * SLOT / 4);
+  }
+  /** Adds a slot for a `size`² face (or a width × 1 row); returns its byte offset. */
+  add(width, layer, height = width) {
+    const o = this.count * SLOT / 4;
+    this.data[o] = width;
+    this.data[o + 1] = height;
+    this.data[o + 2] = 1;
+    this.data[o + 3] = layer;
+    return this.count++ * SLOT;
+  }
+}
+function encode(ctx, k, draws) {
+  for (const d of draws) {
+    const pass = ctx.encoder.beginRenderPass({
+      label: d.label,
+      colorAttachments: [
+        { view: d.view, loadOp: "clear", storeOp: "store", clearValue: [0, 0, 0, 0] }
+      ]
+    });
+    pass.setPipeline(pipeline(ctx.world, ctx.gpu, k, d.kernel));
+    pass.setBindGroup(0, d.group, [d.offset]);
+    pass.draw(3);
+    pass.end();
+  }
+  draws.length = 0;
+}
+function runBaselineEnvironment(ctx, store) {
+  const world = ctx.world;
+  const gpu = ctx.gpu;
+  if (store.pending.length === 0 && store.lutReady) {
+    store.ranFrame = store.frame;
+    return;
+  }
+  const k = kernelsOf(gpu);
+  let missing = false;
+  for (const name of Object.keys(ROOTS))
+    if (!pipeline(world, gpu, k, name)) missing = true;
+  if (missing) {
+    gpu.pipelines.skipped++;
+    return;
+  }
+  store.ranFrame = store.frame;
+  const device = gpu.device;
+  const assets = world.resource(GpuAssetsResource);
+  const sampler = store.sampler;
+  const wrapU = gpu.layouts.sampler({
+    label: "environment/equirect",
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "repeat",
+    addressModeV: "clamp-to-edge"
+  });
+  const targets = new Targets(1 + store.pending.length * (6 + 6 * 10 + 1 + 6 * SPECULAR_MIPS));
+  const params = new GpuBuffer(gpu, {
+    label: "env/baseline/targets",
+    usage: GPUBufferUsage.UNIFORM,
+    size: targets.data.byteLength
+  });
+  const specularData = new Float32Array(SPECULAR_MIPS * SLOT / 4);
+  const specularParams = new GpuBuffer(gpu, {
+    label: "env/baseline/specular",
+    usage: GPUBufferUsage.UNIFORM,
+    size: specularData.byteLength
+  });
+  ctx.afterSubmit(() => {
+    params.destroy();
+    specularParams.destroy();
+  });
+  const target = { buffer: params.buffer, size: 16 };
+  const draws = [];
+  if (!store.lutReady) {
+    draws.push({
+      label: "environment/brdf-lut",
+      view: store.lut.createView(),
+      kernel: "lut",
+      group: device.createBindGroup({
+        layout: k.layouts.lut,
+        entries: [{ binding: 0, resource: target }]
+      }),
+      offset: targets.add(LUT_SIZE, 0)
+    });
+    store.lutReady = true;
+  }
+  const done = [];
+  for (const env of store.pending) {
+    const size = env.size;
+    if (env.kind === "map") {
+      const input = env.input && assets.texture(env.input);
+      if (!input) continue;
+      const cube = env.input.faces === 6;
+      const group = device.createBindGroup({
+        layout: cube ? k.layouts.cube : k.layouts.equirect,
+        entries: [
+          { binding: 0, resource: input.linear },
+          { binding: 1, resource: cube ? sampler : wrapU },
+          { binding: 2, resource: target }
+        ]
+      });
+      for (let face = 0; face < 6; face++) {
+        draws.push({
+          label: "environment/source",
+          view: faceView(env.source, face, 0),
+          kernel: cube ? "cube" : "equirect",
+          group,
+          offset: targets.add(size, face)
+        });
+      }
+    } else {
+      const bake = baselineBakers.get(env.kind);
+      if (!bake) continue;
+      encode(ctx, k, draws);
+      let ready = true;
+      for (let face = 0; face < 6 && ready; face++) {
+        ready = bake(ctx, env, face, faceView(env.source, face, 0));
+      }
+      if (!ready) continue;
+    }
+    const mips = Math.log2(size) + 1;
+    for (let m = 1; m < mips; m++) {
+      const group = device.createBindGroup({
+        layout: k.layouts.downsample,
+        entries: [
+          { binding: 0, resource: target },
+          {
+            binding: 1,
+            resource: env.source.createView({
+              dimension: "cube",
+              baseMipLevel: m - 1,
+              mipLevelCount: 1
+            })
+          },
+          { binding: 2, resource: sampler }
+        ]
+      });
+      for (let face = 0; face < 6; face++) {
+        draws.push({
+          label: "environment/mip",
+          view: faceView(env.source, face, m),
+          kernel: "downsample",
+          group,
+          offset: targets.add(Math.max(1, size >> m), face)
+        });
+      }
+    }
+    const shLevel = Math.max(0, Math.log2(size) - 5);
+    draws.push({
+      label: "environment/sh",
+      view: k.shTarget.createView(),
+      kernel: "sh",
+      group: device.createBindGroup({
+        layout: k.layouts.sh,
+        entries: [
+          { binding: 0, resource: target },
+          {
+            binding: 1,
+            resource: env.source.createView({
+              dimension: "cube",
+              baseMipLevel: shLevel,
+              mipLevelCount: 1
+            })
+          },
+          { binding: 2, resource: sampler }
+        ]
+      }),
+      offset: targets.add(Math.max(1, size >> shLevel), 0)
+    });
+    for (let m = 0; m < SPECULAR_MIPS; m++) {
+      const o = m * SLOT / 4;
+      specularData[o] = m / (SPECULAR_MIPS - 1);
+      specularData[o + 1] = size;
+      specularData[o + 2] = SPECULAR_SIZE >> m;
+      const group = device.createBindGroup({
+        layout: k.layouts.specular,
+        entries: [
+          { binding: 0, resource: env.sourceView },
+          { binding: 1, resource: sampler },
+          { binding: 2, resource: target },
+          { binding: 3, resource: { buffer: specularParams.buffer, offset: m * SLOT, size: 16 } }
+        ]
+      });
+      for (let face = 0; face < 6; face++) {
+        draws.push({
+          label: "environment/specular",
+          view: faceView(env.specular, face, m),
+          kernel: "specular",
+          group,
+          offset: targets.add(SPECULAR_SIZE >> m, face)
+        });
+      }
+    }
+    encode(ctx, k, draws);
+    ctx.encoder.copyTextureToBuffer({ texture: k.shTarget }, { buffer: env.sh.gpuBuffer }, [9, 1]);
+    env.state = "ready";
+    env.bakes++;
+    done.push(env);
+  }
+  encode(ctx, k, draws);
+  params.write(targets.data, 0, 0, targets.count * SLOT / 4);
+  specularParams.write(specularData);
+  for (const env of done) store.pending.splice(store.pending.indexOf(env), 1);
+}
+export {
+  BASELINE_ENVIRONMENT_SHADERS,
+  baselineBakers,
+  runBaselineEnvironment
+};

package/dist/baseline/exposure.d.ts

@@ -0,0 +1,25 @@
+import type { GpuContext } from '@aethervtt/shard-gpu';
+import type { NodeContext } from '../graph.js';
+export declare const METER_WIDTH = 64;
+export declare const METER_HEIGHT = 36;
+export declare const BASELINE_EXPOSURE_SHADERS: Record<string, string>;
+/** A view's meter image and its readbacks in flight. */
+export interface MeterView {
+    target: GPUTexture;
+    view: GPUTextureView;
+    params: GPUBuffer;
+    readbacks: GPUBuffer[];
+    busy: boolean[];
+    generation: number;
+    group: GPUBindGroup | undefined;
+    groupKey: string;
+}
+export declare function meterView(gpu: GpuContext, name: string, readbacks: number): MeterView;
+export declare function meterLayout(gpu: GpuContext): GPUBindGroupLayout;
+/**
+ * Renders the meter image and, when a readback is free, copies it out. Returns the readback that
+ * will hold it, or undefined when all are still mapping (this frame isn't metered).
+ */
+export declare function renderMeter(ctx: NodeContext, m: MeterView, pipeline: GPURenderPipeline, group: GPUBindGroup, range: Float32Array, glow: Float32Array): number | undefined;
+/** The meter image's samples binned into the full tier's histogram: weight into its EV bin. */
+export declare function binMeter(bytes: ArrayBuffer, minEv: number, binsPerEv: number, bins: Uint32Array): Uint32Array;

package/dist/baseline/exposure.js

@@ -0,0 +1,133 @@
+import { halfToFloat } from "../readback.js";
+const METER_WIDTH = 64;
+const METER_HEIGHT = 36;
+const BASELINE_EXPOSURE_SHADERS = {
+  "shard::post::baseline::meter": `
+import shard::view::view;
+import shard::color::luminance;
+@if(BLOOM) import shard::post::glow::add_glow;
+
+struct Meter {
+  /** EV of bin 0, bins per EV, metering mode, 0. */
+  range: vec4f,
+  /** The meter image's size. */
+  size: vec4f,
+  /** Bloom, which the tonemap adds to the image: intensity, level count, mix (1) or add (0). */
+  glow: vec4f,
+}
+
+@group(0) @binding(1) var input: texture_2d<f32>;
+@group(0) @binding(2) var<uniform> meter: Meter;
+@if(BLOOM) @group(0) @binding(3) var bloom: texture_2d<f32>;
+@if(BLOOM) @group(0) @binding(4) var bloom_sampler: sampler;
+
+/** One sample: the EV100 of the input pixel under it, and its metering weight (of 16). */
+@fragment fn main(@builtin(position) p: vec4f) -> @location(0) vec4f {
+  let size = textureDimensions(input);
+  let px = min(vec2u((floor(p.xy) + 0.5) / meter.size.xy * vec2f(size)), size - 1u);
+  var c = textureLoad(input, vec2i(px), 0).rgb;
+  // What the tonemap shows: the image with bloom's glow over it.
+  @if(BLOOM) {
+    let uv = (vec2f(px) + 0.5) / vec2f(size);
+    c = add_glow(c, textureSampleLevel(bloom, bloom_sampler, uv, 0.0).rgb, meter.glow);
+  }
+  let l = luminance(c) / max(view.exposure, 1e-20);
+  let ev = log2(max(l, 1e-10) * 8.0);
+  let q = vec2f(px) / vec2f(size) * 2.0 - 1.0;
+  let r = length(q * vec2f(f32(size.x) / f32(size.y), 1.0)) / 1.4142;
+  var w = 16.0;
+  if (meter.range.z == 1.0) { w = round(16.0 * exp(-r * r / 0.18)); }
+  if (meter.range.z == 2.0) { w = select(0.0, 16.0, r < 0.1); }
+  return vec4f(ev, w, 0.0, 1.0);
+}`
+};
+const BYTES = METER_WIDTH * METER_HEIGHT * 4;
+function meterView(gpu, name, readbacks) {
+  const target = gpu.device.createTexture({
+    label: `${name}/exposure-meter`,
+    size: [METER_WIDTH, METER_HEIGHT],
+    format: "rg16float",
+    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC
+  });
+  return {
+    target,
+    view: target.createView(),
+    params: gpu.device.createBuffer({
+      label: `${name}/exposure-meter`,
+      size: 48,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    }),
+    readbacks: Array.from(
+      { length: readbacks },
+      (_, i) => gpu.device.createBuffer({
+        label: `${name}/exposure-readback-${i}`,
+        size: BYTES,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+      })
+    ),
+    busy: Array.from({ length: readbacks }, () => false),
+    generation: gpu.generation,
+    group: void 0,
+    groupKey: ""
+  };
+}
+function meterLayout(gpu) {
+  const F = GPUShaderStage.FRAGMENT;
+  return gpu.layouts.bindGroupLayout({
+    label: "exposure/baseline",
+    entries: [
+      { binding: 0, visibility: F, buffer: { type: "uniform" } },
+      { binding: 1, visibility: F, texture: { sampleType: "unfilterable-float" } },
+      { binding: 2, visibility: F, buffer: { type: "uniform" } },
+      { binding: 3, visibility: F, texture: { sampleType: "float" } },
+      { binding: 4, visibility: F, sampler: { type: "filtering" } }
+    ]
+  });
+}
+const params = new Float32Array(12);
+function renderMeter(ctx, m, pipeline, group, range, glow) {
+  params.set(range, 0);
+  params[4] = METER_WIDTH;
+  params[5] = METER_HEIGHT;
+  params.set(glow, 8);
+  ctx.gpu.device.queue.writeBuffer(m.params, 0, params);
+  const pass = ctx.encoder.beginRenderPass({
+    label: `${ctx.view.name}/exposure`,
+    colorAttachments: [
+      { view: m.view, loadOp: "clear", storeOp: "store", clearValue: [0, 0, 0, 0] }
+    ]
+  });
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, group);
+  pass.draw(3);
+  pass.end();
+  const k = m.busy.indexOf(false);
+  if (k < 0) return void 0;
+  ctx.encoder.copyTextureToBuffer(
+    { texture: m.target },
+    { buffer: m.readbacks[k], bytesPerRow: METER_WIDTH * 4 },
+    [METER_WIDTH, METER_HEIGHT]
+  );
+  m.busy[k] = true;
+  return k;
+}
+function binMeter(bytes, minEv, binsPerEv, bins) {
+  bins.fill(0);
+  const h = new Uint16Array(bytes);
+  for (let i = 0; i < METER_WIDTH * METER_HEIGHT; i++) {
+    const w = halfToFloat(h[i * 2 + 1]);
+    if (w <= 0) continue;
+    const ev = halfToFloat(h[i * 2]);
+    bins[Math.min(255, Math.max(0, Math.floor((ev - minEv) * binsPerEv)))] += w;
+  }
+  return bins;
+}
+export {
+  BASELINE_EXPOSURE_SHADERS,
+  METER_HEIGHT,
+  METER_WIDTH,
+  binMeter,
+  meterLayout,
+  meterView,
+  renderMeter
+};

package/dist/baseline/lights.d.ts

@@ -0,0 +1,33 @@
+import type { GpuContext } from '@aethervtt/shard-gpu';
+import { type ViewLightList } from '../clusters.js';
+import { DataStore } from '../data-store.js';
+import type { CameraData } from '../view.js';
+/** Lights a view's uniform array holds on baseline (the bitmask's width). */
+export declare const BASELINE_MAX_LIGHTS = 128;
+export interface BaselineViewLights {
+    /** The packed light records (`@data(uniform, 128)` at binding 1). */
+    lights: DataStore;
+    /** Four u32 of light bits per cluster (`@data` at binding 2). */
+    bits: DataStore;
+    packed: Float32Array;
+    /** The light store slot of each packed light. */
+    slots: Uint32Array;
+    words: Uint32Array;
+    /** What the AABBs were made for, and the AABBs (8 floats per cluster). */
+    aabbKey: string;
+    aabbs: Float32Array;
+    /** Lights past the budget last frame (dropped, farthest first). */
+    dropped: number;
+    /** Lights in view last frame, dropped ones included. */
+    inView: number;
+    /** `dropped` as last reported to RenderHealth. */
+    reported: number;
+    count: number;
+}
+export declare function baselineViewLights(gpu: GpuContext, name: string): BaselineViewLights;
+/**
+ * Packs the view's visible lights (the nearest `max`, at most BASELINE_MAX_LIGHTS, when there are
+ * more) and sets each one's bit in every cluster it touches. `records` is the light store's data
+ * (LIGHT_FLOATS a slot); `list` the view's visible lights in view space.
+ */
+export declare function binBaselineLights(v: BaselineViewLights, list: ViewLightList, records: Float32Array, cam: CameraData, clusterFar: number, max: number): void;

package/dist/baseline/lights.js

@@ -0,0 +1,133 @@
+import {
+  CLUSTER_COUNT,
+  CLUSTER_X,
+  CLUSTER_Y,
+  CLUSTER_Z,
+  clusterAabbs,
+  clusterKey,
+  clusterRange,
+  lightTouchesCluster,
+  VIEW_LIGHT_FLOATS
+} from "../clusters.js";
+import { DataStore } from "../data-store.js";
+import { LIGHT_FLOATS } from "../lights.js";
+const BASELINE_MAX_LIGHTS = 128;
+function baselineViewLights(gpu, name) {
+  return {
+    lights: new DataStore(gpu, {
+      label: `${name}/lights`,
+      kind: "uniform",
+      size: BASELINE_MAX_LIGHTS * LIGHT_FLOATS * 4
+    }),
+    bits: new DataStore(gpu, { label: `${name}/cluster-bits`, size: CLUSTER_COUNT * 16 }),
+    packed: new Float32Array(BASELINE_MAX_LIGHTS * LIGHT_FLOATS),
+    slots: new Uint32Array(BASELINE_MAX_LIGHTS),
+    words: new Uint32Array(CLUSTER_COUNT * 4),
+    aabbKey: "",
+    aabbs: new Float32Array(CLUSTER_COUNT * 8),
+    dropped: 0,
+    inView: 0,
+    reported: 0,
+    count: 0
+  };
+}
+const box = new Float32Array(6);
+const order = new Uint32Array(4096);
+const keys = new Float64Array(4096);
+function binBaselineLights(v, list, records, cam, clusterFar, max) {
+  const budget = Math.max(0, Math.min(max, BASELINE_MAX_LIGHTS));
+  const key = clusterKey(cam, clusterFar);
+  if (key !== v.aabbKey) {
+    v.aabbKey = key;
+    clusterAabbs(v.aabbs, cam, clusterFar);
+  }
+  const light = list.data;
+  const u32 = list.u32;
+  let n = Math.min(list.count, order.length);
+  v.inView = n;
+  for (let i = 0; i < n; i++) order[i] = i;
+  if (n > budget) {
+    for (let i = 0; i < keys.length; i++) {
+      if (i >= n) {
+        keys[i] = Number.POSITIVE_INFINITY;
+        continue;
+      }
+      const o = 4 + i * VIEW_LIGHT_FLOATS;
+      const x = light[o];
+      const y = light[o + 1];
+      const z = light[o + 2];
+      const d = Math.max(0, Math.sqrt(x * x + y * y + z * z) - light[o + 3]);
+      keys[i] = Math.floor(Math.min(d, 1e9) * 256) * 4096 + i;
+    }
+    keys.sort();
+    for (let i = 0; i < n; i++) order[i] = keys[i] % 4096;
+  }
+  v.dropped = Math.max(0, n - budget);
+  n = Math.min(n, budget);
+  v.count = n;
+  v.words.fill(0);
+  const [near, far] = clusterRange(cam, clusterFar);
+  const logRatio = Math.log(far / near);
+  for (let k = 0; k < n; k++) {
+    const i = order[k];
+    const o = 4 + i * VIEW_LIGHT_FLOATS;
+    const slot = u32[o + 8];
+    v.slots[k] = slot;
+    v.packed.set(records.subarray(slot * LIGHT_FLOATS, (slot + 1) * LIGHT_FLOATS), k * LIGHT_FLOATS);
+    const px = light[o];
+    const py = light[o + 1];
+    const pz = light[o + 2];
+    const range = light[o + 3];
+    const d0 = Math.max(near, -pz - range);
+    const d1 = -pz + range;
+    if (d1 < near) continue;
+    const z0 = Math.max(0, Math.floor(Math.log(d0 / near) / logRatio * CLUSTER_Z) - 1);
+    const z1 = Math.min(CLUSTER_Z - 1, Math.floor(Math.log(d1 / near) / logRatio * CLUSTER_Z) + 1);
+    const p = cam.proj;
+    let nx0 = Number.POSITIVE_INFINITY;
+    let nx1 = Number.NEGATIVE_INFINITY;
+    let ny0 = Number.POSITIVE_INFINITY;
+    let ny1 = Number.NEGATIVE_INFINITY;
+    for (let e = 0; e < 4; e++) {
+      const x = e & 1 ? px + range : px - range;
+      const y = e & 1 ? py + range : py - range;
+      for (let q = 0; q < 2; q++) {
+        const d = q ? d1 : d0;
+        const ndcX = cam.orthographic ? x * p[0] + p[12] : x * p[0] / d;
+        const ndcY = cam.orthographic ? y * p[5] + p[13] : y * p[5] / d;
+        if (ndcX < nx0) nx0 = ndcX;
+        if (ndcX > nx1) nx1 = ndcX;
+        if (ndcY < ny0) ny0 = ndcY;
+        if (ndcY > ny1) ny1 = ndcY;
+      }
+    }
+    const x0 = Math.max(0, Math.floor((nx0 + 1) / 2 * CLUSTER_X) - 1);
+    const x1 = Math.min(CLUSTER_X - 1, Math.floor((nx1 + 1) / 2 * CLUSTER_X) + 1);
+    const y0 = Math.max(0, Math.floor((1 - ny1) / 2 * CLUSTER_Y) - 1);
+    const y1 = Math.min(CLUSTER_Y - 1, Math.floor((1 - ny0) / 2 * CLUSTER_Y) + 1);
+    const word = k >> 5;
+    const bit = 1 << (k & 31);
+    for (let z = z0; z <= z1; z++) {
+      for (let y = y0; y <= y1; y++) {
+        for (let x = x0; x <= x1; x++) {
+          const c = (z * CLUSTER_Y + y) * CLUSTER_X + x;
+          const a = c * 8;
+          box[0] = v.aabbs[a];
+          box[1] = v.aabbs[a + 1];
+          box[2] = v.aabbs[a + 2];
+          box[3] = v.aabbs[a + 4];
+          box[4] = v.aabbs[a + 5];
+          box[5] = v.aabbs[a + 6];
+          if (lightTouchesCluster(box, light, o)) v.words[c * 4 + word] |= bit;
+        }
+      }
+    }
+  }
+  v.lights.write(v.packed, 0, 0, Math.max(1, n) * LIGHT_FLOATS);
+  v.bits.write(v.words);
+}
+export {
+  BASELINE_MAX_LIGHTS,
+  baselineViewLights,
+  binBaselineLights
+};