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_SmallArray.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_UniquePtr.h>

#include <VE/VE_VK.h>
#include "RV_Instance.h"
#include "RV_Type.h"
#include "RV_TypePtrs.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;
    bool                        myIsDepthReadOnly = false;

    // NOTE: using same sample count for all attachments
    int32                       mySamples = 1;
    uint32                      myMultiviewMask = 0;
    UT_FixedArray<VkFormat, 8>  myColorFormats = {};
    int32                       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
            && myMultiviewMask == other.myMultiviewMask
            && myColorFormats == other.myColorFormats
            && myColorFormatCount == other.myColorFormatCount
            && myDepthStencilFormat == other.myDepthStencilFormat;
    }

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

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,
            const UT_StringRef &name = UT_StringRef());

    RV_Framebuffer(
            int w,
            int h,
            int samples = 1,
            const UT_StringRef& name = UT_StringRef());
    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;

    exint      getMemoryUsage() const;

    UT_DimRect getRenderRegion() const;

    int        getMaxLayers() 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);
    int         getNumColorImages() const;
    RV_VKImage* getColorImage(int i=0);
    RV_VKImage* getDepthImage();

    void        setMultiview(bool enable) { myIsMultiview = enable; }
    bool        getMultiview() const { return myIsMultiview;}

    void        setReadOnlyDepth(bool enable) { myIsReadOnlyDepth = enable; }
    bool        getReadOnlyDepth() const { return myIsReadOnlyDepth; }

    void        drawToBuffer(int color_buf_num);
    void        drawToBuffers(int num, const int *bufferlist);
    void        drawToNoBuffers();
    void        drawToAllBuffers();

    static const int ALL_LAYERS = -1;

    // 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_VKImagePtr 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);

    const UT_StringHolder &name() const { return myName; }

    void        writeToFiles(RV_Render *r,
                             const UT_StringHolder &base_name,
                             const UT_StringHolder &ext,
                             bool depth_too = false);

protected:

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

    void getColorDrawTargets(UT_Array<rv_VKAttachment*> &out_list);

    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;
    bool myIsMultiview = false;
    bool myIsReadOnlyDepth = false;

    UT_Array<rv_VKAttachmentPtr>    myColorAttachments;
    rv_VKAttachmentPtr              myDepthAttachment;
    UT_SmallArray<int8>             myDrawTargets;
    bool                            myHasDrawTargets = true;
    UT_StringHolder                 myName;
};

class RV_API RV_DynamicFramebuffer : public RV_Framebuffer
{
public:
    RV_DynamicFramebuffer(
            int w,
            int h,
            int samples = 1,
            const UT_StringRef& name = UT_StringRef());
    ~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,
            const UT_StringRef& name = UT_StringRef());
    ~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;
    bool                            myLastMultiview = false;

    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; }

    static UT_UniquePtr<RV_VKRenderPass> create(
            RV_Instance* inst,
            const RV_RenderPassFormatInfo& pass_info,
            RV_ImageOp load_op);

    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;
};

#endif