HighlightEffect.h

//
//  HighlightEffect.h
//  render-utils/src/
//
//  Created by Olivier Prat on 08/08/17.
//  Copyright 2017 High Fidelity, Inc.
//  Copyright 2024 Overte e.V.
//
//  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_utils_HighlightEffect_h
#define hifi_render_utils_HighlightEffect_h
 
#include <render/Engine.h>
#include <render/HighlightStage.h>
#include <render/RenderFetchCullSortTask.h>
 
#include "DeferredFramebuffer.h"
#include "DeferredFrameTransform.h"
 
class HighlightResources {
public:
    HighlightResources();
 
    gpu::FramebufferPointer getDepthFramebuffer();
    gpu::TexturePointer getDepthTexture();
 
    gpu::FramebufferPointer getColorFramebuffer();
 
    // Update the source framebuffer size which will drive the allocation of all the other resources.
    void update(const gpu::FramebufferPointer& primaryFrameBuffer);
    const glm::ivec2& getSourceFrameSize() const { return _frameSize; }
 
protected:
 
    gpu::FramebufferPointer _depthFrameBuffer;
    gpu::FramebufferPointer _colorFrameBuffer;
    gpu::TexturePointer _depthStencilTexture;
 
    glm::ivec2 _frameSize;
 
    void allocateColorBuffer(const gpu::FramebufferPointer& primaryFrameBuffer);
    void allocateDepthBuffer(const gpu::FramebufferPointer& primaryFrameBuffer);
};
 
using HighlightResourcesPointer = std::shared_ptr<HighlightResources>;
 
class HighlightSharedParameters {
public:
 
    enum {
        MAX_PASS_COUNT = 8
    };
 
    HighlightSharedParameters();
 
    std::array<render::HighlightStage::Index, MAX_PASS_COUNT> _highlightIds;
 
    static float getBlurPixelWidth(const render::HighlightStyle& style, int frameBufferHeight);
};
 
using HighlightSharedParametersPointer = std::shared_ptr<HighlightSharedParameters>;
 
class PrepareDrawHighlight {
public:
    using Inputs = gpu::FramebufferPointer;
    using Outputs = render::VaryingSet2<HighlightResourcesPointer, render::Args::RenderMode>;
    using JobModel = render::Job::ModelIO<PrepareDrawHighlight, Inputs, Outputs>;
 
    PrepareDrawHighlight();
 
    void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs);
 
private:
 
    HighlightResourcesPointer _resources;
 
};
 
class SelectionToHighlight {
public:
 
    using Inputs = render::VaryingSet2<render::ItemBounds, gpu::FramebufferPointer>;
    using Outputs = render::VaryingSet2<std::vector<std::string>, std::vector<render::HighlightStage::Index>>;
    using JobModel = render::Job::ModelIO<SelectionToHighlight, Inputs, Outputs>;
 
    SelectionToHighlight(HighlightSharedParametersPointer parameters) : _sharedParameters{ parameters } {}
 
    void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs);
 
private:
 
    HighlightSharedParametersPointer _sharedParameters;
};
 
class ExtractSelectionName {
public:
 
    using Inputs = std::vector<std::string>;
    using Outputs = std::string;
    using JobModel = render::Job::ModelIO<ExtractSelectionName, Inputs, Outputs>;
 
    ExtractSelectionName(unsigned int highlightIndex) : _highlightPassIndex{ highlightIndex } {}
 
    void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs);
 
private:
 
    unsigned int _highlightPassIndex;
 
};
 
class DrawHighlightMask {
public:
    using Inputs = render::VaryingSet2<render::ShapeBounds, HighlightResourcesPointer>;
    using Outputs = glm::ivec4;
    using JobModel = render::Job::ModelIO<DrawHighlightMask, Inputs, Outputs>;
 
    DrawHighlightMask(unsigned int highlightIndex, render::ShapePlumberPointer shapePlumber, HighlightSharedParametersPointer parameters, uint transformSlot);
 
    void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs);
 
