RV_VKMemory.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_VKMemory.h ( RV Library, C++)
 *
 * COMMENTS:
 *      Class Representing a Vulkan memory allocation,
 *      And the creation info used to allocate it.
 *      Memory blocks are needed by VkImages and VkBuffers
 */

#ifndef RV_VKMemory_h
#define RV_VKMemory_h

#include "RV_API.h"

#include <SYS/SYS_Types.h>
#include <SYS/SYS_Handle.h>

#include <UT/UT_Debug.h>
#include <UT/UT_Array.h>
#include <UT/UT_Assert.h>
#include <UT/UT_UniquePtr.h>

#include <VE/VE_VK.h>

#include <VE/VE_Memory.h>

#include "RV_Instance.h"
#include "RV_Render.h"
#include "RV_Type.h"
#include "RV_TypePtrs.h"
#include "RV_VKExt.h"

class RV_Instance;
class RV_VKMemory;
class RV_VKMemory;

typedef RV_VKMemory RV_VKMemory;

class RV_API RV_VKMemory : public VE_Memory
{
public:
    bool isCoherent() const
                      { 
                        uint32_t mem_type = allocInfo().memoryType;
                        const auto props = myInst->getMemoryProps();
                        auto flags = props->memoryTypes[mem_type].propertyFlags;
                        
                        return (flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
                      }
    SYS_Handle exportMemory(RV_Render* r)
                      { return exportMemory(r->instance()); }
    SYS_Handle exportMemory(RV_Instance* inst)
                      {
                        UT_ASSERT(getType() == VE_MEM_OPENGL_EXPORTABLE);
                        VE_Result<SYS_Handle> res = getExternalHandle(
                            inst->getDevice(),
                            inst->getExt()
                        );
                        if (res.ok())
                            return res.unpack();
                        return SYS_Handle();
                      }

private:
    struct PassKey {};
public:
    RV_VKMemory(RV_Instance *inst, VE_Memory &&mem, const PassKey &)
        : VE_Memory(std::move(mem))
        , myInst(inst)
    {}

private:
    RV_Instance *myInst;

    friend class RV_VKMemAllocator;
};

class RV_API RV_VKMemAllocator
{
public:
    RV_VKMemoryPtr allocateImage(
            RV_MemType type,
            const VkImageCreateInfo& img_info,
            VkImage& vk_img);
    RV_VKMemoryPtr allocateBuffer(
            RV_MemType type,
            const VkBufferCreateInfo& buf_info,
            VkBuffer& vk_buf,
            exint alignment = 0);
    RV_VKMemoryPtr allocateMemory(
            RV_MemType type,
            const VkMemoryRequirements& info);

    RV_VKMemAllocator(RV_Instance* inst);

    static VkExternalMemoryHandleTypeFlags getExternMemHandleType()
            { return VE_MemoryAllocator::getExternMemHandleType(); }

    const VE_MemoryAllocator& getBaseAllocator() const
            { return myAllocator; }

private:
    using PassKey = RV_VKMemory::PassKey;

    // Primary handles
    RV_Instance* myInst = nullptr;
    VE_MemoryAllocator myAllocator;
};


#endif