getting rescaling to work for forward yop

libraries/render-utils/src/DeferredLightingEffect.h

@@ -93,7 +93,7 @@ class PreparePrimaryFramebufferConfig : public render::Job::Config {
 public:
     float getResolutionScale() const { return resolutionScale; }
     void setResolutionScale(float scale) {
-        resolutionScale = std::max(0.1f, std::min(1.0f, resolutionScale));
+        resolutionScale = std::max(0.1f, std::min(2.0f, scale));
     }
 
 signals:

libraries/render-utils/src/RenderCommonTask.cpp

@@ -205,6 +205,27 @@ void Blit::run(const RenderContextPointer& renderContext, const gpu::Framebuffer
     });
 }
 
+void NewFramebuffer::run(const render::RenderContextPointer& renderContext, const Input& input, Output& output) {
+    RenderArgs* args = renderContext->args;
+   // auto frameSize = input;
+    output.reset();
+
+    glm::uvec2 frameSize(args->_viewport.z, args->_viewport.w);
+
+    if (_outputFramebuffer && _outputFramebuffer->getSize() != frameSize) {
+        _outputFramebuffer.reset();
+    }
+
+    if (!_outputFramebuffer) {
+        _outputFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("newFramebuffer.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);
+    }
+
+    output = _outputFramebuffer;
+}
 
 void ResolveFramebuffer::run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs) {
     RenderArgs* args = renderContext->args;

libraries/render-utils/src/RenderCommonTask.h

@@ -95,6 +95,17 @@ public:
 };
 
 
+class NewFramebuffer {
+public:
+    using Input = glm::uvec2;
+    using Output = gpu::FramebufferPointer;
+    using JobModel = render::Job::ModelIO<NewFramebuffer, Input, Output>;
+
+    void run(const render::RenderContextPointer& renderContext, const Input& input, Output& output);
+private:
+    gpu::FramebufferPointer _outputFramebuffer;
+};
+
 class ResolveFramebuffer {
 public:
     using Inputs = render::VaryingSet2<gpu::FramebufferPointer, gpu::FramebufferPointer>;

libraries/render-utils/src/RenderForwardTask.cpp

@@ -19,6 +19,7 @@
 #include <gpu/Texture.h>
 #include <graphics/ShaderConstants.h>
 #include <render/ShapePipeline.h>
+#include <render/ResampleTask.h>
 
 #include <render/FilterTask.h>
 
@@ -50,11 +51,11 @@ 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<Upsample>("PrimaryBufferUpscale");
+    auto upsamplePrimaryBufferConfig = config.getConfig<Upsample2>("PrimaryBufferUpscale");
     assert(preparePrimaryBufferConfig);
-//    assert(upsamplePrimaryBufferConfig);
+    assert(upsamplePrimaryBufferConfig);
     preparePrimaryBufferConfig->setResolutionScale(config.resolutionScale);
- //   upsamplePrimaryBufferConfig->setProperty("factor", 1.0f / config.resolutionScale);
+    upsamplePrimaryBufferConfig->setProperty("factor", 1.0f / config.resolutionScale);
 }
 
 void RenderForwardTask::build(JobModel& task, const render::Varying& input, render::Varying& output) {
@@ -141,24 +142,35 @@ 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, 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);
+   // auto resolvedFramebuffer = task.addJob<ResolveNewFramebuffer>("Resolve", framebuffer);
 
 #if defined(Q_OS_ANDROID)
 #else
+
+    // Upscale to finale resolution
+    const auto primaryFramebuffer = task.addJob<render::Upsample2>("PrimaryBufferUpscale", resolvedFramebuffer);
+
     // 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(resolvedFramebuffer, static_cast<gpu::FramebufferPointer>(nullptr)).asVarying();
+      const auto toneMappingInputs = ToneMappingDeferred::Inputs(primaryFramebuffer, static_cast<gpu::FramebufferPointer>(nullptr)).asVarying();
+   // const auto toneMappingInputs = ToneMappingDeferred::Inputs(resolvedFramebuffer, newResolvedFramebuffer).asVarying();
     task.addJob<ToneMappingDeferred>("ToneMapping", toneMappingInputs);
+
+
 #endif
 
     // Layered Overlays
     // Composite the HUD and HUD overlays
-    task.addJob<CompositeHUD>("HUD", resolvedFramebuffer);
+    task.addJob<CompositeHUD>("HUD", primaryFramebuffer);
 
     const auto hudOpaquesInputs = DrawLayered3D::Inputs(hudOpaque, lightingModel, nullJitter).asVarying();
     const auto hudTransparentsInputs = DrawLayered3D::Inputs(hudTransparent, lightingModel, nullJitter).asVarying();
