RV_OGLInteropTextureBase.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_OGLInteropTextureBase.h ( RV Library, C++)
 *
 * COMMENTS:
 *      Texture usable in Vulkan and OpenGL
 */


#ifndef RV_OGLInteropTextureBase_h
#define RV_OGLInteropTextureBase_h

#include "RV_API.h"

#include <VE/VE_VK.h>
#include "RV_VKImage.h"
#include "RV_TypePtrs.h"

#include <atomic>
#include <glcorearb.h>

#include <RE/RE_Texture.h>
#include <UT/UT_UniquePtr.h>


#ifdef WIN32
    #include <windows.h>
    typedef HANDLE handle;
#else
// export handles
// NOTE: vulkan + GL function signatures use `int`,
//      in `xx_external_fd` functions, rather than 
//      sized type .. using `int` to match
    typedef int handle;
#endif

class RE_RenderContext;

class RV_VKCommandBuffer;
class RV_VKQueue;
class RV_OGLInteropTextureBase;
class RV_Instance;

typedef UT_UniquePtr<RV_OGLInteropTextureBase> RV_OGLInteropTexturePtr;
class VE_Memory;

// RV_VKInteropImageCreateInfo
// Create info for a VkImage which can be exported.
class RV_API RV_VKInteropImageCreateInfo : public RV_VKImageCreateInfo
{
public:
    bool fillCreateInfo() override;

    RV_MemType getAllocType(RV_Instance *inst) override
    {
        return RV_MEM_OPENGL_EXPORTABLE;
    }

    RV_VKInteropImageCreateInfo() = default;
    RV_VKImageCreateInfo *clone() const override
    {
        return new RV_VKInteropImageCreateInfo(*this);
    }
    ~RV_VKInteropImageCreateInfo() override {}

protected:
    RV_VKInteropImageCreateInfo(const RV_VKInteropImageCreateInfo &) = default;

public:

    static const VkExternalMemoryImageCreateInfo myExImgInfo;
};

// RV_OGLInteropTextureBase
/// Set of resources needed to share a texture between
/// OpenGL and Vulkan. Can create a vulkan image,
/// or recieve an alloacted memory. Creates semaphores
/// for sync, and exports the handles for the memory and
/// semaphores then imports them into an openGL context.
class RV_API RV_OGLInteropTextureBase 
{
public:
    struct SemaphoreSet
    {
        VkSemaphore vkHandle;
        handle  shareHandle;
        GLuint  oglHandle;
    };

    enum RV_OGLInteropOwner
    {
        RV_VULKAN,
        RV_OPENGL,
    } myCurOwner;

    RV_OGLInteropTextureBase();
    virtual ~RV_OGLInteropTextureBase();

    // Returns a new texture with no attributes of the given type.
    static RV_OGLInteropTexturePtr create(RE_TextureDimension dim);

    // Default usage state is GL. Change to Vulkan if rendering or uploading via
    // VK to the texture first.
    void        setCurrentState(RV_OGLInteropOwner owner)
                    {  myCurOwner = owner; }
    
    RV_VKImage* getRvImage() 
            {
                UT_ASSERT(myCurOwner == RV_VULKAN);
                return myRvImg.get();
            }

    virtual RE_Texture* getRe() = 0;

    RV_OGLInteropOwner getCurrentRenderType() const { return myCurOwner; }

    RE_TextureID getGLID();

    inline SemaphoreSet getGLToVkSemaphore()
    {
        return SemaphoreSet{
            myVkSemGLToVk,      /* vkHandle*/ 
            myShareSemGLToVk,   /* shareHandle */
            myOglSemGLToVk,     /* oglHandle */
        };
    }

    inline SemaphoreSet getVkToGLSemaphore()
    {
        return SemaphoreSet{
            myVkSemVkToGL,      /* vkHandle*/ 
            myShareSemVkToGL,   /* shareHandle */
            myOglSemVkToGL,     /* oglHandle */
        };
    }

