${internal_src_dir}/update/render-tasks/scene-graph-render-task-list.cpp
${internal_src_dir}/update/rendering/scene-graph-texture-set.cpp
${internal_src_dir}/update/rendering/scene-graph-renderer.cpp
+ ${internal_src_dir}/update/rendering/scene-graph-visual-renderer.cpp
)
SET( SOURCES ${SOURCES}
};
DoubleBuffered()
- : mValue1(NULL),
- mValue2(NULL)
+ : mValue1(nullptr),
+ mValue2(nullptr)
{
}
namespace SceneGraph
{
class PropertyOwner;
+class ResetterManager;
using OwnedPropertyContainer = OwnerContainer<PropertyBase*>;
using OwnedPropertyIter = OwnedPropertyContainer::Iterator;
return true;
}
+ /**
+ * @brief Install custom resetter messages to resetter manager.
+ * @pre ConnectToSceneGraph() Should be called before this API.
+ *
+ * @param[in] manager ResetterManager to add resetter.
+ */
+ virtual void AddInitializeResetter(ResetterManager& manager) const
+ {
+ // Do nothing
+ }
+
protected:
/**
* Protected constructor.
--- /dev/null
+#ifndef DALI_INTERNAL_SCENEGRAPH_RENDERER_RESETTER_H
+#define DALI_INTERNAL_SCENEGRAPH_RENDERER_RESETTER_H
+
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// EXTERNAL INCLDUES
+#include <cstdint> // int8_t
+
+#include <dali/internal/update/animation/property-accessor.h>
+#include <dali/internal/update/animation/property-component-accessor.h>
+#include <dali/internal/update/common/property-owner.h>
+#include <dali/internal/update/rendering/scene-graph-renderer.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace SceneGraph
+{
+/**
+ * Class to reset the renderer's properties to their base values. Used by UpdateManager
+ * to reset the renderer properties after the renderer is created.
+ */
+class RendererResetter : public PropertyOwner::Observer
+{
+public:
+ /**
+ * New method.
+ * @param[in] renderer The renderer
+ * @return the new renderer resetter
+ */
+ static RendererResetter* New(const Renderer& renderer)
+ {
+ return new RendererResetter(const_cast<Renderer*>(&renderer));
+ }
+
+ /**
+ * Virtual Destructor
+ */
+ ~RendererResetter() override
+ {
+ if(mRenderer != nullptr)
+ {
+ mRenderer->RemoveObserver(*this);
+ }
+ }
+
+ /**
+ * Initialize.
+ *
+ * Watches the renderer to track if it's destroyed or not.
+ */
+ void Initialize()
+ {
+ mRenderer->AddObserver(*this);
+ }
+
+ /**
+ * Reset the renderer properties to their base values if the renderer is still alive and on stage
+ * @param[in] updateBufferIndex the current buffer index
+ */
+ void ResetToBaseValue(BufferIndex updateBufferIndex)
+ {
+ if(mRenderer != nullptr && mActive)
+ {
+ // Start aging the renderer properties.
+ // We need to reset the renderer properties for only one frames to ensure
+ // initialized case.
+ --mActive;
+
+ mRenderer->ResetToBaseValues(updateBufferIndex);
+ }
+ };
+
+ /**
+ * Called when the renderer is connected to the scene graph.
+ *
+ * Note, SceneGraph::Renderer don't call this API.
+ *
+ * @param[in] owner The property owner
+ */
+ void PropertyOwnerConnected(PropertyOwner& owner) override
+ {
+ }
+
+ /**
+ * Called when mPropertyOwner is disconnected from the scene graph.
+ *
+ * Note, SceneGraph::Renderer don't call this API.
+ *
+ * @param[in] bufferIndex the current buffer index
+ * @param[in] owner The property owner
+ */
+ void PropertyOwnerDisconnected(BufferIndex bufferIndex, PropertyOwner& owner) override
+ {
+ }
+
+ /**
+ * Called shortly before the propertyOwner is destroyed
+ * @param[in] owner The property owner
+ */
+ void PropertyOwnerDestroyed(PropertyOwner& owner) override
+ {
+ mRenderer = nullptr;
+
+ // Don't need to wait another frame as the properties are being destroyed
+ mActive = STOPPED;
+ }
+
+ /**
+ * Determine if the renderer resetter has finished.
+ *
+ * @return true if the renderer resetter has finished.
+ */
+ virtual bool IsFinished()
+ {
+ return mActive <= STOPPED;
+ }
+
+protected:
+ enum
+ {
+ STOPPED = 0,
+ AGING = 1,
+ ACTIVE = 2,
+ };
+
+ /**
+ * Constructor
+ *
+ * @param[in] renderer The renderer storing the base properties
+ */
+ RendererResetter(Renderer* renderer)
+ : mRenderer(renderer),
+ mActive(AGING) // Since we make this resetter only initialize case now.
+ {
+ mRenderer->MarkAsDirty();
+ }
+
+ Renderer* mRenderer; ///< The renderer that owns the properties
+ int8_t mActive; ///< 2 if active, 1 if aging, 0 if stopped
+};
+
+} // namespace SceneGraph
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif //DALI_INTERNAL_SCENEGRAPH_RENDERER_RESETTER_H
--- /dev/null
+#ifndef DALI_INTERNAL_SCENEGRAPH_RESETTER_MANAGER_H
+#define DALI_INTERNAL_SCENEGRAPH_RESETTER_MANAGER_H
+
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// INTERNAL INCLDUES
+#include <dali/internal/common/owner-pointer.h>
+#include <dali/internal/update/common/property-resetter.h>
+
+namespace Dali::Internal::SceneGraph
+{
+class Node;
+class Renderer;
+
+/**
+ * Abstract interface for passing a Resetter object add.
+ */
+class ResetterManager
+{
+public:
+ /**
+ * Add a property resetter. ResetterManager takes ownership of the object.
+ * It will be killed by ResetterManager when the associated animator or
+ * constraint has finished; or the property owner of the property is destroyed.
+ */
+ virtual void AddPropertyResetter(OwnerPointer<PropertyResetterBase>& propertyResetter) = 0;
+
+ /**
+ * Add a node resetter. ResetterManager takes ownership of the object.
+ * It will be killed by ResetterManager when the node is disconnected from the scene graph;
+ * or when the node is destroyed.
+ */
+ virtual void AddNodeResetter(const Node& node) = 0;
+
+ /**
+ * Add a renderer resetter. ResetterManager takes ownership of the object.
+ * It will be killed by ResetterManager when the renderer is destroyed
+ */
+ virtual void AddRendererResetter(const Renderer& renderer) = 0;
+
+protected:
+ /**
+ * Destructor. Protected as no derived class should ever be deleted
+ * through a reference to this pure abstract interface.
+ */
+ virtual ~ResetterManager() = default;
+};
+
+} // namespace Dali::Internal::SceneGraph
+
+#endif //DALI_INTERNAL_SCENEGRAPH_RESETTER_MANAGER_H
for(uint32_t index = 0; index < renderableCount; ++index, ++renderListIter)
{
*renderListIter = mSortingHelper[index].renderItem;
- DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %x\n", index, mSortingHelper[index].renderItem->mRenderer);
+ DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = node : %x renderer : %x\n", index, mSortingHelper[index].renderItem->mNode, mSortingHelper[index].renderItem->mRenderer.Get());
}
}
// We only use the clipping version of the sort comparitor if any clipping nodes exist within the RenderList.
SortRenderItems(updateBufferIndex, *renderList, layer, hasClippingNodes, isOrthographicCamera);
}
+ else
+ {
+ renderList->SetHasColorRenderItems(true);
+ }
isRenderListAdded = true;
}
// Clipping hierarchy is irrelevant when sorting overlay items, so we specify using the non-clipping version of the sort comparitor.
SortRenderItems(updateBufferIndex, *renderList, layer, false, isOrthographicCamera);
}
+ else
+ {
+ renderList->SetHasColorRenderItems(false);
+ }
isRenderListAdded = true;
}
ResetterContainer<PropertyResetterBase> propertyResetters; ///< A container of property resetters
ResetterContainer<NodeResetter> nodeResetters; ///< A container of node resetters
+ ResetterContainer<RendererResetter> rendererResetters; ///< A container of renderer resetters
OwnerContainer<Animation*> animations; ///< A container of owned animations
OwnerContainer<PropertyNotification*> propertyNotifications; ///< A container of owner property notifications.
rootLayer->CreateTransform(&mImpl->transformManager);
rootLayer->SetRoot(true);
- AddNodeResetter(*rootLayer);
+ rootLayer->AddInitializeResetter(*this);
mImpl->scenes.emplace_back(new Impl::SceneInfo(rootLayer));
}
parent->ConnectChild(node);
- AddNodeResetter(*node);
+ node->AddInitializeResetter(*this);
// Inform the frame-callback-processor, if set, about the node-hierarchy changing
if(mImpl->frameCallbackProcessor)
void UpdateManager::AddRenderTaskList(OwnerPointer<RenderTaskList>& taskList)
{
RenderTaskList* taskListPointer = taskList.Release();
- taskListPointer->SetRenderMessageDispatcher(&mImpl->renderMessageDispatcher);
+ taskListPointer->Initialize(*this, mImpl->renderMessageDispatcher);
mImpl->scenes.back()->taskList = taskListPointer;
}
mImpl->nodeResetters.PushBack(nodeResetter.Release());
}
+void UpdateManager::AddRendererResetter(const Renderer& renderer)
+{
+ OwnerPointer<SceneGraph::RendererResetter> rendererResetter = SceneGraph::RendererResetter::New(renderer);
+ rendererResetter->Initialize();
+ mImpl->rendererResetters.PushBack(rendererResetter.Release());
+}
+
void UpdateManager::AddPropertyNotification(OwnerPointer<PropertyNotification>& propertyNotification)
{
mImpl->propertyNotifications.PushBack(propertyNotification.Release());
DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] AddRenderer\n", renderer);
renderer->ConnectToSceneGraph(*mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex());
+ renderer->AddInitializeResetter(*this);
+
mImpl->renderers.PushBack(rendererKey);
}
// Reset node properties
mImpl->nodeResetters.ResetToBaseValues(bufferIndex);
+ // Reset renderer properties
+ mImpl->rendererResetters.ResetToBaseValues(bufferIndex);
+
// Reset all animating / constrained properties
mImpl->propertyResetters.ResetToBaseValues(bufferIndex);
#include <dali/internal/update/animation/scene-graph-animation.h>
#include <dali/internal/update/common/node-resetter.h>
#include <dali/internal/update/common/property-resetter.h>
+#include <dali/internal/update/common/renderer-resetter.h>
+#include <dali/internal/update/common/resetter-manager.h>
#include <dali/internal/update/common/scene-graph-buffers.h>
#include <dali/internal/update/common/scene-graph-property-notification.h>
#include <dali/internal/update/common/scene-graph-scene.h>
* It also maintains the lifecycle of nodes and other property owners that are
* disconnected from the scene graph.
*/
-class UpdateManager : public ShaderSaver
+class UpdateManager : public ShaderSaver, public ResetterManager
{
public:
/**
*/
bool IsAnimationRunning() const;
+ // ResetterManager
+
+ /**
+ * @copydoc Dali::Internal::SceneGraph::ResetterManager::AddPropertyResetter()
+ */
+ void AddPropertyResetter(OwnerPointer<PropertyResetterBase>& propertyResetter) override;
+
/**
- * Add a property resetter. UpdateManager takes ownership of the object.
- * It will be killed by UpdateManager when the associated animator or
- * constraint has finished; or the property owner of the property is destroyed.
+ * @copydoc Dali::Internal::SceneGraph::ResetterManager::AddNodeResetter()
*/
- void AddPropertyResetter(OwnerPointer<PropertyResetterBase>& propertyResetter);
+ void AddNodeResetter(const Node& node) override;
/**
- * Add a node resetter. UpdateManager takes ownership of the object.
- * It will be killed by UpdateManager when the node is disconnected from the scene graph;
- * or when the node is destroyed.
+ * @copydoc Dali::Internal::SceneGraph::ResetterManager::AddRendererResetter()
*/
- void AddNodeResetter(const Node& node);
+ void AddRendererResetter(const Renderer& renderer) override;
// Property Notification
#include <dali/public-api/common/constants.h>
#include <dali/public-api/common/dali-common.h>
+#include <dali/internal/update/common/resetter-manager.h> ///< For AddInitializeResetter
+
namespace
{
// Memory pool used to allocate new nodes. Memory used by this pool will be released when process dies
return mIsConnectedToSceneGraph;
}
+void Node::AddInitializeResetter(ResetterManager& manager) const
+{
+ manager.AddNodeResetter(*this);
+}
+
void Node::ConnectChild(Node* childNode)
{
DALI_ASSERT_ALWAYS(this != childNode);
class Layer;
class RenderTask;
class UpdateManager;
+class ResetterManager;
class Node;
// Flags which require the scene renderable lists to be updated
bool IsAnimationPossible() const override;
/**
+ * @copydoc Dali::Internal::SceneGraph::PropertyOwner::AddInitializeResetter
+ */
+ void AddInitializeResetter(ResetterManager& manager) const override;
+
+ /**
* Called by UpdateManager when the node is added.
* Creates a new transform component in the transform manager and initialize all the properties
* related to the transformation
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/math/math-utils.h>
+#include <dali/internal/update/common/property-resetter.h>
+#include <dali/internal/update/common/resetter-manager.h> ///< For AddInitializeResetter
+
namespace // unnamed namespace
{
const uint32_t UPDATE_COUNT = 2u; // Update projection or view matrix this many frames after a change
!mAspectRatio.IsClean();
}
+void Camera::AddInitializeResetter(ResetterManager& manager) const
+{
+ // Call base class initialize resetter
+ Node::AddInitializeResetter(manager);
+
+ OwnerPointer<SceneGraph::PropertyResetterBase> resetterFieldOvView = SceneGraph::BakerResetter::New(*this, mFieldOfView, SceneGraph::BakerResetter::Lifetime::BAKE);
+ OwnerPointer<SceneGraph::PropertyResetterBase> resetterOrthographicSize = SceneGraph::BakerResetter::New(*this, mOrthographicSize, SceneGraph::BakerResetter::Lifetime::BAKE);
+ OwnerPointer<SceneGraph::PropertyResetterBase> resetterAspectRatio = SceneGraph::BakerResetter::New(*this, mAspectRatio, SceneGraph::BakerResetter::Lifetime::BAKE);
+ manager.AddPropertyResetter(resetterFieldOvView);
+ manager.AddPropertyResetter(resetterOrthographicSize);
+ manager.AddPropertyResetter(resetterAspectRatio);
+}
+
uint32_t Camera::UpdateViewMatrix(BufferIndex updateBufferIndex)
{
uint32_t retval(mUpdateViewFlag);
*/
bool IsProjectionMatrixAnimated() const;
+public:
+ /**
+ * @copydoc Dali::Internal::SceneGraph::PropertyOwner::AddInitializeResetter
+ */
+ void AddInitializeResetter(ResetterManager& manager) const override;
+
private:
/**
* Constructor
// INTERNAL INCLUDES
#include <dali/internal/common/memory-pool-object-allocator.h>
+#include <dali/internal/update/common/resetter-manager.h> ///< For AddInitializeResetter
namespace //Unnamed namespace
{
GetRenderTaskListMemoryPool().FreeThreadSafe(static_cast<RenderTaskList*>(ptr));
}
-void RenderTaskList::SetRenderMessageDispatcher(RenderMessageDispatcher* renderMessageDispatcher)
+void RenderTaskList::Initialize(ResetterManager& resetterManager, RenderMessageDispatcher& renderMessageDispatcher)
{
- mRenderMessageDispatcher = renderMessageDispatcher;
+ mResetterManager = &resetterManager;
+ mRenderMessageDispatcher = &renderMessageDispatcher;
}
void RenderTaskList::AddTask(OwnerPointer<RenderTask>& newTask)
DALI_ASSERT_DEBUG(newTask && "SceneGraph RenderTask is null");
DALI_ASSERT_DEBUG(mRenderMessageDispatcher != NULL && "RenderMessageDispatcher is null");
- newTask->Initialize(*mRenderMessageDispatcher);
+ newTask->Initialize(*mResetterManager, *mRenderMessageDispatcher);
if(mOverlayRenderTask && mRenderTasks[mRenderTasks.Size() - 1] == mOverlayRenderTask)
{
#define DALI_INTERNAL_SCENE_GRAPH_RENDER_TASK_LIST_H
/*
- * 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.
{
class RenderMessageDispatcher;
class RenderTask;
+class ResetterManager;
/**
* An ordered list of render-tasks.
void operator delete(void* ptr);
/**
- * Set the renderMessageDispatcher to send message.
+ * Set the resetterManager and renderMessageDispatcher to send message.
+ * @param[in] resetterManager to send resetter
* @param[in] renderMessageDispatcher The renderMessageDispatcher to send messages.
*/
- void SetRenderMessageDispatcher(RenderMessageDispatcher* renderMessageDispatcher);
+ void Initialize(ResetterManager& resetterManager, RenderMessageDispatcher& renderMessageDispatcher);
/**
* Add a new RenderTask to the list.
private:
CompleteNotificationInterface* mNotificationObject; ///< object to pass in to the complete notification
+ ResetterManager* mResetterManager; ///< for sending bake resetter if rendertask initalized
RenderMessageDispatcher* mRenderMessageDispatcher; ///< for sending messages to render thread
RenderTaskContainer mRenderTasks; ///< A container of owned RenderTasks
RenderTask* mOverlayRenderTask; ///< OverlayRenderTask.
#include <dali/internal/update/nodes/node.h>
#include <dali/public-api/math/matrix.h>
+#include <dali/internal/update/common/property-resetter.h>
+#include <dali/internal/update/common/resetter-manager.h> ///< For AddInitializeResetter
+
#include <dali/internal/update/render-tasks/scene-graph-render-task-debug.h>
namespace Dali
}
}
-void RenderTask::Initialize(RenderMessageDispatcher& renderMessageDispatcher)
+void RenderTask::Initialize(ResetterManager& resetterManager, RenderMessageDispatcher& renderMessageDispatcher)
{
+ mResetterManager = &resetterManager;
mRenderMessageDispatcher = &renderMessageDispatcher;
}
}
}
+void RenderTask::AddInitializeResetter(ResetterManager& manager) const
+{
+ OwnerPointer<SceneGraph::PropertyResetterBase> resetterViewportPosition = SceneGraph::BakerResetter::New(*this, mViewportPosition, SceneGraph::BakerResetter::Lifetime::BAKE);
+ OwnerPointer<SceneGraph::PropertyResetterBase> resetterViewportSize = SceneGraph::BakerResetter::New(*this, mViewportSize, SceneGraph::BakerResetter::Lifetime::BAKE);
+ OwnerPointer<SceneGraph::PropertyResetterBase> resetterClearColor = SceneGraph::BakerResetter::New(*this, mClearColor, SceneGraph::BakerResetter::Lifetime::BAKE);
+ manager.AddPropertyResetter(resetterViewportPosition);
+ manager.AddPropertyResetter(resetterViewportSize);
+ manager.AddPropertyResetter(resetterClearColor);
+}
+
RenderTask::RenderTask()
: mViewportPosition(Vector2::ZERO),
mViewportSize(Vector2::ZERO),
mClearColor(Dali::RenderTask::DEFAULT_CLEAR_COLOR),
+ mResetterManager(nullptr),
mRenderMessageDispatcher(nullptr),
mRenderSyncTracker(nullptr),
mSourceNode(nullptr),
void RenderTask::SetActiveStatus()
{
+ bool oldActive = mActive;
+
// must have a source and camera both connected to scene
mActive = (mSourceNode && mSourceNode->ConnectedToScene() &&
mCameraNode && mCameraNode->ConnectedToScene() && mCamera);
TASK_LOG_FMT(Debug::General, " Source node(%x) active %d. Frame counter: %d\n", mSourceNode, mSourceNode && mSourceNode->ConnectedToScene(), mFrameCounter);
TASK_LOG_FMT(Debug::General, " Camera node(%x) active %d\n", mCameraNode, mCameraNode && mCameraNode->ConnectedToScene());
+
+ if(!oldActive && mActive)
+ {
+ // Send resetter only if newly activated
+ AddInitializeResetter(*mResetterManager);
+ }
}
} // namespace SceneGraph
class Camera;
class RenderInstruction;
class RenderMessageDispatcher;
+class ResetterManager;
/**
* RenderTasks describe how the Dali scene should be rendered.
/**
* Initialize the render task. Called in update thread
+ * @param[in] resetterManager to send resetter
* @param[in] renderMessageDispatcher to send messages to render thread
*/
- void Initialize(RenderMessageDispatcher& renderMessageDispatcher);
+ void Initialize(ResetterManager& resetterManager, RenderMessageDispatcher& renderMessageDispatcher);
/**
* Set the nodes to be rendered.
*/
void PropertyOwnerDestroyed(PropertyOwner& owner) override;
+public:
+ /**
+ * @copydoc Dali::Internal::SceneGraph::PropertyOwner::AddInitializeResetter
+ */
+ void AddInitializeResetter(ResetterManager& manager) const override;
+
private:
void SetActiveStatus();
AnimatableProperty<Vector4> mClearColor; ///< clearColor
private:
+ ResetterManager* mResetterManager;
RenderMessageDispatcher* mRenderMessageDispatcher;
Render::RenderTracker* mRenderSyncTracker;
Node* mSourceNode;
*/
// CLASS HEADER
-#include "scene-graph-renderer.h"
+#include <dali/internal/update/rendering/scene-graph-renderer.h>
// INTERNAL INCLUDES
#include <dali/internal/common/blending-options.h>
#include <dali/internal/update/nodes/node.h>
#include <dali/internal/update/rendering/scene-graph-texture-set.h>
+#include <dali/internal/update/common/property-resetter.h>
+#include <dali/internal/update/common/resetter-manager.h> ///< For AddInitializeResetter
+
#include <dali/integration-api/debug.h>
namespace Dali
SetUpdated(false);
}
+void Renderer::ResetToBaseValues(BufferIndex updateBufferIndex)
+{
+ mOpacity.ResetToBaseValue(updateBufferIndex);
+ if(mVisualProperties)
+ {
+ mVisualProperties->ResetToBaseValues(updateBufferIndex);
+ }
+}
+
+void Renderer::MarkAsDirty()
+{
+ mOpacity.MarkAsDirty();
+ if(mVisualProperties)
+ {
+ mVisualProperties->MarkAsDirty();
+ }
+}
+
uint32_t Renderer::GetMemoryPoolCapacity()
{
return GetRendererMemoryPool().GetCapacity();
mRegenerateUniformMap = true; // Should remain true until this renderer is added to a RenderList.
}
+void Renderer::AddInitializeResetter(ResetterManager& manager) const
+{
+ manager.AddRendererResetter(*this);
+}
+
const CollectedUniformMap& Renderer::GetCollectedUniformMap() const
{
return mCollectedUniformMap;
void ResetDirtyFlag();
/**
+ * @brief Reset to base values of all animatable properties.
+ *
+ * @param[in] updateBufferIndex the current buffer index
+ */
+ void ResetToBaseValues(BufferIndex updateBufferIndex);
+
+ /**
+ * @brief Mark all animatable properties as dirty.
+ */
+ void MarkAsDirty();
+
+ /**
* Get the capacity of the memory pools
* @return the capacity of the memory pools
*/
*/
virtual void ResetDefaultProperties(BufferIndex updateBufferIndex){};
+ /**
+ * @copydoc Dali::Internal::SceneGraph::PropertyOwner::AddInitializeResetter
+ */
+ void AddInitializeResetter(ResetterManager& manager) const override;
+
public: // From UniformMapDataProvider
/**
* @copydoc UniformMapDataProvider::GetCollectedUniformMap
--- /dev/null
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// CLASS HEADER
+#include <dali/internal/update/rendering/scene-graph-visual-renderer.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/update/common/property-resetter.h>
+#include <dali/internal/update/rendering/scene-graph-renderer.h>
+
+namespace Dali::Internal::SceneGraph::VisualRenderer
+{
+void AnimatableVisualProperties::ResetToBaseValues(BufferIndex updateBufferIndex)
+{
+ mTransformOffset.ResetToBaseValue(updateBufferIndex);
+ mTransformSize.ResetToBaseValue(updateBufferIndex);
+ mTransformOrigin.ResetToBaseValue(updateBufferIndex);
+ mTransformAnchorPoint.ResetToBaseValue(updateBufferIndex);
+ mTransformOffsetSizeMode.ResetToBaseValue(updateBufferIndex);
+ mExtraSize.ResetToBaseValue(updateBufferIndex);
+ mMixColor.ResetToBaseValue(updateBufferIndex);
+ mPreMultipliedAlpha.ResetToBaseValue(updateBufferIndex);
+ if(mExtendedProperties)
+ {
+ auto* decoratedVisualProperties = static_cast<VisualRenderer::AnimatableDecoratedVisualProperties*>(mExtendedProperties);
+ decoratedVisualProperties->ResetToBaseValues(updateBufferIndex);
+ }
+}
+
+void AnimatableVisualProperties::MarkAsDirty()
+{
+ mTransformOffset.MarkAsDirty();
+ mTransformSize.MarkAsDirty();
+ mTransformOrigin.MarkAsDirty();
+ mTransformAnchorPoint.MarkAsDirty();
+ mTransformOffsetSizeMode.MarkAsDirty();
+ mExtraSize.MarkAsDirty();
+ mMixColor.MarkAsDirty();
+ mPreMultipliedAlpha.MarkAsDirty();
+ if(mExtendedProperties)
+ {
+ auto* decoratedVisualProperties = static_cast<VisualRenderer::AnimatableDecoratedVisualProperties*>(mExtendedProperties);
+ decoratedVisualProperties->MarkAsDirty();
+ }
+}
+
+void AnimatableDecoratedVisualProperties::ResetToBaseValues(BufferIndex updateBufferIndex)
+{
+ mCornerRadius.ResetToBaseValue(updateBufferIndex);
+ mCornerRadiusPolicy.ResetToBaseValue(updateBufferIndex);
+ mBorderlineWidth.ResetToBaseValue(updateBufferIndex);
+ mBorderlineColor.ResetToBaseValue(updateBufferIndex);
+ mBorderlineOffset.ResetToBaseValue(updateBufferIndex);
+ mBlurRadius.ResetToBaseValue(updateBufferIndex);
+}
+
+void AnimatableDecoratedVisualProperties::MarkAsDirty()
+{
+ mCornerRadius.MarkAsDirty();
+ mCornerRadiusPolicy.MarkAsDirty();
+ mBorderlineWidth.MarkAsDirty();
+ mBorderlineColor.MarkAsDirty();
+ mBorderlineOffset.MarkAsDirty();
+ mBlurRadius.MarkAsDirty();
+}
+
+} // namespace Dali::Internal::SceneGraph::VisualRenderer
\ No newline at end of file
}
}
+public: // Public API
+ /**
+ * @copydoc Dali::Internal::SceneGraph::Renderer::ResetToBaseValues
+ */
+ void ResetToBaseValues(BufferIndex updateBufferIndex);
+
+ /**
+ * @copydoc Dali::Internal::SceneGraph::Renderer::MarkAsDirty
+ */
+ void MarkAsDirty();
+
+public:
/**
* @brief Cached coefficient value when we calculate visual transformed update size.
* It can reduce complexity of calculate the vertex position.
{
}
+public: // Public API
// Delete function of AnimatableDecoratedVisualProperties* converted as void*
static void DeleteFunction(void* data)
{
}
/**
+ * @copydoc Dali::Internal::SceneGraph::Renderer::ResetToBaseValues
+ */
+ void ResetToBaseValues(BufferIndex updateBufferIndex);
+
+ /**
+ * @copydoc Dali::Internal::SceneGraph::Renderer::MarkAsDirty
+ */
+ void MarkAsDirty();
+
+public:
+ /**
* @brief Cached coefficient value when we calculate visual transformed update size.
* It can reduce complexity of calculate the vertex position.
*
projects / platform / core / uifw / dali-core.git / commitdiff