Introducing the deferredFRameTransform to DeferredLighting Effect and simplifying the rendering!

libraries/render-utils/src/DeferredBufferRead.slh

@@ -32,38 +32,6 @@ uniform sampler2D obscuranceMap;
 uniform sampler2D lightingMap;
 
 
-struct DeferredTransform { 
-    mat4 projection;
-    mat4 viewInverse;
-    float stereoSide;
-    vec3 _spareABC;
-};
-
-layout(std140) uniform deferredTransformBuffer {
-    DeferredTransform _deferredTransform;
-};
-DeferredTransform getDeferredTransform() {
-    return _deferredTransform;
-}
-
-bool getStereoMode(DeferredTransform deferredTransform) {
-    return (deferredTransform.stereoSide != 0.0);
-}
-float getStereoSide(DeferredTransform deferredTransform) {
-    return  (deferredTransform.stereoSide);
-}
-
-vec4 evalEyePositionFromZ(DeferredTransform deferredTransform, float depthVal, vec2 texcoord) {
-    vec3 nPos = vec3(texcoord.xy * 2.0f - 1.0f, depthVal * 2.0f - 1.0f);
-
-    // compute the view space position using the depth
-    // basically manually pick the proj matrix components to do the inverse
-    float Ze = -deferredTransform.projection[3][2] / (nPos.z + deferredTransform.projection[2][2]);
-    float Xe = (-Ze * nPos.x - Ze * deferredTransform.projection[2][0] - deferredTransform.projection[3][0]) /  deferredTransform.projection[0][0];
-    float Ye = (-Ze * nPos.y - Ze * deferredTransform.projection[2][1] - deferredTransform.projection[3][1]) /  deferredTransform.projection[1][1];
-    return vec4(Xe, Ye, Ze, 1.0f);
-}
-
 struct DeferredFragment {
     vec4 normalVal;
     vec4 diffuseVal;
@@ -80,16 +48,6 @@ struct DeferredFragment {
     float depthVal;
 };
 
-vec4 unpackDeferredPosition(DeferredTransform deferredTransform, float depthValue, vec2 texcoord) {
-    if (getStereoMode(deferredTransform)) {
-        if (texcoord.x > 0.5) {
-            texcoord.x -= 0.5;
-        }
-        texcoord.x *= 2.0;
-    }
-    return evalEyePositionFromZ(deferredTransform, depthValue, texcoord);
-}
-
 DeferredFragment unpackDeferredFragmentNoPosition(vec2 texcoord) {
 
     DeferredFragment frag;
@@ -122,6 +80,52 @@ DeferredFragment unpackDeferredFragmentNoPosition(vec2 texcoord) {
     return frag;
 }
 
+
+<@include DeferredTransform.slh@>
+<$declareDeferredFrameTransform()$>
+
+<!
+struct DeferredTransform { 
+    mat4 projection;
+    mat4 viewInverse;
+    float stereoSide;
+    vec3 _spareABC;
+};
+
+layout(std140) uniform deferredTransformBuffer {
+    DeferredTransform _deferredTransform;
+};
+DeferredTransform getDeferredTransform() {
+    return _deferredTransform;
+}
+
+bool getStereoMode(DeferredTransform deferredTransform) {
+    return (deferredTransform.stereoSide != 0.0);
+}
+float getStereoSide(DeferredTransform deferredTransform) {
+    return  (deferredTransform.stereoSide);
+}
+
+vec4 evalEyePositionFromZ(DeferredTransform deferredTransform, float depthVal, vec2 texcoord) {
+    vec3 nPos = vec3(texcoord.xy * 2.0f - 1.0f, depthVal * 2.0f - 1.0f);
+
+    // compute the view space position using the depth
+    // basically manually pick the proj matrix components to do the inverse
+    float Ze = -deferredTransform.projection[3][2] / (nPos.z + deferredTransform.projection[2][2]);
+    float Xe = (-Ze * nPos.x - Ze * deferredTransform.projection[2][0] - deferredTransform.projection[3][0]) /  deferredTransform.projection[0][0];
+    float Ye = (-Ze * nPos.y - Ze * deferredTransform.projection[2][1] - deferredTransform.projection[3][1]) /  deferredTransform.projection[1][1];
+    return vec4(Xe, Ye, Ze, 1.0f);
+}
+
+vec4 unpackDeferredPosition(DeferredTransform deferredTransform, float depthValue, vec2 texcoord) {
+    if (getStereoMode(deferredTransform)) {
+        if (texcoord.x > 0.5) {
+            texcoord.x -= 0.5;
+        }
+        texcoord.x *= 2.0;
+    }
+    return evalEyePositionFromZ(deferredTransform, depthValue, texcoord);
+}
 DeferredFragment unpackDeferredFragment(DeferredTransform deferredTransform, vec2 texcoord) {
 
     float depthValue = texture(depthMap, texcoord).r;
@@ -133,8 +137,36 @@ DeferredFragment unpackDeferredFragment(DeferredTransform deferredTransform, vec
 
     return frag;
 }
+mat4 getViewInverse() {
+    return _deferredTransform.viewInverse;
+}
+
+!>
+
+vec4 unpackDeferredPosition(DeferredFrameTransform deferredTransform, float depthValue, vec2 texcoord) {
+    int side = 0;
+    if (isStereo()) {
+        if (texcoord.x > 0.5) {
+            texcoord.x -= 0.5;
+            side = 1;
+        }
+        texcoord.x *= 2.0;
+    }
+    float Zeye = evalZeyeFromZdb(depthValue);
+
+    return vec4(evalEyePositionFromZeye(side, Zeye, texcoord), 1.0);
+}
+DeferredFragment unpackDeferredFragment(DeferredFrameTransform deferredTransform, vec2 texcoord) {
+
+    float depthValue = texture(depthMap, texcoord).r;
+
+    DeferredFragment frag = unpackDeferredFragmentNoPosition(texcoord);
+
+    frag.depthVal = depthValue;
+    frag.position = unpackDeferredPosition(deferredTransform, frag.depthVal, texcoord);
+
+    return frag;
+}
 
 
-
-
 <@endif@>

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -38,6 +38,8 @@
 #include "point_light_frag.h"
 #include "spot_light_frag.h"
 
+using namespace render;
+
 struct LightLocations {
     int radius;
     int ambientSphere;
@@ -45,6 +47,7 @@ struct LightLocations {
     int texcoordMat;
     int coneParam;
     int deferredTransformBuffer;
+    int deferredFrameTransformBuffer;
     int shadowTransformBuffer;
 };
 
@@ -56,6 +59,9 @@ enum {
     DEFERRED_BUFFER_OBSCURANCE_UNIT = 4,
     SHADOW_MAP_UNIT = 5,
     SKYBOX_MAP_UNIT = 6,
+};
+enum {
+
 };
 static void loadLightProgram(const char* vertSource, const char* fragSource, bool lightVolume, gpu::PipelinePointer& program, LightLocationsPtr& locations);
 
@@ -132,33 +138,7 @@ void DeferredLightingEffect::addSpotLight(const glm::vec3& position, float radiu
     }
 }
 
-void DeferredLightingEffect::prepare(RenderArgs* args) {
+void DeferredLightingEffect::render(const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform) {
-    gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
-        batch.enableStereo(false);
-        batch.setViewportTransform(args->_viewport);
-        batch.setStateScissorRect(args->_viewport);
-
-        // Clear Lighting buffer
-        auto lightingFbo = DependencyManager::get<FramebufferCache>()->getLightingFramebuffer();
-
-        batch.setFramebuffer(lightingFbo);
-        batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, vec4(vec3(0), 0), true);
-
-        // Clear deferred
-        auto deferredFbo = DependencyManager::get<FramebufferCache>()->getDeferredFramebuffer();
-
-        batch.setFramebuffer(deferredFbo);
-
-        // Clear Color, Depth and Stencil for deferred buffer
-        batch.clearFramebuffer(
-            gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_COLOR1 | gpu::Framebuffer::BUFFER_COLOR2 |
-            gpu::Framebuffer::BUFFER_DEPTH |
-            gpu::Framebuffer::BUFFER_STENCIL,
-            vec4(vec3(0), 0), 1.0, 0.0, true);
-    });
-}
-
-void DeferredLightingEffect::render(const render::RenderContextPointer& renderContext) {
     auto args = renderContext->args;
     gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
         
@@ -185,6 +165,7 @@ void DeferredLightingEffect::render(const render::RenderContextPointer& renderCo
         batch.setViewportTransform(args->_viewport);
         batch.setStateScissorRect(args->_viewport);
 
+
         // Bind the G-Buffer surfaces
         batch.setResourceTexture(DEFERRED_BUFFER_COLOR_UNIT, framebufferCache->getDeferredColorTexture());
         batch.setResourceTexture(DEFERRED_BUFFER_NORMAL_UNIT, framebufferCache->getDeferredNormalTexture());
@@ -294,6 +275,7 @@ void DeferredLightingEffect::render(const render::RenderContextPointer& renderCo
         auto eyePoint = viewFrustum.getPosition();
         float nearRadius = glm::distance(eyePoint, viewFrustum.getNearTopLeft());
 
+        batch.setUniformBuffer(_directionalLightLocations->deferredFrameTransformBuffer, frameTransform->getFrameTransformBuffer());
 
         for (int side = 0; side < numPasses; side++) {
             // Render in this side's viewport
@@ -302,7 +284,9 @@ void DeferredLightingEffect::render(const render::RenderContextPointer& renderCo
 
             // Sync and Bind the correct DeferredTransform ubo
             _deferredTransformBuffer[side]._buffer->setSubData(0, sizeof(DeferredTransform), (const gpu::Byte*) &deferredTransforms[side]);
-            batch.setUniformBuffer(_directionalLightLocations->deferredTransformBuffer, _deferredTransformBuffer[side]);
+       //     batch.setUniformBuffer(_directionalLightLocations->deferredTransformBuffer, _deferredTransformBuffer[side]);
+
+
 
             glm::vec2 topLeft(-1.0f, -1.0f);
             glm::vec2 bottomRight(1.0f, 1.0f);
@@ -482,7 +466,8 @@ void DeferredLightingEffect::render(const render::RenderContextPointer& renderCo
         batch.setResourceTexture(SHADOW_MAP_UNIT, nullptr);
         batch.setResourceTexture(SKYBOX_MAP_UNIT, nullptr);
 
-        batch.setUniformBuffer(_directionalLightLocations->deferredTransformBuffer, nullptr);
+       // batch.setUniformBuffer(_directionalLightLocations->deferredTransformBuffer, nullptr);
+        batch.setUniformBuffer(_directionalLightLocations->deferredFrameTransformBuffer, nullptr);
     });
 
     // End of the Lighting pass
@@ -524,8 +509,10 @@ static void loadLightProgram(const char* vertSource, const char* fragSource, boo
 
     static const int LIGHT_GPU_SLOT = 3;
     static const int DEFERRED_TRANSFORM_BUFFER_SLOT = 2;
+    static const int DEFERRED_FRAME_TRANSFORM_BUFFER_SLOT = 4;
     slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), LIGHT_GPU_SLOT));
     slotBindings.insert(gpu::Shader::Binding(std::string("deferredTransformBuffer"), DEFERRED_TRANSFORM_BUFFER_SLOT));
+    slotBindings.insert(gpu::Shader::Binding(std::string("deferredFrameTransformBuffer"), DEFERRED_FRAME_TRANSFORM_BUFFER_SLOT));
 
     gpu::Shader::makeProgram(*program, slotBindings);
 
@@ -537,6 +524,7 @@ static void loadLightProgram(const char* vertSource, const char* fragSource, boo
 
     locations->lightBufferUnit = program->getBuffers().findLocation("lightBuffer");
     locations->deferredTransformBuffer = program->getBuffers().findLocation("deferredTransformBuffer");
+    locations->deferredFrameTransformBuffer = program->getBuffers().findLocation("deferredFrameTransformBuffer");
     locations->shadowTransformBuffer = program->getBuffers().findLocation("shadowTransformBuffer");
 
     auto state = std::make_shared<gpu::State>();
@@ -667,3 +655,33 @@ model::MeshPointer DeferredLightingEffect::getSpotLightMesh() {
     return _spotLightMesh;
 }
 
+void PrepareDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
+    auto args = renderContext->args;
+    gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
+        batch.enableStereo(false);
+        batch.setViewportTransform(args->_viewport);
+        batch.setStateScissorRect(args->_viewport);
+
+        // Clear Lighting buffer
+        auto lightingFbo = DependencyManager::get<FramebufferCache>()->getLightingFramebuffer();
+
+        batch.setFramebuffer(lightingFbo);
+        batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, vec4(vec3(0), 0), true);
+
+        // Clear deferred
+        auto deferredFbo = DependencyManager::get<FramebufferCache>()->getDeferredFramebuffer();
+
+        batch.setFramebuffer(deferredFbo);
+
+        // Clear Color, Depth and Stencil for deferred buffer
+        batch.clearFramebuffer(
+            gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_COLOR1 | gpu::Framebuffer::BUFFER_COLOR2 |
+            gpu::Framebuffer::BUFFER_DEPTH |
+            gpu::Framebuffer::BUFFER_STENCIL,
+            vec4(vec3(0), 0), 1.0, 0.0, true);
+    });
+}
+
+void RenderDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const DeferredFrameTransformPointer& deferredTransform) {
+    DependencyManager::get<DeferredLightingEffect>()->render(renderContext, deferredTransform);
+}

