d6/d40/_s_s_a_o_pre_render_operator_8cpp_source.html

#include "Headers/SSAOPreRenderOperator.h"


#include "Core/Resources/Headers/ResourceCache.h"

#include "Managers/Headers/ProjectManager.h"

#include "Core/Headers/StringHelper.h"

#include "Core/Headers/Configuration.h"

#include "Core/Headers/PlatformContext.h"

#include "Platform/Video/Headers/GFXDevice.h"

#include "Platform/Video/Headers/GFXRTPool.h"

#include "Platform/Video/Headers/RenderStateBlock.h"

#include "Platform/Video/Shaders/Headers/ShaderProgram.h"

#include "Geometry/Shapes/Predefined/Headers/Quad3D.h"


#include "Rendering/PostFX/Headers/PreRenderBatch.h"


namespace Divide {


namespace

{

    constexpr U8 SSAO_NOISE_SIZE = 4;

    constexpr U8 SSAO_BLUR_SIZE = SSAO_NOISE_SIZE / 2;

    constexpr U8 MAX_KERNEL_SIZE = 64;

    constexpr U8 MIN_KERNEL_SIZE = 8;

    vector<vec4<F32>> g_kernels;


    [[nodiscard]] const vector<vec4<F32>>& ComputeKernel(const U8 sampleCount)

    {

        g_kernels.resize(sampleCount);

        for (U16 i = 0; i < sampleCount; ++i) {

            vec3<F32>& k = g_kernels[i].xyz;

            k.set(Random(-1.f, 1.f),

                  Random(-1.f, 1.f),

                  Random( 0.f, 1.f)); // Kernel hemisphere points to positive Z-Axis.

            k.normalize();             // Normalize, so included in the hemisphere.

            k *= FastLerp(0.1f, 1.0f, SQUARED(to_F32(i) / to_F32(sampleCount))); // Create a scale value between [0;1].

        }


        return g_kernels;

    }

}


//ref: http://john-chapman-graphics.blogspot.co.uk/2013/01/ssao-tutorial.html

SSAOPreRenderOperator::SSAOPreRenderOperator(GFXDevice& context, PreRenderBatch& parent)

