@aura3d/rendering 3.0.1 → 4.0.2

package/dist/shaders/deform/skinning.wgsl.js

@@ -0,0 +1,58 @@
+/**
+ * PRD-06 T2.7 — WGSL twin of `a3d_prd06_skinning_common`
+ * (`shaders/deform/skinning.glsl.ts`). Same palette semantics, WGSL idiom:
+ *
+ *   - `u_boneTexture` (RGBA32F sampler, 4 texels per mat4) →
+ *     `a3dBones: var<storage> array<mat4x4<f32>>` — a storage buffer sized to
+ *     the rig (`jointCount * 64` bytes), matching §8.1's "bones sized to the
+ *     rig" shape instead of a texel-width lookup. `u_boneTextureWidth`
+ *     disappears with the addressing math.
+ *   - `u_prevBoneTexture` → `a3dPrevBones` — declared unconditionally; WebGPU
+ *     only requires bindings a program statically reads, so non-velocity
+ *     programs never bind it.
+ *   - GLSL `in` attributes (`a_joints`, `a_weights`, `a_joints1`, `a_weights1`)
+ *     become function parameters — WGSL vertex inputs live in the generated
+ *     entry-point struct, not in chunks. Joints arrive as `vec4<u32>`; the
+ *     generated program converts the float vertex attributes at the call site.
+ *   - `A3D_SKINNING == 8` (preprocessor fork) becomes two functions,
+ *     `a3dSkin4`/`a3dSkin8` (+ `Prev` twins); the generator emits the call its
+ *     features select.
+ *
+ * Group/binding numbers are placeholders for the WebGPU generator (Q-11-1
+ * owns device-side binding) — group 3 matches the lane-11 per-draw-resource
+ * convention.
+ */
+export const A3D_PRD06_SKINNING_COMMON_WGSL = /* wgsl */ `
+// §8.1 — storage-buffer bones sized to the rig (jointCount mat4s).
+@group(3) @binding(10) var<storage, read> a3dBones: array<mat4x4<f32>>;
+// §8.5 — previous-frame palette for velocity programs. Declared
+// unconditionally: WebGPU only requires bindings the entry point
+// transitively reads, so forward programs never bind it.
+@group(3) @binding(11) var<storage, read> a3dPrevBones: array<mat4x4<f32>>;
+
+fn a3dBone(j: u32) -> mat4x4<f32> {
+  return a3dBones[j];
+}
+fn a3dBonePrev(j: u32) -> mat4x4<f32> {
+  return a3dPrevBones[j];
+}
+fn a3dSkin4(joints: vec4<u32>, weights: vec4<f32>) -> mat4x4<f32> {
+  return a3dBone(joints.x) * weights.x + a3dBone(joints.y) * weights.y
+       + a3dBone(joints.z) * weights.z + a3dBone(joints.w) * weights.w;
+}
+fn a3dSkin8(joints: vec4<u32>, weights: vec4<f32>, joints1: vec4<u32>, weights1: vec4<f32>) -> mat4x4<f32> {
+  return a3dSkin4(joints, weights)
+       + a3dBone(joints1.x) * weights1.x + a3dBone(joints1.y) * weights1.y
+       + a3dBone(joints1.z) * weights1.z + a3dBone(joints1.w) * weights1.w;
+}
+fn a3dSkinPrev4(joints: vec4<u32>, weights: vec4<f32>) -> mat4x4<f32> {
+  return a3dBonePrev(joints.x) * weights.x + a3dBonePrev(joints.y) * weights.y
+       + a3dBonePrev(joints.z) * weights.z + a3dBonePrev(joints.w) * weights.w;
+}
+fn a3dSkinPrev8(joints: vec4<u32>, weights: vec4<f32>, joints1: vec4<u32>, weights1: vec4<f32>) -> mat4x4<f32> {
+  return a3dSkinPrev4(joints, weights)
+       + a3dBonePrev(joints1.x) * weights1.x + a3dBonePrev(joints1.y) * weights1.y
+       + a3dBonePrev(joints1.z) * weights1.z + a3dBonePrev(joints1.w) * weights1.w;
+}
+`;
+//# sourceMappingURL=skinning.wgsl.js.map

package/dist/shaders/deform/skinning.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skinning.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/skinning.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCxD,CAAC"}

