Adding the lighting model class to configure accross the jobs the lighting

libraries/render-utils/src/DeferredGlobalLight.slh

@@ -14,6 +14,9 @@
 <@include model/Light.slh@>
 <@include DeferredLighting.slh@>
 
+<@include LightingModel.slh@>
+<$declareLightingModel()$>
+
 <@func declareSkyboxMap()@>
 // declareSkyboxMap
 uniform samplerCube skyboxMap;
@@ -79,8 +82,9 @@ vec3 evalGlobalSpecularIrradiance(Light light, vec3 fragEyeDir, vec3 fragNormal,
         metallic = 1.0;
     }
     vec4 shading = evalFragShading(fragNormal, -getLightDirection(light), fragEyeDir, metallic, fresnel, roughness);
-    vec3 color = vec3(albedo * shading.w + shading.rgb) * min(shadowAttenuation, obscurance) * getLightColor(light) * getLightIntensity(light);
-    color += emissive;
+    vec3 color = vec3(0.0);
+    color += vec3(albedo * shading.w * isDiffuseEnabled() + shading.rgb * isSpecularEnabled()) * min(shadowAttenuation, obscurance) * getLightColor(light) * getLightIntensity(light) * isDirectionalEnabled();
+    color += emissive * isEmissiveEnabled();
 <@endfunc@>
 
 
@@ -180,7 +184,7 @@ vec3 evalAmbientSphereGlobalColorScattering(mat4 invViewMat, float shadowAttenua
     brdf = mix(vec3(standardDiffuse), brdf, scatteringLevel * scattering);
 
 
-    vec3 color = vec3(albedo * vec3(brdf.xyz) * shading.w + shading.rgb) * getLightColor(light) * getLightIntensity(light);
+    vec3 color = vec3(albedo * vec3(brdf.xyz) * isDiffuseEnabled() * shading.w + shading.rgb * isSpecularEnabled()) * getLightColor(light) * getLightIntensity(light) * isDirectionalEnabled();
 
 
     // Diffuse from ambient

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -66,6 +66,7 @@ enum DeferredShader_MapSlot {
 };
 enum DeferredShader_BufferSlot {
     DEFERRED_FRAME_TRANSFORM_BUFFER_SLOT = 0,
+    LIGHTING_MODEL_BUFFER_SLOT,
     SCATTERING_PARAMETERS_BUFFER_SLOT,
     LIGHT_GPU_SLOT,
 };
@@ -180,6 +181,7 @@ static void loadLightProgram(const char* vertSource, const char* fragSource, boo
 
 
     slotBindings.insert(gpu::Shader::Binding(std::string("deferredFrameTransformBuffer"), DEFERRED_FRAME_TRANSFORM_BUFFER_SLOT));
+    slotBindings.insert(gpu::Shader::Binding(std::string("lightingModelBuffer"), LIGHTING_MODEL_BUFFER_SLOT));
     slotBindings.insert(gpu::Shader::Binding(std::string("subsurfaceScatteringParametersBuffer"), SCATTERING_PARAMETERS_BUFFER_SLOT));
     slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), LIGHT_GPU_SLOT));
 
