[Tizen] Support int uniform in shader

[platform/core/uifw/dali-adaptor.git] / dali / internal / graphics / gles-impl / gles-graphics-program.cpp

diff --git a/dali/internal/graphics/gles-impl/gles-graphics-program.cpp b/dali/internal/graphics/gles-impl/gles-graphics-program.cpp
index 64de708..8fa051c 100644 (file)
--- a/dali/internal/graphics/gles-impl/gles-graphics-program.cpp
+++ b/dali/internal/graphics/gles-impl/gles-graphics-program.cpp
@@ -28,6 +28,47 @@
 
 namespace Dali::Graphics::GLES
 {
+using Integration::GlAbstraction;
+
+/**
+ * Memory compare working on 4-byte types. Since all types used in shaders are
+ * size of 4*N then no need for size and alignment checks.
+ */
+template<class A, class B>
+inline bool memcmp4(A* a, B* b, uint32_t size)
+{
+  auto* pa = reinterpret_cast<const uint32_t*>(a);
+  auto* pb = reinterpret_cast<const uint32_t*>(b);
+  size >>= 2;
+  while(size-- && *pa++ == *pb++)
+    ;
+  return (-1u == size);
+};
+
+/**
+ * Structure stores pointer to the function
+ * which will set the uniform of particular type
+ */
+struct UniformSetter
+{
+  union
+  {
+    void (GlAbstraction::*uniformfProc)(GLint, GLsizei, const float*);
+    void (GlAbstraction::*uniformiProc)(GLint, GLsizei, const int*);
+    void (GlAbstraction::*uniformMatrixProc)(GLint, GLsizei, GLboolean, const float*);
+  };
+
+  enum class Type
+  {
+    UNDEFINED = 0,
+    FLOAT,
+    INT,
+    MATRIX
+  };
+
+  Type type;
+};
+
 struct ProgramImpl::Impl
 {
   explicit Impl(EglGraphicsController& _controller, const ProgramCreateInfo& info)
@@ -51,6 +92,12 @@ struct ProgramImpl::Impl
   uint32_t               refCount{0u};
 
   std::unique_ptr<GLES::Reflection> reflection{nullptr};
+
+  // Uniform cache
+  std::vector<uint8_t> uniformData;
+
+  // List of standalone uniform setters
+  std::vector<UniformSetter> uniformSetters;
 };
 
 ProgramImpl::ProgramImpl(const Graphics::ProgramCreateInfo& createInfo, Graphics::EglGraphicsController& controller)
@@ -125,6 +172,20 @@ bool ProgramImpl::Create()
   mImpl->reflection->BuildUniformReflection();
   mImpl->reflection->BuildVertexAttributeReflection();
 
+  // populate uniform cache memory for standalone uniforms (it's not needed
+  // for real UBOs as real UBOs work with whole memory blocks)
+  auto& reflection = mImpl->reflection;
+  if(!reflection->GetStandaloneUniformExtraInfo().empty())
+  {
+    UniformBlockInfo blockInfo;
+    mImpl->reflection->GetUniformBlock(0, blockInfo);
+    auto uniformCacheSize = blockInfo.size;
+    mImpl->uniformData.resize(uniformCacheSize);
+
+    std::fill(mImpl->uniformData.begin(), mImpl->uniformData.end(), 0);
+
+    BuildStandaloneUniformCache();
+  }
   return true;
 }
 
@@ -168,6 +229,144 @@ const ProgramCreateInfo& ProgramImpl::GetCreateInfo() const
   return mImpl->createInfo;
 }
 
