[dali_1.2.48] Merge branch 'devel/master'

Change-Id: I3c31aed793ca79db87198c3e0fd6736b48e0137a

[dali_1.2.48] Merge branch 'devel/master'
Change-Id: I3c31aed793ca79db87198c3e0fd6736b48e0137a
adam.b
2 parents 71345347 88f01d60
Showing 4 changed files with 155 additions and 139 deletions
examples/image-view/image-view-example.cpp
examples/rendering-basic-pbr/obj-loader.cpp
examples/rendering-basic-pbr/obj-loader.h
packaging/com.samsung.dali-demo.spec
@@ -15,9 +15,11 @@
  *
  */
+#include <string>
 #include "shared/view.h"
 #include <dali/dali.h>
 #include <dali-toolkit/dali-toolkit.h>
+#include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 using namespace Dali;
@@ -29,16 +31,41 @@ const char* TOOLBAR_IMAGE( DEMO_IMAGE_DIR &quot;top-bar.png&quot; );
 const char* APPLICATION_TITLE( "Image view" );
 const char* IMAGE_PATH[] = {
-    DEMO_IMAGE_DIR "blocks-ball.png",
     DEMO_IMAGE_DIR "gallery-small-23.jpg",
-    DEMO_IMAGE_DIR "selection-popup-bg.2.9.png",
+    DEMO_IMAGE_DIR "woodEffect.jpg",
     DEMO_IMAGE_DIR "heartsframe.9.png",
+    DEMO_IMAGE_DIR "World.svg"
 };
-const unsigned int NUM_IMAGES = sizeof(IMAGE_PATH) / sizeof(char*);
+const unsigned int NUMBER_OF_IMAGES = 3;
-const unsigned int COLUMNS = 3;
-const unsigned int ROWS = 4;
+enum CellPlacement
+{
+   TOP_BUTTON,
+   LOWER_BUTTON,
+   IMAGE,
+   NUMBER_OF_ROWS
+};
+
+
+unsigned int GetButtonIndex( Toolkit::Button button )
+{
+  std::string buttonName = button.GetName();
+  unsigned int index = 0;
+
+  if ( buttonName != "")
+  {
+    index = std::stoul( buttonName );
+  }
+
+  return index;
+}
+
+
+const unsigned int NUMBER_OF_RESOURCES = sizeof(IMAGE_PATH) / sizeof(char*);
+
+std::string EXAMPLE_INSTRUCTIONS = "Instructions: Change button cycles through different image visuals, "
+                           "on/off takes the ImageView and it's current visual on or off stage.";
 }  // namespace
@@ -49,9 +76,7 @@ class ImageViewController: public ConnectionTracker
   ImageViewController( Application& application )
     : mApplication( application ),
       mCurrentPositionToggle( 0, 0 ),
-      mCurrentPositionImage( 0, 0 ),
-      mToggleOff( true ),
-      mImageIdx( 1 )
+      mCurrentPositionImage( 0, 0 )
   {
     // Connect to the Application's Init signal
     mApplication.InitSignal().Connect( this, &ImageViewController::Create );
@@ -76,109 +101,99 @@ class ImageViewController: public ConnectionTracker
                                             APPLICATION_TITLE );
-    mTable = Toolkit::TableView::New( ROWS, COLUMNS );
+    // Create a table view to show a pair of buttons above each image.
+    mTable = Toolkit::TableView::New( CellPlacement::NUMBER_OF_ROWS, NUMBER_OF_IMAGES );
     mTable.SetAnchorPoint( AnchorPoint::CENTER );
     mTable.SetParentOrigin( ParentOrigin::CENTER );
-    mTable.SetResizePolicy( ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT, Dimension::ALL_DIMENSIONS );
-    Vector3 offset( -50.0f, -350.0f, 0.0f );
+    mTable.SetResizePolicy( ResizePolicy::SIZE_RELATIVE_TO_PARENT, Dimension::ALL_DIMENSIONS );
+    Vector3 offset( 0.9f, 0.70f, 0.0f );
     mTable.SetSizeModeFactor( offset );
