@aura3d/rendering 3.0.1 → 4.0.2

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

@@ -0,0 +1,70 @@
+import A3D_PRD04_CLEARCOAT_WGSL from "../physical-wgsl/clearcoat.wgsl.js";
+const glsl = /* glsl */ `
+// Factor resolution (r185 lights_physical_fragment.glsl.js:56-80).
+// clearcoatTex = clearcoatMap texel (.x), roughnessTex = clearcoatRoughnessMap
+// texel (.y); pass vec4(1.0) when no map is bound.
+void a3dPrd04ClearcoatInit( inout A3DPrd04Lobes lobes, const in float clearcoatFactor, const in float clearcoatRoughnessFactor, const in vec4 clearcoatTex, const in vec4 roughnessTex, const in vec3 clearcoatNormal, const in float geometryRoughness ) {
+
+	float clearcoat = clearcoatFactor * clearcoatTex.x;
+	float clearcoatRoughness = clearcoatRoughnessFactor * roughnessTex.y;
+
+	clearcoat = saturate( clearcoat ); // Burley clearcoat model
+
+	lobes.clearcoat = clearcoat;
+	lobes.clearcoatRoughness = a3dPrd04ResolveRoughness( clearcoatRoughness, geometryRoughness );
+	lobes.clearcoatNormal = clearcoatNormal;
+
+}
+
+// Direct GGX lobe at F0 0.04 / F90 1.0 (r185 BRDF_GGX_Clearcoat,
+// lights_physical_pars_fragment.glsl.js:126-149).
+vec3 a3dPrd04ClearcoatDirect( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in float clearcoatRoughness ) {
+
+	float alpha = pow2( clearcoatRoughness ); // UE4's 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( vec3( 0.04 ), 1.0, dotVH );
+
+	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
+
+	float D = D_GGX( alpha, dotNH );
+
+	return F * ( V * D );
+
+}
+
+// Indirect: clearcoatRadiance * EnvironmentBRDF( Ncc, V, 0.04, 1.0, ccR )
+// (r185 lights_physical_pars_fragment.glsl.js:581-585).
+vec3 a3dPrd04ClearcoatIndirect( const in vec3 normal, const in vec3 viewDir, const in float clearcoatRoughness, const in vec3 clearcoatRadiance ) {
+
+	return clearcoatRadiance * a3dPrd04EnvironmentBRDF( normal, viewDir, vec3( 0.04 ), 1.0, clearcoatRoughness );
+
+}
+
+// Layering composition (r185 meshphysical.glsl.js:205-212):
+// dotNVcc = saturate( dot( ccN, V ) ); Fcc = F_Schlick( 0.04, 1.0, dotNVcc );
+// out = out * ( 1 - clearcoat * Fcc ) + ( ccDirect + ccIndirect ) * clearcoat.
+vec3 a3dPrd04ComposeClearcoat( const in vec3 outgoing, const in float clearcoat, const in vec3 clearcoatNormal, const in vec3 viewDir, const in vec3 clearcoatDirect, const in vec3 clearcoatIndirect ) {
+
+	float dotNVcc = saturate( dot( clearcoatNormal, viewDir ) );
+	vec3 Fcc = F_Schlick( vec3( 0.04 ), 1.0, dotNVcc );
+
+	return outgoing * ( 1.0 - clearcoat * Fcc ) + ( clearcoatDirect + clearcoatIndirect ) * clearcoat;
+
+}
+`;
+export const A3D_PRD04_CLEARCOAT = {
+    name: "a3d_prd04_clearcoat",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_CLEARCOAT_WGSL,
+    stage: "fragment",
+    requires: ["brdf", "a3d_prd04_bsdf_lobes_common"]
+};
+//# sourceMappingURL=clearcoat.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clearcoat.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/clearcoat.glsl.ts"],"names":[],"mappings":"AAqBA,OAAO,wBAAwB,MAAM,oCAAoC,CAAC;AAE1E,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DvB,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,CAAC,MAAM,EAAE,6BAA6B,CAAC;CACjD,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * a3d_prd04_debug_view — material-channel debug visualization
+ * (PRD-04 §8.2 [14], C-15 renderer.debugView).
+ *
+ * Contract: the debug feature emits exactly one
+ * `A3D_PRD04_DEBUG_VIEW_<NAME>` define; `a3dPrd04DebugView` returns that
+ * channel as linear RGB. Channels (C-15 debugView option): baseColor,
+ * normal, roughness, metallic, clearcoat, clearcoatRoughness,
+ * clearcoatRoughnessEffective, sheen, F0, tangent, anisotropyDirection.
+ *
+ * Inputs arrive via `A3DPrd04DebugInput` so a lobe not present in the
+ * program passes zeros — the debug value for an inactive channel is black,
+ * not a compile failure (PRD-04 §14.4 debug contract).
+ *
+ * Requires `a3d_prd04_bsdf_lobes_common` (A3DPrd04Lobes) and `brdf`.
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_DEBUG_VIEW: ShaderChunk;
+//# sourceMappingURL=debug_view.glsl.d.ts.map

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

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

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