@@ -354,6 +356,7 @@ void PrepareDeferred::run(const SceneContextPointer& sceneContext, const RenderC
 
 void RenderDeferredSetup::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext,
     const DeferredFrameTransformPointer& frameTransform,
+    const LightingModelPointer& lightingModel,
     const gpu::TexturePointer& diffusedCurvature2,
     const SubsurfaceScatteringResourcePointer& subsurfaceScatteringResource) {
     
@@ -393,6 +396,9 @@ void RenderDeferredSetup::run(const render::SceneContextPointer& sceneContext, c
         // The Deferred Frame Transform buffer
         batch.setUniformBuffer(DEFERRED_FRAME_TRANSFORM_BUFFER_SLOT, frameTransform->getFrameTransformBuffer());
 
+        // THe lighting model
+        batch.setUniformBuffer(LIGHTING_MODEL_BUFFER_SLOT, lightingModel->getParametersBuffer());
+
         // Subsurface scattering specific
         batch.setResourceTexture(DEFERRED_BUFFER_CURVATURE_UNIT, framebufferCache->getCurvatureTexture());
         batch.setResourceTexture(DEFERRED_BUFFER_DIFFUSED_CURVATURE_UNIT, diffusedCurvature2);
@@ -599,6 +605,7 @@ void RenderDeferredCleanup::run(const render::SceneContextPointer& sceneContext,
         batch.setResourceTexture(SCATTERING_SPECULAR_UNIT, nullptr);
         
         batch.setUniformBuffer(SCATTERING_PARAMETERS_BUFFER_SLOT, nullptr);
+        batch.setUniformBuffer(LIGHTING_MODEL_BUFFER_SLOT, nullptr);
         batch.setUniformBuffer(DEFERRED_FRAME_TRANSFORM_BUFFER_SLOT, nullptr);
     });
     
@@ -619,19 +626,17 @@ RenderDeferred::RenderDeferred() {
 
 
 void RenderDeferred::configure(const Config& config) {
-
-    _enablePointLights = config.enablePointLights;
-    _enableSpotLights = config.enableSpotLights;
 }
 
 void RenderDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const Inputs& inputs) {
     auto deferredTransform = inputs.get0();
+    auto lightingModel = inputs.get1();
     auto diffusedCurvature2 = inputs.get2()->getRenderBuffer(0);
-    auto subsurfaceScatteringResource = inputs.get3();
+    auto subsurfaceScatteringResource = inputs.get4();
 
-    setupJob.run(sceneContext, renderContext, deferredTransform, diffusedCurvature2, subsurfaceScatteringResource);
+    setupJob.run(sceneContext, renderContext, deferredTransform, lightingModel, diffusedCurvature2, subsurfaceScatteringResource);
     
-    lightsJob.run(sceneContext, renderContext, deferredTransform, _enablePointLights, _enableSpotLights);
+    lightsJob.run(sceneContext, renderContext, deferredTransform, lightingModel->isPointLightEnabled(), lightingModel->isSpotLightEnabled());
 
     cleanupJob.run(sceneContext, renderContext);
 }

libraries/render-utils/src/DeferredLightingEffect.h

@@ -24,6 +24,7 @@
 #include <render/CullTask.h>
 
 #include "DeferredFrameTransform.h"
+#include "LightingModel.h"
 
 #include "LightStage.h"
 
@@ -115,7 +116,9 @@ class RenderDeferredSetup {
 public:
   //  using JobModel = render::Job::ModelI<RenderDeferredSetup, DeferredFrameTransformPointer>;
     
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform,
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext,
+        const DeferredFrameTransformPointer& frameTransform,
+        const LightingModelPointer& lightingModel,
         const gpu::TexturePointer& diffusedCurvature2,
         const SubsurfaceScatteringResourcePointer& subsurfaceScatteringResource);
 };
@@ -138,15 +141,9 @@ public:
 
 class RenderDeferredConfig : public render::Job::Config {
     Q_OBJECT
-    Q_PROPERTY(bool enablePointLights MEMBER enablePointLights NOTIFY dirty)
-    Q_PROPERTY(bool enableSpotLights MEMBER enableSpotLights NOTIFY dirty)
-
 public:
     RenderDeferredConfig() : render::Job::Config(true) {}
 
-    bool enablePointLights{ true };
-    bool enableSpotLights{ true };
-
 signals:
     void dirty();
 };
@@ -154,7 +151,7 @@ signals:
 
 class RenderDeferred {
 public:
-    using Inputs = render::VaryingSet4 < DeferredFrameTransformPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, SubsurfaceScatteringResourcePointer>;
+    using Inputs = render::VaryingSet5 < DeferredFrameTransformPointer, LightingModelPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, SubsurfaceScatteringResourcePointer>;
     using Config = RenderDeferredConfig;
     using JobModel = render::Job::ModelI<RenderDeferred, Inputs, Config>;
 
@@ -169,9 +166,6 @@ public:
     RenderDeferredCleanup cleanupJob;
 
 protected:
-
-    bool _enablePointLights{ true };
-    bool _enableSpotLights{ true };
 };
 
 #endif // hifi_DeferredLightingEffect_h

libraries/render-utils/src/LightingModel.cpp