    : PreRenderOperator(context, parent, FilterType::FILTER_SS_AMBIENT_OCCLUSION)

{

    const auto& config = context.context().config().rendering.postFX.ssao;

    _genHalfRes = config.UseHalfResolution;

    _blurThreshold[0] = config.FullRes.BlurThreshold;

    _blurThreshold[1] = config.HalfRes.BlurThreshold;

    _blurSharpness[0] = config.FullRes.BlurSharpness;

    _blurSharpness[1] = config.HalfRes.BlurSharpness;

    _kernelSampleCount[0] = CLAMPED(config.FullRes.KernelSampleCount, MIN_KERNEL_SIZE, MAX_KERNEL_SIZE);

    _kernelSampleCount[1] = CLAMPED(config.HalfRes.KernelSampleCount, MIN_KERNEL_SIZE, MAX_KERNEL_SIZE);

    _blur[0] = config.FullRes.Blur;

    _blur[1] = config.HalfRes.Blur;

    _radius[0] = config.FullRes.Radius;

    _radius[1] = config.HalfRes.Radius;

    _power[0] = config.FullRes.Power;

    _power[1] = config.HalfRes.Power;

    _bias[0] = config.FullRes.Bias;

    _bias[1] = config.HalfRes.Bias;

    _maxRange[0] = config.FullRes.MaxRange;

    _maxRange[1] = config.HalfRes.MaxRange;

    _fadeStart[0] = config.FullRes.FadeDistance;

    _fadeStart[1] = config.HalfRes.FadeDistance;


    std::array<vec4<F32>, SQUARED(SSAO_NOISE_SIZE)> noiseData;


    for (vec4<F32>& noise : noiseData)

    {

        noise.set(Random(-1.f, 1.f), Random(-1.f, 1.f), 0.f, 1.f);

        noise.normalize();

    }


    SamplerDescriptor nearestSampler = {};

    nearestSampler._wrapU = TextureWrap::CLAMP_TO_EDGE;

    nearestSampler._wrapV = TextureWrap::CLAMP_TO_EDGE;

    nearestSampler._wrapW = TextureWrap::CLAMP_TO_EDGE;

    nearestSampler._minFilter = TextureFilter::NEAREST;

    nearestSampler._magFilter = TextureFilter::NEAREST;

    nearestSampler._mipSampling = TextureMipSampling::NONE;

    nearestSampler._anisotropyLevel = 0u;


    SamplerDescriptor screenSampler = {};

    screenSampler._wrapU = TextureWrap::CLAMP_TO_EDGE;

    screenSampler._wrapV = TextureWrap::CLAMP_TO_EDGE;

    screenSampler._wrapW = TextureWrap::CLAMP_TO_EDGE;

    screenSampler._mipSampling = TextureMipSampling::NONE;

    screenSampler._anisotropyLevel = 0u;


    _noiseSampler._wrapU = TextureWrap::REPEAT;

    _noiseSampler._wrapV = TextureWrap::REPEAT;

    _noiseSampler._wrapW = TextureWrap::REPEAT;

    _noiseSampler._minFilter = TextureFilter::NEAREST;

    _noiseSampler._magFilter = TextureFilter::NEAREST;

    _noiseSampler._mipSampling = TextureMipSampling::NONE;

    _noiseSampler._anisotropyLevel = 0u;


    ResourceDescriptor<Texture> textureAttachment( "SSAOPreRenderOperator_NoiseTexture" );

    TextureDescriptor& noiseDescriptor = textureAttachment._propertyDescriptor;


    noiseDescriptor._dataType = GFXDataFormat::FLOAT_32;

    noiseDescriptor._packing = GFXImagePacking::UNNORMALIZED;

    noiseDescriptor._mipMappingState = MipMappingState::OFF;


    _noiseTexture = CreateResource( textureAttachment);

    Get(_noiseTexture)->createWithData((Byte*)noiseData.data(), noiseData.size() * sizeof(vec4<F32>), vec2<U16>(SSAO_NOISE_SIZE, SSAO_NOISE_SIZE), {});

    {

        TextureDescriptor outputDescriptor{};

        outputDescriptor._dataType = GFXDataFormat::FLOAT_16;

        outputDescriptor._baseFormat = GFXImageFormat::RED;

        outputDescriptor._packing = GFXImagePacking::UNNORMALIZED;

        outputDescriptor._mipMappingState = MipMappingState::OFF;

        const vec2<U16> res = parent.screenRT()._rt->getResolution();


        RenderTargetDescriptor desc = {};

        desc._attachments =

        {

            InternalRTAttachmentDescriptor{ outputDescriptor, nearestSampler, RTAttachmentType::COLOUR, RTColourAttachmentSlot::SLOT_0},

        };

        desc._name = "SSAO_Out";

        desc._resolution = res;


        //Colour0 holds the AO texture

        _ssaoOutput = _context.renderTargetPool().allocateRT(desc);


        desc._name = "SSAO_Blur_Buffer";

        _ssaoBlurBuffer = _context.renderTargetPool().allocateRT(desc);


        desc._name = "SSAO_Out_HalfRes";

        desc._resolution /= 2;


        _ssaoHalfResOutput = _context.renderTargetPool().allocateRT(desc);

    }

    {

        TextureDescriptor outputDescriptor{};

        outputDescriptor._dataType = GFXDataFormat::FLOAT_32;

        outputDescriptor._packing = GFXImagePacking::UNNORMALIZED;

        outputDescriptor._mipMappingState = MipMappingState::OFF;


        RenderTargetDescriptor desc = {};

        desc._attachments =

        {

            InternalRTAttachmentDescriptor{ outputDescriptor, nearestSampler, RTAttachmentType::COLOUR, RTColourAttachmentSlot::SLOT_0 },

        };


        desc._name = "HalfRes_Normals_Depth";

        desc._resolution = parent.screenRT()._rt->getResolution() / 2;


        _halfDepthAndNormals = _context.renderTargetPool().allocateRT(desc);

    }


    const ShaderModuleDescriptor vertModule{ ShaderType::VERTEX, "baseVertexShaders.glsl", "FullScreenQuad" };


    ShaderModuleDescriptor fragModule = {};

    fragModule._moduleType = ShaderType::FRAGMENT;

    fragModule._sourceFile = "SSAOPass.glsl";


    { //Calc Full

        fragModule._variant = "SSAOCalc";

        fragModule._defines.resize(0);

        fragModule._defines.emplace_back(Util::StringFormat("SSAO_SAMPLE_COUNT {}", _kernelSampleCount[0]));


        ShaderProgramDescriptor ssaoShaderDescriptor = {};

        ssaoShaderDescriptor._modules.push_back(vertModule);

        ssaoShaderDescriptor._modules.push_back(fragModule);


        ResourceDescriptor<ShaderProgram> ssaoGenerate("SSAOCalc", ssaoShaderDescriptor );

        ssaoGenerate.waitForReady(false);

        _ssaoGenerateShader = CreateResource(ssaoGenerate);

    }

    { //Calc Half

        fragModule._variant = "SSAOCalc";

        fragModule._defines.resize(0);

        fragModule._defines.emplace_back(Util::StringFormat("SSAO_SAMPLE_COUNT {}", _kernelSampleCount[1]));

        fragModule._defines.emplace_back("COMPUTE_HALF_RES");


        ShaderProgramDescriptor ssaoShaderDescriptor = {};

        ssaoShaderDescriptor._modules.push_back(vertModule);

        ssaoShaderDescriptor._modules.push_back(fragModule);


        ResourceDescriptor<ShaderProgram> ssaoGenerateHalfRes( "SSAOCalcHalfRes", ssaoShaderDescriptor );

        ssaoGenerateHalfRes.waitForReady(false);

        _ssaoGenerateHalfResShader = CreateResource(ssaoGenerateHalfRes);

    }


    { //Blur

        fragModule._variant = "SSAOBlur.Nvidia";

        fragModule._defines.resize(0);

        fragModule._defines.emplace_back(Util::StringFormat("BLUR_SIZE {}", SSAO_BLUR_SIZE));


        ShaderProgramDescriptor ssaoShaderDescriptor = {};

        ssaoShaderDescriptor._modules.push_back(vertModule);

        ssaoShaderDescriptor._modules.push_back(fragModule);


        ssaoShaderDescriptor._modules.back()._defines.emplace_back("HORIZONTAL");

        ResourceDescriptor<ShaderProgram> ssaoBlurH( "SSAOBlur.Horizontal", ssaoShaderDescriptor );

        ssaoBlurH.waitForReady(false);

        _ssaoBlurShaderHorizontal = CreateResource(ssaoBlurH);


        ssaoShaderDescriptor._modules.back()._defines.back() = { "VERTICAL" };


        ResourceDescriptor<ShaderProgram> ssaoBlurV( "SSAOBlur.Vertical", ssaoShaderDescriptor );

        ssaoBlurV.waitForReady(false);

        _ssaoBlurShaderVertical = CreateResource(ssaoBlurV);

    }

    { //Pass-through

        fragModule._variant = "SSAOPassThrough";

        fragModule._defines.resize(0);


        ShaderProgramDescriptor ssaoShaderDescriptor  = {};

        ssaoShaderDescriptor._modules.push_back(vertModule);

        ssaoShaderDescriptor._modules.push_back(fragModule);


        ResourceDescriptor<ShaderProgram> ssaoPassThrough( "SSAOPassThrough", ssaoShaderDescriptor );

        ssaoPassThrough.waitForReady(false);


        _ssaoPassThroughShader = CreateResource(ssaoPassThrough);

    }

    { //DownSample

        fragModule._variant = "SSAODownsample";

        fragModule._defines.resize(0);


        ShaderProgramDescriptor ssaoShaderDescriptor = {};

        ssaoShaderDescriptor._modules.push_back(vertModule);

        ssaoShaderDescriptor._modules.push_back(fragModule);


        ResourceDescriptor<ShaderProgram> ssaoDownSample( "SSAODownSample", ssaoShaderDescriptor );

        ssaoDownSample.waitForReady(false);


        _ssaoDownSampleShader = CreateResource(ssaoDownSample);

    }

    { //UpSample

        fragModule._variant = "SSAOUpsample";

        fragModule._defines.resize(0);


        ShaderProgramDescriptor ssaoShaderDescriptor = {};

        ssaoShaderDescriptor._modules.push_back(vertModule);

        ssaoShaderDescriptor._modules.push_back(fragModule);


        ResourceDescriptor<ShaderProgram> ssaoUpSample( "SSAOUpSample", ssaoShaderDescriptor );

        ssaoUpSample.waitForReady(false);


        _ssaoUpSampleShader = CreateResource(ssaoUpSample);

    }


    _ssaoGenerateConstants.set(_ID("sampleKernel"), PushConstantType::VEC4, ComputeKernel(sampleCount()));

    _ssaoGenerateConstants.set(_ID("SSAO_RADIUS"), PushConstantType::FLOAT, radius());

    _ssaoGenerateConstants.set(_ID("SSAO_INTENSITY"), PushConstantType::FLOAT, power());

    _ssaoGenerateConstants.set(_ID("SSAO_BIAS"), PushConstantType::FLOAT, bias());

    _ssaoGenerateConstants.set(_ID("SSAO_NOISE_SCALE"), PushConstantType::VEC2, vec2<F32>((parent.screenRT()._rt->getResolution() * (_genHalfRes ? 0.5f : 1.f)) / SSAO_NOISE_SIZE));

    _ssaoGenerateConstants.set(_ID("maxRange"), PushConstantType::FLOAT, maxRange());

    _ssaoGenerateConstants.set(_ID("fadeStart"), PushConstantType::FLOAT, fadeStart());


    _ssaoBlurConstants.set(_ID("depthThreshold"), PushConstantType::FLOAT, blurThreshold());

    _ssaoBlurConstants.set(_ID("blurSharpness"), PushConstantType::FLOAT, blurSharpness());

    _ssaoBlurConstants.set(_ID("blurKernelSize"), PushConstantType::INT, blurKernelSize());


    WAIT_FOR_CONDITION(ready());


    PipelineDescriptor pipelineDescriptor = {};

    pipelineDescriptor._primitiveTopology = PrimitiveTopology::TRIANGLES;

    pipelineDescriptor._stateBlock = _context.get2DStateBlock();

    pipelineDescriptor._shaderProgramHandle = _ssaoDownSampleShader;


    _downsamplePipeline = _context.newPipeline(pipelineDescriptor);


    pipelineDescriptor._shaderProgramHandle = _ssaoGenerateHalfResShader;

    _generateHalfResPipeline = _context.newPipeline(pipelineDescriptor);


    pipelineDescriptor._shaderProgramHandle = _ssaoUpSampleShader;

    _upsamplePipeline = _context.newPipeline(pipelineDescriptor);


    pipelineDescriptor._shaderProgramHandle = _ssaoGenerateShader;

    _generateFullResPipeline = _context.newPipeline(pipelineDescriptor);


    RenderStateBlock redChannelOnly = _context.get2DStateBlock();

    redChannelOnly._colourWrite.b[0] = true;

    redChannelOnly._colourWrite.b[1] = redChannelOnly._colourWrite.b[2] = redChannelOnly._colourWrite.b[3] = false;


    pipelineDescriptor._stateBlock = redChannelOnly;

    pipelineDescriptor._shaderProgramHandle = _ssaoBlurShaderHorizontal;

    _blurHorizontalPipeline = _context.newPipeline(pipelineDescriptor);


    pipelineDescriptor._shaderProgramHandle = _ssaoBlurShaderVertical;

    _blurVerticalPipeline = _context.newPipeline(pipelineDescriptor);


    pipelineDescriptor._shaderProgramHandle = _ssaoPassThroughShader;

    _passThroughPipeline = _context.newPipeline(pipelineDescriptor);

}


SSAOPreRenderOperator::~SSAOPreRenderOperator()

{

    if (!_context.renderTargetPool().deallocateRT(_ssaoOutput) ||

        !_context.renderTargetPool().deallocateRT(_halfDepthAndNormals) ||

        !_context.renderTargetPool().deallocateRT(_ssaoHalfResOutput) ||

        !_context.renderTargetPool().deallocateRT(_ssaoBlurBuffer))

    {

        DIVIDE_UNEXPECTED_CALL();

    }


    DestroyResource(_ssaoGenerateShader);

    DestroyResource(_ssaoGenerateHalfResShader);

    DestroyResource(_ssaoBlurShaderHorizontal);

    DestroyResource(_ssaoBlurShaderVertical);

    DestroyResource(_ssaoPassThroughShader);

    DestroyResource(_ssaoDownSampleShader);

    DestroyResource(_ssaoUpSampleShader);

    DestroyResource(_noiseTexture);

}


bool SSAOPreRenderOperator::ready() const noexcept

{

    if (_ssaoBlurShaderHorizontal  != INVALID_HANDLE<ShaderProgram> && Get(_ssaoBlurShaderHorizontal)->getState()  == ResourceState::RES_LOADED &&

        _ssaoBlurShaderVertical    != INVALID_HANDLE<ShaderProgram> && Get(_ssaoBlurShaderVertical)->getState()    == ResourceState::RES_LOADED &&

        _ssaoGenerateShader        != INVALID_HANDLE<ShaderProgram> && Get(_ssaoGenerateShader)->getState()        == ResourceState::RES_LOADED &&

        _ssaoGenerateHalfResShader != INVALID_HANDLE<ShaderProgram> && Get(_ssaoGenerateHalfResShader)->getState() == ResourceState::RES_LOADED &&

        _ssaoDownSampleShader      != INVALID_HANDLE<ShaderProgram> && Get(_ssaoDownSampleShader)->getState()      == ResourceState::RES_LOADED &&

        _ssaoPassThroughShader     != INVALID_HANDLE<ShaderProgram> && Get(_ssaoPassThroughShader)->getState()     == ResourceState::RES_LOADED &&

        _ssaoUpSampleShader        != INVALID_HANDLE<ShaderProgram> && Get(_ssaoUpSampleShader)->getState()        == ResourceState::RES_LOADED)

    {

        return PreRenderOperator::ready();

    }


    return false;

}


void SSAOPreRenderOperator::reshape(const U16 width, const U16 height)

{

    PreRenderOperator::reshape(width, height);


    _ssaoOutput._rt->resize(width, height);

    _halfDepthAndNormals._rt->resize(width / 2, height / 2);


    const vec2<F32> targetDim = vec2<F32>(width, height) * (_genHalfRes ? 0.5f : 1.f);


    _ssaoGenerateConstants.set(_ID("SSAO_NOISE_SCALE"), PushConstantType::VEC2, targetDim  / SSAO_NOISE_SIZE);

}


void SSAOPreRenderOperator::genHalfRes(const bool state)

{

    if (_genHalfRes != state)

    {

        _genHalfRes = state;

        _context.context().config().rendering.postFX.ssao.UseHalfResolution = state;

        _context.context().config().changed(true);


        const U16 width = state ? _halfDepthAndNormals._rt->getWidth() : _ssaoOutput._rt->getWidth();

        const U16 height = state ? _halfDepthAndNormals._rt->getHeight() : _ssaoOutput._rt->getHeight();


        _ssaoGenerateConstants.set(_ID("SSAO_NOISE_SCALE"), PushConstantType::VEC2, vec2<F32>(width, height) / SSAO_NOISE_SIZE);

        _ssaoGenerateConstants.set(_ID("sampleKernel"), PushConstantType::VEC4, ComputeKernel(sampleCount()));

        _ssaoGenerateConstants.set(_ID("SSAO_RADIUS"), PushConstantType::FLOAT, radius());

        _ssaoGenerateConstants.set(_ID("SSAO_INTENSITY"), PushConstantType::FLOAT, power());

        _ssaoGenerateConstants.set(_ID("SSAO_BIAS"), PushConstantType::FLOAT, bias());

        _ssaoGenerateConstants.set(_ID("maxRange"), PushConstantType::FLOAT, maxRange());

        _ssaoGenerateConstants.set(_ID("fadeStart"), PushConstantType::FLOAT, fadeStart());

        _ssaoBlurConstants.set(_ID("depthThreshold"), PushConstantType::FLOAT, blurThreshold());

        _ssaoBlurConstants.set(_ID("blurSharpness"), PushConstantType::FLOAT, blurSharpness());

        _ssaoBlurConstants.set(_ID("blurKernelSize"), PushConstantType::INT, blurKernelSize());

    }

}


void SSAOPreRenderOperator::radius(const F32 val)

{

    if (!COMPARE(radius(), val))

    {

        _radius[_genHalfRes ? 1 : 0] = val;

        _ssaoGenerateConstants.set(_ID("SSAO_RADIUS"), PushConstantType::FLOAT, val);

        if (_genHalfRes)

        {

            _context.context().config().rendering.postFX.ssao.HalfRes.Radius = val;

        }

        else

        {

            _context.context().config().rendering.postFX.ssao.FullRes.Radius = val;

        }

        _context.context().config().changed(true);

    }

}


void SSAOPreRenderOperator::power(const F32 val)

{

    if (!COMPARE(power(), val))

    {

        _power[_genHalfRes ? 1 : 0] = val;

        _ssaoGenerateConstants.set(_ID("SSAO_INTENSITY"), PushConstantType::FLOAT, val);

        if (_genHalfRes)

        {

            _context.context().config().rendering.postFX.ssao.HalfRes.Power = val;

        }

        else

        {

            _context.context().config().rendering.postFX.ssao.FullRes.Power = val;

        }

        _context.context().config().changed(true);

    }

}


void SSAOPreRenderOperator::bias(const F32 val)

{

    if (!COMPARE(bias(), val))

    {

        _bias[_genHalfRes ? 1 : 0] = val;

        _ssaoGenerateConstants.set(_ID("SSAO_BIAS"), PushConstantType::FLOAT, val);

        if (_genHalfRes)

        {

            _context.context().config().rendering.postFX.ssao.HalfRes.Bias = val;

        }

        else

        {

            _context.context().config().rendering.postFX.ssao.FullRes.Bias = val;

        }

        _context.context().config().changed(true);

    }

}


void SSAOPreRenderOperator::blurResults(const bool state) noexcept

{

    if (blurResults() != state)

    {

        _blur[_genHalfRes ? 1 : 0] = state;

        if (_genHalfRes)

        {

            _context.context().config().rendering.postFX.ssao.HalfRes.Blur = state;

        }

        else

        {

            _context.context().config().rendering.postFX.ssao.FullRes.Blur = state;

        }

        _context.context().config().changed(true);

    }

}


void SSAOPreRenderOperator::blurThreshold(const F32 val)

{

    if (!COMPARE(blurThreshold(), val))

    {

        _blurThreshold[_genHalfRes ? 1 : 0] = val;

        _ssaoBlurConstants.set(_ID("depthThreshold"), PushConstantType::FLOAT, val);

        if (_genHalfRes)

        {

            _context.context().config().rendering.postFX.ssao.HalfRes.BlurThreshold = val;

        }

        else

        {

            _context.context().config().rendering.postFX.ssao.FullRes.BlurThreshold = val;

        }

        _context.context().config().changed(true);

    }

}


void SSAOPreRenderOperator::blurSharpness(const F32 val)

{

    if (!COMPARE(blurSharpness(), val))

    {

        _blurSharpness[_genHalfRes ? 1 : 0] = val;

        _ssaoBlurConstants.set(_ID("blurSharpness"), PushConstantType::FLOAT, val);

        if (_genHalfRes)

        {

            _context.context().config().rendering.postFX.ssao.HalfRes.BlurSharpness = val;

        }

        else

        {

            _context.context().config().rendering.postFX.ssao.FullRes.BlurSharpness = val;

        }

        _context.context().config().changed(true);

    }

}


void SSAOPreRenderOperator::blurKernelSize(const I32 val)

{

    if (blurKernelSize() != val)

    {

        _kernelSize[_genHalfRes ? 1 : 0] = val;

        _ssaoBlurConstants.set(_ID("blurKernelSize"), PushConstantType::INT, val);

        if (_genHalfRes)

        {

            _context.context().config().rendering.postFX.ssao.HalfRes.BlurKernelSize = val;

        }

        else

        {

            _context.context().config().rendering.postFX.ssao.FullRes.BlurKernelSize = val;

        }

        _context.context().config().changed(true);

    }

}


void SSAOPreRenderOperator::maxRange(F32 val)

{

    val = std::max(0.01f, val);


    if (!COMPARE(maxRange(), val))

    {

        _maxRange[_genHalfRes ? 1 : 0] = val;

        _ssaoGenerateConstants.set(_ID("maxRange"), PushConstantType::FLOAT, val);

        if (_genHalfRes)

        {

            _context.context().config().rendering.postFX.ssao.HalfRes.MaxRange = val;

        }

        else

        {

            _context.context().config().rendering.postFX.ssao.FullRes.MaxRange = val;

        }

        _context.context().config().changed(true);

    }

}


void SSAOPreRenderOperator::fadeStart(F32 val)

{

    val = std::max(0.01f, val);


    if (!COMPARE(fadeStart(), val))

    {

        _fadeStart[_genHalfRes ? 1 : 0] = val;

        _ssaoGenerateConstants.set(_ID("fadeStart"), PushConstantType::FLOAT, val);

        if (_genHalfRes)

        {

            _context.context().config().rendering.postFX.ssao.HalfRes.FadeDistance = val;

        }

        else

        {

            _context.context().config().rendering.postFX.ssao.FullRes.FadeDistance = val;

        }

        _context.context().config().changed(true);

    }

}


U8 SSAOPreRenderOperator::sampleCount() const noexcept

{

    return _kernelSampleCount[_genHalfRes ? 1 : 0];

}


void SSAOPreRenderOperator::prepare([[maybe_unused]] const PlayerIndex idx, GFX::CommandBuffer& bufferInOut)

{

    PreRenderOperator::prepare(idx, bufferInOut);


    if (_stateChanged && !_enabled)

    {

        GFX::BeginRenderPassCommand* renderPassCmd = GFX::EnqueueCommand<GFX::BeginRenderPassCommand>(bufferInOut);

        renderPassCmd->_name = "DO_SSAO_CLEAR_TARGET";

        renderPassCmd->_target = RenderTargetNames::SSAO_RESULT;

        renderPassCmd->_descriptor._drawMask[to_base( RTColourAttachmentSlot::SLOT_0 )] = true;

        renderPassCmd->_clearDescriptor[RT_DEPTH_ATTACHMENT_IDX] = DEFAULT_CLEAR_ENTRY;

        renderPassCmd->_clearDescriptor[to_base( RTColourAttachmentSlot::SLOT_0 )] = DEFAULT_CLEAR_ENTRY;


        GFX::EnqueueCommand<GFX::EndRenderPassCommand>(bufferInOut);

    }


    _stateChanged = false;

}


bool SSAOPreRenderOperator::execute([[maybe_unused]] const PlayerIndex idx, const CameraSnapshot& cameraSnapshot, [[maybe_unused]] const RenderTargetHandle& input, [[maybe_unused]] const RenderTargetHandle& output, GFX::CommandBuffer& bufferInOut)

{

    assert(_enabled);


    _ssaoGenerateConstants.set(_ID("_zPlanes"),            PushConstantType::VEC2, cameraSnapshot._zPlanes);


    const auto& depthAtt   = _parent.screenRT()._rt->getAttachment(RTAttachmentType::DEPTH);

    const auto& normalsAtt = _context.renderTargetPool().getRenderTarget( RenderTargetNames::NORMALS_RESOLVED )->getAttachment(RTAttachmentType::COLOUR);


    if(genHalfRes())

    {

        { // DownSample depth and normals

            GFX::BeginRenderPassCommand* renderPassCmd = GFX::EnqueueCommand<GFX::BeginRenderPassCommand>(bufferInOut);

            renderPassCmd->_name = "DO_SSAO_DOWNSAMPLE_NORMALS";

            renderPassCmd->_target = _halfDepthAndNormals._targetID;

            renderPassCmd->_clearDescriptor[to_base(RTColourAttachmentSlot::SLOT_0)] = DEFAULT_CLEAR_ENTRY;

            renderPassCmd->_descriptor._drawMask[to_base( RTColourAttachmentSlot::SLOT_0 )] = true;


            GFX::EnqueueCommand<GFX::BindPipelineCommand>(bufferInOut)->_pipeline = _downsamplePipeline;


            auto cmd = GFX::EnqueueCommand<GFX::BindShaderResourcesCommand>(bufferInOut);

            cmd->_usage = DescriptorSetUsage::PER_DRAW;

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 1u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, depthAtt->texture(), depthAtt->_descriptor._sampler );

            }

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 2u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, normalsAtt->texture(), normalsAtt->_descriptor._sampler );

            }


            GFX::EnqueueCommand<GFX::DrawCommand>(bufferInOut)->_drawCommands.emplace_back();

            GFX::EnqueueCommand<GFX::EndRenderPassCommand>(bufferInOut);

        }

        { // Generate Half Res AO

            GFX::BeginRenderPassCommand* renderPassCmd = GFX::EnqueueCommand<GFX::BeginRenderPassCommand>(bufferInOut);

            renderPassCmd->_name = "DO_SSAO_HALF_RES_CALC";

            renderPassCmd->_target = _ssaoHalfResOutput._targetID;

            renderPassCmd->_clearDescriptor[to_base( RTColourAttachmentSlot::SLOT_0 )] = DEFAULT_CLEAR_ENTRY;

            renderPassCmd->_descriptor._drawMask[to_base( RTColourAttachmentSlot::SLOT_0 )] = true;


            GFX::EnqueueCommand<GFX::BindPipelineCommand>(bufferInOut)->_pipeline = _generateHalfResPipeline;


            GFX::SendPushConstantsCommand* sendPushConstantsCmd = GFX::EnqueueCommand<GFX::SendPushConstantsCommand>( bufferInOut );

            sendPushConstantsCmd->_uniformData = &_ssaoGenerateConstants;

            sendPushConstantsCmd->_fastData.data[0] = cameraSnapshot._projectionMatrix;

            sendPushConstantsCmd->_fastData.data[1] = cameraSnapshot._invProjectionMatrix;


            const auto& halfDepthAtt  = _halfDepthAndNormals._rt->getAttachment(RTAttachmentType::COLOUR);


            auto cmd = GFX::EnqueueCommand<GFX::BindShaderResourcesCommand>(bufferInOut);

            cmd->_usage = DescriptorSetUsage::PER_DRAW;

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 0u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, _noiseTexture, _noiseSampler );

            }

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 1u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, halfDepthAtt->texture(), halfDepthAtt->_descriptor._sampler );

            }


            GFX::EnqueueCommand<GFX::DrawCommand>(bufferInOut)->_drawCommands.emplace_back();

            GFX::EnqueueCommand<GFX::EndRenderPassCommand>(bufferInOut);

        }

        { // UpSample AO

            GFX::BeginRenderPassCommand* renderPassCmd = GFX::EnqueueCommand<GFX::BeginRenderPassCommand>(bufferInOut);

            renderPassCmd->_name = "DO_SSAO_UPSAMPLE_AO";

            renderPassCmd->_target = _ssaoOutput._targetID;

            renderPassCmd->_clearDescriptor[to_base( RTColourAttachmentSlot::SLOT_0 )] = DEFAULT_CLEAR_ENTRY;

            renderPassCmd->_descriptor._drawMask[to_base( RTColourAttachmentSlot::SLOT_0 )] = true;


            GFX::EnqueueCommand<GFX::BindPipelineCommand>(bufferInOut)->_pipeline = _upsamplePipeline;


            SamplerDescriptor linearSampler = {};

            linearSampler._wrapU = TextureWrap::CLAMP_TO_EDGE;

            linearSampler._wrapV = TextureWrap::CLAMP_TO_EDGE;

            linearSampler._wrapW = TextureWrap::CLAMP_TO_EDGE;

            linearSampler._mipSampling = TextureMipSampling::NONE;

            linearSampler._anisotropyLevel = 0u;


            const auto& halfResAOAtt = _ssaoHalfResOutput._rt->getAttachment(RTAttachmentType::COLOUR );

            const auto& halfDepthAtt = _halfDepthAndNormals._rt->getAttachment(RTAttachmentType::COLOUR );


            auto cmd = GFX::EnqueueCommand<GFX::BindShaderResourcesCommand>(bufferInOut);

            cmd->_usage = DescriptorSetUsage::PER_DRAW;

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 0u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, halfResAOAtt->texture(), linearSampler );

            }

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 1u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, depthAtt->texture(), depthAtt->_descriptor._sampler );

            }

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 2u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, halfDepthAtt->texture(), halfDepthAtt->_descriptor._sampler );

            }

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 3u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, halfResAOAtt->texture(), halfResAOAtt->_descriptor._sampler );

            }

            GFX::EnqueueCommand<GFX::DrawCommand>(bufferInOut)->_drawCommands.emplace_back();

            GFX::EnqueueCommand<GFX::EndRenderPassCommand>(bufferInOut);

        }

    }

    else

    {

        { // Generate Full Res AO

            GFX::BeginRenderPassCommand* renderPassCmd = GFX::EnqueueCommand<GFX::BeginRenderPassCommand>(bufferInOut);

            renderPassCmd->_name = "DO_SSAO_CALC";

            renderPassCmd->_target = _ssaoOutput._targetID;

            renderPassCmd->_clearDescriptor[to_base( RTColourAttachmentSlot::SLOT_0 )] = DEFAULT_CLEAR_ENTRY;

            renderPassCmd->_descriptor._drawMask[to_base( RTColourAttachmentSlot::SLOT_0 )] = true;


            GFX::EnqueueCommand<GFX::BindPipelineCommand>(bufferInOut)->_pipeline = _generateFullResPipeline;


            auto cmd = GFX::EnqueueCommand<GFX::BindShaderResourcesCommand>(bufferInOut);

            cmd->_usage = DescriptorSetUsage::PER_DRAW;

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 0u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, _noiseTexture, _noiseSampler );

            }

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 1u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, depthAtt->texture(), depthAtt->_descriptor._sampler );

            }

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 2u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, normalsAtt->texture(), normalsAtt->_descriptor._sampler );

            }


            GFX::SendPushConstantsCommand* sendPushConstantsCmd = GFX::EnqueueCommand<GFX::SendPushConstantsCommand>( bufferInOut );

            sendPushConstantsCmd->_uniformData = &_ssaoGenerateConstants;

            sendPushConstantsCmd->_fastData.data[0] = cameraSnapshot._projectionMatrix;

            sendPushConstantsCmd->_fastData.data[1] = cameraSnapshot._invProjectionMatrix;


            GFX::EnqueueCommand<GFX::DrawCommand>(bufferInOut)->_drawCommands.emplace_back();

            GFX::EnqueueCommand<GFX::EndRenderPassCommand>(bufferInOut);

        }

    }

    {

        const auto& ssaoAtt = _ssaoOutput._rt->getAttachment(RTAttachmentType::COLOUR);


        if (blurResults() && blurKernelSize() > 0)

        {

            _ssaoBlurConstants.set(_ID("_zPlanes"), PushConstantType::VEC2, cameraSnapshot._zPlanes);

            _ssaoBlurConstants.set(_ID("texelSize"), PushConstantType::VEC2, vec2<F32>{ 1.f / Get(ssaoAtt->texture())->width(), 1.f / Get(ssaoAtt->texture())->height() });


            // Blur AO

            { //Horizontal

                GFX::BeginRenderPassCommand* renderPassCmd = GFX::EnqueueCommand<GFX::BeginRenderPassCommand>(bufferInOut);

                renderPassCmd->_name = "DO_SSAO_BLUR_HORIZONTAL";

                renderPassCmd->_target = _ssaoBlurBuffer._targetID;

                renderPassCmd->_clearDescriptor[to_base( RTColourAttachmentSlot::SLOT_0 )] = DEFAULT_CLEAR_ENTRY;

                renderPassCmd->_descriptor._drawMask[to_base( RTColourAttachmentSlot::SLOT_0 )] = true;


                GFX::EnqueueCommand<GFX::BindPipelineCommand>(bufferInOut)->_pipeline = _blurHorizontalPipeline;


                GFX::SendPushConstantsCommand* sendPushConstantsCmd = GFX::EnqueueCommand<GFX::SendPushConstantsCommand>( bufferInOut );

                sendPushConstantsCmd->_uniformData = &_ssaoBlurConstants;

                sendPushConstantsCmd->_fastData.data[0] = cameraSnapshot._invProjectionMatrix;


                auto cmd = GFX::EnqueueCommand<GFX::BindShaderResourcesCommand>(bufferInOut);

                cmd->_usage = DescriptorSetUsage::PER_DRAW;

                {

                    DescriptorSetBinding& binding = AddBinding( cmd->_set, 0u, ShaderStageVisibility::FRAGMENT );

                    Set( binding._data, ssaoAtt->texture(), ssaoAtt->_descriptor._sampler );

                }

                {

                    DescriptorSetBinding& binding = AddBinding( cmd->_set, 1u, ShaderStageVisibility::FRAGMENT );

                    Set( binding._data, depthAtt->texture(), depthAtt->_descriptor._sampler );

                }

                {

                    DescriptorSetBinding& binding = AddBinding( cmd->_set, 2u, ShaderStageVisibility::FRAGMENT );

                    Set( binding._data, normalsAtt->texture(), normalsAtt->_descriptor._sampler );

                }


                GFX::EnqueueCommand<GFX::DrawCommand>(bufferInOut)->_drawCommands.emplace_back();

                GFX::EnqueueCommand<GFX::EndRenderPassCommand>(bufferInOut);

            }

            { //Vertical

                GFX::BeginRenderPassCommand* renderPassCmd = GFX::EnqueueCommand<GFX::BeginRenderPassCommand>(bufferInOut);

                renderPassCmd->_name = "DO_SSAO_BLUR_VERTICAL";

                renderPassCmd->_target = RenderTargetNames::SSAO_RESULT;

                renderPassCmd->_clearDescriptor[to_base( RTColourAttachmentSlot::SLOT_0 )] = DEFAULT_CLEAR_ENTRY;

                renderPassCmd->_descriptor._drawMask[to_base( RTColourAttachmentSlot::SLOT_0 )] = true;


                GFX::EnqueueCommand<GFX::BindPipelineCommand>(bufferInOut)->_pipeline = _blurVerticalPipeline;


                GFX::SendPushConstantsCommand* sendPushConstantsCmd = GFX::EnqueueCommand<GFX::SendPushConstantsCommand>( bufferInOut );

                sendPushConstantsCmd->_uniformData = &_ssaoBlurConstants;

                sendPushConstantsCmd->_fastData.data[0] = cameraSnapshot._invProjectionMatrix;


                const auto& horizBlur = _ssaoBlurBuffer._rt->getAttachment(RTAttachmentType::COLOUR);

                auto cmd = GFX::EnqueueCommand<GFX::BindShaderResourcesCommand>(bufferInOut);

                cmd->_usage = DescriptorSetUsage::PER_DRAW;

                {

                    DescriptorSetBinding& binding = AddBinding( cmd->_set, 0u, ShaderStageVisibility::FRAGMENT );

                    Set( binding._data, horizBlur->texture(), ssaoAtt->_descriptor._sampler );

                }

                {

                    DescriptorSetBinding& binding = AddBinding( cmd->_set, 1u, ShaderStageVisibility::FRAGMENT );

                    Set( binding._data, depthAtt->texture(), depthAtt->_descriptor._sampler );

                }

                {

                    DescriptorSetBinding& binding = AddBinding( cmd->_set, 2u, ShaderStageVisibility::FRAGMENT );

                    Set( binding._data, normalsAtt->texture(), normalsAtt->_descriptor._sampler );

                }


                GFX::EnqueueCommand<GFX::DrawCommand>(bufferInOut)->_drawCommands.emplace_back();

                GFX::EnqueueCommand<GFX::EndRenderPassCommand>(bufferInOut);

            }

        }

        else

        {

            GFX::BeginRenderPassCommand* renderPassCmd = GFX::EnqueueCommand<GFX::BeginRenderPassCommand>(bufferInOut);

            renderPassCmd->_name = "DO_SSAO_PASS_THROUGH";

            renderPassCmd->_target = RenderTargetNames::SSAO_RESULT;

            renderPassCmd->_clearDescriptor[to_base( RTColourAttachmentSlot::SLOT_0 )] = DEFAULT_CLEAR_ENTRY;

            renderPassCmd->_descriptor._drawMask[to_base( RTColourAttachmentSlot::SLOT_0 )] = true;


            GFX::EnqueueCommand<GFX::BindPipelineCommand>(bufferInOut)->_pipeline = _passThroughPipeline;


            auto cmd = GFX::EnqueueCommand<GFX::BindShaderResourcesCommand>(bufferInOut);

            cmd->_usage = DescriptorSetUsage::PER_DRAW;

            {

                DescriptorSetBinding& binding = AddBinding( cmd->_set, 0u, ShaderStageVisibility::FRAGMENT );

                Set( binding._data, ssaoAtt->texture(), ssaoAtt->_descriptor._sampler );

            }

            GFX::EnqueueCommand<GFX::DrawCommand>(bufferInOut)->_drawCommands.emplace_back();

            GFX::EnqueueCommand<GFX::EndRenderPassCommand>(bufferInOut);

        }

    }


    // No need to swap targets

    return false;

}

}

