@aura3d/rendering 3.0.1 → 4.0.2

package/dist/resources/UniformBlock.js

@@ -0,0 +1,184 @@
+/**
+ * C-08 (PRD-01 §8.2, Phase 3) — std140 packer + `AuraFrame` UBO.
+ *
+ * `layoutStd140` computes the std140 offsets of a block field list; `UniformBlock`
+ * owns a `BufferUsage:"uniform"` buffer, a Float32Array staging view and
+ * `bindBufferBase` wiring through `RenderDevice.bindUniformBuffer`. `FrameUniforms`
+ * is the real `FrameUniformsLike`: `AuraFrame` at binding 0 in the frozen C-08
+ * order, uploaded once per `update()` via `bufferSubData`.
+ *
+ * The block's GLSL declaration is emitted from the same field list, so generated
+ * sources can never drift from the packed layout.
+ */
+import { RenderDeviceError } from "../RenderDevice.js";
+import { AURA_FRAME_BLOCK } from "../contracts/frameUniforms.js";
+/** std140 base alignment + footprint (floats) for the block types Aura3D emits. */
+function std140Shape(type) {
+    switch (type) {
+        case "float":
+        case "int":
+        case "uint":
+        case "bool":
+            return { align: 4, floats: 1 };
+        case "vec2":
+        case "ivec2":
+        case "uvec2":
+        case "bvec2":
+            return { align: 8, floats: 2 };
+        case "vec3":
+        case "ivec3":
+        case "uvec3":
+        case "bvec3":
+            return { align: 16, floats: 3 };
+        case "vec4":
+        case "ivec4":
+        case "uvec4":
+        case "bvec4":
+            return { align: 16, floats: 4 };
+        // Matrices: C columns stored at a vec4 stride (16B) each — mat2: 2×4 floats
+        // (32B), mat3: 3×4 (48B), mat4: 4×4 (64B).
+        case "mat2":
+            return { align: 16, floats: 8, columns: { rows: 2, count: 2 } };
+        case "mat3":
+            return { align: 16, floats: 12, columns: { rows: 3, count: 3 } };
+        case "mat4":
+            return { align: 16, floats: 16, columns: { rows: 4, count: 4 } };
+        default:
+            throw new RenderDeviceError(`Unsupported std140 field type "${type}"`, "UNSUPPORTED_UNIFORM_BLOCK_FIELD", { type });
+    }
+}
+const alignUp = (offset, align) => offset + ((align - (offset % align)) % align);
+/** Compute the std140 layout of `fields` (block size is 16-aligned). */
+export function layoutStd140(fields) {
+    const laidOut = [];
+    const offsets = new Map();
+    let offset = 0;
+    for (const [name, type] of fields) {
+        const { align, floats } = std140Shape(type);
+        offset = alignUp(offset, align);
+        if (offsets.has(name)) {
+            throw new RenderDeviceError(`Duplicate uniform block field "${name}"`, "UNIFORM_BLOCK_DUPLICATE_FIELD", { name });
+        }
+        offsets.set(name, offset);
+        laidOut.push({ name, type, offset, floats });
+        offset += floats * 4;
+    }
+    return { byteSize: alignUp(offset, 16), fields: laidOut, offsets };
+}
+/**
+ * Emit `layout(std140) uniform <name> { <type> <field>; ... };` for a block.
+ * T0-02: declarations carry no baked `binding=` — the device assigns the named
+ * block → binding-point mapping with `gl.uniformBlockBinding` post-link.
+ */
+export function uniformBlockGlsl(name, fields) {
+    const body = fields.map(([field, type]) => `  ${type} ${field};`).join("\n");
+    return `layout(std140) uniform ${name} {\n${body}\n};`;
+}
+/**
+ * A std140 uniform block: one `BufferUsage:"uniform"` buffer plus a Float32Array
+ * staging image. `set*` writes into staging; `upload()` pushes it with a single
+ * `bufferSubData` (PRD-01: uploaded once per view).
+ */
+export class UniformBlock {
+    device;
+    name;
+    layout;
+    buffer;
+    binding;
+    /** CPU staging image of the whole block (float units). */
+    data;
+    constructor(device, name, fields, options = {}) {
+        this.device = device;
+        this.name = name;
+        this.layout = layoutStd140(fields);
+        this.binding = options.binding ?? 0;
+        this.data = new Float32Array(this.layout.byteSize / 4);
+        this.buffer = device.createBuffer("uniform", this.layout.byteSize);
+    }
+    offsetOf(name) {
+        const offset = this.layout.offsets.get(name);
+        if (offset === undefined) {
+            throw new RenderDeviceError(`Unknown uniform block field "${name}"`, "UNIFORM_BLOCK_UNKNOWN_FIELD", {
+                block: this.name,
+                field: name
+            });
+        }
+        return offset;
+    }
+    /** Write a scalar/vector/matrix field (column-major for matrices). */
+    set(name, value) {
+        const offset = this.offsetOf(name) / 4;
+        const field = this.layout.fields.find((f) => f.name === name);
+        const shape = std140Shape(field.type);
+        if (shape.columns) {
+            // Column stride is a vec4 (16 bytes) in std140 even for mat2/mat3.
+            for (let c = 0; c < shape.columns.count; c += 1) {
+                for (let r = 0; r < shape.columns.rows; r += 1) {
+                    this.data[offset + c * 4 + r] = value[c * shape.columns.rows + r];
+                }
+            }
+            return;
+        }
+        for (let i = 0; i < shape.floats; i += 1) {
+            this.data[offset + i] = value[i];
+        }
+    }
+    /** Push the staging image to the GPU once (bufferSubData over the whole block). */
+    upload() {
+        this.device.updateBuffer(this.buffer, 0, this.data);
+    }
+    /** `bindBufferBase(UNIFORM_BUFFER, binding, buffer)`. */
+    bind() {
+        this.device.bindUniformBuffer?.(this.buffer, this.binding);
+    }
+    dispose() {
+        this.buffer.dispose();
+    }
+}
+/** AuraFrame binding point (C-08 frozen). */
+export const AURA_FRAME_BINDING = 0;
+/** AuraLights binding point; layout owned by PRD 02 inside the C-08 name. */
+export const AURA_LIGHTS_BINDING = 1;
+/**
+ * C-08 real `FrameUniformsLike`: the `AuraFrame` block at binding 0. `update()`
+ * packs the frozen field order and uploads once; `viewport` must be refreshed by
+ * the caller per view so `u_resolutionFarTime.xy` reports render pixels.
+ */
+export class FrameUniforms {
+    block;
+    /** Render-target pixels for `u_resolutionFarTime.xy`; caller sets per view. */
+    viewport = { width: 0, height: 0 };
+    constructor(device, options = {}) {
+        this.block = new UniformBlock(device, "AuraFrame", AURA_FRAME_BLOCK, {
+            binding: options.binding ?? AURA_FRAME_BINDING
+        });
+    }
+    get buffer() {
+        return this.block.buffer;
+    }
+    get byteSize() {
+        return this.block.layout.byteSize;
+    }
+    /** GLSL declaration for generated programs (`layout(std140)`; bound at link). */
+    glsl() {
+        return uniformBlockGlsl("AuraFrame", AURA_FRAME_BLOCK);
+    }
+    update(camera, timeSeconds, exposure, flags) {
+        this.block.set("u_view", camera.viewMatrix);
+        this.block.set("u_projection", camera.projectionMatrix);
+        this.block.set("u_viewProjection", camera.viewProjectionMatrix);
+        this.block.set("u_prevViewProjection", camera.previousViewProjectionMatrix ?? camera.viewProjectionMatrix);
+        this.block.set("u_cameraPositionNear", [camera.position[0], camera.position[1], camera.position[2], camera.near]);
+        this.block.set("u_resolutionFarTime", [this.viewport.width, this.viewport.height, camera.far, timeSeconds]);
+        const orthoBit = camera.projection === "orthographic" ? 1 : 0;
+        this.block.set("u_exposureFlags", [exposure, flags | orthoBit, 0, 0]);
+        this.block.upload();
+    }
+    bind() {
+        this.block.bind();
+    }
+    dispose() {
+        this.block.dispose();
+    }
+}
+//# sourceMappingURL=UniformBlock.js.map