@@ -201,20 +213,12 @@ void PreparePrimaryFramebufferMSAA::run(const RenderContextPointer& renderContex
     if (!_framebuffer || (_framebuffer->getSize() != scaledFrameSize) || (_framebuffer->getNumSamples() != _numSamples)) {
         _framebuffer = createFramebuffer("forward", scaledFrameSize, _numSamples);
     }
-/*
-    auto args = renderContext->args;
-    gpu::doInBatch("PrepareFramebuffer::run", args->_context, [&](gpu::Batch& batch) {
-        batch.enableStereo(false);
-        batch.setViewportTransform(args->_viewport);
-        batch.setStateScissorRect(args->_viewport);
-
-        batch.setFramebuffer(_framebuffer);
-        batch.clearFramebuffer(gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_DEPTH |
-            gpu::Framebuffer::BUFFER_STENCIL,
-            vec4(vec3(0), 0), 1.0, 0, true);
-    });*/
 
     framebuffer = _framebuffer;
+
+    // Set viewport for the rest of the scaled passes
+    renderContext->args->_viewport.z = scaledFrameSize.x;
+    renderContext->args->_viewport.w = scaledFrameSize.y;
 }
 
 void PrepareForward::run(const RenderContextPointer& renderContext, const Inputs& inputs) {

libraries/render-utils/src/RenderForwardTask.h

@@ -47,7 +47,7 @@ class PreparePrimaryFramebufferMSAAConfig : public render::Job::Config {
 public:
     float getResolutionScale() const { return resolutionScale; }
     void setResolutionScale(float scale) {
-        resolutionScale = std::max(0.1f, std::min(1.0f, resolutionScale));
+        resolutionScale = std::max(0.1f, std::min(2.0f, scale));
     }
 
     int getNumSamples() const { return numSamples; }

libraries/render/src/render/ResampleTask.cpp

@@ -135,3 +135,50 @@ void Upsample::run(const RenderContextPointer& renderContext, const gpu::Framebu
         args->_viewport = viewport;
     }
 }
+
+gpu::PipelinePointer Upsample2::_pipeline;
+
+void Upsample2::configure(const Config& config) {
+    _factor = config.factor;
+}
+
+void Upsample2::run(const RenderContextPointer& renderContext, const Input& input, gpu::FramebufferPointer& resampledFrameBuffer) {
+    assert(renderContext->args);
+    assert(renderContext->args->hasViewFrustum());
+    RenderArgs* args = renderContext->args;
+    auto sourceFramebuffer = input;
+ //   auto srcFramebuffer = input.get0();
+  //  auto dstFramebuffer = input.get1();
+
+//    resampledFrameBuffer = getResampledFrameBuffer(sourceFramebuffer);
+    resampledFrameBuffer = args->_blitFramebuffer;
+
+    if (resampledFrameBuffer != sourceFramebuffer) {
+        if (!_pipeline) {
+            gpu::ShaderPointer program = gpu::Shader::createProgram(shader::gpu::program::drawTransformUnitQuadTextureOpaque);
+            gpu::StatePointer state = gpu::StatePointer(new gpu::State());
+            state->setDepthTest(gpu::State::DepthTest(false, false));
+            _pipeline = gpu::Pipeline::create(program, state);
+        }
+        const auto bufferSize = resampledFrameBuffer->getSize();
+        glm::ivec4 viewport{ 0, 0, bufferSize.x, bufferSize.y };
+
+        gpu::doInBatch("Upsample::run", args->_context, [&](gpu::Batch& batch) {
+            batch.enableStereo(false);
+
+            batch.setFramebuffer(resampledFrameBuffer);
+
+            batch.setViewportTransform(viewport);
+            batch.setProjectionTransform(glm::mat4());
+            batch.resetViewTransform();
+            batch.setPipeline(_pipeline);
+
+            batch.setModelTransform(gpu::Framebuffer::evalSubregionTexcoordTransform(bufferSize, viewport));
+            batch.setResourceTexture(0, sourceFramebuffer->getRenderBuffer(0));
+            batch.draw(gpu::TRIANGLE_STRIP, 4);
+        });
+
+        // Set full final viewport
+        args->_viewport = viewport;
+    }
+}

libraries/render/src/render/ResampleTask.h

@@ -67,6 +67,25 @@ namespace render {
 
         gpu::FramebufferPointer getResampledFrameBuffer(const gpu::FramebufferPointer& sourceFramebuffer);
     };
+
+    class Upsample2 {
+    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>;
+
+        Upsample2(float factor = 2.0f) : _factor{ factor } {}
+
+        void configure(const Config& config);
+        void run(const RenderContextPointer& renderContext, const Input& input, gpu::FramebufferPointer& resampledFrameBuffer);
+
+    protected:
+
+        static gpu::PipelinePointer _pipeline;
+
+        float _factor{ 2.0f };
+    };
 }
 
 #endif // hifi_render_ResampleTask_h

scripts/developer/utilities/render/luci/RenderSettings.qml

@@ -35,7 +35,7 @@ Column {
         object: Render
         property: "viewportResolutionScale"
         min: 0.1
-        max: 1.0
+        max: 2.0
     }
 }