libraries/render-utils/src/DeferredLightingEffect.h

@@ -21,6 +21,9 @@
 #include "model/Geometry.h"
 
 #include "render/Context.h"
+#include <render/CullTask.h>
+
+#include "DeferredFrameTransform.h"
 
 #include "LightStage.h"
 
@@ -42,9 +45,8 @@ public:
     void addSpotLight(const glm::vec3& position, float radius, const glm::vec3& color = glm::vec3(1.0f, 1.0f, 1.0f),
         float intensity = 0.5f, float falloffRadius = 0.01f,
         const glm::quat& orientation = glm::quat(), float exponent = 0.0f, float cutoff = PI);
-    
+
-    void prepare(RenderArgs* args);
+    void render(const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform);
-    void render(const render::RenderContextPointer& renderContext);
 
     void setupKeyLightBatch(gpu::Batch& batch, int lightBufferUnit, int skyboxCubemapUnit);
 
@@ -110,4 +112,18 @@ private:
     UniformBufferView _deferredTransformBuffer[2];
 };
 
+class PrepareDeferred {
+public:
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
+
+    using JobModel = render::Job::Model<PrepareDeferred>;
+};
+
+class RenderDeferred {
+public:
+    using JobModel = render::Job::ModelI<RenderDeferred, DeferredFrameTransformPointer>;
+
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform);
+};
+
 #endif // hifi_DeferredLightingEffect_h

