@aura3d/rendering 3.0.1 → 4.0.2

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

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

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

@@ -0,0 +1,64 @@
+import A3D_PRD04_SPECULAR_IOR_WGSL from "../physical-wgsl/specular_ior.wgsl.js";
+const glsl = /* glsl */ `
+// IOR <-> F0 conversion (r185 iridescence_fragment.glsl.js:14-33).
+vec3 a3dPrd04IorToF0( const in vec3 transmittedIor, const in float incidentIor ) {
+
+	return pow2( ( transmittedIor - vec3( incidentIor ) ) / ( transmittedIor + vec3( incidentIor ) ) );
+
+}
+
+float a3dPrd04IorToF0f( const in float transmittedIor, const in float incidentIor ) {
+
+	return pow2( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ) );
+
+}
+
+vec3 a3dPrd04F0ToIor( const in vec3 fresnel0 ) {
+
+	vec3 sqrtF0 = sqrt( fresnel0 );
+	return ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );
+
+}
+
+// Resolve specular texture factors (r185 lights_physical_fragment.glsl.js:20-33).
+// Returns specularColorFactor = specularColor * texel.rgb;
+// outSpecIntensity = specularIntensity * texel.a.
+vec3 a3dPrd04SpecIorFactors( const in vec3 specularColorFactor, const in float specularIntensityFactor, const in vec3 specularColorTexel, const in float specularIntensityTexel, out float outSpecIntensity ) {
+
+	outSpecIntensity = specularIntensityFactor * specularIntensityTexel;
+	return specularColorFactor * specularColorTexel;
+
+}
+
+// Dielectric specularColor from ior (r185 lights_physical_fragment.glsl.js:45).
+// min( pow2( ( ior - 1 ) / ( ior + 1 ) ) * specularColorFactor, 1 ) * specularIntensity
+vec3 a3dPrd04SpecIorSpecularColor( const in float ior, const in vec3 specularColorFactor, const in float specularIntensity ) {
+
+	return min( a3dPrd04IorToF0( vec3( ior ), 1.0 ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensity;
+
+}
+
+// specularF90 = mix( specularIntensity, 1, metalness ) (r185 :35);
+// default path uses 1.0 (:41).
+float a3dPrd04SpecIorSpecularF90( const in float specularIntensity, const in float metallic ) {
+
+	return mix( specularIntensity, 1.0, metallic );
+
+}
+
+// specularColorBlended = mix( specularColor, diffuseColor, metalness ) (r185 :46, :51).
+vec3 a3dPrd04SpecIorSpecularColorBlended( const in vec3 specularColor, const in vec3 diffuseColor, const in float metallic ) {
+
+	return mix( specularColor, diffuseColor, metallic );
+
+}
+`;
+export const A3D_PRD04_SPECULAR_IOR = {
+    name: "a3d_prd04_specular_ior",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_SPECULAR_IOR_WGSL,
+    stage: "fragment",
+    requires: ["brdf", "a3d_prd04_bsdf_lobes_common"]
+};
+//# sourceMappingURL=specular_ior.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"specular_ior.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/specular_ior.glsl.ts"],"names":[],"mappings":"AAkBA,OAAO,2BAA2B,MAAM,uCAAuC,CAAC;AAEhF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDvB,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAgB;IAClD,IAAI,EAAE,wBAAwB;IAC9B,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,2BAA2B;IACjC,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,CAAC,MAAM,EAAE,6BAA6B,CAAC;CACjD,CAAC"}

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

