From David Callu, "Here an update of osg::Uniform :
- add non square matrix - add double - add all uniform type available in OpenGL 4.2 - backward compatibility for Matrixd to set/get an float uniform matrix - update of IVE / Wrapper ReadWriter implementation of AtomicCounterBuffer based on BufferIndexBinding add example that use AtomicCounterBuffer and show rendering order of fragments, original idea from geeks3d.com."
This commit is contained in:
Robert Osfield
@@ -1,5 +1,6 @@
|
||||
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
|
||||
* Copyright (C) 2010 Tim Moore
|
||||
* Copyright (C) 2012 David Callu
|
||||
*
|
||||
* This library is open source and may be redistributed and/or modified under
|
||||
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
||||
@@ -15,6 +16,9 @@
|
||||
#include <osg/BufferIndexBinding>
|
||||
#include <osg/State>
|
||||
|
||||
#include <string.h> // for memcpy
|
||||
|
||||
|
||||
namespace osg {
|
||||
|
||||
BufferIndexBinding::BufferIndexBinding(GLenum target, GLuint index)
|
||||
@@ -95,4 +99,48 @@ TransformFeedbackBufferBinding::TransformFeedbackBufferBinding(const TransformFe
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
AtomicCounterBufferBinding::AtomicCounterBufferBinding(GLuint index)
|
||||
: BufferIndexBinding(GL_ATOMIC_COUNTER_BUFFER, index)
|
||||
{
|
||||
}
|
||||
|
||||
AtomicCounterBufferBinding::AtomicCounterBufferBinding(GLuint index, BufferObject* bo, GLintptr offset, GLsizeiptr size)
|
||||
: BufferIndexBinding(GL_ATOMIC_COUNTER_BUFFER, index, bo, offset, size)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
AtomicCounterBufferBinding::AtomicCounterBufferBinding(const AtomicCounterBufferBinding& rhs, const CopyOp& copyop)
|
||||
: BufferIndexBinding(rhs, copyop)
|
||||
{
|
||||
}
|
||||
|
||||
void AtomicCounterBufferBinding::readData(osg::State & state, osg::UIntArray & uintArray) const
|
||||
{
|
||||
if (!_bufferObject) return;
|
||||
|
||||
GLBufferObject* bo = _bufferObject->getOrCreateGLBufferObject( state.getContextID() );
|
||||
if (!bo) return;
|
||||
|
||||
|
||||
GLint previousID = 0;
|
||||
glGetIntegerv(GL_ATOMIC_COUNTER_BUFFER_BINDING, &previousID);
|
||||
|
||||
if (static_cast<GLuint>(previousID) != bo->getGLObjectID())
|
||||
bo->_extensions->glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bo->getGLObjectID());
|
||||
|
||||
GLubyte* src = (GLubyte*)bo->_extensions->glMapBuffer(GL_ATOMIC_COUNTER_BUFFER,
|
||||
GL_READ_ONLY_ARB);
|
||||
if(src)
|
||||
{
|
||||
size_t size = osg::minimum<int>(_size, uintArray.getTotalDataSize());
|
||||
memcpy((void*) &(uintArray.front()), src+_offset, size);
|
||||
bo->_extensions->glUnmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
|
||||
}
|
||||
|
||||
if (static_cast<GLuint>(previousID) != bo->getGLObjectID())
|
||||
bo->_extensions->glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, static_cast<GLuint>(previousID));
|
||||
}
|
||||
|
||||
} // namespace osg
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
|
||||
* Copyright (C) 2012 David Callu
|
||||
*
|
||||
* This library is open source and may be redistributed and/or modified under
|
||||
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
||||
@@ -1668,6 +1669,11 @@ void PixelDataBufferObject::resizeGLObjectBuffers(unsigned int maxSize)
|
||||
_mode.resize(maxSize);
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// UniformBufferObject
|
||||
//
|
||||
UniformBufferObject::UniformBufferObject()
|
||||
{
|
||||
setTarget(GL_UNIFORM_BUFFER);
|
||||
@@ -1682,3 +1688,24 @@ UniformBufferObject::UniformBufferObject(const UniformBufferObject& ubo, const C
|
||||
UniformBufferObject::~UniformBufferObject()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// AtomicCounterBufferObject
|
||||
//
|
||||
AtomicCounterBufferObject::AtomicCounterBufferObject()
|
||||
{
|
||||
setTarget(GL_ATOMIC_COUNTER_BUFFER);
|
||||
setUsage(GL_DYNAMIC_DRAW);
|
||||
}
|
||||
|
||||
AtomicCounterBufferObject::AtomicCounterBufferObject(const AtomicCounterBufferObject& ubo, const CopyOp& copyop)
|
||||
: BufferObject(ubo, copyop)
|
||||
{
|
||||
}
|
||||
|
||||
AtomicCounterBufferObject::~AtomicCounterBufferObject()
|
||||
{
|
||||
}
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
* Copyright (C) 2003-2005 3Dlabs Inc. Ltd.
|
||||
* Copyright (C) 2004-2005 Nathan Cournia
|
||||
* Copyright (C) 2008 Zebra Imaging
|
||||
* Copyright (C) 2012 David Callu
|
||||
*
|
||||
* This application is open source and may be redistributed and/or modified
|
||||
* freely and without restriction, both in commercial and non commercial
|
||||
@@ -46,9 +47,12 @@ GL2Extensions::GL2Extensions(const GL2Extensions& rhs) : osg::Referenced()
|
||||
_isFragmentShaderSupported = rhs._isFragmentShaderSupported;
|
||||
_isLanguage100Supported = rhs._isLanguage100Supported;
|
||||
_isGeometryShader4Supported = rhs._isGeometryShader4Supported;
|
||||
_areTessellationShadersSupported = rhs._areTessellationShadersSupported;
|
||||
_isGpuShader4Supported = rhs._isGpuShader4Supported;
|
||||
_isUniformBufferObjectSupported = rhs._isUniformBufferObjectSupported;
|
||||
_isGetProgramBinarySupported = rhs._isGetProgramBinarySupported;
|
||||
_isGpuShaderFp64Supported = rhs._isGpuShaderFp64Supported;
|
||||
_isShaderAtomicCountersSupported = rhs._isShaderAtomicCountersSupported;
|
||||
|
||||
_glBlendEquationSeparate = rhs._glBlendEquationSeparate;
|
||||
_glDrawBuffers = rhs._glDrawBuffers;
|
||||
@@ -189,7 +193,27 @@ GL2Extensions::GL2Extensions(const GL2Extensions& rhs) : osg::Referenced()
|
||||
_glGetProgramBinary = rhs._glGetProgramBinary;
|
||||
_glProgramBinary = rhs._glProgramBinary;
|
||||
|
||||
_areTessellationShadersSupported = rhs._areTessellationShadersSupported;
|
||||
// ARB_gpu_shader_fp64
|
||||
_glUniform1d = rhs._glUniform1d;
|
||||
_glUniform2d = rhs._glUniform2d;
|
||||
_glUniform3d = rhs._glUniform3d;
|
||||
_glUniform4d = rhs._glUniform4d;
|
||||
_glUniform1dv = rhs._glUniform1dv;
|
||||
_glUniform2dv = rhs._glUniform2dv;
|
||||
_glUniform3dv = rhs._glUniform3dv;
|
||||
_glUniform4dv = rhs._glUniform4dv;
|
||||
_glUniformMatrix2dv = rhs._glUniformMatrix2dv;
|
||||
_glUniformMatrix3dv = rhs._glUniformMatrix3dv;
|
||||
_glUniformMatrix4dv = rhs._glUniformMatrix4dv;
|
||||
_glUniformMatrix2x3dv = rhs._glUniformMatrix2x3dv;
|
||||
_glUniformMatrix3x2dv = rhs._glUniformMatrix3x2dv;
|
||||
_glUniformMatrix2x4dv = rhs._glUniformMatrix2x4dv;
|
||||
_glUniformMatrix4x2dv = rhs._glUniformMatrix4x2dv;
|
||||
_glUniformMatrix3x4dv = rhs._glUniformMatrix3x4dv;
|
||||
_glUniformMatrix4x3dv = rhs._glUniformMatrix4x3dv;
|
||||
|
||||
// ARB_shader_atomic_counters
|
||||
_glGetActiveAtomicCounterBufferiv = rhs._glGetActiveAtomicCounterBufferiv;
|
||||
}
|
||||
|
||||
|
||||
@@ -204,7 +228,12 @@ void GL2Extensions::lowestCommonDenominator(const GL2Extensions& rhs)
|
||||
if (!rhs._isFragmentShaderSupported) _isFragmentShaderSupported = false;
|
||||
if (!rhs._isLanguage100Supported) _isLanguage100Supported = false;
|
||||
if (!rhs._isGeometryShader4Supported) _isGeometryShader4Supported = false;
|
||||
if (!rhs._areTessellationShadersSupported) _areTessellationShadersSupported = false;
|
||||
if (!rhs._isGpuShader4Supported) _isGpuShader4Supported = false;
|
||||
if (!rhs._isUniformBufferObjectSupported) _isUniformBufferObjectSupported = false;
|
||||
if (!rhs._isGetProgramBinarySupported) _isGetProgramBinarySupported = false;
|
||||
if (!rhs._isGpuShaderFp64Supported) _isGpuShaderFp64Supported = false;
|
||||
if (!rhs._isShaderAtomicCountersSupported) _isShaderAtomicCountersSupported = false;
|
||||
|
||||
if (!rhs._glBlendEquationSeparate) _glBlendEquationSeparate = 0;
|
||||
if (!rhs._glDrawBuffers) _glDrawBuffers = 0;
|
||||
@@ -348,6 +377,28 @@ void GL2Extensions::lowestCommonDenominator(const GL2Extensions& rhs)
|
||||
// ARB_get_program_binary
|
||||
if (!rhs._glGetProgramBinary) _glGetProgramBinary = 0;
|
||||
if (!rhs._glProgramBinary) _glProgramBinary = 0;
|
||||
|
||||
// ARB_gpu_shader_fp64
|
||||
if(!rhs._glUniform1d) _glUniform1d = 0;
|
||||
if(!rhs._glUniform2d) _glUniform2d = 0;
|
||||
if(!rhs._glUniform3d) _glUniform3d = 0;
|
||||
if(!rhs._glUniform4d) _glUniform4d = 0;
|
||||
if(!rhs._glUniform1dv) _glUniform1dv = 0;
|
||||
if(!rhs._glUniform2dv) _glUniform2dv = 0;
|
||||
if(!rhs._glUniform3dv) _glUniform3dv = 0;
|
||||
if(!rhs._glUniform4dv) _glUniform4dv = 0;
|
||||
if(!rhs._glUniformMatrix2dv) _glUniformMatrix2dv = 0;
|
||||
if(!rhs._glUniformMatrix3dv) _glUniformMatrix3dv = 0;
|
||||
if(!rhs._glUniformMatrix4dv) _glUniformMatrix4dv = 0;
|
||||
if(!rhs._glUniformMatrix2x3dv) _glUniformMatrix2x3dv = 0;
|
||||
if(!rhs._glUniformMatrix3x2dv) _glUniformMatrix3x2dv = 0;
|
||||
if(!rhs._glUniformMatrix2x4dv) _glUniformMatrix2x4dv = 0;
|
||||
if(!rhs._glUniformMatrix4x2dv) _glUniformMatrix4x2dv = 0;
|
||||
if(!rhs._glUniformMatrix3x4dv) _glUniformMatrix3x4dv = 0;
|
||||
if(!rhs._glUniformMatrix4x3dv) _glUniformMatrix4x3dv = 0;
|
||||
|
||||
// ARB_shader_atomic_counters
|
||||
if(!rhs._glGetActiveAtomicCounterBufferiv) _glGetActiveAtomicCounterBufferiv = 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -370,6 +421,8 @@ void GL2Extensions::setupGL2Extensions(unsigned int contextID)
|
||||
_isGpuShader4Supported = false;
|
||||
_isUniformBufferObjectSupported = false;
|
||||
_isGetProgramBinarySupported = false;
|
||||
_isGpuShaderFp64Supported = false;
|
||||
_isShaderAtomicCountersSupported = false;
|
||||
|
||||
_glBlendEquationSeparate= 0;
|
||||
_glDrawBuffers= 0;
|
||||
@@ -510,10 +563,32 @@ void GL2Extensions::setupGL2Extensions(unsigned int contextID)
|
||||
_glGetActiveUniformBlockName= 0;
|
||||
_glUniformBlockBinding= 0;
|
||||
|
||||
//ARB_get_program_binary
|
||||
// ARB_get_program_binary
|
||||
_glGetProgramBinary= 0;
|
||||
_glProgramBinary= 0;
|
||||
|
||||
// ARB_gpu_shader_fp64
|
||||
_glUniform1d= 0;
|
||||
_glUniform2d= 0;
|
||||
_glUniform3d= 0;
|
||||
_glUniform4d= 0;
|
||||
_glUniform1dv= 0;
|
||||
_glUniform2dv= 0;
|
||||
_glUniform3dv= 0;
|
||||
_glUniform4dv= 0;
|
||||
_glUniformMatrix2dv= 0;
|
||||
_glUniformMatrix3dv= 0;
|
||||
_glUniformMatrix4dv= 0;
|
||||
_glUniformMatrix2x3dv= 0;
|
||||
_glUniformMatrix3x2dv= 0;
|
||||
_glUniformMatrix2x4dv= 0;
|
||||
_glUniformMatrix4x2dv= 0;
|
||||
_glUniformMatrix3x4dv= 0;
|
||||
_glUniformMatrix4x3dv= 0;
|
||||
|
||||
// ARB_shader_atomic_counters
|
||||
_glGetActiveAtomicCounterBufferiv= 0;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -531,6 +606,8 @@ void GL2Extensions::setupGL2Extensions(unsigned int contextID)
|
||||
_areTessellationShadersSupported = osg::isGLExtensionSupported(contextID, "GL_ARB_tessellation_shader");
|
||||
_isUniformBufferObjectSupported = osg::isGLExtensionSupported(contextID,"GL_ARB_uniform_buffer_object");
|
||||
_isGetProgramBinarySupported = osg::isGLExtensionSupported(contextID,"GL_ARB_get_program_binary");
|
||||
_isGpuShaderFp64Supported = osg::isGLExtensionSupported(contextID,"GL_ARB_gpu_shader_fp64");
|
||||
_isShaderAtomicCountersSupported = osg::isGLExtensionSupported(contextID,"GL_ARB_shader_atomic_counters");
|
||||
|
||||
if( isGlslSupported() )
|
||||
{
|
||||
@@ -691,9 +768,32 @@ void GL2Extensions::setupGL2Extensions(unsigned int contextID)
|
||||
setGLExtensionFuncPtr(_glGetActiveUniformBlockiv, "glGetActiveUniformBlockiv");
|
||||
setGLExtensionFuncPtr(_glGetActiveUniformBlockName, "glGetActiveUniformBlockName");
|
||||
setGLExtensionFuncPtr(_glUniformBlockBinding, "glUniformBlockBinding");
|
||||
//ARB_get_program_binary
|
||||
|
||||
// ARB_get_program_binary
|
||||
setGLExtensionFuncPtr(_glGetProgramBinary, "glGetProgramBinary");
|
||||
setGLExtensionFuncPtr(_glProgramBinary, "glProgramBinary");
|
||||
|
||||
// ARB_gpu_shader_fp64
|
||||
setGLExtensionFuncPtr(_glUniform1d, "glUniform1d" );
|
||||
setGLExtensionFuncPtr(_glUniform2d, "glUniform2d" );
|
||||
setGLExtensionFuncPtr(_glUniform3d, "glUniform3d" );
|
||||
setGLExtensionFuncPtr(_glUniform4d, "glUniform4d" );
|
||||
setGLExtensionFuncPtr(_glUniform1dv, "glUniform1dv" );
|
||||
setGLExtensionFuncPtr(_glUniform2dv, "glUniform2dv" );
|
||||
setGLExtensionFuncPtr(_glUniform3dv, "glUniform3dv" );
|
||||
setGLExtensionFuncPtr(_glUniform4dv, "glUniform4dv" );
|
||||
setGLExtensionFuncPtr(_glUniformMatrix2dv, "glUniformMatrix2dv" );
|
||||
setGLExtensionFuncPtr(_glUniformMatrix3dv, "glUniformMatrix3dv" );
|
||||
setGLExtensionFuncPtr(_glUniformMatrix4dv, "glUniformMatrix4dv" );
|
||||
setGLExtensionFuncPtr(_glUniformMatrix2x3dv, "glUniformMatrix2x3dv" );
|
||||
setGLExtensionFuncPtr(_glUniformMatrix3x2dv, "glUniformMatrix3x2dv" );
|
||||
setGLExtensionFuncPtr(_glUniformMatrix2x4dv, "glUniformMatrix2x4dv" );
|
||||
setGLExtensionFuncPtr(_glUniformMatrix4x2dv, "glUniformMatrix4x2dv" );
|
||||
setGLExtensionFuncPtr(_glUniformMatrix3x4dv, "glUniformMatrix3x4dv" );
|
||||
setGLExtensionFuncPtr(_glUniformMatrix4x3dv, "glUniformMatrix4x3dv" );
|
||||
|
||||
// ARB_shader_atomic_counters
|
||||
setGLExtensionFuncPtr(_glGetActiveAtomicCounterBufferiv, "glGetActiveAtomicCounterBufferiv" );
|
||||
}
|
||||
|
||||
|
||||
@@ -2492,6 +2592,240 @@ void GL2Extensions::glProgramBinary(GLuint program,
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniform1d(GLint location, GLdouble v0) const
|
||||
{
|
||||
if (_glUniform1d)
|
||||
{
|
||||
|
||||
_glUniform1d(location, v0);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniform1d" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniform2d(GLint location, GLdouble v0, GLdouble v1) const
|
||||
{
|
||||
if (_glUniform2d)
|
||||
{
|
||||
|
||||
_glUniform2d(location, v0, v1);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniform2d" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2) const
|
||||
{
|
||||
if (_glUniform3d)
|
||||
{
|
||||
|
||||
_glUniform3d(location, v0, v1, v2);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniform3d" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) const
|
||||
{
|
||||
if (_glUniform4d)
|
||||
{
|
||||
|
||||
_glUniform4d(location, v0, v1, v2, v3);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniform4d" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniform1dv(GLint location, GLsizei count, const GLdouble *value) const
|
||||
{
|
||||
if (_glUniform1dv)
|
||||
{
|
||||
|
||||
_glUniform1dv(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniform1dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniform2dv(GLint location, GLsizei count, const GLdouble *value) const
|
||||
{
|
||||
if (_glUniform2dv)
|
||||
{
|
||||
|
||||
_glUniform2dv(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniform2dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniform3dv(GLint location, GLsizei count, const GLdouble *value) const
|
||||
{
|
||||
if (_glUniform3dv)
|
||||
{
|
||||
|
||||
_glUniform3dv(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniform3dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniform4dv(GLint location, GLsizei count, const GLdouble *value) const
|
||||
{
|
||||
if (_glUniform4dv)
|
||||
{
|
||||
|
||||
_glUniform4dv(location, count, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniform4dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) const
|
||||
{
|
||||
if (_glUniformMatrix2dv)
|
||||
{
|
||||
|
||||
_glUniformMatrix2dv(location, count, transpose, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniformMatrix2dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) const
|
||||
{
|
||||
if (_glUniformMatrix3dv)
|
||||
{
|
||||
|
||||
_glUniformMatrix3dv(location, count, transpose, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniformMatrix3dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) const
|
||||
{
|
||||
if (_glUniformMatrix4dv)
|
||||
{
|
||||
|
||||
_glUniformMatrix4dv(location, count, transpose, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniformMatrix4dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniformMatrix2x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) const
|
||||
{
|
||||
if (_glUniformMatrix2x3dv)
|
||||
{
|
||||
|
||||
_glUniformMatrix2x3dv( location, count, transpose, value );
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniformMatrix2x3dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniformMatrix3x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) const
|
||||
{
|
||||
if (_glUniformMatrix3x2dv)
|
||||
{
|
||||
|
||||
_glUniformMatrix3x2dv( location, count, transpose, value );
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniformMatrix3x2dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniformMatrix2x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) const
|
||||
{
|
||||
if (_glUniformMatrix2x4dv)
|
||||
{
|
||||
|
||||
_glUniformMatrix2x4dv( location, count, transpose, value );
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniformMatrix2x4dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniformMatrix4x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) const
|
||||
{
|
||||
if (_glUniformMatrix4x2dv)
|
||||
{
|
||||
|
||||
_glUniformMatrix4x2dv( location, count, transpose, value );
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniformMatrix4x2dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniformMatrix3x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) const
|
||||
{
|
||||
if (_glUniformMatrix3x4dv)
|
||||
{
|
||||
|
||||
_glUniformMatrix3x4dv( location, count, transpose, value );
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniformMatrix3x4dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glUniformMatrix4x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) const
|
||||
{
|
||||
if (_glUniformMatrix4x3dv)
|
||||
{
|
||||
|
||||
_glUniformMatrix4x3dv( location, count, transpose, value );
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glUniformMatrix4x3dv" );
|
||||
}
|
||||
}
|
||||
|
||||
void GL2Extensions::glGetActiveAtomicCounterBufferiv( GLuint program, GLuint bufferIndex, GLenum pname, GLint* params ) const
|
||||
{
|
||||
if (_glGetActiveAtomicCounterBufferiv)
|
||||
{
|
||||
|
||||
_glGetActiveAtomicCounterBufferiv( program, bufferIndex, pname, params );
|
||||
}
|
||||
else
|
||||
{
|
||||
NotSupported( "glGetActiveAtomicCounterBufferiv" );
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// C++-friendly convenience methods
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
* Copyright (C) 2004-2005 Nathan Cournia
|
||||
* Copyright (C) 2008 Zebra Imaging
|
||||
* Copyright (C) 2010 VIRES Simulationstechnologie GmbH
|
||||
* Copyright (C) 2012 David Callu
|
||||
*
|
||||
* This application is open source and may be redistributed and/or modified
|
||||
* freely and without restriction, both in commercial and non commercial
|
||||
@@ -104,7 +105,8 @@ Program::ProgramBinary::ProgramBinary() : _format(0)
|
||||
{
|
||||
}
|
||||
|
||||
Program::ProgramBinary::ProgramBinary(const ProgramBinary& rhs, const osg::CopyOp&) :
|
||||
Program::ProgramBinary::ProgramBinary(const ProgramBinary& rhs, const osg::CopyOp& copyop) :
|
||||
osg::Object(rhs, copyop),
|
||||
_data(rhs._data), _format(rhs._format)
|
||||
{
|
||||
}
|
||||
@@ -353,7 +355,7 @@ void Program::setParameter( GLenum pname, GLint value )
|
||||
}
|
||||
}
|
||||
|
||||
void Program::setParameterfv( GLenum pname, const GLfloat* value )
|
||||
void Program::setParameterfv( GLenum pname, const GLfloat* /*value*/ )
|
||||
{
|
||||
switch( pname )
|
||||
{
|
||||
@@ -714,11 +716,12 @@ void Program::PerContextProgram::linkProgram(osg::State& state)
|
||||
{
|
||||
OSG_WARN << "uniform block " << blockName << " has no binding.\n";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
typedef std::map<GLuint, std::string> AtomicCounterMap;
|
||||
AtomicCounterMap atomicCounterMap;
|
||||
|
||||
// build _uniformInfoMap
|
||||
GLint numUniforms = 0;
|
||||
GLsizei maxLen = 0;
|
||||
@@ -744,6 +747,11 @@ void Program::PerContextProgram::linkProgram(osg::State& state)
|
||||
name[pos] = 0;
|
||||
}
|
||||
|
||||
if (type == GL_UNSIGNED_INT_ATOMIC_COUNTER)
|
||||
{
|
||||
atomicCounterMap[i] = name;
|
||||
}
|
||||
|
||||
GLint loc = _extensions->glGetUniformLocation( _glProgramHandle, name );
|
||||
|
||||
if( loc != -1 )
|
||||
@@ -760,6 +768,83 @@ void Program::PerContextProgram::linkProgram(osg::State& state)
|
||||
delete [] name;
|
||||
}
|
||||
|
||||
// print atomic counter
|
||||
if (_extensions->isShaderAtomicCounterSupported())
|
||||
{
|
||||
std::vector<GLint> bufferIndex( atomicCounterMap.size(), 0 );
|
||||
std::vector<GLuint> uniformIndex;
|
||||
for (AtomicCounterMap::iterator it = atomicCounterMap.begin(), end = atomicCounterMap.end();
|
||||
it != end; ++it)
|
||||
{
|
||||
uniformIndex.push_back(it->first);
|
||||
}
|
||||
|
||||
_extensions->glGetActiveUniformsiv( _glProgramHandle, uniformIndex.size(),
|
||||
&(uniformIndex[0]), GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX,
|
||||
&(bufferIndex[0]) );
|
||||
|
||||
for (unsigned int j = 0; j < uniformIndex.size(); ++j)
|
||||
{
|
||||
OSG_INFO << "\tUniform atomic counter \""<<atomicCounterMap[ uniformIndex[j] ] <<"\""
|
||||
<<" buffer bind= " << bufferIndex[j] << ".\n";
|
||||
}
|
||||
|
||||
std::map<int, std::vector<int> > bufferIndexToUniformIndices;
|
||||
for (unsigned int i=0; i<bufferIndex.size(); ++i)
|
||||
{
|
||||
bufferIndexToUniformIndices[ bufferIndex[i] ].push_back( uniformIndex[i] );
|
||||
}
|
||||
|
||||
GLuint activeAtomicCounterBuffers = 0;
|
||||
_extensions->glGetProgramiv(_glProgramHandle, GL_ACTIVE_ATOMIC_COUNTER_BUFFERS,
|
||||
reinterpret_cast<GLint*>(&activeAtomicCounterBuffers));
|
||||
if (activeAtomicCounterBuffers > 0)
|
||||
{
|
||||
for (GLuint i = 0; i < activeAtomicCounterBuffers; ++i)
|
||||
{
|
||||
GLint bindID = 0;
|
||||
_extensions->glGetActiveAtomicCounterBufferiv(_glProgramHandle, i,
|
||||
GL_ATOMIC_COUNTER_BUFFER_BINDING,
|
||||
&bindID);
|
||||
|
||||
GLsizei num = 0;
|
||||
_extensions->glGetActiveAtomicCounterBufferiv(_glProgramHandle, i,
|
||||
GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS,
|
||||
&num);
|
||||
GLsizei minSize = 0;
|
||||
_extensions->glGetActiveAtomicCounterBufferiv(_glProgramHandle, i,
|
||||
GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE,
|
||||
&minSize);
|
||||
|
||||
|
||||
OSG_INFO << "\tUniform atomic counter buffer bind \"" << bindID << "\""
|
||||
<< " num active atomic counter= "<< num
|
||||
<< " min size= " << minSize << "\n";
|
||||
|
||||
if (num)
|
||||
{
|
||||
std::vector<GLint> indices(num);
|
||||
_extensions->glGetActiveAtomicCounterBufferiv(_glProgramHandle, i,
|
||||
GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES,
|
||||
&(indices[0]));
|
||||
OSG_INFO << "\t\tindices used= ";
|
||||
for (GLint j = 0; j < num; ++j)
|
||||
{
|
||||
OSG_INFO << indices[j];
|
||||
if (j < (num-1))
|
||||
{
|
||||
OSG_INFO << ", ";
|
||||
}
|
||||
else
|
||||
{
|
||||
OSG_INFO << ".\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// build _attribInfoMap
|
||||
GLint numAttrib = 0;
|
||||
_extensions->glGetProgramiv( _glProgramHandle, GL_ACTIVE_ATTRIBUTES, &numAttrib );
|
||||
|
||||
1479
src/osg/Uniform.cpp
1479
src/osg/Uniform.cpp
File diff suppressed because it is too large
Load Diff
@@ -43,7 +43,9 @@ void Uniform::write(DataOutputStream* out){
|
||||
out->writeUInt(getNumElements());
|
||||
|
||||
if( getFloatArray() ) out->writeArray( getFloatArray() );
|
||||
if( getDoubleArray() ) out->writeArray( getDoubleArray() );
|
||||
if( getIntArray() ) out->writeArray( getIntArray() );
|
||||
if( getUIntArray() ) out->writeArray( getUIntArray() );
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -177,7 +179,9 @@ void Uniform::read(DataInputStream* in)
|
||||
|
||||
osg::Array* data = in->readArray();
|
||||
setArray( dynamic_cast<osg::FloatArray*>(data) );
|
||||
setArray( dynamic_cast<osg::DoubleArray*>(data) );
|
||||
setArray( dynamic_cast<osg::IntArray*>(data) );
|
||||
setArray( dynamic_cast<osg::UIntArray*>(data) );
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
@@ -65,6 +65,7 @@ bool Uniform_readLocalData(Object& obj, Input& fr)
|
||||
|
||||
Array* data = Array_readLocalData(fr);
|
||||
uniform.setArray( dynamic_cast<FloatArray*>(data) );
|
||||
uniform.setArray( dynamic_cast<DoubleArray*>(data) );
|
||||
uniform.setArray( dynamic_cast<IntArray*>(data) );
|
||||
uniform.setArray( dynamic_cast<UIntArray*>(data) );
|
||||
}
|
||||
|
||||
@@ -18,6 +18,8 @@ static bool readElements( osgDB::InputStream& is, osg::Uniform& uniform )
|
||||
{
|
||||
case osg::Array::FloatArrayType:
|
||||
uniform.setArray( static_cast<osg::FloatArray*>(array) ); break;
|
||||
case osg::Array::DoubleArrayType:
|
||||
uniform.setArray( static_cast<osg::DoubleArray*>(array) ); break;
|
||||
case osg::Array::IntArrayType:
|
||||
uniform.setArray( static_cast<osg::IntArray*>(array) ); break;
|
||||
case osg::Array::UIntArrayType:
|
||||
@@ -35,6 +37,11 @@ static bool writeElements( osgDB::OutputStream& os, const osg::Uniform& uniform
|
||||
os << (uniform.getFloatArray()!=NULL);
|
||||
os.writeArray( uniform.getFloatArray() );
|
||||
}
|
||||
if ( uniform.getDoubleArray()!=NULL )
|
||||
{
|
||||
os << (uniform.getDoubleArray()!=NULL);
|
||||
os.writeArray( uniform.getDoubleArray() );
|
||||
}
|
||||
else if ( uniform.getIntArray()!=NULL )
|
||||
{
|
||||
os << (uniform.getIntArray()!=NULL);
|
||||
@@ -58,17 +65,47 @@ REGISTER_OBJECT_WRAPPER( Uniform,
|
||||
ADD_ENUM_VALUE( FLOAT_VEC2 );
|
||||
ADD_ENUM_VALUE( FLOAT_VEC3 );
|
||||
ADD_ENUM_VALUE( FLOAT_VEC4 );
|
||||
|
||||
ADD_ENUM_VALUE( DOUBLE );
|
||||
ADD_ENUM_VALUE( DOUBLE_VEC2 );
|
||||
ADD_ENUM_VALUE( DOUBLE_VEC3 );
|
||||
ADD_ENUM_VALUE( DOUBLE_VEC4 );
|
||||
|
||||
ADD_ENUM_VALUE( INT );
|
||||
ADD_ENUM_VALUE( INT_VEC2 );
|
||||
ADD_ENUM_VALUE( INT_VEC3 );
|
||||
ADD_ENUM_VALUE( INT_VEC4 );
|
||||
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_VEC2 );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_VEC3 );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_VEC4 );
|
||||
|
||||
ADD_ENUM_VALUE( BOOL );
|
||||
ADD_ENUM_VALUE( BOOL_VEC2 );
|
||||
ADD_ENUM_VALUE( BOOL_VEC3 );
|
||||
ADD_ENUM_VALUE( BOOL_VEC4 );
|
||||
|
||||
ADD_ENUM_VALUE( FLOAT_MAT2 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT3 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT4 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT2x3 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT2x4 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT3x2 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT3x4 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT4x2 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT4x3 );
|
||||
|
||||
ADD_ENUM_VALUE( DOUBLE_MAT2 );
|
||||
ADD_ENUM_VALUE( DOUBLE_MAT3 );
|
||||
ADD_ENUM_VALUE( DOUBLE_MAT4 );
|
||||
ADD_ENUM_VALUE( DOUBLE_MAT2x3 );
|
||||
ADD_ENUM_VALUE( DOUBLE_MAT2x4 );
|
||||
ADD_ENUM_VALUE( DOUBLE_MAT3x2 );
|
||||
ADD_ENUM_VALUE( DOUBLE_MAT3x4 );
|
||||
ADD_ENUM_VALUE( DOUBLE_MAT4x2 );
|
||||
ADD_ENUM_VALUE( DOUBLE_MAT4x3 );
|
||||
|
||||
ADD_ENUM_VALUE( SAMPLER_1D );
|
||||
ADD_ENUM_VALUE( SAMPLER_2D );
|
||||
ADD_ENUM_VALUE( SAMPLER_3D );
|
||||
@@ -77,41 +114,82 @@ REGISTER_OBJECT_WRAPPER( Uniform,
|
||||
ADD_ENUM_VALUE( SAMPLER_2D_SHADOW );
|
||||
ADD_ENUM_VALUE( SAMPLER_1D_ARRAY );
|
||||
ADD_ENUM_VALUE( SAMPLER_2D_ARRAY );
|
||||
ADD_ENUM_VALUE( SAMPLER_CUBE_MAP_ARRAY );
|
||||
ADD_ENUM_VALUE( SAMPLER_1D_ARRAY_SHADOW );
|
||||
ADD_ENUM_VALUE( SAMPLER_2D_ARRAY_SHADOW );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT2x3 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT2x4 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT3x2 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT3x4 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT4x2 );
|
||||
ADD_ENUM_VALUE( FLOAT_MAT4x3 );
|
||||
ADD_ENUM_VALUE( SAMPLER_BUFFER );
|
||||
ADD_ENUM_VALUE( SAMPLER_2D_MULTISAMPLE );
|
||||
ADD_ENUM_VALUE( SAMPLER_2D_MULTISAMPLE_ARRAY );
|
||||
ADD_ENUM_VALUE( SAMPLER_CUBE_SHADOW );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_VEC2 );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_VEC3 );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_VEC4 );
|
||||
ADD_ENUM_VALUE( SAMPLER_CUBE_MAP_ARRAY_SHADOW );
|
||||
ADD_ENUM_VALUE( SAMPLER_BUFFER );
|
||||
ADD_ENUM_VALUE( SAMPLER_2D_RECT );
|
||||
ADD_ENUM_VALUE( SAMPLER_2D_RECT_SHADOW );
|
||||
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_1D );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_2D );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_3D );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_CUBE );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_2D_RECT );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_1D_ARRAY );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_2D_ARRAY );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_CUBE_MAP_ARRAY );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_2D_MULTISAMPLE );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_2D_MULTISAMPLE_ARRAY );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_BUFFER );
|
||||
ADD_ENUM_VALUE( INT_SAMPLER_2D_RECT );
|
||||
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_1D );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_2D );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_3D );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_CUBE );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_2D_RECT );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_1D_ARRAY );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_2D_ARRAY );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_BUFFER );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_2D_RECT );
|
||||
|
||||
ADD_ENUM_VALUE( IMAGE_1D );
|
||||
ADD_ENUM_VALUE( IMAGE_2D );
|
||||
ADD_ENUM_VALUE( IMAGE_3D );
|
||||
ADD_ENUM_VALUE( IMAGE_2D_RECT );
|
||||
ADD_ENUM_VALUE( IMAGE_CUBE );
|
||||
ADD_ENUM_VALUE( IMAGE_BUFFER );
|
||||
ADD_ENUM_VALUE( IMAGE_1D_ARRAY );
|
||||
ADD_ENUM_VALUE( IMAGE_2D_ARRAY );
|
||||
ADD_ENUM_VALUE( IMAGE_CUBE_MAP_ARRAY );
|
||||
ADD_ENUM_VALUE( IMAGE_2D_MULTISAMPLE );
|
||||
ADD_ENUM_VALUE( IMAGE_2D_MULTISAMPLE_ARRAY );
|
||||
|
||||
ADD_ENUM_VALUE( INT_IMAGE_1D );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_2D );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_3D );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_2D_RECT );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_CUBE );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_BUFFER );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_1D_ARRAY );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_2D_ARRAY );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_CUBE_MAP_ARRAY );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_2D_MULTISAMPLE );
|
||||
ADD_ENUM_VALUE( INT_IMAGE_2D_MULTISAMPLE_ARRAY );
|
||||
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_1D );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_2D );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_3D );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_2D_RECT );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_CUBE );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_BUFFER );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_1D_ARRAY );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_2D_ARRAY );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_2D_MULTISAMPLE );
|
||||
ADD_ENUM_VALUE( UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY );
|
||||
|
||||
ADD_ENUM_VALUE( UNDEFINED );
|
||||
END_ENUM_SERIALIZER(); // _type
|
||||
|
||||
ADD_UINT_SERIALIZER( NumElements, 0 ); // _numElements
|
||||
ADD_USER_SERIALIZER( Elements ); // _floatArray, _intArray, _uintArray
|
||||
ADD_USER_SERIALIZER( Elements ); // _floatArray, _doubleArray, _intArray, _uintArray
|
||||
ADD_OBJECT_SERIALIZER( UpdateCallback, osg::Uniform::Callback, NULL ); // _updateCallback
|
||||
ADD_OBJECT_SERIALIZER( EventCallback, osg::Uniform::Callback, NULL ); // _eventCallback
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user