WAIT_FOR_CONDITION
#define WAIT_FOR_CONDITION(...)
Definition: ConditionalWait.h:65

Configuration.h

GFXDevice.h

GFXRTPool.h

PlatformContext.h

DIVIDE_UNEXPECTED_CALL
#define DIVIDE_UNEXPECTED_CALL()
Definition: PlatformDefines.h:737

PreRenderBatch.h

ProjectManager.h

Quad3D.h

RenderStateBlock.h

ResourceCache.h

SSAOPreRenderOperator.h

ShaderProgram.h

StringHelper.h

Divide::GFX::CommandBuffer
Definition: CommandBuffer.h:110

Divide::GFXDevice
Rough around the edges Adapter pattern abstracting the actual rendering API and access to the GPU.
Definition: GFXDevice.h:215

Divide::GFXDevice::renderTargetPool
GFXRTPool & renderTargetPool() noexcept
Definition: GFXDevice.inl:133

Divide::GFXDevice::newPipeline
Pipeline * newPipeline(const PipelineDescriptor &descriptor)
Create and return a new graphics pipeline. This is only used for caching and doesn't use the object a...
Definition: GFXDevice.cpp:3074

Divide::GFXDevice::get2DStateBlock
const RenderStateBlock & get2DStateBlock() const noexcept
Definition: GFXDevice.inl:123