@@ -0,0 +1,27 @@
+/**
+ * a3d_prd04_tangent_frame — TANGENT attribute TBN construction (PRD-04 §8.11,
+ * tangents requirement R2).
+ *
+ * Ported from three r185:
+ *  - Vertex: `v_tangent = vec4( normalize( mat3( skinnedModel ) *
+ *    a_tangent.xyz ), a_tangent.w )` —
+ *    ShaderChunk/defaultnormal_vertex + skinnormal path (tangent transformed
+ *    by the same skinning matrix as the normal, w bitangent sign preserved).
+ *  - Fragment: TBN assembly + re-orthogonalization
+ *    `T = normalize( T - N * dot( N, T ) ); B = cross( N, T ) * w` —
+ *    normal_fragment_begin.glsl.js:24-48; double-sided face-direction flip on
+ *    both axes (:42-47).
+ *  - `getTangentFrame` derivative fallback (Normal Mapping Without
+ *    Precomputed Tangents, thetenthplanet.de/archives/1180):
+ *    normalmap_pars_fragment.glsl.js:15-40 — active only under
+ *    `A3D_TANGENT_DERIVATIVE` when the mesh lacks a TANGENT attribute
+ *    (PRD-04 §8.11 decision: authored TANGENT wins; derivative frame is the
+ *    documented fallback, never silently substituted on meshes that carry
+ *    tangents).
+ *
+ * Stage "both": the vertex arm computes the varying, the fragment arm builds
+ * the frame. Self-contained (no requires).
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_TANGENT_FRAME: ShaderChunk;
+//# sourceMappingURL=tangent_frame.glsl.d.ts.map

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

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

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

@@ -0,0 +1,71 @@
+import A3D_PRD04_TANGENT_FRAME_WGSL from "../physical-wgsl/tangent_frame.wgsl.js";
+const glsl = /* glsl */ `
+#ifdef A3D_STAGE_VERTEX
+
+// v_tangent payload: xyz = world-space tangent, w = bitangent sign
+// (r185 defaultnormal_vertex path).
+vec4 a3dPrd04TangentWorld( const in mat3 skinnedModel, const in vec4 tangent ) {
+
+	return vec4( normalize( skinnedModel * tangent.xyz ), tangent.w );
+
+}
+
+#else
+
+// Re-orthogonalized TBN from interpolated attributes (r185
+// normal_fragment_begin.glsl.js:24-28 + Gram-Schmidt; faceDirection applies
+// the double-sided flip to both axes, :42-47).
+mat3 a3dPrd04TangentFrame( const in vec3 normal, const in vec4 tangent, const in float faceDirection ) {
+
+	vec3 T = normalize( tangent.xyz );
+	T = normalize( T - normal * dot( normal, T ) );
+	vec3 B = cross( normal, T ) * tangent.w;
+
+	mat3 tbn = mat3( T, B, normal );
+
+	tbn[ 0 ] *= faceDirection;
+	tbn[ 1 ] *= faceDirection;
+
+	return tbn;
+
+}
+
+#ifdef A3D_TANGENT_DERIVATIVE
+
+// Derivative fallback frame — Normal Mapping Without Precomputed Tangents
+// (r185 getTangentFrame, normalmap_pars_fragment.glsl.js:20-39).
+mat3 a3dPrd04GetTangentFrame( const in vec3 eye_pos, const in vec3 surf_norm, const in vec2 uv ) {
+
+	vec3 q0 = dFdx( eye_pos.xyz );
+	vec3 q1 = dFdy( eye_pos.xyz );
+	vec2 st0 = dFdx( uv.st );
+	vec2 st1 = dFdy( uv.st );
+
+	vec3 N = surf_norm; // normalized
+
+	vec3 q1perp = cross( q1, N );
+	vec3 q0perp = cross( N, q0 );
+
+	vec3 T = q1perp * st0.x + q0perp * st1.x;
+	vec3 B = q1perp * st0.y + q0perp * st1.y;
+
+	float det = max( dot( T, T ), dot( B, B ) );
+	float scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );
+
+	return mat3( T * scale, B * scale, N );
+
+}
+
+#endif // A3D_TANGENT_DERIVATIVE
+
+#endif // A3D_STAGE_VERTEX
+`;
+export const A3D_PRD04_TANGENT_FRAME = {
+    name: "a3d_prd04_tangent_frame",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_TANGENT_FRAME_WGSL,
+    stage: "both",
+    requires: []
+};
+//# sourceMappingURL=tangent_frame.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tangent_frame.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/tangent_frame.glsl.ts"],"names":[],"mappings":"AAyBA,OAAO,4BAA4B,MAAM,wCAAwC,CAAC;AAElF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DvB,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAgB;IACnD,IAAI,EAAE,yBAAyB;IAC/B,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,4BAA4B;IAClC,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,EAAE;CACZ,CAAC"}

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

