cuberendertarget.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>
#include <texturelink.h>
 
namespace nap
{
    // Forward Declares
    class TextureCube;
    class CubeRenderTarget;
    class RenderService;
    class PerspCameraComponentInstance;
 
    // Called when rendering a cube texture layer
    using CubeRenderTargetCallback = std::function<void(CubeRenderTarget& target, const glm::mat4& projection, const glm::mat4& view)>;
 
 
    // Cube RenderTarget
 
    class NAPAPI CubeRenderTarget : public Resource, public IRenderTarget
    {
        RTTI_ENABLE(Resource)
    public:
        CubeRenderTarget(Core& core);
        
        ~CubeRenderTarget();
 
        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        { mClearColor = color; }
        
        virtual const RGBAColorFloat& getClearColor() const override            { return mClearColor; }
 
        virtual ECullWindingOrder getWindingOrder() const override              { return ECullWindingOrder::Clockwise; }
 
        virtual VkRenderPass getRenderPass() const override                     { return mRenderPass; }
 
        TextureCube& getColorTexture()                                          { return *mCubeTexture; }
 
        virtual VkFormat getColorFormat() const override                        { return mVulkanColorFormat; }
 
        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; }
 
        virtual VkImageLayout getFinalLayout() const override                   { return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; }
 
        glm::ivec2 getSize() const                                              { return mSize; }
 
        void render(CubeRenderTargetCallback renderCallback);
 
        void render(PerspCameraComponentInstance& camera, CubeRenderTargetCallback renderCallback);
 
        uint getLayerIndex() const                                              { return mLayerIndex; }
 
        static const std::vector<glm::mat4>& getCubeMapViewTransforms();
 
        bool                                    mSampleShading = true;                                      
        bool                                    mUpdateLODs = false;                                        
        RGBAColorFloat                          mClearColor = { 0.0f, 0.0f, 0.0f, 0.0f };                   
        RenderTextureCube::EFormat              mColorFormat = RenderTextureCube::EFormat::RGBA8;           
        DepthRenderTextureCube::EDepthFormat    mDepthFormat = DepthRenderTextureCube::EDepthFormat::D16;   
        ResourcePtr<RenderTextureCube>          mCubeTexture;                                               
        bool                                    mClear = true;                                              
 
    private:
        void renderInternal(const glm::vec3& camPosition, const glm::mat4& projectionMatrix, CubeRenderTargetCallback renderCallback);
 
        void setLayerIndex(uint index);
 
        RenderService*                          mRenderService;
        VkRenderPass                            mRenderPass = VK_NULL_HANDLE;
 
        VkFormat                                mVulkanColorFormat = VK_FORMAT_UNDEFINED;
        VkFormat                                mVulkanDepthFormat = VK_FORMAT_UNDEFINED;
 
        ImageData                               mDepthImage{ TextureCube::layerCount };
        ImageData                               mColorImage{ TextureCube::layerCount };
 
        std::array<VkFramebuffer, TextureCube::layerCount>  mFramebuffers = { VK_NULL_HANDLE };
 
        glm::ivec2                              mSize = { 0, 0 };
        uint                                    mLayerIndex = 0;
        TextureCubeTargetLink                   mTextureLink;
    };
}