protected:
    unsigned int _highlightPassIndex;
    render::ShapePlumberPointer _shapePlumber;
    HighlightSharedParametersPointer _sharedParameters;
    gpu::BufferPointer _boundsBuffer;
    gpu::StructBuffer<glm::vec2> _outlineWidth;
    uint _transformSlot { 0 };
 
    static gpu::PipelinePointer _stencilMaskPipeline;
    static gpu::PipelinePointer _stencilMaskFillPipeline;
};
 
class DrawHighlight {
public:
 
    using Inputs = render::VaryingSet4<DeferredFrameTransformPointer, HighlightResourcesPointer, DeferredFramebufferPointer, glm::ivec4>;
    using Config = render::Job::Config;
    using JobModel = render::Job::ModelI<DrawHighlight, Inputs, Config>;
 
    DrawHighlight(unsigned int highlightIndex, HighlightSharedParametersPointer parameters);
 
    void run(const render::RenderContextPointer& renderContext, const Inputs& inputs);
 
private:
 
#include "Highlight_shared.slh"
 
    using HighlightConfigurationBuffer = gpu::StructBuffer<HighlightParameters>;
 
    static const gpu::PipelinePointer& getPipeline(const render::HighlightStyle& style);
 
    static gpu::PipelinePointer _pipeline;
    static gpu::PipelinePointer _pipelineFilled;
 
    unsigned int _highlightPassIndex;
    HighlightParameters _parameters;
    HighlightSharedParametersPointer _sharedParameters;
    HighlightConfigurationBuffer _configuration;
};
 
class DebugHighlightConfig : public render::Job::Config {
    Q_OBJECT
    Q_PROPERTY(bool viewMask MEMBER viewMask NOTIFY dirty)
 
public:
    bool viewMask { false };
 
signals:
    void dirty();
};
 
class DebugHighlight {
public:
    using Inputs = render::VaryingSet2<HighlightResourcesPointer, glm::ivec4>;
    using Config = DebugHighlightConfig;
    using JobModel = render::Job::ModelI<DebugHighlight, Inputs, Config>;
 
    DebugHighlight(uint transformSlot);
    ~DebugHighlight();
 
    void configure(const Config& config);
    void run(const render::RenderContextPointer& renderContext, const Inputs& inputs);
 
private:
 
    static gpu::PipelinePointer _depthPipeline;
    int _geometryDepthId { 0 };
    bool _isDisplayEnabled { false };
    uint _transformSlot { 0 };
 
    static gpu::PipelinePointer& getDepthPipeline();
    static void initializePipelines();
};
 
class DrawHighlightTask {
public:
 
    using Inputs = render::VaryingSet4<RenderFetchCullSortTask::BucketList, DeferredFramebufferPointer, gpu::FramebufferPointer, DeferredFrameTransformPointer>;    using Config = render::Task::Config;
    using JobModel = render::Task::ModelI<DrawHighlightTask, Inputs, Config>;
 
    DrawHighlightTask();
 
    void configure(const Config& config);
    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, uint transformSlot);
 
private:
    static const render::Varying addSelectItemJobs(JobModel& task, const render::Varying& selectionName, const RenderFetchCullSortTask::BucketList& items);
 
};
 
class AppendNonMetaOutlines {
public:
    using Inputs = render::VaryingSet2<render::ItemIDs, render::ItemBounds>;
    using Outputs = render::ItemIDs;
    using JobModel = render::Job::ModelIO<AppendNonMetaOutlines, Inputs, Outputs>;
 
    AppendNonMetaOutlines() {}
 
    void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs);
};
 
class HighlightCleanup {
public:
    using Inputs = render::VaryingSet2<std::vector<render::HighlightStage::Index>, render::Args::RenderMode>;
    using JobModel = render::Job::ModelI<HighlightCleanup, Inputs>;
 
    HighlightCleanup() {}
 
    void run(const render::RenderContextPointer& renderContext, const Inputs& inputs);
};
 
#endif // hifi_render_utils_HighlightEffect_h