RV_VKFramebuffer.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        RV_VKFramebuffer.h ( RV Library, C++)
 *
 * COMMENTS:
 *      Class for representing list of attachments as a framebuffer in Vulkan
 */
#ifndef RV_VKFramebuffer_h
#define RV_VKFramebuffer_h

#include "RV_API.h"

#include <UT/UT_Array.h>
#include <UT/UT_Rect.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_UniquePtr.h>

#include "RV_VK.h"
#include "RV_Instance.h"
#include "RV_Type.h"
#include "RV_VKEnum.h"

class RV_Instance;
class RV_Render;
class RV_Framebuffer;
class RV_VKCommandBuffer;
class RV_VKFramebuffer;
class RV_VKImage;
class RV_VKImageView;
class RV_VKRenderPass;

class rv_VKAttachment;
typedef UT_UniquePtr<rv_VKAttachment> rv_VKAttachmentPtr;

// info about the format of a renderpass i.e. the
// info required to know if two render passes are 
// compatible:
//  - attachment formats and samples
//  - creation flags
//  - subpass descriptions
//  - (layouts do not matter)
struct RV_RenderPassFormatInfo
{
    bool                        myIsDynamicRendering = false;
    bool                        myIsRenderPassRendering = false;

    // NOTE: using same sample count for all attachments
    int                         mySamples = 1;
    UT_FixedArray<VkFormat, 8>  myColorFormats = {};
    int                         myColorFormatCount = 0;
    VkFormat                    myDepthStencilFormat = VK_FORMAT_UNDEFINED;

    // TODO: multiview rendering
    // uint32                      myViewMask = 0;
    // NOTE: not bothering with subpasses at the moment
    // int                         mySubPassCount  = 1;

    bool operator==(const RV_RenderPassFormatInfo& other) const
    {
        return myIsDynamicRendering == other.myIsDynamicRendering
            && myIsRenderPassRendering == other.myIsRenderPassRendering
            && mySamples == other.mySamples
            && myColorFormats == other.myColorFormats
            && myColorFormatCount == other.myColorFormatCount
            && myDepthStencilFormat == other.myDepthStencilFormat;
    }

    bool operator!=(const RV_RenderPassFormatInfo& other) const
    {
        return !(*this == other);
    }
};

//#define USE_FRAMEBUFFER_CREATE_INFO
//
// VKFramebuffer doesn't represent an actual
// Vulkan object, and doesn't necessarily
// need to use a createInfo class -- 
// which allows detaching/attaching after
// creation 

#if !defined(USE_FRAMEBUFFER_CREATE_INFO)

class RV_API RV_Framebuffer : public UT_NonCopyable
{
public:
    static UT_UniquePtr<RV_Framebuffer> create(
            RV_Instance* inst,
            int w,
            int h,
            int samples = 1);

    RV_Framebuffer(int w, int h, int samples = 1);
    virtual ~RV_Framebuffer();

    virtual bool beginRendering(
            RV_Instance *inst,
            RV_VKCommandBuffer *cb,
            RV_ImageOp img_op = RV_IMAGE_LOAD,
            RV_RenderPassType type = RV_PASS_WHOLE) =0;
    
    virtual void endRendering(
            RV_Instance *inst,
            RV_VKCommandBuffer *cb) = 0;

    virtual bool fillPipelineInfo(RV_RenderPassFormatInfo& info) = 0;

    UT_DimRect getRenderRegion() const;

    // Update Framebuffer format state
    void        setSize(int w, int h) 
                        {
                            UT_ASSERT(w > 0 && h > 0);
                            myWidth = w; myHeight = h;
                        }
    int         getWidth() { return myWidth;}
    int         getHeight() { return myHeight;}

    void        setSampleCount(int samples);
    int         getSampleCount() { return mySamples; }

    void        setClearColor(UT_Vector4F c) { myClearColor = c; }
    UT_Vector4F getClearColor() const { return myClearColor; }

    void        setClearInt(UT_Vector4i i) { myClearInt = i; }
    UT_Vector4i getClearInt() const { return myClearInt; }

    void        setClearDepth(fpreal32 d) { myClearDepth = d; }
    fpreal32    getClearDepth() const { return myClearDepth; }

    void        getColorImages(UT_Array<const RV_VKImage*> &out_list);
    RV_VKImage* getDepthImage();

    // Update Target info
    bool        attachImage(RV_Render* r,
                            RV_VKImage* img,
                            RV_AttachmentType buffer_type,
                            int buffer_target = 0,
                            int level = 0,
                            int layer = 0);

