Pixel-perfect GI Without Ray Tracing

1float frag(Varyings i) : SV_Target
2{
3    float2 uv = i.texcoord;
4    
5    float blockAllLightColor = 0;
6    float allowAllLightColor = 1;
7 
8    float2 worldCoord = uvToGrid(uv);
↳uvToGrid returns grid coordinates, it's defined in the next section
9    int2 worldTile = int2(floor(worldCoord));
10 
11    // Apply offset to convert world coords to buffer indices
12    int2 bufferTile = worldTile + int2(_GridOffsetX, _GridOffsetY);
13 
14    if (bufferTile.x < 0 || bufferTile.x >= _GridWidth || bufferTile.y < 0 || bufferTile.y >= _GridHeight)
15    {
16        return allowAllLightColor;
17    }
18 
19    int bufferIndex = Convert2DIndexTo1D(bufferTile, _GridWidth);
20    int isWall = _WallBuffer[bufferIndex];
21    
22    if (isWall == 0)
23    {
24        return allowAllLightColor;
25    }
26 
27    return blockAllLightColor; // Wall cell: no conduction (light can't exist/propagate here)
28}

1int Convert2DIndexTo1D(int2 idx, int width)
2{
3    return idx.x + idx.y * width;
4}

1_bufferSize = new int2(diameter, diameter);
2_coordinateOffset = diameter / 2;
3 
4Shader.SetGlobalInt("_GridWidth", _bufferSize.x);
5Shader.SetGlobalInt("_GridHeight", _bufferSize.y);
6Shader.SetGlobalFloat("_WallHeight", wallHeight);
7 
8_wallBuffer = new ComputeBuffer(_bufferSize.x * _bufferSize.y, sizeof(int));
9_wallBuffer.SetData(_cpuMirror);
10Shader.SetGlobalBuffer("_WallBuffer", _wallBuffer);
11 
12GIBridge.GridSizeOverride = _bufferSize;
13GIBridge.GridOffsetOverride = new int2(_coordinateOffset, _coordinateOffset);

1float2 worldPos = uvToGrid(uv);
2float giRes = max(_GI_Resolution_Lib, 1.0);
3float2 gridPos = (floor(worldPos * giRes) + 0.5) / giRes;
4 
5int2 baseTile = int2(floor(gridPos));
6float radius = max(_AORadius, 0.01);
7int range = (int)ceil(radius);
8 
9float occSum = 0.0;
10float weightSum = 0.0;
11 
12for (int y = -range; y <= range; y++)
13{
14    for (int x = -range; x <= range; x++)
15    {
16        float2 tileCenter = float2(baseTile.x + x + 0.5, baseTile.y + y + 0.5);
17        float dist = distance(gridPos, tileCenter);
18        if (dist > radius) continue;
19 
20        float w = 1.0 - saturate(dist / radius);
21        w = pow(w, max(_AOPower, 0.01));
22        weightSum += w;
23 
24        if (IsObstacle(baseTile.x + x, baseTile.y + y))
25            occSum += w;
26    }
27}
28 
29float occ = (weightSum > 0.0) ? (occSum / weightSum) : 0.0;
30float ao = 1.0 - saturate(_AOStrength) * occ;

1public static float4 CalculateCameraVisibleArea(Camera camera, float cameraViewPadding)
2{
3    const float groundPlaneY = 0.0f;
4 
5    Vector2[] corners = { new(0f, 0f), new(1f, 0f), new(0f, 1f), new(1f, 1f) };
6 
7    float2 minGrid = new float2(float.MaxValue, float.MaxValue);
8    float2 maxGrid = new float2(float.MinValue, float.MinValue);
9 
10    for (int i = 0; i < corners.Length; i++)
11    {
12        Vector2 corner = corners[i];
13        Ray ray = camera.ViewportPointToRay(new Vector3(corner.x, corner.y, 0f));
14        float denom = ray.direction.y;
15 
16        // If the camera ray is parallel to the ground plane (or something goes NaN), we bail out and skip GI for the frame.
17        if (math.abs(denom) < 1e-4f)
18            return new float4(0f, 0f, 0f, 0f);
19 
20        float t = (groundPlaneY - ray.origin.y) / denom;
21        if (t <= 0.0f || float.IsNaN(t) || float.IsInfinity(t))
22            return new float4(0f, 0f, 0f, 0f);
23 
24        Vector3 hit = ray.origin + ray.direction * t;
25        minGrid = math.min(minGrid, new float2(hit.x, hit.z));
26        maxGrid = math.max(maxGrid, new float2(hit.x, hit.z));
27    }
28 
29    float2 center = (minGrid + maxGrid) * 0.5f;
30    float2 paddedSize = (maxGrid - minGrid) * cameraViewPadding;
31 
32    float2 minCorner = center - paddedSize * 0.5f;
33    return new float4(minCorner.x, minCorner.y, paddedSize);
34}

