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 <sstream>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/internal/common/dali-hash.h>
  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 = CalculateHash(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 the shader (loaded synchronously in Update thread so its ready by the time the set shader message is processed)
 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->SendProgramMessage( GEOMETRY_TYPE_IMAGE, SHADER_DEFAULT, ImageVertex, ImageFragment, false );
 116
 117   // Untextured meshes
 118   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_DEFAULT,
 119                                       UntexturedMeshVertex,
 120                                       std::string( SHADER_DEF_USE_LIGHTING ) + UntexturedMeshFragment,
 121                                       false );
 122
 123   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_EVENLY_LIT,
 124                                       UntexturedMeshVertex,
 125                                       UntexturedMeshFragment,
 126                                       false );
 127
 128   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_RIGGED_AND_LIT,
 129                                       std::string( SHADER_DEF_USE_BONES ) + UntexturedMeshVertex,
 130                                       std::string( SHADER_DEF_USE_LIGHTING ) + UntexturedMeshFragment,
 131                                       true );
 132
 133   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_RIGGED_AND_EVENLY_LIT,
 134                                       std::string( SHADER_DEF_USE_BONES ) + UntexturedMeshVertex,
 135                                       UntexturedMeshFragment,
 136                                       true );
 137
 138   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_RIGGED_AND_VERTEX_COLOR,
 139                                       std::string( SHADER_DEF_USE_BONES SHADER_DEF_USE_COLOR ) + UntexturedMeshVertex,
 140                                       std::string( SHADER_DEF_USE_COLOR ) + UntexturedMeshFragment,
 141                                       true );
 142
 143   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_VERTEX_COLOR,
 144                                       std::string( SHADER_DEF_USE_COLOR ) + UntexturedMeshVertex,
 145                                       std::string( SHADER_DEF_USE_COLOR ) + UntexturedMeshFragment,
 146                                       false );
 147
 148   // Textured meshes
 149   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_TEXTURED_MESH, SHADER_DEFAULT,
 150                                       TexturedMeshVertex,
 151                                       std::string( SHADER_DEF_USE_LIGHTING ) + TexturedMeshFragment,
 152                                       false );
 153
 154   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_TEXTURED_MESH, SHADER_EVENLY_LIT,
 155                                       TexturedMeshVertex,
 156                                       TexturedMeshFragment,
 157                                       false );
 158
 159   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_TEXTURED_MESH, SHADER_RIGGED_AND_LIT,
 160                                       std::string( SHADER_DEF_USE_BONES ) + TexturedMeshVertex,
 161                                       std::string( SHADER_DEF_USE_LIGHTING ) + TexturedMeshFragment,
 162                                       true );
 163
 164   mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_TEXTURED_MESH, SHADER_RIGGED_AND_EVENLY_LIT,
 165                                       std::string( SHADER_DEF_USE_BONES ) + TexturedMeshVertex,
 166                                       TexturedMeshFragment,
 167                                       true );
 168 }
 169
 170 } // namespace Internal
 171
 172 } // namespace Dali