@@ -0,0 +1,134 @@
+//
+//  LightingModel.cpp
+//  libraries/render-utils/src/
+//
+//  Created by Sam Gateau 7/1/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
+//
+#include "LightingModel.h"
+
+LightingModel::LightingModel() {
+    Parameters parameters;
+    _parametersBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(Parameters), (const gpu::Byte*) &parameters));
+}
+
+void LightingModel::setUnlit(bool enable) {
+    if (enable != isUnlitEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableUnlit = (float) enable;
+    }
+}
+bool LightingModel::isUnlitEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableUnlit;
+}
+
+void LightingModel::setShaded(bool enable) {
+    if (enable != isShadedEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableShaded = (float)enable;
+    }
+}
+bool LightingModel::isShadedEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableShaded;
+}
+
+void LightingModel::setEmissive(bool enable) {
+    if (enable != isEmissiveEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableEmissive = (float)enable;
+    }
+}
+bool LightingModel::isEmissiveEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableEmissive;
+}
+void LightingModel::setLightmap(bool enable) {
+    if (enable != isLightmapEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableLightmap = (float)enable;
+    }
+}
+bool LightingModel::isLightmapEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableLightmap;
+}
+
+void LightingModel::setScattering(bool enable) {
+    if (enable != isScatteringEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableScattering = (float)enable;
+    }
+}
+bool LightingModel::isScatteringEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableScattering;
+}
+
+void LightingModel::setDiffuse(bool enable) {
+    if (enable != isDiffuseEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableDiffuse = (float)enable;
+    }
+}
+bool LightingModel::isDiffuseEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableDiffuse;
+}
+void LightingModel::setSpecular(bool enable) {
+    if (enable != isSpecularEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableSpecular = (float)enable;
+    }
+}
+bool LightingModel::isSpecularEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableSpecular;
+}
+
+void LightingModel::setAmbientLight(bool enable) {
+    if (enable != isAmbientLightEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableAmbientLight = (float)enable;
+    }
+}
+bool LightingModel::isAmbientLightEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableAmbientLight;
+}
+void LightingModel::setDirectionalLight(bool enable) {
+    if (enable != isDirectionalLightEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableDirectionalLight = (float)enable;
+    }
+}
+bool LightingModel::isDirectionalLightEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableDirectionalLight;
+}
+void LightingModel::setPointLight(bool enable) {
+    if (enable != isPointLightEnabled()) {
+        _parametersBuffer.edit<Parameters>().enablePointLight = (float)enable;
+    }
+}
+bool LightingModel::isPointLightEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enablePointLight;
+}
+void LightingModel::setSpotLight(bool enable) {
+    if (enable != isSpotLightEnabled()) {
+        _parametersBuffer.edit<Parameters>().enableSpotLight = (float)enable;
+    }
+}
+bool LightingModel::isSpotLightEnabled() const {
+    return (bool)_parametersBuffer.get<Parameters>().enableSpotLight;
+}
+
+
+MakeLightingModel::MakeLightingModel() {
+    _lightingModel = std::make_shared<LightingModel>();
+}
+
+void MakeLightingModel::configure(const Config& config) {
+    _lightingModel->setUnlit(config.enableUnlit);
+    _lightingModel->setShaded(config.enableShaded);
+    _lightingModel->setEmissive(config.enableEmissive);
+    _lightingModel->setLightmap(config.enableLightmap);
+    _lightingModel->setScattering(config.enableScattering);
+    _lightingModel->setDiffuse(config.enableDiffuse);
+    _lightingModel->setSpecular(config.enableSpecular);
+    _lightingModel->setAmbientLight(config.enableAmbientLight);
+    _lightingModel->setDirectionalLight(config.enableDirectionalLight);
+    _lightingModel->setPointLight(config.enablePointLight);
+    _lightingModel->setSpotLight(config.enableSpotLight);
+}
+
+void MakeLightingModel::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, LightingModelPointer& lightingModel) {
+
+    lightingModel = _lightingModel;
+}

libraries/render-utils/src/LightingModel.h