libraries/render-utils/src/DeferredTransform.slh

@@ -27,6 +27,10 @@ uniform deferredFrameTransformBuffer {
     DeferredFrameTransform frameTransform;
 };
 
+DeferredFrameTransform getDeferredFrameTransform() {
+    return frameTransform;
+}
+
 vec2 getWidthHeight(int resolutionLevel) {
     return vec2(ivec2(frameTransform._pixelInfo.zw) >> resolutionLevel);
 }

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -43,14 +43,6 @@ extern void initStencilPipeline(gpu::PipelinePointer& pipeline);
 extern void initOverlay3DPipelines(render::ShapePlumber& plumber);
 extern void initDeferredPipelines(render::ShapePlumber& plumber);
 
-void PrepareDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
-    DependencyManager::get<DeferredLightingEffect>()->prepare(renderContext->args);
-}
-
-void RenderDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
-    DependencyManager::get<DeferredLightingEffect>()->render(renderContext);
-}
-
 RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
     cullFunctor = cullFunctor ? cullFunctor : [](const RenderArgs*, const AABox&){ return true; };
 
@@ -135,7 +127,7 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
     const auto scatteringFramebuffer = addJob<SubsurfaceScattering>("Scattering", scatteringInputs);
 
     // DeferredBuffer is complete, now let's shade it into the LightingBuffer