@@ -0,0 +1,25 @@
+/**
+ * a3d_prd04_transmission — KHR_materials_transmission (PRD-04 §8.7).
+ *
+ * Ported from three r185 (glTF-Sampler-Viewer lineage):
+ *  - `getVolumeTransmissionRay` — refraction vector scaled by model matrix:
+ *    transmission_pars_fragment.glsl.js:121-135.
+ *  - `applyIorToRoughness` — `roughness * clamp( ior * 2 - 2, 0, 1 )`:
+ *    transmission_pars_fragment.glsl.js:137-143.
+ *  - `getTransmissionSample` — lod = log2( size.x ) * applyIorToRoughness;
+ *    bicubic filtering (N8, shadertoy Dl2SDW) behind
+ *    `A3D_TRANSMISSION_BICUBIC` (PRD-04 quality tier table: bilinear Medium,
+ *    bicubic High/Ultra): transmission_pars_fragment.glsl.js:32-119,145-150.
+ *  - `getIBLVolumeRefraction` composition:
+ *    transmission_pars_fragment.glsl.js:170-233.
+ *
+ * All declarations live inside `#ifdef A3D_TRANSMISSION` mirroring r185's
+ * USE_TRANSMISSION guards. Sampler uniforms are the TransmissiveSurface's
+ * opaque-scene copy (PRD-04 §7.3 TransmissiveSurface, §17).
+ *
+ * Requires `brdf` (saturate), `a3d_prd04_bsdf_lobes_common`
+ * (a3dPrd04EnvironmentBRDF) and `a3d_prd04_volume` (a3dVolumeAttenuation).
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_TRANSMISSION: ShaderChunk;
+//# sourceMappingURL=transmission.glsl.d.ts.map

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

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

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

@@ -0,0 +1,204 @@
+import A3D_PRD04_TRANSMISSION_WGSL from "../physical-wgsl/transmission.wgsl.js";
+const glsl = /* glsl */ `
+#ifdef A3D_TRANSMISSION
+
+uniform sampler2D a3d_prd04_transmissionSampler;
+uniform vec2 a3d_prd04_transmissionSamplerSize;
+
+uniform mat4 a3d_prd04_modelMatrix;
+#ifdef A3D_GENERATED_PROGRAM
+// C-02 generated programs: view/projection come from the AuraFrame block (C-08).
+#define a3d_prd04_projectionMatrix u_projection
+#define a3d_prd04_viewMatrix u_view
+#else
+uniform mat4 a3d_prd04_projectionMatrix;
+uniform mat4 a3d_prd04_viewMatrix;
+#endif
+
+// Mipped Bicubic Texture Filtering by N8
+// https://www.shadertoy.com/view/Dl2SDW
+// (r185 transmission_pars_fragment.glsl.js:35-119)
+#ifdef A3D_TRANSMISSION_BICUBIC
+
+float a3d_prd04_w0( const in float a ) {
+
+	return ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );
+
+}
+
+float a3d_prd04_w1( const in float a ) {
+
+	return ( 1.0 / 6.0 ) * ( a *  a * ( 3.0 * a - 6.0 ) + 4.0 );
+
+}
+
+float a3d_prd04_w2( const in float a ){
+
+	return ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );
+
+}
+
+float a3d_prd04_w3( const in float a ) {
+
+	return ( 1.0 / 6.0 ) * ( a * a * a );
+
+}
+
+float a3d_prd04_g0( const in float a ) {
+
+	return a3d_prd04_w0( a ) + a3d_prd04_w1( a );
+
+}
+
+float a3d_prd04_g1( const in float a ) {
+
+	return a3d_prd04_w2( a ) + a3d_prd04_w3( a );
+
+}
+
+float a3d_prd04_h0( const in float a ) {
+
+	return - 1.0 + a3d_prd04_w1( a ) / ( a3d_prd04_w0( a ) + a3d_prd04_w1( a ) );
+
+}
+
+float a3d_prd04_h1( const in float a ) {
+
+	return 1.0 + a3d_prd04_w3( a ) / ( a3d_prd04_w2( a ) + a3d_prd04_w3( a ) );
+
+}
+
+vec4 a3d_prd04_bicubic( const in sampler2D tex, const in vec2 uv, const in vec4 texelSize, const in float lod ) {
+
+	vec2 uvScaled = uv * texelSize.zw + 0.5;
+
+	vec2 iuv = floor( uvScaled );
+	vec2 fuv = fract( uvScaled );
+
+	float g0x = a3d_prd04_g0( fuv.x );
+	float g1x = a3d_prd04_g1( fuv.x );
+	float h0x = a3d_prd04_h0( fuv.x );
+	float h1x = a3d_prd04_h1( fuv.x );
+	float h0y = a3d_prd04_h0( fuv.y );
+	float h1y = a3d_prd04_h1( fuv.y );
+
+	vec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;
+	vec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;
+	vec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;
+	vec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;
+
+	return a3d_prd04_g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +
+		a3d_prd04_g1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );
+
+}
+
+vec4 a3d_prd04_textureBicubic( const in sampler2D sampler, const in vec2 uv, const in float lod ) {
+
+	vec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );
+	vec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );
+	vec2 fLodSizeInv = 1.0 / fLodSize;
+	vec2 cLodSizeInv = 1.0 / cLodSize;
+	vec4 fSample = a3d_prd04_bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );
+	vec4 cSample = a3d_prd04_bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );
+	return mix( fSample, cSample, fract( lod ) );
+
+}
+
+#endif // A3D_TRANSMISSION_BICUBIC
+
+// Direction of refracted light through the volume (r185
+// getVolumeTransmissionRay, transmission_pars_fragment.glsl.js:121-135).
+vec3 a3dVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
+
+	vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
+
+	// Compute rotation-independent scaling of the model matrix.
+	vec3 modelScale;
+	modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
+	modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
+	modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
+
+	// The thickness is specified in local space.
+	return normalize( refractionVector ) * thickness * modelScale;
+
+}
+
+// Scale roughness with IOR so that an IOR of 1.0 results in no microfacet
+// refraction and an IOR of 1.5 results in the default amount (r185
+// applyIorToRoughness, transmission_pars_fragment.glsl.js:137-143).
+float a3dApplyIorToRoughness( const in float roughness, const in float ior ) {
+
+	return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
+
+}
+
+// Sample the opaque-scene copy at the mip implied by the IOR-scaled
+// roughness (r185 getTransmissionSample,
+// transmission_pars_fragment.glsl.js:145-150). fragCoord in [0,1] NDC-UV.
+vec4 a3dTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
+
+	float lod = log2( a3d_prd04_transmissionSamplerSize.x ) * a3dApplyIorToRoughness( roughness, ior );
+
+	#ifdef A3D_TRANSMISSION_BICUBIC
+
+		return a3d_prd04_textureBicubic( a3d_prd04_transmissionSampler, fragCoord.xy, lod );
+
+	#else
+
+		return textureLod( a3d_prd04_transmissionSampler, fragCoord.xy, lod );
+
+	#endif
+
+}
+
+// Screen-space refraction sample: NDC-UV for the point position +
+// transmissionRay (r185 getIBLVolumeRefraction projection block,
+// transmission_pars_fragment.glsl.js:188-195).
+vec2 a3dTransmissionCoords( const in vec3 exitPosition, const in mat4 viewMatrix, const in mat4 projMatrix ) {
+
+	vec4 ndcPos = projMatrix * viewMatrix * vec4( exitPosition, 1.0 );
+	vec2 refractionCoords = ndcPos.xy / ndcPos.w;
+	refractionCoords += 1.0;
+	refractionCoords /= 2.0;
+	return refractionCoords;
+
+}
+
+// Single-band volume refraction (r185 getIBLVolumeRefraction non-dispersion
+// arm, transmission_pars_fragment.glsl.js:206-231).
+vec4 a3dGetIBLVolumeRefraction( 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 ior, const in float thickness, const in vec3 attenuationColor, const in float attenuationDistance ) {
+
+	vec3 transmissionRay = a3dVolumeTransmissionRay( n, v, thickness, ior, 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 transmittedLight = a3dTransmissionSample( refractionCoords, roughness, ior );
+	vec3 transmittance = diffuseColor * a3dVolumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );
+
+	vec3 attenuatedColor = transmittance * transmittedLight.rgb;
+
+	// Get the specular component.
+	vec3 F = a3dPrd04EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
+
+	// As less light is transmitted, the opacity should be increased. This simple approximation does a decent job
+	// of modulating a CSS background, and has no effect when the buffer is opaque, due to a solid object or clear color.
+	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
+`;
+export const A3D_PRD04_TRANSMISSION = {
+    name: "a3d_prd04_transmission",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_TRANSMISSION_WGSL,
+    stage: "fragment",
+    requires: ["brdf", "a3d_prd04_bsdf_lobes_common", "a3d_prd04_volume"]
+};
+//# sourceMappingURL=transmission.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transmission.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/transmission.glsl.ts"],"names":[],"mappings":"AAuBA,OAAO,2BAA2B,MAAM,uCAAuC,CAAC;AAEhF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiMvB,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAgB;IAClD,IAAI,EAAE,wBAAwB;IAC9B,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,2BAA2B;IACjC,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,CAAC,MAAM,EAAE,6BAA6B,EAAE,kBAAkB,CAAC;CACrE,CAAC"}

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