1private float4 CalculatePhaseLockedCameraView(float2 center, float2 size, int resolution)
2{
3    float minX = center.x - size.x * 0.5f;
4    float minY = center.y - size.y * 0.5f;
5 
6    // Convert world -> texels
7    int minXTexel = Mathf.FloorToInt(minX * resolution);
8    int minYTexel = Mathf.FloorToInt(minY * resolution);
9 
10    // Snap to 1 world unit boundaries (resolution texels)
11    minXTexel = Mathf.FloorToInt(minXTexel / (float)resolution) * resolution;
12    minYTexel = Mathf.FloorToInt(minYTexel / (float)resolution) * resolution;
13 
14    float invRes = 1.0f / resolution;
15    return new float4(minXTexel * invRes, minYTexel * invRes, size.x, size.y);
16}

1float2 uvToGrid(float2 uv)
2{
3    // _CameraView = (minX, minZ, width, height)
4    float2 gridPos;
5    gridPos.x = _CameraView.x + uv.x * _CameraView.z;
6    gridPos.y = _CameraView.y + uv.y * _CameraView.w;
7    return gridPos;
8}

1float2 gridToViewportUV(float2 gridPos)
2{
3    CamBounds bounds = GetGlobalCameraViewData();
4    float2 uv;
5    uv.x = (gridPos.x - bounds.min.x) / bounds.size.x;
6    uv.y = (gridPos.y - bounds.min.y) / bounds.size.y;
7    return uv;
8}
9 
10float2 snapUVToTexelCenter(float2 uv)
11{
12    float2 texelSize = getViewportTexelSize();
13    float2 halfTexel = texelSize * 0.5;
14    uv = clamp(uv, halfTexel, 1.0 - halfTexel);
15    return (floor(uv / texelSize) + 0.5) * texelSize;
16}

1struct VM_LightData
2{
3    float4 color;
4    float2 position;
5    float radius;
6    float _padding; // 16 byte alignment
7};

1// In RecordRenderGraph
2 
3var lightData = frameData.Get<UniversalLightData>();
4 
5for (int i = 0; i < lightData.visibleLights.Length; i++)
↳By using lightData.visibleLights, we don't need to handle culling + range checks, but max lights are capped at 256 by URP. If you need more, gather them in a job or similar.
6{
7    var visibleLight = lightData.visibleLights[i];
8    var unityLight = visibleLight.light;
9    var position = unityLight.transform.position;
10 
11 
12    WritePointLight(lightCount,
13        new float3(position.x, position.y, position.z),
14        visibleLight.finalColor,
15        unityLight.range);
↳WritePointLight writes to the light buffer we'll send to the shaders
16}

1float CalculateShadowDDA(float2 lightPos, float2 pixelPos, float radius)
2{
3    float2 rayDir = pixelPos - lightPos;
4    float rayLength = length(rayDir);
5 
6    if (rayLength < 1e-4)
7        return 1.0;
8 
9    rayDir /= rayLength;
10 
11    // Bias the ray off grid boundaries to avoid corner/edge ambiguity.
12    const float RAY_BIAS = 1e-4;
13    float2 startPos = lightPos + rayDir * RAY_BIAS;
14    float2 endPos = pixelPos - rayDir * RAY_BIAS;
15    rayLength = max(rayLength - 2.0 * RAY_BIAS, 0.0);
↳Start/end bias keeps floor() stable when positions land on grid boundaries.
16 
17    // Grid cell coordinates of starting and ending points
18    int2 startCell = int2(floor(startPos));
19    int2 endCell = int2(floor(endPos));
20 
21    int2 cell = startCell;
22 
23    // Calculate step direction
24    int2 step = int2(sign(rayDir));
25 
26    // Calculate distance to first X and Y cell boundaries
27    const float DIR_EPS = 1e-6;
28    bool xZero = abs(rayDir.x) < DIR_EPS;
29    bool yZero = abs(rayDir.y) < DIR_EPS;
↳Guard near-zero directions to avoid 1/dir blowups.
30 
31    float2 tMax;
32    if (xZero)
33        tMax.x = 1e30;
34    else
35        tMax.x = (step.x > 0)
36            ? (floor(startPos.x) + 1 - startPos.x) / rayDir.x
37            : (startPos.x - floor(startPos.x)) / -rayDir.x;
38 
39    if (yZero)
40        tMax.y = 1e30;
41    else
42        tMax.y = (step.y > 0)
43            ? (floor(startPos.y) + 1 - startPos.y) / rayDir.y
44            : (startPos.y - floor(startPos.y)) / -rayDir.y;
45 
46    // Calculate how far to step in each direction to move one cell
47    float2 tDelta = float2(
48        xZero ? 1e30 : abs(1.0 / rayDir.x),
49        yZero ? 1e30 : abs(1.0 / rayDir.y));
50 
51    float distanceTraveled;
52    const float CORNER_EPS = 1e-5;
53 
54    // Maximum number of steps to prevent infinite loops
55    int maxSteps = max(1, (int)ceil(radius * 2.0) + 2);
56 
57    for (int i = 0; i < maxSteps; i++)
58    {
59        // IsObstacle MUST use _WallBuffer in this path
60        if (IsObstacle(cell.x, cell.y))
↳IsObstacle treats out-of-bounds as empty (streaming-friendly).
61        {
62            return 0;
63        }
64 
65        // If we've reached the destination cell, we're not in shadow
66        if (cell.x == endCell.x && cell.y == endCell.y)
67            return 1.0;
68 
69        // Step to next cell
70        if (tMax.x < tMax.y - CORNER_EPS)
71        {
72            distanceTraveled = tMax.x;
73            tMax.x += tDelta.x;
74            cell.x += step.x;
75        }
76        else if (tMax.y < tMax.x - CORNER_EPS)
77        {
78            distanceTraveled = tMax.y;
79            tMax.y += tDelta.y;
80            cell.y += step.y;
81        }
82        else
83        {
84            // Corner hit: only block if both adjacent cells are obstacles
85            distanceTraveled = tMax.x;
86            int2 nextX = cell + int2(step.x, 0);
87            int2 nextY = cell + int2(0, step.y);
88            if (IsObstacle(nextX.x, nextX.y) && IsObstacle(nextY.x, nextY.y))
89                return 0;
90 
91            tMax.x += tDelta.x;
92            tMax.y += tDelta.y;
93            cell.x += step.x;
94            cell.y += step.y;
95        }
96 
97        // If we've traveled farther than the ray length, we're done
98        if (distanceTraveled > rayLength)
99            return 1.0;
100    }
101 
102    // If we've exceeded max steps, assume no shadow
103    return 1.0;
104}

