Trying to clean up the solution...

libraries/render-utils/src/RenderCommonTask.cpp

@@ -228,42 +228,6 @@ void ResolveFramebuffer::run(const render::RenderContextPointer& renderContext,
     });
 }
 
-void ResolveNewFramebuffer::run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs) {
-    RenderArgs* args = renderContext->args;
-    auto srcFbo = inputs;
-    outputs.reset();
-
-    // Check valid src
-    if (!srcFbo) {
-        return;
-    }
-
-    // Check valid size for sr and dest
-    auto frameSize(srcFbo->getSize());
-
-    // Resizing framebuffers instead of re-building them seems to cause issues with threaded rendering
-    if (_outputFramebuffer && _outputFramebuffer->getSize() != frameSize) {
-        _outputFramebuffer.reset();
-    }
-
-    if (!_outputFramebuffer) {
-        _outputFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("resolvedNew.out"));
-        auto colorFormat = gpu::Element::COLOR_SRGBA_32;
-        auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR);
-        auto colorTexture = gpu::Texture::createRenderBuffer(colorFormat, frameSize.x, frameSize.y, gpu::Texture::SINGLE_MIP, defaultSampler);
-        _outputFramebuffer->setRenderBuffer(0, colorTexture);
-    }
-
-    gpu::Vec4i rectSrc;
-    rectSrc.z = frameSize.x;
-    rectSrc.w = frameSize.y;
-    gpu::doInBatch("ResolveNew", args->_context, [&](gpu::Batch& batch) { batch.blit(srcFbo, rectSrc, _outputFramebuffer, rectSrc); });
-
-    outputs = _outputFramebuffer;
-}
-
-
-
  void ExtractFrustums::run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& output) {
     assert(renderContext->args);
     assert(renderContext->args->_context);

libraries/render-utils/src/RenderCommonTask.h

@@ -105,18 +105,6 @@ public:
     void run(const render::RenderContextPointer& renderContext, const Inputs& source, Outputs& dest);
 };
 
-class ResolveNewFramebuffer {
-public:
-    using Inputs = gpu::FramebufferPointer;
-    using Outputs = gpu::FramebufferPointer;
-    using JobModel = render::Job::ModelIO<ResolveNewFramebuffer, Inputs, Outputs>;
-
-    void run(const render::RenderContextPointer& renderContext, const Inputs& source, Outputs& dest);
-private:
-    gpu::FramebufferPointer _outputFramebuffer;
-};
-
-
 class ExtractFrustums {
 public:
 

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -242,8 +242,8 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     task.addJob<BloomEffect>("Bloom", bloomInputs);
 
     // Lighting Buffer ready for tone mapping
-    const auto toneMappingInputs = ToneMappingDeferred::Inputs(lightingFramebuffer, scaledPrimaryFramebuffer).asVarying();
+    const auto toneMappingInputs = ToneMappingDeferred::Input(lightingFramebuffer, scaledPrimaryFramebuffer).asVarying();
-    task.addJob<ToneMappingDeferred>("ToneMapping", toneMappingInputs);
+    const auto toneMappedBuffer = task.addJob<ToneMappingDeferred>("ToneMapping", toneMappingInputs);
 
     // 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
@@ -254,13 +254,15 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     }
 
     // Upscale to finale resolution
-    const auto primaryFramebuffer = task.addJob<render::Upsample>("PrimaryBufferUpscale", scaledPrimaryFramebuffer);
+    //const auto primaryFramebuffer = task.addJob<render::Upsample>("PrimaryBufferUpscale", toneMappedBuffer);
+    const auto primaryFramebuffer = task.addJob<render::UpsampleToBlitFramebuffer>("PrimaryBufferUpscale", toneMappedBuffer);
 
+    // HUD Layer
     const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(primaryFramebuffer, lightingModel, hudOpaque, hudTransparent).asVarying();
     task.addJob<RenderHUDLayerTask>("RenderHUDLayer", renderHUDLayerInputs);
 
     // Blit!
