X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Frender%2Fshaders%2Fprogram.cpp;h=451de0bb6c7083eeccb9bf7e90e73e82b30a29c9;hb=649ec06daecb510fb84fe4642a6af957f127e7ab;hp=7c1282bdd67bdf17f43ea4a49784382d57a4b8a8;hpb=16a3dd40ed62ff48f86c02d3445c0e58577c4550;p=platform%2Fcore%2Fuifw%2Fdali-core.git

diff --git a/dali/internal/render/shaders/program.cpp b/dali/internal/render/shaders/program.cpp
index 7c1282b..451de0b 100644
--- a/dali/internal/render/shaders/program.cpp
+++ b/dali/internal/render/shaders/program.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@
 
 // EXTERNAL INCLUDES
 #include <iomanip>
+#include <cstring>
 
 // INTERNAL INCLUDES
 #include <dali/public-api/common/dali-common.h>
@@ -79,11 +80,7 @@ namespace
 const char* gStdAttribs[ Program::ATTRIB_TYPE_LAST ] =
 {
   "aPosition",    // ATTRIB_POSITION
-  "aNormal",      // ATTRIB_NORMAL
   "aTexCoord",    // ATTRIB_TEXCOORD
-  "aColor",       // ATTRIB_COLOR
-  "aBoneWeights", // ATTRIB_BONE_WEIGHTS
-  "aBoneIndices"  // ATTRIB_BONE_INDICES
 };
 
 const char* gStdUniforms[ Program::UNIFORM_TYPE_LAST ] =
@@ -95,14 +92,9 @@ const char* gStdUniforms[ Program::UNIFORM_TYPE_LAST ] =
   "uViewMatrix",          // UNIFORM_VIEW_MATRIX,
   "uNormalMatrix",        // UNIFORM_NORMAL_MATRIX
   "uColor",               // UNIFORM_COLOR
-  "uCustomTextureCoords", // UNIFORM_CUSTOM_TEXTURE_COORDS
   "sTexture",             // UNIFORM_SAMPLER
   "sTextureRect",         // UNIFORM_SAMPLER_RECT
   "sEffect",              // UNIFORM_EFFECT_SAMPLER
-  "sEffectRect",          // UNIFORM_EFFECT_SAMPLER_RECT
-  "uTimeDelta",           // UNIFORM_TIME_DELTA
-  "sOpacityTexture",      // UNIFORM_SAMPLER_OPACITY
-  "sNormalMapTexture",    // UNIFORM_SAMPLER_NORMAL_MAP
   "uSize"                 // UNIFORM_SIZE
 };
 