@@ -0,0 +1,142 @@
+//
+//  LightingModel.h
+//  libraries/render-utils/src/
+//
+//  Created by Sam Gateau 7/1/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
+//
+
+#ifndef hifi_LightingModel_h
+#define hifi_LightingModel_h
+
+#include "gpu/Resource.h"
+#include "render/DrawTask.h"
+
+class RenderArgs;
+
+// LightingModel is  a helper class gathering in one place the flags to enable the lighting contributions
+class LightingModel {
+public:
+    using UniformBufferView = gpu::BufferView;
+
+    LightingModel();
+
+
+    void setUnlit(bool enable);
+    bool isUnlitEnabled() const;
+    void setShaded(bool enable);
+    bool isShadedEnabled() const;
+
+    void setEmissive(bool enable);
+    bool isEmissiveEnabled() const;
+    void setLightmap(bool enable);
+    bool isLightmapEnabled() const;
+
+    void setScattering(bool enable);
+    bool isScatteringEnabled() const;
+
+    void setDiffuse(bool enable);
+    bool isDiffuseEnabled() const;
+    void setSpecular(bool enable);
+    bool isSpecularEnabled() const;
+
+    void setAmbientLight(bool enable);
+    bool isAmbientLightEnabled() const;
+    void setDirectionalLight(bool enable);
+    bool isDirectionalLightEnabled() const;
+    void setPointLight(bool enable);
+    bool isPointLightEnabled() const;
+    void setSpotLight(bool enable);
+    bool isSpotLightEnabled() const;
+
+
+    UniformBufferView getParametersBuffer() const { return _parametersBuffer; }
+
+protected:
+
+
+    // Class describing the uniform buffer with the transform info common to the AO shaders
+    // It s changing every frame
+    class Parameters {
+    public:
+        float enableUnlit{ 1.0f };
+        float enableShaded{ 1.0f };
+        float enableEmissive{ 1.0f };
+        float enableLightmap{ 1.0f };
+
+        float enableScattering{ 1.0f };
+        float enableDiffuse{ 1.0f };
+        float enableSpecular{ 1.0f };
+        float spare;
+
+        float enableAmbientLight{ 1.0f };
+        float enableDirectionalLight{ 1.0f };
+        float enablePointLight{ 1.0f };
+        float enableSpotLight{ 1.0f };
+
+        Parameters() {}
+    };
+    UniformBufferView _parametersBuffer;
+};
+
+using LightingModelPointer = std::shared_ptr<LightingModel>;
+
+
+
+
+class MakeLightingModelConfig : public render::Job::Config {
+    Q_OBJECT
+
+    Q_PROPERTY(bool enableUnlit MEMBER enableUnlit NOTIFY dirty)
+    Q_PROPERTY(bool enableShaded MEMBER enableShaded NOTIFY dirty)
+    Q_PROPERTY(bool enableEmissive MEMBER enableEmissive NOTIFY dirty)
+    Q_PROPERTY(bool enableLightmap MEMBER enableLightmap NOTIFY dirty)
+
+    Q_PROPERTY(bool enableScattering MEMBER enableScattering NOTIFY dirty)
+    Q_PROPERTY(bool enableDiffuse MEMBER enableDiffuse NOTIFY dirty)
+    Q_PROPERTY(bool enableSpecular MEMBER enableSpecular NOTIFY dirty)
+
+    Q_PROPERTY(bool enableAmbientLight MEMBER enableAmbientLight NOTIFY dirty)
+    Q_PROPERTY(bool enableDirectionalLight MEMBER enableDirectionalLight NOTIFY dirty)
+    Q_PROPERTY(bool enablePointLight MEMBER enablePointLight NOTIFY dirty)
+    Q_PROPERTY(bool enableSpotLight MEMBER enableSpotLight NOTIFY dirty)
+
+public:
+    MakeLightingModelConfig() : render::Job::Config() {} // Make Lighting Model is always on
+
+    bool enableUnlit{ true };
+    bool enableShaded{ true };
+    bool enableEmissive{ true };
+    bool enableLightmap{ true };
+
+    bool enableScattering{ true };
+    bool enableDiffuse{ true };
+    bool enableSpecular{ true };
+
+    bool enableAmbientLight{ true };
+    bool enableDirectionalLight{ true };
+    bool enablePointLight{ true };
+    bool enableSpotLight{ true };
+
+signals:
+    void dirty();
+};
+
+class MakeLightingModel {
+public:
+    using Config = MakeLightingModelConfig;
+    using JobModel = render::Job::ModelO<MakeLightingModel, LightingModelPointer, Config>;
+
+    MakeLightingModel();
+
+    void configure(const Config& config);
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, LightingModelPointer& lightingModel);
+
+private:
+    LightingModelPointer _lightingModel;
+};
+
+#endif // hifi_SurfaceGeometryPass_h

libraries/render-utils/src/LightingModel.slh

