@adobe/data-gpu 0.9.69

package/src/graphics/rendering/ibl-render/ibl/float-to-half.ts

@@ -0,0 +1,35 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// IEEE 754 binary16 (half-float) encoder. WebGPU's rgba16float upload path
+// expects Uint16-packed half-floats; Float32 source data has to be converted
+// element-wise. Standard bit-twiddle, no infinity/NaN edge cases needed for
+// well-formed HDRI input (subnormals are flushed to zero).
+
+const f32 = new Float32Array(1);
+const u32 = new Uint32Array(f32.buffer);
+
+export function floatToHalf(value: number): number {
+    f32[0] = value;
+    const bits = u32[0];
+
+    const sign = (bits >> 16) & 0x8000;
+    const expRaw = (bits >> 23) & 0xff;
+    const mantissa = bits & 0x7fffff;
+
+    if (expRaw === 0xff) {
+        // Infinity or NaN.
+        return sign | 0x7c00 | (mantissa ? 0x200 : 0);
+    }
+    const exp = expRaw - 127;
+    if (exp >= 16) return sign | 0x7c00;       // overflow → ±Inf
+    if (exp < -14) return sign;                  // underflow → ±0
+    return sign | ((exp + 15) << 10) | (mantissa >> 13);
+}
+
+export function floatArrayToHalf(src: Float32Array): Uint16Array {
+    const out = new Uint16Array(src.length);
+    for (let i = 0; i < src.length; i++) {
+        out[i] = floatToHalf(src[i]);
+    }
+    return out;
+}

package/src/graphics/rendering/ibl-render/ibl/ibl-math.wgsl.ts

@@ -0,0 +1,60 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// Shared WGSL math for IBL precomputation passes.
+// - cube_uv_to_dir: WebGPU cube layer (face 0..5) + 2D uv → world-space direction
+// - hammersley / radical_inverse_vdc: low-discrepancy 2D sample sequence
+// - importance_sample_ggx: GGX-distributed half-vector in tangent space, returned in world space
+
+export default /* wgsl */ `
+const PI: f32 = 3.14159265359;
+
+fn cube_uv_to_dir(face: u32, uv: vec2f) -> vec3f {
+    let p = uv * 2.0 - vec2f(1.0);
+    var dir: vec3f;
+    switch face {
+        case 0u: { dir = vec3f( 1.0, -p.y, -p.x); }
+        case 1u: { dir = vec3f(-1.0, -p.y,  p.x); }
+        case 2u: { dir = vec3f( p.x,  1.0,  p.y); }
+        case 3u: { dir = vec3f( p.x, -1.0, -p.y); }
+        case 4u: { dir = vec3f( p.x, -p.y,  1.0); }
+        default: { dir = vec3f(-p.x, -p.y, -1.0); }
+    }
+    return normalize(dir);
+}
+
+fn radical_inverse_vdc(bitsIn: u32) -> f32 {
+    var bits = bitsIn;
+    bits = (bits << 16u) | (bits >> 16u);
+    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+    return f32(bits) * 2.3283064365386963e-10;
+}
+
+fn hammersley(i: u32, n: u32) -> vec2f {
+    return vec2f(f32(i) / f32(n), radical_inverse_vdc(i));
+}
+
+fn importance_sample_ggx(xi: vec2f, N: vec3f, roughness: f32) -> vec3f {
+    let a = roughness * roughness;
+    let phi = 2.0 * PI * xi.x;
+    let cosTheta = sqrt((1.0 - xi.y) / (1.0 + (a * a - 1.0) * xi.y));
+    let sinTheta = sqrt(1.0 - cosTheta * cosTheta);
+    let H_tangent = vec3f(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta);
+
+    let up = select(vec3f(0.0, 0.0, 1.0), vec3f(1.0, 0.0, 0.0), abs(N.z) < 0.999);
+    let tangent = normalize(cross(up, N));
+    let bitangent = cross(N, tangent);
+
+    return normalize(tangent * H_tangent.x + bitangent * H_tangent.y + N * H_tangent.z);
+}
+
+fn g_smith_ibl(nDotV: f32, nDotL: f32, roughness: f32) -> f32 {
+    let a = roughness;
+    let k = (a * a) / 2.0;
+    let gv = nDotV / (nDotV * (1.0 - k) + k);
+    let gl = nDotL / (nDotL * (1.0 - k) + k);
+    return gv * gl;
+}
+`;

package/src/graphics/rendering/ibl-render/ibl/irradiance.ts

