@zephyr3d/scene 0.9.26 → 0.10.0

package/dist/material/mixins/lit.js

@@ -1,8 +1,10 @@
-import { RENDER_PASS_TYPE_LIGHT, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT } from '../../values.js';
+import { REVERSE_Z } from '@zephyr3d/base';
+import { RENDER_PASS_TYPE_LIGHT, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT, MAX_GLOBAL_LIGHTS } from '../../values.js';
 import { applyMaterialMixins } from '../meshmaterial.js';
 import { mixinTextureProps } from './texture.js';
 import { mixinAlbedoColor } from './albedocolor.js';
 import { ShaderHelper } from '../shader/helper.js';
+import { defineLTCEdgeFunctions } from '../../shaders/ltc_rect.js';
 
 /**
  * Light mixin
@@ -332,7 +334,8 @@ import { ShaderHelper } from '../shader/helper.js';
                 console.warn('getEnvLightIrradiance(): No need to calculate environment lighting');
                 return scope.$builder.vec3(0);
             }
-            return this.drawContext.env.light.envLight.hasIrradiance() ? this.drawContext.SSGI && this.drawContext.SSGIIrradianceHistoryTexture && this.drawContext.SSGISurfaceHistoryTexture && (this.drawContext.device.type === 'webgl' || this.drawContext.motionVectorTexture) ? this.drawContext.env.light.envLight.getIrradiance(scope, normal, this.drawContext).rgb : scope.$builder.mul(this.drawContext.env.light.envLight.getIrradiance(scope, normal, this.drawContext).rgb, ShaderHelper.getEnvLightStrength(scope)) : scope.$builder.vec3(0);
+            // Already scaled by the environment strength; see EnvironmentLighting.getIrradiance
+            return this.drawContext.env.light.envLight.hasIrradiance() ? this.drawContext.env.light.envLight.getIrradiance(scope, normal, this.drawContext).rgb : scope.$builder.vec3(0);
         }
         /**
      * Get Radiance of current environment light
@@ -375,6 +378,29 @@ import { ShaderHelper } from '../shader/helper.js';
             }
             return ShaderHelper.calculateShadow(scope, worldPos, worldNormal, NoL, this.drawContext);
         }
+        /**
+     * Whether this material's fragments are lit through water and so pick up the
+     * water caustics.
+     *
+     * True for ordinary surfaces, which may sit under a water body. A water
+     * surface itself must override this to false: the caustic lookup decides
+     * whether a fragment is submerged by comparing its own height against the
+     * displaced surface height on its *sun ray*, and those are two different
+     * points on the water unless the sun is exactly overhead. Under a tilted sun
+     * every water fragment has some other part of the surface upstream of it, so
+     * a fragment in a trough is read as being under the crest up-sun of it and
+     * gets the caustic pattern - whose peaks are well above 1 - painted onto the
+     * water as bright blotches that swim with the waves.
+     *
+     * Only the sampling is gated, not the uniform declarations: the caustic
+     * uniforms live in the pass-wide global bind group, whose layout is built
+     * once per {@link DrawContext.renderPassHash} and shared by every material
+     * drawn in that pass, so it cannot vary per material.
+     *
+     * @returns True when the water caustics modulate this material's lighting.
+     */ receivesWaterCaustics() {
+            return true;
+        }
         getClusterIndex(scope, fragCoord) {
             const pb = scope.$builder;
             const funcName = 'lm_getClusterIndex';
@@ -383,9 +409,24 @@ import { ShaderHelper } from '../shader/helper.js';
             ], function() {
                 const clusterParams = ShaderHelper.getClusterParams(this);
                 const countParams = ShaderHelper.getCountParams(this);
-                this.$l.zTile = pb.int(pb.max(pb.add(pb.mul(pb.log2(ShaderHelper.nonLinearDepthToLinear(this, this.fragCoord.z)), clusterParams.z), clusterParams.w), 0));
-                this.$l.f = pb.vec2(this.fragCoord.x, pb.sub(clusterParams.y, pb.add(this.fragCoord.y, 1)));
-                this.$l.xyTile = pb.ivec2(pb.div(this.f, pb.div(clusterParams.xy, pb.vec2(countParams.xy))));
+                // Slice = t * scale + bias, with t = log2(view depth) for perspective (exponential
+                // slices) and the view depth itself for orthographic (linear slices), matching the
+                // index pass. Orthographic device depth is linear between near and far.
+                this.$l.sliceDepth = pb.float();
+                this.$if(pb.notEqual(ShaderHelper.getClusterOrthographic(this), 0), function() {
+                    const nearFar = ShaderHelper.getCameraParams(this);
+                    this.sliceDepth = REVERSE_Z ? pb.mix(nearFar.y, nearFar.x, this.fragCoord.z) : pb.mix(nearFar.x, nearFar.y, this.fragCoord.z);
+                }).$else(function() {
+                    this.sliceDepth = pb.log2(ShaderHelper.nonLinearDepthToLinear(this, this.fragCoord.z));
+                });
+                // Depth at (or jittered past) the far plane would land in slice countParams.z, one past
+                // the last row of the index texture, so clamp both ends. Clamped as float before the int
+                // conversion because GLSL ES 1.0 has no integer clamp.
+                this.$l.zTile = pb.int(pb.clamp(pb.add(pb.mul(this.sliceDepth, clusterParams.z), clusterParams.w), 0, pb.sub(pb.float(countParams.z), 1)));
+                // fragCoord holds pixel centers (n + 0.5); flipping to the top-down tile space of the
+                // index pass is H - fragCoord.y, with no extra -1 that would shift tile rows by a pixel.
+                this.$l.f = pb.vec2(this.fragCoord.x, pb.sub(clusterParams.y, this.fragCoord.y));
+                this.$l.xyTile = pb.ivec2(pb.clamp(pb.div(this.f, pb.div(clusterParams.xy, pb.vec2(countParams.xy))), pb.vec2(0), pb.sub(pb.vec2(countParams.xy), pb.vec2(1))));
                 this.$return(pb.ivec3(this.xyTile, this.zTile));
             });
             return pb.getGlobalScope()[funcName](fragCoord);
