X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fimage%2Fimage-visual.cpp;h=2f0e800cd5aa88a372f8b8d27c8bcfeb626b16f6;hb=d749cedb62fa1476c144d0dbc1c29ee9b21e4fa2;hp=ef7178682d195d13da44726b6bde300a5a48967c;hpb=45ad62cd772319bc585a48c868b31892881374bb;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/visuals/image/image-visual.cpp b/dali-toolkit/internal/visuals/image/image-visual.cpp index ef71786..2f0e800 100644 --- a/dali-toolkit/internal/visuals/image/image-visual.cpp +++ b/dali-toolkit/internal/visuals/image/image-visual.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Samsung Electronics Co., Ltd. + * Copyright (c) 2023 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,6 +27,7 @@ #include #include #include +#include #include #include // for strlen() @@ -97,9 +98,6 @@ DALI_ENUM_TO_STRING_TABLE_END(RELEASE_POLICY) const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); -const float PIXEL_ALIGN_ON = 1.0f; -const float PIXEL_ALIGN_OFF = 0.0f; - constexpr uint32_t TEXTURE_COUNT_FOR_GPU_ALPHA_MASK = 2u; Geometry CreateGeometry(VisualFactoryCache& factoryCache, ImageDimensions gridSize) @@ -171,7 +169,8 @@ ImageVisual::ImageVisual(VisualFactoryCache& factoryCache, mAtlasRectSize(0, 0), mLoadState(TextureManager::LoadState::NOT_STARTED), mAttemptAtlasing(false), - mOrientationCorrection(true) + mOrientationCorrection(true), + mEnableBrokenImage(true) { EnablePreMultipliedAlpha(mFactoryCache.GetPreMultiplyOnLoad()); } @@ -180,18 +179,6 @@ ImageVisual::~ImageVisual() { if(Stage::IsInstalled()) { - if(mMaskingData) - { - // TextureManager could have been deleted before the actor that contains this - // ImageVisual is destroyed (e.g. due to stage shutdown). Ensure the stage - // is still valid before accessing texture manager. - if(mMaskingData->mAlphaMaskId != TextureManager::INVALID_TEXTURE_ID) - { - TextureManager& textureManager = mFactoryCache.GetTextureManager(); - textureManager.Remove(mMaskingData->mAlphaMaskId, this); - } - } - if(mImageUrl.IsValid()) { // Decrease reference count of External Resources : @@ -214,6 +201,8 @@ ImageVisual::~ImageVisual() { RemoveTexture(); } + + ResetFastTrackLoadingTask(); } } @@ -281,6 +270,10 @@ void ImageVisual::DoSetProperties(const Property::Map& propertyMap) { DoSetProperty(Toolkit::DevelImageVisual::Property::MASKING_TYPE, keyValue.second); } + else if(keyValue.first == ENABLE_BROKEN_IMAGE) + { + DoSetProperty(Toolkit::DevelImageVisual::Property::ENABLE_BROKEN_IMAGE, keyValue.second); + } else if(keyValue.first == LOAD_POLICY_NAME) { DoSetProperty(Toolkit::ImageVisual::Property::LOAD_POLICY, keyValue.second); @@ -293,6 +286,10 @@ void ImageVisual::DoSetProperties(const Property::Map& propertyMap) { DoSetProperty(Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION, keyValue.second); } + else if(keyValue.first == FAST_TRACK_UPLOADING_NAME) + { + DoSetProperty(Toolkit::DevelImageVisual::Property::FAST_TRACK_UPLOADING, keyValue.second); + } } } // Load image immediately if LOAD_POLICY requires it @@ -330,7 +327,7 @@ void ImageVisual::DoSetProperty(Property::Index index, const Property::Value& va case Toolkit::ImageVisual::Property::DESIRED_WIDTH: { - float desiredWidth = 0.0f; + int32_t desiredWidth = 0; if(value.Get(desiredWidth)) { mDesiredSize.SetWidth(desiredWidth); @@ -344,7 +341,7 @@ void ImageVisual::DoSetProperty(Property::Index index, const Property::Value& va case Toolkit::ImageVisual::Property::DESIRED_HEIGHT: { - float desiredHeight = 0.0f; + int32_t desiredHeight = 0; if(value.Get(desiredHeight)) { mDesiredSize.SetHeight(desiredHeight); @@ -439,7 +436,26 @@ void ImageVisual::DoSetProperty(Property::Index index, const Property::Value& va if(value.Get(maskingType)) { AllocateMaskData(); - mMaskingData->mPreappliedMasking = Toolkit::DevelImageVisual::MaskingType::Type(maskingType) == Toolkit::DevelImageVisual::MaskingType::MASKING_ON_LOADING ? true : false; + if(mImageUrl.IsValid() && mImageUrl.GetProtocolType() == VisualUrl::TEXTURE) + { + // For external textures, only gpu masking is available. + // Therefore, MASKING_TYPE is set to MASKING_ON_RENDERING forcelly. + mMaskingData->mPreappliedMasking = false; + } + else + { + mMaskingData->mPreappliedMasking = Toolkit::DevelImageVisual::MaskingType::Type(maskingType) == Toolkit::DevelImageVisual::MaskingType::MASKING_ON_LOADING ? true : false; + } + } + break; + } + + case Toolkit::DevelImageVisual::Property::ENABLE_BROKEN_IMAGE: + { + bool enableBrokenImage(mEnableBrokenImage); + if(value.Get(enableBrokenImage)) + { + mEnableBrokenImage = enableBrokenImage; } break; } @@ -468,6 +484,16 @@ void ImageVisual::DoSetProperty(Property::Index index, const Property::Value& va } break; } + + case Toolkit::DevelImageVisual::Property::FAST_TRACK_UPLOADING: + { + bool fastTrackUploading = false; + if(value.Get(fastTrackUploading)) + { + mUseFastTrackUploading = fastTrackUploading; + } + break; + } } } @@ -476,6 +502,10 @@ void ImageVisual::AllocateMaskData() if(!mMaskingData) { mMaskingData.reset(new TextureManager::MaskingData()); + if(mImageUrl.IsValid() && mImageUrl.GetProtocolType() == VisualUrl::TEXTURE) + { + mMaskingData->mPreappliedMasking = false; + } } } @@ -537,6 +567,11 @@ void ImageVisual::GetNaturalSize(Vector2& naturalSize) { imageSize = actor.GetProperty(Actor::Property::SIZE).Get(); } + else + { + imageSize = mPlacementActorSize; + } + mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize); Texture brokenImage = mImpl->mRenderer.GetTextures().GetTexture(0); naturalSize.x = brokenImage.GetWidth(); @@ -616,9 +651,92 @@ void ImageVisual::LoadTexture(bool& atlasing, Vector4& atlasRect, TextureSet& te : TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY; bool synchronousLoading = IsSynchronousLoadingRequired(); - bool loadingStatus; + bool loadingStatus = false; + + // Remove previous loading task. + ResetFastTrackLoadingTask(); + + // Rare case. If someone call LoadTexture during fast track loading task running, (Ex : Action::RELOAD) + // we should remove previously added renderer now. + if(mRendererAdded) + { + Actor actor = mPlacementActor.GetHandle(); + if(actor) + { + actor.RemoveRenderer(mImpl->mRenderer); + mRendererAdded = false; + } + } + + /** + * @brief Check whether FastTrackUploading is avaliable or not. + * @return True if we can use fast track uploading feature. False otherwise. + */ + auto IsFastTrackUploadingAvailable = [&]() { + if(mUseFastTrackUploading && + mLoadPolicy == Toolkit::ImageVisual::LoadPolicy::ATTACHED && + mReleasePolicy == Toolkit::ImageVisual::ReleasePolicy::DETACHED && + forceReload == TextureManager::ReloadPolicy::CACHED && + (mImageUrl.GetProtocolType() == VisualUrl::LOCAL || mImageUrl.GetProtocolType() == VisualUrl::REMOTE) && + !synchronousLoading && + !atlasing && + !mImpl->mCustomShader && + !(mMaskingData && mMaskingData->mAlphaMaskUrl.IsValid())) + { + return true; + } + else if(mUseFastTrackUploading) + { + DALI_LOG_DEBUG_INFO("FastTrack : Fail to load fast track. mUrl : [%s]%s%s%s%s%s%s%s%s\n", + mImageUrl.GetUrl().c_str(), + (mLoadPolicy != Toolkit::ImageVisual::LoadPolicy::ATTACHED) ? "/ mLoadPolicy != ATTACHED" : "", + (mReleasePolicy != Toolkit::ImageVisual::ReleasePolicy::DETACHED) ? "/ mReleasePolicy != DETACHED" : "", + (forceReload != TextureManager::ReloadPolicy::CACHED) ? "/ forceReload != CACHED" : "", + (!(mImageUrl.GetProtocolType() == VisualUrl::LOCAL || mImageUrl.GetProtocolType() == VisualUrl::REMOTE)) ? "/ url is not image" : "", + (synchronousLoading) ? "/ synchronousLoading" : "", + (atlasing) ? "/ atlasing" : "", + (mImpl->mCustomShader) ? "/ use customs shader" : "", + (mMaskingData && mMaskingData->mAlphaMaskUrl.IsValid()) ? "/ use masking url" : ""); + } + return false; + }; + + if(IsFastTrackUploadingAvailable()) + { + // Enable PremultipliedAlpha first. + EnablePreMultipliedAlpha(preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD); - textures = textureManager.LoadTexture(mImageUrl, mDesiredSize, mFittingMode, mSamplingMode, mMaskingData, synchronousLoading, mTextureId, atlasRect, mAtlasRectSize, atlasing, loadingStatus, mWrapModeU, mWrapModeV, textureObserver, atlasUploadObserver, atlasManager, mOrientationCorrection, forceReload, preMultiplyOnLoad); + // Set new TextureSet with fast track loading task + mFastTrackLoadingTask = new FastTrackLoadingTask(mImageUrl, mDesiredSize, mFittingMode, mSamplingMode, mOrientationCorrection, preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD ? DevelAsyncImageLoader::PreMultiplyOnLoad::ON : DevelAsyncImageLoader::PreMultiplyOnLoad::OFF, mFactoryCache.GetLoadYuvPlanes(), MakeCallback(this, &ImageVisual::FastLoadComplete)); + + TextureSet textureSet = TextureSet::New(); + if(!mFastTrackLoadingTask->mLoadPlanesAvaliable) + { + DALI_ASSERT_ALWAYS(mFastTrackLoadingTask->mTextures.size() >= 1u); + textureSet.SetTexture(0u, mFastTrackLoadingTask->mTextures[0]); + } + else + { + DALI_ASSERT_ALWAYS(mFastTrackLoadingTask->mTextures.size() >= 3u); + textureSet.SetTexture(0u, mFastTrackLoadingTask->mTextures[0]); + textureSet.SetTexture(1u, mFastTrackLoadingTask->mTextures[1]); + textureSet.SetTexture(2u, mFastTrackLoadingTask->mTextures[2]); + + // We cannot determine what kind of shader will be used. + // Just use unified shader, and then change shader after load completed. + mNeedUnifiedYuvAndRgb = true; + UpdateShader(); + } + mImpl->mRenderer.SetTextures(textureSet); + + Dali::AsyncTaskManager::Get().AddTask(mFastTrackLoadingTask); + + mLoadState = TextureManager::LoadState::LOADING; + } + else + { + textures = textureManager.LoadTexture(mImageUrl, mDesiredSize, mFittingMode, mSamplingMode, mMaskingData, synchronousLoading, mTextureId, atlasRect, mAtlasRectSize, atlasing, loadingStatus, textureObserver, atlasUploadObserver, atlasManager, mOrientationCorrection, forceReload, preMultiplyOnLoad); + } if(textures) { @@ -632,6 +750,12 @@ void ImageVisual::LoadTexture(bool& atlasing, Vector4& atlasRect, TextureSet& te } EnablePreMultipliedAlpha(preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD); + if(!atlasing) + { + Sampler sampler = Sampler::New(); + sampler.SetWrapMode(mWrapModeU, mWrapModeV); + textures.SetSampler(0u, sampler); + } } else if(synchronousLoading) { @@ -676,6 +800,12 @@ void ImageVisual::InitializeRenderer() else { mTextures = mFactoryCache.GetTextureManager().GetTextureSet(mTextureId); + if(!(mImpl->mFlags & Visual::Base::Impl::IS_ATLASING_APPLIED) && mTextures) + { + Sampler sampler = Sampler::New(); + sampler.SetWrapMode(mWrapModeU, mWrapModeV); + mTextures.SetSampler(0u, sampler); + } } } @@ -684,7 +814,19 @@ void ImageVisual::InitializeRenderer() mImpl->mRenderer.SetTextures(mTextures); ComputeTextureSize(); CheckMaskTexture(); - if(DevelTexture::IsNative(mTextures.GetTexture(0))) + + bool needToUpdateShader = DevelTexture::IsNative(mTextures.GetTexture(0)); + + if(mTextures.GetTextureCount() == 3) + { + if(mTextures.GetTexture(0).GetPixelFormat() == Pixel::L8 && mTextures.GetTexture(1).GetPixelFormat() == Pixel::CHROMINANCE_U && mTextures.GetTexture(2).GetPixelFormat() == Pixel::CHROMINANCE_V) + { + mNeedYuvToRgb = true; + needToUpdateShader = true; + } + } + + if(needToUpdateShader) { UpdateShader(); } @@ -719,13 +861,6 @@ void ImageVisual::DoSetOnScene(Actor& actor) } mPlacementActor = actor; - // Search the Actor tree to find if Layer UI behaviour set. - Layer layer = actor.GetLayer(); - if(layer && layer.GetProperty(Layer::Property::BEHAVIOR) == Layer::LAYER_3D) - { - // Layer 3D set, do not align pixels - mImpl->mRenderer.RegisterProperty(PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF); - } if(mPixelArea != FULL_TEXTURE_RECT) { @@ -735,6 +870,7 @@ void ImageVisual::DoSetOnScene(Actor& actor) if(mLoadState == TextureManager::LoadState::LOAD_FINISHED) { actor.AddRenderer(mImpl->mRenderer); + mRendererAdded = true; mPlacementActor.Reset(); // Image loaded and ready to display @@ -742,16 +878,16 @@ void ImageVisual::DoSetOnScene(Actor& actor) } else if(mLoadState == TextureManager::LoadState::LOAD_FAILED) { - Vector2 imageSize = Vector2::ZERO; - if(actor) + ShowBrokenImage(); + ResourceReady(Toolkit::Visual::ResourceStatus::FAILED); + } + else + { + if(mFastTrackLoadingTask) { - imageSize = actor.GetProperty(Actor::Property::SIZE).Get(); + actor.AddRenderer(mImpl->mRenderer); + mRendererAdded = true; } - mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize); - actor.AddRenderer(mImpl->mRenderer); - mPlacementActor.Reset(); - - ResourceReady(Toolkit::Visual::ResourceStatus::FAILED); } } @@ -761,16 +897,11 @@ void ImageVisual::DoSetOffScene(Actor& actor) // Image release is dependent on the ReleasePolicy, renderer is removed. actor.RemoveRenderer(mImpl->mRenderer); + mRendererAdded = false; + if(mReleasePolicy == Toolkit::ImageVisual::ReleasePolicy::DETACHED) { - RemoveTexture(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas - mImpl->mResourceStatus = Toolkit::Visual::ResourceStatus::PREPARING; - - TextureSet textureSet = TextureSet::New(); - mImpl->mRenderer.SetTextures(textureSet); - ComputeTextureSize(); - - mLoadState = TextureManager::LoadState::NOT_STARTED; + ResetRenderer(); } mPlacementActor.Reset(); @@ -810,6 +941,8 @@ void ImageVisual::DoCreatePropertyMap(Property::Map& map) const map.Insert(Toolkit::ImageVisual::Property::LOAD_POLICY, mLoadPolicy); map.Insert(Toolkit::ImageVisual::Property::RELEASE_POLICY, mReleasePolicy); map.Insert(Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION, mOrientationCorrection); + + map.Insert(Toolkit::DevelImageVisual::Property::FAST_TRACK_UPLOADING, mUseFastTrackUploading); } void ImageVisual::DoCreateInstancePropertyMap(Property::Map& map) const @@ -865,6 +998,7 @@ void ImageVisual::UploadCompleted() { mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, mAtlasRect); actor.AddRenderer(mImpl->mRenderer); + mRendererAdded = true; // reset the weak handle so that the renderer only get added to actor once mPlacementActor.Reset(); } @@ -874,6 +1008,64 @@ void ImageVisual::UploadCompleted() mLoadState = TextureManager::LoadState::LOAD_FINISHED; } +// From FastTrackLoadingTask +void ImageVisual::FastLoadComplete(FastTrackLoadingTaskPtr task) +{ + Toolkit::Visual::ResourceStatus resourceStatus; + + DALI_ASSERT_ALWAYS(mFastTrackLoadingTask == task && "Task was not canceled successfully!"); + DALI_ASSERT_ALWAYS(mRendererAdded && "Some FastTrack logic missed!"); + + Actor actor = mPlacementActor.GetHandle(); + + if(mFastTrackLoadingTask && mFastTrackLoadingTask->mLoadSuccess) + { + resourceStatus = Toolkit::Visual::ResourceStatus::READY; + mLoadState = TextureManager::LoadState::LOAD_FINISHED; + + // Change premultiplied alpha flag after change renderer. + EnablePreMultipliedAlpha(mFastTrackLoadingTask->mPremultiplied); + + if(mFastTrackLoadingTask->mLoadPlanesAvaliable) + { + if(mFastTrackLoadingTask->mPlanesLoaded) + { + // Let we use regular yuv cases. + mNeedYuvToRgb = true; + } + else + { + // Let we use regular image cases. + mNeedYuvToRgb = false; + + auto textureSet = mImpl->mRenderer.GetTextures(); + DALI_ASSERT_ALWAYS(textureSet && textureSet.GetTextureCount() > 0u && "Previous texture set must exist!"); + + Dali::TextureSet newTextureSet = TextureSet::New(); + newTextureSet.SetTexture(0u, textureSet.GetTexture(0u)); + mImpl->mRenderer.SetTextures(newTextureSet); + } + + // We can specify what kind of shader we need to use now. Update shader. + mNeedUnifiedYuvAndRgb = false; + UpdateShader(); + } + } + else + { + resourceStatus = Toolkit::Visual::ResourceStatus::FAILED; + mLoadState = TextureManager::LoadState::LOAD_FAILED; + + // Change renderer as broken. + ShowBrokenImage(); + } + + mFastTrackLoadingTask.Reset(); + + // Signal to observers ( control ) that resources are ready. Must be all resources. + ResourceReady(resourceStatus); +} + // From Texture Manager void ImageVisual::LoadComplete(bool loadingSuccess, TextureInformation textureInformation) { @@ -890,29 +1082,38 @@ void ImageVisual::LoadComplete(bool loadingSuccess, TextureInformation textureIn Actor actor = mPlacementActor.GetHandle(); if(!loadingSuccess) { - Vector2 imageSize = Vector2::ZERO; - if(actor) - { - imageSize = actor.GetProperty(Actor::Property::SIZE).Get(); - } - mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize); + ShowBrokenImage(); textureInformation.textureSet = mImpl->mRenderer.GetTextures(); } else { - Sampler sampler = Sampler::New(); - sampler.SetWrapMode(mWrapModeU, mWrapModeV); - textureInformation.textureSet.SetSampler(0u, sampler); + if(!textureInformation.useAtlasing) + { + Sampler sampler = Sampler::New(); + sampler.SetWrapMode(mWrapModeU, mWrapModeV); + textureInformation.textureSet.SetSampler(0u, sampler); + } + mImpl->mRenderer.SetTextures(textureInformation.textureSet); ComputeTextureSize(); CheckMaskTexture(); - } - if(actor) - { - actor.AddRenderer(mImpl->mRenderer); - // reset the weak handle so that the renderer only get added to actor once - mPlacementActor.Reset(); + if(textureInformation.textureSet.GetTextureCount() == 3) + { + if(textureInformation.textureSet.GetTexture(0).GetPixelFormat() == Pixel::L8 && textureInformation.textureSet.GetTexture(1).GetPixelFormat() == Pixel::CHROMINANCE_U && textureInformation.textureSet.GetTexture(2).GetPixelFormat() == Pixel::CHROMINANCE_V) + { + mNeedYuvToRgb = true; + UpdateShader(); + } + } + + if(actor) + { + actor.AddRenderer(mImpl->mRenderer); + mRendererAdded = true; + // reset the weak handle so that the renderer only get added to actor once + mPlacementActor.Reset(); + } } } @@ -972,11 +1173,13 @@ void ImageVisual::RemoveTexture() { if(mTextureId != TextureManager::INVALID_TEXTURE_ID) { - mFactoryCache.GetTextureManager().Remove(mTextureId, this); + mFactoryCache.GetTextureManager().RequestRemove(mTextureId, this); mTextureId = TextureManager::INVALID_TEXTURE_ID; } else { + ResetFastTrackLoadingTask(); + Vector4 atlasRect(0.f, 0.f, 1.f, 1.f); Property::Index index = mImpl->mRenderer.GetPropertyIndex(ATLAS_RECT_UNIFORM_NAME); if(index != Property::INVALID_INDEX) @@ -1052,7 +1255,6 @@ Shader ImageVisual::GenerateShader() const { Shader shader; - bool usesWholeTexture = true; const bool useStandardShader = !mImpl->mCustomShader; const bool useNativeImage = (mTextures && DevelTexture::IsNative(mTextures.GetTexture(0))); @@ -1068,10 +1270,12 @@ Shader ImageVisual::GenerateShader() const .EnableRoundedCorner(IsRoundedCornerRequired()) .EnableBorderline(IsBorderlineRequired()) .SetTextureForFragmentShaderCheck(useNativeImage ? mTextures.GetTexture(0) : Dali::Texture()) - .EnableAlphaMaskingOnRendering(requiredAlphaMaskingOnRendering)); + .EnableAlphaMaskingOnRendering(requiredAlphaMaskingOnRendering) + .EnableYuvToRgb(mNeedYuvToRgb, mNeedUnifiedYuvAndRgb)); } else { + bool usesWholeTexture = true; std::string_view vertexShaderView; std::string_view fragmentShaderView; @@ -1115,18 +1319,13 @@ Shader ImageVisual::GenerateShader() const { shader = Shader::New(vertexShaderView, fragmentShaderView, mImpl->mCustomShader->mHints); } - } - if(usesWholeTexture) - { - shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT); + if(usesWholeTexture) + { + shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT); + } } - // Set pixel align off as default. - // ToDo: Pixel align causes issues such as rattling image animation. - // We should trun it off until issues are resolved - shader.RegisterProperty(PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF); - return shader; } @@ -1153,6 +1352,69 @@ void ImageVisual::CheckMaskTexture() } } +void ImageVisual::ResetRenderer() +{ + RemoveTexture(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas + mImpl->mResourceStatus = Toolkit::Visual::ResourceStatus::PREPARING; + + TextureSet textureSet = TextureSet::New(); + mImpl->mRenderer.SetTextures(textureSet); + ComputeTextureSize(); + + mLoadState = TextureManager::LoadState::NOT_STARTED; +} + +void ImageVisual::ShowBrokenImage() +{ + if(mEnableBrokenImage) + { + Actor actor = mPlacementActor.GetHandle(); + + Vector2 imageSize = Vector2::ZERO; + if(actor) + { + imageSize = actor.GetProperty(Actor::Property::SIZE).Get(); + mPlacementActorSize = imageSize; + + if(mRendererAdded) + { + actor.RemoveRenderer(mImpl->mRenderer); + mRendererAdded = false; + } + } + + mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize); + if(actor) + { + actor.AddRenderer(mImpl->mRenderer); + mRendererAdded = true; + mPlacementActor.Reset(); + } + } + else + { + if(mRendererAdded) + { + Actor actor = mPlacementActor.GetHandle(); + if(actor) + { + actor.RemoveRenderer(mImpl->mRenderer); + mRendererAdded = false; + } + } + ResetRenderer(); + } +} + +void ImageVisual::ResetFastTrackLoadingTask() +{ + if(mFastTrackLoadingTask) + { + Dali::AsyncTaskManager::Get().RemoveTask(mFastTrackLoadingTask); + mFastTrackLoadingTask.Reset(); + } +} + } // namespace Internal } // namespace Toolkit