1struct VM_ShadowProxyData
2{
3    float2 position;        // World XZ
4    float2 size;            // Half extents (box) or radius (circle)
5    float maxLength;        // Shadow length
6    float endCapBlend;      // Blend between light dir and proxy axis
7    float penumbraWidth;    // Soft edge across width
8    float penumbraLength;   // Soft edge along length
9    float penumbraPower;    // Curve sharpness
10    float shape;            // 0 = box, 1 = circle
11    float widthMode;        // 0 = projected width, 1 = max axis
12    float penumbraMode;     // inward/outward/both
13};

1float ComputePointLightProxyShadow(float2 lightPos, float2 pixelPos)
2{
3    if (_ShadowProxyCount <= 0) return 1.0;
4 
5    float2 ray = pixelPos - lightPos;
6    float rayLen = length(ray);
7    if (rayLen < 1e-4) return 1.0;
8 
9    float2 dir = ray / rayLen;
10    float shadow = 1.0;
11 
12    for (int i = 0; i < _ShadowProxyCount; i++)
13    {
14        VM_ShadowProxyData proxy = _ShadowProxyBuffer[i];
15        float2 toProxy = proxy.position - lightPos;
16        float proxyDist = length(toProxy);
17        if (proxyDist < 1e-4) continue;
18 
19        float2 dirFlat = toProxy / proxyDist;
20        float2 dirShadow = normalize(lerp(dir, dirFlat, saturate(proxy.endCapBlend)));
21        float2 perpDir = float2(-dirShadow.y, dirShadow.x);
22 
23        float occluderDist = dot(toProxy, dirShadow);
24        if (occluderDist <= 0.0) continue;
25 
26        float2 toPixelFromProxy = pixelPos - proxy.position;
27        float alongDist = dot(toPixelFromProxy, dirShadow);
28        if (alongDist <= 0.0) continue;
29 
30        float perpDist = abs(dot(toPixelFromProxy, perpDir));
31        float width = GetShadowProxyWidth(proxy, perpDir);
32 
33        if (alongDist > proxy.maxLength + proxy.penumbraLength) continue;
34 
35        float edge = ComputePenumbraFactor(perpDist, width, proxy.penumbraWidth, proxy.penumbraPower, proxy.penumbraMode);
36        float len  = ComputePenumbraFactor(alongDist, proxy.maxLength, proxy.penumbraLength, proxy.penumbraPower, proxy.penumbraMode);
37 
38        float occlusion = edge * len;
39        shadow = min(shadow, 1.0 - occlusion);
40        if (shadow <= 0.001) break;
41    }
42 
43    return shadow;
44}

1struct FragmentOutput
2{
3    float4 color   : SV_Target0;  // Direct light color
4    float4 shadow  : SV_Target1;  // Shadow map (R=point, G=directional)
5    float4 wallFace0 : SV_Target2;  // +X face (RGB)
6    float4 wallFace1 : SV_Target3;  // -X face (RGB)
7    float4 wallFace2 : SV_Target4;  // +Z face (RGB)
8    float4 wallFace3 : SV_Target5;  // -Z face (RGB)
9};

1// Which faces of this wall tile are exposed (not buried in other walls)?
2float4 GetWallFaceMask(int2 cell)
3{
4    if (!IsObstacle(cell.x, cell.y))
5        return float4(0, 0, 0, 0);  // Not a wall
6 
7    // Check each neighbor - if neighbor is NOT a wall, this face is exposed
8    float facePosX = IsObstacle(cell.x + 1, cell.y) ? 0.0 : 1.0;
9    float faceNegX = IsObstacle(cell.x - 1, cell.y) ? 0.0 : 1.0;
10    float facePosZ = IsObstacle(cell.x, cell.y + 1) ? 0.0 : 1.0;
11    float faceNegZ = IsObstacle(cell.x, cell.y - 1) ? 0.0 : 1.0;
12 
13    return float4(facePosX, faceNegX, facePosZ, faceNegZ);
14}
15 
16// How much does this light contribute to each face?
17float4 GetWallFacing(float2 dirToLight)
18{
19    return float4(
20        saturate(dirToLight.x),   // +X face lit when light is to the right
21        saturate(-dirToLight.x),  // -X face lit when light is to the left
22        saturate(dirToLight.y),   // +Z face lit when light is above
23        saturate(-dirToLight.y)   // -Z face lit when light is below
24    );
25}

