From ca776fb9b4db3708116e0f2e397e1ac434529aff Mon Sep 17 00:00:00 2001
From: Olivier Prat <olivier@zvork.fr>
Date: Mon, 15 Jan 2018 11:36:52 +0100
Subject: [PATCH 1/8] Added LightLocal.slh to centralize shading with local
 lights

---
 libraries/render-utils/src/LightLocal.slh     | 48 +++++++++++++++++++
 .../render-utils/src/local_lights_shading.slf | 36 +-------------
 2 files changed, 50 insertions(+), 34 deletions(-)
 create mode 100644 libraries/render-utils/src/LightLocal.slh

diff --git a/libraries/render-utils/src/LightLocal.slh b/libraries/render-utils/src/LightLocal.slh
new file mode 100644
index 0000000000..69563d4985
--- /dev/null
+++ b/libraries/render-utils/src/LightLocal.slh
@@ -0,0 +1,48 @@
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  Created by Olivier Prat on 15/01/18.
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+// Everything about light
+<@include model/Light.slh@>
+<$declareLightBuffer(256)$>
+<@include LightingModel.slh@>
+
+
+<@include LightPoint.slh@>
+<$declareLightingPoint(supportScattering)$>
+<@include LightSpot.slh@>
+<$declareLightingSpot(supportScattering)$>
+
+<@include LightClusterGrid.slh@>
+
+<@func fetchClusterInfo(fragPos)@>
+
+    // From frag world pos find the cluster
+    vec4 clusterEyePos = frustumGrid_worldToEye(<$fragPos$>);
+    ivec3 clusterPos = frustumGrid_eyeToClusterPos(clusterEyePos.xyz);
+
+    ivec3 cluster = clusterGrid_getCluster(frustumGrid_clusterToIndex(clusterPos));
+    int numLights = cluster.x + cluster.y;
+    if (numLights <= 0) {
+        discard;
+    }
+    int lightClusterOffset = cluster.z;
+
+    ivec3 dims = frustumGrid.dims.xyz;
+    if (clusterPos.x < 0 || clusterPos.x >= dims.x) {
+        discard;
+    }
+
+    if (clusterPos.y < 0 || clusterPos.y >= dims.y) {
+        discard;
+    }
+    if (clusterPos.z < 0 || clusterPos.z > dims.z) {
+        discard;
+    }
+
+<@endfunc@>
\ No newline at end of file
diff --git a/libraries/render-utils/src/local_lights_shading.slf b/libraries/render-utils/src/local_lights_shading.slf
index c6310cb079..3968ec9077 100644
--- a/libraries/render-utils/src/local_lights_shading.slf
+++ b/libraries/render-utils/src/local_lights_shading.slf
@@ -17,18 +17,7 @@
 
 <$declareDeferredCurvature()$>
 
-// Everything about light
-<@include model/Light.slh@>
-<$declareLightBuffer(256)$>
-<@include LightingModel.slh@>
-
-
-<@include LightPoint.slh@>
-<$declareLightingPoint(supportScattering)$>
-<@include LightSpot.slh@>
-<$declareLightingSpot(supportScattering)$>
-
-<@include LightClusterGrid.slh@>
+<@include LightLocal.slh@>
 
 in vec2 _texCoord0;
 out vec4 _fragColor;
