@aura3d/rendering 3.0.0 → 4.0.0

package/dist/shaders/physical-wgsl/transmission.wgsl.js

@@ -0,0 +1,159 @@
+/**
+ * WGSL twin of a3d_prd04_transmission (PRD-04 §8.12): same `a3d_` names,
+ * identical math (r185 transmission_pars_fragment.glsl.js:32-233).
+ *
+ * §8.12 deltas vs the GLSL chunk: `textureSampleLevel` for LOD, a material
+ * uniform struct instead of loose `uniform mat4` globals, and separate
+ * `texture_2d`/`sampler` bindings. The `A3D_TRANSMISSION`/`A3D_TRANSMISSION_BICUBIC`
+ * guards are generator-time defines (C-29), so the twin emits all functions;
+ * the bicubic helpers stay inert until the generator selects them.
+ */
+const wgsl = /* wgsl */ `
+struct A3DPrd04TransmissionUniforms {
+	transmissionSamplerSize: vec2f,
+	modelMatrix: mat4x4f,
+	projectionMatrix: mat4x4f,
+	viewMatrix: mat4x4f,
+}
+
+@group(1) @binding(30) var<uniform> a3d_prd04_transmission: A3DPrd04TransmissionUniforms;
+@group(1) @binding(31) var a3d_prd04_transmissionTex: texture_2d<f32>;
+@group(1) @binding(32) var a3d_prd04_transmissionSmp: sampler;
+
+// Mipped Bicubic Texture Filtering by N8
+// https://www.shadertoy.com/view/Dl2SDW
+// (r185 transmission_pars_fragment.glsl.js:35-119 — A3D_TRANSMISSION_BICUBIC arm)
+fn a3d_prd04_w0(a: f32) -> f32 {
+	return (1.0 / 6.0) * (a * (a * (-a + 3.0) - 3.0) + 1.0);
+}
+
+fn a3d_prd04_w1(a: f32) -> f32 {
+	return (1.0 / 6.0) * (a * a * (3.0 * a - 6.0) + 4.0);
+}
+
+fn a3d_prd04_w2(a: f32) -> f32 {
+	return (1.0 / 6.0) * (a * (a * (-3.0 * a + 3.0) + 3.0) + 1.0);
+}
+
+fn a3d_prd04_w3(a: f32) -> f32 {
+	return (1.0 / 6.0) * (a * a * a);
+}
+
+fn a3d_prd04_g0(a: f32) -> f32 {
+	return a3d_prd04_w0(a) + a3d_prd04_w1(a);
+}
+
+fn a3d_prd04_g1(a: f32) -> f32 {
+	return a3d_prd04_w2(a) + a3d_prd04_w3(a);
+}
+
+fn a3d_prd04_h0(a: f32) -> f32 {
+	return -1.0 + a3d_prd04_w1(a) / (a3d_prd04_w0(a) + a3d_prd04_w1(a));
+}
+
+fn a3d_prd04_h1(a: f32) -> f32 {
+	return 1.0 + a3d_prd04_w3(a) / (a3d_prd04_w2(a) + a3d_prd04_w3(a));
+}
+
+fn a3d_prd04_bicubic(tex: texture_2d<f32>, smp: sampler, uv: vec2f, texelSize: vec4f, lod: f32) -> vec4f {
+	let uvScaled = uv * texelSize.zw + vec2f(0.5);
+
+	let iuv = floor(uvScaled);
+	let fuv = fract(uvScaled);
+
+	let g0x = a3d_prd04_g0(fuv.x);
+	let g1x = a3d_prd04_g1(fuv.x);
+	let h0x = a3d_prd04_h0(fuv.x);
+	let h1x = a3d_prd04_h1(fuv.x);
+	let h0y = a3d_prd04_h0(fuv.y);
+	let h1y = a3d_prd04_h1(fuv.y);
+
+	let p0 = (vec2f(iuv.x + h0x, iuv.y + h0y) - vec2f(0.5)) * texelSize.xy;
+	let p1 = (vec2f(iuv.x + h1x, iuv.y + h0y) - vec2f(0.5)) * texelSize.xy;
+	let p2 = (vec2f(iuv.x + h0x, iuv.y + h1y) - vec2f(0.5)) * texelSize.xy;
+	let p3 = (vec2f(iuv.x + h1x, iuv.y + h1y) - vec2f(0.5)) * texelSize.xy;
+
+	return a3d_prd04_g0(fuv.y) * (g0x * textureSampleLevel(tex, smp, p0, lod) + g1x * textureSampleLevel(tex, smp, p1, lod)) +
+		a3d_prd04_g1(fuv.y) * (g0x * textureSampleLevel(tex, smp, p2, lod) + g1x * textureSampleLevel(tex, smp, p3, lod));
+}
+
+fn a3d_prd04_textureBicubic(tex: texture_2d<f32>, smp: sampler, uv: vec2f, lod: f32) -> vec4f {
+	let fLodSize = vec2f(textureDimensions(tex, u32(lod)));
+	let cLodSize = vec2f(textureDimensions(tex, u32(lod + 1.0)));
+	let fLodSizeInv = 1.0 / fLodSize;
+	let cLodSizeInv = 1.0 / cLodSize;
+	let fSample = a3d_prd04_bicubic(tex, smp, uv, vec4f(fLodSizeInv, fLodSize), floor(lod));
+	let cSample = a3d_prd04_bicubic(tex, smp, uv, vec4f(cLodSizeInv, cLodSize), ceil(lod));
+	return mix(fSample, cSample, fract(lod));
+}
+
+// Direction of refracted light through the volume (r185
+// getVolumeTransmissionRay, transmission_pars_fragment.glsl.js:121-135).
+fn a3dVolumeTransmissionRay(n: vec3f, v: vec3f, thickness: f32, ior: f32, modelMatrix: mat4x4f) -> vec3f {
+	let refractionVector = refract(-v, normalize(n), 1.0 / ior);
+
+	// Compute rotation-independent scaling of the model matrix.
+	var modelScale: vec3f;
+	modelScale.x = length(modelMatrix[0].xyz);
+	modelScale.y = length(modelMatrix[1].xyz);
+	modelScale.z = length(modelMatrix[2].xyz);
+
+	// The thickness is specified in local space.
+	return normalize(refractionVector) * thickness * modelScale;
+}
+
+// Scale roughness with IOR (r185 applyIorToRoughness,
+// transmission_pars_fragment.glsl.js:137-143).
+fn a3dApplyIorToRoughness(roughness: f32, ior: f32) -> f32 {
+	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.
+// WGSL twin keeps the bicubic arm as a separate function the generator picks;
+// default arm is the plain textureSampleLevel.
+fn a3dTransmissionSample(fragCoord: vec2f, roughness: f32, ior: f32) -> vec4f {
+	let lod = log2(a3d_prd04_transmission.transmissionSamplerSize.x) * a3dApplyIorToRoughness(roughness, ior);
+	return textureSampleLevel(a3d_prd04_transmissionTex, a3d_prd04_transmissionSmp, fragCoord, lod);
+}
+
+fn a3dTransmissionSampleBicubic(fragCoord: vec2f, roughness: f32, ior: f32) -> vec4f {
+	let lod = log2(a3d_prd04_transmission.transmissionSamplerSize.x) * a3dApplyIorToRoughness(roughness, ior);
+	return a3d_prd04_textureBicubic(a3d_prd04_transmissionTex, a3d_prd04_transmissionSmp, fragCoord, lod);
+}
+
+// Screen-space refraction sample: NDC-UV for position + transmissionRay
+// (r185 getIBLVolumeRefraction projection block,
+// transmission_pars_fragment.glsl.js:188-195).
+fn a3dTransmissionCoords(exitPosition: vec3f, viewMatrix: mat4x4f, projMatrix: mat4x4f) -> vec2f {
+	let ndcPos = projMatrix * viewMatrix * vec4f(exitPosition, 1.0);
+	var 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).
+fn a3dGetIBLVolumeRefraction(n: vec3f, v: vec3f, roughness: f32, diffuseColor: vec3f, specularColor: vec3f, specularF90: f32, position: vec3f, modelMatrix: mat4x4f, ior: f32, thickness: f32, attenuationColor: vec3f, attenuationDistance: f32) -> vec4f {
+	let transmissionRay = a3dVolumeTransmissionRay(n, v, thickness, ior, modelMatrix);
+	let refractedRayExit = position + transmissionRay;
+
+	let refractionCoords = a3dTransmissionCoords(refractedRayExit, a3d_prd04_transmission.viewMatrix, a3d_prd04_transmission.projectionMatrix);
+
+	let transmittedLight = a3dTransmissionSample(refractionCoords, roughness, ior);
+	let transmittance = diffuseColor * a3dVolumeAttenuation(length(transmissionRay), attenuationColor, attenuationDistance);
+
+	let attenuatedColor = transmittance * transmittedLight.rgb;
+
+	let F = a3dPrd04EnvironmentBRDF(n, v, specularColor, specularF90, roughness);
+
+	let transmittanceFactor = (transmittance.r + transmittance.g + transmittance.b) / 3.0;
+
+	return vec4f((1.0 - F) * attenuatedColor, 1.0 - (1.0 - transmittedLight.a) * transmittanceFactor);
+}
+`;
+export const A3D_PRD04_TRANSMISSION_WGSL = wgsl;
+export default wgsl;
+//# sourceMappingURL=transmission.wgsl.js.map