@@ -0,0 +1,76 @@
+import A3D_PRD04_DEBUG_VIEW_WGSL from "../physical-wgsl/debug_view.wgsl.js";
+const glsl = /* glsl */ `
+struct A3DPrd04DebugInput {
+	vec3 baseColor;
+	vec3 normal;
+	float roughness;
+	float metallic;
+	vec3 specularF0;
+	vec3 tangent;
+	// T0-05: the remaining prd04.debugView channels (materials/features.ts
+	// PRD04_DEBUG_VIEW_CHANNELS); each <NAME> also has a <NAME>EFFECTIVE define.
+	float roughnessEffective;
+	vec3 emissive;
+	float occlusion;
+	float alpha;
+	vec2 uv0;
+	vec2 uv1;
+};
+
+vec3 a3dPrd04DebugView( const in A3DPrd04DebugInput dbg, const in A3DPrd04Lobes lobes ) {
+
+	#if defined( A3D_PRD04_DEBUG_VIEW_BASECOLOR ) || defined( A3D_PRD04_DEBUG_VIEW_BASECOLOREFFECTIVE )
+		return dbg.baseColor;
+	#elif defined( A3D_PRD04_DEBUG_VIEW_NORMAL ) || defined( A3D_PRD04_DEBUG_VIEW_NORMALEFFECTIVE )
+		return dbg.normal * 0.5 + 0.5;
+	#elif defined( A3D_PRD04_DEBUG_VIEW_ROUGHNESS )
+		return vec3( dbg.roughness );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_ROUGHNESSEFFECTIVE )
+		return vec3( dbg.roughnessEffective );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_METALLIC ) || defined( A3D_PRD04_DEBUG_VIEW_METALLICEFFECTIVE )
+		return vec3( dbg.metallic );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_EMISSIVE ) || defined( A3D_PRD04_DEBUG_VIEW_EMISSIVEEFFECTIVE )
+		return dbg.emissive;
+	#elif defined( A3D_PRD04_DEBUG_VIEW_OCCLUSION ) || defined( A3D_PRD04_DEBUG_VIEW_OCCLUSIONEFFECTIVE )
+		return vec3( dbg.occlusion );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_ALPHA ) || defined( A3D_PRD04_DEBUG_VIEW_ALPHAEFFECTIVE )
+		return vec3( dbg.alpha );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_CLEARCOAT ) || defined( A3D_PRD04_DEBUG_VIEW_CLEARCOATEFFECTIVE )
+		return vec3( lobes.clearcoat );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_CLEARCOAT_ROUGHNESS )
+		return vec3( lobes.clearcoatRoughness );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_CLEARCOAT_ROUGHNESS_EFFECTIVE )
+		return vec3( lobes.clearcoatRoughness );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_SHEEN ) || defined( A3D_PRD04_DEBUG_VIEW_SHEENCOLOR ) || defined( A3D_PRD04_DEBUG_VIEW_SHEENCOLOREFFECTIVE )
+		return lobes.sheenColor;
+	#elif defined( A3D_PRD04_DEBUG_VIEW_IRIDESCENCE ) || defined( A3D_PRD04_DEBUG_VIEW_IRIDESCENCEEFFECTIVE )
+		return vec3( lobes.iridescence );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_ANISOTROPY ) || defined( A3D_PRD04_DEBUG_VIEW_ANISOTROPYEFFECTIVE )
+		return vec3( lobes.anisotropy );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_TRANSMISSION ) || defined( A3D_PRD04_DEBUG_VIEW_TRANSMISSIONEFFECTIVE )
+		return vec3( lobes.transmission );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_F0 )
+		return dbg.specularF0;
+	#elif defined( A3D_PRD04_DEBUG_VIEW_TANGENT ) || defined( A3D_PRD04_DEBUG_VIEW_TANGENTEFFECTIVE )
+		return dbg.tangent * 0.5 + 0.5;
+	#elif defined( A3D_PRD04_DEBUG_VIEW_ANISOTROPY_DIRECTION )
+		return lobes.anisotropyT * 0.5 + 0.5;
+	#elif defined( A3D_PRD04_DEBUG_VIEW_UV0 ) || defined( A3D_PRD04_DEBUG_VIEW_UV0EFFECTIVE )
+		return vec3( fract( dbg.uv0 ), 0.0 );
+	#elif defined( A3D_PRD04_DEBUG_VIEW_UV1 ) || defined( A3D_PRD04_DEBUG_VIEW_UV1EFFECTIVE )
+		return vec3( fract( dbg.uv1 ), 0.0 );
+	#else
+		return vec3( 0.0 );
+	#endif
+
+}
+`;
+export const A3D_PRD04_DEBUG_VIEW = {
+    name: "a3d_prd04_debug_view",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_DEBUG_VIEW_WGSL,
+    stage: "fragment",
+    requires: ["brdf", "a3d_prd04_bsdf_lobes_common"]
+};
+//# sourceMappingURL=debug_view.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debug_view.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/debug_view.glsl.ts"],"names":[],"mappings":"AAiBA,OAAO,yBAAyB,MAAM,qCAAqC,CAAC;AAE5E,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiEvB,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/dispersion.glsl.d.ts