package/dist/resources/UniformBlock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniformBlock.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/resources/UniformBlock.ts"],"names":[],"mappings":"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"}

package/dist/shaders/camera-fade.glsl.d.ts

@@ -0,0 +1,26 @@
+import type { ShaderChunk, ShaderFeature } from "../contracts/program.js";
+import type { FrameContributor } from "../contracts/frameGraph.js";
+/** Uniform declarations + Bayer helper, inserted at `fragment:pars`. */
+export declare const cameraFadeParsChunk: ShaderChunk;
+/** First alpha-stage statement: the guarded stipple discard itself. */
+export declare const cameraFadeDiscardChunk: ShaderChunk;
+/**
+ * Per-frame pattern offset (px). The `prd08.occluderFade` contributor sets it
+ * from `FrameContributorContext.frameIndex` when a registered C-13 pass has
+ * "taa" in its id; otherwise it stays (0,0). Module state is the only channel
+ * between a collect-phase contributor and per-draw `bindUniforms`.
+ */
+export declare const cameraFadeOffset: [number, number];
+/** Called once per frame by the `prd08.cameraFadeOffset` contributor. */
+export declare function setCameraFadeOffset(frameIndex: number, taaActive: boolean): void;
+/**
+ * S-2 offset channel: advances `u_cameraFadeOffset` from
+ * `FrameContributorContext.frameIndex` only when a registered C-13 pass has
+ * "taa" in its id. Registered from `lanes/prd08.ts` (rendering side) so the
+ * engine-side occluder-fade contributor never needs to reach this module.
+ */
+export declare function createCameraFadeOffsetContributor(): FrameContributor;
+export declare const CAMERA_FADE_BIT = "cameraFade";
+export declare const cameraFadeFeature: ShaderFeature;
+export declare function registerCameraFadeShader(registerChunk: (c: ShaderChunk) => void, registerFeature: (f: ShaderFeature) => () => void): () => void;
+//# sourceMappingURL=camera-fade.glsl.d.ts.map

package/dist/shaders/camera-fade.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-fade.glsl.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/shaders/camera-fade.glsl.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAgBhE,wEAAwE;AACxE,eAAO,MAAM,mBAAmB,EAAE,WAiBjC,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,sBAAsB,EAAE,WAOpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAU,CAAC;AAIzD,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CAIhF;AAMD;;;;;GAKG;AACH,wBAAgB,iCAAiC,IAAI,gBAAgB,CAYpE;AAED,eAAO,MAAM,eAAe,eAAe,CAAC;AAE5C,eAAO,MAAM,iBAAiB,EAAE,aAqB/B,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,aAAa,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,MAAM,IAAI,GAAG,MAAM,IAAI,CAI/I"}