package/dist/shaders/deform/twins.d.ts

@@ -0,0 +1,8 @@
+/**
+ * PRD-06 T2.7 — WGSL twin registration for the three deform chunks. Kept in a
+ * leaf module (no scene/engine imports) so `tools/wgsl-validate/emit-twins.ts`
+ * can register them without pulling the lane's runtime graph.
+ */
+/** Record the prd06 WGSL twins in the C-02 manifest. Idempotent. */
+export declare function registerPrd06WgslTwins(): void;
+//# sourceMappingURL=twins.d.ts.map

package/dist/shaders/deform/twins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"twins.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/twins.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,oEAAoE;AACpE,wBAAgB,sBAAsB,IAAI,IAAI,CAM7C"}

package/dist/shaders/deform/twins.js

@@ -0,0 +1,20 @@
+/**
+ * PRD-06 T2.7 — WGSL twin registration for the three deform chunks. Kept in a
+ * leaf module (no scene/engine imports) so `tools/wgsl-validate/emit-twins.ts`
+ * can register them without pulling the lane's runtime graph.
+ */
+import { registerWgslTwin } from "../../program/chunks/manifest.js";
+import { A3D_PRD06_SKINNING_COMMON_WGSL } from "./skinning.wgsl.js";
+import { A3D_PRD06_MORPH_TEXTURE_WGSL } from "./morph.wgsl.js";
+import { A3D_PRD06_DEFORM_WGSL } from "./deform.wgsl.js";
+let registered = false;
+/** Record the prd06 WGSL twins in the C-02 manifest. Idempotent. */
+export function registerPrd06WgslTwins() {
+    if (registered)
+        return;
+    registered = true;
+    registerWgslTwin({ chunkName: "a3d_prd06_skinning_common", owner: "prd06", wgsl: A3D_PRD06_SKINNING_COMMON_WGSL });
+    registerWgslTwin({ chunkName: "a3d_prd06_morph_texture", owner: "prd06", wgsl: A3D_PRD06_MORPH_TEXTURE_WGSL });
+    registerWgslTwin({ chunkName: "a3d_prd06_deform", owner: "prd06", wgsl: A3D_PRD06_DEFORM_WGSL });
+}
+//# sourceMappingURL=twins.js.map

package/dist/shaders/deform/twins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"twins.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/twins.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,IAAI,UAAU,GAAG,KAAK,CAAC;AAEvB,oEAAoE;AACpE,MAAM,UAAU,sBAAsB;IACpC,IAAI,UAAU;QAAE,OAAO;IACvB,UAAU,GAAG,IAAI,CAAC;IAClB,gBAAgB,CAAC,EAAE,SAAS,EAAE,2BAA2B,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,8BAA8B,EAAE,CAAC,CAAC;IACnH,gBAAgB,CAAC,EAAE,SAAS,EAAE,yBAAyB,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,4BAA4B,EAAE,CAAC,CAAC;IAC/G,gBAAgB,CAAC,EAAE,SAAS,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAC;AACnG,CAAC"}

package/dist/shaders/lod-dither.glsl.d.ts

@@ -0,0 +1,12 @@
+import type { ShaderChunk, ShaderFeature } from "../contracts/program.js";
+import type { DepthVariantFeature } from "../contracts/shadows.js";
+/** Uniform + Bayer helper, inserted at `fragment:pars`. */
+export declare const lodDitherParsChunk: ShaderChunk;
+/** First alpha-stage statement: the stipple discard itself. */
+export declare const lodDitherDiscardChunk: ShaderChunk;
+export declare const LOD_DITHER_BIT = "lodDither";
+/** Forward-pass feature: dithers only while `lodFade` is mid-transition. */
+export declare const lodDitherFeature: ShaderFeature;
+/** Depth/distance variant: the same stipple keeps silhouettes dithered in shadow passes. */
+export declare const lodDitherDepthFeature: DepthVariantFeature;
+//# sourceMappingURL=lod-dither.glsl.d.ts.map

package/dist/shaders/lod-dither.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lod-dither.glsl.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/shaders/lod-dither.glsl.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAgBhE,2DAA2D;AAC3D,eAAO,MAAM,kBAAkB,EAAE,WAuBhC,CAAC;AAEF,+DAA+D;AAC/D,eAAO,MAAM,qBAAqB,EAAE,WAgBnC,CAAC;AAEF,eAAO,MAAM,cAAc,cAAc,CAAC;AAQ1C,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,EAAE,aAgB9B,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,qBAAqB,EAAE,mBAiBnC,CAAC"}