    bool            beginTransferToVk(RE_Render *r);
    bool            finishTransferToVk(RV_Instance *r,
                                      RV_VKCommandBuffer* cb);

    bool            beginTransferToGL(RV_Instance *r, 
                                      RV_VKCommandBuffer* cb);
    bool            finishTransferToGL(RE_Render *r);


    bool submitTransferToGL(RE_RenderContext r);

    bool submitTransferToVk(RE_RenderContext r);

    bool allocateImage(RV_Instance* inst, 
                       RV_ImageDim image_type, VkFormat format,
                            size_t width, size_t height, size_t depth=1,
                            int levels =1, int layers =1, int samples=1);

    bool checkImageParams(RV_Instance* inst, 
                          RV_ImageDim image_type, VkFormat format,
                            size_t width, size_t height, size_t depth=1,
                            int levels =1, int layers =1, int samples=1);



protected:
    // Checks whether the image will created with this create
    // info will be exportable
    static bool queryMemoryHandleValid(
            RV_Instance *inst,
            RV_VKInteropImageCreateInfo *info);

    // Assigns memory backing image -- called from allocateImage 
    //  if image was allocated internally
    //  Doesn't take ownership if given external memory
    //  external memory should be destroyed AFTER this object
    bool assignMemory(RV_Instance *inst, VE_Memory* mem);

    void deleteImage(RV_Instance* inst);

    // Vulkan Image -- may be NULL, 
    //      if initialized with externally allocated memory
    UT_UniquePtr<RV_VKImage> myRvImg;
    VE_Memory* myRvMem;

    VkDeviceMemory  myVkMem = VK_NULL_HANDLE;
    VkDeviceSize    myMemSize = 0;
    VkDeviceSize    myMemOffset = 0;
    VkImage         myVkImg = VK_NULL_HANDLE;
    
    VkImageLayout        myLastLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    VkAccessFlags        myLastAccess = 0;
    VkPipelineStageFlags myLastStage = 0;

    // transfer must be committed by submitting the command buffer
    //  before work on the GL side can be done
    //  -- tacked atomically since they may be accessed form
    //     Vulkan or GL flag
    std::atomic_bool myIsTransferToGLWaiting = false;
    
#if 0 // TODO: allow multiple GL->VK sems to be signaled with a single signal+flush op
    // Note: not locking access to this member,
    //       it will always be accessed from the
    //       GL thread
    std::atomic_bool myIsTransferToVkWaiting = false;
    static void     commitAllTransfersToVk(RE_Render* r);
    static std::list<std::atomic_bool*> theWaitingVkTransfers;
#endif

    // semaphores from Vulkan perspective
    VkSemaphore myVkSemVkToGL = VK_NULL_HANDLE;
    VkSemaphore myVkSemGLToVk = VK_NULL_HANDLE;

    bool allocateSemaphores(RV_Instance* inst);
    void deleteSemaphores(RV_Instance* inst);

    int     myRERenderID = -1;

    // semaphores from OS perspective
    handle  myShareSemVkToGL = 0;
    handle  myShareSemGLToVk = 0;
    
    // semaphores from OpenGL perspective
    GLuint  myOglSemVkToGL = 0;
    GLuint  myOglSemGLToVk = 0;

    handle  myShareMem = 0;

    // Memory from GL perspective
    GLuint  myOglMem = 0;
    GLuint  myOglID = 0;

    bool importMemory(RE_Render *r);
    bool importOglSemaphores(RE_Render *r);
    void deleteMemory(RE_Render *r);
    void deleteOglSemaphores(RE_Render *r);

    void deleteMemoryHandle();
    void deleteSemaphoreHandles();
};

/// Transfer a list of interop textures from VK to GL usage
RV_API void RVtransferToGL(
                    RE_RenderContext rc,
                    UT_Array<RV_OGLInteropTextureBase*> tex_list);

/// Transfer a list of interop textures from GL to VK usage
RV_API void RVtransferToVK(
                    RE_RenderContext rc,
                    UT_Array<RV_OGLInteropTextureBase*> tex_list);

#endif