GLTexToCPUCopier.hpp

#ifndef VVGL_GLTexToCPUCopier_hpp
#define VVGL_GLTexToCPUCopier_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 GLTexToCPUCopier  {
    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 = 1; //  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
        queue<GLBufferRef>      _fboQueue;  //  queue of FBOs.  the fastest texture download pipeline involves attaching the texture to an FBO so we can use glReadPixels() instead of glGetTexImage().
        
        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, const GLBufferRef & inFBOBuffer);
        void _finishProcessing(const GLBufferRef & inCPUBuffer, const GLBufferRef & inPBOBuffer, const GLBufferRef & inTexBuffer, const GLBufferRef & inFBOBuffer);
    
    public:
        GLTexToCPUCopier();
        GLTexToCPUCopier(const GLContextRef & inCtx) : _queueCtx(inCtx) {};
        ~GLTexToCPUCopier();
        
        void clearStream();
        
        void setQueueSize(const int & inNewQueueSize);
        inline int queueSize() { lock_guard<recursive_mutex> lock(_queueLock); return _queueSize; };
        

        GLBufferRef downloadTexToCPU(const GLBufferRef & inTexBuffer, const GLBufferRef & inCPUBuffer=nullptr, const bool & createInCurrentContext=false);
        

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




inline GLTexToCPUCopierRef CreateGLTexToCPUCopierRef() { return make_shared<GLTexToCPUCopier>(); }
inline GLTexToCPUCopierRef CreateGLTexToCPUCopierRefUsing(const GLContextRef & inCtx) { return make_shared<GLTexToCPUCopier>(inCtx); }




}




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




#endif /* VVGL_GLTexToCPUCopier_hpp */