@@ -0,0 +1,15 @@
+/**
+ * a3d_prd04_transmission_copy — fullscreen blit used by the T0-18(c)
+ * GPU-side transmission-target copy in `forward/Transmission.ts` (PRD-04 P4-2;
+ * lane-original, no r185 port).
+ *
+ * Lives under `shaders/physical/` because the arch-gate `glsl-location`
+ * (PRD-15 §6.12) only permits `#version` template strings inside
+ * chunk/post/output locations; `forward/` is not one.
+ *
+ * The device requires `marker` to appear verbatim in both GLSL stages.
+ */
+export declare const TRANSMISSION_COPY_VERTEX = "#version 300 es\n// a3d_prd04_transmission_copy\nprecision highp float;\nout vec2 v_uv;\nvoid main() {\n  vec2 position = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));\n  v_uv = position;\n  gl_Position = vec4(position * 2.0 - 1.0, 0.0, 1.0);\n}\n";
+export declare const TRANSMISSION_COPY_FRAGMENT = "#version 300 es\n// a3d_prd04_transmission_copy\nprecision highp float;\nuniform sampler2D u_source;\nin vec2 v_uv;\nout vec4 outColor;\nvoid main() {\n  outColor = texture(u_source, v_uv);\n}\n";
+export declare const TRANSMISSION_COPY_MARKER = "a3d_prd04_transmission_copy";
+//# sourceMappingURL=transmission_copy.glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transmission_copy.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/transmission_copy.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,2QASpC,CAAC;AAEF,eAAO,MAAM,0BAA0B,uMAStC,CAAC;AAEF,eAAO,MAAM,wBAAwB,gCAAgC,CAAC"}

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

