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())
 157   {
 158     bool preMultiplyOnLoad = IsPreMultipliedAlphaEnabled() && !mImpl->mCustomShader ? true : false;
 159     mId                    = mLoader.Load(textureManager, this, mImageUrl.GetUrl(), 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())
 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(mFactoryCache, false, true, false);
 380
 381   mImpl->mRenderer = Renderer::New(geometry, shader);
 382
 383   //Register transform properties
 384   mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 385 }
 386
 387 Geometry NPatchVisual::CreateGeometry()
 388 {
 389   Geometry          geometry;
 390   const NPatchData* data;
 391   if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
 392   {
 393     if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
 394     {
 395       if(DALI_UNLIKELY(mBorderOnly))
 396       {
 397         geometry = GetNinePatchGeometry(VisualFactoryCache::NINE_PATCH_BORDER_GEOMETRY);
 398       }
 399       else
 400       {
 401         if(data->GetRenderingMap())
 402         {
 403           uint32_t elementCount[2];
 404           geometry = RenderingAddOn::Get().CreateGeometryGrid(data->GetRenderingMap(), Uint16Pair(3, 3), elementCount);
 405           if(mImpl->mRenderer)
 406           {
 407             RenderingAddOn::Get().SubmitRenderTask(mImpl->mRenderer, data->GetRenderingMap());
 408           }
 409         }
 410         else
 411         {
 412           geometry = GetNinePatchGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
 413         }
 414       }
 415     }
 416     else if(data->GetStretchPixelsX().Size() > 0 || data->GetStretchPixelsY().Size() > 0)
 417     {
 418       Uint16Pair gridSize(2 * data->GetStretchPixelsX().Size() + 1, 2 * data->GetStretchPixelsY().Size() + 1);
 419       if(!data->GetRenderingMap())
 420       {
 421         geometry = !mBorderOnly ? CreateGridGeometry(gridSize) : CreateBorderGeometry(gridSize);
 422       }
 423       else
 424       {
 425         uint32_t elementCount[2];
 426         geometry = !mBorderOnly ? RenderingAddOn::Get().CreateGeometryGrid(data->GetRenderingMap(), gridSize, elementCount) : CreateBorderGeometry(gridSize);
 427         if(mImpl->mRenderer)
 428         {
 429           RenderingAddOn::Get().SubmitRenderTask(mImpl->mRenderer, data->GetRenderingMap());
 430         }
 431       }
 432     }
 433   }
 434   else
 435   {
 436     // no N patch data so use default geometry
 437     geometry = GetNinePatchGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
 438   }
 439   return geometry;
 440 }
 441
 442 Shader NPatchVisual::CreateShader()
 443 {
 444   Shader            shader;
 445   const NPatchData* data;
 446   // 0 is either no data (load failed?) or no stretch regions on image
 447   // for both cases we use the default shader
 448   NPatchUtility::StretchRanges::SizeType xStretchCount = 0;
 449   NPatchUtility::StretchRanges::SizeType yStretchCount = 0;
 450
 451   auto fragmentShader = mAuxiliaryPixelBuffer ? SHADER_NPATCH_VISUAL_MASK_SHADER_FRAG
 452                                               : SHADER_NPATCH_VISUAL_SHADER_FRAG;
 453   auto shaderType     = mAuxiliaryPixelBuffer ? VisualFactoryCache::NINE_PATCH_MASK_SHADER
 454                                               : VisualFactoryCache::NINE_PATCH_SHADER;
 455
 456   // ask loader for the regions
 457   if(mLoader.GetNPatchData(mId, data))
 458   {
 459     xStretchCount = data->GetStretchPixelsX().Count();
 460     yStretchCount = data->GetStretchPixelsY().Count();
 461   }
 462
 463   if(DALI_LIKELY(!mImpl->mCustomShader))
 464   {
 465     if(DALI_LIKELY((xStretchCount == 1 && yStretchCount == 1) ||
 466                    (xStretchCount == 0 && yStretchCount == 0)))
 467     {
 468       shader = mFactoryCache.GetShader(shaderType);
 469       if(DALI_UNLIKELY(!shader))
 470       {
 471         shader = Shader::New(SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, fragmentShader);
 472         // Only cache vanilla 9 patch shaders
 473         mFactoryCache.SaveShader(shaderType, shader);
 474       }
 475     }
 476     else if(xStretchCount > 0 || yStretchCount > 0)
 477     {
 478       std::stringstream vertexShader;
 479       vertexShader << "#define FACTOR_SIZE_X " << xStretchCount + 2 << "\n"
 480                    << "#define FACTOR_SIZE_Y " << yStretchCount + 2 << "\n"
 481                    << SHADER_NPATCH_VISUAL_SHADER_VERT;
 482
 483       shader = Shader::New(vertexShader.str(), fragmentShader);
 484     }
 485   }
 486   else
 487   {
 488     Dali::Shader::Hint::Value hints = Dali::Shader::Hint::NONE;
 489
 490     if(!mImpl->mCustomShader->mFragmentShader.empty())
 491     {
 492       fragmentShader = mImpl->mCustomShader->mFragmentShader.c_str();
 493     }
 494     hints = mImpl->mCustomShader->mHints;
 495
 496     /* Apply Custom Vertex Shader only if image is 9-patch */
 497     if((xStretchCount == 1 && yStretchCount == 1) ||
 498        (xStretchCount == 0 && yStretchCount == 0))
 499     {
 500       const char* vertexShader = SHADER_NPATCH_VISUAL_3X3_SHADER_VERT.data();
 501
 502       if(!mImpl->mCustomShader->mVertexShader.empty())
 503       {
 504         vertexShader = mImpl->mCustomShader->mVertexShader.c_str();
 505       }
 506       shader = Shader::New(vertexShader, fragmentShader, hints);
 507     }
 508     else if(xStretchCount > 0 || yStretchCount > 0)
 509     {
 510       std::stringstream vertexShader;
 511       vertexShader << "#define FACTOR_SIZE_X " << xStretchCount + 2 << "\n"
 512                    << "#define FACTOR_SIZE_Y " << yStretchCount + 2 << "\n"
 513                    << SHADER_NPATCH_VISUAL_SHADER_VERT;
 514
 515       shader = Shader::New(vertexShader.str(), fragmentShader, hints);
 516     }
 517   }
 518
 519   return shader;
 520 }
 521
 522 void NPatchVisual::ApplyTextureAndUniforms()
 523 {
 524   const NPatchData* data;
 525   TextureSet        textureSet;
 526
 527   if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
 528   {
 529     textureSet = data->GetTextures();
 530
 531     if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
 532     {
 533       //special case for 9 patch
 534       Uint16Pair stretchX = data->GetStretchPixelsX()[0];
 535       Uint16Pair stretchY = data->GetStretchPixelsY()[0];
 536
 537       uint16_t stretchWidth  = (stretchX.GetY() >= stretchX.GetX()) ? stretchX.GetY() - stretchX.GetX() : 0;
 538       uint16_t stretchHeight = (stretchY.GetY() >= stretchY.GetX()) ? stretchY.GetY() - stretchY.GetX() : 0;
 539
 540       mImpl->mRenderer.RegisterProperty("uFixed[0]", Vector2::ZERO);
 541       mImpl->mRenderer.RegisterProperty("uFixed[1]", Vector2(stretchX.GetX(), stretchY.GetX()));
 542       mImpl->mRenderer.RegisterProperty("uFixed[2]", Vector2(data->GetCroppedWidth() - stretchWidth, data->GetCroppedHeight() - stretchHeight));
 543       mImpl->mRenderer.RegisterProperty("uStretchTotal", Vector2(stretchWidth, stretchHeight));
 544     }
 545     else
 546     {
 547       mImpl->mRenderer.RegisterProperty("uNinePatchFactorsX[0]", Vector2::ZERO);
 548       mImpl->mRenderer.RegisterProperty("uNinePatchFactorsY[0]", Vector2::ZERO);
 549
 550       RegisterStretchProperties(mImpl->mRenderer, "uNinePatchFactorsX", data->GetStretchPixelsX(), data->GetCroppedWidth());
 551       RegisterStretchProperties(mImpl->mRenderer, "uNinePatchFactorsY", data->GetStretchPixelsY(), data->GetCroppedHeight());
 552     }
 553   }
 554   else
 555   {
 556     DALI_LOG_ERROR("The N patch image '%s' is not a valid N patch image\n", mImageUrl.GetUrl().c_str());
 557     textureSet = TextureSet::New();
 558
 559     Texture croppedImage = mFactoryCache.GetBrokenVisualImage();
 560     textureSet.SetTexture(0u, croppedImage);
 561     mImpl->mRenderer.RegisterProperty("uFixed[0]", Vector2::ZERO);
 562     mImpl->mRenderer.RegisterProperty("uFixed[1]", Vector2::ZERO);
 563     mImpl->mRenderer.RegisterProperty("uFixed[2]", Vector2::ZERO);
 564     mImpl->mRenderer.RegisterProperty("uStretchTotal", Vector2(croppedImage.GetWidth(), croppedImage.GetHeight()));
 565   }
 566
 567   if(mAuxiliaryPixelBuffer)
 568   {
 569     // If the auxiliary image is smaller than the un-stretched NPatch, use CPU resizing to enlarge it to the
 570     // same size as the unstretched NPatch. This will give slightly higher quality results than just relying
 571     // on GL interpolation alone.
 572     if(mAuxiliaryPixelBuffer.GetWidth() < data->GetCroppedWidth() &&
 573        mAuxiliaryPixelBuffer.GetHeight() < data->GetCroppedHeight())
 574     {
 575       mAuxiliaryPixelBuffer.Resize(data->GetCroppedWidth(), data->GetCroppedHeight());
 576     }
 577
 578     // Note, this resets mAuxiliaryPixelBuffer handle
 579     auto auxiliaryPixelData = Devel::PixelBuffer::Convert(mAuxiliaryPixelBuffer);
 580
 581     auto texture = Texture::New(TextureType::TEXTURE_2D,
 582                                 auxiliaryPixelData.GetPixelFormat(),
 583                                 auxiliaryPixelData.GetWidth(),
 584                                 auxiliaryPixelData.GetHeight());
 585     texture.Upload(auxiliaryPixelData);
 586     textureSet.SetTexture(1, texture);
 587     mImpl->mRenderer.RegisterProperty(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA,
 588                                       AUXILIARY_IMAGE_ALPHA_NAME,
 589                                       mAuxiliaryImageAlpha);
 590   }
 591   mImpl->mRenderer.SetTextures(textureSet);
 592
 593   // Register transform properties
 594   mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 595 }
 596
 597 Geometry NPatchVisual::GetNinePatchGeometry(VisualFactoryCache::GeometryType subType)
 598 {
 599   Geometry geometry = mFactoryCache.GetGeometry(subType);
 600   if(!geometry)
 601   {
 602     if(DALI_LIKELY(VisualFactoryCache::NINE_PATCH_GEOMETRY == subType))
 603     {
 604       geometry = CreateGridGeometry(Uint16Pair(3, 3));
 605     }
 606     else if(VisualFactoryCache::NINE_PATCH_BORDER_GEOMETRY == subType)
 607     {
 608       geometry = CreateBorderGeometry(Uint16Pair(3, 3));
 609     }
 610     mFactoryCache.SaveGeometry(subType, geometry);
 611   }
 612   return geometry;
 613 }
 614
 615 Geometry NPatchVisual::CreateGridGeometry(Uint16Pair gridSize)
 616 {
 617   uint16_t gridWidth  = gridSize.GetWidth();
 618   uint16_t gridHeight = gridSize.GetHeight();
 619
 620   // Create vertices
 621   Vector<Vector2> vertices;
 622   vertices.Reserve((gridWidth + 1) * (gridHeight + 1));
 623
 624   for(int y = 0; y < gridHeight + 1; ++y)
 625   {
 626     for(int x = 0; x < gridWidth + 1; ++x)
 627     {
 628       AddVertex(vertices, x, y);
 629     }
 630   }
 631
 632   // Create indices
 633   Vector<unsigned short> indices;
 634   indices.Reserve(gridWidth * gridHeight * 6);
 635
 636   unsigned int rowIdx     = 0;
 637   unsigned int nextRowIdx = gridWidth + 1;
 638   for(int y = 0; y < gridHeight; ++y, ++nextRowIdx, ++rowIdx)
 639   {
 640     for(int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx)
 641     {
 642       AddQuadIndices(indices, rowIdx, nextRowIdx);
 643     }
 644   }
 645
 646   return GenerateGeometry(vertices, indices);
 647 }
 648
 649 Geometry NPatchVisual::CreateBorderGeometry(Uint16Pair gridSize)
 650 {
 651   uint16_t gridWidth  = gridSize.GetWidth();
 652   uint16_t gridHeight = gridSize.GetHeight();
 653
 654   // Create vertices
 655   Vector<Vector2> vertices;
 656   vertices.Reserve((gridWidth + 1) * (gridHeight + 1));
 657
 658   //top
 659   int y = 0;
 660   for(; y < 2; ++y)
 661   {
 662     for(int x = 0; x < gridWidth + 1; ++x)
 663     {
 664       AddVertex(vertices, x, y);
 665     }
 666   }
 667
 668   for(; y < gridHeight - 1; ++y)
 669   {
 670     //left
 671     AddVertex(vertices, 0, y);
 672     AddVertex(vertices, 1, y);
 673
 674     //right
 675     AddVertex(vertices, gridWidth - 1, y);
 676     AddVertex(vertices, gridWidth, y);
 677   }
 678
 679   //bottom
 680   for(; y < gridHeight + 1; ++y)
 681   {
 682     for(int x = 0; x < gridWidth + 1; ++x)
 683     {
 684       AddVertex(vertices, x, y);
 685     }
 686   }
 687
 688   // Create indices
 689   Vector<unsigned short> indices;
 690   indices.Reserve(gridWidth * gridHeight * 6);
 691
 692   //top
 693   unsigned int rowIdx     = 0;
 694   unsigned int nextRowIdx = gridWidth + 1;
 695   for(int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx)
 696   {
 697     AddQuadIndices(indices, rowIdx, nextRowIdx);
 698   }
 699
 700   if(gridHeight > 2)
 701   {
 702     rowIdx     = gridWidth + 1;
 703     nextRowIdx = (gridWidth + 1) * 2;
 704
 705     unsigned increment = gridWidth - 1;
 706     if(gridHeight > 3)
 707     {
 708       increment = 2;
 709       //second row left
 710       AddQuadIndices(indices, rowIdx, nextRowIdx);
 711
 712       rowIdx     = gridWidth * 2;
 713       nextRowIdx = (gridWidth + 1) * 2 + 2;
 714       //second row right
 715       AddQuadIndices(indices, rowIdx, nextRowIdx);
 716
 717       //left and right
 718       rowIdx     = nextRowIdx - 2;
 719       nextRowIdx = rowIdx + 4;
 720       for(int y = 2; y < 2 * (gridHeight - 3); ++y, rowIdx += 2, nextRowIdx += 2)
 721       {
 722         AddQuadIndices(indices, rowIdx, nextRowIdx);
 723       }
 724     }
 725
 726     //second row left
 727     AddQuadIndices(indices, rowIdx, nextRowIdx);
 728
 729     rowIdx += increment;
 730     nextRowIdx += gridWidth - 1;
 731     //second row right
 732     AddQuadIndices(indices, rowIdx, nextRowIdx);
 733   }
 734
 735   //bottom
 736   rowIdx     = nextRowIdx - gridWidth + 1;
 737   nextRowIdx = rowIdx + gridWidth + 1;
 738   for(int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx)
 739   {
 740     AddQuadIndices(indices, rowIdx, nextRowIdx);
 741   }
 742
 743   return GenerateGeometry(vertices, indices);
 744 }
 745
 746 void NPatchVisual::SetResource()
 747 {
 748   const NPatchData* data;
 749   if(mImpl->mRenderer && mLoader.GetNPatchData(mId, data))
 750   {
 751     Geometry geometry = CreateGeometry();
 752     Shader   shader   = CreateShader();
 753
 754     mImpl->mRenderer.SetGeometry(geometry);
 755     mImpl->mRenderer.SetShader(shader);
 756
 757     Actor actor = mPlacementActor.GetHandle();
 758     if(actor)
 759     {
 760       ApplyTextureAndUniforms();
 761       actor.AddRenderer(mImpl->mRenderer);
 762       mPlacementActor.Reset();
 763
 764       // npatch loaded and ready to display
 765       ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 766     }
 767   }
 768 }
 769
 770 void NPatchVisual::UploadComplete(bool loadSuccess, int32_t textureId, TextureSet textureSet, bool useAtlasing, const Vector4& atlasRect, bool preMultiplied)
 771 {
 772   EnablePreMultipliedAlpha(preMultiplied);
 773   if(!loadSuccess)
 774   {
 775     // Image loaded and ready to display
 776     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 777   }
 778
 779   if(mAuxiliaryPixelBuffer || !mAuxiliaryUrl.IsValid())
 780   {
 781     SetResource();
 782   }
 783 }
 784
 785 void NPatchVisual::LoadComplete(bool loadSuccess, Devel::PixelBuffer pixelBuffer, const VisualUrl& url, bool preMultiplied)
 786 {
 787   if(loadSuccess && url.GetUrl() == mAuxiliaryUrl.GetUrl())
 788   {
 789     mAuxiliaryPixelBuffer = pixelBuffer;
 790     SetResource();
 791   }
 792   else
 793   {
 794     // Image loaded and ready to display
 795     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 796   }
 797 }
 798
 799 } // namespace Internal
 800
 801 } // namespace Toolkit
 802
 803 } // namespace Dali