ISFDoc.hpp

#ifndef ISFDoc_hpp
#define ISFDoc_hpp

#include <vector>
#include "VVISF_Base.hpp"
#include "ISFAttr.hpp"




namespace VVISF
{




using namespace std;

class ISFScene;




class VVISF_EXPORT ISFDoc   {
    private:
        recursive_mutex     _propLock;
        
        string          *_path = nullptr;   //  full path to the loaded file
        string          *_name = nullptr;   //  just the file name (including its extension)
        string          *_description = nullptr;    //  description of whatever the file does
        string          *_credit = nullptr; //  credit
        string          *_vsn = nullptr;
        ISFFileType     _type = ISFFileType_Source;
        bool            _throwExcept = true;
        
        vector<string>          _categories;    //  array of strings of the category names this doc should be listed under
        vector<ISFAttrRef>      _inputs;    //  array of ISFAttrRef instances for the various inputs
        vector<ISFAttrRef>      _imageInputs;   //  array of ISFAttrRef instances for the image inputs (the image inputs are stored in two arrays).
        vector<ISFAttrRef>      _audioInputs;   //  array of ISFAttrRef instances for the audio inputs
        vector<ISFAttrRef>      _imageImports;  //  array of ISFAttrRef instances that describe imported images. attrib's 'attribName' is the name of the sampler, attrib's 'description' is the path to the file.
        
        //bool                  bufferRequiresEval = false; //  NO by default, set to YES during file open if any of the buffers require evaluation (faster than checking every single buffer every pass)
        vector<ISFPassTargetRef>    _persistentPassTargets;
        vector<ISFPassTargetRef>    _tempPassTargets;
        vector<string>          _renderPasses;
        
        string          *_jsonSourceString = nullptr;   //  the JSON string from the source *including the comments and any linebreaks before/after it*
        string          *_jsonString = nullptr; //  the JSON string copied from the source- doesn't include any comments before/after it
        string          *_vertShaderSource = nullptr;   //  the raw vert shader source before being find-and-replaced
        string          *_fragShaderSource = nullptr;   //  the raw frag shader source before being find-and-replaced
        
        ISFScene        *_parentScene = nullptr;    //  nil by default, weak ref to the scene that "owns" me.  only non-nil when an ISFScene is using the doc to render.
        
    public:
        
        

        ISFDoc(const string & inPath, ISFScene * inParentScene=nullptr, const bool & inThrowExcept=true) noexcept(false);
        
        /*
        \param inFSContents A string containing the fragment shader portion of the ISF file.  The JSON blob that defines the ISF file must be contained in here.
        \param inVSContents A string containing the vertex shader portion of the ISF file.  If you don't have a vertex shader to pass, VVISF defines a static string "ISFVertPassthru_GL2", which should work as a "passthru" vertex shader for most purposes.
        \param inImportsDir A string containing the path to the directory that will contain any related media files (used for IMPORT/etc).
        \param inParentScene The scene that will be used to render this ISFDoc, or null if no scene is to be used.
        \param inThrowExcept Whether or not the ISFDoc should throw any exceptions if it encounters errors parsing anything.
        Throws an ISFErr if there is a problem of some sort parsing the JSON blob from the frag shader string.
        */
        ISFDoc(const string & inFSContents, const string & inVSContents, const string & importsDir, ISFScene * inParentScene=nullptr, const bool & inThrowExcept=true);
        
        
        
        ~ISFDoc();
        
        
        
        string path() const { return (_path==nullptr) ? string("") : string(*_path); }
        string name() const { return (_name==nullptr) ? string("") : string(*_name); }
        string description() const { return (_description==nullptr) ? string("") : string(*_description); }
        string credit() const { return (_credit==nullptr) ? string("") : string(*_credit); }
        string vsn() const { return (_vsn==nullptr) ? string("") : string(*_vsn); }
        ISFFileType type() const { return _type; }
        vector<string> & categories() { return _categories; }
        
        
        
        
        vector<ISFAttrRef> & inputs() { return _inputs; }
        vector<ISFAttrRef> & imageInputs() { return _imageInputs; }
        vector<ISFAttrRef> & audioInputs() { return _audioInputs; }
        vector<ISFAttrRef> & imageImports() { return _imageImports; }
        vector<ISFAttrRef> inputsOfType(const ISFValType & inInputType);
        ISFAttrRef input(const string & inAttrName);
        
        
        
        
        vector<ISFPassTargetRef> persistentPassTargets() const { return _persistentPassTargets; }
        vector<ISFPassTargetRef> tempPassTargets() const { return _tempPassTargets; }
        vector<string> & renderPasses() { return _renderPasses; }
        const VVGL::GLBufferRef getBufferForKey(const string & n);
        const VVGL::GLBufferRef getPersistentBufferForKey(const string & n);
        const VVGL::GLBufferRef getTempBufferForKey(const string & n);
        const ISFPassTargetRef passTargetForKey(const string & n);
        const ISFPassTargetRef persistentPassTargetForKey(const string & n);
        const ISFPassTargetRef tempPassTargetForKey(const string & n);
        
        
        
        
        string * jsonSourceString() const { return _jsonSourceString; }
        string * jsonString() const { return _jsonString; }
        string * vertShaderSource() const { return _vertShaderSource; }
        string * fragShaderSource() const { return _fragShaderSource; }
        void jsonSourceString(string & outStr);
        
        
        void setParentScene(ISFScene * n) { _parentScene=n; }
        ISFScene * parentScene() { return _parentScene; }
        
        //  returns a string describing the type of the expected texture samplers ("2" for 2D, "R" for Rect, "C" for Cube).  save this, if it changes in a later pass the shader source must be generated again.
        string generateTextureTypeString();
        bool generateShaderSource(string * outFragSrc, string * outVertSrc, VVGL::GLVersion & inGLVers, const bool & inVarsAsUBO=false);
        //  this method must be called before rendering (passes/etc may have expressions that require the render dims to be evaluated)
        void evalBufferDimensionsWithRenderSize(const VVGL::Size & inSize);
        
        VVISF_EXPORT friend ostream & operator<<(ostream & os, const ISFDoc & n);
        
    protected:
        //  used so we can have two constructors without duplicating code
        void _initWithRawFragShaderString(const string & inRawFile);
        //  returns a true if successful.  populates a string with variable declarations for a frag shader
        bool _assembleShaderSource_VarDeclarations(string * outVSString, string * outFSString, VVGL::GLVersion & inGLVers, const bool & inVarsAsUBO=false);
        //  returns a true if successful.  populates a map with string/value pairs that will be used to evaluate variable names in strings
        bool _assembleSubstitutionMap(map<string,double*> * outMap);
};





inline ISFDocRef CreateISFDocRef(const string & inPath, ISFScene * inParentScene=nullptr, const bool & inThrowExcept=true) noexcept(false) { return make_shared<ISFDoc>(inPath,inParentScene,inThrowExcept); }


inline ISFDocRef CreateISFDocRefWith(const string & inFSContents, const string & inImportsDir=string("/"), const string & inVSContents=string(ISFVertPassthru_GL2), ISFScene * inParentScene=nullptr, const bool & inThrowExcept=true) { return make_shared<ISFDoc>(inFSContents,inVSContents,inImportsDir,inParentScene,inThrowExcept); }



}




#endif /* ISFDoc_hpp */