GLBuffer.hpp

#ifndef VVGL_GLBuffer_hpp
#define VVGL_GLBuffer_hpp

#include "VVGL_Defines.hpp"

#include <vector>
#include <chrono>
#include "GLContext.hpp"




namespace VVGL  {


using namespace std;





class VVGL_EXPORT GLBuffer  {
    
    public:
        using BackingReleaseCallback = function<void(GLBuffer&, void*)>;
        
        
        enum Type   {
            Type_CPU,
            Type_RB,
            Type_FBO,
            Type_Tex,
            Type_PBO,
            Type_VBO,
            Type_EBO,
            Type_VAO,
        };
        
        
        //  enums describing the various GL object (usually texture) properties- split up b/c availability depends on platform
#if defined(VVGL_SDK_MAC)
        #include "GLBuffer_Enums_Mac.h"
#elif defined(VVGL_SDK_RPI)
        #include "GLBuffer_Enums_RPI.h"
#elif defined(VVGL_SDK_IOS)
        #include "GLBuffer_Enums_IOS.h"
#elif defined(VVGL_SDK_GLFW)
        #include "GLBuffer_Enums_GLFW.h"
#elif defined(VVGL_SDK_QT)
        #include "GLBuffer_Enums_Qt.h"
#endif
        
        
        enum Backing    {
            Backing_None,   
            Backing_Internal,   
            Backing_External    
        };
        
        

        enum BackingID  {
            BackingID_None,
            BackingID_GWorld,
            BackingID_Pixels,
            BackingID_CVPixBuf,
            BackingID_CVTex,
            BackingID_NSBitImgRep,
            BackingID_RemoteIOSrf,
            BackingID_GenericExternalCPU,
            BackingID_QImage,
            BackingID_QVideoFrame,
        };
        
        

        struct VVGL_EXPORT Descriptor   {
            Type                    type = Type_Tex;
            Target      target = Target_2D;
#if defined(VVGL_SDK_MAC)
            InternalFormat          internalFormat = IF_RGBA8;
#else
            InternalFormat          internalFormat = IF_RGBA;
#endif
            PixelFormat             pixelFormat = PF_RGBA;
            PixelType               pixelType = PT_UByte;
            Backing                 cpuBackingType = Backing_None;
            Backing                 gpuBackingType = Backing_None;
            bool                    texRangeFlag = false;
            bool                    texClientStorageFlag = false;
            uint32_t                msAmount = 0;
            uint32_t                localSurfaceID = 0;
            
            uint32_t bytesPerRowForWidth(const uint32_t & w) const;
            uint32_t backingLengthForSize(const Size & s) const;
        };
    
    
    public:
        Descriptor              desc;
        
        uint32_t                name = 0;
        bool                    preferDeletion = false;
        Size                    size = { 0, 0 };
        Rect                    srcRect = { 0, 0, 0, 0 };
        bool                    flipped = false;
        Size                    backingSize = { 0, 0 };
        Timestamp               contentTimestamp = { static_cast<uint64_t>(0), static_cast<uint32_t>(0) };
        bool                    pboMapped = false;
        
        
        BackingReleaseCallback  backingReleaseCallback = nullptr;
        void                    *backingContext = nullptr;
        BackingID               backingID = BackingID_None;
        void                    *cpuBackingPtr = nullptr;
    
    private:
#if defined(VVGL_SDK_MAC)
        //id                        userInfo = nullptr; //  RETAINED, nil by default.  not used by this class- stick whatever you want here and it will be retained for the lifetime of this buffer.  retained if you copy the buffer!
        IOSurfaceRef            _localSurfaceRef = nullptr;
        IOSurfaceRef            _remoteSurfaceRef = nullptr;
#endif
    
    public:
        //  Every GLBuffer maintains a strong ref to the GLBufferPoolRef that created it, when the buffer is deallocated its underlying GL resources are returned to the pool where they are either released or recycled.
        GLBufferPoolRef     parentBufferPool = nullptr;
        //  If this GLBuffer was created by copying another buffer using GLBufferCopy(), the original source buffer is retained here.  If you copy a copy, the original GLBuffer is retained here.
        GLBufferRef         copySourceBuffer = nullptr;
        int                 idleCount = 0;
    
    
    //  public methods
    public:
        GLBuffer(GLBuffer &&) = default;
        GLBuffer() = default;
        GLBuffer(GLBufferPoolRef inParentPool);
        GLBuffer(const GLBuffer &);
        virtual ~GLBuffer();
        friend ostream & operator<<(ostream & os, const GLBuffer & n) { os << n.getDescriptionString(); return os; }
        
        //  copy assignment operators are disabled to prevent accidents
        GLBuffer& operator=(const GLBuffer&) = delete;
        //GLBuffer& operator=(GLBuffer&) = delete;
        //GLBuffer (GLBuffer&&) = default;
        
        uint32_t calculateBackingBytesPerRow() { return desc.bytesPerRowForWidth(static_cast<uint32_t>(round(backingSize.width))); }
        uint32_t calculateBackingLength() { return desc.backingLengthForSize(backingSize); }
        
        //  use this to create a shallow copy (memberwise copy)
        GLBuffer * allocShallowCopy();
        
#if defined(VVGL_SDK_MAC)
        //  getter/setters
        //id getUserInfo() const;
        //void setUserInfo(id n);
        IOSurfaceRef localSurfaceRef() const;
        void setLocalSurfaceRef(const IOSurfaceRef & n);
        IOSurfaceRef remoteSurfaceRef() const;
        void setRemoteSurfaceRef(const IOSurfaceRef & n);
#endif
        
        //  member methods
        bool isComparableForRecycling(const GLBuffer::Descriptor & n) const;
        uint32_t backingLengthForSize(Size s) const;
        Rect glReadySrcRect() const;
        /*
        Rect croppedSrcRect(Rect & cropRect, bool & takeFlipIntoAccount) const;
        */
        bool isFullFrame() const;
        bool isNPOT2DTex() const;
        bool isPOT2DTex() const;
#if defined(VVGL_SDK_MAC)
        bool safeToPublishToSyphon() const;
#endif
        
#if !defined(VVGL_TARGETENV_GLES) && !defined(VVGL_TARGETENV_GLES3)

        void mapPBO(const uint32_t & inAccess, const bool & inUseCurrentContext=false);
        void unmapPBO(const bool & inUseCurrentContext=false);
#endif  //  !defined(VVGL_TARGETENV_GLES) && !defined(VVGL_TARGETENV_GLES3)
        bool isContentMatch(GLBuffer & n) const;
        //void draw(const Rect & dst) const;
        string getDescriptionString() const;
};





VVGL_EXPORT GLBufferRef GLBufferCopy(const GLBufferRef & n);




}




#endif /* VVGL_GLBuffer_hpp */