@@ -0,0 +1,105 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import iblMath from "./ibl-math.wgsl.js";
+import { createCubemap, cubeFaceView, cubemapSampleView, FULLSCREEN_VS } from "./render-helpers.js";
+
+// Cosine-weighted hemispherical Monte-Carlo convolution of the source
+// environment. With cos-weighted PDF, irradiance/π = mean(L(ωi)) — no extra
+// factor needed. 1024 samples is plenty for a 32x32 output.
+const IRRADIANCE_FS = /* wgsl */ `
+struct Params { face: u32, size: u32 };
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var envMap: texture_cube<f32>;
+@group(0) @binding(2) var envSampler: sampler;
+
+const SAMPLES: u32 = 1024u;
+
+fn convolve(N: vec3f) -> vec3f {
+    let up = select(vec3f(0.0, 0.0, 1.0), vec3f(1.0, 0.0, 0.0), abs(N.z) < 0.999);
+    let tangent = normalize(cross(up, N));
+    let bitangent = cross(N, tangent);
+
+    var acc = vec3f(0.0);
+    for (var i = 0u; i < SAMPLES; i = i + 1u) {
+        let xi = hammersley(i, SAMPLES);
+        let phi = 2.0 * PI * xi.x;
+        let cosTheta = sqrt(xi.y);
+        let sinTheta = sqrt(1.0 - xi.y);
+        let local = vec3f(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta);
+        let dir = normalize(tangent * local.x + bitangent * local.y + N * local.z);
+        acc = acc + textureSampleLevel(envMap, envSampler, dir, 0.0).rgb;
+    }
+    return acc / f32(SAMPLES);
+}
+
+@fragment
+fn fs_main(@builtin(position) frag: vec4f) -> @location(0) vec4f {
+    let uv = frag.xy / f32(params.size);
+    let N = cube_uv_to_dir(params.face, uv);
+    return vec4f(convolve(N), 1.0);
+}
+`;
+
+export function generateIrradiance(
+    device: GPUDevice,
+    encoder: GPUCommandEncoder,
+    envMap: GPUTexture,
+    size: number,
+): GPUTexture {
+    const format: GPUTextureFormat = "rgba16float";
+    const texture = createCubemap(device, size, format, 1);
+
+    const module = device.createShaderModule({ code: FULLSCREEN_VS + iblMath + IRRADIANCE_FS });
+    const bindGroupLayout = device.createBindGroupLayout({
+        entries: [
+            { binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+            { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+            { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+        ],
+    });
+    const pipeline = device.createRenderPipeline({
+        layout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] }),
+        vertex: { module, entryPoint: "vs_fullscreen" },
+        fragment: { module, entryPoint: "fs_main", targets: [{ format }] },
+        primitive: { topology: "triangle-list" },
+    });
+
+    const sampler = device.createSampler({
+        magFilter: "linear",
+        minFilter: "linear",
+        addressModeU: "clamp-to-edge",
+        addressModeV: "clamp-to-edge",
+        addressModeW: "clamp-to-edge",
+    });
+    const envView = cubemapSampleView(envMap);
+
+    for (let face = 0; face < 6; face++) {
+        const ub = device.createBuffer({
+            size: 16,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        device.queue.writeBuffer(ub, 0, new Uint32Array([face, size, 0, 0]));
+        const bindGroup = device.createBindGroup({
+            layout: bindGroupLayout,
+            entries: [
+                { binding: 0, resource: { buffer: ub } },
+                { binding: 1, resource: envView },
+                { binding: 2, resource: sampler },
+            ],
+        });
+        const pass = encoder.beginRenderPass({
+            colorAttachments: [{
+                view: cubeFaceView(texture, face, 0),
+                loadOp: "clear",
+                storeOp: "store",
+                clearValue: [0, 0, 0, 1],
+            }],
+        });
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, bindGroup);
+        pass.draw(3);
+        pass.end();
+    }
+
+    return texture;
+}

package/src/graphics/rendering/ibl-render/ibl/parse-hdr.ts

@@ -0,0 +1,108 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// Minimal Radiance .hdr / RGBE parser. Decodes the run-length encoded form
+// (standard for files written by HDRshop / Photosphere / Polyhaven) and
+// returns Float32 RGBA in row-major order. A=1 for every pixel.
+
+export interface ParsedHdr {
+    width: number;
+    height: number;
+    rgba: Float32Array;
+}
+
+export function parseHdr(buffer: ArrayBuffer): ParsedHdr {
+    const bytes = new Uint8Array(buffer);
+
+    // Header: ASCII, terminated by a blank line; then the resolution line.
+    const text = new TextDecoder("latin1").decode(bytes);
+    const headerEnd = text.indexOf("\n\n");
+    if (headerEnd < 0) throw new Error("HDR: missing header terminator");
+    const header = text.slice(0, headerEnd);
+    if (!header.startsWith("#?RADIANCE") && !header.startsWith("#?RGBE")) {
+        throw new Error("HDR: unknown magic");
+    }
+    if (!/FORMAT=32-bit_rle_rgbe/i.test(header)) {
+        throw new Error("HDR: only 32-bit_rle_rgbe is supported");
+    }
+
+    // Resolution: e.g. "-Y 512 +X 1024". Negative Y means top-to-bottom.
+    const resStart = headerEnd + 2;
+    const newline = bytes.indexOf(0x0a, resStart);
+    const resLine = new TextDecoder().decode(bytes.subarray(resStart, newline));
+    const m = /([+-][YX])\s+(\d+)\s+([+-][YX])\s+(\d+)/.exec(resLine);
+    if (!m) throw new Error(`HDR: bad resolution line "${resLine}"`);
+    const axisA = m[1], dimA = +m[2], axisB = m[3], dimB = +m[4];
+    // We only handle the common -Y +X / +Y +X orientations.
+    let width: number, height: number, flipY: boolean;
+    if (axisA[1] === "Y") {
+        height = dimA; width = dimB;
+        flipY = axisA[0] === "+";
+    } else {
+        width = dimA; height = dimB;
+        flipY = axisB[0] === "+";
+    }
+    if (axisA[1] === axisB[1]) throw new Error("HDR: redundant axes");
+
+    const data = bytes.subarray(newline + 1);
+    let p = 0;
+    const rgba = new Float32Array(width * height * 4);
+
+    const scanline = new Uint8Array(width * 4);
+    for (let y = 0; y < height; y++) {
+        if (p + 4 > data.length) throw new Error("HDR: truncated scanline header");
+        // RLE-encoded scanline: starts with 0x02 0x02 (hi lo) of width.
+        if (
+            data[p] === 0x02 && data[p + 1] === 0x02 &&
+            ((data[p + 2] << 8) | data[p + 3]) === width &&
+            width >= 8 && width <= 0x7fff
+        ) {
+            p += 4;
+            for (let c = 0; c < 4; c++) {
+                let x = 0;
+                while (x < width) {
+                    if (p >= data.length) throw new Error("HDR: truncated RLE channel");
+                    const len = data[p++];
+                    if (len > 128) {
+                        const runLen = len - 128;
+                        if (p >= data.length || x + runLen > width) throw new Error("HDR: bad run");
+                        const val = data[p++];
+                        for (let i = 0; i < runLen; i++) scanline[(x + i) * 4 + c] = val;
+                        x += runLen;
+                    } else {
+                        if (p + len > data.length || x + len > width) throw new Error("HDR: bad literal");
+                        for (let i = 0; i < len; i++) scanline[(x + i) * 4 + c] = data[p + i];
+                        p += len;
+                        x += len;
+                    }
+                }
+            }
+        } else {
+            // Old-style: raw RGBE pixels in raster order.
+            if (p + width * 4 > data.length) throw new Error("HDR: truncated raw scanline");
+            scanline.set(data.subarray(p, p + width * 4));
+            p += width * 4;
+        }
+
+        const dstY = flipY ? height - 1 - y : y;
+        const rowOffset = dstY * width * 4;
+        for (let x = 0; x < width; x++) {
+            const r = scanline[x * 4];
+            const g = scanline[x * 4 + 1];
+            const b = scanline[x * 4 + 2];
+            const e = scanline[x * 4 + 3];
+            if (e === 0) {
+                rgba[rowOffset + x * 4 + 0] = 0;
+                rgba[rowOffset + x * 4 + 1] = 0;
+                rgba[rowOffset + x * 4 + 2] = 0;
+            } else {
+                const scale = Math.pow(2, e - 128) / 256;
+                rgba[rowOffset + x * 4 + 0] = r * scale;
+                rgba[rowOffset + x * 4 + 1] = g * scale;
+                rgba[rowOffset + x * 4 + 2] = b * scale;
+            }
+            rgba[rowOffset + x * 4 + 3] = 1;
+        }
+    }
+
+    return { width, height, rgba };
+}

package/src/graphics/rendering/ibl-render/ibl/prefilter.ts

@@ -0,0 +1,121 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import iblMath from "./ibl-math.wgsl.js";
+import { createCubemap, cubeFaceView, cubemapSampleView, FULLSCREEN_VS } from "./render-helpers.js";
+
+// Split-sum prefiltered specular: each mip stores GGX importance-sampled
+// reflections at a fixed roughness. Mip 0 = mirror (roughness 0), mip max =
+// fully blurred (roughness 1). Uses Karis' simplification of N == V == R.
+const PREFILTER_FS = /* wgsl */ `
+struct Params { face: u32, size: u32, roughness: f32, _pad: f32 };
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var envMap: texture_cube<f32>;
+@group(0) @binding(2) var envSampler: sampler;
+
+const SAMPLES: u32 = 1024u;
+
+fn prefilter(N: vec3f) -> vec3f {
+    if (params.roughness < 0.001) {
+        return textureSampleLevel(envMap, envSampler, N, 0.0).rgb;
+    }
+    let V = N;
+    var color = vec3f(0.0);
+    var weight = 0.0;
+    for (var i = 0u; i < SAMPLES; i = i + 1u) {
+        let xi = hammersley(i, SAMPLES);
+        let H = importance_sample_ggx(xi, N, params.roughness);
+        let L = normalize(2.0 * dot(V, H) * H - V);
+        let nDotL = max(dot(N, L), 0.0);
+        if (nDotL > 0.0) {
+            color = color + textureSampleLevel(envMap, envSampler, L, 0.0).rgb * nDotL;
+            weight = weight + nDotL;
+        }
+    }
+    return color / max(weight, 0.0001);
+}
+
+@fragment
+fn fs_main(@builtin(position) frag: vec4f) -> @location(0) vec4f {
+    let uv = frag.xy / f32(params.size);
+    let N = cube_uv_to_dir(params.face, uv);
+    return vec4f(prefilter(N), 1.0);
+}
+`;
+
+export interface PrefilteredResult {
+    texture: GPUTexture;
+    mipLevelCount: number;
+}
+
+export function generatePrefiltered(
+    device: GPUDevice,
+    encoder: GPUCommandEncoder,
+    envMap: GPUTexture,
+    baseSize: number,
+    mipLevelCount: number,
+): PrefilteredResult {
+    const format: GPUTextureFormat = "rgba16float";
+    const texture = createCubemap(device, baseSize, format, mipLevelCount);
+
+    const module = device.createShaderModule({ code: FULLSCREEN_VS + iblMath + PREFILTER_FS });
+    const bindGroupLayout = device.createBindGroupLayout({
+        entries: [
+            { binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+            { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+            { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+        ],
+    });
+    const pipeline = device.createRenderPipeline({
+        layout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] }),
+        vertex: { module, entryPoint: "vs_fullscreen" },
+        fragment: { module, entryPoint: "fs_main", targets: [{ format }] },
+        primitive: { topology: "triangle-list" },
+    });
+
+    const sampler = device.createSampler({
+        magFilter: "linear",
+        minFilter: "linear",
+        addressModeU: "clamp-to-edge",
+        addressModeV: "clamp-to-edge",
+        addressModeW: "clamp-to-edge",
+    });
+    const envView = cubemapSampleView(envMap);
+
+    for (let mip = 0; mip < mipLevelCount; mip++) {
+        const mipSize = Math.max(1, baseSize >> mip);
+        const roughness = mipLevelCount > 1 ? mip / (mipLevelCount - 1) : 0;
+        for (let face = 0; face < 6; face++) {
+            const ub = device.createBuffer({
+                size: 16,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            });
+            const buf = new ArrayBuffer(16);
+            new Uint32Array(buf, 0, 2).set([face, mipSize]);
+            new Float32Array(buf, 8, 2).set([roughness, 0]);
+            device.queue.writeBuffer(ub, 0, buf);
+
+            const bindGroup = device.createBindGroup({
+                layout: bindGroupLayout,
+                entries: [
+                    { binding: 0, resource: { buffer: ub } },
+                    { binding: 1, resource: envView },
+                    { binding: 2, resource: sampler },
+                ],
+            });
+            const pass = encoder.beginRenderPass({
+                colorAttachments: [{
+                    view: cubeFaceView(texture, face, mip),
+                    loadOp: "clear",
+                    storeOp: "store",
+                    clearValue: [0, 0, 0, 1],
+                }],
+            });
+            pass.setPipeline(pipeline);
+            pass.setBindGroup(0, bindGroup);
+            pass.draw(3);
+            pass.end();
+        }
+    }
+
+    return { texture, mipLevelCount };
+}

package/src/graphics/rendering/ibl-render/ibl/render-helpers.ts

@@ -0,0 +1,17 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+export { createCubemap } from "./create-cubemap.js";
+export { cubeFaceView } from "./cube-face-view.js";
+export { cubemapSampleView } from "./cubemap-sample-view.js";
+
+// Fullscreen-triangle vertex shader: three vertices generate a clip-space
+// triangle that covers the viewport. The fragment shader then uses
+// @builtin(position) (framebuffer pixels) to derive per-fragment UVs.
+export const FULLSCREEN_VS = /* wgsl */ `
+@vertex
+fn vs_fullscreen(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f {
+    let xs = array<f32, 3>(-1.0, 3.0, -1.0);
+    let ys = array<f32, 3>(-1.0, -1.0, 3.0);
+    return vec4f(xs[i], ys[i], 0.0, 1.0);
+}
+`;