GLScene.hpp

#ifndef VVGL_GLScene_hpp
#define VVGL_GLScene_hpp

#include "VVGL_Defines.hpp"

#include <functional>
#include <mutex>
#include <map>
#include "GLBufferPool.hpp"
#include "GLCachedProperty.hpp"

#if defined(VVGL_SDK_MAC)
#import <TargetConditionals.h>
#endif




namespace VVGL  {


using namespace std;





class VVGL_EXPORT GLScene   {
    //  objects/structs/data types
    public:
        using RenderCallback = std::function<void(const GLScene & inScene)>;
        using RenderPrepCallback = std::function<void(const GLScene & inScene, const bool & inSceneReshaped, const bool & inPgmChanged)>;
        
        struct RenderTarget {
                GLBufferRef fbo = nullptr;
                GLBufferRef color = nullptr;
                GLBufferRef depth = nullptr;
            public:
                RenderTarget(){};
                RenderTarget(const GLBufferRef &f, const GLBufferRef &c, const GLBufferRef &d) { fbo=f;color=c;depth=d; };
                
                inline uint32_t fboName() const { return (fbo==nullptr) ? 0 : fbo->name; };
                inline uint32_t colorName() const { return (color==nullptr) ? 0 : color->name; };
                inline uint32_t colorTarget() const { return (color==nullptr) ? GL_TEXTURE_2D : color->desc.target; };
                inline uint32_t depthName() const { return (depth==nullptr) ? 0 : depth->name; };
                inline uint32_t depthTarget() const { return (depth==nullptr) ? GL_TEXTURE_2D : depth->desc.target; };
        };
    
    
    //  instance variables
    protected:
        recursive_mutex     _renderLock;
        GLContextRef        _context = nullptr;
        
        bool                _deleted = false;
        bool                _initialized = false;
        bool                _needsReshape = true;
        bool                _alwaysNeedsReshape = false;
        
        //  every time the scene is doing its render prep, this lambda is executed.  drawing setup code goes here.
        RenderPrepCallback      _renderPrepCallback = nullptr;
        //  this callback gets hit immediately before the program is linked (after the shaders have been compiled & attached to the program, but before the program was linked).
        RenderCallback      _renderPreLinkCallback = nullptr;
        //  every time the scene renders, this lambda is executed.  drawing code goes here.
        RenderCallback      _renderCallback = nullptr;
        RenderCallback      _renderCleanupCallback = nullptr;
        //  the render target contains the GL framebuffer and relevant attachments (render to texture/buffer/depth buffer/etc)
        RenderTarget        _renderTarget;
        
        //  these vars pertain to optional default orthogonal sizing, which i use a lot for compositing/drawing 2D UIs with GL- if 'orthoUniId' is >= 0 then the vertex shader will create an orthogonal projection matrix of size 'orthoSize' and incorporating 'orthoFlipped'
        Size                _orthoSize = { 0., 0. };
        bool                _orthoFlipped = false;
        GLCachedUni         _orthoUni = GLCachedUni("vvglOrthoProj");
        
        //  these vars pertain to whether or not the scene clears the attached framebuffer before drawing (and what color is used to clear)
        bool                _performClear = true;
        GLColor             _clearColor = GLColor(0., 0., 0., 0.);
        bool                _clearColorUpdated = false;
        
        //  these vars pertain to the program being used by the GL context
        string              *_vsString = nullptr;
        string              *_gsString = nullptr;
        string              *_fsString = nullptr;
        bool                _vsStringUpdated = false;
        bool                _gsStringUpdated = false;
        bool                _fsStringUpdated = false;
        uint32_t            _program = 0;   //  0, or the compiled program
        uint32_t            _vs = 0;
        uint32_t            _gs = 0;
        uint32_t            _fs = 0;
        mutex               _errLock;
        mutex               _errDictLock;
        map<string,string>      _errDict;
        
        //  this class- and subclasses of it- often need to create GPU resources.  by default the global buffer pool (GetGlobalBufferPool()) will be used- unless this var is non-null...
        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.
        GLTexToTexCopierRef _privateCopier = nullptr;   //  by default this is null and the scene will try to use the global buffer copier to create interim resources.  if non-null, the scene will use this copier to create interim resources.
    
    
    //  functions
    public:
        GLScene();
        GLScene(const GLContextRef & inCtx);
        
        virtual ~GLScene();
        
        virtual void prepareToBeDeleted();
        
        
        virtual GLBufferRef createAndRenderABuffer(const Size & inSize=Size(640.,480.), const GLBufferPoolRef & inPool=nullptr);
        virtual void renderToBuffer(const GLBufferRef & inBuffer);
        virtual void render(const RenderTarget & inRenderTarget=RenderTarget());
        virtual void renderBlackFrame(const RenderTarget & inRenderTarget=RenderTarget());
        virtual void renderOpaqueBlackFrame(const RenderTarget & inRenderTarget=RenderTarget());
        virtual void renderRedFrame(const RenderTarget & inRenderTarget=RenderTarget());
        
        
        
        inline GLContextRef context() const { return _context; }
        
        
        
        void setRenderPreLinkCallback(const RenderCallback & n);
        void setRenderPrepCallback(const RenderPrepCallback & n);
        void setRenderCallback(const RenderCallback & n);
        void setRenderCleanupCallback(const RenderCallback & n);
        
        
        
        
        void setAlwaysNeedsReshape(const bool & n);
        virtual void setOrthoSize(const Size & n);
        Size orthoSize() const;
        void setOrthoFlipped(const bool & n);
        bool orthoFlipped() const;
        
        
        
        void setClearColor(const GLColor & n);
        void setClearColor(const float & r, const float & g, const float & b, const float & a);
        void setClearColor(float * n);
        void setPerformClear(const bool & n);
        
        
        
        //  getters/setters for program stuff
        
        virtual void setVertexShaderString(const string & n);
        virtual string vertexShaderString();
        virtual void setGeometryShaderString(const string & n);
        virtual string geometryShaderString();
        virtual void setFragmentShaderString(const string & n);
        virtual string fragmentShaderString();
        inline uint32_t program() const { return _program; }
        
        
        
        inline GLVersion glVersion() const { if (_context==nullptr) return GLVersion_Unknown; return _context->version; }
        
        void setPrivatePool(const GLBufferPoolRef & n) { _privatePool=n; }
        GLBufferPoolRef privatePool() const { return _privatePool; }
        void setPrivateCopier(const GLTexToTexCopierRef & n) { _privateCopier=n; }
        GLTexToTexCopierRef privateCopier() const { return _privateCopier; }
        
    protected:
        //  assumed that _renderLock was obtained before calling.  assumed that context is non-null and has been set as current GL context before calling.
        virtual void _renderPrep();
        //  assumed that _renderLock was obtained before calling.  assumed that context is non-null and has been set as current GL context before calling.
        virtual void _initialize();
        //  assumed that _renderLock was obtained before calling.  assumed that context is non-null and has been set as current GL context before calling.
        virtual void _reshape();
        //  assumed that _renderLock was obtained before calling.  assumed that context is non-null and has been set as current GL context before calling.
        virtual void _renderCleanup();
};




inline GLSceneRef CreateGLSceneRef() { return make_shared<GLScene>(); }
inline GLSceneRef CreateGLSceneRefUsing(const GLContextRef & inCtx) { return make_shared<GLScene>(inCtx); }




}


#endif /* VVGL_GLScene_hpp */