package/dist/shaders/camera-fade.glsl.js

@@ -0,0 +1,109 @@
+import { registeredPostPasses } from "../contracts/post.js";
+const BAYER_GLSL = `float a3dBayer4(vec2 p) {
+  ivec2 i = ivec2(mod(floor(p), 4.0));
+  int idx = i.x + i.y * 4;
+  const float m[16] = float[16](0.,8.,2.,10.,12.,4.,14.,6.,3.,11.,1.,9.,15.,7.,13.,5.);
+  return (m[idx] + 0.5) / 16.0;
+}`;
+const BAYER_WGSL = `fn a3dBayer4(p: vec2<f32>) -> f32 {
+  let m = array<f32, 16>(0.,8.,2.,10.,12.,4.,14.,6.,3.,11.,1.,9.,15.,7.,13.,5.);
+  let i = vec2<i32>(floor(p) % vec2<f32>(4.0));
+  return (m[i.x + i.y * 4] + 0.5) / 16.0;
+}`;
+/** Uniform declarations + Bayer helper, inserted at `fragment:pars`. */
+export const cameraFadeParsChunk = {
+    name: "a3d_prd08_cameraFadePars",
+    owner: "prd08",
+    stage: "fragment",
+    glsl: `uniform float u_cameraFade;
+uniform vec2 u_cameraFadeOffset;   // per-frame pattern offset in pixels, integer 0..3
+${BAYER_GLSL}
+void a3dCameraFadeDiscard() {
+  if (u_cameraFade < 0.999 && a3dBayer4(gl_FragCoord.xy + u_cameraFadeOffset) >= u_cameraFade) discard;
+}
+`,
+    wgsl: `@group(1) @binding(0) var<uniform> a3dCameraFadeParams: vec4<f32>; // x: fade, yz: offset
+${BAYER_WGSL}
+fn a3dCameraFadeDiscard(pos: vec4<f32>, params: vec4<f32>) {
+  if (params.x < 0.999 && a3dBayer4(pos.xy + params.yz) >= params.x) { discard; }
+}
+`
+};
+/** First alpha-stage statement: the guarded stipple discard itself. */
+export const cameraFadeDiscardChunk = {
+    name: "a3d_prd08_cameraFadeDiscard",
+    owner: "prd08",
+    stage: "fragment",
+    requires: ["a3d_prd08_cameraFadePars"],
+    glsl: `a3dCameraFadeDiscard();`,
+    wgsl: `a3dCameraFadeDiscard(a3dFragCoord, a3dCameraFadeParams);`
+};
+/**
+ * Per-frame pattern offset (px). The `prd08.occluderFade` contributor sets it
+ * from `FrameContributorContext.frameIndex` when a registered C-13 pass has
+ * "taa" in its id; otherwise it stays (0,0). Module state is the only channel
+ * between a collect-phase contributor and per-draw `bindUniforms`.
+ */
+export const cameraFadeOffset = [0, 0];
+const OFFSET_CYCLE = [[0, 0], [2, 2], [2, 0], [0, 2]];
+/** Called once per frame by the `prd08.cameraFadeOffset` contributor. */
+export function setCameraFadeOffset(frameIndex, taaActive) {
+    const next = taaActive ? OFFSET_CYCLE[Math.abs(frameIndex | 0) % OFFSET_CYCLE.length] : OFFSET_CYCLE[0];
+    cameraFadeOffset[0] = next[0];
+    cameraFadeOffset[1] = next[1];
+}
+function taaRegistered() {
+    return registeredPostPasses().some((p) => p.id.toLowerCase().includes("taa"));
+}
+/**
+ * S-2 offset channel: advances `u_cameraFadeOffset` from
+ * `FrameContributorContext.frameIndex` only when a registered C-13 pass has
+ * "taa" in its id. Registered from `lanes/prd08.ts` (rendering side) so the
+ * engine-side occluder-fade contributor never needs to reach this module.
+ */
+export function createCameraFadeOffsetContributor() {
+    return {
+        id: "prd08.cameraFadeOffset",
+        owner: "prd08",
+        flag: "A3D_QR_CAMERA",
+        phases: ["collect"],
+        collect(items, ctx) {
+            if (ctx.flags.on("A3D_QR_CAMERA"))
+                setCameraFadeOffset(ctx.frameIndex, taaRegistered());
+            else
+                setCameraFadeOffset(0, false);
+            return items;
+        }
+    };
+}
+export const CAMERA_FADE_BIT = "cameraFade";
+export const cameraFadeFeature = {
+    id: "prd08.cameraFade",
+    owner: "prd08",
+    flag: "A3D_QR_CAMERA",
+    chunks: ["a3d_prd08_cameraFadePars", "a3d_prd08_cameraFadeDiscard"],
+    hooks: ["fragment:pars", "fragment:alpha"],
+    select(input) {
+        const fade = input.item.cameraFade;
+        // Shadow/depth variants never request the feature (C-11): the occluder
+        // still casts onto the subject while it fades visually.
+        if (input.pass !== "forward")
+            return undefined;
+        if (fade === undefined || fade >= 0.999)
+            return undefined;
+        return CAMERA_FADE_BIT;
+    },
+    defines() {
+        return { A3D_CAMERA_FADE: true };
+    },
+    bindUniforms(_value, item, set) {
+        set("u_cameraFade", item.cameraFade ?? 1);
+        set("u_cameraFadeOffset", [cameraFadeOffset[0], cameraFadeOffset[1]]);
+    }
+};
+export function registerCameraFadeShader(registerChunk, registerFeature) {
+    registerChunk(cameraFadeParsChunk);
+    registerChunk(cameraFadeDiscardChunk);
+    return registerFeature(cameraFadeFeature);
+}
+//# sourceMappingURL=camera-fade.glsl.js.map

