ISFScene.hpp

#ifndef ISFScene_hpp
#define ISFScene_hpp

#include "VVISF_Base.hpp"
#if defined(VVGL_SDK_MAC)
#import <TargetConditionals.h>
#endif




namespace VVISF
{


using namespace std;





class VVISF_EXPORT ISFScene : public VVGL::GLScene  {
    private:
        bool            _throwExceptions = false;   //  NO by default

        mutex           _propertyLock;  //  locks the below two vars
        //bool          loadingInProgress = false;
        ISFDocRef       _doc = nullptr; //  the ISFDoc being used

        //  access to these vars should be restricted by the '_renderLock' var inherited from GLScene
        VVGL::Size      _renderSize = _orthoSize;   //  the last size at which i was requested to render a buffer (used to produce vals from normalized point inputs that need a render size to be used)
        VVGL::Timestamp     _baseTime;  //  used to generate time values, some of which get passed to the ISF scene
        uint32_t        _renderFrameIndex = 0;  //  used to pass FRAMEINDEX to shaders
        double          _renderTime = 0.;   //  this is the render time that gets passed to the ISF
        double          _renderTimeDelta = 0.;  //  this is the render time delta (frame duration) which gets passed to the ISF
        uint32_t        _passIndex = 1; //  used to store the index of the rendered pass, which gets passed to the shader
        string          *_compiledInputTypeString = nullptr;    //  a sequence of characters, either "2" or "R" or "C", one character for each input image. describes whether the shader was compiled to work with 2D textures or RECT textures or cube textures.

        //  access to these vars should be restricted by the '_renderLock' var inherited from GLScene
        VVGL::GLCachedAttrib    _vertexAttrib = VVGL::GLCachedAttrib("VERTEXDATA"); //  caches the location of the attribute in the compiled GL program for the vertex input
        VVGL::GLCachedUni       _renderSizeUni = VVGL::GLCachedUni("RENDERSIZE");   //  caches the location of the uniform in the compiled GL program for the render size
        VVGL::GLCachedUni       _passIndexUni = VVGL::GLCachedUni("PASSINDEX"); //  caches the location of the uniform in the compiled GL program for the pass index
        VVGL::GLCachedUni       _timeUni = VVGL::GLCachedUni("TIME");   //  caches the location of the uniform in the compiled GL program for the time
        VVGL::GLCachedUni       _timeDeltaUni = VVGL::GLCachedUni("TIMEDELTA"); //  caches the location of the uniform in the compiled GL program for the time delta
        VVGL::GLCachedUni       _dateUni = VVGL::GLCachedUni("DATE");   //  caches the location of the uniform in the compiled GL program for the date
        VVGL::GLCachedUni       _renderFrameIndexUni = VVGL::GLCachedUni("FRAMEINDEX"); //  caches the location of the uniform in the compiled GL program for the frame index

        //  access to these vars should be restricted by the '_renderLock' var inherited from GLScene
        //VVGL::GLBufferRef         geoXYVBO = nullptr;
#if !defined(VVGL_TARGETENV_GLES)
        VVGL::GLBufferRef           _vao = nullptr;
#endif
        VVGL::GLBufferRef           _vbo = nullptr;
        VVGL::Quad<VVGL::VertXY>        _vboContents;   //  the VBO owned by VAO is described by this var- we check this, and if there's a delta then we have to upload new data to the VBO

        //  these vars describe some non-default/non-standard options for more unusual situations
        bool                _alwaysRenderToFloat = false;   //  false by default- if true, all interim buffers generated by the ISF will be float32 per component.  set this before loading the doc.
        bool                _persistentToIOSurface = false; //  false by default- if true, persistent buffers generated by the ISF will be backed by IOSurfaces (so they can be re-used if the underlying GL context changes to one in a different sharegroup).  set this before loading the doc.

    public:
        ISFScene();
        ISFScene(const VVGL::GLContextRef & inCtx);
        virtual ~ISFScene();

        virtual void prepareToBeDeleted();
        
        
        
        void useFile() noexcept(false);
        void useFile(const string & inPath) noexcept(false);
        void useDoc(ISFDocRef & inDoc);
        inline ISFDocRef doc() { lock_guard<mutex> lock(_propertyLock); return _doc; }
        
        
        
        
        void setAlwaysRenderToFloat(const bool & n) { _alwaysRenderToFloat=n; }
        bool alwaysRenderToFloat() { return _alwaysRenderToFloat; }
        void setPersistentToIOSurface(const bool & n) { _persistentToIOSurface=n; }
        bool persistentToIOSurface() { return _persistentToIOSurface; }
        
        
        
        
        void setBufferForInputNamed(const VVGL::GLBufferRef & inBuffer, const string & inName);
        void setFilterInputBuffer(const VVGL::GLBufferRef & inBuffer);
        void setBufferForInputImageKey(const VVGL::GLBufferRef & inBuffer, const string & inString);
        void setBufferForAudioInputKey(const VVGL::GLBufferRef & inBuffer, const string & inString);
        VVGL::GLBufferRef getBufferForImageInput(const string & inKey);
        VVGL::GLBufferRef getBufferForAudioInput(const string & inKey);
        VVGL::GLBufferRef getPersistentBufferNamed(const string & inKey);
        VVGL::GLBufferRef getTempBufferNamed(const string & inKey);
        