-    task.addJob<Blit>("Blit", primaryFramebuffer);
+  //  task.addJob<Blit>("Blit", primaryFramebuffer);
 }
 
 RenderDeferredTaskDebug::RenderDeferredTaskDebug() {

libraries/render-utils/src/RenderForwardTask.cpp

@@ -52,7 +52,7 @@ extern void initForwardPipelines(ShapePlumber& plumber);
 void RenderForwardTask::configure(const Config& config) {
     // Propagate resolution scale to sub jobs who need it
     auto preparePrimaryBufferConfig = config.getConfig<PreparePrimaryFramebufferMSAA>("PreparePrimaryBuffer");
-    auto upsamplePrimaryBufferConfig = config.getConfig<Upsample2>("PrimaryBufferUpscale");
+    auto upsamplePrimaryBufferConfig = config.getConfig<UpsampleToBlitFramebuffer>("PrimaryBufferUpscale");
     assert(preparePrimaryBufferConfig);
     assert(upsamplePrimaryBufferConfig);
     preparePrimaryBufferConfig->setResolutionScale(config.resolutionScale);
@@ -143,39 +143,43 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend
         task.addJob<DebugZoneLighting>("DrawZoneStack", debugZoneInputs);
     }
 
-
-    const auto newResolvedFramebuffer = task.addJob<NewFramebuffer>("MakeResolvingFramebuffer");
-    // Just resolve the msaa
-    const auto resolveInputs =
-      //  ResolveFramebuffer::Inputs(scaledPrimaryFramebuffer, static_cast<gpu::FramebufferPointer>(nullptr)).asVarying();
-        ResolveFramebuffer::Inputs(scaledPrimaryFramebuffer, newResolvedFramebuffer).asVarying();
-    const auto resolvedFramebuffer = task.addJob<ResolveFramebuffer>("Resolve", resolveInputs);
-   // auto resolvedFramebuffer = task.addJob<ResolveNewFramebuffer>("Resolve", framebuffer);
-
 #if defined(Q_OS_ANDROID)
-#else
+    const auto resolveInputs =
+          ResolveFramebuffer::Inputs(scaledPrimaryFramebuffer, static_cast<gpu::FramebufferPointer>(nullptr)).asVarying();
 
-    // Upscale to finale resolution
+    // Just resolve the msaa
-    const auto primaryFramebuffer = task.addJob<render::Upsample2>("PrimaryBufferUpscale", resolvedFramebuffer);
+     const auto resolvedFramebuffer = task.addJob<ResolveFramebuffer>("Resolve", resolveInputs);
+
+     const auto toneMappedBuffer = resolvedFramebuffer;
+#else
+    const auto newResolvedFramebuffer = task.addJob<NewFramebuffer>("MakeResolvingFramebuffer");
+
+    const auto resolveInputs = ResolveFramebuffer::Inputs(scaledPrimaryFramebuffer, newResolvedFramebuffer).asVarying();
+
+    // Just resolve the msaa
+    const auto resolvedFramebuffer = task.addJob<ResolveFramebuffer>("Resolve", resolveInputs);
 
     // Lighting Buffer ready for tone mapping
     // Forward rendering on GLES doesn't support tonemapping to and from the same FBO, so we specify 
     // the output FBO as null, which causes the tonemapping to target the blit framebuffer
     //  const auto toneMappingInputs = ToneMappingDeferred::Inputs(resolvedFramebuffer, static_cast<gpu::FramebufferPointer>(nullptr)).asVarying();
-      const auto toneMappingInputs = ToneMappingDeferred::Inputs(primaryFramebuffer, static_cast<gpu::FramebufferPointer>(nullptr)).asVarying();
+ //   const auto toneMappingInputs = ToneMappingDeferred::Input(resolvedFramebuffer, static_cast<gpu::FramebufferPointer>(nullptr)).asVarying();
-   // const auto toneMappingInputs = ToneMappingDeferred::Inputs(resolvedFramebuffer, newResolvedFramebuffer).asVarying();
+    const auto toneMappingInputs = ToneMappingDeferred::Input(resolvedFramebuffer, resolvedFramebuffer).asVarying();
-    task.addJob<ToneMappingDeferred>("ToneMapping", toneMappingInputs);
+    // const auto toneMappingInputs = ToneMappingDeferred::Input(resolvedFramebuffer, newResolvedFramebuffer).asVarying();
-
+    const auto toneMappedBuffer = task.addJob<ToneMappingDeferred>("ToneMapping", toneMappingInputs);
 
 #endif
 
+    // Upscale to finale resolution
+    const auto primaryFramebuffer = task.addJob<render::UpsampleToBlitFramebuffer>("PrimaryBufferUpscale", toneMappedBuffer);
+
     // HUD Layer
     const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(primaryFramebuffer, lightingModel, hudOpaque, hudTransparent).asVarying();
     task.addJob<RenderHUDLayerTask>("RenderHUDLayer", renderHUDLayerInputs);
 
     // Disable blit because we do tonemapping and compositing directly to the blit FBO
     // Blit!
-    // task.addJob<Blit>("Blit", framebuffer);
+    // task.addJob<Blit>("Blit", primaryFramebuffer);
 }
 
 gpu::FramebufferPointer PreparePrimaryFramebufferMSAA::createFramebuffer(const char* name, const glm::uvec2& frameSize, int numSamples) {

libraries/render-utils/src/ToneMappingEffect.cpp

@@ -47,14 +47,13 @@ void ToneMappingEffect::setToneCurve(ToneCurve curve) {
     }
 }
 
