created tonemapandresample

libraries/render-utils/src/BloomEffect.cpp

@@ -15,7 +15,7 @@
 #include <shaders/Shaders.h>
 
 #include <render/BlurTask.h>
-#include <render/ResampleTask.h>
+#include <render/ToneMapAndResampleTask.h>
 #include "render-utils/ShaderConstants.h"
 
 #define BLOOM_BLUR_LEVEL_COUNT  3

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -29,7 +29,7 @@
 #include <render/DrawStatus.h>
 #include <render/DrawSceneOctree.h>
 #include <render/BlurTask.h>
-#include <render/ResampleTask.h>
+#include <render/ToneMapAndResampleTask.h>
 
 #include "RenderHifi.h"
 #include "render-utils/ShaderConstants.h"
@@ -251,11 +251,11 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     }
 
     // Upscale to finale resolution
-    const auto primaryFramebuffer = task.addJob<render::UpsampleToBlitFramebuffer>("PrimaryBufferUpscale", toneMappedBuffer);
+    //const auto primaryFramebuffer = task.addJob<render::UpsampleToBlitFramebuffer>("PrimaryBufferUpscale", toneMappedBuffer);
 
     // HUD Layer
-    const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(primaryFramebuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame).asVarying();
-    task.addJob<RenderHUDLayerTask>("RenderHUDLayer", renderHUDLayerInputs);
+    //const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(primaryFramebuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame).asVarying();
+    //task.addJob<RenderHUDLayerTask>("RenderHUDLayer", renderHUDLayerInputs);
 }
 
 RenderDeferredTaskDebug::RenderDeferredTaskDebug() {

libraries/render-utils/src/RenderForwardTask.cpp

@@ -19,7 +19,8 @@
 #include <gpu/Texture.h>
 #include <graphics/ShaderConstants.h>
 #include <render/ShapePipeline.h>
-#include <render/ResampleTask.h>
+//#include <render/ResampleTask.h>
+#include <render/ToneMapAndResampleTask.h>
 
 #include <render/FilterTask.h>
 
@@ -29,6 +30,7 @@
 #include "ZoneRenderer.h"
 #include "FadeEffect.h"
 #include "ToneMappingEffect.h"
+//#include "ToneMapAndResampleTask.h"
 #include "BackgroundStage.h"
 #include "FramebufferCache.h"
 #include "TextureCache.h"
@@ -165,7 +167,8 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend
 #endif
 
     // Upscale to finale resolution
-    const auto primaryFramebuffer = task.addJob<render::UpsampleToBlitFramebuffer>("PrimaryBufferUpscale", toneMappedBuffer);
+    //const auto primaryFramebuffer = task.addJob<ToneMapAndResample>("ToneMapAndResample", toneMappedBuffer);
+    const auto primaryFramebuffer = task.addJob<render::ResampleToBlitFramebuffer>("ToneMapAndResample", toneMappedBuffer);
 
     // HUD Layer
     const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(primaryFramebuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame).asVarying();

libraries/render/src/render/ToneMapAndResampleTask.cpp

@@ -0,0 +1,180 @@
+//
+//  ResampleTask.cpp
+//  render/src/render
+//
+//  Various to Resample or downsample textures into framebuffers.
+//
+//  Created by Olivier Prat on 10/09/17.
+//  Copyright 2017 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 "ToneMapAndResampleTask.h"
+
+#include <gpu/Context.h>
+#include <shaders/Shaders.h>
+
+using namespace render;
+using namespace shader::gpu::program;
+/*
+gpu::PipelinePointer HalfDownsample::_pipeline;
+
+HalfDownsample::HalfDownsample() {
+
+}
+
+void HalfDownsample::configure(const Config& config) {
+
+}
+
+gpu::FramebufferPointer HalfDownsample::getResampledFrameBuffer(const gpu::FramebufferPointer& sourceFramebuffer) {
+    auto resampledFramebufferSize = sourceFramebuffer->getSize();
+
+    resampledFramebufferSize.x /= 2U;
+    resampledFramebufferSize.y /= 2U;
+
+    if (!_destinationFrameBuffer || resampledFramebufferSize != _destinationFrameBuffer->getSize()) {
+        _destinationFrameBuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("HalfOutput"));
+
+        auto sampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT);
+        auto target = gpu::Texture::createRenderBuffer(sourceFramebuffer->getRenderBuffer(0)->getTexelFormat(), resampledFramebufferSize.x, resampledFramebufferSize.y, gpu::Texture::SINGLE_MIP, sampler);
+        _destinationFrameBuffer->setRenderBuffer(0, target);
+    }
+    return _destinationFrameBuffer;
+}
+
+void HalfDownsample::run(const RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceFramebuffer, gpu::FramebufferPointer& resampledFrameBuffer) {
+    assert(renderContext->args);
+    assert(renderContext->args->hasViewFrustum());
+    RenderArgs* args = renderContext->args;
+
+    resampledFrameBuffer = getResampledFrameBuffer(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("HalfDownsample::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);
+    });
+}
+*/
+gpu::PipelinePointer Resample::_pipeline;
+
+void Resample::configure(const Config& config) {
+    _factor = config.factor;
+}
+
+gpu::FramebufferPointer Resample::getResampledFrameBuffer(const gpu::FramebufferPointer& sourceFramebuffer) {
+    if (_factor == 1.0f) {
+        return sourceFramebuffer;
+    }
+
+    auto resampledFramebufferSize = glm::uvec2(glm::vec2(sourceFramebuffer->getSize()) * _factor);
+
+    if (!_destinationFrameBuffer || resampledFramebufferSize != _destinationFrameBuffer->getSize()) {
+        _destinationFrameBuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("ResampledOutput"));
+
+        auto sampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR);
+        auto target = gpu::Texture::createRenderBuffer(sourceFramebuffer->getRenderBuffer(0)->getTexelFormat(), resampledFramebufferSize.x, resampledFramebufferSize.y, gpu::Texture::SINGLE_MIP, sampler);
+        _destinationFrameBuffer->setRenderBuffer(0, target);
+    }
+    return _destinationFrameBuffer;
+}
+
+void Resample::run(const RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceFramebuffer, gpu::FramebufferPointer& resampledFrameBuffer) {
+    assert(renderContext->args);
+    assert(renderContext->args->hasViewFrustum());
+    RenderArgs* args = renderContext->args;
+
+    resampledFrameBuffer = getResampledFrameBuffer(sourceFramebuffer);
+    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("Resample::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;
+    }
+}
+
+gpu::PipelinePointer ResampleToBlitFramebuffer::_pipeline;
+gpu::PipelinePointer ResampleToBlitFramebuffer::_mirrorPipeline;
+
+void ResampleToBlitFramebuffer::run(const RenderContextPointer& renderContext, const Input& input, gpu::FramebufferPointer& resampledFrameBuffer) {
+    assert(renderContext->args);
+    assert(renderContext->args->hasViewFrustum());
+    RenderArgs* args = renderContext->args;
+    auto sourceFramebuffer = input;
+
+    resampledFrameBuffer = args->_blitFramebuffer;
+
+    if (resampledFrameBuffer != sourceFramebuffer) {
+        if (!_pipeline) {
+            gpu::StatePointer state = gpu::StatePointer(new gpu::State());
+            state->setDepthTest(gpu::State::DepthTest(false, false));
+
+            _pipeline = gpu::Pipeline::create(gpu::Shader::createProgram(drawTransformUnitQuadTextureOpaque), state);
+            _mirrorPipeline = gpu::Pipeline::create(gpu::Shader::createProgram(DrawTextureMirroredX), state);
+        }
+        const auto bufferSize = resampledFrameBuffer->getSize();
+        glm::ivec4 viewport{ 0, 0, bufferSize.x, bufferSize.y };
+
+        gpu::doInBatch("Resample::run", args->_context, [&](gpu::Batch& batch) {
+            batch.enableStereo(false);
+
+            batch.setFramebuffer(resampledFrameBuffer);
+
+            batch.setViewportTransform(viewport);
+            batch.setProjectionTransform(glm::mat4());
+            batch.resetViewTransform();
+            batch.setPipeline(args->_renderMode == RenderArgs::MIRROR_RENDER_MODE ? _mirrorPipeline : _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/ToneMapAndResampleTask.h

@@ -0,0 +1,87 @@
+//
+//  ResampleTask.h
+//  render/src/render
+//
+//  Various to upsample or downsample textures into framebuffers.
+//
+//  Created by Olivier Prat on 10/09/17.
+//  Copyright 2017 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_render_ToneMapAndResampleTask_h
+#define hifi_render_ToneMapAndResampleTask_h
+
+#include "Engine.h"
+
+namespace render {
+/*
+    class HalfDownsample {
+    public:
+        using Config = JobConfig;
+        using JobModel = Job::ModelIO<HalfDownsample, gpu::FramebufferPointer, gpu::FramebufferPointer, Config>;
+
+        HalfDownsample();
+
+        void configure(const Config& config);
+        void run(const RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceFramebuffer, gpu::FramebufferPointer& resampledFrameBuffer);
+
+    protected:
+
+        static gpu::PipelinePointer _pipeline;
+
+        gpu::FramebufferPointer _destinationFrameBuffer;
+
+        gpu::FramebufferPointer getResampledFrameBuffer(const gpu::FramebufferPointer& sourceFramebuffer);
+    };
+*/
+    class ResampleConfig : public render::Job::Config {
+        Q_OBJECT
+        Q_PROPERTY(float factor MEMBER factor NOTIFY dirty)
+    public:
+
+        float factor{ 1.0f };
+
+        signals:
+            void dirty();
+    };
+
+    class Resample {
+    public:
+        using Config = ResampleConfig;
+        using JobModel = Job::ModelIO<Resample, gpu::FramebufferPointer, gpu::FramebufferPointer, Config>;
+
+        Resample(float factor = 2.0f) : _factor{ factor } {}
+
+        void configure(const Config& config);
+        void run(const RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceFramebuffer, gpu::FramebufferPointer& resampledFrameBuffer);
+
+    protected:
+
+        static gpu::PipelinePointer _pipeline;
+
+        gpu::FramebufferPointer _destinationFrameBuffer;
+        float _factor{ 2.0f };
+
+        gpu::FramebufferPointer getResampledFrameBuffer(const gpu::FramebufferPointer& sourceFramebuffer);
+    };
+
+    class ResampleToBlitFramebuffer {
+    public:
+        using Input = gpu::FramebufferPointer;
+        using JobModel = Job::ModelIO<ResampleToBlitFramebuffer, Input, gpu::FramebufferPointer>;
+
+        ResampleToBlitFramebuffer() {}
+
+        void run(const RenderContextPointer& renderContext, const Input& input, gpu::FramebufferPointer& resampledFrameBuffer);
+
+    protected:
+
+        static gpu::PipelinePointer _pipeline;
+        static gpu::PipelinePointer _mirrorPipeline;
+    };
+}
+
+#endif // hifi_render_ResampleTask_h