package/dist/shaders/physical-wgsl/transmission.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transmission.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical-wgsl/transmission.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiJvB,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,CAAC;AAChD,eAAe,IAAI,CAAC"}

package/dist/shaders/physical-wgsl/unlit.wgsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WGSL twin of a3d_prd04_unlit (PRD-04 §8.12): same `a3d_` name, identical
+ * math (r185 unlit arm — baseColor straight through).
+ */
+declare const wgsl = "\n// Unlit output: baseColor straight through (r185 unlit arm).\nfn a3dPrd04UnlitColor(diffuseColor: vec4f) -> vec4f {\n\treturn diffuseColor;\n}\n";
+export declare const A3D_PRD04_UNLIT_WGSL = "\n// Unlit output: baseColor straight through (r185 unlit arm).\nfn a3dPrd04UnlitColor(diffuseColor: vec4f) -> vec4f {\n\treturn diffuseColor;\n}\n";
+export default wgsl;
+//# sourceMappingURL=unlit.wgsl.d.ts.map

package/dist/shaders/physical-wgsl/unlit.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlit.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical-wgsl/unlit.wgsl.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,QAAA,MAAM,IAAI,wJAKT,CAAC;AAEF,eAAO,MAAM,oBAAoB,wJAAO,CAAC;AACzC,eAAe,IAAI,CAAC"}