-
+    mTable.SetFitHeight(CellPlacement::TOP_BUTTON);
+    mTable.SetFitHeight(CellPlacement::LOWER_BUTTON);
     mContentLayer.Add( mTable );
-    for( unsigned int y = 0; y < ROWS; ++y )
-    {
-      for( unsigned int x = 0; x < COLUMNS; ++x )
-      {
-        mImageViews[x][y] = Toolkit::ImageView::New( IMAGE_PATH[ 0 ] );
-        mImageViews[x][y].SetParentOrigin( ParentOrigin::CENTER );
-        mImageViews[x][y].SetAnchorPoint( AnchorPoint::CENTER );
-        mImageViews[x][y].SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+    Toolkit::TextLabel instructions = Toolkit::TextLabel::New( EXAMPLE_INSTRUCTIONS );
+    instructions.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
+    instructions.SetParentOrigin(ParentOrigin::BOTTOM_CENTER);
+    instructions.SetY(-50.0f);
+    instructions.SetProperty( Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL, true  );
+    instructions.SetProperty( Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 10  );
+    mContentLayer.Add(instructions);
-        mTable.AddChild( mImageViews[x][y], Toolkit::TableView::CellPosition( y, x ) );
-      }
+    for( unsigned int x = 0; x < NUMBER_OF_IMAGES; x++ )
+    {
+      Toolkit::PushButton button = Toolkit::PushButton::New();
+      button.SetProperty( Toolkit::Button::Property::LABEL, "on/off" );
+      button.SetParentOrigin( ParentOrigin::TOP_CENTER );
+      button.SetAnchorPoint( AnchorPoint::TOP_CENTER );
+      button.ClickedSignal().Connect( this, &ImageViewController::ToggleImageOnStage );
+      button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
+      button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
+      std::string s = std::to_string(x);
+      button.SetName( s );
+      mTable.AddChild( button, Toolkit::TableView::CellPosition( CellPlacement::TOP_BUTTON, x )  );
+
+      Toolkit::PushButton button2 = Toolkit::PushButton::New();
+      button2.SetProperty( Toolkit::Button::Property::LABEL, "Change" );
+      button2.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
+      button2.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
+      button2.ClickedSignal().Connect( this, &ImageViewController::ChangeImageClicked );
+      button2.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
+      button2.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
+      button2.SetName( s );
+      mTable.AddChild( button2, Toolkit::TableView::CellPosition( CellPlacement::LOWER_BUTTON, x )  );
+
+      mImageViews[x] = Toolkit::ImageView::New( IMAGE_PATH[ 0 ] );
+      mImageViews[x].SetParentOrigin( ParentOrigin::CENTER );
+      mImageViews[x].SetAnchorPoint( AnchorPoint::CENTER );
+      mImageViews[x].SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+      mTable.AddChild( mImageViews[x], Toolkit::TableView::CellPosition( CellPlacement::IMAGE, x ) );
+
+      // Set changeable counter and toggle for each ImageView
+      mImageViewImageIndexStatus[x] = true;
+      mImageViewToggleStatus[x] = true;
     }
-    Toolkit::TableView buttonsTable = Toolkit::TableView::New( 3, 1 );
-    buttonsTable.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
-    buttonsTable.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
-    buttonsTable.SetFitHeight( 0 );
-    buttonsTable.SetFitHeight( 1 );
-    buttonsTable.SetFitHeight( 2 );
-    buttonsTable.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
-
-    Toolkit::PushButton button = Toolkit::PushButton::New();
-    button.SetProperty( Toolkit::Button::Property::LABEL, "Toggle on/off stage" );
-    button.SetParentOrigin( ParentOrigin::CENTER );
-    button.SetAnchorPoint( AnchorPoint::CENTER );
-    button.ClickedSignal().Connect( this, &ImageViewController::ToggleImageOnStage );
-    button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
-    buttonsTable.AddChild( button, Toolkit::TableView::CellPosition( 0, 0 ) );
-
-    Toolkit::PushButton button2 = Toolkit::PushButton::New();
-    button2.SetProperty( Toolkit::Button::Property::LABEL, "Change Image" );
-    button2.SetParentOrigin( ParentOrigin::CENTER );
-    button2.SetAnchorPoint( AnchorPoint::CENTER );
-    button2.ClickedSignal().Connect( this, &ImageViewController::ChangeImageClicked );
-    button2.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
-    buttonsTable.AddChild( button2, Toolkit::TableView::CellPosition( 1, 0 ) );
-
-    mContentLayer.Add(buttonsTable);
-
     Stage::GetCurrent().KeyEventSignal().Connect(this, &ImageViewController::OnKeyEvent);
   }
 private:
