dali-toolkit/internal/controls/model3d-view/model3d-view-impl.cpp

   1 /*
   2  * Copyright (c) 2017 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 "model3d-view-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/object/type-registry.h>
  23 #include <dali/public-api/animation/constraint.h>
  24 #include <dali/public-api/animation/constraint-source.h>
  25 #include <dali/public-api/animation/constraints.h>
  26 #include <dali/public-api/object/type-registry-helper.h>
  27 #include <dali-toolkit/public-api/controls/model3d-view/model3d-view.h>
  28 #include <dali/public-api/images/resource-image.h>
  29 #include <dali/devel-api/adaptor-framework/file-loader.h>
  30 #include <dali/devel-api/adaptor-framework/image-loading.h>
  31
  32 // INTERNAL INCLUDES
  33 #include <dali-toolkit/internal/controls/model3d-view/obj-loader.h>
  34
  35 namespace Dali
  36 {
  37
  38 namespace Toolkit
  39 {
  40
  41 namespace Internal
  42 {
  43
  44 namespace
  45 {
  46
  47 // Texture indices are constants.
  48 enum TextureIndex
  49 {
  50   DIFFUSE_TEXTURE_INDEX,
  51   NORMAL_TEXTURE_INDEX,
  52   GLOSS_TEXTURE_INDEX
  53 };
  54
  55 /**
  56  * @brief Loads a texture from a file.
  57  * @param[in] imageUrl The URL of the file
  58  * @return A texture if loading succeeds, an empty handle otherwise
  59  */
  60 Texture LoadTexture( const char* imageUrl )
  61 {
  62   Texture texture;
  63   Devel::PixelBuffer pixelBuffer = LoadImageFromFile( imageUrl );
  64   if( pixelBuffer )
  65   {
  66     texture = Texture::New( TextureType::TEXTURE_2D, pixelBuffer.GetPixelFormat(), pixelBuffer.GetWidth(), pixelBuffer.GetHeight() );
  67     PixelData pixelData = Devel::PixelBuffer::Convert( pixelBuffer );
  68     texture.Upload( pixelData );
  69     texture.GenerateMipmaps();
  70   }
  71
  72   return texture;
  73 }
  74
  75 // Type registration
  76 BaseHandle Create()
  77 {
  78   return Toolkit::Model3dView::New();
  79 }
  80
  81 // Setup properties, signals and actions using the type-registry.
  82 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Model3dView, Toolkit::Control, Create );
  83
  84 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "geometryUrl",  STRING, GEOMETRY_URL)
  85 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "materialUrl",  STRING, MATERIAL_URL)
  86 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "imagesUrl",  STRING, IMAGES_URL)
  87 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "illuminationType",  INTEGER, ILLUMINATION_TYPE)
  88 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture0Url",  STRING, TEXTURE0_URL)
  89 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture1Url",  STRING, TEXTURE1_URL)
  90 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture2Url",  STRING, TEXTURE2_URL)
  91
  92 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Model3dView, "lightPosition",  VECTOR3, LIGHT_POSITION)
  93
  94 DALI_TYPE_REGISTRATION_END()
  95
  96
  97 #define MAKE_SHADER(A)#A
  98
  99 //  Diffuse illumination shader
 100
 101 const char* SIMPLE_VERTEX_SHADER = MAKE_SHADER(
 102   attribute highp vec3 aPosition;\n
 103   attribute highp vec2 aTexCoord;\n
 104   attribute highp vec3 aNormal;\n
 105   varying mediump vec3 vIllumination;\n
 106   uniform mediump vec3 uSize;\n
 107   uniform mediump mat4 uMvpMatrix;\n
 108   uniform mediump mat4 uModelView;\n
 109   uniform mediump mat3 uNormalMatrix;
 110   uniform mediump mat4 uObjectMatrix;\n
 111   uniform mediump vec3 uLightPosition;\n
 112
 113   void main()\n
 114   {\n
 115     vec4 vertexPosition = vec4(aPosition*min(uSize.x, uSize.y), 1.0);\n
 116     vertexPosition = uObjectMatrix * vertexPosition;\n
 117     vertexPosition = uMvpMatrix * vertexPosition;\n
 118
 119     //Illumination in Model-View space - Transform attributes and uniforms\n
 120     vec4 vertPos = uModelView * vec4(aPosition.xyz, 1.0);\n
 121     vec3 normal = uNormalMatrix * aNormal;\n
 122     vec4 lightPos = uModelView * vec4(uLightPosition, 1.0);\n
 123     vec3 vecToLight = normalize( lightPos.xyz - vertPos.xyz );\n
 124
 125     float lightDiffuse = max( dot( vecToLight, normal ), 0.0 );\n
 126     vIllumination = vec3(lightDiffuse * 0.5 + 0.5);\n
 127
 128     gl_Position = vertexPosition;\n
 129   }\n
 130 );
 131
 132 const char* SIMPLE_FRAGMENT_SHADER = MAKE_SHADER(
 133   precision mediump float;\n
 134   varying mediump vec3 vIllumination;\n
 135   uniform lowp vec4 uColor;\n
 136
 137   void main()\n
 138   {\n
 139     gl_FragColor = vec4( vIllumination.rgb * uColor.rgb, uColor.a);\n
 140   }\n
 141 );
 142
 143 //  Diffuse and specular illumination shader with albedo texture
 144
 145 const char* VERTEX_SHADER = MAKE_SHADER(
 146   attribute highp vec3 aPosition;\n
 147   attribute highp vec2 aTexCoord;\n
 148   attribute highp vec3 aNormal;\n
 149   varying mediump vec2 vTexCoord;\n
 150   varying mediump vec3 vIllumination;\n
 151   varying mediump float vSpecular;\n
 152   uniform mediump vec3 uSize;\n
 153   uniform mediump mat4 uMvpMatrix;\n
 154   uniform mediump mat4 uModelView;
 155   uniform mediump mat3 uNormalMatrix;
 156   uniform mediump mat4 uObjectMatrix;\n
 157   uniform mediump vec3 uLightPosition;\n
 158
 159   void main()
 160   {\n
 161     vec4 vertexPosition = vec4(aPosition*min(uSize.x, uSize.y), 1.0);\n
 162     vertexPosition = uObjectMatrix * vertexPosition;\n
 163     vertexPosition = uMvpMatrix * vertexPosition;\n
 164
 165     //Illumination in Model-View space - Transform attributes and uniforms\n
 166     vec4 vertPos = uModelView * vec4(aPosition.xyz, 1.0);\n
 167     vec4 lightPos = uModelView * vec4(uLightPosition, 1.0);\n
 168     vec3 normal = normalize(uNormalMatrix * aNormal);\n
 169
 170     vec3 vecToLight = normalize( lightPos.xyz - vertPos.xyz );\n
 171     vec3 viewDir = normalize(-vertPos.xyz);
 172
 173     vec3 halfVector = normalize(viewDir + vecToLight);
 174
 175     float lightDiffuse = dot( vecToLight, normal );\n
 176     lightDiffuse = max(0.0,lightDiffuse);\n
 177     vIllumination = vec3(lightDiffuse * 0.5 + 0.5);\n
 178
 179     vec3 reflectDir = reflect(-vecToLight, normal);
 180     vSpecular = pow( max(dot(reflectDir, viewDir), 0.0), 4.0 );
 181
 182     vTexCoord = aTexCoord;\n
 183     gl_Position = vertexPosition;\n
 184   }\n
 185 );
 186
 187 const char* FRAGMENT_SHADER = MAKE_SHADER(
 188   precision mediump float;\n
 189   varying mediump vec2 vTexCoord;\n
 190   varying mediump vec3 vIllumination;\n
 191   varying mediump float vSpecular;\n
 192   uniform sampler2D sDiffuse;\n
 193   uniform lowp vec4 uColor;\n
 194
 195   void main()\n
 196   {\n
 197     vec4 texture = texture2D( sDiffuse, vTexCoord );\n
 198     gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a);\n
 199   }\n
 200 );
 201
 202 //  Diffuse and specular illumination shader with albedo texture, normal map and gloss map shader
 203
 204 const char* NRMMAP_VERTEX_SHADER = MAKE_SHADER(
 205   attribute highp vec3 aPosition;\n
 206   attribute highp vec2 aTexCoord;\n
 207   attribute highp vec3 aNormal;\n
 208   attribute highp vec3 aTangent;\n
 209   attribute highp vec3 aBiNormal;\n
 210   varying mediump vec2 vTexCoord;\n
 211   varying mediump vec3 vLightDirection;\n
 212   varying mediump vec3 vHalfVector;\n
 213   uniform mediump vec3 uSize;\n
 214   uniform mediump mat4 uMvpMatrix;\n
 215   uniform mediump mat4 uModelView;
 216   uniform mediump mat3 uNormalMatrix;
 217   uniform mediump mat4 uObjectMatrix;\n
 218   uniform mediump vec3 uLightPosition;\n
 219
 220   void main()
 221   {\n
 222     vec4 vertexPosition = vec4(aPosition*min(uSize.x, uSize.y), 1.0);\n
 223     vertexPosition = uObjectMatrix * vertexPosition;\n
 224     vertexPosition = uMvpMatrix * vertexPosition;\n
 225
 226     vec4 vertPos = uModelView * vec4(aPosition.xyz, 1.0);\n
 227     vec4 lightPos = uModelView * vec4(uLightPosition, 1.0);\n
 228
 229     vec3 tangent = normalize(uNormalMatrix * aTangent);
 230     vec3 binormal = normalize(uNormalMatrix * aBiNormal);
 231     vec3 normal = normalize(uNormalMatrix * aNormal);
 232
 233     vec3 vecToLight = normalize( lightPos.xyz - vertPos.xyz );\n
 234     vLightDirection.x = dot(vecToLight, tangent);
 235     vLightDirection.y = dot(vecToLight, binormal);
 236     vLightDirection.z = dot(vecToLight, normal);
 237
 238     vec3 viewDir = normalize(-vertPos.xyz);
 239     vec3 halfVector = normalize(viewDir + vecToLight);
 240     vHalfVector.x = dot(halfVector, tangent);
 241     vHalfVector.y = dot(halfVector, binormal);
 242     vHalfVector.z = dot(halfVector, normal);
 243
 244     vTexCoord = aTexCoord;\n
 245     gl_Position = vertexPosition;\n
 246   }\n
 247 );
 248
 249 const char* NRMMAP_FRAGMENT_SHADER = MAKE_SHADER(
 250   precision mediump float;\n
 251   varying mediump vec2 vTexCoord;\n
 252   varying mediump vec3 vLightDirection;\n
 253   varying mediump vec3 vHalfVector;\n
 254   uniform sampler2D sDiffuse;\n
 255   uniform sampler2D sNormal;\n
 256   uniform sampler2D sGloss;\n
 257   uniform lowp vec4 uColor;\n
 258
 259   void main()\n
 260   {\n
 261     vec4 texture = texture2D( sDiffuse, vTexCoord );\n
 262     vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );\n
 263     vec4 glossMap = texture2D( sGloss, vTexCoord );\n
 264
 265     float lightDiffuse = max( 0.0, dot( normal, normalize(vLightDirection) ) );\n
 266     lightDiffuse = lightDiffuse * 0.5 + 0.5;\n
 267
 268     float shininess = pow (max (dot (normalize( vHalfVector ), normal), 0.0), 16.0)  ;
 269
 270     gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a);\n
 271   }\n
 272 );
 273
 274
 275 } // anonymous namespace
 276
 277 using namespace Dali;
 278
 279 Model3dView::Model3dView()
 280 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) )
 281 {
 282   mIlluminationType = Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP;
 283
 284   mCameraFOV = Math::PI_OVER_180 * 45.f;
 285
 286   mControlSize = Vector2(100.,100.);
 287 }
 288
 289 Model3dView::~Model3dView()
 290 {
 291 }
 292
 293 Toolkit::Model3dView Model3dView::New()
 294 {
 295   Model3dView* impl = new Model3dView();
 296
 297   Dali::Toolkit::Model3dView handle = Dali::Toolkit::Model3dView( *impl );
 298
 299   // Second-phase init of the implementation
 300   // This can only be done after the CustomActor connection has been made...
 301   impl->Initialize();
 302
 303   return handle;
 304 }
 305
 306 void Model3dView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 307 {
 308   Toolkit::Model3dView model3dView = Toolkit::Model3dView::DownCast( Dali::BaseHandle( object ) );
 309
 310   if( model3dView )
 311   {
 312     Model3dView& impl( GetImpl( model3dView ) );
 313     switch( index )
 314     {
 315       case Toolkit::Model3dView::Property::GEOMETRY_URL:
 316       {
 317         if( value.Get(impl.mObjUrl) )
 318         {
 319           impl.LoadGeometry();
 320           impl.CreateGeometry();
 321         }
 322         break;
 323       }
 324       case Toolkit::Model3dView::Property::MATERIAL_URL:
 325       {
 326         if( value.Get(impl.mTextureSetUrl) )
 327         {
 328           impl.LoadMaterial();
 329           impl.CreateMaterial();
 330           impl.LoadTextures();
 331         }
 332         break;
 333       }
 334       case Toolkit::Model3dView::Property::IMAGES_URL:
 335       {
 336         if( value.Get(impl.mImagesUrl) )
 337         {
 338           impl.LoadTextures();
 339         }
 340         break;
 341       }
 342       case Toolkit::Model3dView::Property::ILLUMINATION_TYPE:
 343       {
 344         int illuminationType;
 345         if( value.Get(illuminationType) )
 346         {
 347           impl.mIlluminationType = Toolkit::Model3dView::IlluminationType(illuminationType);
 348           impl.CreateGeometry();
 349           impl.CreateMaterial();
 350           impl.LoadTextures();
 351         }
 352         break;
 353       }
 354       case Toolkit::Model3dView::Property::TEXTURE0_URL:
 355       {
 356         value.Get(impl.mTexture0Url);
 357         break;
 358       }
 359       case Toolkit::Model3dView::Property::TEXTURE1_URL:
 360       {
 361         value.Get(impl.mTexture1Url);
 362         break;
 363       }
 364       case Toolkit::Model3dView::Property::TEXTURE2_URL:
 365       {
 366         value.Get(impl.mTexture2Url);
 367         break;
 368       }
 369     }
 370   }
 371 }
 372
 373 Property::Value Model3dView::GetProperty( BaseObject* object, Property::Index index )
 374 {
 375   Property::Value value;
 376
 377   Toolkit::Model3dView model3dView = Toolkit::Model3dView::DownCast( Dali::BaseHandle( object ) );
 378
 379   if( model3dView )
 380   {
 381     Model3dView& impl( GetImpl( model3dView ) );
 382     switch( index )
 383     {
 384       case Toolkit::Model3dView::Property::GEOMETRY_URL:
 385       {
 386         value = impl.mObjUrl;
 387         break;
 388       }
 389       case Toolkit::Model3dView::Property::MATERIAL_URL:
 390       {
 391         value = impl.mTextureSetUrl;
 392         break;
 393       }
 394       case Toolkit::Model3dView::Property::IMAGES_URL:
 395       {
 396         value = impl.mImagesUrl;
 397         break;
 398       }
 399       case Toolkit::Model3dView::Property::ILLUMINATION_TYPE:
 400       {
 401         value = int(impl.mIlluminationType);
 402         break;
 403       }
 404       case Toolkit::Model3dView::Property::TEXTURE0_URL:
 405       {
 406         value = impl.mTexture0Url;
 407         break;
 408       }
 409       case Toolkit::Model3dView::Property::TEXTURE1_URL:
 410       {
 411         value = impl.mTexture1Url;
 412         break;
 413       }
 414       case Toolkit::Model3dView::Property::TEXTURE2_URL:
 415       {
 416         value = impl.mTexture2Url;
 417         break;
 418       }
 419     }
 420   }
 421
 422   return value;
 423 }
 424
 425 /////////////////////////////////////////////////////////////
 426
 427
 428 void Model3dView::OnStageConnection( int depth )
 429 {
 430   CustomActor self = Self();
 431   self.AddRenderer( mRenderer );
 432
 433   if( mObjLoader.IsSceneLoaded() )
 434   {
 435     mMesh = mObjLoader.CreateGeometry( GetShaderProperties( mIlluminationType ), true );
 436
 437     CreateMaterial();
 438     LoadTextures();
 439
 440     mRenderer.SetGeometry( mMesh );
 441
 442     //create constraint for lightPosition Property with uLightPosition in the shader
 443     Vector3 lightPosition( 0, 0, 0 );
 444     Dali::Property::Index lightProperty = mShader.RegisterProperty( "uLightPosition", lightPosition );
 445     Constraint constraint = Constraint::New<Vector3>( mShader, lightProperty, EqualToConstraint() );
 446     constraint.AddSource( Source( self, Toolkit::Model3dView::Property::LIGHT_POSITION ) );
 447     constraint.Apply();
 448   }
 449
 450   Control::OnStageConnection( depth );
 451 }
 452
 453 ///////////////////////////////////////////////////////////
 454 //
 455 // Private methods
 456 //
 457
 458 void Model3dView::OnInitialize()
 459 {
 460   //Create empty versions of the geometry and material so we always have a Renderer
 461   Geometry mesh = Geometry::New();
 462   Shader shader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
 463   mRenderer = Renderer::New( mesh, shader );
 464
 465 }
 466
 467 void Model3dView::LoadGeometry()
 468 {
 469   //Load file in adaptor
 470   std::streampos fileSize;
 471   Dali::Vector<char> fileContent;
 472
 473   if (FileLoader::ReadFile(mObjUrl,fileSize,fileContent,FileLoader::TEXT))
 474   {
 475     mObjLoader.ClearArrays();
 476     mObjLoader.LoadObject(fileContent.Begin(), fileSize);
 477
 478     //Get size information from the obj loaded
 479     mSceneCenter = mObjLoader.GetCenter();
 480     mSceneSize = mObjLoader.GetSize();
 481   }
 482   else
 483   {
 484     //Error
 485   }
 486 }
 487
 488 void Model3dView::LoadMaterial()
 489 {
 490   //Load file in adaptor
 491   std::streampos fileSize;
 492   Dali::Vector<char> fileContent;
 493
 494   if( FileLoader::ReadFile(mTextureSetUrl, fileSize, fileContent, FileLoader::TEXT) )
 495   {
 496     mObjLoader.LoadMaterial(fileContent.Begin(), fileSize, mTexture0Url, mTexture1Url, mTexture2Url);
 497   }
 498   else
 499   {
 500     //Error
 501   }
 502 }
 503
 504 void Model3dView::Load()
 505 {
 506   LoadGeometry();
 507   LoadMaterial();
 508 }
 509
 510 void Model3dView::OnRelayout( const Vector2& size, RelayoutContainer& container )
 511 {
 512   UpdateView();
 513 }
 514
 515 void Model3dView::UpdateView()
 516 {
 517   if( mObjLoader.IsSceneLoaded() )
 518   {
 519     //The object will always be centred
 520
 521     Matrix scaleMatrix;
 522     scaleMatrix.SetIdentityAndScale(Vector3(1.0, -1.0, 1.0));
 523
 524     mShader.RegisterProperty( "uObjectMatrix", scaleMatrix );
 525   }
 526 }
 527
 528 void Model3dView::CreateGeometry()
 529 {
 530   if( mObjLoader.IsSceneLoaded() )
 531   {
 532     mMesh = mObjLoader.CreateGeometry( GetShaderProperties( mIlluminationType ), true );
 533
 534     if( mRenderer )
 535     {
 536       mRenderer.SetGeometry( mMesh );
 537       mRenderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON );
 538       mRenderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON );
 539     }
 540   }
 541 }
 542
 543 void Model3dView::UpdateShaderUniforms()
 544 {
 545   if( mShader )
 546   {
 547     //Update shader related info, uniforms, etc. for the new shader
 548     UpdateView();
 549
 550     Vector3 lightPosition( 0, 0, 0 );
 551     Dali::Property::Index lightProperty = mShader.RegisterProperty( "uLightPosition", lightPosition );
 552
 553     CustomActor self = Self();
 554
 555     //create constraint for lightPosition Property with uLightPosition in the shader
 556     if( lightProperty )
 557     {
 558       Constraint constraint = Constraint::New<Vector3>( mShader, lightProperty, EqualToConstraint() );
 559       constraint.AddSource( Source( self, Toolkit::Model3dView::Property::LIGHT_POSITION ) );
 560       constraint.Apply();
 561     }
 562   }
 563 }
 564
 565 void Model3dView::CreateMaterial()
 566 {
 567   if( mObjLoader.IsMaterialLoaded() && (mTexture0Url != "") && mObjLoader.IsTexturePresent() )
 568   {
 569     if( (mTexture2Url != "") && (mTexture1Url != "") && (mIlluminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP) )
 570     {
 571       mShader = Shader::New( NRMMAP_VERTEX_SHADER, NRMMAP_FRAGMENT_SHADER );
 572     }
 573     else if( mIlluminationType == Toolkit::Model3dView::DIFFUSE_WITH_TEXTURE ||
 574              mIlluminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP )
 575     {
 576       mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
 577     }
 578     else
 579     {
 580       mShader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
 581     }
 582   }
 583   else
 584   {
 585     mShader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
 586   }
 587
 588   mTextureSet = TextureSet::New();
 589
 590   if( mRenderer )
 591   {
 592     mRenderer.SetTextures( mTextureSet );
 593     mRenderer.SetShader( mShader );
 594     mRenderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK );
 595   }
 596
 597   UpdateShaderUniforms();
 598 }
 599
 600 void Model3dView::LoadTextures()
 601 {
 602   if( !mTextureSet )
 603   {
 604     return;
 605   }
 606
 607   Sampler sampler = Sampler::New();
 608   sampler.SetFilterMode( FilterMode::LINEAR_MIPMAP_LINEAR, FilterMode::LINEAR_MIPMAP_LINEAR );
 609
 610   // Setup diffuse texture.
 611   if( !mTexture0Url.empty() && ( mIlluminationType != Toolkit::Model3dView::DIFFUSE ) )
 612   {
 613     std::string imageUrl = mImagesUrl + mTexture0Url;
 614
 615     //Load textures
 616     Texture diffuseTexture = LoadTexture( imageUrl.c_str() );
 617     if( diffuseTexture )
 618     {
 619       mTextureSet.SetTexture( DIFFUSE_TEXTURE_INDEX, diffuseTexture );
 620       mTextureSet.SetSampler( DIFFUSE_TEXTURE_INDEX, sampler );
 621     }
 622   }
 623
 624   if( mIlluminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP )
 625   {
 626     // Setup normal map texture.
 627     if( !mTexture1Url.empty() )
 628     {
 629       std::string imageUrl = mImagesUrl + mTexture1Url;
 630
 631       //Load textures
 632       Texture normalTexture = LoadTexture( imageUrl.c_str() );
 633       if( normalTexture )
 634       {
 635         mTextureSet.SetTexture( NORMAL_TEXTURE_INDEX, normalTexture );
 636         mTextureSet.SetSampler( NORMAL_TEXTURE_INDEX, sampler );
 637       }
 638     }
 639     if( !mTexture2Url.empty() )
 640     {
 641       // Setup gloss map texture.
 642       std::string imageUrl = mImagesUrl + mTexture2Url;
 643
 644       //Load textures
 645       Texture glossTexture = LoadTexture( imageUrl.c_str() );
 646       if( glossTexture )
 647       {
 648         mTextureSet.SetTexture( GLOSS_TEXTURE_INDEX, glossTexture );
 649         mTextureSet.SetSampler( GLOSS_TEXTURE_INDEX, sampler );
 650       }
 651     }
 652   }
 653 }
 654
 655 int Model3dView::GetShaderProperties( Toolkit::Model3dView::IlluminationType illuminationType )
 656 {
 657   int objectProperties = 0;
 658
 659   if( illuminationType == Toolkit::Model3dView::DIFFUSE_WITH_TEXTURE ||
 660       illuminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP )
 661   {
 662     objectProperties |= ObjLoader::TEXTURE_COORDINATES;
 663   }
 664
 665   if( illuminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP )
 666   {
 667     objectProperties |= ObjLoader::TANGENTS | ObjLoader::BINORMALS;
 668   }
 669
 670   return objectProperties;
 671 }
 672
 673 } // namespace Internal
 674 } // namespace Toolkit
 675 } // namespace Dali