package/dist/shaders/physical-wgsl/unlit.wgsl.js

@@ -0,0 +1,13 @@
+/**
+ * WGSL twin of a3d_prd04_unlit (PRD-04 §8.12): same `a3d_` name, identical
+ * math (r185 unlit arm — baseColor straight through).
+ */
+const wgsl = /* wgsl */ `
+// Unlit output: baseColor straight through (r185 unlit arm).
+fn a3dPrd04UnlitColor(diffuseColor: vec4f) -> vec4f {
+	return diffuseColor;
+}
+`;
+export const A3D_PRD04_UNLIT_WGSL = wgsl;
+export default wgsl;
+//# sourceMappingURL=unlit.wgsl.js.map

package/dist/shaders/physical-wgsl/unlit.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlit.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical-wgsl/unlit.wgsl.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;CAKvB,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CAAC;AACzC,eAAe,IAAI,CAAC"}

package/dist/shaders/physical-wgsl/uv_transform.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * WGSL twin of a3d_prd04_uv_transform (PRD-04 §8.10/§8.12): same `a3d_`
+ * names, identical math. §8.12: per-slot `mat3x3<f32>` in a material uniform
+ * struct is the caller-side contract; the transform itself is the same
+ * T·R·S affine application.
+ */
+declare const wgsl = "\n// Apply a KHR_texture_transform matrix to the requested UV set.\n// m is the CPU-computed T\u00B7R\u00B7S affine (column-major, z=1 point transform).\n// texCoord selects uv0 or uv1 exactly like r185 getUvChannel.\nfn a3dPrd04UvTransform(m: mat3x3f, texCoord: i32, uv0: vec2f, uv1: vec2f) -> vec2f {\n\tlet uv = select(uv0, uv1, texCoord == 1);\n\treturn (m * vec3f(uv, 1.0)).xy;\n}\n\n// Identity-transform fast path: uvN untransformed when the caller already\n// knows the transform is identity.\nfn a3dPrd04UvSelect(texCoord: i32, uv0: vec2f, uv1: vec2f) -> vec2f {\n\treturn select(uv0, uv1, texCoord == 1);\n}\n";
+export declare const A3D_PRD04_UV_TRANSFORM_WGSL = "\n// Apply a KHR_texture_transform matrix to the requested UV set.\n// m is the CPU-computed T\u00B7R\u00B7S affine (column-major, z=1 point transform).\n// texCoord selects uv0 or uv1 exactly like r185 getUvChannel.\nfn a3dPrd04UvTransform(m: mat3x3f, texCoord: i32, uv0: vec2f, uv1: vec2f) -> vec2f {\n\tlet uv = select(uv0, uv1, texCoord == 1);\n\treturn (m * vec3f(uv, 1.0)).xy;\n}\n\n// Identity-transform fast path: uvN untransformed when the caller already\n// knows the transform is identity.\nfn a3dPrd04UvSelect(texCoord: i32, uv0: vec2f, uv1: vec2f) -> vec2f {\n\treturn select(uv0, uv1, texCoord == 1);\n}\n";
+export default wgsl;
+//# sourceMappingURL=uv_transform.wgsl.d.ts.map