@@ -0,0 +1,64 @@
+<!
+//  LightingModel.slh
+//  fragment shader
+//
+//  Created by Sam Gateau on 1/25/14.
+//  Copyright 2013 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
+!>
+<@if not LIGHTING_MODEL_SLH@>
+<@def LIGHTING_MODEL_SLH@>
+
+<@func declareLightingModel()@>
+
+struct LightingModel {
+    vec4 _UnlitShadedEmissiveLightmap;
+    vec4 _ScatteringDiffuseSpecular;
+    vec4 _AmbientDirectionalPointSpot;
+};
+
+uniform lightingModelBuffer {
+    LightingModel lightingModel;
+};
+
+float isUnlitEnabled() {
+    return lightingModel._UnlitShadedEmissiveLightmap.x;
+}
+float isShadedEnabled() {
+    return lightingModel._UnlitShadedEmissiveLightmap.y;
+}
+float isEmissiveEnabled() {
+    return lightingModel._UnlitShadedEmissiveLightmap.z;
+}
+float isLightmapEnabled() {
+    return lightingModel._UnlitShadedEmissiveLightmap.w;
+}
+
+float isScatteringEnabled() {
+    return lightingModel._ScatteringDiffuseSpecular.x;
+}
+float isDiffuseEnabled() {
+    return lightingModel._ScatteringDiffuseSpecular.y;
+}
+float isSpecularEnabled() {
+    return lightingModel._ScatteringDiffuseSpecular.z;
+}
+
+float isAmbientEnabled() {
+    return lightingModel._AmbientDirectionalPointSpot.x;
+}
+float isDirectionalEnabled() {
+    return lightingModel._AmbientDirectionalPointSpot.y;
+}
+float isPointEnabled() {
+    return lightingModel._AmbientDirectionalPointSpot.z;
+}
+float isSpotEnabled() {
+    return lightingModel._AmbientDirectionalPointSpot.w;
+}
+
+<@endfunc@>
+
+<@endif@>

libraries/render-utils/src/MaterialTextures.slh

