gathering the lighting stage jobs in their own task away from the renderer specificities

libraries/render-utils/src/AssembleLightingStageTask.cpp

@@ -0,0 +1,52 @@
+//
+//  Created by Samuel Gateau on 2018/12/06
+//  Copyright 2013-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 "AssembleLightingStageTask.h"
+
+
+void FetchCurrentFrames::run(const render::RenderContextPointer& renderContext, Outputs& outputs) {
+    auto lightStage = renderContext->_scene->getStage<LightStage>();
+    assert(lightStage);
+    outputs.edit0() = std::make_shared<LightStage::Frame>(lightStage->_currentFrame);
+
+    auto backgroundStage = renderContext->_scene->getStage<BackgroundStage>();
+    assert(backgroundStage);
+    outputs.edit1() = std::make_shared<BackgroundStage::Frame>(backgroundStage->_currentFrame);
+
+    auto hazeStage = renderContext->_scene->getStage<HazeStage>();
+    assert(hazeStage);
+    outputs.edit2() = std::make_shared<HazeStage::Frame>(hazeStage->_currentFrame);
+
+    auto bloomStage = renderContext->_scene->getStage<BloomStage>();
+    assert(bloomStage);
+    outputs.edit3() = std::make_shared<BloomStage::Frame>(bloomStage->_currentFrame);
+}
+
+
+void RenderUpdateLightingStagesTask::build(JobModel& task, const render::Varying& input, render::Varying& output) {
+    const auto& items = input.get<Inputs>();
+
+    const auto& metas = items[RenderFetchCullSortTask::META];
+
+    // Clear Light, Haze, Bloom, and Skybox Stages and render zones from the general metas bucket
+    const auto zones = task.addJob<ZoneRendererTask>("ZoneRenderer", metas);
+
+    // Draw Lights just add the lights to the current list of lights to deal with. NOt really gpu job for now.
+    task.addJob<DrawLight>("DrawLight", lights);
+
+    // Fetch the current frame stacks from all the stages
+    const auto currentStageFrames = task.addJob<FetchCurrentFrames>("FetchCurrentFrames");
+
+    const auto lightFrame = currentStageFrames.getN<FetchCurrentFrames::Outputs>(0);
+    const auto backgroundFrame = currentStageFrames.getN<FetchCurrentFrames::Outputs>(1);
+    const auto hazeFrame = currentStageFrames.getN<FetchCurrentFrames::Outputs>(2);
+    const auto bloomFrame = currentStageFrames.getN<FetchCurrentFrames::Outputs>(3);
+
+    outputs.edit0() = currentStageFrames;
+    outputs.edit1() = zones;
+}
+

libraries/render-utils/src/AssembleLightingStageTask.h

@@ -0,0 +1,44 @@
+//
+//  Created by Samuel Gateau on 2018/12/06
+//  Copyright 2013-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
+//
+
+#ifndef hifi_AssembleLightingStageTask_h
+#define hifi_AssembleLightingStageTask_h
+
+#include <render/RenderFetchCullSortTask.h>
+#include "LightingModel.h"
+
+#include "LightStage.h"
+#include "BackgroundStage.h"
+#include "HazeStage.h"
+#include "BloomStage.h"
+
+#include "ZoneRenderer.h"
+
+
+class FetchCurrentFrames {
+public:
+    using Outputs = render::VaryingSet4<LightStage::FramePointer, BackgroundStage::FramePointer, HazeStage::FramePointer, BloomStage::FramePointer>;
+    using JobModel = render::Job::ModelO<FetchCurrentFrames, Outputs>;
+
+    FetchCurrentFrames() {}
+
+    void run(const render::RenderContextPointer& renderContext, Outputs& outputs);
+};
+
+class AssembleLightingStageTask {
+public:
+    using Inputs = RenderFetchCullSortTask::BucketList;
+    using Outputs = render::VaryingSet2<FetchCurrentFrames::Outputs, ZoneRendererTask::Outputs>;
+    using JobModel = render::Task::ModelIO<FetchCurrentFrames, Inputs, Outputs>;
+
+    AssembleLightingStageTask() {}
+
+    void build(JobModel& task, const render::Varying& input, render::Varying& output);
+};
+
+#endif