package/dist/shaders/camera-fade.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-fade.glsl.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/shaders/camera-fade.glsl.ts"],"names":[],"mappings":"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"}

package/dist/shaders/chunks/contact_shadow.glsl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * a3d_prd02_contact_shadow — screen-space contact shadow march
+ * (PRD-02 §6.5/§8.6). Marches up to 16 steps along the primary shadowed
+ * light's view-space direction over `length` against the scene depth buffer
+ * (linearized to metres), with a `thickness` test and interleaved-gradient
+ * noise jitter. Returns a soft [0,1] visibility applied inside that light's
+ * V_l only — never to total colour. The pass reports
+ * contactShadows.passExecuted through C-31 diagnostics.
+ */
+export declare const CONTACT_SHADOW_CHUNK_ID = "a3d_prd02_contact_shadow";
+export declare const CONTACT_SHADOW_CHUNK_GLSL = "\nuniform highp sampler2D u_prd02ContactDepth;     // scene depth buffer ([0,1])\nuniform mat4 u_prd02ContactInvProj;              // clip -> view\nuniform mat4 u_prd02ContactProj;                 // view -> clip\nuniform vec3 u_prd02ContactSun;                  // shadowed-light dir, view space\nuniform vec4 u_prd02ContactParams;               // (length_m, thickness_m, steps, jitter)\nuniform vec2 u_prd02ContactNearFar;              // (near, far)\n\nfloat a3d_prd02ContactNoise(vec2 px) {\n  return fract(52.9829189 * fract(0.06711056 * px.x + 0.00583715 * px.y));\n}\n\nfloat a3d_prd02ContactLinear(float z) {\n  float n = u_prd02ContactNearFar.x;\n  float f = u_prd02ContactNearFar.y;\n  return (n * f) / (f - z * (f - n));\n}\n\nfloat a3d_contactShadow(vec2 uv) {\n  float sceneZ = texture(u_prd02ContactDepth, uv).r;\n  vec4 ndc = vec4(uv * 2.0 - 1.0, sceneZ * 2.0 - 1.0, 1.0);\n  vec4 vpos = u_prd02ContactInvProj * ndc;\n  vec3 pos = vpos.xyz / vpos.w;\n  float len = u_prd02ContactParams.x;\n  float thickness = u_prd02ContactParams.y;\n  float steps = max(u_prd02ContactParams.z, 1.0);\n  float jitter = a3d_prd02ContactNoise(gl_FragCoord.xy) * u_prd02ContactParams.w;\n  float occluded = 0.0;\n  for (int i = 1; i <= 16; i++) {\n    if (float(i) > steps) break;\n    float t = (float(i) - jitter) / steps;\n    vec3 p = pos + u_prd02ContactSun * (t * len);\n    vec4 clip = u_prd02ContactProj * vec4(p, 1.0);\n    vec3 r = clip.xyz / clip.w;\n    vec2 suv = r.xy * 0.5 + 0.5;\n    if (suv.x < 0.0 || suv.x > 1.0 || suv.y < 0.0 || suv.y > 1.0) continue;\n    float blocker = a3d_prd02ContactLinear(texture(u_prd02ContactDepth, suv).r);\n    if (blocker < -p.z - thickness) occluded = max(occluded, 1.0 - t);\n  }\n  return 1.0 - occluded;\n}\n";
+//# sourceMappingURL=contact_shadow.glsl.d.ts.map

package/dist/shaders/chunks/contact_shadow.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact_shadow.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/contact_shadow.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,6BAA6B,CAAC;AAElE,eAAO,MAAM,yBAAyB,muDAyCrC,CAAC"}

package/dist/shaders/chunks/contact_shadow.glsl.js

