dali/internal/event/effects/shader-factory.cpp

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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 // CLASS HEADER
  18 #include <dali/internal/event/effects/shader-factory.h>
  19
  20 // EXTERNAL INCLUDES
  21 #include <algorithm>
  22 #include <sstream>
  23 #include <boost/functional/hash.hpp>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/public-api/common/dali-common.h>
  27 #include <dali/integration-api/debug.h>
  28 #include <dali/internal/event/resources/resource-client.h>
  29 #include <dali/internal/event/effects/shader-effect-impl.h>
  30 #include <dali/internal/event/effects/shader-declarations.h>
  31
  32 // the generated shader strings
  33 #include "dali-shaders.h"
  34
  35
  36 // Use pre-compiler constants in order to utilize string concatenation
  37 #define SHADER_DEF_USE_BONES    "#define USE_BONES\n"
  38 #define SHADER_DEF_USE_LIGHTING "#define USE_LIGHTING\n"
  39 #define SHADER_DEF_USE_COLOR    "#define USE_COLOR\n"
  40 #define SHADER_DEF_USE_GRADIENT "#define USE_GRADIENT\n"
  41
  42 using namespace Dali::Integration;
  43
  44 namespace Dali
  45 {
  46
  47 namespace Internal
  48 {
  49
  50 ShaderFactory::ShaderFactory(ResourceClient& resourceClient)
  51 : mResourceClient(resourceClient)
  52 {
  53 }
  54
  55 ShaderFactory::~ShaderFactory()
  56 {
  57 }
  58
  59 ResourceTicketPtr ShaderFactory::Load(const std::string& vertexSource, const std::string& fragmentSource, size_t& shaderHash)
  60 {
  61   ResourceTicketPtr ticket;
  62
  63   shaderHash = HashShaderSource(vertexSource, fragmentSource);
  64   std::stringstream stringHash;
  65   stringHash << shaderHash;
  66   std::string filename = DALI_SHADERBIN_DIR;
  67   filename += stringHash.str();
  68   filename += ".dali-bin";
  69
  70   ShaderResourceType resourceType(shaderHash, vertexSource, fragmentSource);
  71   ResourceTypePath typePath(resourceType, filename);
  72
  73   // Search for a matching resource
  74   ResourceTypePathIdIter iter = mResourceTypePathIdMap.end();
  75   if ( !mResourceTypePathIdMap.empty() )
  76   {
  77     iter = mResourceTypePathIdMap.find( typePath );
  78   }
  79
  80   if ( mResourceTypePathIdMap.end() != iter )
  81   {
  82     // The resource was previously requested
  83     unsigned int resourceId = iter->second;
  84
  85     // The ticket may still be alive, request another copy
  86     ticket = mResourceClient.RequestResourceTicket( resourceId );
  87
  88     // Clean-up the map of resource IDs, if the ticket has been discarded
  89     if ( !ticket )
  90     {
  91       mResourceTypePathIdMap.erase( iter );
  92     }
  93     else
  94     {
  95       DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "ShaderFactory::Load filename= %s already requested to Load\n", filename.c_str());
  96     }
  97   }
  98
  99   if ( !ticket )
 100   {
 101     // Load a shader (loaded in Update thread)
 102     ticket = mResourceClient.LoadShader(resourceType, filename);
 103     DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "ShaderFactory::Load Ticket ID:%d, path: \"%s\"\n", ticket->GetId(), filename.c_str());
 104
 105     mResourceTypePathIdMap.insert( ResourceTypePathIdPair( typePath, ticket->GetId() ) );
 106   }
 107
 108   return ticket;
 109 }
 110
 111 void ShaderFactory::LoadDefaultShaders()
 112 {
 113   mDefaultShader = ShaderEffect::New();
 114
 115   mDefaultShader->SetProgram( GEOMETRY_TYPE_IMAGE, SHADER_DEFAULT, FlatColorTextureVertex, FlatColorTextureFragment );
 116
 117   mDefaultShader->SetProgram( GEOMETRY_TYPE_TEXT, SHADER_DEFAULT, DistanceFieldFontVertex, DistanceFieldFontFragment );
 118
 119   LoadTextSubtypeShaders(mDefaultShader); // TODO: Remove when applications no longer need these shaders
 120
 121   // Untextured meshes
 122   mDefaultShader->SetProgram( GEOMETRY_TYPE_MESH, SHADER_DEFAULT,
 123                               "", // Vertex shader defs
 124                               SHADER_DEF_USE_LIGHTING, // fragment shader defs
 125                               MeshColorNoTextureVertex, MeshColorNoTextureFragment );
 126
 127   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_EVENLY_LIT,
 128                              "", // Vertex shader defs
 129                              "", // fragment shader defs
 130                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 131
 132   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_RIGGED_AND_LIT,
 133                              SHADER_DEF_USE_BONES,    // vertex shader defs
 134                              SHADER_DEF_USE_LIGHTING, // fragment shader defs
 135                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 136
 137   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_RIGGED_AND_EVENLY_LIT,
 138                              SHADER_DEF_USE_BONES, // Vertex shader defs
 139                              "",                   // Fragment shader defs
 140                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 141
 142   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_RIGGED_AND_VERTEX_COLOR,
 143                              (SHADER_DEF_USE_BONES SHADER_DEF_USE_COLOR), // Vertex shader defs
 144                              SHADER_DEF_USE_COLOR,                        // Fragment shader defs
 145                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 146
 147   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_VERTEX_COLOR,
 148                              SHADER_DEF_USE_COLOR,  // Vertex shader defs
 149                              SHADER_DEF_USE_COLOR,  // Fragment shader defs
 150                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 151
 152   // Textured meshes
 153   mDefaultShader->SetProgram( GEOMETRY_TYPE_TEXTURED_MESH, SHADER_DEFAULT,
 154                               "",                      // Vertex shader defs
 155                               SHADER_DEF_USE_LIGHTING, // fragment shader defs
 156                               MeshVertex, MeshFragment );
 157
 158
 159   mDefaultShader->SetProgram(GEOMETRY_TYPE_TEXTURED_MESH, SHADER_EVENLY_LIT,
 160                              "",                      // Vertex shader defs
 161                              "",                      // Fragment shader defs
 162                              MeshVertex, MeshFragment);
 163
 164   mDefaultShader->SetProgram(GEOMETRY_TYPE_TEXTURED_MESH, SHADER_RIGGED_AND_LIT,
 165                              SHADER_DEF_USE_BONES,    // Vertex shader defs
 166                              SHADER_DEF_USE_LIGHTING, // Fragment shader defs
 167                              MeshVertex, MeshFragment);
 168
 169   mDefaultShader->SetProgram(GEOMETRY_TYPE_TEXTURED_MESH, SHADER_RIGGED_AND_EVENLY_LIT,
 170                              SHADER_DEF_USE_BONES, // Vertex shader defs
 171                              "",                   // Fragment shader defs
 172                              MeshVertex, MeshFragment);
 173 }
 174
 175 void ShaderFactory::LoadTextSubtypeShaders(ShaderEffectPtr shaderEffect)
 176 {
 177   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT,
 178                              SHADER_DEF_USE_GRADIENT,
 179                              SHADER_DEF_USE_GRADIENT,
 180                              DistanceFieldFontVertex, DistanceFieldFontFragment);
 181
 182   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT_GLOW, DistanceFieldFontGlowVertex, DistanceFieldFontGlowFragment);
 183
 184   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT_SHADOW, DistanceFieldFontShadowVertex, DistanceFieldFontShadowFragment);
 185
 186   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT_OUTLINE, DistanceFieldFontOutlineVertex, DistanceFieldFontOutlineFragment);
 187
 188   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT_OUTLINE_GLOW, DistanceFieldFontOutlineGlowVertex, DistanceFieldFontOutlineGlowFragment);
 189 }
 190
 191
 192 size_t ShaderFactory::HashShaderSource(const std::string& vertexSource, const std::string& fragmentSource) const
 193 {
 194   std::string source = vertexSource + fragmentSource;
 195
 196   // remove all white spaces, tabs and new lines
 197   source.erase(std::remove(source.begin(), source.end(), ' '), source.end());
 198   source.erase(std::remove(source.begin(), source.end(), '\n'), source.end());
 199   source.erase(std::remove(source.begin(), source.end(), '\t'), source.end());
 200
 201   return boost::hash_value( source );
 202 }
 203
 204 } // namespace Internal
 205
 206 } // namespace Dali