2c7b82b401
in osg::Program::PerContextProgram : typedef std::vector<UniformModifiedCountPair> LastAppliedUniformList; should be typedef std::map<unsigned int, UniformModifiedCountPair> LastAppliedUniformList; Intel driver can use index uniform value > 200000. With a std::vector, this index uniform value generate an out of memory error Nothing in OpenGL or GLSL specification define index uniform value rules. And all other implementation that deal with uniform index in osg::Program use a std::map. This fix could have a little performance impact but this is the cost to pay to work with all driver."
400 lines
18 KiB
C++
400 lines
18 KiB
C++
/* -*-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;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/** 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<unsigned int>(_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<unsigned char> _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<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; }
|
|
|
|
/** 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<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;
|
|
|
|
/** 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
|
|
{
|
|
_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; }
|
|
|
|
/**
|
|
* 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<GL2Extensions> _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<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
|
|
};
|
|
|
|
/** 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<PerContextProgram> > _pcpList;
|
|
AttribBindingList _attribBindingList;
|
|
FragDataBindingList _fragDataBindingList;
|
|
UniformBlockBindingList _uniformBlockBindingList;
|
|
|
|
typedef std::vector< ref_ptr<Shader> > ShaderList;
|
|
ShaderList _shaderList;
|
|
|
|
osg::ref_ptr<ProgramBinary> _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
|