@@ -51,28 +40,7 @@ void main(void) {
     mat4 invViewMat = getViewInverse();
     vec4 fragPos = invViewMat * fragPosition;
 
-    // From frag world pos find the cluster
-    vec4 clusterEyePos = frustumGrid_worldToEye(fragPos);
-    ivec3 clusterPos = frustumGrid_eyeToClusterPos(clusterEyePos.xyz);
-
-    ivec3 cluster = clusterGrid_getCluster(frustumGrid_clusterToIndex(clusterPos));
-    int numLights = cluster.x + cluster.y;
-    if (numLights <= 0) {
-        discard;
-    }
-    int lightClusterOffset = cluster.z;
-
-    ivec3 dims = frustumGrid.dims.xyz;
-    if (clusterPos.x < 0 || clusterPos.x >= dims.x) {
-        discard;
-    }
-
-    if (clusterPos.y < 0 || clusterPos.y >= dims.y) {
-        discard;
-    }
-    if (clusterPos.z < 0 || clusterPos.z > dims.z) {
-        discard;
-    }
+    <$fetchClusterInfo(fragPos)$>;
 
     vec4 midNormalCurvature;
     vec4 lowNormalCurvature;

From 6af6b5fe41839f8155a468bd69f4e5edee02e554 Mon Sep 17 00:00:00 2001
From: Olivier Prat <olivier@zvork.fr>
Date: Mon, 15 Jan 2018 12:02:29 +0100
Subject: [PATCH 2/8] evalLocalLighting function created in LightLocal.slh

---
 libraries/render-utils/src/LightLocal.slh     | 123 +++++++++++++++++-
 .../render-utils/src/local_lights_shading.slf | 114 +---------------
 2 files changed, 124 insertions(+), 113 deletions(-)

diff --git a/libraries/render-utils/src/LightLocal.slh b/libraries/render-utils/src/LightLocal.slh
index 69563d4985..dac5f74bc8 100644
--- a/libraries/render-utils/src/LightLocal.slh
+++ b/libraries/render-utils/src/LightLocal.slh
@@ -20,10 +20,10 @@
 
 <@include LightClusterGrid.slh@>
 
-<@func fetchClusterInfo(fragPos)@>
+<@func fetchClusterInfo(fragWorldPos)@>
 
     // From frag world pos find the cluster
-    vec4 clusterEyePos = frustumGrid_worldToEye(<$fragPos$>);
+    vec4 clusterEyePos = frustumGrid_worldToEye(<$fragWorldPos$>);
     ivec3 clusterPos = frustumGrid_eyeToClusterPos(clusterEyePos.xyz);
 
     ivec3 cluster = clusterGrid_getCluster(frustumGrid_clusterToIndex(clusterPos));
@@ -31,7 +31,6 @@
     if (numLights <= 0) {
         discard;
     }
-    int lightClusterOffset = cluster.z;
 
     ivec3 dims = frustumGrid.dims.xyz;
     if (clusterPos.x < 0 || clusterPos.x >= dims.x) {
@@ -45,4 +44,120 @@
         discard;
     }
 
-<@endfunc@>
\ No newline at end of file
+<@endfunc@>
+
+vec4 evalLocalLighting(ivec3 cluster, int numLights, vec3 fragWorldPos, vec3 fragNormal, vec3 fragEyeDir, 
+                       vec4 midNormalCurvature, vec4 lowNormalCurvature,
+                       float fragRoughness, float fragScattering, float fragMetallic, vec3 fragFresnel, vec3 fragAlbedo) {
+    vec4 _fragColor = vec4(0.0);
+    int lightClusterOffset = cluster.z;
+
+    // Compute the rougness into gloss2 once:
+    float fragGloss2 = pow(fragRoughness + 0.001, 4.0);
+    bool withScattering = (fragScattering * isScatteringEnabled() > 0.0);
+
+    int numLightTouching = 0;
+    for (int i = 0; i < cluster.x; i++) {
+        // Need the light now
+        int theLightIndex = clusterGrid_getClusterLightId(i, lightClusterOffset);
+        Light light = getLight(theLightIndex);
+
+        // Clip againgst the light volume and Make the Light vector going from fragment to light center in world space
+        vec4 fragLightVecLen2;
+        vec4 fragLightDirLen;
+
+        if (!lightVolume_clipFragToLightVolumePoint(light.volume, fragWorldPos.xyz, fragLightVecLen2)) {
+            continue;
+        }
+
+        // Allright we re in the light sphere volume
+        fragLightDirLen.w = length(fragLightVecLen2.xyz);
+        fragLightDirLen.xyz = fragLightVecLen2.xyz / fragLightDirLen.w;
+        if (dot(fragNormal, fragLightDirLen.xyz) < 0.0) {
+            continue;
+        }
+
+        numLightTouching++;
+
+        vec3 diffuse = vec3(1.0);
+        vec3 specular = vec3(0.1);
+
+        // Allright we re valid in the volume
+        float fragLightDistance = fragLightDirLen.w;
+        vec3 fragLightDir = fragLightDirLen.xyz;
+
+        // Eval attenuation
+        float radialAttenuation = lightIrradiance_evalLightAttenuation(light.irradiance, fragLightDistance);
+        vec3 lightEnergy = radialAttenuation * getLightIrradiance(light);
+
+        // Eval shading
+        if (withScattering) {
+            evalFragShadingScattering(diffuse, specular, fragNormal, fragLightDir, fragEyeDir, fragMetallic, fragFresnel, fragRoughness, fragAlbedo
+                ,fragScattering, midNormalCurvature, lowNormalCurvature );
+        } else {
+           evalFragShadingGloss(diffuse, specular, fragNormal, fragLightDir, fragEyeDir, fragMetallic, fragFresnel, fragGloss2, fragAlbedo);
+        }
+
+        diffuse *= lightEnergy * isDiffuseEnabled();
+        specular *= lightEnergy * isSpecularEnabled();
+
+        _fragColor.rgb += diffuse;
+        _fragColor.rgb += specular;
+    }
+
+    for (int i = cluster.x; i < numLights; i++) {
+        // Need the light now
+        int theLightIndex = clusterGrid_getClusterLightId(i, lightClusterOffset);
+        Light light = getLight(theLightIndex);
+
+        // Clip againgst the light volume and Make the Light vector going from fragment to light center in world space
+        vec4 fragLightVecLen2;
+        vec4 fragLightDirLen;
+        float cosSpotAngle;
+
+        if (!lightVolume_clipFragToLightVolumePoint(light.volume, fragWorldPos.xyz, fragLightVecLen2)) {
+            continue;
+        }
+
+        // Allright we re in the light sphere volume
+        fragLightDirLen.w = length(fragLightVecLen2.xyz);
+        fragLightDirLen.xyz = fragLightVecLen2.xyz / fragLightDirLen.w;
+        if (dot(fragNormal, fragLightDirLen.xyz) < 0.0) {
+            continue;
+        }
+
+        // Check spot
+        if (!lightVolume_clipFragToLightVolumeSpotSide(light.volume, fragLightDirLen, cosSpotAngle)) {
+            continue;
+        }
+
+        numLightTouching++;
+
+        vec3 diffuse = vec3(1.0);
+        vec3 specular = vec3(0.1);
+
+        // Allright we re valid in the volume
+        float fragLightDistance = fragLightDirLen.w;
+        vec3 fragLightDir = fragLightDirLen.xyz;
+
+        // Eval attenuation
+        float radialAttenuation = lightIrradiance_evalLightAttenuation(light.irradiance, fragLightDistance);
+        float angularAttenuation = lightIrradiance_evalLightSpotAttenuation(light.irradiance, cosSpotAngle);
+        vec3 lightEnergy = radialAttenuation * angularAttenuation * getLightIrradiance(light);
+
+        // Eval shading
+        if (withScattering) {
+            evalFragShadingScattering(diffuse, specular, fragNormal, fragLightDir, fragEyeDir, fragMetallic, fragFresnel, fragRoughness, fragAlbedo
+                ,fragScattering, midNormalCurvature, lowNormalCurvature );
+        } else {
+           evalFragShadingGloss(diffuse, specular, fragNormal, fragLightDir, fragEyeDir, fragMetallic, fragFresnel, fragGloss2, fragAlbedo);
+        }
+
+        diffuse *= lightEnergy * isDiffuseEnabled();
+        specular *= lightEnergy * isSpecularEnabled();
+
+        _fragColor.rgb += diffuse;
+        _fragColor.rgb += specular;
+    }
+    return _fragColor;
+}
\ No newline at end of file
diff --git a/libraries/render-utils/src/local_lights_shading.slf b/libraries/render-utils/src/local_lights_shading.slf
index 3968ec9077..f302c6daba 100644
--- a/libraries/render-utils/src/local_lights_shading.slf
+++ b/libraries/render-utils/src/local_lights_shading.slf
@@ -38,9 +38,9 @@ void main(void) {
 
     // Frag pos in world
     mat4 invViewMat = getViewInverse();
-    vec4 fragPos = invViewMat * fragPosition;
+    vec4 fragWorldPos = invViewMat * fragPosition;
 
-    <$fetchClusterInfo(fragPos)$>;
+    <$fetchClusterInfo(fragWorldPos)$>;
 
     vec4 midNormalCurvature;
     vec4 lowNormalCurvature;
@@ -53,113 +53,9 @@ void main(void) {
     vec4 fragEyeVector = invViewMat * vec4(-frag.position.xyz, 0.0);
     vec3 fragEyeDir = normalize(fragEyeVector.xyz);
 
-    // Compute the rougness into gloss2 once:
-    float fragGloss2 = pow(frag.roughness + 0.001, 4.0);
-    bool withScattering = (frag.scattering * isScatteringEnabled() > 0.0);
-
-    int numLightTouching = 0;
-    for (int i = 0; i < cluster.x; i++) {
-        // Need the light now
-        int theLightIndex = clusterGrid_getClusterLightId(i, lightClusterOffset);
-        Light light = getLight(theLightIndex);
-
-        // Clip againgst the light volume and Make the Light vector going from fragment to light center in world space
-        vec4 fragLightVecLen2;
-        vec4 fragLightDirLen;
-
-        if (!lightVolume_clipFragToLightVolumePoint(light.volume, fragPos.xyz, fragLightVecLen2)) {
-            continue;
-        }
-
-        // Allright we re in the light sphere volume
-        fragLightDirLen.w = length(fragLightVecLen2.xyz);
-        fragLightDirLen.xyz = fragLightVecLen2.xyz / fragLightDirLen.w;
-        if (dot(frag.normal, fragLightDirLen.xyz) < 0.0) {
-            continue;
-        }
-
-        numLightTouching++;
-
-        vec3 diffuse = vec3(1.0);
-        vec3 specular = vec3(0.1);
-
-        // Allright we re valid in the volume
-        float fragLightDistance = fragLightDirLen.w;
-        vec3 fragLightDir = fragLightDirLen.xyz;
-
-        // Eval attenuation
-        float radialAttenuation = lightIrradiance_evalLightAttenuation(light.irradiance, fragLightDistance);
-        vec3 lightEnergy = radialAttenuation * getLightIrradiance(light);
-
-        // Eval shading
-        if (withScattering) {
-            evalFragShadingScattering(diffuse, specular, frag.normal, fragLightDir, fragEyeDir, frag.metallic, frag.fresnel, frag.roughness, frag.albedo
-                ,frag.scattering, midNormalCurvature, lowNormalCurvature );
-        } else {
-           evalFragShadingGloss(diffuse, specular, frag.normal, fragLightDir, fragEyeDir, frag.metallic, frag.fresnel, fragGloss2, frag.albedo);
-        }
-
-        diffuse *= lightEnergy * isDiffuseEnabled();
-        specular *= lightEnergy * isSpecularEnabled();
-
-        _fragColor.rgb += diffuse;
-        _fragColor.rgb += specular;
-    }
-
-    for (int i = cluster.x; i < numLights; i++) {
-        // Need the light now
-        int theLightIndex = clusterGrid_getClusterLightId(i, lightClusterOffset);
-        Light light = getLight(theLightIndex);
-
-        // Clip againgst the light volume and Make the Light vector going from fragment to light center in world space
-        vec4 fragLightVecLen2;
-        vec4 fragLightDirLen;
-        float cosSpotAngle;
-
-        if (!lightVolume_clipFragToLightVolumePoint(light.volume, fragPos.xyz, fragLightVecLen2)) {
-            continue;
-        }
-
-        // Allright we re in the light sphere volume
-        fragLightDirLen.w = length(fragLightVecLen2.xyz);
-        fragLightDirLen.xyz = fragLightVecLen2.xyz / fragLightDirLen.w;
-        if (dot(frag.normal, fragLightDirLen.xyz) < 0.0) {
-            continue;
-        }
-
-        // Check spot
-        if (!lightVolume_clipFragToLightVolumeSpotSide(light.volume, fragLightDirLen, cosSpotAngle)) {
-            continue;
-        }
-
-        numLightTouching++;
-
-        vec3 diffuse = vec3(1.0);
-        vec3 specular = vec3(0.1);
-
-        // Allright we re valid in the volume
-        float fragLightDistance = fragLightDirLen.w;
-        vec3 fragLightDir = fragLightDirLen.xyz;
-
-        // Eval attenuation
-        float radialAttenuation = lightIrradiance_evalLightAttenuation(light.irradiance, fragLightDistance);
-        float angularAttenuation = lightIrradiance_evalLightSpotAttenuation(light.irradiance, cosSpotAngle);
-        vec3 lightEnergy = radialAttenuation * angularAttenuation * getLightIrradiance(light);
-
-        // Eval shading
-        if (withScattering) {
-            evalFragShadingScattering(diffuse, specular, frag.normal, fragLightDir, fragEyeDir, frag.metallic, frag.fresnel, frag.roughness, frag.albedo
-                ,frag.scattering, midNormalCurvature, lowNormalCurvature );
-        } else {
-           evalFragShadingGloss(diffuse, specular, frag.normal, fragLightDir, fragEyeDir, frag.metallic, frag.fresnel, fragGloss2, frag.albedo);
-        }
-
-        diffuse *= lightEnergy * isDiffuseEnabled();
-        specular *= lightEnergy * isSpecularEnabled();
-
-        _fragColor.rgb += diffuse;
-        _fragColor.rgb += specular;
-    }
+    _fragColor = evalLocalLighting(cluster, numLights, fragWorldPos.xyz, frag.normal, fragEyeDir, 
+                                   midNormalCurvature, lowNormalCurvature, frag.roughness, frag.scattering,
+                                   frag.metallic, frag.fresnel, frag.albedo);
 
 }
 

From a3e50689cbf27d45a705385879e4012542abc715 Mon Sep 17 00:00:00 2001
From: Olivier Prat <olivier@zvork.fr>
Date: Mon, 15 Jan 2018 12:18:22 +0100
Subject: [PATCH 3/8] Modified light outline shader to use some factorized code

---
 .../render-utils/src/LightClusterGrid.slh     | 27 +++++++++++++++++++
 libraries/render-utils/src/LightLocal.slh     | 26 ------------------
 .../src/local_lights_drawOutline.slf          | 24 ++---------------
 3 files changed, 29 insertions(+), 48 deletions(-)

diff --git a/libraries/render-utils/src/LightClusterGrid.slh b/libraries/render-utils/src/LightClusterGrid.slh
index 722d37814d..d2eb213c71 100644
--- a/libraries/render-utils/src/LightClusterGrid.slh
+++ b/libraries/render-utils/src/LightClusterGrid.slh
@@ -86,4 +86,31 @@ int clusterGrid_getClusterLightId(int index, int offset) {
     return (((elementIndex & 0x00000001) == 1) ? (element >> 16) : element) & 0x0000FFFF;
 }
 
+
+<@func fetchClusterInfo(fragWorldPos)@>
+
+    // From frag world pos find the cluster
+    vec4 clusterEyePos = frustumGrid_worldToEye(<$fragWorldPos$>);
+    ivec3 clusterPos = frustumGrid_eyeToClusterPos(clusterEyePos.xyz);
+
+    ivec3 cluster = clusterGrid_getCluster(frustumGrid_clusterToIndex(clusterPos));
+    int numLights = cluster.x + cluster.y;
+    if (numLights <= 0) {
+        discard;
+    }
+
+    ivec3 dims = frustumGrid.dims.xyz;
+    if (clusterPos.x < 0 || clusterPos.x >= dims.x) {
+        discard;
+    }
+
+    if (clusterPos.y < 0 || clusterPos.y >= dims.y) {
+        discard;
+    }
+    if (clusterPos.z < 0 || clusterPos.z > dims.z) {
+        discard;
+    }
+
+<@endfunc@>
+
 <@endif@>
diff --git a/libraries/render-utils/src/LightLocal.slh b/libraries/render-utils/src/LightLocal.slh
index dac5f74bc8..d9980b1fa6 100644
--- a/libraries/render-utils/src/LightLocal.slh
+++ b/libraries/render-utils/src/LightLocal.slh
@@ -20,32 +20,6 @@
 
 <@include LightClusterGrid.slh@>
 
-<@func fetchClusterInfo(fragWorldPos)@>
-
-    // From frag world pos find the cluster
-    vec4 clusterEyePos = frustumGrid_worldToEye(<$fragWorldPos$>);
-    ivec3 clusterPos = frustumGrid_eyeToClusterPos(clusterEyePos.xyz);
-
-    ivec3 cluster = clusterGrid_getCluster(frustumGrid_clusterToIndex(clusterPos));
-    int numLights = cluster.x + cluster.y;
-    if (numLights <= 0) {
-        discard;
-    }
-
-    ivec3 dims = frustumGrid.dims.xyz;
-    if (clusterPos.x < 0 || clusterPos.x >= dims.x) {
-        discard;
-    }
-
-    if (clusterPos.y < 0 || clusterPos.y >= dims.y) {
-        discard;
-    }
-    if (clusterPos.z < 0 || clusterPos.z > dims.z) {
-        discard;
-    }
-
-<@endfunc@>
-
 vec4 evalLocalLighting(ivec3 cluster, int numLights, vec3 fragWorldPos, vec3 fragNormal, vec3 fragEyeDir, 
                        vec4 midNormalCurvature, vec4 lowNormalCurvature,
                        float fragRoughness, float fragScattering, float fragMetallic, vec3 fragFresnel, vec3 fragAlbedo) {
diff --git a/libraries/render-utils/src/local_lights_drawOutline.slf b/libraries/render-utils/src/local_lights_drawOutline.slf
index 3aa210a241..f7527d0542 100644
--- a/libraries/render-utils/src/local_lights_drawOutline.slf
+++ b/libraries/render-utils/src/local_lights_drawOutline.slf
@@ -54,34 +54,14 @@ void main(void) {
     mat4 invViewMat = getViewInverse();
     vec4 fragPos = invViewMat * fragPosition;
     
-    // From frag world pos find the cluster
-    vec4 clusterEyePos = frustumGrid_worldToEye(fragPos);
-    ivec3 clusterPos = frustumGrid_eyeToClusterPos(clusterEyePos.xyz);
-
-    ivec3 cluster = clusterGrid_getCluster(frustumGrid_clusterToIndex(clusterPos));
-    int numLights = cluster.x + cluster.y;
-    if (numLights <= 0) {
-        discard;
-    }
-    int lightClusterOffset = cluster.z;
-
-    ivec3 dims = frustumGrid.dims.xyz;
-    if (clusterPos.x < 0 || clusterPos.x >= dims.x) {
-        discard;
-    }
-
-    if (clusterPos.y < 0 || clusterPos.y >= dims.y) {
-        discard;
-    }
-    if (clusterPos.z < 0 || clusterPos.z > dims.z) {
-        discard;
-    }
+    <$fetchClusterInfo(fragPos)$>;
 
     // Frag to eye vec
     vec4 fragEyeVector = invViewMat * vec4(-frag.position.xyz, 0.0);
     vec3 fragEyeDir = normalize(fragEyeVector.xyz);
     
     int numLightTouching = 0;
+    int lightClusterOffset = cluster.z;
     for (int i = 0; i < cluster.x; i++) {
         // Need the light now
         int theLightIndex = clusterGrid_getClusterLightId(i, lightClusterOffset);

From 54eab1c878d1e5ccb534d1d605b9808254c9b6c2 Mon Sep 17 00:00:00 2001
From: Olivier Prat <olivier@zvork.fr>
Date: Mon, 15 Jan 2018 17:49:55 +0100
Subject: [PATCH 4/8] First working local lights on transparent objects

---
 libraries/model/src/model/Light.slh           |  4 +-
 .../render-utils/src/DeferredGlobalLight.slh  |  4 +-
 .../src/DeferredLightingEffect.cpp            | 37 ++++++++++++----
 .../render-utils/src/DeferredLightingEffect.h |  3 ++
 libraries/render-utils/src/DrawHaze.cpp       |  2 +-
 .../render-utils/src/ForwardGlobalLight.slh   |  4 +-
 libraries/render-utils/src/Haze.slf           |  2 +-
 .../render-utils/src/RenderDeferredTask.cpp   | 19 +++++++-
 .../render-utils/src/RenderDeferredTask.h     |  3 +-
 .../render-utils/src/RenderPipelines.cpp      | 30 ++++++++-----
 .../render-utils/src/SubsurfaceScattering.cpp |  2 +-
 libraries/render-utils/src/ZoneRenderer.cpp   |  2 +-
 .../render-utils/src/model_translucent.slf    | 13 ++++++
 .../render-utils/src/model_translucent.slv    | 44 +++++++++++++++++++
 .../src/model_translucent_fade.slf            | 12 +++++
 libraries/render-utils/src/overlay3D.slf      |  2 +-
 .../src/overlay3D_translucent.slf             |  2 +-
 .../subsurfaceScattering_drawScattering.slf   |  4 +-
 .../render-utils/src/zone_drawKeyLight.slf    |  2 +-
 libraries/render/src/render/ShapePipeline.cpp | 20 ++++++++-
 libraries/render/src/render/ShapePipeline.h   |  9 ++++
 21 files changed, 181 insertions(+), 39 deletions(-)
 create mode 100644 libraries/render-utils/src/model_translucent.slv

diff --git a/libraries/model/src/model/Light.slh b/libraries/model/src/model/Light.slh
index 093a87adc8..a7960e473e 100644
--- a/libraries/model/src/model/Light.slh
+++ b/libraries/model/src/model/Light.slh
@@ -56,10 +56,10 @@ Light getLight(int index) {
 }
 
 <@else@>
-uniform lightBuffer {
+uniform keyLightBuffer {
     Light light;
 };
-Light getLight() {
+Light getKeyLight() {
     return light;
 }
 
diff --git a/libraries/render-utils/src/DeferredGlobalLight.slh b/libraries/render-utils/src/DeferredGlobalLight.slh
index de2d41be6b..8406e4a0c5 100644
--- a/libraries/render-utils/src/DeferredGlobalLight.slh
+++ b/libraries/render-utils/src/DeferredGlobalLight.slh
@@ -29,7 +29,7 @@
     vec3 fragEyeDir = normalize(fragEyeVector);
 
     // Get light
-    Light light = getLight();
+    Light light = getKeyLight();
     LightAmbient lightAmbient = getLightAmbient();
     
     vec3 lightDirection = getLightDirection(light);
@@ -143,7 +143,7 @@ vec3 evalSkyboxGlobalColor(mat4 invViewMat, float shadowAttenuation, float obscu
 
 <@func declareEvalLightmappedColor()@>
 vec3 evalLightmappedColor(mat4 invViewMat, float shadowAttenuation, float obscurance, vec3 normal, vec3 albedo, vec3 lightmap) {
-    Light light = getLight();
+    Light light = getKeyLight();
     LightAmbient ambient = getLightAmbient();
 
     // Catch normals perpendicular to the projection plane, hence the magic number for the threshold
diff --git a/libraries/render-utils/src/DeferredLightingEffect.cpp b/libraries/render-utils/src/DeferredLightingEffect.cpp
index 81a33f17e3..227c1ce339 100644
--- a/libraries/render-utils/src/DeferredLightingEffect.cpp
+++ b/libraries/render-utils/src/DeferredLightingEffect.cpp
@@ -42,6 +42,7 @@ using namespace render;
 
 struct LightLocations {
     int radius{ -1 };
+    int keyLightBufferUnit{ -1 };
     int lightBufferUnit{ -1 };
     int ambientBufferUnit { -1 };
     int lightIndexBufferUnit { -1 };
@@ -144,6 +145,29 @@ void DeferredLightingEffect::unsetKeyLightBatch(gpu::Batch& batch, int lightBuff
     }
 }
 
+void DeferredLightingEffect::setupLocalLightsBatch(gpu::Batch& batch,
+                                                   int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit,
+                                                   const LightClustersPointer& lightClusters) {
+    // Bind the global list of lights and the visible lights this frame
+    batch.setUniformBuffer(_localLightLocations->lightBufferUnit, lightClusters->_lightStage->getLightArrayBuffer());
+
+    batch.setUniformBuffer(frustumGridBufferUnit, lightClusters->_frustumGridBuffer);
+    batch.setUniformBuffer(clusterGridBufferUnit, lightClusters->_clusterGridBuffer);
+    batch.setUniformBuffer(clusterContentBufferUnit, lightClusters->_clusterContentBuffer);
+}
+
+void DeferredLightingEffect::unsetLocalLightsBatch(gpu::Batch& batch, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit) {
+    if (clusterGridBufferUnit >= 0) {
+        batch.setUniformBuffer(clusterGridBufferUnit, nullptr);
+    }
+    if (clusterContentBufferUnit >= 0) {
+        batch.setUniformBuffer(clusterContentBufferUnit, nullptr);
+    }
+    if (frustumGridBufferUnit >= 0) {
+        batch.setUniformBuffer(frustumGridBufferUnit, nullptr);
+    }
+}
+
 static gpu::ShaderPointer makeLightProgram(const char* vertSource, const char* fragSource, LightLocationsPtr& locations) {
     auto VS = gpu::Shader::createVertex(std::string(vertSource));
     auto PS = gpu::Shader::createPixel(std::string(fragSource));
@@ -186,6 +210,7 @@ static gpu::ShaderPointer makeLightProgram(const char* vertSource, const char* f
 
     locations->texcoordFrameTransform = program->getUniforms().findLocation("texcoordFrameTransform");
 
+    locations->keyLightBufferUnit = program->getUniformBuffers().findLocation("keyLightBuffer");
     locations->lightBufferUnit = program->getUniformBuffers().findLocation("lightBuffer");
     locations->ambientBufferUnit = program->getUniformBuffers().findLocation("lightAmbientBuffer");
     locations->lightIndexBufferUnit = program->getUniformBuffers().findLocation("lightIndexBuffer");
@@ -558,7 +583,7 @@ void RenderDeferredSetup::run(const render::RenderContextPointer& renderContext,
         batch._glUniform4fv(locations->texcoordFrameTransform, 1, reinterpret_cast< const float* >(&textureFrameTransform));
 
         // Setup the global lighting
-        deferredLightingEffect->setupKeyLightBatch(args, batch, locations->lightBufferUnit, locations->ambientBufferUnit, SKYBOX_MAP_UNIT);
+        deferredLightingEffect->setupKeyLightBatch(args, batch, locations->keyLightBufferUnit, locations->ambientBufferUnit, SKYBOX_MAP_UNIT);
 
         // Haze
         if (haze) {
@@ -567,7 +592,7 @@ void RenderDeferredSetup::run(const render::RenderContextPointer& renderContext,
 		
         batch.draw(gpu::TRIANGLE_STRIP, 4);
 
-        deferredLightingEffect->unsetKeyLightBatch(batch, locations->lightBufferUnit, locations->ambientBufferUnit, SKYBOX_MAP_UNIT);
+        deferredLightingEffect->unsetKeyLightBatch(batch, locations->keyLightBufferUnit, locations->ambientBufferUnit, SKYBOX_MAP_UNIT);
 
         for (auto i = 0; i < SHADOW_CASCADE_MAX_COUNT; i++) {
             batch.setResourceTexture(SHADOW_MAP_UNIT+i, nullptr);
@@ -622,12 +647,8 @@ void RenderDeferredLocals::run(const render::RenderContextPointer& renderContext
 
         auto& lightIndices = lightClusters->_visibleLightIndices;
         if (!lightIndices.empty() && lightIndices[0] > 0) {
-            // Bind the global list of lights and the visible lights this frame
-            batch.setUniformBuffer(deferredLightingEffect->_localLightLocations->lightBufferUnit, lightClusters->_lightStage->getLightArrayBuffer());
-
-            batch.setUniformBuffer(LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT, lightClusters->_frustumGridBuffer);
-            batch.setUniformBuffer(LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT, lightClusters->_clusterGridBuffer);
-            batch.setUniformBuffer(LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT, lightClusters->_clusterContentBuffer);
+            deferredLightingEffect->setupLocalLightsBatch(batch, LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT, LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT, LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT,
+                                                          lightClusters);
 
             // Local light pipeline
             batch.setPipeline(deferredLightingEffect->_localLight);
diff --git a/libraries/render-utils/src/DeferredLightingEffect.h b/libraries/render-utils/src/DeferredLightingEffect.h
index 212d17db12..1607cb2c85 100644
--- a/libraries/render-utils/src/DeferredLightingEffect.h
+++ b/libraries/render-utils/src/DeferredLightingEffect.h
@@ -51,6 +51,9 @@ public:
     void setupKeyLightBatch(const RenderArgs* args, gpu::Batch& batch, int lightBufferUnit, int ambientBufferUnit, int skyboxCubemapUnit);
     void unsetKeyLightBatch(gpu::Batch& batch, int lightBufferUnit, int ambientBufferUnit, int skyboxCubemapUnit);
 
+    void setupLocalLightsBatch(gpu::Batch& batch, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit, const LightClustersPointer& lightClusters);
+    void unsetLocalLightsBatch(gpu::Batch& batch, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit);
+
     void setShadowMapEnabled(bool enable) { _shadowMapEnabled = enable; };
     void setAmbientOcclusionEnabled(bool enable) { _ambientOcclusionEnabled = enable; }
     bool isAmbientOcclusionEnabled() const { return _ambientOcclusionEnabled; }
diff --git a/libraries/render-utils/src/DrawHaze.cpp b/libraries/render-utils/src/DrawHaze.cpp
index da07f5bd9b..783dadba7c 100644
--- a/libraries/render-utils/src/DrawHaze.cpp
+++ b/libraries/render-utils/src/DrawHaze.cpp
@@ -147,7 +147,7 @@ void DrawHaze::run(const render::RenderContextPointer& renderContext, const Inpu
         slotBindings.insert(gpu::Shader::Binding(std::string("deferredFrameTransformBuffer"), HazeEffect_TransformBufferSlot));
         slotBindings.insert(gpu::Shader::Binding(std::string("colorMap"), HazeEffect_ColorMapSlot));
         slotBindings.insert(gpu::Shader::Binding(std::string("linearDepthMap"), HazeEffect_LinearDepthMapSlot));
-        slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), HazeEffect_LightingMapSlot));
+        slotBindings.insert(gpu::Shader::Binding(std::string("keyLightBuffer"), HazeEffect_LightingMapSlot));
         gpu::Shader::makeProgram(*program, slotBindings);
 
         _hazePipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
diff --git a/libraries/render-utils/src/ForwardGlobalLight.slh b/libraries/render-utils/src/ForwardGlobalLight.slh
index aba0498ef5..cde37e0ba7 100644
--- a/libraries/render-utils/src/ForwardGlobalLight.slh
+++ b/libraries/render-utils/src/ForwardGlobalLight.slh
@@ -29,7 +29,7 @@
     vec3 fragEyeDir = normalize(fragEyeVector);
 
     // Get light
-    Light light = getLight();
+    Light light = getKeyLight();
     LightAmbient lightAmbient = getLightAmbient();
     
     vec3 lightDirection = getLightDirection(light);
@@ -139,7 +139,7 @@ vec3 evalSkyboxGlobalColor(mat4 invViewMat, float shadowAttenuation, float obscu
 
 <@func declareEvalLightmappedColor()@>
 vec3 evalLightmappedColor(mat4 invViewMat, float shadowAttenuation, float obscurance, vec3 normal, vec3 albedo, vec3 lightmap) {
-    Light light = getLight();
+    Light light = getKeyLight();
     LightAmbient ambient = getLightAmbient();
 
     // Catch normals perpendicular to the projection plane, hence the magic number for the threshold
diff --git a/libraries/render-utils/src/Haze.slf b/libraries/render-utils/src/Haze.slf
index 0270aa58f0..b3b1e6d979 100644
--- a/libraries/render-utils/src/Haze.slf
+++ b/libraries/render-utils/src/Haze.slf
@@ -53,7 +53,7 @@ void main(void) {
     vec4 worldFragPos = viewInverse * eyeFragPos;
     vec4 worldEyePos = viewInverse[3];
 
-    Light light = getLight();
+    Light light = getKeyLight();
     vec3 lightDirection = getLightDirection(light);
 
     outFragColor = computeHazeColor(fragColor, eyeFragPos.xyz, worldFragPos.xyz, worldEyePos.y, lightDirection);
diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp
index f860c0494e..3aa8538fbc 100644
--- a/libraries/render-utils/src/RenderDeferredTask.cpp
+++ b/libraries/render-utils/src/RenderDeferredTask.cpp
@@ -12,6 +12,8 @@
 
 #include "RenderDeferredTask.h"
 
+#include <DependencyManager.h>
+
 #include <PerfStat.h>
 #include <PathUtils.h>
 #include <ViewFrustum.h>
@@ -167,7 +169,7 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     task.addJob<DrawHaze>("DrawHazeDeferred", drawHazeInputs);
 
     // Render transparent objects forward in LightingBuffer
-    const auto transparentsInputs = DrawDeferred::Inputs(transparents, lightingModel).asVarying();
+    const auto transparentsInputs = DrawDeferred::Inputs(transparents, lightingModel, lightClusters).asVarying();
     task.addJob<DrawDeferred>("DrawTransparentDeferred", transparentsInputs, shapePlumber);
 
     // Light Cluster Grid Debuging job
@@ -314,6 +316,8 @@ void DrawDeferred::run(const RenderContextPointer& renderContext, const Inputs&
 
     const auto& inItems = inputs.get0();
     const auto& lightingModel = inputs.get1();
+    const auto& lightClusters = inputs.get2();
+    auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
 
     RenderArgs* args = renderContext->args;
 
@@ -335,7 +339,13 @@ void DrawDeferred::run(const RenderContextPointer& renderContext, const Inputs&
         // Setup lighting model for all items;
         batch.setUniformBuffer(render::ShapePipeline::Slot::LIGHTING_MODEL, lightingModel->getParametersBuffer());
 
-        // Setup haze iff curretn zone has haze
+        deferredLightingEffect->setupLocalLightsBatch(batch, 
+                                                      render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT,
+                                                      render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT,
+                                                      render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT,
+                                                      lightClusters);
+
+        // Setup haze if current zone has haze
         auto hazeStage = args->_scene->getStage<HazeStage>();
         if (hazeStage && hazeStage->_currentFrame._hazes.size() > 0) {
             model::HazePointer hazePointer = hazeStage->getHaze(hazeStage->_currentFrame._hazes.front());
@@ -355,6 +365,11 @@ void DrawDeferred::run(const RenderContextPointer& renderContext, const Inputs&
 
         args->_batch = nullptr;
         args->_globalShapeKey = 0;
+
+        deferredLightingEffect->unsetLocalLightsBatch(batch,
+                                                      render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT,
+                                                      render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT,
+                                                      render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT);
     });
 
     config->setNumDrawn((int)inItems.size());
diff --git a/libraries/render-utils/src/RenderDeferredTask.h b/libraries/render-utils/src/RenderDeferredTask.h
index e41b7edc77..7e439a547f 100644
--- a/libraries/render-utils/src/RenderDeferredTask.h
+++ b/libraries/render-utils/src/RenderDeferredTask.h
@@ -15,6 +15,7 @@
 #include <gpu/Pipeline.h>
 #include <render/RenderFetchCullSortTask.h>
 #include "LightingModel.h"
+#include "LightClusters.h"
 
 class BeginGPURangeTimer {
 public:
@@ -65,7 +66,7 @@ protected:
 
 class DrawDeferred {
 public:
-    using Inputs = render::VaryingSet2 <render::ItemBounds, LightingModelPointer>;
+    using Inputs = render::VaryingSet3 <render::ItemBounds, LightingModelPointer, LightClustersPointer>;
     using Config = DrawConfig;
     using JobModel = render::Job::ModelI<DrawDeferred, Inputs, Config>;
 
diff --git a/libraries/render-utils/src/RenderPipelines.cpp b/libraries/render-utils/src/RenderPipelines.cpp
index 7f644add72..668d524018 100644
--- a/libraries/render-utils/src/RenderPipelines.cpp
+++ b/libraries/render-utils/src/RenderPipelines.cpp
@@ -29,6 +29,7 @@
 
 #include "model_lightmap_fade_vert.h"
 #include "model_lightmap_normal_map_fade_vert.h"
+#include "model_translucent_vert.h"
 #include "skin_model_fade_vert.h"
 #include "skin_model_normal_map_fade_vert.h"
 
@@ -188,6 +189,7 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
     auto modelNormalMapVertex = gpu::Shader::createVertex(std::string(model_normal_map_vert));
     auto modelLightmapVertex = gpu::Shader::createVertex(std::string(model_lightmap_vert));
     auto modelLightmapNormalMapVertex = gpu::Shader::createVertex(std::string(model_lightmap_normal_map_vert));
+    auto modelTranslucentVertex = gpu::Shader::createVertex(std::string(model_translucent_vert));
     auto modelShadowVertex = gpu::Shader::createVertex(std::string(model_shadow_vert));
     auto skinModelVertex = gpu::Shader::createVertex(std::string(skin_model_vert));
     auto skinModelNormalMapVertex = gpu::Shader::createVertex(std::string(skin_model_normal_map_vert));
@@ -196,9 +198,13 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
     auto modelLightmapNormalMapFadeVertex = gpu::Shader::createVertex(std::string(model_lightmap_normal_map_fade_vert));
     auto skinModelFadeVertex = gpu::Shader::createVertex(std::string(skin_model_fade_vert));
     auto skinModelNormalMapFadeVertex = gpu::Shader::createVertex(std::string(skin_model_normal_map_fade_vert));
+    auto skinModelTranslucentVertex = skinModelFadeVertex;  // We use the same because it ouputs world position per vertex
+    auto skinModelNormalMapTranslucentVertex = skinModelNormalMapFadeVertex;  // We use the same because it ouputs world position per vertex
 
     auto modelFadeVertex = gpu::Shader::createVertex(std::string(model_fade_vert));
+    auto modelTranslucentFadeVertex = modelTranslucentVertex; // We use the same because it ouputs world position per vertex
     auto modelNormalMapFadeVertex = gpu::Shader::createVertex(std::string(model_normal_map_fade_vert));
+    auto modelNormalMapTranslucentVertex = modelNormalMapFadeVertex;  // We use the same because it ouputs world position per vertex
     auto simpleFadeVertex = gpu::Shader::createVertex(std::string(simple_fade_vert));
     auto modelShadowFadeVertex = gpu::Shader::createVertex(std::string(model_shadow_fade_vert));
     auto skinModelShadowFadeVertex = gpu::Shader::createVertex(std::string(skin_model_shadow_fade_vert));
@@ -289,7 +295,7 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
     // Translucents
     addPipeline(
         Key::Builder().withMaterial().withTranslucent(),
-        modelVertex, modelTranslucentPixel, nullptr, nullptr);
+        modelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withTranslucent(),
         simpleVertex, simpleTranslucentPixel, nullptr, nullptr);
@@ -301,21 +307,21 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
         simpleVertex, simpleTranslucentUnlitPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withTangents(),
-        modelNormalMapVertex, modelTranslucentPixel, nullptr, nullptr);
+        modelNormalMapTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withSpecular(),
-        modelVertex, modelTranslucentPixel, nullptr, nullptr);
+        modelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withTangents().withSpecular(),
-        modelNormalMapVertex, modelTranslucentPixel, nullptr, nullptr);
+        modelNormalMapTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         // FIXME: Ignore lightmap for translucents meshpart
         Key::Builder().withMaterial().withTranslucent().withLightmap(),
-        modelVertex, modelTranslucentPixel, nullptr, nullptr);
+        modelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     // Same thing but with Fade on
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withFade(),
-        modelFadeVertex, modelTranslucentFadePixel, batchSetter, itemSetter);
+        modelTranslucentFadeVertex, modelTranslucentFadePixel, batchSetter, itemSetter);
     addPipeline(
         Key::Builder().withTranslucent().withFade(),
         simpleFadeVertex, simpleTranslucentFadePixel, batchSetter, itemSetter);
@@ -396,16 +402,16 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
     // Skinned and Translucent
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent(),
-        skinModelVertex, modelTranslucentPixel, nullptr, nullptr);
+        skinModelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withTangents(),
-        skinModelNormalMapVertex, modelTranslucentPixel, nullptr, nullptr);
+        skinModelNormalMapTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withSpecular(),
-        skinModelVertex, modelTranslucentPixel, nullptr, nullptr);
+        skinModelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withTangents().withSpecular(),
-        skinModelNormalMapVertex, modelTranslucentPixel, nullptr, nullptr);
+        skinModelNormalMapTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     // Same thing but with Fade on
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withFade(),
@@ -565,9 +571,9 @@ void lightBatchSetter(const ShapePipeline& pipeline, gpu::Batch& batch, RenderAr
     batchSetter(pipeline, batch, args);
 
     // Set the light
-    if (pipeline.locations->lightBufferUnit >= 0) {
+    if (pipeline.locations->keyLightBufferUnit >= 0) {
         DependencyManager::get<DeferredLightingEffect>()->setupKeyLightBatch(args, batch,
-            pipeline.locations->lightBufferUnit,
+            pipeline.locations->keyLightBufferUnit,
             pipeline.locations->lightAmbientBufferUnit,
             pipeline.locations->lightAmbientMapUnit);
     }
diff --git a/libraries/render-utils/src/SubsurfaceScattering.cpp b/libraries/render-utils/src/SubsurfaceScattering.cpp
index 1786898e57..2183f95565 100644
--- a/libraries/render-utils/src/SubsurfaceScattering.cpp
+++ b/libraries/render-utils/src/SubsurfaceScattering.cpp
@@ -463,7 +463,7 @@ gpu::PipelinePointer DebugSubsurfaceScattering::getScatteringPipeline() {
         gpu::Shader::BindingSet slotBindings;
         slotBindings.insert(gpu::Shader::Binding(std::string("deferredFrameTransformBuffer"), ScatteringTask_FrameTransformSlot));
         slotBindings.insert(gpu::Shader::Binding(std::string("scatteringParamsBuffer"), ScatteringTask_ParamSlot));
-        slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), ScatteringTask_LightSlot));
+        slotBindings.insert(gpu::Shader::Binding(std::string("keyLightBuffer"), ScatteringTask_LightSlot));
 
         slotBindings.insert(gpu::Shader::Binding(std::string("scatteringLUT"), ScatteringTask_ScatteringTableSlot));
         slotBindings.insert(gpu::Shader::Binding(std::string("curvatureMap"), ScatteringTask_CurvatureMapSlot));
diff --git a/libraries/render-utils/src/ZoneRenderer.cpp b/libraries/render-utils/src/ZoneRenderer.cpp
index c0d01c2eaf..ce2957dc9f 100644
--- a/libraries/render-utils/src/ZoneRenderer.cpp
+++ b/libraries/render-utils/src/ZoneRenderer.cpp
@@ -83,7 +83,7 @@ const gpu::PipelinePointer& DebugZoneLighting::getKeyLightPipeline() {
 
         gpu::Shader::BindingSet slotBindings;
         slotBindings.insert(gpu::Shader::Binding(std::string("deferredFrameTransformBuffer"), ZONE_DEFERRED_TRANSFORM_BUFFER));
-        slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), ZONE_KEYLIGHT_BUFFER));
+        slotBindings.insert(gpu::Shader::Binding(std::string("keyLightBuffer"), ZONE_KEYLIGHT_BUFFER));
 
         gpu::Shader::makeProgram(*program, slotBindings);
 
diff --git a/libraries/render-utils/src/model_translucent.slf b/libraries/render-utils/src/model_translucent.slf
index 38f162fdc3..5f61aea889 100644
--- a/libraries/render-utils/src/model_translucent.slf
+++ b/libraries/render-utils/src/model_translucent.slf
@@ -18,6 +18,8 @@
 
 <$declareEvalGlobalLightingAlphaBlended()$>
 
+<@include LightLocal.slh@>
+
 <@include gpu/Transform.slh@>
 <$declareStandardCameraTransform()$>
 
@@ -27,6 +29,7 @@
 in vec2 _texCoord0;
 in vec2 _texCoord1;
 in vec4 _position;
+in vec4 _worldPosition;
 in vec3 _normal;
 in vec3 _color;
 in float _alpha;
@@ -66,6 +69,16 @@ void main(void) {
 
     TransformCamera cam = getTransformCamera();
 
+    <$fetchClusterInfo(_worldPosition)$>;
+
+    vec3 fragEyeVector = vec3(cam._viewInverse * vec4(-fragPosition, 0.0));
+    vec3 fragEyeDir = normalize(fragEyeVector);
+
+    vec4 localLighting = evalLocalLighting(cluster, numLights, _worldPosition.xyz, fragNormal, fragEyeDir, 
+                                   vec4(0), vec4(0), roughness, 0.0,
+                                   metallic, fresnel, albedo);
+    emissive += localLighting.rgb;
+
     _fragColor =  vec4(evalGlobalLightingAlphaBlendedWithHaze(
         cam._viewInverse,
         1.0,
diff --git a/libraries/render-utils/src/model_translucent.slv b/libraries/render-utils/src/model_translucent.slv
new file mode 100644
index 0000000000..2fe4c511f0
--- /dev/null
+++ b/libraries/render-utils/src/model_translucent.slv
@@ -0,0 +1,44 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//  model_translucent.slv
+//  vertex shader
+//
+//  Created by Olivier Prat on 15/01/18.
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+<@include gpu/Inputs.slh@>
+<@include gpu/Color.slh@>
+<@include gpu/Transform.slh@>
+<$declareStandardTransform()$>
+
+<@include MaterialTextures.slh@>
+<$declareMaterialTexMapArrayBuffer()$>
+
+out float _alpha;
+out vec2 _texCoord0;
+out vec2 _texCoord1;
+out vec4 _position;
+out vec4 _worldPosition;
+out vec3 _normal;
+out vec3 _color;
+
+void main(void) {
+    _color = colorToLinearRGB(inColor.xyz);
+    _alpha = inColor.w;
+
+    TexMapArray texMapArray = getTexMapArray();
+    <$evalTexMapArrayTexcoord0(texMapArray, inTexCoord0, _texCoord0)$>
+    <$evalTexMapArrayTexcoord1(texMapArray, inTexCoord0, _texCoord1)$>
+
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    TransformObject obj = getTransformObject();
+    <$transformModelToEyeAndClipPos(cam, obj, inPosition, _position, gl_Position)$>
+    <$transformModelToWorldPos(obj, inPosition, _worldPosition)$>
+    <$transformModelToEyeDir(cam, obj, inNormal.xyz, _normal)$>
+}
diff --git a/libraries/render-utils/src/model_translucent_fade.slf b/libraries/render-utils/src/model_translucent_fade.slf
index 9d5477304c..e07730a07e 100644
--- a/libraries/render-utils/src/model_translucent_fade.slf
+++ b/libraries/render-utils/src/model_translucent_fade.slf
@@ -18,6 +18,8 @@
 
 <$declareEvalGlobalLightingAlphaBlended()$>
 
+<@include LightLocal.slh@>
+
 <@include gpu/Transform.slh@>
 <$declareStandardCameraTransform()$>
 
@@ -76,6 +78,16 @@ void main(void) {
 
     TransformCamera cam = getTransformCamera();
 
+    <$fetchClusterInfo(_worldPosition)$>;
+
+    vec3 fragEyeVector = vec3(cam._viewInverse * vec4(-fragPosition, 0.0));
+    vec3 fragEyeDir = normalize(fragEyeVector);
+
+    vec4 localLighting = evalLocalLighting(cluster, numLights, _worldPosition.xyz, fragNormal, fragEyeDir, 
+                                   vec4(0), vec4(0), roughness, 0.0,
+                                   metallic, fresnel, albedo);
+    emissive += localLighting.rgb;
+
     _fragColor =  vec4(evalGlobalLightingAlphaBlendedWithHaze(
         cam._viewInverse,
         1.0,
diff --git a/libraries/render-utils/src/overlay3D.slf b/libraries/render-utils/src/overlay3D.slf
index 0cb3340845..683e1420bc 100644
--- a/libraries/render-utils/src/overlay3D.slf
+++ b/libraries/render-utils/src/overlay3D.slf
@@ -27,7 +27,7 @@
 vec4 evalGlobalColor(float shadowAttenuation, vec3 position, vec3 normal, vec3 albedo, float metallic, vec3 fresnel, float roughness, float opacity) {
 
     // Need the light now
-    Light light = getLight();
+    Light light = getKeyLight();
     vec3 lightDirection = getLightDirection(light);
     vec3 lightIrradiance = getLightIrradiance(light);
 
diff --git a/libraries/render-utils/src/overlay3D_translucent.slf b/libraries/render-utils/src/overlay3D_translucent.slf
index 9bdac2d21f..c39d4b0c3b 100644
--- a/libraries/render-utils/src/overlay3D_translucent.slf
+++ b/libraries/render-utils/src/overlay3D_translucent.slf
@@ -27,7 +27,7 @@
 vec4 evalGlobalColor(float shadowAttenuation, vec3 position, vec3 normal, vec3 albedo, float metallic, vec3 fresnel, float roughness, float opacity) {
 
     // Need the light now
-    Light light = getLight();
+    Light light = getKeyLight();
     vec3 lightDirection = getLightDirection(light);
     vec3 lightIrradiance = getLightIrradiance(light);
 
diff --git a/libraries/render-utils/src/subsurfaceScattering_drawScattering.slf b/libraries/render-utils/src/subsurfaceScattering_drawScattering.slf
index 981993615c..6f52e02040 100644
--- a/libraries/render-utils/src/subsurfaceScattering_drawScattering.slf
+++ b/libraries/render-utils/src/subsurfaceScattering_drawScattering.slf
@@ -42,7 +42,7 @@ vec3 evalScatteringBRDF(vec2 texcoord) {
     vec3 fragNormal = vec3((normal));
 
     // Get light
-    Light light = getLight();
+    Light light = getKeyLight();
     vec3 fresnel = vec3(0.028); // Default Di-electric fresnel value for skin
     float metallic = 0.0;
 
@@ -65,7 +65,7 @@ vec3 drawScatteringTableUV(vec2 cursor, vec2 texcoord) {
     float curvature = unpackCurvature(diffusedCurvature.w);
 
     // Get light
-    Light light = getLight();
+    Light light = getKeyLight();
     vec3 fresnel = vec3(0.028); // Default Di-electric fresnel value for skin
 
     vec3 fragLightDir = -normalize(getLightDirection(light));
diff --git a/libraries/render-utils/src/zone_drawKeyLight.slf b/libraries/render-utils/src/zone_drawKeyLight.slf
index e96239b6dc..f7caf9b44a 100644
--- a/libraries/render-utils/src/zone_drawKeyLight.slf
+++ b/libraries/render-utils/src/zone_drawKeyLight.slf
@@ -25,7 +25,7 @@ void main(void) {
 
     <$evalGlobeWidget()$>
 
-    Light light = getLight();
+    Light light = getKeyLight();
     vec3 lightDirection = normalize(getLightDirection(light));
     vec3 lightIrradiance = getLightIrradiance(light);
     vec3 color = vec3(0.0);
diff --git a/libraries/render/src/render/ShapePipeline.cpp b/libraries/render/src/render/ShapePipeline.cpp
index 4254280fa1..27fe6604ff 100644
--- a/libraries/render/src/render/ShapePipeline.cpp
+++ b/libraries/render/src/render/ShapePipeline.cpp
@@ -70,6 +70,8 @@ void ShapePlumber::addPipeline(const Key& key, const gpu::ShaderPointer& program
 
 void ShapePlumber::addPipeline(const Filter& filter, const gpu::ShaderPointer& program, const gpu::StatePointer& state,
         BatchSetter batchSetter, ItemSetter itemSetter) {
+    ShapeKey key{ filter._flags };
+
     gpu::Shader::BindingSet slotBindings;
     slotBindings.insert(gpu::Shader::Binding(std::string("lightingModelBuffer"), Slot::BUFFER::LIGHTING_MODEL));
     slotBindings.insert(gpu::Shader::Binding(std::string("skinClusterBuffer"), Slot::BUFFER::SKINNING));
@@ -82,6 +84,7 @@ void ShapePlumber::addPipeline(const Filter& filter, const gpu::ShaderPointer& p
     slotBindings.insert(gpu::Shader::Binding(std::string("emissiveMap"), Slot::MAP::EMISSIVE_LIGHTMAP));
     slotBindings.insert(gpu::Shader::Binding(std::string("occlusionMap"), Slot::MAP::OCCLUSION));
     slotBindings.insert(gpu::Shader::Binding(std::string("scatteringMap"), Slot::MAP::SCATTERING));
+    slotBindings.insert(gpu::Shader::Binding(std::string("keyLightBuffer"), Slot::BUFFER::KEY_LIGHT));
     slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), Slot::BUFFER::LIGHT));
     slotBindings.insert(gpu::Shader::Binding(std::string("lightAmbientBuffer"), Slot::BUFFER::LIGHT_AMBIENT_BUFFER));
     slotBindings.insert(gpu::Shader::Binding(std::string("skyboxMap"), Slot::MAP::LIGHT_AMBIENT));
@@ -89,6 +92,12 @@ void ShapePlumber::addPipeline(const Filter& filter, const gpu::ShaderPointer& p
     slotBindings.insert(gpu::Shader::Binding(std::string("fadeParametersBuffer"), Slot::BUFFER::FADE_PARAMETERS));
     slotBindings.insert(gpu::Shader::Binding(std::string("hazeParametersBuffer"), Slot::BUFFER::HAZE_MODEL));
 
+    if (key.isTranslucent()) {
+        slotBindings.insert(gpu::Shader::Binding(std::string("clusterGridBuffer"), Slot::BUFFER::LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT));
+        slotBindings.insert(gpu::Shader::Binding(std::string("clusterContentBuffer"), Slot::BUFFER::LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT));
+        slotBindings.insert(gpu::Shader::Binding(std::string("frustumGridBuffer"), Slot::BUFFER::LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT));
+    }
+
     gpu::Shader::makeProgram(*program, slotBindings);
 
     auto locations = std::make_shared<Locations>();
@@ -103,14 +112,23 @@ void ShapePlumber::addPipeline(const Filter& filter, const gpu::ShaderPointer& p
     locations->skinClusterBufferUnit = program->getUniformBuffers().findLocation("skinClusterBuffer");
     locations->materialBufferUnit = program->getUniformBuffers().findLocation("materialBuffer");
     locations->texMapArrayBufferUnit = program->getUniformBuffers().findLocation("texMapArrayBuffer");
+    locations->keyLightBufferUnit = program->getUniformBuffers().findLocation("keyLightBuffer");
     locations->lightBufferUnit = program->getUniformBuffers().findLocation("lightBuffer");
     locations->lightAmbientBufferUnit = program->getUniformBuffers().findLocation("lightAmbientBuffer");
     locations->lightAmbientMapUnit = program->getTextures().findLocation("skyboxMap");
     locations->fadeMaskTextureUnit = program->getTextures().findLocation("fadeMaskMap");
     locations->fadeParameterBufferUnit = program->getUniformBuffers().findLocation("fadeParametersBuffer");
     locations->hazeParameterBufferUnit = program->getUniformBuffers().findLocation("hazeParametersBuffer");
+    if (key.isTranslucent()) {
+        locations->lightClusterGridBufferUnit = program->getUniformBuffers().findLocation("clusterGridBuffer");
+        locations->lightClusterContentBufferUnit = program->getUniformBuffers().findLocation("clusterContentBuffer");
+        locations->lightClusterFrustumBufferUnit = program->getUniformBuffers().findLocation("frustumGridBuffer");
+    } else {
+        locations->lightClusterGridBufferUnit = -1;
+        locations->lightClusterContentBufferUnit = -1;
+        locations->lightClusterFrustumBufferUnit = -1;
+    }
 
-    ShapeKey key{filter._flags};
     auto gpuPipeline = gpu::Pipeline::create(program, state);
     auto shapePipeline = std::make_shared<Pipeline>(gpuPipeline, locations, batchSetter, itemSetter);
     addPipelineHelper(filter, key, 0, shapePipeline);
diff --git a/libraries/render/src/render/ShapePipeline.h b/libraries/render/src/render/ShapePipeline.h
index be77e2f95e..c84f7efba5 100644
--- a/libraries/render/src/render/ShapePipeline.h
+++ b/libraries/render/src/render/ShapePipeline.h
@@ -235,10 +235,15 @@ public:
             MATERIAL,
             TEXMAPARRAY,
             LIGHTING_MODEL,
+            KEY_LIGHT,
             LIGHT,
             LIGHT_AMBIENT_BUFFER,
             HAZE_MODEL,
             FADE_PARAMETERS,
+            LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT,
+            LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT,
+            LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT,
+
         };
 
         enum MAP {
@@ -266,12 +271,16 @@ public:
         int skinClusterBufferUnit;
         int materialBufferUnit;
         int texMapArrayBufferUnit;
+        int keyLightBufferUnit;
         int lightBufferUnit;
         int lightAmbientBufferUnit;
         int lightAmbientMapUnit;
         int fadeMaskTextureUnit;
         int fadeParameterBufferUnit;
         int hazeParameterBufferUnit;
+        int lightClusterGridBufferUnit;
+        int lightClusterContentBufferUnit;
+        int lightClusterFrustumBufferUnit;
     };
     using LocationsPointer = std::shared_ptr<Locations>;
 

From 32445a566017b9c59cf499e6cda2e67b25a08bb8 Mon Sep 17 00:00:00 2001
From: Olivier Prat <olivier@zvork.fr>
Date: Mon, 15 Jan 2018 18:18:13 +0100
Subject: [PATCH 5/8] Updated pipelines

---
 .../render-utils/src/RenderPipelines.cpp      |  8 ++--
 .../src/model_translucent_fade.slv            | 44 +++++++++++++++++++
 2 files changed, 48 insertions(+), 4 deletions(-)
 create mode 100644 libraries/render-utils/src/model_translucent_fade.slv

diff --git a/libraries/render-utils/src/RenderPipelines.cpp b/libraries/render-utils/src/RenderPipelines.cpp
index 668d524018..e9b1b59016 100644
--- a/libraries/render-utils/src/RenderPipelines.cpp
+++ b/libraries/render-utils/src/RenderPipelines.cpp
@@ -30,6 +30,7 @@
 #include "model_lightmap_fade_vert.h"
 #include "model_lightmap_normal_map_fade_vert.h"
 #include "model_translucent_vert.h"
+#include "model_translucent_fade_vert.h"
 #include "skin_model_fade_vert.h"
 #include "skin_model_normal_map_fade_vert.h"
 
@@ -190,6 +191,7 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
     auto modelLightmapVertex = gpu::Shader::createVertex(std::string(model_lightmap_vert));
     auto modelLightmapNormalMapVertex = gpu::Shader::createVertex(std::string(model_lightmap_normal_map_vert));
     auto modelTranslucentVertex = gpu::Shader::createVertex(std::string(model_translucent_vert));
+    auto modelTranslucentFadeVertex = gpu::Shader::createVertex(std::string(model_translucent_fade_vert));
     auto modelShadowVertex = gpu::Shader::createVertex(std::string(model_shadow_vert));
     auto skinModelVertex = gpu::Shader::createVertex(std::string(skin_model_vert));
     auto skinModelNormalMapVertex = gpu::Shader::createVertex(std::string(skin_model_normal_map_vert));
@@ -202,9 +204,7 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
     auto skinModelNormalMapTranslucentVertex = skinModelNormalMapFadeVertex;  // We use the same because it ouputs world position per vertex
 
     auto modelFadeVertex = gpu::Shader::createVertex(std::string(model_fade_vert));
-    auto modelTranslucentFadeVertex = modelTranslucentVertex; // We use the same because it ouputs world position per vertex
     auto modelNormalMapFadeVertex = gpu::Shader::createVertex(std::string(model_normal_map_fade_vert));
-    auto modelNormalMapTranslucentVertex = modelNormalMapFadeVertex;  // We use the same because it ouputs world position per vertex
     auto simpleFadeVertex = gpu::Shader::createVertex(std::string(simple_fade_vert));
     auto modelShadowFadeVertex = gpu::Shader::createVertex(std::string(model_shadow_fade_vert));
     auto skinModelShadowFadeVertex = gpu::Shader::createVertex(std::string(skin_model_shadow_fade_vert));
@@ -307,13 +307,13 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
         simpleVertex, simpleTranslucentUnlitPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withTangents(),
-        modelNormalMapTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
+        modelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withSpecular(),
         modelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withTangents().withSpecular(),
-        modelNormalMapTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
+        modelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         // FIXME: Ignore lightmap for translucents meshpart
         Key::Builder().withMaterial().withTranslucent().withLightmap(),
diff --git a/libraries/render-utils/src/model_translucent_fade.slv b/libraries/render-utils/src/model_translucent_fade.slv
new file mode 100644
index 0000000000..eaabdd27e8
--- /dev/null
+++ b/libraries/render-utils/src/model_translucent_fade.slv
@@ -0,0 +1,44 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//  model_translucent_fade.slv
+//  vertex shader
+//
+//  Created by Olivier Prat on 15/01/18.
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+<@include gpu/Inputs.slh@>
+<@include gpu/Color.slh@>
+<@include gpu/Transform.slh@>
+<$declareStandardTransform()$>
+
+<@include MaterialTextures.slh@>
+<$declareMaterialTexMapArrayBuffer()$>
+
+out float _alpha;
+out vec2 _texCoord0;
+out vec2 _texCoord1;
+out vec4 _position;
+out vec4 _worldPosition;
+out vec3 _normal;
+out vec3 _color;
+
+void main(void) {
+    _color = colorToLinearRGB(inColor.xyz);
+    _alpha = inColor.w;
+
+    TexMapArray texMapArray = getTexMapArray();
+    <$evalTexMapArrayTexcoord0(texMapArray, inTexCoord0, _texCoord0)$>
+    <$evalTexMapArrayTexcoord1(texMapArray, inTexCoord0, _texCoord1)$>
+
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    TransformObject obj = getTransformObject();
+    <$transformModelToEyeAndClipPos(cam, obj, inPosition, _position, gl_Position)$>
+    <$transformModelToWorldPos(obj, inPosition, _worldPosition)$>
+    <$transformModelToEyeDir(cam, obj, inNormal.xyz, _normal)$>
+}

From 3382a35c3fff97c3897b4e39eff413eb6abff96a Mon Sep 17 00:00:00 2001
From: Olivier Prat <olivier@zvork.fr>
Date: Tue, 16 Jan 2018 12:13:45 +0100
Subject: [PATCH 6/8] Fixed bug due to incorrect discard of fragments with no
 local lights

---
 .../render-utils/src/DeferredGlobalLight.slh  | 15 +++++---
 .../render-utils/src/LightClusterGrid.slh     | 38 ++++++++++++-------
 libraries/render-utils/src/LightLocal.slh     | 31 +++++++++------
 .../src/local_lights_drawOutline.slf          |  3 ++
 .../render-utils/src/local_lights_shading.slf |  5 ++-
 .../render-utils/src/model_translucent.slf    | 17 +++++----
 .../src/model_translucent_fade.slf            | 17 +++++----
 .../src/overlay3D_model_translucent.slf       |  2 +-
 .../src/simple_transparent_textured.slf       |  2 +-
 .../src/simple_transparent_textured_fade.slf  |  2 +-
 10 files changed, 81 insertions(+), 51 deletions(-)

diff --git a/libraries/render-utils/src/DeferredGlobalLight.slh b/libraries/render-utils/src/DeferredGlobalLight.slh
index 8406e4a0c5..02ab97b825 100644
--- a/libraries/render-utils/src/DeferredGlobalLight.slh
+++ b/libraries/render-utils/src/DeferredGlobalLight.slh
@@ -171,9 +171,11 @@ vec3 evalLightmappedColor(mat4 invViewMat, float shadowAttenuation, float obscur
 <$declareLightingAmbient(1, 1, 1)$>
 <$declareLightingDirectional()$>
 
-vec3 evalGlobalLightingAlphaBlended(mat4 invViewMat, float shadowAttenuation, float obscurance, vec3 position, vec3 normal, vec3 albedo, vec3 fresnel, float metallic, vec3 emissive, float roughness, float opacity) {
+vec3 evalGlobalLightingAlphaBlended(mat4 invViewMat, float shadowAttenuation, float obscurance, vec3 position, vec3 normal, vec3 albedo, vec3 fresnel, float metallic, vec3 emissive, float roughness, float opacity, vec3 prevLighting) {
     <$prepareGlobalLight()$>
     
+    color = prevLighting;
+
     color += emissive * isEmissiveEnabled();
 
     // Ambient
@@ -195,25 +197,26 @@ vec3 evalGlobalLightingAlphaBlended(mat4 invViewMat, float shadowAttenuation, fl
 
 vec3 evalGlobalLightingAlphaBlendedWithHaze(
     mat4 invViewMat, float shadowAttenuation, float obscurance, vec3 position, vec3 normal, 
-    vec3 albedo, vec3 fresnel, float metallic, vec3 emissive, float roughness, float opacity) 
+    vec3 albedo, vec3 fresnel, float metallic, vec3 emissive, float roughness, float opacity, vec3 prevLighting) 
 {
     <$prepareGlobalLight()$>
     
+    color = prevLighting;
+
     color += emissive * isEmissiveEnabled();
 
     // Ambient
     vec3 ambientDiffuse;
     vec3 ambientSpecular;
     evalLightingAmbient(ambientDiffuse, ambientSpecular, lightAmbient, fragEyeDir, fragNormal, roughness, metallic, fresnel, albedo, obscurance);
-    color += ambientDiffuse;
-    color += ambientSpecular / opacity;
 
     // Directional
     vec3 directionalDiffuse;
     vec3 directionalSpecular;
     evalLightingDirectional(directionalDiffuse, directionalSpecular, lightDirection, lightIrradiance, fragEyeDir, fragNormal, roughness, metallic, fresnel, albedo, shadowAttenuation);
-    color += directionalDiffuse;
-    color += directionalSpecular / opacity;
+
+    color += ambientDiffuse + directionalDiffuse;
+    color += (ambientSpecular + directionalSpecular) / opacity;
 
     // Haze
     if ((hazeParams.hazeMode & HAZE_MODE_IS_ACTIVE) == HAZE_MODE_IS_ACTIVE) {
diff --git a/libraries/render-utils/src/LightClusterGrid.slh b/libraries/render-utils/src/LightClusterGrid.slh
index d2eb213c71..60daa520a3 100644
--- a/libraries/render-utils/src/LightClusterGrid.slh
+++ b/libraries/render-utils/src/LightClusterGrid.slh
@@ -95,22 +95,32 @@ int clusterGrid_getClusterLightId(int index, int offset) {
 
     ivec3 cluster = clusterGrid_getCluster(frustumGrid_clusterToIndex(clusterPos));
     int numLights = cluster.x + cluster.y;
-    if (numLights <= 0) {
-        discard;
-    }
-
     ivec3 dims = frustumGrid.dims.xyz;
-    if (clusterPos.x < 0 || clusterPos.x >= dims.x) {
-        discard;
-    }
-
-    if (clusterPos.y < 0 || clusterPos.y >= dims.y) {
-        discard;
-    }
-    if (clusterPos.z < 0 || clusterPos.z > dims.z) {
-        discard;
-    }
 
 <@endfunc@>
 
+bool hasLocalLights(int numLights, ivec3 clusterPos, ivec3 dims) {
+/*
+    if (numLights <= 0) {
+        return false;
+    }
+
+    if (clusterPos.x < 0 || clusterPos.x >= dims.x) {
+        return false;
+    }
+
+    if (clusterPos.y < 0 || clusterPos.y >= dims.y) {
+        return false;
+    }
+    if (clusterPos.z < 0 || clusterPos.z > dims.z) {
+        return false;
+    }
+    return true;
+*/
+    return numLights>0 
+        && all(greaterThanEqual(clusterPos, ivec3(0))) 
+        && all(lessThan(clusterPos.xy, dims.xy))
+        && clusterPos.z <= dims.z;
+}
+
 <@endif@>
diff --git a/libraries/render-utils/src/LightLocal.slh b/libraries/render-utils/src/LightLocal.slh
index d9980b1fa6..895955269d 100644
--- a/libraries/render-utils/src/LightLocal.slh
+++ b/libraries/render-utils/src/LightLocal.slh
@@ -22,8 +22,11 @@
 
 vec4 evalLocalLighting(ivec3 cluster, int numLights, vec3 fragWorldPos, vec3 fragNormal, vec3 fragEyeDir, 
                        vec4 midNormalCurvature, vec4 lowNormalCurvature,
-                       float fragRoughness, float fragScattering, float fragMetallic, vec3 fragFresnel, vec3 fragAlbedo) {
-    vec4 _fragColor = vec4(0.0);
+                       float fragRoughness, float fragScattering, float fragMetallic, vec3 fragFresnel, vec3 fragAlbedo,
+                       float opacity) {
+    vec4 fragColor = vec4(0.0);
+    vec3 fragSpecular = vec3(0.0);
+    vec3 fragDiffuse = vec3(0.0);
     int lightClusterOffset = cluster.z;
 
     // Compute the rougness into gloss2 once:
@@ -72,11 +75,11 @@ vec4 evalLocalLighting(ivec3 cluster, int numLights, vec3 fragWorldPos, vec3 fra
            evalFragShadingGloss(diffuse, specular, fragNormal, fragLightDir, fragEyeDir, fragMetallic, fragFresnel, fragGloss2, fragAlbedo);
         }
 
-        diffuse *= lightEnergy * isDiffuseEnabled();
-        specular *= lightEnergy * isSpecularEnabled();
+        diffuse *= lightEnergy;
+        specular *= lightEnergy;
 
-        _fragColor.rgb += diffuse;
-        _fragColor.rgb += specular;
+        fragDiffuse.rgb += diffuse;
+        fragSpecular.rgb += specular;
     }
 
     for (int i = cluster.x; i < numLights; i++) {
@@ -127,11 +130,17 @@ vec4 evalLocalLighting(ivec3 cluster, int numLights, vec3 fragWorldPos, vec3 fra
            evalFragShadingGloss(diffuse, specular, fragNormal, fragLightDir, fragEyeDir, fragMetallic, fragFresnel, fragGloss2, fragAlbedo);
         }
 
-        diffuse *= lightEnergy * isDiffuseEnabled();
-        specular *= lightEnergy * isSpecularEnabled();
+        diffuse *= lightEnergy;
+        specular *= lightEnergy;
 
-        _fragColor.rgb += diffuse;
-        _fragColor.rgb += specular;
+        fragDiffuse.rgb += diffuse;
+        fragSpecular.rgb += specular;
     }
-    return _fragColor;
+
+    fragDiffuse *= isDiffuseEnabled();
+    fragSpecular *= isSpecularEnabled();
+
+    fragColor.rgb += fragDiffuse;
+    fragColor.rgb += fragSpecular / opacity;
+    return fragColor;
 }
\ No newline at end of file
diff --git a/libraries/render-utils/src/local_lights_drawOutline.slf b/libraries/render-utils/src/local_lights_drawOutline.slf
index f7527d0542..de49478eba 100644
--- a/libraries/render-utils/src/local_lights_drawOutline.slf
+++ b/libraries/render-utils/src/local_lights_drawOutline.slf
@@ -55,6 +55,9 @@ void main(void) {
     vec4 fragPos = invViewMat * fragPosition;
     
     <$fetchClusterInfo(fragPos)$>;
+    if (!hasLocalLights(numLights, clusterPos, dims)) {
+        discard;
+    }
 
     // Frag to eye vec
     vec4 fragEyeVector = invViewMat * vec4(-frag.position.xyz, 0.0);
diff --git a/libraries/render-utils/src/local_lights_shading.slf b/libraries/render-utils/src/local_lights_shading.slf
index f302c6daba..b9c57b82cb 100644
--- a/libraries/render-utils/src/local_lights_shading.slf
+++ b/libraries/render-utils/src/local_lights_shading.slf
@@ -41,6 +41,9 @@ void main(void) {
     vec4 fragWorldPos = invViewMat * fragPosition;
 
     <$fetchClusterInfo(fragWorldPos)$>;
+    if (!hasLocalLights(numLights, clusterPos, dims)) {
+        discard;
+    }
 
     vec4 midNormalCurvature;
     vec4 lowNormalCurvature;
@@ -55,7 +58,7 @@ void main(void) {
 
     _fragColor = evalLocalLighting(cluster, numLights, fragWorldPos.xyz, frag.normal, fragEyeDir, 
                                    midNormalCurvature, lowNormalCurvature, frag.roughness, frag.scattering,
-                                   frag.metallic, frag.fresnel, frag.albedo);
+                                   frag.metallic, frag.fresnel, frag.albedo, 1.0);
 
 }
 
diff --git a/libraries/render-utils/src/model_translucent.slf b/libraries/render-utils/src/model_translucent.slf
index 5f61aea889..c054a5c096 100644
--- a/libraries/render-utils/src/model_translucent.slf
+++ b/libraries/render-utils/src/model_translucent.slf
@@ -68,16 +68,17 @@ void main(void) {
     vec3 fragNormal = normalize(_normal);
 
     TransformCamera cam = getTransformCamera();
+    vec4 localLighting = vec4(0.0);
 
     <$fetchClusterInfo(_worldPosition)$>;
+    if (hasLocalLights(numLights, clusterPos, dims)) {
+        vec3 fragEyeVector = vec3(cam._viewInverse * vec4(-fragPosition, 0.0));
+        vec3 fragEyeDir = normalize(fragEyeVector);
 
-    vec3 fragEyeVector = vec3(cam._viewInverse * vec4(-fragPosition, 0.0));
-    vec3 fragEyeDir = normalize(fragEyeVector);
-
-    vec4 localLighting = evalLocalLighting(cluster, numLights, _worldPosition.xyz, fragNormal, fragEyeDir, 
-                                   vec4(0), vec4(0), roughness, 0.0,
-                                   metallic, fresnel, albedo);
-    emissive += localLighting.rgb;
+        localLighting = evalLocalLighting(cluster, numLights, _worldPosition.xyz, fragNormal, fragEyeDir, 
+                                          vec4(0), vec4(0), roughness, 0.0,
+                                          metallic, fresnel, albedo, opacity);
+    }
 
     _fragColor =  vec4(evalGlobalLightingAlphaBlendedWithHaze(
         cam._viewInverse,
@@ -89,6 +90,6 @@ void main(void) {
         fresnel,
         metallic,
         emissive,
-        roughness, opacity),
+        roughness, opacity, localLighting.rgb),
         opacity);
 }
diff --git a/libraries/render-utils/src/model_translucent_fade.slf b/libraries/render-utils/src/model_translucent_fade.slf
index e07730a07e..c6bfd1659d 100644
--- a/libraries/render-utils/src/model_translucent_fade.slf
+++ b/libraries/render-utils/src/model_translucent_fade.slf
@@ -77,16 +77,17 @@ void main(void) {
     vec3 fragNormal = normalize(_normal);
 
     TransformCamera cam = getTransformCamera();
+    vec4 localLighting = vec4(0.0);
 
     <$fetchClusterInfo(_worldPosition)$>;
+    if (hasLocalLights(numLights, clusterPos, dims)) {
+        vec3 fragEyeVector = vec3(cam._viewInverse * vec4(-fragPosition, 0.0));
+        vec3 fragEyeDir = normalize(fragEyeVector);
 
-    vec3 fragEyeVector = vec3(cam._viewInverse * vec4(-fragPosition, 0.0));
-    vec3 fragEyeDir = normalize(fragEyeVector);
-
-    vec4 localLighting = evalLocalLighting(cluster, numLights, _worldPosition.xyz, fragNormal, fragEyeDir, 
-                                   vec4(0), vec4(0), roughness, 0.0,
-                                   metallic, fresnel, albedo);
-    emissive += localLighting.rgb;
+        localLighting = evalLocalLighting(cluster, numLights, _worldPosition.xyz, fragNormal, fragEyeDir, 
+                                          vec4(0), vec4(0), roughness, 0.0,
+                                          metallic, fresnel, albedo, opacity);
+    }
 
     _fragColor =  vec4(evalGlobalLightingAlphaBlendedWithHaze(
         cam._viewInverse,
@@ -98,6 +99,6 @@ void main(void) {
         fresnel,
         metallic,
         emissive+fadeEmissive,
-        roughness, opacity),
+        roughness, opacity, localLighting.rgb),
         opacity);
 }
diff --git a/libraries/render-utils/src/overlay3D_model_translucent.slf b/libraries/render-utils/src/overlay3D_model_translucent.slf
index b26e70f465..18f40a37b4 100644
--- a/libraries/render-utils/src/overlay3D_model_translucent.slf
+++ b/libraries/render-utils/src/overlay3D_model_translucent.slf
@@ -75,7 +75,7 @@ void main(void) {
         fresnel,
         metallic,
         emissive,
-        roughness, opacity),
+        roughness, opacity, vec3(0)),
         opacity);
 
     // Apply standard tone mapping
diff --git a/libraries/render-utils/src/simple_transparent_textured.slf b/libraries/render-utils/src/simple_transparent_textured.slf
index b16b19c8b4..5068b59e89 100644
--- a/libraries/render-utils/src/simple_transparent_textured.slf
+++ b/libraries/render-utils/src/simple_transparent_textured.slf
@@ -56,7 +56,7 @@ void main(void) {
         0.0,
         vec3(0.0f),
         DEFAULT_ROUGHNESS,
-        opacity),
+        opacity, vec3(0)),
         opacity);
 
 }
\ No newline at end of file
diff --git a/libraries/render-utils/src/simple_transparent_textured_fade.slf b/libraries/render-utils/src/simple_transparent_textured_fade.slf
index ad260210a7..2fff00849f 100644
--- a/libraries/render-utils/src/simple_transparent_textured_fade.slf
+++ b/libraries/render-utils/src/simple_transparent_textured_fade.slf
@@ -68,7 +68,7 @@ void main(void) {
         0.0f,
         fadeEmissive,
         DEFAULT_ROUGHNESS,
-        opacity),
+        opacity, vec3(0)),
         opacity);
 
 }
\ No newline at end of file

From 8fb863e98c259ac16a7cc4dbaaa695229b38ee24 Mon Sep 17 00:00:00 2001
From: Olivier Prat <olivier@zvork.fr>
Date: Tue, 16 Jan 2018 15:57:05 +0100
Subject: [PATCH 7/8] Added SurfaceData mechanism to evalGlobalLight

---
 .../render-utils/src/DeferredGlobalLight.slh  | 60 ++++++++++++++++---
 .../render-utils/src/model_translucent.slf    |  4 +-
 .../render-utils/src/model_translucent.slv    |  2 +-
 .../src/model_translucent_fade.slf            |  4 +-
 .../src/model_translucent_fade.slv            |  2 +-
 .../src/overlay3D_model_translucent.slf       |  2 +-
 .../src/simple_transparent_textured.slf       |  2 +-
 .../src/simple_transparent_textured_fade.slf  |  2 +-
 8 files changed, 60 insertions(+), 18 deletions(-)

diff --git a/libraries/render-utils/src/DeferredGlobalLight.slh b/libraries/render-utils/src/DeferredGlobalLight.slh
index ab26f95482..7750b62430 100644
--- a/libraries/render-utils/src/DeferredGlobalLight.slh
+++ b/libraries/render-utils/src/DeferredGlobalLight.slh
@@ -21,13 +21,7 @@
 <@include LightDirectional.slh@>
 
 
-<@func prepareGlobalLight(isScattering)@>
-    // prepareGlobalLight
-    // Transform directions to worldspace
-    vec3 fragNormal = vec3((normal));
-    vec3 fragEyeVector = vec3(invViewMat * vec4(-1.0*position, 0.0));
-    vec3 fragEyeDir = normalize(fragEyeVector);
-
+<@func fetchGlobalLight()@>
     // Get light
     Light light = getKeyLight();
     LightAmbient lightAmbient = getLightAmbient();
@@ -36,6 +30,16 @@
     vec3 lightIrradiance = getLightIrradiance(light);
 
     vec3 color = vec3(0.0);
+<@endfunc@>
+
+<@func prepareGlobalLight(isScattering)@>
+    // prepareGlobalLight
+    // Transform directions to worldspace
+    vec3 fragNormal = vec3((normal));
+    vec3 fragEyeVector = vec3(invViewMat * vec4(-position, 0.0));
+    vec3 fragEyeDir = normalize(fragEyeVector);
+
+    <$fetchGlobalLight()$>
 
 <@endfunc@>
 
@@ -202,12 +206,50 @@ vec3 evalGlobalLightingAlphaBlended(mat4 invViewMat, float shadowAttenuation, fl
 
 vec3 evalGlobalLightingAlphaBlendedWithHaze(
     mat4 invViewMat, float shadowAttenuation, float obscurance, vec3 position, vec3 normal, 
-    vec3 albedo, vec3 fresnel, float metallic, vec3 emissive, float roughness, float opacity, vec3 prevLighting) 
+    vec3 albedo, vec3 fresnel, float metallic, vec3 emissive, float roughness, float opacity) 
 {
     <$prepareGlobalLight()$>
     
     SurfaceData surface = initSurfaceData(roughness, fragNormal, fragEyeDir);
 
+    color += emissive * isEmissiveEnabled();
+
+    // Ambient
+    vec3 ambientDiffuse;
+    vec3 ambientSpecular;
+    evalLightingAmbient(ambientDiffuse, ambientSpecular, lightAmbient, surface, metallic, fresnel, albedo, obscurance);
+    color += ambientDiffuse;
+    color += ambientSpecular / opacity;
+
+    // Directional
+    vec3 directionalDiffuse;
+    vec3 directionalSpecular;
+    evalLightingDirectional(directionalDiffuse, directionalSpecular, lightDirection, lightIrradiance, surface, metallic, fresnel, albedo, shadowAttenuation);
+    color += directionalDiffuse;
+    color += directionalSpecular / opacity;
+
+    // Haze
+    if ((hazeParams.hazeMode & HAZE_MODE_IS_ACTIVE) == HAZE_MODE_IS_ACTIVE) {
+        vec4 colorV4 = computeHazeColor(
+            vec4(color, 1.0),               // fragment original color
+            position,                       // fragment position in eye   coordinates
+            fragEyeVector,                  // fragment position in world coordinates
+            invViewMat[3].y,                // eye      height   in world coordinates
+            lightDirection                  // keylight direction vector
+        );
+
+        color = colorV4.rgb;
+    }
+
+    return color;
+}
+
+vec3 evalGlobalLightingAlphaBlendedWithHaze(
+    mat4 invViewMat, float shadowAttenuation, float obscurance, vec3 position, 
+    vec3 albedo, vec3 fresnel, float metallic, vec3 emissive, SurfaceData surface, float opacity, vec3 prevLighting) 
+{
+    <$fetchGlobalLight()$>
+    
     color = prevLighting;
     color += emissive * isEmissiveEnabled();
 
@@ -229,7 +271,7 @@ vec3 evalGlobalLightingAlphaBlendedWithHaze(
         vec4 colorV4 = computeHazeColor(
             vec4(color, 1.0),               // fragment original color
             position,                       // fragment position in eye   coordinates
-            fragEyeVector,                  // fragment position in world coordinates
+            surface.eyeDir,                 // fragment eye vector in world coordinates
             invViewMat[3].y,                // eye      height   in world coordinates
             lightDirection                  // keylight direction vector
         );
diff --git a/libraries/render-utils/src/model_translucent.slf b/libraries/render-utils/src/model_translucent.slf
index 9b6913fe1c..6b3fe5991b 100644
--- a/libraries/render-utils/src/model_translucent.slf
+++ b/libraries/render-utils/src/model_translucent.slf
@@ -59,6 +59,7 @@ void main(void) {
     <$evalMaterialEmissive(emissiveTex, emissive, matKey, emissive)$>;
 
     vec3 fragPosition = _position.xyz;
+    // Lighting is done in world space
     vec3 fragNormal = normalize(_normal);
 
     TransformCamera cam = getTransformCamera();
@@ -80,11 +81,10 @@ void main(void) {
         1.0,
         occlusionTex,
         fragPosition,
-        fragNormal,
         albedo,
         fresnel,
         metallic,
         emissive,
-        roughness, opacity, localLighting.rgb),
+        surface, opacity, localLighting.rgb),
         opacity);
 }
diff --git a/libraries/render-utils/src/model_translucent.slv b/libraries/render-utils/src/model_translucent.slv
index 2fe4c511f0..305aba06c3 100644
--- a/libraries/render-utils/src/model_translucent.slv
+++ b/libraries/render-utils/src/model_translucent.slv
@@ -40,5 +40,5 @@ void main(void) {
     TransformObject obj = getTransformObject();
     <$transformModelToEyeAndClipPos(cam, obj, inPosition, _position, gl_Position)$>
     <$transformModelToWorldPos(obj, inPosition, _worldPosition)$>
-    <$transformModelToEyeDir(cam, obj, inNormal.xyz, _normal)$>
+    <$transformModelToWorldDir(cam, obj, inNormal.xyz, _normal)$>
 }
diff --git a/libraries/render-utils/src/model_translucent_fade.slf b/libraries/render-utils/src/model_translucent_fade.slf
index ea8774fd4e..46eac17cf7 100644
--- a/libraries/render-utils/src/model_translucent_fade.slf
+++ b/libraries/render-utils/src/model_translucent_fade.slf
@@ -68,6 +68,7 @@ void main(void) {
     <$evalMaterialEmissive(emissiveTex, emissive, matKey, emissive)$>;
 
     vec3 fragPosition = _position.xyz;
+    // Lighting is done in world space
     vec3 fragNormal = normalize(_normal);
 
     TransformCamera cam = getTransformCamera();
@@ -89,11 +90,10 @@ void main(void) {
         1.0,
         occlusionTex,
         fragPosition,
-        fragNormal,
         albedo,
         fresnel,
         metallic,
         emissive+fadeEmissive,
-        roughness, opacity, localLighting.rgb),
+        surface, opacity, localLighting.rgb),
         opacity);
 }
diff --git a/libraries/render-utils/src/model_translucent_fade.slv b/libraries/render-utils/src/model_translucent_fade.slv
index eaabdd27e8..3fb9ad2cb4 100644
--- a/libraries/render-utils/src/model_translucent_fade.slv
+++ b/libraries/render-utils/src/model_translucent_fade.slv
@@ -40,5 +40,5 @@ void main(void) {
     TransformObject obj = getTransformObject();
     <$transformModelToEyeAndClipPos(cam, obj, inPosition, _position, gl_Position)$>
     <$transformModelToWorldPos(obj, inPosition, _worldPosition)$>
-    <$transformModelToEyeDir(cam, obj, inNormal.xyz, _normal)$>
+    <$transformModelToWorldDir(cam, obj, inNormal.xyz, _normal)$>
 }
diff --git a/libraries/render-utils/src/overlay3D_model_translucent.slf b/libraries/render-utils/src/overlay3D_model_translucent.slf
index 6f1d34926e..b6ae8eb75e 100644
--- a/libraries/render-utils/src/overlay3D_model_translucent.slf
+++ b/libraries/render-utils/src/overlay3D_model_translucent.slf
@@ -69,7 +69,7 @@ void main(void) {
         fresnel,
         metallic,
         emissive,
-        roughness, opacity, vec3(0)),
+        roughness, opacity),
         opacity);
 
     // Apply standard tone mapping
diff --git a/libraries/render-utils/src/simple_transparent_textured.slf b/libraries/render-utils/src/simple_transparent_textured.slf
index 5068b59e89..b16b19c8b4 100644
--- a/libraries/render-utils/src/simple_transparent_textured.slf
+++ b/libraries/render-utils/src/simple_transparent_textured.slf
@@ -56,7 +56,7 @@ void main(void) {
         0.0,
         vec3(0.0f),
         DEFAULT_ROUGHNESS,
-        opacity, vec3(0)),
+        opacity),
         opacity);
 
 }
\ No newline at end of file
diff --git a/libraries/render-utils/src/simple_transparent_textured_fade.slf b/libraries/render-utils/src/simple_transparent_textured_fade.slf
index 2fff00849f..ad260210a7 100644
--- a/libraries/render-utils/src/simple_transparent_textured_fade.slf
+++ b/libraries/render-utils/src/simple_transparent_textured_fade.slf
@@ -68,7 +68,7 @@ void main(void) {
         0.0f,
         fadeEmissive,
         DEFAULT_ROUGHNESS,
-        opacity, vec3(0)),
+        opacity),
         opacity);
 
 }
\ No newline at end of file

From 43f7bb5f56e9dbd72939a54e2cc1f63821ba2fa8 Mon Sep 17 00:00:00 2001
From: Olivier Prat <olivier@zvork.fr>
Date: Mon, 22 Jan 2018 16:50:03 +0100
Subject: [PATCH 8/8] Fixed compilation error due to really long shader

---
 libraries/render-utils/src/LightClusterGrid.slh | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/libraries/render-utils/src/LightClusterGrid.slh b/libraries/render-utils/src/LightClusterGrid.slh
index 60daa520a3..709e8c0f70 100644
--- a/libraries/render-utils/src/LightClusterGrid.slh
+++ b/libraries/render-utils/src/LightClusterGrid.slh
@@ -100,23 +100,6 @@ int clusterGrid_getClusterLightId(int index, int offset) {
 <@endfunc@>
 
 bool hasLocalLights(int numLights, ivec3 clusterPos, ivec3 dims) {
-/*
-    if (numLights <= 0) {
-        return false;
-    }
-
-    if (clusterPos.x < 0 || clusterPos.x >= dims.x) {
-        return false;
-    }
-
-    if (clusterPos.y < 0 || clusterPos.y >= dims.y) {
-        return false;
-    }
-    if (clusterPos.z < 0 || clusterPos.z > dims.z) {
-        return false;
-    }
-    return true;
-*/
     return numLights>0 
         && all(greaterThanEqual(clusterPos, ivec3(0))) 
         && all(lessThan(clusterPos.xy, dims.xy))