dali-toolkit/internal/visuals/npatch/npatch-visual.cpp

   1 /*
   2  * Copyright (c) 2021 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-visual.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/adaptor-framework/image-loading.h>
  23 #include <dali/devel-api/rendering/renderer-devel.h>
  24 #include <dali/integration-api/debug.h>
  25 #include <dali/devel-api/common/stage.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  29 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
  30 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  31 #include <dali-toolkit/internal/visuals/npatch-loader.h>
  32 #include <dali-toolkit/internal/visuals/rendering-addon.h>
  33 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  34 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
  35 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  36 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
  37 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  38 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  39
  40 namespace Dali
  41 {
  42 namespace Toolkit
  43 {
  44 namespace Internal
  45 {
  46 namespace
  47 {
  48 /**
  49  * @brief Creates the geometry formed from the vertices and indices
  50  *
  51  * @param[in]  vertices             The vertices to generate the geometry from
  52  * @param[in]  indices              The indices to generate the geometry from
  53  * @return The geometry formed from the vertices and indices
  54  */
  55 Geometry GenerateGeometry(const Vector<Vector2>& vertices, const Vector<unsigned short>& indices)
  56 {
  57   Property::Map vertexFormat;
  58   vertexFormat["aPosition"] = Property::VECTOR2;
  59   VertexBuffer vertexBuffer = VertexBuffer::New(vertexFormat);
  60   if(vertices.Size() > 0)
  61   {
  62     vertexBuffer.SetData(&vertices[0], vertices.Size());
  63   }
  64
  65   // Create the geometry object
  66   Geometry geometry = Geometry::New();
  67   geometry.AddVertexBuffer(vertexBuffer);
  68   if(indices.Size() > 0)
  69   {
  70     geometry.SetIndexBuffer(&indices[0], indices.Size());
  71   }
  72
  73   return geometry;
  74 }
  75
  76 /**
  77  * @brief Adds the indices to form a quad composed off two triangles where the indices are organised in a grid
  78  *
  79  * @param[out] indices     The indices to add to
  80  * @param[in]  rowIdx      The row index to start the quad
  81  * @param[in]  nextRowIdx  The index to the next row
  82  */
  83 void AddQuadIndices(Vector<unsigned short>& indices, unsigned int rowIdx, unsigned int nextRowIdx)
  84 {
  85   indices.PushBack(rowIdx);
  86   indices.PushBack(nextRowIdx + 1);
  87   indices.PushBack(rowIdx + 1);
  88
  89   indices.PushBack(rowIdx);
  90   indices.PushBack(nextRowIdx);
  91   indices.PushBack(nextRowIdx + 1);
  92 }
  93
  94 void AddVertex(Vector<Vector2>& vertices, unsigned int x, unsigned int y)
  95 {
  96   vertices.PushBack(Vector2(x, y));
  97 }
  98
  99 void RegisterStretchProperties(Renderer& renderer, const char* uniformName, const NPatchUtility::StretchRanges& stretchPixels, uint16_t imageExtent)
 100 {
 101   uint16_t     prevEnd     = 0;
 102   uint16_t     prevFix     = 0;
 103   uint16_t     prevStretch = 0;
 104   unsigned int i           = 1;
 105   for(NPatchUtility::StretchRanges::ConstIterator it = stretchPixels.Begin(); it != stretchPixels.End(); ++it, ++i)
 106   {
 107     uint16_t start = it->GetX();
 108     uint16_t end   = it->GetY();
 109
 110     uint16_t fix     = prevFix + start - prevEnd;
 111     uint16_t stretch = prevStretch + end - start;
 112
 113     std::stringstream uniform;
 114     uniform << uniformName << "[" << i << "]";
 115     renderer.RegisterProperty(uniform.str(), Vector2(fix, stretch));
 116
 117     prevEnd     = end;
 118     prevFix     = fix;
 119     prevStretch = stretch;
 120   }
 121
 122   {
 123     prevFix += imageExtent - prevEnd;
 124     std::stringstream uniform;
 125     uniform << uniformName << "[" << i << "]";
 126     renderer.RegisterProperty(uniform.str(), Vector2(prevFix, prevStretch));
 127   }
 128 }
 129
 130 } //unnamed namespace
 131
 132 /////////////////NPatchVisual////////////////
 133
 134 NPatchVisualPtr NPatchVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties)
 135 {
 136   NPatchVisualPtr nPatchVisual(new NPatchVisual(factoryCache, shaderFactory));
 137   nPatchVisual->mImageUrl = imageUrl;
 138   nPatchVisual->SetProperties(properties);
 139   nPatchVisual->Initialize();
 140   return nPatchVisual;
 141 }
 142
 143 NPatchVisualPtr NPatchVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl)
 144 {
 145   NPatchVisualPtr nPatchVisual(new NPatchVisual(factoryCache, shaderFactory));
 146   nPatchVisual->mImageUrl = imageUrl;
 147   nPatchVisual->Initialize();
 148   return nPatchVisual;
 149 }
 150
 151 void NPatchVisual::LoadImages()
 152 {
 153   TextureManager& textureManager     = mFactoryCache.GetTextureManager();
 154   bool            synchronousLoading = mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 155
 156   if(mId == NPatchData::INVALID_NPATCH_DATA_ID && (mImageUrl.IsLocalResource() || mImageUrl.IsBufferResource()))
 157   {
 158     bool preMultiplyOnLoad = IsPreMultipliedAlphaEnabled() && !mImpl->mCustomShader ? true : false;
 159     mId                    = mLoader.Load(textureManager, this, mImageUrl, mBorder, preMultiplyOnLoad, synchronousLoading);
 160
 161     const NPatchData* data;
 162     if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
 163     {
 164       EnablePreMultipliedAlpha(data->IsPreMultiplied());
 165     }
 166   }
 167
 168   if(!mAuxiliaryPixelBuffer && mAuxiliaryUrl.IsValid() && (mAuxiliaryUrl.IsLocalResource() || mAuxiliaryUrl.IsBufferResource()))
 169   {
 170     // Load the auxiliary image
 171     auto preMultiplyOnLoading = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
 172     mAuxiliaryPixelBuffer     = textureManager.LoadPixelBuffer(mAuxiliaryUrl, Dali::ImageDimensions(), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, synchronousLoading, this, true, preMultiplyOnLoading);
 173   }
 174 }
 175
 176 void NPatchVisual::GetNaturalSize(Vector2& naturalSize)
 177 {
 178   naturalSize.x = 0u;
 179   naturalSize.y = 0u;
 180
 181   // load now if not already loaded
 182   const NPatchData* data;
 183   if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() != NPatchData::LoadingState::LOADING)
 184   {
 185     naturalSize.x = data->GetCroppedWidth();
 186     naturalSize.y = data->GetCroppedHeight();
 187   }
 188   else
 189   {
 190     if(mImageUrl.IsValid())
 191     {
 192       ImageDimensions dimensions = Dali::GetOriginalImageSize(mImageUrl.GetUrl());
 193       if(dimensions != ImageDimensions(0, 0))
 194       {
 195         naturalSize.x = dimensions.GetWidth();
 196         naturalSize.y = dimensions.GetHeight();
 197       }
 198     }
 199   }
 200
 201   if(mAuxiliaryPixelBuffer)
 202   {
 203     naturalSize.x = std::max(naturalSize.x, float(mAuxiliaryPixelBuffer.GetWidth()));
 204     naturalSize.y = std::max(naturalSize.y, float(mAuxiliaryPixelBuffer.GetHeight()));
 205   }
 206 }
 207
 208 void NPatchVisual::DoSetProperties(const Property::Map& propertyMap)
 209 {
 210   // URL is already passed in via constructor
 211
 212   Property::Value* borderOnlyValue = propertyMap.Find(Toolkit::ImageVisual::Property::BORDER_ONLY, BORDER_ONLY);
 213   if(borderOnlyValue)
 214   {
 215     borderOnlyValue->Get(mBorderOnly);
 216   }
 217
 218   Property::Value* borderValue = propertyMap.Find(Toolkit::ImageVisual::Property::BORDER, BORDER);
 219   if(borderValue && !borderValue->Get(mBorder)) // If value exists and is rect, just set mBorder
 220   {
 221     // Not a rect so try vector4
 222     Vector4 border;
 223     if(borderValue->Get(border))
 224     {
 225       mBorder.left   = static_cast<int>(border.x);
 226       mBorder.right  = static_cast<int>(border.y);
 227       mBorder.bottom = static_cast<int>(border.z);
 228       mBorder.top    = static_cast<int>(border.w);
 229     }
 230   }
 231
 232   Property::Value* auxImage = propertyMap.Find(Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE, AUXILIARY_IMAGE_NAME);
 233   if(auxImage)
 234   {
 235     std::string url;
 236     if(auxImage->Get(url))
 237     {
 238       mAuxiliaryUrl = url;
 239     }
 240   }
 241
 242   Property::Value* auxImageAlpha = propertyMap.Find(Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, AUXILIARY_IMAGE_ALPHA_NAME);
 243   if(auxImageAlpha)
 244   {
 245     auxImageAlpha->Get(mAuxiliaryImageAlpha);
 246   }
 247
 248   Property::Value* synchronousLoading = propertyMap.Find(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, SYNCHRONOUS_LOADING);
 249   if(synchronousLoading)
 250   {
 251     bool sync = false;
 252     synchronousLoading->Get(sync);
 253     if(sync)
 254     {
 255       mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 256     }
 257     else
 258     {
 259       mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 260     }
 261   }
 262
 263   Property::Value* releasePolicy = propertyMap.Find(Toolkit::ImageVisual::Property::RELEASE_POLICY, RELEASE_POLICY_NAME);
 264   if(releasePolicy)
 265   {
 266     releasePolicy->Get(mReleasePolicy);
 267   }
 268 }
 269
 270 void NPatchVisual::DoSetOnScene(Actor& actor)
 271 {
 272   // load when first go on stage
 273   LoadImages();
 274
 275   const NPatchData* data;
 276   if(mLoader.GetNPatchData(mId, data))
 277   {
 278     Geometry geometry = CreateGeometry();
 279     Shader   shader   = CreateShader();
 280
 281     mImpl->mRenderer.SetGeometry(geometry);
 282     mImpl->mRenderer.SetShader(shader);
 283
 284     mPlacementActor = actor;
 285     if(data->GetLoadingState() != NPatchData::LoadingState::LOADING)
 286     {
 287       if(RenderingAddOn::Get().IsValid())
 288       {
 289         RenderingAddOn::Get().SubmitRenderTask(mImpl->mRenderer, data->GetRenderingMap());
 290       }
 291
 292       ApplyTextureAndUniforms();
 293       actor.AddRenderer(mImpl->mRenderer);
 294       mPlacementActor.Reset();
 295
 296       // npatch loaded and ready to display
 297       ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 298     }
 299   }
 300 }
 301
 302 void NPatchVisual::DoSetOffScene(Actor& actor)
 303 {
 304   if((mId != NPatchData::INVALID_NPATCH_DATA_ID) && mReleasePolicy == Toolkit::ImageVisual::ReleasePolicy::DETACHED)
 305   {
 306     mLoader.Remove(mId, this);
 307     mImpl->mResourceStatus = Toolkit::Visual::ResourceStatus::PREPARING;
 308     mId                    = NPatchData::INVALID_NPATCH_DATA_ID;
 309   }
 310
 311   actor.RemoveRenderer(mImpl->mRenderer);
 312   mPlacementActor.Reset();
 313 }
 314
 315 void NPatchVisual::OnSetTransform()
 316 {
 317   if(mImpl->mRenderer)
 318   {
 319     mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 320   }
 321 }
 322
 323 void NPatchVisual::DoCreatePropertyMap(Property::Map& map) const
 324 {
 325   map.Clear();
 326   bool sync = IsSynchronousLoadingRequired();
 327   map.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, sync);
 328   map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::N_PATCH);
 329   map.Insert(Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl());
 330   map.Insert(Toolkit::ImageVisual::Property::BORDER_ONLY, mBorderOnly);
 331   map.Insert(Toolkit::ImageVisual::Property::BORDER, mBorder);
 332   map.Insert(Toolkit::ImageVisual::Property::RELEASE_POLICY, mReleasePolicy);
 333
 334   if(mAuxiliaryUrl.IsValid())
 335   {
 336     map.Insert(Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE, mAuxiliaryUrl.GetUrl());
 337     map.Insert(Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, mAuxiliaryImageAlpha);
 338   }
 339 }
 340
 341 void NPatchVisual::DoCreateInstancePropertyMap(Property::Map& map) const
 342 {
 343   if(mAuxiliaryUrl.IsValid())
 344   {
 345     map.Insert(Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE, mAuxiliaryUrl.GetUrl());
 346     map.Insert(Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, mAuxiliaryImageAlpha);
 347   }
 348 }
 349
 350 NPatchVisual::NPatchVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory)
 351 : Visual::Base(factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::N_PATCH),
 352   mPlacementActor(),
 353   mLoader(factoryCache.GetNPatchLoader()),
 354   mImageVisualShaderFactory(shaderFactory),
 355   mImageUrl(),
 356   mAuxiliaryUrl(),
 357   mId(NPatchData::INVALID_NPATCH_DATA_ID),
 358   mBorderOnly(false),
 359   mBorder(),
 360   mAuxiliaryImageAlpha(0.0f),
 361   mReleasePolicy(Toolkit::ImageVisual::ReleasePolicy::DETACHED)
 362 {
 363   EnablePreMultipliedAlpha(mFactoryCache.GetPreMultiplyOnLoad());
 364 }
 365
 366 NPatchVisual::~NPatchVisual()
 367 {
 368   if(Stage::IsInstalled() && (mId != NPatchData::INVALID_NPATCH_DATA_ID) && (mReleasePolicy != Toolkit::ImageVisual::ReleasePolicy::NEVER))
 369   {
 370     mLoader.Remove(mId, this);
 371     mId = NPatchData::INVALID_NPATCH_DATA_ID;
 372   }
 373 }
 374
 375 void NPatchVisual::OnInitialize()
 376 {
 377   // Get basic geometry and shader
 378   Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
 379   Shader   shader   = mImageVisualShaderFactory.GetShader(
 380     mFactoryCache,
 381     ImageVisualShaderFeature::FeatureBuilder()
 382   );
 383
 384   mImpl->mRenderer = Renderer::New(geometry, shader);
 385
 386   //Register transform properties
 387   mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 388 }
 389
 390 Geometry NPatchVisual::CreateGeometry()
 391 {
 392   Geometry          geometry;
 393   const NPatchData* data;
 394   if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
 395   {
 396     if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
 397     {
 398       if(DALI_UNLIKELY(mBorderOnly))
 399       {
 400         geometry = GetNinePatchGeometry(VisualFactoryCache::NINE_PATCH_BORDER_GEOMETRY);
 401       }
 402       else
 403       {
 404         if(data->GetRenderingMap())
 405         {
 406           uint32_t elementCount[2];
 407           geometry = RenderingAddOn::Get().CreateGeometryGrid(data->GetRenderingMap(), Uint16Pair(3, 3), elementCount);
 408           if(mImpl->mRenderer)
 409           {
 410             RenderingAddOn::Get().SubmitRenderTask(mImpl->mRenderer, data->GetRenderingMap());
 411           }
 412         }
 413         else
 414         {
 415           geometry = GetNinePatchGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
 416         }
 417       }
 418     }
 419     else if(data->GetStretchPixelsX().Size() > 0 || data->GetStretchPixelsY().Size() > 0)
 420     {
 421       Uint16Pair gridSize(2 * data->GetStretchPixelsX().Size() + 1, 2 * data->GetStretchPixelsY().Size() + 1);
 422       if(!data->GetRenderingMap())
 423       {
 424         geometry = !mBorderOnly ? CreateGridGeometry(gridSize) : CreateBorderGeometry(gridSize);
 425       }
 426       else
 427       {
 428         uint32_t elementCount[2];
 429         geometry = !mBorderOnly ? RenderingAddOn::Get().CreateGeometryGrid(data->GetRenderingMap(), gridSize, elementCount) : CreateBorderGeometry(gridSize);
 430         if(mImpl->mRenderer)
 431         {
 432           RenderingAddOn::Get().SubmitRenderTask(mImpl->mRenderer, data->GetRenderingMap());
 433         }
 434       }
 435     }
 436   }
 437   else
 438   {
 439     // no N patch data so use default geometry
 440     geometry = GetNinePatchGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
 441   }
 442   return geometry;
 443 }
 444
 445 Shader NPatchVisual::CreateShader()
 446 {
 447   Shader            shader;
 448   const NPatchData* data;
 449   // 0 is either no data (load failed?) or no stretch regions on image
 450   // for both cases we use the default shader
 451   NPatchUtility::StretchRanges::SizeType xStretchCount = 0;
 452   NPatchUtility::StretchRanges::SizeType yStretchCount = 0;
 453
 454   auto fragmentShader = mAuxiliaryPixelBuffer ? SHADER_NPATCH_VISUAL_MASK_SHADER_FRAG
 455                                               : SHADER_NPATCH_VISUAL_SHADER_FRAG;
 456   auto shaderType     = mAuxiliaryPixelBuffer ? VisualFactoryCache::NINE_PATCH_MASK_SHADER
 457                                               : VisualFactoryCache::NINE_PATCH_SHADER;
 458
 459   // ask loader for the regions
 460   if(mLoader.GetNPatchData(mId, data))
 461   {
 462     xStretchCount = data->GetStretchPixelsX().Count();
 463     yStretchCount = data->GetStretchPixelsY().Count();
 464   }
 465
 466   if(DALI_LIKELY(!mImpl->mCustomShader))
 467   {
 468     if(DALI_LIKELY((xStretchCount == 1 && yStretchCount == 1) ||
 469                    (xStretchCount == 0 && yStretchCount == 0)))
 470     {
 471       shader = mFactoryCache.GetShader(shaderType);
 472       if(DALI_UNLIKELY(!shader))
 473       {
 474         shader = Shader::New(SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, fragmentShader);
 475         // Only cache vanilla 9 patch shaders
 476         mFactoryCache.SaveShader(shaderType, shader);
 477       }
 478     }
 479     else if(xStretchCount > 0 || yStretchCount > 0)
 480     {
 481       std::stringstream vertexShader;
 482       vertexShader << "#define FACTOR_SIZE_X " << xStretchCount + 2 << "\n"
 483                    << "#define FACTOR_SIZE_Y " << yStretchCount + 2 << "\n"
 484                    << SHADER_NPATCH_VISUAL_SHADER_VERT;
 485
 486       shader = Shader::New(vertexShader.str(), fragmentShader);
 487     }
 488   }
 489   else
 490   {
 491     Dali::Shader::Hint::Value hints = Dali::Shader::Hint::NONE;
 492
 493     if(!mImpl->mCustomShader->mFragmentShader.empty())
 494     {
 495       fragmentShader = mImpl->mCustomShader->mFragmentShader.c_str();
 496     }
 497     hints = mImpl->mCustomShader->mHints;
 498
 499     /* Apply Custom Vertex Shader only if image is 9-patch */
 500     if((xStretchCount == 1 && yStretchCount == 1) ||
 501        (xStretchCount == 0 && yStretchCount == 0))
 502     {
 503       const char* vertexShader = SHADER_NPATCH_VISUAL_3X3_SHADER_VERT.data();
 504
 505       if(!mImpl->mCustomShader->mVertexShader.empty())
 506       {
 507         vertexShader = mImpl->mCustomShader->mVertexShader.c_str();
 508       }
 509       shader = Shader::New(vertexShader, fragmentShader, hints);
 510     }
 511     else if(xStretchCount > 0 || yStretchCount > 0)
 512     {
 513       std::stringstream vertexShader;
 514       vertexShader << "#define FACTOR_SIZE_X " << xStretchCount + 2 << "\n"
 515                    << "#define FACTOR_SIZE_Y " << yStretchCount + 2 << "\n"
 516                    << SHADER_NPATCH_VISUAL_SHADER_VERT;
 517
 518       shader = Shader::New(vertexShader.str(), fragmentShader, hints);
 519     }
 520   }
 521
 522   return shader;
 523 }
 524
 525 void NPatchVisual::ApplyTextureAndUniforms()
 526 {
 527   const NPatchData* data;
 528   TextureSet        textureSet;
 529
 530   if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
 531   {
 532     textureSet = data->GetTextures();
 533
 534     if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
 535     {
 536       //special case for 9 patch
 537       Uint16Pair stretchX = data->GetStretchPixelsX()[0];
 538       Uint16Pair stretchY = data->GetStretchPixelsY()[0];
 539
 540       uint16_t stretchWidth  = (stretchX.GetY() >= stretchX.GetX()) ? stretchX.GetY() - stretchX.GetX() : 0;
 541       uint16_t stretchHeight = (stretchY.GetY() >= stretchY.GetX()) ? stretchY.GetY() - stretchY.GetX() : 0;
 542
 543       mImpl->mRenderer.RegisterProperty("uFixed[0]", Vector2::ZERO);
 544       mImpl->mRenderer.RegisterProperty("uFixed[1]", Vector2(stretchX.GetX(), stretchY.GetX()));
 545       mImpl->mRenderer.RegisterProperty("uFixed[2]", Vector2(data->GetCroppedWidth() - stretchWidth, data->GetCroppedHeight() - stretchHeight));
 546       mImpl->mRenderer.RegisterProperty("uStretchTotal", Vector2(stretchWidth, stretchHeight));
 547     }
 548     else
 549     {
 550       mImpl->mRenderer.RegisterProperty("uNinePatchFactorsX[0]", Vector2::ZERO);
 551       mImpl->mRenderer.RegisterProperty("uNinePatchFactorsY[0]", Vector2::ZERO);
 552
 553       RegisterStretchProperties(mImpl->mRenderer, "uNinePatchFactorsX", data->GetStretchPixelsX(), data->GetCroppedWidth());
 554       RegisterStretchProperties(mImpl->mRenderer, "uNinePatchFactorsY", data->GetStretchPixelsY(), data->GetCroppedHeight());
 555     }
 556   }
 557   else
 558   {
 559     DALI_LOG_ERROR("The N patch image '%s' is not a valid N patch image\n", mImageUrl.GetUrl().c_str());
 560     textureSet = TextureSet::New();
 561
 562     Actor actor = mPlacementActor.GetHandle();
 563     Vector2 imageSize = Vector2::ZERO;
 564     if(actor)
 565     {
 566       imageSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
 567     }
 568     mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize);
 569     Texture croppedImage = mImpl->mRenderer.GetTextures().GetTexture(0);
 570     textureSet.SetTexture(0u, croppedImage);
 571     mImpl->mRenderer.RegisterProperty("uFixed[0]", Vector2::ZERO);
 572     mImpl->mRenderer.RegisterProperty("uFixed[1]", Vector2::ZERO);
 573     mImpl->mRenderer.RegisterProperty("uFixed[2]", Vector2::ZERO);
 574     mImpl->mRenderer.RegisterProperty("uStretchTotal", Vector2(croppedImage.GetWidth(), croppedImage.GetHeight()));
 575   }
 576
 577   if(mAuxiliaryPixelBuffer)
 578   {
 579     // If the auxiliary image is smaller than the un-stretched NPatch, use CPU resizing to enlarge it to the
 580     // same size as the unstretched NPatch. This will give slightly higher quality results than just relying
 581     // on GL interpolation alone.
 582     if(mAuxiliaryPixelBuffer.GetWidth() < data->GetCroppedWidth() &&
 583        mAuxiliaryPixelBuffer.GetHeight() < data->GetCroppedHeight())
 584     {
 585       mAuxiliaryPixelBuffer.Resize(data->GetCroppedWidth(), data->GetCroppedHeight());
 586     }
 587
 588     // Note, this resets mAuxiliaryPixelBuffer handle
 589     auto auxiliaryPixelData = Devel::PixelBuffer::Convert(mAuxiliaryPixelBuffer);
 590
 591     auto texture = Texture::New(TextureType::TEXTURE_2D,
 592                                 auxiliaryPixelData.GetPixelFormat(),
 593                                 auxiliaryPixelData.GetWidth(),
 594                                 auxiliaryPixelData.GetHeight());
 595     texture.Upload(auxiliaryPixelData);
 596     textureSet.SetTexture(1, texture);
 597     mImpl->mRenderer.RegisterProperty(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA,
 598                                       AUXILIARY_IMAGE_ALPHA_NAME,
 599                                       mAuxiliaryImageAlpha);
 600   }
 601   mImpl->mRenderer.SetTextures(textureSet);
 602
 603   // Register transform properties
 604   mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 605 }
 606
 607 Geometry NPatchVisual::GetNinePatchGeometry(VisualFactoryCache::GeometryType subType)
 608 {
 609   Geometry geometry = mFactoryCache.GetGeometry(subType);
 610   if(!geometry)
 611   {
 612     if(DALI_LIKELY(VisualFactoryCache::NINE_PATCH_GEOMETRY == subType))
 613     {
 614       geometry = CreateGridGeometry(Uint16Pair(3, 3));
 615     }
 616     else if(VisualFactoryCache::NINE_PATCH_BORDER_GEOMETRY == subType)
 617     {
 618       geometry = CreateBorderGeometry(Uint16Pair(3, 3));
 619     }
 620     mFactoryCache.SaveGeometry(subType, geometry);
 621   }
 622   return geometry;
 623 }
 624
 625 Geometry NPatchVisual::CreateGridGeometry(Uint16Pair gridSize)
 626 {
 627   uint16_t gridWidth  = gridSize.GetWidth();
 628   uint16_t gridHeight = gridSize.GetHeight();
 629
 630   // Create vertices
 631   Vector<Vector2> vertices;
 632   vertices.Reserve((gridWidth + 1) * (gridHeight + 1));
 633
 634   for(int y = 0; y < gridHeight + 1; ++y)
 635   {
 636     for(int x = 0; x < gridWidth + 1; ++x)
 637     {
 638       AddVertex(vertices, x, y);
 639     }
 640   }
 641
 642   // Create indices
 643   Vector<unsigned short> indices;
 644   indices.Reserve(gridWidth * gridHeight * 6);
 645
 646   unsigned int rowIdx     = 0;
 647   unsigned int nextRowIdx = gridWidth + 1;
 648   for(int y = 0; y < gridHeight; ++y, ++nextRowIdx, ++rowIdx)
 649   {
 650     for(int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx)
 651     {
 652       AddQuadIndices(indices, rowIdx, nextRowIdx);
 653     }
 654   }
 655
 656   return GenerateGeometry(vertices, indices);
 657 }
 658
 659 Geometry NPatchVisual::CreateBorderGeometry(Uint16Pair gridSize)
 660 {
 661   uint16_t gridWidth  = gridSize.GetWidth();
 662   uint16_t gridHeight = gridSize.GetHeight();
 663
 664   // Create vertices
 665   Vector<Vector2> vertices;
 666   vertices.Reserve((gridWidth + 1) * (gridHeight + 1));
 667
 668   //top
 669   int y = 0;
 670   for(; y < 2; ++y)
 671   {
 672     for(int x = 0; x < gridWidth + 1; ++x)
 673     {
 674       AddVertex(vertices, x, y);
 675     }
 676   }
 677
 678   for(; y < gridHeight - 1; ++y)
 679   {
 680     //left
 681     AddVertex(vertices, 0, y);
 682     AddVertex(vertices, 1, y);
 683
 684     //right
 685     AddVertex(vertices, gridWidth - 1, y);
 686     AddVertex(vertices, gridWidth, y);
 687   }
 688
 689   //bottom
 690   for(; y < gridHeight + 1; ++y)
 691   {
 692     for(int x = 0; x < gridWidth + 1; ++x)
 693     {
 694       AddVertex(vertices, x, y);
 695     }
 696   }
 697
 698   // Create indices
 699   Vector<unsigned short> indices;
 700   indices.Reserve(gridWidth * gridHeight * 6);
 701
 702   //top
 703   unsigned int rowIdx     = 0;
 704   unsigned int nextRowIdx = gridWidth + 1;
 705   for(int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx)
 706   {
 707     AddQuadIndices(indices, rowIdx, nextRowIdx);
 708   }
 709
 710   if(gridHeight > 2)
 711   {
 712     rowIdx     = gridWidth + 1;
 713     nextRowIdx = (gridWidth + 1) * 2;
 714
 715     unsigned increment = gridWidth - 1;
 716     if(gridHeight > 3)
 717     {
 718       increment = 2;
 719       //second row left
 720       AddQuadIndices(indices, rowIdx, nextRowIdx);
 721
 722       rowIdx     = gridWidth * 2;
 723       nextRowIdx = (gridWidth + 1) * 2 + 2;
 724       //second row right
 725       AddQuadIndices(indices, rowIdx, nextRowIdx);
 726
 727       //left and right
 728       rowIdx     = nextRowIdx - 2;
 729       nextRowIdx = rowIdx + 4;
 730       for(int y = 2; y < 2 * (gridHeight - 3); ++y, rowIdx += 2, nextRowIdx += 2)
 731       {
 732         AddQuadIndices(indices, rowIdx, nextRowIdx);
 733       }
 734     }
 735
 736     //second row left
 737     AddQuadIndices(indices, rowIdx, nextRowIdx);
 738
 739     rowIdx += increment;
 740     nextRowIdx += gridWidth - 1;
 741     //second row right
 742     AddQuadIndices(indices, rowIdx, nextRowIdx);
 743   }
 744
 745   //bottom
 746   rowIdx     = nextRowIdx - gridWidth + 1;
 747   nextRowIdx = rowIdx + gridWidth + 1;
 748   for(int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx)
 749   {
 750     AddQuadIndices(indices, rowIdx, nextRowIdx);
 751   }
 752
 753   return GenerateGeometry(vertices, indices);
 754 }
 755
 756 void NPatchVisual::SetResource()
 757 {
 758   const NPatchData* data;
 759   if(mImpl->mRenderer && mLoader.GetNPatchData(mId, data))
 760   {
 761     Geometry geometry = CreateGeometry();
 762     Shader   shader   = CreateShader();
 763
 764     mImpl->mRenderer.SetGeometry(geometry);
 765     mImpl->mRenderer.SetShader(shader);
 766
 767     Actor actor = mPlacementActor.GetHandle();
 768     if(actor)
 769     {
 770       ApplyTextureAndUniforms();
 771       actor.AddRenderer(mImpl->mRenderer);
 772       mPlacementActor.Reset();
 773
 774       // npatch loaded and ready to display
 775       ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 776     }
 777   }
 778 }
 779
 780 void NPatchVisual::LoadComplete(bool loadSuccess, TextureInformation textureInformation)
 781 {
 782   if(textureInformation.returnType == TextureUploadObserver::ReturnType::TEXTURE)
 783   {
 784     EnablePreMultipliedAlpha(textureInformation.preMultiplied);
 785     if(!loadSuccess)
 786     {
 787       // Image loaded and ready to display
 788       ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 789     }
 790
 791     if(mAuxiliaryPixelBuffer || !mAuxiliaryUrl.IsValid())
 792     {
 793       SetResource();
 794     }
 795   }
 796   else  // for the ReturnType::PIXEL_BUFFER
 797   {
 798     if(loadSuccess && textureInformation.url == mAuxiliaryUrl.GetUrl())
 799     {
 800       mAuxiliaryPixelBuffer = textureInformation.pixelBuffer;
 801       SetResource();
 802     }
 803     else
 804     {
 805       // Image loaded and ready to display
 806       ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 807     }
 808   }
 809 }
 810
 811 } // namespace Internal
 812
 813 } // namespace Toolkit
 814
 815 } // namespace Dali