-    addJob<RenderDeferred>("RenderDeferred");
+    addJob<RenderDeferred>("RenderDeferred", deferredFrameTransform);
 
 
     // AA job to be revisited

libraries/render-utils/src/RenderDeferredTask.h

@@ -15,28 +15,6 @@
 #include <gpu/Pipeline.h>
 #include <render/CullTask.h>
 
-class SetupDeferred {
-public:
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
-
-    using JobModel = render::Job::Model<SetupDeferred>;
-};
-
-
-class PrepareDeferred {
-public:
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
-
-    using JobModel = render::Job::Model<PrepareDeferred>;
-};
-
-class RenderDeferred {
-public:
-    using JobModel = render::Job::Model<RenderDeferred>;
-
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
-};
-
 class DrawConfig : public render::Job::Config {
     Q_OBJECT
     Q_PROPERTY(int numDrawn READ getNumDrawn NOTIFY newStats)

libraries/render-utils/src/SubsurfaceScattering.cpp

@@ -137,7 +137,7 @@ bool SubsurfaceScattering::updateScatteringFramebuffer(const gpu::FramebufferPoi
      //       _scatteringFramebuffer->setDepthStencilBuffer(sourceFramebuffer->getDepthStencilBuffer(), sourceFramebuffer->getDepthStencilBufferFormat());
         }
         auto blurringSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT);