@@ -0,0 +1,18 @@
+/**
+ * a3d_prd04_dispersion — KHR_materials_dispersion (PRD-04 §8.7, §12.8).
+ *
+ * Ported from three r185:
+ *  - `halfSpread = ( ior - 1 ) * 0.025 * dispersion`;
+ *    `iors = vec3( ior - halfSpread, ior, ior + halfSpread )`; three refraction
+ *    samples, one per band — transmission_pars_fragment.glsl.js:178-204.
+ *
+ * Sits inside `#ifdef A3D_TRANSMISSION` + `#ifdef A3D_DISPERSION` mirroring
+ * r185's USE_TRANSMISSION + USE_DISPERSION guards.
+ *
+ * Requires `a3d_prd04_transmission` (a3dVolumeTransmissionRay,
+ * a3dTransmissionCoords, a3dTransmissionSample) and `a3d_prd04_volume`
+ * (a3dVolumeAttenuation).
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_DISPERSION: ShaderChunk;
+//# sourceMappingURL=dispersion.glsl.d.ts.map

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

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

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

@@ -0,0 +1,67 @@
+import A3D_PRD04_DISPERSION_WGSL from "../physical-wgsl/dispersion.wgsl.js";
+const glsl = /* glsl */ `
+// A3D_LOBE_DISPERSION: the C-02 generator's define for an active dispersion lobe
+// (T0-05); A3D_DISPERSION stays accepted for the ChunkHarness / direct callers.
+#if defined( A3D_TRANSMISSION ) && ( defined( A3D_DISPERSION ) || defined( A3D_LOBE_DISPERSION ) )
+
+// Per-band IOR spread (r185 transmission_pars_fragment.glsl.js:180-182):
+// halfSpread = ( ior - 1 ) * 0.025 * dispersion.
+vec3 a3dPrd04DispersionIors( const in float ior, const in float dispersion ) {
+
+	float halfSpread = ( ior - 1.0 ) * 0.025 * dispersion;
+	return vec3( ior - halfSpread, ior, ior + halfSpread );
+
+}
+
+// Dispersive volume refraction — three rays at ior ± halfSpread, channel i
+// keeps band i of the transmission sample and the full alpha averaged
+// (r185 getIBLVolumeRefraction USE_DISPERSION arm,
+// transmission_pars_fragment.glsl.js:178-204,222-231).
+vec4 a3dGetIBLVolumeRefractionDispersion( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor, const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix, const in float dispersion, const in float ior, const in float thickness, const in vec3 attenuationColor, const in float attenuationDistance ) {
+
+	vec4 transmittedLight = vec4( 0.0 );
+	vec3 transmittance = vec3( 0.0 );
+
+	vec3 iors = a3dPrd04DispersionIors( ior, dispersion );
+
+	for ( int i = 0; i < 3; i ++ ) {
+
+		vec3 transmissionRay = a3dVolumeTransmissionRay( n, v, thickness, iors[ i ], modelMatrix );
+		vec3 refractedRayExit = position + transmissionRay;
+
+		// Project refracted vector on the framebuffer, while mapping to normalized device coordinates.
+		vec2 refractionCoords = a3dTransmissionCoords( refractedRayExit, a3d_prd04_viewMatrix, a3d_prd04_projectionMatrix );
+
+		// Sample framebuffer to get pixel the refracted ray hits.
+		vec4 transmissionSample = a3dTransmissionSample( refractionCoords, roughness, iors[ i ] );
+		transmittedLight[ i ] = transmissionSample[ i ];
+		transmittedLight.a += transmissionSample.a;
+
+		transmittance[ i ] = diffuseColor[ i ] * a3dVolumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance )[ i ];
+
+	}
+
+	transmittedLight.a /= 3.0;
+
+	vec3 attenuatedColor = transmittance * transmittedLight.rgb;
+
+	// Get the specular component.
+	vec3 F = a3dPrd04EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
+
+	float transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;
+
+	return vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );
+
+}
+
+#endif // A3D_TRANSMISSION && A3D_DISPERSION
+`;
+export const A3D_PRD04_DISPERSION = {
+    name: "a3d_prd04_dispersion",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_DISPERSION_WGSL,
+    stage: "fragment",
+    requires: ["brdf", "a3d_prd04_bsdf_lobes_common", "a3d_prd04_volume", "a3d_prd04_transmission"]
+};
+//# sourceMappingURL=dispersion.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dispersion.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/dispersion.glsl.ts"],"names":[],"mappings":"AAgBA,OAAO,yBAAyB,MAAM,qCAAqC,CAAC;AAE5E,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDvB,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,EAAE,kBAAkB,EAAE,wBAAwB,CAAC;CAC/F,CAAC"}

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