-void ToneMappingEffect::render(RenderArgs* args, const gpu::TexturePointer& lightingBuffer, const gpu::FramebufferPointer& requestedDestinationFramebuffer) {
+void ToneMappingEffect::render(RenderArgs* args, const gpu::TexturePointer& lightingBuffer, const gpu::FramebufferPointer& destinationFramebuffer) {
     if (!_blitLightBuffer) {
         init(args);
     }
-
+    
-    auto destinationFramebuffer = requestedDestinationFramebuffer;
+    if (!lightingBuffer || !destinationFramebuffer) {
-    if (!destinationFramebuffer) {
+        return;
-        destinationFramebuffer = args->_blitFramebuffer;
     }
 
     auto framebufferSize = glm::ivec2(lightingBuffer->getDimensions());
@@ -83,9 +82,15 @@ void ToneMappingDeferred::configure(const Config& config) {
     _toneMappingEffect.setToneCurve((ToneMappingEffect::ToneCurve)config.curve);
 }
 
-void ToneMappingDeferred::run(const render::RenderContextPointer& renderContext, const Inputs& inputs) {
+void ToneMappingDeferred::run(const render::RenderContextPointer& renderContext, const Input& input, Output& output) {
+
+    auto lightingBuffer = input.get0()->getRenderBuffer(0);
+    auto destFbo = input.get1();
+
+    if (!destFbo) {
+        destFbo = renderContext->args->_blitFramebuffer;
+    }
 
-    auto lightingBuffer = inputs.get0()->getRenderBuffer(0);
-    auto destFbo = inputs.get1();
     _toneMappingEffect.render(renderContext->args, lightingBuffer, destFbo);
+    output = destFbo;
 }

libraries/render-utils/src/ToneMappingEffect.h

@@ -82,12 +82,13 @@ signals:
 class ToneMappingDeferred {
 public:
     // Inputs: lightingFramebuffer, destinationFramebuffer
-    using Inputs = render::VaryingSet2<gpu::FramebufferPointer, gpu::FramebufferPointer>;
+    using Input = render::VaryingSet2<gpu::FramebufferPointer, gpu::FramebufferPointer>;
+    using Output = gpu::FramebufferPointer;
     using Config = ToneMappingConfig;
-    using JobModel = render::Job::ModelI<ToneMappingDeferred, Inputs, Config>;
+    using JobModel = render::Job::ModelIO<ToneMappingDeferred, Input, Output, Config>;
 
     void configure(const Config& config);
-    void run(const render::RenderContextPointer& renderContext, const Inputs& inputs);
+    void run(const render::RenderContextPointer& renderContext, const Input& input, Output& output);
 
     ToneMappingEffect _toneMappingEffect;
 };

libraries/render/src/render/ResampleTask.cpp

@@ -136,13 +136,13 @@ void Upsample::run(const RenderContextPointer& renderContext, const gpu::Framebu
     }
 }
 
-gpu::PipelinePointer Upsample2::_pipeline;
+gpu::PipelinePointer UpsampleToBlitFramebuffer::_pipeline;
 
-void Upsample2::configure(const Config& config) {
+void UpsampleToBlitFramebuffer::configure(const Config& config) {
     _factor = config.factor;
 }
 
-void Upsample2::run(const RenderContextPointer& renderContext, const Input& input, gpu::FramebufferPointer& resampledFrameBuffer) {
+void UpsampleToBlitFramebuffer::run(const RenderContextPointer& renderContext, const Input& input, gpu::FramebufferPointer& resampledFrameBuffer) {
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
     RenderArgs* args = renderContext->args;

libraries/render/src/render/ResampleTask.h

@@ -68,14 +68,14 @@ namespace render {
         gpu::FramebufferPointer getResampledFrameBuffer(const gpu::FramebufferPointer& sourceFramebuffer);
     };
 
-    class Upsample2 {
+    class UpsampleToBlitFramebuffer {
     public:
        // using Input = render::VaryingSet2<gpu::FramebufferPointer, gpu::FramebufferPointer>;
         using Input = gpu::FramebufferPointer;
         using Config = UpsampleConfig;
-        using JobModel = Job::ModelIO<Upsample2, Input, gpu::FramebufferPointer, Config>;
+        using JobModel = Job::ModelIO<UpsampleToBlitFramebuffer, Input, gpu::FramebufferPointer, Config>;
 
-        Upsample2(float factor = 2.0f) : _factor{ factor } {}
+        UpsampleToBlitFramebuffer(float factor = 2.0f) : _factor{ factor } {}
 
         void configure(const Config& config);
         void run(const RenderContextPointer& renderContext, const Input& input, gpu::FramebufferPointer& resampledFrameBuffer);