From 5be46a1f1ed8d4e78c59b445705f0de7cb06de52 Mon Sep 17 00:00:00 2001 From: David Steele Date: Thu, 20 Jul 2023 14:14:45 +0100 Subject: [PATCH] Reducing uniform memory usage Removing lookup/cache of property type function getter & size getter. Reduces size of uniform map from 64 bytes to 48 bytes on x86-64 platform Change-Id: I1f5259192a974a5579b381564a8d16df67d28589 --- automated-tests/src/dali-internal/CMakeLists.txt | 1 + .../utc-Dali-Internal-AnimatableProperty.cpp | 131 +++++++++++++++++++ .../utc-Dali-Internal-TransformManagerProperty.cpp | 87 ++++++++++++- dali/internal/event/common/property-input-impl.h | 14 +- dali/internal/render/renderers/render-renderer.cpp | 107 +-------------- dali/internal/render/renderers/render-renderer.h | 11 +- dali/internal/update/common/animatable-property.h | 144 +++++++++++++++++++++ dali/internal/update/common/inherited-property.h | 66 +++++++++- dali/internal/update/gestures/gesture-properties.h | 34 ++++- .../update/manager/transform-manager-property.h | 87 +++++++++++++ 10 files changed, 570 insertions(+), 112 deletions(-) create mode 100644 automated-tests/src/dali-internal/utc-Dali-Internal-AnimatableProperty.cpp diff --git a/automated-tests/src/dali-internal/CMakeLists.txt b/automated-tests/src/dali-internal/CMakeLists.txt index e902727..4ffc6d0 100644 --- a/automated-tests/src/dali-internal/CMakeLists.txt +++ b/automated-tests/src/dali-internal/CMakeLists.txt @@ -6,6 +6,7 @@ SET(RPM_NAME "core-${PKG_NAME}-tests") SET(CAPI_LIB "dali-internal") SET(TC_SOURCES + utc-Dali-Internal-AnimatableProperty.cpp utc-Dali-Internal-ActorObserver.cpp utc-Dali-Internal-ActorRelayout.cpp utc-Dali-Internal-ConstString.cpp diff --git a/automated-tests/src/dali-internal/utc-Dali-Internal-AnimatableProperty.cpp b/automated-tests/src/dali-internal/utc-Dali-Internal-AnimatableProperty.cpp new file mode 100644 index 0000000..42a4cbb --- /dev/null +++ b/automated-tests/src/dali-internal/utc-Dali-Internal-AnimatableProperty.cpp @@ -0,0 +1,131 @@ +/* + * Copyright (c) 2024 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 + +// INTERNAL INCLUDES +#include +#include +#include +#include +#include +#include + +using namespace Dali::Internal::SceneGraph; + +void utc_dali_internal_animatable_property_startup(void) +{ + test_return_value = TET_UNDEF; +} + +void utc_dali_internal_animatable_property_cleanup(void) +{ + test_return_value = TET_PASS; +} + +int UtcDaliInternalPropertyGetValueAddress(void) +{ + struct S + { + Dali::Internal::PropertyInputImpl* property; + Property::Value value; + size_t size; + S(Dali::Internal::PropertyInputImpl* p, Property::Value v, size_t s) + : property(p), + value(v), + size(s) + { + } + }; + std::vector properties; + properties.emplace_back(new AnimatableProperty(true), true, sizeof(bool)); + properties.emplace_back(new AnimatableProperty(1337), 1337, sizeof(int)); + properties.emplace_back(new AnimatableProperty(8.008135f), 8.008135f, sizeof(float)); + properties.emplace_back(new AnimatableProperty(Vector2(1.0f, 1.0f)), Vector2(1.0f, 1.0f), sizeof(Vector2)); + properties.emplace_back(new AnimatableProperty(Vector3(1.0f, 1.0f, 1.0f)), Vector3(1.0f, 1.0f, 1.0f), sizeof(Vector3)); + properties.emplace_back(new AnimatableProperty(Vector4(1.0f, 1.0f, 1.0f, 1.0f)), Vector4(1.0f, 1.0f, 1.0f, 1.0f), sizeof(Vector4)); + properties.emplace_back(new AnimatableProperty(Quaternion(Radian(1.619f), Vector3::ZAXIS)), Quaternion(Radian(1.619f), Vector3::ZAXIS), sizeof(Quaternion)); + properties.emplace_back(new AnimatableProperty(Matrix::IDENTITY), Matrix::IDENTITY, sizeof(Matrix)); + properties.emplace_back(new AnimatableProperty(Matrix3::IDENTITY), Matrix3::IDENTITY, sizeof(Matrix3)); + + properties.emplace_back(new InheritedVector3(Vector3(1.0f, 1.0f, 1.0f)), Vector3(1.0f, 1.0f, 1.0f), sizeof(Vector3)); + properties.emplace_back(new InheritedColor(Color::SIENNA), Color::SIENNA, sizeof(Vector4)); + properties.emplace_back(new InheritedQuaternion(), Quaternion(Radian(1.619f), Vector3::ZAXIS), sizeof(Quaternion)); + static_cast(properties.back().property)->Set(0, properties.back().value.Get()); + properties.emplace_back(new InheritedMatrix(), Matrix::IDENTITY, sizeof(Matrix)); + static_cast(properties.back().property)->Set(0, properties.back().value.Get()); + + properties.emplace_back(new GesturePropertyBool(), true, sizeof(bool)); + static_cast(properties.back().property)->Set(true); + + properties.emplace_back(new GesturePropertyVector2(), Vector2(3.2f, 2.1f), sizeof(Vector2)); + static_cast(properties.back().property)->Set(properties.back().value.Get()); + + for(auto& s : properties) + { + void* addr = const_cast(s.property->GetValueAddress(0)); + switch(s.value.GetType()) + { + case Property::Type::BOOLEAN: + { + DALI_TEST_EQUALS(s.value.Get(), *reinterpret_cast(addr), TEST_LOCATION); + break; + } + case Property::Type::INTEGER: + { + DALI_TEST_EQUALS(s.value.Get(), *reinterpret_cast(addr), TEST_LOCATION); + break; + } + case Property::Type::FLOAT: + { + DALI_TEST_EQUALS(s.value.Get(), *reinterpret_cast(addr), TEST_LOCATION); + break; + } + case Property::Type::VECTOR2: + { + DALI_TEST_EQUALS(s.value.Get(), *reinterpret_cast(addr), TEST_LOCATION); + break; + } + case Property::Type::VECTOR3: + { + DALI_TEST_EQUALS(s.value.Get(), *reinterpret_cast(addr), TEST_LOCATION); + break; + } + case Property::Type::VECTOR4: + { + DALI_TEST_EQUALS(s.value.Get(), *reinterpret_cast(addr), TEST_LOCATION); + break; + } + case Property::Type::MATRIX: + { + DALI_TEST_EQUALS(s.value.Get(), *reinterpret_cast(addr), TEST_LOCATION); + break; + } + case Property::Type::MATRIX3: + { + DALI_TEST_EQUALS(s.value.Get(), *reinterpret_cast(addr), TEST_LOCATION); + break; + } + default: + break; + } + DALI_TEST_EQUALS(s.property->GetValueSize(), s.size, TEST_LOCATION); + } + + END_TEST; +} diff --git a/automated-tests/src/dali-internal/utc-Dali-Internal-TransformManagerProperty.cpp b/automated-tests/src/dali-internal/utc-Dali-Internal-TransformManagerProperty.cpp index 0b6a440..65e1164 100644 --- a/automated-tests/src/dali-internal/utc-Dali-Internal-TransformManagerProperty.cpp +++ b/automated-tests/src/dali-internal/utc-Dali-Internal-TransformManagerProperty.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Samsung Electronics Co., Ltd. + * Copyright (c) 2024 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. @@ -19,6 +19,7 @@ #include #include +#include // Internal headers are allowed here @@ -88,3 +89,87 @@ int UtcTransformManagerPropertyUninitializedMgrData(void) END_TEST; } + +using namespace Dali::Internal::SceneGraph; +int UtcDaliInternalTransformPropertyGetValueSize(void) +{ + struct S + { + Dali::Internal::PropertyInputImpl* property; + Property::Value value; + size_t size; + S(Dali::Internal::PropertyInputImpl* p, Property::Value v, size_t s) + : property(p), + value(v), + size(s) + { + } + }; + std::vector properties; + + properties.emplace_back(new TransformManagerPropertyVector3(), Vector3(2.3f, 4.5f, 1.9f), sizeof(Vector3)); + + properties.emplace_back(new TransformManagerPropertyQuaternion<0>(), Quaternion(Radian(1.619f), Vector3::ZAXIS), sizeof(Quaternion)); + + properties.emplace_back(new TransformManagerVector3Input<0>(TransformManagerProperty::TRANSFORM_PROPERTY_WORLD_SCALE, Vector3(2.3f, 4.5f, 1.9f)), Vector3(2.3f, 4.5f, 1.9f), sizeof(Vector3)); + + properties.emplace_back(new TransformManagerQuaternionInput<0>(), Quaternion(Radian(1.619f), Vector3::ZAXIS), sizeof(Quaternion)); + + properties.emplace_back(new TransformManagerMatrixInput<0>(), Matrix::IDENTITY, sizeof(Matrix)); + + for(auto& s : properties) + { + DALI_TEST_EQUALS(s.property->GetValueSize(), s.size, TEST_LOCATION); + } + + END_TEST; +} + +int UtcDaliInternalTransformPropertyGetValueAddress(void) +{ + struct N + { + BASE(TransformManagerData, mTransformManagerData); + PROPERTY_WRAPPER(mTransformManagerData, TransformManagerPropertyVector3, TRANSFORM_PROPERTY_SCALE, mScale); + TEMPLATE_WRAPPER(mScale, TransformManagerPropertyQuaternion, mOrientation); + TEMPLATE_WRAPPER(mOrientation, TransformManagerVector3Input, mWorldPosition); + TEMPLATE_WRAPPER(mWorldPosition, TransformManagerQuaternionInput, mWorldOrientation); + TEMPLATE_WRAPPER(mWorldOrientation, TransformManagerMatrixInput, mWorldMatrix); + + N() + : mTransformManagerData(), + mWorldPosition(TRANSFORM_PROPERTY_WORLD_POSITION, Vector3(1.0f, 1.0f, 1.0f)), + mWorldOrientation(), + mWorldMatrix() + { + } + }; + + TransformManager testManager; + N node; + node.mTransformManagerData.mManager = &testManager; + node.mTransformManagerData.mId = testManager.CreateTransform(); + + const void* addr = node.mScale.GetValueAddress(0); + node.mScale.Set(0, Vector3(1.2f, 1.2f, 1.2f)); + + DALI_TEST_EQUALS(*reinterpret_cast(addr), Vector3(1.2f, 1.2f, 1.2f), TEST_LOCATION); + + node.mOrientation.Set(0, Quaternion(Radian(1.619f), Vector3::ZAXIS)); + addr = node.mOrientation.GetValueAddress(0); + DALI_TEST_EQUALS(*reinterpret_cast(addr), Quaternion(Radian(1.619f), Vector3::ZAXIS), TEST_LOCATION); + + Matrix& m = node.mWorldMatrix.Get(0); + m = Matrix::IDENTITY; + + addr = node.mWorldPosition.GetValueAddress(0); + DALI_TEST_EQUALS(*reinterpret_cast(addr), Vector3(0.f, 0.f, 0.f), TEST_LOCATION); + + addr = node.mWorldOrientation.GetValueAddress(0); + DALI_TEST_EQUALS(*reinterpret_cast(addr), Quaternion(Radian(0), Vector3::ZAXIS), TEST_LOCATION); + + addr = node.mWorldMatrix.GetValueAddress(0); + DALI_TEST_EQUALS(*reinterpret_cast(addr), Matrix::IDENTITY, TEST_LOCATION); + + END_TEST; +} diff --git a/dali/internal/event/common/property-input-impl.h b/dali/internal/event/common/property-input-impl.h index 2bb3a3b..ab2ee09 100644 --- a/dali/internal/event/common/property-input-impl.h +++ b/dali/internal/event/common/property-input-impl.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_PROPERTY_INPUT_IMPL_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. @@ -181,6 +181,18 @@ public: return reinterpret_cast(*this); } + /** + * Retrieve the address of the property value. Only for use + * when writing uniforms. + */ + virtual const void* GetValueAddress(BufferIndex bufferIndex) const = 0; + + /** + * Retrieve the size of the property value for use in copying. + * Only for use when writing uniforms. + */ + virtual size_t GetValueSize() const = 0; + // Accessors for Constraint functions /** diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp index 4baebf9..11a20f9 100644 --- a/dali/internal/render/renderers/render-renderer.cpp +++ b/dali/internal/render/renderers/render-renderer.cpp @@ -46,98 +46,6 @@ uint32_t mvpBufferIndex; namespace { -// Helper to get the property value getter by type -typedef const float& (PropertyInputImpl::*FuncGetter)(BufferIndex) const; -constexpr FuncGetter GetPropertyValueGetter(Property::Type type) -{ - switch(type) - { - case Property::BOOLEAN: - { - return FuncGetter(&PropertyInputImpl::GetBoolean); - } - case Property::INTEGER: - { - return FuncGetter(&PropertyInputImpl::GetInteger); - } - case Property::FLOAT: - { - return FuncGetter(&PropertyInputImpl::GetFloat); - } - case Property::VECTOR2: - { - return FuncGetter(&PropertyInputImpl::GetVector2); - } - case Property::VECTOR3: - { - return FuncGetter(&PropertyInputImpl::GetVector3); - } - case Property::VECTOR4: - { - return FuncGetter(&PropertyInputImpl::GetVector4); - } - case Property::MATRIX3: - { - return FuncGetter(&PropertyInputImpl::GetMatrix3); - } - case Property::MATRIX: - { - return FuncGetter(&PropertyInputImpl::GetMatrix); - } - default: - { - return nullptr; - } - } -} - -/** - * Helper function that returns size of uniform datatypes based - * on property type. - */ -constexpr int GetPropertyValueSizeForUniform(Property::Type type) -{ - switch(type) - { - case Property::Type::BOOLEAN: - { - return sizeof(bool); - } - case Property::Type::FLOAT: - { - return sizeof(float); - } - case Property::Type::INTEGER: - { - return sizeof(int); - } - case Property::Type::VECTOR2: - { - return sizeof(Vector2); - } - case Property::Type::VECTOR3: - { - return sizeof(Vector3); - } - case Property::Type::VECTOR4: - { - return sizeof(Vector4); - } - case Property::Type::MATRIX3: - { - return sizeof(Matrix3); - } - case Property::Type::MATRIX: - { - return sizeof(Matrix); - } - default: - { - return 0; - } - }; -} - /** * Helper function to calculate the correct alignment of data for uniform buffers * @param dataSize size of uniform buffer @@ -927,7 +835,7 @@ void Renderer::FillUniformBuffer(Program& { auto& uniform = iter; int arrayIndex = uniform.arrayIndex; - if(!uniform.uniformFunc) + if(!uniform.initialized) { auto uniformInfo = Graphics::UniformInfo{}; auto uniformFound = program.GetUniform(uniform.uniformName.GetStringView(), @@ -948,15 +856,13 @@ void Renderer::FillUniformBuffer(Program& uniform.uniformOffset = uniformInfo.offset; uniform.uniformLocation = uniformInfo.location; uniform.uniformBlockIndex = uniformInfo.bufferIndex; + uniform.initialized = true; auto dst = ubo->GetOffset() + uniformInfo.offset; - const auto typeSize = GetPropertyValueSizeForUniform(iter.propertyValue->GetType()); + const auto typeSize = iter.propertyValue->GetValueSize(); const auto dest = dst + static_cast(typeSize) * arrayIndex; - const auto func = GetPropertyValueGetter(iter.propertyValue->GetType()); - uniform.uniformSize = typeSize; - uniform.uniformFunc = func; - ubo->Write(&(iter.propertyValue->*func)(updateBufferIndex), + ubo->Write(iter.propertyValue->GetValueAddress(updateBufferIndex), typeSize, dest); } @@ -965,11 +871,10 @@ void Renderer::FillUniformBuffer(Program& UniformBufferView* ubo = uboViews[uniform.uniformBlockIndex].get(); auto dst = ubo->GetOffset() + uniform.uniformOffset; - const auto typeSize = uniform.uniformSize; + const auto typeSize = iter.propertyValue->GetValueSize(); const auto dest = dst + static_cast(typeSize) * arrayIndex; - const auto func = uniform.uniformFunc; - ubo->Write(&(iter.propertyValue->*func)(updateBufferIndex), + ubo->Write(iter.propertyValue->GetValueAddress(updateBufferIndex), typeSize, dest); } diff --git a/dali/internal/render/renderers/render-renderer.h b/dali/internal/render/renderers/render-renderer.h index c8e9d3c..af05bcc 100644 --- a/dali/internal/render/renderers/render-renderer.h +++ b/dali/internal/render/renderers/render-renderer.h @@ -630,8 +630,6 @@ private: using Hash = std::size_t; - typedef const float& (PropertyInputImpl::*FuncGetter)(BufferIndex) const; - struct UniformIndexMap { ConstString uniformName; ///< The uniform name @@ -640,11 +638,10 @@ private: Hash uniformNameHashNoArray{0u}; int32_t arrayIndex{-1}; ///< The array index - int16_t uniformLocation{0u}; - uint16_t uniformOffset{0u}; - uint16_t uniformSize{0u}; - uint16_t uniformBlockIndex{0u}; - FuncGetter uniformFunc{0}; + int16_t uniformLocation{0u}; + uint16_t uniformOffset{0u}; + uint16_t uniformBlockIndex{0u}; + bool initialized{false}; }; StencilParameters mStencilParameters; ///< Struct containing all stencil related options diff --git a/dali/internal/update/common/animatable-property.h b/dali/internal/update/common/animatable-property.h index 612af3f..c2bb6fe 100644 --- a/dali/internal/update/common/animatable-property.h +++ b/dali/internal/update/common/animatable-property.h @@ -174,6 +174,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(bool); + } + + /** * Set the property value. This will only persist for the current frame; the property * will be reset with the base value, at the beginning of the next frame. * @param[in] bufferIndex The buffer to write. @@ -340,6 +356,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(int); + } + + /** * Set the property value. This will only persist for the current frame; the property * will be reset with the base value, at the beginning of the next frame. * @param[in] bufferIndex The buffer to write. @@ -515,6 +547,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(float); + } + + /** * Set the property value. This will only persist for the current frame; the property * will be reset with the base value, at the beginning of the next frame. * @param[in] bufferIndex The buffer to write. @@ -692,6 +740,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector2); + } + + /** * Set the property value. This will only persist for the current frame; the property * will be reset with the base value, at the beginning of the next frame. * @param[in] bufferIndex The buffer to write. @@ -958,6 +1022,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector3); + } + + /** * Set the property value. This will only persist for the current frame; the property * will be reset with the base value, at the beginning of the next frame. * @param[in] bufferIndex The buffer to write. @@ -1278,6 +1358,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector4); + } + + /** * Set the property value. This will only persist for the current frame; the property * will be reset with the base value, at the beginning of the next frame. * @param[in] bufferIndex The buffer to write. @@ -1670,6 +1766,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector4); + } + + /** * Change the property value by a relative amount. * @param[in] bufferIndex The buffer to write. * @param[in] delta The property will change by this amount. @@ -1810,6 +1922,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Matrix); + } + + /** * Set the property value. This will only persist for the current frame; the property * will be reset with the base value, at the beginning of the next frame. * @param[in] bufferIndex The buffer to write. @@ -1966,6 +2094,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Matrix3); + } + + /** * Set the property value. This will only persist for the current frame; the property * will be reset with the base value, at the beginning of the next frame. * @param[in] bufferIndex The buffer to write. diff --git a/dali/internal/update/common/inherited-property.h b/dali/internal/update/common/inherited-property.h index e4a8446..08d62b4 100644 --- a/dali/internal/update/common/inherited-property.h +++ b/dali/internal/update/common/inherited-property.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_SCENE_GRAPH_INHERITED_PROPERTY_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. @@ -123,6 +123,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector3); + } + + /** * @copydoc Dali::PropertyInput::GetConstraintInputVector3() */ const Vector3& GetConstraintInputVector3(BufferIndex bufferIndex) const override @@ -269,6 +285,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector4); + } + + /** * @copydoc Dali::PropertyInput::GetConstraintInputVector4() */ const Vector4& GetConstraintInputVector4(BufferIndex bufferIndex) const override @@ -433,6 +465,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector4); + } + + /** * @copydoc Dali::PropertyInput::GetConstraintInputQuaternion() */ const Quaternion& GetConstraintInputQuaternion(BufferIndex bufferIndex) const override @@ -578,6 +626,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue[bufferIndex]; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Matrix); + } + + /** * @copydoc Dali::Internal::PropertyInputImpl::GetConstraintInputMatrix() */ const Matrix& GetConstraintInputMatrix(BufferIndex bufferIndex) const override diff --git a/dali/internal/update/gestures/gesture-properties.h b/dali/internal/update/gestures/gesture-properties.h index 33e28b5..92e635e 100644 --- a/dali/internal/update/gestures/gesture-properties.h +++ b/dali/internal/update/gestures/gesture-properties.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_SCENE_GRAPH_GESTURE_PROPERTIES_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. @@ -151,6 +151,22 @@ public: { return mValue; } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector2); + } }; /** @@ -171,6 +187,22 @@ public: { return mValue; } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &mValue; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(bool); + } }; } // namespace SceneGraph diff --git a/dali/internal/update/manager/transform-manager-property.h b/dali/internal/update/manager/transform-manager-property.h index fe5fec4..e093e01 100644 --- a/dali/internal/update/manager/transform-manager-property.h +++ b/dali/internal/update/manager/transform-manager-property.h @@ -196,6 +196,22 @@ struct TransformManagerPropertyVector3 final : public TransformManagerPropertyHa return Get(bufferIndex); } + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &GetVector3(bufferIndex); + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector3); + } + const float& GetFloatComponent(uint32_t component) const override { return GetTxManagerData()->Manager()->GetVector3PropertyComponentValue(GetTxManagerData()->Id(), PropertyT, component); @@ -312,6 +328,22 @@ public: { return Get(bufferIndex); } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &Get(bufferIndex); + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector4); + } }; /** @@ -415,6 +447,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &GetVector3(bufferIndex); + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector3); + } + + /** * @copydoc Dali::PropertyInput::GetConstraintInputVector3() */ const Vector3& GetConstraintInputVector3(BufferIndex bufferIndex) const override @@ -555,6 +603,22 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + return &GetQuaternion(bufferIndex); + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Vector4); + } + + /** * @copydoc Dali::PropertyInput::GetConstraintInputQuaternion() */ const Quaternion& GetConstraintInputQuaternion(BufferIndex bufferIndex) const override @@ -683,6 +747,29 @@ public: } /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueAddress() + */ + const void* GetValueAddress(BufferIndex bufferIndex) const override + { + static const Matrix identityMatrix(Matrix::IDENTITY); + auto transformManagerData = GetTxManagerData(); + auto id = transformManagerData->Id(); + if(id != INVALID_TRANSFORM_ID) + { + return &(transformManagerData->Manager()->GetWorldMatrix(id)); + } + return &identityMatrix; + } + + /** + * @copydoc Dali::Internal::PropertyInputImpl::GetValueSize() + */ + size_t GetValueSize() const override + { + return sizeof(Matrix); + } + + /** * @copydoc Dali::PropertyInput::GetConstraintInputMatrix() */ const Matrix& GetConstraintInputMatrix(BufferIndex bufferIndex) const override -- 2.7.4