@@ -0,0 +1,18 @@
+/**
+ * a3d_prd04_emissive_strength — KHR_materials_emissive_strength
+ * (PRD-04 §8.9 [09]).
+ *
+ * Ported from three r185:
+ *  - `totalEmissiveRadiance = emissiveFactor * emissiveMap.rgb *
+ *    emissiveStrength` — emissivemap_fragment.glsl.js:1-13 with the
+ *    emissive_strength multiplier folded in (ShaderLib/meshphysical uses
+ *    material.emissive uniform already multiplied by emissiveStrength on CPU;
+ *    the FS contract here keeps the strength explicit so factor edits stay
+ *    shader-side).
+ *
+ * Requires `brdf` (saturate). Declared unconditionally: a strength of 1.0 is
+ * the identity.
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_EMISSIVE_STRENGTH: ShaderChunk;
+//# sourceMappingURL=emissive_strength.glsl.d.ts.map

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

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

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

@@ -0,0 +1,20 @@
+import A3D_PRD04_EMISSIVE_STRENGTH_WGSL from "../physical-wgsl/emissive_strength.wgsl.js";
+const glsl = /* glsl */ `
+// Emissive term: emissiveFactor * emissiveTex.rgb * emissiveStrength
+// (r185 emissivemap_fragment.glsl.js:1-13 × KHR_materials_emissive_strength).
+// emissiveTex = emissiveMap texel; pass vec4(1.0) when no map is bound.
+vec3 a3dPrd04EmissiveRadiance( const in vec3 emissiveFactor, const in vec4 emissiveTex, const in float emissiveStrength ) {
+
+	return emissiveFactor * emissiveTex.rgb * emissiveStrength;
+
+}
+`;
+export const A3D_PRD04_EMISSIVE_STRENGTH = {
+    name: "a3d_prd04_emissive_strength",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_EMISSIVE_STRENGTH_WGSL,
+    stage: "fragment",
+    requires: ["brdf"]
+};
+//# sourceMappingURL=emissive_strength.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emissive_strength.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/emissive_strength.glsl.ts"],"names":[],"mappings":"AAgBA,OAAO,gCAAgC,MAAM,4CAA4C,CAAC;AAE1F,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;CASvB,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/index.d.ts

@@ -0,0 +1,27 @@
+import { A3D_PRD04_BSDF_LOBES_COMMON } from "./bsdf_lobes_common.glsl.js";
+import { A3D_PRD04_SPECULAR_IOR } from "./specular_ior.glsl.js";
+import { A3D_PRD04_CLEARCOAT } from "./clearcoat.glsl.js";
+import { A3D_PRD04_SHEEN } from "./sheen.glsl.js";
+import { A3D_PRD04_IRIDESCENCE } from "./iridescence.glsl.js";
+import { A3D_PRD04_ANISOTROPY } from "./anisotropy.glsl.js";
+import { A3D_PRD04_TRANSMISSION } from "./transmission.glsl.js";
+import { A3D_PRD04_VOLUME } from "./volume.glsl.js";
+import { A3D_PRD04_DISPERSION } from "./dispersion.glsl.js";
+import { A3D_PRD04_EMISSIVE_STRENGTH } from "./emissive_strength.glsl.js";
+import { A3D_PRD04_UNLIT } from "./unlit.glsl.js";
+import { A3D_PRD04_TANGENT_FRAME } from "./tangent_frame.glsl.js";
+import { A3D_PRD04_UV_TRANSFORM } from "./uv_transform.glsl.js";
+import { A3D_PRD04_ALPHA_A2C } from "./alpha_a2c.glsl.js";
+import { A3D_PRD04_DEBUG_VIEW } from "./debug_view.glsl.js";
+import { PRD04_CALL_CHUNKS } from "./lobe_calls.glsl.js";
+export declare const PRD04_SHADER_CHUNKS: readonly [import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk, import("../../contracts/index.js").ShaderChunk];
+/**
+ * Register every a3d_prd04_* chunk with the program registry (C-02): the
+ * fifteen declaration chunks plus their pars/call split (`lobe_calls`, T0-05).
+ * Idempotent: a second call is a no-op so repeated lane-barrel evaluation
+ * or test setups cannot double-register.
+ */
+export declare function registerPrd04ShaderChunks(): void;
+export { PRD04_CALL_CHUNKS };
+export { A3D_PRD04_BSDF_LOBES_COMMON, A3D_PRD04_SPECULAR_IOR, A3D_PRD04_CLEARCOAT, A3D_PRD04_SHEEN, A3D_PRD04_IRIDESCENCE, A3D_PRD04_ANISOTROPY, A3D_PRD04_TRANSMISSION, A3D_PRD04_VOLUME, A3D_PRD04_DISPERSION, A3D_PRD04_EMISSIVE_STRENGTH, A3D_PRD04_UNLIT, A3D_PRD04_TANGENT_FRAME, A3D_PRD04_UV_TRANSFORM, A3D_PRD04_ALPHA_A2C, A3D_PRD04_DEBUG_VIEW };
+//# sourceMappingURL=index.d.ts.map

