GLCPUToTexCopier.hpp

#ifndef VVGL_GLCPUToTexCopier_hpp
#define VVGL_GLCPUToTexCopier_hpp

#include "VVGL_Defines.hpp"
#include "GLBufferPool.hpp"

#include <mutex>
#include <queue>




//  none of this stuff should be available if we're running ES
#if !defined(VVGL_TARGETENV_GLES) && !defined(VVGL_TARGETENV_GLES3)




namespace VVGL
{




using namespace std;





class VVGL_EXPORT GLCPUToTexCopier  {
    private:
        recursive_mutex         _queueLock; //  this should be used to serialize access to all member vars
        GLContextRef            _queueCtx = nullptr;    //  this is the context used to perform all GL action
        int                     _queueSize = 2; //  the number of buffers that should be in 'queue' before popping a new buffer off of it (double-buffering is 1)
        queue<GLBufferRef>      _cpuQueue;  //  queue of CPU-based images
        queue<GLBufferRef>      _pboQueue;  //  queue of PBOs
        queue<GLBufferRef>      _texQueue;  //  queue of textures
        bool                    _swapBytes = false;
        GLBufferPoolRef         _privatePool = nullptr; //  by default this is null and the scene will try to use the global buffer pool to create interim resources (temp/persistent buffers).  if non-null, the scene will use this pool to create interim resources.
    
    private:
        //  before calling either of these functions, _queueLock should be locked and a GL context needs to be made current on this thread.
        void _beginProcessing(const GLBufferRef & inCPUBuffer, const GLBufferRef & inPBOBuffer, const GLBufferRef & inTexBuffer);
        void _finishProcessing(const GLBufferRef & inCPUBuffer, const GLBufferRef & inPBOBuffer, const GLBufferRef & inTexBuffer);
    
    public:
        GLCPUToTexCopier();
        GLCPUToTexCopier(const GLContextRef & inCtx) : _queueCtx(inCtx) {};
        ~GLCPUToTexCopier();
        
        GLContextRef context() { return _queueCtx; }
        
        void clearStream();
        
        void setQueueSize(const int & inNewQueueSize);
        inline int queueSize() { lock_guard<recursive_mutex> lock(_queueLock); return _queueSize; };
        
        void setSwapBytes(const bool & n) { lock_guard<recursive_mutex> lock(_queueLock); _swapBytes=n; }
        bool swapBytes() { lock_guard<recursive_mutex> lock(_queueLock); return _swapBytes; }
        
        GLBufferRef uploadCPUToTex(const GLBufferRef & inCPUBuffer, const bool & createInCurrentContext=false);
        GLBufferRef uploadCPUToTex(const GLBufferRef & inCPUBuffer, const GLBufferRef & inTexBuffer, const bool & createInCurrentContext=false);
        

        GLBufferRef streamCPUToTex(const GLBufferRef & inCPUBuffer, const bool & createInCurrentContext=false);

        GLBufferRef streamCPUToTex(const GLBufferRef & inCPUBuffer, const GLBufferRef & inTexBuffer, const bool & createInCurrentContext=false);
        
        void setPrivatePool(const GLBufferPoolRef & n) { _privatePool=n; }
        GLBufferPoolRef privatePool() { return _privatePool; }
};




inline GLCPUToTexCopierRef CreateGLCPUToTexCopierRef() { return make_shared<GLCPUToTexCopier>(); }
inline GLCPUToTexCopierRef CreateGLCPUToTexCopierRefUsing(const GLContextRef & inCtx) { return make_shared<GLCPUToTexCopier>(inCtx); }




}




#endif  //  !defined(VVGL_TARGETENV_GLES) && !defined(VVGL_TARGETENV_GLES3)




#endif /* VVGL_GLCPUToTexCopier_hpp */