#include <dali/internal/render/shaders/program.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
#include <iomanip>
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/common/constants.h>
-#include <dali/internal/render/common/performance-monitor.h>
#include <dali/integration-api/debug.h>
#include <dali/integration-api/shader-data.h>
+#include <dali/integration-api/gl-defines.h>
+#include <dali/internal/render/common/performance-monitor.h>
+#include <dali/internal/render/shaders/program-cache.h>
+#include <dali/internal/render/gl-resources/gl-call-debug.h>
namespace
{
// IMPLEMENTATION
-std::set< std::string > Program::mExternalUniformNames;
-
-Program* Program::New( const Integration::ResourceId& resourceId, Integration::ShaderData* shaderData, Context& context )
+Program* Program::New( ProgramCache& cache, Integration::ShaderDataPtr shaderData, bool modifiesGeometry )
{
size_t shaderHash = shaderData->GetHashValue();
- Program* program = context.GetCachedProgram( shaderHash );
+ Program* program = cache.GetProgram( shaderHash );
if( NULL == program )
{
// program not found so create it
- program = new Program( shaderData, context );
+ program = new Program( cache, shaderData, modifiesGeometry );
- program->Load();
+ // we want to lazy load programs so dont do a Load yet, it gets done in Use()
- // tell context to cache it
- context.CacheProgram( shaderHash, program );
+ cache.AddProgram( shaderHash, program );
}
return program;
void Program::Use()
{
- if ( !mLinked &&
- mContext.IsGlContextCreated() )
+ if ( !mLinked )
{
Load();
}
if ( mLinked )
{
- if ( this != mContext.GetCurrentProgram() )
+ if ( this != mCache.GetCurrentProgram() )
{
LOG_GL( "UseProgram(%d)\n", mProgramId );
- CHECK_GL( mContext, mGlAbstraction.UseProgram(mProgramId) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.UseProgram(mProgramId) );
INCREASE_COUNTER(PerformanceMonitor::SHADER_STATE_CHANGES);
- mContext.SetCurrentProgram( this );
+ mCache.SetCurrentProgram( this );
}
}
}
bool Program::IsUsed()
{
- return ( this == mContext.GetCurrentProgram() );
+ return ( this == mCache.GetCurrentProgram() );
}
GLint Program::GetAttribLocation( AttribType type )
if( mAttribLocations[ type ] == ATTRIB_UNKNOWN )
{
- LOG_GL( "GetAttribLocation(program=%d,%s) = %d\n", mProgramId, gStdAttribs[type], mAttribLocations[type] );
- GLint loc = CHECK_GL( mContext, mGlAbstraction.GetAttribLocation( mProgramId, gStdAttribs[type] ) );
+ GLint loc = CHECK_GL( mGlAbstraction, mGlAbstraction.GetAttribLocation( mProgramId, gStdAttribs[type] ) );
mAttribLocations[ type ] = loc;
+ LOG_GL( "GetAttribLocation(program=%d,%s) = %d\n", mProgramId, gStdAttribs[type], mAttribLocations[type] );
}
return mAttribLocations[type];
}
-unsigned int Program::RegisterExternalUniform( const std::string& name )
-{
- // insert the name in the table to keep it alive as long as this program exists
- // we rely on C++ strings COW behaviour to keep the char* alive.
- // TODO In C++ 11 this is no longer the case so this code needs changing if we upgrade
- mExternalUniformNames.insert( name );
- return RegisterUniform( name.c_str() );
-}
-
-unsigned int Program::RegisterUniform( const char* name )
+unsigned int Program::RegisterUniform( const std::string& name )
{
unsigned int index = 0;
// find the value from cache
- for( ;index < mCustomUniformLocations.size(); ++index )
+ for( ;index < mUniformLocations.size(); ++index )
{
- if( !strcmp( mCustomUniformLocations[ index ].first, name ) )
+ if( mUniformLocations[ index ].first == name )
{
- // name found so return index plus built in index count
- return index + UNIFORM_TYPE_LAST;
+ // name found so return index
+ return index;
}
}
// if we get here, index is one past end so push back the new name
- mCustomUniformLocations.push_back( std::make_pair( name, UNIFORM_NOT_QUERIED ) );
- return index + UNIFORM_TYPE_LAST; // remember to add the count of the built in ones
+ mUniformLocations.push_back( std::make_pair( name, UNIFORM_NOT_QUERIED ) );
+ return index;
}
GLint Program::GetUniformLocation( unsigned int uniformIndex )
{
- GLint location = UNIFORM_NOT_QUERIED;
- // is it built in
- if( uniformIndex < UNIFORM_TYPE_LAST )
- {
- // check if we have already queried the location of the uniform
- location = mBuiltinUniformLocations[ uniformIndex ];
- if( location == UNIFORM_NOT_QUERIED )
- {
- LOG_GL( "GetUniformLocation(program=%d,%s) = %d\n", mProgramId, mBuiltinUniformLocations[ uniformIndex ], gStdUniforms[ uniformIndex ] );
- location = CHECK_GL( mContext, mGlAbstraction.GetUniformLocation( mProgramId, gStdUniforms[ uniformIndex ] ) );
+ // debug check that index is within name cache
+ DALI_ASSERT_DEBUG( mUniformLocations.size() > uniformIndex );
- mBuiltinUniformLocations[ uniformIndex ] = location;
- }
- }
- else
+ // check if we have already queried the location of the uniform
+ GLint location = mUniformLocations[ uniformIndex ].second;
+
+ if( location == UNIFORM_NOT_QUERIED )
{
- // translate the index to custom locations vector
- unsigned int customIndex = uniformIndex - UNIFORM_TYPE_LAST;
- if( customIndex < mCustomUniformLocations.size() ) // custom uniform
- {
- // check if we have already queried the location of the uniform
- location = mCustomUniformLocations[ customIndex ].second;
- if( location == UNIFORM_NOT_QUERIED )
- {
- LOG_GL( "GetUniformLocation(program=%d,%s) = %d\n", mProgramId, mCustomUniformLocations[ customIndex ].first, mCustomUniformLocations[ customIndex ].second );
- location = CHECK_GL( mContext, mGlAbstraction.GetUniformLocation( mProgramId, mCustomUniformLocations[ customIndex ].first ) );
+ location = CHECK_GL( mGlAbstraction, mGlAbstraction.GetUniformLocation( mProgramId, mUniformLocations[ uniformIndex ].first.c_str() ) );
- mCustomUniformLocations[ customIndex ].second = location;
- }
- }
+ mUniformLocations[ uniformIndex ].second = location;
+ LOG_GL( "GetUniformLocation(program=%d,%s) = %d\n", mProgramId, mUniformLocations[ uniformIndex ].first.c_str(), mUniformLocations[ uniformIndex ].second );
}
return location;
// check if uniform location fits the cache
if( location >= MAX_UNIFORM_CACHE_SIZE )
{
- // not cached, make the gl call through context
+ // not cached, make the gl call
LOG_GL( "Uniform1i(%d,%d)\n", location, value0 );
- CHECK_GL( mContext, mGlAbstraction.Uniform1i( location, value0 ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform1i( location, value0 ) );
}
else
{
// check if the value is different from what's already been set
if( value0 != mUniformCacheInt[ location ] )
{
- // make the gl call through context
+ // make the gl call
LOG_GL( "Uniform1i(%d,%d)\n", location, value0 );
- CHECK_GL( mContext, mGlAbstraction.Uniform1i( location, value0 ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform1i( location, value0 ) );
// update cache
mUniformCacheInt[ location ] = value0;
}
// Not caching these as based on current analysis this is not called that often by our shaders
LOG_GL( "Uniform4i(%d,%d,%d,%d,%d)\n", location, value0, value1, value2, value3 );
- CHECK_GL( mContext, mGlAbstraction.Uniform4i( location, value0, value1, value2, value3 ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform4i( location, value0, value1, value2, value3 ) );
}
void Program::SetUniform1f( GLint location, GLfloat value0 )
// check if uniform location fits the cache
if( location >= MAX_UNIFORM_CACHE_SIZE )
{
- // not cached, make the gl call through context
+ // not cached, make the gl call
LOG_GL( "Uniform1f(%d,%f)\n", location, value0 );
- CHECK_GL( mContext, mGlAbstraction.Uniform1f( location, value0 ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform1f( location, value0 ) );
}
else
{
// check if the same value has already been set, reset if it is different
if( ( fabsf(value0 - mUniformCacheFloat[ location ]) >= Math::MACHINE_EPSILON_1 ) )
{
- // make the gl call through context
+ // make the gl call
LOG_GL( "Uniform1f(%d,%f)\n", location, value0 );
- CHECK_GL( mContext, mGlAbstraction.Uniform1f( location, value0 ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform1f( location, value0 ) );
// update cache
mUniformCacheFloat[ location ] = value0;
// Not caching these as based on current analysis this is not called that often by our shaders
LOG_GL( "Uniform2f(%d,%f,%f)\n", location, value0, value1 );
- CHECK_GL( mContext, mGlAbstraction.Uniform2f( location, value0, value1 ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform2f( location, value0, value1 ) );
}
void Program::SetUniform3f( GLint location, GLfloat value0, GLfloat value1, GLfloat value2 )
// Not caching these as based on current analysis this is not called that often by our shaders
LOG_GL( "Uniform3f(%d,%f,%f,%f)\n", location, value0, value1, value2 );
- CHECK_GL( mContext, mGlAbstraction.Uniform3f( location, value0, value1, value2 ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform3f( location, value0, value1, value2 ) );
}
void Program::SetUniform4f( GLint location, GLfloat value0, GLfloat value1, GLfloat value2, GLfloat value3 )
// check if uniform location fits the cache
if( location >= MAX_UNIFORM_CACHE_SIZE )
{
- // not cached, make the gl call through context
+ // not cached, make the gl call
LOG_GL( "Uniform4f(%d,%f,%f,%f,%f)\n", location, value0, value1, value2, value3 );
- CHECK_GL( mContext, mGlAbstraction.Uniform4f( location, value0, value1, value2, value3 ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform4f( location, value0, value1, value2, value3 ) );
}
else
{
( fabsf(value1 - mUniformCacheFloat4[ location ][ 1 ]) >= Math::MACHINE_EPSILON_1 )||
( fabsf(value2 - mUniformCacheFloat4[ location ][ 2 ]) >= Math::MACHINE_EPSILON_1 ) )
{
- // make the gl call through context
+ // make the gl call
LOG_GL( "Uniform4f(%d,%f,%f,%f,%f)\n", location, value0, value1, value2, value3 );
- CHECK_GL( mContext, mGlAbstraction.Uniform4f( location, value0, value1, value2, value3 ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform4f( location, value0, value1, value2, value3 ) );
// update cache
mUniformCacheFloat4[ location ][ 0 ] = value0;
mUniformCacheFloat4[ location ][ 1 ] = value1;
return;
}
-
// Not caching these calls. Based on current analysis this is called very often
// but with different values (we're using this for MVP matrices)
- // NOTE! we never want GPU to transpose
+ // NOTE! we never want driver or GPU to transpose
LOG_GL( "UniformMatrix4fv(%d,%d,GL_FALSE,%x)\n", location, count, value );
- CHECK_GL( mContext, mGlAbstraction.UniformMatrix4fv( location, count, GL_FALSE, value ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.UniformMatrix4fv( location, count, GL_FALSE, value ) );
}
void Program::SetUniformMatrix3fv( GLint location, GLsizei count, const GLfloat* value )
// Not caching these calls. Based on current analysis this is called very often
// but with different values (we're using this for MVP matrices)
- // NOTE! we never want GPU to transpose
+ // NOTE! we never want driver or GPU to transpose
LOG_GL( "UniformMatrix3fv(%d,%d,GL_FALSE,%x)\n", location, count, value );
- CHECK_GL( mContext, mGlAbstraction.UniformMatrix3fv( location, count, GL_FALSE, value ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.UniformMatrix3fv( location, count, GL_FALSE, value ) );
}
void Program::GlContextCreated()
{
- if (!mLinked)
- {
- Load();
- }
}
void Program::GlContextDestroyed()
{
- Unload();
-
+ mLinked = false;
mVertexShaderId = 0;
mFragmentShaderId = 0;
mProgramId = 0;
- mContext.SetCurrentProgram( NULL );
- ResetAttribsUniforms();
+ ResetAttribsUniformCache();
}
-Program::Program(Integration::ShaderData* shaderData, Context& context )
-: mContext( context ),
- mGlAbstraction( context.GetAbstraction() ),
+bool Program::ModifiesGeometry()
+{
+ return mModifiesGeometry;
+}
+
+Program::Program( ProgramCache& cache, Integration::ShaderDataPtr shaderData, bool modifiesGeometry )
+: mCache( cache ),
+ mGlAbstraction( mCache.GetGlAbstraction() ),
+ mProjectionMatrix( NULL ),
+ mViewMatrix( NULL ),
mLinked( false ),
mVertexShaderId( 0 ),
mFragmentShaderId( 0 ),
mProgramId( 0 ),
- mProgramData(shaderData)
+ mProgramData(shaderData),
+ mModifiesGeometry( modifiesGeometry )
{
+ // reserve space for standard uniforms
+ mUniformLocations.reserve( UNIFORM_TYPE_LAST );
+ // reset built in uniform names in cache
+ for( int i = 0; i < UNIFORM_TYPE_LAST; ++i )
+ {
+ RegisterUniform( gStdUniforms[ i ] );
+ }
// reset values
- ResetAttribsUniforms();
+ ResetAttribsUniformCache();
}
Program::~Program()
{
- Unload(); // Resets gCurrentProgram
+ Unload();
}
void Program::Load()
{
- DALI_ASSERT_ALWAYS( NULL != mProgramData && "Program data is not initialized" );
-
- Unload();
+ DALI_ASSERT_ALWAYS( NULL != mProgramData.Get() && "Program data is not initialized" );
LOG_GL( "CreateProgram()\n" );
- mProgramId = CHECK_GL( mContext, mGlAbstraction.CreateProgram() );
+ mProgramId = CHECK_GL( mGlAbstraction, mGlAbstraction.CreateProgram() );
GLint linked = GL_FALSE;
- // ShaderData contains compiled bytecode?
- if( 0 != mContext.CachedNumberOfProgramBinaryFormats() && mProgramData->HasBinary() )
+ const bool binariesSupported = mCache.IsBinarySupported();
+
+ // if shader binaries are supported and ShaderData contains compiled bytecode?
+ if( binariesSupported && mProgramData->HasBinary() )
{
- DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "Program::Load() - Using Compiled Shader, Size = %d\n", mProgramData->buffer.size());
+ DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "Program::Load() - Using Compiled Shader, Size = %d\n", mProgramData->GetBufferSize());
- CHECK_GL( mContext, mGlAbstraction.ProgramBinary(mProgramId, mContext.CachedProgramBinaryFormat(), mProgramData->buffer.data(), mProgramData->buffer.size()) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.ProgramBinary(mProgramId, mCache.ProgramBinaryFormat(), mProgramData->GetBufferData(), mProgramData->GetBufferSize()) );
- CHECK_GL( mContext, mGlAbstraction.ValidateProgram(mProgramId) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.ValidateProgram(mProgramId) );
GLint success;
- CHECK_GL( mContext, mGlAbstraction.GetProgramiv( mProgramId, GL_VALIDATE_STATUS, &success ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.GetProgramiv( mProgramId, GL_VALIDATE_STATUS, &success ) );
DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "ValidateProgram Status = %d\n", success);
- CHECK_GL( mContext, mGlAbstraction.GetProgramiv( mProgramId, GL_LINK_STATUS, &linked ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.GetProgramiv( mProgramId, GL_LINK_STATUS, &linked ) );
if( GL_FALSE == linked )
{
DALI_LOG_ERROR("Failed to load program binary \n");
- char* szLog = NULL;
GLint nLength;
- CHECK_GL( mContext, mGlAbstraction.GetProgramiv( mProgramId, GL_INFO_LOG_LENGTH, &nLength) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.GetProgramiv( mProgramId, GL_INFO_LOG_LENGTH, &nLength) );
if(nLength > 0)
{
- szLog = new char[ nLength ];
- CHECK_GL( mContext, mGlAbstraction.GetProgramInfoLog( mProgramId, nLength, &nLength, szLog ) );
- DALI_LOG_ERROR( "Program Link Error: %s\n", szLog );
-
- delete [] szLog;
+ Dali::Vector< char > szLog;
+ szLog.Reserve( nLength ); // Don't call Resize as we don't want to initialise the data, just reserve a buffer
+ CHECK_GL( mGlAbstraction, mGlAbstraction.GetProgramInfoLog( mProgramId, nLength, &nLength, szLog.Begin() ) );
+ DALI_LOG_ERROR( "Program Link Error: %s\n", szLog.Begin() );
}
}
else
if( GL_FALSE == linked )
{
DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "Program::Load() - Runtime compilation\n");
- if( CompileShader( GL_VERTEX_SHADER, mVertexShaderId, mProgramData->vertexShader.c_str() ) )
+ if( CompileShader( GL_VERTEX_SHADER, mVertexShaderId, mProgramData->GetVertexShader() ) )
{
- if( CompileShader( GL_FRAGMENT_SHADER, mFragmentShaderId, mProgramData->fragmentShader.c_str() ) )
+ if( CompileShader( GL_FRAGMENT_SHADER, mFragmentShaderId, mProgramData->GetFragmentShader() ) )
{
Link();
- if( mLinked )
+ if( binariesSupported && mLinked )
{
GLint binaryLength = 0;
GLenum binaryFormat;
- CHECK_GL( mContext, mGlAbstraction.GetProgramiv(mProgramId, GL_PROGRAM_BINARY_LENGTH_OES, &binaryLength) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.GetProgramiv(mProgramId, GL_PROGRAM_BINARY_LENGTH_OES, &binaryLength) );
DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "Program::Load() - GL_PROGRAM_BINARY_LENGTH_OES: %d\n", binaryLength);
-
- // Allocate space for the bytecode in ShaderData
- mProgramData->AllocateBuffer(binaryLength);
- // Copy the bytecode to ShaderData
- CHECK_GL( mContext, mGlAbstraction.GetProgramBinary(mProgramId, binaryLength, NULL, &binaryFormat, mProgramData->buffer.data()) );
+ if( binaryLength > 0 )
+ {
+ // Allocate space for the bytecode in ShaderData
+ mProgramData->AllocateBuffer(binaryLength);
+ // Copy the bytecode to ShaderData
+ CHECK_GL( mGlAbstraction, mGlAbstraction.GetProgramBinary(mProgramId, binaryLength, NULL, &binaryFormat, mProgramData->GetBufferData()) );
+ mCache.StoreBinary( mProgramData );
+ }
}
}
}
// No longer needed
FreeShaders();
-
}
void Program::Unload()
{
FreeShaders();
- if( this == mContext.GetCurrentProgram() )
+ if( this == mCache.GetCurrentProgram() )
{
- CHECK_GL( mContext, mGlAbstraction.UseProgram(0) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.UseProgram(0) );
- mContext.SetCurrentProgram( NULL );
+ mCache.SetCurrentProgram( NULL );
}
if (mProgramId)
{
LOG_GL( "DeleteProgram(%d)\n", mProgramId );
- CHECK_GL( mContext, mGlAbstraction.DeleteProgram( mProgramId ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteProgram( mProgramId ) );
mProgramId = 0;
}
if (!shaderId)
{
LOG_GL( "CreateShader(%d)\n", shaderType );
- shaderId = CHECK_GL( mContext, mGlAbstraction.CreateShader( shaderType ) );
+ shaderId = CHECK_GL( mGlAbstraction, mGlAbstraction.CreateShader( shaderType ) );
LOG_GL( "AttachShader(%d,%d)\n", mProgramId, shaderId );
- CHECK_GL( mContext, mGlAbstraction.AttachShader( mProgramId, shaderId ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.AttachShader( mProgramId, shaderId ) );
}
LOG_GL( "ShaderSource(%d)\n", shaderId );
- CHECK_GL( mContext, mGlAbstraction.ShaderSource(shaderId, 1, &src, NULL ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.ShaderSource(shaderId, 1, &src, NULL ) );
LOG_GL( "CompileShader(%d)\n", shaderId );
- CHECK_GL( mContext, mGlAbstraction.CompileShader( shaderId ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.CompileShader( shaderId ) );
GLint compiled;
LOG_GL( "GetShaderiv(%d)\n", shaderId );
- CHECK_GL( mContext, mGlAbstraction.GetShaderiv( shaderId, GL_COMPILE_STATUS, &compiled ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.GetShaderiv( shaderId, GL_COMPILE_STATUS, &compiled ) );
if (compiled == GL_FALSE)
{
DALI_LOG_ERROR("Failed to compile shader\n");
LogWithLineNumbers(src);
- std::vector< char > szLog;
GLint nLength;
mGlAbstraction.GetShaderiv( shaderId, GL_INFO_LOG_LENGTH, &nLength);
if(nLength > 0)
{
- szLog.reserve( nLength );
- mGlAbstraction.GetShaderInfoLog( shaderId, nLength, &nLength, &szLog[ 0 ] );
- DALI_LOG_ERROR( "Shader Compiler Error: %s\n", &szLog[ 0 ] );
+ Dali::Vector< char > szLog;
+ szLog.Reserve( nLength ); // Don't call Resize as we don't want to initialise the data, just reserve a buffer
+ mGlAbstraction.GetShaderInfoLog( shaderId, nLength, &nLength, szLog.Begin() );
+ DALI_LOG_ERROR( "Shader Compiler Error: %s\n", szLog.Begin() );
}
- throw DaliException( "Shader compilation failure", &szLog[ 0 ] );
+ DALI_ASSERT_ALWAYS( 0 && "Shader compilation failure" );
}
return compiled != 0;
void Program::Link()
{
LOG_GL( "LinkProgram(%d)\n", mProgramId );
- CHECK_GL( mContext, mGlAbstraction.LinkProgram( mProgramId ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.LinkProgram( mProgramId ) );
GLint linked;
LOG_GL( "GetProgramiv(%d)\n", mProgramId );
- CHECK_GL( mContext, mGlAbstraction.GetProgramiv( mProgramId, GL_LINK_STATUS, &linked ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.GetProgramiv( mProgramId, GL_LINK_STATUS, &linked ) );
if (linked == GL_FALSE)
{
DALI_LOG_ERROR("Shader failed to link \n");
- char* szLog = NULL;
GLint nLength;
mGlAbstraction.GetProgramiv( mProgramId, GL_INFO_LOG_LENGTH, &nLength);
if(nLength > 0)
{
- szLog = new char[ nLength ];
- mGlAbstraction.GetProgramInfoLog( mProgramId, nLength, &nLength, szLog );
- DALI_LOG_ERROR( "Shader Link Error: %s\n", szLog );
- delete [] szLog;
+ Dali::Vector< char > szLog;
+ szLog.Reserve( nLength ); // Don't call Resize as we don't want to initialise the data, just reserve a buffer
+ mGlAbstraction.GetProgramInfoLog( mProgramId, nLength, &nLength, szLog.Begin() );
+ DALI_LOG_ERROR( "Shader Link Error: %s\n", szLog.Begin() );
}
- DALI_ASSERT_DEBUG(0);
+ DALI_ASSERT_ALWAYS( 0 && "Shader linking failure" );
}
mLinked = linked != GL_FALSE;
if (mVertexShaderId)
{
LOG_GL( "DeleteShader(%d)\n", mVertexShaderId );
- CHECK_GL( mContext, mGlAbstraction.DetachShader( mProgramId, mVertexShaderId ) );
- CHECK_GL( mContext, mGlAbstraction.DeleteShader( mVertexShaderId ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.DetachShader( mProgramId, mVertexShaderId ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteShader( mVertexShaderId ) );
mVertexShaderId = 0;
}
if (mFragmentShaderId)
{
LOG_GL( "DeleteShader(%d)\n", mFragmentShaderId );
- CHECK_GL( mContext, mGlAbstraction.DetachShader( mProgramId, mFragmentShaderId ) );
- CHECK_GL( mContext, mGlAbstraction.DeleteShader( mFragmentShaderId ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.DetachShader( mProgramId, mFragmentShaderId ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.DeleteShader( mFragmentShaderId ) );
mFragmentShaderId = 0;
}
}
-void Program::ResetAttribsUniforms()
+void Program::ResetAttribsUniformCache()
{
// reset attribute locations
for( unsigned i = 0; i < ATTRIB_TYPE_LAST; ++i )
}
// reset all gl uniform locations
- for( unsigned int i = 0; i < UNIFORM_TYPE_LAST; ++i )
- {
- mBuiltinUniformLocations[ i ] = UNIFORM_NOT_QUERIED;
- }
- for( unsigned int i = 0; i < mCustomUniformLocations.size(); ++i )
+ for( unsigned int i = 0; i < mUniformLocations.size(); ++i )
{
- mCustomUniformLocations[ i ].second = UNIFORM_NOT_QUERIED;
+ // reset gl program locations and names
+ mUniformLocations[ i ].second = UNIFORM_NOT_QUERIED;
}
// reset uniform cache
projects / platform / core / uifw / dali-core.git / blobdiff