package/dist/shaders/lod-dither.glsl.js

@@ -0,0 +1,101 @@
+const BAYER_GLSL = `float a3dLodBayer4(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 a3dLodBayer4(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 + Bayer helper, inserted at `fragment:pars`. */
+export const lodDitherParsChunk = {
+    name: "a3d_prd05_lod_dither",
+    owner: "prd05",
+    stage: "fragment",
+    glsl: `uniform float u_lodFade;
+${BAYER_GLSL}
+void a3dLodDitherDiscard() {
+  float a = abs(u_lodFade);
+  if (a < 0.999) {
+    if (u_lodFade >= 0.0 ? a3dLodBayer4(gl_FragCoord.xy) >= a : a3dLodBayer4(gl_FragCoord.xy) < a) discard;
+  }
+}
+`,
+    wgsl: `@group(1) @binding(0) var<uniform> a3dLodFade: f32;
+${BAYER_WGSL}
+fn a3dLodDitherDiscard(pos: vec4<f32>, fade: f32) {
+  let a = abs(fade);
+  if (a < 0.999) {
+    let b = a3dLodBayer4(pos.xy);
+    if (select(b < a, b >= a, fade >= 0.0)) { discard; }
+  }
+}
+`
+};
+/** First alpha-stage statement: the stipple discard itself. */
+export const lodDitherDiscardChunk = {
+    name: "a3d_prd05_lod_ditherDiscard",
+    owner: "prd05",
+    stage: "fragment",
+    // No `requires` on the pars chunk: hookSplice appends required chunks
+    // AFTER the requiring one at the SAME hook, so the pars chunk's
+    // uniform/function declarations would land inside main() (Q-05-8).
+    // The feature's chunks+hooks already splice the pars chunk at fragment:pars.
+    requires: [],
+    // Guarded by the feature's own define: the ChunkHarness splices chunk GLSL
+    // at pars position (outside main), where a bare statement cannot compile;
+    // real programs define A3D_LOD_DITHER via the feature's defines().
+    glsl: `#ifdef A3D_LOD_DITHER
+a3dLodDitherDiscard();
+#endif`,
+    wgsl: `a3dLodDitherDiscard(a3dFragCoord, a3dLodFade);`
+};
+export const LOD_DITHER_BIT = "lodDither";
+function activeFade(item) {
+    const fade = item.lodFade;
+    if (fade === undefined || Math.abs(fade) >= 0.999)
+        return undefined;
+    return fade;
+}
+/** Forward-pass feature: dithers only while `lodFade` is mid-transition. */
+export const lodDitherFeature = {
+    id: "prd05.lodDither",
+    owner: "prd05",
+    flag: "A3D_QR_ASSETS_LOD",
+    chunks: ["a3d_prd05_lod_dither", "a3d_prd05_lod_ditherDiscard"],
+    hooks: ["fragment:pars", "fragment:alpha"],
+    select(input) {
+        if (input.pass !== "forward")
+            return undefined;
+        return activeFade(input.item) === undefined ? undefined : LOD_DITHER_BIT;
+    },
+    defines() {
+        return { A3D_LOD_DITHER: true };
+    },
+    bindUniforms(_value, item, set) {
+        set("u_lodFade", item.lodFade ?? 1);
+    }
+};
+/** Depth/distance variant: the same stipple keeps silhouettes dithered in shadow passes. */
+export const lodDitherDepthFeature = {
+    id: "prd05.lodDither.depth",
+    owner: "prd05",
+    flag: "A3D_QR_ASSETS_LOD",
+    passes: ["depth", "distance"],
+    chunks: ["a3d_prd05_lod_dither", "a3d_prd05_lod_ditherDiscard"],
+    hooks: ["fragment:pars", "fragment:alpha"],
+    select(input) {
+        if (input.pass !== "depth" && input.pass !== "distance")
+            return undefined;
+        return activeFade(input.item) === undefined ? undefined : LOD_DITHER_BIT;
+    },
+    defines() {
+        return { A3D_LOD_DITHER: true };
+    },
+    bindUniforms(_value, item, set) {
+        set("u_lodFade", item.lodFade ?? 1);
+    }
+};
+//# sourceMappingURL=lod-dither.glsl.js.map

