foray_comparerstage.hpp

Go to the documentation of this file.

#pragma once
#include "../core/foray_samplercollection.hpp"
#include "../foray_glm.hpp"
#include "foray_computestage.hpp"
#include <array>
 
namespace foray::stages {
 
    class ComparerStage : public RenderStage
    {
      public:
        inline static constexpr std::string_view OutputName = "Comparer.Out";
 
        virtual void Init(core::Context* context, bool flipY);
 
        virtual void RecordFrame(VkCommandBuffer cmdBuffer, base::FrameRenderInfo& renderInfo) override;
 
        virtual void HandleEvent(const osi::Event* event);
        virtual void Resize(const VkExtent2D& extent) override;
 
        virtual void Destroy() override;
 
        enum class EInputType
        {
            Float,
            Int,
            Uint
        };
 
        struct InputInfo
        {
            core::ManagedImage* Image = nullptr;
            uint32_t ChannelCount = 4;
            glm::vec4 Scale = glm::vec4(1.f);
            VkImageAspectFlags Aspect = VkImageAspectFlagBits::VK_IMAGE_ASPECT_COLOR_BIT;
            EInputType Type = EInputType::Float;
        };
 
        struct PipetteValue
        {
            glm::vec4  Value;
            glm::vec2  UvPos;
            glm::ivec2 TexelPos;
        };
 
        virtual void SetInput(uint32_t index, const InputInfo& input);
 
        FORAY_PROPERTY_V(MixValue)
        FORAY_GETTER_CR(PipetteValue)
 
      protected:
        struct SubStage
        {
            uint32_t                   Index;
            InputInfo                  Input;
            core::CombinedImageSampler InputSampled;
            core::ShaderModule*        Shader;
            core::DescriptorSet        DescriptorSet;
            util::PipelineLayout       PipelineLayout;
            VkPipeline                 Pipeline = nullptr;
        };
 
        void CreateSubStage(SubStage& substage);
        void DispatchSubStage(SubStage& substage, VkCommandBuffer buffer, base::FrameRenderInfo& renderInfo);
        void DestroySubStage(SubStage& substage, bool final);
 
        void CreateOutputImage();
 
        void LoadShaders();
        void CreatePipetteBuffer();
 
        struct PushConstant
        {
            glm::vec4  Scale;
            glm::ivec2 MousePos;
            uint32_t   Channels;
            fp32_t     Mix;
            uint32_t   WriteOffset;
            VkBool32   WriteLeft;
        };
 
        std::array<SubStage, 2> mSubStages;
 
        core::ManagedImage  mOutput;
        core::ManagedBuffer mPipetteBuffer;
        void*               mPipetteMap = nullptr;
 
        PipetteValue mPipetteValue;
 
        std::array<core::ShaderModule, 3> mShaders;
 
        fp32_t     mMixValue = 0.5;
        glm::ivec2 mMousePos = {};
        bool       mFlipY    = false;
    };
}  // namespace foray::stages