libraries/render-utils/src/RenderCommonTask.cpp

@@ -232,20 +232,3 @@ void ExtractFrustums::run(const render::RenderContextPointer& renderContext, con
     }
 }
 
-void FetchCurrentFrames::run(const render::RenderContextPointer& renderContext, Outputs& outputs) {
-    auto lightStage = renderContext->_scene->getStage<LightStage>();
-    assert(lightStage);
-    outputs.edit0() = std::make_shared<LightStage::Frame>(lightStage->_currentFrame);
-
-    auto backgroundStage = renderContext->_scene->getStage<BackgroundStage>();
-    assert(backgroundStage);
-    outputs.edit1() = std::make_shared<BackgroundStage::Frame>(backgroundStage->_currentFrame);
-
-    auto hazeStage = renderContext->_scene->getStage<HazeStage>();
-    assert(hazeStage);
-    outputs.edit2() = std::make_shared<HazeStage::Frame>(hazeStage->_currentFrame);
-
-    auto bloomStage = renderContext->_scene->getStage<BloomStage>();
-    assert(bloomStage);
-    outputs.edit3() = std::make_shared<BloomStage::Frame>(bloomStage->_currentFrame);
-}

libraries/render-utils/src/RenderCommonTask.h

@@ -10,13 +10,8 @@
 #define hifi_RenderCommonTask_h
 
 #include <gpu/Pipeline.h>
-#include <render/RenderFetchCullSortTask.h>
-#include "LightingModel.h"
-
 #include "LightStage.h"
-#include "BackgroundStage.h"
-#include "HazeStage.h"
-#include "BloomStage.h"
+#include "LightingModel.h"
 
 class BeginGPURangeTimer {
 public:
@@ -118,26 +113,4 @@ public:
     void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& output);
 };
 
-
-class FetchCurrentFrames {
-public:
-    using Outputs = render::VaryingSet4<LightStage::FramePointer, BackgroundStage::FramePointer, HazeStage::FramePointer, BloomStage::FramePointer>;
-    using JobModel = render::Job::ModelO<FetchCurrentFrames, Outputs>;
-
-    FetchCurrentFrames() {}
-
-    void run(const render::RenderContextPointer& renderContext, Outputs& outputs);
-};
-
-class RenderUpdateStageLightingTask {
-public:
-    using Inputs = 
-    using Outputs = render::VaryingSet4<LightStage::FramePointer, BackgroundStage::FramePointer, HazeStage::FramePointer, BloomStage::FramePointer>;
-    using JobModel = render::Job::ModelIO<FetchCurrentFrames, Outputs>;
-
-    RenderUpdateStageLightingTask() {}
-
-    void run(const render::RenderContextPointer& renderContext, Outputs& outputs);
-};
-
 #endif // hifi_RenderDeferredTask_h

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -151,6 +151,17 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
 
     const auto& spatialSelection = fetchedItems[1];
 
+    // Extract the Lighting Stages Current frame ( and zones)
+    const auto& lightingStageInputs = inputs[1];
+    // Fetch the current frame stacks from all the stages
+    const auto& currentStageFrames = lightingStageInputs[0];
+    const auto& lightFrame = currentStageFrames[0];
+    const auto& backgroundFrame = currentStageFrames[1];
+    const auto& hazeFrame = currentStageFrames[2];
+    const auto& bloomFrame = currentStageFrames[3];
+   
+    const auto& zones = lightingStageInputs[1];
+
     fadeEffect->build(task, opaques);
 
     const auto jitter = task.addJob<JitterSample>("JitterCam");
@@ -207,19 +218,6 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     const auto velocityBufferOutputs = task.addJob<VelocityBufferPass>("VelocityBuffer", velocityBufferInputs);
     const auto velocityBuffer = velocityBufferOutputs.getN<VelocityBufferPass::Outputs>(0);
 
