Pushing a shitty state where the pairs of Varyings don;t get copied correctly

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -115,14 +115,16 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
 
     addJob<render::BlurGaussianDepthAware>("DiffuseCurvature", curvatureFramebufferAndDepth);
 
-
+    const auto diffusedCurvatureFramebuffer = addJob<render::BlurGaussianDepthAware>("DiffuseCurvature2", curvatureFramebufferAndDepth, true);
+    
     // AO job
     addJob<AmbientOcclusionEffect>("AmbientOcclusion");
 
     // 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 scatteringFramebuffer = addJob<SubsurfaceScattering>("Scattering", deferredFrameTransform);
+    const auto scatteringInputs = render::Varying(SubsurfaceScattering::Inputs(deferredFrameTransform, curvatureFramebufferAndDepth[0]));
+    const auto scatteringFramebuffer = addJob<SubsurfaceScattering>("Scattering", scatteringInputs);
 
     // DeferredBuffer is complete, now let's shade it into the LightingBuffer
     addJob<RenderDeferred>("RenderDeferred");

libraries/render-utils/src/SubsurfaceScattering.cpp

@@ -102,7 +102,7 @@ bool SubsurfaceScattering::updateScatteringFramebuffer(const gpu::FramebufferPoi
 
         // attach depthStencil if present in source
         if (sourceFramebuffer->hasDepthStencil()) {
-            _scatteringFramebuffer->setDepthStencilBuffer(sourceFramebuffer->getDepthStencilBuffer(), sourceFramebuffer->getDepthStencilBufferFormat());
+     //       _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));
@@ -126,7 +126,7 @@ bool SubsurfaceScattering::updateScatteringFramebuffer(const gpu::FramebufferPoi
 }
 
 
-void SubsurfaceScattering::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform, gpu::FramebufferPointer& scatteringFramebuffer) {
+void SubsurfaceScattering::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const Inputs& inputs, gpu::FramebufferPointer& scatteringFramebuffer) {
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
 
@@ -138,10 +138,14 @@ void SubsurfaceScattering::run(const render::SceneContextPointer& sceneContext,
 
 
     auto pipeline = getScatteringPipeline();
+    
+    auto& frameTransform = inputs.first. template get<DeferredFrameTransformPointer>();//getFirst();
+    auto& curvatureFramebuffer = inputs.second. template get<gpu::FramebufferPointer>();//getSecond();
+    
 
     auto framebufferCache = DependencyManager::get<FramebufferCache>();
  
-    if (!updateScatteringFramebuffer(framebufferCache->getCurvatureFramebuffer(), scatteringFramebuffer)) {
+    if (!updateScatteringFramebuffer(curvatureFramebuffer, scatteringFramebuffer)) {
         return;
     }
 
@@ -156,7 +160,7 @@ void SubsurfaceScattering::run(const render::SceneContextPointer& sceneContext,
 
         batch.setPipeline(pipeline);
         batch.setResourceTexture(SubsurfaceScattering_NormalMapSlot, framebufferCache->getDeferredNormalTexture());
-        batch.setResourceTexture(SubsurfaceScattering_CurvatureMapSlot, framebufferCache->getCurvatureTexture());
+        batch.setResourceTexture(SubsurfaceScattering_CurvatureMapSlot, curvatureFramebuffer->getRenderBuffer(0));
         batch.setResourceTexture(SubsurfaceScattering_ScatteringTableSlot, _scatteringTable);
         batch.draw(gpu::TRIANGLE_STRIP, 4);
 

libraries/render-utils/src/SubsurfaceScattering.h

@@ -33,13 +33,15 @@ signals:
 
 class SubsurfaceScattering {
 public:
+    using Inputs = render::VaryingPair;//<DeferredFrameTransformPointer, gpu::FramebufferPointer>;
+    //using Inputs = render::VaryingPairBase;//<gpu::FramebufferPointer, gpu::TexturePointer>;
     using Config = SubsurfaceScatteringConfig;
-    using JobModel = render::Job::ModelIO<SubsurfaceScattering, DeferredFrameTransformPointer, gpu::FramebufferPointer, Config>;
+    using JobModel = render::Job::ModelIO<SubsurfaceScattering, Inputs, gpu::FramebufferPointer, Config>;
 
     SubsurfaceScattering();
 
     void configure(const Config& config);
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform, gpu::FramebufferPointer& scatteringFramebuffer);
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const Inputs& inputs, gpu::FramebufferPointer& scatteringFramebuffer);
     
     float getCurvatureDepthThreshold() const { return _parametersBuffer.get<Parameters>().curvatureInfo.x; }
 

libraries/render-utils/src/SurfaceGeometryPass.cpp

@@ -45,7 +45,7 @@ void SurfaceGeometryPass::configure(const Config& config) {
     }
 }
 
-void SurfaceGeometryPass::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform, InputPair& curvatureAndDepth) {
+void SurfaceGeometryPass::run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform, Outputs& curvatureAndDepth) {
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
 
@@ -59,8 +59,8 @@ void SurfaceGeometryPass::run(const render::SceneContextPointer& sceneContext, c
     
     auto pyramidTexture = framebufferCache->getDepthPyramidTexture();
     auto curvatureFBO = framebufferCache->getCurvatureFramebuffer();
-    curvatureAndDepth.editFirst() = curvatureFBO;
-    curvatureAndDepth.editSecond() = pyramidTexture;
+    curvatureAndDepth.first. template edit<gpu::FramebufferPointer>() = curvatureFBO;
+    curvatureAndDepth.second. template edit<gpu::TexturePointer>() = pyramidTexture;
 
     auto curvatureTexture = framebufferCache->getCurvatureTexture();
 
@@ -154,8 +154,6 @@ const gpu::PipelinePointer& SurfaceGeometryPass::getCurvaturePipeline() {
         // Stencil test the curvature pass for objects pixels only, not the background
         state->setStencilTest(true, 0xFF, gpu::State::StencilTest(0, 0xFF, gpu::NOT_EQUAL, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_KEEP));
 
-      //  state->setColorWriteMask(true, false, false, false);
-
         // Good to go add the brand new pipeline
         _curvaturePipeline = gpu::Pipeline::create(program, state);
     }

libraries/render-utils/src/SurfaceGeometryPass.h

@@ -40,14 +40,14 @@ signals:
 
 class SurfaceGeometryPass {
 public:
-    using InputPair = render::VaryingPair<gpu::FramebufferPointer, gpu::TexturePointer>;
+    using Outputs = render::VaryingPair;//<gpu::FramebufferPointer, gpu::TexturePointer>;
     using Config = SurfaceGeometryPassConfig;
-    using JobModel = render::Job::ModelIO<SurfaceGeometryPass, DeferredFrameTransformPointer, InputPair, Config>;
+    using JobModel = render::Job::ModelIO<SurfaceGeometryPass, DeferredFrameTransformPointer, Outputs, Config>;
 
     SurfaceGeometryPass();
 
     void configure(const Config& config);
-    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform, InputPair& curvatureAndDepth);
+    void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const DeferredFrameTransformPointer& frameTransform, Outputs& curvatureAndDepth);
     
     float getCurvatureDepthThreshold() const { return _parametersBuffer.get<Parameters>().curvatureInfo.x; }
     float getCurvatureBasisScale() const { return _parametersBuffer.get<Parameters>().curvatureInfo.y; }

libraries/render-utils/src/subsurfaceScattering_drawScattering.slf

@@ -100,9 +100,10 @@ void main(void) {
     
  //   _fragColor = vec4(fetchBRDF(dot(bentNormalR, lightVector), abs(diffusedCurvature.w * 2 - 1)), 1.0);
 
-    _fragColor = vec4(bentNormalR * lightVector, 1.0);
+ //    _fragColor = vec4(vec3(abs(dot(bentNormalR, lightVector))), 1.0);
+     _fragColor = vec4(vec3(varTexCoord0, 0.0), 1.0);
 
-    //_fragColor = vec4(vec3(bentNormalR * 0.5 + 0.5), 1.0);
+  //  _fragColor = vec4(vec3(bentNormalR * 0.5 + 0.5), 1.0);
 
 
 /*

libraries/render/src/render/BlurTask.cpp

@@ -202,7 +202,9 @@ void BlurGaussian::run(const SceneContextPointer& sceneContext, const RenderCont
 
 
 
-BlurGaussianDepthAware::BlurGaussianDepthAware() {
+BlurGaussianDepthAware::BlurGaussianDepthAware(bool generateOutputFramebuffer) :
+    _generateOutputFramebuffer(generateOutputFramebuffer)
+{
     _parameters = std::make_shared<BlurParams>();
 }
 
@@ -276,12 +278,40 @@ bool BlurGaussianDepthAware::updateBlurringResources(const gpu::FramebufferPoint
             }
         }
     }
-
+    
     blurringResources.sourceTexture = sourceFramebuffer->getRenderBuffer(0);
     blurringResources.blurringFramebuffer = _blurredFramebuffer;
     blurringResources.blurringTexture = _blurredFramebuffer->getRenderBuffer(0);
-    blurringResources.finalFramebuffer = sourceFramebuffer;
 
+    if (_generateOutputFramebuffer) {
+        // The job output the blur result in a new Framebuffer spawning here.
+        // Let s make sure it s ready for this
+        if (!_outputFramebuffer) {
+            _outputFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
+            
+            // attach depthStencil if present in source
+            if (sourceFramebuffer->hasDepthStencil()) {
+                _outputFramebuffer->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));
+            _outputFramebuffer->setRenderBuffer(0, blurringTarget);
+        } else {
+            if ((_outputFramebuffer->getWidth() != sourceFramebuffer->getWidth()) || (_outputFramebuffer->getHeight() != sourceFramebuffer->getHeight())) {
+                _outputFramebuffer->resize(sourceFramebuffer->getWidth(), sourceFramebuffer->getHeight(), sourceFramebuffer->getNumSamples());
+                if (sourceFramebuffer->hasDepthStencil()) {
+                    _outputFramebuffer->setDepthStencilBuffer(sourceFramebuffer->getDepthStencilBuffer(), sourceFramebuffer->getDepthStencilBufferFormat());
+                }
+            }
+        }
+        
+        // Should be good to use the output Framebuffer as final
+        blurringResources.finalFramebuffer = _outputFramebuffer;
+    } else {
+        // Just the reuse the input as output to blur itself.
+        blurringResources.finalFramebuffer = sourceFramebuffer;
+    }
+    
     return true;
 }
 
@@ -291,20 +321,22 @@ void BlurGaussianDepthAware::configure(const Config& config) {
 }
 
 
-void BlurGaussianDepthAware::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const InputPair& SourceAndDepth) {
+void BlurGaussianDepthAware::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const Inputs& SourceAndDepth, gpu::FramebufferPointer& blurredFramebuffer) {
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
 
     RenderArgs* args = renderContext->args;
 
-    auto& sourceFramebuffer = SourceAndDepth.getFirst();
-    auto& depthTexture = SourceAndDepth.getSecond();
+    auto& sourceFramebuffer = SourceAndDepth.first. template get<gpu::FramebufferPointer>();//getFirst();
+    auto& depthTexture = SourceAndDepth.second. template get<gpu::TexturePointer>();//getSecond();
 
     BlurringResources blurringResources;
     if (!updateBlurringResources(sourceFramebuffer, blurringResources)) {
         // early exit if no valid blurring resources
         return;
     }
+    
+    blurredFramebuffer = blurringResources.finalFramebuffer;
 
     auto blurVPipeline = getBlurVPipeline();
     auto blurHPipeline = getBlurHPipeline();

libraries/render/src/render/BlurTask.h

@@ -108,14 +108,15 @@ protected:
 
 class BlurGaussianDepthAware {
 public:
-    using InputPair = VaryingPair<gpu::FramebufferPointer, gpu::TexturePointer>;
+    using Inputs = VaryingPair;//<gpu::FramebufferPointer, gpu::TexturePointer>;
+   // using InputPair = VaryingPairBase;//<gpu::FramebufferPointer, gpu::TexturePointer>;
     using Config = BlurGaussianDepthAwareConfig;
-    using JobModel = Job::ModelI<BlurGaussianDepthAware, InputPair, Config>;
+    using JobModel = Job::ModelIO<BlurGaussianDepthAware, Inputs, gpu::FramebufferPointer, Config>;
 
-    BlurGaussianDepthAware();
+    BlurGaussianDepthAware(bool generateNewOutput = false);
 
     void configure(const Config& config);
-    void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const InputPair& SourceAndDepth);
+    void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const Inputs& SourceAndDepth, gpu::FramebufferPointer& blurredFramebuffer);
 
 protected:
 
@@ -129,6 +130,10 @@ protected:
 
     gpu::FramebufferPointer _blurredFramebuffer;
 
+    // the output framebuffer defined if the job needs to output the result in a new framebuffer and not in place in th einput buffer
+    gpu::FramebufferPointer _outputFramebuffer;
+    bool _generateOutputFramebuffer { false };
+    
     struct BlurringResources {
         gpu::TexturePointer sourceTexture;
         gpu::FramebufferPointer blurringFramebuffer;

libraries/render/src/render/Task.cpp

@@ -23,3 +23,18 @@ void TaskConfig::refresh() {
 
     _task->configure(*this);
 }
+
+
+namespace render{
+    
+    template <> void varyingGet(const VaryingPair& data, uint8_t index, Varying& var) {
+        if (index == 0) {
+            var = data.first;
+        } else {
+            var = data.second;
+        }
+    }
+        
+    template <> uint8_t varyingLength(const VaryingPair& data) { return 2; }
+    
+}

libraries/render/src/render/Task.h

@@ -28,21 +28,38 @@
 
 namespace render {
 
+class Varying;
+    
+    template <class T> void varyingGet(const T& data, uint8_t index, Varying& var) {}
+template <class T> uint8_t varyingLength(const T& data) { return 0; }
+    
 // A varying piece of data, to be used as Job/Task I/O
 // TODO: Task IO
 class Varying {
 public:
     Varying() {}
     Varying(const Varying& var) : _concept(var._concept) {}
+    Varying& operator=(const Varying& var) {
+        _concept = var._concept;
+        return (*this);
+    }
     template <class T> Varying(const T& data) : _concept(std::make_shared<Model<T>>(data)) {}
 
     template <class T> T& edit() { return std::static_pointer_cast<Model<T>>(_concept)->_data; }
     template <class T> const T& get() const { return std::static_pointer_cast<const Model<T>>(_concept)->_data; }
 
+    
+    // access potential sub varyings contained in this one.
+    Varying operator[] (uint8_t index) const { return (*_concept)[index]; }
+    uint8_t length() const { return _concept->length(); }
+    
 protected:
     class Concept {
     public:
         virtual ~Concept() = default;
+    
+        virtual Varying operator[] (uint8_t index) const = 0;
+        virtual uint8_t length() const = 0;
     };
     template <class T> class Model : public Concept {
     public:
@@ -50,6 +67,14 @@ protected:
 
         Model(const Data& data) : _data(data) {}
         virtual ~Model() = default;
+        
+        
+        virtual Varying operator[] (uint8_t index) const {
+            Varying var;
+            varyingGet<T>(_data, index, var);
+            return var;
+        }
+        virtual uint8_t length() const { return varyingLength<T>(_data); }
 
         Data _data;
     };
@@ -58,20 +83,82 @@ protected:
 };
 
 
+
+ 
+using VaryingPair = std::pair<Varying, Varying>;
+/*
+class VaryingPairBase {
+    public:
+    Varying first;
+    Varying second;
+    
+    
+        //  template < class T0, class T1> VaryingPairBase() : Parent(Varying(T0()), Varying(T1())) {}
+      //  VaryingPairBase(const VaryingPairBase& pair) : Parent(pair.first, pair.second) {}
+        VaryingPairBase(const Varying& _first, const Varying& _second) : first(_first), second(_second) {}
+        
+};
+  */  /*
 template < class T0, class T1 >
 class VaryingPair : public std::pair<Varying, Varying> {
 public:
     using Parent = std::pair<Varying, Varying>;
 
-    VaryingPair() : Parent(Varying(T0()), T1()) {}
-    
+    VaryingPair() : Parent(Varying(T0()), Varying(T1())) {}
+    VaryingPair(const VaryingPair& pair) : Parent(pair.first, pair.second) {}
+    VaryingPair(const Varying& first, const Varying& second) : Parent(first, second) {}
+
     const T0& getFirst() const { return first.get<T0>(); }
     T0& editFirst() { return first.edit<T0>(); }
 
     const T1& getSecond() const { return second.get<T1>(); }
     T1& editSecond() { return second.edit<T1>(); }
-};
 
+};
+    */
+    
+    template <> void varyingGet(const VaryingPair& data, uint8_t index, Varying& var);
+    template <> uint8_t varyingLength(const VaryingPair& data);
+ /*   template <class T> Varying varyingGet(const T& data, uint8_t index) {
+        return Varying(T());
+    }*/
+
+//template <T0, T1> Varying varyingGet(template VaryingPair<T0, T1>& data, uint8_t index);
+//template <> uint8_t varyingLength(template VaryingPair<T0, T1>& data);
+
+
+/*
+template < class T0, class T1 >
+class VaryingPair : Varying {
+public:
+    using Parent = Varying;
+    using Pair = std::pair<Varying, Varying>;
+    
+    VaryingPair() : Parent(Pair(Varying(T0()), Varying(T1()))) {}
+    VaryingPair(const Varying& first, const Varying& second) : Parent(Pair(first, second)) {}
+    
+    
+    Pair& editPair() { return edit<Pair>(); }
+    const Pair& getPair() const { return get<Pair>(); }
+
+    const T0& getFirst() const { return getPair().first.template get<T0>(); }
+    T0& editFirst() { return editPair().first.template edit<T0>(); }
+    
+    const T1& getSecond() const { return getPair().second.template get<T1>(); }
+    T1& editSecond() { return editPair().second.template edit<T1>(); }
+    
+    // access potential sub varyings contained in this one.
+    virtual Varying operator[] (uint8_t index) const {
+        if (index == 0) {
+            return getPair().first;
+        } else {
+            return getPair().second;
+        } }
+    virtual uint8_t length() const { return 2; }
+    
+};
+ */
+    
 template < class T, int NUM >
 class VaryingArray : public std::array<Varying, NUM> {
 public: