ISFPassTarget.hpp

#ifndef ISFPassTarget_hpp
#define ISFPassTarget_hpp

#include "VVISF_Base.hpp"

#include "exprtk/exprtk.hpp"




namespace VVISF
{




using namespace std;




class ISFDoc;





class VVISF_EXPORT ISFPassTarget    {
    private:
        string          _name;
        VVGL::GLBufferRef       _buffer = nullptr;
        ISFDoc          *_parentDoc;    //  weak ref to the parent doc (ISFDoc*) that created and owns me
        
        mutex           _targetLock;
        
        double          _targetWidth = 1.0; //  the target width for this pass.  the expression evaluates to this value
        string          *_targetWidthString = nullptr;
        exprtk::expression<double>      *_targetWidthExpression = nullptr;
        double          _widthExpressionVar = 1.0;  //  the expression expects you to maintain static memory for the variables in its symbol table (the memory has to be retained as long as the expression is in use)

        double          _targetHeight = 1.0;    //  the target height for this pass.  the expression evaluates to this value
        string          *_targetHeightString = nullptr;
        exprtk::expression<double>      *_targetHeightExpression = nullptr;
        double          _heightExpressionVar = 1.0; //  the expression expects you to maintain static memory for the variables in its symbol table (the memory has to be retained as long as the expression is in use)

        bool            _floatFlag = false; //  NO by default, if YES makes float texutres
        VVGL::GLCachedUniRef    _cachedUnis[4] = { nullptr, nullptr, nullptr, nullptr };
    public:
        //  "class method" that creates a buffer ref
        static ISFPassTargetRef Create(const string & inName, const ISFDoc * inParentDoc);
        //  clears the static tex-to-tex copier maintained by the class
        static void cleanup();
        
        ISFPassTarget(const string & inName, const ISFDoc * inParentDoc);
        ~ISFPassTarget();
        ISFPassTarget(const ISFPassTarget & n) = default;
        ISFPassTarget(ISFPassTarget && n) = default;
        ISFPassTarget & operator=(ISFPassTarget & n) = delete;
        ISFPassTarget & operator=(ISFPassTarget && n) = delete;
        
        void setTargetWidthString(const string & n);
        const string targetWidthString();
        void setTargetHeightString(const string & n);
        const string targetHeightString();
        void setFloatFlag(const bool & n);
        bool floatFlag() const { return _floatFlag; }
        void clearBuffer();
        
        bool targetSizeNeedsEval() const { return (_targetHeightString!=nullptr || _targetHeightString!=nullptr); }
        void evalTargetSize(const VVGL::Size & inSize, map<string, double*> & inSymbols, const bool & inResize, const bool & inCreateNewBuffer);
        
        string & name() { return _name; }
        VVGL::GLBufferRef & buffer() { return _buffer; }
        void setBuffer(const VVGL::GLBufferRef & n) { _buffer=n; }
        
        VVGL::Size targetSize() { return { _targetWidth, _targetHeight }; }
        
        void cacheUniformLocations(const int & inPgmToCheck) { for (int i=0; i<4; ++i) _cachedUnis[i]->cacheTheLoc(inPgmToCheck); }
        int32_t getUniformLocation(const int & inIndex) const { return (inIndex<0||inIndex>3) ? -1 : _cachedUnis[inIndex]->loc; }
        void clearUniformLocations() { for (int i=0; i<4; ++i) _cachedUnis[i]->purgeCache(); }
    
    private:
        void setTargetSize(const VVGL::Size & inSize, const bool & inResize=true, const bool & inCreateNewBuffer=true);
    
};




}

#endif /* ISFPassTarget_hpp */