-/*    // Clear Light, Haze, Bloom, and Skybox Stages and render zones from the general metas bucket
-    const auto zones = task.addJob<ZoneRendererTask>("ZoneRenderer", metas);
-
-    // Draw Lights just add the lights to the current list of lights to deal with. NOt really gpu job for now.
-    task.addJob<DrawLight>("DrawLight", lights);
-
-    // Fetch the current frame stacks from all the stages
-    const auto currentStageFrames = task.addJob<FetchCurrentFrames>("FetchCurrentFrames");
-    const auto lightFrame = currentStageFrames.getN<FetchCurrentFrames::Outputs>(0);
-    const auto backgroundFrame = currentStageFrames.getN<FetchCurrentFrames::Outputs>(1);
-    const auto hazeFrame = currentStageFrames.getN<FetchCurrentFrames::Outputs>(2);
-    const auto bloomFrame = currentStageFrames.getN<FetchCurrentFrames::Outputs>(3);
-*/
     // Light Clustering
     // Create the cluster grid of lights, cpu job for now
     const auto lightClusteringPassInputs = LightClusteringPass::Inputs(deferredFrameTransform, lightingModel, lightFrame, linearDepthTarget).asVarying();
@@ -279,7 +277,7 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
 
     // Debugging task is happening in the "over" layer after tone mapping and just before HUD
     { // Debug the bounds of the rendered items, still look at the zbuffer
-        const auto debugInputs = RenderDeferredTaskDebug::Input(fetchedItems, inputs[1], zones, selectedItems, currentStageFrames, prepareDeferredOutputs, deferredFrameTransform, jitter, lightingModel).asVarying();
+        const auto debugInputs = RenderDeferredTaskDebug::Input(fetchedItems, inputs[2], zones, selectedItems, currentStageFrames, prepareDeferredOutputs, deferredFrameTransform, jitter, lightingModel).asVarying();
         task.addJob<RenderDeferredTaskDebug>("DebugRenderDeferredTask", debugInputs);
     }
 

libraries/render-utils/src/RenderDeferredTask.h

@@ -14,10 +14,10 @@
 
 #include <gpu/Pipeline.h>
 #include <render/RenderFetchCullSortTask.h>
+#include "AssembleLightingStageTask.h"
 #include "LightingModel.h"
 #include "LightClusters.h"
 #include "RenderShadowTask.h"
