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)
{