Divide::GFXRTPool::getRenderTarget
RenderTarget * getRenderTarget(const RenderTargetID target) const
Definition: GFXRTPool.cpp:50

Divide::GFXRTPool::allocateRT
RenderTargetHandle allocateRT(const RenderTargetDescriptor &descriptor)
Definition: GFXRTPool.cpp:17

Divide::GFXRTPool::deallocateRT
bool deallocateRT(RenderTargetHandle &handle)
Definition: GFXRTPool.cpp:33

Divide::PlatformContextComponent::context
PlatformContext & context() noexcept
Definition: PlatformContextComponent.h:48

Divide::PlatformContext::config
Configuration & config() noexcept
Definition: PlatformContext.h:117

Divide::PreRenderBatch
Definition: PreRenderBatch.h:83

Divide::PreRenderBatch::screenRT
RenderTargetHandle screenRT() const noexcept
Definition: PreRenderBatch.inl:58

Divide::PreRenderOperator
Definition: PreRenderOperator.h:53

Divide::PreRenderOperator::_enabled
bool _enabled
Definition: PreRenderOperator.h:81

Divide::PreRenderOperator::reshape
virtual void reshape(U16 width, U16 height)
Definition: PreRenderOperator.cpp:27

Divide::PreRenderOperator::prepare
virtual void prepare(PlayerIndex idx, GFX::CommandBuffer &bufferInOut)
Definition: PreRenderOperator.cpp:23

