FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #211 from D-A-Heitbrink/master

Browse Source 
Added support for unsigned 64 bit ints + some code for bindless textures
This commit is contained in:
OpenSceneGraph git repository
2017-03-11 11:58:20 +00:00
committed by GitHub
parent 8dd22d9178 cfaf72bc56
commit 75e4d85681
21 changed files with 969 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/osg/GLExtensions.cpp
View File

@@ -22,6 +22,7 @@
#include <float.h>
#include <string>
#include <vector>
#include <set>
#include <sstream>
@@ -640,6 +641,25 @@ GLExtensions::GLExtensions(unsigned int in_contextID):
setGLExtensionFuncPtr(glUniform2uiv, "glUniform2uiv", "glUniform2uivEXT", validContext);
setGLExtensionFuncPtr(glUniform3uiv, "glUniform3uiv", "glUniform3uivEXT", validContext);
setGLExtensionFuncPtr(glUniform4uiv, "glUniform4uiv", "glUniform4uivEXT", validContext);
// ARB_gpu_shader_int64
setGLExtensionFuncPtr(glUniform1i64, "glUniform1i64", "glUniform1i64ARB", validContext);
setGLExtensionFuncPtr(glUniform1ui64, "glUniform1ui64", "glUniform1ui64ARB", validContext);
setGLExtensionFuncPtr(glUniform2i64, "glUniform2i64", "glUniform2i64ARB", validContext);
setGLExtensionFuncPtr(glUniform2ui64, "glUniform2ui64", "glUniform2ui64ARB", validContext);
setGLExtensionFuncPtr(glUniform3i64, "glUniform3i64", "glUniform3i64ARB", validContext);
setGLExtensionFuncPtr(glUniform3ui64, "glUniform3ui64", "glUniform3ui64ARB", validContext);
setGLExtensionFuncPtr(glUniform4i64, "glUniform4i64", "glUniform4i64ARB", validContext);
setGLExtensionFuncPtr(glUniform4ui64, "glUniform4ui64", "glUniform4ui64ARB", validContext);
setGLExtensionFuncPtr(glUniform1i64v, "glUniform1i64v", "glUniform1i64vARB", validContext);
setGLExtensionFuncPtr(glUniform1ui64v,"glUniform1ui64v","glUniform1ui64vARB",validContext);
setGLExtensionFuncPtr(glUniform2i64v, "glUniform2i64v", "glUniform2i64vARB", validContext);
setGLExtensionFuncPtr(glUniform2ui64v,"glUniform2ui64v","glUniform2ui64vARB",validContext);
setGLExtensionFuncPtr(glUniform3i64v, "glUniform3i64v", "glUniform3i64vARB", validContext);
setGLExtensionFuncPtr(glUniform3ui64v,"glUniform3ui64v","glUniform3ui64vARB",validContext);
setGLExtensionFuncPtr(glUniform4i64v, "glUniform4i64v", "glUniform4i64vARB", validContext);
setGLExtensionFuncPtr(glUniform4ui64v,"glUniform4ui64v","glUniform4ui64vARB",validContext);
// ARB_uniform_buffer_object
setGLExtensionFuncPtr(glGetUniformIndices, "glGetUniformIndices", validContext);
setGLExtensionFuncPtr(glGetActiveUniformsiv, "glGetActiveUniformsiv", validContext);
@@ -910,6 +930,13 @@ GLExtensions::GLExtensions(unsigned int in_contextID):
maxLayerCount = 0;
if (validContext) glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS_EXT, &maxLayerCount);
// Bindless textures
setGLExtensionFuncPtr(glGetTextureHandle, "glGetTextureHandle", "glGetTextureHandleARB","glGetTextureHandleNV", validContext);
setGLExtensionFuncPtr(glMakeTextureHandleResident, "glMakeTextureHandleResident", "glMakeTextureHandleResidentARB","glMakeTextureHandleResidentNV", validContext);
setGLExtensionFuncPtr(glMakeTextureHandleNonResident, "glMakeTextureHandleNonResident", "glMakeTextureHandleNonResidentARB", "glMakeTextureHandleNonResidentNV",validContext);
setGLExtensionFuncPtr(glUniformHandleui64, "glUniformHandleui64", "glUniformHandleui64ARB","glUniformHandleui64NV", validContext);
setGLExtensionFuncPtr(glIsTextureHandleResident, "glIsTextureHandleResident","glIsTextureHandleResidentARB", "glIsTextureHandleResidentNV", validContext);
// Blending
isBlendColorSupported = validContext &&
(OSG_GLES2_FEATURES || OSG_GL3_FEATURES ||

7
src/osg/State.cpp
View File

@@ -1229,6 +1229,13 @@ bool State::convertVertexShaderSourceToOsgBuiltIns(std::string& source) const
declPos = 0;
}
std::string::size_type extPos = source.rfind( "#extension " );
if ( extPos != std::string::npos )
{
// found the string, now find the next linefeed and set the insertion point after it.
declPos = source.find( '\n', extPos );
declPos = declPos != std::string::npos ? declPos+1 : source.length();
}
if (_useModelViewAndProjectionUniforms)
{
// replace ftransform as it only works with built-ins

169
src/osg/Uniform.cpp
View File

@@ -168,6 +168,8 @@ bool Uniform::setArray( FloatArray* array )
_doubleArray = 0;
_intArray = 0;
_uintArray = 0;
_int64Array = 0;
_uint64Array = 0;
dirty();
return true;
}
@@ -187,6 +189,8 @@ bool Uniform::setArray( DoubleArray* array )
_floatArray = 0;
_intArray = 0;
_uintArray = 0;
_int64Array = 0;
_uint64Array = 0;
dirty();
return true;
}
@@ -206,6 +210,8 @@ bool Uniform::setArray( IntArray* array )
_floatArray = 0;
_doubleArray = 0;
_uintArray = 0;
_int64Array = 0;
_uint64Array = 0;
dirty();
return true;
}
@@ -225,6 +231,49 @@ bool Uniform::setArray( UIntArray* array )
_floatArray = 0;
_doubleArray = 0;
_intArray = 0;
_int64Array = 0;
_uint64Array = 0;
dirty();
return true;
}
bool Uniform::setArray( UInt64Array* array )
{
if( !array ) return false;
// incoming array must match configuration of the Uniform
if( getInternalArrayType(getType())!=GL_UNSIGNED_INT || getInternalArrayNumElements()!=array->getNumElements() )
{
OSG_WARN << "Uniform::setArray : incompatible array" << std::endl;
return false;
}
_uint64Array = array;
_floatArray = 0;
_doubleArray = 0;
_intArray = 0;
_uintArray = 0;
_int64Array =0;
dirty();
return true;
}
bool Uniform::setArray( Int64Array* array )
{
if( !array ) return false;
// incoming array must match configuration of the Uniform
if( getInternalArrayType(getType())!=GL_UNSIGNED_INT || getInternalArrayNumElements()!=array->getNumElements() )
{
OSG_WARN << "Uniform::setArray : incompatible array" << std::endl;
return false;
}
_int64Array = array;
_floatArray = 0;
_doubleArray = 0;
_intArray = 0;
_uintArray = 0;
_uint64Array =0;
dirty();
return true;
}
@@ -282,6 +331,22 @@ int Uniform::compareData(const Uniform& rhs) const
return memcmp( _uintArray->getDataPointer(), rhs._uintArray->getDataPointer(),
_uintArray->getTotalDataSize() );
}
else if( _uint64Array.valid() )
{
if( ! rhs._uint64Array ) return 1;
if( _uint64Array == rhs._uint64Array ) return 0;
return memcmp( _uint64Array->getDataPointer(), rhs._uint64Array->getDataPointer(),
_uint64Array->getTotalDataSize() );
}
else if( _int64Array.valid() )
{
if( ! rhs._int64Array ) return 1;
if( _int64Array == rhs._int64Array ) return 0;
return memcmp( _int64Array->getDataPointer(), rhs._int64Array->getDataPointer(),
_int64Array->getTotalDataSize() );
}
return -1; // how got here?
}
@@ -296,6 +361,8 @@ void Uniform::copyData(const Uniform& rhs)
if( _doubleArray.valid() && rhs._doubleArray.valid() ) *_doubleArray = *rhs._doubleArray;
if( _intArray.valid() && rhs._intArray.valid() ) *_intArray = *rhs._intArray;
if( _uintArray.valid() && rhs._uintArray.valid() ) *_uintArray = *rhs._uintArray;
if( _int64Array.valid() && rhs._int64Array.valid() ) *_int64Array = *rhs._int64Array;
if( _uint64Array.valid() && rhs._uint64Array.valid() ) *_uint64Array = *rhs._uint64Array;
dirty();
}
@@ -361,6 +428,9 @@ const char* Uniform::getTypename( Type t )
case BOOL_VEC3: return "bvec3";
case BOOL_VEC4: return "bvec4";
case INT64: return "int64_t";
case UNSIGNED_INT64: return "uint64_t";
case FLOAT_MAT2: return "mat2";
case FLOAT_MAT3: return "mat3";
case FLOAT_MAT4: return "mat4";
@@ -473,6 +543,8 @@ int Uniform::getTypeNumComponents( Type t )
case INT:
case UNSIGNED_INT:
case BOOL:
case UNSIGNED_INT64:
case INT64:
case SAMPLER_1D:
case SAMPLER_2D:
@@ -635,6 +707,9 @@ Uniform::Type Uniform::getTypeId( const std::string& tname )
if( tname == "bvec3" ) return BOOL_VEC3;
if( tname == "bvec4" ) return BOOL_VEC4;
if( tname == "uint64_t" ) return UNSIGNED_INT64;
if( tname == "int64_t" ) return INT64;
if( tname == "mat2" || tname == "mat2x2" ) return FLOAT_MAT2;
if( tname == "mat3" || tname == "mat3x3" ) return FLOAT_MAT3;
if( tname == "mat4" || tname == "mat4x4" ) return FLOAT_MAT4;
@@ -832,6 +907,12 @@ Uniform::Type Uniform::getGlApiType( Type t )
case BOOL_VEC4:
return INT_VEC4;
case UNSIGNED_INT64:
return UNSIGNED_INT64;
case INT64:
return INT64;
default:
return t;
}
@@ -965,6 +1046,12 @@ GLenum Uniform::getInternalArrayType( Type t )
case UNSIGNED_INT_VEC4:
return GL_UNSIGNED_INT;
case UNSIGNED_INT64:
return GL_UNSIGNED_INT64_ARB;
case INT64:
return GL_INT64_ARB;
default:
return 0;
}
@@ -1298,8 +1385,21 @@ Uniform::Uniform( const char* name, bool b0, bool b1, bool b2, bool b3 ) :
allocateDataArray();
set( b0, b1, b2, b3 );
}
///////////////////////////////////////////////////////////////////////////
Uniform::Uniform( const char* name, unsigned long long ull) :
_type(UNSIGNED_INT64), _numElements(1), _modifiedCount(0)
{
setName(name);
allocateDataArray();
set( ull );
}
Uniform::Uniform( const char* name, long long ll) :
_type(INT64), _numElements(1), _modifiedCount(0)
{
setName(name);
allocateDataArray();
set( ll );
}
////////////////////////////////////////////////////////////////////////
// Value assignment for single-element (ie: non-array) uniforms.
// (For backwards compatibility, if not already configured, set the
// Uniform's _numElements=1)
@@ -1532,6 +1632,17 @@ bool Uniform::set( bool b0, bool b1, bool b2, bool b3 )
return isScalar() ? setElement(0,b0,b1,b2,b3) : false;
}
bool Uniform::set( unsigned long long ull )
{
if( getNumElements() == 0 ) setNumElements(1);
return isScalar() ? setElement(0,ull) : false;
}
bool Uniform::set( long long ll )
{
if( getNumElements() == 0 ) setNumElements(1);
return isScalar() ? setElement(0,ll) : false;
}
///////////////////////////////////////////////////////////////////////////
// Value query for single-element (ie: non-array) uniforms.
@@ -1725,6 +1836,14 @@ bool Uniform::get( bool& b0, bool& b1, bool& b2, bool& b3 ) const
return isScalar() ? getElement(0,b0,b1,b2,b3) : false;
}
bool Uniform::get( unsigned long long& ull ) const
{
return isScalar() ? getElement(0,ull) : false;
}
bool Uniform::get( long long& ll ) const
{
return isScalar() ? getElement(0,ll) : false;
}
///////////////////////////////////////////////////////////////////////////
// Value assignment for array uniforms.
@@ -2110,7 +2229,22 @@ bool Uniform::setElement( unsigned int index, bool b0, bool b1, bool b2, bool b3
dirty();
return true;
}
bool Uniform::setElement( unsigned int index, unsigned long long ull )
{
if( index>=getNumElements() || !isCompatibleType(UNSIGNED_INT64) ) return false;
unsigned int j = index * getTypeNumComponents(getType());
(*_uint64Array)[j] = ull;
dirty();
return true;
}
bool Uniform::setElement( unsigned int index, long long ll )
{
if( index>=getNumElements() || !isCompatibleType(INT64) ) return false;
unsigned int j = index * getTypeNumComponents(getType());
(*_int64Array)[j] = ll;
dirty();
return true;
}
///////////////////////////////////////////////////////////////////////////
// Value query for array uniforms.
@@ -2422,6 +2556,22 @@ bool Uniform::getElement( unsigned int index, bool& b ) const
return true;
}
bool Uniform::getElement( unsigned int index, unsigned long long& ull ) const
{
if( index>=getNumElements() || !isCompatibleType(UNSIGNED_INT64) ) return false;
unsigned int j = index * getTypeNumComponents(getType());
ull = ((*_uint64Array)[j] != 0);
return true;
}
bool Uniform::getElement( unsigned int index, long long& ll ) const
{
if( index>=getNumElements() || !isCompatibleType(INT64) ) return false;
unsigned int j = index * getTypeNumComponents(getType());
ll = ((*_int64Array)[j] != 0);
return true;
}
bool Uniform::getElement( unsigned int index, bool& b0, bool& b1 ) const
{
if( index>=getNumElements() || !isCompatibleType(BOOL_VEC2) ) return false;
@@ -2604,6 +2754,19 @@ void Uniform::apply(const GLExtensions* ext, GLint location) const
if( _uintArray.valid() ) ext->glUniform4uiv( location, num, &_uintArray->front() );
break;
case UNSIGNED_INT64:
if( _uint64Array.valid() ){
if (ext->glUniform1ui64v)
ext->glUniform1ui64v( location, num, &_uint64Array->front() );
else
OSG_WARN << "how got here? " __FILE__ ":" << __LINE__ << std::endl;
}
break;
case INT64:
if( _int64Array.valid() ) ext->glUniform1i64v( location, num, &_int64Array->front() );
break;
default:
OSG_FATAL << "how got here? " __FILE__ ":" << __LINE__ << std::endl;
break;

2
src/osgDB/ClassInterface.cpp
View File

@@ -58,6 +58,8 @@ public:
virtual void writeULong( unsigned long l ) { write(l); }
virtual void writeFloat( float f ) { write(f); }
virtual void writeDouble( double d ) { write(d); }
virtual void writeInt64( long long ll ) { write(ll); }
virtual void writeUInt64( unsigned long long ull ) { write(ull); }
virtual void writeString( const std::string& s ) { _str.insert(_str.end(), s.begin(), s.end()); }
virtual void writeStream( std::ostream& (*)(std::ostream&) ) {}
virtual void writeBase( std::ios_base& (*)(std::ios_base&) ) {}

34
src/osgPlugins/ive/DataOutputStream.cpp
View File

@@ -497,6 +497,34 @@ void DataOutputStream::writeVec4b(const osg::Vec4b& v){
if (_verboseOutput) std::cout<<"read/writeVec4b() ["<<v<<"]"<<std::endl;
}
void DataOutputStream::writeUInt64(unsigned long long ull){
_ostream->write((char*)&ull, INT64SIZE);
if (_verboseOutput) std::cout<<"read/writeUInt64() ["<<ull<<"]"<<std::endl;
}
void DataOutputStream::writeInt64(long long ll){
_ostream->write((char*)&ll, INT64SIZE);
if (_verboseOutput) std::cout<<"read/writeInt64() ["<<ll<<"]"<<std::endl;
}
void DataOutputStream::writeUInt64Array(const osg::UInt64Array* a){
int size = a->getNumElements();
writeUInt64(size);
for(int i =0; i<size ;i++){
writeInt((*a)[i]);
}
if (_verboseOutput) std::cout<<"read/writeUInt64Array() ["<<size<<"]"<<std::endl;
}
void DataOutputStream::writeInt64Array(const osg::Int64Array* a){
int size = a->getNumElements();
writeInt64(size);
for(int i =0; i<size ;i++){
writeInt((*a)[i]);
}
if (_verboseOutput) std::cout<<"read/writeInt64Array() ["<<size<<"]"<<std::endl;
}
void DataOutputStream::writeQuat(const osg::Quat& q){
writeFloat(q.x());
@@ -589,10 +617,14 @@ void DataOutputStream::writeArray(const osg::Array* a){
writeChar((char)16);
writeVec3dArray(static_cast<const osg::Vec3dArray*>(a));
break;
case osg::Array::Vec4dArrayType:
case osg::Array::Vec4dArrayType:
writeChar((char)17);
writeVec4dArray(static_cast<const osg::Vec4dArray*>(a));
break;
case osg::Array::UInt64ArrayType:
writeChar((char)18);
writeUInt64Array(static_cast<const osg::UInt64Array*>(a));
break;
default: throwException("Unknown array type in DataOutputStream::writeArray()");
}
}

6
src/osgPlugins/ive/DataOutputStream.h
View File

@@ -72,7 +72,11 @@ public:
void writeVec2b(const osg::Vec2b& v);
void writeVec3b(const osg::Vec3b& v);
void writeVec4b(const osg::Vec4b& v);
void writeUInt64(unsigned long long ull);
void writeInt64(long long ll);
void writeUInt64Array(const osg::UInt64Array* a);
void writeInt64Array(const osg::Int64Array* a);
void writePackedFloatArray(const osg::FloatArray* a, float maxError);
void writeFloatArray(const osg::FloatArray* a);

2
src/osgPlugins/ive/DataTypeSize.h
View File

@@ -9,7 +9,7 @@
#define FLOATSIZE 4
#define LONGSIZE 4
#define DOUBLESIZE 8
#define INT64SIZE 8
//Don't know where else to put this
namespace ive{

6
src/osgPlugins/osg/AsciiStreamOperator.h
View File

@@ -49,6 +49,12 @@ public:
virtual void writeULong( unsigned long l )
{ indentIfRequired(); *_out << l << ' '; }
virtual void writeInt64( long long ll )
{ indentIfRequired(); *_out << ll << ' '; }
virtual void writeUInt64( unsigned long long ull )
{ indentIfRequired(); *_out << ull << ' '; }
virtual void writeFloat( float f )
{ indentIfRequired(); *_out << f << ' '; }

12
src/osgPlugins/osg/BinaryStreamOperator.h
View File

@@ -49,6 +49,18 @@ public:
_out->write( (char*)&value, osgDB::LONG_SIZE );
}
virtual void writeInt64( int64_t ll )
{_out->write( (char*)&ll, osgDB::INT64_SIZE );}
virtual void writeUInt64( uint64_t ull )
{_out->write( (char*)&ull, osgDB::INT64_SIZE );}
virtual void writeInt( long long ll )
{ _out->write( (char*)&ll, osgDB::INT64_SIZE ); }
virtual void writeUInt( unsigned long long ull )
{ _out->write( (char*)&ull, osgDB::INT64_SIZE ); }
virtual void writeFloat( float f )
{ _out->write( (char*)&f, osgDB::FLOAT_SIZE ); }

12
src/osgPlugins/osg/XmlStreamOperator.h
View File

@@ -59,6 +59,18 @@ public:
virtual void writeULong( unsigned long l )
{ _sstream << l; addToCurrentNode( _sstream.str() ); _sstream.str(""); }
virtual void writeUInt64(uint64_t ull)
{_sstream << ull; addToCurrentNode( _sstream.str() ); _sstream.str("");}
virtual void writeInt64(int64_t ll)
{_sstream << ll; addToCurrentNode( _sstream.str() ); _sstream.str("");}
virtual void writeInt( unsigned long long ull )
{ _sstream << ull; addToCurrentNode( _sstream.str() ); _sstream.str(""); }
virtual void writeUInt( long long ll )
{ _sstream << ll; addToCurrentNode( _sstream.str() ); _sstream.str(""); }
virtual void writeFloat( float f )
{ _sstream << f; addToCurrentNode( _sstream.str() ); _sstream.str(""); }

15
src/osgWrappers/deprecated-dotosg/osg/Geometry.cpp
View File

@@ -995,6 +995,21 @@ bool Array_writeLocalData(const Array& array,Output& fw)
return true;
}
break;
case(Array::UInt64ArrayType):
{
fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
const UInt64Array::ElementDataType* base = static_cast<const UInt64Array::ElementDataType*>(array.getDataPointer());
writeArray(fw,&base[0], &base[array.getNumElements()]);
return true;
}
case(Array::Int64ArrayType):
{
fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
const Int64Array::ElementDataType* base = static_cast<const Int64Array::ElementDataType*>(array.getDataPointer());
writeArray(fw,&base[0], &base[array.getNumElements()]);
return true;
}
break;
case(Array::ArrayType):
default:
return false;