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.
Change-Id: Ibeab31bc309869aa7c2ee65cbff8789e7bb2a721
Signed-off-by: Eunki, Hong <eunkiki.hong@samsung.com>
void Model::OnModelLoadComplete()
{
+ IntrusivePtr<Model> self = this; // Keep reference until this API finished
+
if(!mModelLoadTask->HasSucceeded())
{
ResetResourceTasks();
Self().SetProperty(Dali::Actor::Property::ANCHOR_POINT, Vector3(mModelPivot.x, 1.0f - mModelPivot.y, mModelPivot.z));
mModelResourceReady = true;
- NotifyResourceReady();
ResetResourceTask(mModelLoadTask);
+ NotifyResourceReady();
}
void Model::OnIblDiffuseLoadComplete()
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
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::OnResourceReady(VectorAnimationTask::ResourceStatus status)
{
+ AnimatedVectorImageVisualPtr self = this; // Keep reference until this API finished
+
if(status == VectorAnimationTask::ResourceStatus::LOADED)
{
if(mImpl->mEventObserver)
void AnimatedVectorImageVisual::OnAnimationFinished()
{
+ 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)
void NPatchData::LoadComplete(bool loadSuccess, TextureInformation textureInformation)
{
+ NPatchDataPtr self = this; // Keep reference until this API finished
+
if(loadSuccess)
{
if(mLoadingState != LoadingState::LOAD_COMPLETE)
// 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 NPatchData : public ConnectionTracker, public Dali::Toolkit::TextureUploadObserver
+class NPatchData;
+typedef IntrusivePtr<NPatchData> NPatchDataPtr;
+
+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.
private:
using ObserverListType = Dali::Vector<TextureUploadObserver*>;
- 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
- VisualUrl mUrl; ///< Url of the N-Patch
- TextureSet mTextureSet; ///< Texture containing the cropped image
- NPatchUtility::StretchRanges mStretchPixelsX; ///< X stretch pixels
- NPatchUtility::StretchRanges mStretchPixelsY; ///< Y stretch pixels
- std::size_t mHash; ///< Hash code for the Url
- uint32_t mCroppedWidth; ///< Width of the cropped middle part of N-patch
- uint32_t mCroppedHeight; ///< Height of the cropped middle part of N-patch
- Rect<int> mBorder; ///< The size of the border
- LoadingState mLoadingState; ///< True if the data loading is completed
- void* mRenderingMap; ///< NPatch rendering data
+ 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
+
+ VisualUrl mUrl; ///< Url of the N-Patch
+ TextureSet mTextureSet; ///< Texture containing the cropped image
+ NPatchUtility::StretchRanges mStretchPixelsX; ///< X stretch pixels
+ NPatchUtility::StretchRanges mStretchPixelsY; ///< Y stretch pixels
+ std::size_t mHash; ///< Hash code for the Url
+ uint32_t mCroppedWidth; ///< Width of the cropped middle part of N-patch
+ uint32_t mCroppedHeight; ///< Height of the cropped middle part of N-patch
+ Rect<int> mBorder; ///< The size of the border
+ LoadingState mLoadingState; ///< True if the data loading is completed
+ void* mRenderingMap; ///< NPatch rendering data
bool mPreMultiplyOnLoad : 1; ///< Whether to multiply alpha into color channels on load
bool mObserverNotifying : 1; ///< Whether this NPatchData notifying observers or not.
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)
}
}
-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>());
+ 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>());
+ 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.
*/
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
+
+ // We don't need to keep tasks anymore. reset now.
+ if(task == mLoadingTask)
+ {
+ mLoadingTask.Reset();
+ }
+ if(task == mRasterizingTask)
+ {
+ mRasterizingTask.Reset();
+ }
+
if(task->HasSucceeded())
{
PixelData rasterizedPixelData = task->GetPixelData();
ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
}
-
- // We don't need to keep tasks anymore. reset now.
- if(task == mLoadingTask)
- {
- mLoadingTask.Reset();
- }
- if(task == mRasterizingTask)
- {
- mRasterizingTask.Reset();
- }
}
void SvgVisual::OnSetTransform()
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)
{
projects / platform / core / uifw / dali-toolkit.git / commitdiff