@@ -0,0 +1,33 @@
+/**
+ * a3d_prd04_transmission_copy — fullscreen blit used by the T0-18(c)
+ * GPU-side transmission-target copy in `forward/Transmission.ts` (PRD-04 P4-2;
+ * lane-original, no r185 port).
+ *
+ * Lives under `shaders/physical/` because the arch-gate `glsl-location`
+ * (PRD-15 §6.12) only permits `#version` template strings inside
+ * chunk/post/output locations; `forward/` is not one.
+ *
+ * The device requires `marker` to appear verbatim in both GLSL stages.
+ */
+export const TRANSMISSION_COPY_VERTEX = /* glsl */ `#version 300 es
+// a3d_prd04_transmission_copy
+precision highp float;
+out vec2 v_uv;
+void main() {
+  vec2 position = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
+  v_uv = position;
+  gl_Position = vec4(position * 2.0 - 1.0, 0.0, 1.0);
+}
+`;
+export const TRANSMISSION_COPY_FRAGMENT = /* glsl */ `#version 300 es
+// a3d_prd04_transmission_copy
+precision highp float;
+uniform sampler2D u_source;
+in vec2 v_uv;
+out vec4 outColor;
+void main() {
+  outColor = texture(u_source, v_uv);
+}
+`;
+export const TRANSMISSION_COPY_MARKER = "a3d_prd04_transmission_copy";
+//# sourceMappingURL=transmission_copy.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transmission_copy.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/transmission_copy.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;CASlD,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG,UAAU,CAAC;;;;;;;;;CASpD,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,6BAA6B,CAAC"}

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