-        auto blurringTarget = gpu::TexturePointer(gpu::Texture::create2D(sourceFramebuffer->getRenderBuffer(0)->getTexelFormat(), sourceFramebuffer->getWidth(), sourceFramebuffer->getHeight(), blurringSampler));
+        auto blurringTarget = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_SRGBA_32, sourceFramebuffer->getWidth(), sourceFramebuffer->getHeight(), blurringSampler));
         _scatteringFramebuffer->setRenderBuffer(0, blurringTarget);
     } else {
         // it would be easier to just call resize on the bluredFramebuffer and let it work if needed but the source might loose it's depth buffer when doing so
@@ -190,7 +190,6 @@ void SubsurfaceScattering::run(const render::SceneContextPointer& sceneContext,
         batch.setViewportTransform(args->_viewport);
 
         batch.setFramebuffer(_scatteringFramebuffer);
-     //   batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, vec4(vec3(0), 0), false);
 
         batch.setPipeline(pipeline);
 

libraries/render-utils/src/directional_ambient_light.slf

@@ -22,7 +22,7 @@ in vec2 _texCoord0;
 out vec4 _fragColor;
 
 void main(void) {
-    DeferredTransform deferredTransform = getDeferredTransform();
+    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
     DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0);
 
     float shadowAttenuation = 1.0;
@@ -31,7 +31,7 @@ void main(void) {
         _fragColor = vec4(frag.diffuse, 1.0);
     } else if (frag.mode == FRAG_MODE_LIGHTMAPPED) {
         vec3 color = evalLightmappedColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.normal,
@@ -40,7 +40,7 @@ void main(void) {
         _fragColor = vec4(color, 1.0);
     } else {
         vec3 color =  evalAmbientSphereGlobalColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.position.xyz,

libraries/render-utils/src/directional_ambient_light_shadow.slf

@@ -23,17 +23,17 @@ in vec2 _texCoord0;
 out vec4 _fragColor;
 
 void main(void) {
-    DeferredTransform deferredTransform = getDeferredTransform();
+    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
     DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0);
 
-    vec4 worldPos = deferredTransform.viewInverse * vec4(frag.position.xyz, 1.0);
+    vec4 worldPos = getViewInverse() * vec4(frag.position.xyz, 1.0);
     float shadowAttenuation = evalShadowAttenuation(worldPos);
 
     if (frag.mode == FRAG_MODE_UNLIT) {
         _fragColor = vec4(frag.diffuse, 1.0);
     } else if (frag.mode == FRAG_MODE_LIGHTMAPPED) {
         vec3 color = evalLightmappedColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.normal,
@@ -42,7 +42,7 @@ void main(void) {
         _fragColor = vec4(color, 1.0);
     } else {
         vec3 color =  evalAmbientSphereGlobalColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.position.xyz,

libraries/render-utils/src/directional_light.slf

@@ -22,7 +22,7 @@ in vec2 _texCoord0;
 out vec4 _fragColor;
 
 void main(void) {
-    DeferredTransform deferredTransform = getDeferredTransform();
+    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
     DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0);
 
     float shadowAttenuation = 1.0;
@@ -32,7 +32,7 @@ void main(void) {
         _fragColor = vec4(frag.diffuse, 1.0);
     } else if (frag.mode == FRAG_MODE_LIGHTMAPPED) {
          vec3 color = evalLightmappedColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.normal,
@@ -41,7 +41,7 @@ void main(void) {
         _fragColor = vec4(color, 1.0);
     } else {
         vec3 color =  evalAmbientGlobalColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.position.xyz,

libraries/render-utils/src/directional_light_shadow.slf

@@ -23,10 +23,10 @@ in vec2 _texCoord0;
 out vec4 _fragColor;
 
 void main(void) {
-    DeferredTransform deferredTransform = getDeferredTransform();
+    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
     DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0);
 
-    vec4 worldPos = deferredTransform.viewInverse * vec4(frag.position.xyz, 1.0);
+    vec4 worldPos = getViewInverse() * vec4(frag.position.xyz, 1.0);
     float shadowAttenuation = evalShadowAttenuation(worldPos);
 
     // Light mapped or not ?
@@ -34,7 +34,7 @@ void main(void) {
         _fragColor = vec4(frag.diffuse, 1.0);
     } else if (frag.mode == FRAG_MODE_LIGHTMAPPED) {
          vec3 color = evalLightmappedColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.normal,
@@ -43,7 +43,7 @@ void main(void) {
         _fragColor = vec4(color, 1.0);
     } else {
         vec3 color =  evalAmbientGlobalColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.position.xyz,

libraries/render-utils/src/directional_skybox_light.slf

@@ -22,7 +22,7 @@ in vec2 _texCoord0;
 out vec4 _fragColor;
 
 void main(void) {
-    DeferredTransform deferredTransform = getDeferredTransform();
+    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
     DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0);
 
     float shadowAttenuation = 1.0;
@@ -32,7 +32,7 @@ void main(void) {
         _fragColor = vec4(frag.diffuse, 1.0);
     } else if (frag.mode == FRAG_MODE_LIGHTMAPPED) {
         vec3 color = evalLightmappedColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.normal,
@@ -41,7 +41,7 @@ void main(void) {
         _fragColor = vec4(color, 1.0);
     } else {
         vec3 color =  evalSkyboxGlobalColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.position.xyz,

libraries/render-utils/src/directional_skybox_light_shadow.slf

@@ -23,10 +23,10 @@ in vec2 _texCoord0;
 out vec4 _fragColor;
 
 void main(void) {
-    DeferredTransform deferredTransform = getDeferredTransform();
+    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
     DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0);
 
-    vec4 worldPos = deferredTransform.viewInverse * vec4(frag.position.xyz, 1.0);
+    vec4 worldPos = getViewInverse() * vec4(frag.position.xyz, 1.0);
     float shadowAttenuation = evalShadowAttenuation(worldPos);
 
     // Light mapped or not ?
@@ -34,7 +34,7 @@ void main(void) {
         _fragColor = vec4(frag.diffuse, 1.0);
     } else if (frag.mode == FRAG_MODE_LIGHTMAPPED) {
         vec3 color = evalLightmappedColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.normal,
@@ -43,7 +43,7 @@ void main(void) {
         _fragColor = vec4(color, 1.0);
     } else {
         vec3 color =  evalSkyboxGlobalColor(
-                        deferredTransform.viewInverse,
+                        getViewInverse(),
                         shadowAttenuation,
                         frag.obscurance,
                         frag.position.xyz,

libraries/render-utils/src/point_light.slf

@@ -26,7 +26,7 @@ in vec4 _texCoord0;
 out vec4 _fragColor;
 
 void main(void) {
-    DeferredTransform deferredTransform = getDeferredTransform();
+    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
 
     // Grab the fragment data from the uv
     vec2 texCoord = _texCoord0.st / _texCoord0.q;
@@ -36,7 +36,7 @@ void main(void) {
         discard;
     }
 
-    mat4 invViewMat = deferredTransform.viewInverse;
+    mat4 invViewMat = getViewInverse();
 
     // Kill if in front of the light volume
     float depth = frag.depthVal;

libraries/render-utils/src/spot_light.slf

@@ -26,7 +26,7 @@ out vec4 _fragColor;
 
 void main(void) {
 
-    DeferredTransform deferredTransform = getDeferredTransform();
+    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
 
     // Grab the fragment data from the uv
     vec2 texCoord = _texCoord0.st / _texCoord0.q;
@@ -36,7 +36,7 @@ void main(void) {
         discard;
     }
 
-    mat4 invViewMat = deferredTransform.viewInverse;
+    mat4 invViewMat = getViewInverse();
 
     // Kill if in front of the light volume
     float depth = frag.depthVal;

libraries/render-utils/src/subsurfaceScattering_drawScattering.slf

@@ -10,9 +10,11 @@
 //
 
 
-<@include DeferredTransform.slh@>
+<!<@include DeferredTransform.slh@>
 <$declareDeferredFrameTransform()$>
+!>
 
+<@include DeferredBufferRead.slh@>
 
 <@include DeferredGlobalLight.slh@>
 
@@ -26,7 +28,6 @@ float getZEyeLinear(vec2 texcoord) {
     return -texture(linearDepthMap, texcoord).x;
 }
 
-<@include DeferredBufferRead.slh@>
 
 vec2 sideToFrameTexcoord(vec2 side, vec2 texcoordPos) {
     return vec2((texcoordPos.x + side.x) * side.y, texcoordPos.y);

scripts/developer/utilities/render/currentZone.js

@@ -0,0 +1,73 @@
+//
+//  currentZone.js
+//  examples/utilities/tools/render
+//
+//  Sam Gateau created on 6/18/2016.
+//  Copyright 2016 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
+//
+
+// Set up the qml ui
+/*var qml = Script.resolvePath('framebuffer.qml');
+var window = new OverlayWindow({
+    title: 'Framebuffer Debug',
+    source: qml,
+    width: 400, height: 400,
+});
+window.setPosition(25, 50);
+window.closed.connect(function() { Script.stop(); });
+*/
+
+
+
+function findCurrentZones() {
+    var foundEntitiesArray = Entities.findEntities(MyAvatar.position, 2.0);
+    //print(foundEntitiesArray.length);
+    var zones = [];
+
+    foundEntitiesArray.forEach(function(foundID){
+        var properties = Entities.getEntityProperties(foundID);
+        if (properties.type == "Zone") {
+            zones.push(foundID);
+        } 
+    });
+    return zones;
+}
+
+
+var currentZone;
+var currentZoneProperties;
+
+function setCurrentZone(newCurrentZone) {
+    if (currentZone == newCurrentZone) {
+        return;
+    }
+        
+    currentZone = newCurrentZone;
+    currentZoneProperties = Entities.getEntityProperties(currentZone);
+
+    print(JSON.stringify(currentZoneProperties));
+}
+
+var checkCurrentZone = function() {
+   
+    var currentZones = findCurrentZones();
+    if (currentZones.length > 0) {
+        if (currentZone != currentZones[0]) {
+            print("New Zone");
+            setCurrentZone(currentZones[0]);
+        }
+    }
+   
+}
+var ticker = Script.setInterval(checkCurrentZone, 2000);
+
+//checkCurrentZone();
+
+function onQuit() {
+    Script.clearInterval(ticker);
+    print("Quit Zone");
+}
+Script.scriptEnding.connect(onQuit);

scripts/developer/utilities/render/framebuffer.qml

@@ -10,6 +10,7 @@
 //
 import QtQuick 2.5
 import QtQuick.Controls 1.4
+import "configSlider"
 
 Column {
     spacing: 8
@@ -22,13 +23,17 @@ Column {
             debug.config.mode = mode;
         }
 
-        function setLayout(layout) {
+        function setX(x) {
-            debug.config.size = { x: -1, y: -1, z: 1, w: 1 };
+            print(x)
-        }
 
-        Button { 
+            debug.config.size = Vec4({ x: x, y: -1, z: 1, w: 1 });
-            text: "Fullscreen"
+        }       
-            onClicked: { debug.setLayout(1); }
+        Slider {
+            minimumValue: -1.0
+            value: debug.config.size.x
+            onValueChanged: {
+                debug.setX( value);
+            }
         }
 
         ExclusiveGroup { id: bufferGroup }

scripts/developer/utilities/render/globalLight.qml

@@ -0,0 +1,36 @@
+//
+//  globalLight.qml
+//  examples/utilities/render
+//
+//  Copyright 2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or https://www.apache.org/licenses/LICENSE-2.0.html
+//
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import "configSlider"
+
+Column {
+    id: root
+    spacing: 8
+    property var currentZoneID
+    property var zoneProperties
+
+     Component.onCompleted: {
+        Entities.getProperties
+        sceneOctree.enabled = true;
+        itemSelection.enabled = true;                    
+        sceneOctree.showVisibleCells = false;
+        sceneOctree.showEmptyCells = false;
+        itemSelection.showInsideItems = false;
+        itemSelection.showInsideSubcellItems = false;
+        itemSelection.showPartialItems = false;
+        itemSelection.showPartialSubcellItems = false;
+    }
+    Component.onDestruction: {
+        sceneOctree.enabled = false;
+        itemSelection.enabled = false;  
+        Render.getConfig("FetchSceneSelection").freezeFrustum = false;
+        Render.getConfig("CullSceneSelection").freezeFrustum = false;                     
+    }

scripts/developer/utilities/render/surfaceGeometryPass.qml

@@ -15,6 +15,7 @@ Column {
     spacing: 8
     Column {
         id: surfaceGeometry
+        spacing: 10
 
         Column{
             Repeater {
@@ -63,5 +64,11 @@ Column {
                 }
             }
         }
+        CheckBox {
+            text: "Show scatteringLUT"
+            checked: false
+            onCheckedChanged: { Render.getConfig("Scattering").showLUT = checked }
+        }
+
     }
 }