+
   bool ToggleImageOnStage( Toolkit::Button button )
   {
-    Toolkit::ImageView imageView =  mImageViews[ mCurrentPositionToggle.columnIndex ][ mCurrentPositionToggle.rowIndex ];
+    unsigned int buttonIndex = GetButtonIndex( button );
-    if( mToggleOff )
+    Toolkit::ImageView imageView =  mImageViews[ buttonIndex ];
+
+    if( mImageViewToggleStatus[ buttonIndex ] )
     {
       imageView.Unparent();
     }
     else
     {
-      mTable.AddChild( imageView, mCurrentPositionToggle );
+      mTable.AddChild( imageView, Toolkit::TableView::CellPosition( 2, GetButtonIndex( button ) ) );
     }
-    ++mCurrentPositionToggle.columnIndex;
-    if( mCurrentPositionToggle.columnIndex == COLUMNS )
-    {
-      mCurrentPositionToggle.columnIndex = 0;
-      ++mCurrentPositionToggle.rowIndex;
-    }
-    if( mCurrentPositionToggle.rowIndex == ROWS )
-    {
-      mCurrentPositionToggle.rowIndex = 0;
-      mToggleOff = !mToggleOff;
-    }
+    mImageViewToggleStatus[ buttonIndex ] = !mImageViewToggleStatus[ buttonIndex ];
     return true;
   }
   bool ChangeImageClicked( Toolkit::Button button )
   {
-    Toolkit::ImageView imageView =  mImageViews[ mCurrentPositionImage.columnIndex ][ mCurrentPositionImage.rowIndex ];
-
-    imageView.SetImage( IMAGE_PATH[ mImageIdx ] );
+    unsigned int buttonIndex = GetButtonIndex( button );
-    ++mCurrentPositionImage.columnIndex;
-    if( mCurrentPositionImage.columnIndex == COLUMNS )
-    {
-      mCurrentPositionImage.columnIndex = 0;
-      ++mCurrentPositionImage.rowIndex;
-    }
-    if( mCurrentPositionImage.rowIndex == ROWS )
+    if (  mImageViews[buttonIndex].OnStage() )
     {
-      mCurrentPositionImage.rowIndex = 0;
-      ++mImageIdx;
+      mImageViews[buttonIndex].SetImage( IMAGE_PATH[ mImageViewImageIndexStatus[buttonIndex] ] );
-      if( mImageIdx == NUM_IMAGES )
+      ++mImageViewImageIndexStatus[buttonIndex];
+
+      if( mImageViewImageIndexStatus[buttonIndex] == NUMBER_OF_RESOURCES )
       {
-        mImageIdx = 0;
+        mImageViewImageIndexStatus[buttonIndex] = 0;
       }
     }
-
     return true;
   }
@@ -203,14 +218,13 @@ private:
   Toolkit::ToolBar           mToolBar;                           ///< The View's Toolbar.
   Layer                      mContentLayer;                      ///< Content layer
   Toolkit::TableView         mTable;
-  Toolkit::ImageView        mImageViews[ COLUMNS ][ ROWS ];
+  Toolkit::ImageView         mImageViews[ NUMBER_OF_IMAGES ];
+  bool                       mImageViewToggleStatus[ NUMBER_OF_IMAGES ];
+  unsigned int               mImageViewImageIndexStatus[ NUMBER_OF_IMAGES ];
   Toolkit::TableView::CellPosition mCurrentPositionToggle;
   Toolkit::TableView::CellPosition mCurrentPositionImage;