package/dist/shaders/lod-dither.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lod-dither.glsl.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/shaders/lod-dither.glsl.ts"],"names":[],"mappings":"AAwBA,MAAM,UAAU,GAAG;;;;;EAKjB,CAAC;AAEH,MAAM,UAAU,GAAG;;;;EAIjB,CAAC;AAEH,2DAA2D;AAC3D,MAAM,CAAC,MAAM,kBAAkB,GAAgB;IAC7C,IAAI,EAAE,sBAAsB;IAC5B,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,IAAI,EAAE;EACN,UAAU;;;;;;;CAOX;IACC,IAAI,EAAE;EACN,UAAU;;;;;;;;CAQX;CACA,CAAC;AAEF,+DAA+D;AAC/D,MAAM,CAAC,MAAM,qBAAqB,GAAgB;IAChD,IAAI,EAAE,6BAA6B;IACnC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,sEAAsE;IACtE,gEAAgE;IAChE,mEAAmE;IACnE,6EAA6E;IAC7E,QAAQ,EAAE,EAAE;IACZ,2EAA2E;IAC3E,0EAA0E;IAC1E,mEAAmE;IACnE,IAAI,EAAE;;OAED;IACL,IAAI,EAAE,gDAAgD;CACvD,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,WAAW,CAAC;AAE1C,SAAS,UAAU,CAAC,IAAgB;IAClC,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC;IAC1B,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK;QAAE,OAAO,SAAS,CAAC;IACpE,OAAO,IAAI,CAAC;AACd,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,MAAM,gBAAgB,GAAkB;IAC7C,EAAE,EAAE,iBAAiB;IACrB,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,mBAAmB;IACzB,MAAM,EAAE,CAAC,sBAAsB,EAAE,6BAA6B,CAAC;IAC/D,KAAK,EAAE,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC1C,MAAM,CAAC,KAAK;QACV,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC/C,OAAO,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC;IAC3E,CAAC;IACD,OAAO;QACL,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC;IAClC,CAAC;IACD,YAAY,CAAC,MAAM,EAAE,IAAgB,EAAE,GAA4C;QACjF,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;IACtC,CAAC;CACF,CAAC;AAEF,4FAA4F;AAC5F,MAAM,CAAC,MAAM,qBAAqB,GAAwB;IACxD,EAAE,EAAE,uBAAuB;IAC3B,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,mBAAmB;IACzB,MAAM,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,MAAM,EAAE,CAAC,sBAAsB,EAAE,6BAA6B,CAAC;IAC/D,KAAK,EAAE,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC1C,MAAM,CAAC,KAAK;QACV,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU;YAAE,OAAO,SAAS,CAAC;QAC1E,OAAO,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC;IAC3E,CAAC;IACD,OAAO;QACL,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC;IAClC,CAAC;IACD,YAAY,CAAC,MAAM,EAAE,IAAgB,EAAE,GAA4C;QACjF,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;IACtC,CAAC;CACF,CAAC"}

package/dist/shaders/physical/alpha_a2c.glsl.d.ts