package/dist/shaders/physical-wgsl/uv_transform.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uv_transform.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical-wgsl/uv_transform.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,QAAA,MAAM,IAAI,gnBAcT,CAAC;AAEF,eAAO,MAAM,2BAA2B,gnBAAO,CAAC;AAChD,eAAe,IAAI,CAAC"}

package/dist/shaders/physical-wgsl/uv_transform.wgsl.js

@@ -0,0 +1,24 @@
+/**
+ * WGSL twin of a3d_prd04_uv_transform (PRD-04 §8.10/§8.12): same `a3d_`
+ * names, identical math. §8.12: per-slot `mat3x3<f32>` in a material uniform
+ * struct is the caller-side contract; the transform itself is the same
+ * T·R·S affine application.
+ */
+const wgsl = /* wgsl */ `
+// 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.
+fn a3dPrd04UvTransform(m: mat3x3f, texCoord: i32, uv0: vec2f, uv1: vec2f) -> vec2f {
+	let uv = select(uv0, uv1, texCoord == 1);
+	return (m * vec3f(uv, 1.0)).xy;
+}
+
+// Identity-transform fast path: uvN untransformed when the caller already
+// knows the transform is identity.
+fn a3dPrd04UvSelect(texCoord: i32, uv0: vec2f, uv1: vec2f) -> vec2f {
+	return select(uv0, uv1, texCoord == 1);
+}
+`;
+export const A3D_PRD04_UV_TRANSFORM_WGSL = wgsl;
+export default wgsl;
+//# sourceMappingURL=uv_transform.wgsl.js.map