@@ -0,0 +1,53 @@
+/**
+ * a3d_prd02_contact_shadow — screen-space contact shadow march
+ * (PRD-02 §6.5/§8.6). Marches up to 16 steps along the primary shadowed
+ * light's view-space direction over `length` against the scene depth buffer
+ * (linearized to metres), with a `thickness` test and interleaved-gradient
+ * noise jitter. Returns a soft [0,1] visibility applied inside that light's
+ * V_l only — never to total colour. The pass reports
+ * contactShadows.passExecuted through C-31 diagnostics.
+ */
+export const CONTACT_SHADOW_CHUNK_ID = "a3d_prd02_contact_shadow";
+export const CONTACT_SHADOW_CHUNK_GLSL = /* glsl */ `
+uniform highp sampler2D u_prd02ContactDepth;     // scene depth buffer ([0,1])
+uniform mat4 u_prd02ContactInvProj;              // clip -> view
+uniform mat4 u_prd02ContactProj;                 // view -> clip
+uniform vec3 u_prd02ContactSun;                  // shadowed-light dir, view space
+uniform vec4 u_prd02ContactParams;               // (length_m, thickness_m, steps, jitter)
+uniform vec2 u_prd02ContactNearFar;              // (near, far)
+
+float a3d_prd02ContactNoise(vec2 px) {
+  return fract(52.9829189 * fract(0.06711056 * px.x + 0.00583715 * px.y));
+}
+
+float a3d_prd02ContactLinear(float z) {
+  float n = u_prd02ContactNearFar.x;
+  float f = u_prd02ContactNearFar.y;
+  return (n * f) / (f - z * (f - n));
+}
+
+float a3d_contactShadow(vec2 uv) {
+  float sceneZ = texture(u_prd02ContactDepth, uv).r;
+  vec4 ndc = vec4(uv * 2.0 - 1.0, sceneZ * 2.0 - 1.0, 1.0);
+  vec4 vpos = u_prd02ContactInvProj * ndc;
+  vec3 pos = vpos.xyz / vpos.w;
+  float len = u_prd02ContactParams.x;
+  float thickness = u_prd02ContactParams.y;
+  float steps = max(u_prd02ContactParams.z, 1.0);
+  float jitter = a3d_prd02ContactNoise(gl_FragCoord.xy) * u_prd02ContactParams.w;
+  float occluded = 0.0;
+  for (int i = 1; i <= 16; i++) {
+    if (float(i) > steps) break;
+    float t = (float(i) - jitter) / steps;
+    vec3 p = pos + u_prd02ContactSun * (t * len);
+    vec4 clip = u_prd02ContactProj * vec4(p, 1.0);
+    vec3 r = clip.xyz / clip.w;
+    vec2 suv = r.xy * 0.5 + 0.5;
+    if (suv.x < 0.0 || suv.x > 1.0 || suv.y < 0.0 || suv.y > 1.0) continue;
+    float blocker = a3d_prd02ContactLinear(texture(u_prd02ContactDepth, suv).r);
+    if (blocker < -p.z - thickness) occluded = max(occluded, 1.0 - t);
+  }
+  return 1.0 - occluded;
+}
+`;
+//# sourceMappingURL=contact_shadow.glsl.js.map

package/dist/shaders/chunks/contact_shadow.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact_shadow.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/contact_shadow.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,0BAA0B,CAAC;AAElE,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCnD,CAAC"}

package/dist/shaders/chunks/lighting_ibl.glsl.d.ts

