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