Divide::PreRenderOperator::ready
virtual bool ready() const noexcept
Definition: PreRenderOperator.h:73

Divide::PreRenderOperator::_context
GFXDevice & _context
Definition: PreRenderOperator.h:76

Divide::PreRenderOperator::_parent
PreRenderBatch & _parent
Definition: PreRenderOperator.h:78

Divide::RenderTarget::getAttachment
RTAttachment * getAttachment(RTAttachmentType type, RTColourAttachmentSlot slot=RTColourAttachmentSlot::SLOT_0) const
Definition: RenderTarget.cpp:179

Divide::RenderTarget::resize
bool resize(U16 width, U16 height)
Resize all attachments.
Definition: RenderTarget.cpp:245

Divide::RenderTarget::getWidth
U16 getWidth() const noexcept
Definition: RenderTarget.cpp:220

Divide::RenderTarget::getHeight
U16 getHeight() const noexcept
Definition: RenderTarget.cpp:225

Divide::SSAOPreRenderOperator::_blurSharpness
F32 _blurSharpness[2]
Definition: SSAOPreRenderOperator.h:117

Divide::SSAOPreRenderOperator::bias
F32 bias() const noexcept
Definition: SSAOPreRenderOperator.h:55

Divide::SSAOPreRenderOperator::_blur
bool _blur[2]
Definition: SSAOPreRenderOperator.h:120