        void setValueForInputNamed(const ISFVal & inVal, const string & inName);
        ISFVal valueForInputNamed(const string & inName);
        
        
        
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Woverloaded-virtual"
        //virtual GLBufferRef createAndRenderABuffer(const VVGL::Size & inSize=VVGL::Size(640.,480.), const GLBufferPoolRef & inPool=nullptr);
        virtual VVGL::GLBufferRef createAndRenderABuffer(const VVGL::Size & inSize=VVGL::Size(640.,480.), map<int32_t,VVGL::GLBufferRef> * outPassDict=nullptr, const VVGL::GLBufferPoolRef & inPoolRef=nullptr);
        //virtual VVGL::GLBufferRef createAndRenderABuffer(const VVGL::Size & inSize, const double & inRenderTime, const VVGL::GLBufferPoolRef & inPoolRef=nullptr);
        virtual VVGL::GLBufferRef createAndRenderABuffer(const VVGL::Size & inSize, const double & inRenderTime, map<int32_t,VVGL::GLBufferRef> * outPassDict=nullptr, const VVGL::GLBufferPoolRef & inPoolRef=nullptr);
#pragma clang diagnostic pop
        
        
        void renderToBuffer(const VVGL::GLBufferRef & inTargetBuffer, const VVGL::Size & inRenderSize, const double & inRenderTime, map<int32_t,VVGL::GLBufferRef> * outPassDict);
        void renderToBuffer(const VVGL::GLBufferRef & inTargetBuffer, const VVGL::Size & inRenderSize, const double & inRenderTime);
        void renderToBuffer(const VVGL::GLBufferRef & inTargetBuffer, const VVGL::Size & inRenderSize, map<int32_t,VVGL::GLBufferRef> * outPassDict);
        void renderToBuffer(const VVGL::GLBufferRef & inTargetBuffer, const VVGL::Size & inRenderSize);
        void renderToBuffer(const VVGL::GLBufferRef & inTargetBuffer);

        virtual void setSize(const VVGL::Size & n);
        VVGL::Size size() const { return _orthoSize; }
        VVGL::Size renderSize() const { return _renderSize; }
        inline VVGL::Timestamp getTimestamp() { return VVGL::Timestamp()-_baseTime; }
        inline void setThrowExceptions(const bool & n) { _throwExceptions=n; }

        //virtual void renderToBuffer(const VVGL::GLBufferRef & inTargetBuffer, const VVGL::Size & inRenderSize=VVGL::Size(640.,480.), const double & inRenderTime=timestamper.nowTime().getTimeInSeconds(), map<string,VVGL::GLBufferRef> * outPassDict=nullptr);
        
        
        
        ISFAttrRef inputNamed(const string & inName);
        vector<ISFAttrRef> inputs();
        vector<ISFAttrRef> inputsOfType(const ISFValType & inType);
        vector<ISFAttrRef> imageInputs();
        vector<ISFAttrRef> audioInputs();
        vector<ISFAttrRef> imageImports();
        
        
        
        virtual void setVertexShaderString(const string & n);
        virtual void setFragmentShaderString(const string & n);

    protected:
#if !defined(VVGL_TARGETENV_GLES)
        inline VVGL::GLBufferRef vao() const { return _vao; }
        inline void setVAO(const VVGL::GLBufferRef & n) { _vao = n; }
#endif
        inline VVGL::GLBufferRef vbo() const { return _vbo; }
        inline void setVBO(const VVGL::GLBufferRef & n) { _vbo = n; }
        void _setUpRenderCallback();
        virtual void _renderPrep();
        virtual void _initialize();
        virtual void _renderCleanup();
        virtual void _render(const VVGL::GLBufferRef & inTargetBuffer, const VVGL::Size & inSize, const double & inTime, map<int32_t,VVGL::GLBufferRef> * outPassDict);

};




inline ISFSceneRef CreateISFSceneRef() { return make_shared<ISFScene>(); }
inline ISFSceneRef CreateISFSceneRefUsing(const VVGL::GLContextRef & inCtx) { return make_shared<ISFScene>(inCtx); }




}




#endif /* ISFScene_hpp */