Removed osgGL2 from CVS, osgGL2 now can be found on the Community/NodeKits section on the OSG website.
This commit is contained in:
Robert Osfield
@@ -1,767 +0,0 @@
|
||||
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
|
||||
* Copyright (C) 2003-2004 3Dlabs Inc. Ltd.
|
||||
*
|
||||
* This application is open source and may be redistributed and/or modified
|
||||
* freely and without restriction, both in commericial and non commericial
|
||||
* 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: src/osgGL2/Extensions.cpp
|
||||
* author: Mike Weiblen 2004-07-08
|
||||
*
|
||||
* See http://www.3dlabs.com/opengl2/ for more information regarding
|
||||
* the OpenGL Shading Language.
|
||||
*/
|
||||
|
||||
|
||||
#include <osg/Notify>
|
||||
#include <osg/GLExtensions>
|
||||
#include <osg/buffered_value>
|
||||
#include <osg/ref_ptr>
|
||||
|
||||
#include <osgGL2/Extensions>
|
||||
|
||||
using namespace osgGL2;
|
||||
|
||||
|
||||
Extensions::Extensions()
|
||||
{
|
||||
setupGLExtensions();
|
||||
}
|
||||
|
||||
Extensions::Extensions(const Extensions& rhs) : osg::Referenced()
|
||||
{
|
||||
_isShaderObjectsSupported = rhs._isShaderObjectsSupported;
|
||||
_isVertexShaderSupported = rhs._isVertexShaderSupported;
|
||||
_isFragmentShaderSupported = rhs._isFragmentShaderSupported;
|
||||
_isLanguage100Supported = rhs._isLanguage100Supported;
|
||||
_languageVersion = rhs._languageVersion;
|
||||
|
||||
_glCreateShaderObject = rhs._glCreateShaderObject;
|
||||
_glCreateProgramObject = rhs._glCreateProgramObject;
|
||||
_glDeleteObject = rhs._glDeleteObject;
|
||||
_glAttachObject = rhs._glAttachObject;
|
||||
_glDetachObject = rhs._glDetachObject;
|
||||
_glShaderSource = rhs._glShaderSource;
|
||||
_glCompileShader = rhs._glCompileShader;
|
||||
_glBindAttribLocation = rhs._glBindAttribLocation;
|
||||
_glLinkProgram = rhs._glLinkProgram;
|
||||
_glUseProgramObject = rhs._glUseProgramObject;
|
||||
_glGetInfoLog = rhs._glGetInfoLog;
|
||||
_glGetAttachedObjects = rhs._glGetAttachedObjects;
|
||||
_glGetShaderSource = rhs._glGetShaderSource;
|
||||
_glUniform1f = rhs._glUniform1f;
|
||||
_glUniform2f = rhs._glUniform2f;
|
||||
_glUniform3f = rhs._glUniform3f;
|
||||
_glUniform4f = rhs._glUniform4f;
|
||||
_glUniform1i = rhs._glUniform1i;
|
||||
_glUniform2i = rhs._glUniform2i;
|
||||
_glUniform3i = rhs._glUniform3i;
|
||||
_glUniform4i = rhs._glUniform4i;
|
||||
_glUniform1fv = rhs._glUniform1fv;
|
||||
_glUniform2fv = rhs._glUniform2fv;
|
||||
_glUniform3fv = rhs._glUniform3fv;
|
||||
_glUniform4fv = rhs._glUniform4fv;
|
||||
_glUniform1iv = rhs._glUniform1iv;
|
||||
_glUniform2iv = rhs._glUniform2iv;
|
||||
_glUniform3iv = rhs._glUniform3iv;
|
||||
_glUniform4iv = rhs._glUniform4iv;
|
||||
_glUniformMatrix2fv = rhs._glUniformMatrix2fv;
|
||||
_glUniformMatrix3fv = rhs._glUniformMatrix3fv;
|
||||
_glUniformMatrix4fv = rhs._glUniformMatrix4fv;
|
||||
_glGetUniformLocation = rhs._glGetUniformLocation;
|
||||
_glGetAttribLocation = rhs._glGetAttribLocation;
|
||||
_glGetActiveUniform = rhs._glGetActiveUniform;
|
||||
_glGetActiveAttribs = rhs._glGetActiveAttribs;
|
||||
_glGetUniformfv = rhs._glGetUniformfv;
|
||||
_glGetUniformiv = rhs._glGetUniformiv;
|
||||
_glGetObjectParameterfv = rhs._glGetObjectParameterfv;
|
||||
_glGetObjectParameteriv = rhs._glGetObjectParameteriv;
|
||||
_glGetHandle = rhs._glGetHandle;
|
||||
}
|
||||
|
||||
|
||||
void Extensions::lowestCommonDenominator(const Extensions& rhs)
|
||||
{
|
||||
if (!rhs._isShaderObjectsSupported) _isShaderObjectsSupported = false;
|
||||
if (!rhs._isVertexShaderSupported) _isVertexShaderSupported = false;
|
||||
if (!rhs._isFragmentShaderSupported) _isFragmentShaderSupported = false;
|
||||
if (!rhs._isLanguage100Supported) _isLanguage100Supported = false;
|
||||
if (rhs._languageVersion < _languageVersion) _languageVersion = rhs._languageVersion;
|
||||
|
||||
if (!rhs._glCreateShaderObject) _glCreateShaderObject = 0;
|
||||
if (!rhs._glCreateProgramObject) _glCreateProgramObject = 0;
|
||||
if (!rhs._glDeleteObject) _glDeleteObject = 0;
|
||||
if (!rhs._glAttachObject) _glAttachObject = 0;
|
||||
if (!rhs._glDetachObject) _glDetachObject = 0;
|
||||
if (!rhs._glShaderSource) _glShaderSource = 0;
|
||||
if (!rhs._glCompileShader) _glCompileShader = 0;
|
||||
if (!rhs._glBindAttribLocation) _glBindAttribLocation = 0;
|
||||
if (!rhs._glLinkProgram) _glLinkProgram = 0;
|
||||
if (!rhs._glUseProgramObject) _glUseProgramObject = 0;
|
||||
if (!rhs._glGetInfoLog) _glGetInfoLog = 0;
|
||||
if (!rhs._glGetAttachedObjects) _glGetAttachedObjects = 0;
|
||||
if (!rhs._glGetShaderSource) _glGetShaderSource = 0;
|
||||
if (!rhs._glUniform1f) _glUniform1f = 0;
|
||||
if (!rhs._glUniform2f) _glUniform2f = 0;
|
||||
if (!rhs._glUniform3f) _glUniform3f = 0;
|
||||
if (!rhs._glUniform4f) _glUniform4f = 0;
|
||||
if (!rhs._glUniform1i) _glUniform1i = 0;
|
||||
if (!rhs._glUniform2i) _glUniform2i = 0;
|
||||
if (!rhs._glUniform3i) _glUniform3i = 0;
|
||||
if (!rhs._glUniform4i) _glUniform4i = 0;
|
||||
if (!rhs._glUniform1fv) _glUniform1fv = 0;
|
||||
if (!rhs._glUniform2fv) _glUniform2fv = 0;
|
||||
if (!rhs._glUniform3fv) _glUniform3fv = 0;
|
||||
if (!rhs._glUniform4fv) _glUniform4fv = 0;
|
||||
if (!rhs._glUniform1iv) _glUniform1iv = 0;
|
||||
if (!rhs._glUniform2iv) _glUniform2iv = 0;
|
||||
if (!rhs._glUniform3iv) _glUniform3iv = 0;
|
||||
if (!rhs._glUniform4iv) _glUniform4iv = 0;
|
||||
if (!rhs._glUniformMatrix2fv) _glUniformMatrix2fv = 0;
|
||||
if (!rhs._glUniformMatrix3fv) _glUniformMatrix3fv = 0;
|
||||
if (!rhs._glUniformMatrix4fv) _glUniformMatrix4fv = 0;
|
||||
if (!rhs._glGetUniformLocation) _glGetUniformLocation = 0;
|
||||
if (!rhs._glGetAttribLocation) _glGetAttribLocation = 0;
|
||||
if (!rhs._glGetActiveUniform) _glGetActiveUniform = 0;
|
||||
if (!rhs._glGetActiveAttribs) _glGetActiveAttribs = 0;
|
||||
if (!rhs._glGetUniformfv) _glGetUniformfv = 0;
|
||||
if (!rhs._glGetUniformiv) _glGetUniformiv = 0;
|
||||
if (!rhs._glGetObjectParameterfv) _glGetObjectParameterfv = 0;
|
||||
if (!rhs._glGetObjectParameteriv) _glGetObjectParameteriv = 0;
|
||||
if (!rhs._glGetHandle) _glGetHandle = 0;
|
||||
}
|
||||
|
||||
void Extensions::setupGLExtensions()
|
||||
{
|
||||
_isShaderObjectsSupported = osg::isGLExtensionSupported("GL_ARB_shader_objects");
|
||||
_isVertexShaderSupported = osg::isGLExtensionSupported("GL_ARB_vertex_shader");
|
||||
_isFragmentShaderSupported = osg::isGLExtensionSupported("GL_ARB_fragment_shader");
|
||||
_isLanguage100Supported = osg::isGLExtensionSupported("GL_ARB_shading_language_100");
|
||||
_languageVersion = 0.0f;
|
||||
|
||||
if( _isLanguage100Supported )
|
||||
{
|
||||
// If glGetString raises an error, assume initial release "1.00"
|
||||
glGetError(); // reset error flag
|
||||
const char* langVerStr = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
|
||||
const GLenum errorNum = glGetError();
|
||||
if( (errorNum != GL_NO_ERROR) || (langVerStr == 0) )
|
||||
{
|
||||
langVerStr = "1.00 (default)";
|
||||
}
|
||||
osg::notify(osg::INFO) << "GL_SHADING_LANGUAGE_VERSION_ARB: \"" << langVerStr << "\"" << std::endl;
|
||||
|
||||
// TODO verify this parser is sufficiently robust
|
||||
_languageVersion = atof( langVerStr );
|
||||
}
|
||||
|
||||
osg::notify(osg::INFO) << "GLSL language version = " << _languageVersion << std::endl;
|
||||
|
||||
_glCreateShaderObject = osg::getGLExtensionFuncPtr("glCreateShaderObjectARB");
|
||||
_glCreateProgramObject = osg::getGLExtensionFuncPtr("glCreateProgramObjectARB");
|
||||
_glDeleteObject = osg::getGLExtensionFuncPtr("glDeleteObjectARB");
|
||||
_glAttachObject = osg::getGLExtensionFuncPtr("glAttachObjectARB");
|
||||
_glDetachObject = osg::getGLExtensionFuncPtr("glDetachObjectARB");
|
||||
_glShaderSource = osg::getGLExtensionFuncPtr("glShaderSourceARB");
|
||||
_glCompileShader = osg::getGLExtensionFuncPtr("glCompileShaderARB");
|
||||
_glBindAttribLocation = osg::getGLExtensionFuncPtr("glBindAttribLocationARB");
|
||||
_glLinkProgram = osg::getGLExtensionFuncPtr("glLinkProgramARB");
|
||||
_glUseProgramObject = osg::getGLExtensionFuncPtr("glUseProgramObjectARB");
|
||||
_glGetInfoLog = osg::getGLExtensionFuncPtr("glGetInfoLogARB");
|
||||
_glGetAttachedObjects = osg::getGLExtensionFuncPtr("glGetAttachedObjectsARB");
|
||||
_glGetShaderSource = osg::getGLExtensionFuncPtr("glGetShaderSourceARB");
|
||||
_glUniform1f = osg::getGLExtensionFuncPtr("glUniform1fARB");
|
||||
_glUniform2f = osg::getGLExtensionFuncPtr("glUniform2fARB");
|
||||
_glUniform3f = osg::getGLExtensionFuncPtr("glUniform3fARB");
|
||||
_glUniform4f = osg::getGLExtensionFuncPtr("glUniform4fARB");
|
||||
_glUniform1i = osg::getGLExtensionFuncPtr("glUniform1iARB");
|
||||
_glUniform2i = osg::getGLExtensionFuncPtr("glUniform2iARB");
|
||||
_glUniform3i = osg::getGLExtensionFuncPtr("glUniform3iARB");
|
||||
_glUniform4i = osg::getGLExtensionFuncPtr("glUniform4iARB");
|
||||
_glUniform1fv = osg::getGLExtensionFuncPtr("glUniform1fvARB");
|
||||
_glUniform2fv = osg::getGLExtensionFuncPtr("glUniform2fvARB");
|
||||
_glUniform3fv = osg::getGLExtensionFuncPtr("glUniform3fvARB");
|
||||
_glUniform4fv = osg::getGLExtensionFuncPtr("glUniform4fvARB");
|
||||
_glUniform1iv = osg::getGLExtensionFuncPtr("glUniform1ivARB");
|
||||
_glUniform2iv = osg::getGLExtensionFuncPtr("glUniform2ivARB");
|
||||
_glUniform3iv = osg::getGLExtensionFuncPtr("glUniform3ivARB");
|
||||
_glUniform4iv = osg::getGLExtensionFuncPtr("glUniform4ivARB");
|
||||
_glUniformMatrix2fv = osg::getGLExtensionFuncPtr("glUniformMatrix2fvARB");
|
||||
_glUniformMatrix3fv = osg::getGLExtensionFuncPtr("glUniformMatrix3fvARB");
|
||||
_glUniformMatrix4fv = osg::getGLExtensionFuncPtr("glUniformMatrix4fvARB");
|
||||
_glGetUniformLocation = osg::getGLExtensionFuncPtr("glGetUniformLocationARB");
|
||||
_glGetAttribLocation = osg::getGLExtensionFuncPtr("glGetAttribLocationARB");
|
||||
_glGetActiveUniform = osg::getGLExtensionFuncPtr("glGetActiveUniformARB");
|
||||
_glGetActiveAttribs = osg::getGLExtensionFuncPtr("glGetActiveAttribsARB");
|
||||
_glGetUniformfv = osg::getGLExtensionFuncPtr("glGetUniformfvARB");
|
||||
_glGetUniformiv = osg::getGLExtensionFuncPtr("glGetUniformivARB");
|
||||
_glGetObjectParameterfv = osg::getGLExtensionFuncPtr("glGetObjectParameterfvARB");
|
||||
_glGetObjectParameteriv = osg::getGLExtensionFuncPtr("glGetObjectParameterivARB");
|
||||
_glGetHandle = osg::getGLExtensionFuncPtr("glGetHandleARB");
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
// Static array of per-context osgGL2::Extensions instances
|
||||
|
||||
typedef osg::buffered_value< osg::ref_ptr<Extensions> > BufferedExtensions;
|
||||
static BufferedExtensions s_extensions;
|
||||
|
||||
Extensions* Extensions::Get(unsigned int contextID, bool createIfNotInitalized)
|
||||
{
|
||||
if (!s_extensions[contextID] && createIfNotInitalized)
|
||||
s_extensions[contextID] = new Extensions;
|
||||
|
||||
return s_extensions[contextID].get();
|
||||
}
|
||||
|
||||
void Extensions::Set(unsigned int contextID, Extensions* extensions)
|
||||
{
|
||||
s_extensions[contextID] = extensions;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
GLhandleARB Extensions::glCreateShaderObject(GLenum shaderType) const
|
||||
{
|
||||
if (_glCreateShaderObject)
|
||||
{
|
||||
typedef GLhandleARB (APIENTRY * CreateShaderObjectProc) (GLenum shaderType);
|
||||
return ((CreateShaderObjectProc)_glCreateShaderObject)(shaderType);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glCreateShaderObject not supported by OpenGL driver"<<std::endl;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
GLhandleARB Extensions::glCreateProgramObject() const
|
||||
{
|
||||
if (_glCreateProgramObject)
|
||||
{
|
||||
typedef GLhandleARB (APIENTRY * CreateProgramObjectProc) ();
|
||||
return ((CreateProgramObjectProc)_glCreateProgramObject)();
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glCreateProgramObject not supported by OpenGL driver"<<std::endl;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glDeleteObject(GLhandleARB obj) const
|
||||
{
|
||||
if (_glDeleteObject)
|
||||
{
|
||||
typedef void (APIENTRY * DeleteObjectProc) (GLhandleARB obj);
|
||||
((DeleteObjectProc)_glDeleteObject)(obj);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glDeleteObject not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glAttachObject(GLhandleARB containerObj, GLhandleARB obj) const
|
||||
{
|
||||
if (_glAttachObject)
|
||||
{
|
||||
typedef void (APIENTRY * AttachObjectProc) (GLhandleARB containerObj, GLhandleARB obj);
|
||||
((AttachObjectProc)_glAttachObject)(containerObj, obj);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glAttachObject not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glDetachObject(GLhandleARB containerObj, GLhandleARB attachedObj) const
|
||||
{
|
||||
if (_glDetachObject)
|
||||
{
|
||||
typedef void (APIENTRY * DetachObjectProc) (GLhandleARB containerObj, GLhandleARB attachedObj);
|
||||
((DetachObjectProc)_glDetachObject)(containerObj, attachedObj);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glDetachObject not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glShaderSource(GLhandleARB shaderObj, GLsizei count, const GLcharARB **strings, const GLint *length) const
|
||||
{
|
||||
if (_glShaderSource)
|
||||
{
|
||||
typedef void (APIENTRY * ShaderSourceProc) (GLhandleARB shaderObj, GLsizei count, const GLcharARB **strings, const GLint *length);
|
||||
((ShaderSourceProc)_glShaderSource)(shaderObj, count, strings, length);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glShaderSource not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glCompileShader(GLhandleARB shaderObj) const
|
||||
{
|
||||
if (_glCompileShader)
|
||||
{
|
||||
typedef void (APIENTRY * CompileShaderProc) (GLhandleARB shaderObj);
|
||||
((CompileShaderProc)_glCompileShader)(shaderObj);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glCompileShader not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glBindAttribLocation(GLhandleARB programObj, GLuint index, const GLcharARB *name) const
|
||||
{
|
||||
if (_glBindAttribLocation)
|
||||
{
|
||||
typedef void (APIENTRY * BindAttribLocationProc) (GLhandleARB programObj, GLuint index, const GLcharARB *name);
|
||||
((BindAttribLocationProc)_glBindAttribLocation)(programObj, index, name);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glBindAttribLocation not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glLinkProgram(GLhandleARB programObj) const
|
||||
{
|
||||
if (_glLinkProgram)
|
||||
{
|
||||
typedef void (APIENTRY * LinkProgramProc) (GLhandleARB programObj);
|
||||
((LinkProgramProc)_glLinkProgram)(programObj);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glLinkProgram not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUseProgramObject(GLhandleARB programObj) const
|
||||
{
|
||||
if (_glUseProgramObject)
|
||||
{
|
||||
typedef void (APIENTRY * UseProgramObjectProc) (GLhandleARB programObj);
|
||||
((UseProgramObjectProc)_glUseProgramObject)(programObj);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUseProgramObject not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glGetInfoLog(GLhandleARB obj,GLsizei maxLength, GLsizei *length, GLcharARB *infoLog) const
|
||||
{
|
||||
if (_glGetInfoLog)
|
||||
{
|
||||
typedef void (APIENTRY * GetInfoLogProc) (GLhandleARB obj,GLsizei maxLength, GLsizei *length, GLcharARB *infoLog);
|
||||
((GetInfoLogProc)_glGetInfoLog)(obj,maxLength, length, infoLog);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetInfoLog not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glGetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj) const
|
||||
{
|
||||
if (_glGetAttachedObjects)
|
||||
{
|
||||
typedef void (APIENTRY * GetAttachedObjectsProc) (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj);
|
||||
((GetAttachedObjectsProc)_glGetAttachedObjects)(containerObj, maxCount, count, obj);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetAttachedObjects not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glGetShaderSource(GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source) const
|
||||
{
|
||||
if (_glGetShaderSource)
|
||||
{
|
||||
typedef void (APIENTRY * GetShaderSourceProc) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source);
|
||||
((GetShaderSourceProc)_glGetShaderSource)(obj, maxLength, length, source);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetShaderSource not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform1f(GLint location, GLfloat v0) const
|
||||
{
|
||||
if (_glUniform1f)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform1fProc) (GLint location, GLfloat v0);
|
||||
((Uniform1fProc)_glUniform1f)(location, v0);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform1f not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform2f(GLint location, GLfloat v0, GLfloat v1) const
|
||||
{
|
||||
if (_glUniform2f)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform2fProc) (GLint location, GLfloat v0, GLfloat v1);
|
||||
((Uniform2fProc)_glUniform2f)(location, v0, v1);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform2f not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) const
|
||||
{
|
||||
if (_glUniform3f)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform3fProc) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
|
||||
((Uniform3fProc)_glUniform3f)(location, v0, v1, v2);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform3f not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) const
|
||||
{
|
||||
if (_glUniform4f)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform4fProc) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
|
||||
((Uniform4fProc)_glUniform4f)(location, v0, v1, v2, v3);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform4f not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform1i(GLint location, GLint v0) const
|
||||
{
|
||||
if (_glUniform1i)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform1iProc) (GLint location, GLint v0);
|
||||
((Uniform1iProc)_glUniform1i)(location, v0);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform1i not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform2i(GLint location, GLint v0, GLint v1) const
|
||||
{
|
||||
if (_glUniform2i)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform2iProc) (GLint location, GLint v0, GLint v1);
|
||||
((Uniform2iProc)_glUniform2i)(location, v0, v1);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform2i not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2) const
|
||||
{
|
||||
if (_glUniform3i)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform3iProc) (GLint location, GLint v0, GLint v1, GLint v2);
|
||||
((Uniform3iProc)_glUniform3i)(location, v0, v1, v2);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform3i not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) const
|
||||
{
|
||||
if (_glUniform4i)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform4iProc) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
|
||||
((Uniform4iProc)_glUniform4i)(location, v0, v1, v2, v3);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform4i not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform1fv(GLint location, GLsizei count, const GLfloat *value) const
|
||||
{
|
||||
if (_glUniform1fv)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform1fvProc) (GLint location, GLsizei count, const GLfloat *value);
|
||||
((Uniform1fvProc)_glUniform1fv)(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform1fv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform2fv(GLint location, GLsizei count, const GLfloat *value) const
|
||||
{
|
||||
if (_glUniform2fv)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform2fvProc) (GLint location, GLsizei count, const GLfloat *value);
|
||||
((Uniform2fvProc)_glUniform2fv)(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform2fv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform3fv(GLint location, GLsizei count, const GLfloat *value) const
|
||||
{
|
||||
if (_glUniform3fv)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform3fvProc) (GLint location, GLsizei count, const GLfloat *value);
|
||||
((Uniform3fvProc)_glUniform3fv)(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform3fv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform4fv(GLint location, GLsizei count, const GLfloat *value) const
|
||||
{
|
||||
if (_glUniform4fv)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform4fvProc) (GLint location, GLsizei count, const GLfloat *value);
|
||||
((Uniform4fvProc)_glUniform4fv)(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform4fv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform1iv(GLint location, GLsizei count, const GLint *value) const
|
||||
{
|
||||
if (_glUniform1iv)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform1ivProc) (GLint location, GLsizei count, const GLint *value);
|
||||
((Uniform1ivProc)_glUniform1iv)(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform1iv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform2iv(GLint location, GLsizei count, const GLint *value) const
|
||||
{
|
||||
if (_glUniform2iv)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform2ivProc) (GLint location, GLsizei count, const GLint *value);
|
||||
((Uniform2ivProc)_glUniform2iv)(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform2iv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform3iv(GLint location, GLsizei count, const GLint *value) const
|
||||
{
|
||||
if (_glUniform3iv)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform3ivProc) (GLint location, GLsizei count, const GLint *value);
|
||||
((Uniform3ivProc)_glUniform3iv)(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform3iv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniform4iv(GLint location, GLsizei count, const GLint *value) const
|
||||
{
|
||||
if (_glUniform4iv)
|
||||
{
|
||||
typedef void (APIENTRY * Uniform4ivProc) (GLint location, GLsizei count, const GLint *value);
|
||||
((Uniform4ivProc)_glUniform4iv)(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniform4iv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) const
|
||||
{
|
||||
if (_glUniformMatrix2fv)
|
||||
{
|
||||
typedef void (APIENTRY * UniformMatrix2fvProc) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
|
||||
((UniformMatrix2fvProc)_glUniformMatrix2fv)(location, count, transpose, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniformMatrix2fv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) const
|
||||
{
|
||||
if (_glUniformMatrix3fv)
|
||||
{
|
||||
typedef void (APIENTRY * UniformMatrix3fvProc) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
|
||||
((UniformMatrix3fvProc)_glUniformMatrix3fv)(location, count, transpose, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniformMatrix3fv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) const
|
||||
{
|
||||
if (_glUniformMatrix4fv)
|
||||
{
|
||||
typedef void (APIENTRY * UniformMatrix4fvProc) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
|
||||
((UniformMatrix4fvProc)_glUniformMatrix4fv)(location, count, transpose, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glUniformMatrix4fv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
GLint Extensions::glGetUniformLocation(GLhandleARB programObject, const GLcharARB *name) const
|
||||
{
|
||||
if (_glGetUniformLocation)
|
||||
{
|
||||
typedef GLint (APIENTRY * GetUniformLocationProc) (GLhandleARB programObject, const GLcharARB *name);
|
||||
return ((GetUniformLocationProc)_glGetUniformLocation)(programObject, name);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetUniformLocation not supported by OpenGL driver"<<std::endl;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
GLint Extensions::glGetAttribLocation(GLhandleARB programObj, const GLcharARB *name) const
|
||||
{
|
||||
if (_glGetAttribLocation)
|
||||
{
|
||||
typedef GLint (APIENTRY * GetAttribLocationProc) (GLhandleARB programObj, const GLcharARB *name);
|
||||
return ((GetAttribLocationProc)_glGetAttribLocation)(programObj, name);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetAttribLocation not supported by OpenGL driver"<<std::endl;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glGetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLint *type, GLcharARB *name) const
|
||||
{
|
||||
if (_glGetActiveUniform)
|
||||
{
|
||||
typedef void (APIENTRY * GetActiveUniformProc) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLint *type, GLcharARB *name);
|
||||
((GetActiveUniformProc)_glGetActiveUniform)(programObj, index, maxLength, length, size, type, name);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetActiveUniform not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glGetActiveAttribs(GLhandleARB programObj, GLint *count, const GLint **size, const GLenum **type, const GLcharARB* const **attributes) const
|
||||
{
|
||||
if (_glGetActiveAttribs)
|
||||
{
|
||||
typedef void (APIENTRY * GetActiveAttribsProc) (GLhandleARB programObj, GLint *count, const GLint **size, const GLenum **type, const GLcharARB* const **attributes);
|
||||
((GetActiveAttribsProc)_glGetActiveAttribs)(programObj, count, size, type, attributes);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetActiveAttribs not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glGetUniformfv(GLhandleARB programObj, GLint location, GLfloat *params) const
|
||||
{
|
||||
if (_glGetUniformfv)
|
||||
{
|
||||
typedef void (APIENTRY * GetUniformfvProc) (GLhandleARB programObj, GLint location, GLfloat *params);
|
||||
((GetUniformfvProc)_glGetUniformfv)(programObj, location, params);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetUniformfv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glGetUniformiv(GLhandleARB programObj, GLint location, GLint *params) const
|
||||
{
|
||||
if (_glGetUniformiv)
|
||||
{
|
||||
typedef void (APIENTRY * GetUniformivProc) (GLhandleARB programObj, GLint location, GLint *params);
|
||||
((GetUniformivProc)_glGetUniformiv)(programObj, location, params);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetUniformiv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glGetObjectParameterfv(GLhandleARB obj, GLenum pname, GLfloat *params) const
|
||||
{
|
||||
if (_glGetObjectParameterfv)
|
||||
{
|
||||
typedef void (APIENTRY * GetObjectParameterfvProc) (GLhandleARB obj, GLenum pname, GLfloat *params);
|
||||
((GetObjectParameterfvProc)_glGetObjectParameterfv)(obj, pname, params);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetObjectParameterfv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Extensions::glGetObjectParameteriv(GLhandleARB obj, GLenum pname, GLint *params) const
|
||||
{
|
||||
if (_glGetObjectParameteriv)
|
||||
{
|
||||
typedef void (APIENTRY * GetObjectParameterivProc) (GLhandleARB obj, GLenum pname, GLint *params);
|
||||
((GetObjectParameterivProc)_glGetObjectParameteriv)(obj, pname, params);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetObjectParameteriv not supported by OpenGL driver"<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
GLhandleARB Extensions::glGetHandle(GLenum pname) const
|
||||
{
|
||||
if (_glGetHandle)
|
||||
{
|
||||
typedef GLhandleARB (APIENTRY * GetHandleProc) (GLenum pname);
|
||||
return ((GetHandleProc)_glGetHandle)(pname);
|
||||
}
|
||||
else
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: glGetHandle not supported by OpenGL driver"<<std::endl;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
TOPDIR = ../..
|
||||
include $(TOPDIR)/Make/makedefs
|
||||
|
||||
|
||||
CXXFILES = \
|
||||
Extensions.cpp \
|
||||
Version.cpp \
|
||||
ProgramObject.cpp\
|
||||
UniformValue.cpp
|
||||
|
||||
|
||||
DEF += -DOSGGL2_LIBRARY
|
||||
|
||||
LIBS += -losg -losgUtil $(GL_LIBS) $(OTHER_LIBS)
|
||||
|
||||
TARGET_BASENAME = osgGL2
|
||||
LIB = $(LIB_PREFIX)$(TARGET_BASENAME).$(LIB_EXT)
|
||||
|
||||
include $(TOPDIR)/Make/makerules
|
||||
|
||||
|
||||
@@ -1,617 +0,0 @@
|
||||
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
|
||||
* Copyright (C) 2003-2004 3Dlabs Inc. Ltd.
|
||||
*
|
||||
* This application is open source and may be redistributed and/or modified
|
||||
* freely and without restriction, both in commericial and non commericial
|
||||
* 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: src/osgGL2/ProgramObject.cpp
|
||||
* author: Mike Weiblen 2005-03-21
|
||||
*
|
||||
* See http://www.3dlabs.com/opengl2/ for more information regarding
|
||||
* the OpenGL Shading Language.
|
||||
*/
|
||||
|
||||
#include <fstream>
|
||||
|
||||
#include <osg/Notify>
|
||||
#include <osg/State>
|
||||
#include <osg/Timer>
|
||||
#include <osg/FrameStamp>
|
||||
|
||||
#include <osgGL2/ProgramObject>
|
||||
#include <osgGL2/UniformValue>
|
||||
#include <osgGL2/Extensions>
|
||||
|
||||
#include <list>
|
||||
|
||||
#include <OpenThreads/ScopedLock>
|
||||
#include <OpenThreads/Mutex>
|
||||
|
||||
using namespace osgGL2;
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace {
|
||||
|
||||
class InfoLog
|
||||
{
|
||||
public:
|
||||
InfoLog( Extensions* ext, const GLhandleARB handle )
|
||||
{
|
||||
GLint blen = 0; // length of buffer to allocate
|
||||
GLint slen = 0; // strlen GL actually wrote to buffer
|
||||
|
||||
ext->glGetObjectParameteriv(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB , &blen);
|
||||
if (blen > 1)
|
||||
{
|
||||
GLcharARB* infoLog = new GLcharARB[blen];
|
||||
ext->glGetInfoLog( handle, blen, &slen, infoLog );
|
||||
_text = infoLog;
|
||||
delete [] infoLog;
|
||||
}
|
||||
}
|
||||
|
||||
friend std::ostream& operator<< ( std::ostream& o, const InfoLog& log )
|
||||
{
|
||||
return o << log._text;
|
||||
}
|
||||
|
||||
private:
|
||||
InfoLog();
|
||||
std::string _text;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// static cache of deleted GL2 objects which may only
|
||||
// by actually deleted in the correct GL context.
|
||||
|
||||
typedef std::list<GLhandleARB> GL2ObjectList;
|
||||
typedef std::map<unsigned int, GL2ObjectList> DeletedGL2ObjectCache;
|
||||
|
||||
static OpenThreads::Mutex s_mutex_deletedGL2ObjectCache;
|
||||
static DeletedGL2ObjectCache s_deletedGL2ObjectCache;
|
||||
|
||||
void ProgramObject::deleteObject(unsigned int contextID, GLhandleARB handle)
|
||||
{
|
||||
if (handle!=0)
|
||||
{
|
||||
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_mutex_deletedGL2ObjectCache);
|
||||
|
||||
// add handle to the cache for the appropriate context.
|
||||
s_deletedGL2ObjectCache[contextID].push_back(handle);
|
||||
}
|
||||
}
|
||||
|
||||
void ProgramObject::flushDeletedGL2Objects(unsigned int contextID,double /*currentTime*/, double& availableTime)
|
||||
{
|
||||
// if no time available don't try to flush objects.
|
||||
if (availableTime<=0.0) return;
|
||||
|
||||
const osg::Timer& timer = *osg::Timer::instance();
|
||||
osg::Timer_t start_tick = timer.tick();
|
||||
double elapsedTime = 0.0;
|
||||
|
||||
{
|
||||
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_mutex_deletedGL2ObjectCache);
|
||||
|
||||
DeletedGL2ObjectCache::iterator citr = s_deletedGL2ObjectCache.find(contextID);
|
||||
if( citr != s_deletedGL2ObjectCache.end() )
|
||||
{
|
||||
const Extensions* extensions = Extensions::Get(contextID,true);
|
||||
|
||||
if (!extensions->isGlslSupported())
|
||||
{
|
||||
// can we really get here?
|
||||
osg::notify(osg::WARN) << "flushDeletedGL2Objects not supported by OpenGL driver" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
GL2ObjectList& vpObjectList = citr->second;
|
||||
|
||||
for(GL2ObjectList::iterator titr=vpObjectList.begin();
|
||||
titr!=vpObjectList.end() && elapsedTime<availableTime;
|
||||
)
|
||||
{
|
||||
extensions->glDeleteObject( *titr );
|
||||
titr = vpObjectList.erase( titr );
|
||||
elapsedTime = timer.delta_s(start_tick,timer.tick());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
availableTime -= elapsedTime;
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// osgGL2::ProgramObject
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
ProgramObject::ProgramObject()
|
||||
{
|
||||
// To ensure all PCPOs consistently get the same values, we must
|
||||
// postpone updates until all PCPOs have been created.
|
||||
// They are created during ProgramObject::apply(), so let a frame
|
||||
// go by before sending the updates.
|
||||
_frameNumberOfLastPCPOUpdate = 1;
|
||||
_enabled = true;
|
||||
}
|
||||
|
||||
|
||||
ProgramObject::ProgramObject(const ProgramObject& rhs, const osg::CopyOp& copyop):
|
||||
osg::StateAttribute(rhs, copyop)
|
||||
{
|
||||
osg::notify(osg::FATAL) << "how got here?" << std::endl;
|
||||
}
|
||||
|
||||
|
||||
// virtual
|
||||
ProgramObject::~ProgramObject()
|
||||
{
|
||||
for( unsigned int cxt=0; cxt < _pcpoList.size(); ++cxt )
|
||||
{
|
||||
if( ! _pcpoList[cxt] ) continue;
|
||||
|
||||
PerContextProgObj* pcpo = _pcpoList[cxt].get();
|
||||
|
||||
deleteObject( cxt, pcpo->getHandle() );
|
||||
// TODO add shader objects to delete list.
|
||||
_pcpoList[cxt] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int ProgramObject::compare(const osg::StateAttribute& sa) const
|
||||
{
|
||||
// check the types are equal and then create the rhs variable
|
||||
// used by the COMPARE_StateAttribute_Paramter macro's below.
|
||||
COMPARE_StateAttribute_Types(ProgramObject,sa)
|
||||
|
||||
if (_shaderObjectList.size()<rhs._shaderObjectList.size()) return -1;
|
||||
if (_shaderObjectList.size()>rhs._shaderObjectList.size()) return 1;
|
||||
|
||||
ShaderObjectList::const_iterator litr=_shaderObjectList.begin();
|
||||
ShaderObjectList::const_iterator ritr=rhs._shaderObjectList.begin();
|
||||
for(;
|
||||
litr!=_shaderObjectList.end();
|
||||
++litr,++ritr)
|
||||
{
|
||||
int result = (*litr)->compare(*(*ritr));
|
||||
if (result!=0) return result;
|
||||
}
|
||||
|
||||
|
||||
if (_univalList.size()<rhs._univalList.size()) return -1;
|
||||
if (_univalList.size()>rhs._univalList.size()) return 1;
|
||||
|
||||
UniformValueList::const_iterator luitr=_univalList.begin();
|
||||
UniformValueList::const_iterator ruitr=rhs._univalList.begin();
|
||||
for(;
|
||||
luitr!=_univalList.end();
|
||||
++luitr,++ruitr)
|
||||
{
|
||||
int result = (*luitr)->compare(*(*ruitr));
|
||||
if (result!=0) return result;
|
||||
}
|
||||
|
||||
return 0; // passed all the above comparison macro's, must be equal.
|
||||
}
|
||||
|
||||
|
||||
void ProgramObject::compileGLObjects(osg::State&) const
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
// mark all PCPOs as needing a relink
|
||||
void ProgramObject::dirtyProgramObject()
|
||||
{
|
||||
for( unsigned int cxt=0; cxt < _pcpoList.size(); ++cxt )
|
||||
{
|
||||
if( ! _pcpoList[cxt] ) continue;
|
||||
|
||||
PerContextProgObj* pcpo = _pcpoList[cxt].get();
|
||||
pcpo->markAsDirty();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// mark all attached ShaderObjects as needing a rebuild
|
||||
void ProgramObject::dirtyShaderObjects()
|
||||
{
|
||||
for( unsigned int i=0; i < _shaderObjectList.size() ; ++i )
|
||||
{
|
||||
_shaderObjectList[i]->dirtyShaderObject();
|
||||
}
|
||||
}
|
||||
|
||||
void ProgramObject::releaseGLObjects(osg::State* state) const
|
||||
{
|
||||
|
||||
if (!state) const_cast<ProgramObject*>(this)->dirtyShaderObjects();
|
||||
else
|
||||
{
|
||||
unsigned int contextID = state->getContextID();
|
||||
const_cast<ProgramObject*>(this)->_shaderObjectList[contextID]->dirtyShaderObject();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void ProgramObject::addShader( ShaderObject* shadObj )
|
||||
{
|
||||
_shaderObjectList.push_back( shadObj );
|
||||
shadObj->addProgObjRef( this );
|
||||
dirtyProgramObject();
|
||||
}
|
||||
|
||||
|
||||
void ProgramObject::setUniform( const char* uniformName, int value )
|
||||
{
|
||||
_univalList.push_back( new UniformValue_int( uniformName, value ) );
|
||||
}
|
||||
|
||||
void ProgramObject::setUniform( const char* uniformName, float value )
|
||||
{
|
||||
_univalList.push_back( new UniformValue_float( uniformName, value ) );
|
||||
}
|
||||
|
||||
void ProgramObject::setUniform( const char* uniformName, osg::Vec2 value )
|
||||
{
|
||||
_univalList.push_back( new UniformValue_Vec2( uniformName, value ) );
|
||||
}
|
||||
|
||||
void ProgramObject::setUniform( const char* uniformName, osg::Vec3 value )
|
||||
{
|
||||
_univalList.push_back( new UniformValue_Vec3( uniformName, value ) );
|
||||
}
|
||||
|
||||
void ProgramObject::setUniform( const char* uniformName, osg::Vec4 value )
|
||||
{
|
||||
_univalList.push_back( new UniformValue_Vec4( uniformName, value ) );
|
||||
}
|
||||
|
||||
|
||||
void ProgramObject::apply(osg::State& state) const
|
||||
{
|
||||
const unsigned int contextID = state.getContextID();
|
||||
const Extensions* extensions = Extensions::Get(contextID,true);
|
||||
|
||||
// if there are no ShaderObjects on this ProgramObject,
|
||||
// use GL 1.x "fixed functionality" rendering.
|
||||
if( !_enabled || _shaderObjectList.empty() )
|
||||
{
|
||||
if( extensions->isGlslSupported() )
|
||||
{
|
||||
extensions->glUseProgramObject( 0 );
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if( ! extensions->isGlslSupported() )
|
||||
{
|
||||
osg::notify(osg::WARN) << "GLSL not supported by OpenGL driver" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
const osg::FrameStamp* frameStamp = state.getFrameStamp();
|
||||
const int frameNumber = (frameStamp) ? frameStamp->getFrameNumber() : -1;
|
||||
|
||||
PerContextProgObj* pcpo = getPCPO( contextID );
|
||||
|
||||
if( pcpo->isDirty() )
|
||||
{
|
||||
for( unsigned int i=0; i < _shaderObjectList.size() ; ++i )
|
||||
{
|
||||
_shaderObjectList[i]->build( contextID );
|
||||
}
|
||||
pcpo->build();
|
||||
}
|
||||
|
||||
updateUniforms( frameNumber );
|
||||
|
||||
// make this glProgramObject part of current GL state
|
||||
pcpo->use();
|
||||
|
||||
// consume any pending setUniform messages
|
||||
pcpo->applyUniformValues();
|
||||
}
|
||||
|
||||
|
||||
ProgramObject::PerContextProgObj* ProgramObject::getPCPO(unsigned int contextID) const
|
||||
{
|
||||
if( ! _pcpoList[contextID].valid() )
|
||||
{
|
||||
_pcpoList[contextID] = new PerContextProgObj( this, contextID );
|
||||
|
||||
// attach all PCSOs to this new PCPO
|
||||
for( unsigned int i=0; i < _shaderObjectList.size() ; ++i )
|
||||
{
|
||||
_shaderObjectList[i]->attach( contextID, _pcpoList[contextID]->getHandle() );
|
||||
}
|
||||
}
|
||||
return _pcpoList[contextID].get();
|
||||
}
|
||||
|
||||
|
||||
void ProgramObject::updateUniforms( int frameNumber ) const
|
||||
{
|
||||
if( frameNumber <= _frameNumberOfLastPCPOUpdate )
|
||||
return;
|
||||
|
||||
_frameNumberOfLastPCPOUpdate = frameNumber;
|
||||
|
||||
if( _univalList.empty() )
|
||||
return;
|
||||
|
||||
for( unsigned int cxt=0; cxt < _pcpoList.size(); ++cxt )
|
||||
{
|
||||
if( ! _pcpoList[cxt] ) continue;
|
||||
|
||||
PerContextProgObj* pcpo = _pcpoList[cxt].get();
|
||||
pcpo->updateUniforms( _univalList );
|
||||
}
|
||||
_univalList.clear();
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// PCPO : OSG abstraction of the per-context Program Object
|
||||
|
||||
ProgramObject::PerContextProgObj::PerContextProgObj(const ProgramObject* progObj, unsigned int contextID ) :
|
||||
osg::Referenced(),
|
||||
_contextID( contextID )
|
||||
{
|
||||
_progObj = progObj;
|
||||
_extensions = Extensions::Get( _contextID, true );
|
||||
_glProgObjHandle = _extensions->glCreateProgramObject();
|
||||
markAsDirty();
|
||||
}
|
||||
|
||||
ProgramObject::PerContextProgObj::PerContextProgObj(const PerContextProgObj& rhs) :
|
||||
osg::Referenced(),
|
||||
_contextID( rhs._contextID )
|
||||
{
|
||||
_progObj = rhs._progObj;
|
||||
_extensions = rhs._extensions;
|
||||
_glProgObjHandle = rhs._glProgObjHandle ;
|
||||
_dirty = rhs._dirty;
|
||||
}
|
||||
|
||||
ProgramObject::PerContextProgObj::~PerContextProgObj()
|
||||
{
|
||||
}
|
||||
|
||||
void ProgramObject::PerContextProgObj::build()
|
||||
{
|
||||
GLint linked;
|
||||
|
||||
_extensions->glLinkProgram( _glProgObjHandle );
|
||||
_extensions->glGetObjectParameteriv(_glProgObjHandle,
|
||||
GL_OBJECT_LINK_STATUS_ARB, &linked);
|
||||
|
||||
_dirty = (linked == 0);
|
||||
if( _dirty )
|
||||
{
|
||||
InfoLog log( _extensions.get(), _glProgObjHandle );
|
||||
osg::notify(osg::WARN) << "glLinkProgram FAILED:\n" << log << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void ProgramObject::PerContextProgObj::use() const
|
||||
{
|
||||
_extensions->glUseProgramObject( _glProgObjHandle );
|
||||
}
|
||||
|
||||
void ProgramObject::PerContextProgObj::updateUniforms( const UniformValueList& univalList )
|
||||
{
|
||||
// TODO: should the incoming list be appended rather than assigned?
|
||||
_univalList = univalList;
|
||||
}
|
||||
|
||||
void ProgramObject::PerContextProgObj::applyUniformValues()
|
||||
{
|
||||
Extensions *ext = _extensions.get();
|
||||
for( unsigned int i=0; i < _univalList.size() ; ++i )
|
||||
{
|
||||
_univalList[i]->apply( ext, _glProgObjHandle );
|
||||
}
|
||||
_univalList.clear();
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// osgGL2::ShaderObject
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
ShaderObject::ShaderObject() :
|
||||
_type(UNKNOWN)
|
||||
{
|
||||
}
|
||||
|
||||
ShaderObject::ShaderObject(Type type) :
|
||||
_type(type)
|
||||
{
|
||||
}
|
||||
|
||||
ShaderObject::ShaderObject(Type type, const char* sourceText) :
|
||||
_type(type)
|
||||
{
|
||||
setShaderSource(sourceText);
|
||||
}
|
||||
|
||||
ShaderObject::ShaderObject(const ShaderObject& rhs, const osg::CopyOp& copyop):
|
||||
osg::Object(rhs, copyop)
|
||||
{
|
||||
/*TODO*/
|
||||
}
|
||||
|
||||
ShaderObject::~ShaderObject()
|
||||
{
|
||||
/*TODO*/
|
||||
}
|
||||
|
||||
int ShaderObject::compare(const ShaderObject& so) const
|
||||
{
|
||||
if (getShaderSource()<so.getShaderSource()) return -1;
|
||||
if (so.getShaderSource()<getShaderSource()) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// mark each PCSO (per-context Shader Object) as needing a recompile
|
||||
void ShaderObject::dirtyShaderObject()
|
||||
{
|
||||
for( unsigned int cxt=0; cxt < _pcsoList.size(); ++cxt )
|
||||
{
|
||||
if( ! _pcsoList[cxt] ) continue;
|
||||
|
||||
PerContextShaderObj* pcso = _pcsoList[cxt].get();
|
||||
pcso->markAsDirty();
|
||||
}
|
||||
|
||||
// mark attached ProgramObjects dirty as well
|
||||
for( unsigned int i=0; i < _programObjectList.size(); ++i )
|
||||
{
|
||||
_programObjectList[i]->dirtyProgramObject();
|
||||
}
|
||||
}
|
||||
|
||||
void ShaderObject::setShaderSource( const char* sourceText )
|
||||
{
|
||||
_shaderSource = sourceText;
|
||||
dirtyShaderObject();
|
||||
}
|
||||
|
||||
bool ShaderObject::loadShaderSourceFromFile( const char* fileName )
|
||||
{
|
||||
std::ifstream sourceFile;
|
||||
|
||||
sourceFile.open(fileName, std::ios::binary);
|
||||
if(!sourceFile)
|
||||
{
|
||||
osg::notify(osg::WARN)<<"Error: can't open file \""<<fileName<<"\""<<std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
osg::notify(osg::INFO)<<"Loading shader source file \""<<fileName<<"\""<<std::endl;
|
||||
|
||||
sourceFile.seekg(0, std::ios::end);
|
||||
int length = sourceFile.tellg();
|
||||
char *text = new char[length + 1];
|
||||
sourceFile.seekg(0, std::ios::beg);
|
||||
sourceFile.read(text, length);
|
||||
sourceFile.close();
|
||||
text[length] = '\0';
|
||||
|
||||
setShaderSource( text );
|
||||
delete [] text;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
const char* ShaderObject::getTypename() const
|
||||
{
|
||||
switch( getType() )
|
||||
{
|
||||
case VERTEX: return "Vertex";
|
||||
case FRAGMENT: return "Fragment";
|
||||
default: return "UNKNOWN";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void ShaderObject::build(unsigned int contextID ) const
|
||||
{
|
||||
PerContextShaderObj* pcso = getPCSO( contextID );
|
||||
|
||||
if( pcso->isDirty() )
|
||||
{
|
||||
pcso->build();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ShaderObject::PerContextShaderObj* ShaderObject::getPCSO(unsigned int contextID) const
|
||||
{
|
||||
if( ! _pcsoList[contextID].valid() )
|
||||
{
|
||||
_pcsoList[contextID] = new PerContextShaderObj( this, contextID );
|
||||
}
|
||||
return _pcsoList[contextID].get();
|
||||
}
|
||||
|
||||
|
||||
void ShaderObject::attach(unsigned int contextID, GLhandleARB progObj) const
|
||||
{
|
||||
getPCSO( contextID )->attach( progObj );
|
||||
}
|
||||
|
||||
|
||||
void ShaderObject::addProgObjRef( ProgramObject* progObj )
|
||||
{
|
||||
_programObjectList.push_back( progObj );
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// PCSO : OSG abstraction of the per-context Shader Object
|
||||
|
||||
ShaderObject::PerContextShaderObj::PerContextShaderObj(const ShaderObject* shadObj, unsigned int contextID) :
|
||||
osg::Referenced(),
|
||||
_contextID( contextID )
|
||||
{
|
||||
_shadObj = shadObj;
|
||||
_extensions = Extensions::Get( _contextID, true );
|
||||
_glShaderObjHandle = _extensions->glCreateShaderObject( shadObj->getType() );
|
||||
markAsDirty();
|
||||
}
|
||||
|
||||
ShaderObject::PerContextShaderObj::PerContextShaderObj(const PerContextShaderObj& rhs) :
|
||||
osg::Referenced(),
|
||||
_contextID( rhs._contextID )
|
||||
{
|
||||
_shadObj = rhs._shadObj;
|
||||
_extensions = rhs._extensions;
|
||||
_glShaderObjHandle = rhs._glShaderObjHandle;
|
||||
_dirty = rhs._dirty;
|
||||
}
|
||||
|
||||
ShaderObject::PerContextShaderObj::~PerContextShaderObj()
|
||||
{
|
||||
}
|
||||
|
||||
void ShaderObject::PerContextShaderObj::build()
|
||||
{
|
||||
GLint compiled;
|
||||
const char* sourceText = _shadObj->getShaderSource().c_str();
|
||||
|
||||
_extensions->glShaderSource( _glShaderObjHandle, 1, &sourceText, NULL );
|
||||
_extensions->glCompileShader( _glShaderObjHandle );
|
||||
_extensions->glGetObjectParameteriv(_glShaderObjHandle,
|
||||
GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
|
||||
|
||||
_dirty = (compiled == 0);
|
||||
if( _dirty )
|
||||
{
|
||||
InfoLog log( _extensions.get(), _glShaderObjHandle );
|
||||
osg::notify(osg::WARN) << _shadObj->getTypename() <<
|
||||
" glCompileShader FAILED:\n" << log << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void ShaderObject::PerContextShaderObj::attach(GLhandleARB progObj) const
|
||||
{
|
||||
_extensions->glAttachObject( progObj, _glShaderObjHandle );
|
||||
}
|
||||
|
||||
/*EOF*/
|
||||
@@ -1,108 +0,0 @@
|
||||
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2005 Robert Osfield
|
||||
* Copyright (C) 2003 3Dlabs Inc. Ltd.
|
||||
*
|
||||
* This application is open source and may be redistributed and/or modified
|
||||
* freely and without restriction, both in commericial and non commericial
|
||||
* 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: src/osgGL2/UniformValue
|
||||
* author: Mike Weiblen 2003-12-27
|
||||
*
|
||||
* See http://www.3dlabs.com/opengl2/ for more information regarding
|
||||
* the OpenGL Shading Language.
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <osg/Notify>
|
||||
#include <osgGL2/UniformValue>
|
||||
|
||||
using namespace osgGL2;
|
||||
using namespace osg;
|
||||
|
||||
int UniformValue::compare(const UniformValue& uv) const
|
||||
{
|
||||
if (_name<uv._name) return -1;
|
||||
if (uv._name<_name) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int UniformValue::getLocation( Extensions *ext, const GLhandleARB progObj ) const
|
||||
{
|
||||
GLint loc = ext->glGetUniformLocation( progObj, _name.c_str() );
|
||||
if( loc == -1 )
|
||||
{
|
||||
osg::notify(osg::INFO) << "Uniform \"" << _name <<
|
||||
"\" not found in ProgramObject" << std::endl;
|
||||
}
|
||||
return loc;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef sgi
|
||||
template <>
|
||||
#endif
|
||||
void UniformValue_int::apply( Extensions *ext, const GLhandleARB progObj ) const
|
||||
{
|
||||
int loc = getLocation( ext, progObj );
|
||||
if( loc != -1 )
|
||||
{
|
||||
ext->glUniform1i( loc, _value );
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef sgi
|
||||
template <>
|
||||
#endif
|
||||
void UniformValue_float::apply( Extensions *ext, const GLhandleARB progObj ) const
|
||||
{
|
||||
int loc = getLocation( ext, progObj );
|
||||
if( loc != -1 )
|
||||
{
|
||||
ext->glUniform1f( loc, _value );
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef sgi
|
||||
template <>
|
||||
#endif
|
||||
void UniformValue_Vec2::apply( Extensions *ext, const GLhandleARB progObj ) const
|
||||
{
|
||||
int loc = getLocation( ext, progObj );
|
||||
if( loc != -1 )
|
||||
{
|
||||
ext->glUniform2fv( loc, 1, _value.ptr() );
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef sgi
|
||||
template <>
|
||||
#endif
|
||||
void UniformValue_Vec3::apply( Extensions *ext, const GLhandleARB progObj ) const
|
||||
{
|
||||
int loc = getLocation( ext, progObj );
|
||||
if( loc != -1 )
|
||||
{
|
||||
ext->glUniform3fv( loc, 1, _value.ptr() );
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef sgi
|
||||
template <>
|
||||
#endif
|
||||
void UniformValue_Vec4::apply( Extensions *ext, const GLhandleARB progObj ) const
|
||||
{
|
||||
int loc = getLocation( ext, progObj );
|
||||
if( loc != -1 )
|
||||
{
|
||||
ext->glUniform4fv( loc, 1, _value.ptr() );
|
||||
}
|
||||
}
|
||||
|
||||
/*EOF*/
|
||||
@@ -1,13 +0,0 @@
|
||||
#include <osgGL2/Version>
|
||||
|
||||
const char* osgGL2GetVersion()
|
||||
{
|
||||
return "0.9.8";
|
||||
}
|
||||
|
||||
|
||||
const char* osgGL2GetLibraryName()
|
||||
{
|
||||
return "OpenSceneGraph OpenGL Shading Language Library";
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user