package/dist/shaders/physical/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzD,eAAO,MAAM,mBAAmB,olBAgBtB,CAAC;AAIX;;;;;GAKG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAQhD;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAE7B,OAAO,EACN,2BAA2B,EAC3B,sBAAsB,EACtB,mBAAmB,EACnB,eAAe,EACf,qBAAqB,EACrB,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,EAChB,oBAAoB,EACpB,2BAA2B,EAC3B,eAAe,EACf,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,CAAC"}

package/dist/shaders/physical/index.js

@@ -0,0 +1,69 @@
+/**
+ * PRD 04 physical-material shader chunks (PRD-04 §8, P1-1).
+ *
+ * One exported ShaderChunk per file, named `a3d_prd04_<name>`, owner
+ * "prd04". Registration happens unconditionally via the rendering lane
+ * barrel (`lanes/prd04.ts`); chunk activation stays feature/flag driven —
+ * a registered chunk is inert until a ShaderFeature selects it.
+ *
+ * The `requires` edges order chunk splices inside generateProgram: every
+ * lobe that uses the PhysicalMaterial-facing helpers (saturate, pow2,
+ * F_Schlick, V_GGX_SmithCorrelated, D_GGX, a3dDFG, …) declares `brdf`; lobes
+ * that read the shared A3DPrd04Lobes struct declare
+ * `a3d_prd04_bsdf_lobes_common`; transmission-family lobes chain
+ * `a3d_prd04_volume` / `a3d_prd04_transmission` / `a3d_prd04_dispersion`.
+ */
+import { registerShaderChunk, shaderChunk } from "../../contracts/program.js";
+import { A3D_PRD04_BSDF_LOBES_COMMON } from "./bsdf_lobes_common.glsl.js";
+import { A3D_PRD04_SPECULAR_IOR } from "./specular_ior.glsl.js";
+import { A3D_PRD04_CLEARCOAT } from "./clearcoat.glsl.js";
+import { A3D_PRD04_SHEEN } from "./sheen.glsl.js";
+import { A3D_PRD04_IRIDESCENCE } from "./iridescence.glsl.js";
+import { A3D_PRD04_ANISOTROPY } from "./anisotropy.glsl.js";
+import { A3D_PRD04_TRANSMISSION } from "./transmission.glsl.js";
+import { A3D_PRD04_VOLUME } from "./volume.glsl.js";
+import { A3D_PRD04_DISPERSION } from "./dispersion.glsl.js";
+import { A3D_PRD04_EMISSIVE_STRENGTH } from "./emissive_strength.glsl.js";
+import { A3D_PRD04_UNLIT } from "./unlit.glsl.js";
+import { A3D_PRD04_TANGENT_FRAME } from "./tangent_frame.glsl.js";
+import { A3D_PRD04_UV_TRANSFORM } from "./uv_transform.glsl.js";
+import { A3D_PRD04_ALPHA_A2C } from "./alpha_a2c.glsl.js";
+import { A3D_PRD04_DEBUG_VIEW } from "./debug_view.glsl.js";
+import { PRD04_CALL_CHUNKS } from "./lobe_calls.glsl.js";
+export const PRD04_SHADER_CHUNKS = [
+    A3D_PRD04_BSDF_LOBES_COMMON,
+    A3D_PRD04_SPECULAR_IOR,
+    A3D_PRD04_CLEARCOAT,
+    A3D_PRD04_SHEEN,
+    A3D_PRD04_IRIDESCENCE,
+    A3D_PRD04_ANISOTROPY,
+    A3D_PRD04_TRANSMISSION,
+    A3D_PRD04_VOLUME,
+    A3D_PRD04_DISPERSION,
+    A3D_PRD04_EMISSIVE_STRENGTH,
+    A3D_PRD04_UNLIT,
+    A3D_PRD04_TANGENT_FRAME,
+    A3D_PRD04_UV_TRANSFORM,
+    A3D_PRD04_ALPHA_A2C,
+    A3D_PRD04_DEBUG_VIEW
+];
+let registered = false;
+/**
+ * Register every a3d_prd04_* chunk with the program registry (C-02): the
+ * fifteen declaration chunks plus their pars/call split (`lobe_calls`, T0-05).
+ * Idempotent: a second call is a no-op so repeated lane-barrel evaluation
+ * or test setups cannot double-register.
+ */
+export function registerPrd04ShaderChunks() {
+    if (registered)
+        return;
+    for (const chunk of [...PRD04_SHADER_CHUNKS, ...PRD04_CALL_CHUNKS]) {
+        if (shaderChunk(chunk.name) === undefined) {
+            registerShaderChunk(chunk);
+        }
+    }
+    registered = true;
+}
+export { PRD04_CALL_CHUNKS };
+export { A3D_PRD04_BSDF_LOBES_COMMON, A3D_PRD04_SPECULAR_IOR, A3D_PRD04_CLEARCOAT, A3D_PRD04_SHEEN, A3D_PRD04_IRIDESCENCE, A3D_PRD04_ANISOTROPY, A3D_PRD04_TRANSMISSION, A3D_PRD04_VOLUME, A3D_PRD04_DISPERSION, A3D_PRD04_EMISSIVE_STRENGTH, A3D_PRD04_UNLIT, A3D_PRD04_TANGENT_FRAME, A3D_PRD04_UV_TRANSFORM, A3D_PRD04_ALPHA_A2C, A3D_PRD04_DEBUG_VIEW };
+//# sourceMappingURL=index.js.map