@@ -409,9 +450,10 @@ import { ShaderHelper } from '../shader/helper.js';
         }
         calculateSpotLightAttenuation(scope, worldPos, posRange, dirCutoff, angleScaleOffset) {
             const pb = scope.$builder;
+            const that = this;
             const physical = this.drawContext.scene.lightingMode === 'physical';
-            // The two modes emit different falloff and cone-attenuation bodies, so they must not share a
-            // cached function under one name.
+            // The two modes emit different cone-attenuation bodies, so they must not share a cached
+            // function under one name.
             const funcName = physical ? 'Z_calculateSpotLightAttenuationPhysical' : 'Z_calculateSpotLightAttenuation';
             pb.func(funcName, [
                 pb.vec3('worldPos'),
@@ -419,18 +461,9 @@ import { ShaderHelper } from '../shader/helper.js';
                 pb.vec4('dirCutoff'),
                 pb.vec2('angleScaleOffset')
             ], function() {
-                this.$l.dist = pb.distance(this.posRange.xyz, this.worldPos);
-                if (physical) {
-                    this.$l.dist2 = pb.mul(this.dist, this.dist);
-                    this.$l.lightAtten = pb.div(1, pb.max(this.dist2, 0.0001));
-                    this.$l.range2 = pb.mul(this.posRange.w, this.posRange.w);
-                    this.$l.f = pb.div(this.dist2, pb.max(this.range2, 0.0001));
-                    this.$l.f2 = pb.clamp(pb.sub(1, pb.mul(this.f, this.f)), 0, 1);
-                    this.$l.falloff = pb.mul(this.lightAtten, this.f2, this.f2);
-                } else {
-                    this.$l.falloff = pb.max(0, pb.sub(1, pb.div(this.dist, this.posRange.w)));
-                    this.falloff = pb.mul(this.falloff, this.falloff);
-                }
+                // The point light's distance falloff in both modes: inverse square with the windowing
+                // to the range, so a spot and a point light of one intensity light a surface alike
+                this.$l.falloff = that.calculatePointLightAttenuation(this, this.worldPos, this.posRange);
                 this.$l.cd = pb.dot(pb.normalize(pb.sub(this.worldPos, this.posRange.xyz)), this.dirCutoff.xyz);
                 if (physical) {
                     // Filament's getAngleAttenuation: saturate(cd * scale + offset) squared. The scale/offset
@@ -445,15 +478,116 @@ import { ShaderHelper } from '../shader/helper.js';
             const resolvedScaleOffset = physical && angleScaleOffset ? angleScaleOffset : pb.vec2(0);
             return pb.getGlobalScope()[funcName](worldPos, posRange, dirCutoff, resolvedScaleOffset);
         }
+        /**
+     * A rect light reduced to one direction and one magnitude, for BxDFs that
+     * have no area-light integration of their own.
+     *
+     * @internal
+     */ calculateRectLightVectorIrradiance(scope, worldPos, posRange, axisX, axisY) {
+            const pb = scope.$builder;
+            defineLTCEdgeFunctions(scope);
+            pb.func('Z_rectLightVectorIrradiance', [
+                pb.vec3('worldPos'),
+                pb.vec4('posRange'),
+                pb.vec3('ax'),
+                pb.vec3('ay')
+            ], function() {
+                this.$l.toCenter = pb.sub(this.posRange.xyz, this.worldPos);
+                this.$l.dist = pb.length(this.toCenter);
+                this.$l.centerDir = pb.div(this.toCenter, pb.max(this.dist, 1e-6));
+                this.$l.planeNormal = pb.cross(this.ax, this.ay);
+                // The rect emits along -(ax x ay), so a lit point lies on that side of
+                // it, where the vector back to the centre points along +(ax x ay).
+                this.$if(pb.or(pb.lessThan(pb.dot(this.planeNormal, this.planeNormal), 1e-12), pb.lessThanEqual(pb.dot(this.planeNormal, this.toCenter), 0)), function() {
+                    this.$return(pb.vec4(this.centerDir, 0));
+                });
+                this.$l.v0 = pb.normalize(pb.sub(pb.sub(this.toCenter, this.ax), this.ay));
+                this.$l.v1 = pb.normalize(pb.sub(pb.add(this.toCenter, this.ax), this.ay));
+                this.$l.v2 = pb.normalize(pb.add(pb.add(this.toCenter, this.ax), this.ay));
+                this.$l.v3 = pb.normalize(pb.add(pb.sub(this.toCenter, this.ax), this.ay));
+                this.$l.F = pb.add(this.Z_LTCIntegrateEdgeVec(this.v0, this.v1), this.Z_LTCIntegrateEdgeVec(this.v1, this.v2), this.Z_LTCIntegrateEdgeVec(this.v2, this.v3), this.Z_LTCIntegrateEdgeVec(this.v3, this.v0));
+                this.$l.len = pb.length(this.F);
+                this.$if(pb.lessThan(this.len, 1e-8), function() {
+                    this.$return(pb.vec4(this.centerDir, 0));
+                });
+                this.$l.falloff = pb.float(1);
+                this.$if(pb.greaterThan(this.posRange.w, 0), function() {
+                    this.falloff = pb.sub(1, pb.smoothStep(pb.mul(this.posRange.w, 0.9), this.posRange.w, this.dist));
+                });
+                this.$return(pb.vec4(pb.div(this.F, this.len), pb.mul(this.len, this.falloff)));
+            });
+            return pb.getGlobalScope().Z_rectLightVectorIrradiance(worldPos, posRange, axisX, axisY);
+        }
         calculateLightAttenuation(scope, type, worldPos, posRange, dirCutoff, extra) {
             const pb = scope.$builder;
-            return scope.$choice(pb.equal(type, LIGHT_TYPE_DIRECTIONAL), pb.float(1), scope.$choice(pb.equal(type, LIGHT_TYPE_POINT), this.calculatePointLightAttenuation(scope, worldPos.xyz, posRange), scope.$choice(pb.equal(type, LIGHT_TYPE_RECT), this.calculatePointLightAttenuation(scope, worldPos.xyz, posRange), this.calculateSpotLightAttenuation(scope, worldPos.xyz, posRange, dirCutoff, extra?.xy))));
+            const that = this;
+            const physical = this.drawContext.scene.lightingMode === 'physical';
+            // Branches rather than a $choice, which would evaluate every light type's
+            // attenuation - the rect's vector form factor included - for every light.
+            // Named per mode because the spot light body it calls differs by mode.
+            const funcName = physical ? 'Z_calculateLightAttenuationPhysical' : 'Z_calculateLightAttenuation';
+            pb.func(funcName, [
+                pb.int('lightType'),
+                pb.vec3('worldPos'),
+                pb.vec4('posRange'),
+                pb.vec4('dirCutoff'),
+                pb.vec4('extra')
+            ], function() {
+                this.$if(pb.equal(this.lightType, LIGHT_TYPE_DIRECTIONAL), function() {
+                    this.$return(pb.float(1));
+                });
+                this.$if(pb.equal(this.lightType, LIGHT_TYPE_POINT), function() {
+                    this.$return(that.calculatePointLightAttenuation(this, this.worldPos, this.posRange));
+                });
+                this.$if(pb.equal(this.lightType, LIGHT_TYPE_RECT), function() {
+                    // extra.xyz carries the rect's half-height axis; see RectLight.computeUniforms.
+                    this.$return(pb.mul(that.calculateRectLightVectorIrradiance(this, this.worldPos, this.posRange, this.dirCutoff.xyz, this.extra.xyz).w, Math.PI));
+                });
+                this.$return(that.calculateSpotLightAttenuation(this, this.worldPos, this.posRange, this.dirCutoff, this.extra.xy));
+            });
+            const attenuation = pb.getGlobalScope()[funcName](type, worldPos.xyz, posRange, dirCutoff, extra ?? pb.vec4(0));
+            // Water caustics ride here rather than on calculateShadow(): every light
+            // model already folds this value into its light colour and nothing else
+            // reads it, so a vec3 return applies the caustic tint everywhere without
+            // touching a single call site. It also covers both lighting paths, which
+            // matters because a shadow-casting sun goes through the clustered path
+            // when the screen-space shadow mask is on and through a per-light additive
+            // pass when it is off.
+            const caustic = this.receivesWaterCaustics() ? ShaderHelper.calculateWaterCaustic(scope, worldPos.xyz, type, dirCutoff.xyz, this.drawContext) : null;
+            return caustic ? pb.mul(caustic, attenuation) : attenuation;
         }
-        calculateLightDirection(scope, type, worldPos, posRange, dirCutoff) {
+        /**
+     * Unit vector from `worldPos` towards the light.
+     *
+     * @remarks
+     * For a rect light this is the direction of its vector form factor (see
+     * {@link calculateRectLightVectorIrradiance}), which needs the rect's second
+     * axis from `extra`. Without `extra` a rect light falls back to the direction
+     * of its centre.
+     */ calculateLightDirection(scope, type, worldPos, posRange, dirCutoff, extra) {
             const pb = scope.$builder;
-            return scope.$choice(pb.equal(type, LIGHT_TYPE_DIRECTIONAL), pb.neg(dirCutoff.xyz), pb.normalize(pb.sub(posRange.xyz, worldPos.xyz)));
+            if (!extra) {
+                return scope.$choice(pb.equal(type, LIGHT_TYPE_DIRECTIONAL), pb.neg(dirCutoff.xyz), pb.normalize(pb.sub(posRange.xyz, worldPos.xyz)));
+            }
+            const that = this;
+            pb.func('Z_calculateLightDirection', [
+                pb.int('lightType'),
+                pb.vec3('worldPos'),
+                pb.vec4('posRange'),
+                pb.vec4('dirCutoff'),
+                pb.vec4('extra')
+            ], function() {
+                this.$if(pb.equal(this.lightType, LIGHT_TYPE_DIRECTIONAL), function() {
+                    this.$return(pb.neg(this.dirCutoff.xyz));
+                });
+                this.$if(pb.equal(this.lightType, LIGHT_TYPE_RECT), function() {
+                    this.$return(that.calculateRectLightVectorIrradiance(this, this.worldPos, this.posRange, this.dirCutoff.xyz, this.extra.xyz).xyz);
+                });
+                this.$return(pb.normalize(pb.sub(this.posRange.xyz, this.worldPos)));
+            });
+            return pb.getGlobalScope().Z_calculateLightDirection(type, worldPos.xyz, posRange, dirCutoff, extra);
         }
-        forEachLight(scope, callback) {
+        /** Invokes `callback` once per light affecting the fragment. */ forEachLight(scope, callback) {
             const pb = scope.$builder;
             const that = this;
             if (that.drawContext.renderPass.type !== RENDER_PASS_TYPE_LIGHT) {
@@ -467,75 +601,81 @@ import { ShaderHelper } from '../shader/helper.js';
                 const extra = scope.light.extraParams ?? pb.vec4(0);
                 scope.$scope(function() {
                     const lightType = pb.int(extra.w);
-                    callback.call(this, lightType, posRange, dirCutoff, colorIntensity, extra, true);
+                    // The per-light additive path has no thickness texture: it is produced
+                    // for the clustered queue only. 1 is the "no data" sentinel the
+                    // thickness pass can never write, so consumers read this as "this
+                    // light contributes no transmission" rather than as zero thickness —
+                    // which would be the *most* transmissive reading of the encoding.
+                    callback.call(this, lightType, posRange, dirCutoff, colorIntensity, extra, true, pb.float(1), colorIntensity);
                 });
             } else {
+                // Emits the shading of the light at buffer index `index` (an int or uint).
+                const shadeLight = function(index) {
+                    this.$l.positionRange = ShaderHelper.getLightPositionAndRange(this, index);
+                    this.$l.directionCutoff = ShaderHelper.getLightDirectionAndCutoff(this, index);
+                    this.$l.diffuseIntensity = ShaderHelper.getLightColorAndIntensity(this, index);
+                    this.$l.extra = ShaderHelper.getLightExtra(this, index);
+                    this.$l.unshadowedIntensity = this.diffuseIntensity;
+                    if (that.drawContext.screenSpaceShadowMask) {
+                        // Shadow-casting lights (buffer index <= numShadowLights) attenuate
+                        // by the pre-rendered screen-space shadow mask; others return 1.0.
+                        this.$l.shadowMask = ShaderHelper.sampleShadowMask(this, pb.int(index));
+                        this.diffuseIntensity = pb.vec4(pb.mul(this.diffuseIntensity.rgb, this.shadowMask), this.diffuseIntensity.w);
+                    }
+                    this.$l.thickness = pb.float(1);
+                    if (that.drawContext.transmissionThickness) {
+                        this.thickness = ShaderHelper.sampleTransmissionThickness(this, pb.int(index));
+                    }
+                    this.$l.lightType = pb.int(this.extra.w);
+                    this.$scope(function() {
+                        callback.call(this, this.lightType, this.positionRange, this.directionCutoff, this.diffuseIntensity, this.extra, false, this.thickness, this.unshadowedIntensity);
+                    });
+                };
                 scope.$scope(function() {
+                    // Lights that reach every fragment (directional) are kept out of the clusters.
+                    const globalLights = ShaderHelper.getGlobalLights(this);
+                    this.$for(pb.int('g'), 0, MAX_GLOBAL_LIGHTS, function() {
+                        this.$l.gi = globalLights.at(this.g);
+                        this.$if(pb.equal(this.gi, 0), function() {
+                            this.$break();
+                        });
+                        this.$scope(function() {
+                            shadeLight.call(this, this.gi);
+                        });
+                    });
                     const countParams = ShaderHelper.getCountParams(this);
                     this.$l.cluster = that.getClusterIndex(this, this.$builtins.fragCoord.xyz);
                     this.$l.clusterIndex = pb.add(this.cluster.x, pb.mul(this.cluster.y, countParams.x), pb.mul(this.cluster.z, countParams.x, countParams.y));
-                    this.$l.texSize = scope.light.lightIndexTexSize;
-                    if (pb.getDevice().type === 'webgl') {
-                        this.$l.texCoordX = pb.div(pb.add(pb.mod(pb.float(this.clusterIndex), pb.float(this.texSize.x)), 0.5), pb.float(this.texSize.x));
-                        this.$l.texCoordY = pb.div(pb.add(pb.float(pb.div(this.clusterIndex, this.texSize.x)), 0.5), pb.float(this.texSize.y));
-                        this.$l.samp = pb.textureSample(ShaderHelper.getClusteredLightIndexTexture(this), pb.vec2(this.texCoordX, this.texCoordY));
-                    } else {
-                        this.$l.texCoordX = pb.mod(this.clusterIndex, this.texSize.x);
-                        this.$l.texCoordY = pb.div(this.clusterIndex, this.texSize.x);
-                        this.$l.samp = pb.textureLoad(ShaderHelper.getClusteredLightIndexTexture(this), pb.ivec2(this.texCoordX, this.texCoordY), 0);
-                    }
-                    if (pb.getDevice().type === 'webgl') {
-                        this.$for(pb.int('i'), 0, 4, function() {
-                            this.$l.k = this.samp.at(this.i);
-                            this.$l.lights = pb.int[2]();
-                            this.$l.lights[0] = pb.int(pb.mod(this.k, 256));
-                            this.$l.lights[1] = pb.int(pb.div(this.k, 256));
-                            this.$for(pb.int('k'), 0, 2, function() {
-                                this.$l.li = this.lights.at(this.k);
-                                this.$if(pb.greaterThan(this.li, 0), function() {
-                                    this.$for(pb.int('j'), 1, 256, function() {
-                                        this.$if(pb.equal(this.j, this.li), function() {
-                                            this.$l.positionRange = ShaderHelper.getLightPositionAndRange(this, this.j);
-                                            this.$l.directionCutoff = ShaderHelper.getLightDirectionAndCutoff(this, this.j);
-                                            this.$l.diffuseIntensity = ShaderHelper.getLightColorAndIntensity(this, this.j);
-                                            this.$l.extra = ShaderHelper.getLightExtra(this, this.j);
-                                            if (that.drawContext.screenSpaceShadowMask) {
-                                                this.$l.shadowMask = ShaderHelper.sampleShadowMask(this, this.j);
-                                                this.diffuseIntensity = pb.vec4(pb.mul(this.diffuseIntensity.rgb, this.shadowMask), this.diffuseIntensity.w);
-                                            }
-                                            this.$l.lightType = pb.int(this.extra.w);
-                                            this.$scope(function() {
-                                                callback.call(this, this.lightType, this.positionRange, this.directionCutoff, this.diffuseIntensity, this.extra, false);
-                                            });
-                                            this.$break();
-                                        });
-                                    });
-                                });
-                            });
-                        });
-                    } else {
-                        this.$for(pb.uint('i'), 0, 4, function() {
-                            this.$for(pb.uint('k'), 0, 4, function() {
-                                this.$l.c = pb.compAnd(pb.sar(this.samp.at(this.i), pb.mul(this.k, 8)), 0xff);
-                                this.$if(pb.greaterThan(this.c, 0), function() {
-                                    this.$l.positionRange = ShaderHelper.getLightPositionAndRange(this, this.c);
-                                    this.$l.directionCutoff = ShaderHelper.getLightDirectionAndCutoff(this, this.c);
-                                    this.$l.diffuseIntensity = ShaderHelper.getLightColorAndIntensity(this, this.c);
-                                    this.$l.extra = ShaderHelper.getLightExtra(this, this.c);
-                                    if (that.drawContext.screenSpaceShadowMask) {
-                                        // Shadow-casting lights (buffer index <= numShadowLights) attenuate
-                                        // by the pre-rendered screen-space shadow mask; others return 1.0.
-                                        this.$l.shadowMask = ShaderHelper.sampleShadowMask(this, pb.int(this.c));
-                                        this.diffuseIntensity = pb.vec4(pb.mul(this.diffuseIntensity.rgb, this.shadowMask), this.diffuseIntensity.w);
-                                    }
-                                    this.$l.lightType = pb.int(this.extra.w);
-                                    this.$scope(function() {
-                                        callback.call(this, this.lightType, this.positionRange, this.directionCutoff, this.diffuseIntensity, this.extra, false);
-                                    });
-                                });
+                    if (ShaderHelper.usesClusterLightLists()) {
+                        // The cluster's lights are list[offset .. offset + count), however many.
+                        const grid = ShaderHelper.getClusterGrid(this);
+                        const list = ShaderHelper.getClusterLightList(this);
+                        this.$l.cell = pb.mul(pb.uint(this.clusterIndex), 2);
+                        this.$l.listOffset = grid.at(this.cell);
+                        this.$l.listCount = grid.at(pb.add(this.cell, 1));
+                        this.$for(pb.uint('n'), 0, this.listCount, function() {
+                            this.$l.c = list.at(pb.add(this.listOffset, this.n));
+                            this.$scope(function() {
+                                shadeLight.call(this, this.c);
                             });
                         });
+                        return;
                     }
+                    this.$l.texSize = scope.light.lightIndexTexSize;
+                    this.$l.texCoordX = pb.mod(this.clusterIndex, this.texSize.x);
+                    this.$l.texCoordY = pb.div(this.clusterIndex, this.texSize.x);
+                    this.$l.samp = pb.textureLoad(ShaderHelper.getClusteredLightIndexTexture(this), pb.ivec2(this.texCoordX, this.texCoordY), 0);
+                    // Slots are packed front to back (slot 0 in the top byte of .r) with a zero tail, so
+                    // walk them in that order and stop at the first empty one.
+                    this.$for(pb.uint('n'), 0, 16, function() {
+                        this.$l.c = pb.compAnd(pb.sar(this.samp.at(pb.div(this.n, 4)), pb.sub(24, pb.mul(pb.compAnd(this.n, 3), 8))), 0xff);
+                        this.$if(pb.equal(this.c, 0), function() {
+                            this.$break();
+                        });
+                        this.$scope(function() {
+                            shadeLight.call(this, this.c);
+                        });
+                    });
                 });
             }
         }