This is a combination of 3 commits.
Revert "[Tizen] Keep reference when member callback excute"
Keep reference when member callback excute + Make NPatchData as RefObject
Some CallbackBase didn't hold the reference of itself.
So it was possible to call destructor of itself during it's
API was running.
It might makes some unknown issues. So let we keep reference
for some issue-comes known APIs : SvgVisual, NPatchData, and lottie
It future, we should discard visuals rather than delate it directly.
Destroy removal visuals after idler
There was some bug when visual destructor called during
it's emit ResourceReady.
To avoid this case, Let we keep visuals more long term,
and Discard + Destroy after some idler called.
To avoid multiple Idler callback register,
let we make that idler callback in VisualFactory.
Change-Id: I4156f1af3cf40ffb30235dc9e6c55f9c7633f21d
void Adaptor::RemoveIdle(CallbackBase* callback)
{
- mCallbacks.Erase(std::find_if(mCallbacks.Begin(), mCallbacks.End(), [&callback](CallbackBase* current) { return callback == current; }));
- mReturnCallbacks.Erase(std::find_if(mReturnCallbacks.Begin(), mReturnCallbacks.End(), [&callback](CallbackBase* current) { return callback == current; }));
+ mCallbacks.Erase(std::remove_if(mCallbacks.Begin(), mCallbacks.End(), [&callback](CallbackBase* current) { return callback == current; }), mCallbacks.End());
+ mReturnCallbacks.Erase(std::remove_if(mReturnCallbacks.Begin(), mReturnCallbacks.End(), [&callback](CallbackBase* current) { return callback == current; }), mReturnCallbacks.End());
}
void Adaptor::RunIdles()
/*
- * 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.
END_TEST;
}
-int UtcDaliSetPropertyP(void)
+int UtcDaliSliderSetPropertyP(void)
{
ToolkitTestApplication application;
- tet_infoline("UtcDaliSetPropertyP");
+ tet_infoline("UtcDaliSliderSetPropertyP");
Slider slider = Slider::New();
slider.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
shadowLightCamera.RemoveConstraints();
// Compute ViewProjectionMatrix and store it to "tempViewProjectionMatrix" property
- auto tempViewProjectionMatrixIndex = shadowLightCamera.RegisterProperty("tempViewProjectionMatrix", Matrix::IDENTITY);
- Constraint projectionMatrixConstraint = Constraint::New<Matrix>(shadowLightCamera, tempViewProjectionMatrixIndex, [](Matrix& output, const PropertyInputContainer& inputs)
- {
- Matrix worldMatrix = inputs[0]->GetMatrix();
- float tangentFov_2 = tanf(inputs[4]->GetFloat());
- float nearDistance = inputs[5]->GetFloat();
- float farDistance = inputs[6]->GetFloat();
- float aspectRatio = inputs[7]->GetFloat();
- float nearY = 0.0f;
- float nearX = 0.0f;
- float farY = 0.0f;
- float farX = 0.0f;
- if(inputs[1]->GetInteger() == Dali::Camera::ProjectionMode::PERSPECTIVE_PROJECTION)
- {
- if(inputs[2]->GetInteger() == Dali::DevelCameraActor::ProjectionDirection::VERTICAL)
- {
- nearY = tangentFov_2 * nearDistance;
- nearX = nearY * aspectRatio;
- farY = tangentFov_2 * farDistance;
- farX = farY * aspectRatio;
- }
- else
- {
- nearX = tangentFov_2 * nearDistance;
- nearY = nearX / aspectRatio;
- farX = tangentFov_2 * farDistance;
- farY = farX / aspectRatio;
- }
- }
- else
- {
- if(inputs[2]->GetInteger() == Dali::DevelCameraActor::ProjectionDirection::VERTICAL)
- {
- nearY = inputs[3]->GetFloat();
- nearX = nearY * aspectRatio;
- }
- else
- {
- nearX = inputs[3]->GetFloat();
- nearY = nearX / aspectRatio;
- }
- farX = nearX;
- farY = nearY;
- }
-
- std::vector<Vector4> points;
- points.push_back(Vector4(nearX, nearY, nearDistance, 1.0f));
- points.push_back(Vector4(-nearX, nearY, nearDistance, 1.0f));
- points.push_back(Vector4(-nearX, -nearY, nearDistance, 1.0f));
- points.push_back(Vector4(nearX, -nearY, nearDistance, 1.0f));
- points.push_back(Vector4(farX, farY, farDistance, 1.0f));
- points.push_back(Vector4(-farX, farY, farDistance, 1.0f));
- points.push_back(Vector4(-farX, -farY, farDistance, 1.0f));
- points.push_back(Vector4(farX, -farY, farDistance, 1.0f));
-
- Matrix shadowCameraWorldMatrix = inputs[8]->GetMatrix();
- Vector4 worldCenter;
- for(auto&& point : points)
- {
- point = worldMatrix * point;
- worldCenter += point;
- }
- worldCenter /= 8.0f;
- shadowCameraWorldMatrix.SetTranslation(Vector3(worldCenter));
- Matrix shadowCameraViewMatrix = shadowCameraWorldMatrix;
- shadowCameraViewMatrix.Invert();
-
- Vector3 areaMin = Vector3::ONE * MAXFLOAT, areaMax = Vector3::ONE * -MAXFLOAT;
- for(auto&& point : points)
- {
- Vector4 pointV = shadowCameraViewMatrix * point;
- areaMin.x = std::min(areaMin.x, pointV.x);
- areaMin.y = std::min(areaMin.y, pointV.y);
- areaMin.z = std::min(areaMin.z, pointV.z);
- areaMax.x = std::max(areaMax.x, pointV.x);
- areaMax.y = std::max(areaMax.y, pointV.y);
- areaMax.z = std::max(areaMax.z, pointV.z);
- }
-
- Vector2 center = Vector2(areaMax + areaMin) * 0.5;
- float delta = std::max(std::abs(areaMax.x - areaMin.x), std::abs(areaMax.y - areaMin.y));
- float delta_2 = delta * 0.5f;
- Vector2 squareAreaMin = center - Vector2::ONE * delta_2;
- Vector2 squareAreaMax = center + Vector2::ONE * delta_2;
- float deltaZ = areaMax.z - areaMin.z;
-
- float right = -squareAreaMin.x;
- float left = -squareAreaMax.x;
- float top = squareAreaMin.y;
- float bottom = squareAreaMax.y;
- float near = areaMin.z;
- float far = areaMax.z;
-
- float* projMatrix = output.AsFloat();
-
- projMatrix[0] = -2.0f / delta;
- projMatrix[1] = 0.0f;
- projMatrix[2] = 0.0f;
- projMatrix[3] = 0.0f;
-
- projMatrix[4] = 0.0f;
- projMatrix[5] = -2.0f / delta;
- projMatrix[6] = 0.0f;
- projMatrix[7] = 0.0f;
-
- projMatrix[8] = 0.0f;
- projMatrix[9] = 0.0f;
- projMatrix[10] = 2.0f / deltaZ;
- projMatrix[11] = 0.0f;
-
- projMatrix[12] = -(right + left) / delta;
- projMatrix[13] = -(top + bottom) / delta;
- projMatrix[14] = -(near + far) / deltaZ;
- projMatrix[15] = 1.0f;
-
- output = output * shadowCameraViewMatrix;
- });
+ auto tempViewProjectionMatrixIndex = shadowLightCamera.RegisterProperty("tempViewProjectionMatrix", Matrix::IDENTITY);
+ Constraint projectionMatrixConstraint = Constraint::New<Matrix>(shadowLightCamera, tempViewProjectionMatrixIndex, [](Matrix& output, const PropertyInputContainer& inputs) {
+ Matrix worldMatrix = inputs[0]->GetMatrix();
+ float tangentFov_2 = tanf(inputs[4]->GetFloat());
+ float nearDistance = inputs[5]->GetFloat();
+ float farDistance = inputs[6]->GetFloat();
+ float aspectRatio = inputs[7]->GetFloat();
+ float nearY = 0.0f;
+ float nearX = 0.0f;
+ float farY = 0.0f;
+ float farX = 0.0f;
+ if(inputs[1]->GetInteger() == Dali::Camera::ProjectionMode::PERSPECTIVE_PROJECTION)
+ {
+ if(inputs[2]->GetInteger() == Dali::DevelCameraActor::ProjectionDirection::VERTICAL)
+ {
+ nearY = tangentFov_2 * nearDistance;
+ nearX = nearY * aspectRatio;
+ farY = tangentFov_2 * farDistance;
+ farX = farY * aspectRatio;
+ }
+ else
+ {
+ nearX = tangentFov_2 * nearDistance;
+ nearY = nearX / aspectRatio;
+ farX = tangentFov_2 * farDistance;
+ farY = farX / aspectRatio;
+ }
+ }
+ else
+ {
+ if(inputs[2]->GetInteger() == Dali::DevelCameraActor::ProjectionDirection::VERTICAL)
+ {
+ nearY = inputs[3]->GetFloat();
+ nearX = nearY * aspectRatio;
+ }
+ else
+ {
+ nearX = inputs[3]->GetFloat();
+ nearY = nearX / aspectRatio;
+ }
+ farX = nearX;
+ farY = nearY;
+ }
+
+ std::vector<Vector4> points;
+ points.push_back(Vector4(nearX, nearY, nearDistance, 1.0f));
+ points.push_back(Vector4(-nearX, nearY, nearDistance, 1.0f));
+ points.push_back(Vector4(-nearX, -nearY, nearDistance, 1.0f));
+ points.push_back(Vector4(nearX, -nearY, nearDistance, 1.0f));
+ points.push_back(Vector4(farX, farY, farDistance, 1.0f));
+ points.push_back(Vector4(-farX, farY, farDistance, 1.0f));
+ points.push_back(Vector4(-farX, -farY, farDistance, 1.0f));
+ points.push_back(Vector4(farX, -farY, farDistance, 1.0f));
+
+ Matrix shadowCameraWorldMatrix = inputs[8]->GetMatrix();
+ Vector4 worldCenter;
+ for(auto&& point : points)
+ {
+ point = worldMatrix * point;
+ worldCenter += point;
+ }
+ worldCenter /= 8.0f;
+ shadowCameraWorldMatrix.SetTranslation(Vector3(worldCenter));
+ Matrix shadowCameraViewMatrix = shadowCameraWorldMatrix;
+ shadowCameraViewMatrix.Invert();
+
+ Vector3 areaMin = Vector3::ONE * MAXFLOAT, areaMax = Vector3::ONE * -MAXFLOAT;
+ for(auto&& point : points)
+ {
+ Vector4 pointV = shadowCameraViewMatrix * point;
+ areaMin.x = std::min(areaMin.x, pointV.x);
+ areaMin.y = std::min(areaMin.y, pointV.y);
+ areaMin.z = std::min(areaMin.z, pointV.z);
+ areaMax.x = std::max(areaMax.x, pointV.x);
+ areaMax.y = std::max(areaMax.y, pointV.y);
+ areaMax.z = std::max(areaMax.z, pointV.z);
+ }
+
+ Vector2 center = Vector2(areaMax + areaMin) * 0.5;
+ float delta = std::max(std::abs(areaMax.x - areaMin.x), std::abs(areaMax.y - areaMin.y));
+ float delta_2 = delta * 0.5f;
+ Vector2 squareAreaMin = center - Vector2::ONE * delta_2;
+ Vector2 squareAreaMax = center + Vector2::ONE * delta_2;
+ float deltaZ = areaMax.z - areaMin.z;
+
+ float right = -squareAreaMin.x;
+ float left = -squareAreaMax.x;
+ float top = squareAreaMin.y;
+ float bottom = squareAreaMax.y;
+ float near = areaMin.z;
+ float far = areaMax.z;
+
+ float* projMatrix = output.AsFloat();
+
+ projMatrix[0] = -2.0f / delta;
+ projMatrix[1] = 0.0f;
+ projMatrix[2] = 0.0f;
+ projMatrix[3] = 0.0f;
+
+ projMatrix[4] = 0.0f;
+ projMatrix[5] = -2.0f / delta;
+ projMatrix[6] = 0.0f;
+ projMatrix[7] = 0.0f;
+
+ projMatrix[8] = 0.0f;
+ projMatrix[9] = 0.0f;
+ projMatrix[10] = 2.0f / deltaZ;
+ projMatrix[11] = 0.0f;
+
+ projMatrix[12] = -(right + left) / delta;
+ projMatrix[13] = -(top + bottom) / delta;
+ projMatrix[14] = -(near + far) / deltaZ;
+ projMatrix[15] = 1.0f;
+
+ output = output * shadowCameraViewMatrix;
+ });
projectionMatrixConstraint.AddSource(Source{selectedCamera, Dali::Actor::Property::WORLD_MATRIX});
projectionMatrixConstraint.AddSource(Source{selectedCamera, Dali::CameraActor::Property::PROJECTION_MODE});
projectionMatrixConstraint.AddSource(Source{selectedCamera, Dali::DevelCameraActor::Property::PROJECTION_DIRECTION});
return;
}
- auto foundLight = std::find_if(mLights.begin(), mLights.end(), [light](std::pair<Scene3D::Light, bool> lightEntity) -> bool
- { return (lightEntity.second && lightEntity.first == light); });
+ auto foundLight = std::find_if(mLights.begin(), mLights.end(), [light](std::pair<Scene3D::Light, bool> lightEntity) -> bool { return (lightEntity.second && lightEntity.first == light); });
if(foundLight == mLights.end())
{
SetShadowLightConstraint(selectedCamera, lightCamera);
// make framebuffer for depth map and set it to render task.
- Vector3 size = Self().GetProperty<Vector3>(Dali::Actor::Property::SIZE);
+ Vector3 size = Self().GetProperty<Vector3>(Dali::Actor::Property::SIZE);
uint32_t shadowMapBufferSize = std::min(static_cast<uint32_t>(std::max(size.width, size.height)), MAXIMUM_SIZE_SHADOW_MAP);
UpdateShadowMapBuffer(shadowMapBufferSize);
}
mSkyboxResourceReady = true;
- if(IsResourceReady())
- {
- Control::SetResourceReady();
- }
-
- mSkyboxTexture = mSkyboxLoadTask->GetLoadedTexture();
+ mSkyboxTexture = mSkyboxLoadTask->GetLoadedTexture();
Shader skyboxShader;
if(mSkyboxLoadTask->GetEnvironmentMapType() == Scene3D::EnvironmentMapType::CUBEMAP)
{
}
mSkyboxLoadTask.Reset();
+
+ if(IsResourceReady())
+ {
+ Control::SetResourceReady();
+ }
}
void SceneView::OnIblDiffuseLoadComplete()
{
mDiffuseTexture = mIblDiffuseLoadTask->GetLoadedTexture();
mIblDiffuseResourceReady = true;
+ mIblDiffuseLoadTask.Reset();
if(mIblDiffuseResourceReady && mIblSpecularResourceReady)
{
OnIblLoadComplete();
}
- mIblDiffuseLoadTask.Reset();
}
void SceneView::OnIblSpecularLoadComplete()
mSpecularTexture = mIblSpecularLoadTask->GetLoadedTexture();
mSpecularMipmapLevels = mIblSpecularLoadTask->GetMipmapLevels();
mIblSpecularResourceReady = true;
+ mIblSpecularLoadTask.Reset();
if(mIblDiffuseResourceReady && mIblSpecularResourceReady)
{
OnIblLoadComplete();
}
- mIblSpecularLoadTask.Reset();
}
void SceneView::OnIblLoadComplete()
/*
-* 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.
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/visuals/npatch-data.h>
+
namespace Dali
{
namespace Toolkit
}
}
-void ApplyTextureAndUniforms(Renderer& renderer, const std::shared_ptr<const Internal::NPatchData> data)
+void ApplyTextureAndUniforms(Renderer& renderer, const Internal::NPatchData* data)
{
TextureSet textureSet;
textureSet = data->GetTextures();
#define DALI_TOOLKIT_NPATCH_HELPER_H
/*
- * Copyright (c) 2021 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.
*/
// EXTERNAL INCLUDES
+#include <dali/devel-api/rendering/renderer-devel.h>
#include <dali/public-api/math/uint-16-pair.h>
#include <dali/public-api/rendering/geometry.h>
-#include <dali/devel-api/rendering/renderer-devel.h>
-#include <memory> ///< for std::shared_ptr
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/utility/npatch-utilities.h>
#include <dali-toolkit/public-api/dali-toolkit-common.h>
-#include <dali-toolkit/internal/visuals/npatch-data.h>
namespace Dali
{
namespace Toolkit
{
-namespace NPatchHelper
+namespace Internal
{
-/**
- * The list that includes stretch pixel ranges
- */
-using StretchRanges = Dali::Vector<Uint16Pair>;
+class NPatchData;
+}
+namespace NPatchHelper
+{
/**
* @brief Creates a Npatch Geometry object
*
*/
DALI_TOOLKIT_API Geometry CreateBorderGeometry(Uint16Pair gridSize);
-
/**
* @brief Registers a properties for Stretch Ranges
*
* @param[in,out] renderer The renderer for broken image
* @param[in] data The pointer of npatch-data
*/
-void ApplyTextureAndUniforms(Renderer& renderer, const std::shared_ptr<const Internal::NPatchData> data);
+void ApplyTextureAndUniforms(Renderer& renderer, const Internal::NPatchData* data);
-} // namespace NPatchUtility
+} // namespace NPatchHelper
} // namespace Toolkit
/*
- * Copyright (c) 2020 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.
GetImplementation(*this).UsePreCompiledShader();
}
+void VisualFactory::DiscardVisual(Visual::Base visual)
+{
+ GetImplementation(*this).DiscardVisual(visual);
+}
+
} // namespace Toolkit
} // namespace Dali
#define DALI_TOOLKIT_VISUAL_FACTORY_H
/*
- * Copyright (c) 2020 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.
*/
void UsePreCompiledShader();
+ /**
+ * @brief Discard visual base. It will keep reference of visual until idle callback called.
+ *
+ * @param[in] visual Discarded visual base.
+ */
+ void DiscardVisual(Visual::Base visual);
+
private:
explicit DALI_INTERNAL VisualFactory(Internal::VisualFactory* impl);
};
}
/**
+ * Discard visual from source to visual factory.
+ */
+void DiscardVisual(RegisteredVisualContainer::Iterator sourceIter, RegisteredVisualContainer& source)
+{
+ Toolkit::Visual::Base visual = (*sourceIter)->visual;
+ if(visual)
+ {
+ if(Stage::IsInstalled())
+ {
+ Toolkit::VisualFactory::Get().DiscardVisual(visual);
+ }
+ }
+
+ source.Erase(sourceIter);
+}
+
+/**
* Performs actions as requested using the action name.
* @param[in] object The object on which to perform the action.
* @param[in] actionName The action to perform.
Actor self(mControlImpl.Self());
Toolkit::GetImplementation((*iter)->visual).SetOffScene(self);
(*iter)->pending = false;
- (*iter)->visual.Reset();
- mRemoveVisuals.Erase(iter);
+
+ // Discard removed visual. It will be destroyed at next Idle time.
+ DiscardVisual(iter, mRemoveVisuals);
}
}
{
Toolkit::GetImplementation((*visualToRemoveIter)->visual).SetOffScene(self);
}
- mRemoveVisuals.Erase(visualToRemoveIter);
+
+ // Discard removed visual. It will be destroyed at next Idle time.
+ DiscardVisual(visualToRemoveIter, mRemoveVisuals);
}
// A visual is ready so control may need relayouting if staged
// Visuals pending replacement can now be taken out of the removal list and set off scene
// Iterate through all replacement visuals and add to a move queue then set off scene
- for(auto removalIter = mRemoveVisuals.Begin(), end = mRemoveVisuals.End(); removalIter != end; removalIter++)
+
+ if(!mRemoveVisuals.Empty())
{
- Toolkit::GetImplementation((*removalIter)->visual).SetOffScene(self);
+ std::reverse(mRemoveVisuals.Begin(), mRemoveVisuals.End());
+
+ while(!mRemoveVisuals.Empty())
+ {
+ auto removalIter = mRemoveVisuals.End() - 1u;
+ Toolkit::GetImplementation((*removalIter)->visual).SetOffScene(self);
+
+ // Discard removed visual. It will be destroyed at next Idle time.
+ DiscardVisual(removalIter, mRemoveVisuals);
+ }
}
for(auto replacedIter = mVisuals.Begin(), end = mVisuals.End(); replacedIter != end; replacedIter++)
{
(*replacedIter)->pending = false;
}
-
- mRemoveVisuals.Clear();
}
void Control::Impl::SetMargin(Extents margin)
MakeFrameReady(loadSuccess, textureInformation.textureSet, textureInformation.interval, textureInformation.preMultiplied);
+ // TODO : We need to remove some below logics, since user can remove Visual during ResourceReady callback.
+
if(loadSuccess)
{
// The frames of a single animated image can not be loaded parallelly.
void AnimatedVectorImageVisual::OnAnimationFinished()
{
- AnimatedVectorImageVisualPtr self = this; // Keep reference until this API finished
-
if(DALI_UNLIKELY(mImpl == nullptr))
{
DALI_LOG_ERROR("Fatal error!! already destroyed object callback called! AnimatedVectorImageVisual : %p, url : %s\n", this, mUrl.GetUrl().c_str());
return;
}
+ AnimatedVectorImageVisualPtr self = this; // Keep reference until this API finished
+
DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnAnimationFinished: action state = %d [%p]\n", mPlayState, this);
if(mPlayState != DevelImageVisual::PlayState::STOPPED)
#include <dali-toolkit/internal/visuals/npatch-data.h>
// INTERNAL HEADERS
-#include <dali-toolkit/internal/visuals/npatch-loader.h> ///< for NPatchLoader
#include <dali-toolkit/internal/visuals/rendering-addon.h>
// EXTERNAL HEADERS
{
namespace Internal
{
-NPatchData::NPatchData(NPatchLoader& loader)
+NPatchData::NPatchData()
: mId(INVALID_NPATCH_DATA_ID),
- mNPatchLoader(loader),
mUrl(),
mTextureSet(),
mHash(0),
void NPatchData::LoadComplete(bool loadSuccess, TextureInformation textureInformation)
{
- // Increase reference count of itself
- mNPatchLoader.IncreaseReference(mId);
+ NPatchDataPtr self = this; // Keep reference until this API finished
if(loadSuccess)
{
// (If mLoadingState was LOAD_COMPLETE, NotifyObserver will be called directly. @todo : Should we fix this logic, matched with texture manager?)
// So LoadComplete will be called.
mObserverList.Swap(mQueuedObservers);
-
- // Decrease reference count of itself
- mNPatchLoader.RequestRemove(mId, nullptr);
}
void NPatchData::ObserverDestroyed(TextureUploadObserver* observer)
// EXTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
+#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/rendering/texture-set.h>
#include <string>
{
namespace Internal
{
-class NPatchLoader;
+class NPatchData;
+typedef IntrusivePtr<NPatchData> NPatchDataPtr;
-class NPatchData : public ConnectionTracker, public Dali::Toolkit::TextureUploadObserver
+class NPatchData : public ConnectionTracker, public Dali::Toolkit::TextureUploadObserver, public Dali::RefObject
{
public:
typedef int32_t NPatchDataId; ///< The NPatchDataId type. This is used as a handle to refer to a particular Npatch Data.
public:
/**
* Constructor
- *
- * @param[in] loader NPatchLoader who create this data.
*/
- NPatchData(NPatchLoader& loader);
+ NPatchData();
/**
* Destructor, non-virtual as not a base class
NPatchDataId mId;
ObserverListType mObserverList; ///< Container used to store all observer clients of this Texture
ObserverListType mQueuedObservers; ///< Container observers when user try to add during notify observers
- NPatchLoader& mNPatchLoader; ///< NPatchLoader who keep this data
VisualUrl mUrl; ///< Url of the N-Patch
TextureSet mTextureSet; ///< Texture containing the cropped image
NPatchData::NPatchDataId NPatchLoader::Load(TextureManager& textureManager, TextureUploadObserver* textureObserver, const VisualUrl& url, const Rect<int>& border, bool& preMultiplyOnLoad, bool synchronousLoading)
{
- std::shared_ptr<NPatchData> data = GetNPatchData(url, border, preMultiplyOnLoad);
+ NPatchDataPtr data = GetNPatchData(url, border, preMultiplyOnLoad);
- DALI_ASSERT_ALWAYS(data.get() && "NPatchData creation failed!");
+ DALI_ASSERT_ALWAYS(data.Get() && "NPatchData creation failed!");
if(data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
{
auto preMultiplyOnLoading = preMultiplyOnLoad ? TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD
: TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
- Devel::PixelBuffer pixelBuffer = textureManager.LoadPixelBuffer(url, Dali::ImageDimensions(), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, synchronousLoading, data.get(), true, preMultiplyOnLoading);
+ Devel::PixelBuffer pixelBuffer = textureManager.LoadPixelBuffer(url, Dali::ImageDimensions(), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, synchronousLoading, data.Get(), true, preMultiplyOnLoading);
if(pixelBuffer)
{
return INVALID_CACHE_INDEX;
}
-bool NPatchLoader::GetNPatchData(const NPatchData::NPatchDataId id, std::shared_ptr<const NPatchData>& data)
+bool NPatchLoader::GetNPatchData(const NPatchData::NPatchDataId id, NPatchDataPtr& data)
{
int32_t cacheIndex = GetCacheIndexFromId(id);
if(cacheIndex != INVALID_CACHE_INDEX)
}
}
-void NPatchLoader::IncreaseReference(NPatchData::NPatchDataId id)
-{
- int32_t cacheIndex = GetCacheIndexFromId(id);
- if(cacheIndex == INVALID_CACHE_INDEX)
- {
- return;
- }
-
- NPatchInfo& info(mCache[cacheIndex]);
-
- ++info.mReferenceCount;
-}
-
void NPatchLoader::Remove(NPatchData::NPatchDataId id, TextureUploadObserver* textureObserver)
{
int32_t cacheIndex = GetCacheIndexFromId(id);
}
}
-std::shared_ptr<NPatchData> NPatchLoader::GetNPatchData(const VisualUrl& url, const Rect<int>& border, bool& preMultiplyOnLoad)
+NPatchDataPtr NPatchLoader::GetNPatchData(const VisualUrl& url, const Rect<int>& border, bool& preMultiplyOnLoad)
{
std::size_t hash = CalculateHash(url.GetUrl());
std::vector<NPatchInfo>::size_type index = UNINITIALIZED_ID;
// If this is new image loading, make new cache data
if(infoPtr == nullptr)
{
- NPatchInfo info(std::make_shared<NPatchData>(*this));
+ NPatchInfo info(new NPatchData());
info.mData->SetId(GenerateUniqueNPatchDataId());
info.mData->SetHash(hash);
info.mData->SetUrl(url);
// Else if LOAD_COMPLETE, Same url but border is different - use the existing texture
else if(infoPtr->mData->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
{
- NPatchInfo info(std::make_shared<NPatchData>(*this));
+ NPatchInfo info(new NPatchData());
info.mData->SetId(GenerateUniqueNPatchDataId());
info.mData->SetHash(hash);
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/integration-api/processor-interface.h>
#include <dali/public-api/rendering/texture-set.h>
-#include <memory> // for std::shared_ptr
#include <string>
#include <utility> // for std::pair
* @param [out] data const pointer to the NPatchData
* @return true if data matching to id was really found
*/
- bool GetNPatchData(const NPatchData::NPatchDataId id, std::shared_ptr<const NPatchData>& data);
+ bool GetNPatchData(const NPatchData::NPatchDataId id, NPatchDataPtr& data);
/**
* @brief Request remove a texture matching id.
*/
void RequestRemove(NPatchData::NPatchDataId id, TextureUploadObserver* textureObserver);
- /**
- * @brief Increase reference count of a texture matching id.
- *
- * @param [in] id cache data id
- */
- void IncreaseReference(NPatchData::NPatchDataId id);
-
protected: // Implementation of Processor
/**
* @copydoc Dali::Integration::Processor::Process()
*/
struct NPatchInfo
{
- NPatchInfo(std::shared_ptr<NPatchData> data)
+ NPatchInfo(NPatchDataPtr data)
: mData(data),
mReferenceCount(1u)
{
NPatchInfo(const NPatchInfo& info) = delete; // Do not use copy constructor
NPatchInfo& operator=(const NPatchInfo& info) = delete; // Do not use copy assign
- std::shared_ptr<NPatchData> mData;
- std::int16_t mReferenceCount; ///< The number of N-patch visuals that use this data.
+ NPatchDataPtr mData;
+ std::int16_t mReferenceCount; ///< The number of N-patch visuals that use this data.
};
/**
* image has no alpha channel
* @return NPatchData pointer that Load function will used.
*/
- std::shared_ptr<NPatchData> GetNPatchData(const VisualUrl& url, const Rect<int>& border, bool& preMultiplyOnLoad);
+ NPatchDataPtr GetNPatchData(const VisualUrl& url, const Rect<int>& border, bool& preMultiplyOnLoad);
protected:
/**
bool preMultiplyOnLoad = IsPreMultipliedAlphaEnabled() && !mImpl->mCustomShader ? true : false;
mId = mLoader.Load(textureManager, this, mImageUrl, mBorder, preMultiplyOnLoad, synchronousLoading);
- std::shared_ptr<const NPatchData> data;
+ NPatchDataPtr data;
if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
{
EnablePreMultipliedAlpha(data->IsPreMultiplied());
naturalSize.y = 0u;
// load now if not already loaded
- std::shared_ptr<const NPatchData> data;
+ NPatchDataPtr data;
if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() != NPatchData::LoadingState::LOADING)
{
naturalSize.x = data->GetCroppedWidth();
// at this case, we try to SetResouce to mPlaceActor twice. so, we should avoid that case.
mPlacementActor = actor;
- std::shared_ptr<const NPatchData> data;
+ NPatchDataPtr data;
if(mImpl->mRenderer && mLoader.GetNPatchData(mId, data) && data->GetLoadingState() != NPatchData::LoadingState::LOADING)
{
// If mAuxiliaryUrl need to be loaded, we should wait it until LoadComplete called.
void NPatchVisual::OnInitialize()
{
// Get basic geometry and shader
- Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
- auto imageVisualShaderFeatureBuilder = ImageVisualShaderFeatureBuilder();
- Shader shader = mImageVisualShaderFactory.GetShader(
+ Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
+ auto imageVisualShaderFeatureBuilder = ImageVisualShaderFeatureBuilder();
+ Shader shader = mImageVisualShaderFactory.GetShader(
mFactoryCache,
imageVisualShaderFeatureBuilder);
Geometry NPatchVisual::CreateGeometry()
{
- Geometry geometry;
- std::shared_ptr<const NPatchData> data;
+ Geometry geometry;
+ NPatchDataPtr data;
if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
{
if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
Shader NPatchVisual::CreateShader()
{
- Shader shader;
- std::shared_ptr<const NPatchData> data;
+ Shader shader;
+ NPatchDataPtr 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;
void NPatchVisual::ApplyTextureAndUniforms()
{
- std::shared_ptr<const NPatchData> data;
- TextureSet textureSet;
+ NPatchDataPtr data;
+ TextureSet textureSet;
if(mLoader.GetNPatchData(mId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
{
textureSet = data->GetTextures();
- NPatchHelper::ApplyTextureAndUniforms(mImpl->mRenderer, data);
+ NPatchHelper::ApplyTextureAndUniforms(mImpl->mRenderer, data.Get());
if(mAuxiliaryResourceStatus == Toolkit::Visual::ResourceStatus::READY)
{
void NPatchVisual::SetResource()
{
- std::shared_ptr<const NPatchData> data;
+ NPatchDataPtr data;
if(mImpl->mRenderer && mLoader.GetNPatchData(mId, data))
{
Geometry geometry = CreateGeometry();
// If auxiliaryUrl didn't required OR auxiliaryUrl load done.
if(!mAuxiliaryUrl.IsValid() || mAuxiliaryResourceStatus != Toolkit::Visual::ResourceStatus::PREPARING)
{
- std::shared_ptr<const NPatchData> data;
+ NPatchDataPtr data;
// and.. If Url loading done.
if(mImpl->mRenderer && mLoader.GetNPatchData(mId, data) && data->GetLoadingState() != NPatchData::LoadingState::LOADING)
{
void SvgVisual::ApplyRasterizedImage(SvgTaskPtr task)
{
- SvgVisualPtr self = this; // Keep reference until this API finished
-
if(DALI_UNLIKELY(mImpl == nullptr))
{
DALI_LOG_ERROR("Fatal error!! already destroyed object callback called! SvgVisual : %p, url : %s, task : %p\n", this, mImageUrl.GetUrl().c_str(), task.Get());
return;
}
+ SvgVisualPtr self = this; // Keep reference until this API finished
// We don't need to keep tasks anymore. reset now.
if(task == mLoadingTask)
Geometry VisualFactoryCache::GetNPatchGeometry(int index)
{
- Geometry geometry;
- std::shared_ptr<const NPatchData> data;
+ Geometry geometry;
+ NPatchDataPtr data;
if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
{
if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
Shader VisualFactoryCache::GetNPatchShader(int index)
{
- Shader shader;
- std::shared_ptr<const NPatchData> data;
+ Shader shader;
+ NPatchDataPtr 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;
void VisualFactoryCache::ApplyTextureAndUniforms(Renderer& renderer, int index)
{
- std::shared_ptr<const NPatchData> data;
- TextureSet textureSet;
+ NPatchDataPtr 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);
+ NPatchHelper::ApplyTextureAndUniforms(renderer, data.Get());
renderer.SetTextures(textureSet);
}
}
mBrokenImageInfoContainer[index].visualType = visualUrl.GetType();
if(mBrokenImageInfoContainer[index].visualType == VisualUrl::Type::N_PATCH)
{
- std::shared_ptr<const NPatchData> data;
- Rect<int> border;
+ NPatchDataPtr 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)
{
// EXTERNAL INCLUDES
#include <dali/devel-api/scripting/scripting.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <dali/integration-api/debug.h>
#include <dali/public-api/object/property-array.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/devel-api/styling/style-manager-devel.h>
#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
+#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
#include <dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.h>
#include <dali-toolkit/internal/visuals/animated-image/animated-image-visual.h>
#include <dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.h>
#include <dali-toolkit/internal/visuals/npatch/npatch-visual.h>
#include <dali-toolkit/internal/visuals/primitive/primitive-visual.h>
#include <dali-toolkit/internal/visuals/svg/svg-visual.h>
-#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
#include <dali-toolkit/internal/visuals/text-visual-shader-factory.h>
#include <dali-toolkit/internal/visuals/text/text-visual.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/public-api/visuals/text-visual-properties.h>
#include <dali-toolkit/public-api/visuals/visual-properties.h>
-
namespace Dali
{
namespace Toolkit
DALI_TYPE_REGISTRATION_END()
const char* const BROKEN_IMAGE_FILE_NAME = "broken.png"; ///< The file name of the broken image.
-static constexpr auto SHADER_TYPE_COUNT = 2u;
-const std::string_view VertexPredefines[SHADER_TYPE_COUNT]
-{
- "", //VisualFactoryCache::COLOR_SHADER
+static constexpr auto SHADER_TYPE_COUNT = 2u;
+const std::string_view VertexPredefines[SHADER_TYPE_COUNT]{
+ "", //VisualFactoryCache::COLOR_SHADER
"#define IS_REQUIRED_ROUNDED_CORNER\n", //VisualFactoryCache::COLOR_SHADER_ROUNDED_CORNER
};
-const std::string_view FragmentPredefines[SHADER_TYPE_COUNT]
-{
- "", //VisualFactoryCache::COLOR_SHADER
+const std::string_view FragmentPredefines[SHADER_TYPE_COUNT]{
+ "", //VisualFactoryCache::COLOR_SHADER
"#define IS_REQUIRED_ROUNDED_CORNER\n", //VisualFactoryCache::COLOR_SHADER_ROUNDED_CORNER
};
mImageVisualShaderFactory(),
mTextVisualShaderFactory(),
mSlotDelegate(this),
+ mIdleCallback(nullptr),
mDebugEnabled(debugEnabled),
mPreMultiplyOnLoad(true)
{
VisualFactory::~VisualFactory()
{
+ if(mIdleCallback && Adaptor::IsAvailable())
+ {
+ // Removes the callback from the callback manager in case the control is destroyed before the callback is executed.
+ Adaptor::Get().RemoveIdle(mIdleCallback);
+ mIdleCallback = nullptr;
+ }
}
void VisualFactory::OnStyleChangedSignal(Toolkit::StyleManager styleManager, StyleChange::Type type)
// Get image shader
std::vector<RawShaderData> rawShaderList;
- RawShaderData imageShaderData;
+ RawShaderData imageShaderData;
GetImageVisualShaderFactory().GetPrecompiledShader(imageShaderData);
rawShaderList.push_back(imageShaderData);
GetPrecompiledShader(colorShaderData);
rawShaderList.push_back(colorShaderData);
-
// Save all shader
Integration::ShaderPrecompiler::Get().SavePrecomipleShaderList(rawShaderList);
}
+void VisualFactory::DiscardVisual(Toolkit::Visual::Base visual)
+{
+ mDiscardedVisuals.emplace_back(visual);
+
+ RegisterDiscardCallback();
+}
+
Internal::TextureManager& VisualFactory::GetTextureManager()
{
return GetFactoryCache().GetTextureManager();
{
std::vector<std::string_view> vertexPrefix;
std::vector<std::string_view> fragmentPrefix;
- int shaderCount = 0;
- shaders.shaderCount = 0;
- for(int i=0; i< SHADER_TYPE_COUNT; ++i)
+ int shaderCount = 0;
+ shaders.shaderCount = 0;
+ for(int i = 0; i < SHADER_TYPE_COUNT; ++i)
{
vertexPrefix.push_back(VertexPredefines[i]);
fragmentPrefix.push_back(FragmentPredefines[i]);
shaderCount++;
}
- shaders.vertexPrefix = vertexPrefix;
+ shaders.vertexPrefix = vertexPrefix;
shaders.fragmentPrefix = fragmentPrefix;
- shaders.vertexShader = SHADER_COLOR_VISUAL_SHADER_VERT;
+ shaders.vertexShader = SHADER_COLOR_VISUAL_SHADER_VERT;
shaders.fragmentShader = SHADER_COLOR_VISUAL_SHADER_FRAG;
- shaders.shaderCount = shaderCount;
+ shaders.shaderCount = shaderCount;
}
Internal::VisualFactoryCache& VisualFactory::GetFactoryCache()
return *mTextVisualShaderFactory;
}
+void VisualFactory::OnDiscardCallback()
+{
+ mIdleCallback = nullptr;
+
+ // Discard visual now.
+ mDiscardedVisuals.clear();
+}
+
+void VisualFactory::RegisterDiscardCallback()
+{
+ if(!mIdleCallback && Adaptor::IsAvailable())
+ {
+ // The callback manager takes the ownership of the callback object.
+ mIdleCallback = MakeCallback(this, &VisualFactory::OnDiscardCallback);
+
+ Adaptor& adaptor = Adaptor::Get();
+
+ if(!adaptor.AddIdle(mIdleCallback, false))
+ {
+ // Fail to add idle. (Maybe adaptor is paused.)
+ mIdleCallback = nullptr;
+ }
+ }
+}
+
} // namespace Internal
} // namespace Toolkit
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/object/base-object.h>
#include <dali/integration-api/shader-precompiler.h>
+#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/public-api/object/base-object.h>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
void UsePreCompiledShader();
/**
+ * @copydoc Toolkit::VisualFactory::DiscardVisual()
+ */
+ void DiscardVisual(Toolkit::Visual::Base visual);
+
+ /**
* @return the reference to texture manager
*/
Internal::TextureManager& GetTextureManager();
*/
TextVisualShaderFactory& GetTextVisualShaderFactory();
+ /**
+ * @brief Callbacks called for clear discarded visuals.
+ */
+ void OnDiscardCallback();
+
+ /**
+ * @brief Register idle callback for discard visuals if need.
+ */
+ void RegisterDiscardCallback();
+
VisualFactory(const VisualFactory&) = delete;
VisualFactory& operator=(const VisualFactory& rhs) = delete;
std::unique_ptr<ImageVisualShaderFactory> mImageVisualShaderFactory;
std::unique_ptr<TextVisualShaderFactory> mTextVisualShaderFactory;
SlotDelegate<VisualFactory> mSlotDelegate;
- bool mDebugEnabled : 1;
- bool mPreMultiplyOnLoad : 1; ///< Local store for this flag
- bool mPrecompiledShaderRequested{false};
+ CallbackBase* mIdleCallback;
+
+ using DiscardedVisualContainer = std::vector<Toolkit::Visual::Base>;
+ DiscardedVisualContainer mDiscardedVisuals{};
+
+ bool mDebugEnabled : 1;
+ bool mPreMultiplyOnLoad : 1; ///< Local store for this flag
+ bool mPrecompiledShaderRequested{false};
};
/**
projects / platform / core / uifw / dali-toolkit.git / commitdiff