Program.h

Go to the documentation of this file.

/* -*-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 <string>
#include <vector>
#include <map>

#include <osg/buffered_value>
#include <osg/ref_ptr>
#include <osg/Uniform>
#include <osg/Shader>
#include <osg/StateAttribute>

namespace osg {

class State;



class OSG_EXPORT Program : public osg::StateAttribute
{
    public:
        Program();

        Program(const Program& rhs, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);

        META_StateAttribute(osg, Program, PROGRAM);

        virtual int compare(const osg::StateAttribute& sa) const;

        virtual void apply(osg::State& state) const;

        virtual void setThreadSafeRefUnref(bool threadSafe);

        virtual void compileGLObjects(osg::State& state) const;

        virtual void resizeGLObjectBuffers(unsigned int maxSize);

        virtual void releaseGLObjects(osg::State* state=0) const;

        void dirtyProgram();

        bool addShader( Shader* shader );

        unsigned int getNumShaders() const { return static_cast<unsigned int>(_shaderList.size()); }

        Shader* getShader( unsigned int i ) { return _shaderList[i].get(); }
        const Shader* getShader( unsigned int i ) const { return _shaderList[i].get(); }

        bool removeShader( Shader* shader );

        void setParameter( GLenum pname, GLint value );
        GLint getParameter( GLenum pname ) const;

        void setComputeGroups( GLint numGroupsX, GLint numGroupsY, GLint numGroupsZ );
        void getComputeGroups( GLint& numGroupsX, GLint& numGroupsY, GLint& numGroupsZ ) const;

        void addBindAttribLocation( const std::string& name, GLuint index );

        void removeBindAttribLocation( const std::string& name );

        void addBindFragDataLocation( const std::string& name, GLuint index );

        void removeBindFragDataLocation( const std::string& name );

        void addBindUniformBlock(const std::string& name, GLuint index);

        void removeBindUniformBlock(const std::string& name);

        void removeTransformFeedBackVarying(const std::string& name)
        {
            for(std::vector<std::string>::iterator i=_feedbackout.begin(); i!=_feedbackout.end(); i++)
            {
                if (*i == name) {_feedbackout.erase(i);break; }
            }
        }

        void addTransformFeedBackVarying(const std::string& outname)
        {
            _feedbackout.push_back(outname);
        }

        inline unsigned int getNumTransformFeedBackVaryings() const { return _feedbackout.size(); }

        inline const std::string& getTransformFeedBackVarying(unsigned int i) const { return _feedbackout[i]; }

        void setTransformFeedBackMode(GLenum e) {_feedbackmode=e;}

        GLenum getTransformFeedBackMode() const {return _feedbackmode;}

        void setShaderDefines(const ShaderDefines& shaderDefs) { _shaderDefines = shaderDefs; }
        ShaderDefines& getShaderDefines() { return _shaderDefines; }
        const ShaderDefines& getShaderDefines() const { return _shaderDefines; }



        class OSG_EXPORT ProgramBinary : public osg::Object
        {
            public:

                ProgramBinary();

                ProgramBinary(const ProgramBinary& rhs, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);

                META_Object(osg, ProgramBinary);

                void allocate(unsigned int size);

                void assign(unsigned int size, const unsigned char* data);

                void setFormat(GLenum format) {_format = format;}

                GLenum getFormat() const {return _format;}

                unsigned int getSize() const { return static_cast<unsigned int>(_data.size()); }

                unsigned char* getData() { return _data.empty() ? 0 : &(_data.front()); }

                const unsigned char* getData() const { return _data.empty() ? 0 : &(_data.front()); }

            protected:
                std::vector<unsigned char> _data;
                GLenum _format;
        };


        void setProgramBinary(ProgramBinary* programBinary) { _programBinary = programBinary; }

        ProgramBinary* getProgramBinary() { return _programBinary.get(); }

        const ProgramBinary* getProgramBinary() const { return _programBinary.get(); }

        typedef std::map<std::string,GLuint> AttribBindingList;
        typedef std::map<std::string,GLuint> FragDataBindingList;
        typedef std::map<std::string,GLuint> UniformBlockBindingList;

        const AttribBindingList& getAttribBindingList() const { return _attribBindingList; }
        const FragDataBindingList& getFragDataBindingList() const { return _fragDataBindingList; }
        const UniformBlockBindingList& getUniformBlockBindingList() const { return _uniformBlockBindingList; }

        bool isFixedFunction() const;

        bool getGlProgramInfoLog(unsigned int contextID, std::string& log) const;

        static void deleteGlProgram(unsigned int contextID, GLuint program);

        static void flushDeletedGlPrograms(unsigned int contextID,double currentTime, double& availableTime);

        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<std::string, UniformBlockInfo> 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;

        class OSG_EXPORT PerContextProgram : public osg::Referenced
        {
            public:
                PerContextProgram(const Program* program, unsigned int contextID, GLuint programHandle=0);

                GLuint getHandle() const {return _glProgramHandle;}

                const osg::Program* getProgram() const { return _program; }

                void setDefineString(const std::string& defStr) { _defineStr = defStr; }
                const std::string& getDefineString() const { return _defineStr; }

                void requestLink();
                virtual void linkProgram(osg::State& state);
                virtual bool validateProgram();
                bool needsLink() const {return _needsLink;}
                bool isLinked() const {return _isLinked;}
                virtual bool getInfoLog( std::string& infoLog ) const;

                bool loadedBinary() const {return _loadedBinary;}

                virtual ProgramBinary* compileProgramBinary(osg::State& state);

                virtual void useProgram() const;

                void resetAppliedUniforms() const
                {
                    _lastAppliedUniformList.clear();
                }


                inline void apply(const Uniform& uniform) const
                {
                    GLint location = getUniformLocation(uniform.getNameID());
                    if (location>=0)
                    {
                        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; }

                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*/
                virtual ~PerContextProgram();

            protected:        /*data*/
                const Program* _program;
                osg::ref_ptr<GLExtensions> _extensions;

                GLuint _glProgramHandle;

                std::string _defineStr;

                bool _needsLink;
                bool _isLinked;
                bool _loadedBinary;

                const unsigned int _contextID;

                bool _ownsProgramHandle;

                ActiveUniformMap _uniformInfoMap;
                ActiveVarInfoMap _attribInfoMap;
                UniformBlockMap _uniformBlockMap;

                typedef std::pair<osg::ref_ptr<const osg::Uniform>, unsigned int> UniformModifiedCountPair;
                typedef std::map<unsigned int, UniformModifiedCountPair> LastAppliedUniformList;
                mutable LastAppliedUniformList _lastAppliedUniformList;

                typedef std::vector< ref_ptr<Shader> > ShaderList;
                ShaderList _shadersToDetach;
                ShaderList _shadersToAttach;

            private:
                PerContextProgram();        // disallowed
                PerContextProgram(const PerContextProgram&);        // disallowed
                PerContextProgram& operator=(const PerContextProgram&);        // disallowed
        };

        struct OSG_EXPORT ProgramObjects : public osg::Referenced
        {
            typedef std::vector< osg::ref_ptr<PerContextProgram> > PerContextPrograms;

            ProgramObjects(const Program* program, unsigned int contextID);

            unsigned int        _contextID;
            const Program*      _program;
            mutable PerContextPrograms  _perContextPrograms;

            PerContextProgram* getPCP(const std::string& defineStr) const;
            PerContextProgram* createPerContextProgram(const std::string& defineStr);
            void requestLink();
            void addShaderToAttach(Shader* shader);
            void addShaderToDetach(Shader* shader);
            bool getGlProgramInfoLog(std::string& log) const;
        };

        PerContextProgram* getPCP(State& state) const;

    protected:        /*methods*/
        virtual ~Program();

    protected:        /*data*/

        mutable osg::buffered_value< osg::ref_ptr<ProgramObjects> > _pcpList;
        AttribBindingList _attribBindingList;
        FragDataBindingList _fragDataBindingList;
        UniformBlockBindingList _uniformBlockBindingList;

        typedef std::vector< ref_ptr<Shader> > ShaderList;
        ShaderList _shaderList;

        osg::ref_ptr<ProgramBinary> _programBinary;

        GLint _geometryVerticesOut;
        GLint _geometryInputType;
        GLint _geometryOutputType;


        GLint _numGroupsX;
        GLint _numGroupsY;
        GLint _numGroupsZ;

        GLenum _feedbackmode;
        std::vector<std::string> _feedbackout;

        ShaderDefines _shaderDefines;


    private:
        Program& operator=(const Program&);        // disallowed

};

}

#endif