X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fvisual-base-impl.cpp;h=960a9fd46072ed3f6c53fdd614689fc0c1adf9e4;hb=ff6ce970724ccc8bee65f7c93411b274907c09d7;hp=f155b868b1fc40737945c33007657ba39bf49cf1;hpb=f25156f6460c7b288797ed40aaeca1ae6fc827dd;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/visuals/visual-base-impl.cpp b/dali-toolkit/internal/visuals/visual-base-impl.cpp index f155b86..960a9fd 100644 --- a/dali-toolkit/internal/visuals/visual-base-impl.cpp +++ b/dali-toolkit/internal/visuals/visual-base-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 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. @@ -23,6 +23,7 @@ #include #include #include +#include //INTERNAL HEARDER #include @@ -40,7 +41,9 @@ namespace Debug::Filter* gVisualBaseLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VISUAL_BASE"); #endif -const char* const PRE_MULTIPLIED_ALPHA_PROPERTY("preMultipliedAlpha"); +// visual string constants contains OFFSET_SIZE_MODE instead +const char* const OFFSET_POLICY("offsetPolicy"); +const char* const SIZE_POLICY("sizePolicy"); } // namespace @@ -135,16 +138,16 @@ void Visual::Base::Initialize() if(IsRoundedCornerRequired()) { - mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius); - mImpl->mRenderer.RegisterProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy); + mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius); + mImpl->mRenderer.RegisterUniqueProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy); mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON); } if(IsBorderlineRequired()) { - mImpl->mBorderlineWidthIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_WIDTH, BORDERLINE_WIDTH, mImpl->mBorderlineWidth); - mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor); - mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset); + mImpl->mBorderlineWidthIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_WIDTH, BORDERLINE_WIDTH, mImpl->mBorderlineWidth); + mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor); + mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset); mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL); } @@ -168,6 +171,7 @@ void Visual::Base::SetCustomShader(const Property::Map& shaderMap) void Visual::Base::SetProperties(const Property::Map& propertyMap) { + bool needUpdateShader = false; for(size_t i = 0; i < propertyMap.Count(); ++i) { const KeyValuePair& pair = propertyMap.GetKeyValue(i); @@ -295,6 +299,31 @@ void Visual::Base::SetProperties(const Property::Map& propertyMap) { mImpl->mBorderlineWidth = width; } + + if(mImpl->mBorderlineWidthIndex != Property::INVALID_INDEX) + { + mImpl->mRenderer.SetProperty(mImpl->mBorderlineWidthIndex, mImpl->mBorderlineWidth); + } + else if(DALI_UNLIKELY(mImpl->mRenderer && IsBorderlineRequired())) + { + // Unusual case. SetProperty called after OnInitialize(). + // Assume that DoAction call UPDATE_PROPERTY. + // We must regist properies into renderer, and update shader. + + // Borderline added by this action. Register property to renderer. + mImpl->mBorderlineWidthIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_WIDTH, BORDERLINE_WIDTH, mImpl->mBorderlineWidth); + mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor); + mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset); + + // Make Blend mode ON_WITHOUT_CULL for transparent mix color. + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL); + + // Change the shader must not be occured many times. we always have to use borderline feature. + mImpl->mAlwaysUsingBorderline = true; + + // Change shader + needUpdateShader = true; + } break; } case Toolkit::DevelVisual::Property::BORDERLINE_COLOR: @@ -304,6 +333,11 @@ void Visual::Base::SetProperties(const Property::Map& propertyMap) { mImpl->mBorderlineColor = color; } + + if(mImpl->mBorderlineColorIndex != Property::INVALID_INDEX) + { + mImpl->mRenderer.SetProperty(mImpl->mBorderlineColorIndex, mImpl->mBorderlineColor); + } break; } case Toolkit::DevelVisual::Property::BORDERLINE_OFFSET: @@ -313,6 +347,11 @@ void Visual::Base::SetProperties(const Property::Map& propertyMap) { mImpl->mBorderlineOffset = offset; } + + if(mImpl->mBorderlineOffsetIndex != Property::INVALID_INDEX) + { + mImpl->mRenderer.SetProperty(mImpl->mBorderlineOffsetIndex, mImpl->mBorderlineOffset); + } break; } case Toolkit::DevelVisual::Property::CORNER_RADIUS: @@ -338,6 +377,33 @@ void Visual::Base::SetProperties(const Property::Map& propertyMap) mImpl->mCornerRadius = Vector4(radius, radius, radius, radius); } } + + if(mImpl->mCornerRadiusIndex != Property::INVALID_INDEX) + { + mImpl->mRenderer.SetProperty(mImpl->mCornerRadiusIndex, mImpl->mCornerRadius); + } + else if(DALI_UNLIKELY(mImpl->mRenderer && IsRoundedCornerRequired())) + { + // Unusual case. SetProperty called after OnInitialize(). + // Assume that DoAction call UPDATE_PROPERTY. + // We must regist properies into renderer, and update shader. + + // CornerRadius added by this action. Regist property to renderer. + mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius); + mImpl->mRenderer.RegisterUniqueProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy); + + // Change the shader must not be occured many times. we always have to use corner radius feature. + mImpl->mAlwaysUsingCornerRadius = true; + + if(!IsBorderlineRequired()) + { + // If IsBorderlineRequired is true, BLEND_MODE is already BlendMode::ON_WITHOUT_CULL. So we don't overwrite it. + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON); + } + + // Change shader + needUpdateShader = true; + } break; } case Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY: @@ -351,6 +417,15 @@ void Visual::Base::SetProperties(const Property::Map& propertyMap) case Toolkit::Visual::Transform::Policy::ABSOLUTE: { mImpl->mCornerRadiusPolicy = policy; + if(DALI_UNLIKELY(mImpl->mRenderer && mImpl->mCornerRadiusIndex != Property::INVALID_INDEX)) + { + // Unusual case. SetProperty called after OnInitialize(). + // Assume that DoAction call UPDATE_PROPERTY. + // We must update properies result into renderer + // Note : mImpl->mCornerRadiusIndex is not INVALID_INDEX. + // So CornerRadiusPolicy property is already registed. + mImpl->mRenderer.SetProperty(mImpl->mRenderer.GetPropertyIndex(CORNER_RADIUS_POLICY), mImpl->mCornerRadiusPolicy); + } break; } default: @@ -366,6 +441,11 @@ void Visual::Base::SetProperties(const Property::Map& propertyMap) } DoSetProperties(propertyMap); + + if(DALI_UNLIKELY(needUpdateShader)) + { + UpdateShader(); + } } void Visual::Base::SetTransformAndSize(const Property::Map& transform, Size controlSize) @@ -486,16 +566,12 @@ void Visual::Base::CreatePropertyMap(Property::Map& map) const if(mImpl->mRenderer) { // Update values from Renderer - mImpl->mMixColor = mImpl->mRenderer.GetProperty(mImpl->mMixColorIndex); + mImpl->mMixColor = mImpl->mRenderer.GetProperty(VisualRenderer::Property::VISUAL_MIX_COLOR); mImpl->mMixColor.a = mImpl->mRenderer.GetProperty(DevelRenderer::Property::OPACITY); - if(mImpl->mTransform.mOffsetIndex != Property::INVALID_INDEX) - { - mImpl->mTransform.mOffset = mImpl->mRenderer.GetProperty(mImpl->mTransform.mOffsetIndex); - } - if(mImpl->mTransform.mSizeIndex != Property::INVALID_INDEX) - { - mImpl->mTransform.mSize = mImpl->mRenderer.GetProperty(mImpl->mTransform.mSizeIndex); - } + + mImpl->mTransform.mOffset = mImpl->mRenderer.GetProperty(VisualRenderer::Property::TRANSFORM_OFFSET); + mImpl->mTransform.mSize = mImpl->mRenderer.GetProperty(VisualRenderer::Property::TRANSFORM_SIZE); + if(mImpl->mCornerRadiusIndex != Property::INVALID_INDEX) { mImpl->mCornerRadius = mImpl->mRenderer.GetProperty(mImpl->mCornerRadiusIndex); @@ -529,7 +605,7 @@ void Visual::Base::CreatePropertyMap(Property::Map& map) const map.Insert(Toolkit::Visual::Property::PREMULTIPLIED_ALPHA, premultipliedAlpha); // Note, Color and Primitive will also insert their own mix color into the map - // which is ok, because they have a different key value range. + // which is ok, because they have a different key value range, but uses same cached value anyway. map.Insert(Toolkit::Visual::Property::MIX_COLOR, mImpl->mMixColor); // vec4 map.Insert(Toolkit::Visual::Property::OPACITY, mImpl->mMixColor.a); @@ -537,12 +613,18 @@ void Visual::Base::CreatePropertyMap(Property::Map& map) const mImpl->mFittingMode, VISUAL_FITTING_MODE_TABLE, VISUAL_FITTING_MODE_TABLE_COUNT); map.Insert(Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE, fittingModeString); - map.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, mImpl->mBorderlineWidth); - map.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, mImpl->mBorderlineColor); - map.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, mImpl->mBorderlineOffset); + if(IsTypeAvailableForBorderline(mImpl->mType)) + { + map.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, mImpl->mBorderlineWidth); + map.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, mImpl->mBorderlineColor); + map.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, mImpl->mBorderlineOffset); + } - map.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS, mImpl->mCornerRadius); - map.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, static_cast(mImpl->mCornerRadiusPolicy)); + if(IsTypeAvailableForCornerRadius(mImpl->mType)) + { + map.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS, mImpl->mCornerRadius); + map.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, static_cast(mImpl->mCornerRadiusPolicy)); + } } void Visual::Base::CreateInstancePropertyMap(Property::Map& map) const @@ -569,7 +651,7 @@ void Visual::Base::EnablePreMultipliedAlpha(bool preMultiplied) if(mImpl->mRenderer) { mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, preMultiplied); - mImpl->mRenderer.RegisterProperty(PRE_MULTIPLIED_ALPHA_PROPERTY, static_cast(preMultiplied)); + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA, preMultiplied); } } @@ -625,24 +707,19 @@ void Visual::Base::OnDoAction(const Property::Index actionId, const Property::Va void Visual::Base::RegisterMixColor() { - // Only register if not already registered. - // (Color and Primitive visuals will register their own and save to this index) - if(mImpl->mMixColorIndex == Property::INVALID_INDEX) + if(mImpl->mRenderer) { - mImpl->mMixColorIndex = mImpl->mRenderer.RegisterProperty( - Toolkit::Visual::Property::MIX_COLOR, - MIX_COLOR, - Vector3(mImpl->mMixColor)); - } + // All visual renderers now use same mix color / opacity properties. + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_MIX_COLOR, Vector3(mImpl->mMixColor)); + mImpl->mRenderer.SetProperty(DevelRenderer::Property::OPACITY, mImpl->mMixColor.a); - mImpl->mRenderer.SetProperty(DevelRenderer::Property::OPACITY, mImpl->mMixColor.a); - - float preMultipliedAlpha = 0.0f; - if(IsPreMultipliedAlphaEnabled()) - { - preMultipliedAlpha = 1.0f; + float preMultipliedAlpha = 0.0f; + if(IsPreMultipliedAlphaEnabled()) + { + preMultipliedAlpha = 1.0f; + } + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA, preMultipliedAlpha); } - mImpl->mRenderer.RegisterProperty(PRE_MULTIPLIED_ALPHA_PROPERTY, preMultipliedAlpha); } void Visual::Base::SetMixColor(const Vector4& color) @@ -651,7 +728,7 @@ void Visual::Base::SetMixColor(const Vector4& color) if(mImpl->mRenderer) { - mImpl->mRenderer.SetProperty(mImpl->mMixColorIndex, Vector3(color)); + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_MIX_COLOR, Vector3(color)); mImpl->mRenderer.SetProperty(DevelRenderer::Property::OPACITY, color.a); } } @@ -664,7 +741,7 @@ void Visual::Base::SetMixColor(const Vector3& color) if(mImpl->mRenderer) { - mImpl->mRenderer.SetProperty(mImpl->mMixColorIndex, color); + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_MIX_COLOR, color); } } @@ -694,7 +771,8 @@ void Visual::Base::ResourceReady(Toolkit::Visual::ResourceStatus resourceStatus) bool Visual::Base::IsResourceReady() const { - return (mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY); + return (mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY || + mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED); } bool Visual::Base::IsSynchronousLoadingRequired() const @@ -727,8 +805,123 @@ Renderer Visual::Base::GetRenderer() return mImpl->mRenderer; } +Property::Index Visual::Base::GetIntKey(Property::Key key) +{ + if(key.type == Property::Key::INDEX) + { + return key.indexKey; + } + + if(key.stringKey == ANCHOR_POINT) + { + return Toolkit::Visual::Transform::Property::ANCHOR_POINT; + } + else if(key.stringKey == EXTRA_SIZE) + { + return Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE; + } + else if(key.stringKey == MIX_COLOR) + { + return Toolkit::Visual::Property::MIX_COLOR; + } + else if(key.stringKey == OPACITY) + { + return Toolkit::Visual::Property::OPACITY; + } + else if(key.stringKey == OFFSET) + { + return Toolkit::Visual::Transform::Property::OFFSET; + } + else if(key.stringKey == OFFSET_POLICY) + { + return Toolkit::Visual::Transform::Property::OFFSET_POLICY; + } + else if(key.stringKey == ORIGIN) + { + return Toolkit::Visual::Transform::Property::ORIGIN; + } + else if(key.stringKey == PREMULTIPLIED_ALPHA) + { + return Toolkit::Visual::Property::PREMULTIPLIED_ALPHA; + } + else if(key.stringKey == CUSTOM_SHADER) + { + return Toolkit::Visual::Property::SHADER; + } + else if(key.stringKey == SIZE) + { + return Toolkit::Visual::Transform::Property::SIZE; + } + else if(key.stringKey == SIZE_POLICY) + { + return Toolkit::Visual::Transform::Property::SIZE_POLICY; + } + else if(key.stringKey == TRANSFORM) + { + return Toolkit::Visual::Property::TRANSFORM; + } + else if(key.stringKey == VISUAL_FITTING_MODE) + { + return Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE; + } + else if(key.stringKey == CORNER_RADIUS) + { + return Toolkit::DevelVisual::Property::CORNER_RADIUS; + } + else if(key.stringKey == CORNER_RADIUS_POLICY) + { + return Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY; + } + else if(key.stringKey == BORDERLINE_WIDTH) + { + return Toolkit::DevelVisual::Property::BORDERLINE_WIDTH; + } + else if(key.stringKey == BORDERLINE_COLOR) + { + return Toolkit::DevelVisual::Property::BORDERLINE_COLOR; + } + else if(key.stringKey == BORDERLINE_OFFSET) + { + return Toolkit::DevelVisual::Property::BORDERLINE_OFFSET; + } + + return Property::INVALID_INDEX; +} + Property::Index Visual::Base::GetPropertyIndex(Property::Key key) { + switch(GetIntKey(key)) + { + case Dali::Toolkit::Visual::Transform::Property::OFFSET: + { + return VisualRenderer::Property::TRANSFORM_OFFSET; + } + case Dali::Toolkit::Visual::Transform::Property::SIZE: + { + return VisualRenderer::Property::TRANSFORM_SIZE; + } + case Dali::Toolkit::Visual::Transform::Property::ORIGIN: + { + return VisualRenderer::Property::TRANSFORM_ORIGIN; + } + case Dali::Toolkit::Visual::Transform::Property::ANCHOR_POINT: + { + return VisualRenderer::Property::TRANSFORM_ANCHOR_POINT; + } + case Dali::Toolkit::Visual::Property::MIX_COLOR: + { + return VisualRenderer::Property::VISUAL_MIX_COLOR; + } + case Dali::Toolkit::Visual::Property::OPACITY: + { + return DevelRenderer::Property::OPACITY; + } + case Dali::Toolkit::Visual::Property::PREMULTIPLIED_ALPHA: + { + return VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA; + } + } + Property::Index index = mImpl->mRenderer.GetPropertyIndex(key); if(index == Property::INVALID_INDEX) @@ -753,7 +946,9 @@ Property::Index Visual::Base::GetPropertyIndex(Property::Key key) // Leave keyIndex as INVALID_KEY - it can still be registered against the string key. } Property::Value value = shader.GetProperty(index); - index = mImpl->mRenderer.RegisterProperty(keyIndex, keyName, value); + + // We already know that mRenderer didn't have property. So we can assume that it is unique. + index = mImpl->mRenderer.RegisterUniqueProperty(keyIndex, keyName, value); } } return index; @@ -845,7 +1040,9 @@ void Visual::Base::AnimateRendererProperty( Dali::Animation& transition, Internal::TransitionData::Animator& animator) { + // Get actual renderer index (will convert transform keys into visualproperty indices) Property::Index index = GetPropertyIndex(animator.propertyKey); + if(index != Property::INVALID_INDEX) { if(animator.targetValue.GetType() != Property::NONE) @@ -864,7 +1061,6 @@ void Visual::Base::AnimateRendererProperty( mImpl->mTransform.UpdatePropertyMap(map); } - SetupTransition(transition, animator, index, animator.initialValue, animator.targetValue); } } @@ -873,50 +1069,47 @@ void Visual::Base::AnimateMixColorProperty( Dali::Animation& transition, Internal::TransitionData::Animator& animator) { - Property::Index index = mImpl->mMixColorIndex; - bool animateOpacity = false; + bool animateOpacity = false; Property::Value initialOpacity; Property::Value targetOpacity; Property::Value initialMixColor; Property::Value targetMixColor; - if(index != Property::INVALID_INDEX) + Vector4 initialColor; + if(animator.initialValue.Get(initialColor)) { - Vector4 initialColor; - if(animator.initialValue.Get(initialColor)) + if(animator.initialValue.GetType() == Property::VECTOR4) { - if(animator.initialValue.GetType() == Property::VECTOR4) - { - // if there is an initial color specifying alpha, test it - initialOpacity = initialColor.a; - } - initialMixColor = Vector3(initialColor); + // if there is an initial color specifying alpha, test it + initialOpacity = initialColor.a; } + initialMixColor = Vector3(initialColor); + } - // Set target value into data store - if(animator.targetValue.GetType() != Property::NONE) + // Set target value into data store + if(animator.targetValue.GetType() != Property::NONE) + { + Vector4 mixColor; + animator.targetValue.Get(mixColor); + if(animator.targetValue.GetType() == Property::VECTOR4) { - Vector4 mixColor; - animator.targetValue.Get(mixColor); - if(animator.targetValue.GetType() == Property::VECTOR4) - { - mImpl->mMixColor.a = mixColor.a; - targetOpacity = mixColor.a; - animateOpacity = true; - } - - mImpl->mMixColor.r = mixColor.r; - mImpl->mMixColor.g = mixColor.g; - mImpl->mMixColor.b = mixColor.b; - targetMixColor = Vector3(mixColor); + mImpl->mMixColor.a = mixColor.a; + targetOpacity = mixColor.a; + animateOpacity = true; } - SetupTransition(transition, animator, index, initialMixColor, targetMixColor); - if(animateOpacity) - { - SetupTransition(transition, animator, DevelRenderer::Property::OPACITY, initialOpacity, targetOpacity); - } + mImpl->mMixColor.r = mixColor.r; + mImpl->mMixColor.g = mixColor.g; + mImpl->mMixColor.b = mixColor.b; + targetMixColor = Vector3(mixColor); + } + + SetupTransition(transition, animator, VisualRenderer::Property::VISUAL_MIX_COLOR, initialMixColor, targetMixColor); + + if(animateOpacity) + { + SetupTransition(transition, animator, DevelRenderer::Property::OPACITY, initialOpacity, targetOpacity); } } @@ -928,43 +1121,33 @@ Dali::Property Visual::Base::GetPropertyObject(Dali::Property::Key key) return Dali::Property(handle, Property::INVALID_INDEX); } - // Mix color or opacity cases - if(key.type == Property::Key::INDEX) + // Default animatable properties from VisualRenderer + switch(GetIntKey(key)) { - if(key.indexKey == Toolkit::Visual::Property::MIX_COLOR || (mImpl->mType == Toolkit::Visual::COLOR && key.indexKey == ColorVisual::Property::MIX_COLOR) || (mImpl->mType == Toolkit::Visual::PRIMITIVE && key.indexKey == PrimitiveVisual::Property::MIX_COLOR)) + case Toolkit::Visual::Property::MIX_COLOR: { - return Dali::Property(mImpl->mRenderer, mImpl->mMixColorIndex); + return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::VISUAL_MIX_COLOR); } - else if(key.indexKey == Toolkit::Visual::Property::OPACITY) + case Toolkit::Visual::Property::OPACITY: { return Dali::Property(mImpl->mRenderer, DevelRenderer::Property::OPACITY); } - else if(key.indexKey == Toolkit::Visual::Transform::Property::OFFSET) + case Toolkit::Visual::Transform::Property::OFFSET: { - return Dali::Property(mImpl->mRenderer, OFFSET); + return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::TRANSFORM_OFFSET); } - else if(key.indexKey == Toolkit::Visual::Transform::Property::SIZE) - { - return Dali::Property(mImpl->mRenderer, SIZE); - } - } - else - { - if(key.stringKey == MIX_COLOR) + case Toolkit::Visual::Transform::Property::SIZE: { - return Dali::Property(mImpl->mRenderer, mImpl->mMixColorIndex); + return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::TRANSFORM_SIZE); } - else if(key.stringKey == OPACITY) - { - return Dali::Property(mImpl->mRenderer, DevelRenderer::Property::OPACITY); - } - else if(key.stringKey == OFFSET) - { - return Dali::Property(mImpl->mRenderer, OFFSET); - } - else if(key.stringKey == SIZE) + default: { - return Dali::Property(mImpl->mRenderer, SIZE); + if(key.type == Property::Key::INDEX && + ((mImpl->mType == Toolkit::Visual::COLOR && key.indexKey == ColorVisual::Property::MIX_COLOR) || + (mImpl->mType == Toolkit::Visual::PRIMITIVE && key.indexKey == PrimitiveVisual::Property::MIX_COLOR))) + { + return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::VISUAL_MIX_COLOR); + } } } @@ -973,16 +1156,16 @@ Dali::Property Visual::Base::GetPropertyObject(Dali::Property::Key key) if(index == Property::INVALID_INDEX) { if(IsTypeAvailableForBorderline(mImpl->mType) && - ((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_WIDTH) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_WIDTH) || - (key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_COLOR) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_COLOR) || + ((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_WIDTH) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_WIDTH) || + (key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_COLOR) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_COLOR) || (key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_OFFSET) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_OFFSET))) { mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL); // Register borderline properties - mImpl->mBorderlineWidthIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_WIDTH, BORDERLINE_WIDTH, mImpl->mBorderlineWidth); - mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor); - mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset); + mImpl->mBorderlineWidthIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_WIDTH, BORDERLINE_WIDTH, mImpl->mBorderlineWidth); + mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor); + mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset); // Borderline is animated now. we always have to use borderline feature. mImpl->mAlwaysUsingBorderline = true; @@ -995,10 +1178,10 @@ Dali::Property Visual::Base::GetPropertyObject(Dali::Property::Key key) else if(IsTypeAvailableForCornerRadius(mImpl->mType) && ((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::CORNER_RADIUS) || (key.type == Property::Key::STRING && key.stringKey == CORNER_RADIUS))) { // Register CORNER_RADIUS property - mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius); - mImpl->mRenderer.RegisterProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy); + mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius); + mImpl->mRenderer.RegisterUniqueProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy); - // ConerRadius is animated now. we always have to use corner radius feature. + // CornerRadius is animated now. we always have to use corner radius feature. mImpl->mAlwaysUsingCornerRadius = true; if(!IsBorderlineRequired()) @@ -1019,6 +1202,21 @@ Dali::Property Visual::Base::GetPropertyObject(Dali::Property::Key key) return OnGetPropertyObject(key); } } + else + { + if(index == mImpl->mBorderlineWidthIndex || + index == mImpl->mBorderlineColorIndex || + index == mImpl->mBorderlineOffsetIndex) + { + // Borderline is animated now. we always have to use borderline feature. + mImpl->mAlwaysUsingBorderline = true; + } + if(index == mImpl->mCornerRadiusIndex) + { + // CornerRadius is animated now. we always have to use corner radius feature. + mImpl->mAlwaysUsingCornerRadius = true; + } + } return Dali::Property(mImpl->mRenderer, index); }