cubedepthrendertarget.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "irendertarget.h"
#include "rendertexturecube.h"
 
// External Includes
#include <nap/resource.h>
#include <nap/resourceptr.h>
#include <vulkan/vulkan_core.h>
 
namespace nap
{
    // Forward Declares
    class DepthRenderTextureCube;
    class CubeDepthRenderTarget;
    class RenderService;
    class PerspCameraComponentInstance;
 
    // Called when rendering a cube depth texture layer
    using CubeDepthRenderTargetCallback = std::function<void(CubeDepthRenderTarget& target, const glm::mat4& projection, const glm::mat4& view)>;
 
 
    // CubeDepthRenderTarget
 
    class NAPAPI CubeDepthRenderTarget : public Resource, public IRenderTarget
    {
        RTTI_ENABLE(Resource)
    public:
        CubeDepthRenderTarget(Core& core);
        
        ~CubeDepthRenderTarget();
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual void beginRendering() override;
 
        virtual void endRendering() override;
 
        virtual const glm::ivec2 getBufferSize() const override                 { return mSize; }
 
        virtual void setClearColor(const RGBAColorFloat& color) override        { mClearValue = color.getRed(); }
        
        virtual const RGBAColorFloat& getClearColor() const override            { return mClearColor; }
 
        virtual ECullWindingOrder getWindingOrder() const override              { return ECullWindingOrder::Clockwise; }
 
        virtual VkRenderPass getRenderPass() const override                     { return mRenderPass; }
 
        virtual VkFormat getColorFormat() const override                        { return VK_FORMAT_UNDEFINED; }
 
        virtual VkFormat getDepthFormat() const override                        { return mVulkanDepthFormat; }
 
        virtual VkSampleCountFlagBits getSampleCount() const override           { return VK_SAMPLE_COUNT_1_BIT; }
        
        virtual bool getSampleShadingEnabled() const override                   { return mSampleShading; }
 
        glm::ivec2 getSize() const                                              { return mSize; }
 
        void render(CubeDepthRenderTargetCallback renderCallback);
 
        void render(PerspCameraComponentInstance& camera, CubeDepthRenderTargetCallback renderCallback);
 
        bool                                    mSampleShading = true;                                      
        float                                   mClearValue = 1.0f;                                         
        ERasterizationSamples                   mRequestedSamples = ERasterizationSamples::One;             
        DepthRenderTextureCube::EDepthFormat    mDepthFormat = DepthRenderTextureCube::EDepthFormat::D32;   
                                                                                                            
        ResourcePtr<DepthRenderTextureCube>     mCubeDepthTexture;                                          
 
    private:
        void renderInternal(const glm::vec3& camPosition, const glm::mat4& projectionMatrix, CubeDepthRenderTargetCallback renderCallback);
 
        void setLayerIndex(uint index);
 
        RenderService*                          mRenderService;
        VkRenderPass                            mRenderPass = VK_NULL_HANDLE;
        VkFormat                                mVulkanDepthFormat = VK_FORMAT_UNDEFINED;
 
        std::array<VkFramebuffer, TextureCube::layerCount>  mFramebuffers = { VK_NULL_HANDLE };
 
        glm::ivec2                              mSize;
        RGBAColorFloat                          mClearColor = { 1.0f, 1.0f, 1.0f, 1.0f };
        uint                                    mLayerIndex = 0U;
        bool                                    mIsFirstPass = true;
    };
}