1FragmentOutput frag(Varyings input)
2{
3    FragmentOutput output;
4    output.color = float4(0);
5    output.shadow = float4(0);
6    output.wallFace0 = float4(0);
7    output.wallFace1 = float4(0);
8    output.wallFace2 = float4(0);
9    output.wallFace3 = float4(0);
10 
11    float2 gridPos = uvToGrid(input.texcoord);
12    float giRes = max(_GI_Resolution_Lib, 1.0);
13    float2 gridPosCell = (floor(gridPos * giRes) + 0.5) / giRes;
↳Snap to GI texel centers so wall/ground sampling is stable across camera movement.
14 
15    int2 wallCell = int2(floor(gridPos));
16    // IsObstacle MUST use _WallBuffer in this path, otherwise popping might occur
17    bool isWall = IsObstacle(wallCell.x, wallCell.y);
↳Walls are encoded in the wall buffer (1 = wall).
18 
19    float totalShadow = 0.0;
20    float3 wallFace0 = float3(0, 0, 0);
21    float3 wallFace1 = float3(0, 0, 0);
22    float3 wallFace2 = float3(0, 0, 0);
23    float3 wallFace3 = float3(0, 0, 0);
↳Wall lighting accumulates into per-face outputs (valid only on wall texels).
24 
25    if (isWall)
26    {
27        float2 wallSamplePos = gridPosCell;
↳Base wall position; per-face offsets push just outside the wall cell.
28        float4 faceMask = GetWallFaceMask(wallCell);
29        float2 cellMin = float2(wallCell);
30        float2 cellMax = cellMin + 1.0;
31        const float faceEps = 1e-3;
↳Small epsilon pushes the ray target just outside the wall cell (aligns wall/ground shadows).
32        const float4 zero4 = float4(0, 0, 0, 0);
33 
34        for (int i = 0; i < _LightCount; i++)
35        {
36            float2 lightGridPos = _LightBuffer[i].position;
37            float4 lightColor = _LightBuffer[i].color;
38            float lightRadius = _LightBuffer[i].radius;
39 
40            float dist = distance(wallSamplePos, lightGridPos);
41            if (dist > lightRadius)
42                continue;
43 
44            float2 dirToLight = lightGridPos - wallSamplePos;
45            float invLen = rsqrt(max(dot(dirToLight, dirToLight), 1e-6));
46            dirToLight *= invLen;
47            float4 facing = GetWallFacing(dirToLight);
48            float4 faceWeight = faceMask * facing;
↳Face weights bias toward the wall face oriented to the light.
49 
50            if (all(faceWeight == zero4))
51                continue;
52 
53            float falloff = 1.0 - saturate(dist / lightRadius);
54            falloff = pow(falloff, _LightSoftness);
55 
56            float3 directContribution = lightColor.rgb * falloff;
57 
58            float4 faceShadow = float4(1, 1, 1, 1);
59            if (faceWeight.x > 0.0)
↳Each face gets its own DDA to the adjacent cell + proxy shadow.
60            {
61                float2 facePos = float2(cellMax.x + faceEps, wallSamplePos.y);
62                float shadowFactor = CalculateShadowDDA(lightGridPos, facePos, lightRadius);
63                float proxyShadowFactor = ComputePointLightProxyShadow(lightGridPos, facePos);
64                faceShadow.x = min(shadowFactor, proxyShadowFactor);
65            }
66            if (faceWeight.y > 0.0)
67            {
68                float2 facePos = float2(cellMin.x - faceEps, wallSamplePos.y);
69                float shadowFactor = CalculateShadowDDA(lightGridPos, facePos, lightRadius);
70                float proxyShadowFactor = ComputePointLightProxyShadow(lightGridPos, facePos);
71                faceShadow.y = min(shadowFactor, proxyShadowFactor);
72            }
73            if (faceWeight.z > 0.0)
74            {
75                float2 facePos = float2(wallSamplePos.x, cellMax.y + faceEps);
76                float shadowFactor = CalculateShadowDDA(lightGridPos, facePos, lightRadius);
77                float proxyShadowFactor = ComputePointLightProxyShadow(lightGridPos, facePos);
78                faceShadow.z = min(shadowFactor, proxyShadowFactor);
79            }
80            if (faceWeight.w > 0.0)
81            {
82                float2 facePos = float2(wallSamplePos.x, cellMin.y - faceEps);
83                float shadowFactor = CalculateShadowDDA(lightGridPos, facePos, lightRadius);
84                float proxyShadowFactor = ComputePointLightProxyShadow(lightGridPos, facePos);
85                faceShadow.w = min(shadowFactor, proxyShadowFactor);
86            }
87 
88            float4 faceContribution = faceWeight * faceShadow;
89 
90            wallFace0 += directContribution * faceContribution.x;
91            wallFace1 += directContribution * faceContribution.y;
92            wallFace2 += directContribution * faceContribution.z;
93            wallFace3 += directContribution * faceContribution.w;
94        }
95 
96        for (int i = 0; i < _EmissiveLightCount; i++)
↳Emissives skip DDA but still light wall faces.
97        {
98            float2 lightGridPos = _EmissiveLightBuffer[i].position;
99            float4 lightColor = _EmissiveLightBuffer[i].color;
100            float lightRadius = _EmissiveLightBuffer[i].radius;
101 
102            float dist = distance(wallSamplePos, lightGridPos);
103            if (dist > lightRadius)
104                continue;
105 
106            float falloff = 1.0 - saturate(dist / lightRadius);
107            falloff = pow(falloff, _LightSoftness);
108 
109            float3 directContribution = lightColor.rgb * falloff;
110            float2 dirToLight = lightGridPos - wallSamplePos;
111            float invLen = rsqrt(max(dot(dirToLight, dirToLight), 1e-6));
112            dirToLight *= invLen;
113            float4 facing = GetWallFacing(dirToLight);
114            float4 faceWeight = faceMask * facing;
115 
116            wallFace0 += directContribution * faceWeight.x;
117            wallFace1 += directContribution * faceWeight.y;
118            wallFace2 += directContribution * faceWeight.z;
119            wallFace3 += directContribution * faceWeight.w;
120        }
121    }
122    else
123    {
124        // Process each light for ground
125        for (int i = 0; i < _LightCount; i++)
126        {
127            float2 lightGridPos = _LightBuffer[i].position;
128            float4 lightColor = _LightBuffer[i].color;
129            float lightRadius = _LightBuffer[i].radius;
130 
131            float dist = distance(gridPos, lightGridPos);
132            if (dist > lightRadius)
133                continue;
134 
135            float shadowFactor = CalculateShadowDDA(lightGridPos, gridPosCell, lightRadius);
↳Ground samples DDA to the GI texel center (not the wall boundary).
136            float proxyShadowFactor = ComputePointLightProxyShadow(lightGridPos, gridPosCell);
137            shadowFactor = min(shadowFactor, proxyShadowFactor);
138 
139            totalShadow = max(totalShadow, shadowFactor);
140 
141            float falloff = 1.0 - saturate(dist / lightRadius);
142            falloff = pow(falloff, _LightSoftness);
143 
144            float3 directContribution = lightColor.rgb * falloff * shadowFactor;
145            output.color.rgb += directContribution;
146        }
147 
148        // Process emissive-only lights (no shadows)
149        for (int i = 0; i < _EmissiveLightCount; i++)
150        {
151            float2 lightGridPos = _EmissiveLightBuffer[i].position;
152            float4 lightColor = _EmissiveLightBuffer[i].color;
153            float lightRadius = _EmissiveLightBuffer[i].radius;
154 
155            float dist = distance(gridPos, lightGridPos);
156            if (dist > lightRadius)
157                continue;
158 
159            float falloff = 1.0 - saturate(dist / lightRadius);
160            falloff = pow(falloff, _LightSoftness);
161 
162            output.color.rgb += lightColor.rgb * falloff;
163        }
164    }
165 
166    float shadowMask = isWall ? 0.0 : 1.0;
↳Shadow map only stores visibility for non-wall texels.
167    output.shadow = float4(totalShadow * shadowMask, 0.0, 0.0, 0.0);
168    output.wallFace0 = float4(wallFace0, 1.0);
169    output.wallFace1 = float4(wallFace1, 1.0);
170    output.wallFace2 = float4(wallFace2, 1.0);
171    output.wallFace3 = float4(wallFace3, 1.0);
172    return output;
173}