package/dist/shaders/physical-wgsl/uv_transform.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uv_transform.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical-wgsl/uv_transform.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;CAcvB,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,CAAC;AAChD,eAAe,IAAI,CAAC"}

package/dist/shaders/physical-wgsl/volume.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * WGSL twin of a3d_prd04_volume (PRD-04 §8.12): same `a3d_` names, identical
+ * math (r185 transmission_pars_fragment.glsl.js:152-168,
+ * transmission_fragment.glsl.js:3-18). WGSL has no `isinf`; +∞ is detected by
+ * comparison against the f32 maximum.
+ */
+declare const wgsl = "\n// Beer-Lambert attenuation (r185 volumeAttenuation,\n// transmission_pars_fragment.glsl.js:152-168).\nfn a3dVolumeAttenuation(transmissionDistance: f32, attenuationColor: vec3f, attenuationDistance: f32) -> vec3f {\n\t// 04-P6-1 (GPU run 38140816058): Tint rejects 3.4028235e38 (\"cannot be\n\t// represented as 'f32'\"; it rounds past FLT_MAX). The literal below is FLT_MAX\n\t// exactly, and only +inf compares greater.\n\tif (attenuationDistance > 3.4028234663852886e38) {\n\t\t// Attenuation distance is +\u221E (WGSL lacks an infinity test; only +inf exceeds f32 max).\n\t\treturn vec3f(1.0);\n\t} else {\n\t\t// Compute light attenuation using Beer's law.\n\t\tlet attenuationCoefficient = -log(attenuationColor) / attenuationDistance;\n\t\tlet transmittance = exp(-attenuationCoefficient * transmissionDistance); // Beer's law\n\t\treturn transmittance;\n\t}\n}\n\n// Factor resolution (r185 transmission_fragment.glsl.js:3-18).\nfn a3dPrd04VolumeInit(lobes: ptr<function, A3DPrd04Lobes>, transmissionFactor: f32, thicknessFactor: f32, attenuationDistanceFactor: f32, attenuationColorFactor: vec3f, transmissionTex: vec4f, thicknessTex: vec4f) {\n\t(*lobes).transmission = transmissionFactor * transmissionTex.r;\n\t(*lobes).thickness = thicknessFactor * thicknessTex.g;\n\t(*lobes).attenuationDistance = attenuationDistanceFactor;\n\t(*lobes).attenuationColor = attenuationColorFactor;\n}\n";
+export declare const A3D_PRD04_VOLUME_WGSL = "\n// Beer-Lambert attenuation (r185 volumeAttenuation,\n// transmission_pars_fragment.glsl.js:152-168).\nfn a3dVolumeAttenuation(transmissionDistance: f32, attenuationColor: vec3f, attenuationDistance: f32) -> vec3f {\n\t// 04-P6-1 (GPU run 38140816058): Tint rejects 3.4028235e38 (\"cannot be\n\t// represented as 'f32'\"; it rounds past FLT_MAX). The literal below is FLT_MAX\n\t// exactly, and only +inf compares greater.\n\tif (attenuationDistance > 3.4028234663852886e38) {\n\t\t// Attenuation distance is +\u221E (WGSL lacks an infinity test; only +inf exceeds f32 max).\n\t\treturn vec3f(1.0);\n\t} else {\n\t\t// Compute light attenuation using Beer's law.\n\t\tlet attenuationCoefficient = -log(attenuationColor) / attenuationDistance;\n\t\tlet transmittance = exp(-attenuationCoefficient * transmissionDistance); // Beer's law\n\t\treturn transmittance;\n\t}\n}\n\n// Factor resolution (r185 transmission_fragment.glsl.js:3-18).\nfn a3dPrd04VolumeInit(lobes: ptr<function, A3DPrd04Lobes>, transmissionFactor: f32, thicknessFactor: f32, attenuationDistanceFactor: f32, attenuationColorFactor: vec3f, transmissionTex: vec4f, thicknessTex: vec4f) {\n\t(*lobes).transmission = transmissionFactor * transmissionTex.r;\n\t(*lobes).thickness = thicknessFactor * thicknessTex.g;\n\t(*lobes).attenuationDistance = attenuationDistanceFactor;\n\t(*lobes).attenuationColor = attenuationColorFactor;\n}\n";
+export default wgsl;
+//# sourceMappingURL=volume.wgsl.d.ts.map

