dali/internal/render/shaders/program.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/render/shaders/program.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <cstring>
  23 #include <map>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/devel-api/common/hash.h>
  27 #include <dali/graphics-api/graphics-controller.h>
  28 #include <dali/graphics-api/graphics-program.h>
  29 #include <dali/graphics-api/graphics-reflection.h>
  30 #include <dali/integration-api/debug.h>
  31 #include <dali/internal/common/shader-data.h>
  32 #include <dali/internal/render/common/performance-monitor.h>
  33 #include <dali/internal/render/shaders/program-cache.h>
  34 #include <dali/public-api/common/constants.h>
  35 #include <dali/public-api/common/dali-common.h>
  36 #include <dali/public-api/common/dali-vector.h>
  37
  38 namespace Dali
  39 {
  40 namespace Internal
  41 {
  42 // LOCAL STUFF
  43 namespace
  44 {
  45 const unsigned int NUMBER_OF_DEFAULT_UNIFORMS = static_cast<unsigned int>(Program::DefaultUniformIndex::COUNT);
  46
  47 /**
  48  * List of all default uniforms used for quicker lookup
  49  */
  50 size_t DEFAULT_UNIFORM_HASHTABLE[NUMBER_OF_DEFAULT_UNIFORMS] =
  51   {
  52     CalculateHash(std::string("uModelMatrix")),
  53     CalculateHash(std::string("uMvpMatrix")),
  54     CalculateHash(std::string("uViewMatrix")),
  55     CalculateHash(std::string("uModelView")),
  56     CalculateHash(std::string("uNormalMatrix")),
  57     CalculateHash(std::string("uProjection")),
  58     CalculateHash(std::string("uSize")),
  59     CalculateHash(std::string("uColor")),
  60     CalculateHash(std::string("uActorColor"))};
  61
  62 /**
  63  * Helper function to calculate the correct alignment of data for uniform buffers
  64  * @param dataSize size of uniform buffer
  65  * @return aligned offset of data
  66  */
  67 inline uint32_t GetUniformBufferDataAlignment(uint32_t dataSize)
  68 {
  69   return ((dataSize / 256u) + ((dataSize % 256u) ? 1u : 0u)) * 256u;
  70 }
  71
  72 } // namespace
  73
  74 // IMPLEMENTATION
  75
  76 Program* Program::New(ProgramCache& cache, Internal::ShaderDataPtr shaderData, Graphics::Controller& gfxController)
  77 {
  78   size_t shaderHash = shaderData->GetHashValue();
  79
  80   Program* program = cache.GetProgram(shaderHash);
  81
  82   if(nullptr == program)
  83   {
  84     // program not found so create it
  85     program = new Program(cache, shaderData, gfxController);
  86     cache.AddProgram(shaderHash, program);
  87   }
  88
  89   return program;
  90 }
  91
  92 Program::Program(ProgramCache& cache, Internal::ShaderDataPtr shaderData, Graphics::Controller& controller)
  93 : mCache(cache),
  94   mProjectionMatrix(nullptr),
  95   mViewMatrix(nullptr),
  96   mGfxProgram(nullptr),
  97   mGfxController(controller),
  98   mProgramData(shaderData)
  99 {
 100 }
 101
 102 Program::~Program() = default;
 103
 104 void Program::BuildReflection(const Graphics::Reflection& graphicsReflection)
 105 {
 106   mReflectionDefaultUniforms.clear();
 107   mReflectionDefaultUniforms.resize(NUMBER_OF_DEFAULT_UNIFORMS);
 108
 109   auto uniformBlockCount = graphicsReflection.GetUniformBlockCount();
 110
 111   // add uniform block fields
 112   for(auto i = 0u; i < uniformBlockCount; ++i)
 113   {
 114     Graphics::UniformBlockInfo uboInfo;
 115     graphicsReflection.GetUniformBlock(i, uboInfo);
 116
 117     // for each member store data
 118     for(const auto& item : uboInfo.members)
 119     {
 120       auto hashValue = CalculateHash(item.name);
 121       mReflection.emplace_back(ReflectionUniformInfo{hashValue, false, item});
 122
 123       // update buffer index
 124       mReflection.back().uniformInfo.bufferIndex = i;
 125
 126       // Update default uniforms
 127       for(auto j = 0u; j < NUMBER_OF_DEFAULT_UNIFORMS; ++j)
 128       {
 129         if(hashValue == DEFAULT_UNIFORM_HASHTABLE[j])
 130         {
 131           mReflectionDefaultUniforms[j] = mReflection.back();
 132           break;
 133         }
 134       }
 135     }
 136   }
 137
 138   // add samplers
 139   auto samplers = graphicsReflection.GetSamplers();
 140   for(const auto& sampler : samplers)
 141   {
 142     mReflection.emplace_back(ReflectionUniformInfo{CalculateHash(sampler.name), false, sampler});
 143   }
 144
 145   // check for potential collisions
 146   std::map<size_t, bool> hashTest;
 147   bool                   hasCollisions(false);
 148   for(auto&& item : mReflection)
 149   {
 150     if(hashTest.find(item.hashValue) == hashTest.end())
 151     {
 152       hashTest[item.hashValue] = false;
 153     }
 154     else
 155     {
 156       hashTest[item.hashValue] = true;
 157       hasCollisions            = true;
 158     }
 159   }
 160
 161   // update collision flag for further use
 162   if(hasCollisions)
 163   {
 164     for(auto&& item : mReflection)
 165     {
 166       item.hasCollision = hashTest[item.hashValue];
 167     }
 168   }
 169
 170   // Calculate size of memory for uniform blocks
 171   mUniformBlockRequirements.totalSizeRequired = 0;
 172   mUniformBlockRequirements.blockCount = graphicsReflection.GetUniformBlockCount();
 173   for (auto i = 0u; i < mUniformBlockRequirements.blockCount; ++i)
 174   {
 175     auto blockSize = GetUniformBufferDataAlignment(graphicsReflection.GetUniformBlockSize(i));
 176     mUniformBlockRequirements.totalSizeRequired += blockSize;
 177   }
 178 }
 179
 180 void Program::SetGraphicsProgram( Graphics::UniquePtr<Graphics::Program>&& program )
 181 {
 182   mGfxProgram = std::move(program);
 183   BuildReflection(mGfxController.GetProgramReflection(*mGfxProgram.get()));
 184 }
 185
 186
 187 bool Program::GetUniform(const std::string& name, size_t hashedName, Graphics::UniformInfo& out) const
 188 {
 189   if(mReflection.empty())
 190   {
 191     return false;
 192   }
 193
 194   hashedName = !hashedName ? CalculateHash(name, '[') : hashedName;
 195
 196   for(const ReflectionUniformInfo& item : mReflection)
 197   {
 198     if(item.hashValue == hashedName)
 199     {
 200       if(!item.hasCollision || item.uniformInfo.name == name)
 201       {
 202         out = item.uniformInfo;
 203         return true;
 204       }
 205       else
 206       {
 207         return false;
 208       }
 209     }
 210   }
 211   return false;
 212 }
 213
 214 const Graphics::UniformInfo* Program::GetDefaultUniform(DefaultUniformIndex defaultUniformIndex) const
 215 {
 216   if(mReflectionDefaultUniforms.empty())
 217   {
 218     return nullptr;
 219   }
 220
 221   const auto value = &mReflectionDefaultUniforms[static_cast<uint32_t>(defaultUniformIndex)];
 222   return &value->uniformInfo;
 223 }
 224
 225 } // namespace Internal
 226
 227 } // namespace Dali