@@ -0,0 +1,29 @@
+/**
+ * a3d_prd02_lighting_ibl — environment terms (PRD-02 §8.1).
+ * Uniform names follow §8.1 verbatim (they live in the A3DEnvironment
+ * std140 block; bound by environment/EnvUniforms.ts):
+ *   u_envSpecular (RGBA16F mip-mapped cube), u_envMipCount, u_envRotation,
+ *   u_envDiffuseIntensity, u_envSpecularIntensity, u_envSH[7]
+ *   (27 irradiance coefficients, cosine constants folded at upload),
+ *   u_ambientIrradiance, u_hemiSky/u_hemiGround (pre-multiplied),
+ *   u_hemiDirection. Plus u_envDfgLut for the split-sum DFG lookup.
+ */
+export declare const LIGHTING_IBL_CHUNK_GLSL = "\nuniform samplerCube u_envSpecular;\nuniform sampler2D u_envDfgLut;\nuniform float u_envMipCount;\nuniform float u_envRotation;\nuniform float u_envDiffuseIntensity;\nuniform float u_envSpecularIntensity;\nuniform vec4 u_envSH[7];\nuniform vec3 u_ambientIrradiance;\nuniform vec3 u_hemiSky;\nuniform vec3 u_hemiGround;\nuniform vec3 u_hemiDirection;\n\nvec3 a3dRotateY(vec3 d, float a) {\n  float c = cos(a), s = sin(a);\n  return vec3(c * d.x - s * d.z, d.y, s * d.x + c * d.z);\n}\n\n// (N-1)\u00B7r\u00B7(2-r) \u2014 identical to workers/cpuPrefilter.ts roughnessToLod.\nfloat a3dRoughnessToLod(float r) {\n  r = clamp(r, 0.0, 1.0);\n  return (u_envMipCount - 1.0) * r * (2.0 - r);\n}\n\n// Unpack 27 folded coefficients from u_envSH[7] and evaluate\n// Ramamoorthi\u2013Hanrahan irradiance at n. packEnvSH already folds the cosine\n// band constants A_l = {\u03C0, 2\u03C0/3, \u03C0/4} into the coefficients, so only the\n// plain real-SH basis Y_lm(n) is applied here (02 IBL fix: the previous\n// constants multiplied A_l a second time).\nvec3 a3dSH9Irradiance(vec3 n) {\n  n = normalize(n);\n  float x = n.x, y = n.y, z = n.z;\n  vec3 c0 = u_envSH[0].xyz;\n  vec3 c1 = vec3(u_envSH[0].w, u_envSH[1].x, u_envSH[1].y);\n  vec3 c2 = vec3(u_envSH[1].z, u_envSH[1].w, u_envSH[2].x);\n  vec3 c3 = u_envSH[2].yzw;\n  vec3 c4 = u_envSH[3].xyz;\n  vec3 c5 = vec3(u_envSH[3].w, u_envSH[4].x, u_envSH[4].y);\n  vec3 c6 = vec3(u_envSH[4].z, u_envSH[4].w, u_envSH[5].x);\n  vec3 c7 = u_envSH[5].yzw;\n  vec3 c8 = u_envSH[6].xyz;\n  vec3 E = c0 * 0.282095;\n  E += c1 * (-0.488603 * y) + c2 * (0.488603 * z) + c3 * (-0.488603 * x);\n  E += c4 * (1.092548 * x * y) + c5 * (1.092548 * y * z);\n  E += c6 * (0.315392 * (3.0 * z * z - 1.0));\n  E += c7 * (1.092548 * x * z) + c8 * (0.546274 * (x * x - y * y));\n  return max(E, vec3(0.0));\n}\n\nvec3 a3dIndirectDiffuseIrradiance(vec3 n) {\n  vec3 E = a3dSH9Irradiance(a3dRotateY(n, u_envRotation)) * u_envDiffuseIntensity;\n  E += u_ambientIrradiance;\n  E += mix(u_hemiGround, u_hemiSky, dot(n, u_hemiDirection) * 0.5 + 0.5);\n  return E; // caller multiplies by kd*albedo/PI and ao\n}\n\nvec3 a3dEnvSpecularRadiance(vec3 n, vec3 v, float r) {\n  vec3 R = reflect(-v, n);\n  R = normalize(mix(R, n, r * r * r * r)); // three getIBLRadiance bend\n  return textureLod(u_envSpecular, a3dRotateY(R, u_envRotation), a3dRoughnessToLod(r)).rgb * u_envSpecularIntensity;\n}\n\n// Lagarde 2014 specular occlusion.\nfloat a3dSpecularOcclusion(float NoV, float ao, float r) {\n  return clamp(pow(NoV + ao, exp2(-16.0 * r - 1.0)) - 1.0 + ao, 0.0, 1.0);\n}\n\nfloat a3dHorizonOcclusion(vec3 R, vec3 Ng) {\n  float h = min(1.0 + dot(R, Ng), 1.0);\n  return h * h;\n}\n\n// DFG LUT (Karis): texelFetch at (ndv, roughness) \u2192 (scale, bias) on F0.\nvec2 a3d_dfg(float ndv, float roughness) {\n  return texture(u_envDfgLut, vec2(clamp(ndv, 0.0, 1.0), clamp(roughness, 0.0, 1.0))).rg;\n}\n\nvec3 a3d_iblSpecular(vec3 n, vec3 v, float roughness, vec3 f0) {\n  vec2 dfg = a3d_dfg(max(dot(n, v), 0.0), roughness);\n  return a3dEnvSpecularRadiance(n, v, roughness) * (f0 * dfg.x + dfg.y);\n}\n\n// Fresnel for the diffuse lobe (roughness-aware Schlick).\nvec3 a3d_iblDiffuseFresnel(vec3 f0, float roughness, float ndv) {\n  vec3 fr = max(vec3(1.0 - roughness), f0) - f0;\n  return f0 + fr * pow(1.0 - ndv, 5.0);\n}\n";
+/**
+ * a3d_prd02_lighting_ibl_call — the E3 stage-2b replacement
+ * `fragment:indirect` body (statements only; spliced inside `main` where
+ * `V`, `N`, `material`, `indirectDiffuse` and `indirectSpecular` exist).
+ * The C-02 generator emits this INSTEAD of its default indirect body under
+ * the E3 conjunction — never in addition to it — so ambient, sampled and
+ * procedural terms cannot stack.
+ *
+ * Units: `a3dIndirectDiffuseIrradiance` sums the SH9/hemisphere irradiance
+ * with `u_ambientIrradiance`, which the packer stores as exit radiance
+ * (already x1/pi, `ambientToExitRadiance`). The ambient term is therefore
+ * split back out of the irradiance fed to the r185 multiscatter helpers
+ * (which divide by pi) and applied once as exit radiance. `a3dEnvIrradiance`
+ * keeps the name/scale the C-03 lobe IBL calls read from the default body
+ * (true irradiance, cf. `PI * a3dSampleEnvironment(N, 8.0)` there).
+ */
+export declare const LIGHTING_IBL_CALL_GLSL = "\nvec3 a3dPrd02Irradiance = a3dIndirectDiffuseIrradiance(N);\nvec3 a3dEnvIrradiance = max(a3dPrd02Irradiance - u_ambientIrradiance, vec3(0.0));\nindirectDiffuse += a3dIndirectDiffuse(a3dEnvIrradiance, V, N, material);\nindirectDiffuse += u_ambientIrradiance * material.diffuseContribution;\nindirectSpecular += a3dIndirectSpecular(a3dEnvSpecularRadiance(N, V, material.roughness), a3dEnvIrradiance, V, N, material);\n";
+//# sourceMappingURL=lighting_ibl.glsl.d.ts.map

package/dist/shaders/chunks/lighting_ibl.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lighting_ibl.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/lighting_ibl.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,gxGAuFnC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,saAMlC,CAAC"}

package/dist/shaders/chunks/lighting_ibl.glsl.js