Divide::SSAOPreRenderOperator::prepare
void prepare(PlayerIndex idx, GFX::CommandBuffer &bufferInOut) override
Definition: SSAOPreRenderOperator.cpp:536

Divide::SSAOPreRenderOperator::blurSharpness
F32 blurSharpness() const noexcept
Definition: SSAOPreRenderOperator.h:67

Divide::SSAOPreRenderOperator::_radius
F32 _radius[2]
Definition: SSAOPreRenderOperator.h:111

Divide::SSAOPreRenderOperator::blurKernelSize
I32 blurKernelSize() const noexcept
Definition: SSAOPreRenderOperator.h:70

Divide::SSAOPreRenderOperator::_ssaoHalfResOutput
RenderTargetHandle _ssaoHalfResOutput
Definition: SSAOPreRenderOperator.h:108

Divide::SSAOPreRenderOperator::_power
F32 _power[2]
Definition: SSAOPreRenderOperator.h:113

Divide::SSAOPreRenderOperator::_kernelSize
I32 _kernelSize[2]
Definition: SSAOPreRenderOperator.h:118

Divide::SSAOPreRenderOperator::~SSAOPreRenderOperator
~SSAOPreRenderOperator() override
Definition: SSAOPreRenderOperator.cpp:294

Divide::SSAOPreRenderOperator::_noiseSampler
SamplerDescriptor _noiseSampler
Definition: SSAOPreRenderOperator.h:106

Divide::SSAOPreRenderOperator::_maxRange
F32 _maxRange[2]
Definition: SSAOPreRenderOperator.h:114

Divide::SSAOPreRenderOperator::_ssaoUpSampleShader
Handle< ShaderProgram > _ssaoUpSampleShader
Definition: SSAOPreRenderOperator.h:96

Divide::SSAOPreRenderOperator::blurResults
bool blurResults() const noexcept
Definition: SSAOPreRenderOperator.h:61

Divide::SSAOPreRenderOperator::_generateFullResPipeline
Pipeline * _generateFullResPipeline
Definition: SSAOPreRenderOperator.h:100

Divide::SSAOPreRenderOperator::_bias
F32 _bias[2]
Definition: SSAOPreRenderOperator.h:112

Divide::SSAOPreRenderOperator::_blurVerticalPipeline
Pipeline * _blurVerticalPipeline
Definition: SSAOPreRenderOperator.h:102

Divide::SSAOPreRenderOperator::_blurThreshold
F32 _blurThreshold[2]
Definition: SSAOPreRenderOperator.h:116

Divide::SSAOPreRenderOperator::_ssaoGenerateConstants
UniformData _ssaoGenerateConstants
Definition: SSAOPreRenderOperator.h:88

Divide::SSAOPreRenderOperator::_noiseTexture
Handle< Texture > _noiseTexture
Definition: SSAOPreRenderOperator.h:105

Divide::SSAOPreRenderOperator::_ssaoBlurShaderVertical
Handle< ShaderProgram > _ssaoBlurShaderVertical
Definition: SSAOPreRenderOperator.h:93

Divide::SSAOPreRenderOperator::_halfDepthAndNormals
RenderTargetHandle _halfDepthAndNormals
Definition: SSAOPreRenderOperator.h:109

Divide::SSAOPreRenderOperator::_genHalfRes
bool _genHalfRes
Definition: SSAOPreRenderOperator.h:122

Divide::SSAOPreRenderOperator::blurThreshold
F32 blurThreshold() const noexcept
Definition: SSAOPreRenderOperator.h:64

Divide::SSAOPreRenderOperator::reshape
void reshape(U16 width, U16 height) override
Definition: SSAOPreRenderOperator.cpp:330

Divide::SSAOPreRenderOperator::fadeStart
F32 fadeStart() const noexcept
Definition: SSAOPreRenderOperator.h:76

Divide::SSAOPreRenderOperator::_ssaoBlurBuffer
RenderTargetHandle _ssaoBlurBuffer
Definition: SSAOPreRenderOperator.h:110

Divide::SSAOPreRenderOperator::_ssaoOutput
RenderTargetHandle _ssaoOutput
Definition: SSAOPreRenderOperator.h:107

Divide::SSAOPreRenderOperator::_ssaoGenerateHalfResShader
Handle< ShaderProgram > _ssaoGenerateHalfResShader
Definition: SSAOPreRenderOperator.h:91

Divide::SSAOPreRenderOperator::_kernelSampleCount
U8 _kernelSampleCount[2]
Definition: SSAOPreRenderOperator.h:119

Divide::SSAOPreRenderOperator::_ssaoGenerateShader
Handle< ShaderProgram > _ssaoGenerateShader
Definition: SSAOPreRenderOperator.h:90

Divide::SSAOPreRenderOperator::_passThroughPipeline
Pipeline * _passThroughPipeline
Definition: SSAOPreRenderOperator.h:103

Divide::SSAOPreRenderOperator::sampleCount
U8 sampleCount() const noexcept
Definition: SSAOPreRenderOperator.cpp:531

Divide::SSAOPreRenderOperator::ready
bool ready() const noexcept override
Definition: SSAOPreRenderOperator.cpp:314

Divide::SSAOPreRenderOperator::_ssaoDownSampleShader
Handle< ShaderProgram > _ssaoDownSampleShader
Definition: SSAOPreRenderOperator.h:95

Divide::SSAOPreRenderOperator::_generateHalfResPipeline
Pipeline * _generateHalfResPipeline
Definition: SSAOPreRenderOperator.h:98