package/dist/shaders/physical-wgsl/volume.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volume.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical-wgsl/volume.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,QAAA,MAAM,IAAI,83CAyBT,CAAC;AAEF,eAAO,MAAM,qBAAqB,83CAAO,CAAC;AAC1C,eAAe,IAAI,CAAC"}

package/dist/shaders/physical-wgsl/volume.wgsl.js

@@ -0,0 +1,35 @@
+/**
+ * WGSL twin of a3d_prd04_volume (PRD-04 §8.12): same `a3d_` names, identical
+ * math (r185 transmission_pars_fragment.glsl.js:152-168,
+ * transmission_fragment.glsl.js:3-18). WGSL has no `isinf`; +∞ is detected by
+ * comparison against the f32 maximum.
+ */
+const wgsl = /* wgsl */ `
+// Beer-Lambert attenuation (r185 volumeAttenuation,
+// transmission_pars_fragment.glsl.js:152-168).
+fn a3dVolumeAttenuation(transmissionDistance: f32, attenuationColor: vec3f, attenuationDistance: f32) -> vec3f {
+	// 04-P6-1 (GPU run 38140816058): Tint rejects 3.4028235e38 ("cannot be
+	// represented as 'f32'"; it rounds past FLT_MAX). The literal below is FLT_MAX
+	// exactly, and only +inf compares greater.
+	if (attenuationDistance > 3.4028234663852886e38) {
+		// Attenuation distance is +∞ (WGSL lacks an infinity test; only +inf exceeds f32 max).
+		return vec3f(1.0);
+	} else {
+		// Compute light attenuation using Beer's law.
+		let attenuationCoefficient = -log(attenuationColor) / attenuationDistance;
+		let transmittance = exp(-attenuationCoefficient * transmissionDistance); // Beer's law
+		return transmittance;
+	}
+}
+
+// Factor resolution (r185 transmission_fragment.glsl.js:3-18).
+fn a3dPrd04VolumeInit(lobes: ptr<function, A3DPrd04Lobes>, transmissionFactor: f32, thicknessFactor: f32, attenuationDistanceFactor: f32, attenuationColorFactor: vec3f, transmissionTex: vec4f, thicknessTex: vec4f) {
+	(*lobes).transmission = transmissionFactor * transmissionTex.r;
+	(*lobes).thickness = thicknessFactor * thicknessTex.g;
+	(*lobes).attenuationDistance = attenuationDistanceFactor;
+	(*lobes).attenuationColor = attenuationColorFactor;
+}
+`;
+export const A3D_PRD04_VOLUME_WGSL = wgsl;
+export default wgsl;
+//# sourceMappingURL=volume.wgsl.js.map

package/dist/shaders/physical-wgsl/volume.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"volume.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/physical-wgsl/volume.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;CAyBvB,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAC1C,eAAe,IAAI,CAAC"}

package/dist/shadows/DirectionalCascadeFitter.d.ts