@@ -0,0 +1,19 @@
+/**
+ * a3d_prd04_alpha_a2c — MASK alpha-test + alpha-to-coverage (PRD-04 §8.10
+ * [02], material.alphaToCoverage flag).
+ *
+ * Ported from three r185:
+ *  - MASK path: `if ( alpha < cutoff ) discard` —
+ *    alphatest_fragment.glsl.js:9-13.
+ *  - Alpha-to-coverage path:
+ *    `alpha = smoothstep( cutoff, cutoff + fwidth( alpha ), alpha );
+ *    if ( alpha == 0 ) discard` — alphatest_fragment.glsl.js:5-7.
+ *    Activation is a pipeline/MSAA decision (renderer.alphaToCoverage alias
+ *    plus material.strictness 'spec' acceptance); the shader side is this
+ *    smoothing (PRD-04 §8.10 + §11 alphaMode table).
+ *
+ * Self-contained (no requires). Stage fragment.
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_ALPHA_A2C: ShaderChunk;
+//# sourceMappingURL=alpha_a2c.glsl.d.ts.map

package/dist/shaders/physical/alpha_a2c.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alpha_a2c.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/alpha_a2c.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAuB3D,eAAO,MAAM,mBAAmB,EAAE,WAOjC,CAAC"}

package/dist/shaders/physical/alpha_a2c.glsl.js

@@ -0,0 +1,29 @@
+import A3D_PRD04_ALPHA_A2C_WGSL from "../physical-wgsl/alpha_a2c.wgsl.js";
+const glsl = /* glsl */ `
+// MASK without coverage: hard cutoff discard (r185 USE_ALPHATEST arm,
+// alphatest_fragment.glsl.js:9-13).
+void a3dPrd04AlphaTest( const in float alpha, const in float cutoff ) {
+
+	if ( alpha < cutoff ) discard;
+
+}
+
+// MASK + alpha-to-coverage: screen-space derivative smoothing around the
+// cutoff, then discard fully-covered-out texels (r185 ALPHA_TO_COVERAGE arm,
+// alphatest_fragment.glsl.js:5-7).
+void a3dPrd04AlphaToCoverage( inout float alpha, const in float cutoff ) {
+
+	alpha = smoothstep( cutoff, cutoff + fwidth( alpha ), alpha );
+	if ( alpha == 0.0 ) discard;
+
+}
+`;
+export const A3D_PRD04_ALPHA_A2C = {
+    name: "a3d_prd04_alpha_a2c",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_ALPHA_A2C_WGSL,
+    stage: "fragment",
+    requires: []
+};
+//# sourceMappingURL=alpha_a2c.glsl.js.map

package/dist/shaders/physical/alpha_a2c.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alpha_a2c.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/alpha_a2c.glsl.ts"],"names":[],"mappings":"AAiBA,OAAO,wBAAwB,MAAM,oCAAoC,CAAC;AAE1E,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;CAkBvB,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAgB;IAC/C,IAAI,EAAE,qBAAqB;IAC3B,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,wBAAwB;IAC9B,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,EAAE;CACZ,CAAC"}

package/dist/shaders/physical/anisotropy.glsl.d.ts

