three-realtime-rt 0.6.0 → 0.7.0

package/src/GBufferPass.js

@@ -1,4 +1,5 @@
 import * as THREE from "three";
+import { makeMRT } from "./mrtCompat.js";
 
 // three defines USE_SKINNING and supplies the bindMatrix / bindMatrixInverse /
 // boneTexture uniforms + skinIndex / skinWeight attributes automatically when the
@@ -85,6 +86,20 @@ uniform bool uHasMetalnessMap;
 uniform bool uBlend;
 uniform float uOpacity;
 
+// World-space 3D-texture albedo ("volumetric surface albedo"), compiled in ONLY
+// when a scene registers a material with userData.rtVolumeAlbedo (the whole block
+// is behind the RT_VOLUME_ALBEDO define, so a scene without the feature builds a
+// byte-identical G-buffer program with no extra sampler). Primary visibility can
+// afford this sampler3D — the raster pass has ample sampler headroom, unlike the
+// lighting megakernel. The value is gated per-mesh by uHasVolume, so non-volume
+// meshes sharing this program write exactly the same albedo they did before.
+#ifdef RT_VOLUME_ALBEDO
+uniform highp sampler3D uVolumeTex;
+uniform vec3 uVolumeOrigin;
+uniform vec3 uVolumeSize;
+uniform bool uHasVolume;
+#endif
+
 // Screen-space cotangent frame (Mikkelsen 2010): reconstruct a tangent basis
 // from derivatives of world position and uv, so tangent-space normal maps work
 // without a per-vertex tangent attribute (none is uploaded to the BVH/G-buffer).
@@ -105,6 +120,17 @@ void main() {
     albedo *= texture(uMap, vUvCoord).rgb;
   }
   albedo *= vColor; // vertex colours (white when the mesh has no color attribute)
