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 );
 117
 118   mDefaultShader->SetProgram( GEOMETRY_TYPE_TEXT, SHADER_DEFAULT, DistanceFieldFontVertex, DistanceFieldFontFragment );
 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
 128   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_EVENLY_LIT,
 129                              "", // Vertex shader defs
 130                              "", // fragment shader defs
 131                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 132
 133   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_RIGGED_AND_LIT,
 134                              SHADER_DEF_USE_BONES,    // vertex shader defs
 135                              SHADER_DEF_USE_LIGHTING, // fragment shader defs
 136                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 137
 138   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_RIGGED_AND_EVENLY_LIT,
 139                              SHADER_DEF_USE_BONES, // Vertex shader defs
 140                              "",                   // Fragment shader defs
 141                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 142
 143   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_RIGGED_AND_VERTEX_COLOR,
 144                              (SHADER_DEF_USE_BONES SHADER_DEF_USE_COLOR), // Vertex shader defs
 145                              SHADER_DEF_USE_COLOR,                        // Fragment shader defs
 146                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 147
 148   mDefaultShader->SetProgram(GEOMETRY_TYPE_MESH, SHADER_VERTEX_COLOR,
 149                              SHADER_DEF_USE_COLOR,  // Vertex shader defs
 150                              SHADER_DEF_USE_COLOR,  // Fragment shader defs
 151                              MeshColorNoTextureVertex, MeshColorNoTextureFragment);
 152
 153   // Textured meshes
 154   mDefaultShader->SetProgram( GEOMETRY_TYPE_TEXTURED_MESH, SHADER_DEFAULT,
 155                               "",                      // Vertex shader defs
 156                               SHADER_DEF_USE_LIGHTING, // fragment shader defs
 157                               MeshVertex, MeshFragment );
 158
 159
 160   mDefaultShader->SetProgram(GEOMETRY_TYPE_TEXTURED_MESH, SHADER_EVENLY_LIT,
 161                              "",                      // Vertex shader defs
 162                              "",                      // Fragment shader defs
 163                              MeshVertex, MeshFragment);
 164
 165   mDefaultShader->SetProgram(GEOMETRY_TYPE_TEXTURED_MESH, SHADER_RIGGED_AND_LIT,
 166                              SHADER_DEF_USE_BONES,    // Vertex shader defs
 167                              SHADER_DEF_USE_LIGHTING, // Fragment shader defs
 168                              MeshVertex, MeshFragment);
 169
 170   mDefaultShader->SetProgram(GEOMETRY_TYPE_TEXTURED_MESH, SHADER_RIGGED_AND_EVENLY_LIT,
 171                              SHADER_DEF_USE_BONES, // Vertex shader defs
 172                              "",                   // Fragment shader defs
 173                              MeshVertex, MeshFragment);
 174 }
 175
 176 void ShaderFactory::LoadTextSubtypeShaders(ShaderEffectPtr shaderEffect)
 177 {
 178   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT,
 179                              SHADER_DEF_USE_GRADIENT,
 180                              SHADER_DEF_USE_GRADIENT,
 181                              DistanceFieldFontVertex, DistanceFieldFontFragment);
 182
 183   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT_GLOW, DistanceFieldFontGlowVertex, DistanceFieldFontGlowFragment);
 184
 185   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT_SHADOW, DistanceFieldFontShadowVertex, DistanceFieldFontShadowFragment);
 186
 187   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT_OUTLINE, DistanceFieldFontOutlineVertex, DistanceFieldFontOutlineFragment);
 188
 189   shaderEffect->SetProgram(GEOMETRY_TYPE_TEXT, SHADER_GRADIENT_OUTLINE_GLOW, DistanceFieldFontOutlineGlowVertex, DistanceFieldFontOutlineGlowFragment);
 190 }
 191
 192
 193 size_t ShaderFactory::HashShaderSource(const std::string& vertexSource, const std::string& fragmentSource) const
 194 {
 195   std::string source = vertexSource + fragmentSource;
 196
 197   // remove all white spaces, tabs and new lines
 198   source.erase(std::remove(source.begin(), source.end(), ' '), source.end());
 199   source.erase(std::remove(source.begin(), source.end(), '\n'), source.end());
 200   source.erase(std::remove(source.begin(), source.end(), '\t'), source.end());
 201
 202   return boost::hash_value( source );
 203 }
 204
 205 } // namespace Internal
 206
 207 } // namespace Dali