Divide::SSAOPreRenderOperator::_blurHorizontalPipeline
Pipeline * _blurHorizontalPipeline
Definition: SSAOPreRenderOperator.h:101

Divide::SSAOPreRenderOperator::_stateChanged
bool _stateChanged
Definition: SSAOPreRenderOperator.h:121

Divide::SSAOPreRenderOperator::radius
F32 radius() const noexcept
Definition: SSAOPreRenderOperator.h:49

Divide::SSAOPreRenderOperator::_ssaoPassThroughShader
Handle< ShaderProgram > _ssaoPassThroughShader
Definition: SSAOPreRenderOperator.h:94

Divide::SSAOPreRenderOperator::_ssaoBlurShaderHorizontal
Handle< ShaderProgram > _ssaoBlurShaderHorizontal
Definition: SSAOPreRenderOperator.h:92

Divide::SSAOPreRenderOperator::_downsamplePipeline
Pipeline * _downsamplePipeline
Definition: SSAOPreRenderOperator.h:97

Divide::SSAOPreRenderOperator::power
F32 power() const noexcept
Definition: SSAOPreRenderOperator.h:52

Divide::SSAOPreRenderOperator::_ssaoBlurConstants
UniformData _ssaoBlurConstants
Definition: SSAOPreRenderOperator.h:89

Divide::SSAOPreRenderOperator::SSAOPreRenderOperator
SSAOPreRenderOperator(GFXDevice &context, PreRenderBatch &parent)
Definition: SSAOPreRenderOperator.cpp:45

Divide::SSAOPreRenderOperator::_fadeStart
F32 _fadeStart[2]
Definition: SSAOPreRenderOperator.h:115

Divide::SSAOPreRenderOperator::execute
bool execute(PlayerIndex idx, const CameraSnapshot &cameraSnapshot, const RenderTargetHandle &input, const RenderTargetHandle &output, GFX::CommandBuffer &bufferInOut) override
Return true if we rendered into "output".
Definition: SSAOPreRenderOperator.cpp:555

Divide::SSAOPreRenderOperator::maxRange
F32 maxRange() const noexcept
Definition: SSAOPreRenderOperator.h:73

Divide::SSAOPreRenderOperator::genHalfRes
bool genHalfRes() const noexcept
Definition: SSAOPreRenderOperator.h:58

Divide::SSAOPreRenderOperator::_upsamplePipeline
Pipeline * _upsamplePipeline
Definition: SSAOPreRenderOperator.h:99

Divide::vec2
Definition: MathVectors.h:130

Divide::vec3
Definition: MathVectors.h:480

Divide::vec3::normalize
vec3 & normalize() noexcept
transform the vector to unit length
Definition: MathVectors.inl:516

Divide::vec3::set
void set(const T *v) noexcept
set the 3 components of the vector manually using a source pointer to a (large enough) array
Definition: MathVectors.h:707

Divide::vec4
Definition: MathVectors.h:915

Divide::Util::StringFormat
Str StringFormat(const char *fmt, Args &&...args)
Definition: StringHelper.inl:358

Divide::anonymous_namespace{SSAOPreRenderOperator.cpp}::ComputeKernel
const vector< vec4< F32 > > & ComputeKernel(const U8 sampleCount)
Definition: SSAOPreRenderOperator.cpp:28

Divide::anonymous_namespace{SSAOPreRenderOperator.cpp}::g_kernels
vector< vec4< F32 > > g_kernels
Definition: SSAOPreRenderOperator.cpp:26

Divide::anonymous_namespace{SSAOPreRenderOperator.cpp}::SSAO_BLUR_SIZE
constexpr U8 SSAO_BLUR_SIZE
Definition: SSAOPreRenderOperator.cpp:23

Divide::anonymous_namespace{SSAOPreRenderOperator.cpp}::SSAO_NOISE_SIZE
constexpr U8 SSAO_NOISE_SIZE
Definition: SSAOPreRenderOperator.cpp:22

Divide::anonymous_namespace{SSAOPreRenderOperator.cpp}::MAX_KERNEL_SIZE
constexpr U8 MAX_KERNEL_SIZE
Definition: SSAOPreRenderOperator.cpp:24

Divide::anonymous_namespace{SSAOPreRenderOperator.cpp}::MIN_KERNEL_SIZE
constexpr U8 MIN_KERNEL_SIZE
Definition: SSAOPreRenderOperator.cpp:25

Divide
Handle console commands that start with a forward slash.
Definition: AIProcessor.cpp:7

Divide::PushConstantType::INT
@ INT

Divide::PushConstantType::VEC2
@ VEC2

Divide::PushConstantType::FLOAT
@ FLOAT

Divide::PushConstantType::VEC4
@ VEC4

Divide::Byte
std::byte Byte
Definition: PlatformDataTypes.h:97

Divide::DestroyResource
FORCE_INLINE void DestroyResource(Handle< T > &handle, const bool immediate=false)
Definition: ResourceCache.h:147

Divide::RT_DEPTH_ATTACHMENT_IDX
static constexpr U32 RT_DEPTH_ATTACHMENT_IDX
Definition: RTAttachment.h:71

Divide::SQUARED
constexpr T SQUARED(T input) noexcept
Definition: MathHelper.inl:156

Divide::TextureMipSampling::NONE
@ NONE

Divide::I32
int32_t I32
Definition: PlatformDataTypes.h:50

Divide::U8
uint8_t U8
Definition: PlatformDataTypes.h:44

Divide::TextureFilter::NEAREST
@ NEAREST

Divide::ResourceState::RES_LOADED
@ RES_LOADED
The resource is available for usage.

Divide::PrimitiveTopology::TRIANGLES
@ TRIANGLES

Divide::to_F32
constexpr F32 to_F32(const T value)
Definition: PlatformDataTypes.h:318

Divide::TextureWrap::REPEAT
@ REPEAT

Divide::TextureWrap::CLAMP_TO_EDGE
@ CLAMP_TO_EDGE

Divide::RTAttachmentType::DEPTH
@ DEPTH

Divide::RTAttachmentType::COLOUR
@ COLOUR

Divide::Random
T Random()
Definition: MathHelper.inl:95

Divide::F32
float F32
Definition: PlatformDataTypes.h:82

Divide::vector
eastl::vector< Type > vector
Definition: Vector.h:42

Divide::GFXImagePacking::UNNORMALIZED
@ UNNORMALIZED

Divide::parent
Project & parent
Definition: DefaultScene.h:41

Divide::U16
uint16_t U16
Definition: PlatformDataTypes.h:45

Divide::Set
void Set(DescriptorSetBindingData &dataInOut, ShaderBuffer *buffer, const BufferRange range) noexcept
Definition: DescriptorSets.cpp:62

Divide::_ID
constexpr U64 _ID(const char *const str, const U64 value=val_64_const) noexcept
Definition: PlatformDefines.h:171

Divide::AddBinding
DescriptorSetBinding & AddBinding(DescriptorSet &setInOut, U8 slot, U16 stageVisibilityMask)
Definition: DescriptorSets.inl:128

Divide::PlayerIndex
U8 PlayerIndex
Definition: PlatformDefines.h:153

Divide::CreateResource
FORCE_INLINE Handle< T > CreateResource(const ResourceDescriptor< T > &descriptor, bool &wasInCache, std::atomic_uint &taskCounter)
Definition: ResourceCache.h:113

Divide::RTColourAttachmentSlot::SLOT_0
@ SLOT_0

Divide::CLAMPED
::value constexpr T CLAMPED(T n, T min, T max) noexcept
Definition: MathHelper.inl:126

Divide::FilterType
FilterType
Definition: PreRenderOperator.h:26

Divide::FilterType::FILTER_SS_AMBIENT_OCCLUSION
@ FILTER_SS_AMBIENT_OCCLUSION

Divide::ShaderStageVisibility::FRAGMENT
@ FRAGMENT

Divide::GFXImageFormat::RED
@ RED

Divide::ShaderType::VERTEX
@ VERTEX

Divide::ShaderType::FRAGMENT
@ FRAGMENT

Divide::DEFAULT_CLEAR_ENTRY
RTClearEntry DEFAULT_CLEAR_ENTRY
Definition: RTDrawDescriptor.cpp:10

Divide::FastLerp
T FastLerp(T v1, T v2, U t) noexcept
Definition: MathHelper.inl:246

Divide::COMPARE
bool COMPARE(T X, U Y) noexcept
Definition: PlatformDefines.h:597

Divide::DescriptorSetUsage::PER_DRAW
@ PER_DRAW