@@ -0,0 +1,97 @@
+/**
+ * DirectionalCascadeFitter — stable-fit CSM cascade matrices (PRD-02 Phase 4,
+ * §6.4). Works on a plain C-08 `CameraLike` (view/projection matrices) — no
+ * PerspectiveCamera instanceof. Split scheme reuses
+ * `CascadedShadowMaps.computeSplits` (practical λ blend); each cascade's
+ * ortho centre snaps to the shadow-texel grid so the edge mask is stable
+ * under sub-texel camera motion (the `prd02-17` shimmer gate).
+ */
+import type { RenderItem } from "../contracts/renderItem.js";
+export interface CascadeFitterCamera {
+    readonly viewProjectionMatrix: Float32Array | readonly number[];
+    readonly near?: number;
+    readonly far?: number;
+}
+export interface DirectionalCascadeFit {
+    readonly index: number;
+    /** Column-major light-space view-projection (world → [0,1]³ shadow UV), for sampling. */
+    readonly viewProjection: Float32Array;
+    /** Unbiased world → clip-space VP used to rasterize the depth target. */
+    readonly drawViewProjection: Float32Array;
+    /** View-space far distance of this cascade's split (for `a3d_selectCascade`). */
+    readonly splitFar: number;
+    /** World-space size of one shadow-map texel (normal-bias + stability unit). */
+    readonly texelWorld: number;
+    /** Bounding-sphere radius of the cascade slice (+ casters), before padding. */
+    readonly radius: number;
+    /** Texel-snapped light-space ortho centre (x, y) and depth mid (z). */
+    readonly center: readonly [number, number, number];
+    readonly casterCount: number;
+}
+export interface DirectionalCascadeFitOptions {
+    readonly camera: CascadeFitterCamera;
+    readonly lightDirection: readonly [number, number, number];
+    readonly casters: readonly RenderItem[];
+    readonly mapSize: number;
+    readonly cascadeCount: number;
+    readonly splitLambda?: number;
+    readonly padding?: number;
+    /**
+     * Shadow distance cap (view-space, PRD-02 §6.4 `maxDistance`): cascades
+     * cover [near, min(far, maxDistance)]. The camera's own far still anchors
+     * the frustum-corner interpolation.
+     */
+    readonly maxDistance?: number;
+}
+type V3 = readonly [number, number, number];
+/**
+ * #1141: near/far of a perspective camera known only by its view-projection
+ * and eye (structural CameraLikes carry no near/far): distances from the eye
+ * to the unprojected NDC centres of the near and far planes.
+ */
+export declare function clipRangeFromViewProjection(viewProjection: Float32Array | readonly number[], eye: readonly [number, number, number]): {
+    near: number;
+    far: number;
+} | null;
+type LightBasis = {
+    right: V3;
+    up: V3;
+    forward: V3;
+};
+/**
+ * #1141 caster-rectangle fit: the light-space rectangle of all casters
+ * (padded), when it lies inside the slice footprint, plus the depth interval
+ * covering the casters and every in-slice receiver they can shadow.
+ */
+export declare function casterRectClamp(slicePts: readonly V3[], casterBounds: readonly {
+    min: V3;
+    max: V3;
+}[], basis: LightBasis, padding: number): {
+    extent: number;
+    centerX: number;
+    centerY: number;
+    zMin: number;
+    zMax: number;
+} | null;
+type LightRect = {
+    readonly minX: number;
+    readonly maxX: number;
+    readonly minY: number;
+    readonly maxY: number;
+};
+/**
+ * #1141: light-space depth interval [zMin, zMax] of the receivers a caster
+ * rectangle can shadow — the convex frustum slice `pts` (light space)
+ * intersected with the infinite prism `rect` × (-∞, ∞) along the light.
+ * Extremes of a convex intersection lie on its vertices: slice corners inside
+ * the prism, slice edges crossing a prism wall, and the four prism edges
+ * clipped by the slice faces. Null when the slice misses the prism.
+ */
+export declare function sliceDepthWithinRect(pts: readonly V3[], rect: LightRect): {
+    zMin: number;
+    zMax: number;
+} | null;
+/** Stable-fit cascades for one directional light from a C-08 CameraLike. */
+export declare function fitDirectionalCascades(options: DirectionalCascadeFitOptions): DirectionalCascadeFit[];
+export {};
+//# sourceMappingURL=DirectionalCascadeFitter.d.ts.map

package/dist/shadows/DirectionalCascadeFitter.d.ts.map

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