+void ProgramImpl::UpdateStandaloneUniformBlock(const char* ptr)
+{
+  const auto& reflection = GetReflection();
+
+  const auto& extraInfos = reflection.GetStandaloneUniformExtraInfo();
+
+  auto& gl = *GetController().GetGL();
+
+  // Set uniforms
+  int  index    = 0;
+  auto cachePtr = reinterpret_cast<char*>(mImpl->uniformData.data());
+  for(const auto& info : extraInfos)
+  {
+    auto& setter = mImpl->uniformSetters[index++];
+    auto  offset = info.offset;
+    if(!memcmp4(&cachePtr[offset], &ptr[offset], info.size * info.arraySize))
+    {
+      switch(setter.type)
+      {
+        case UniformSetter::Type::FLOAT:
+        {
+          (gl.*(setter.uniformfProc))(info.location, info.arraySize, reinterpret_cast<const float*>(&ptr[offset]));
+          break;
+        }
+        case UniformSetter::Type::INT:
+        {
+          (gl.*(setter.uniformiProc))(info.location, info.arraySize, reinterpret_cast<const int*>(&ptr[offset]));
+          break;
+        }
+        case UniformSetter::Type::MATRIX:
+        {
+          (gl.*(setter.uniformMatrixProc))(info.location, info.arraySize, GL_FALSE, reinterpret_cast<const float*>(&ptr[offset]));
+          break;
+        }
+        case UniformSetter::Type::UNDEFINED:
+        {
+        }
+      }
+    }
+  }
+  // Update caches
+  memmove(mImpl->uniformData.data(), ptr, mImpl->uniformData.size());
+}
+
+void ProgramImpl::BuildStandaloneUniformCache()
+{
+  const auto& reflection = GetReflection();
+  const auto& extraInfos = reflection.GetStandaloneUniformExtraInfo();
+
+  // Prepare pointers to the uniform setter calls
+  mImpl->uniformSetters.resize(extraInfos.size());
+  int index = 0;
+  for(const auto& info : extraInfos)
+  {
+    auto type                         = GLTypeConversion(info.type).type;
+    mImpl->uniformSetters[index].type = UniformSetter::Type::UNDEFINED;
+    switch(type)
+    {
+      case GLType::FLOAT_VEC2:
+      {
+        mImpl->uniformSetters[index].uniformfProc = &GlAbstraction::Uniform2fv;
+        mImpl->uniformSetters[index].type         = UniformSetter::Type::FLOAT;
+        break;
+      }
+      case GLType::FLOAT_VEC3:
+      {
+        mImpl->uniformSetters[index].uniformfProc = &GlAbstraction::Uniform3fv;
+        mImpl->uniformSetters[index].type         = UniformSetter::Type::FLOAT;
+        break;
+      }
+      case GLType::FLOAT_VEC4:
+      {
+        mImpl->uniformSetters[index].uniformfProc = &GlAbstraction::Uniform4fv;
+        mImpl->uniformSetters[index].type         = UniformSetter::Type::FLOAT;
+        break;
+      }
+      case GLType::INT_VEC2:
+      {
+        mImpl->uniformSetters[index].uniformiProc = &GlAbstraction::Uniform2iv;
+        mImpl->uniformSetters[index].type         = UniformSetter::Type::INT;
+        break;
+      }
+      case GLType::INT_VEC3:
+      {
+        mImpl->uniformSetters[index].uniformiProc = &GlAbstraction::Uniform3iv;
+        mImpl->uniformSetters[index].type         = UniformSetter::Type::INT;
+        break;
+      }
+      case GLType::INT_VEC4:
+      {
+        mImpl->uniformSetters[index].uniformiProc = &GlAbstraction::Uniform4iv;
+        mImpl->uniformSetters[index].type         = UniformSetter::Type::INT;
+        break;
+      }
+      case GLType::INT:
+      {
+        mImpl->uniformSetters[index].uniformiProc = &GlAbstraction::Uniform1iv;
+        mImpl->uniformSetters[index].type         = UniformSetter::Type::INT;
+        break;
+      }
+      case GLType::BOOL:
+      case GLType::BOOL_VEC2:
+      case GLType::BOOL_VEC3:
+      case GLType::BOOL_VEC4:
+      case GLType::FLOAT:
+      {
+        mImpl->uniformSetters[index].uniformfProc = &GlAbstraction::Uniform1fv;
+        mImpl->uniformSetters[index].type         = UniformSetter::Type::FLOAT;
+        break;
+      }
+      case GLType::FLOAT_MAT2:
+      {
+        mImpl->uniformSetters[index].uniformMatrixProc = &GlAbstraction::UniformMatrix2fv;
+        mImpl->uniformSetters[index].type              = UniformSetter::Type::MATRIX;
+        break;
+      }
+      case GLType::FLOAT_MAT3:
+      {
+        mImpl->uniformSetters[index].uniformMatrixProc = &GlAbstraction::UniformMatrix3fv;
+        mImpl->uniformSetters[index].type              = UniformSetter::Type::MATRIX;
+        break;
+      }
+      case GLType::FLOAT_MAT4:
+      {
+        mImpl->uniformSetters[index].uniformMatrixProc = &GlAbstraction::UniformMatrix4fv;
+        mImpl->uniformSetters[index].type              = UniformSetter::Type::MATRIX;
+        break;
+      }
+      case GLType::SAMPLER_2D:
+      case GLType::SAMPLER_CUBE:
+      default:
+      {
+      }
+    }
+    index++;
+  }
+}
+
 Program::~Program()
 {
   // Destroy GL resources of implementation. This should happen