    RV_VKImage* createImage(RV_Render* r, 
                            RV_GPUType type, int vec_size,
                            RV_AttachmentType attach_type,
                            int buffer_target = 0);

    void        detachColorImage(RV_Render *r, int buffer_target = 0);
    void        detachDepthImage(RV_Render *r);

protected:

    bool  fillPipelineAttachments(RV_RenderPassFormatInfo& out_info);
    const UT_Array<rv_VKAttachmentPtr>& colorAttachments() const
                    { return myColorAttachments; }
    const rv_VKAttachmentPtr&   depthAttachment() const
                    { return myDepthAttachment; }

    virtual void attachmentsChanged();

    // typed to match VK structs
    uint32_t myWidth = 0;
    uint32_t myHeight = 0;
    
    uint32_t mySamples = 1;

    UT_Vector4F myClearColor = UT_Vector4F(0.f, 0.f, 0.f, 0.f);
    UT_Vector4i myClearInt = UT_Vector4i(0, 0, 0, 0);
    fpreal32 myClearDepth = 1.f;

    int myDrawMask = 0;

    UT_Array<rv_VKAttachmentPtr>    myColorAttachments;
    rv_VKAttachmentPtr              myDepthAttachment;
};

class RV_API RV_DynamicFramebuffer : public RV_Framebuffer
{
public:
    RV_DynamicFramebuffer(int w, int h, int samples = 1);
    ~RV_DynamicFramebuffer() override;
    
    RV_DynamicFramebuffer(const RV_DynamicFramebuffer&) = delete;

    bool fillPipelineInfo(RV_RenderPassFormatInfo& info) override;

    // Act on framebuffer
    bool beginRendering(
            RV_Instance *inst,
            RV_VKCommandBuffer *cb,
            RV_ImageOp img_op = RV_IMAGE_LOAD,
            RV_RenderPassType type = RV_PASS_WHOLE) override;

    void endRendering(
            RV_Instance *inst,
            RV_VKCommandBuffer *cb) override;
};

class RV_API RV_RenderPassFramebuffer : public RV_Framebuffer
{
public:
    RV_RenderPassFramebuffer(int w, int h, int samples = 1);
    ~RV_RenderPassFramebuffer() override;
    
    bool fillPipelineInfo(RV_RenderPassFormatInfo& info) override;

    bool beginRendering(
            RV_Instance *inst,
            RV_VKCommandBuffer *cb,
            RV_ImageOp img_op = RV_IMAGE_LOAD,
            RV_RenderPassType type = RV_PASS_WHOLE) override;

    void endRendering(
            RV_Instance *inst,
            RV_VKCommandBuffer *cb) override;
private:
    void attachmentsChanged() override;

    bool                            myIsDirty = false;
    
    RV_ImageOp                      myLastLoadOp = RV_IMAGE_LOAD;
    RV_RenderPassFormatInfo       myLastFormat;

    UT_UniquePtr<RV_VKRenderPass>   myRenderPass;
    UT_UniquePtr<RV_VKFramebuffer> myFramebuffer;
};

class RV_VKFramebuffer : public UT_NonCopyable
{
public:
    VkFramebuffer getVkFramebuffer() const { return myVkFramebuffer; }

    RV_VKFramebuffer(RV_Instance* inst, VkFramebuffer vk_handle)
        : myInst(inst), myVkFramebuffer(vk_handle)
        {}

    RV_VKFramebuffer(RV_VKFramebuffer&& other)
            : myInst(other.myInst), myVkFramebuffer(other.myVkFramebuffer)
            {   
                other.myInst = nullptr;
                other.myVkFramebuffer = 0;
            }

    // Disable move operator (since it would leave `rhs`) in null state
    RV_VKFramebuffer& operator=(RV_VKFramebuffer&& rhs) noexcept = delete;

    void destroy()
            {
                UT_ASSERT(myInst || !myVkFramebuffer);
                if (myInst && myInst->getDevice())
                {
                    ::vkDestroyFramebuffer(
                            myInst->getDevice(), myVkFramebuffer, nullptr);
                }
            }

    virtual ~RV_VKFramebuffer() { destroy(); }
private:
    RV_Instance* myInst = nullptr;
    VkFramebuffer myVkFramebuffer = 0;
};

class RV_VKRenderPass : public UT_NonCopyable
{
public:
    VkRenderPass getVkRenderPass() const { return myVkRenderPass; }