@@ -91,7 +91,8 @@ float fetchOcclusionMap(vec2 uv) {
 <@if withScattering@>
 uniform sampler2D scatteringMap;
 float fetchScatteringMap(vec2 uv) {
-    //return step(0.5, texture(scatteringMap, uv).r); // boolean scattering for now
+    float scattering = texture(scatteringMap, uv).r; // boolean scattering for now
+    return max(((scattering - 0.1) / 0.9), 0.0);
     return texture(scatteringMap, uv).r; // boolean scattering for now
 }
 <@endif@>

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -25,6 +25,7 @@
 #include <render/DrawSceneOctree.h>
 #include <render/BlurTask.h>
 
+#include "LightingModel.h"
 #include "DebugDeferredBuffer.h"
 #include "DeferredLightingEffect.h"
 #include "SurfaceGeometryPass.h"
@@ -88,7 +89,9 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
     const auto background = filteredNonspatialBuckets[BACKGROUND_BUCKET];
 
     // Prepare deferred, generate the shared Deferred Frame Transform
-    const auto deferredFrameTransform = addJob<GenerateDeferredFrameTransform>("EvalDeferredFrameTransform");
+    const auto deferredFrameTransform = addJob<GenerateDeferredFrameTransform>("DeferredFrameTransform");
+    const auto lightingModel = addJob<MakeLightingModel>("LightingModel");
+
 
     // GPU jobs: Start preparing the deferred and lighting buffer
     addJob<PrepareDeferred>("PrepareDeferred");
@@ -125,7 +128,7 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
     // Draw Lights just add the lights to the current list of lights to deal with. NOt really gpu job for now.
     addJob<DrawLight>("DrawLight", lights);
 
-    const auto deferredLightingInputs = render::Varying(RenderDeferred::Inputs(deferredFrameTransform, curvatureFramebuffer, diffusedCurvatureFramebuffer, scatteringResource));
+    const auto deferredLightingInputs = render::Varying(RenderDeferred::Inputs(deferredFrameTransform, lightingModel, curvatureFramebuffer, diffusedCurvatureFramebuffer, scatteringResource));
    
     // DeferredBuffer is complete, now let's shade it into the LightingBuffer
     addJob<RenderDeferred>("RenderDeferred", deferredLightingInputs);

libraries/render-utils/src/SubsurfaceScattering.cpp

@@ -510,9 +510,10 @@ void DebugSubsurfaceScattering::run(const render::SceneContextPointer& sceneCont
 
 
     auto& frameTransform = inputs.get0();
-    auto& curvatureFramebuffer = inputs.get1();
-    auto& diffusedFramebuffer = inputs.get2();
-    auto& scatteringResource = inputs.get3();
+    auto& lightingModel = inputs.get1();
+    auto& curvatureFramebuffer = inputs.get2();
+    auto& diffusedFramebuffer = inputs.get3();
+    auto& scatteringResource = inputs.get4();
 
     if (!scatteringResource) {
         return;

libraries/render-utils/src/SubsurfaceScattering.h

@@ -16,6 +16,7 @@
 
 #include "render/DrawTask.h"
 #include "DeferredFrameTransform.h"
+#include "LightingModel.h"
 
 class SubsurfaceScatteringResource {
 public:
@@ -160,7 +161,7 @@ signals:
 
 class DebugSubsurfaceScattering {
 public:
-    using Inputs = render::VaryingSet4<DeferredFrameTransformPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, SubsurfaceScatteringResourcePointer>;
+    using Inputs = render::VaryingSet5<DeferredFrameTransformPointer, LightingModelPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, SubsurfaceScatteringResourcePointer>;
     using Config = DebugSubsurfaceScatteringConfig;
     using JobModel = render::Job::ModelI<DebugSubsurfaceScattering, Inputs, Config>;
 

libraries/render/src/render/Task.h

@@ -148,6 +148,32 @@ public:
     T3& edit3() { return std::get<3>((*this)).template edit<T3>(); }
 };
 
+
+template <class T0, class T1, class T2, class T3, class T4>
+class VaryingSet5 : public std::tuple<Varying, Varying, Varying, Varying, Varying>{
+public:
+    using Parent = std::tuple<Varying, Varying, Varying, Varying, Varying>;
+
+    VaryingSet5() : Parent(Varying(T0()), Varying(T1()), Varying(T2()), Varying(T3()), Varying(T4())) {}
+    VaryingSet5(const VaryingSet5& src) : Parent(std::get<0>(src), std::get<1>(src), std::get<2>(src), std::get<3>(src), std::get<4>(src)) {}
+    VaryingSet5(const Varying& first, const Varying& second, const Varying& third, const Varying& fourth, const Varying& fifth) : Parent(first, second, third, fourth, fifth) {}
+
+    const T0& get0() const { return std::get<0>((*this)).template get<T0>(); }
+    T0& edit0() { return std::get<0>((*this)).template edit<T0>(); }
+
+    const T1& get1() const { return std::get<1>((*this)).template get<T1>(); }
+    T1& edit1() { return std::get<1>((*this)).template edit<T1>(); }
+
+    const T2& get2() const { return std::get<2>((*this)).template get<T2>(); }
+    T2& edit2() { return std::get<2>((*this)).template edit<T2>(); }
+
+    const T3& get3() const { return std::get<3>((*this)).template get<T3>(); }
+    T3& edit3() { return std::get<3>((*this)).template edit<T3>(); }
+
+    const T4& get4() const { return std::get<4>((*this)).template get<T4>(); }
+    T4& edit4() { return std::get<4>((*this)).template edit<T4>(); }
+};
+
 template < class T, int NUM >
 class VaryingArray : public std::array<Varying, NUM> {
 public:

scripts/developer/utilities/render/deferredLighting.qml

@@ -16,16 +16,25 @@ Column {
     Column {
         id: deferredLighting
         spacing: 10
-
-        CheckBox {
-            text: "Point Lights"
-            checked: true
-            onCheckedChanged: { Render.getConfig("RenderDeferred").enablePointLights = checked }
-        }
-        CheckBox {
-            text: "Spot Lights"
-            checked: true
-            onCheckedChanged: { Render.getConfig("RenderDeferred").enableSpotLights = checked }
+        Repeater {
+            model: [
+                 "Unlit:LightingModel:enableUnlit", 
+                 "Shaded:LightingModel:enableShaded", 
+                 "Emissive:LightingModel:enableEmissive", 
+                 "Lightmap:LightingModel:enableLightmap",
+                 "Scattering:LightingModel:enableScattering",
+                 "Diffuse:LightingModel:enableDiffuse",
+                 "Specular:LightingModel:enableSpecular",
+                 "Ambient:LightingModel:enableAmbientLight",
+                 "Directional:LightingModel:enableDirectionalLight",
+                 "Point:LightingModel:enablePointLight",
+                 "Spot:LightingModel:enableSpotLight" 
+            ]
+            CheckBox {
+                text: modelData.split(":")[0]
+                checked: Render.getConfig(modelData.split(":")[1])
+                onCheckedChanged: { Render.getConfig(modelData.split(":")[1])[modelData.split(":")[2]] = checked }
+            }
         }
     }
 }