-  bool mToggleOff;
-  int mImageIdx;
-
 };
 void RunTest( Application& application )
@@ -20,7 +20,6 @@
 // EXTERNAL INCLUDES
 #include <dali/integration-api/debug.h>
-#include <string>
 #include <sstream>
 #include <string.h>
@@ -35,7 +34,7 @@ const int MAX_POINT_INDICES = 4;
 ObjLoader::ObjLoader()
 : mSceneLoaded( false ),
   mMaterialLoaded( false ),
-  mHasTexturePoints( false ),
+  mHasTextureUv( false ),
   mHasDiffuseMap( false ),
   mHasNormalMap( false ),
   mHasSpecularMap( false )
@@ -58,10 +57,10 @@ bool ObjLoader::IsMaterialLoaded()
   return mMaterialLoaded;
 }
-void ObjLoader::CalculateHardFaceNormals( const Dali::Vector<Vector3>& vertices, Dali::Vector<TriIndex>& triangles,
+void ObjLoader::CalculateHardFaceNormals( const Dali::Vector<Vector3>& points, Dali::Vector<TriIndex>& triangles,
                                           Dali::Vector<Vector3>& normals )
 {
-  int numFaceVertices = 3 * triangles.Size();  //Vertex per face, as each point has different normals for each face.
+  int numFaceVertices = 3 * triangles.Size();  //Vertices per face, as each vertex has different normals instance for each face.
   int normalIndex = 0;  //Tracks progress through the array of normals.
   normals.Clear();
@@ -71,19 +70,19 @@ void ObjLoader::CalculateHardFaceNormals( const Dali::Vector&lt;Vector3&gt;&amp; vertices,
   for( unsigned long i = 0; i < triangles.Size(); i++ )
   {
     //Triangle vertices.
-    const Vector3& v0 = vertices[triangles[i].pointIndex[0]];
-    const Vector3& v1 = vertices[triangles[i].pointIndex[1]];
-    const Vector3& v2 = vertices[triangles[i].pointIndex[2]];
+    const Vector3& v0 = points[triangles[i].pointIndex[0]];
+    const Vector3& v1 = points[triangles[i].pointIndex[1]];
+    const Vector3& v2 = points[triangles[i].pointIndex[2]];
     //Triangle edges.
     Vector3 edge1 = v1 - v0;
     Vector3 edge2 = v2 - v0;
-    //Using edges as vectors on the plane, cross to get the normal.
+    //Using edges as vectors on the plane, cross product to get the normal.
     Vector3 normalVector = edge1.Cross(edge2);
     normalVector.Normalize();
-    //Assign normals to points.
+    //Assign normal index to triangle vertex and set the normal vector to the list of normals.
     for( unsigned long j = 0; j < 3; j++, normalIndex++ )
     {
       triangles[i].normalIndex[j] = normalIndex;
@@ -92,22 +91,22 @@ void ObjLoader::CalculateHardFaceNormals( const Dali::Vector&lt;Vector3&gt;&amp; vertices,
   }
 }
-void ObjLoader::CalculateSoftFaceNormals( const Dali::Vector<Vector3>& vertices, Dali::Vector<TriIndex>& triangles,
+void ObjLoader::CalculateSoftFaceNormals( const Dali::Vector<Vector3>& points, Dali::Vector<TriIndex>& triangles,
                                           Dali::Vector<Vector3>& normals )
 {
   int normalIndex = 0;  //Tracks progress through the array of normals.
   normals.Clear();
-  normals.Resize( vertices.Size() );  //One (averaged) normal per point.
+  normals.Resize( points.Size() );  //One (averaged) normal per point.
   //For each triangle, calculate the normal by crossing two vectors on the triangle's plane
   //We then add the triangle's normal to the cumulative normals at each point of it
   for( unsigned long i = 0; i < triangles.Size(); i++ )
   {
-    //Triangle vertices.
-    const Vector3& v0 = vertices[triangles[i].pointIndex[0]];
-    const Vector3& v1 = vertices[triangles[i].pointIndex[1]];
-    const Vector3& v2 = vertices[triangles[i].pointIndex[2]];
+    //Triangle points.
+    const Vector3& v0 = points[triangles[i].pointIndex[0]];
+    const Vector3& v1 = points[triangles[i].pointIndex[1]];
+    const Vector3& v2 = points[triangles[i].pointIndex[2]];
     //Triangle edges.
     Vector3 edge1 = v1 - v0;
@@ -116,11 +115,12 @@ void ObjLoader::CalculateSoftFaceNormals( const Dali::Vector&lt;Vector3&gt;&amp; vertices,
     //Using edges as vectors on the plane, cross to get the normal.
     Vector3 normalVector = edge1.Cross(edge2);
-    //Add this triangle's normal to the cumulative normal of each constituent point and set the index of the normal accordingly.
-    for( unsigned long j = 0; j < 3; j++, normalIndex++ )
+    //Add this triangle's normal to the cumulative normal of each constituent triangle point and set the index of the normal accordingly.
+    for( unsigned long j = 0; j < 3; j++)
     {
-      triangles[i].normalIndex[j] = triangles[i].pointIndex[j]; //Normal index matches up to vertex index, as one normal per vertex.
-      normals[triangles[i].normalIndex[j]] += normalVector;
+      normalIndex = triangles[i].pointIndex[j];
+      triangles[i].normalIndex[j] = normalIndex; //Normal index matches up to vertex index, as one normal per vertex.
+      normals[normalIndex] += normalVector;
     }
   }
@@ -135,9 +135,9 @@ void ObjLoader::CalculateTangentFrame()
 {
   //Reset tangent vector to hold new values.
   mTangents.Clear();
-  mTangents.Resize( mPoints.Size() );
+  mTangents.Resize( mNormals.Size() );
-  //For each triangle, calculate the tangent vector and then add it to the total tangent vector of each point.
+  //For each triangle, calculate the tangent vector and then add it to the total tangent vector of each normal.
   for ( unsigned long a = 0; a < mTriangles.Size(); a++ )
   {
     Vector3 tangentVector;
@@ -149,27 +149,29 @@ void ObjLoader::CalculateTangentFrame()
     Vector3 edge1 = v1 - v0;
     Vector3 edge2 = v2 - v0;
-    const Vector2& w0 = mTextures[mTriangles[a].textureIndex[0]];
-    const Vector2& w1 = mTextures[mTriangles[a].textureIndex[1]];
-    const Vector2& w2 = mTextures[mTriangles[a].textureIndex[2]];
+    const Vector2& w0 = mTextureUv[mTriangles[a].textureIndex[0]];
+    const Vector2& w1 = mTextureUv[mTriangles[a].textureIndex[1]];
+    const Vector2& w2 = mTextureUv[mTriangles[a].textureIndex[2]];
     float deltaU1 = w1.x - w0.x;
     float deltaV1 = w1.y - w0.y;
     float deltaU2 = w2.x - w0.x;
     float deltaV2 = w2.y - w0.y;
-    float f = 1.0f / (deltaU1 * deltaV2 - deltaU2 * deltaV1);
+    // 1.0/f could cause division by zero in some cases, this factor will act
+    // as a weight of the tangent vector and it is fixed when it is normalised.
+    float f = (deltaU1 * deltaV2 - deltaU2 * deltaV1);
     tangentVector.x = f * ( deltaV2 * edge1.x - deltaV1 * edge2.x );
     tangentVector.y = f * ( deltaV2 * edge1.y - deltaV1 * edge2.y );
     tangentVector.z = f * ( deltaV2 * edge1.z - deltaV1 * edge2.z );
-    mTangents[mTriangles[a].pointIndex[0]] += tangentVector;
-    mTangents[mTriangles[a].pointIndex[1]] += tangentVector;
-    mTangents[mTriangles[a].pointIndex[2]] += tangentVector;
+    mTangents[mTriangles[a].normalIndex[0]] += tangentVector;
+    mTangents[mTriangles[a].normalIndex[1]] += tangentVector;
+    mTangents[mTriangles[a].normalIndex[2]] += tangentVector;
   }
-  //Orthogonalize tangents and set binormals.
+  //Orthogonalize tangents.
   for ( unsigned long a = 0; a < mTangents.Size(); a++ )
   {
     const Vector3& n = mNormals[a];
@@ -219,14 +221,15 @@ void ObjLoader::CreateGeometryArray( Dali::Vector&lt;Vector3&gt;&amp; positions,
   bool mustCalculateTangents = ( mTangents.Size() == 0 ) || ( mTangents.Size() != mNormals.Size() );
   //However, we don't need to do this if the object doesn't use textures to begin with.
-  mustCalculateTangents &= mHasTexturePoints;
+  mustCalculateTangents &= mHasTextureUv;
-  //We also have to recalculate the normals if we need to calculate tangents,
-  // as we need just one normal, tangent per vertex, rather than the supplied per-face vertices.
-  //Alternatively, we need to calculate the normals if there weren't any to begin with.
-  if( mNormals.Size() == 0 || mustCalculateTangents )
+  // We calculate the normals if hard normals(flat normals) is set.
+  // Use the normals provided by the file to make the tangent calculation per normal,
+  // the correct results depends of normal generated by file, otherwise we need to recalculate
+  // the normal programmatically.
+  if( ( ( mNormals.Size() == 0 ) && mustCalculateTangents ) || !useSoftNormals )
   {
-    if( useSoftNormals || mustCalculateTangents )
+    if( useSoftNormals )
     {
       CalculateSoftFaceNormals( mPoints, mTriangles, mNormals );
     }
@@ -236,16 +239,16 @@ void ObjLoader::CreateGeometryArray( Dali::Vector&lt;Vector3&gt;&amp; positions,
     }
   }
-  if( mHasTexturePoints && mustCalculateTangents )
+  if( mHasTextureUv && mustCalculateTangents )
   {
     CalculateTangentFrame();
   }
-  bool mapsCorrespond; //True if the sizes of the arrays necessary for the object agree.
+  bool mapsCorrespond; //True if the sizes of the arrays necessary to draw the object match.
-  if ( mHasTexturePoints )
+  if ( mHasTextureUv )
   {
-    mapsCorrespond = ( mPoints.Size() == mTextures.Size() ) && ( mTextures.Size() == mNormals.Size() );
+    mapsCorrespond = ( mPoints.Size() == mTextureUv.Size() ) && ( mTextureUv.Size() == mNormals.Size() );
   }
   else
   {
@@ -278,9 +281,9 @@ void ObjLoader::CreateGeometryArray( Dali::Vector&lt;Vector3&gt;&amp; positions,
         normals[mTriangles[ui].pointIndex[j]] = mNormals[mTriangles[ui].normalIndex[j]];
-        if ( mHasTexturePoints )
+        if ( mHasTextureUv )
         {
-          textures[mTriangles[ui].pointIndex[j]] = mTextures[mTriangles[ui].textureIndex[j]];
+          textures[mTriangles[ui].pointIndex[j]] = mTextureUv[mTriangles[ui].textureIndex[j]];
           tangents[mTriangles[ui].pointIndex[j]] = mTangents[mTriangles[ui].normalIndex[j]];
         }
       }
@@ -304,9 +307,9 @@ void ObjLoader::CreateGeometryArray( Dali::Vector&lt;Vector3&gt;&amp; positions,
         positions[index] = mPoints[mTriangles[ui].pointIndex[j]];
         normals[index] = mNormals[mTriangles[ui].normalIndex[j]];
-        if( mHasTexturePoints )
+        if( mHasTextureUv )
         {
-          textures[index] = mTextures[mTriangles[ui].textureIndex[j]];
+          textures[index] = mTextureUv[mTriangles[ui].textureIndex[j]];
           tangents[index] = mTangents[mTriangles[ui].normalIndex[j]];
         }
@@ -335,7 +338,7 @@ bool ObjLoader::LoadObject( char* objBuffer, std::streampos fileSize )
   std::string strMatActual;
-  std::string input = objBuffer;
+  std::string input( objBuffer, fileSize );
   std::istringstream ss(input);
   ss.imbue( std::locale( "C" ) );
@@ -388,9 +391,8 @@ bool ObjLoader::LoadObject( char* objBuffer, std::streampos fileSize )
     {
       isline >> texture.x;
       isline >> texture.y;
-
       texture.y = 1.0-texture.y;
-      mTextures.PushBack( texture );
+      mTextureUv.PushBack( texture );
     }
     else if ( tag == "#_#vt1" )
     {
@@ -398,7 +400,7 @@ bool ObjLoader::LoadObject( char* objBuffer, std::streampos fileSize )
       isline >> texture.y;
       texture.y = 1.0-texture.y;
-      mTextures2.PushBack( texture );
+      mTextureUv2.PushBack( texture );
     }
     else if ( tag == "s" )
     {
@@ -413,7 +415,7 @@ bool ObjLoader::LoadObject( char* objBuffer, std::streampos fileSize )
       }
       int numIndices = 0;
-      while( isline >> vet[numIndices] && numIndices < MAX_POINT_INDICES )
+      while( ( numIndices < MAX_POINT_INDICES ) && ( isline >> vet[numIndices] ) )
       {
         numIndices++;
       }
@@ -523,7 +525,7 @@ bool ObjLoader::LoadObject( char* objBuffer, std::streampos fileSize )
   {
     CenterAndScale( true, mPoints );
     mSceneLoaded = true;
-    mHasTexturePoints = hasTexture;
+    mHasTextureUv = hasTexture;
     return true;
   }
@@ -627,7 +629,7 @@ Geometry ObjLoader::CreateGeometry( int objectProperties, bool useSoftNormals )
   surface.AddVertexBuffer( normalBuffer );
   //Some need tangent
-  if( ( objectProperties & TANGENTS ) && mHasTexturePoints )
+  if( ( objectProperties & TANGENTS ) && mHasTextureUv )
   {
     Property::Map tangentMap;
     tangentMap["aTangent"] = Property::VECTOR3;
@@ -638,7 +640,7 @@ Geometry ObjLoader::CreateGeometry( int objectProperties, bool useSoftNormals )
   }
   //Some need texture coordinates
-  if( ( objectProperties & TEXTURE_COORDINATES ) && mHasTexturePoints )
+  if( ( objectProperties & TEXTURE_COORDINATES ) && mHasTextureUv )
   {
     Property::Map textCoordMap;
     textCoordMap["aTexCoord"] = Property::VECTOR2;
@@ -672,8 +674,8 @@ Vector3 ObjLoader::GetSize()
 void ObjLoader::ClearArrays()
 {
   mPoints.Clear();
-  mTextures.Clear();
-  mTextures2.Clear();
+  mTextureUv.Clear();
+  mTextureUv2.Clear();
   mNormals.Clear();
   mTangents.Clear();
   mBiTangents.Clear();
@@ -685,7 +687,7 @@ void ObjLoader::ClearArrays()
 bool ObjLoader::IsTexturePresent()
 {
-  return mHasTexturePoints;
+  return mHasTextureUv;
 }
 bool ObjLoader::IsDiffuseMapPresent()
@@ -95,8 +95,8 @@ public:
 private:
   Dali::Vector<Vector3>  mPoints;
-  Dali::Vector<Vector2>  mTextures;
-  Dali::Vector<Vector2>  mTextures2;
+  Dali::Vector<Vector2>  mTextureUv;
+  Dali::Vector<Vector2>  mTextureUv2;
   Dali::Vector<Vector3>  mNormals;
   Dali::Vector<Vector3>  mTangents;
   Dali::Vector<Vector3>  mBiTangents;
@@ -106,7 +106,7 @@ private:
   bool mSceneLoaded;
   bool mMaterialLoaded;
-  bool mHasTexturePoints;
+  bool mHasTextureUv;
   //Material file properties.
   bool mHasDiffuseMap;
@@ -2,7 +2,7 @@
 Name:       com.samsung.dali-demo
 Summary:    The OpenGLES Canvas Core Demo
-Version:    1.2.47
+Version:    1.2.48
 Release:    1
 Group:      System/Libraries
 License:    Apache-2.0