@@ -0,0 +1,122 @@
+/**
+ * a3d_prd02_lighting_ibl — environment terms (PRD-02 §8.1).
+ * Uniform names follow §8.1 verbatim (they live in the A3DEnvironment
+ * std140 block; bound by environment/EnvUniforms.ts):
+ *   u_envSpecular (RGBA16F mip-mapped cube), u_envMipCount, u_envRotation,
+ *   u_envDiffuseIntensity, u_envSpecularIntensity, u_envSH[7]
+ *   (27 irradiance coefficients, cosine constants folded at upload),
+ *   u_ambientIrradiance, u_hemiSky/u_hemiGround (pre-multiplied),
+ *   u_hemiDirection. Plus u_envDfgLut for the split-sum DFG lookup.
+ */
+export const LIGHTING_IBL_CHUNK_GLSL = /* glsl */ `
+uniform samplerCube u_envSpecular;
+uniform sampler2D u_envDfgLut;
+uniform float u_envMipCount;
+uniform float u_envRotation;
+uniform float u_envDiffuseIntensity;
+uniform float u_envSpecularIntensity;
+uniform vec4 u_envSH[7];
+uniform vec3 u_ambientIrradiance;
+uniform vec3 u_hemiSky;
+uniform vec3 u_hemiGround;
+uniform vec3 u_hemiDirection;
+
+vec3 a3dRotateY(vec3 d, float a) {
+  float c = cos(a), s = sin(a);
+  return vec3(c * d.x - s * d.z, d.y, s * d.x + c * d.z);
+}
+
+// (N-1)·r·(2-r) — identical to workers/cpuPrefilter.ts roughnessToLod.
+float a3dRoughnessToLod(float r) {
+  r = clamp(r, 0.0, 1.0);
+  return (u_envMipCount - 1.0) * r * (2.0 - r);
+}
+
+// Unpack 27 folded coefficients from u_envSH[7] and evaluate
+// Ramamoorthi–Hanrahan irradiance at n. packEnvSH already folds the cosine
+// band constants A_l = {π, 2π/3, π/4} into the coefficients, so only the
+// plain real-SH basis Y_lm(n) is applied here (02 IBL fix: the previous
+// constants multiplied A_l a second time).
+vec3 a3dSH9Irradiance(vec3 n) {
+  n = normalize(n);
+  float x = n.x, y = n.y, z = n.z;
+  vec3 c0 = u_envSH[0].xyz;
+  vec3 c1 = vec3(u_envSH[0].w, u_envSH[1].x, u_envSH[1].y);
+  vec3 c2 = vec3(u_envSH[1].z, u_envSH[1].w, u_envSH[2].x);
+  vec3 c3 = u_envSH[2].yzw;
+  vec3 c4 = u_envSH[3].xyz;
+  vec3 c5 = vec3(u_envSH[3].w, u_envSH[4].x, u_envSH[4].y);
+  vec3 c6 = vec3(u_envSH[4].z, u_envSH[4].w, u_envSH[5].x);
+  vec3 c7 = u_envSH[5].yzw;
+  vec3 c8 = u_envSH[6].xyz;
+  vec3 E = c0 * 0.282095;
+  E += c1 * (-0.488603 * y) + c2 * (0.488603 * z) + c3 * (-0.488603 * x);
+  E += c4 * (1.092548 * x * y) + c5 * (1.092548 * y * z);
+  E += c6 * (0.315392 * (3.0 * z * z - 1.0));
+  E += c7 * (1.092548 * x * z) + c8 * (0.546274 * (x * x - y * y));
+  return max(E, vec3(0.0));
+}
+
+vec3 a3dIndirectDiffuseIrradiance(vec3 n) {
+  vec3 E = a3dSH9Irradiance(a3dRotateY(n, u_envRotation)) * u_envDiffuseIntensity;
+  E += u_ambientIrradiance;
+  E += mix(u_hemiGround, u_hemiSky, dot(n, u_hemiDirection) * 0.5 + 0.5);
+  return E; // caller multiplies by kd*albedo/PI and ao
+}
+
+vec3 a3dEnvSpecularRadiance(vec3 n, vec3 v, float r) {
+  vec3 R = reflect(-v, n);
+  R = normalize(mix(R, n, r * r * r * r)); // three getIBLRadiance bend
+  return textureLod(u_envSpecular, a3dRotateY(R, u_envRotation), a3dRoughnessToLod(r)).rgb * u_envSpecularIntensity;
+}
+
+// Lagarde 2014 specular occlusion.
+float a3dSpecularOcclusion(float NoV, float ao, float r) {
+  return clamp(pow(NoV + ao, exp2(-16.0 * r - 1.0)) - 1.0 + ao, 0.0, 1.0);
+}
+
+float a3dHorizonOcclusion(vec3 R, vec3 Ng) {
+  float h = min(1.0 + dot(R, Ng), 1.0);
+  return h * h;
+}
+
+// DFG LUT (Karis): texelFetch at (ndv, roughness) → (scale, bias) on F0.
+vec2 a3d_dfg(float ndv, float roughness) {
+  return texture(u_envDfgLut, vec2(clamp(ndv, 0.0, 1.0), clamp(roughness, 0.0, 1.0))).rg;
+}
+
+vec3 a3d_iblSpecular(vec3 n, vec3 v, float roughness, vec3 f0) {
+  vec2 dfg = a3d_dfg(max(dot(n, v), 0.0), roughness);
+  return a3dEnvSpecularRadiance(n, v, roughness) * (f0 * dfg.x + dfg.y);
+}
+
+// Fresnel for the diffuse lobe (roughness-aware Schlick).
+vec3 a3d_iblDiffuseFresnel(vec3 f0, float roughness, float ndv) {
+  vec3 fr = max(vec3(1.0 - roughness), f0) - f0;
+  return f0 + fr * pow(1.0 - ndv, 5.0);
+}
+`;
+/**
+ * a3d_prd02_lighting_ibl_call — the E3 stage-2b replacement
+ * `fragment:indirect` body (statements only; spliced inside `main` where
+ * `V`, `N`, `material`, `indirectDiffuse` and `indirectSpecular` exist).
+ * The C-02 generator emits this INSTEAD of its default indirect body under
+ * the E3 conjunction — never in addition to it — so ambient, sampled and
+ * procedural terms cannot stack.
+ *
+ * Units: `a3dIndirectDiffuseIrradiance` sums the SH9/hemisphere irradiance
+ * with `u_ambientIrradiance`, which the packer stores as exit radiance
+ * (already x1/pi, `ambientToExitRadiance`). The ambient term is therefore
+ * split back out of the irradiance fed to the r185 multiscatter helpers
+ * (which divide by pi) and applied once as exit radiance. `a3dEnvIrradiance`
+ * keeps the name/scale the C-03 lobe IBL calls read from the default body
+ * (true irradiance, cf. `PI * a3dSampleEnvironment(N, 8.0)` there).
+ */
+export const LIGHTING_IBL_CALL_GLSL = /* glsl */ `
+vec3 a3dPrd02Irradiance = a3dIndirectDiffuseIrradiance(N);
+vec3 a3dEnvIrradiance = max(a3dPrd02Irradiance - u_ambientIrradiance, vec3(0.0));
+indirectDiffuse += a3dIndirectDiffuse(a3dEnvIrradiance, V, N, material);
+indirectDiffuse += u_ambientIrradiance * material.diffuseContribution;
+indirectSpecular += a3dIndirectSpecular(a3dEnvSpecularRadiance(N, V, material.roughness), a3dEnvIrradiance, V, N, material);
+`;
+//# sourceMappingURL=lighting_ibl.glsl.js.map