1struct VM_DirectionalLightData {
2    float3 direction;              // Normalized light direction
3    float4 color;
4    float shadowDistanceMultiplier; // Pre-computed: 1.0 / max(abs(direction.y), 0.02)
5    float baseShadowDistance;
6    float bounceIntensity;
7    float2 _padding;               // 16 byte alignment
8};

1float DirectionalShadowDDA(float2 pixelPos, float3 lightDir,
2                           float baseShadowDistance, float shadowDistanceMultiplier)
3{
4    float3 rayDir3D = -lightDir;
5    float2 rayDir = normalize(rayDir3D.xz);
6    float rayDirXZLen = length(rayDir3D.xz);
7    if (rayDirXZLen < 1e-4) return 1.0;
8 
9    const float DIR_EPS = 1e-6;
10    const float RAY_BIAS = 1e-4;
11    float2 startPos = pixelPos + rayDir * RAY_BIAS;
12    int2 cell = int2(floor(startPos));
13    int2 step = int2(sign(rayDir));
14    bool xZero = abs(rayDir.x) < DIR_EPS;
15    bool yZero = abs(rayDir.y) < DIR_EPS;
16 
17    float2 tMax;
18    tMax.x = xZero ? 1e30 :
19        (step.x > 0 ? (floor(startPos.x) + 1 - startPos.x) / rayDir.x
20                    : (startPos.x - floor(startPos.x)) / -rayDir.x);
21    tMax.y = yZero ? 1e30 :
22        (step.y > 0 ? (floor(startPos.y) + 1 - startPos.y) / rayDir.y
23                    : (startPos.y - floor(startPos.y)) / -rayDir.y);
24 
25    float2 tDelta = float2(
26        xZero ? 1e30 : abs(1.0 / rayDir.x),
27        yZero ? 1e30 : abs(1.0 / rayDir.y));
28 
29    float maxDist = baseShadowDistance * shadowDistanceMultiplier;
30    int maxSteps = 2 * (_GridWidth + _GridHeight);
31 
32    for (int i = 0; i < maxSteps; i++)
33    {
34        if (BlocksDirectionalCell(cell, startPos, rayDir3D, rayDirXZLen))
35            return 0.0;
36 
37        if (tMax.x < tMax.y) { tMax.x += tDelta.x; cell.x += step.x; }
38        else                 { tMax.y += tDelta.y; cell.y += step.y; }
39 
40        float traveled = min(tMax.x, tMax.y);
41        if (traveled > maxDist) return 1.0;
42 
43        int bufferX = cell.x + _GridOffsetX;
44        int bufferY = cell.y + _GridOffsetY;
45        if (bufferX < 0 || bufferY < 0 || bufferX >= _GridWidth || bufferY >= _GridHeight)
46            return 1.0;
47    }
48    return 1.0;
49}
50 
51float3 direct = 0;
52float totalShadow = 0;
53for (int i = 0; i < _DirectionalLightCount; i++)
54{
55    VM_DirectionalLightData lightData = _DirectionalLightBuffer[i];
56    float3 lightDir = lightData.direction;
57    float4 lightColor = lightData.color;
58    float shadowDistanceMultiplier = lightData.shadowDistanceMultiplier;
59    float baseShadowDistance = lightData.baseShadowDistance;
60 
61    float visibility = (lightDir.y >= 0.0) ? 0.0
62        : DirectionalShadowDDA(gridPosCell, lightDir, baseShadowDistance, shadowDistanceMultiplier);
63    visibility = min(visibility, ComputeDirectionalProxyShadow(gridPosCell, lightDir));
64 
65    float angle = saturate(-lightDir.y * 2.0);
66    angle = lerp(angle, 1.0, _GI_DirectionalAngleScale);
67 
68    totalShadow = max(totalShadow, visibility);
69    direct += lightColor.rgb * angle * visibility;
70    // Wall faces use the same face-weight accumulation as point lights,
71    // but their shadow rays start just outside each face to avoid self-occlusion.
72}
73output.color.rgb += direct;
74output.shadow.g = totalShadow * shadowMask;

