+ if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
+ {
+ geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
+ if(!geometry)
+ {
+ geometry = NPatchHelper::CreateGridGeometry(Uint16Pair(3, 3));
+ SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
+ }
+ }
+ else if(data->GetStretchPixelsX().Size() > 0 || data->GetStretchPixelsY().Size() > 0)
+ {
+ Uint16Pair gridSize(2 * data->GetStretchPixelsX().Size() + 1, 2 * data->GetStretchPixelsY().Size() + 1);
+ geometry = NPatchHelper::CreateGridGeometry(gridSize);
+ }
+ }
+ else
+ {
+ // no N patch data so use default geometry
+ geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
+ if(!geometry)
+ {
+ geometry = NPatchHelper::CreateGridGeometry(Uint16Pair(3, 3));
+ SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
+ }
+ }
+ return geometry;
+}
+
+Shader VisualFactoryCache::GetNPatchShader(int index)
+{
+ Shader shader;
+ const NPatchData* data;
+ // 0 is either no data (load failed?) or no stretch regions on image
+ // for both cases we use the default shader
+ NPatchUtility::StretchRanges::SizeType xStretchCount = 0;
+ NPatchUtility::StretchRanges::SizeType yStretchCount = 0;
+
+ // ask loader for the regions
+ if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data))
+ {
+ xStretchCount = data->GetStretchPixelsX().Count();
+ yStretchCount = data->GetStretchPixelsY().Count();
+ }
+
+ if(DALI_LIKELY((xStretchCount == 0 && yStretchCount == 0) || (xStretchCount == 1 && yStretchCount == 1)))
+ {
+ shader = GetShader(VisualFactoryCache::NINE_PATCH_SHADER);
+ if(DALI_UNLIKELY(!shader))
+ {
+ shader = Shader::New(SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, SHADER_NPATCH_VISUAL_SHADER_FRAG);
+
+ // Only cache vanilla 9 patch shaders
+ SaveShader(VisualFactoryCache::NINE_PATCH_SHADER, shader);
+ }
+ }
+ else if(xStretchCount > 0 || yStretchCount > 0)
+ {
+ std::stringstream vertexShader;
+ vertexShader << "#define FACTOR_SIZE_X " << xStretchCount + 2 << "\n"
+ << "#define FACTOR_SIZE_Y " << yStretchCount + 2 << "\n"
+ << SHADER_NPATCH_VISUAL_SHADER_VERT;
+ shader = Shader::New(vertexShader.str(), SHADER_NPATCH_VISUAL_SHADER_FRAG);
+ }
+ return shader;
+}
+
+void VisualFactoryCache::ApplyTextureAndUniforms(Renderer& renderer, int index)
+{
+ const NPatchData* data;
+ TextureSet textureSet;
+ if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
+ {
+ textureSet = data->GetTextures();
+ mBrokenImageInfoContainer[index].texture = textureSet.GetTexture(0);
+ NPatchHelper::ApplyTextureAndUniforms(renderer, data);
+ renderer.SetTextures(textureSet);
+ }
+}
+
+void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size, const bool& rendererIsImage)
+{
+ bool useDefaultBrokenImage = false;
+ if(mBrokenImageInfoContainer.size() == 0)
+ {
+ useDefaultBrokenImage = true;
+ }
+
+ // Load Information for broken image
+ for(uint32_t index = 0; (index < mBrokenImageInfoContainer.size()) && !useDefaultBrokenImage; index++)
+ {
+ if(mBrokenImageInfoContainer[index].width == 0 && mBrokenImageInfoContainer[index].height == 0)
+ {
+ if(!mBrokenImageInfoContainer[index].url.empty())
+ {
+ VisualUrl visualUrl(mBrokenImageInfoContainer[index].url);
+ mBrokenImageInfoContainer[index].visualType = visualUrl.GetType();
+ if(mBrokenImageInfoContainer[index].visualType == VisualUrl::Type::N_PATCH)
+ {
+ const NPatchData* data;
+ Rect<int> border;
+ mBrokenImageInfoContainer[index].npatchId = mNPatchLoader.Load(mTextureManager, NULL, mBrokenImageInfoContainer[index].url, border, mPreMultiplyOnLoad, true);
+ if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
+ {
+ mBrokenImageInfoContainer[index].width = data->GetCroppedWidth();
+ mBrokenImageInfoContainer[index].height = data->GetCroppedHeight();
+ }
+ else
+ {
+ DALI_LOG_ERROR("Can't update renderer for broken image. maybe image loading is failed [index:%d] [path:%s] \n", index, mBrokenImageInfoContainer[index].url.c_str());
+ useDefaultBrokenImage = true;
+ }
+ }
+ else
+ {
+ if(!GetBrokenVisualImage(index))
+ {
+ DALI_LOG_ERROR("Can't update renderer for broken image. maybe image loading is failed [index:%d] [path:%s] \n", index, mBrokenImageInfoContainer[index].url.c_str());
+ useDefaultBrokenImage = true;
+ }
+ }
+ }
+ }
+ }
+
+ if(!mUseDefaultBrokenImageOnly && useDefaultBrokenImage)
+ {
+ // Clear broken info
+ mBrokenImageInfoContainer.clear();
+
+ // assign for broken image
+ const int defaultBrokenIndex = 0;
+ mBrokenImageInfoContainer.assign(1, BrokenImageInfo());
+ mBrokenImageInfoContainer[defaultBrokenIndex].url = mDefaultBrokenImageUrl;
+ VisualUrl visualUrl(mBrokenImageInfoContainer[defaultBrokenIndex].url);
+ mBrokenImageInfoContainer[defaultBrokenIndex].visualType = visualUrl.GetType();
+ mUseDefaultBrokenImageOnly = true;
+ }
+
+ // Set Texutre to renderer
+ int brokenIndex = GetProperBrokenImageIndex(size);
+ if(GetBrokenImageVisualType(brokenIndex) == VisualUrl::N_PATCH)
+ {
+ DALI_LOG_ERROR("Broken npatch?");
+ // Set geometry and shader for npatch
+ Geometry geometry = GetNPatchGeometry(brokenIndex);
+ Shader shader = GetNPatchShader(brokenIndex);
+ renderer.SetGeometry(geometry);
+ renderer.SetShader(shader);
+ ApplyTextureAndUniforms(renderer, brokenIndex);
+ }
+ else
+ {
+ DALI_LOG_ERROR("Broken single image");
+ // Create single image renderer only if rederer is not use normal ImageShader. i.e. npatch visual.
+ if(!rendererIsImage)
+ {
+ Geometry geometry = GetGeometry(QUAD_GEOMETRY);
+ Shader shader = GetShader(IMAGE_SHADER);
+ if(!shader)
+ {
+ std::string vertexShader = std::string(Dali::Shader::GetVertexShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_VERT.data());
+ std::string fragmentShader = std::string(Dali::Shader::GetFragmentShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_FRAG.data());
+ shader = Shader::New(vertexShader, fragmentShader);
+ shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
+ SaveShader(IMAGE_SHADER, shader);
+ }
+ renderer.SetGeometry(geometry);
+ renderer.SetShader(shader);
+ }
+ Texture brokenImage = GetBrokenVisualImage(brokenIndex);
+ TextureSet textureSet = TextureSet::New();
+ textureSet.SetTexture(0u, brokenImage);
+ renderer.SetTextures(textureSet);
+ }
+}
+
+int32_t VisualFactoryCache::GetProperBrokenImageIndex(const Vector2& size)
+{
+ // Sets the default broken type
+ int32_t returnIndex = 0;
+ if((size.width == 0 || size.height == 0) || mUseDefaultBrokenImageOnly)
+ {
+ // To do : Need to add observer about size
+ return returnIndex;
+ }
+
+ // Find the proper value if we know the size of the image
+ for(int32_t index = static_cast<int32_t>(mBrokenImageInfoContainer.size()) - 1; index >= 0; index--)
+ {
+ // Skip if the value is not set
+ if(mBrokenImageInfoContainer[index].width == 0 || mBrokenImageInfoContainer[index].height == 0)
+ {
+ continue;
+ }
+
+ if(mBrokenImageInfoContainer[index].width < size.width && mBrokenImageInfoContainer[index].height < size.height)
+ {
+ returnIndex = index;
+ break;
+ }