dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.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 "npatch-renderer.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/platform-abstraction.h>
  23 #include <dali/public-api/images/buffer-image.h>
  24 #include <dali/public-api/images/resource-image.h>
  25 #include <dali/devel-api/images/texture-set-image.h>
  26
  27 // INTERNAL IINCLUDES
  28 #include <dali-toolkit/internal/controls/renderers/renderer-factory-impl.h>
  29 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
  30 #include <dali-toolkit/internal/controls/renderers/renderer-string-constants.h>
  31 #include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
  32 #include <dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h>
  33
  34
  35 namespace Dali
  36 {
  37
  38 namespace Toolkit
  39 {
  40
  41 namespace Internal
  42 {
  43
  44 namespace
  45 {
  46 const char * const BORDER_ONLY("borderOnly");
  47
  48 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
  49   attribute mediump vec2 aPosition;\n
  50   varying mediump vec2 vTexCoord;\n
  51   uniform mediump mat4 uMvpMatrix;\n
  52   uniform mediump vec3 uSize;\n
  53   uniform mediump vec2 uNinePatchFactorsX[ FACTOR_SIZE_X ];\n
  54   uniform mediump vec2 uNinePatchFactorsY[ FACTOR_SIZE_Y ];\n
  55   \n
  56   void main()\n
  57   {\n
  58     mediump vec2 fixedFactor  = vec2( uNinePatchFactorsX[ int( ( aPosition.x + 1.0 ) * 0.5 ) ].x, uNinePatchFactorsY[ int( ( aPosition.y + 1.0 ) * 0.5 ) ].x );\n
  59     mediump vec2 stretch      = vec2( uNinePatchFactorsX[ int( ( aPosition.x       ) * 0.5 ) ].y, uNinePatchFactorsY[ int( ( aPosition.y       ) * 0.5 ) ].y );\n
  60     \n
  61     mediump vec2 fixedTotal   = vec2( uNinePatchFactorsX[ FACTOR_SIZE_X - 1 ].x, uNinePatchFactorsY[ FACTOR_SIZE_Y - 1 ].x );\n
  62     mediump vec2 stretchTotal = vec2( uNinePatchFactorsX[ FACTOR_SIZE_X - 1 ].y, uNinePatchFactorsY[ FACTOR_SIZE_Y - 1 ].y );\n
  63     \n
  64     mediump vec4 vertexPosition = vec4( ( fixedFactor + ( uSize.xy - fixedTotal ) * stretch / stretchTotal ), 0.0, 1.0 );\n
  65     vertexPosition.xy -= uSize.xy * vec2( 0.5, 0.5 );\n
  66     vertexPosition = uMvpMatrix * vertexPosition;\n
  67     \n
  68     vTexCoord = ( fixedFactor + stretch ) / ( fixedTotal + stretchTotal );\n
  69     \n
  70     gl_Position = vertexPosition;\n
  71   }\n
  72 );
  73
  74 const char* VERTEX_SHADER_3X3 = DALI_COMPOSE_SHADER(
  75     attribute mediump vec2 aPosition;\n
  76     varying mediump vec2 vTexCoord;\n
  77     uniform mediump mat4 uModelMatrix;\n
  78     uniform mediump mat4 uMvpMatrix;\n
  79     uniform mediump vec3 uSize;\n
  80     uniform mediump vec2 uFixed[ 3 ];\n
  81     uniform mediump vec2 uStretchTotal;\n
  82     \n
  83     void main()\n
  84     {\n
  85       mediump vec2 scale        = vec2( length( uModelMatrix[ 0 ].xyz ), length( uModelMatrix[ 1 ].xyz ) );\n
  86       mediump vec2 size         = uSize.xy * scale;\n
  87       \n
  88       mediump vec2 fixedFactor  = vec2( uFixed[ int( ( aPosition.x + 1.0 ) * 0.5 ) ].x, uFixed[ int( ( aPosition.y  + 1.0 ) * 0.5 ) ].y );\n
  89       mediump vec2 stretch      = floor( aPosition * 0.5 );\n
  90       mediump vec2 fixedTotal   = uFixed[ 2 ];\n
  91       \n
  92       mediump vec4 vertexPosition = vec4( fixedFactor + ( size - fixedTotal ) * stretch, 0.0, 1.0 );\n
  93       vertexPosition.xy -= size * vec2( 0.5, 0.5 );\n
  94       vertexPosition.xy =  vertexPosition.xy / scale;\n
  95       \n
  96       vertexPosition = uMvpMatrix * vertexPosition;\n
  97       \n
  98       vTexCoord = ( fixedFactor + stretch * uStretchTotal ) / ( fixedTotal + uStretchTotal );\n
  99       \n
 100       gl_Position = vertexPosition;\n
 101     }\n
 102 );
 103
 104 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
 105   varying mediump vec2 vTexCoord;\n
 106   uniform sampler2D sTexture;\n
 107   uniform lowp vec4 uColor;\n
 108   \n
 109   void main()\n
 110   {\n
 111     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
 112   }\n
 113 );
 114
 115 /**
 116  * @brief Creates the geometry formed from the vertices and indices
 117  *
 118  * @param[in]  vertices             The vertices to generate the geometry from
 119  * @param[in]  indices              The indices to generate the geometry from
 120  * @return The geometry formed from the vertices and indices
 121  */
 122 Geometry GenerateGeometry( const Vector< Vector2 >& vertices, const Vector< unsigned short >& indices )
 123 {
 124   Property::Map vertexFormat;
 125   vertexFormat[ "aPosition" ] = Property::VECTOR2;
 126   PropertyBuffer vertexPropertyBuffer = PropertyBuffer::New( vertexFormat );
 127   if( vertices.Size() > 0 )
 128   {
 129     vertexPropertyBuffer.SetData( &vertices[ 0 ], vertices.Size() );
 130   }
 131
 132   // Create the geometry object
 133   Geometry geometry = Geometry::New();
 134   geometry.AddVertexBuffer( vertexPropertyBuffer );
 135   if( indices.Size() > 0 )
 136   {
 137     geometry.SetIndexBuffer( &indices[ 0 ], indices.Size() );
 138   }
 139
 140
 141   return geometry;
 142 }
 143
 144 /**
 145  * @brief Adds the indices to form a quad composed off two triangles where the indices are organised in a grid
 146  *
 147  * @param[out] indices     The indices to add to
 148  * @param[in]  rowIdx      The row index to start the quad
 149  * @param[in]  nextRowIdx  The index to the next row
 150  */
 151 void AddQuadIndices( Vector< unsigned short >& indices, unsigned int rowIdx, unsigned int nextRowIdx )
 152 {
 153   indices.PushBack( rowIdx );
 154   indices.PushBack( nextRowIdx + 1 );
 155   indices.PushBack( rowIdx + 1 );
 156
 157   indices.PushBack( rowIdx );
 158   indices.PushBack( nextRowIdx );
 159   indices.PushBack( nextRowIdx + 1 );
 160 }
 161
 162 void AddVertex( Vector< Vector2 >& vertices, unsigned int x, unsigned int y )
 163 {
 164   vertices.PushBack( Vector2( x, y ) );
 165 }
 166
 167 void RegisterStretchProperties( Renderer& renderer, const char * uniformName, const NinePatchImage::StretchRanges& stretchPixels, uint16_t imageExtent)
 168 {
 169   uint16_t prevEnd = 0;
 170   uint16_t prevFix = 0;
 171   uint16_t prevStretch = 0;
 172   unsigned int i = 1;
 173   for( NinePatchImage::StretchRanges::ConstIterator it = stretchPixels.Begin(); it != stretchPixels.End(); ++it, ++i )
 174   {
 175     uint16_t start = it->GetX();
 176     uint16_t end = it->GetY();
 177
 178     uint16_t fix = prevFix + start - prevEnd;
 179     uint16_t stretch = prevStretch + end - start;
 180
 181     std::stringstream uniform;
 182     uniform << uniformName << "[" << i << "]";
 183     renderer.RegisterProperty( uniform.str(), Vector2( fix, stretch ) );
 184
 185     prevEnd = end;
 186     prevFix = fix;
 187     prevStretch = stretch;
 188   }
 189
 190   {
 191     prevFix += imageExtent - prevEnd;
 192     std::stringstream uniform;
 193     uniform << uniformName << "[" << i << "]";
 194     renderer.RegisterProperty( uniform.str(), Vector2( prevFix, prevStretch ) );
 195   }
 196 }
 197
 198 } //unnamed namespace
 199
 200 /////////////////NPatchRenderer////////////////
 201
 202 NPatchRenderer::NPatchRenderer( RendererFactoryCache& factoryCache )
 203 : ControlRenderer( factoryCache ),
 204   mBorderOnly( false )
 205 {
 206 }
 207
 208 NPatchRenderer::~NPatchRenderer()
 209 {
 210 }
 211
 212 void NPatchRenderer::DoInitialize( Actor& actor, const Property::Map& propertyMap )
 213 {
 214   Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
 215   if( imageURLValue )
 216   {
 217     //Read the borderOnly property first since InitialiseFromImage relies on mBorderOnly to be properly set
 218     Property::Value* borderOnlyValue = propertyMap.Find( BORDER_ONLY );
 219     if( borderOnlyValue )
 220     {
 221       borderOnlyValue->Get( mBorderOnly );
 222     }
 223
 224     if( imageURLValue->Get( mImageUrl ) )
 225     {
 226       NinePatchImage nPatch = NinePatchImage::New( mImageUrl );
 227       InitializeFromImage( nPatch );
 228     }
 229     else
 230     {
 231       InitializeFromBrokenImage();
 232       DALI_LOG_ERROR( "The property '%s' is not a string\n", IMAGE_URL_NAME );
 233     }
 234   }
 235 }
 236
 237 void NPatchRenderer::GetNaturalSize( Vector2& naturalSize ) const
 238 {
 239   if( mImage )
 240   {
 241     naturalSize.x = mImage.GetWidth();
 242     naturalSize.y = mImage.GetHeight();
 243   }
 244   else if( !mImageUrl.empty() )
 245   {
 246     ImageDimensions dimentions = ResourceImage::GetImageSize( mImageUrl );
 247     naturalSize.x = dimentions.GetWidth();
 248     naturalSize.y = dimentions.GetHeight();
 249   }
 250   else
 251   {
 252     naturalSize = Vector2::ZERO;
 253   }
 254 }
 255
 256 void NPatchRenderer::SetClipRect( const Rect<int>& clipRect )
 257 {
 258   ControlRenderer::SetClipRect( clipRect );
 259   //ToDo: renderer responds to the clipRect change
 260 }
 261
 262 void NPatchRenderer::SetOffset( const Vector2& offset )
 263 {
 264   //ToDo: renderer applies the offset
 265 }
 266
 267 Geometry NPatchRenderer::CreateGeometry()
 268 {
 269   Geometry geometry;
 270   if( mStretchPixelsX.Size() == 1 && mStretchPixelsY.Size() == 1 )
 271   {
 272     if( !mBorderOnly )
 273     {
 274       geometry = mFactoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY );
 275       if( !geometry )
 276       {
 277         geometry = CreateGeometry( Uint16Pair( 3, 3 ) );
 278         mFactoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY, geometry );
 279       }
 280     }
 281     else
 282     {
 283       geometry = mFactoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY );
 284       if( !geometry )
 285       {
 286         geometry = CreateGeometryBorder( Uint16Pair( 3, 3 ) );
 287         mFactoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY, geometry );
 288       }
 289     }
 290   }
 291   else if( mStretchPixelsX.Size() > 0 || mStretchPixelsY.Size() > 0)
 292   {
 293     Uint16Pair gridSize( 2 * mStretchPixelsX.Size() + 1,  2 * mStretchPixelsY.Size() + 1 );
 294     geometry = !mBorderOnly ? CreateGeometry( gridSize ) : CreateGeometryBorder( gridSize );
 295   }
 296
 297   return geometry;
 298 }
 299
 300 Shader NPatchRenderer::CreateShader()
 301 {
 302   Shader shader;
 303   if( !mImpl->mCustomShader )
 304   {
 305     if( mStretchPixelsX.Size() == 1 && mStretchPixelsY.Size() == 1 )
 306     {
 307       shader = mFactoryCache.GetShader( RendererFactoryCache::NINE_PATCH_SHADER );
 308       if( !shader )
 309       {
 310         shader = Shader::New( VERTEX_SHADER_3X3, FRAGMENT_SHADER );
 311         mFactoryCache.SaveShader( RendererFactoryCache::NINE_PATCH_SHADER, shader );
 312       }
 313     }
 314     else if( mStretchPixelsX.Size() > 0 || mStretchPixelsY.Size() > 0)
 315     {
 316       std::stringstream vertexShader;
 317       vertexShader << "#define FACTOR_SIZE_X " << mStretchPixelsX.Size() + 2 << "\n"
 318                    << "#define FACTOR_SIZE_Y " << mStretchPixelsY.Size() + 2 << "\n"
 319                    << VERTEX_SHADER;
 320
 321       shader = Shader::New( vertexShader.str(), FRAGMENT_SHADER );
 322     }
 323   }
 324   else
 325   {
 326     const char* fragmentShader = FRAGMENT_SHADER;
 327     Dali::Shader::ShaderHints hints = Dali::Shader::HINT_NONE;
 328
 329     if( !mImpl->mCustomShader->mFragmentShader.empty() )
 330     {
 331       fragmentShader = mImpl->mCustomShader->mFragmentShader.c_str();
 332     }
 333     hints = mImpl->mCustomShader->mHints;
 334
 335     if( mStretchPixelsX.Size() == 1 && mStretchPixelsY.Size() == 1 )
 336     {
 337       shader = Shader::New( VERTEX_SHADER_3X3, fragmentShader, hints );
 338     }
 339     else if( mStretchPixelsX.Size() > 0 || mStretchPixelsY.Size() > 0)
 340     {
 341       std::stringstream vertexShader;
 342       vertexShader << "#define FACTOR_SIZE_X " << mStretchPixelsX.Size() + 2 << "\n"
 343                    << "#define FACTOR_SIZE_Y " << mStretchPixelsY.Size() + 2 << "\n"
 344                    << VERTEX_SHADER;
 345
 346       shader = Shader::New( vertexShader.str(), fragmentShader, hints );
 347     }
 348   }
 349
 350   return shader;
 351 }
 352
 353 void NPatchRenderer::InitializeRenderer()
 354 {
 355   Geometry geometry = CreateGeometry();
 356   Shader shader = CreateShader();
 357
 358   if( !geometry || !shader )
 359   {
 360     DALI_LOG_ERROR("The 9 patch image '%s' doesn't have any valid stretch borders and so is not a valid 9 patch image\n", mImageUrl.c_str() );
 361     InitializeFromBrokenImage();
 362   }
 363
 364   TextureSet textureSet = TextureSet::New();
 365   mImpl->mRenderer = Renderer::New( geometry, shader );
 366   mImpl->mRenderer.SetTextures( textureSet );
 367 }
 368
 369
 370 void NPatchRenderer::DoSetOnStage( Actor& actor )
 371 {
 372   if( !mCroppedImage )
 373   {
 374     if( !mImageUrl.empty() )
 375     {
 376       NinePatchImage nPatch = NinePatchImage::New( mImageUrl );
 377       InitializeFromImage( nPatch );
 378     }
 379     else if( mImage )
 380     {
 381       InitializeFromImage( mImage );
 382     }
 383   }
 384
 385   //initialize the renderer after initializing from the image since we need to know the grid size from the image before creating the geometry
 386   InitializeRenderer();
 387
 388   if( mCroppedImage )
 389   {
 390     ApplyImageToSampler();
 391   }
 392 }
 393
 394 void NPatchRenderer::DoSetOffStage( Actor& actor )
 395 {
 396   mCroppedImage.Reset();
 397   actor.RemoveRenderer( mImpl->mRenderer );
 398   mImpl->mRenderer.Reset();
 399 }
 400
 401 void NPatchRenderer::DoCreatePropertyMap( Property::Map& map ) const
 402 {
 403   map.Clear();
 404   map.Insert( RENDERER_TYPE, IMAGE_RENDERER );
 405   if( !mImageUrl.empty() )
 406   {
 407     map.Insert( IMAGE_URL_NAME, mImageUrl );
 408   }
 409   else if( mImage )
 410   {
 411     map.Insert( IMAGE_URL_NAME, mImage.GetUrl() );
 412   }
 413   map.Insert( BORDER_ONLY, mBorderOnly );
 414 }
 415
 416 void NPatchRenderer::ChangeRenderer( bool oldBorderOnly, size_t oldGridX, size_t oldGridY )
 417 {
 418   //check to see if the border style has changed
 419
 420   bool borderOnlyChanged = oldBorderOnly != mBorderOnly;
 421   bool gridChanged = oldGridX != mStretchPixelsX.Size() || oldGridY != mStretchPixelsY.Size();
 422
 423   if( borderOnlyChanged || gridChanged )
 424   {
 425     Geometry geometry = CreateGeometry();
 426     if( geometry )
 427     {
 428       mImpl->mRenderer.SetGeometry( geometry );
 429     }
 430     else
 431     {
 432       InitializeFromBrokenImage();
 433     }
 434   }
 435
 436   if( gridChanged )
 437   {
 438     Shader shader = CreateShader();
 439     TextureSet textureSet;
 440     if( shader )
 441     {
 442       textureSet = mImpl->mRenderer.GetTextures();
 443       if( !textureSet )
 444       {
 445         InitializeFromBrokenImage();
 446       }
 447       mImpl->mRenderer.SetShader( shader );
 448     }
 449   }
 450 }
 451
 452 void NPatchRenderer::SetImage( const std::string& imageUrl, bool borderOnly )
 453 {
 454   bool oldBorderOnly = mBorderOnly;
 455   size_t oldGridX = mStretchPixelsX.Size();
 456   size_t oldGridY = mStretchPixelsY.Size();
 457
 458   mBorderOnly = borderOnly;
 459   mImage.Reset();
 460   if( mImageUrl == imageUrl )
 461   {
 462     return;
 463   }
 464
 465   mImageUrl = imageUrl;
 466   if( mImpl->mRenderer )
 467   {
 468     NinePatchImage nPatch = NinePatchImage::New( mImageUrl );
 469     InitializeFromImage( nPatch );
 470
 471     ChangeRenderer( oldBorderOnly, oldGridX, oldGridY );
 472
 473     if( mCroppedImage )
 474     {
 475       ApplyImageToSampler();
 476     }
 477   }
 478 }
 479
 480 void NPatchRenderer::SetImage( NinePatchImage image, bool borderOnly )
 481 {
 482   bool oldBorderOnly = mBorderOnly;
 483   size_t oldGridX = mStretchPixelsX.Size();
 484   size_t oldGridY = mStretchPixelsY.Size();
 485
 486   mBorderOnly = borderOnly;
 487   mImageUrl.empty();
 488   if( mImage == image )
 489   {
 490     return;
 491   }
 492
 493   mImage = image;
 494   if( mImpl->mRenderer )
 495   {
 496     InitializeFromImage( mImage );
 497     ChangeRenderer( oldBorderOnly, oldGridX, oldGridY );
 498
 499     if( mCroppedImage )
 500     {
 501       ApplyImageToSampler();
 502     }
 503   }
 504 }
 505
 506 void NPatchRenderer::InitializeFromImage( NinePatchImage nPatch )
 507 {
 508   mCroppedImage = nPatch.CreateCroppedBufferImage();
 509   if( !mCroppedImage )
 510   {
 511     DALI_LOG_ERROR("'%s' specify a valid 9 patch image\n", mImageUrl.c_str() );
 512     InitializeFromBrokenImage();
 513     return;
 514   }
 515
 516   mImageSize = ImageDimensions( mCroppedImage.GetWidth(), mCroppedImage.GetHeight() );
 517
 518   mStretchPixelsX = nPatch.GetStretchPixelsX();
 519   mStretchPixelsY = nPatch.GetStretchPixelsY();
 520 }
 521
 522 void NPatchRenderer::InitializeFromBrokenImage()
 523 {
 524   mCroppedImage = RendererFactory::GetBrokenRendererImage();
 525   mImageSize = ImageDimensions( mCroppedImage.GetWidth(), mCroppedImage.GetHeight() );
 526
 527   mStretchPixelsX.Clear();
 528   mStretchPixelsX.PushBack( Uint16Pair( 0, mImageSize.GetWidth() ) );
 529   mStretchPixelsY.Clear();
 530   mStretchPixelsY.PushBack( Uint16Pair( 0, mImageSize.GetHeight() ) );
 531 }
 532
 533 void NPatchRenderer::ApplyImageToSampler()
 534 {
 535   TextureSet textureSet = mImpl->mRenderer.GetTextures();
 536   if( textureSet )
 537   {
 538     TextureSetImage( textureSet, 0u, mCroppedImage );
 539
 540     if( mStretchPixelsX.Size() == 1 && mStretchPixelsY.Size() == 1 )
 541     {
 542       //special case for 9 patch
 543       Uint16Pair stretchX = mStretchPixelsX[ 0 ];
 544       Uint16Pair stretchY = mStretchPixelsY[ 0 ];
 545
 546       uint16_t stretchWidth = stretchX.GetY() - stretchX.GetX();
 547       uint16_t stretchHeight = stretchY.GetY() - stretchY.GetX();
 548
 549       mImpl->mRenderer.RegisterProperty( "uFixed[0]", Vector2::ZERO );
 550       mImpl->mRenderer.RegisterProperty( "uFixed[1]", Vector2( stretchX.GetX(), stretchY.GetX()) );
 551       mImpl->mRenderer.RegisterProperty( "uFixed[2]", Vector2( mImageSize.GetWidth() - stretchWidth, mImageSize.GetHeight() - stretchHeight ) );
 552       mImpl->mRenderer.RegisterProperty( "uStretchTotal", Vector2( stretchWidth, stretchHeight ) );
 553     }
 554     else
 555     {
 556       mImpl->mRenderer.RegisterProperty( "uNinePatchFactorsX[0]", Vector2::ZERO );
 557       mImpl->mRenderer.RegisterProperty( "uNinePatchFactorsY[0]", Vector2::ZERO );
 558
 559       RegisterStretchProperties( mImpl->mRenderer, "uNinePatchFactorsX", mStretchPixelsX, mImageSize.GetWidth() );
 560       RegisterStretchProperties( mImpl->mRenderer, "uNinePatchFactorsY", mStretchPixelsY, mImageSize.GetHeight() );
 561     }
 562   }
 563 }
 564
 565 Geometry NPatchRenderer::CreateGeometry( Uint16Pair gridSize )
 566 {
 567   uint16_t gridWidth = gridSize.GetWidth();
 568   uint16_t gridHeight = gridSize.GetHeight();
 569
 570   // Create vertices
 571   Vector< Vector2 > vertices;
 572   vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
 573
 574   for( int y = 0; y < gridHeight + 1; ++y )
 575   {
 576     for( int x = 0; x < gridWidth + 1; ++x )
 577     {
 578       AddVertex( vertices, x, y );
 579     }
 580   }
 581
 582   // Create indices
 583   //TODO: compare performance with triangle strip when Geometry supports it
 584   Vector< unsigned short > indices;
 585   indices.Reserve( gridWidth * gridHeight * 6 );
 586
 587   unsigned int rowIdx     = 0;
 588   unsigned int nextRowIdx = gridWidth + 1;
 589   for( int y = 0; y < gridHeight; ++y, ++nextRowIdx, ++rowIdx )
 590   {
 591     for( int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx )
 592     {
 593       AddQuadIndices( indices, rowIdx, nextRowIdx );
 594     }
 595   }
 596
 597   return GenerateGeometry( vertices, indices );
 598 }
 599
 600 Geometry NPatchRenderer::CreateGeometryBorder( Uint16Pair gridSize )
 601 {
 602   uint16_t gridWidth = gridSize.GetWidth();
 603   uint16_t gridHeight = gridSize.GetHeight();
 604
 605   // Create vertices
 606   Vector< Vector2 > vertices;
 607   vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
 608
 609   //top
 610   int y = 0;
 611   for(; y < 2; ++y)
 612   {
 613     for( int x = 0; x < gridWidth + 1; ++x )
 614     {
 615       AddVertex( vertices, x, y );
 616     }
 617   }
 618
 619   for(; y < gridHeight - 1; ++y)
 620   {
 621     //left
 622     AddVertex( vertices, 0, y );
 623     AddVertex( vertices, 1, y );
 624
 625     //right
 626     AddVertex( vertices, gridWidth - 1, y );
 627     AddVertex( vertices, gridWidth, y );
 628   }
 629
 630   //bottom
 631   for(; y < gridHeight + 1; ++y)
 632   {
 633     for( int x = 0; x < gridWidth + 1; ++x )
 634     {
 635       AddVertex( vertices, x, y );
 636     }
 637   }
 638
 639   // Create indices
 640   //TODO: compare performance with triangle strip when Geometry supports it
 641   Vector< unsigned short > indices;
 642   indices.Reserve( gridWidth * gridHeight * 6 );
 643
 644   //top
 645   unsigned int rowIdx     = 0 ;
 646   unsigned int nextRowIdx = gridWidth + 1;
 647   for( int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx )
 648   {
 649     AddQuadIndices( indices, rowIdx, nextRowIdx );
 650   }
 651
 652   if(gridHeight > 2)
 653   {
 654     rowIdx     = gridWidth + 1;
 655     nextRowIdx = ( gridWidth + 1 ) * 2;
 656
 657     unsigned increment = gridWidth - 1;
 658     if(gridHeight > 3)
 659     {
 660       increment = 2;
 661       //second row left
 662       AddQuadIndices( indices, rowIdx, nextRowIdx );
 663
 664       rowIdx     = gridWidth * 2;
 665       nextRowIdx = ( gridWidth + 1 ) * 2 + 2;
 666       //second row right
 667       AddQuadIndices( indices, rowIdx, nextRowIdx );
 668
 669       //left and right
 670       rowIdx     = nextRowIdx - 2;
 671       nextRowIdx = rowIdx + 4;
 672       for(int y = 2; y < 2*(gridHeight - 3); ++y, rowIdx += 2, nextRowIdx += 2)
 673       {
 674         AddQuadIndices( indices, rowIdx, nextRowIdx );
 675       }
 676     }
 677
 678     //second row left
 679     AddQuadIndices( indices, rowIdx, nextRowIdx );
 680
 681     rowIdx     += increment;
 682     nextRowIdx += gridWidth - 1;
 683     //second row right
 684     AddQuadIndices( indices, rowIdx, nextRowIdx );
 685   }
 686
 687   //bottom
 688   rowIdx     = nextRowIdx - gridWidth + 1;
 689   nextRowIdx = rowIdx + gridWidth + 1;
 690   for( int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx )
 691   {
 692     AddQuadIndices( indices, rowIdx, nextRowIdx );
 693   }
 694
 695   return GenerateGeometry( vertices, indices );
 696 }
 697
 698 } // namespace Internal
 699
 700 } // namespace Toolkit
 701
 702 } // namespace Dali