@@ -0,0 +1,17 @@
+/**
+ * a3d_prd04_unlit — KHR_materials_unlit (PRD-04 §8.2 [11]).
+ *
+ * Ported from three r185:
+ *  - Unlit path emits `diffuseColor` directly: no lighting accumulation, no
+ *    specular/diffuse evaluation (ShaderLib/meshbasic + the unlit arm of
+ *    WebGLPrograms; the lobe contract is `outgoingLight = diffuseColor`,
+ *    premultiplied alpha handled by the opaque_fragment stage downstream).
+ *
+ * Self-contained — no requires. Selected when `lighting: "unlit"` in
+ * ProgramFeatures (replaces brdf evaluation entirely; a materialStrictness
+ * 'spec' import reports `extension-lobe-pending` if it arrives before this
+ * lobe, PRD-04 §11).
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_UNLIT: ShaderChunk;
+//# sourceMappingURL=unlit.glsl.d.ts.map

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

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

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

@@ -0,0 +1,19 @@
+import A3D_PRD04_UNLIT_WGSL from "../physical-wgsl/unlit.wgsl.js";
+const glsl = /* glsl */ `
+// Unlit output: baseColor straight through (r185 unlit arm).
+// postAlpha keeps a single call site for opacity multiplication.
+vec4 a3dPrd04UnlitColor( const in vec4 diffuseColor ) {
+
+	return diffuseColor;
+
+}
+`;
+export const A3D_PRD04_UNLIT = {
+    name: "a3d_prd04_unlit",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_UNLIT_WGSL,
+    stage: "fragment",
+    requires: []
+};
+//# sourceMappingURL=unlit.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unlit.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/unlit.glsl.ts"],"names":[],"mappings":"AAeA,OAAO,oBAAoB,MAAM,gCAAgC,CAAC;AAElE,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;CAQvB,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAgB;IAC3C,IAAI,EAAE,iBAAiB;IACvB,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,oBAAoB;IAC1B,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,EAAE;CACZ,CAAC"}

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

@@ -0,0 +1,18 @@
+/**
+ * a3d_prd04_uv_transform — KHR_texture_transform UV evaluation
+ * (PRD-04 §8.10).
+ *
+ * Ported from three r185:
+ *  - Fragment-side UV selection + transform:
+ *    `( uvTransform * vec3( texCoord == 1 ? uv1 : uv0, 1 ) ).xy` —
+ *    ShaderChunk/uv_pars_fragment + map_fragment convention; the transform
+ *    matrix itself is the CPU-built T·R·S 2D affine (uvTransformMatrix in
+ *    features.ts Phase 3, matching r185 WebGLUniforms uvTransform path).
+ *  - Channel order: the extension's texCoord override picks which UV set a
+ *    texture samples; default is set 0 (r185 getUvChannel).
+ *
+ * Self-contained (no requires). Stage fragment.
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_UV_TRANSFORM: ShaderChunk;
+//# sourceMappingURL=uv_transform.glsl.d.ts.map

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

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

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

@@ -0,0 +1,30 @@
+import A3D_PRD04_UV_TRANSFORM_WGSL from "../physical-wgsl/uv_transform.wgsl.js";
+const glsl = /* glsl */ `
+// Apply a KHR_texture_transform matrix to the requested UV set.
+// m is the CPU-computed T·R·S affine (column-major, z=1 point transform).
+// texCoord selects uv0 or uv1 exactly like r185 getUvChannel.
+vec2 a3dPrd04UvTransform( const in mat3 m, const in int texCoord, const in vec2 uv0, const in vec2 uv1 ) {
+
+	vec2 uv = ( texCoord == 1 ) ? uv1 : uv0;
+	return ( m * vec3( uv, 1.0 ) ).xy;
+
+}
+
+// Identity-transform fast path helper: returns uvN untransformed when the
+// caller already knows the transform is identity (avoids a needless mat3
+// multiply — r185 skips binding the uniform entirely in that case).
+vec2 a3dPrd04UvSelect( const in int texCoord, const in vec2 uv0, const in vec2 uv1 ) {
+
+	return ( texCoord == 1 ) ? uv1 : uv0;
+
+}
+`;
+export const A3D_PRD04_UV_TRANSFORM = {
+    name: "a3d_prd04_uv_transform",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_UV_TRANSFORM_WGSL,
+    stage: "fragment",
+    requires: []
+};
+//# sourceMappingURL=uv_transform.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uv_transform.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/uv_transform.glsl.ts"],"names":[],"mappings":"AAgBA,OAAO,2BAA2B,MAAM,uCAAuC,CAAC;AAEhF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;CAmBvB,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAgB;IAClD,IAAI,EAAE,wBAAwB;IAC9B,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,2BAA2B;IACjC,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,EAAE;CACZ,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * a3d_prd04_volume — KHR_materials_volume attenuation (PRD-04 §8.8).
+ *
+ * Ported from three r185:
+ *  - `volumeAttenuation` Beer-Lambert:
+ *    transmission_pars_fragment.glsl.js:152-168.
+ *  - Thickness/attenuation factor resolution:
+ *    transmission_fragment.glsl.js:3-18 (thickness *= thicknessMap.g;
+ *    attenuationColor/attenuationDistance factors).
+ *
+ * The volume lobe rides the transmission sub-flag: all declarations sit inside
+ * `#ifdef A3D_TRANSMISSION` exactly like r185's USE_TRANSMISSION blocks.
+ *
+ * Requires `brdf` (saturate); A3DPrd04Lobes from
+ * `a3d_prd04_bsdf_lobes_common`.
+ */
+import type { ShaderChunk } from "../../contracts/program.js";
+export declare const A3D_PRD04_VOLUME: ShaderChunk;
+//# sourceMappingURL=volume.glsl.d.ts.map

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

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

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