1bool BlocksDirectionalCell(int2 cell, float2 startPos, float3 rayDir3D, float rayDirXZLen)
2{
3    if (!IsObstacle(cell.x, cell.y)) return false;
4 
5    float distanceToWall = length(float2(cell) + 0.5 - startPos);
6    if (abs(rayDir3D.y) > 0.001 && rayDirXZLen > 1e-4)
7    {
8        float verticalRate = rayDir3D.y / rayDirXZLen;
9        float rayHeightAtWall = distanceToWall * verticalRate;
10        return rayHeightAtWall < _WallHeight; // uniform wall height
11    }
12    return true;
13}

1struct VM_EmissiveLightData {
2    float2 position;
3    float4 color;
4    float radius;
5    float _padding; // 16 byte alignment
6};

1float4 directLight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
2 
3// Non-linear extraction to prevent white hotspots
4float maxChannel = max(directLight.r, max(directLight.g, directLight.b));
5float curve = 1.0 - exp(-maxChannel * 2.0);  // Exponential rolloff
6float scaleFactor = _EmissionStrength * curve / (maxChannel + 0.001);
7 
8float4 emission = directLight * scaleFactor;
9 
10// Boost saturation to compensate for averaging
11float luminance = dot(emission.rgb, float3(0.299, 0.587, 0.114));
12emission.rgb = luminance + (emission.rgb - luminance) * 1.2;

1// Standard 8-neighbor offsets
2static const float2 offsets[8] = {
3    float2(-1, -1), float2(0, -1), float2(1, -1),
4    float2(-1, 0),                 float2(1, 0),
5    float2(-1, 1),  float2(0, 1),  float2(1, 1)
6};
7 
8// Diagonal neighbors get less weight (1 / sqrt(2))
9static const float weights[8] = {
10    0.7071, 1.0, 0.7071,
11    1.0,         1.0,
12    0.7071, 1.0, 0.7071
13};