+  // Volumetric surface albedo: sample a world-space 3D texture at this fragment's
+  // world position and use it as the base colour, replacing color x map x vColor.
+  // uvw = clamp((p - origin) / size, 0, 1); the ClampToEdge sampler + this clamp
+  // keep hits just outside the volume reading the boundary colour instead of
+  // wrapping. Gated so only rtVolumeAlbedo meshes are affected.
+#ifdef RT_VOLUME_ALBEDO
+  if (uHasVolume) {
+    vec3 uvw = clamp((vWorldPos - uVolumeOrigin) / uVolumeSize, 0.0, 1.0);
+    albedo = texture(uVolumeTex, uvw).rgb;
+  }
+#endif
   vec3 emissive = uEmissive;
   if (uHasEmissiveMap) {
     emissive *= texture(uEmissiveMap, vUvCoord).rgb;
@@ -186,11 +212,48 @@ export class GBufferPass {
 
     this._materialCache = new WeakMap(); // mesh -> gbuffer ShaderMaterial
     this._swapped = []; // [mesh, originalMaterial] pairs during render
+    this._hidden = []; // objects temporarily hidden for the G-buffer draw
     this._normalMat3 = new THREE.Matrix3();
+    // World-space 3D-texture albedo: off unless a scene registers a material with
+    // userData.rtVolumeAlbedo (see setVolume). When off, the gbuffer program is
+    // compiled WITHOUT the RT_VOLUME_ALBEDO define — no sampler3D, byte-identical.
+    this._volumeEnabled = false;
+    this._dummyVolumeTex = null; // 1x1x1 fallback bound to non-volume meshes when on
+  }
+
+  // A valid 1x1x1 3D texture to bind on gbuffer materials whose mesh is NOT a
+  // volume material while the feature is compiled in — keeps every declared
+  // sampler3D pointing at a complete texture (its branch is never taken, so the
+  // value is irrelevant; it just must not be an unbound/incomplete sampler).
+  _dummyVolume() {
+    if (!this._dummyVolumeTex) {
+      const t = new THREE.Data3DTexture(new Uint8Array([255, 255, 255, 255]), 1, 1, 1);
+      t.format = THREE.RGBAFormat;
+      t.type = THREE.UnsignedByteType;
+      t.minFilter = THREE.LinearFilter;
+      t.magFilter = THREE.LinearFilter;
+      t.needsUpdate = true;
+      this._dummyVolumeTex = t;
+    }
+    return this._dummyVolumeTex;
+  }
+
+  /**
+   * Enable/disable the world-space 3D-texture albedo path for the primary
+   * (G-buffer) visibility. Compiles the RT_VOLUME_ALBEDO define into the per-mesh
+   * gbuffer program when on. Toggling clears the material cache so the programs
+   * recompile with/without the define. Called by RealtimeRaytracer after each
+   * compile with whether the scene registered any rtVolumeAlbedo material.
+   */
+  setVolume(enabled) {
+    const on = !!enabled;
+    if (on === this._volumeEnabled) return;
+    this._volumeEnabled = on;
+    this._materialCache = new WeakMap(); // force recompile with the new define
   }
 
   _makeTarget(width, height) {
-    const t = new THREE.WebGLMultipleRenderTargets(width, height, 4, {
+    const t = makeMRT(width, height, 4, {
       minFilter: THREE.NearestFilter,
       magFilter: THREE.NearestFilter,
       type: THREE.FloatType,
@@ -240,7 +303,15 @@ export class GBufferPass {
 
   _makeGbufferMaterial(mesh) {
     const material = new THREE.ShaderMaterial({
+      // Stable program name for the compile-failure self-diagnosis (see
+      // RealtimeRaytracer._scanPrograms). Per-mesh materials share one program
+      // cache key, so they all surface as the single core pass "rt:gbuffer".
+      name: "rt:gbuffer",
       glslVersion: THREE.GLSL3,
+      // RT_VOLUME_ALBEDO is present only while a scene uses the volumetric-albedo
+      // feature (see setVolume); absent, the compiled program is identical to the
+      // pre-feature G-buffer (no sampler3D, no volume branch).
+      defines: this._volumeEnabled ? { RT_VOLUME_ALBEDO: "1" } : {},
       vertexShader: gbufferVert,
       fragmentShader: gbufferFrag,
       uniforms: {
@@ -264,6 +335,16 @@ export class GBufferPass {
         uHasMetalnessMap: { value: false },
         uBlend: { value: false },
         uOpacity: { value: 1.0 },
+        // Volume-albedo uniforms are always present in the JS uniform object
+        // (harmless when the define is off — three uploads only uniforms that
+        // exist in the compiled program, so a non-volume scene never touches
+        // these). While the define is on, _syncGbufferMaterial binds either the
+        // material's own volume texture or the shared dummy, so a non-volume mesh
+        // never leaves an incomplete sampler3D bound.
+        uVolumeTex: { value: null },
+        uVolumeOrigin: { value: new THREE.Vector3() },
+        uVolumeSize: { value: new THREE.Vector3(1, 1, 1) },
+        uHasVolume: { value: false },
       },
       side: THREE.FrontSide,
     });
@@ -309,6 +390,23 @@ export class GBufferPass {
     // lighting pass. opacity 1 renders opaque, matching the old force-opaque path.
     u.uBlend.value = !!src.transparent;
     u.uOpacity.value = src.opacity ?? 1.0;
+    // World-space 3D-texture albedo. Only meshes whose material opted in via
+    // userData.rtVolumeAlbedo get uHasVolume=true; every other mesh keeps the
+    // dummy sampler (branch never taken) so its albedo is byte-identical. This is
+    // per-mesh, so DISTINCT volumes each render correctly in primary visibility.
+    if (this._volumeEnabled) {
+      const vol = src.userData && src.userData.rtVolumeAlbedo;
+      if (vol && vol.texture) {
+        u.uHasVolume.value = true;
+        u.uVolumeTex.value = vol.texture;
+        u.uVolumeOrigin.value.copy(vol.origin ?? { x: 0, y: 0, z: 0 });
+        const s = vol.size ?? { x: 1, y: 1, z: 1 };
+        u.uVolumeSize.value.set(s.x || 1, s.y || 1, s.z || 1);
+      } else {
+        u.uHasVolume.value = false;
+        u.uVolumeTex.value = this._dummyVolume();
+      }
+    }
     u.uNormalMatrixWorld.value.getNormalMatrix(mesh.matrixWorld);
     material.side = src.side ?? THREE.FrontSide;
   }
@@ -348,11 +446,27 @@ export class GBufferPass {
     // material word + gEmissive.a, and the lighting pass blends them against the
     // geometry behind. opacity 1 writes fully opaque, so alpha-textured cases
     // (LittlestTokyo's glass) look exactly as before.
+    //
+    // Objects that are NOT meshes (Sprite / Line / Points) keep their OWN
+    // material here, and those materials write a single gl_FragColor. Rendering
+    // one into this 4-attachment MRT framebuffer is a GL_INVALID_OPERATION (an
+    // ESSL1 fragment shader cannot feed multiple draw buffers) and the object is
+    // not traceable geometry either — the BVH compiler skips it. So they are
+    // HIDDEN for the duration of the G-buffer draw and restored right after;
+    // draw them yourself in an overlay pass on top of rt.render() if you need
+    // them on screen. compileScene() warns once naming them.
     this._swapped.length = 0;
+    this._hidden.length = 0;
     scene.traverse((obj) => {
-      if (obj.isMesh && obj.geometry && obj.visible) {
+      if (!obj.visible) return;
+      if (obj.isMesh && obj.geometry) {
         this._swapped.push([obj, obj.material]);
         obj.material = this._gbufferMaterialFor(obj);
+        return;
+      }
+      if (obj.isSprite || obj.isLine || obj.isPoints) {
+        obj.visible = false;
+        this._hidden.push(obj);
       }
     });
 
@@ -368,9 +482,14 @@ export class GBufferPass {
     scene.background = prevBackground;
     for (const [mesh, mat] of this._swapped) mesh.material = mat;
     this._swapped.length = 0;
+    // Restore visibility exactly once per object (each was pushed once, and only
+    // if it was visible when we hid it).
+    for (const obj of this._hidden) obj.visible = true;
+    this._hidden.length = 0;
   }
 
   dispose() {
     for (const t of this._targets) t.dispose();
+    if (this._dummyVolumeTex) this._dummyVolumeTex.dispose();
   }
 }

package/src/GIReservoirPass.js

@@ -3,6 +3,7 @@ import { shaderStructs, shaderIntersectFunction } from "three-mesh-bvh";
 import { MAX_LIGHTS } from "./SceneCompiler.js";
 import { SKY_GLSL } from "./sky.glsl.js";
 import { BVH_ANY_HIT_GLSL } from "./bvhAnyHit.glsl.js";
+import { makeMRT } from "./mrtCompat.js";
 
 const fullscreenVert = /* glsl */ `
 out vec2 vUv;
@@ -133,7 +134,10 @@ vec4 fetchBlueNoise() {
   return fract(bn + shift);
 }
 
-float luminance(vec3 c) { return dot(c, vec3(0.299, 0.587, 0.114)); }
+// Named rtLum, NOT luminance: three r166+ prepends its own rtLum(vec3)
+// to every non-raw ShaderMaterial fragment shader, and GLSL treats a second
+// (vec3) body as a redefinition — the whole program fails to compile.
+float rtLum(vec3 c) { return dot(c, vec3(0.299, 0.587, 0.114)); }
 
 // ---------- reservoir .w bit-packing: M (8 bit) + oct-normal (12+12 bit) ------
 // The RGBA32F reservoir-position attachment is at the pass's hard 16-sampler
@@ -483,7 +487,7 @@ void main() {
   vec3 rad = traceRadianceGI(P + N * uEps, wi, nLight, hitPos, hitNormal);
   // Match the inline firefly clamp, which is applied to indirect (= L_i) so
   // the biased mean of the two paths agrees.
-  float rl = luminance(rad);
+  float rl = rtLum(rad);
   if (rl > uFireflyClamp) rad *= uFireflyClamp / rl;
 
   float cosT = max(dot(N, wi), 0.0);
@@ -532,8 +536,8 @@ void main() {
     float valTol = max(0.02 * expectDist, 4.0 * uEps);
     float hitDist = length(hitPos - P);
     bool geomChanged = abs(hitDist - expectDist) > valTol;
-    float pHatOld = luminance(radPrev) * cosT;   // stored target at this pixel
-    float pHatNew = luminance(rad) * cosT;        // re-shaded target (current light)
+    float pHatOld = rtLum(radPrev) * cosT;   // stored target at this pixel
+    float pHatNew = rtLum(rad) * cosT;        // re-shaded target (current light)
     bool wentDark = pHatNew < VAL_DARK_FRAC * pHatOld;
     // KILL (drop the stale temporal term so this pixel's fresh candidates rebuild
     // from the current scene) on geometry change OR a collapse to near-black; leave
@@ -543,7 +547,7 @@ void main() {
     killStore = geomChanged || wentDark;
   } else {
     // --- normal fresh candidate: one cosine-hemisphere GI bounce, shaded inline.
-    float pHatFresh = luminance(rad) * cosT;
+    float pHatFresh = rtLum(rad) * cosT;
     // w = p_hat / p_source = p_hat / (cos/PI). cosT cancels; guard cosT==0.
     float wFresh = cosT > 0.0 ? pHatFresh * PI / cosT : 0.0;
     wSum = wFresh;
@@ -571,7 +575,7 @@ void main() {
     vec3 dp = hitPrev - P;
     float dl = length(dp);
     float cosPrev = dl > 1e-5 ? max(dot(N, dp / dl), 0.0) : 0.0;
-    float pHatPrev = luminance(radPrev) * cosPrev;
+    float pHatPrev = rtLum(radPrev) * cosPrev;
     float Mc = min(Mprev, uMCap);
     // Combine reservoirs: w = p_hat_current(sample) * W_prev * M_prev.
     float w = pHatPrev * Wprev * Mc;
@@ -585,7 +589,7 @@ void main() {
     // Reconstruct last frame's resolve from this same sample (same W cap
     // and clamp as the live resolve, for a like-for-like EMA partner).
     vec3 pg = radPrev * (cosPrev / PI) * min(Wprev, 32.0);
-    float pgl = luminance(pg);
+    float pgl = rtLum(pg);
     if (pgl > uFireflyClamp) pg *= uFireflyClamp / pgl;
     if (!any(isnan(pg)) && !any(isinf(pg))) {
       emaPrevGi = pg;
@@ -650,7 +654,7 @@ void main() {
 
       // Target function at q (same shape the pass already uses).
       float cosQ = max(dot(N, normalize(xS - P)), 0.0);
-      float pHatQ = luminance(Ls) * cosQ;
+      float pHatQ = rtLum(Ls) * cosQ;
       // Invalid-shift reject: if the neighbour's hit x_s lies below q's shading
       // hemisphere (cosQ == 0) or carries no radiance, the reconnected target is
       // zero — the shift could never have produced this sample at q, so it must
@@ -676,7 +680,7 @@ void main() {
   vec3 sd = selPos - P;
   float sl = length(sd);
   float selCos = sl > 1e-5 ? max(dot(N, sd / sl), 0.0) : 0.0;
-  float pHatSel = luminance(selRad) * selCos;
+  float pHatSel = rtLum(selRad) * selCos;
   float W = (M > 0.0 && pHatSel > 0.0) ? wSum / (M * pHatSel) : 0.0;
 
   // --- final visibility (mandatory): ONE any-hit occlusion ray from x_q toward
@@ -715,7 +719,7 @@ void main() {
   // slightly dim GI on freshly revealed surfaces for a steady image in motion.
   float conf = clamp(M / uMCap, 0.0, 1.0);
   float cap = uFireflyClamp * mix(0.3, 1.0, conf);
-  float gil = luminance(gi);
+  float gil = rtLum(gi);
   if (gil > cap) gi *= cap / gil;
   if (any(isnan(gi)) || any(isinf(gi))) gi = vec3(0.0);
   // Resolve EMA (see the emaPrevGi note above): ~5-frame effective average.
@@ -729,7 +733,7 @@ void main() {
   vec3 sdT = selPosT - P;
   float slT = length(sdT);
   float selCosT = slT > 1e-5 ? max(dot(N, sdT / slT), 0.0) : 0.0;
-  float pHatSelT = luminance(selRadT) * selCosT;
+  float pHatSelT = rtLum(selRadT) * selCosT;
   float WT = (MT > 0.0 && pHatSelT > 0.0) ? wSumT / (MT * pHatSelT) : 0.0;
   if (any(isnan(selRadT)) || any(isinf(selRadT))) { selRadT = vec3(0.0); WT = 0.0; }
 
@@ -797,6 +801,9 @@ export class GIReservoirPass {
     this.targetB = this._makeTarget(width, height);
 
     this.material = new THREE.ShaderMaterial({
+      // Stable program name for compile-failure self-diagnosis; a link failure
+      // disables the experimental `restirGI` feature (falls back to inline GI).
+      name: "rt:gi-reservoir",
       glslVersion: THREE.GLSL3,
       vertexShader: fullscreenVert,
       fragmentShader: giFrag,
@@ -851,7 +858,7 @@ export class GIReservoirPass {
     // (needs fp32) + M + radiance + W, which must never be interpolated. All fp32
     // (rather than a mixed fp32/fp16 layout) sidesteps drivers that reject mixed
     // MRT precision; the resolved GI (attachment 2) is read 1:1 by the denoise.
-    const t = new THREE.WebGLMultipleRenderTargets(width, height, 3, {
+    const t = makeMRT(width, height, 3, {
       minFilter: THREE.NearestFilter,
       magFilter: THREE.NearestFilter,
       format: THREE.RGBAFormat,

package/src/RTLightingPass.js

@@ -3,6 +3,7 @@ import { shaderStructs, shaderIntersectFunction } from "three-mesh-bvh";
 import { MAX_LIGHTS } from "./SceneCompiler.js";
 import { SKY_GLSL } from "./sky.glsl.js";
 import { BVH_ANY_HIT_GLSL } from "./bvhAnyHit.glsl.js";
+import { makeMRT } from "./mrtCompat.js";
 
 const fullscreenVert = /* glsl */ `
 out vec2 vUv;
@@ -192,6 +193,27 @@ void fetchMaterial(float matIndex, out vec3 albedo, out float roughness,
   metalness = t1.a;
 }
 
+// World-space 3D-texture albedo ("volumetric surface albedo") for the traced
+// SECONDARY rays (GI bounces + reflection/refraction), so global illumination and
+// mirror views carry the same field colours the primary G-buffer shows. Compiled
+// in ONLY behind RT_VOLUME_ALBEDO: this megakernel already sits at the WebGL2
+// 16-sampler minimum, so the extra sampler3D is added exclusively when a scene
+// registers a volume AND the GPU exposes >= 17 fragment texture units (the
+// RealtimeRaytracer gates both conditions). Absent, the shader is textually
+// identical to the pre-feature megakernel — same 16 samplers, same program. v1 is
+// single-volume: one texture + one material index; a hit on that material samples
+// the field, every other hit reads its flat table albedo unchanged.
+#ifdef RT_VOLUME_ALBEDO
+uniform highp sampler3D uVolumeTex;
+uniform vec3 uVolumeOrigin;
+uniform vec3 uVolumeSize;
+uniform int uVolumeMatIndex;
+vec3 sampleVolumeAlbedo(vec3 p) {
+  vec3 uvw = clamp((p - uVolumeOrigin) / uVolumeSize, 0.0, 1.0);
+  return texture(uVolumeTex, uvw).rgb;
+}
+#endif
+
 // ---------- PBR specular (Cook-Torrance GGX) ----------
 // A separate specular radiance is accumulated for the primary surface's DIRECT
 // lighting alongside the demodulated diffuse irradiance. Because CompositePass
@@ -494,6 +516,12 @@ vec3 traceRadiance(vec3 ro, vec3 rd, bool specular) {
   vec3 hN = normalize(attr.xyz);
   if (dot(hN, rd) > 0.0) hN = -hN;
   vec3 hP = ro + rd * dist;
+  // Volumetric surface albedo: if this hit is the volume material, replace its
+  // flat table albedo with the 3D-texture sample at the world hit point, so GI /
+  // reflection bounces carry the field colours (matches the primary G-buffer).
+#ifdef RT_VOLUME_ALBEDO
+  if (int(round(attr.w)) == uVolumeMatIndex) hAlbedo = sampleVolumeAlbedo(hP);
+#endif
   vec3 Ld = sampleOneAny(hP + hN * uEps, hN);
   vec3 hLe = (!specular && uEmissiveCount > 0) ? vec3(0.0) : hEmissive;
   return hLe + hAlbedo * Ld * (1.0 / PI);
@@ -995,7 +1023,16 @@ export class RTLightingPass {
     this.specB = specMRT ? this._makeSpecTarget(width, height) : null;
 
     this.material = new THREE.ShaderMaterial({
+      // Stable program name for compile-failure self-diagnosis: this is the
+      // CORE lighting megakernel — a link failure here has no fallback (see
+      // RealtimeRaytracer._passClass -> coreFailure).
+      name: "rt:lighting",
       glslVersion: THREE.GLSL3,
+      // RT_VOLUME_ALBEDO is injected only when a scene uses world-space 3D-texture
+      // albedo AND the GPU has a spare fragment sampler (see setVolumeAlbedo +
+      // RealtimeRaytracer). Absent, this megakernel is textually identical to the
+      // pre-feature build — same 16 samplers, same Metal translation.
+      defines: {},
       vertexShader: fullscreenVert,
       fragmentShader: specMRT
         ? rtLightingFrag
@@ -1049,6 +1086,13 @@ export class RTLightingPass {
         uSkyZenith: { value: new THREE.Color(0.18, 0.34, 0.62) },
         uSkyHorizon: { value: new THREE.Color(0.7, 0.8, 0.9) },
         uSkyIntensity: { value: 1.0 },
+        // World-space 3D-texture albedo (present only in the compiled program when
+        // the RT_VOLUME_ALBEDO define is set; harmless otherwise — three uploads
+        // only uniforms the program actually declares).
+        uVolumeTex: { value: null },
+        uVolumeOrigin: { value: new THREE.Vector3() },
+        uVolumeSize: { value: new THREE.Vector3(1, 1, 1) },
+        uVolumeMatIndex: { value: -1 },
       },
       depthTest: false,
       depthWrite: false,
@@ -1057,6 +1101,9 @@ export class RTLightingPass {
     // Specular temporal accumulation program (its own sampler budget — well
     // clear of the lighting pass's 16-sampler ceiling).
     this.specMaterial = new THREE.ShaderMaterial({
+      // Optional additive specular buffer — a link failure degrades to the
+      // Lambert-only look (RealtimeRaytracer disables `specular`), image stays lit.
+      name: "rt:specular",
       glslVersion: THREE.GLSL3,
       vertexShader: fullscreenVert,
       fragmentShader: specAccumFrag,
@@ -1081,6 +1128,9 @@ export class RTLightingPass {
     // buffers. In single-target fallback the second output collapses the same
     // way as the lighting shader's.
     this.carryMaterial = new THREE.ShaderMaterial({
+      // Resize-only history-carry blit; a link failure is non-fatal (history is
+      // not carried across a resolution step) so it classifies as auxiliary.
+      name: "rt:history-carry",
       glslVersion: THREE.GLSL3,
       vertexShader: fullscreenVert,
       fragmentShader: specMRT
@@ -1120,7 +1170,7 @@ export class RTLightingPass {
       t.texture.generateMipmaps = false;
       return t;
     }
-    const t = new THREE.WebGLMultipleRenderTargets(width, height, 2, opts);
+    const t = makeMRT(width, height, 2, opts);
     for (const tex of t.texture) tex.generateMipmaps = false;
     return t;
   }
@@ -1226,6 +1276,36 @@ export class RTLightingPass {
     u.uEmissiveCount.value = compiled.emissiveTriCount;
   }
 
+  /**
+   * Enable/disable the world-space 3D-texture albedo path for the traced
+   * SECONDARY rays (GI + reflections). Pass the compiled `volumeAlbedo` descriptor
+   * ({ texture, origin, size, matIndex }) to turn it on, or null to turn it off.
+   * Toggling the RT_VOLUME_ALBEDO define recompiles this megakernel (adds/removes
+   * the single sampler3D), which the caller does at compile time, not per frame.
+   * The caller is responsible for only enabling this when the GPU has a spare
+   * fragment texture unit — this pass is at the 16-sampler minimum, so the 17th
+   * sampler would fail to link on a bare-minimum WebGL2 device.
+   */
+  setVolumeAlbedo(volume) {
+    const wasOn = this.material.defines.RT_VOLUME_ALBEDO !== undefined;
+    const on = !!volume;
+    const u = this.material.uniforms;
+    if (on) {
+      u.uVolumeTex.value = volume.texture;
+      u.uVolumeOrigin.value.copy(volume.origin);
+      u.uVolumeSize.value.copy(volume.size);
+      u.uVolumeMatIndex.value = volume.matIndex;
+    } else {
+      u.uVolumeTex.value = null;
+      u.uVolumeMatIndex.value = -1;
+    }
+    if (on !== wasOn) {
+      if (on) this.material.defines.RT_VOLUME_ALBEDO = "1";
+      else delete this.material.defines.RT_VOLUME_ALBEDO;
+      this.material.needsUpdate = true; // recompile with/without the sampler3D
+    }
+  }
+
   /**
    * Renders lighting into targetA (reading targetB as irradiance history), then
    * accumulates the fresh specular (targetA attachment 1) into specA (reading