package/dist/shaders/physical/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3E,OAAO,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzD,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAClC,2BAA2B;IAC3B,sBAAsB;IACtB,mBAAmB;IACnB,eAAe;IACf,qBAAqB;IACrB,oBAAoB;IACpB,sBAAsB;IACtB,gBAAgB;IAChB,oBAAoB;IACpB,2BAA2B;IAC3B,eAAe;IACf,uBAAuB;IACvB,sBAAsB;IACtB,mBAAmB;IACnB,oBAAoB;CACX,CAAC;AAEX,IAAI,UAAU,GAAG,KAAK,CAAC;AAEvB;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB;IACxC,IAAI,UAAU;QAAE,OAAO;IACvB,KAAK,MAAM,KAAK,IAAI,CAAC,GAAG,mBAAmB,EAAE,GAAG,iBAAiB,CAAC,EAAE,CAAC;QACpE,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;YAC3C,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;IACF,CAAC;IACD,UAAU,GAAG,IAAI,CAAC;AACnB,CAAC;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAE7B,OAAO,EACN,2BAA2B,EAC3B,sBAAsB,EACtB,mBAAmB,EACnB,eAAe,EACf,qBAAqB,EACrB,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,EAChB,oBAAoB,EACpB,2BAA2B,EAC3B,eAAe,EACf,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,CAAC"}

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