1float4 centerHeat = SAMPLE_TEXTURE2D(_ColorBuffer, sampler_ColorBuffer, uv);
2float centerCond = SAMPLE_TEXTURE2D(_ConductionMask, sampler_ConductionMask, uv).r;
3if (centerCond < 1e-4) return centerHeat;
4 
5float4 shadowInfo = SAMPLE_TEXTURE2D(_ShadowMap, sampler_ShadowMap, uv);
6float directVisibility = max(shadowInfo.r, shadowInfo.g);
7float inShadow = 1.0 - directVisibility;
8 
9CamBounds bounds = GetGlobalCameraViewData();
10float2 worldToUV = float2(1.0 / bounds.size.x, 1.0 / bounds.size.y);
11float2 sampleDistance = _DiffusionDistance * worldToUV;
12 
13float3 accum = 0.0;
14float3 wsum = 0.0;
15 
16// Loop neighbors (tiered if adaptive). Offsets + distanceWeight are precomputed.
17for (int i = 0; i < 8; i++)
18{
19    float2 nUV = uv + offsets[i] * sampleDistance;
20    float4 nHeat = SAMPLE_TEXTURE2D(_ColorBuffer, sampler_ColorBuffer, nUV);
21    float nCond = SAMPLE_TEXTURE2D(_ConductionMask, sampler_ConductionMask, nUV).r;
22 
23    float weight = nCond * centerCond * weights[i] * _DiffusionRate;
24 
25    // Stylized per-channel (see next section)
26    float3 channelPresence = saturate(nHeat.rgb + 0.1);
27    float3 channelWeights = weight * channelPresence;
28    accum += nHeat.rgb * channelWeights;
29    wsum += channelWeights;
30}
31 
32accum /= max(wsum, 1e-4);
33 
34float blend = lerp(0.5, 0.8, inShadow) * _DiffusionRate;
35float3 newHeat = lerp(centerHeat.rgb, accum, blend);
36 
37// Optional dark-area bias (keeps deep shadows from staying dead)
38float centerLum = dot(centerHeat.rgb, float3(0.299, 0.587, 0.114));
39float darkness = 1.0 - saturate(centerLum);
40newHeat *= 1.0 + _RangeBoost * darkness * inShadow;
41 
42newHeat *= _IntensityMultiplier;
43 
44// Soft cap
45float maxChannel = max(newHeat.r, max(newHeat.g, newHeat.b));
46if (maxChannel > 2.0)
47    newHeat *= 2.0 / maxChannel;
48 
49return float4(newHeat, centerHeat.a);

1// Each channel can spread independently
2float3 channelPresence = saturate(neighborHeat.rgb + 0.1);
3float3 channelWeights = pathConductivity * channelPresence;
4 
5// Accumulate each channel independently
6accumulatedHeat.r += neighborHeat.r * channelWeights.r;
7accumulatedHeat.g += neighborHeat.g * channelWeights.g;
8accumulatedHeat.b += neighborHeat.b * channelWeights.b;
9 
10totalWeightPerChannel += channelWeights;
11 
12// Later: normalize each channel independently
13if (totalWeightPerChannel.r > 0.001)
14    accumulatedHeat.r /= totalWeightPerChannel.r;

1float samplingPixelDistance = _DiffusionDistance * pixelsPerWorldUnit;
2bool useAdaptiveSampling = samplingPixelDistance > 2.5;
3 
4if (useAdaptiveSampling)
5{
6    // Tier 1: Near-field (30%) - local smoothness
7    for (int i = 0; i < 8; i++) {
8        float2 nearSampleUV = viewportUV + offsets[i] * texelSize * 1.5;
9        // ... accumulate with 30% weight
10    }
11 
12    // Tier 2: Mid-field (30%) - bridge the gap
13    for (int j = 0; j < 8; j++) {
14        float2 midSampleUV = viewportUV + offsets[j] * sampleDistance * 0.5;
↳sampleDistance is the UV offset corresponding to _DiffusionDistance in world units (i.e., a world-space hop expressed in GI texture UVs).
15        // ... accumulate with 30% weight
16    }
17 
18    // Tier 3: Far-field (40%) - long-range transport
19    for (int k = 0; k < 8; k++) {
20        float2 farSampleUV = viewportUV + offsets[k] * sampleDistance;
21        // ... accumulate with 40% weight
22    }
23}

1float neighborConductivity = SAMPLE_TEXTURE2D(_ConductionMask, ...).r;
2float pathConductivity = neighborConductivity * centerConductivity * weight;

1// Edge-aware: only blur between similar surfaces
2bool centerIsObstacle = centerConductivity < 0.1;
3bool neighborIsObstacle = neighborConductivity < 0.1;
4 
5if (centerIsObstacle == neighborIsObstacle)
6{
7    // Same surface type - include in blur
8    color += sampleColor * weights[i];
9    totalWeight += weights[i];
10}

1float2 gridPos = uvToGrid(input.uv);
2float giRes = max(_GI_Resolution_Lib, 1.0);
3float2 gridPosCell = (floor(gridPos * giRes) + 0.5) / giRes;
4 
5int2 cell = int2(floor(gridPos));
6if (!IsObstacle(cell.x, cell.y))
7    return output; // Not a wall
8 
9float4 faceMask = GetWallFaceMask(cell);
10 
11float3 posX = faceMask.x > 0.0 ? SampleIndirectAt(gridPosCell + float2(1, 0)) : 0;
12float3 negX = faceMask.y > 0.0 ? SampleIndirectAt(gridPosCell + float2(-1, 0)) : 0;
13float3 posZ = faceMask.z > 0.0 ? SampleIndirectAt(gridPosCell + float2(0, 1)) : 0;
14float3 negZ = faceMask.w > 0.0 ? SampleIndirectAt(gridPosCell + float2(0, -1)) : 0;
15 
16output.wallFace0 = float4(posX, 1.0);
17output.wallFace1 = float4(negX, 1.0);
18output.wallFace2 = float4(posZ, 1.0);
19output.wallFace3 = float4(negZ, 1.0);