@@ -0,0 +1,47 @@
+import A3D_PRD04_VOLUME_WGSL from "../physical-wgsl/volume.wgsl.js";
+const glsl = /* glsl */ `
+#ifdef A3D_TRANSMISSION
+
+// Beer-Lambert attenuation (r185 volumeAttenuation,
+// transmission_pars_fragment.glsl.js:152-168).
+vec3 a3dVolumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
+
+	if ( isinf( attenuationDistance ) ) {
+
+		// Attenuation distance is +∞, i.e. the transmitted color is not attenuated at all.
+		return vec3( 1.0 );
+
+	} else {
+
+		// Compute light attenuation using Beer's law.
+		vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
+		vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance ); // Beer's law
+		return transmittance;
+
+	}
+
+}
+
+// Factor resolution (r185 transmission_fragment.glsl.js:3-18).
+// transmissionTex = transmissionMap texel (.r), thicknessTex = thicknessMap
+// texel (.g); pass vec4(1.0) when no map is bound.
+void a3dPrd04VolumeInit( inout A3DPrd04Lobes lobes, const in float transmissionFactor, const in float thicknessFactor, const in float attenuationDistanceFactor, const in vec3 attenuationColorFactor, const in vec4 transmissionTex, const in vec4 thicknessTex ) {
+
+	lobes.transmission = transmissionFactor * transmissionTex.r;
+	lobes.thickness = thicknessFactor * thicknessTex.g;
+	lobes.attenuationDistance = attenuationDistanceFactor;
+	lobes.attenuationColor = attenuationColorFactor;
+
+}
+
+#endif
+`;
+export const A3D_PRD04_VOLUME = {
+    name: "a3d_prd04_volume",
+    owner: "prd04",
+    glsl,
+    wgsl: A3D_PRD04_VOLUME_WGSL,
+    stage: "fragment",
+    requires: ["brdf", "a3d_prd04_bsdf_lobes_common"]
+};
+//# sourceMappingURL=volume.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"volume.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical/volume.glsl.ts"],"names":[],"mappings":"AAiBA,OAAO,qBAAqB,MAAM,iCAAiC,CAAC;AAEpE,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCvB,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAgB;IAC5C,IAAI,EAAE,kBAAkB;IACxB,KAAK,EAAE,OAAO;IACd,IAAI;IACJ,IAAI,EAAE,qBAAqB;IAC3B,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,CAAC,MAAM,EAAE,6BAA6B,CAAC;CACjD,CAAC"}