    RV_VKRenderPass(RV_Instance* inst, VkRenderPass vk_handle)
        : myInst(inst), myVkRenderPass(vk_handle)
        {}

    RV_VKRenderPass(RV_VKRenderPass&& other)
            : myInst(other.myInst), myVkRenderPass(other.myVkRenderPass)
            {   
                other.myInst = nullptr;
                other.myVkRenderPass = 0;
            }

    // Disable move operator (since it would leave `rhs`) in null state
    RV_VKRenderPass& operator=(RV_VKRenderPass&& rhs) noexcept = delete;

    void destroy()
            {
                UT_ASSERT(myInst || !myVkRenderPass);
                if (myInst && myInst->getDevice())
                {
                    ::vkDestroyRenderPass(
                            myInst->getDevice(), myVkRenderPass, nullptr);
                }
            }

    virtual ~RV_VKRenderPass() { destroy(); }
private:
    RV_Instance* myInst = nullptr;
    VkRenderPass myVkRenderPass = 0;
};

#else
struct rv_AttachmentInfo
{
    RV_VKImage* img = nullptr;

    VkFormat format = VK_FORMAT_UNDEFINED;

    uint32_t mip_level;
    uint32_t array_layer;
    uint32_t output_num;

    bool is_init() const { return (img != nullptr || format != VK_FORMAT_UNDEFINED); }
};

class RV_API RV_VKFramebufferInfo
{
public:
    RV_VKFramebufferInfo(int width = 0, int height = 0, int samples = 1)
    : myHeight(height), myWidth(width), mySamples(samples)
    {
        UT_ASSERT(width >= 0 && height >=0 && samples >= 1);
    }

    // setup format used for image creation
    void setSize(int w, int h) { myWidth = w; myHeight = h;}
    int getWidth() { return myWidth; }
    int getHeight() { return myHeight; }

    void setSampleCount(int samples) { mySamples = samples; }
    int  getSampleCount();

    // Attaches Image to framebuffer
    void attachImage(
            RV_VKImage* img,
            RV_AttachmentType buffer_type,
            int buffer_target = 0,
            int level = 0,
            int layer = 0 );
            
    void detachImage(int buffer_target);

    // Create image matching FB output, and automatically attach it.
    // Created image must be owned by caller, will not be destroyed by FB
    // NOTE: RE_ equivalent includes flags for enabling mip-mapping 
    //       and rectangular mapping on image .. left out since they're unused
    RV_VKImage* createImage(RV_Instance* inst,
                     RV_GPUType type, int vec_size,
                     RV_AttachmentType attach_type = RV_COLOR_BUFFER,
                     int buffer_target = 0);
    
private:
    uint32_t myWidth = 0;
    uint32_t myHeight = 0;
    uint32_t mySamples = 1;

    UT_Array<rv_AttachmentInfo> myColorAttachments;
    rv_AttachmentInfo myDepthAttachment;

    friend RV_Framebuffer;
};

// Framebuffer to be used with dynamic rendering
// Keeps a list of attachments, and can start
// a dynamic render pass using them
class RV_API RV_Framebuffer
{
public:
    static
    RV_Framebuffer* createFramebuffer(
            uint32_t width, uint32_t height,
            int32_t offset_x, int32_t offset_y,
            UT_Array<rv_VKAttachmentPtr> &color_attachments,
            rv_VKAttachmentPtr depth_stencil_attachment);
    static
    RV_Framebuffer* createFramebuffer(
            RV_Instance* inst, const RV_VKFramebufferInfo &info);

    ~RV_Framebuffer();

    RV_Framebuffer(const RV_Framebuffer&) = delete;

    // - transitions images into needed layout (if not already in them)
    // - begins the renderbuffer
    bool beginRendering(
            RV_Instance* inst,
            RV_VKCommandBuffer* cb,
            RV_ImageOp img_op,
            RV_RenderPassType type = RV_PASS_WHOLE) const;

private:

    RV_Framebuffer(
            uint32_t width, uint32_t height,
            int32_t offset_x, int32_t offset_y,
            UT_Array<rv_VKAttachmentPtr>& color_attachments,
            rv_VKAttachmentPtr depth_stencil_attachment);

    VkRect2D myRenderRegion;
    UT_Array<rv_VKAttachmentPtr>    myColorAttachments;
    rv_VKAttachmentPtr              myDepthAttachment;
};

#endif
#endif