1float3 CalculateAverageLightBrightness(float3 worldPos, float3 worldNormal)
2{
3    if (ShouldUseWallLighting(worldPos, worldNormal))
4    {
5        float3 combined = SampleWallDirect(worldPos, worldNormal)
6                        + SampleWallIndirect(worldPos, worldNormal);
7        return ApplyToneMap(combined);
8    }
9 
10    if (ShouldUseWallTopLighting(worldPos, worldNormal))
11    {
12        float3 combined = SampleWallTopDirect(worldPos)
13                        + SampleWallTopIndirect(worldPos);
14        return ApplyToneMap(combined);
15    }
16 
17    float3 direct = SampleGITextureAtWorldPos(_DirectLightColor, sampler_DirectLightColor, worldPos, worldNormal);
18    float3 indirect = SampleGITextureAtWorldPos(_IndirectLightColor, sampler_IndirectLightColor, worldPos, worldNormal);
19    indirect = ApplyDirectionalBounce(indirect, worldPos.xz);
20 
21    float3 combined = (direct + indirect);
22    combined *= SampleGIAmbientOcclusion(worldPos.xz);
23    combined *= SampleConduction(worldPos.xz);
24    return ApplyToneMap(combined);
25}

1float3 SampleGITextureAtWorldPos(Texture2D giTexture, SamplerState giSampler, float3 worldPos, float3 worldNormal)
2{
3    // Walls get routed elsewhere; ground samples directly.
4    float2 uv = gridToViewportUV(worldPos.xz);
5    uv = snapUVToTexelCenter(uv);
6    
7    return SAMPLE_TEXTURE2D(giTexture, giSampler, uv).xyz;
8}

1bool ShouldUseWallLighting(float3 worldPos, float3 worldNormal)
2{
3    if (_WallLightingEnabled < 0.5)
4        return false;
5 
6    // Treat surfaces with significant XZ normal component as walls (even if slightly tilted).
7    float2 nXZ = worldNormal.xz;
8    if (length(nXZ) < 0.5)
9        return false;
10 
11    float2 samplePos = GetWallSamplePosition(worldPos, worldNormal);
12 
13    // IsWallAtWorld samples the conduction mask at the corresponding UV and thresholds it.
14    return IsWallAtWorld(samplePos) || IsWallAtWorld(worldPos.xz);
15}

1int GetDominantWallFace(float3 worldNormal)
2{
3    float2 n = worldNormal.xz;
4    float2 absN = abs(n);
5 
6    if (absN.x >= absN.y)
7        return n.x >= 0 ? 0 : 1; // +X / -X
8    return n.y >= 0 ? 2 : 3;     // +Z / -Z
9}

1float3 SampleWallDirect(float3 worldPos, float3 worldNormal)
2{
3    float2 samplePos = GetWallSamplePosition(worldPos, worldNormal);
4    float2 uv = gridToViewportUV(samplePos);
5    uv = snapUVToTexelCenter(uv);
6 
7    int face = GetDominantWallFace(worldNormal);
8    if (face == 0) return SAMPLE_TEXTURE2D(_WallDirect_PosX, sampler_WallDirect_PosX, uv).rgb;
9    if (face == 1) return SAMPLE_TEXTURE2D(_WallDirect_NegX, sampler_WallDirect_NegX, uv).rgb;
10    if (face == 2) return SAMPLE_TEXTURE2D(_WallDirect_PosZ, sampler_WallDirect_PosZ, uv).rgb;
11    return SAMPLE_TEXTURE2D(_WallDirect_NegZ, sampler_WallDirect_NegZ, uv).rgb;
12}

1bool ShouldUseWallTopLighting(float3 worldPos, float3 worldNormal)
2{
3    if (_WallLightingEnabled < 0.5)
4        return false;
5 
6    // Top faces should be mostly upward with minimal XZ component.
7    float2 nXZ = worldNormal.xz;
8    if (worldNormal.y < 0.5 || length(nXZ) > 0.35)
9        return false;
10 
11    float2 cellCenter = floor(worldPos.xz) + 0.5;
12    return IsWallAtWorld(cellCenter);
13}

1float3 SampleWallTopDirect(float3 worldPos)
2{
3    float3 lightDir = normalize(_GI_MainDirectionalDir.xyz);
4    float angle = saturate(-lightDir.y * 2.0);
5    angle = lerp(angle, 1.0, _GI_DirectionalAngleScale);
6    return _GI_MainDirectionalColor.rgb * angle;
↳_GI_MainDirectionalColor and _GI_MainDirectionalDir is set based on URPs lightData.mainLightIndex.
7}
8 
9float3 SampleWallTopIndirect(float3 worldPos)
10{
11    return SampleGroundAverage(_IndirectLightColor, sampler_IndirectLightColor, worldPos.xz);
12}