@@ -0,0 +1,23 @@
+/**
+ * a3d_prd04_anisotropy — KHR_materials_anisotropy (PRD-04 §8.6).
+ *
+ * Ported from three r185:
+ *  - Direction resolution: `anisotropyV = mat2(rot) * normalize( 2 *
+ *    anisoPolar.rg - 1 ) * anisoPolar.b`; `material.anisotropy =
+ *    length(anisotropyV)`; zero → vec2(1,0) else normalize + saturate —
+ *    lights_physical_fragment.glsl.js:131-152.
+ *  - `alphaT = mix( pow2( roughness ), 1.0, pow2( anisotropy ) )` and the T/B
+ *    tangent-frame basis — lights_physical_fragment.glsl.js:154-158.
+ *  - `V_GGX_SmithCorrelated_Anisotropic` + `D_GGX_Anisotropic`:
+ *    lights_physical_pars_fragment.glsl.js:102-119.
+ *  - Direct lobe (anisotropic BRDF_GGX variant):
+ *    lights_physical_pars_fragment.glsl.js:176-195.
+ *  - IBL bent normal `getIBLAnisotropyRadiance`:
+ *    envmap_physical_pars_fragment.glsl.js:38-56.
+ *
+ * Requires `brdf` (F_Schlick, pow2, pow4, saturate, EPSILON, RECIPROCAL_PI)
+ * and `a3d_prd04_bsdf_lobes_common` (A3DPrd04Lobes).
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_ANISOTROPY: ShaderChunk;
+//# sourceMappingURL=anisotropy.glsl.d.ts.map

package/dist/shaders/physical/anisotropy.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anisotropy.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/anisotropy.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AA8G3D,eAAO,MAAM,oBAAoB,EAAE,WAOlC,CAAC"}

package/dist/shaders/physical/anisotropy.glsl.js

@@ -0,0 +1,116 @@
+import A3D_PRD04_ANISOTROPY_WGSL from "../physical-wgsl/anisotropy.wgsl.js";
+const glsl = /* glsl */ `
+// Anisotropic visibility — Filament model (r185
+// V_GGX_SmithCorrelated_Anisotropic, lights_physical_pars_fragment.glsl.js:102-108).
+float a3dPrd04VGGXAnisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {
+
+	float gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );
+	float gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );
+	return 0.5 / max( gv + gl, EPSILON );
+
+}
+
+// Anisotropic GGX distribution (r185 D_GGX_Anisotropic,
+// lights_physical_pars_fragment.glsl.js:110-119).
+float a3dPrd04DGGXAnisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {
+
+	float a2 = alphaT * alphaB;
+	highp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );
+	highp float v2 = dot( v, v );
+	float w2 = a2 / v2;
+
+	return RECIPROCAL_PI * a2 * ( w2 * w2 );
+
+}
+
+// Direction/frame resolution (r185 lights_physical_fragment.glsl.js:131-158).
+// anisotropyVector = strength*dir factor; anisoTex = anisotropyMap texel
+// (.rg polar dir, .b strength); pass vec4(0.0) when no map is bound — the
+// 2*rg-1 decode makes vec4(0.0) invalid, so useTexMap selects the path.
+void a3dPrd04AnisotropyInit( inout A3DPrd04Lobes lobes, const in vec2 anisotropyVector, const in vec4 anisoTex, const in bool useAnisoTex, const in vec3 tangent, const in vec3 bitangent, const in float roughness ) {
+
+	vec2 anisotropyV;
+	if ( useAnisoTex ) {
+
+		mat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );
+		vec3 anisotropyPolar = anisoTex.rgb;
+		anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;
+
+	} else {
+
+		anisotropyV = anisotropyVector;
+
+	}
+
+	lobes.anisotropy = length( anisotropyV );
+
+	if ( lobes.anisotropy == 0.0 ) {
+
+		anisotropyV = vec2( 1.0, 0.0 );
+
+	} else {
+
+		anisotropyV /= lobes.anisotropy;
+		lobes.anisotropy = saturate( lobes.anisotropy );
+
+	}
+
+	// Roughness along the anisotropy bitangent is the material roughness, while
+	// the tangent roughness increases with anisotropy.
+	lobes.alphaT = mix( pow2( roughness ), 1.0, pow2( lobes.anisotropy ) );
+
+	lobes.anisotropyT = tangent * anisotropyV.x + bitangent * anisotropyV.y;
+	lobes.anisotropyB = bitangent * anisotropyV.x - tangent * anisotropyV.y;
+
+}
+
+// Direct anisotropic specular (r185 BRDF_GGX USE_ANISOTROPY arm,
+// lights_physical_pars_fragment.glsl.js:176-197).
+vec3 a3dPrd04AnisotropyDirect( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness, const in A3DPrd04Lobes lobes ) {
+
+	float alpha = pow2( roughness );
+
+	vec3 halfDir = normalize( lightDir + viewDir );
+
+	float dotNL = saturate( dot( normal, lightDir ) );
+	float dotNV = saturate( dot( normal, viewDir ) );
+	float dotNH = saturate( dot( normal, halfDir ) );
+	float dotVH = saturate( dot( viewDir, halfDir ) );
+
+	vec3 F = F_Schlick( f0, f90, dotVH );
+
+	float dotTL = dot( lobes.anisotropyT, lightDir );
+	float dotTV = dot( lobes.anisotropyT, viewDir );
+	float dotTH = dot( lobes.anisotropyT, halfDir );
+	float dotBL = dot( lobes.anisotropyB, lightDir );
+	float dotBV = dot( lobes.anisotropyB, viewDir );
+	float dotBH = dot( lobes.anisotropyB, halfDir );
+
+	float V = a3dPrd04VGGXAnisotropic( lobes.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );
+
+	float D = a3dPrd04DGGXAnisotropic( lobes.alphaT, alpha, dotNH, dotTH, dotBH );
+
+	return F * ( V * D );
+
+}
+
+// IBL bent normal (r185 getIBLAnisotropyRadiance,
+// envmap_physical_pars_fragment.glsl.js:38-56) — returns the direction the
+// caller reflects through the env map.
+vec3 a3dPrd04AnisotropyBentNormal( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {
+
+	vec3 bentNormal = cross( bitangent, viewDir );
+	bentNormal = normalize( cross( bentNormal, bitangent ) );
+	return normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );
+
+}
+`;
+export const A3D_PRD04_ANISOTROPY = {
+    name: "a3d_prd04_anisotropy",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_ANISOTROPY_WGSL,
+    stage: "fragment",
+    requires: ["brdf", "a3d_prd04_bsdf_lobes_common"]
+};
+//# sourceMappingURL=anisotropy.glsl.js.map

