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

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