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