package/dist/shaders/physical/anisotropy.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anisotropy.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/anisotropy.glsl.ts"],"names":[],"mappings":"AAqBA,OAAO,yBAAyB,MAAM,qCAAqC,CAAC;AAE5E,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGvB,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAChD,IAAI,EAAE,sBAAsB;IAC5B,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,yBAAyB;IAC/B,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,CAAC,MAAM,EAAE,6BAA6B,CAAC;CACjD,CAAC"}

package/dist/shaders/physical/bsdf_lobes_common.glsl.d.ts

@@ -0,0 +1,25 @@
+/**
+ * a3d_prd04_bsdf_lobes_common — shared PRD 04 lobe infrastructure (PRD-04 §8.2).
+ *
+ * Ported from three r185:
+ *  - `A3DPrd04Lobes` mirrors the PRD 04-owned fields of `PhysicalMaterial`,
+ *    src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js:5-58.
+ *    Any field PRD 01's `brdf` chunk struct lacks lives here until request
+ *    Q-01-5 lands (PRD-04 §8.2 comment block).
+ *  - `a3dPrd04GeometryRoughness` — geometric specular antialiasing,
+ *    lights_physical_fragment.glsl.js:7-12.
+ *  - `a3dPrd04SpecularOcclusion` — computeSpecularOcclusion,
+ *    lights_physical_pars_fragment.glsl.js:651-656.
+ *  - `a3dPrd04EnvironmentBRDF` — EnvironmentBRDF over the PRD 01 `brdf` chunk's
+ *    `a3dDFG` accessor (lights_physical_pars_fragment.glsl.js:377-384). Lobes
+ *    never sample `u_dfgLut` directly so the (roughness, NdotV) axis order is
+ *    decided in one place (PRD-04 §8.2).
+ *  - `a3dPrd04ComputeMultiscattering` — computeMultiscattering,
+ *    lights_physical_pars_fragment.glsl.js:390-419.
+ *
+ * Requires the `brdf` chunk (PRD 01 / test shim): saturate, pow2, EPSILON,
+ * a3dDFG.
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_BSDF_LOBES_COMMON: ShaderChunk;
+//# sourceMappingURL=bsdf_lobes_common.glsl.d.ts.map

package/dist/shaders/physical/bsdf_lobes_common.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bsdf_lobes_common.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/bsdf_lobes_common.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAyF3D,eAAO,MAAM,2BAA2B,EAAE,WAOzC,CAAC"}

package/dist/shaders/physical/bsdf_lobes_common.glsl.js

@@ -0,0 +1,95 @@
+import A3D_PRD04_BSDF_LOBES_COMMON_WGSL from "../physical-wgsl/bsdf_lobes_common.wgsl.js";
+const glsl = /* glsl */ `
+struct A3DPrd04Lobes {
+	float ior;
+	float clearcoat;
+	float clearcoatRoughness;
+	vec3 clearcoatNormal;
+	vec3 sheenColor;
+	float sheenRoughness;
+	float iridescence;
+	float iridescenceIOR;
+	float iridescenceThickness;
+	vec3 iridescenceFresnel;
+	vec3 iridescenceF0;
+	float anisotropy;
+	vec3 anisotropyT;
+	vec3 anisotropyB;
+	float alphaT;
+	float transmission;
+	float thickness;
+	float attenuationDistance;
+	vec3 attenuationColor;
+	float dispersion;
+};
+
+// Geometric specular AA (r185 lights_physical_fragment.glsl.js:7-12).
+// Returns the roughness increment from screen-space normal divergence.
+float a3dPrd04GeometryRoughness( const in vec3 nonPerturbedNormal ) {
+
+	vec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );
+	return max( max( dxy.x, dxy.y ), dxy.z );
+
+}
+
+// r185 roughness floor (base mip of a 256 cubemap), then spec-AA clamp to 1.
+float a3dPrd04ResolveRoughness( const in float roughnessFactor, const in float geometryRoughness ) {
+
+	float roughness = max( roughnessFactor, 0.0525 );
+	roughness += geometryRoughness;
+	return min( roughness, 1.0 );
+
+}
+
+// Specular occlusion (r185 computeSpecularOcclusion,
+// lights_physical_pars_fragment.glsl.js:651-656). Multiplies indirect specular;
+// the ao term itself multiplies indirect diffuse (PRD-04 §8.2 [02] row).
+float a3dPrd04SpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
+
+	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
+
+}
+
+// Environment BRDF (r185 EnvironmentBRDF,
+// lights_physical_pars_fragment.glsl.js:377-384) over a3dDFG. f90 is scalar in
+// r185 (specularF90); F = f0 * ab.x + f90 * ab.y.
+vec3 a3dPrd04EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
+
+	float dotNV = saturate( dot( normal, viewDir ) );
+	vec2 fab = a3dDFG( roughness, dotNV );
+
+	return specularColor * fab.x + specularF90 * fab.y;
+
+}
+
+// IBL multiscattering (r185 computeMultiscattering,
+// lights_physical_pars_fragment.glsl.js:390-419; single LUT fetch at NdotV).
+void a3dPrd04ComputeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
+
+	float dotNV = saturate( dot( normal, viewDir ) );
+	vec2 fab = a3dDFG( roughness, dotNV );
+
+	vec3 Fr = specularColor;
+
+	vec3 FssEss = Fr * fab.x + specularF90 * fab.y;
+
+	float Ess = fab.x + fab.y;
+	float Ems = 1.0 - Ess;
+
+	vec3 Favg = Fr + ( 1.0 - Fr ) * 0.047619; // 1/21
+	vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
+
+	singleScatter += FssEss;
+	multiScatter += Fms * Ems;
+
+}
+`;
+export const A3D_PRD04_BSDF_LOBES_COMMON = {
+    name: "a3d_prd04_bsdf_lobes_common",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_BSDF_LOBES_COMMON_WGSL,
+    stage: "fragment",
+    requires: ["brdf"]
+};
+//# sourceMappingURL=bsdf_lobes_common.glsl.js.map

