/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield * Copyright (C) 2003-2005 3Dlabs Inc. Ltd. * Copyright (C) 2004-2005 Nathan Cournia * Copyright (C) 2008 Zebra Imaging * Copyright (C) 2010 Vires Simulationstechnologie GmbH * * This application is open source and may be redistributed and/or modified * freely and without restriction, both in commercial and non commercial * applications, as long as this copyright notice is maintained. * * This application is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* file: include/osg/Program * author: Mike Weiblen 2008-01-02 * Holger Helmich 2010-10-21 */ #ifndef OSG_PROGRAM #define OSG_PROGRAM 1 #include #include #include #include #include #include #include #include namespace osg { class State; /////////////////////////////////////////////////////////////////////////// /** osg::Program is an application-level abstraction of an OpenGL glProgram. * It is an osg::StateAttribute that, when applied, will activate a * glProgram for subsequent rendering. * osg::Shaders containing the actual shader source code are * attached to a Program, which will then manage the compilation, * linking, and activation of the GLSL program. * osg::Program will automatically manage per-context instancing of the * OpenGL glPrograms, if that is necessary for a particular display * configuration. */ class OSG_EXPORT Program : public osg::StateAttribute { public: Program(); /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ Program(const Program& rhs, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); META_StateAttribute(osg, Program, PROGRAM); /** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.*/ virtual int compare(const osg::StateAttribute& sa) const; /** If enabled, activate our program in the GL pipeline, * performing any rebuild operations that might be pending. */ virtual void apply(osg::State& state) const; /** Set whether to use a mutex to ensure ref() and unref() are thread safe.*/ virtual void setThreadSafeRefUnref(bool threadSafe); /** Compile program and associated shaders.*/ virtual void compileGLObjects(osg::State& state) const; /** Resize any per context GLObject buffers to specified size. */ virtual void resizeGLObjectBuffers(unsigned int maxSize); /** release OpenGL objects in specified graphics context if State object is passed, otherwise release OpenGL objects for all graphics context if State object pointer NULL.*/ virtual void releaseGLObjects(osg::State* state=0) const; /** Mark our PCSOs as needing relink */ void dirtyProgram(); /** Attach an osg::Shader to this osg::Program. * Mark Program as needing relink. Return true for success */ bool addShader( Shader* shader ); unsigned int getNumShaders() const { return static_cast(_shaderList.size()); } Shader* getShader( unsigned int i ) { return _shaderList[i].get(); } const Shader* getShader( unsigned int i ) const { return _shaderList[i].get(); } /** Remove osg::Shader from this osg::Program. * Mark Program as needing relink. Return true for success */ bool removeShader( Shader* shader ); /** Set/get GL program parameters */ void setParameter( GLenum pname, GLint value ); GLint getParameter( GLenum pname ) const; void setParameterfv( GLenum pname, const GLfloat* value ); const GLfloat* getParameterfv( GLenum pname ) const; /** Add an attribute location binding. */ void addBindAttribLocation( const std::string& name, GLuint index ); /** Remove an attribute location binding. */ void removeBindAttribLocation( const std::string& name ); /** Add an frag data location binding. See EXT_gpu_shader4 for BindFragDataLocationEXT */ void addBindFragDataLocation( const std::string& name, GLuint index ); /** Remove an frag data location binding. */ void removeBindFragDataLocation( const std::string& name ); /** Add a uniform block binding to an index target. XXX This * should not be an attribute of the program. It should be a * pseudo-uniform that can live in StateSet objects because * it is cheap to set. */ void addBindUniformBlock(const std::string& name, GLuint index); /** Remove a uniform block binding. */ void removeBindUniformBlock(const std::string& name); /** Simple class for wrapping up the data used in glProgramBinary and glGetProgramBinary. * On the first run of your application Programs should be assigned an empty ProgramBinary. * Before your application exits it should retrieve the program binary via * Program::PerContextProgram::compileProgramBinary and save it to disk. * When your application is run subsequently, load your binary from disk and use it to set * the data of a ProgramBinary, and set the ProgramBinary on the associated Program. * This will typically result in Program::compileGLObjects executing much faster.*/ class OSG_EXPORT ProgramBinary : public osg::Object { public: ProgramBinary(); /** Copy constructor using CopyOp to manage deep vs shallow copy.*/ ProgramBinary(const ProgramBinary& rhs, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY); META_Object(osg, ProgramBinary); /** Allocated a data buffer of specified size/*/ void allocate(unsigned int size); /** Assign program binary data, copying the specified data into locally stored data buffer, the original data can then be deleted.*/ void assign(unsigned int size, const unsigned char* data); /** Set the format of the program binary data.*/ void setFormat(GLenum format) {_format = format;} /** Get the format of the program binary data.*/ GLenum getFormat() const {return _format;} /** Get the size of the program binary data.*/ unsigned int getSize() const { return _data.size(); } /** Get a ptr to the program binary data.*/ unsigned char* getData() { return _data.empty() ? 0 : &(_data.front()); } /** Get a const ptr to the program binary data.*/ const unsigned char* getData() const { return _data.empty() ? 0 : &(_data.front()); } protected: std::vector _data; GLenum _format; }; /** Set the Program using a ProgramBinary. If a ProgramBinary is not yet * available then setting an empty one signals that compileProgramBinary * will be called later.*/ void setProgramBinary(ProgramBinary* programBinary) { _programBinary = programBinary; } /** Get the Program's ProgramBinary, return NULL if none is assigned. */ ProgramBinary* getProgramBinary() { return _programBinary.get(); } /** Get the const Program's ProgramBinary, return NULL if none is assigned. */ const ProgramBinary* getProgramBinary() const { return _programBinary.get(); } typedef std::map AttribBindingList; typedef std::map FragDataBindingList; typedef std::map UniformBlockBindingList; const AttribBindingList& getAttribBindingList() const { return _attribBindingList; } const FragDataBindingList& getFragDataBindingList() const { return _fragDataBindingList; } const UniformBlockBindingList& getUniformBlockBindingList() const { return _uniformBlockBindingList; } /** Return true if this Program represents "fixed-functionality" rendering */ bool isFixedFunction() const; /** Query InfoLog from a glProgram */ bool getGlProgramInfoLog(unsigned int contextID, std::string& log) const; /** Mark internal glProgram for deletion. * Deletion requests are queued until they can be executed * in the proper GL context. */ static void deleteGlProgram(unsigned int contextID, GLuint program); /** flush all the cached glPrograms which need to be deleted * in the OpenGL context related to contextID.*/ static void flushDeletedGlPrograms(unsigned int contextID,double currentTime, double& availableTime); /** discard all the cached glPrograms which need to be deleted * in the OpenGL context related to contextID. * Note, unlike flush no OpenGL calls are made, instead the handles are all removed. * this call is useful for when an OpenGL context has been destroyed. */ static void discardDeletedGlPrograms(unsigned int contextID); struct ActiveVarInfo { ActiveVarInfo() : _location(-1), _type(Uniform::UNDEFINED), _size(-1) {} ActiveVarInfo( GLint loc, GLenum type, GLint size ) : _location(loc), _type(type), _size(size) {} GLint _location; GLenum _type; GLint _size; }; typedef std::map< unsigned int, ActiveVarInfo > ActiveUniformMap; typedef std::map< std::string, ActiveVarInfo > ActiveVarInfoMap; const ActiveUniformMap& getActiveUniforms(unsigned int contextID) const; const ActiveVarInfoMap& getActiveAttribs(unsigned int contextID) const; struct UniformBlockInfo { UniformBlockInfo() : _index(GL_INVALID_INDEX), _size(0) {} UniformBlockInfo(GLuint index, GLsizei size) : _index(index), _size(size) { } GLuint _index; GLsizei _size; }; typedef std::map UniformBlockMap; const UniformBlockMap& getUniformBlocks(unsigned contextID) const; public: // make PerContextProgram a friend to allow it access Program's protected // methods and member variables. class PerContextProgram; friend class PerContextProgram; /** PerContextProgram (PCP) is an OSG-internal encapsulation of glPrograms per-GL context. */ class OSG_EXPORT PerContextProgram : public osg::Referenced { public: PerContextProgram(const Program* program, unsigned int contextID); GLuint getHandle() const {return _glProgramHandle;} void requestLink(); void linkProgram(osg::State& state); bool validateProgram(); bool needsLink() const {return _needsLink;} bool isLinked() const {return _isLinked;} bool getInfoLog( std::string& infoLog ) const; /** Was glProgramBinary called successfully? */ bool loadedBinary() const {return _loadedBinary;} /** Compile a program binary. For this to work setProgramBinary must have * been called on the osg::Program with an empty ProgramBinary prior to * compileGLObjects being called. * compileProgramBinary should be called after the program has been * "exercised" by rendering with it. The ProgramBinary can then be saved * to disk for faster subsequent compiling. */ ProgramBinary* compileProgramBinary(osg::State& state); void useProgram() const; void resetAppliedUniforms() const { for(LastAppliedUniformList::iterator itr=_lastAppliedUniformList.begin(); itr!=_lastAppliedUniformList.end(); ++itr) { (*itr).first = 0; (*itr).second = 0; } } inline void apply(const Uniform& uniform) const { GLint location = getUniformLocation(uniform.getNameID()); if (location>=0) { if ((unsigned int)location>=_lastAppliedUniformList.size()) _lastAppliedUniformList.resize(location+1); const Uniform* lastAppliedUniform = _lastAppliedUniformList[location].first.get(); if (lastAppliedUniform != &uniform) { // new attribute uniform.apply(_extensions.get(),location); _lastAppliedUniformList[location].first = &uniform; _lastAppliedUniformList[location].second = uniform.getModifiedCount(); } else if (_lastAppliedUniformList[location].second != uniform.getModifiedCount()) { // existing attribute has been modified uniform.apply(_extensions.get(),location); _lastAppliedUniformList[location].first = &uniform; _lastAppliedUniformList[location].second = uniform.getModifiedCount(); } } } const ActiveUniformMap& getActiveUniforms() const {return _uniformInfoMap;} const ActiveVarInfoMap& getActiveAttribs() const {return _attribInfoMap;} const UniformBlockMap& getUniformBlocks() const {return _uniformBlockMap; } inline GLint getUniformLocation( unsigned int uniformNameID ) const { ActiveUniformMap::const_iterator itr = _uniformInfoMap.find(uniformNameID); return (itr!=_uniformInfoMap.end()) ? itr->second._location : -1; } /** * Alternative version of getUniformLocation( unsigned int uniformNameID ) * retrofited into OSG for backward compatibility with osgCal, * after uniform ids were refactored from std::strings to GLints in OSG version 2.9.10. * * Drawbacks: This method is not particularly fast. It has to access mutexed static * map of uniform ids. So don't overuse it or your app performance will suffer. */ inline GLint getUniformLocation( const std::string & uniformName ) const { return getUniformLocation( Uniform::getNameID( uniformName ) ); } inline GLint getAttribLocation( const std::string& name ) const { ActiveVarInfoMap::const_iterator itr = _attribInfoMap.find(name); return (itr!=_attribInfoMap.end()) ? itr->second._location : -1; } inline void addShaderToAttach(Shader *shader) { _shadersToAttach.push_back(shader); } inline void addShaderToDetach(Shader *shader) { _shadersToDetach.push_back(shader); } protected: /*methods*/ ~PerContextProgram(); protected: /*data*/ /** Pointer to our parent Program */ const Program* _program; /** Pointer to this context's extension functions */ osg::ref_ptr _extensions; /** Handle to the actual OpenGL glProgram */ GLuint _glProgramHandle; /** Does our glProgram need to be linked? */ bool _needsLink; /** Is our glProgram successfully linked? */ bool _isLinked; /** Was glProgramBinary called successfully? */ bool _loadedBinary; const unsigned int _contextID; ActiveUniformMap _uniformInfoMap; ActiveVarInfoMap _attribInfoMap; UniformBlockMap _uniformBlockMap; typedef std::pair, unsigned int> UniformModifiedCountPair; typedef std::vector LastAppliedUniformList; mutable LastAppliedUniformList _lastAppliedUniformList; typedef std::vector< ref_ptr > ShaderList; ShaderList _shadersToDetach; ShaderList _shadersToAttach; private: PerContextProgram(); // disallowed PerContextProgram(const PerContextProgram&); // disallowed PerContextProgram& operator=(const PerContextProgram&); // disallowed }; /** Get the PCP for a particular GL context */ PerContextProgram* getPCP(unsigned int contextID) const; protected: /*methods*/ virtual ~Program(); protected: /*data*/ mutable osg::buffered_value< osg::ref_ptr > _pcpList; AttribBindingList _attribBindingList; FragDataBindingList _fragDataBindingList; UniformBlockBindingList _uniformBlockBindingList; typedef std::vector< ref_ptr > ShaderList; ShaderList _shaderList; osg::ref_ptr _programBinary; /** Parameters maintained with glProgramParameteriEXT */ GLint _geometryVerticesOut; GLint _geometryInputType; GLint _geometryOutputType; /** Parameter maintained with glPatchParameteri */ GLint _patchVertices; /** Parameter maintained with glPatchParameterfv */ // todo add tessellation default level //GLfloat _patchDefaultInnerLevel[2]; //GLfloat _patchDefaultOuterLevel[4]; private: Program& operator=(const Program&); // disallowed }; } #endif