From: David Steele Date: Thu, 16 Mar 2023 17:47:29 +0000 (+0000) Subject: Merge "Add BuildPickingRay to devel api" into devel/master X-Git-Tag: dali_2.2.18~1 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-core.git;a=commitdiff_plain;h=c4750afbf79f15bf71e2aa8ef54f84750463aae2;hp=321f65b9d42abf0c7c69b32105c7d7239116b68b Merge "Add BuildPickingRay to devel api" into devel/master --- diff --git a/automated-tests/src/dali-internal/utc-Dali-Internal-PipelineCache.cpp b/automated-tests/src/dali-internal/utc-Dali-Internal-PipelineCache.cpp index 4f3bb13..9783618 100644 --- a/automated-tests/src/dali-internal/utc-Dali-Internal-PipelineCache.cpp +++ b/automated-tests/src/dali-internal/utc-Dali-Internal-PipelineCache.cpp @@ -1,5 +1,5 @@ /* - * 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. @@ -27,28 +27,26 @@ using namespace Dali; - - template -void InvokeNext(Object *obj, Args... args) +void InvokeNext(Object* obj, Args... args) { - auto addr = __builtin_return_address(0); + auto addr = __builtin_return_address(0); Dl_info info; dladdr(addr, &info); auto func = dlsym(RTLD_NEXT, info.dli_sname); - typedef void(*FuncPtr)(void*, Args...); + typedef void (*FuncPtr)(void*, Args...); auto memb = FuncPtr(func); memb(obj, args...); } template -Ret InvokeReturnNext(Object *obj, Args... args) +Ret InvokeReturnNext(Object* obj, Args... args) { - auto addr = __builtin_return_address(0); + auto addr = __builtin_return_address(0); Dl_info info; dladdr(addr, &info); auto func = dlsym(RTLD_NEXT, info.dli_sname); - typedef Ret(*FuncPtr)(void*, Args...); + typedef Ret (*FuncPtr)(void*, Args...); auto memb = FuncPtr(func); return memb(obj, args...); } @@ -60,18 +58,17 @@ namespace Internal { namespace Render { - // Store internal PipelineCache as singleton PipelineCache::PipelineCache(Dali::Graphics::Controller& controller) { gPipelineCache = this; - InvokeNext( this, &controller ); + InvokeNext(this, &controller); } -} -} -} +} // namespace Render +} // namespace Internal +} // namespace Dali int UtcDaliCorePipelineCacheTest(void) { @@ -82,10 +79,10 @@ int UtcDaliCorePipelineCacheTest(void) // PipelineCache* cache = PipelineCache::GetPipelineCacheWithController( &application.GetGraphicsController() ); // Pipeline cache must be initialized - DALI_TEST_EQUALS( gPipelineCache != 0, true, TEST_LOCATION); + DALI_TEST_EQUALS(gPipelineCache != 0, true, TEST_LOCATION); // Test size of level0 nodes (should be 0, nothing added yet) - DALI_TEST_EQUALS( (gPipelineCache->level0nodes.size() == 0), true, TEST_LOCATION); + DALI_TEST_EQUALS((gPipelineCache->level0nodes.size() == 0), true, TEST_LOCATION); // Create something to render Geometry geometry = CreateQuadGeometry(); @@ -107,11 +104,11 @@ int UtcDaliCorePipelineCacheTest(void) application.Render(); // 1 pipeline should be added - DALI_TEST_EQUALS( (gPipelineCache->level0nodes.size() == 1), true, TEST_LOCATION); + DALI_TEST_EQUALS((gPipelineCache->level0nodes.size() == 1), true, TEST_LOCATION); // Add another actor, new pipeline will be created - Shader shader1 = Shader::New("newVertexSrc", "newFragmentSrc"); - Actor actor1 = Actor::New(); + Shader shader1 = Shader::New("newVertexSrc", "newFragmentSrc"); + Actor actor1 = Actor::New(); Renderer renderer1 = Renderer::New(geometry, shader1); renderer1.SetProperty(Dali::Renderer::Property::BLEND_MODE, Dali::BlendMode::ON); actor1.AddRenderer(renderer1); @@ -121,11 +118,11 @@ int UtcDaliCorePipelineCacheTest(void) application.SendNotification(); application.Render(); - DALI_TEST_EQUALS( (gPipelineCache->level0nodes.size() == 2), true, TEST_LOCATION); + DALI_TEST_EQUALS((gPipelineCache->level0nodes.size() == 2), true, TEST_LOCATION); // Now add 3rd actor reusing first pipeline { - Actor actor2 = Actor::New(); + Actor actor2 = Actor::New(); Renderer renderer2 = Renderer::New(geometry, shader); renderer2.SetProperty(Dali::Renderer::Property::BLEND_MODE, Dali::BlendMode::ON); actor2.AddRenderer(renderer); @@ -136,11 +133,11 @@ int UtcDaliCorePipelineCacheTest(void) application.Render(); // Number of pipelines shouldn't change - DALI_TEST_EQUALS( (gPipelineCache->level0nodes.size() == 2), true, TEST_LOCATION); + DALI_TEST_EQUALS((gPipelineCache->level0nodes.size() == 2), true, TEST_LOCATION); // Test final 'noBlend' path on first pipeline { - Actor actor3 = Actor::New(); + Actor actor3 = Actor::New(); Renderer renderer3 = Renderer::New(geometry, shader); renderer3.SetProperty(Dali::Renderer::Property::BLEND_MODE, Dali::BlendMode::OFF); actor3.AddRenderer(renderer3); @@ -151,7 +148,18 @@ int UtcDaliCorePipelineCacheTest(void) application.Render(); // Test whether noBlend pipeline is set in cache - DALI_TEST_EQUALS( gPipelineCache->level0nodes[0].level1nodes[0].noBlend.pipeline != nullptr, true, TEST_LOCATION); + uint32_t noBlendFoundCount = 0u; + for(auto& iterLevel0 : gPipelineCache->level0nodes) + { + for(auto& iterLevel1 : iterLevel0.level1nodes) + { + if(iterLevel1.noBlend.pipeline != nullptr) + { + noBlendFoundCount++; + } + } + } + DALI_TEST_EQUALS(noBlendFoundCount, 1u, TEST_LOCATION); END_TEST; } \ No newline at end of file diff --git a/automated-tests/src/dali/utc-Dali-Actor.cpp b/automated-tests/src/dali/utc-Dali-Actor.cpp index 4413115..000fbda 100644 --- a/automated-tests/src/dali/utc-Dali-Actor.cpp +++ b/automated-tests/src/dali/utc-Dali-Actor.cpp @@ -8578,6 +8578,83 @@ int utcDaliActorGetSizeAfterAnimation(void) END_TEST; } +int utcDaliActorGetSizeAfterAnimation2(void) +{ + TestApplication application; + tet_infoline("Check the actor size before / after an animation is finished if before size is equal to animation target size"); + + Vector3 actorSize(100.0f, 100.0f, 0.0f); + + Actor actor = Actor::New(); + actor.SetProperty(Actor::Property::SIZE, actorSize); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + // Size should be updated without rendering. + Vector3 size = actor.GetProperty(Actor::Property::SIZE).Get(); + DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION); + + application.SendNotification(); + application.Render(); + + // Size and current size should be updated. + size = actor.GetProperty(Actor::Property::SIZE).Get(); + DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION); + DALI_TEST_EQUALS(actorSize.width, actor.GetProperty(Actor::Property::SIZE_WIDTH), TEST_LOCATION); + DALI_TEST_EQUALS(actorSize.height, actor.GetProperty(Actor::Property::SIZE_HEIGHT), TEST_LOCATION); + DALI_TEST_EQUALS(actorSize.depth, actor.GetProperty(Actor::Property::SIZE_DEPTH), TEST_LOCATION); + + Vector3 currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get(); + DALI_TEST_EQUALS(currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION); + DALI_TEST_EQUALS(actorSize.width, actor.GetCurrentProperty(Actor::Property::SIZE_WIDTH), TEST_LOCATION); + DALI_TEST_EQUALS(actorSize.height, actor.GetCurrentProperty(Actor::Property::SIZE_HEIGHT), TEST_LOCATION); + DALI_TEST_EQUALS(actorSize.depth, actor.GetCurrentProperty(Actor::Property::SIZE_DEPTH), TEST_LOCATION); + + // Set size again + actorSize = Vector3(200.0f, 200.0f, 0.0f); + actor.SetProperty(Actor::Property::SIZE, actorSize); + + size = actor.GetProperty(Actor::Property::SIZE).Get(); + DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION); + + Vector3 targetValue(actorSize); + + Animation animation = Animation::New(1.0f); + animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetValue); + animation.Play(); + + // Size should be updated without rendering. + size = actor.GetProperty(Actor::Property::SIZE).Get(); + DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION); + + application.SendNotification(); + application.Render(100); // During the animation + + size = actor.GetProperty(Actor::Property::SIZE).Get(); + DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION); + DALI_TEST_EQUALS(targetValue.width, actor.GetProperty(Actor::Property::SIZE_WIDTH), TEST_LOCATION); + DALI_TEST_EQUALS(targetValue.height, actor.GetProperty(Actor::Property::SIZE_HEIGHT), TEST_LOCATION); + DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty(Actor::Property::SIZE_DEPTH), TEST_LOCATION); + + // We should get target value because targetValue is equal to current actor size. + currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get(); + DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION); + DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty(Actor::Property::SIZE_WIDTH), TEST_LOCATION); + DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty(Actor::Property::SIZE_HEIGHT), TEST_LOCATION); + DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty(Actor::Property::SIZE_DEPTH), TEST_LOCATION); + + application.SendNotification(); + application.Render(1000); // After animation finished + + size = actor.GetProperty(Actor::Property::SIZE).Get(); + DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION); + + currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get(); + DALI_TEST_EQUALS(currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION); + + END_TEST; +} + int utcDaliActorRelayoutAndAnimation(void) { TestApplication application; diff --git a/automated-tests/src/dali/utc-Dali-Extents.cpp b/automated-tests/src/dali/utc-Dali-Extents.cpp index 435dfd5..f4e09b0 100644 --- a/automated-tests/src/dali/utc-Dali-Extents.cpp +++ b/automated-tests/src/dali/utc-Dali-Extents.cpp @@ -112,6 +112,37 @@ int UtcDaliExtentsCopyAssignment(void) END_TEST; } +int UtcDaliExtentsMoveConstructor(void) +{ + TestApplication application; + + Extents extent(10u, 20u, 400u, 200u); + + Extents extent2(std::move(extent)); + + DALI_TEST_EQUALS(extent2.start, 10u, TEST_LOCATION); + DALI_TEST_EQUALS(extent2.end, 20u, TEST_LOCATION); + DALI_TEST_EQUALS(extent2.top, 400u, TEST_LOCATION); + DALI_TEST_EQUALS(extent2.bottom, 200u, TEST_LOCATION); + END_TEST; +} + +int UtcDaliExtentsMoveAssignment(void) +{ + TestApplication application; + + Extents extent; + + Extents extent2(10u, 20u, 400u, 200u); + extent = std::move(extent2); + + DALI_TEST_EQUALS(extent.start, 10u, TEST_LOCATION); + DALI_TEST_EQUALS(extent.end, 20u, TEST_LOCATION); + DALI_TEST_EQUALS(extent.top, 400u, TEST_LOCATION); + DALI_TEST_EQUALS(extent.bottom, 200u, TEST_LOCATION); + END_TEST; +} + int UtcDaliExtentsAssignP(void) { Extents extent; diff --git a/automated-tests/src/dali/utc-Dali-Matrix.cpp b/automated-tests/src/dali/utc-Dali-Matrix.cpp index f72dd93..da8e265 100644 --- a/automated-tests/src/dali/utc-Dali-Matrix.cpp +++ b/automated-tests/src/dali/utc-Dali-Matrix.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Samsung Electronics Co., Ltd. + * Copyright (c) 2023 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -405,6 +405,38 @@ int UtcDaliMatrixGetTranslation3P(void) END_TEST; } +int UtcDaliMatrixGetScale(void) +{ + // Create an arbitrary vector + for(float x = 0.0f; x <= 2.0f; x += 0.1f) + { + for(float y = 0.0f; y < 2.0f; y += 0.1f) + { + for(float z = 0.0f; z < 2.0f; z += 0.1f) + { + Vector3 vScale(x, y, z); + + for(float angle = 5.0f; angle <= 360.0f; angle += 15.0f) + { + Vector3 forward(1.0f, 1.3f, 2.0f); + forward.Normalize(); + + Quaternion rotation1(Radian(Degree(angle)), forward); + Vector3 position1(1.0f, 2.0f, 3.0f); + + Matrix m1(false); + m1.SetTransformComponents(vScale, rotation1, position1); + + Vector3 scale2 = m1.GetScale(); + + DALI_TEST_EQUALS(vScale, scale2, 0.001, TEST_LOCATION); + } + } + } + } + END_TEST; +} + int UtcDaliMatrixSetTranslationP(void) { Matrix m; diff --git a/automated-tests/src/dali/utc-Dali-Renderer.cpp b/automated-tests/src/dali/utc-Dali-Renderer.cpp index 67fa251..763fa67 100644 --- a/automated-tests/src/dali/utc-Dali-Renderer.cpp +++ b/automated-tests/src/dali/utc-Dali-Renderer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Samsung Electronics Co., Ltd. + * Copyright (c) 2023 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/dali/integration-api/scene.cpp b/dali/integration-api/scene.cpp index a836ad8..d84c422 100644 --- a/dali/integration-api/scene.cpp +++ b/dali/integration-api/scene.cpp @@ -49,9 +49,9 @@ Scene::Scene(const Scene& handle) = default; Scene& Scene::operator=(const Scene& rhs) = default; -Scene::Scene(Scene&& handle) = default; +Scene::Scene(Scene&& handle) noexcept = default; -Scene& Scene::operator=(Scene&& rhs) = default; +Scene& Scene::operator=(Scene&& rhs) noexcept = default; Scene::Scene(Internal::Scene* internal) : BaseHandle(internal) diff --git a/dali/integration-api/scene.h b/dali/integration-api/scene.h index a54b0dd..75d4939 100644 --- a/dali/integration-api/scene.h +++ b/dali/integration-api/scene.h @@ -126,7 +126,7 @@ public: * * @param [in] handle A reference to the moved handle */ - Scene(Scene&& handle); + Scene(Scene&& handle) noexcept; /** * @brief This move assignment operator is required for (smart) pointer semantics. @@ -134,7 +134,7 @@ public: * @param [in] rhs A reference to the moved handle * @return A reference to this */ - Scene& operator=(Scene&& rhs); + Scene& operator=(Scene&& rhs) noexcept; /** * @brief Adds a child Actor to the Scene. diff --git a/dali/internal/common/ordered-set.h b/dali/internal/common/ordered-set.h index 9f86dae..7c76310 100644 --- a/dali/internal/common/ordered-set.h +++ b/dali/internal/common/ordered-set.h @@ -66,7 +66,7 @@ public: /** * @brief Move construct */ - OrderedSet(OrderedSet&& rhs) + OrderedSet(OrderedSet&& rhs) noexcept : mMap(std::move(rhs.mMap)), mList(std::move(rhs.mList)) { @@ -78,7 +78,7 @@ public: /** * @brief Move assign */ - OrderedSet& operator=(OrderedSet&& rhs) + OrderedSet& operator=(OrderedSet&& rhs) noexcept { Clear(); mMap = std::move(rhs.mMap); diff --git a/dali/internal/event/actors/actor-sizer.cpp b/dali/internal/event/actors/actor-sizer.cpp index d3bbfa4..62c4b34 100644 --- a/dali/internal/event/actors/actor-sizer.cpp +++ b/dali/internal/event/actors/actor-sizer.cpp @@ -685,7 +685,13 @@ float ActorSizer::GetMaximumSize(Dimension::Type dimension) const void ActorSizer::OnAnimateSize(Animation& animation, Vector3 targetSize, bool relative) { + Vector3 originalTargetSize = mTargetSize; mTargetSize = targetSize + mTargetSize * float(relative); + if(originalTargetSize != mTargetSize) + { + mTargetSizeDirtyFlag = true; + } + mAnimatedSize = mTargetSize; mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH; @@ -701,7 +707,12 @@ void ActorSizer::OnAnimateSize(Animation& animation, Vector3 targetSize, bool re void ActorSizer::OnAnimateWidth(Animation& animation, float width, bool relative) { + const float originalWidth = mTargetSize.width; mTargetSize.width = width + float(relative) * mTargetSize.width; + if(!Equals(originalWidth,mTargetSize.width)) + { + mTargetSizeDirtyFlag = true; + } mAnimatedSize.width = mTargetSize.width; mUseAnimatedSize |= AnimatedSizeFlag::WIDTH; @@ -716,7 +727,12 @@ void ActorSizer::OnAnimateWidth(Animation& animation, float width, bool relative void ActorSizer::OnAnimateHeight(Animation& animation, float height, bool relative) { + const float originalHeight = mTargetSize.height; mTargetSize.height = height + float(relative) * mTargetSize.height; + if(!Equals(originalHeight, mTargetSize.height)) + { + mTargetSizeDirtyFlag = true; + } mAnimatedSize.height = mTargetSize.height; mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT; @@ -731,7 +747,12 @@ void ActorSizer::OnAnimateHeight(Animation& animation, float height, bool relati void ActorSizer::OnAnimateDepth(Animation& animation, float depth, bool relative) { + const float originalDepth = mTargetSize.depth; mTargetSize.depth = depth + float(relative) * mTargetSize.depth; + if(!Equals(originalDepth, mTargetSize.depth)) + { + mTargetSizeDirtyFlag = true; + } mAnimatedSize.depth = mTargetSize.depth; mUseAnimatedSize |= AnimatedSizeFlag::DEPTH; diff --git a/dali/internal/event/size-negotiation/relayout-controller-impl.cpp b/dali/internal/event/size-negotiation/relayout-controller-impl.cpp index 93585f6..2d639f5 100644 --- a/dali/internal/event/size-negotiation/relayout-controller-impl.cpp +++ b/dali/internal/event/size-negotiation/relayout-controller-impl.cpp @@ -16,7 +16,7 @@ */ // CLASS HEADER -#include "relayout-controller-impl.h" +#include // EXTERNAL INCLUDES #if defined(DEBUG_ENABLED) @@ -119,6 +119,8 @@ RelayoutController::RelayoutController(Integration::RenderController& controller { // Make space for 32 controls to avoid having to copy construct a lot in the beginning mRelayoutStack->Reserve(32); + mPotentialRedundantSubRoots.reserve(32); + mTopOfSubTreeStack.reserve(32); } RelayoutController::~RelayoutController() = default; @@ -152,8 +154,11 @@ void RelayoutController::RequestRelayout(Dali::Actor& actor, Dimension::Type dim return; } - std::vector potentialRedundantSubRoots; - std::vector topOfSubTreeStack; + std::vector& potentialRedundantSubRoots = mPotentialRedundantSubRoots; + std::vector& topOfSubTreeStack = mTopOfSubTreeStack; + + DALI_ASSERT_ALWAYS(potentialRedundantSubRoots.empty() && "potentialRedundantSubRoots must be empty before RequestRelayout!"); + DALI_ASSERT_ALWAYS(topOfSubTreeStack.empty() && "topOfSubTreeStack must be empty before RequestRelayout!"); topOfSubTreeStack.push_back(actor); @@ -194,6 +199,8 @@ void RelayoutController::RequestRelayout(Dali::Actor& actor, Dimension::Type dim RemoveRequest(subRoot); } + potentialRedundantSubRoots.clear(); + if(!mProcessingCoreEvents) { mRenderController.RequestProcessEventsOnIdle(false); diff --git a/dali/internal/event/size-negotiation/relayout-controller-impl.h b/dali/internal/event/size-negotiation/relayout-controller-impl.h index e524406..91ffd97 100644 --- a/dali/internal/event/size-negotiation/relayout-controller-impl.h +++ b/dali/internal/event/size-negotiation/relayout-controller-impl.h @@ -206,6 +206,9 @@ private: std::unique_ptr mRelayoutStack; ///< Stack for relayouting + std::vector mPotentialRedundantSubRoots; ///< Stack of Actor when RequestLayout comes. Keep it as member to avoid vector size reserving. + std::vector mTopOfSubTreeStack; + bool mRelayoutConnection : 1; ///< Whether EventProcessingFinishedSignal signal is connected. bool mRelayoutFlag : 1; ///< Relayout flag to avoid unnecessary calls bool mEnabled : 1; ///< Initially disabled. Must be enabled at some point. diff --git a/dali/internal/render/common/render-algorithms.cpp b/dali/internal/render/common/render-algorithms.cpp index 152798d..13dfcc4 100644 --- a/dali/internal/render/common/render-algorithms.cpp +++ b/dali/internal/render/common/render-algorithms.cpp @@ -643,6 +643,9 @@ inline void RenderAlgorithms::ProcessRenderList(const RenderList& mHasLayerScissor = true; } + // Prepare Render::Renderer Render for this secondary command buffer. + Renderer::PrepareCommandBuffer(); + // Loop through all RenderItems in the RenderList, set up any prerequisites to render them, then perform the render. for(uint32_t index = 0u; index < count; ++index) { diff --git a/dali/internal/render/common/render-manager.cpp b/dali/internal/render/common/render-manager.cpp index b72ec9b..4f8e236 100644 --- a/dali/internal/render/common/render-manager.cpp +++ b/dali/internal/render/common/render-manager.cpp @@ -449,6 +449,9 @@ void RenderManager::PreRender(Integration::RenderStatus& status, bool forceClear } } + // Clean latest used pipeline + mImpl->pipelineCache->CleanLatestUsedCache(); + mImpl->commandBufferSubmitted = false; } diff --git a/dali/internal/render/renderers/pipeline-cache.cpp b/dali/internal/render/renderers/pipeline-cache.cpp index aefbe32..3f655f4 100644 --- a/dali/internal/render/renderers/pipeline-cache.cpp +++ b/dali/internal/render/renderers/pipeline-cache.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Samsung Electronics Co., Ltd. + * Copyright (c) 2023 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -190,10 +190,10 @@ constexpr Graphics::BlendOp ConvertBlendEquation(DevelBlendEquation::Type blendE } } // namespace -PipelineCacheL0* PipelineCache::GetPipelineCacheL0(Program* program, Render::Geometry* geometry) +PipelineCacheL0* PipelineCache::GetPipelineCacheL0(std::size_t hash, Program* program, Render::Geometry* geometry) { - auto it = std::find_if(level0nodes.begin(), level0nodes.end(), [program, geometry](PipelineCacheL0& item) { - return ((item.program == program && item.geometry == geometry)); + auto it = std::find_if(level0nodes.begin(), level0nodes.end(), [hash, program, geometry](PipelineCacheL0& item) { + return ((item.hash == hash && item.program == program && item.geometry == geometry)); }); // Add new node to cache @@ -237,6 +237,7 @@ PipelineCacheL0* PipelineCache::GetPipelineCacheL0(Program* program, Render::Geo ++bindingIndex; } PipelineCacheL0 level0; + level0.hash = hash; level0.program = program; level0.geometry = geometry; level0.inputState = vertexInputState; @@ -403,14 +404,59 @@ PipelineCacheL2* PipelineCacheL1::GetPipelineCacheL2(bool blend, bool premul, Bl return retval; } +void PipelineCacheQueryInfo::GenerateHash() +{ + // Lightweight hash value generation. + hash = (reinterpret_cast(program) >> Dali::Log::value) ^ + (reinterpret_cast(geometry) >> Dali::Log::value) ^ + ((blendingEnabled ? 1u : 0u) << 0u) ^ + ((alphaPremultiplied ? 1u : 0u) << 1u) ^ + (static_cast(geometry->GetTopology()) << 2u) ^ + (static_cast(renderer->GetFaceCullMode()) << 5u) ^ + ((cameraUsingReflection ? 1u : 0u) << 8u) ^ + (blendingEnabled ? static_cast(blendingOptions->GetBitmask()) : 0xDA11u); +} + +bool PipelineCacheQueryInfo::Equal(const PipelineCacheQueryInfo& lhs, const PipelineCacheQueryInfo& rhs) noexcept +{ + // Naive equal check. + const bool ret = (lhs.hash == rhs.hash) && // Check hash value first + (lhs.program == rhs.program) && + (lhs.geometry == rhs.geometry) && + (lhs.blendingEnabled == rhs.blendingEnabled) && + (lhs.alphaPremultiplied == rhs.alphaPremultiplied) && + (lhs.geometry->GetTopology() == rhs.geometry->GetTopology()) && + (lhs.renderer->GetFaceCullMode() == rhs.renderer->GetFaceCullMode()) && + (lhs.cameraUsingReflection == rhs.cameraUsingReflection) && + (!lhs.blendingEnabled || + (lhs.blendingOptions->GetBitmask() == rhs.blendingOptions->GetBitmask() && + ((lhs.blendingOptions->GetBlendColor() == nullptr && rhs.blendingOptions->GetBlendColor() == nullptr) || + (lhs.blendingOptions->GetBlendColor() && + rhs.blendingOptions->GetBlendColor() && + (*lhs.blendingOptions->GetBlendColor() == *rhs.blendingOptions->GetBlendColor()))))); + + return ret; +} + PipelineCache::PipelineCache(Graphics::Controller& controller) : graphicsController(&controller) { + // Clean up cache first + CleanLatestUsedCache(); } PipelineResult PipelineCache::GetPipeline(const PipelineCacheQueryInfo& queryInfo, bool createNewIfNotFound) { - auto* level0 = GetPipelineCacheL0(queryInfo.program, queryInfo.geometry); + // Seperate branch whether query use blending or not. + const int latestUsedCacheIndex = queryInfo.blendingEnabled ? 0 : 1; + + // If we can reuse latest bound pipeline, Fast return. + if(ReuseLatestBoundPipeline(latestUsedCacheIndex, queryInfo)) + { + return mLatestResult[latestUsedCacheIndex]; + } + + auto* level0 = GetPipelineCacheL0(queryInfo.hash, queryInfo.program, queryInfo.geometry); auto* level1 = level0->GetPipelineCacheL1(queryInfo.renderer, queryInfo.cameraUsingReflection); auto* level2 = level1->GetPipelineCacheL2(queryInfo.blendingEnabled, queryInfo.alphaPremultiplied, *queryInfo.blendingOptions); @@ -440,7 +486,16 @@ PipelineResult PipelineCache::GetPipeline(const PipelineCacheQueryInfo& queryInf result.level1 = level1; result.level2 = level2; + // Copy query and result + mLatestQuery[latestUsedCacheIndex] = queryInfo; + mLatestResult[latestUsedCacheIndex] = result; + return result; } +bool PipelineCache::ReuseLatestBoundPipeline(const int latestUsedCacheIndex, const PipelineCacheQueryInfo& queryInfo) const +{ + return mLatestResult[latestUsedCacheIndex].pipeline != nullptr && PipelineCacheQueryInfo::Equal(queryInfo, mLatestQuery[latestUsedCacheIndex]); +} + } // namespace Dali::Internal::Render diff --git a/dali/internal/render/renderers/pipeline-cache.h b/dali/internal/render/renderers/pipeline-cache.h index c9027d3..6bf11d8 100644 --- a/dali/internal/render/renderers/pipeline-cache.h +++ b/dali/internal/render/renderers/pipeline-cache.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_RENDER_PIPELINE_CACHE_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. @@ -18,10 +18,10 @@ */ // INTERNAL INCLUDES -#include -#include #include #include +#include +#include // EXTERNAL INCLUDES #include @@ -49,8 +49,7 @@ struct PipelineCacheL2 */ struct PipelineCacheL1 { - - PipelineCacheL2 *GetPipelineCacheL2(bool blend, bool premul, BlendingOptions &blendingOptions); + PipelineCacheL2* GetPipelineCacheL2(bool blend, bool premul, BlendingOptions& blendingOptions); uint32_t hashCode{}; // 1byte cull, 1byte poly, 1byte frontface Graphics::RasterizationState rs{}; @@ -61,14 +60,15 @@ struct PipelineCacheL1 }; /** - * Cache Level 0 : Stores geometry, program amd vertex input state + * Cache Level 0 : Stores hash, geometry, program amd vertex input state */ struct PipelineCacheL0 // L0 cache { - PipelineCacheL1 *GetPipelineCacheL1(Render::Renderer *renderer, bool usingReflection); + PipelineCacheL1* GetPipelineCacheL1(Render::Renderer* renderer, bool usingReflection); - Geometry *geometry{}; - Program *program{}; + std::size_t hash{}; + Geometry* geometry{}; + Program* program{}; Graphics::VertexInputState inputState; std::vector level1nodes; @@ -77,17 +77,25 @@ struct PipelineCacheL0 // L0 cache struct PipelineCacheQueryInfo { // Program/Geometry - Renderer *renderer; - Program *program; - Geometry *geometry; + Renderer* renderer; + Program* program; + Geometry* geometry; bool cameraUsingReflection; // Blending - bool blendingEnabled; - bool alphaPremultiplied; - BlendingOptions *blendingOptions; + bool blendingEnabled; + bool alphaPremultiplied; + BlendingOptions* blendingOptions; + + // Lightweight hash value before compare each query. + std::size_t hash{0u}; + // Generate hash value for this query. + void GenerateHash(); + + // Value comparision between two query info. + static bool Equal(const PipelineCacheQueryInfo& lhs, const PipelineCacheQueryInfo& rhs) noexcept; }; /** @@ -117,22 +125,47 @@ public: /** * Retrieves next cache level */ - PipelineCacheL0* GetPipelineCacheL0( Program *program, Render::Geometry *geometry); + PipelineCacheL0* GetPipelineCacheL0(std::size_t hash, Program* program, Render::Geometry* geometry); /** * Retrieves pipeline matching queryInfo struct * * May retrieve existing pipeline or create one or return nullptr. */ - PipelineResult GetPipeline( const PipelineCacheQueryInfo& queryInfo, bool createNewIfNotFound ); + PipelineResult GetPipeline(const PipelineCacheQueryInfo& queryInfo, bool createNewIfNotFound); -private: + /** + * @brief Check whether we can reuse latest found PipelineResult. + * We can reuse latest pipeline only if query info is equal with latest query + * and we don't call CleanLatestUsedCache() before. + * + * @param[in] latestUsedCacheIndex Index of cache we want to compare. + * @param[in] queryInfo Query for current pipeline. + * @return True if we can reuse latest pipeline result. False otherwise + */ + bool ReuseLatestBoundPipeline(const int latestUsedCacheIndex, const PipelineCacheQueryInfo& queryInfo) const; + + /** + * @brief Clear latest bound result. + */ + void CleanLatestUsedCache() + { + // Set pipeline as nullptr is enough. + mLatestResult[0].pipeline = nullptr; + mLatestResult[1].pipeline = nullptr; + } - Graphics::Controller* graphicsController{nullptr}; +private: + Graphics::Controller* graphicsController{nullptr}; std::vector level0nodes; + + // Cache latest queries whether blend enabled or not. + // (Since most UI case (like Text and Image) enable blend, and most 3D case disable blend.) + PipelineCacheQueryInfo mLatestQuery[2]; ///< Latest requested query info. It will be invalidate after query's renderer / geometry / blendingOptions value changed. + PipelineResult mLatestResult[2]; ///< Latest used result. It will be invalidate when we call CleanLatestUsedCache() or some cache changed. }; -} -} +} // namespace Render +} // namespace Dali::Internal #endif // DALI_INTERNAL_RENDER_PIPELINE_CACHE_H diff --git a/dali/internal/render/renderers/render-geometry.cpp b/dali/internal/render/renderers/render-geometry.cpp index feb6244..b407b6f 100644 --- a/dali/internal/render/renderers/render-geometry.cpp +++ b/dali/internal/render/renderers/render-geometry.cpp @@ -149,11 +149,7 @@ void Geometry::Upload(Graphics::Controller& graphicsController) } } -bool Geometry::Draw( - Graphics::Controller& graphicsController, - Graphics::CommandBuffer& commandBuffer, - uint32_t elementBufferOffset, - uint32_t elementBufferCount) +bool Geometry::BindVertexAttributes(Graphics::CommandBuffer& commandBuffer) { //Bind buffers to attribute locations const auto vertexBufferCount = static_cast(mVertexBuffers.Count()); @@ -183,6 +179,15 @@ bool Geometry::Draw( commandBuffer.BindVertexBuffers(0, buffers, offsets); + return true; +} + +bool Geometry::Draw( + Graphics::Controller& graphicsController, + Graphics::CommandBuffer& commandBuffer, + uint32_t elementBufferOffset, + uint32_t elementBufferCount) +{ uint32_t numIndices(0u); intptr_t firstIndexOffset(0u); if(mIndexBuffer) @@ -220,7 +225,8 @@ bool Geometry::Draw( { // Un-indexed draw call uint32_t numVertices(0u); - if(vertexBufferCount > 0) + + if(mVertexBuffers.Count() > 0) { // truncated, no value loss happening in practice numVertices = static_cast(mVertexBuffers[0]->GetElementCount()); diff --git a/dali/internal/render/renderers/render-geometry.h b/dali/internal/render/renderers/render-geometry.h index a23c7a0..2f04c97 100644 --- a/dali/internal/render/renderers/render-geometry.h +++ b/dali/internal/render/renderers/render-geometry.h @@ -125,7 +125,7 @@ public: * Set up the attributes and perform the Draw call corresponding to the geometry type. * * @param[in] graphicsController The graphics controller - * @param[in] bufferIndex The current buffer index + * @param[in,out] commandBuffer The current command buffer queue * @param[in] elementBufferOffset The index of first element to draw if index buffer bound * @param[in] elementBufferCount Number of elements to draw if index buffer bound, uses whole buffer when 0 * @return true if the draw command was issued, false otherwise @@ -135,6 +135,14 @@ public: uint32_t elementBufferOffset, uint32_t elementBufferCount); + /** + * @brief Set up the attributes bind commaneds + * + * @param[in,out] commandBuffer The current command buffer queue + * @return true if the bind command was issued, false otherwise + */ + bool BindVertexAttributes(Graphics::CommandBuffer& commandBuffer); + private: // VertexBuffers Vector mVertexBuffers; diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp index 9b8c2c9..7a19c6b 100644 --- a/dali/internal/render/renderers/render-renderer.cpp +++ b/dali/internal/render/renderers/render-renderer.cpp @@ -146,6 +146,23 @@ inline uint32_t GetUniformBufferDataAlignment(uint32_t dataSize) return ((dataSize / 256u) + ((dataSize % 256u) ? 1u : 0u)) * 256u; } +/** + * @brief Store latest bound RenderGeometry, and help that we can skip duplicated vertex attributes bind. + * + * @param[in] geometry Current geometry to be used, or nullptr if render finished + * @return True if we can reuse latest bound vertex attributes. False otherwise. + */ +inline bool ReuseLatestBoundVertexAttributes(const Render::Geometry* geometry) +{ + static const Render::Geometry* gLatestVertexBoundGeometry = nullptr; + if(gLatestVertexBoundGeometry == geometry) + { + return true; + } + gLatestVertexBoundGeometry = geometry; + return false; +} + } // namespace namespace Render @@ -155,6 +172,14 @@ namespace MemoryPoolObjectAllocator gRenderRendererMemoryPool; } +void Renderer::PrepareCommandBuffer() +{ + // Reset latest geometry informations, So we can bind the first of geometry. + ReuseLatestBoundVertexAttributes(nullptr); + + // todo : Fill here as many caches as we can store for reduce the number of command buffers +} + RendererKey Renderer::NewKey(SceneGraph::RenderDataProvider* dataProvider, Render::Geometry* geometry, uint32_t blendingBitmask, @@ -571,16 +596,25 @@ bool Renderer::Render(Graphics::CommandBuffer& comma bool drawn = false; // Draw can fail if there are no vertex buffers or they haven't been uploaded yet // @todo We should detect this case much earlier to prevent unnecessary work - if(mDrawCommands.empty()) + // Reuse latest bound vertex attributes location, or Bind buffers to attribute locations. + if(ReuseLatestBoundVertexAttributes(mGeometry) || mGeometry->BindVertexAttributes(commandBuffer)) { - drawn = mGeometry->Draw(*mGraphicsController, commandBuffer, mIndexedDrawFirstElement, mIndexedDrawElementsCount); + if(mDrawCommands.empty()) + { + drawn = mGeometry->Draw(*mGraphicsController, commandBuffer, mIndexedDrawFirstElement, mIndexedDrawElementsCount); + } + else + { + for(auto& cmd : commands) + { + drawn |= mGeometry->Draw(*mGraphicsController, commandBuffer, cmd->firstIndex, cmd->elementCount); + } + } } else { - for(auto& cmd : commands) - { - mGeometry->Draw(*mGraphicsController, commandBuffer, cmd->firstIndex, cmd->elementCount); - } + // BindVertexAttributes failed. Reset cached geometry. + ReuseLatestBoundVertexAttributes(nullptr); } return drawn; @@ -927,6 +961,9 @@ Graphics::Pipeline& Renderer::PrepareGraphicsPipeline( queryInfo.alphaPremultiplied = mPremultipliedAlphaEnabled; queryInfo.cameraUsingReflection = instruction.GetCamera()->GetReflectionUsed(); + queryInfo.GenerateHash(); + + // Find or generate new pipeline. auto pipelineResult = mPipelineCache->GetPipeline(queryInfo, true); // should be never null? diff --git a/dali/internal/render/renderers/render-renderer.h b/dali/internal/render/renderers/render-renderer.h index 9f25651..38b0493 100644 --- a/dali/internal/render/renderers/render-renderer.h +++ b/dali/internal/render/renderers/render-renderer.h @@ -115,6 +115,11 @@ public: }; /** + * @brief Global static initialize for Render::Renderer before new CommandBuffer's Render fill start. + */ + static void PrepareCommandBuffer(); + + /** * Create a new renderer instance * @param[in] dataProviders The data providers for the renderer * @param[in] geometry The geometry for the renderer diff --git a/dali/internal/update/animation/scene-graph-constraint-base.h b/dali/internal/update/animation/scene-graph-constraint-base.h index f3f8f08..5bab505 100644 --- a/dali/internal/update/animation/scene-graph-constraint-base.h +++ b/dali/internal/update/animation/scene-graph-constraint-base.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_SCENE_GRAPH_CONSTRAINT_BASE_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. @@ -232,9 +232,10 @@ protected: bool mFirstApply : 1; bool mDisconnected : 1; + PropertyOwnerContainer mObservedOwners; ///< A set of pointers to each observed object. Not owned. + private: - PropertyOwnerContainer mObservedOwners; ///< A set of pointers to each observed object. Not owned. - LifecycleObserver* mLifecycleObserver; ///< Resetter observers this object + LifecycleObserver* mLifecycleObserver; ///< Resetter observers this object #ifdef DEBUG_ENABLED static uint32_t mCurrentInstanceCount; ///< The current number of Constraint instances in existence. diff --git a/dali/internal/update/animation/scene-graph-constraint.h b/dali/internal/update/animation/scene-graph-constraint.h index d7ba807..dc6a867 100644 --- a/dali/internal/update/animation/scene-graph-constraint.h +++ b/dali/internal/update/animation/scene-graph-constraint.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_SCENE_GRAPH_CONSTRAINT_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. @@ -80,8 +80,34 @@ public: if(mFunc->InputsInitialized()) { PropertyType current = mTargetProperty.Get(updateBufferIndex); + PropertyType old = mTargetProperty.Get(!updateBufferIndex); + mFunc->Apply(updateBufferIndex, current); + // Compare with value of the previous frame + if constexpr(std::is_same_v) + { + if(!Equals(old, current)) + { + if(!mObservedOwners.Empty()) + { + // The first observer is the target of the constraint + mObservedOwners[0]->SetUpdated(true); + } + } + } + else + { + if(old != current) + { + if(!mObservedOwners.Empty()) + { + // The first observer is the target of the constraint + mObservedOwners[0]->SetUpdated(true); + } + } + } + // Optionally bake the final value if(Dali::Constraint::BAKE == mRemoveAction) { diff --git a/dali/internal/update/common/animatable-property.h b/dali/internal/update/common/animatable-property.h index 949fec7..612af3f 100644 --- a/dali/internal/update/common/animatable-property.h +++ b/dali/internal/update/common/animatable-property.h @@ -79,7 +79,7 @@ protected: // for derived classes /** * Flag that the property has been Set during the current frame. */ - void OnSet() + virtual void OnSet() { mDirtyFlags = SET_FLAG; } @@ -87,7 +87,7 @@ protected: // for derived classes /** * Flag that the property has been Baked during the current frame. */ - void OnBake() + virtual void OnBake() { mDirtyFlags = BAKED_FLAG; } diff --git a/dali/internal/update/common/property-resetter.h b/dali/internal/update/common/property-resetter.h index ddbc110..68a3986 100644 --- a/dali/internal/update/common/property-resetter.h +++ b/dali/internal/update/common/property-resetter.h @@ -60,6 +60,7 @@ public: void Initialize() { mPropertyOwner->AddObserver(*this); + mPropertyOwner->SetUpdated(true); } /** @@ -201,7 +202,7 @@ public: Lifetime lifetime) : PropertyResetterBase(propertyOwner, baseProperty) { - mRunning = lifetime == Lifetime::BAKE ? ACTIVE : AGING; + mRunning = lifetime == Lifetime::BAKE ? AGING : ACTIVE; } /** @@ -219,7 +220,10 @@ public: mRunning--; mBaseProperty->ResetToBaseValue(updateBufferIndex); - // @todo Consider adding mPropertyOwner->SetUpdated(true) here. + if(mRunning > 0) + { + mPropertyOwner->SetUpdated(true); + } } } }; diff --git a/dali/internal/update/manager/render-instruction-processor.cpp b/dali/internal/update/manager/render-instruction-processor.cpp index 4187b8f..87c3c98 100644 --- a/dali/internal/update/manager/render-instruction-processor.cpp +++ b/dali/internal/update/manager/render-instruction-processor.cpp @@ -216,7 +216,7 @@ inline void AddRendererToRenderList(BufferIndex updateBufferIndex, SetNodeUpdateArea(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateArea); nodeUpdateAreaSet = true; - const Vector3& scale = node->GetWorldScale(updateBufferIndex); + const Vector3& scale = nodeWorldMatrix.GetScale(); const Vector3& size = Vector3(nodeUpdateArea.z, nodeUpdateArea.w, 1.0f) * scale; if(size.LengthSquared() > Math::MACHINE_EPSILON_1000) diff --git a/dali/internal/update/manager/transform-manager-property.h b/dali/internal/update/manager/transform-manager-property.h index b9600bd..fe5fec4 100644 --- a/dali/internal/update/manager/transform-manager-property.h +++ b/dali/internal/update/manager/transform-manager-property.h @@ -400,9 +400,7 @@ public: } else if(mProperty == TRANSFORM_PROPERTY_WORLD_SCALE) { - Vector3 position; - Quaternion orientation; - worldMatrix.GetTransformComponents(position, orientation, mValue); + mValue = worldMatrix.GetScale(); } } } diff --git a/dali/internal/update/manager/update-algorithms.cpp b/dali/internal/update/manager/update-algorithms.cpp index 0baa4f7..9cdd211 100644 --- a/dali/internal/update/manager/update-algorithms.cpp +++ b/dali/internal/update/manager/update-algorithms.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Samsung Electronics Co., Ltd. + * Copyright (c) 2023 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -113,8 +113,6 @@ inline NodePropertyFlags UpdateNodes(Node& node, UpdateNodeOpacity(node, nodeDirtyFlags, updateBufferIndex); - node.UpdateUniformHash(updateBufferIndex); - // For partial update, mark all children of an animating node as updated. if(updated) // Only set to updated if parent was updated. { diff --git a/dali/internal/update/manager/update-manager.cpp b/dali/internal/update/manager/update-manager.cpp index 5b3bf16..d47185a 100644 --- a/dali/internal/update/manager/update-manager.cpp +++ b/dali/internal/update/manager/update-manager.cpp @@ -1155,6 +1155,11 @@ void UpdateManager::PostRender() renderer->ResetDirtyFlag(); } + for(auto&& shader : mImpl->shaders) + { + shader->SetUpdated(false); + } + for(auto&& scene : mImpl->scenes) { scene->root->SetUpdatedTree(false); diff --git a/dali/internal/update/nodes/node-helper.h b/dali/internal/update/nodes/node-helper.h index 4997868..f6e5d40 100644 --- a/dali/internal/update/nodes/node-helper.h +++ b/dali/internal/update/nodes/node-helper.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_SCENEGRAPH_NODE_HELPER_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. @@ -43,12 +43,12 @@ * It is assumed that successive elements are aligned, and that no padding * is inserted by the compiler. */ -#define PROPERTY_WRAPPER(_BASE_ELEMENT, _TEMPLATE, _PROPERTY, _ELEMENT) \ - using _TEMPLATE##_PROPERTY = _TEMPLATE<_PROPERTY, OFFSET_##_BASE_ELEMENT>; \ - _TEMPLATE##_PROPERTY _ELEMENT; \ - enum \ - { \ - OFFSET_##_ELEMENT = sizeof(_TEMPLATE##_PROPERTY) + OFFSET_##_BASE_ELEMENT \ +#define PROPERTY_WRAPPER(_BASE_ELEMENT, _TEMPLATE, _PROPERTY, _ELEMENT) \ + using _TEMPLATE##_ELEMENT = _TEMPLATE<_PROPERTY, OFFSET_##_BASE_ELEMENT>; \ + _TEMPLATE##_ELEMENT _ELEMENT; \ + enum \ + { \ + OFFSET_##_ELEMENT = sizeof(_TEMPLATE##_ELEMENT) + OFFSET_##_BASE_ELEMENT \ }; /* diff --git a/dali/internal/update/nodes/node.cpp b/dali/internal/update/nodes/node.cpp index 8ae7963..5dc2e99 100644 --- a/dali/internal/update/nodes/node.cpp +++ b/dali/internal/update/nodes/node.cpp @@ -281,20 +281,6 @@ void Node::ResetDirtyFlags(BufferIndex updateBufferIndex) mUpdateAreaChanged = false; } -void Node::UpdateUniformHash(BufferIndex bufferIndex) -{ - uint64_t hash = 0xc70f6907UL; - for(uint32_t i = 0u, count = mUniformMaps.Count(); i < count; ++i) - { - hash = mUniformMaps[i].propertyPtr->Hash(bufferIndex, hash); - } - if(mUniformsHash != hash) - { - mUniformsHash = hash; - SetUpdated(true); - } -} - void Node::SetParent(Node& parentNode) { DALI_ASSERT_ALWAYS(this != &parentNode); diff --git a/dali/internal/update/nodes/node.h b/dali/internal/update/nodes/node.h index 7611531..a99129b 100644 --- a/dali/internal/update/nodes/node.h +++ b/dali/internal/update/nodes/node.h @@ -918,12 +918,6 @@ public: */ void ResetDirtyFlags(BufferIndex updateBufferIndex); - /** - * Update uniform hash - * @param[in] bufferIndex The buffer to read from. - */ - void UpdateUniformHash(BufferIndex bufferIndex); - protected: /** * Set the parent of a Node. @@ -1007,7 +1001,6 @@ public: // Default properties InheritedColor mWorldColor; ///< Full inherited color Vector4 mUpdateAreaHint; ///< Update area hint is provided for damaged area calculation. (x, y, width, height) - uint64_t mUniformsHash{0u}; ///< Hash of uniform map property values uint32_t mClippingSortModifier; ///< Contains bit-packed clipping information for quick access when sorting const uint32_t mId; ///< The Unique ID of the node. diff --git a/dali/internal/update/rendering/scene-graph-renderer.cpp b/dali/internal/update/rendering/scene-graph-renderer.cpp index 752a56d..1b666a4 100644 --- a/dali/internal/update/rendering/scene-graph-renderer.cpp +++ b/dali/internal/update/rendering/scene-graph-renderer.cpp @@ -736,19 +736,6 @@ void Renderer::UpdateUniformMap(BufferIndex updateBufferIndex) mRegenerateUniformMap = false; SetUpdated(true); } - - uint64_t hash = 0xc70f6907UL; - const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = GetUniformMapDataProvider(); - const SceneGraph::CollectedUniformMap& collectedUniformMap = uniformMapDataProvider.GetCollectedUniformMap(); - for(uint32_t i = 0u, count = collectedUniformMap.Count(); i < count; ++i) - { - hash = collectedUniformMap.mUniformMap[i].propertyPtr->Hash(updateBufferIndex, hash); - } - if(mUniformsHash != hash) - { - mUniformsHash = hash; - SetUpdated(true); - } } void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size) @@ -787,28 +774,24 @@ const CollectedUniformMap& Renderer::GetCollectedUniformMap() const return mCollectedUniformMap; } +bool Renderer::IsUpdated() const +{ + if(Updated() || (mShader && mShader->Updated())) + { + return true; + } + return false; +} + Vector4 Renderer::GetVisualTransformedUpdateArea(BufferIndex updateBufferIndex, const Vector4& originalUpdateArea) noexcept { if(mVisualProperties) { auto& coefficient = mVisualProperties->mCoefficient; - // TODO : We may need to get some method that visual properties changed, without hash. - // Or, need to call this API in PreRender side. - - uint64_t hash = 0xc70f6907UL; - - hash = mVisualProperties->mTransformOffset.Hash(updateBufferIndex, hash); - hash = mVisualProperties->mTransformOffsetSizeMode.Hash(updateBufferIndex, hash); - hash = mVisualProperties->mTransformSize.Hash(updateBufferIndex, hash); - hash = mVisualProperties->mTransformOrigin.Hash(updateBufferIndex, hash); - hash = mVisualProperties->mTransformAnchorPoint.Hash(updateBufferIndex, hash); - hash = mVisualProperties->mExtraSize.Hash(updateBufferIndex, hash); - - if(coefficient.hash != hash) + // Recalculate only if coefficient need to be updated. + if(coefficient.IsUpdated()) { - coefficient.hash = hash; - // VisualProperty const Vector2 transformOffset = mVisualProperties->mTransformOffset.Get(updateBufferIndex); const Vector4 transformOffsetSizeMode = mVisualProperties->mTransformOffsetSizeMode.Get(updateBufferIndex); @@ -859,20 +842,18 @@ Vector4 Renderer::GetVisualTransformedUpdateArea(BufferIndex updateBufferIndex, coefficient.coefCA = transformSize * Vector2(transformOffsetSizeMode.z, transformOffsetSizeMode.w) + extraSize; coefficient.coefCB = coefficient.coefCA * transformAnchorPoint + transformOffset * Vector2(transformOffsetSizeMode.x, transformOffsetSizeMode.y); } + + float coefD = 0.0f; ///< Default as 0.0f when we don't use decorated renderer. + if(mVisualProperties->mExtendedProperties) { const auto decoratedVisualProperties = static_cast(mVisualProperties->mExtendedProperties); - uint64_t decoratedHash = 0xc70f6907UL; - - decoratedHash = decoratedVisualProperties->mBorderlineWidth.Hash(updateBufferIndex, decoratedHash); - decoratedHash = decoratedVisualProperties->mBorderlineOffset.Hash(updateBufferIndex, decoratedHash); - decoratedHash = decoratedVisualProperties->mBlurRadius.Hash(updateBufferIndex, decoratedHash); + auto& decoratedCoefficient = decoratedVisualProperties->mCoefficient; - if(coefficient.decoratedHash != decoratedHash) + // Recalculate only if coefficient need to be updated. + if(decoratedCoefficient.IsUpdated()) { - coefficient.decoratedHash = decoratedHash; - // DecoratedVisualProperty const float borderlineWidth = decoratedVisualProperties->mBorderlineWidth.Get(updateBufferIndex); const float borderlineOffset = decoratedVisualProperties->mBorderlineOffset.Get(updateBufferIndex); @@ -883,10 +864,12 @@ Vector4 Renderer::GetVisualTransformedUpdateArea(BufferIndex updateBufferIndex, DALI_LOG_INFO(gSceneGraphRendererLogFilter, Debug::Verbose, "blur radius %5.3f\n", blurRadius); // D coefficients be used only decoratedVisual. - // It can be calculated parallely with transform. - - coefficient.coefD = std::max((1.0f + Dali::Clamp(borderlineOffset, -1.0f, 1.0f)) * borderlineWidth, 2.0f * blurRadius); + // It can be calculated parallely with visual transform. + decoratedCoefficient.coefD = std::max((1.0f + Dali::Clamp(borderlineOffset, -1.0f, 1.0f)) * borderlineWidth, 2.0f * blurRadius); } + + // Update coefD so we can use this value out of this scope. + coefD = decoratedCoefficient.coefD; } // Calculate vertex position by coefficient @@ -916,8 +899,8 @@ Vector4 Renderer::GetVisualTransformedUpdateArea(BufferIndex updateBufferIndex, // TODO : We need to re-generate coefficient to consitder area width/height const Vector4 resultArea = Vector4(originalXY.x, originalXY.y, - scaleVertexPosition.x + 2.0f * abs(basicVertexPosition.x) + coefficient.coefD, - scaleVertexPosition.y + 2.0f * abs(basicVertexPosition.y) + coefficient.coefD); + scaleVertexPosition.x + 2.0f * abs(basicVertexPosition.x) + coefD, + scaleVertexPosition.y + 2.0f * abs(basicVertexPosition.y) + coefD); DALI_LOG_INFO(gSceneGraphRendererLogFilter, Debug::Verbose, "%f %f %f %f--> %f %f %f %f\n", originalUpdateArea.x, originalUpdateArea.y, originalUpdateArea.z, originalUpdateArea.w, resultArea.x, resultArea.y, resultArea.z, resultArea.w); diff --git a/dali/internal/update/rendering/scene-graph-renderer.h b/dali/internal/update/rendering/scene-graph-renderer.h index 889a791..153ff85 100644 --- a/dali/internal/update/rendering/scene-graph-renderer.h +++ b/dali/internal/update/rendering/scene-graph-renderer.h @@ -26,6 +26,7 @@ #include #include #include +#include #include #include // Dali::Renderer @@ -70,93 +71,6 @@ using RendererContainer = Dali::Vector; using RendererIter = RendererContainer::Iterator; using RendererConstIter = RendererContainer::ConstIterator; -namespace VisualRenderer -{ -struct AnimatableVisualProperties -{ - AnimatableVisualProperties() - : mTransformOffset(Vector2::ZERO), - mTransformSize(Vector2::ONE), - mTransformOrigin(Vector2::ZERO), - mTransformAnchorPoint(Vector2::ZERO), - mTransformOffsetSizeMode(Vector4::ZERO), - mExtraSize(Vector2::ZERO), - mMixColor(Vector3::ONE), - mPreMultipliedAlpha(0.0f), - mExtendedPropertiesDeleteFunction(nullptr) - { - } - - ~AnimatableVisualProperties() - { - if(mExtendedProperties && mExtendedPropertiesDeleteFunction) - { - mExtendedPropertiesDeleteFunction(mExtendedProperties); - } - } - - /** - * @brief Cached coefficient value when we calculate visual transformed update size. - * It can reduce complexity of calculate the vertex position. - * - * Vector2 vertexPosition = (XA * aPosition + XB) * originalSize + (CA * aPosition + CB) + Vector2(D, D) * aPosition - */ - struct VisualTransformedUpdateSizeCoefficientCache - { - Vector2 coefXA{Vector2::ZERO}; - Vector2 coefXB{Vector2::ZERO}; - Vector2 coefCA{Vector2::ZERO}; - Vector2 coefCB{Vector2::ZERO}; - float coefD{0.0f}; - - uint64_t hash{0u}; - uint64_t decoratedHash{0u}; - }; - VisualTransformedUpdateSizeCoefficientCache mCoefficient; ///< Coefficient value to calculate visual transformed update size by VisualProperties more faster. - - AnimatableProperty mTransformOffset; - AnimatableProperty mTransformSize; - AnimatableProperty mTransformOrigin; - AnimatableProperty mTransformAnchorPoint; - AnimatableProperty mTransformOffsetSizeMode; - AnimatableProperty mExtraSize; - AnimatableProperty mMixColor; - AnimatableProperty mPreMultipliedAlpha; - - void* mExtendedProperties{nullptr}; // Enable derived class to extend properties further - void (*mExtendedPropertiesDeleteFunction)(void*){nullptr}; // Derived class's custom delete functor -}; - -struct AnimatableDecoratedVisualProperties -{ - AnimatableDecoratedVisualProperties() - : mCornerRadius(Vector4::ZERO), - mCornerRadiusPolicy(1.0f), - mBorderlineWidth(0.0f), - mBorderlineColor(Color::BLACK), - mBorderlineOffset(0.0f), - mBlurRadius(0.0f) - { - } - ~AnimatableDecoratedVisualProperties() - { - } - - // Delete function of AnimatableDecoratedVisualProperties* converted as void* - static void DeleteFunction(void* data) - { - delete static_cast(data); - } - - AnimatableProperty mCornerRadius; - AnimatableProperty mCornerRadiusPolicy; - AnimatableProperty mBorderlineWidth; - AnimatableProperty mBorderlineColor; - AnimatableProperty mBorderlineOffset; - AnimatableProperty mBlurRadius; -}; -} // namespace VisualRenderer - class Renderer : public PropertyOwner, public UniformMapDataProvider, public RenderDataProvider @@ -511,10 +425,7 @@ public: /** * @copydoc RenderDataProvider::IsUpdated() */ - bool IsUpdated() const override - { - return Updated(); - } + bool IsUpdated() const override; /** * @copydoc RenderDataProvider::GetVisualTransformedUpdateArea() @@ -633,7 +544,6 @@ private: Dali::Internal::Render::Renderer::StencilParameters mStencilParameters; ///< Struct containing all stencil related options - uint64_t mUniformsHash{0}; ///< Hash of uniform map property values uint32_t mIndexedDrawFirstElement; ///< first element index to be drawn using indexed draw uint32_t mIndexedDrawElementsCount; ///< number of elements to be drawn using indexed draw uint32_t mBlendBitmask; ///< The bitmask of blending options diff --git a/dali/internal/update/rendering/scene-graph-visual-renderer-property.h b/dali/internal/update/rendering/scene-graph-visual-renderer-property.h new file mode 100644 index 0000000..5360173 --- /dev/null +++ b/dali/internal/update/rendering/scene-graph-visual-renderer-property.h @@ -0,0 +1,124 @@ +#ifndef DALI_INTERNAL_SCENE_GRAPH_VISUAL_RENDERER_PROPERTY_H +#define DALI_INTERNAL_SCENE_GRAPH_VISUAL_RENDERER_PROPERTY_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. + */ + +#include + +namespace Dali::Internal::SceneGraph::VisualRenderer +{ +/** + * @brief Base class for VisualRender properties coefficient. + * It will mark update flag as dirty if some properties are changed. + * By that update flag, we can determine that we need to re-calculate + * coefficient values or not. + */ +struct VisualRendererCoefficientCacheBase +{ + VisualRendererCoefficientCacheBase() + : mUpdated(true) + { + } + + virtual ~VisualRendererCoefficientCacheBase() = default; + + /** + * @brief Check whether this cache need to be update. + * After call this API, update flag will be reset. + * + * @return True if this coefficient updated. False otherwise. + */ + bool IsUpdated() + { + bool ret = mUpdated; + mUpdated = false; + return ret; + } + + /** + * @brief Mark update flag as true. + */ + void Update() + { + mUpdated = true; + } + +private: + bool mUpdated; ///< Updated flag for this coefficient cache. +}; + +/** + * @brief Special AnimatableProperty class for VisualRenderer properties + * that will be used for coefficient calculation. + * It will be used to avoid useless coefficient update. + * + * @tparam T Type of animatable property + */ +template +struct VisualRendererProperty : public AnimatableProperty +{ + enum + { + VISUAL_RENDERER_CACHE_BASE_DATA_OFFSET = CacheBaseDataOffset + }; + VisualRendererCoefficientCacheBase* GetCacheBaseData() + { + return reinterpret_cast( + reinterpret_cast(this) - VISUAL_RENDERER_CACHE_BASE_DATA_OFFSET); + } + const VisualRendererCoefficientCacheBase* GetCacheBaseData() const + { + return reinterpret_cast( + reinterpret_cast(this) - VISUAL_RENDERER_CACHE_BASE_DATA_OFFSET); + } + +public: + /** + * Constructor, initialize the dirty flag + */ + VisualRendererProperty(const T& initialValue) + : AnimatableProperty(initialValue) + { + } + + /** + * Virtual destructor. + */ + ~VisualRendererProperty() override = default; + + /** + * @copydoc Dali::Internal::SceneGraph::AnimatablePropertyBase::OnSet + */ + void OnSet() override + { + GetCacheBaseData()->Update(); + AnimatablePropertyBase::OnSet(); + } + + /** + * @copydoc Dali::Internal::SceneGraph::AnimatablePropertyBase::OnBake + */ + void OnBake() override + { + GetCacheBaseData()->Update(); + AnimatablePropertyBase::OnBake(); + } +}; + +} // namespace Dali::Internal::SceneGraph::VisualRenderer + +#endif // DALI_INTERNAL_SCENE_GRAPH_VISUAL_RENDERER_PROPERTY_H diff --git a/dali/internal/update/rendering/scene-graph-visual-renderer.h b/dali/internal/update/rendering/scene-graph-visual-renderer.h new file mode 100644 index 0000000..610aee0 --- /dev/null +++ b/dali/internal/update/rendering/scene-graph-visual-renderer.h @@ -0,0 +1,154 @@ +#ifndef DALI_INTERNAL_SCENE_GRAPH_VISUAL_RENDERER_H +#define DALI_INTERNAL_SCENE_GRAPH_VISUAL_RENDERER_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 INCLUDES +#include ///< For size_t + +// INTERNAL INCLUDES +#include ///< For property wrapper macro +#include + +namespace Dali::Internal::SceneGraph::VisualRenderer +{ +struct AnimatableVisualProperties +{ + AnimatableVisualProperties() + : mTransformOffset(Vector2::ZERO), + mTransformSize(Vector2::ONE), + mTransformOrigin(Vector2::ZERO), + mTransformAnchorPoint(Vector2::ZERO), + mTransformOffsetSizeMode(Vector4::ZERO), + mExtraSize(Vector2::ZERO), + mMixColor(Vector3::ONE), + mPreMultipliedAlpha(0.0f), + mExtendedPropertiesDeleteFunction(nullptr) + { + } + + ~AnimatableVisualProperties() + { + if(mExtendedProperties && mExtendedPropertiesDeleteFunction) + { + mExtendedPropertiesDeleteFunction(mExtendedProperties); + } + } + + /** + * @brief Cached coefficient value when we calculate visual transformed update size. + * It can reduce complexity of calculate the vertex position. + * + * Vector2 vertexPosition = (XA * aPosition + XB) * originalSize + (CA * aPosition + CB) + */ + struct VisualTransformedUpdateSizeCoefficientCache : public VisualRendererCoefficientCacheBase + { + VisualTransformedUpdateSizeCoefficientCache() + : VisualRendererCoefficientCacheBase(), + coefXA(Vector2::ZERO), + coefXB(Vector2::ZERO), + coefCA(Vector2::ZERO), + coefCB(Vector2::ZERO) + { + } + + ~VisualTransformedUpdateSizeCoefficientCache() override = default; + + Vector2 coefXA; + Vector2 coefXB; + Vector2 coefCA; + Vector2 coefCB; + }; + +public: // Default properties + // Define a base offset for the following wrappers. The wrapper macros calculate offsets from the previous + // element such that each wrapper type generates a compile time offset to the CoefficientCache data. + BASE(VisualTransformedUpdateSizeCoefficientCache, mCoefficient); ///< Coefficient value to calculate visual transformed update size by VisualProperties more faster. + + PROPERTY_WRAPPER(mCoefficient, VisualRendererProperty, Vector2, mTransformOffset); + PROPERTY_WRAPPER(mTransformOffset, VisualRendererProperty, Vector2, mTransformSize); + PROPERTY_WRAPPER(mTransformSize, VisualRendererProperty, Vector2, mTransformOrigin); + PROPERTY_WRAPPER(mTransformOrigin, VisualRendererProperty, Vector2, mTransformAnchorPoint); + PROPERTY_WRAPPER(mTransformAnchorPoint, VisualRendererProperty, Vector4, mTransformOffsetSizeMode); + PROPERTY_WRAPPER(mTransformOffsetSizeMode, VisualRendererProperty, Vector2, mExtraSize); + + // Properties that don't give any effort to coefficient. + AnimatableProperty mMixColor; + AnimatableProperty mPreMultipliedAlpha; + +public: // Extended properties + void* mExtendedProperties{nullptr}; // Enable derived class to extend properties further + void (*mExtendedPropertiesDeleteFunction)(void*){nullptr}; // Derived class's custom delete functor +}; + +struct AnimatableDecoratedVisualProperties +{ + AnimatableDecoratedVisualProperties() + : mBorderlineWidth(0.0f), + mBorderlineOffset(0.0f), + mBlurRadius(0.0f), + mBorderlineColor(Color::BLACK), + mCornerRadius(Vector4::ZERO), + mCornerRadiusPolicy(1.0f) + { + } + ~AnimatableDecoratedVisualProperties() + { + } + + // Delete function of AnimatableDecoratedVisualProperties* converted as void* + static void DeleteFunction(void* data) + { + delete static_cast(data); + } + + /** + * @brief Cached coefficient value when we calculate visual transformed update size. + * It can reduce complexity of calculate the vertex position. + * + * Vector2 vertexPosition += Vector2(D, D) * aPosition + */ + struct DecoratedVisualTransformedUpdateSizeCoefficientCache : public VisualRendererCoefficientCacheBase + { + DecoratedVisualTransformedUpdateSizeCoefficientCache() + : VisualRendererCoefficientCacheBase(), + coefD(0.0f) + { + } + + ~DecoratedVisualTransformedUpdateSizeCoefficientCache() override = default; + + float coefD; + }; + +public: // Default properties + // Define a base offset for the following wrappers. The wrapper macros calculate offsets from the previous + // element such that each wrapper type generates a compile time offset to the CoefficientCache data. + BASE(DecoratedVisualTransformedUpdateSizeCoefficientCache, mCoefficient); ///< Coefficient value to calculate visual transformed update size by VisualProperties more faster. + + PROPERTY_WRAPPER(mCoefficient, VisualRendererProperty, float, mBorderlineWidth); + PROPERTY_WRAPPER(mBorderlineWidth, VisualRendererProperty, float, mBorderlineOffset); + PROPERTY_WRAPPER(mBorderlineOffset, VisualRendererProperty, float, mBlurRadius); + + // Properties that don't give any effort to coefficient. + AnimatableProperty mBorderlineColor; + AnimatableProperty mCornerRadius; + AnimatableProperty mCornerRadiusPolicy; +}; +} // namespace Dali::Internal::SceneGraph::VisualRenderer + +#endif // DALI_INTERNAL_SCENE_GRAPH_VISUAL_RENDERER_H diff --git a/dali/public-api/actors/actor.cpp b/dali/public-api/actors/actor.cpp index 33c6f9f..0c1b911 100644 --- a/dali/public-api/actors/actor.cpp +++ b/dali/public-api/actors/actor.cpp @@ -54,9 +54,9 @@ Actor::Actor(const Actor& copy) = default; Actor& Actor::operator=(const Actor& rhs) = default; -Actor::Actor(Actor&& rhs) = default; +Actor::Actor(Actor&& rhs) noexcept = default; -Actor& Actor::operator=(Actor&& rhs) = default; +Actor& Actor::operator=(Actor&& rhs) noexcept = default; Layer Actor::GetLayer() { diff --git a/dali/public-api/actors/actor.h b/dali/public-api/actors/actor.h index 0252ce5..8d3e9b6 100644 --- a/dali/public-api/actors/actor.h +++ b/dali/public-api/actors/actor.h @@ -807,7 +807,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the actor to move */ - Actor(Actor&& rhs); + Actor(Actor&& rhs) noexcept; /** * @brief Move assignment operator. @@ -816,7 +816,7 @@ public: * @param[in] rhs A reference to the actor to move * @return A reference to this */ - Actor& operator=(Actor&& rhs); + Actor& operator=(Actor&& rhs) noexcept; // Containment diff --git a/dali/public-api/actors/camera-actor.cpp b/dali/public-api/actors/camera-actor.cpp index 10593d7..fa8f08c 100644 --- a/dali/public-api/actors/camera-actor.cpp +++ b/dali/public-api/actors/camera-actor.cpp @@ -62,9 +62,9 @@ CameraActor::CameraActor(const CameraActor& copy) = default; CameraActor& CameraActor::operator=(const CameraActor& rhs) = default; -CameraActor::CameraActor(CameraActor&& rhs) = default; +CameraActor::CameraActor(CameraActor&& rhs) noexcept = default; -CameraActor& CameraActor::operator=(CameraActor&& rhs) = default; +CameraActor& CameraActor::operator=(CameraActor&& rhs) noexcept = default; void CameraActor::SetType(Dali::Camera::Type type) { diff --git a/dali/public-api/actors/camera-actor.h b/dali/public-api/actors/camera-actor.h index 00337f2..5f5268b 100644 --- a/dali/public-api/actors/camera-actor.h +++ b/dali/public-api/actors/camera-actor.h @@ -208,7 +208,7 @@ public: * @SINCE_2_2.4 * @param[in] rhs A reference to the actor to move */ - CameraActor(CameraActor&& rhs); + CameraActor(CameraActor&& rhs) noexcept; /** * @brief Move assignment operator. @@ -217,7 +217,7 @@ public: * @param[in] rhs A reference to the actor to move * @return A reference to this */ - CameraActor& operator=(CameraActor&& rhs); + CameraActor& operator=(CameraActor&& rhs) noexcept; /** * @brief Sets the camera type. diff --git a/dali/public-api/actors/custom-actor.cpp b/dali/public-api/actors/custom-actor.cpp index bceb7e1..99cf536 100644 --- a/dali/public-api/actors/custom-actor.cpp +++ b/dali/public-api/actors/custom-actor.cpp @@ -51,9 +51,9 @@ CustomActor::CustomActor(const CustomActor& copy) = default; CustomActor& CustomActor::operator=(const CustomActor& rhs) = default; -CustomActor::CustomActor(CustomActor&& rhs) = default; +CustomActor::CustomActor(CustomActor&& rhs) noexcept = default; -CustomActor& CustomActor::operator=(CustomActor&& rhs) = default; +CustomActor& CustomActor::operator=(CustomActor&& rhs) noexcept = default; CustomActorImpl& CustomActor::GetImplementation() { diff --git a/dali/public-api/actors/custom-actor.h b/dali/public-api/actors/custom-actor.h index d353d6c..329840e 100644 --- a/dali/public-api/actors/custom-actor.h +++ b/dali/public-api/actors/custom-actor.h @@ -119,7 +119,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs The actor to move */ - CustomActor(CustomActor&& rhs); + CustomActor(CustomActor&& rhs) noexcept; /** * @brief Move assignment operator. @@ -128,7 +128,7 @@ public: * @param[in] rhs The actor to move * @return A reference to this */ - CustomActor& operator=(CustomActor&& rhs); + CustomActor& operator=(CustomActor&& rhs) noexcept; public: // Not intended for application developers /** diff --git a/dali/public-api/actors/drawable-actor.h b/dali/public-api/actors/drawable-actor.h index 72a94c2..f0b0ac5 100644 --- a/dali/public-api/actors/drawable-actor.h +++ b/dali/public-api/actors/drawable-actor.h @@ -60,6 +60,39 @@ public: */ DrawableActor() = default; + /** + * @brief Copy constructor. + * + * @SINCE_2_2.17 + * @param[in] copy The actor to copy + */ + DrawableActor(const DrawableActor& copy) = default; + + /** + * @brief Assignment operator. + * + * @SINCE_2_2.17 + * @param[in] rhs The actor to copy + * @return A reference to this + */ + DrawableActor& operator=(const DrawableActor& rhs) = default; + + /** + * @brief Move constructor. + * + * @SINCE_2_2.17 + * @param[in] rhs The actor to move + */ + DrawableActor(DrawableActor&& rhs) noexcept = default; + + /** + * @brief Move assignment operator. + * + * @SINCE_2_2.17 + * @param[in] rhs The actor to move + * @return A reference to this + */ + DrawableActor& operator=(DrawableActor&& rhs) noexcept = default; private: explicit DrawableActor(Internal::DrawableActor* internal); }; diff --git a/dali/public-api/actors/layer.cpp b/dali/public-api/actors/layer.cpp index 31d1729..2f19079 100644 --- a/dali/public-api/actors/layer.cpp +++ b/dali/public-api/actors/layer.cpp @@ -43,9 +43,9 @@ Layer::Layer(const Layer& copy) = default; Layer& Layer::operator=(const Layer& rhs) = default; -Layer::Layer(Layer&& rhs) = default; +Layer::Layer(Layer&& rhs) noexcept = default; -Layer& Layer::operator=(Layer&& rhs) = default; +Layer& Layer::operator=(Layer&& rhs) noexcept = default; void Layer::Raise() { diff --git a/dali/public-api/actors/layer.h b/dali/public-api/actors/layer.h index 13f5328..311f63d 100644 --- a/dali/public-api/actors/layer.h +++ b/dali/public-api/actors/layer.h @@ -277,7 +277,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs The layer to move */ - Layer(Layer&& rhs); + Layer(Layer&& rhs) noexcept; /** * @brief Move assignment operator. @@ -286,7 +286,7 @@ public: * @param[in] rhs The layer to move * @return A reference to this */ - Layer& operator=(Layer&& rhs); + Layer& operator=(Layer&& rhs) noexcept; /** * @brief Increments the depth of the layer. diff --git a/dali/public-api/animation/animation.cpp b/dali/public-api/animation/animation.cpp index d1987c5..fbb8a93 100644 --- a/dali/public-api/animation/animation.cpp +++ b/dali/public-api/animation/animation.cpp @@ -52,9 +52,9 @@ Animation::Animation(const Animation& handle) = default; Animation& Animation::operator=(const Animation& rhs) = default; -Animation::Animation(Animation&& rhs) = default; +Animation::Animation(Animation&& rhs) noexcept = default; -Animation& Animation::operator=(Animation&& rhs) = default; +Animation& Animation::operator=(Animation&& rhs) noexcept = default; void Animation::SetDuration(float durationSeconds) { diff --git a/dali/public-api/animation/animation.h b/dali/public-api/animation/animation.h index 73599f4..4117d01 100644 --- a/dali/public-api/animation/animation.h +++ b/dali/public-api/animation/animation.h @@ -237,7 +237,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - Animation(Animation&& rhs); + Animation(Animation&& rhs) noexcept; /** * @brief Move assignment operator. @@ -246,7 +246,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - Animation& operator=(Animation&& rhs); + Animation& operator=(Animation&& rhs) noexcept; /** * @brief Sets the duration of an animation. diff --git a/dali/public-api/animation/constraint.cpp b/dali/public-api/animation/constraint.cpp index 4175919..8fdc606 100644 --- a/dali/public-api/animation/constraint.cpp +++ b/dali/public-api/animation/constraint.cpp @@ -51,9 +51,9 @@ Constraint::Constraint(const Constraint& constraint) = default; Constraint& Constraint::operator=(const Constraint& rhs) = default; -Constraint::Constraint(Constraint&& rhs) = default; +Constraint::Constraint(Constraint&& rhs) noexcept = default; -Constraint& Constraint::operator=(Constraint&& rhs) = default; +Constraint& Constraint::operator=(Constraint&& rhs) noexcept = default; Constraint Constraint::DownCast(BaseHandle baseHandle) { diff --git a/dali/public-api/animation/constraint.h b/dali/public-api/animation/constraint.h index 6bdcb7c..8df0446 100644 --- a/dali/public-api/animation/constraint.h +++ b/dali/public-api/animation/constraint.h @@ -423,7 +423,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - Constraint(Constraint&& rhs); + Constraint(Constraint&& rhs) noexcept; /** * @brief Move assignment operator. @@ -432,7 +432,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - Constraint& operator=(Constraint&& rhs); + Constraint& operator=(Constraint&& rhs) noexcept; /** * @brief Downcasts a handle to Constraint handle. diff --git a/dali/public-api/animation/key-frames.cpp b/dali/public-api/animation/key-frames.cpp index bff6040..a700771 100644 --- a/dali/public-api/animation/key-frames.cpp +++ b/dali/public-api/animation/key-frames.cpp @@ -45,9 +45,9 @@ KeyFrames::KeyFrames(const KeyFrames& handle) = default; KeyFrames& KeyFrames::operator=(const KeyFrames& rhs) = default; -KeyFrames::KeyFrames(KeyFrames&& rhs) = default; +KeyFrames::KeyFrames(KeyFrames&& rhs) noexcept = default; -KeyFrames& KeyFrames::operator=(KeyFrames&& rhs) = default; +KeyFrames& KeyFrames::operator=(KeyFrames&& rhs) noexcept = default; Property::Type KeyFrames::GetType() const { diff --git a/dali/public-api/animation/key-frames.h b/dali/public-api/animation/key-frames.h index 0d140b0..d7bafc7 100644 --- a/dali/public-api/animation/key-frames.h +++ b/dali/public-api/animation/key-frames.h @@ -107,7 +107,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - KeyFrames(KeyFrames&& rhs); + KeyFrames(KeyFrames&& rhs) noexcept; /** * @brief Move assignment operator. @@ -116,7 +116,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - KeyFrames& operator=(KeyFrames&& rhs); + KeyFrames& operator=(KeyFrames&& rhs) noexcept; /** * @brief Gets the type of the key frame. diff --git a/dali/public-api/animation/linear-constrainer.cpp b/dali/public-api/animation/linear-constrainer.cpp index 3f147a4..d3b7f29 100644 --- a/dali/public-api/animation/linear-constrainer.cpp +++ b/dali/public-api/animation/linear-constrainer.cpp @@ -47,9 +47,9 @@ LinearConstrainer::LinearConstrainer(Internal::LinearConstrainer* internal) LinearConstrainer& LinearConstrainer::operator=(const LinearConstrainer& rhs) = default; -LinearConstrainer::LinearConstrainer(LinearConstrainer&& rhs) = default; +LinearConstrainer::LinearConstrainer(LinearConstrainer&& rhs) noexcept = default; -LinearConstrainer& LinearConstrainer::operator=(LinearConstrainer&& rhs) = default; +LinearConstrainer& LinearConstrainer::operator=(LinearConstrainer&& rhs) noexcept = default; void LinearConstrainer::Apply(Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap) { diff --git a/dali/public-api/animation/linear-constrainer.h b/dali/public-api/animation/linear-constrainer.h index 3346b24..87473f6 100644 --- a/dali/public-api/animation/linear-constrainer.h +++ b/dali/public-api/animation/linear-constrainer.h @@ -133,7 +133,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - LinearConstrainer(LinearConstrainer&& rhs); + LinearConstrainer(LinearConstrainer&& rhs) noexcept; /** * @brief Move assignment operator. @@ -142,7 +142,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - LinearConstrainer& operator=(LinearConstrainer&& rhs); + LinearConstrainer& operator=(LinearConstrainer&& rhs) noexcept; /** * @brief Applies the linear constraint to the target property. diff --git a/dali/public-api/animation/path.cpp b/dali/public-api/animation/path.cpp index d5666a3..133ae94 100644 --- a/dali/public-api/animation/path.cpp +++ b/dali/public-api/animation/path.cpp @@ -47,9 +47,9 @@ Path::Path(Internal::Path* internal) Path& Path::operator=(const Path& rhs) = default; -Path::Path(Path&& rhs) = default; +Path::Path(Path&& rhs) noexcept = default; -Path& Path::operator=(Path&& rhs) = default; +Path& Path::operator=(Path&& rhs) noexcept = default; void Path::AddPoint(const Vector3& point) { diff --git a/dali/public-api/animation/path.h b/dali/public-api/animation/path.h index efb70bb..ceafd15 100644 --- a/dali/public-api/animation/path.h +++ b/dali/public-api/animation/path.h @@ -120,7 +120,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - Path(Path&& rhs); + Path(Path&& rhs) noexcept; /** * @brief Move assignment operator. @@ -129,7 +129,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - Path& operator=(Path&& rhs); + Path& operator=(Path&& rhs) noexcept; /** * @brief Adds an interpolation point. diff --git a/dali/public-api/common/extents.h b/dali/public-api/common/extents.h index 507d1a1..922a955 100644 --- a/dali/public-api/common/extents.h +++ b/dali/public-api/common/extents.h @@ -52,6 +52,13 @@ struct DALI_CORE_API Extents Extents(const Extents& copy) = default; /** + * @brief Move constructor. + * @SINCE_2_2.17 + * @param[in] move A reference to the moved Extents + */ + Extents(Extents&& move) = default; + + /** * @brief Constructor. * * @SINCE_1_2.62 @@ -71,6 +78,14 @@ struct DALI_CORE_API Extents Extents& operator=(const Extents& copy) = default; /** + * @brief Move Assignment operator. + * @SINCE_2_2.17 + * @param[in] move A reference to the moved Extents + * @return Itself + */ + Extents& operator=(Extents&& move) = default; + + /** * @brief Assignment operator. * * @SINCE_1_2.62 diff --git a/dali/public-api/dali-core-version.cpp b/dali/public-api/dali-core-version.cpp index 9f070e2..4d66333 100644 --- a/dali/public-api/dali-core-version.cpp +++ b/dali/public-api/dali-core-version.cpp @@ -27,7 +27,7 @@ namespace Dali { const uint32_t CORE_MAJOR_VERSION = 2; const uint32_t CORE_MINOR_VERSION = 2; -const uint32_t CORE_MICRO_VERSION = 15; +const uint32_t CORE_MICRO_VERSION = 17; const char* const CORE_BUILD_DATE = __DATE__ " " __TIME__; #ifdef DEBUG_ENABLED diff --git a/dali/public-api/events/gesture-detector.cpp b/dali/public-api/events/gesture-detector.cpp index f59fa01..d1d6d0e 100644 --- a/dali/public-api/events/gesture-detector.cpp +++ b/dali/public-api/events/gesture-detector.cpp @@ -41,9 +41,9 @@ GestureDetector::GestureDetector(const GestureDetector& handle) = default; GestureDetector& GestureDetector::operator=(const GestureDetector& rhs) = default; -GestureDetector::GestureDetector(GestureDetector&& handle) = default; +GestureDetector::GestureDetector(GestureDetector&& handle) noexcept = default; -GestureDetector& GestureDetector::operator=(GestureDetector&& rhs) = default; +GestureDetector& GestureDetector::operator=(GestureDetector&& rhs) noexcept = default; void GestureDetector::Attach(Actor actor) { diff --git a/dali/public-api/events/gesture-detector.h b/dali/public-api/events/gesture-detector.h index 5ddcc4d..432d9bc 100644 --- a/dali/public-api/events/gesture-detector.h +++ b/dali/public-api/events/gesture-detector.h @@ -102,7 +102,7 @@ public: // Creation & Destruction * @SINCE_2_2.4 * @param[in] handle A reference to the moved handle */ - GestureDetector(GestureDetector&& handle); + GestureDetector(GestureDetector&& handle) noexcept; /** * @brief This move assignment operator is required for (smart) pointer semantics. @@ -111,7 +111,7 @@ public: // Creation & Destruction * @param[in] rhs A reference to the moved handle * @return A reference to this */ - GestureDetector& operator=(GestureDetector&& rhs); + GestureDetector& operator=(GestureDetector&& rhs) noexcept; public: // Actor related /** diff --git a/dali/public-api/events/gesture.cpp b/dali/public-api/events/gesture.cpp index da26137..575ead0 100644 --- a/dali/public-api/events/gesture.cpp +++ b/dali/public-api/events/gesture.cpp @@ -32,11 +32,11 @@ Gesture::Gesture(Internal::Gesture* internal) Gesture::Gesture(const Gesture& rhs) = default; -Gesture::Gesture(Gesture&& rhs) = default; +Gesture::Gesture(Gesture&& rhs)noexcept = default; Gesture& Gesture::operator=(const Gesture& rhs) = default; -Gesture& Gesture::operator=(Gesture&& rhs) = default; +Gesture& Gesture::operator=(Gesture&& rhs)noexcept = default; Gesture::~Gesture() = default; diff --git a/dali/public-api/events/gesture.h b/dali/public-api/events/gesture.h index 2529cb9..571a593 100644 --- a/dali/public-api/events/gesture.h +++ b/dali/public-api/events/gesture.h @@ -76,7 +76,7 @@ public: * @SINCE_1_9.28 * @param[in] rhs A reference to the handle to move */ - Gesture(Gesture&& rhs); + Gesture(Gesture&& rhs) noexcept; /** * @brief Assignment operator. @@ -92,7 +92,7 @@ public: * @param[in] rhs A reference to the handle to move * @return A reference to this */ - Gesture& operator=(Gesture&& rhs); + Gesture& operator=(Gesture&& rhs) noexcept; /** * @brief Non virtual destructor. diff --git a/dali/public-api/events/hover-event.cpp b/dali/public-api/events/hover-event.cpp index 754db44..962bc1d 100644 --- a/dali/public-api/events/hover-event.cpp +++ b/dali/public-api/events/hover-event.cpp @@ -31,13 +31,13 @@ HoverEvent::HoverEvent() HoverEvent::HoverEvent(const HoverEvent& rhs) = default; -HoverEvent::HoverEvent(HoverEvent&& rhs) = default; +HoverEvent::HoverEvent(HoverEvent&& rhs) noexcept = default; HoverEvent::~HoverEvent() = default; HoverEvent& HoverEvent::operator=(const HoverEvent& rhs) = default; -HoverEvent& HoverEvent::operator=(HoverEvent&& rhs) = default; +HoverEvent& HoverEvent::operator=(HoverEvent&& rhs) noexcept = default; unsigned long HoverEvent::GetTime() const { diff --git a/dali/public-api/events/hover-event.h b/dali/public-api/events/hover-event.h index 26593b5..aed8899 100644 --- a/dali/public-api/events/hover-event.h +++ b/dali/public-api/events/hover-event.h @@ -75,7 +75,7 @@ public: * @SINCE_1_9.25 * @param[in] rhs A reference to the moved HoverEvent */ - HoverEvent(HoverEvent&& rhs); + HoverEvent(HoverEvent&& rhs) noexcept; /** * @brief Destructor. @@ -101,7 +101,7 @@ public: * @param[in] rhs A reference to the moved HoverEvent * @return A reference to this */ - HoverEvent& operator=(HoverEvent&& rhs); + HoverEvent& operator=(HoverEvent&& rhs) noexcept; // Getters diff --git a/dali/public-api/events/key-event.cpp b/dali/public-api/events/key-event.cpp index fe6bfcf..9693649 100644 --- a/dali/public-api/events/key-event.cpp +++ b/dali/public-api/events/key-event.cpp @@ -30,13 +30,13 @@ KeyEvent::KeyEvent() KeyEvent::KeyEvent(const KeyEvent& rhs) = default; -KeyEvent::KeyEvent(KeyEvent&& rhs) = default; +KeyEvent::KeyEvent(KeyEvent&& rhs) noexcept = default; KeyEvent::~KeyEvent() = default; KeyEvent& KeyEvent::operator=(const KeyEvent& rhs) = default; -KeyEvent& KeyEvent::operator=(KeyEvent&& rhs) = default; +KeyEvent& KeyEvent::operator=(KeyEvent&& rhs) noexcept = default; bool KeyEvent::IsShiftModifier() const { diff --git a/dali/public-api/events/key-event.h b/dali/public-api/events/key-event.h index b1e332c..d853c91 100644 --- a/dali/public-api/events/key-event.h +++ b/dali/public-api/events/key-event.h @@ -90,7 +90,7 @@ public: * @SINCE_1_9.27 * @param[in] rhs A reference to the moved handle */ - KeyEvent(KeyEvent&& rhs); + KeyEvent(KeyEvent&& rhs) noexcept; /** * @brief Copy assignment operator. @@ -107,7 +107,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - KeyEvent& operator=(KeyEvent&& rhs); + KeyEvent& operator=(KeyEvent&& rhs) noexcept; /** * @brief Destructor. diff --git a/dali/public-api/events/long-press-gesture-detector.cpp b/dali/public-api/events/long-press-gesture-detector.cpp index a525b71..665122e 100644 --- a/dali/public-api/events/long-press-gesture-detector.cpp +++ b/dali/public-api/events/long-press-gesture-detector.cpp @@ -62,9 +62,9 @@ LongPressGestureDetector::LongPressGestureDetector(const LongPressGestureDetecto LongPressGestureDetector& LongPressGestureDetector::operator=(const LongPressGestureDetector& rhs) = default; -LongPressGestureDetector::LongPressGestureDetector(LongPressGestureDetector&& handle) = default; +LongPressGestureDetector::LongPressGestureDetector(LongPressGestureDetector&& handle) noexcept = default; -LongPressGestureDetector& LongPressGestureDetector::operator=(LongPressGestureDetector&& rhs) = default; +LongPressGestureDetector& LongPressGestureDetector::operator=(LongPressGestureDetector&& rhs) noexcept = default; void LongPressGestureDetector::SetTouchesRequired(uint32_t touches) { diff --git a/dali/public-api/events/long-press-gesture-detector.h b/dali/public-api/events/long-press-gesture-detector.h index 472cd4a..afdcf40 100644 --- a/dali/public-api/events/long-press-gesture-detector.h +++ b/dali/public-api/events/long-press-gesture-detector.h @@ -149,7 +149,7 @@ public: // Creation & Destruction * @SINCE_2_2.4 * @param[in] handle A reference to the moved handle */ - LongPressGestureDetector(LongPressGestureDetector&& handle); + LongPressGestureDetector(LongPressGestureDetector&& handle) noexcept; /** * @brief This move assignment operator is required for (smart) pointer semantics. @@ -158,7 +158,7 @@ public: // Creation & Destruction * @param[in] rhs A reference to the moved handle * @return A reference to this */ - LongPressGestureDetector& operator=(LongPressGestureDetector&& rhs); + LongPressGestureDetector& operator=(LongPressGestureDetector&& rhs) noexcept; public: // Setters /** diff --git a/dali/public-api/events/long-press-gesture.cpp b/dali/public-api/events/long-press-gesture.cpp index 9a08810..eee597a 100644 --- a/dali/public-api/events/long-press-gesture.cpp +++ b/dali/public-api/events/long-press-gesture.cpp @@ -32,11 +32,11 @@ LongPressGesture::LongPressGesture() = default; LongPressGesture::LongPressGesture(const LongPressGesture& rhs) = default; -LongPressGesture::LongPressGesture(LongPressGesture&& rhs) = default; +LongPressGesture::LongPressGesture(LongPressGesture&& rhs) noexcept = default; LongPressGesture& LongPressGesture::operator=(const LongPressGesture& rhs) = default; -LongPressGesture& LongPressGesture::operator=(LongPressGesture&& rhs) = default; +LongPressGesture& LongPressGesture::operator=(LongPressGesture&& rhs) noexcept = default; LongPressGesture::~LongPressGesture() = default; diff --git a/dali/public-api/events/long-press-gesture.h b/dali/public-api/events/long-press-gesture.h index d28a3cf..10f0b40 100644 --- a/dali/public-api/events/long-press-gesture.h +++ b/dali/public-api/events/long-press-gesture.h @@ -68,7 +68,7 @@ public: * @SINCE_1_9.28 * @param[in] rhs A reference to the handle to move */ - LongPressGesture(LongPressGesture&& rhs); + LongPressGesture(LongPressGesture&& rhs) noexcept; /** * @brief Assignment operator. @@ -84,7 +84,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - LongPressGesture& operator=(LongPressGesture&& rhs); + LongPressGesture& operator=(LongPressGesture&& rhs) noexcept; /** * @brief Non virtual destructor. diff --git a/dali/public-api/events/pan-gesture-detector.cpp b/dali/public-api/events/pan-gesture-detector.cpp index 6bf50c6..224ae34 100644 --- a/dali/public-api/events/pan-gesture-detector.cpp +++ b/dali/public-api/events/pan-gesture-detector.cpp @@ -56,9 +56,9 @@ PanGestureDetector::PanGestureDetector(const PanGestureDetector& handle) = defau PanGestureDetector& PanGestureDetector::operator=(const PanGestureDetector& rhs) = default; -PanGestureDetector::PanGestureDetector(PanGestureDetector&& handle) = default; +PanGestureDetector::PanGestureDetector(PanGestureDetector&& handle) noexcept = default; -PanGestureDetector& PanGestureDetector::operator=(PanGestureDetector&& rhs) = default; +PanGestureDetector& PanGestureDetector::operator=(PanGestureDetector&& rhs) noexcept = default; void PanGestureDetector::SetMinimumTouchesRequired(uint32_t minimum) { diff --git a/dali/public-api/events/pan-gesture-detector.h b/dali/public-api/events/pan-gesture-detector.h index edca424..7a0108d 100644 --- a/dali/public-api/events/pan-gesture-detector.h +++ b/dali/public-api/events/pan-gesture-detector.h @@ -163,7 +163,7 @@ public: // Creation & Destruction * @SINCE_2_2.4 * @param[in] handle A reference to the moved handle */ - PanGestureDetector(PanGestureDetector&& handle); + PanGestureDetector(PanGestureDetector&& handle) noexcept; /** * @brief This move assignment operator is required for (smart) pointer semantics. @@ -172,7 +172,7 @@ public: // Creation & Destruction * @param[in] rhs A reference to the moved handle * @return A reference to this */ - PanGestureDetector& operator=(PanGestureDetector&& rhs); + PanGestureDetector& operator=(PanGestureDetector&& rhs) noexcept; public: // Setters /** diff --git a/dali/public-api/events/pan-gesture.cpp b/dali/public-api/events/pan-gesture.cpp index d81c04c..44b0317 100644 --- a/dali/public-api/events/pan-gesture.cpp +++ b/dali/public-api/events/pan-gesture.cpp @@ -33,11 +33,11 @@ PanGesture::PanGesture() = default; PanGesture::PanGesture(const PanGesture& rhs) = default; -PanGesture::PanGesture(PanGesture&& rhs) = default; +PanGesture::PanGesture(PanGesture&& rhs) noexcept = default; PanGesture& PanGesture::operator=(const PanGesture& rhs) = default; -PanGesture& PanGesture::operator=(PanGesture&& rhs) = default; +PanGesture& PanGesture::operator=(PanGesture&& rhs) noexcept = default; PanGesture::~PanGesture() = default; diff --git a/dali/public-api/events/pan-gesture.h b/dali/public-api/events/pan-gesture.h index 69b6e64..93d1535 100644 --- a/dali/public-api/events/pan-gesture.h +++ b/dali/public-api/events/pan-gesture.h @@ -73,7 +73,7 @@ public: * @SINCE_1_9.28 * @param[in] rhs A reference to the moved handle */ - PanGesture(PanGesture&& rhs); + PanGesture(PanGesture&& rhs) noexcept; /** * @brief Assignment operator. @@ -89,7 +89,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - PanGesture& operator=(PanGesture&& rhs); + PanGesture& operator=(PanGesture&& rhs) noexcept; /** * @brief Non virtual destructor. diff --git a/dali/public-api/events/pinch-gesture-detector.cpp b/dali/public-api/events/pinch-gesture-detector.cpp index 8d9fa55..0af9b67 100644 --- a/dali/public-api/events/pinch-gesture-detector.cpp +++ b/dali/public-api/events/pinch-gesture-detector.cpp @@ -48,9 +48,9 @@ PinchGestureDetector::PinchGestureDetector(const PinchGestureDetector& handle) = PinchGestureDetector& PinchGestureDetector::operator=(const PinchGestureDetector& rhs) = default; -PinchGestureDetector::PinchGestureDetector(PinchGestureDetector&& handle) = default; +PinchGestureDetector::PinchGestureDetector(PinchGestureDetector&& handle) noexcept = default; -PinchGestureDetector& PinchGestureDetector::operator=(PinchGestureDetector&& rhs) = default; +PinchGestureDetector& PinchGestureDetector::operator=(PinchGestureDetector&& rhs) noexcept = default; PinchGestureDetector::DetectedSignalType& PinchGestureDetector::DetectedSignal() { diff --git a/dali/public-api/events/pinch-gesture-detector.h b/dali/public-api/events/pinch-gesture-detector.h index 2b5d63a..0fbcadc 100644 --- a/dali/public-api/events/pinch-gesture-detector.h +++ b/dali/public-api/events/pinch-gesture-detector.h @@ -126,7 +126,7 @@ public: // Creation & Destruction * @SINCE_2_2.4 * @param[in] handle A reference to the moved handle */ - PinchGestureDetector(PinchGestureDetector&& handle); + PinchGestureDetector(PinchGestureDetector&& handle) noexcept; /** * @brief This move assignment operator is required for (smart) pointer semantics. @@ -135,7 +135,7 @@ public: // Creation & Destruction * @param[in] rhs A reference to the moved handle * @return A reference to this */ - PinchGestureDetector& operator=(PinchGestureDetector&& rhs); + PinchGestureDetector& operator=(PinchGestureDetector&& rhs) noexcept; public: // Signals /** diff --git a/dali/public-api/events/pinch-gesture.cpp b/dali/public-api/events/pinch-gesture.cpp index 8417785..6f783e5 100644 --- a/dali/public-api/events/pinch-gesture.cpp +++ b/dali/public-api/events/pinch-gesture.cpp @@ -33,11 +33,11 @@ PinchGesture::PinchGesture() = default; PinchGesture::PinchGesture(const PinchGesture& rhs) = default; -PinchGesture::PinchGesture(PinchGesture&& rhs) = default; +PinchGesture::PinchGesture(PinchGesture&& rhs) noexcept = default; PinchGesture& PinchGesture::operator=(const PinchGesture& rhs) = default; -PinchGesture& PinchGesture::operator=(PinchGesture&& rhs) = default; +PinchGesture& PinchGesture::operator=(PinchGesture&& rhs) noexcept = default; PinchGesture::~PinchGesture() = default; diff --git a/dali/public-api/events/pinch-gesture.h b/dali/public-api/events/pinch-gesture.h index 4691bfd..661dffe 100644 --- a/dali/public-api/events/pinch-gesture.h +++ b/dali/public-api/events/pinch-gesture.h @@ -69,7 +69,7 @@ public: * @SINCE_1_9.28 * @param[in] rhs A reference to the moved handle */ - PinchGesture(PinchGesture&& rhs); + PinchGesture(PinchGesture&& rhs) noexcept; /** * @brief Assignment operator. @@ -85,7 +85,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - PinchGesture& operator=(PinchGesture&& rhs); + PinchGesture& operator=(PinchGesture&& rhs) noexcept; /** * @brief Non virtual destructor. diff --git a/dali/public-api/events/rotation-gesture-detector.cpp b/dali/public-api/events/rotation-gesture-detector.cpp index c62deef..def7165 100644 --- a/dali/public-api/events/rotation-gesture-detector.cpp +++ b/dali/public-api/events/rotation-gesture-detector.cpp @@ -48,9 +48,9 @@ RotationGestureDetector::RotationGestureDetector(const RotationGestureDetector& RotationGestureDetector& RotationGestureDetector::operator=(const RotationGestureDetector& rhs) = default; -RotationGestureDetector::RotationGestureDetector(RotationGestureDetector&& handle) = default; +RotationGestureDetector::RotationGestureDetector(RotationGestureDetector&& handle) noexcept = default; -RotationGestureDetector& RotationGestureDetector::operator=(RotationGestureDetector&& rhs) = default; +RotationGestureDetector& RotationGestureDetector::operator=(RotationGestureDetector&& rhs) noexcept = default; RotationGestureDetector::DetectedSignalType& RotationGestureDetector::DetectedSignal() { diff --git a/dali/public-api/events/rotation-gesture-detector.h b/dali/public-api/events/rotation-gesture-detector.h index 01c1548..0e5b57a 100644 --- a/dali/public-api/events/rotation-gesture-detector.h +++ b/dali/public-api/events/rotation-gesture-detector.h @@ -120,7 +120,7 @@ public: // Creation & Destruction * @SINCE_2_2.4 * @param[in] handle A reference to the moved handle */ - RotationGestureDetector(RotationGestureDetector&& handle); + RotationGestureDetector(RotationGestureDetector&& handle) noexcept; /** * @brief This move assignment operator is required for (smart) pointer semantics. @@ -129,7 +129,7 @@ public: // Creation & Destruction * @param[in] rhs A reference to the moved handle * @return A reference to this */ - RotationGestureDetector& operator=(RotationGestureDetector&& rhs); + RotationGestureDetector& operator=(RotationGestureDetector&& rhs) noexcept; public: // Signals /** diff --git a/dali/public-api/events/rotation-gesture.cpp b/dali/public-api/events/rotation-gesture.cpp index 355d910..6a3270a 100644 --- a/dali/public-api/events/rotation-gesture.cpp +++ b/dali/public-api/events/rotation-gesture.cpp @@ -33,11 +33,11 @@ RotationGesture::RotationGesture() = default; RotationGesture::RotationGesture(const RotationGesture& rhs) = default; -RotationGesture::RotationGesture(RotationGesture&& rhs) = default; +RotationGesture::RotationGesture(RotationGesture&& rhs) noexcept = default; RotationGesture& RotationGesture::operator=(const RotationGesture& rhs) = default; -RotationGesture& RotationGesture::operator=(RotationGesture&& rhs) = default; +RotationGesture& RotationGesture::operator=(RotationGesture&& rhs) noexcept = default; RotationGesture::~RotationGesture() = default; diff --git a/dali/public-api/events/rotation-gesture.h b/dali/public-api/events/rotation-gesture.h index 05cbc3a..3b13b9b 100644 --- a/dali/public-api/events/rotation-gesture.h +++ b/dali/public-api/events/rotation-gesture.h @@ -66,7 +66,7 @@ public: * @SINCE_1_9.28 * @param[in] rhs A reference to the moved handle */ - RotationGesture(RotationGesture&& rhs); + RotationGesture(RotationGesture&& rhs) noexcept; /** * @brief Assignment operator. @@ -82,7 +82,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - RotationGesture& operator=(RotationGesture&& rhs); + RotationGesture& operator=(RotationGesture&& rhs) noexcept; /** * @brief Non virtual destructor. diff --git a/dali/public-api/events/tap-gesture-detector.cpp b/dali/public-api/events/tap-gesture-detector.cpp index e45e422..557e138 100644 --- a/dali/public-api/events/tap-gesture-detector.cpp +++ b/dali/public-api/events/tap-gesture-detector.cpp @@ -55,9 +55,9 @@ TapGestureDetector::TapGestureDetector(const TapGestureDetector& handle) = defau TapGestureDetector& TapGestureDetector::operator=(const TapGestureDetector& rhs) = default; -TapGestureDetector::TapGestureDetector(TapGestureDetector&& handle) = default; +TapGestureDetector::TapGestureDetector(TapGestureDetector&& handle) noexcept = default; -TapGestureDetector& TapGestureDetector::operator=(TapGestureDetector&& rhs) = default; +TapGestureDetector& TapGestureDetector::operator=(TapGestureDetector&& rhs) noexcept = default; void TapGestureDetector::SetMinimumTapsRequired(uint32_t taps) { diff --git a/dali/public-api/events/tap-gesture-detector.h b/dali/public-api/events/tap-gesture-detector.h index 2e7392d..de8fa84 100644 --- a/dali/public-api/events/tap-gesture-detector.h +++ b/dali/public-api/events/tap-gesture-detector.h @@ -145,7 +145,7 @@ public: // Creation & Destruction * @SINCE_2_2.4 * @param[in] handle A reference to the moved handle */ - TapGestureDetector(TapGestureDetector&& handle); + TapGestureDetector(TapGestureDetector&& handle) noexcept; /** * @brief This move assignment operator is required for (smart) pointer semantics. @@ -154,7 +154,7 @@ public: // Creation & Destruction * @param[in] rhs A reference to the moved handle * @return A reference to this */ - TapGestureDetector& operator=(TapGestureDetector&& rhs); + TapGestureDetector& operator=(TapGestureDetector&& rhs) noexcept; public: // Setters /** diff --git a/dali/public-api/events/tap-gesture.cpp b/dali/public-api/events/tap-gesture.cpp index 8bec36e..0704924 100644 --- a/dali/public-api/events/tap-gesture.cpp +++ b/dali/public-api/events/tap-gesture.cpp @@ -33,11 +33,11 @@ TapGesture::TapGesture() = default; TapGesture::TapGesture(const TapGesture& rhs) = default; -TapGesture::TapGesture(TapGesture&& rhs) = default; +TapGesture::TapGesture(TapGesture&& rhs) noexcept = default; TapGesture& TapGesture::operator=(const TapGesture& rhs) = default; -TapGesture& TapGesture::operator=(TapGesture&& rhs) = default; +TapGesture& TapGesture::operator=(TapGesture&& rhs) noexcept = default; TapGesture::~TapGesture() = default; diff --git a/dali/public-api/events/tap-gesture.h b/dali/public-api/events/tap-gesture.h index d0efc90..2a8eae5 100644 --- a/dali/public-api/events/tap-gesture.h +++ b/dali/public-api/events/tap-gesture.h @@ -64,7 +64,7 @@ public: * @SINCE_1_9.28 * @param rhs The handle to move. */ - TapGesture(TapGesture&& rhs); + TapGesture(TapGesture&& rhs) noexcept; /** * @brief Assignment operator. @@ -79,7 +79,7 @@ public: * @SINCE_1_9.28 * @param rhs The handle to move. */ - TapGesture& operator=(TapGesture&& rhs); + TapGesture& operator=(TapGesture&& rhs) noexcept; /** * @brief Non virtual destructor. diff --git a/dali/public-api/events/touch-event.cpp b/dali/public-api/events/touch-event.cpp index 215bafa..a222e9f 100644 --- a/dali/public-api/events/touch-event.cpp +++ b/dali/public-api/events/touch-event.cpp @@ -30,13 +30,13 @@ TouchEvent::TouchEvent() = default; TouchEvent::TouchEvent(const TouchEvent& other) = default; -TouchEvent::TouchEvent(TouchEvent&& other) = default; +TouchEvent::TouchEvent(TouchEvent&& other) noexcept = default; TouchEvent::~TouchEvent() = default; TouchEvent& TouchEvent::operator=(const TouchEvent& other) = default; -TouchEvent& TouchEvent::operator=(TouchEvent&& other) = default; +TouchEvent& TouchEvent::operator=(TouchEvent&& other) noexcept = default; unsigned long TouchEvent::GetTime() const { diff --git a/dali/public-api/events/touch-event.h b/dali/public-api/events/touch-event.h index ed99c9c..81e73b1 100644 --- a/dali/public-api/events/touch-event.h +++ b/dali/public-api/events/touch-event.h @@ -85,7 +85,7 @@ public: * @SINCE_1_9.28 * @param[in] other The TouchEvent to move */ - TouchEvent(TouchEvent&& other); + TouchEvent(TouchEvent&& other) noexcept; /** * @brief Destructor. @@ -112,7 +112,7 @@ public: * @param[in] other The TouchEvent to move * @return A reference to this */ - TouchEvent& operator=(TouchEvent&& other); + TouchEvent& operator=(TouchEvent&& other) noexcept; // Getters diff --git a/dali/public-api/events/wheel-event.cpp b/dali/public-api/events/wheel-event.cpp index 95436f5..577adb4 100644 --- a/dali/public-api/events/wheel-event.cpp +++ b/dali/public-api/events/wheel-event.cpp @@ -30,13 +30,13 @@ WheelEvent::WheelEvent() WheelEvent::WheelEvent(const WheelEvent& rhs) = default; -WheelEvent::WheelEvent(WheelEvent&& rhs) = default; +WheelEvent::WheelEvent(WheelEvent&& rhs) noexcept = default; WheelEvent::~WheelEvent() = default; WheelEvent& WheelEvent::operator=(const WheelEvent& rhs) = default; -WheelEvent& WheelEvent::operator=(WheelEvent&& rhs) = default; +WheelEvent& WheelEvent::operator=(WheelEvent&& rhs) noexcept = default; bool WheelEvent::IsShiftModifier() const { diff --git a/dali/public-api/events/wheel-event.h b/dali/public-api/events/wheel-event.h index 0737770..b1da5c0 100644 --- a/dali/public-api/events/wheel-event.h +++ b/dali/public-api/events/wheel-event.h @@ -88,7 +88,7 @@ public: * @SINCE_1_9.26 * @param[in] rhs A reference to the moved WheelEvent */ - WheelEvent(WheelEvent&& rhs); + WheelEvent(WheelEvent&& rhs) noexcept; /** * @brief Destructor. @@ -112,7 +112,7 @@ public: * @param[in] rhs A reference to the moved WheelEvent * @return A reference to this */ - WheelEvent& operator=(WheelEvent&& rhs); + WheelEvent& operator=(WheelEvent&& rhs) noexcept; /** * @brief Checks to see if Shift key modifier has been supplied. diff --git a/dali/public-api/images/pixel-data.cpp b/dali/public-api/images/pixel-data.cpp index c05363a..e69ccf4 100644 --- a/dali/public-api/images/pixel-data.cpp +++ b/dali/public-api/images/pixel-data.cpp @@ -59,9 +59,9 @@ PixelData::PixelData(const PixelData& handle) = default; PixelData& PixelData::operator=(const PixelData& rhs) = default; -PixelData::PixelData(PixelData&& rhs) = default; +PixelData::PixelData(PixelData&& rhs) noexcept = default; -PixelData& PixelData::operator=(PixelData&& rhs) = default; +PixelData& PixelData::operator=(PixelData&& rhs) noexcept = default; uint32_t PixelData::GetWidth() const { diff --git a/dali/public-api/images/pixel-data.h b/dali/public-api/images/pixel-data.h index 70e80da..0fb96db 100644 --- a/dali/public-api/images/pixel-data.h +++ b/dali/public-api/images/pixel-data.h @@ -134,7 +134,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - PixelData(PixelData&& rhs); + PixelData(PixelData&& rhs) noexcept; /** * @brief Move assignment operator. @@ -143,7 +143,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - PixelData& operator=(PixelData&& rhs); + PixelData& operator=(PixelData&& rhs) noexcept; /** * @brief Gets the width of the buffer in pixels. diff --git a/dali/public-api/math/angle-axis.h b/dali/public-api/math/angle-axis.h index 3582d78..721e7a7 100644 --- a/dali/public-api/math/angle-axis.h +++ b/dali/public-api/math/angle-axis.h @@ -69,9 +69,9 @@ struct AngleAxis public: AngleAxis(const AngleAxis&) = default; ///< Default copy constructor - AngleAxis(AngleAxis&&) = default; ///< Default move constructor + AngleAxis(AngleAxis&&) noexcept = default; ///< Default move constructor AngleAxis& operator=(const AngleAxis&) = default; ///< Default copy assignment operator - AngleAxis& operator=(AngleAxis&&) = default; ///< Default move assignment operator + AngleAxis& operator=(AngleAxis&&) noexcept = default; ///< Default move assignment operator public: Radian angle; ///< The angle in radians diff --git a/dali/public-api/math/matrix.cpp b/dali/public-api/math/matrix.cpp index 45b8535..7b810bb 100644 --- a/dali/public-api/math/matrix.cpp +++ b/dali/public-api/math/matrix.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Samsung Electronics Co., Ltd. + * Copyright (c) 2023 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -561,26 +561,29 @@ void Matrix::SetInverseTransformComponents(const Vector3& xAxis, SetTranslation(inverseTranslation); } +Vector3 Matrix::GetScale() const +{ + // Derive scale from axis lengths. + return Vector3(GetXAxis().Length(), GetYAxis().Length(), GetZAxis().Length()); +} + void Matrix::GetTransformComponents(Vector3& position, Quaternion& rotation, Vector3& scale) const { position = GetTranslation3(); + scale = GetScale(); - // Derive scale from axis lengths. - Vector3 theScale(GetXAxis().Length(), GetYAxis().Length(), GetZAxis().Length()); - scale = theScale; - - if(!(fabs(theScale.x - Vector3::ONE.x) < ROTATION_EPSILON && - fabs(theScale.y - Vector3::ONE.y) < ROTATION_EPSILON && - fabs(theScale.z - Vector3::ONE.z) < ROTATION_EPSILON)) + if(!(fabs(scale.x - Vector3::ONE.x) < ROTATION_EPSILON && + fabs(scale.y - Vector3::ONE.y) < ROTATION_EPSILON && + fabs(scale.z - Vector3::ONE.z) < ROTATION_EPSILON)) { MATH_INCREASE_COUNTER(PerformanceMonitor::MATRIX_MULTIPLYS); MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 9); // Non-identity scale is embedded into rotation matrix. Remove it first: Matrix m(*this); - Vector3 inverseScale(1.0f / theScale.x, 1.0f / theScale.y, 1.0f / theScale.z); + Vector3 inverseScale(1.0f / scale.x, 1.0f / scale.y, 1.0f / scale.z); m.mMatrix[0] *= inverseScale.x; m.mMatrix[1] *= inverseScale.x; m.mMatrix[2] *= inverseScale.x; diff --git a/dali/public-api/math/matrix.h b/dali/public-api/math/matrix.h index bdd80bf..332163d 100644 --- a/dali/public-api/math/matrix.h +++ b/dali/public-api/math/matrix.h @@ -2,7 +2,7 @@ #define DALI_MATRIX_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. @@ -257,6 +257,16 @@ public: } /** + * @brief Gets the x,y and z components of the scale as a Vector3. + * Note that transform scale always has positive components. + * + * This assumes the matrix is a transform matrix. + * @SINCE_2_2.17 + * @return The scale + */ + Vector3 GetScale() const; + + /** * @brief Sets the translation. * * This assumes the matrix is a transform matrix. diff --git a/dali/public-api/object/handle.cpp b/dali/public-api/object/handle.cpp index 002b7be..45f8fcd 100644 --- a/dali/public-api/object/handle.cpp +++ b/dali/public-api/object/handle.cpp @@ -46,9 +46,9 @@ Handle::Handle(const Handle& handle) = default; Handle& Handle::operator=(const Handle& rhs) = default; -Handle::Handle(Handle&& rhs) = default; +Handle::Handle(Handle&& rhs) noexcept = default; -Handle& Handle::operator=(Handle&& rhs) = default; +Handle& Handle::operator=(Handle&& rhs) noexcept = default; Handle Handle::DownCast(BaseHandle handle) { diff --git a/dali/public-api/object/handle.h b/dali/public-api/object/handle.h index 549d274..1e4130a 100644 --- a/dali/public-api/object/handle.h +++ b/dali/public-api/object/handle.h @@ -156,7 +156,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - Handle(Handle&& rhs); + Handle(Handle&& rhs) noexcept; /** * @brief Move assignment operator. @@ -165,7 +165,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - Handle& operator=(Handle&& rhs); + Handle& operator=(Handle&& rhs) noexcept; /** * @brief Downcasts to a handle. diff --git a/dali/public-api/object/object-registry.cpp b/dali/public-api/object/object-registry.cpp index b7f9a37..3af5d5b 100644 --- a/dali/public-api/object/object-registry.cpp +++ b/dali/public-api/object/object-registry.cpp @@ -31,9 +31,9 @@ ObjectRegistry::ObjectRegistry(const ObjectRegistry& copy) = default; ObjectRegistry& ObjectRegistry::operator=(const ObjectRegistry& rhs) = default; -ObjectRegistry::ObjectRegistry(ObjectRegistry&& rhs) = default; +ObjectRegistry::ObjectRegistry(ObjectRegistry&& rhs) noexcept = default; -ObjectRegistry& ObjectRegistry::operator=(ObjectRegistry&& rhs) = default; +ObjectRegistry& ObjectRegistry::operator=(ObjectRegistry&& rhs) noexcept = default; ObjectRegistry::ObjectCreatedSignalType& ObjectRegistry::ObjectCreatedSignal() { diff --git a/dali/public-api/object/object-registry.h b/dali/public-api/object/object-registry.h index 4c789be..15a84d9 100644 --- a/dali/public-api/object/object-registry.h +++ b/dali/public-api/object/object-registry.h @@ -113,7 +113,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - ObjectRegistry(ObjectRegistry&& rhs); + ObjectRegistry(ObjectRegistry&& rhs) noexcept; /** * @brief Move assignment operator. @@ -122,7 +122,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - ObjectRegistry& operator=(ObjectRegistry&& rhs); + ObjectRegistry& operator=(ObjectRegistry&& rhs) noexcept; public: // Signals /** diff --git a/dali/public-api/object/property-conditions.cpp b/dali/public-api/object/property-conditions.cpp index 9929d6e..bdfbbf9 100644 --- a/dali/public-api/object/property-conditions.cpp +++ b/dali/public-api/object/property-conditions.cpp @@ -35,9 +35,9 @@ PropertyCondition::PropertyCondition(const PropertyCondition& handle) = default; PropertyCondition& PropertyCondition::operator=(const PropertyCondition& rhs) = default; -PropertyCondition::PropertyCondition(PropertyCondition&& rhs) = default; +PropertyCondition::PropertyCondition(PropertyCondition&& rhs) noexcept = default; -PropertyCondition& PropertyCondition::operator=(PropertyCondition&& rhs) = default; +PropertyCondition& PropertyCondition::operator=(PropertyCondition&& rhs) noexcept = default; std::size_t PropertyCondition::GetArgumentCount() const { diff --git a/dali/public-api/object/property-conditions.h b/dali/public-api/object/property-conditions.h index 36a0df3..a3f39e9 100644 --- a/dali/public-api/object/property-conditions.h +++ b/dali/public-api/object/property-conditions.h @@ -77,7 +77,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - PropertyCondition(PropertyCondition&& rhs); + PropertyCondition(PropertyCondition&& rhs) noexcept; /** * @brief Move assignment operator. @@ -86,7 +86,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - PropertyCondition& operator=(PropertyCondition&& rhs); + PropertyCondition& operator=(PropertyCondition&& rhs) noexcept; public: /** diff --git a/dali/public-api/object/property-notification.cpp b/dali/public-api/object/property-notification.cpp index 6f9e26f..a0b5cab 100644 --- a/dali/public-api/object/property-notification.cpp +++ b/dali/public-api/object/property-notification.cpp @@ -47,9 +47,9 @@ PropertyNotification::PropertyNotification(const PropertyNotification& copy) = d PropertyNotification& PropertyNotification::operator=(const PropertyNotification& rhs) = default; -PropertyNotification::PropertyNotification(PropertyNotification&& rhs) = default; +PropertyNotification::PropertyNotification(PropertyNotification&& rhs) noexcept = default; -PropertyNotification& PropertyNotification::operator=(PropertyNotification&& rhs) = default; +PropertyNotification& PropertyNotification::operator=(PropertyNotification&& rhs) noexcept = default; PropertyCondition PropertyNotification::GetCondition() { diff --git a/dali/public-api/object/property-notification.h b/dali/public-api/object/property-notification.h index 01f14e0..7772336 100644 --- a/dali/public-api/object/property-notification.h +++ b/dali/public-api/object/property-notification.h @@ -111,7 +111,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - PropertyNotification(PropertyNotification&& rhs); + PropertyNotification(PropertyNotification&& rhs) noexcept; /** * @brief Move assignment operator. @@ -120,7 +120,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - PropertyNotification& operator=(PropertyNotification&& rhs); + PropertyNotification& operator=(PropertyNotification&& rhs) noexcept; /** * @brief Gets the condition of this notification. diff --git a/dali/public-api/object/type-info.cpp b/dali/public-api/object/type-info.cpp index 9d5c3cb..6fb2e42 100644 --- a/dali/public-api/object/type-info.cpp +++ b/dali/public-api/object/type-info.cpp @@ -33,9 +33,9 @@ TypeInfo::TypeInfo(const TypeInfo& copy) = default; TypeInfo& TypeInfo::operator=(const TypeInfo& rhs) = default; -TypeInfo::TypeInfo(TypeInfo&& rhs) = default; +TypeInfo::TypeInfo(TypeInfo&& rhs) noexcept = default; -TypeInfo& TypeInfo::operator=(TypeInfo&& rhs) = default; +TypeInfo& TypeInfo::operator=(TypeInfo&& rhs) noexcept = default; const std::string& TypeInfo::GetName() const { diff --git a/dali/public-api/object/type-info.h b/dali/public-api/object/type-info.h index b278c82..9ecabfd 100644 --- a/dali/public-api/object/type-info.h +++ b/dali/public-api/object/type-info.h @@ -126,7 +126,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - TypeInfo(TypeInfo&& rhs); + TypeInfo(TypeInfo&& rhs) noexcept; /** * @brief Move assignment operator. @@ -135,7 +135,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - TypeInfo& operator=(TypeInfo&& rhs); + TypeInfo& operator=(TypeInfo&& rhs) noexcept; /** * @brief Retrieves the type name for this type. diff --git a/dali/public-api/object/type-registry.cpp b/dali/public-api/object/type-registry.cpp index 31d7ad3..2b69d9d 100644 --- a/dali/public-api/object/type-registry.cpp +++ b/dali/public-api/object/type-registry.cpp @@ -35,9 +35,9 @@ TypeRegistry::TypeRegistry(const TypeRegistry& copy) = default; TypeRegistry& TypeRegistry::operator=(const TypeRegistry& rhs) = default; -TypeRegistry::TypeRegistry(TypeRegistry&& rhs) = default; +TypeRegistry::TypeRegistry(TypeRegistry&& rhs) noexcept = default; -TypeRegistry& TypeRegistry::operator=(TypeRegistry&& rhs) = default; +TypeRegistry& TypeRegistry::operator=(TypeRegistry&& rhs) noexcept = default; TypeRegistry TypeRegistry::Get() { diff --git a/dali/public-api/object/type-registry.h b/dali/public-api/object/type-registry.h index e692423..7eddbe2 100644 --- a/dali/public-api/object/type-registry.h +++ b/dali/public-api/object/type-registry.h @@ -140,7 +140,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - TypeRegistry(TypeRegistry&& rhs); + TypeRegistry(TypeRegistry&& rhs) noexcept; /** * @brief Move assignment operator. @@ -149,7 +149,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - TypeRegistry& operator=(TypeRegistry&& rhs); + TypeRegistry& operator=(TypeRegistry&& rhs) noexcept; /** * @brief Gets TypeInfo for a registered type. diff --git a/dali/public-api/object/weak-handle.cpp b/dali/public-api/object/weak-handle.cpp index 3a8ff33..4f5a3f1 100644 --- a/dali/public-api/object/weak-handle.cpp +++ b/dali/public-api/object/weak-handle.cpp @@ -108,13 +108,13 @@ WeakHandleBase& WeakHandleBase::operator=(const WeakHandleBase& rhs) return *this; } -WeakHandleBase::WeakHandleBase(WeakHandleBase&& rhs) +WeakHandleBase::WeakHandleBase(WeakHandleBase&& rhs) noexcept : mImpl(rhs.mImpl) { rhs.mImpl = nullptr; } -WeakHandleBase& WeakHandleBase::operator=(WeakHandleBase&& rhs) +WeakHandleBase& WeakHandleBase::operator=(WeakHandleBase&& rhs) noexcept { if(this != &rhs) { diff --git a/dali/public-api/object/weak-handle.h b/dali/public-api/object/weak-handle.h index b3a8aa7..b64e82c 100644 --- a/dali/public-api/object/weak-handle.h +++ b/dali/public-api/object/weak-handle.h @@ -84,7 +84,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - WeakHandleBase(WeakHandleBase&& rhs); + WeakHandleBase(WeakHandleBase&& rhs) noexcept; /** * @brief Move assignment operator. @@ -93,7 +93,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - WeakHandleBase& operator=(WeakHandleBase&& rhs); + WeakHandleBase& operator=(WeakHandleBase&& rhs) noexcept; /** * @brief Equality operator overload. diff --git a/dali/public-api/render-tasks/render-task-list.cpp b/dali/public-api/render-tasks/render-task-list.cpp index 941c6e7..ae2f9cf 100644 --- a/dali/public-api/render-tasks/render-task-list.cpp +++ b/dali/public-api/render-tasks/render-task-list.cpp @@ -36,9 +36,9 @@ RenderTaskList::RenderTaskList(const RenderTaskList& handle) = default; RenderTaskList& RenderTaskList::operator=(const RenderTaskList& rhs) = default; -RenderTaskList::RenderTaskList(RenderTaskList&& rhs) = default; +RenderTaskList::RenderTaskList(RenderTaskList&& rhs) noexcept = default; -RenderTaskList& RenderTaskList::operator=(RenderTaskList&& rhs) = default; +RenderTaskList& RenderTaskList::operator=(RenderTaskList&& rhs) noexcept = default; RenderTask RenderTaskList::CreateTask() { diff --git a/dali/public-api/render-tasks/render-task-list.h b/dali/public-api/render-tasks/render-task-list.h index 0de427c..afbab77 100644 --- a/dali/public-api/render-tasks/render-task-list.h +++ b/dali/public-api/render-tasks/render-task-list.h @@ -98,7 +98,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - RenderTaskList(RenderTaskList&& rhs); + RenderTaskList(RenderTaskList&& rhs) noexcept; /** * @brief Move assignment operator. @@ -107,7 +107,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - RenderTaskList& operator=(RenderTaskList&& rhs); + RenderTaskList& operator=(RenderTaskList&& rhs) noexcept; /** * @brief Creates a new RenderTask. diff --git a/dali/public-api/render-tasks/render-task.cpp b/dali/public-api/render-tasks/render-task.cpp index e59bd82..cd621e4 100644 --- a/dali/public-api/render-tasks/render-task.cpp +++ b/dali/public-api/render-tasks/render-task.cpp @@ -61,9 +61,9 @@ RenderTask::RenderTask(const RenderTask& handle) = default; RenderTask& RenderTask::operator=(const RenderTask& rhs) = default; -RenderTask::RenderTask(RenderTask&& rhs) = default; +RenderTask::RenderTask(RenderTask&& rhs) noexcept = default; -RenderTask& RenderTask::operator=(RenderTask&& rhs) = default; +RenderTask& RenderTask::operator=(RenderTask&& rhs) noexcept = default; void RenderTask::SetSourceActor(Actor actor) { diff --git a/dali/public-api/render-tasks/render-task.h b/dali/public-api/render-tasks/render-task.h index 0832c4b..683a97e 100644 --- a/dali/public-api/render-tasks/render-task.h +++ b/dali/public-api/render-tasks/render-task.h @@ -230,7 +230,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - RenderTask(RenderTask&& rhs); + RenderTask(RenderTask&& rhs) noexcept; /** * @brief Move assignment operator. @@ -239,7 +239,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - RenderTask& operator=(RenderTask&& rhs); + RenderTask& operator=(RenderTask&& rhs) noexcept; /** * @brief Sets the actors to be rendered. diff --git a/dali/public-api/rendering/decorated-visual-renderer.cpp b/dali/public-api/rendering/decorated-visual-renderer.cpp index debf485..3e85463 100644 --- a/dali/public-api/rendering/decorated-visual-renderer.cpp +++ b/dali/public-api/rendering/decorated-visual-renderer.cpp @@ -44,9 +44,9 @@ DecoratedVisualRenderer DecoratedVisualRenderer::DownCast(BaseHandle handle) DecoratedVisualRenderer& DecoratedVisualRenderer::operator=(const DecoratedVisualRenderer& handle) = default; -DecoratedVisualRenderer::DecoratedVisualRenderer(DecoratedVisualRenderer&& rhs) = default; +DecoratedVisualRenderer::DecoratedVisualRenderer(DecoratedVisualRenderer&& rhs) noexcept = default; -DecoratedVisualRenderer& DecoratedVisualRenderer::operator=(DecoratedVisualRenderer&& rhs) = default; +DecoratedVisualRenderer& DecoratedVisualRenderer::operator=(DecoratedVisualRenderer&& rhs) noexcept = default; void DecoratedVisualRenderer::RegisterCornerRadiusUniform() { diff --git a/dali/public-api/rendering/decorated-visual-renderer.h b/dali/public-api/rendering/decorated-visual-renderer.h index 80563a2..0595829 100644 --- a/dali/public-api/rendering/decorated-visual-renderer.h +++ b/dali/public-api/rendering/decorated-visual-renderer.h @@ -201,7 +201,7 @@ public: * @SINCE_2_1.21 * @param[in] rhs A reference to the moved handle */ - DecoratedVisualRenderer(DecoratedVisualRenderer&& rhs); + DecoratedVisualRenderer(DecoratedVisualRenderer&& rhs) noexcept; /** * @brief Move assignment operator. @@ -210,7 +210,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - DecoratedVisualRenderer& operator=(DecoratedVisualRenderer&& rhs); + DecoratedVisualRenderer& operator=(DecoratedVisualRenderer&& rhs) noexcept; public: /// @cond internal diff --git a/dali/public-api/rendering/frame-buffer.cpp b/dali/public-api/rendering/frame-buffer.cpp index 4b45a92..311d66a 100644 --- a/dali/public-api/rendering/frame-buffer.cpp +++ b/dali/public-api/rendering/frame-buffer.cpp @@ -74,9 +74,9 @@ FrameBuffer::FrameBuffer(Internal::FrameBuffer* pointer) { } -FrameBuffer::FrameBuffer(FrameBuffer&& rhs) = default; +FrameBuffer::FrameBuffer(FrameBuffer&& rhs) noexcept = default; -FrameBuffer& FrameBuffer::operator=(FrameBuffer&& rhs) = default; +FrameBuffer& FrameBuffer::operator=(FrameBuffer&& rhs) noexcept = default; void FrameBuffer::AttachColorTexture(Texture& texture) { diff --git a/dali/public-api/rendering/frame-buffer.h b/dali/public-api/rendering/frame-buffer.h index 9954182..85923d0 100644 --- a/dali/public-api/rendering/frame-buffer.h +++ b/dali/public-api/rendering/frame-buffer.h @@ -138,7 +138,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - FrameBuffer(FrameBuffer&& rhs); + FrameBuffer(FrameBuffer&& rhs) noexcept; /** * @brief Move assignment operator. @@ -147,7 +147,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - FrameBuffer& operator=(FrameBuffer&& rhs); + FrameBuffer& operator=(FrameBuffer&& rhs) noexcept; /** * @brief Attach the base LOD of a 2D texture to the framebuffer for color rendering. diff --git a/dali/public-api/rendering/geometry.cpp b/dali/public-api/rendering/geometry.cpp index a810779..1316497 100644 --- a/dali/public-api/rendering/geometry.cpp +++ b/dali/public-api/rendering/geometry.cpp @@ -42,9 +42,9 @@ Geometry Geometry::DownCast(BaseHandle handle) Geometry& Geometry::operator=(const Geometry& handle) = default; -Geometry::Geometry(Geometry&& rhs) = default; +Geometry::Geometry(Geometry&& rhs) noexcept = default; -Geometry& Geometry::operator=(Geometry&& rhs) = default; +Geometry& Geometry::operator=(Geometry&& rhs) noexcept = default; std::size_t Geometry::AddVertexBuffer(VertexBuffer& vertexBuffer) { diff --git a/dali/public-api/rendering/geometry.h b/dali/public-api/rendering/geometry.h index 81e0421..3ff19a3 100644 --- a/dali/public-api/rendering/geometry.h +++ b/dali/public-api/rendering/geometry.h @@ -117,7 +117,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - Geometry(Geometry&& rhs); + Geometry(Geometry&& rhs) noexcept; /** * @brief Move assignment operator. @@ -126,7 +126,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - Geometry& operator=(Geometry&& rhs); + Geometry& operator=(Geometry&& rhs) noexcept; /** * @brief Adds a VertexBuffer to be used as source of geometry vertices. diff --git a/dali/public-api/rendering/renderer.cpp b/dali/public-api/rendering/renderer.cpp index 326b54b..90cb94e 100644 --- a/dali/public-api/rendering/renderer.cpp +++ b/dali/public-api/rendering/renderer.cpp @@ -51,9 +51,9 @@ Renderer Renderer::DownCast(BaseHandle handle) Renderer& Renderer::operator=(const Renderer& handle) = default; -Renderer::Renderer(Renderer&& rhs) = default; +Renderer::Renderer(Renderer&& rhs) noexcept = default; -Renderer& Renderer::operator=(Renderer&& rhs) = default; +Renderer& Renderer::operator=(Renderer&& rhs) noexcept = default; void Renderer::SetGeometry(Geometry& geometry) { diff --git a/dali/public-api/rendering/renderer.h b/dali/public-api/rendering/renderer.h index e6f1afe..3dfd9ea 100644 --- a/dali/public-api/rendering/renderer.h +++ b/dali/public-api/rendering/renderer.h @@ -484,7 +484,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - Renderer(Renderer&& rhs); + Renderer(Renderer&& rhs) noexcept; /** * @brief Move assignment operator. @@ -493,7 +493,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - Renderer& operator=(Renderer&& rhs); + Renderer& operator=(Renderer&& rhs) noexcept; /** * @brief Sets the geometry to be used by this renderer. diff --git a/dali/public-api/rendering/sampler.cpp b/dali/public-api/rendering/sampler.cpp index 990e2ee..e9a065e 100644 --- a/dali/public-api/rendering/sampler.cpp +++ b/dali/public-api/rendering/sampler.cpp @@ -42,9 +42,9 @@ Sampler Sampler::DownCast(BaseHandle handle) Sampler& Sampler::operator=(const Sampler& handle) = default; -Sampler::Sampler(Sampler&& rhs) = default; +Sampler::Sampler(Sampler&& rhs) noexcept = default; -Sampler& Sampler::operator=(Sampler&& rhs) = default; +Sampler& Sampler::operator=(Sampler&& rhs) noexcept = default; void Sampler::SetFilterMode(FilterMode::Type minFilter, FilterMode::Type magFilter) { diff --git a/dali/public-api/rendering/sampler.h b/dali/public-api/rendering/sampler.h index aeabcf3..dacde4e 100644 --- a/dali/public-api/rendering/sampler.h +++ b/dali/public-api/rendering/sampler.h @@ -97,7 +97,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - Sampler(Sampler&& rhs); + Sampler(Sampler&& rhs) noexcept; /** * @brief Move assignment operator. @@ -106,7 +106,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - Sampler& operator=(Sampler&& rhs); + Sampler& operator=(Sampler&& rhs) noexcept; /** * @brief Sets the filter modes for this sampler. diff --git a/dali/public-api/rendering/shader.cpp b/dali/public-api/rendering/shader.cpp index 7456d9e..bedf275 100644 --- a/dali/public-api/rendering/shader.cpp +++ b/dali/public-api/rendering/shader.cpp @@ -44,9 +44,9 @@ Shader Shader::DownCast(BaseHandle handle) Shader& Shader::operator=(const Shader& handle) = default; -Shader::Shader(Shader&& rhs) = default; +Shader::Shader(Shader&& rhs) noexcept = default; -Shader& Shader::operator=(Shader&& rhs) = default; +Shader& Shader::operator=(Shader&& rhs) noexcept = default; Shader::Shader(Internal::Shader* pointer) : Handle(pointer) diff --git a/dali/public-api/rendering/shader.h b/dali/public-api/rendering/shader.h index 19e138d..9c726af 100644 --- a/dali/public-api/rendering/shader.h +++ b/dali/public-api/rendering/shader.h @@ -176,7 +176,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - Shader(Shader&& rhs); + Shader(Shader&& rhs) noexcept; /** * @brief Move assignment operator. @@ -185,7 +185,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this */ - Shader& operator=(Shader&& rhs); + Shader& operator=(Shader&& rhs) noexcept; /** * @brief Get shader preprocessor of shading language version. diff --git a/dali/public-api/rendering/texture-set.cpp b/dali/public-api/rendering/texture-set.cpp index b59d0bc..c045862 100644 --- a/dali/public-api/rendering/texture-set.cpp +++ b/dali/public-api/rendering/texture-set.cpp @@ -44,9 +44,9 @@ TextureSet TextureSet::DownCast(BaseHandle handle) TextureSet& TextureSet::operator=(const TextureSet& handle) = default; -TextureSet::TextureSet(TextureSet&& rhs) = default; +TextureSet::TextureSet(TextureSet&& rhs) noexcept = default; -TextureSet& TextureSet::operator=(TextureSet&& rhs) = default; +TextureSet& TextureSet::operator=(TextureSet&& rhs) noexcept = default; void TextureSet::SetTexture(size_t index, Texture texture) { diff --git a/dali/public-api/rendering/texture-set.h b/dali/public-api/rendering/texture-set.h index f1525e6..d53dc58 100644 --- a/dali/public-api/rendering/texture-set.h +++ b/dali/public-api/rendering/texture-set.h @@ -101,7 +101,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - TextureSet(TextureSet&& rhs); + TextureSet(TextureSet&& rhs) noexcept; /** * @brief Move assignment operator. @@ -110,7 +110,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - TextureSet& operator=(TextureSet&& rhs); + TextureSet& operator=(TextureSet&& rhs) noexcept; /** * @brief Sets the texture at position "index". diff --git a/dali/public-api/rendering/texture.cpp b/dali/public-api/rendering/texture.cpp index a8925c7..2f62053 100644 --- a/dali/public-api/rendering/texture.cpp +++ b/dali/public-api/rendering/texture.cpp @@ -49,9 +49,9 @@ Texture Texture::DownCast(BaseHandle handle) Texture& Texture::operator=(const Texture& handle) = default; -Texture::Texture(Texture&& rhs) = default; +Texture::Texture(Texture&& rhs) noexcept = default; -Texture& Texture::operator=(Texture&& rhs) = default; +Texture& Texture::operator=(Texture&& rhs) noexcept = default; bool Texture::Upload(PixelData pixelData) { diff --git a/dali/public-api/rendering/texture.h b/dali/public-api/rendering/texture.h index 59e14ce..9819677 100644 --- a/dali/public-api/rendering/texture.h +++ b/dali/public-api/rendering/texture.h @@ -143,7 +143,7 @@ public: * @SINCE_1_9.22 * @param[in] rhs A reference to the moved handle */ - Texture(Texture&& rhs); + Texture(Texture&& rhs) noexcept; /** * @brief Move assignment operator. @@ -152,7 +152,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - Texture& operator=(Texture&& rhs); + Texture& operator=(Texture&& rhs) noexcept; /** * @brief Uploads data to the texture from a PixelData object. diff --git a/dali/public-api/rendering/vertex-buffer.cpp b/dali/public-api/rendering/vertex-buffer.cpp index 4adb49b..c2351c4 100644 --- a/dali/public-api/rendering/vertex-buffer.cpp +++ b/dali/public-api/rendering/vertex-buffer.cpp @@ -44,9 +44,9 @@ VertexBuffer VertexBuffer::DownCast(BaseHandle handle) VertexBuffer& VertexBuffer::operator=(const VertexBuffer& handle) = default; -VertexBuffer::VertexBuffer(VertexBuffer&& rhs) = default; +VertexBuffer::VertexBuffer(VertexBuffer&& rhs) noexcept = default; -VertexBuffer& VertexBuffer::operator=(VertexBuffer&& rhs) = default; +VertexBuffer& VertexBuffer::operator=(VertexBuffer&& rhs) noexcept = default; void VertexBuffer::SetData(const void* data, std::size_t size) { diff --git a/dali/public-api/rendering/vertex-buffer.h b/dali/public-api/rendering/vertex-buffer.h index 5c25bec..6c80284 100644 --- a/dali/public-api/rendering/vertex-buffer.h +++ b/dali/public-api/rendering/vertex-buffer.h @@ -128,7 +128,7 @@ public: * @SINCE_1_9.27 * @param[in] rhs A reference to the moved handle */ - VertexBuffer(VertexBuffer&& rhs); + VertexBuffer(VertexBuffer&& rhs) noexcept; /** * @brief Move assignment operator. @@ -137,7 +137,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - VertexBuffer& operator=(VertexBuffer&& rhs); + VertexBuffer& operator=(VertexBuffer&& rhs) noexcept; /** * @brief Updates the whole buffer information. diff --git a/dali/public-api/rendering/visual-renderer.cpp b/dali/public-api/rendering/visual-renderer.cpp index 224efd0..96db442 100644 --- a/dali/public-api/rendering/visual-renderer.cpp +++ b/dali/public-api/rendering/visual-renderer.cpp @@ -44,9 +44,9 @@ VisualRenderer VisualRenderer::DownCast(BaseHandle handle) VisualRenderer& VisualRenderer::operator=(const VisualRenderer& handle) = default; -VisualRenderer::VisualRenderer(VisualRenderer&& rhs) = default; +VisualRenderer::VisualRenderer(VisualRenderer&& rhs) noexcept = default; -VisualRenderer& VisualRenderer::operator=(VisualRenderer&& rhs) = default; +VisualRenderer& VisualRenderer::operator=(VisualRenderer&& rhs) noexcept = default; VisualRenderer::VisualRenderer(Internal::VisualRenderer* pointer) : Dali::Renderer(pointer) diff --git a/dali/public-api/rendering/visual-renderer.h b/dali/public-api/rendering/visual-renderer.h index 844d480..5924aab 100644 --- a/dali/public-api/rendering/visual-renderer.h +++ b/dali/public-api/rendering/visual-renderer.h @@ -204,7 +204,7 @@ public: * @SINCE_2_1.13 * @param[in] rhs A reference to the moved handle */ - VisualRenderer(VisualRenderer&& rhs); + VisualRenderer(VisualRenderer&& rhs) noexcept; /** * @brief Move assignment operator. @@ -213,7 +213,7 @@ public: * @param[in] rhs A reference to the moved handle * @return A reference to this handle */ - VisualRenderer& operator=(VisualRenderer&& rhs); + VisualRenderer& operator=(VisualRenderer&& rhs) noexcept; public: /// @cond internal diff --git a/packaging/dali.spec b/packaging/dali.spec index 8366533..352e09c 100644 --- a/packaging/dali.spec +++ b/packaging/dali.spec @@ -1,6 +1,6 @@ Name: dali2 Summary: DALi 3D Engine -Version: 2.2.15 +Version: 2.2.17 Release: 1 Group: System/Libraries License: Apache-2.0 and BSD-3-Clause and MIT