@@ -119,9 +111,7 @@ Program* Program::New( ProgramCache& cache, Internal::ShaderDataPtr shaderData,
   {
     // program not found so create it
     program = new Program( cache, shaderData, modifiesGeometry );
-
-    // we want to lazy load programs so dont do a Load yet, it gets done in Use()
-
+    program->Load();
     cache.AddProgram( shaderHash, program );
   }
 
@@ -130,11 +120,6 @@ Program* Program::New( ProgramCache& cache, Internal::ShaderDataPtr shaderData,
 
 void Program::Use()
 {
-  if ( !mLinked )
-  {
-    Load();
-  }
-
   if ( mLinked )
   {
     if ( this != mCache.GetCurrentProgram() )
@@ -232,6 +217,125 @@ GLint Program::GetUniformLocation( unsigned int uniformIndex )
   return location;
 }
 
+namespace
+{
+/**
+ * This struct is used to record the position of a uniform declaration
+ * within the fragment shader source code.
+ */
+struct LocationPosition
+{
+  GLint uniformLocation; ///< The location of the uniform (used as an identifier)
+  int position;          ///< the position of the uniform declaration
+  LocationPosition( GLint uniformLocation, int position )
+  : uniformLocation(uniformLocation), position(position)
+  {
+  }
+};
+
+bool sortByPosition( LocationPosition a, LocationPosition b )
+{
+  return a.position < b.position;
+}
+}
+
+void Program::GetActiveSamplerUniforms()
+{
+  GLint numberOfActiveUniforms = -1;
+  GLint uniformMaxNameLength=-1;
+
+  mGlAbstraction.GetProgramiv( mProgramId, GL_ACTIVE_UNIFORMS, &numberOfActiveUniforms );
+  mGlAbstraction.GetProgramiv( mProgramId, GL_ACTIVE_UNIFORM_MAX_LENGTH, &uniformMaxNameLength );
+
+  std::vector<std::string> samplerNames;
+  char name[uniformMaxNameLength+1]; // Allow for null terminator
+  std::vector< LocationPosition >  samplerUniformLocations;
+
+  {
+    int nameLength = -1;
+    int number = -1;
+    GLenum type = GL_ZERO;
+
+    for( int i=0; i<numberOfActiveUniforms; ++i )
+    {
+      mGlAbstraction.GetActiveUniform( mProgramId, static_cast< GLuint >( i ), uniformMaxNameLength,
+                                       &nameLength, &number, &type, name );
+
+      if( type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE || type == GL_SAMPLER_EXTERNAL_OES )
+      {
+        GLuint location = mGlAbstraction.GetUniformLocation( mProgramId, name );
+        samplerNames.push_back(name);
+        samplerUniformLocations.push_back(LocationPosition(location, -1));
+      }
+    }
+  }
+
+  //Determine declaration order of each sampler
+  char* fragShader = strdup( mProgramData->GetFragmentShader() );
+  char* nextPtr = NULL;
+  const char* token = strtok_r( fragShader, " ;\n", &nextPtr );
+  int samplerPosition = 0;
+  while( token )
+  {
+    if( ( strncmp( token, "sampler2D", 9u )    == 0 ) ||
+        ( strncmp( token, "samplerCube", 11u ) == 0 ) ||
+        ( strncmp( token, "samplerExternalOES", 18u ) == 0 ) )
+    {
+      bool found( false );
+      token = strtok_r( NULL, " ;\n", &nextPtr );
+      for( size_t i=0; i<samplerUniformLocations.size(); ++i )
+      {
+        if( samplerUniformLocations[i].position == -1 &&
+            strncmp( token, samplerNames[i].c_str(), samplerNames[i].size() ) == 0 )
+        {
+          samplerUniformLocations[i].position = samplerPosition++;
+          found = true;
+          break;
+        }
+      }
+      if( !found )
+      {
+        DALI_LOG_ERROR("Sampler uniform %s declared but not used in the shader\n", token );
+      }
+    }
+    else
+    {
+      token = strtok_r( NULL, " ;\n", &nextPtr );
+    }
+  }
+
+  free( fragShader );
+
+  // Re-order according to declaration order in the fragment source.
+  size_t samplerUniformCount = samplerUniformLocations.size();
+  if( samplerUniformCount > 1 )
+  {
+    std::sort( samplerUniformLocations.begin(), samplerUniformLocations.end(), sortByPosition);
+  }
+
+  mSamplerUniformLocations.resize( samplerUniformCount );
+  for( size_t i=0; i<samplerUniformCount; ++i )
+  {
+    mSamplerUniformLocations[i] = samplerUniformLocations[i].uniformLocation;
+  }
+}
+
+bool Program::GetSamplerUniformLocation( unsigned int index, GLint& location  )
+{
+  bool result = false;
+  if( index < mSamplerUniformLocations.size() )
+  {
+    location = mSamplerUniformLocations[index];
+    result = true;
+  }
+  return result;
+}
+
+size_t Program::GetActiveSamplerCount() const
+{
+  return mSamplerUniformLocations.size();
+}
+
 void Program::SetUniform1i( GLint location, GLint value0 )
 {
   DALI_ASSERT_DEBUG( IsUsed() ); // should not call this if this program is not used
@@ -328,9 +432,28 @@ void Program::SetUniform2f( GLint location, GLfloat value0, GLfloat value1 )
     return;
   }
 
-  // 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( mGlAbstraction, mGlAbstraction.Uniform2f( location, value0, value1 ) );
+  // check if uniform location fits the cache
+  if( location >= MAX_UNIFORM_CACHE_SIZE )
+  {
+    // not cached, make the gl call
+    LOG_GL( "Uniform2f(%d,%f,%f)\n", location, value0, value1 );
+    CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform2f( location, value0, value1 ) );
+  }
+  else
+  {
+    // check if the same value has already been set, reset if it is different
+    if( ( fabsf(value0 - mUniformCacheFloat2[ location ][ 0 ]) >= Math::MACHINE_EPSILON_1 )||
+        ( fabsf(value1 - mUniformCacheFloat2[ location ][ 1 ]) >= Math::MACHINE_EPSILON_1 ) )
+    {
+      // make the gl call
+      LOG_GL( "Uniform2f(%d,%f,%f)\n", location, value0, value1 );
+      CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform2f( location, value0, value1 ) );
+
+      // update cache
+      mUniformCacheFloat2[ location ][ 0 ] = value0;
+      mUniformCacheFloat2[ location ][ 1 ] = value1;
+    }
+  }
 }
 
 void Program::SetSizeUniform3f( GLint location, GLfloat value0, GLfloat value1, GLfloat value2 )
@@ -487,6 +610,7 @@ Program::Program( ProgramCache& cache, Internal::ShaderDataPtr shaderData, bool
   {
     RegisterUniform( gStdUniforms[ i ] );
   }
+
   // reset values
   ResetAttribsUniformCache();
 }
@@ -577,6 +701,8 @@ void Program::Load()
     }
   }
 
+  GetActiveSamplerUniforms();
+
   // No longer needed
   FreeShaders();
 }
@@ -707,6 +833,8 @@ void Program::ResetAttribsUniformCache()
     mUniformLocations[ i ].second = UNIFORM_NOT_QUERIED;
   }
 
+  mSamplerUniformLocations.clear();
+
   // reset uniform caches
   mSizeUniformCache.x = mSizeUniformCache.y = mSizeUniformCache.z = 0.f;
 
@@ -715,6 +843,8 @@ void Program::ResetAttribsUniformCache()
     // GL initializes uniforms to 0
     mUniformCacheInt[ i ] = 0;
     mUniformCacheFloat[ i ] = 0.0f;
+    mUniformCacheFloat2[ i ][ 0 ] = 0.0f;
+    mUniformCacheFloat2[ i ][ 1 ] = 0.0f;
     mUniformCacheFloat4[ i ][ 0 ] = 0.0f;
     mUniformCacheFloat4[ i ][ 1 ] = 0.0f;
     mUniformCacheFloat4[ i ][ 2 ] = 0.0f;