-#include "HazeStage.h"
 
 class DrawDeferredConfig : public render::Job::Config {
     Q_OBJECT
@@ -137,7 +137,7 @@ signals:
 
 class RenderDeferredTask {
 public:
-    using Input = render::VaryingSet2<RenderFetchCullSortTask::Output, RenderShadowTask::Output>;
+    using Input = render::VaryingSet3<RenderFetchCullSortTask::Output, AssembleLightingStageTask::Outputs, RenderShadowTask::Output>;
     using Config = RenderDeferredTaskConfig;
     using JobModel = render::Task::ModelI<RenderDeferredTask, Input, Config>;
 

libraries/render-utils/src/RenderForwardTask.cpp

@@ -48,12 +48,24 @@ using namespace render;
 extern void initForwardPipelines(ShapePlumber& plumber);
 
 void RenderForwardTask::build(JobModel& task, const render::Varying& input, render::Varying& output) {
-  //  const auto& inputs = input.get<Input>();
-    const auto& fetchedItems = input.get<Input>();
+    const auto& inputs = input.get<Input>();
+    const auto& fetchedItems = inputs.get0();
     //  const auto& fetchedItems = inputs[0];
     // const auto& items = fetchedItems[0];
     const auto& items = fetchedItems.get0();
 
+
+    const auto& lightingStageInputs = inputs[1];
+    // Fetch the current frame stacks from all the stages
+    const auto& currentStageFrames = lightingStageInputs[0];
+    const auto& lightFrame = currentStageFrames[0];
+    const auto& backgroundFrame = currentStageFrames[1];
+    const auto& hazeFrame = currentStageFrames[2];
+    const auto& bloomFrame = currentStageFrames[3];
+
+    const auto& zones = lightingStageInputs[1];
+
+
     auto fadeEffect = DependencyManager::get<FadeEffect>();
 
     // Prepare the ShapePipelines
@@ -82,12 +94,12 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend
     const auto lightingModel = task.addJob<MakeLightingModel>("LightingModel");
 
     // Filter zones from the general metas bucket
-    const auto zones = task.addJob<ZoneRendererTask>("ZoneRenderer", metas);
+   // const auto zones = task.addJob<ZoneRendererTask>("ZoneRenderer", metas);
 
     // Fetch the current frame stacks from all the stages
-    const auto currentFrames = task.addJob<FetchCurrentFrames>("FetchCurrentFrames");
-    const auto lightFrame = currentFrames.getN<FetchCurrentFrames::Outputs>(0);
-    const auto backgroundFrame = currentFrames.getN<FetchCurrentFrames::Outputs>(1);
+   // const auto currentFrames = task.addJob<FetchCurrentFrames>("FetchCurrentFrames");
+   // const auto lightFrame = currentFrames.getN<FetchCurrentFrames::Outputs>(0);
+   // const auto backgroundFrame = currentFrames.getN<FetchCurrentFrames::Outputs>(1);
     //const auto hazeFrame = currentFrames.getN<FetchCurrentFrames::Outputs>(2);
     //const auto bloomFrame = currentFrames.getN<FetchCurrentFrames::Outputs>(3);
 

libraries/render-utils/src/RenderForwardTask.h

@@ -14,12 +14,12 @@
 
 #include <gpu/Pipeline.h>
 #include <render/RenderFetchCullSortTask.h>
+#include "AssembleLightingStageTask.h"
 #include "LightingModel.h"
-#include "LightStage.h"
 
 class RenderForwardTask {
 public:
-    using Input = RenderFetchCullSortTask::Output;
+    using Input = render::VaryingSet2<RenderFetchCullSortTask::Output, AssembleLightingStageTask::Outputs>;
     using JobModel = render::Task::ModelI<RenderForwardTask, Input>;
 
     RenderForwardTask() {}

libraries/render-utils/src/RenderShadowTask.cpp

@@ -25,6 +25,7 @@
 #include "RenderUtilsLogging.h"
 
 #include "RenderCommonTask.h"
+#include "AssembleLightingStageTask.h"
 
 #include "FadeEffect.h"
 

libraries/render-utils/src/RenderViewTask.cpp

@@ -10,6 +10,7 @@
 //
 #include "RenderViewTask.h"
 
+#include "AssembleLightingStageTask.h"
 #include "RenderShadowTask.h"
 #include "RenderDeferredTask.h"
 #include "RenderForwardTask.h"
@@ -20,14 +21,17 @@ void RenderViewTask::build(JobModel& task, const render::Varying& input, render:
     const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, tagBits, tagMask);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
 
+
+    const auto lightingStageFramesAndZones = task.addJob<AssembleLightingStageTask>("AssembleStages", items[0]);
+
     if (isDeferred) {
         // Warning : the cull functor passed to the shadow pass should only be testing for LOD culling. If frustum culling
         // is performed, then casters not in the view frustum will be removed, which is not what we wish.
         const auto cascadeSceneBBoxes = task.addJob<RenderShadowTask>("RenderShadowTask", cullFunctor, tagBits, tagMask);
-        const auto renderInput = RenderDeferredTask::Input(items, cascadeSceneBBoxes).asVarying();
+        const auto renderInput = RenderDeferredTask::Input(items, lightingStageFramesAndZones, cascadeSceneBBoxes).asVarying();
         task.addJob<RenderDeferredTask>("RenderDeferredTask", renderInput, true);
     } else {
-        task.addJob<RenderForwardTask>("Forward", items);
+        task.addJob<RenderForwardTask>("Forward", items, lightingStageFramesAndZones);
     }
 }
 

libraries/task/src/task/Varying.h

@@ -155,6 +155,13 @@ public:
     Varying asVarying() const { return Varying((*this)); }
 };
 
+template <class T0, class T1, class T2> Varying varyingGetSub(const VaryingSet3<T0, T1, T2>& dat, uint8_t index) {
+    return data[index];
+}
+template <class T0, class T1, class T2> uint8_t varyingGetLength(const VaryingSet3<T0, T1, T2>& data) {
+    return data.length();
+}
+
 template <class T0, class T1, class T2, class T3>
 class VaryingSet4 : public std::tuple<Varying, Varying, Varying, Varying>{
 public:
@@ -191,7 +198,12 @@ public:
 
     Varying asVarying() const { return Varying((*this)); }
 };
-
+template <class T0, class T1, class T2, class T3> Varying varyingGetSub(const VaryingSet4<T0, T1, T2, T3>& dat, uint8_t index) {
+    return data[index];
+}
+template <class T0, class T1, class T2, class T3> uint8_t varyingGetLength(const VaryingSet4<T0, T1, T2, T3>& data) {
+    return data.length();
+}
 
 template <class T0, class T1, class T2, class T3, class T4>
 class VaryingSet5 : public std::tuple<Varying, Varying, Varying, Varying, Varying>{
@@ -234,6 +246,12 @@ public:
 
     Varying asVarying() const { return Varying((*this)); }
 };
+template <class T0, class T1, class T2, class T3, class T4> Varying varyingGetSub(const VaryingSet5<T0, T1, T2, T3, T4>& dat, uint8_t index) {
+    return data[index];
+}
+template <class T0, class T1, class T2, class T3, class T4> uint8_t varyingGetLength(const VaryingSet5<T0, T1, T2, T3, T4>& data) {
+    return data.length();
+}
 
 template <class T0, class T1, class T2, class T3, class T4, class T5>
 class VaryingSet6 : public std::tuple<Varying, Varying, Varying, Varying, Varying, Varying>{
@@ -282,6 +300,12 @@ public:
 
     Varying asVarying() const { return Varying((*this)); }
 };
+template <class T0, class T1, class T2, class T3, class T4, class T5> Varying varyingGetSub(const VaryingSet6<T0, T1, T2, T3, T4, T5>& dat, uint8_t index) {
+    return data[index];
+}
+template <class T0, class T1, class T2, class T3, class T4, class T5> uint8_t varyingGetLength(const VaryingSet6<T0, T1, T2, T3, T4, T5>& data) {
+    return data.length();
+}
 
 template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
 class VaryingSet7 : public std::tuple<Varying, Varying, Varying, Varying, Varying, Varying, Varying>{
@@ -335,6 +359,12 @@ public:
 
     Varying asVarying() const { return Varying((*this)); }
 };
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> Varying varyingGetSub(const VaryingSet7<T0, T1, T2, T3, T4, T5, T6>& dat, uint8_t index) {
+    return data[index];
+}
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> uint8_t varyingGetLength(const VaryingSet7<T0, T1, T2, T3, T4, T5, T6>& data) {
+    return data.length();
+}
 
 template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
 class VaryingSet8 : public std::tuple<Varying, Varying, Varying, Varying, Varying, Varying, Varying, Varying> {
@@ -393,6 +423,12 @@ public:
 
     Varying asVarying() const { return Varying((*this)); }
 };
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7> Varying varyingGetSub(const VaryingSet8<T0, T1, T2, T3, T4, T5, T6, T7>& dat, uint8_t index) {
+    return data[index];
+}
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7> uint8_t varyingGetLength(const VaryingSet8<T0, T1, T2, T3, T4, T5, T6, T7>& data) {
+    return data.length();
+}
 
 template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
 class VaryingSet9 : public std::tuple<Varying, Varying, Varying, Varying, Varying, Varying, Varying, Varying, Varying> {
@@ -455,6 +491,12 @@ public:
 
     Varying asVarying() const { return Varying((*this)); }
 };
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> Varying varyingGetSub(const VaryingSet9<T0, T1, T2, T3, T4, T5, T6, T7, T8>& dat, uint8_t index) {
+    return data[index];
+}
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> uint8_t varyingGetLength(const VaryingSet9<T0, T1, T2, T3, T4, T5, T6, T7, T8>& data) {
+    return data.length();
+}
 
 template < class T, int NUM >
 class VaryingArray : public std::array<Varying, NUM> {
@@ -470,6 +512,13 @@ public:
         std::copy(list.begin(), list.end(), std::array<Varying, NUM>::begin());
     }
 };
+template <class T, int NUM > Varying varyingGetSub(const VaryingArray<T, NUM>& dat, uint8_t index) {
+    return data[index];
+}
+template <class T, int NUM > uint8_t varyingGetLength(const VaryingArray<T, NUM>& data) {
+    return NUM;
+}
+
 }
 
 #endif // hifi_task_Varying_h