package/dist/shaders/chunks/lighting_ibl.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lighting_ibl.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/lighting_ibl.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuFjD,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;CAMhD,CAAC"}

package/dist/shaders/chunks/lighting_mirrors.d.ts

@@ -0,0 +1,18 @@
+/**
+ * CPU mirrors of the PRD-02 §8 chunk math (item 1911): the ChunkHarness
+ * browser test compares GLSL output against these; unit tests compare them
+ * against three r185's `getDistanceAttenuation` /
+ * `getHemisphereLightIrradiance` within 1e-6.
+ */
+type V3 = readonly [number, number, number];
+/** three r185 `getDistanceAttenuation` verbatim. */
+export declare function a3dDistanceFalloff(lightDistance: number, cutoffDistance: number, decayExponent: number): number;
+/**
+ * three r185 `getHemisphereLightIrradiance` verbatim:
+ * `mix(groundColor, skyColor, 0.5·dotNL+0.5)`. Mirrors the
+ * `a3d_prd02_lighting_ibl` hemisphere term (`u_hemi*` uniforms are
+ * intensity-premultiplied host-side — pass premultiplied colours here).
+ */
+export declare function a3dHemisphereIrradiance(skyColor: V3, groundColor: V3, direction: V3, normal: V3): V3;
+export {};
+//# sourceMappingURL=lighting_mirrors.d.ts.map

package/dist/shaders/chunks/lighting_mirrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lighting_mirrors.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/lighting_mirrors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,KAAK,EAAE,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5C,oDAAoD;AACpD,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAO/G;AAQD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,EAAE,EACZ,WAAW,EAAE,EAAE,EACf,SAAS,EAAE,EAAE,EACb,MAAM,EAAE,EAAE,GACT,EAAE,CAOJ"}

package/dist/shaders/chunks/lighting_mirrors.js

@@ -0,0 +1,35 @@
+/**
+ * CPU mirrors of the PRD-02 §8 chunk math (item 1911): the ChunkHarness
+ * browser test compares GLSL output against these; unit tests compare them
+ * against three r185's `getDistanceAttenuation` /
+ * `getHemisphereLightIrradiance` within 1e-6.
+ */
+/** three r185 `getDistanceAttenuation` verbatim. */
+export function a3dDistanceFalloff(lightDistance, cutoffDistance, decayExponent) {
+    const distanceFalloff = 1.0 / Math.max(Math.pow(lightDistance, decayExponent), 0.01);
+    if (cutoffDistance > 0.0) {
+        const x = Math.min(Math.max(1.0 - Math.pow(lightDistance / cutoffDistance, 4.0), 0.0), 1.0);
+        return distanceFalloff * x * x;
+    }
+    return distanceFalloff;
+}
+const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const normalize = (v) => {
+    const l = Math.hypot(v[0], v[1], v[2]) || 1;
+    return [v[0] / l, v[1] / l, v[2] / l];
+};
+/**
+ * three r185 `getHemisphereLightIrradiance` verbatim:
+ * `mix(groundColor, skyColor, 0.5·dotNL+0.5)`. Mirrors the
+ * `a3d_prd02_lighting_ibl` hemisphere term (`u_hemi*` uniforms are
+ * intensity-premultiplied host-side — pass premultiplied colours here).
+ */
+export function a3dHemisphereIrradiance(skyColor, groundColor, direction, normal) {
+    const w = 0.5 * dot3(normalize(normal), normalize(direction)) + 0.5;
+    return [
+        groundColor[0] + (skyColor[0] - groundColor[0]) * w,
+        groundColor[1] + (skyColor[1] - groundColor[1]) * w,
+        groundColor[2] + (skyColor[2] - groundColor[2]) * w
+    ];
+}
+//# sourceMappingURL=lighting_mirrors.js.map