@@ -0,0 +1,25 @@
+/**
+ * a3d_prd04_iridescence — KHR_materials_iridescence thin-film (PRD-04 §8.5).
+ *
+ * Ported from three r185:
+ *  - Factor resolution: iridescence *= tex.r; thickness =
+ *    (max-min) * tex.g + min (default max when no map) —
+ *    lights_physical_fragment.glsl.js:88-109; zero-thickness lobe off and
+ *    saturate — lights_fragment_begin.glsl.js:30-40.
+ *  - `evalSensitivity` XYZ Fourier sensitivity curves and
+ *    `evalIridescence` thin-film Fresnel — Belcour/Barla 2017:
+ *    iridescence_fragment.glsl.js:5-116.
+ *  - Fresnel split + Schlick_to_F0:
+ *    lights_fragment_begin.glsl.js:42-50; direct-lobe blend
+ *    `F = mix( F, iridescenceFresnel, iridescence )`
+ *    (lights_physical_pars_fragment.glsl.js:170-174); indirect
+ *    multiscattering split — dielectric evaluated with
+ *    iridescenceFresnelDielectric/specularF90, metallic with
+ *    iridescenceFresnelMetallic/1.0 (:389-419, :596-644).
+ *
+ * Requires `brdf` (F_Schlick, Schlick_to_F0, pow2, PI, saturate) and
+ * `a3d_prd04_bsdf_lobes_common` (A3DPrd04Lobes, a3dDFG).
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_IRIDESCENCE: ShaderChunk;
+//# sourceMappingURL=iridescence.glsl.d.ts.map

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

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

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

@@ -0,0 +1,186 @@
+import A3D_PRD04_IRIDESCENCE_WGSL from "../physical-wgsl/iridescence.wgsl.js";
+const glsl = /* glsl */ `
+const mat3 a3d_prd04_XYZ_TO_REC709 = mat3(
+	 3.2404542, -0.9692660,  0.0556434,
+	-1.5371385,  1.8760108, -0.2040259,
+	-0.4985314,  0.0415560,  1.0572252
+);
+
+// Fresnel0 -> IOR (r185 iridescence_fragment.glsl.js:14-19).
+vec3 a3dPrd04IridescenceFresnel0ToIor( const in vec3 fresnel0 ) {
+
+	vec3 sqrtF0 = sqrt( fresnel0 );
+	return ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );
+
+}
+
+vec3 a3dPrd04IridescenceIorToFresnel0( const in vec3 transmittedIor, const in float incidentIor ) {
+
+	return pow2( ( transmittedIor - vec3( incidentIor ) ) / ( transmittedIor + vec3( incidentIor ) ) );
+
+}
+
+float a3dPrd04IridescenceIorToFresnel0f( const in float transmittedIor, const in float incidentIor ) {
+
+	return pow2( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ) );
+
+}
+
+// XYZ sensitivity curves in Fourier space — Belcour & Barla 2017
+// (r185 evalSensitivity, iridescence_fragment.glsl.js:38-52).
+vec3 a3dPrd04EvalSensitivity( const in float OPD, const in vec3 shift ) {
+
+	float phase = 2.0 * PI * OPD * 1.0e-9;
+	vec3 val = vec3( 5.4856e-13, 4.4201e-13, 5.2481e-13 );
+	vec3 pos = vec3( 1.6810e+06, 1.7953e+06, 2.2084e+06 );
+	vec3 var = vec3( 4.3278e+09, 9.3046e+09, 6.6121e+09 );
+
+	vec3 xyz = val * sqrt( 2.0 * PI * var ) * cos( pos * phase + shift ) * exp( - pow2( phase ) * var );
+	xyz.x += 9.7470e-14 * sqrt( 2.0 * PI * 4.5282e+09 ) * cos( 2.2399e+06 * phase + shift[ 0 ] ) * exp( - 4.5282e+09 * pow2( phase ) );
+	xyz /= 1.0685e-7;
+
+	vec3 rgb = a3d_prd04_XYZ_TO_REC709 * xyz;
+	return rgb;
+
+}
+
+// Thin-film Fresnel (r185 evalIridescence, iridescence_fragment.glsl.js:54-116).
+vec3 a3dPrd04EvalIridescence( const in float outsideIOR, const in float eta2, const in float cosTheta1, const in float thinFilmThickness, const in vec3 baseF0 ) {
+
+	vec3 I;
+
+	// Force iridescenceIOR -> outsideIOR when thinFilmThickness -> 0.0
+	float iridescenceIOR = mix( outsideIOR, eta2, smoothstep( 0.0, 0.03, thinFilmThickness ) );
+	// Evaluate the cosTheta on the base layer (Snell law)
+	float sinTheta2Sq = pow2( outsideIOR / iridescenceIOR ) * ( 1.0 - pow2( cosTheta1 ) );
+
+	// Handle TIR:
+	float cosTheta2Sq = 1.0 - sinTheta2Sq;
+	if ( cosTheta2Sq < 0.0 ) {
+
+		return vec3( 1.0 );
+
+	}
+
+	float cosTheta2 = sqrt( cosTheta2Sq );
+
+	// First interface
+	float R0 = a3dPrd04IridescenceIorToFresnel0f( iridescenceIOR, outsideIOR );
+	float R12 = F_Schlick( R0, 1.0, cosTheta1 );
+	float T121 = 1.0 - R12;
+	float phi12 = 0.0;
+	if ( iridescenceIOR < outsideIOR ) phi12 = PI;
+	float phi21 = PI - phi12;
+
+	// Second interface
+	vec3 baseIOR = a3dPrd04IridescenceFresnel0ToIor( clamp( baseF0, 0.0, 0.9999 ) ); // guard against 1.0
+	vec3 R1 = a3dPrd04IridescenceIorToFresnel0( baseIOR, iridescenceIOR );
+	vec3 R23 = F_Schlick( R1, 1.0, cosTheta2 );
+	vec3 phi23 = vec3( 0.0 );
+	if ( baseIOR[ 0 ] < iridescenceIOR ) phi23[ 0 ] = PI;
+	if ( baseIOR[ 1 ] < iridescenceIOR ) phi23[ 1 ] = PI;
+	if ( baseIOR[ 2 ] < iridescenceIOR ) phi23[ 2 ] = PI;
+
+	// Phase shift
+	float OPD = 2.0 * iridescenceIOR * thinFilmThickness * cosTheta2;
+	vec3 phi = vec3( phi21 ) + phi23;
+
+	// Compound terms
+	vec3 R123 = clamp( R12 * R23, 1e-5, 0.9999 );
+	vec3 r123 = sqrt( R123 );
+	vec3 Rs = pow2( T121 ) * R23 / ( vec3( 1.0 ) - R123 );
+
+	// Reflectance term for m = 0 (DC term amplitude)
+	vec3 C0 = R12 + Rs;
+	I = C0;
+
+	// Reflectance term for m > 0 (pairs of diracs)
+	vec3 Cm = Rs - T121;
+	for ( int m = 1; m <= 2; ++ m ) {
+
+		Cm *= r123;
+		vec3 Sm = 2.0 * a3dPrd04EvalSensitivity( float( m ) * OPD, float( m ) * phi );
+		I += Cm * Sm;
+
+	}
+
+	// Since out of gamut colors might be produced, negative color values are clamped to 0.
+	return max( I, vec3( 0.0 ) );
+
+}
+
+// Factor resolution (r185 lights_physical_fragment.glsl.js:88-109 +
+// lights_fragment_begin.glsl.js:30-40). thicknessTex = iridescenceThicknessMap
+// texel (.g); pass vec4(1.0) when no map is bound.
+void a3dPrd04IridescenceInit( inout A3DPrd04Lobes lobes, const in float iridescenceFactor, const in float iridescenceIOR, const in vec4 iridescenceTex, const in vec4 thicknessTex, const in float thicknessMin, const in float thicknessMax, const in vec3 specularColor, const in vec3 diffuseColor, const in float metalness, const in float dotNV ) {
+
+	lobes.iridescence = iridescenceFactor * iridescenceTex.r;
+	lobes.iridescenceIOR = iridescenceIOR;
+	lobes.iridescenceThickness = ( thicknessMax - thicknessMin ) * thicknessTex.g + thicknessMin;
+
+	if ( lobes.iridescenceThickness == 0.0 ) {
+
+		lobes.iridescence = 0.0;
+
+	} else {
+
+		lobes.iridescence = saturate( lobes.iridescence );
+
+	}
+
+	if ( lobes.iridescence > 0.0 ) {
+
+		vec3 fresnelDielectric = a3dPrd04EvalIridescence( 1.0, lobes.iridescenceIOR, dotNV, lobes.iridescenceThickness, specularColor );
+		vec3 fresnelMetallic = a3dPrd04EvalIridescence( 1.0, lobes.iridescenceIOR, dotNV, lobes.iridescenceThickness, diffuseColor );
+
+		lobes.iridescenceFresnel = mix( fresnelDielectric, fresnelMetallic, metalness );
+		lobes.iridescenceF0 = Schlick_to_F0( lobes.iridescenceFresnel, 1.0, dotNV );
+
+	} else {
+
+		lobes.iridescenceFresnel = vec3( 0.0 );
+		lobes.iridescenceF0 = vec3( 0.0 );
+
+	}
+
+}
+
+// Direct-lobe Fresnel blend (r185 lights_physical_pars_fragment.glsl.js:170-174):
+// F = mix( F_Schlick( f0, f90, dotVH ), iridescenceFresnel, iridescence ).
+vec3 a3dPrd04IridescenceFresnelMix( const in vec3 F, const in vec3 iridescenceFresnel, const in float iridescence ) {
+
+	return mix( F, iridescenceFresnel, iridescence );
+
+}
+
+// IBL multiscattering with thin-film F0 (r185 computeMultiscatteringIridescence,
+// lights_physical_pars_fragment.glsl.js:389-419).
+void a3dPrd04ComputeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
+
+	float dotNV = saturate( dot( normal, viewDir ) );
+	vec2 fab = a3dDFG( roughness, dotNV );
+
+	vec3 Fr = mix( specularColor, iridescenceF0, iridescence );
+
+	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_IRIDESCENCE = {
+    name: "a3d_prd04_iridescence",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_IRIDESCENCE_WGSL,
+    stage: "fragment",
+    requires: ["brdf", "a3d_prd04_bsdf_lobes_common"]
+};
+//# sourceMappingURL=iridescence.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iridescence.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/iridescence.glsl.ts"],"names":[],"mappings":"AAuBA,OAAO,0BAA0B,MAAM,sCAAsC,CAAC;AAE9E,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+KvB,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAgB;IACjD,IAAI,EAAE,uBAAuB;IAC7B,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,0BAA0B;IAChC,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,CAAC,MAAM,EAAE,6BAA6B,CAAC;CACjD,CAAC"}