Adding Visual namespace and Visual becomes Visual::Base
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / mesh / mesh-visual.cpp
1 /*
2  * Copyright (c) 2016 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 "mesh-visual.h"
20
21 // EXTERNAL INCLUDES
22 #include <dali/integration-api/debug.h>
23 #include <dali/public-api/common/stage.h>
24 #include <dali/devel-api/adaptor-framework/bitmap-loader.h>
25 #include <dali/devel-api/adaptor-framework/file-loader.h>
26 #include <fstream>
27
28 //INTERNAL INCLUDES
29 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
30 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
31
32 namespace Dali
33 {
34
35 namespace
36 {
37   /**
38    * @brief Loads a texture from a file
39    * @param[in] imageUrl The url of the file
40    * @param[in] generateMipmaps Indicates whether to generate mipmaps for the texture
41    * @return A texture if loading succeeds, an empty handle otherwise
42    */
43   Texture LoadTexture( const char* imageUrl, bool generateMipmaps )
44   {
45     Texture texture;
46     Dali::BitmapLoader loader = Dali::BitmapLoader::New( imageUrl );
47     loader.Load();
48     PixelData pixelData = loader.GetPixelData();
49     if( pixelData )
50     {
51       texture = Texture::New( TextureType::TEXTURE_2D, pixelData.GetPixelFormat(), pixelData.GetWidth(), pixelData.GetHeight() );
52       texture.Upload( pixelData );
53
54       if( generateMipmaps )
55       {
56         texture.GenerateMipmaps();
57       }
58     }
59
60     return texture;
61   }
62 }// unnamed namespace
63
64 namespace Toolkit
65 {
66
67 namespace Internal
68 {
69
70 namespace
71 {
72
73 //Defines ordering of textures for shaders.
74 //All shaders, if including certain texture types, must include them in the same order.
75 //Within the texture set for the renderer, textures are ordered in the same manner.
76 enum TextureIndex
77 {
78   DIFFUSE_INDEX = 0u,
79   NORMAL_INDEX = 1u,
80   GLOSS_INDEX = 2u
81 };
82
83 //Shader properties
84 const char * const OBJECT_MATRIX_UNIFORM_NAME( "uObjectMatrix" );
85 const char * const STAGE_OFFSET_UNIFORM_NAME( "uStageOffset" );
86
87 const char * const SHADER_TYPE_TEXTURELESS( "TEXTURELESS" );
88 const char * const SHADER_TYPE_DIFFUSE_TEXTURE( "DIFFUSE_TEXTURE" );
89 const char * const SHADER_TYPE_ALL_TEXTURES( "ALL_TEXTURES" );
90
91 //Shaders
92 //If a shader requires certain textures, they must be listed in order,
93 //as detailed in the TextureIndex enum documentation.
94
95 //A basic shader that doesn't use textures at all.
96 const char* SIMPLE_VERTEX_SHADER = DALI_COMPOSE_SHADER(
97   attribute highp vec3 aPosition;\n
98   attribute highp vec3 aNormal;\n
99   varying mediump vec3 vIllumination;\n
100   uniform mediump vec3 uSize;\n
101   uniform mediump mat4 uMvpMatrix;\n
102   uniform mediump mat4 uModelView;\n
103   uniform mediump mat4 uViewMatrix;\n
104   uniform mediump mat3 uNormalMatrix;
105   uniform mediump mat4 uObjectMatrix;\n
106   uniform mediump vec3 lightPosition;\n
107   uniform mediump vec2 uStageOffset;\n
108
109   void main()\n
110   {\n
111     vec4 normalisedVertexPosition = vec4( aPosition * min( uSize.x, uSize.y ), 1.0 );\n
112     vec4 vertexPosition = uObjectMatrix * normalisedVertexPosition;\n
113     vertexPosition = uMvpMatrix * vertexPosition;\n
114
115     //Illumination in Model-View space - Transform attributes and uniforms\n
116     vec4 mvVertexPosition = uModelView * normalisedVertexPosition;\n
117     vec3 normal = uNormalMatrix * mat3( uObjectMatrix ) * aNormal;\n
118
119     vec4 mvLightPosition = vec4( ( lightPosition.xy - uStageOffset ), lightPosition.z, 1.0 );\n
120     mvLightPosition = uViewMatrix * mvLightPosition;\n
121     vec3 vectorToLight = normalize( mvLightPosition.xyz - mvVertexPosition.xyz );\n
122
123     float lightDiffuse = max( dot( vectorToLight, normal ), 0.0 );\n
124     vIllumination = vec3( lightDiffuse * 0.5 + 0.5 );\n
125
126     gl_Position = vertexPosition;\n
127   }\n
128 );
129
130 //Fragment shader corresponding to the texture-less shader.
131 const char* SIMPLE_FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
132   precision mediump float;\n
133   varying mediump vec3 vIllumination;\n
134   uniform lowp vec4 uColor;\n
135
136   void main()\n
137   {\n
138     gl_FragColor = vec4( vIllumination.rgb * uColor.rgb, uColor.a );\n
139   }\n
140 );
141
142 //Diffuse and specular illumination shader with albedo texture. Texture is index 0.
143 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
144   attribute highp vec3 aPosition;\n
145   attribute highp vec2 aTexCoord;\n
146   attribute highp vec3 aNormal;\n
147   varying mediump vec2 vTexCoord;\n
148   varying mediump vec3 vIllumination;\n
149   varying mediump float vSpecular;\n
150   uniform mediump vec3 uSize;\n
151   uniform mediump mat4 uMvpMatrix;\n
152   uniform mediump mat4 uModelView;
153   uniform mediump mat4 uViewMatrix;\n
154   uniform mediump mat3 uNormalMatrix;
155   uniform mediump mat4 uObjectMatrix;\n
156   uniform mediump vec3 lightPosition;\n
157   uniform mediump vec2 uStageOffset;\n
158
159   void main()
160   {\n
161     vec4 normalisedVertexPosition = vec4( aPosition * min( uSize.x, uSize.y ), 1.0 );\n
162     vec4 vertexPosition = uObjectMatrix * normalisedVertexPosition;\n
163     vertexPosition = uMvpMatrix * vertexPosition;\n
164
165     //Illumination in Model-View space - Transform attributes and uniforms\n
166     vec4 mvVertexPosition = uModelView * normalisedVertexPosition;\n
167     vec3 normal = normalize( uNormalMatrix * mat3( uObjectMatrix ) * aNormal );\n
168
169     vec4 mvLightPosition = vec4( ( lightPosition.xy - uStageOffset ), lightPosition.z, 1.0 );\n
170     mvLightPosition = uViewMatrix * mvLightPosition;\n
171     vec3 vectorToLight = normalize( mvLightPosition.xyz - mvVertexPosition.xyz );\n
172
173     vec3 viewDirection = normalize( -mvVertexPosition.xyz );
174
175     float lightDiffuse = dot( vectorToLight, normal );\n
176     lightDiffuse = max( 0.0,lightDiffuse );\n
177     vIllumination = vec3( lightDiffuse * 0.5 + 0.5 );\n
178
179     vec3 reflectDirection = reflect( -vectorToLight, normal );
180     vSpecular = pow( max( dot( reflectDirection, viewDirection ), 0.0 ), 4.0 );
181
182     vTexCoord = aTexCoord;\n
183     gl_Position = vertexPosition;\n
184   }\n
185 );
186
187 //Fragment shader corresponding to the diffuse and specular illumination shader with albedo texture
188 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
189   precision mediump float;\n
190   varying mediump vec2 vTexCoord;\n
191   varying mediump vec3 vIllumination;\n
192   varying mediump float vSpecular;\n
193   uniform sampler2D sDiffuse;\n
194   uniform lowp vec4 uColor;\n
195
196   void main()\n
197   {\n
198     vec4 texture = texture2D( sDiffuse, vTexCoord );\n
199     gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a );\n
200   }\n
201 );
202
203 //Diffuse and specular illumination shader with albedo texture, normal map and gloss map shader.
204 //Diffuse (albedo) texture is index 0, normal is 1, gloss is 2. They must be declared in this order.
205 const char* NORMAL_MAP_VERTEX_SHADER = DALI_COMPOSE_SHADER(
206   attribute highp vec3 aPosition;\n
207   attribute highp vec2 aTexCoord;\n
208   attribute highp vec3 aNormal;\n
209   attribute highp vec3 aTangent;\n
210   attribute highp vec3 aBiNormal;\n
211   varying mediump vec2 vTexCoord;\n
212   varying mediump vec3 vLightDirection;\n
213   varying mediump vec3 vHalfVector;\n
214   uniform mediump vec3 uSize;\n
215   uniform mediump mat4 uMvpMatrix;\n
216   uniform mediump mat4 uModelView;
217   uniform mediump mat4 uViewMatrix;\n
218   uniform mediump mat3 uNormalMatrix;
219   uniform mediump mat4 uObjectMatrix;\n
220   uniform mediump vec3 lightPosition;\n
221   uniform mediump vec2 uStageOffset;\n
222   void main()
223   {\n
224     vec4 normalisedVertexPosition = vec4( aPosition * min( uSize.x, uSize.y ), 1.0 );\n
225     vec4 vertexPosition = uObjectMatrix * normalisedVertexPosition;\n
226     vertexPosition = uMvpMatrix * vertexPosition;\n
227
228     vec4 mvVertexPosition = uModelView * normalisedVertexPosition;\n
229
230     vec3 tangent = normalize( uNormalMatrix * mat3( uObjectMatrix ) * aTangent );
231     vec3 binormal = normalize( uNormalMatrix * mat3( uObjectMatrix ) * aBiNormal );
232     vec3 normal = normalize( uNormalMatrix * mat3( uObjectMatrix ) * aNormal );
233
234     vec4 mvLightPosition = vec4( ( lightPosition.xy - uStageOffset ), lightPosition.z, 1.0 );\n
235     mvLightPosition = uViewMatrix * mvLightPosition;\n
236     vec3 vectorToLight = normalize( mvLightPosition.xyz - mvVertexPosition.xyz );\n
237     vLightDirection.x = dot( vectorToLight, tangent );
238     vLightDirection.y = dot( vectorToLight, binormal );
239     vLightDirection.z = dot( vectorToLight, normal );
240
241     vec3 viewDirection = normalize( -mvVertexPosition.xyz );
242     vec3 halfVector = normalize( viewDirection + vectorToLight );
243     vHalfVector.x = dot( halfVector, tangent );
244     vHalfVector.y = dot( halfVector, binormal );
245     vHalfVector.z = dot( halfVector, normal );
246
247     vTexCoord = aTexCoord;\n
248     gl_Position = vertexPosition;\n
249   }\n
250 );
251
252 //Fragment shader corresponding to the shader that uses all textures (diffuse, normal and gloss maps)
253 const char* NORMAL_MAP_FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
254   precision mediump float;\n
255   varying mediump vec2 vTexCoord;\n
256   varying mediump vec3 vLightDirection;\n
257   varying mediump vec3 vHalfVector;\n
258   uniform sampler2D sDiffuse;\n
259   uniform sampler2D sNormal;\n
260   uniform sampler2D sGloss;\n
261   uniform lowp vec4 uColor;\n
262
263   void main()\n
264   {\n
265     vec4 texture = texture2D( sDiffuse, vTexCoord );\n
266     vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );\n
267     vec4 glossMap = texture2D( sGloss, vTexCoord );\n
268
269     float lightDiffuse = max( 0.0, dot( normal, normalize( vLightDirection ) ) );\n
270     lightDiffuse = lightDiffuse * 0.5 + 0.5;\n
271
272     float shininess = pow ( max ( dot ( normalize( vHalfVector ), normal ), 0.0 ), 16.0 )  ;
273
274     gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a );\n
275   }\n
276 );
277
278 } // namespace
279
280 MeshVisual::MeshVisual( VisualFactoryCache& factoryCache )
281 : Visual::Base( factoryCache ),
282   mShaderType( ALL_TEXTURES ),
283   mUseTexture( true ),
284   mUseMipmapping( true ),
285   mUseSoftNormals( true )
286 {
287 }
288
289 MeshVisual::~MeshVisual()
290 {
291 }
292
293 void MeshVisual::DoInitialize( Actor& actor, const Property::Map& propertyMap )
294 {
295   Property::Value* objectUrl = propertyMap.Find( OBJECT_URL );
296   if( !objectUrl || !objectUrl->Get( mObjectUrl ) )
297   {
298     DALI_LOG_ERROR( "Fail to provide object URL to the MeshVisual object.\n" );
299   }
300
301   Property::Value* materialUrl = propertyMap.Find( MATERIAL_URL );
302   if( !materialUrl || !materialUrl->Get( mMaterialUrl ) || mMaterialUrl.empty() )
303   {
304     mUseTexture = false;
305   }
306
307   Property::Value* imagesUrl = propertyMap.Find( TEXTURES_PATH );
308   if( !imagesUrl || !imagesUrl->Get( mTexturesPath ) )
309   {
310     //Default behaviour is to assume files are in the same directory,
311     // or have their locations detailed in full when supplied.
312     mTexturesPath.clear();
313   }
314
315   Property::Value* shaderType = propertyMap.Find( SHADER_TYPE );
316   if( shaderType )
317   {
318     std::string shaderTypeString;
319     if( shaderType->Get( shaderTypeString ) )
320     {
321       if( shaderTypeString == SHADER_TYPE_TEXTURELESS )
322       {
323         mShaderType = TEXTURELESS;
324       }
325       else if( shaderTypeString == SHADER_TYPE_DIFFUSE_TEXTURE )
326       {
327         mShaderType = DIFFUSE_TEXTURE;
328       }
329       else if( shaderTypeString == SHADER_TYPE_ALL_TEXTURES )
330       {
331         mShaderType = ALL_TEXTURES;
332       }
333       else
334       {
335         DALI_LOG_ERROR( "Unknown shader type provided to the MeshVisual object.\n");
336       }
337     }
338   }
339
340   Property::Value* useMipmapping = propertyMap.Find( USE_MIPMAPPING );
341   if( useMipmapping )
342   {
343     useMipmapping->Get( mUseMipmapping );
344   }
345
346   Property::Value* useSoftNormals = propertyMap.Find( USE_SOFT_NORMALS );
347   if( useSoftNormals )
348   {
349     useSoftNormals->Get( mUseSoftNormals );
350   }
351
352   Property::Value* lightPosition = propertyMap.Find( LIGHT_POSITION_UNIFORM_NAME );
353   if( lightPosition )
354   {
355     if( !lightPosition->Get( mLightPosition ) )
356     {
357       DALI_LOG_ERROR( "Invalid value passed for light position in MeshRenderer object.\n" );
358       mLightPosition = Vector3::ZERO;
359     }
360   }
361   else
362   {
363     //Default behaviour is to place the light directly in front of the object,
364     // at a reasonable distance to light everything on screen.
365     Stage stage = Stage::GetCurrent();
366
367     mLightPosition = Vector3( stage.GetSize().width / 2, stage.GetSize().height / 2, stage.GetSize().width * 5 );
368   }
369 }
370
371 void MeshVisual::SetSize( const Vector2& size )
372 {
373   Visual::Base::SetSize( size );
374
375   // ToDo: renderer responds to the size change
376 }
377
378 void MeshVisual::SetClipRect( const Rect<int>& clipRect )
379 {
380   Visual::Base::SetClipRect( clipRect );
381
382   //ToDo: renderer responds to the clipRect change
383 }
384
385 void MeshVisual::SetOffset( const Vector2& offset )
386 {
387   //ToDo: renderer applies the offset
388 }
389
390 void MeshVisual::DoSetOnStage( Actor& actor )
391 {
392   InitializeRenderer();
393 }
394
395 void MeshVisual::DoCreatePropertyMap( Property::Map& map ) const
396 {
397   map.Clear();
398   map.Insert( RENDERER_TYPE, MESH_RENDERER );
399   map.Insert( OBJECT_URL, mObjectUrl );
400   map.Insert( MATERIAL_URL, mMaterialUrl );
401   map.Insert( TEXTURES_PATH, mTexturesPath );
402
403   std::string shaderTypeString;
404   switch( mShaderType )
405   {
406     case ALL_TEXTURES:
407     {
408       shaderTypeString = SHADER_TYPE_ALL_TEXTURES;
409       break;
410     }
411
412     case DIFFUSE_TEXTURE:
413     {
414       shaderTypeString = SHADER_TYPE_DIFFUSE_TEXTURE;
415       break;
416     }
417
418     case TEXTURELESS:
419     {
420       shaderTypeString = SHADER_TYPE_TEXTURELESS;
421       break;
422     }
423   }
424   map.Insert( SHADER_TYPE, shaderTypeString );
425
426   map.Insert( USE_MIPMAPPING, mUseMipmapping );
427   map.Insert( USE_SOFT_NORMALS, mUseSoftNormals );
428   map.Insert( LIGHT_POSITION_UNIFORM_NAME, mLightPosition );
429 }
430
431 void MeshVisual::InitializeRenderer()
432 {
433   //Try to load the geometry from the file.
434   if( !LoadGeometry() )
435   {
436     SupplyEmptyGeometry();
437     return;
438   }
439
440   //If a texture is used by the obj file, load the supplied material file.
441   if( mObjLoader.IsTexturePresent() && !mMaterialUrl.empty() )
442   {
443     if( !LoadMaterial() )
444     {
445       SupplyEmptyGeometry();
446       return;
447     }
448   }
449
450   //Now that the required parts are loaded, create the geometry for the object.
451   if( !CreateGeometry() )
452   {
453     SupplyEmptyGeometry();
454     return;
455   }
456
457   CreateShader();
458
459   //Load the various texture files supplied by the material file.
460   if( !LoadTextures() )
461   {
462     SupplyEmptyGeometry();
463     return;
464   }
465
466   mImpl->mRenderer = Renderer::New( mGeometry, mShader );
467   mImpl->mRenderer.SetTextures( mTextureSet );
468   mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON );
469 }
470
471 void MeshVisual::SupplyEmptyGeometry()
472 {
473   mGeometry = Geometry::New();
474   mShader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
475   mImpl->mRenderer = Renderer::New( mGeometry, mShader );
476
477   DALI_LOG_ERROR( "Initialisation error in mesh visual.\n" );
478 }
479
480 void MeshVisual::UpdateShaderUniforms()
481 {
482   Stage stage = Stage::GetCurrent();
483   float width = stage.GetSize().width;
484   float height = stage.GetSize().height;
485
486   Matrix scaleMatrix;
487   scaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
488
489   mShader.RegisterProperty( STAGE_OFFSET_UNIFORM_NAME, Vector2( width, height ) / 2.0f );
490   mShader.RegisterProperty( LIGHT_POSITION_UNIFORM_NAME, mLightPosition );
491   mShader.RegisterProperty( OBJECT_MATRIX_UNIFORM_NAME, scaleMatrix );
492 }
493
494 void MeshVisual::CreateShader()
495 {
496   if( mShaderType == ALL_TEXTURES )
497   {
498     mShader = Shader::New( NORMAL_MAP_VERTEX_SHADER, NORMAL_MAP_FRAGMENT_SHADER );
499   }
500   else if( mShaderType == DIFFUSE_TEXTURE )
501   {
502     mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
503   }
504   else //Textureless
505   {
506     mShader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
507   }
508
509   UpdateShaderUniforms();
510 }
511
512 bool MeshVisual::CreateGeometry()
513 {
514   //Determine if we need to use a simpler shader to handle the provided data
515   if( !mUseTexture || !mObjLoader.IsDiffuseMapPresent() )
516   {
517     mShaderType = TEXTURELESS;
518   }
519   else if( mShaderType == ALL_TEXTURES && (!mObjLoader.IsNormalMapPresent() || !mObjLoader.IsSpecularMapPresent()) )
520   {
521     mShaderType = DIFFUSE_TEXTURE;
522   }
523
524   int objectProperties = 0;
525
526   if( mShaderType == DIFFUSE_TEXTURE ||
527       mShaderType == ALL_TEXTURES )
528   {
529     objectProperties |= ObjLoader::TEXTURE_COORDINATES;
530   }
531
532   if( mShaderType == ALL_TEXTURES )
533   {
534     objectProperties |= ObjLoader::TANGENTS | ObjLoader::BINORMALS;
535   }
536
537   //Create geometry with attributes required by shader.
538   mGeometry = mObjLoader.CreateGeometry( objectProperties, mUseSoftNormals );
539
540   if( mGeometry )
541   {
542     return true;
543   }
544
545   DALI_LOG_ERROR( "Failed to load geometry in mesh visual.\n" );
546   return false;
547 }
548
549 bool MeshVisual::LoadGeometry()
550 {
551   std::streampos fileSize;
552   Dali::Vector<char> fileContent;
553
554   if( FileLoader::ReadFile( mObjectUrl, fileSize, fileContent, FileLoader::TEXT ) )
555   {
556     mObjLoader.ClearArrays();
557     mObjLoader.LoadObject( fileContent.Begin(), fileSize );
558
559     //Get size information from the obj loaded
560     mSceneCenter = mObjLoader.GetCenter();
561     mSceneSize = mObjLoader.GetSize();
562
563     return true;
564   }
565
566   DALI_LOG_ERROR( "Failed to find object to load in mesh visual.\n" );
567   return false;
568 }
569
570 bool MeshVisual::LoadMaterial()
571 {
572   std::streampos fileSize;
573   Dali::Vector<char> fileContent;
574
575   if( FileLoader::ReadFile( mMaterialUrl, fileSize, fileContent, FileLoader::TEXT ) )
576   {
577     //Load data into obj (usable) form
578     mObjLoader.LoadMaterial( fileContent.Begin(), fileSize, mDiffuseTextureUrl, mNormalTextureUrl, mGlossTextureUrl );
579     return true;
580   }
581
582   DALI_LOG_ERROR( "Failed to find texture set to load in mesh visual.\n" );
583   mUseTexture = false;
584   return false;
585 }
586
587 bool MeshVisual::LoadTextures()
588 {
589   mTextureSet = TextureSet::New();
590
591   if( mShaderType != TEXTURELESS )
592   {
593     Sampler sampler = Sampler::New();
594     if( mUseMipmapping )
595     {
596       sampler.SetFilterMode( FilterMode::LINEAR_MIPMAP_LINEAR, FilterMode::LINEAR_MIPMAP_LINEAR );
597     }
598
599     if( !mDiffuseTextureUrl.empty() )
600     {
601       std::string imageUrl = mTexturesPath + mDiffuseTextureUrl;
602
603       //Load textures
604       Texture diffuseTexture = LoadTexture( imageUrl.c_str(), mUseMipmapping );
605       if( diffuseTexture )
606       {
607         mTextureSet.SetTexture( DIFFUSE_INDEX, diffuseTexture );
608         mTextureSet.SetSampler( DIFFUSE_INDEX, sampler );
609       }
610       else
611       {
612         DALI_LOG_ERROR( "Failed to load diffuse map texture in mesh visual.\n");
613         return false;
614       }
615     }
616
617     if( !mNormalTextureUrl.empty() && ( mShaderType == ALL_TEXTURES ) )
618     {
619       std::string imageUrl = mTexturesPath + mNormalTextureUrl;
620
621       //Load textures
622       Texture normalTexture = LoadTexture( imageUrl.c_str(), mUseMipmapping );
623       if( normalTexture )
624       {
625         mTextureSet.SetTexture( NORMAL_INDEX, normalTexture );
626         mTextureSet.SetSampler( NORMAL_INDEX, sampler );
627       }
628       else
629       {
630         DALI_LOG_ERROR( "Failed to load normal map texture in mesh visual.\n");
631         return false;
632       }
633     }
634
635     if( !mGlossTextureUrl.empty() && ( mShaderType == ALL_TEXTURES ) )
636     {
637       std::string imageUrl = mTexturesPath + mGlossTextureUrl;
638
639       //Load textures
640       Texture glossTexture = LoadTexture( imageUrl.c_str(), mUseMipmapping );
641       if( glossTexture )
642       {
643         mTextureSet.SetTexture( GLOSS_INDEX, glossTexture );
644         mTextureSet.SetSampler( GLOSS_INDEX, sampler );
645       }
646       else
647       {
648         DALI_LOG_ERROR( "Failed to load gloss map texture in mesh visual.\n");
649         return false;
650       }
651     }
652   }
653   return true;
654 }
655
656 } // namespace Internal
657
658 } // namespace Toolkit
659
660 } // namespace Dali