Divide::GFXDataFormat::FLOAT_32
@ FLOAT_32

Divide::GFXDataFormat::FLOAT_16
@ FLOAT_16

Divide::Get
FORCE_INLINE T * Get(const Handle< T > handle)
Definition: ResourceCache.h:153

Divide::MipMappingState::OFF
@ OFF

Divide::to_base
constexpr auto to_base(const Type value) -> Type
Definition: PlatformDataTypes.h:228

Divide::CameraSnapshot
Definition: CameraSnapshot.h:39

Divide::CameraSnapshot::_projectionMatrix
mat4< F32 > _projectionMatrix
Definition: CameraSnapshot.h:42

Divide::CameraSnapshot::_zPlanes
vec2< F32 > _zPlanes
Definition: CameraSnapshot.h:47

Divide::CameraSnapshot::_invProjectionMatrix
mat4< F32 > _invProjectionMatrix
Definition: CameraSnapshot.h:43

Divide::Configuration::Rendering::PostFX::SSAO::FullRes
SSAOSettings FullRes
Definition: Configuration.h:216

Divide::Configuration::Rendering::PostFX::SSAO::HalfRes
SSAOSettings HalfRes
Definition: Configuration.h:217

Divide::Configuration::Rendering::PostFX::SSAO::UseHalfResolution
bool UseHalfResolution
Definition: Configuration.h:215

Divide::Configuration::Rendering::PostFX::ssao
struct Divide::Configuration::Rendering::PostFX::SSAO ssao

Divide::Configuration::Rendering::postFX
struct Divide::Configuration::Rendering::PostFX postFX

Divide::Configuration::SSAOSettings::BlurSharpness
F32 BlurSharpness
Definition: Configuration.h:136

Divide::Configuration::SSAOSettings::MaxRange
F32 MaxRange
Definition: Configuration.h:138

Divide::Configuration::SSAOSettings::Radius
F32 Radius
Definition: Configuration.h:130

Divide::Configuration::SSAOSettings::FadeDistance
F32 FadeDistance
Definition: Configuration.h:139

Divide::Configuration::SSAOSettings::Power
F32 Power
Definition: Configuration.h:132

Divide::Configuration::SSAOSettings::BlurThreshold
F32 BlurThreshold
Definition: Configuration.h:135

Divide::Configuration::SSAOSettings::Bias
F32 Bias
Definition: Configuration.h:131

Divide::Configuration::SSAOSettings::BlurKernelSize
I32 BlurKernelSize
Definition: Configuration.h:137

Divide::Configuration::rendering
struct Divide::Configuration::Rendering rendering

Divide::DescriptorSetBinding
Definition: DescriptorSets.h:127

Divide::DescriptorSetBinding::_data
DescriptorSetBindingData _data
Definition: DescriptorSets.h:128

Divide::GFX::BeginRenderPassCommand
Definition: Commands.inl:94

Divide::GFX::BeginRenderPassCommand::_name
Str< 64 > _name
Definition: Commands.inl:98

Divide::GFX::BeginRenderPassCommand::_descriptor
RTDrawDescriptor _descriptor
Definition: Commands.inl:96

Divide::GFX::BeginRenderPassCommand::_clearDescriptor
RTClearDescriptor _clearDescriptor
Definition: Commands.inl:97

Divide::GFX::BeginRenderPassCommand::_target
RenderTargetID _target
Definition: Commands.inl:95

Divide::GFX::SendPushConstantsCommand
Definition: Commands.inl:75

Divide::GFX::SendPushConstantsCommand::_fastData
PushConstantsStruct _fastData
Definition: Commands.inl:77

Divide::GFX::SendPushConstantsCommand::_uniformData
UniformData * _uniformData
Definition: Commands.inl:76

Divide::InternalRTAttachmentDescriptor
Definition: RTAttachment.h:89

Divide::PipelineDescriptor
Definition: Pipeline.h:44

Divide::PipelineDescriptor::_primitiveTopology
PrimitiveTopology _primitiveTopology
Definition: Pipeline.h:48

Divide::PipelineDescriptor::_shaderProgramHandle
Handle< ShaderProgram > _shaderProgramHandle
Definition: Pipeline.h:47

Divide::PipelineDescriptor::_stateBlock
RenderStateBlock _stateBlock
Definition: Pipeline.h:46

Divide::PropertyDescriptor< ShaderProgram >
Definition: ShaderProgramFwd.h:75

Divide::PropertyDescriptor< ShaderProgram >::_modules
vector< ShaderModuleDescriptor > _modules
Definition: ShaderProgramFwd.h:78

Divide::PropertyDescriptor< Texture >
Definition: TextureDescriptor.h:64

Divide::PropertyDescriptor< Texture >::_dataType
GFXDataFormat _dataType
Definition: TextureDescriptor.h:72

Divide::PropertyDescriptor< Texture >::_mipMappingState
MipMappingState _mipMappingState
Definition: TextureDescriptor.h:75

Divide::PropertyDescriptor< Texture >::_packing
GFXImagePacking _packing
Definition: TextureDescriptor.h:73

Divide::PushConstantsStruct::data
mat4< F32 > data[2]
Definition: PushConstants.h:42

Divide::RTDrawDescriptor::_drawMask
RTDrawMask _drawMask
Definition: RTDrawDescriptor.h:85

Divide::RenderStateBlock
Definition: RenderStateBlock.h:53

Divide::RenderStateBlock::_colourWrite
P32 _colourWrite
Definition: RenderStateBlock.h:54

Divide::RenderTargetDescriptor
Definition: RenderTarget.h:51

Divide::RenderTargetDescriptor::_name
Str< 64 > _name
Definition: RenderTarget.h:54

Divide::RenderTargetDescriptor::_resolution
vec2< U16 > _resolution
Definition: RenderTarget.h:55

Divide::RenderTargetDescriptor::_attachments
InternalRTAttachmentDescriptors _attachments
Definition: RenderTarget.h:52

Divide::RenderTargetHandle
Definition: RenderTarget.h:45

Divide::RenderTargetHandle::_targetID
RenderTargetID _targetID
Definition: RenderTarget.h:47

Divide::RenderTargetHandle::_rt
RenderTarget * _rt
Definition: RenderTarget.h:46

Divide::RenderTargetNames::NORMALS_RESOLVED
static RenderTargetID NORMALS_RESOLVED
Definition: GFXDevice.h:199

Divide::RenderTargetNames::SSAO_RESULT
static RenderTargetID SSAO_RESULT
Definition: GFXDevice.h:202

Divide::ResourceDescriptor
Definition: Resource.h:147

Divide::ResourceDescriptor::_propertyDescriptor
PropertyDescriptor< T > _propertyDescriptor
Definition: Resource.h:151

Divide::SamplerDescriptor
Definition: SamplerDescriptor.h:54

Divide::SamplerDescriptor::_minFilter
TextureFilter _minFilter
Texture filtering mode.
Definition: SamplerDescriptor.h:61

Divide::SamplerDescriptor::_wrapU
TextureWrap _wrapU
Texture wrap mode (Or S-R-T)
Definition: SamplerDescriptor.h:65

Divide::SamplerDescriptor::_anisotropyLevel
U8 _anisotropyLevel
The value must be in the range [0...255] and is automatically clamped by the max HW supported level.
Definition: SamplerDescriptor.h:69

Divide::SamplerDescriptor::_magFilter
TextureFilter _magFilter
Definition: SamplerDescriptor.h:62

Divide::SamplerDescriptor::_wrapV
TextureWrap _wrapV
Definition: SamplerDescriptor.h:66

Divide::SamplerDescriptor::_mipSampling
TextureMipSampling _mipSampling
Definition: SamplerDescriptor.h:63

Divide::SamplerDescriptor::_wrapW
TextureWrap _wrapW
Definition: SamplerDescriptor.h:67

Divide::ShaderModuleDescriptor
Definition: ShaderProgramFwd.h:63

Divide::ShaderModuleDescriptor::_variant
Str< 64 > _variant
Definition: ShaderProgramFwd.h:69

Divide::ShaderModuleDescriptor::_defines
ModuleDefines _defines
Definition: ShaderProgramFwd.h:67

Divide::ShaderModuleDescriptor::_sourceFile
Str< 64 > _sourceFile
Definition: ShaderProgramFwd.h:68

Divide::ShaderModuleDescriptor::_moduleType
ShaderType _moduleType
Definition: ShaderProgramFwd.h:70

Divide::UniformData::set
void set(U64 bindingHash, PushConstantType type, const T &value)
Definition: PushConstants.inl:39

Divide::P32::b
U8 b[4]
Definition: PlatformDataTypes.h:179