package/dist/shaders/physical/bsdf_lobes_common.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bsdf_lobes_common.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/bsdf_lobes_common.glsl.ts"],"names":[],"mappings":"AAuBA,OAAO,gCAAgC,MAAM,4CAA4C,CAAC;AAE1F,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFvB,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAgB;IACvD,IAAI,EAAE,6BAA6B;IACnC,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,gCAAgC;IACtC,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,CAAC,MAAM,CAAC;CAClB,CAAC"}

package/dist/shaders/physical/clearcoat.glsl.d.ts

@@ -0,0 +1,23 @@
+/**
+ * a3d_prd04_clearcoat — KHR_materials_clearcoat (PRD-04 §8.3).
+ *
+ * Ported from three r185:
+ *  - Factor resolution with spec-AA floor:
+ *    lights_physical_fragment.glsl.js:56-80 (clearcoat *= tex.r,
+ *    clearcoatRoughness *= tex.g, saturate(), 0.0525 floor + geometryRoughness,
+ *    clamp to 1).
+ *  - `BRDF_GGX_Clearcoat` (F0 = 0.04, F90 = 1.0):
+ *    lights_physical_pars_fragment.glsl.js:126-149.
+ *  - Indirect: `clearcoatRadiance * EnvironmentBRDF` over the DFG LUT:
+ *    lights_physical_pars_fragment.glsl.js:581-585.
+ *  - Layering composition `out = out * (1 - clearcoat * Fcc) +
+ *    (ccDirect + ccIndirect) * clearcoat`:
+ *    ShaderLib/meshphysical.glsl.js:205-212.
+ *
+ * Requires `brdf` (F_Schlick, V_GGX_SmithCorrelated, D_GGX, pow2, saturate)
+ * and `a3d_prd04_bsdf_lobes_common` (A3DPrd04Lobes,
+ * a3dPrd04ResolveRoughness, a3dPrd04EnvironmentBRDF).
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_CLEARCOAT: ShaderChunk;
+//# sourceMappingURL=clearcoat.glsl.d.ts.map

package/dist/shaders/physical/clearcoat.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearcoat.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/clearcoat.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAgE3D,eAAO,MAAM,mBAAmB,EAAE,WAOjC,CAAC"}