Let we add Squareness factor as visual property.
So we can support squircle effects.
Also, let we support it to SceneView / WebView / BackgroundBlurEffect
Change-Id: I6edeb51ee9f917cbed05efe42af12b9b1eb6a21a
Signed-off-by: Eunki Hong <eunkiki.hong@samsung.com>
END_TEST;
}
+int UtcDaliSceneViewCornerSquareness(void)
+{
+ ToolkitTestApplication application;
+
+ Scene3D::SceneView view = Scene3D::SceneView::New();
+ application.GetScene().Add(view);
+
+ DALI_TEST_EQUALS(view.GetProperty<Vector4>(Dali::Scene3D::SceneView::Property::CORNER_RADIUS), Vector4::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(view.GetProperty<Vector4>(Dali::Scene3D::SceneView::Property::CORNER_SQUARENESS), Vector4::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(view.GetProperty<int>(Dali::Scene3D::SceneView::Property::CORNER_RADIUS_POLICY), static_cast<int>(Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
+
+ Vector4 expectCornerRadius = Vector4(0.5f, 0.3f, 0.2f, 0.0f);
+ Vector4 expectCornerSquareness = Vector4(0.1f, 0.2f, 0.3f, 0.4f);
+ int expectCornerRadiusPolicy = static_cast<int>(Visual::Transform::Policy::RELATIVE);
+
+ view.UseFramebuffer(true);
+ view.SetProperty(Dali::Scene3D::SceneView::Property::CORNER_RADIUS, expectCornerRadius);
+ view.SetProperty(Dali::Scene3D::SceneView::Property::CORNER_SQUARENESS, expectCornerSquareness);
+ view.SetProperty(Dali::Scene3D::SceneView::Property::CORNER_RADIUS_POLICY, expectCornerRadiusPolicy);
+
+ DALI_TEST_EQUALS(view.GetProperty<Vector4>(Dali::Scene3D::SceneView::Property::CORNER_RADIUS), expectCornerRadius, TEST_LOCATION);
+ DALI_TEST_EQUALS(view.GetProperty<Vector4>(Dali::Scene3D::SceneView::Property::CORNER_SQUARENESS), expectCornerSquareness, TEST_LOCATION);
+ DALI_TEST_EQUALS(view.GetProperty<int>(Dali::Scene3D::SceneView::Property::CORNER_RADIUS_POLICY), expectCornerRadiusPolicy, TEST_LOCATION);
+
+ END_TEST;
+}
+
namespace
{
static bool gCaptureFinishedCalled{false};
.Add(DevelVisual::Property::BORDERLINE_WIDTH, 33.3f)
.Add(DevelVisual::Property::BORDERLINE_COLOR, Color::RED)
.Add(DevelVisual::Property::BORDERLINE_OFFSET, 0.3f)
+ .Add(DevelVisual::Property::CORNER_SQUARENESS, 0.3f)
.Add(DevelImageVisual::Property::FRAME_SPEED_FACTOR, 2.0f));
Property::Map resultMap;
DALI_TEST_CHECK(value);
DALI_TEST_EQUALS(value->Get<float>(), 0.3f, TEST_LOCATION);
+ value = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.3f, 0.3f, 0.3f, 0.3f), TEST_LOCATION);
+
// Check mask properties
value = resultMap.Find(ImageVisual::Property::ALPHA_MASK_URL, Property::STRING);
DALI_TEST_CHECK(value);
.Add("borderlineWidth", 20.0f)
.Add("borderlineColor", Vector4())
.Add("borderlineOffset", -1.0f)
+ .Add("cornerSquareness", Vector4(1.0f, 0.5f, 0.25f, 0.0f))
.Add("frameSpeedFactor", 0.5f));
Property::Map resultMap;
DALI_TEST_CHECK(value);
DALI_TEST_EQUALS(value->Get<float>(), -1.0f, TEST_LOCATION);
+ value = resultMap.Find(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, "cornerSquareness");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(1.0f, 0.5f, 0.25f, 0.0f), TEST_LOCATION);
+
// Check mask properties
value = resultMap.Find(ImageVisual::Property::ALPHA_MASK_URL, "alphaMaskUrl");
DALI_TEST_CHECK(value);
DALI_TEST_CHECK(value);
DALI_TEST_EQUALS(value->Get<float>(), 0.0f, TEST_LOCATION);
+ value = resultMap.Find(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, "cornerSquareness");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
+
// Check mask properties
value = resultMap.Find(ImageVisual::Property::ALPHA_MASK_URL, "alphaMaskUrl");
DALI_TEST_CHECK(value);
DALI_TEST_CHECK(value);
DALI_TEST_EQUALS(value->Get<float>(), 0.0f, TEST_LOCATION);
+ value = resultMap.Find(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, "cornerSquareness");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
+
END_TEST;
}
float borderlineWidth = 2.0f;
Vector4 borderlineColor = Vector4(1.0f, 1.0f, 1.0f, 1.0f);
float borderlineOffset = 0.1f;
+ float cornerSquareness = 0.6f;
Property::Array playRange;
playRange.PushBack(startFrame);
playRange.PushBack(endFrame);
.Add("borderlineWidth", borderlineWidth)
.Add("borderlineColor", borderlineColor)
.Add("borderlineOffset", borderlineOffset)
+ .Add("cornerSquareness", cornerSquareness)
.Add("desiredWidth", desiredWidth)
.Add("desiredHeight", desiredHeight);
DALI_TEST_CHECK(value);
DALI_TEST_EQUALS(value->Get<float>(), borderlineOffset, TEST_LOCATION);
+ value = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(cornerSquareness, cornerSquareness, cornerSquareness, cornerSquareness), TEST_LOCATION);
+
value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
DALI_TEST_CHECK(value);
DALI_TEST_EQUALS(value->Get<int>(), desiredWidth, TEST_LOCATION);
float borderlineWidth = 2.3f;
Vector4 borderlineColor = Vector4(0.3f, 0.3f, 1.0f, 1.0f);
float borderlineOffset = 0.3f;
+ Vector4 cornerSquareness(0.1f, 0.4f, 0.2f, 0.3f);
Property::Array playRange;
playRange.PushBack(startFrame);
playRange.PushBack(endFrame);
.Add(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth)
.Add(DevelVisual::Property::BORDERLINE_COLOR, borderlineColor)
.Add(DevelVisual::Property::BORDERLINE_OFFSET, borderlineOffset)
+ .Add(DevelVisual::Property::CORNER_SQUARENESS, cornerSquareness)
.Add(ImageVisual::Property::SYNCHRONOUS_LOADING, false)
.Add(ImageVisual::Property::DESIRED_WIDTH, desiredWidth)
.Add(ImageVisual::Property::DESIRED_HEIGHT, desiredHeight);
DALI_TEST_CHECK(value);
DALI_TEST_EQUALS(value->Get<float>(), borderlineOffset, TEST_LOCATION);
+ value = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS(value->Get<Vector4>(), cornerSquareness, TEST_LOCATION);
+
value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
DALI_TEST_CHECK(value);
DALI_TEST_EQUALS(value->Get<int>(), desiredWidth, TEST_LOCATION);
blackDimmerMap.Insert(Toolkit::Visual::Property::MIX_COLOR, Color::BLACK);
blackDimmerMap.Insert(Toolkit::Visual::Property::OPACITY, 0.2f);
blackDimmerMap.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS, 30.0f);
+ blackDimmerMap.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, 0.3f);
RenderEffect effect = BackgroundBlurEffect::New(0.4f, 40);
Vector4 radius = Vector4::ZERO;
renderer.GetProperty(renderer.GetPropertyIndex(std::string("uCornerRadius"))).Get(radius);
+ Vector4 squreness = Vector4::ZERO;
+ renderer.GetProperty(renderer.GetPropertyIndex(std::string("uCornerSquareness"))).Get(squreness);
+
Toolkit::Visual::Transform::Policy::Type policy;
renderer.GetProperty(renderer.GetPropertyIndex(std::string("uCornerRadiusPolicy"))).Get(policy);
DALI_TEST_CHECK(policy == 1);
DALI_TEST_CHECK(radius.z == 30.0f);
DALI_TEST_CHECK(radius.w == 30.0f);
+ DALI_TEST_CHECK(squreness.x == 0.3f);
+ DALI_TEST_CHECK(squreness.y == 0.3f);
+ DALI_TEST_CHECK(squreness.z == 0.3f);
+ DALI_TEST_CHECK(squreness.w == 0.3f);
+
END_TEST;
}
/*
- * 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.
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, 50.f);
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, Vector4(1.0f, 0.0f, 0.0f, 1.0f));
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, 1.f);
+ controlProperty1.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, 0.5f);
control1.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty1);
Control control2 = Control::New();
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, 30.f);
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, Vector4(1.0f, 1.0f, 0.0f, 0.5f));
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, -1.f);
+ controlProperty2.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, 0.2f);
control2.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty2);
application.GetScene().Add(control1);
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, 50.f);
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, Vector4(1.0f, 0.0f, 0.0f, 1.0f));
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, -1.f);
+ controlProperty1.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
control1.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty1);
Control control2 = Control::New();
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, 30.f);
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, Vector4(1.0f, 1.0f, 0.0f, 0.5f));
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, -1.f);
+ controlProperty2.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, Vector4(0.4f, 0.3f, 0.2f, 0.1f));
control2.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty2);
application.GetScene().Add(control1);
float destinationBorderlineWidth(80.0f);
Vector4 destinationBorderlineColor(0.5f, 1.0f, 0.5f, 0.3f);
float destinationBorderlineOffset(-1.0f);
- Vector4 destinationRadiusV4 = Vector4(destinationRadius, destinationRadius, destinationRadius, destinationRadius);
+ float destinationSqureness(0.3f);
+ Vector4 destinationRadiusV4 = Vector4(destinationRadius, destinationRadius, destinationRadius, destinationRadius);
+ Vector4 destinationSqurenessV4 = Vector4(destinationSqureness, destinationSqureness, destinationSqureness, destinationSqureness);
Control control1 = Control::New();
control1.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, 60.f);
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, Vector4(1.0f, 0.0f, 0.0f, 1.0f));
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, 1.f);
+ controlProperty1.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, 0.1f);
control1.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty1);
Control control2 = Control::New();
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, destinationBorderlineWidth);
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, destinationBorderlineColor);
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, destinationBorderlineOffset);
+ controlProperty2.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, destinationSqureness);
control2.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty2);
DALI_TEST_EQUALS(destinationPosition, control2.GetProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
DALI_TEST_EQUALS(destinationBorderlineColor, borderlineColor, TEST_LOCATION);
float borderlineOffset = backgroundMap.Find(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET)->Get<float>();
DALI_TEST_EQUALS(destinationBorderlineOffset, borderlineOffset, TEST_LOCATION);
+ Vector4 cornerSquareness = backgroundMap.Find(Toolkit::DevelVisual::Property::CORNER_SQUARENESS)->Get<Vector4>();
+ DALI_TEST_EQUALS(destinationSqurenessV4, cornerSquareness, TEST_LOCATION);
application.GetScene().Add(control1);
application.GetScene().Add(control2);
DALI_TEST_NOT_EQUALS(destinationBorderlineColor, borderlineColor, 0.00001f, TEST_LOCATION);
borderlineOffset = renderer.GetCurrentProperty<float>(DecoratedVisualRenderer::Property::BORDERLINE_OFFSET);
DALI_TEST_NOT_EQUALS(destinationBorderlineOffset, borderlineOffset, 0.00001f, TEST_LOCATION);
+ cornerSquareness = renderer.GetCurrentProperty<Vector4>(DecoratedVisualRenderer::Property::CORNER_SQUARENESS);
+ DALI_TEST_NOT_EQUALS(destinationSqurenessV4, cornerSquareness, 0.00001f, TEST_LOCATION);
application.SendNotification();
application.Render(700);
DALI_TEST_EQUALS(destinationBorderlineColor, borderlineColor, TEST_LOCATION);
borderlineOffset = renderer.GetCurrentProperty<float>(DecoratedVisualRenderer::Property::BORDERLINE_OFFSET);
DALI_TEST_EQUALS(destinationBorderlineOffset, borderlineOffset, TEST_LOCATION);
+ cornerSquareness = renderer.GetCurrentProperty<Vector4>(DecoratedVisualRenderer::Property::CORNER_SQUARENESS);
+ DALI_TEST_EQUALS(destinationSqurenessV4, cornerSquareness, TEST_LOCATION);
END_TEST;
}
float sourceBorderlineWidth(60.0f);
Vector4 sourceBorderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
float sourceBorderlineOffset(1.f);
- Vector4 sourceRadiusV4 = Vector4(sourceRadius, sourceRadius, sourceRadius, sourceRadius);
+ float sourceSqureness(0.3f);
+ Vector4 sourceRadiusV4 = Vector4(sourceRadius, sourceRadius, sourceRadius, sourceRadius);
+ Vector4 sourceSqurenessV4 = Vector4(sourceSqureness, sourceSqureness, sourceSqureness, sourceSqureness);
Vector3 destinationPosition(50, 50, 0);
Vector3 destinationSize(120, 120, 0);
float destinationBorderlineWidth(80.0f);
Vector4 destinationBorderlineColor(0.5f, 1.0f, 0.5f, 0.3f);
float destinationBorderlineOffset(-1.0f);
- Vector4 destinationRadiusV4 = Vector4(destinationRadius, destinationRadius, destinationRadius, destinationRadius);
+ float destinationSqureness(0.5f);
+ Vector4 destinationRadiusV4 = Vector4(destinationRadius, destinationRadius, destinationRadius, destinationRadius);
+ Vector4 destinationSqurenessV4 = Vector4(destinationSqureness, destinationSqureness, destinationSqureness, destinationSqureness);
Control control1 = Control::New();
control1.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, sourceBorderlineWidth);
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, sourceBorderlineColor);
controlProperty1.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, sourceBorderlineOffset);
+ controlProperty1.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, sourceSqureness);
control1.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty1);
Control control2 = Control::New();
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, destinationBorderlineWidth);
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, destinationBorderlineColor);
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, destinationBorderlineOffset);
+ controlProperty2.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, destinationSqureness);
control2.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty2);
DALI_TEST_EQUALS(destinationPosition, control2.GetProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
DALI_TEST_EQUALS(destinationBorderlineColor, borderlineColor, TEST_LOCATION);
float borderlineOffset = backgroundMap.Find(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET)->Get<float>();
DALI_TEST_EQUALS(destinationBorderlineOffset, borderlineOffset, TEST_LOCATION);
+ Vector4 cornerSquareness = backgroundMap.Find(Toolkit::DevelVisual::Property::CORNER_SQUARENESS)->Get<Vector4>();
+ DALI_TEST_EQUALS(destinationSqurenessV4, cornerSquareness, TEST_LOCATION);
application.GetScene().Add(control1);
application.GetScene().Add(control2);
borderlineOffset = renderer.GetCurrentProperty<float>(DecoratedVisualRenderer::Property::BORDERLINE_OFFSET);
DALI_TEST_NOT_EQUALS(destinationBorderlineOffset, borderlineOffset, 0.00001f, TEST_LOCATION);
+ cornerSquareness = renderer.GetCurrentProperty<Vector4>(DecoratedVisualRenderer::Property::CORNER_RADIUS);
+ DALI_TEST_NOT_EQUALS(destinationSqurenessV4, cornerSquareness, 0.00001f, TEST_LOCATION);
+
application.SendNotification();
application.Render(700);
borderlineOffset = renderer.GetCurrentProperty<float>(DecoratedVisualRenderer::Property::BORDERLINE_OFFSET);
DALI_TEST_EQUALS(destinationBorderlineOffset, borderlineOffset, TEST_LOCATION);
+ cornerSquareness = renderer.GetCurrentProperty<Vector4>(DecoratedVisualRenderer::Property::CORNER_SQUARENESS);
+ DALI_TEST_EQUALS(destinationSqurenessV4, cornerSquareness, TEST_LOCATION);
+
// every actor properties of control1 are returned to the source properties.
DALI_TEST_EQUALS(sourcePosition, control1.GetProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
DALI_TEST_EQUALS(sourceSize, control1.GetProperty<Vector3>(Actor::Property::SIZE), TEST_LOCATION);
borderlineOffset = renderer.GetCurrentProperty<float>(DecoratedVisualRenderer::Property::BORDERLINE_OFFSET);
DALI_TEST_EQUALS(sourceBorderlineOffset, borderlineOffset, TEST_LOCATION);
+ cornerSquareness = renderer.GetCurrentProperty<Vector4>(DecoratedVisualRenderer::Property::CORNER_SQUARENESS);
+ DALI_TEST_EQUALS(sourceSqurenessV4, cornerSquareness, TEST_LOCATION);
+
END_TEST;
}
float destinationBorderlineWidth(40.f);
Vector4 destinationBorderlineColor(1.0f, 0.5f, 0.2f, 0.8f);
float destinationBorderlineOffset(1.f);
+ Vector4 destinationSquareness(0.1f, 0.2f, 0.4f, 0.3f);
Control control1 = Control::New();
control1.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, destinationBorderlineWidth);
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, destinationBorderlineColor);
controlProperty2.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, destinationBorderlineOffset);
+ controlProperty2.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, destinationSquareness);
control2.SetProperty(Toolkit::Control::Property::BACKGROUND, controlProperty2);
Property::Map backgroundMap = control2.GetProperty<Property::Map>(Toolkit::Control::Property::BACKGROUND);
DALI_TEST_EQUALS(destinationBorderlineColor, borderlineColor, TEST_LOCATION);
float borderlineOffset = backgroundMap.Find(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET)->Get<float>();
DALI_TEST_EQUALS(destinationBorderlineOffset, borderlineOffset, TEST_LOCATION);
+ Vector4 cornerSquareness = backgroundMap.Find(Toolkit::DevelVisual::Property::CORNER_SQUARENESS)->Get<Vector4>();
+ DALI_TEST_EQUALS(destinationSquareness, cornerSquareness, TEST_LOCATION);
application.GetScene().Add(control1);
application.GetScene().Add(control2);
DALI_TEST_EQUALS(destinationBorderlineColor, borderlineColor, TEST_LOCATION);
borderlineOffset = backgroundMap.Find(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET)->Get<float>();
DALI_TEST_EQUALS(destinationBorderlineOffset, borderlineOffset, TEST_LOCATION);
+ cornerSquareness = backgroundMap.Find(Toolkit::DevelVisual::Property::CORNER_SQUARENESS)->Get<Vector4>();
+ DALI_TEST_EQUALS(destinationSquareness, cornerSquareness, TEST_LOCATION);
application.SendNotification();
application.Render(700);
DALI_TEST_EQUALS(destinationBorderlineColor, borderlineColor, TEST_LOCATION);
borderlineOffset = backgroundMap.Find(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET)->Get<float>();
DALI_TEST_EQUALS(destinationBorderlineOffset, borderlineOffset, TEST_LOCATION);
+ cornerSquareness = backgroundMap.Find(Toolkit::DevelVisual::Property::CORNER_SQUARENESS)->Get<Vector4>();
+ DALI_TEST_EQUALS(destinationSquareness, cornerSquareness, TEST_LOCATION);
END_TEST;
}
return true;
}
-void TestShaderCodeContainSubstrings(Control control, std::vector<std::pair<std::string, bool>> substringCheckList, const char* location)
+struct ShaderCodeCheckResult
{
- Renderer renderer = control.GetRendererAt(0);
- Shader shader = renderer.GetShader();
- Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
- Property::Map* map = value.GetMap();
- DALI_TEST_CHECK(map);
-
- Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
- std::string vertexShader;
- DALI_TEST_CHECK(vertex->Get(vertexShader));
- for(const auto& checkPair : substringCheckList)
+ ShaderCodeCheckResult(bool expect)
+ : expectVertexResult{expect},
+ expectFragmentResult{expect}
{
- const auto& keyword = checkPair.first;
- const auto& expect = checkPair.second;
- tet_printf("check [%s] %s exist in vertex shader\n", keyword.c_str(), expect ? "is" : "is not");
- DALI_TEST_EQUALS((vertexShader.find(keyword.c_str()) != std::string::npos), expect, location);
}
-
- Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
- DALI_TEST_CHECK(fragment);
- std::string fragmentShader;
- DALI_TEST_CHECK(fragment->Get(fragmentShader));
- for(const auto& checkPair : substringCheckList)
+ ShaderCodeCheckResult(std::initializer_list<bool> list)
+ : expectVertexResult{false},
+ expectFragmentResult{false}
{
- const auto& keyword = checkPair.first;
- const auto& expect = checkPair.second;
- tet_printf("check [%s] %s exist in fragment shader\n", keyword.c_str(), expect ? "is" : "is not");
- DALI_TEST_EQUALS((fragmentShader.find(keyword.c_str()) != std::string::npos), expect, location);
+ if(list.size() == 1)
+ {
+ expectVertexResult = expectFragmentResult = *list.begin();
+ }
+ else if(list.size() > 1)
+ {
+ expectVertexResult = *list.begin();
+ expectFragmentResult = *(list.begin() + 1);
+ }
}
-}
-void TestShaderCodeContainSubstringsForEachShader(Control control, std::vector<std::pair<std::string, std::pair<bool, bool>>> substringCheckList, const char* location)
+ bool expectVertexResult{false};
+ bool expectFragmentResult{false};
+};
+
+void TestShaderCodeContainSubstrings(Control control, std::vector<std::pair<std::string, ShaderCodeCheckResult>> substringCheckList, const char* location)
{
Renderer renderer = control.GetRendererAt(0);
Shader shader = renderer.GetShader();
for(const auto& checkPair : substringCheckList)
{
const auto& keyword = checkPair.first;
- const auto& expect = checkPair.second.first;
+ const auto& expect = checkPair.second.expectVertexResult;
tet_printf("check [%s] %s exist in vertex shader\n", keyword.c_str(), expect ? "is" : "is not");
DALI_TEST_EQUALS((vertexShader.find(keyword.c_str()) != std::string::npos), expect, location);
}
for(const auto& checkPair : substringCheckList)
{
const auto& keyword = checkPair.first;
- const auto& expect = checkPair.second.second;
+ const auto& expect = checkPair.second.expectFragmentResult;
tet_printf("check [%s] %s exist in fragment shader\n", keyword.c_str(), expect ? "is" : "is not");
DALI_TEST_EQUALS((fragmentShader.find(keyword.c_str()) != std::string::npos), expect, location);
}
propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
+ propertyMap.Insert(DevelVisual::Property::CORNER_SQUARENESS, 1.0f);
propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
propertyMap.Insert(DevelColorVisual::Property::CUTOUT_POLICY, DevelColorVisual::CutoutPolicy::CUTOUT_VIEW_WITH_CORNER_RADIUS);
Visual::Base colorVisual = factory.CreateVisual(propertyMap);
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
+ Property::Value* cornerSqaurenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSqaurenessValue);
+ DALI_TEST_CHECK(cornerSqaurenessValue->Get<Vector4>() == Vector4::ONE);
+
Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
DALI_TEST_CHECK(blurRadiusValue);
DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
{
UniformData("cornerRadius", Property::Type::VECTOR4),
UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
+ UniformData("cornerSquareness", Property::Type::VECTOR4),
};
// image visual
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
- float cornerRadius = 30.0f;
+ float cornerRadius = 30.0f;
+ float cornerSquareness = 0.5f;
- properties[Visual::Property::TYPE] = Visual::IMAGE;
- properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
- properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
+ properties[Visual::Property::TYPE] = Visual::IMAGE;
+ properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
+ properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
+ properties[DevelVisual::Property::CORNER_SQUARENESS] = cornerSquareness;
Visual::Base visual = factory.CreateVisual(properties);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
// Default corner radius policy is absolute.
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", Vector4(cornerSquareness, cornerSquareness, cornerSquareness, cornerSquareness)), true, TEST_LOCATION);
}
// color visual 1
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
- float cornerRadius = 30.0f;
+ float cornerRadius = 30.0f;
+ float cornerSquareness = 0.5f;
properties[Visual::Property::TYPE] = Visual::COLOR;
properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
properties["cornerRadius"] = cornerRadius;
properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
+ properties["cornerSquareness"] = cornerSquareness;
Visual::Base visual = factory.CreateVisual(properties);
// Currently test with multiple program doesn't work well. will fix another day
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", Vector4(cornerSquareness, cornerSquareness, cornerSquareness, cornerSquareness)), true, TEST_LOCATION);
}
// color visual 2
// Currently test with multiple program doesn't work well. will fix another day
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
+ // Default corner squareness is Vector4::ZERO.
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", Vector4::ZERO), true, TEST_LOCATION);
}
// color visual 3 - invalid value
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
// Default corner radius policy is absolute.
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
+ // Default corner squareness is Vector4::ZERO.
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", Vector4::ZERO), true, TEST_LOCATION);
}
// gradient visual
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
float cornerRadius = 30.0f;
+ Vector4 cornerSquareness(0.5f, 0.5f, 0.5f, 0.5f);
properties[Visual::Property::TYPE] = Visual::GRADIENT;
properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
+ properties[DevelVisual::Property::CORNER_SQUARENESS] = cornerSquareness;
properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
// Default corner radius policy is absolute.
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", cornerSquareness), true, TEST_LOCATION);
}
// animated image visual
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
+ Vector4 cornerSquareness(0.3f, 0.2f, 0.5f, 0.6f);
properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
+ properties["cornerSquareness"] = cornerSquareness;
properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
Visual::Base visual = factory.CreateVisual(properties);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", cornerSquareness), true, TEST_LOCATION);
}
// vector image visual
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
// Default corner radius policy is absolute.
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
+ // Default corner squareness is Vector4::ZERO.
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", Vector4::ZERO), true, TEST_LOCATION);
}
// animated vector image visual
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
- float cornerRadius = 1.3f;
+ float cornerRadius = 1.3f;
+ float cornerSquareness = 0.1f;
properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
properties["cornerRadius"] = cornerRadius;
properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
+ properties[DevelVisual::Property::CORNER_SQUARENESS] = cornerSquareness;
properties["synchronousLoading"] = false;
Visual::Base visual = factory.CreateVisual(properties);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", Vector4(cornerSquareness, cornerSquareness, cornerSquareness, cornerSquareness)), true, TEST_LOCATION);
}
END_TEST;
UniformData("borderlineWidth", Property::Type::FLOAT),
UniformData("borderlineColor", Property::Type::VECTOR4),
UniformData("borderlineOffset", Property::Type::FLOAT),
+ UniformData("cornerSquareness", Property::Type::VECTOR4),
};
// image visual
float borderlineWidth = 30.0f;
Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
float borderlineOffset = 1.0f;
+ float cornerSquareness = 0.5f;
properties[Visual::Property::TYPE] = Visual::IMAGE;
properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
+ properties[DevelVisual::Property::CORNER_SQUARENESS] = cornerSquareness;
Visual::Base visual = factory.CreateVisual(properties);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", Vector4(cornerSquareness, cornerSquareness, cornerSquareness, cornerSquareness)), true, TEST_LOCATION);
}
// color visual 1
float borderlineWidth = 30.0f;
Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
float borderlineOffset = -0.4f;
+ Vector4 cornerSquareness(0.1f, 0.2f, 0.3f, 0.4f);
properties[Visual::Property::TYPE] = Visual::COLOR;
properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
properties["borderlineWidth"] = borderlineWidth;
properties["borderlineColor"] = borderlineColor;
properties["borderlineOffset"] = borderlineOffset;
+ properties["cornerSquareness"] = cornerSquareness;
Visual::Base visual = factory.CreateVisual(properties);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", cornerSquareness), true, TEST_LOCATION);
}
// color visual 2, default color, default offset
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
- float borderlineWidth = 30.0f;
- float cornerRadius = 70.0f;
+ float borderlineWidth = 30.0f;
+ float cornerRadius = 70.0f;
+ float cornerSquareness = 0.5f;
properties[Visual::Property::TYPE] = Visual::GRADIENT;
properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
+ properties[DevelVisual::Property::CORNER_SQUARENESS] = cornerSquareness;
properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
// Default borderline offset is 0.0f.
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", Vector4(cornerSquareness, cornerSquareness, cornerSquareness, cornerSquareness)), true, TEST_LOCATION);
}
// animated image visual
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
// Default borderline offset is 0.0.
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
+ // Default corner squareness is Vector4::ZERO.
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", Vector4::ZERO), true, TEST_LOCATION);
}
// animated vector image visual
float borderlineWidth = 13.0f;
Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
float borderlineOffset = 13.0f;
+ Vector4 cornerSquareness(0.1f, 0.0f, 0.2f, 0.4f);
properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
properties["borderlineColor"] = borderlineColor;
properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
+ properties["cornerSquareness"] = cornerSquareness;
properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = false;
Visual::Base visual = factory.CreateVisual(properties);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", cornerSquareness), true, TEST_LOCATION);
}
END_TEST;
UniformData("blurRadius", Property::Type::FLOAT),
UniformData("borderlineWidth", Property::Type::FLOAT),
UniformData("borderlineColor", Property::Type::VECTOR4),
- UniformData("borderlineOffset", Property::Type::FLOAT)};
+ UniformData("borderlineOffset", Property::Type::FLOAT),
+ UniformData("cornerSquareness", Property::Type::VECTOR4),
+ };
TestGraphicsController& graphics = application.GetGraphicsController();
graphics.AddCustomUniforms(customUniforms);
propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
+ propertyMap.Insert(DevelVisual::Property::CORNER_SQUARENESS, Vector4(0.1f, 0.2f, 0.0f, 1.0f));
Visual::Base colorVisual = factory.CreateVisual(propertyMap);
DummyControl dummyControl = DummyControl::New(true);
float targetBorderlineWidth = 25.0f;
Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
float targetBorderlineOffset = -1.0f;
+ Vector4 targetCornerSquareness(0.5f, 0.0f, 1.0f, 0.0f);
Animation animation = Animation::New(1.0f);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
+ animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_SQUARENESS), targetCornerSquareness);
animation.Play();
application.SendNotification();
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
+ Property::Value* cornerSqaurenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSqaurenessValue);
+ DALI_TEST_EQUALS(cornerSqaurenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
// Test uniform values
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", targetCornerSquareness), true, TEST_LOCATION);
// Test unregistered visual
Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
UniformData("borderlineCOlor", Property::Type::VECTOR4),
UniformData("borderlineOffset", Property::Type::FLOAT),
UniformData("blurRadius", Property::Type::FLOAT),
+ UniformData("cornerSquareness", Property::Type::VECTOR4),
};
TestGraphicsController& graphics = application.GetGraphicsController();
Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
float targetBorderlineOffset = 1.0f;
float targetBlurRadius = 10.0f;
+ Vector4 targetCornerSquareness(0.0f, 0.2f, 0.4f, 0.5f);
// Should work when the properties are not set before
Animation animation = Animation::New(1.0f);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
+ animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerSquareness"), targetCornerSquareness);
animation.Play();
application.SendNotification();
DALI_TEST_CHECK(blurRadiusValue);
DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
// Test uniform values
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", targetCornerSquareness), true, TEST_LOCATION);
END_TEST;
}
UniformData("borderlineWidth", Property::Type::FLOAT),
UniformData("borderlineColor", Property::Type::VECTOR4),
UniformData("borderlineOffset", Property::Type::FLOAT),
+ UniformData("cornerSquareness", Property::Type::VECTOR4),
};
TestGraphicsController& graphics = application.GetGraphicsController();
float targetBorderlineWidth = 10.0f;
Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
float targetBorderlineOffset = -1.5f;
+ Vector4 targetCornerSquareness(0.0f, 0.2f, 0.4f, 0.5f);
Animation animation = Animation::New(1.0f);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
+ animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_SQUARENESS), targetCornerSquareness);
animation.Play();
application.SendNotification();
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
// Test uniform value
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("pixelArea", targetPixelArea), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", targetCornerSquareness), true, TEST_LOCATION);
// Test non-animatable index, for coverage.
DALI_TEST_EQUALS(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, ImageVisual::Property::URL).propertyIndex, Property::INVALID_INDEX, TEST_LOCATION);
static std::vector<UniformData> customUniforms =
{
UniformData("cornerRadius", Property::Type::VECTOR4),
+ UniformData("cornerSquareness", Property::Type::VECTOR4),
};
TestGraphicsController& graphics = application.GetGraphicsController();
float targetOpacity = 0.5f;
Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
+ Vector4 targetCornerSquareness(0.2f, 0.3f, 0.1f, 0.2f);
Animation animation = Animation::New(1.0f);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
+ animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_SQUARENESS), targetCornerSquareness);
animation.Play();
application.SendNotification();
DALI_TEST_CHECK(cornerRadiusValue);
DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
// Test uniform value
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", targetCornerSquareness), true, TEST_LOCATION);
END_TEST;
}
UniformData("borderlineWidth", Property::Type::FLOAT),
UniformData("borderlineColor", Property::Type::VECTOR4),
UniformData("borderlineOffset", Property::Type::FLOAT),
+ UniformData("cornerSquareness", Property::Type::VECTOR4),
};
TestGraphicsController& graphics = application.GetGraphicsController();
float targetBorderlineWidth = 10.0f;
Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
float targetBorderlineOffset = -1.5f;
+ Vector4 targetCornerSquareness(0.2f, 0.3f, 0.1f, 0.2f);
Animation animation = Animation::New(1.0f);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
+ animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_SQUARENESS), targetCornerSquareness);
animation.Play();
application.SendNotification();
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
// Currently test with multiple program doesn't work well. will fix another day
// Test uniform value
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", targetCornerSquareness), true, TEST_LOCATION);
END_TEST;
}
UniformData("borderlineWidth", Property::Type::FLOAT),
UniformData("borderlineColor", Property::Type::VECTOR4),
UniformData("borderlineOffset", Property::Type::FLOAT),
+ UniformData("cornerSquareness", Property::Type::VECTOR4),
};
TestGraphicsController& graphics = application.GetGraphicsController();
float targetBorderlineWidth = 10.0f;
Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
float targetBorderlineOffset = -1.5f;
+ Vector4 targetCornerSquareness(0.2f, 0.3f, 0.1f, 0.2f);
Animation animation = Animation::New(1.0f);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
+ animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_SQUARENESS), targetCornerSquareness);
animation.Play();
application.SendNotification();
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
// Currently test with multiple program doesn't work well. will fix another day
// Test uniform value
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", targetCornerSquareness), true, TEST_LOCATION);
END_TEST;
}
UniformData("borderlineWidth", Property::Type::FLOAT),
UniformData("borderlineColor", Property::Type::VECTOR4),
UniformData("borderlineOffset", Property::Type::FLOAT),
+ UniformData("cornerSquareness", Property::Type::VECTOR4),
};
TestGraphicsController& graphics = application.GetGraphicsController();
float targetBorderlineWidth = 10.0f;
Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
float targetBorderlineOffset = -1.5f;
+ Vector4 targetCornerSquareness(0.2f, 0.3f, 0.1f, 0.2f);
Animation animation = Animation::New(1.0f);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
+ animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_SQUARENESS), targetCornerSquareness);
animation.Play();
application.SendNotification();
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
// Currently test with multiple program doesn't work well. will fix another day
// Test uniform value
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerSquareness", targetCornerSquareness), true, TEST_LOCATION);
END_TEST;
}
float targetBorderlineWidth = 20.0f;
Vector4 targetBorderlineColor = Color::RED;
float targetBorderlineOffset = 1.0f;
+ Vector4 targetCornerSquareness = Vector4(0.0f, 0.0f, 0.6f, 0.6f);
Property::Map targetPropertyMap;
targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
+ targetPropertyMap[DevelVisual::Property::CORNER_SQUARENESS] = targetCornerSquareness;
// Update Properties
DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
END_TEST;
}
Vector4 borderlineColor = Color::BLUE;
float borderlineOffset = 1.0f;
+ Vector4 cornerSquareness = Vector4::ZERO;
VisualFactory factory = VisualFactory::Get();
Property::Map propertyMap;
propertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
propertyMap[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
propertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
+ propertyMap[DevelVisual::Property::CORNER_SQUARENESS] = cornerSquareness;
Visual::Base imageVisual = factory.CreateVisual(propertyMap);
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), borderlineOffset, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), cornerSquareness, TEST_LOCATION);
+
END_TEST;
}
float targetBorderlineWidth = 20.0f;
Vector4 targetBorderlineColor = Color::RED;
float targetBorderlineOffset = 1.0f;
+ Vector4 targetCornerSquareness = Vector4(0.2f, 0.4f, 0.6f, 0.8f);
Property::Map targetPropertyMap;
targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
+ targetPropertyMap[DevelVisual::Property::CORNER_SQUARENESS] = targetCornerSquareness;
// Update Properties
DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
{
{"#define IS_REQUIRED_BORDERLINE", false},
{"#define IS_REQUIRED_ROUNDED_CORNER", false},
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", false},
},
TEST_LOCATION);
callStack.Reset();
callStack.Enable(true);
- Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
+ Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
+ Vector4 targetCornerSquareness = Vector4(0.2f, 0.4f, 0.6f, 0.8f);
Property::Map targetPropertyMap;
targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
+ targetPropertyMap[DevelVisual::Property::CORNER_SQUARENESS] = targetCornerSquareness;
// Update Properties with CornerRadius
DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
DALI_TEST_CHECK(cornerRadiusPolicyValue);
DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
TestShaderCodeContainSubstrings(
dummyControl,
{
{"#define IS_REQUIRED_BORDERLINE", false},
{"#define IS_REQUIRED_ROUNDED_CORNER", true},
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", {false, true}},
},
TEST_LOCATION);
targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
+ targetPropertyMap2[DevelVisual::Property::CORNER_SQUARENESS] = Vector4::ZERO;
// Update Properties with Borderline
DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
+ cornerSquarenessValue = resultMap2.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
+
TestShaderCodeContainSubstrings(
dummyControl,
{
{"#define IS_REQUIRED_BORDERLINE", true},
- {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", {false, true}}, // Note : mAlwaysUsingCornerSquareness is true.
},
TEST_LOCATION);
targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
+ targetPropertyMap3[DevelVisual::Property::CORNER_SQUARENESS] = Vector4::ZERO;
// Update Properties into zero
DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
DALI_TEST_CHECK(borderlineOffsetValue);
DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
+ cornerSquarenessValue = resultMap3.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
+
TestShaderCodeContainSubstrings(
dummyControl,
{
- {"#define IS_REQUIRED_BORDERLINE", true}, // Note : mAlwaysUsingBorderline is true.
- {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_BORDERLINE", true}, // Note : mAlwaysUsingBorderline is true.
+ {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", {false, true}}, // Note : mAlwaysUsingCornerSquareness is true.
},
TEST_LOCATION);
{
{"#define IS_REQUIRED_BORDERLINE", false},
{"#define IS_REQUIRED_ROUNDED_CORNER", false},
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", false},
},
TEST_LOCATION);
- Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+ Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+ Vector4 targetCornerSquareness = Vector4(0.2f, 0.4f, 0.6f, 0.8f);
Property::Map targetPropertyMap;
- targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
+ targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
+ targetPropertyMap[DevelVisual::Property::CORNER_SQUARENESS] = targetCornerSquareness;
callStack.Reset();
callStack.Enable(true);
DALI_TEST_CHECK(cornerRadiusValue);
DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
TestShaderCodeContainSubstrings(
dummyControl,
{
{"#define IS_REQUIRED_BORDERLINE", false},
- {"#define IS_REQUIRED_ROUNDED_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
+ {"#define IS_REQUIRED_ROUNDED_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
},
TEST_LOCATION);
{
{"#define IS_REQUIRED_BORDERLINE", false}, // Note : borderline width is zero. so we don't change shader!
{"#define IS_REQUIRED_ROUNDED_CORNER", false},
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", false},
},
TEST_LOCATION);
{"#define IS_REQUIRED_BLUR", false},
{"#define IS_REQUIRED_BORDERLINE", false},
{"#define IS_REQUIRED_ROUNDED_CORNER", false},
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", false},
},
TEST_LOCATION);
{"#define IS_REQUIRED_BLUR", true},
{"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
{"#define IS_REQUIRED_ROUNDED_CORNER", true},
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", false},
},
TEST_LOCATION);
{"#define IS_REQUIRED_BLUR", true}, // Note : mAlwaysUsingBlurRadius is true.
{"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
{"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", false},
},
TEST_LOCATION);
VisualFactory factory = VisualFactory::Get();
Property::Map propertyMap;
+ Vector4 targetCornerSquareness = Vector4(1.0f, 1.0f, 1.0f, 1.0f);
// Case ImageVisual
- propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
- propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
- propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
+ propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
+ propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
+ propertyMap[DevelVisual::Property::CORNER_SQUARENESS] = targetCornerSquareness;
Visual::Base imageVisual = factory.CreateVisual(propertyMap);
dummyControl,
{
{"#define IS_REQUIRED_BORDERLINE", false},
- {"#define IS_REQUIRED_ROUNDED_CORNER", true},
+ {"#define IS_REQUIRED_ROUNDED_CORNER", false},
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
},
TEST_LOCATION);
dummyControl,
{
{"#define IS_REQUIRED_BORDERLINE", false},
- {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", {false, true}}, // Note : CornerSqureness is non-zero.
},
TEST_LOCATION);
callStack.Enable(false);
- // Shader not changed
- DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
+ // Shader changed
+ DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
callStack.Reset();
callStack.Enable(true);
DALI_TEST_CHECK(cornerRadiusValue);
DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
+ Property::Value* cornerSquarenessValue = resultMap.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
DALI_TEST_CHECK(cornerRadiusPolicyValue);
DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
dummyControl,
{
{"#define IS_REQUIRED_BORDERLINE", true},
- {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", {false, true}}, // Note : CornerSqureness is non-zero. mAlwaysUsingCornerSquareness become true.
},
TEST_LOCATION);
callStack.Enable(false);
// Shader changed
DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
+ callStack.Reset();
+ callStack.Enable(true);
+
+ // Change CornerSquareness as Zero
+ targetCornerSquareness = Vector4::ZERO;
+ Property::Map targetPropertyMap2;
+ targetPropertyMap2[DevelVisual::Property::CORNER_SQUARENESS] = targetCornerSquareness;
+
+ // Update Properties with CornerRadius
+ DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
+
+ Property::Map resultMap2;
+ imageVisual.CreatePropertyMap(resultMap2);
+
+ // Test property values: they should be updated
+ cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerRadiusValue);
+ DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
+
+ cornerSquarenessValue = resultMap2.Find(DevelVisual::Property::CORNER_SQUARENESS, Property::VECTOR4);
+ DALI_TEST_CHECK(cornerSquarenessValue);
+ DALI_TEST_EQUALS(cornerSquarenessValue->Get<Vector4>(), targetCornerSquareness, TEST_LOCATION);
+
+ cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
+ DALI_TEST_CHECK(cornerRadiusPolicyValue);
+ DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
+
+ borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
+ DALI_TEST_CHECK(borderlineWidthValue);
+ DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
+
+ TestShaderCodeContainSubstrings(
+ dummyControl,
+ {
+ {"#define IS_REQUIRED_BORDERLINE", true},
+ {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", {false, true}}, // Note : mAlwaysUsingCornerSquareness is true.
+ },
+ TEST_LOCATION);
+
+ // Send shader compile signal
+ application.SendNotification();
+ application.Render();
+
+ callStack.Enable(false);
+ // Shader not changed
+ DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
END_TEST;
}
{"#define IS_REQUIRED_BLUR", false},
{"#define IS_REQUIRED_BORDERLINE", false},
{"#define IS_REQUIRED_ROUNDED_CORNER", false},
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", false},
},
TEST_LOCATION);
- float targetBlurRadius = 15.0f;
- Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
+ float targetBlurRadius = 15.0f;
+ Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
+ Vector4 targetCornerSquareness = Vector4(0.0f, 0.1f, 0.1f, 0.0f);
Property::Map targetPropertyMap;
- targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
- targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
- targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
+ targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
+ targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
+ targetPropertyMap[DevelVisual::Property::CORNER_SQUARENESS] = targetCornerSquareness;
+ targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
callStack.Reset();
callStack.Enable(true);
DALI_TEST_CHECK(cornerRadiusValue);
DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
- TestShaderCodeContainSubstringsForEachShader(
+ TestShaderCodeContainSubstrings(
dummyControl,
{
- {"#define IS_REQUIRED_BLUR", {true, true}},
- {"#define IS_REQUIRED_BORDERLINE", {false, false}}, // Note : We ignore borderline when blur radius occured
- {"#define IS_REQUIRED_ROUNDED_CORNER", {true, true}},
+ {"#define IS_REQUIRED_BLUR", true},
+ {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
+ {"#define IS_REQUIRED_ROUNDED_CORNER", true},
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", {false, true}},
{"#define SL_VERSION_LOW", {false, true}},
},
TEST_LOCATION);
DALI_TEST_CHECK(cornerRadiusValue);
DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
- TestShaderCodeContainSubstringsForEachShader(
+ TestShaderCodeContainSubstrings(
dummyControl,
{
- {"#define IS_REQUIRED_BLUR", {true, true}}, // Note : mAlwaysUsingBlurRadius is true.
- {"#define IS_REQUIRED_BORDERLINE", {false, false}}, // Note : We ignore borderline when blur radius occured
- {"#define IS_REQUIRED_ROUNDED_CORNER", {true, true}}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_BLUR", true}, // Note : mAlwaysUsingBlurRadius is true.
+ {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
+ {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
+ {"#define IS_REQUIRED_SQUIRCLE_CORNER", {false, true}}, // Note : mAlwaysUsingCornerSquareness is true.
{"#define SL_VERSION_LOW", {false, true}},
},
TEST_LOCATION);
{
propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
+ propertyMap.Insert(DevelVisual::Property::CORNER_SQUARENESS, 0.6f);
}
if(enableBorderline)
{
imageShader5["shaderType"] = "image";
imageShader5["shaderOption"] = Property::Map().Add("ATLAS_CUSTOM", true);
+ Property::Map imageShader6;
+ imageShader6["shaderType"] = "image";
+ imageShader6["shaderOption"] = Property::Map()
+ .Add("SQUIRCLE_CORNER", true)
+ .Add("BORDERLINE", true)
+ .Add("MASKING", true);
+
Property::Map textShader;
textShader["shaderType"] = "text";
textShader["shaderOption"] = Property::Map()
.Add("ROUNDED_CORNER,", true)
.Add("BLUR_EDGE", true);
+ Property::Map colorShader3;
+ colorShader3["shaderType"] = "color";
+ colorShader3["shaderOption"] = Property::Map()
+ .Add("SQUIRCLE_CORNER,", true)
+ .Add("BLUR_EDGE", true);
+
Property::Map npatchShader;
npatchShader["shaderType"] = "npatch";
factory.AddPrecompileShader(imageShader4);
factory.AddPrecompileShader(imageShader4); // use same shader, because check line coverage
factory.AddPrecompileShader(imageShader5);
+ factory.AddPrecompileShader(imageShader6);
factory.AddPrecompileShader(textShader);
factory.AddPrecompileShader(textShader); // use same shader, because check line coverage
factory.AddPrecompileShader(textShader2);
factory.AddPrecompileShader(colorShader);
factory.AddPrecompileShader(colorShader); // use same shader, because check line coverage
factory.AddPrecompileShader(colorShader2);
+ factory.AddPrecompileShader(colorShader3);
factory.AddPrecompileShader(npatchShader);
factory.AddPrecompileShader(npatchShader2);
factory.AddPrecompileShader(customShader);
DALI_PROPERTY_REGISTRATION(Scene3D, SceneView, "BorderlineWidth", FLOAT, BORDERLINE_WIDTH)
DALI_PROPERTY_REGISTRATION(Scene3D, SceneView, "BorderlineColor", VECTOR4, BORDERLINE_COLOR)
DALI_PROPERTY_REGISTRATION(Scene3D, SceneView, "BorderlineOffset", FLOAT, BORDERLINE_OFFSET)
+DALI_PROPERTY_REGISTRATION(Scene3D, SceneView, "CornerSquareness", VECTOR4, CORNER_SQUARENESS)
DALI_TYPE_REGISTRATION_END()
Property::Index RENDERING_BUFFER = Dali::Toolkit::Control::CONTROL_PROPERTY_END_INDEX + 1;
return mCornerRadius;
}
+void SceneView::SetCornerSquareness(Vector4 cornerSquareness)
+{
+ if(mCornerSquareness != cornerSquareness)
+ {
+ mCornerSquareness = cornerSquareness;
+ if(mUseFrameBuffer)
+ {
+ mDecoratedVisualPropertyChanged = true;
+ UpdateRenderTask();
+ }
+ }
+}
+
+Vector4 SceneView::GetCornerSquareness() const
+{
+ return mCornerSquareness;
+}
+
void SceneView::SetCornerRadiusPolicy(int cornerRadiusPolicy)
{
if(mCornerRadiusPolicy != cornerRadiusPolicy)
sceneViewImpl.SetBorderlineOffset(value.Get<float>());
break;
}
+ case Scene3D::SceneView::Property::CORNER_SQUARENESS:
+ {
+ sceneViewImpl.SetCornerSquareness(value.Get<Vector4>());
+ break;
+ }
}
}
}
value = sceneViewImpl.GetBorderlineOffset();
break;
}
+ case Scene3D::SceneView::Property::CORNER_SQUARENESS:
+ {
+ value = sceneViewImpl.GetCornerSquareness();
+ break;
+ }
}
}
return value;
{
imagePropertyMap.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS, mCornerRadius);
imagePropertyMap.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, mCornerRadiusPolicy);
+ if(mCornerSquareness != Vector4::ZERO)
+ {
+ imagePropertyMap.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, mCornerSquareness);
+ }
}
if(!Dali::EqualsZero(mBorderlineWidth))
{
*/
Vector4 GetCornerRadius() const;
+ /**
+ * @brief Sets the squareness value of each corner.
+ * @param[in] cornerSquareness Squareness value of each corner.
+ */
+ void SetCornerSquareness(Vector4 cornerSquareness);
+
+ /**
+ * @brief Retrieves the squareness value of each corner.
+ * @return The squareness value of each corner.
+ */
+ Vector4 GetCornerSquareness() const;
+
/**
* @brief Sets the policy of corner radius value.
* @param[in] cornerRadiusPolicy Policy of corner radius value.
// Corner Radius
Vector4 mCornerRadius{Vector4::ZERO};
+ Vector4 mCornerSquareness{Vector4::ZERO};
int mCornerRadiusPolicy; ///< Should be initialize at .cpp
// Borderline
/**
* @brief The radius for the rounded corners of the scene view.
- * @details Name "cornerRadius", type Prooperty::VECTOR4, The radius for the rounded corners of the scene view.
+ * @details Name "cornerRadius", type Property::VECTOR4.
* @note By default, it is Vector::ZERO.
* @note Corner radius is only available when framebuffer is used.
* @note Each radius will clamp internally to the half of smaller of the SceneView width and height.
* @note This value will clamp internally to [-1.0f to 1.0f].
*/
BORDERLINE_OFFSET,
+
+ /**
+ * @brief The squareness for the rounded corners of the scene view.
+ * @details Name "cornerSquareness", type Property::VECTOR4.
+ * @note By default, it is Vector::ZERO.
+ * @note Corner radius is only available when framebuffer is used.
+ * @note Each squareness will clamp internally as [0.0 1.0].
+ * @note If squareness is not zero, the width of borderline might not equal with it's real value.
+ * @note Squareness value are used in clockwise order from top-left-corner to bottom-left-corner.
+ * When squareness is Vector4(x, y, z, w)
+ * x y
+ * +--+
+ * | |
+ * +--+
+ * w z
+ */
+ CORNER_SQUARENESS,
};
};
// OPTION
const char* TOKEN_OPTION("shaderOption");
const char* TOKEN_OPTION_ROUNDED_CORNER("ROUNDED_CORNER");
+const char* TOKEN_OPTION_SQUIRCLE_CORNER("SQUIRCLE_CORNER");
const char* TOKEN_OPTION_BORDERLINE("BORDERLINE");
const char* TOKEN_OPTION_BLUR_EDGE("BLUR_EDGE");
const char* TOKEN_OPTION_CUTOUT("CUTOUT");
DALI_ENUM_TO_STRING_TABLE_END(SHADER_TYPE);
DALI_ENUM_TO_STRING_TABLE_BEGIN(SHADER_OPTION_FLAG)
- {TOKEN_OPTION_ROUNDED_CORNER, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::ROUNDED_CORNER)},
- {TOKEN_OPTION_BORDERLINE, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::BORDERLINE)},
- {TOKEN_OPTION_BLUR_EDGE, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::BLUR_EDGE)},
- {TOKEN_OPTION_CUTOUT, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::CUTOUT)},
- {TOKEN_OPTION_ATLAS_DEFAULT, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::ATLAS_DEFAULT)},
- {TOKEN_OPTION_ATLAS_CUSTOM, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::ATLAS_CUSTOM)},
- {TOKEN_OPTION_MASKING, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::MASKING)},
- {TOKEN_OPTION_YUV_TO_RGB, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::YUV_TO_RGB)},
- {TOKEN_OPTION_YUV_AND_RGB, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::YUV_AND_RGB)},
- {TOKEN_OPTION_MULTI_COLOR, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::MULTI_COLOR)},
- {TOKEN_OPTION_STYLES, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::STYLES)},
- {TOKEN_OPTION_OVERLAY, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::OVERLAY)},
- {TOKEN_OPTION_EMOJI, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::EMOJI)},
+ {TOKEN_OPTION_ROUNDED_CORNER, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::ROUNDED_CORNER)},
+ {TOKEN_OPTION_SQUIRCLE_CORNER, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::SQUIRCLE_CORNER)},
+ {TOKEN_OPTION_BORDERLINE, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::BORDERLINE)},
+ {TOKEN_OPTION_BLUR_EDGE, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::BLUR_EDGE)},
+ {TOKEN_OPTION_CUTOUT, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::CUTOUT)},
+ {TOKEN_OPTION_ATLAS_DEFAULT, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::ATLAS_DEFAULT)},
+ {TOKEN_OPTION_ATLAS_CUSTOM, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::ATLAS_CUSTOM)},
+ {TOKEN_OPTION_MASKING, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::MASKING)},
+ {TOKEN_OPTION_YUV_TO_RGB, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::YUV_TO_RGB)},
+ {TOKEN_OPTION_YUV_AND_RGB, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::YUV_AND_RGB)},
+ {TOKEN_OPTION_MULTI_COLOR, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::MULTI_COLOR)},
+ {TOKEN_OPTION_STYLES, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::STYLES)},
+ {TOKEN_OPTION_OVERLAY, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::OVERLAY)},
+ {TOKEN_OPTION_EMOJI, static_cast<int32_t>(Dali::Toolkit::PrecompileShaderOption::Flag::EMOJI)},
DALI_ENUM_TO_STRING_TABLE_END(SHADER_OPTION_FLAG);
// clang-format on
} // namespace
{
UNKNOWN = 0,
ROUNDED_CORNER,
+ SQUIRCLE_CORNER,
BORDERLINE,
BLUR_EDGE,
CUTOUT,
* @note Optional.
* @note The default is 0.
* @note The visual size increases by the blur radius.
+ * @note If squareness is not zero, the width of borderline might not equal with it's real value.
* @note We cannot use blur radius and borderline properties at the same time.
*/
BLUR_RADIUS = MIX_COLOR + 2,
#define DALI_TOOLKIT_DEVEL_API_VISUALS_VISUAL_PROPERTIES_DEVEL_H
/*
- * Copyright (c) 2021 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.
/**
* @brief The radius for the rounded corners of the visual.
- * @details Name "cornerRadius", type Property::FLOAT or Prooperty::VECTOR4, animatable
+ * @details Name "cornerRadius", type Property::FLOAT or Property::VECTOR4, animatable
* @note By default, it is Vector::ZERO.
* @note Only Property::Vector4 can be animated.
* @note Each radius will clamp internally to the half of smaller of the visual width and visual height.
* @note This value will clamp internally to [-1.0f to 1.0f].
*/
BORDERLINE_OFFSET = OPACITY + 6,
+
+ /**
+ * @brief The squareness for the rounded corners of the visual.
+ * @details Name "cornerSquareness", type Property::FLOAT or Property::VECTOR4, animatable
+ * @note By default, it is Vector::ZERO.
+ * @note Each squareness will clamp internally as [0.0 1.0].
+ * @note If squareness is not zero, the width of borderline might not equal with it's real value.
+ * @note Squareness value are used in clockwise order from top-left-corner to bottom-left-corner.
+ * When squareness is Vector4(x, y, z, w)
+ * x y
+ * +--+
+ * | |
+ * +--+
+ * w z
+ */
+ CORNER_SQUARENESS = OPACITY + 7,
};
} // namespace Property
DALI_ASSERT_ALWAYS(GetOwnerControl() && "You should first SetRenderEffect(), then set its background property map");
- Property::Map map = GetOwnerControl().GetProperty<Property::Map>(Toolkit::Control::Property::BACKGROUND);
- Vector4 radius = Vector4::ZERO;
+ Property::Map map = GetOwnerControl().GetProperty<Property::Map>(Toolkit::Control::Property::BACKGROUND);
+
+ Vector4 radius = Vector4::ZERO;
map[Toolkit::DevelVisual::Property::CORNER_RADIUS].Get(radius);
+ Vector4 squareness = Vector4::ZERO;
+ map[Toolkit::DevelVisual::Property::CORNER_SQUARENESS].Get(squareness);
+
Visual::Transform::Policy::Type policy{Visual::Transform::Policy::ABSOLUTE};
map[Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY].Get(policy);
Renderer renderer = GetTargetRenderer();
renderer.RegisterProperty("uCornerRadius", radius);
+ renderer.RegisterProperty("uCornerSquareness", squareness);
renderer.RegisterProperty("uCornerRadiusPolicy", static_cast<float>(policy));
}
#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list.h>
#include <dali-toolkit/devel-api/controls/web-view/web-settings.h>
+#include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
#include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
+#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
#include <dali-toolkit/internal/visuals/visual-base-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/public-api/image-loader/image-url.h>
constexpr Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
+const Property::Map EMPTY_VISUAL_PROPERTIES{
+ {Dali::Toolkit::Visual::Property::TYPE, Dali::Toolkit::Visual::COLOR},
+ {Dali::Toolkit::Visual::Property::MIX_COLOR, Color::TRANSPARENT},
+};
+
+const Property::Map DEFAULT_WEB_IMAGE_VISUAL_PROPERTIES{
+ {Dali::Toolkit::Visual::Property::TYPE, Dali::Toolkit::Visual::IMAGE},
+ {Dali::Toolkit::ImageVisual::Property::URL, ""},
+ {Dali::Toolkit::ImageVisual::Property::PIXEL_AREA, FULL_TEXTURE_RECT},
+ {Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U, Dali::WrapMode::CLAMP_TO_EDGE},
+ {Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V, Dali::WrapMode::CLAMP_TO_EDGE},
+ {Dali::Toolkit::DevelVisual::Property::CORNER_RADIUS, Vector4::ZERO},
+ {Dali::Toolkit::DevelVisual::Property::CORNER_SQUARENESS, Vector4::ZERO},
+ {Dali::Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, Dali::Toolkit::Visual::Transform::Policy::ABSOLUTE},
+};
+
/**
* @brief Helper function to calculate exact pixel area value by view and texture size.
* It will be useful when view size is not integer value, or view size is not matched with texture size.
mVisualChangeRequired(false),
mScreenshotCapturedCallback{nullptr},
mFrameRenderedCallback{nullptr},
- mCornerRadius(Vector4::ZERO),
- mCornerRadiusPolicy(1.0f)
+ mVisualPropertyMap{EMPTY_VISUAL_PROPERTIES}
{
mWebEngine = Dali::WebEngine::New();
mVisualChangeRequired(false),
mScreenshotCapturedCallback{nullptr},
mFrameRenderedCallback{nullptr},
- mCornerRadius(Vector4::ZERO),
- mCornerRadiusPolicy(1.0f)
+ mVisualPropertyMap{EMPTY_VISUAL_PROPERTIES}
{
mWebEngine = Dali::WebEngine::New(type);
mScaleUpdateNotification.NotifySignal().Connect(this, &WebView::OnDisplayAreaUpdated);
// Create WebVisual for WebView
- Property::Map propertyMap;
- propertyMap.Insert(Dali::Toolkit::Visual::Property::TYPE, Dali::Toolkit::Visual::COLOR);
- propertyMap.Insert(Dali::Toolkit::Visual::Property::MIX_COLOR, Color::TRANSPARENT);
- Toolkit::Visual::Base webVisual = Toolkit::VisualFactory::Get().CreateVisual(propertyMap);
+ Toolkit::Visual::Base webVisual = Toolkit::VisualFactory::Get().CreateVisual(mVisualPropertyMap);
if(webVisual)
{
Dali::Toolkit::DevelControl::RegisterVisual(*this, Toolkit::WebView::Property::URL, webVisual);
Toolkit::Visual::Base webVisual = Dali::Toolkit::DevelControl::GetVisual(*this, Toolkit::WebView::Property::URL);
Property::Map webMap;
webVisual.CreatePropertyMap(webMap);
+
+ Property::Map newWebMap = DEFAULT_WEB_IMAGE_VISUAL_PROPERTIES;
+
Property::Value* cornerRadiusValue = webMap.Find(Dali::Toolkit::DevelVisual::Property::CORNER_RADIUS);
if(cornerRadiusValue)
{
- mCornerRadius = cornerRadiusValue->Get<Vector4>();
+ newWebMap[Dali::Toolkit::DevelVisual::Property::CORNER_RADIUS] = cornerRadiusValue->Get<Vector4>();
+ }
+ Property::Value* cornerSquarenessValue = webMap.Find(Dali::Toolkit::DevelVisual::Property::CORNER_SQUARENESS);
+ if(cornerSquarenessValue)
+ {
+ newWebMap[Dali::Toolkit::DevelVisual::Property::CORNER_SQUARENESS] = cornerSquarenessValue->Get<Vector4>();
}
Property::Value* cornerRadiusValuePolicy = webMap.Find(Dali::Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY);
if(cornerRadiusValuePolicy)
{
- mCornerRadiusPolicy = cornerRadiusValuePolicy->Get<int>();
+ newWebMap[Dali::Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY] = cornerRadiusValuePolicy->Get<int>();
}
// Reset flag
Dali::Toolkit::ImageUrl nativeImageUrl = Dali::Toolkit::Image::GenerateUrl(nativeImageSourcePtr);
- mVisual = Toolkit::VisualFactory::Get().CreateVisual(
- {{Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE},
- {Toolkit::ImageVisual::Property::URL, nativeImageUrl.GetUrl()},
- {Toolkit::ImageVisual::Property::PIXEL_AREA, FULL_TEXTURE_RECT},
- {Toolkit::ImageVisual::Property::WRAP_MODE_U, Dali::WrapMode::CLAMP_TO_EDGE},
- {Toolkit::ImageVisual::Property::WRAP_MODE_V, Dali::WrapMode::CLAMP_TO_EDGE},
- {Toolkit::DevelVisual::Property::CORNER_RADIUS, mCornerRadius},
- {Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, mCornerRadiusPolicy}});
+ newWebMap[Toolkit::ImageVisual::Property::URL] = nativeImageUrl.GetUrl();
+
+ // Store new visual property map now.
+ mVisualPropertyMap = std::move(newWebMap);
+
+ mVisual = Toolkit::VisualFactory::Get().CreateVisual(mVisualPropertyMap);
if(mVisual)
{
if(mVisual)
{
auto pixelArea = CalculatePixelArea(mWebViewSize, mLastRenderedNativeImageWidth, mLastRenderedNativeImageHeight);
+
+ mVisualPropertyMap[Toolkit::ImageVisual::Property::PIXEL_AREA] = pixelArea;
Toolkit::GetImplementation(mVisual).DoAction(Toolkit::DevelVisual::Action::UPDATE_PROPERTY, {{Toolkit::ImageVisual::Property::PIXEL_AREA, pixelArea}});
}
Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback mScreenshotCapturedCallback;
Dali::WebEnginePlugin::WebEngineFrameRenderedCallback mFrameRenderedCallback;
- Vector4 mCornerRadius; /// < Corner radius
- float mCornerRadiusPolicy; /// < Corner radius policy
+ Dali::Property::Map mVisualPropertyMap; ///< ImageVisual property map
+
static std::unordered_map<Dali::WebEnginePlugin*, Dali::WeakHandle<Toolkit::WebView>> mPluginWebViewMap;
};
uniform lowp vec4 uActorColor;
#endif
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+uniform highp vec4 cornerSquareness;
+#endif
+
#if defined(IS_REQUIRED_CUTOUT)
uniform highp vec3 uSize;
uniform lowp int uCutoutWithCornerRadius;
// radius of rounded corner on this quadrant
highp float gRadius = 0.0;
+highp float gSquareness = 0.0;
// fragment coordinate. NOTE : vec2(0.0, 0.0) is vRectSize, the corner of visual
highp vec2 gFragmentPosition = vec2(0.0, 0.0);
mix(cornerRadius.w, cornerRadius.z, sign(position.x) * 0.5 + 0.5),
sign(position.y) * 0.5 + 0.5
);
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+ gSquareness = clamp(
+ mix(
+ mix(cornerSquareness.x, cornerSquareness.y, sign(vPosition.x) * 0.5 + 0.5),
+ mix(cornerSquareness.w, cornerSquareness.z, sign(vPosition.x) * 0.5 + 0.5),
+ sign(vPosition.y) * 0.5 + 0.5
+ ), 0.0, 1.0);
+#endif
#endif
}
void calculateFragmentPosition(highp vec2 position, highp vec2 halfSizeOfRect)
void calculatePotential()
{
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+ // We need to found the r value s.t. x^2 + y^2 - s/r/r x^2y^2 = r^2
+ // and check this r is inside [gRadius - vAliasMargin, gRadius + vAliasMargin]
+
+ // If we make as A = x^2 + y^2, B = sx^2y^2
+ // r^2 = (A + sqrt(A^2 - 4B)) / 2
+ // = ((x^2 + y^2) + sqrt(x^4 + (2 - 4s)x^2y^2 + y^4)) / 2
+
+ highp vec2 positiveDiff = max(gDiff, 0.0);
+
+ // If gSquareness is near 1.0, it make some numeric error. Let we avoid this situation by heuristic value.
+ if(gSquareness > 0.99)
+ {
+ gPotential = max(gDiff.x, gDiff.y);
+ return;
+ }
+
+ // make sqr to avoid duplicate codes.
+ positiveDiff *= positiveDiff;
+
+ // TODO : Could we remove this double-sqrt code?
+ gPotential = sqrt(((positiveDiff.x + positiveDiff.y)
+ + sqrt(positiveDiff.x * positiveDiff.x
+ + positiveDiff.y * positiveDiff.y
+ + (2.0 - 4.0 * gSquareness) * positiveDiff.x * positiveDiff.y))
+ * 0.5)
+ + min(0.0, max(gDiff.x, gDiff.y)); ///< Consider negative potential, to support borderline
+#else
gPotential = length(max(gDiff, 0.0)) + min(0.0, max(gDiff.x, gDiff.y));
+#endif
}
void setupMinMaxPotential(highp float currentBorderlineWidth)
#elif defined(IS_REQUIRED_BORDERLINE)
lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
{
+ // TODO : Need to consider squareness
+
highp float potential = gPotential;
// default opacity of borderline is 0.0
#endif
#ifdef IS_REQUIRED_BLUR
-#ifdef SL_VERSION_LOW
+#if defined(SL_VERSION_LOW) || defined(IS_REQUIRED_SQUIRCLE_CORNER)
// Legacy code for low version glsl
mediump float calculateBlurOpacity()
{
#else
mediump float calculateBlurOpacity()
{
-// Don't use borderline!
+ // TODO : Need to consider squareness.
+
+ // Don't use borderline!
highp vec2 v = gDiff;
highp float cy = gRadius + blurRadius;
highp float cr = gRadius + blurRadius;
uniform lowp vec4 uActorColor;
#endif
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+uniform highp vec4 cornerSquareness;
+#endif
+
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
// Global values both rounded corner and borderline use
// radius of rounded corner on this quadrant
highp float gRadius = 0.0;
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+highp float gSquareness = 0.0;
+#endif
// fragment coordinate. NOTE : vec2(0.0, 0.0) is vRectSize, the corner of visual
highp vec2 gFragmentPosition = vec2(0.0, 0.0);
mix(vCornerRadius.w, vCornerRadius.z, sign(vPosition.x) * 0.5 + 0.5),
sign(vPosition.y) * 0.5 + 0.5
);
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+ gSquareness = clamp(
+ mix(
+ mix(cornerSquareness.x, cornerSquareness.y, sign(vPosition.x) * 0.5 + 0.5),
+ mix(cornerSquareness.w, cornerSquareness.z, sign(vPosition.x) * 0.5 + 0.5),
+ sign(vPosition.y) * 0.5 + 0.5
+ ), 0.0, 1.0);
+#endif
#endif
}
void calculatePotential()
{
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+ // We need to found the r value s.t. x^2 + y^2 - s/r/r x^2y^2 = r^2
+ // and check this r is inside [gRadius - vAliasMargin, gRadius + vAliasMargin]
+
+ // If we make as A = x^2 + y^2, B = sx^2y^2
+ // r^2 = (A + sqrt(A^2 - 4B)) / 2
+ // = ((x^2 + y^2) + sqrt(x^4 + (2 - 4s)x^2y^2 + y^4)) / 2
+
+ highp vec2 positiveDiff = max(gDiff, 0.0);
+
+ // If gSquareness is near 1.0, it make some numeric error. Let we avoid this situation by heuristic value.
+ if(gSquareness > 0.99)
+ {
+ gPotential = max(gDiff.x, gDiff.y);
+ return;
+ }
+
+ // make sqr to avoid duplicate codes.
+ positiveDiff *= positiveDiff;
+
+ // TODO : Could we remove this double-sqrt code?
+ gPotential = sqrt(((positiveDiff.x + positiveDiff.y)
+ + sqrt(positiveDiff.x * positiveDiff.x
+ + positiveDiff.y * positiveDiff.y
+ + (2.0 - 4.0 * gSquareness) * positiveDiff.x * positiveDiff.y))
+ * 0.5)
+ + min(0.0, max(gDiff.x, gDiff.y)); ///< Consider negative potential, to support borderline
+#else
gPotential = length(max(gDiff, 0.0)) + min(0.0, max(gDiff.x, gDiff.y));
+#endif
}
void setupMinMaxPotential()
#ifdef IS_REQUIRED_BORDERLINE
lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
{
+ // TODO : Need to consider squareness
+
highp float potential = gPotential;
// default opacity of borderline is 0.0
uniform lowp vec4 uActorColor;
#endif
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+uniform highp vec4 cornerSquareness;
+#endif
+
#ifdef ATLAS_CUSTOM_WARP
mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )
{
// radius of rounded corner on this quadrant
highp float gRadius = 0.0;
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+highp float gSquareness = 0.0;
+#endif
// fragment coordinate. NOTE : vec2(0.0, 0.0) is vRectSize, the corner of visual
highp vec2 gFragmentPosition = vec2(0.0, 0.0);
mix(vCornerRadius.w, vCornerRadius.z, sign(vPosition.x) * 0.5 + 0.5),
sign(vPosition.y) * 0.5 + 0.5
);
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+ gSquareness = clamp(
+ mix(
+ mix(cornerSquareness.x, cornerSquareness.y, sign(vPosition.x) * 0.5 + 0.5),
+ mix(cornerSquareness.w, cornerSquareness.z, sign(vPosition.x) * 0.5 + 0.5),
+ sign(vPosition.y) * 0.5 + 0.5
+ ), 0.0, 1.0);
+#endif
#endif
}
void calculatePotential()
{
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+ // We need to found the r value s.t. x^2 + y^2 - s/r/r x^2y^2 = r^2
+ // and check this r is inside [gRadius - vAliasMargin, gRadius + vAliasMargin]
+
+ // If we make as A = x^2 + y^2, B = sx^2y^2
+ // r^2 = (A + sqrt(A^2 - 4B)) / 2
+ // = ((x^2 + y^2) + sqrt(x^4 + (2 - 4s)x^2y^2 + y^4)) / 2
+
+ highp vec2 positiveDiff = max(gDiff, 0.0);
+
+ // If gSquareness is near 1.0, it make some numeric error. Let we avoid this situation by heuristic value.
+ if(gSquareness > 0.99)
+ {
+ gPotential = max(gDiff.x, gDiff.y);
+ return;
+ }
+
+ // make sqr to avoid duplicate codes.
+ positiveDiff *= positiveDiff;
+
+ // TODO : Could we remove this double-sqrt code?
+ gPotential = sqrt(((positiveDiff.x + positiveDiff.y)
+ + sqrt(positiveDiff.x * positiveDiff.x
+ + positiveDiff.y * positiveDiff.y
+ + (2.0 - 4.0 * gSquareness) * positiveDiff.x * positiveDiff.y))
+ * 0.5)
+ + min(0.0, max(gDiff.x, gDiff.y)); ///< Consider negative potential, to support borderline
+#else
gPotential = length(max(gDiff, 0.0)) + min(0.0, max(gDiff.x, gDiff.y));
+#endif
}
void setupMinMaxPotential()
#ifdef IS_REQUIRED_BORDERLINE
lowp vec4 convertBorderlineColor(lowp vec4 textureColor)
{
+ // TODO : Need to consider squareness
+
highp float potential = gPotential;
// default opacity of borderline is 0.0
#else
const bool IS_REQUIRED_ROUNDED_CORNER_BOOL = false;
#endif
+#ifdef IS_REQUIRED_SQUIRCLE_CORNER
+const bool IS_REQUIRED_SQUIRCLE_CORNER_BOOL = true;
+#else
+const bool IS_REQUIRED_SQUIRCLE_CORNER_BOOL = false;
+#endif
#ifdef IS_REQUIRED_BORDERLINE
const bool IS_REQUIRED_BORDERLINE_BOOL = true;
#else
uniform lowp vec4 uColor;
uniform highp vec3 uSize;
+uniform highp vec4 uCornerSquareness;
uniform sampler2D sTexture;
highp float nrand(const in vec2 uv)
}
// from https://iquilezles.org/articles/distfunctions
-float roundedBoxSDF(vec2 PixelPositionFromCenter, vec2 RectangleEdgePositionFromCenter, float Radius) {
- return length(max(PixelPositionFromCenter
- - RectangleEdgePositionFromCenter
- + Radius
- , 0.0))
- - Radius;
+float roundedBoxSDF(vec2 PixelPositionFromCenter, vec2 RectangleEdgePositionFromCenter, float Radius, float Squareness) {
+ highp vec2 positiveDiff = max(PixelPositionFromCenter
+ - RectangleEdgePositionFromCenter
+ + Radius
+ , 0.0);
+
+ highp float squrenessFactor = Squareness / max(1.0, Radius * Radius);
+
+ // make sqr to avoid duplicate codes.
+ positiveDiff *= positiveDiff;
+
+ return sqrt(positiveDiff.x + positiveDiff.y - squrenessFactor * positiveDiff.x * positiveDiff.y)
+ - Radius;
}
void main()
mix(vCornerRadius.w, vCornerRadius.z, sign(location.x) * 0.5 + 0.5),
sign(location.y) * 0.5 + 0.5
);
+ float squareness =
+ mix(
+ mix(uCornerSquareness.x, uCornerSquareness.y, sign(location.x) * 0.5 + 0.5),
+ mix(uCornerSquareness.w, uCornerSquareness.z, sign(location.x) * 0.5 + 0.5),
+ sign(location.y) * 0.5 + 0.5
+ );
float edgeSoftness = min(1.0, radius);
}
else
{
- float distance = roundedBoxSDF(location, halfSize, radius);
+ float distance = roundedBoxSDF(location, halfSize, radius, squareness);
float smoothedAlpha = 1.0 - smoothstep(-edgeSoftness, edgeSoftness, distance);
constexpr VisualFactoryCache::ShaderType SHADER_TYPE_TABLE[] = {
VisualFactoryCache::COLOR_SHADER,
VisualFactoryCache::COLOR_SHADER_ROUNDED_CORNER,
+ VisualFactoryCache::COLOR_SHADER_SQUIRCLE_CORNER,
VisualFactoryCache::COLOR_SHADER_BORDERLINE,
VisualFactoryCache::COLOR_SHADER_ROUNDED_BORDERLINE,
+ VisualFactoryCache::COLOR_SHADER_SQUIRCLE_BORDERLINE,
VisualFactoryCache::COLOR_SHADER_BLUR_EDGE,
VisualFactoryCache::COLOR_SHADER_ROUNDED_CORNER_BLUR_EDGE,
-};
-
-constexpr VisualFactoryCache::ShaderType SHADER_TYPE_WITH_CUTOUT_TABLE[] = {
+ VisualFactoryCache::COLOR_SHADER_SQUIRCLE_CORNER_BLUR_EDGE,
VisualFactoryCache::COLOR_SHADER_CUTOUT,
VisualFactoryCache::COLOR_SHADER_CUTOUT_ROUNDED_CORNER,
+ VisualFactoryCache::COLOR_SHADER_CUTOUT_SQUIRCLE_CORNER,
VisualFactoryCache::COLOR_SHADER_CUTOUT_BORDERLINE,
VisualFactoryCache::COLOR_SHADER_CUTOUT_ROUNDED_BORDERLINE,
+ VisualFactoryCache::COLOR_SHADER_CUTOUT_SQUIRCLE_BORDERLINE,
VisualFactoryCache::COLOR_SHADER_CUTOUT_BLUR_EDGE,
VisualFactoryCache::COLOR_SHADER_CUTOUT_ROUNDED_CORNER_BLUR_EDGE,
+ VisualFactoryCache::COLOR_SHADER_CUTOUT_SQUIRCLE_CORNER_BLUR_EDGE,
};
+constexpr uint32_t SHADER_TYPE_TABLE_COUNT = sizeof(SHADER_TYPE_TABLE) / sizeof(SHADER_TYPE_TABLE[0]);
// enum of required list when we select shader
enum ColorVisualRequireFlag
{
- DEFAULT = 0,
- ROUNDED_CORNER = 1 << 0,
- BORDERLINE = 1 << 1,
- BLUR = 1 << 2,
+ DEFAULT = 0,
+ ROUNDED_CORNER = 1,
+ SQUIRCLE_CORNER = 2,
+
+ BORDERLINE = (1) * 3,
+ BLUR = (2) * 3,
+
+ CUTOUT = (1) * 3 * 3,
};
constexpr uint32_t MINIMUM_SHADER_VERSION_SUPPORT_ROUNDED_BLUR = 300;
{
}
-FeatureBuilder& FeatureBuilder::EnableRoundCorner(bool enableRoundedCorner)
+FeatureBuilder& FeatureBuilder::EnableRoundCorner(bool enableRoundedCorner, bool enableSquircleCorner)
{
- mColorRoundCorner = (enableRoundedCorner ? RoundedCorner::ENABLED : RoundedCorner::DISABLED);
+ mColorRoundCorner = (enableRoundedCorner ? (enableSquircleCorner ? RoundedCorner::SQUIRCLE_CORNER : RoundedCorner::ROUNDED_CORNER) : RoundedCorner::DISABLED);
return *this;
}
{
VisualFactoryCache::ShaderType shaderType = VisualFactoryCache::COLOR_SHADER;
uint32_t shaderTypeFlag = ColorVisualRequireFlag::DEFAULT;
- if(mColorBlur)
+
+ if(mColorRoundCorner == RoundedCorner::SQUIRCLE_CORNER)
{
- shaderTypeFlag |= ColorVisualRequireFlag::BLUR;
+ shaderTypeFlag += ColorVisualRequireFlag::SQUIRCLE_CORNER;
}
- if(mColorRoundCorner)
+ else if(mColorRoundCorner == RoundedCorner::ROUNDED_CORNER)
{
- shaderTypeFlag |= ColorVisualRequireFlag::ROUNDED_CORNER;
+ shaderTypeFlag += ColorVisualRequireFlag::ROUNDED_CORNER;
}
+
if(mColorBorderline && !mColorBlur)
{
- shaderTypeFlag |= ColorVisualRequireFlag::BORDERLINE;
+ shaderTypeFlag += ColorVisualRequireFlag::BORDERLINE;
+ }
+
+ if(mColorBlur)
+ {
+ shaderTypeFlag += ColorVisualRequireFlag::BLUR;
}
- shaderType = mColorCutout ? SHADER_TYPE_WITH_CUTOUT_TABLE[shaderTypeFlag] : SHADER_TYPE_TABLE[shaderTypeFlag];
+ if(mColorCutout)
+ {
+ shaderTypeFlag += ColorVisualRequireFlag::CUTOUT;
+ }
+
+ DALI_ASSERT_DEBUG(shaderTypeFlag < SHADER_TYPE_TABLE_COUNT && "Invalid color shader type generated!");
+
+ shaderType = SHADER_TYPE_TABLE[shaderTypeFlag];
return shaderType;
}
void FeatureBuilder::GetVertexShaderPrefixList(std::string& vertexShaderPrefixList) const
{
- if(mColorRoundCorner == RoundedCorner::ENABLED)
+ if(mColorRoundCorner != RoundedCorner::DISABLED)
{
vertexShaderPrefixList += "#define IS_REQUIRED_ROUNDED_CORNER\n";
}
void FeatureBuilder::GetFragmentShaderPrefixList(std::string& fragmentShaderPrefixList) const
{
- if(mColorRoundCorner == RoundedCorner::ENABLED)
+ if(mColorRoundCorner != RoundedCorner::DISABLED)
{
fragmentShaderPrefixList += "#define IS_REQUIRED_ROUNDED_CORNER\n";
+ if(mColorRoundCorner == RoundedCorner::SQUIRCLE_CORNER)
+ {
+ fragmentShaderPrefixList += "#define IS_REQUIRED_SQUIRCLE_CORNER\n";
+ }
}
if(mColorBlur == Blur::ENABLED)
{
{
case PrecompileShaderOption::Flag::ROUNDED_CORNER:
{
- builder.EnableRoundCorner(true);
+ builder.EnableRoundCorner(true, false);
+ break;
+ }
+ case PrecompileShaderOption::Flag::SQUIRCLE_CORNER:
+ {
+ builder.EnableRoundCorner(true, true);
break;
}
case PrecompileShaderOption::Flag::BORDERLINE:
namespace RoundedCorner
{
/**
- * @brief Whether use RoundedCorner, or not
+ * @brief Whether use rounded corner, or squircle corner, or not
*/
enum Type
{
- DISABLED = 0, ///< Color visual doesn't use rounded corner
- ENABLED ///< Color visual uses rounded corner
+ DISABLED = 0, ///< Color visual doesn't use rounded corner
+ ROUNDED_CORNER, ///< Color visual uses rounded corner
+ SQUIRCLE_CORNER ///< Color visual use squircle corner
};
} // namespace RoundedCorner
{
public:
FeatureBuilder();
- FeatureBuilder& EnableRoundCorner(bool enableRoundCorner);
+ FeatureBuilder& EnableRoundCorner(bool enableRoundCorner, bool enableSquircleCorner = false);
FeatureBuilder& EnableBorderLine(bool enableBorderLine);
FeatureBuilder& EnableBlur(bool enableBlur);
FeatureBuilder& EnableCutout(bool enableCutout);
void GetVertexShaderPrefixList(std::string& vertexShaderPrefixList) const;
void GetFragmentShaderPrefixList(std::string& fragmentShaderPrefixList) const;
- bool IsEnabledRoundCorner() const
- {
- return mColorRoundCorner == ColorVisualShaderFeature::RoundedCorner::ENABLED;
- }
- bool IsEnabledBorderLine() const
- {
- return mColorBorderline == ColorVisualShaderFeature::Borderline::ENABLED;
- }
- bool IsEnabledBlur() const
- {
- return mColorBlur == ColorVisualShaderFeature::Blur::ENABLED;
- }
- bool IsEnabledCutout() const
- {
- return mColorCutout == ColorVisualShaderFeature::Cutout::ENABLED;
- }
-
private:
RoundedCorner::Type mColorRoundCorner : 2; ///< Whether use rounded corner, or not. default as RoundedCorner::DISABLED
Borderline::Type mColorBorderline : 2; ///< Whether use border line, or not. default as Borderline::DISABLED
Shader shader = mColorVisualShaderFactory.GetShader(
mFactoryCache,
ColorVisualShaderFeature::FeatureBuilder()
- .EnableBlur(IsBlurRequired())
- .EnableBorderLine(IsBorderlineRequired())
- .EnableRoundCorner(IsRoundedCornerRequired())
- .EnableCutout(IsCutoutRequired()));
+ .EnableBlur(IsBlurRequired())
+ .EnableBorderLine(IsBorderlineRequired())
+ .EnableRoundCorner(IsRoundedCornerRequired(), IsSquircleCornerRequired())
+ .EnableCutout(IsCutoutRequired()));
return shader;
}
static constexpr float DEFAULT_OFFSET_MINIMUM = 0.0f;
static constexpr float DEFAULT_OFFSET_MAXIMUM = 1.0f;
-VisualFactoryCache::ShaderType SHADER_TYPE_TABLE[16] =
- {
- VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX,
- VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_CORNER,
- VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX_BORDERLINE,
- VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_BORDERLINE,
- VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE,
- VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_CORNER,
- VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE_BORDERLINE,
- VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_BORDERLINE,
- VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX,
- VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_CORNER,
- VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX_BORDERLINE,
- VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_BORDERLINE,
- VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE,
- VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_CORNER,
- VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE_BORDERLINE,
- VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_BORDERLINE,
+VisualFactoryCache::ShaderType SHADER_TYPE_TABLE[] = {
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_CORNER,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX_SQUIRCLE_CORNER,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_BOUNDING_BOX_SQUIRCLE_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_CORNER,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE_SQUIRCLE_CORNER,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_LINEAR_USER_SPACE_SQUIRCLE_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_CORNER,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX_SQUIRCLE_CORNER,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_BOUNDING_BOX_SQUIRCLE_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_CORNER,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE_SQUIRCLE_CORNER,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_BORDERLINE,
+ VisualFactoryCache::GRADIENT_SHADER_RADIAL_USER_SPACE_SQUIRCLE_BORDERLINE,
};
+constexpr uint32_t SHADER_TYPE_TABLE_COUNT = sizeof(SHADER_TYPE_TABLE) / sizeof(SHADER_TYPE_TABLE[0]);
// enum of required list when we select shader
enum GradientVisualRequireFlag
{
- DEFAULT = 0,
- ROUNDED_CORNER = 1 << 0,
- BORDERLINE = 1 << 1,
- USER_SPACE = 1 << 2,
- RADIAL = 1 << 3,
+ DEFAULT = 0,
+ ROUNDED_CORNER = 1,
+ SQUIRCLE_CORNER = 2,
+
+ BORDERLINE = (1 << 0) * 3,
+ USER_SPACE = (1 << 1) * 3,
+ RADIAL = (1 << 2) * 3,
};
Dali::WrapMode::Type GetWrapMode(Toolkit::GradientVisual::SpreadMethod::Type spread)
{
bool userspaceUnit = (mGradient->GetGradientUnits() == Toolkit::GradientVisual::Units::USER_SPACE);
bool roundedCorner = IsRoundedCornerRequired();
+ bool squircleCorner = IsSquircleCornerRequired();
bool borderline = IsBorderlineRequired();
bool radialGradient = (mGradientType == Type::RADIAL);
- int shaderTypeFlag = GradientVisualRequireFlag::DEFAULT;
- if(roundedCorner)
+ uint32_t shaderTypeFlag = GradientVisualRequireFlag::DEFAULT;
+ if(squircleCorner)
+ {
+ shaderTypeFlag += GradientVisualRequireFlag::SQUIRCLE_CORNER;
+ }
+ else if(roundedCorner)
{
- shaderTypeFlag |= GradientVisualRequireFlag::ROUNDED_CORNER;
+ shaderTypeFlag += GradientVisualRequireFlag::ROUNDED_CORNER;
}
+
if(borderline)
{
- shaderTypeFlag |= GradientVisualRequireFlag::BORDERLINE;
+ shaderTypeFlag += GradientVisualRequireFlag::BORDERLINE;
}
if(userspaceUnit)
{
- shaderTypeFlag |= GradientVisualRequireFlag::USER_SPACE;
+ shaderTypeFlag += GradientVisualRequireFlag::USER_SPACE;
}
if(radialGradient)
{
- shaderTypeFlag |= GradientVisualRequireFlag::RADIAL;
+ shaderTypeFlag += GradientVisualRequireFlag::RADIAL;
}
+ DALI_ASSERT_DEBUG(shaderTypeFlag < SHADER_TYPE_TABLE_COUNT && "Invalid gradient shader type generated!");
+
VisualFactoryCache::ShaderType shaderType = SHADER_TYPE_TABLE[shaderTypeFlag];
Shader shader = mFactoryCache.GetShader(shaderType);
if(!shader)
{
vertexShaderPrefixList += "#define IS_REQUIRED_ROUNDED_CORNER\n";
fragmentShaderPrefixList += "#define IS_REQUIRED_ROUNDED_CORNER\n";
+ if(squircleCorner)
+ {
+ fragmentShaderPrefixList += "#define IS_REQUIRED_SQUIRCLE_CORNER\n";
+ }
}
if(borderline)
{
shader = factoryCache.GenerateAndSaveShader(shaderType, vertexShader, fragmentShader);
shader.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT +
- (featureBuilder.IsEnabledAlphaMaskingOnRendering() ? 1 : 0));
+ ((featureBuilder.IsEnabledAlphaMaskingOnRendering() ? 1 : 0)));
shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
}
case PrecompileShaderOption::Flag::ROUNDED_CORNER:
{
- builder.EnableRoundedCorner(true);
+ builder.EnableRoundedCorner(true, false);
+ break;
+ }
+ case PrecompileShaderOption::Flag::SQUIRCLE_CORNER:
+ {
+ builder.EnableRoundedCorner(true, true);
break;
}
case PrecompileShaderOption::Flag::BORDERLINE:
// enum of required list when we select shader
enum class ImageVisualRequireFlag : uint32_t
{
- DEFAULT = 0,
- ROUNDED_CORNER = 1 << 0,
- BORDERLINE = 1 << 1,
- ALPHA_MASKING = 1 << 2,
- COLOR_CONVERSION = 1 << 3,
+ DEFAULT = 0,
+ ROUNDED_CORNER = 1,
+ SQUIRCLE_CORNER = 2,
- UNIFIED_YUV_AND_RGB = 1 << 2, // Special enum to trick unified YUV and RGB.
+ BORDERLINE = (1 << 0) * 3,
+ ALPHA_MASKING = (1 << 1) * 3,
+ COLOR_CONVERSION = (1 << 2) * 3,
+
+ UNIFIED_YUV_AND_RGB = (1 << 1) * 3, // Special enum to trick unified YUV and RGB.
};
-static constexpr auto SHADER_TYPE_COUNT = 16u;
-VisualFactoryCache::ShaderType SHADER_TYPE_TABLE[SHADER_TYPE_COUNT] =
- {
- VisualFactoryCache::IMAGE_SHADER,
- VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER,
- VisualFactoryCache::IMAGE_SHADER_BORDERLINE,
- VisualFactoryCache::IMAGE_SHADER_ROUNDED_BORDERLINE,
- VisualFactoryCache::IMAGE_SHADER_MASKING,
- VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER_MASKING,
- VisualFactoryCache::IMAGE_SHADER_BORDERLINE_MASKING,
- VisualFactoryCache::IMAGE_SHADER_ROUNDED_BORDERLINE_MASKING,
- VisualFactoryCache::IMAGE_SHADER_YUV_TO_RGB,
- VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER_YUV_TO_RGB,
- VisualFactoryCache::IMAGE_SHADER_BORDERLINE_YUV_TO_RGB,
- VisualFactoryCache::IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_TO_RGB,
- VisualFactoryCache::IMAGE_SHADER_YUV_AND_RGB,
- VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER_YUV_AND_RGB,
- VisualFactoryCache::IMAGE_SHADER_BORDERLINE_YUV_AND_RGB,
- VisualFactoryCache::IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_AND_RGB};
+VisualFactoryCache::ShaderType SHADER_TYPE_TABLE[] = {
+ VisualFactoryCache::IMAGE_SHADER,
+ VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER,
+ VisualFactoryCache::IMAGE_SHADER_SQUIRCLE_CORNER,
+ VisualFactoryCache::IMAGE_SHADER_BORDERLINE,
+ VisualFactoryCache::IMAGE_SHADER_ROUNDED_BORDERLINE,
+ VisualFactoryCache::IMAGE_SHADER_SQUIRCLE_BORDERLINE,
+ VisualFactoryCache::IMAGE_SHADER_MASKING,
+ VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER_MASKING,
+ VisualFactoryCache::IMAGE_SHADER_SQUIRCLE_CORNER_MASKING,
+ VisualFactoryCache::IMAGE_SHADER_BORDERLINE_MASKING,
+ VisualFactoryCache::IMAGE_SHADER_ROUNDED_BORDERLINE_MASKING,
+ VisualFactoryCache::IMAGE_SHADER_SQUIRCLE_BORDERLINE_MASKING,
+ VisualFactoryCache::IMAGE_SHADER_YUV_TO_RGB,
+ VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER_YUV_TO_RGB,
+ VisualFactoryCache::IMAGE_SHADER_SQUIRCLE_CORNER_YUV_TO_RGB,
+ VisualFactoryCache::IMAGE_SHADER_BORDERLINE_YUV_TO_RGB,
+ VisualFactoryCache::IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_TO_RGB,
+ VisualFactoryCache::IMAGE_SHADER_SQUIRCLE_BORDERLINE_YUV_TO_RGB,
+ VisualFactoryCache::IMAGE_SHADER_YUV_AND_RGB,
+ VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER_YUV_AND_RGB,
+ VisualFactoryCache::IMAGE_SHADER_SQUIRCLE_CORNER_YUV_AND_RGB,
+ VisualFactoryCache::IMAGE_SHADER_BORDERLINE_YUV_AND_RGB,
+ VisualFactoryCache::IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_AND_RGB,
+ VisualFactoryCache::IMAGE_SHADER_SQUIRCLE_BORDERLINE_YUV_AND_RGB,
+};
+constexpr uint32_t SHADER_TYPE_TABLE_COUNT = sizeof(SHADER_TYPE_TABLE) / sizeof(SHADER_TYPE_TABLE[0]);
} // unnamed namespace
namespace ImageVisualShaderFeature
return *this;
}
-FeatureBuilder& FeatureBuilder::EnableRoundedCorner(bool enableRoundedCorner)
+FeatureBuilder& FeatureBuilder::EnableRoundedCorner(bool enableRoundedCorner, bool enableSquircleCorner)
{
- mRoundedCorner = (enableRoundedCorner ? RoundedCorner::ENABLED : RoundedCorner::DISABLED);
+ mRoundedCorner = (enableRoundedCorner ? (enableSquircleCorner ? RoundedCorner::SQUIRCLE_CORNER : RoundedCorner::ROUNDED_CORNER) : RoundedCorner::DISABLED);
return *this;
}
else
{
uint32_t shaderTypeFlag = static_cast<uint32_t>(ImageVisualRequireFlag::DEFAULT);
- if(mRoundedCorner == RoundedCorner::ENABLED)
+ if(mRoundedCorner == RoundedCorner::SQUIRCLE_CORNER)
+ {
+ shaderTypeFlag += static_cast<uint32_t>(ImageVisualRequireFlag::SQUIRCLE_CORNER);
+ }
+ else if(mRoundedCorner == RoundedCorner::ROUNDED_CORNER)
{
- shaderTypeFlag |= static_cast<uint32_t>(ImageVisualRequireFlag::ROUNDED_CORNER);
+ shaderTypeFlag += static_cast<uint32_t>(ImageVisualRequireFlag::ROUNDED_CORNER);
}
+
if(mBorderline == Borderline::ENABLED)
{
- shaderTypeFlag |= static_cast<uint32_t>(ImageVisualRequireFlag::BORDERLINE);
+ shaderTypeFlag += static_cast<uint32_t>(ImageVisualRequireFlag::BORDERLINE);
}
+
if(mAlphaMaskingOnRendering == AlphaMaskingOnRendering::ENABLED)
{
- shaderTypeFlag |= static_cast<uint32_t>(ImageVisualRequireFlag::ALPHA_MASKING);
+ shaderTypeFlag += static_cast<uint32_t>(ImageVisualRequireFlag::ALPHA_MASKING);
}
else if(mColorConversion == ColorConversion::YUV_TO_RGB) // Not support gpu masking and color conversion at the same time now
{
- shaderTypeFlag |= static_cast<uint32_t>(ImageVisualRequireFlag::COLOR_CONVERSION);
+ shaderTypeFlag += static_cast<uint32_t>(ImageVisualRequireFlag::COLOR_CONVERSION);
}
else if(mColorConversion == ColorConversion::UNIFIED_YUV_AND_RGB)
{
- shaderTypeFlag |= static_cast<uint32_t>(ImageVisualRequireFlag::COLOR_CONVERSION);
- shaderTypeFlag |= static_cast<uint32_t>(ImageVisualRequireFlag::UNIFIED_YUV_AND_RGB);
+ shaderTypeFlag += static_cast<uint32_t>(ImageVisualRequireFlag::COLOR_CONVERSION);
+ shaderTypeFlag += static_cast<uint32_t>(ImageVisualRequireFlag::UNIFIED_YUV_AND_RGB);
}
+
+ DALI_ASSERT_DEBUG(shaderTypeFlag < SHADER_TYPE_TABLE_COUNT && "Invalid image shader type generated!");
+
shaderType = SHADER_TYPE_TABLE[shaderTypeFlag];
}
{
if(mTextureAtlas != TextureAtlas::ENABLED)
{
- if(mRoundedCorner == RoundedCorner::ENABLED)
+ if(mRoundedCorner != RoundedCorner::DISABLED)
{
vertexShaderPrefixList += "#define IS_REQUIRED_ROUNDED_CORNER\n";
}
}
else
{
- if(mRoundedCorner == RoundedCorner::ENABLED)
+ if(mRoundedCorner != RoundedCorner::DISABLED)
{
fragmentShaderPrefixList += "#define IS_REQUIRED_ROUNDED_CORNER\n";
+ if(mRoundedCorner == RoundedCorner::SQUIRCLE_CORNER)
+ {
+ fragmentShaderPrefixList += "#define IS_REQUIRED_SQUIRCLE_CORNER\n";
+ }
}
if(mBorderline == Borderline::ENABLED)
{
namespace RoundedCorner
{
/**
- * @brief Whether use rounded corner, or not
+ * @brief Whether use rounded corner, or squircle corner, or not
*/
enum Type
{
- DISABLED = 0, ///< Image visual doesn't use rounded corner
- ENABLED ///< Image visual uses rounded corner
+ DISABLED = 0, ///< Image visual doesn't use rounded corner
+ ROUNDED_CORNER, ///< Image visual uses rounded corner
+ SQUIRCLE_CORNER ///< Image visual use squircle corner
};
} // namespace RoundedCorner
FeatureBuilder& ApplyDefaultTextureWrapMode(bool applyDefaultTextureWrapMode);
- FeatureBuilder& EnableRoundedCorner(bool enableRoundedCorner);
+ FeatureBuilder& EnableRoundedCorner(bool enableRoundedCorner, bool enableSquircleCorner = false);
FeatureBuilder& EnableBorderline(bool enableBorderline);
ImageVisualShaderFeature::FeatureBuilder()
.EnableTextureAtlas(mImpl->mFlags & Visual::Base::Impl::IS_ATLASING_APPLIED && !useNativeImage)
.ApplyDefaultTextureWrapMode(mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE)
- .EnableRoundedCorner(IsRoundedCornerRequired())
+ .EnableRoundedCorner(IsRoundedCornerRequired(), IsSquircleCornerRequired())
.EnableBorderline(IsBorderlineRequired())
.SetTextureForFragmentShaderCheck(useNativeImage ? mTextures.GetTexture(0) : Dali::Texture())
.EnableAlphaMaskingOnRendering(requiredAlphaMaskingOnRendering)
mType(type),
mAlwaysUsingBorderline(false),
mAlwaysUsingCornerRadius(false),
+ mAlwaysUsingCornerSquareness(false),
mIgnoreFittingMode(false),
mPixelAreaSetByFittingMode(false),
mTransformMapSetForFittingMode(false)
#define DALI_TOOLKIT_INTERNAL_VISUAL_BASE_DATA_IMPL_H
/*
- * 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.
enum Flags
{
- IS_ON_SCENE = 1,
- IS_ATLASING_APPLIED = 1 << 1,
- IS_PREMULTIPLIED_ALPHA = 1 << 2,
- IS_SYNCHRONOUS_RESOURCE_LOADING = 1 << 3,
+ IS_ON_SCENE = 1,
+ IS_ATLASING_APPLIED = 1 << 1,
+ IS_PREMULTIPLIED_ALPHA = 1 << 2,
+ IS_SYNCHRONOUS_RESOURCE_LOADING = 1 << 3,
};
struct CustomShader
DecorationData()
: mBorderlineColor(Color::BLACK),
mCornerRadius(Vector4::ZERO),
+ mCornerSquareness(Vector4::ZERO),
mBorderlineWidth(0.0f),
mBorderlineOffset(0.0f),
mCornerRadiusPolicy(static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE))
}
Vector4 mBorderlineColor;
Vector4 mCornerRadius;
+ Vector4 mCornerSquareness;
float mBorderlineWidth;
float mBorderlineOffset;
int mCornerRadiusPolicy;
EnsureDecorationData()->mCornerRadiusPolicy = value;
}
+ /**
+ * @brief Get decoration data value : corner squareness
+ *
+ * Keep these API as inline function due to the performance.
+ */
+ Vector4 GetCornerSquareness()
+ {
+ return mDecorationData ? mDecorationData->mCornerSquareness : Vector4::ZERO;
+ }
+
+ /**
+ * @brief Set decoration data value : corner squareness
+ *
+ * Keep these API as inline function due to the performance.
+ */
+ void SetCornerSquareness(Vector4 value)
+ {
+ EnsureDecorationData()->mCornerSquareness = value;
+ }
+
VisualRenderer mRenderer;
CustomShader* mCustomShader;
EventObserver* mEventObserver; ///< Allows controls to observe when the visual has events to notify
int mFlags;
Toolkit::Visual::ResourceStatus mResourceStatus;
const Toolkit::Visual::Type mType;
- bool mAlwaysUsingBorderline : 1; ///< Whether we need the borderline in shader always.
- bool mAlwaysUsingCornerRadius : 1; ///< Whether we need the corner radius in shader always.
- bool mIgnoreFittingMode : 1; ///< Whether we need to ignore fitting mode.
- bool mPixelAreaSetByFittingMode : 1; ///< Whether the pixel area is set for fitting mode.
- bool mTransformMapSetForFittingMode :1; ///< Whether the transformMap is set for fitting mode.
+ bool mAlwaysUsingBorderline : 1; ///< Whether we need the borderline in shader always.
+ bool mAlwaysUsingCornerRadius : 1; ///< Whether we need the corner radius in shader always.
+ bool mAlwaysUsingCornerSquareness : 1; ///< Whether we need the corner squareness in shader always.
+ bool mIgnoreFittingMode : 1; ///< Whether we need to ignore fitting mode.
+ bool mPixelAreaSetByFittingMode : 1; ///< Whether the pixel area is set for fitting mode.
+ bool mTransformMapSetForFittingMode : 1; ///< Whether the transformMap is set for fitting mode.
};
} // namespace Visual
{BORDERLINE_OFFSET, Toolkit::DevelVisual::Property::BORDERLINE_OFFSET},
{CORNER_RADIUS, Toolkit::DevelVisual::Property::CORNER_RADIUS},
{CORNER_RADIUS_POLICY, Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY},
+ {CORNER_SQUARENESS, Toolkit::DevelVisual::Property::CORNER_SQUARENESS},
};
const uint16_t PROPERTY_NAME_INDEX_TABLE_COUNT = sizeof(PROPERTY_NAME_INDEX_TABLE) / sizeof(PROPERTY_NAME_INDEX_TABLE[0]);
}
break;
}
+ case Toolkit::DevelVisual::Property::CORNER_SQUARENESS:
+ {
+ if(value.GetType() == Property::VECTOR4)
+ {
+ // If CORNER_SQUARENESS Property is Vector4,
+ // Each values mean the squareness of
+ // (top-left, top-right, bottom-right, bottom-left)
+ Vector4 squareness;
+ if(value.Get(squareness) && (mImpl->mDecorationData != nullptr || squareness != Vector4::ZERO))
+ {
+ mImpl->SetCornerSquareness(squareness);
+ }
+ }
+ else
+ {
+ // If CORNER_RADIUS Property is float,
+ // Every corner radius have same value
+ float squareness;
+ if(value.Get(squareness) && (mImpl->mDecorationData != nullptr || !Dali::EqualsZero(squareness)))
+ {
+ mImpl->SetCornerSquareness(Vector4(squareness, squareness, squareness, squareness));
+ }
+ }
+
+ if(DALI_UNLIKELY(mImpl->mRenderer && IsTypeAvailableForCornerRadius(mImpl->mType)))
+ {
+ // Unusual case. SetProperty called after OnInitialize().
+ // Assume that DoAction call UPDATE_PROPERTY.
+ DownCast<DecoratedVisualRenderer>(mImpl->mRenderer).RegisterCornerSquarenessUniform();
+ mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_SQUARENESS, mImpl->GetCornerSquareness());
+
+ // Check whether we must update shader.
+ if(!mImpl->mAlwaysUsingCornerSquareness && IsSquircleCornerRequired())
+ {
+ // Required to change shader mean, we didn't setup CORNER_RADIUS_POLICY into mRenderer before. Set property now.
+ mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_RADIUS, static_cast<Vector4>(mImpl->GetCornerRadius()));
+ mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_RADIUS_POLICY, static_cast<float>(mImpl->GetCornerRadiusPolicy()));
+
+ // Change the shader must not be occured many times. we always have to use corner squreness feature.
+ mImpl->mAlwaysUsingCornerSquareness = 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
+ if(!mImpl->mCustomShader)
+ {
+ needUpdateShader = true;
+ }
+ }
+ }
+
+ break;
+ }
}
}
{
mImpl->SetCornerRadius(mImpl->mRenderer.GetProperty<Vector4>(DecoratedVisualRenderer::Property::CORNER_RADIUS));
}
+ if(IsSquircleCornerRequired())
+ {
+ mImpl->SetCornerSquareness(mImpl->mRenderer.GetProperty<Vector4>(DecoratedVisualRenderer::Property::CORNER_SQUARENESS));
+ }
if(IsBorderlineRequired())
{
mImpl->SetBorderlineWidth(mImpl->mRenderer.GetProperty<float>(DecoratedVisualRenderer::Property::BORDERLINE_WIDTH));
{
map.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS, mImpl->GetCornerRadius());
map.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, mImpl->GetCornerRadiusPolicy());
+ map.Insert(Toolkit::DevelVisual::Property::CORNER_SQUARENESS, mImpl->GetCornerSquareness());
}
}
return false;
}
+bool Visual::Base::IsSquircleCornerRequired() const
+{
+ // If VisualType doesn't support rounded corner, always return false.
+ if(IsTypeAvailableForCornerRadius(mImpl->mType))
+ {
+ if(mImpl->mRenderer)
+ {
+ // Update values from Renderer
+ Property::Value value = mImpl->mRenderer.GetProperty(DecoratedVisualRenderer::Property::CORNER_SQUARENESS);
+
+ Vector4 retValue = Vector4::ZERO;
+ if(value.Get(retValue))
+ {
+ if(mImpl->mDecorationData != nullptr || retValue != Vector4::ZERO)
+ {
+ mImpl->SetCornerSquareness(retValue);
+ }
+ }
+ }
+ return IsRoundedCornerRequired() && (mImpl->mAlwaysUsingCornerSquareness || !(mImpl->GetCornerSquareness() == Vector4::ZERO));
+ }
+ return false;
+}
+
bool Visual::Base::IsBorderlineRequired() const
{
// If VisualType doesn't support borderline, always return false.
mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_RADIUS, mImpl->GetCornerRadius());
mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_RADIUS_POLICY, static_cast<float>(mImpl->GetCornerRadiusPolicy()));
}
+ if(mImpl->mAlwaysUsingCornerSquareness || !(mImpl->GetCornerSquareness() == Vector4::ZERO))
+ {
+ DownCast<DecoratedVisualRenderer>(mImpl->mRenderer).RegisterCornerSquarenessUniform();
+ mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_SQUARENESS, mImpl->GetCornerSquareness());
+ }
}
if(IsTypeAvailableForBorderline(mImpl->mType))
{
{
return Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY;
}
+ else if(key.stringKey == CORNER_SQUARENESS)
+ {
+ return Toolkit::DevelVisual::Property::CORNER_SQUARENESS;
+ }
else if(key.stringKey == BORDERLINE_WIDTH)
{
return Toolkit::DevelVisual::Property::BORDERLINE_WIDTH;
{
return DecoratedVisualRenderer::Property::CORNER_RADIUS;
}
+ case Dali::Toolkit::DevelVisual::Property::CORNER_SQUARENESS:
+ {
+ return DecoratedVisualRenderer::Property::CORNER_SQUARENESS;
+ }
case Dali::Toolkit::DevelVisual::Property::BORDERLINE_WIDTH:
{
return DecoratedVisualRenderer::Property::BORDERLINE_WIDTH;
mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_RADIUS, mImpl->GetCornerRadius());
mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_RADIUS_POLICY, static_cast<float>(mImpl->GetCornerRadiusPolicy()));
+ if(IsSquircleCornerRequired())
+ {
+ // Change the shader must not be occured many times. we always have to use corner squreness feature.
+ mImpl->mAlwaysUsingCornerSquareness = true;
+
+ mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_SQUARENESS, mImpl->GetCornerSquareness());
+ }
+
// Change shader
UpdateShader();
}
}
break;
}
+ case Toolkit::DevelVisual::Property::CORNER_SQUARENESS:
+ {
+ if(IsTypeAvailableForCornerRadius(mImpl->mType))
+ {
+ const bool updateShader = !mImpl->mCustomShader && !IsSquircleCornerRequired();
+
+ // CornerSquareness is animated now. we always have to use corner squareness feature.
+ mImpl->mAlwaysUsingCornerSquareness = true;
+
+ if(updateShader)
+ {
+ // Update each values to renderer
+ DownCast<DecoratedVisualRenderer>(mImpl->mRenderer).RegisterCornerSquarenessUniform();
+ mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_RADIUS, mImpl->GetCornerRadius());
+ mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_RADIUS_POLICY, static_cast<float>(mImpl->GetCornerRadiusPolicy()));
+ mImpl->mRenderer.SetProperty(DecoratedVisualRenderer::Property::CORNER_SQUARENESS, mImpl->GetCornerSquareness());
+
+ // Change shader
+ UpdateShader();
+ }
+ 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);
+ }
+ return Dali::Property(mImpl->mRenderer, DecoratedVisualRenderer::Property::CORNER_SQUARENESS);
+ }
+ break;
+ }
case Toolkit::DevelVisual::Property::BORDERLINE_WIDTH:
case Toolkit::DevelVisual::Property::BORDERLINE_COLOR:
case Toolkit::DevelVisual::Property::BORDERLINE_OFFSET:
*/
bool IsRoundedCornerRequired() const;
+ /**
+ * @brief Query whether the corners of the visual requires to be squircle.
+ *
+ * @return Returns true if the rounded corner is required, false otherwise.
+ */
+ bool IsSquircleCornerRequired() const;
+
/**
* @brief Query whether the borderline of the visual requires to be rendered.
*
{
COLOR_SHADER,
COLOR_SHADER_ROUNDED_CORNER,
+ COLOR_SHADER_SQUIRCLE_CORNER,
COLOR_SHADER_BORDERLINE,
COLOR_SHADER_ROUNDED_BORDERLINE,
+ COLOR_SHADER_SQUIRCLE_BORDERLINE,
COLOR_SHADER_BLUR_EDGE,
COLOR_SHADER_ROUNDED_CORNER_BLUR_EDGE,
+ COLOR_SHADER_SQUIRCLE_CORNER_BLUR_EDGE,
COLOR_SHADER_CUTOUT,
COLOR_SHADER_CUTOUT_ROUNDED_CORNER,
+ COLOR_SHADER_CUTOUT_SQUIRCLE_CORNER,
COLOR_SHADER_CUTOUT_BORDERLINE,
COLOR_SHADER_CUTOUT_ROUNDED_BORDERLINE,
+ COLOR_SHADER_CUTOUT_SQUIRCLE_BORDERLINE,
COLOR_SHADER_CUTOUT_BLUR_EDGE,
COLOR_SHADER_CUTOUT_ROUNDED_CORNER_BLUR_EDGE,
+ COLOR_SHADER_CUTOUT_SQUIRCLE_CORNER_BLUR_EDGE,
BORDER_SHADER,
BORDER_SHADER_ANTI_ALIASING,
GRADIENT_SHADER_LINEAR_BOUNDING_BOX,
GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_CORNER,
+ GRADIENT_SHADER_LINEAR_BOUNDING_BOX_SQUIRCLE_CORNER,
GRADIENT_SHADER_LINEAR_BOUNDING_BOX_BORDERLINE,
GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_BORDERLINE,
+ GRADIENT_SHADER_LINEAR_BOUNDING_BOX_SQUIRCLE_BORDERLINE,
GRADIENT_SHADER_LINEAR_USER_SPACE,
GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_CORNER,
+ GRADIENT_SHADER_LINEAR_USER_SPACE_SQUIRCLE_CORNER,
GRADIENT_SHADER_LINEAR_USER_SPACE_BORDERLINE,
GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_BORDERLINE,
+ GRADIENT_SHADER_LINEAR_USER_SPACE_SQUIRCLE_BORDERLINE,
GRADIENT_SHADER_RADIAL_BOUNDING_BOX,
GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_CORNER,
+ GRADIENT_SHADER_RADIAL_BOUNDING_BOX_SQUIRCLE_CORNER,
GRADIENT_SHADER_RADIAL_BOUNDING_BOX_BORDERLINE,
GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_BORDERLINE,
+ GRADIENT_SHADER_RADIAL_BOUNDING_BOX_SQUIRCLE_BORDERLINE,
GRADIENT_SHADER_RADIAL_USER_SPACE,
GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_CORNER,
+ GRADIENT_SHADER_RADIAL_USER_SPACE_SQUIRCLE_CORNER,
GRADIENT_SHADER_RADIAL_USER_SPACE_BORDERLINE,
GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_BORDERLINE,
+ GRADIENT_SHADER_RADIAL_USER_SPACE_SQUIRCLE_BORDERLINE,
IMAGE_SHADER,
IMAGE_SHADER_ROUNDED_CORNER,
+ IMAGE_SHADER_SQUIRCLE_CORNER,
IMAGE_SHADER_BORDERLINE,
IMAGE_SHADER_ROUNDED_BORDERLINE,
+ IMAGE_SHADER_SQUIRCLE_BORDERLINE,
IMAGE_SHADER_MASKING,
IMAGE_SHADER_ROUNDED_CORNER_MASKING,
+ IMAGE_SHADER_SQUIRCLE_CORNER_MASKING,
IMAGE_SHADER_BORDERLINE_MASKING,
IMAGE_SHADER_ROUNDED_BORDERLINE_MASKING,
+ IMAGE_SHADER_SQUIRCLE_BORDERLINE_MASKING,
IMAGE_SHADER_ATLAS_DEFAULT_WRAP,
IMAGE_SHADER_ATLAS_CUSTOM_WRAP,
IMAGE_SHADER_YUV_TO_RGB,
IMAGE_SHADER_ROUNDED_CORNER_YUV_TO_RGB,
+ IMAGE_SHADER_SQUIRCLE_CORNER_YUV_TO_RGB,
IMAGE_SHADER_BORDERLINE_YUV_TO_RGB,
IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_TO_RGB,
+ IMAGE_SHADER_SQUIRCLE_BORDERLINE_YUV_TO_RGB,
IMAGE_SHADER_YUV_AND_RGB,
IMAGE_SHADER_ROUNDED_CORNER_YUV_AND_RGB,
+ IMAGE_SHADER_SQUIRCLE_CORNER_YUV_AND_RGB,
IMAGE_SHADER_BORDERLINE_YUV_AND_RGB,
IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_AND_RGB,
+ IMAGE_SHADER_SQUIRCLE_BORDERLINE_YUV_AND_RGB,
NATIVE_IMAGE_SHADER,
NATIVE_IMAGE_SHADER_ROUNDED_CORNER,
+ NATIVE_IMAGE_SHADER_SQUIRCLE_CORNER,
NATIVE_IMAGE_SHADER_BORDERLINE,
NATIVE_IMAGE_SHADER_ROUNDED_BORDERLINE,
+ NATIVE_IMAGE_SHADER_SQUIRCLE_BORDERLINE,
NATIVE_IMAGE_SHADER_MASKING,
NATIVE_IMAGE_SHADER_ROUNDED_CORNER_MASKING,
+ NATIVE_IMAGE_SHADER_SQUIRCLE_CORNER_MASKING,
NATIVE_IMAGE_SHADER_BORDERLINE_MASKING,
NATIVE_IMAGE_SHADER_ROUNDED_BORDERLINE_MASKING,
+ NATIVE_IMAGE_SHADER_SQUIRCLE_BORDERLINE_MASKING,
NATIVE_IMAGE_SHADER_ATLAS_DEFAULT_WRAP,
NATIVE_IMAGE_SHADER_ATLAS_CUSTOM_WRAP,
NINE_PATCH_SHADER,
DALI_ENUM_TO_STRING_TABLE_BEGIN(VISUAL_SHADER_TYPE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_ROUNDED_CORNER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_SQUIRCLE_CORNER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_ROUNDED_BORDERLINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_SQUIRCLE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_BLUR_EDGE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_ROUNDED_CORNER_BLUR_EDGE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_SQUIRCLE_CORNER_BLUR_EDGE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_CUTOUT)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_CUTOUT_ROUNDED_CORNER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_CUTOUT_SQUIRCLE_CORNER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_CUTOUT_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_CUTOUT_ROUNDED_BORDERLINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_CUTOUT_SQUIRCLE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_CUTOUT_BLUR_EDGE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_CUTOUT_ROUNDED_CORNER_BLUR_EDGE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, COLOR_SHADER_CUTOUT_SQUIRCLE_CORNER_BLUR_EDGE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, BORDER_SHADER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, BORDER_SHADER_ANTI_ALIASING)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_BOUNDING_BOX)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_CORNER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_BOUNDING_BOX_SQUIRCLE_CORNER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_BOUNDING_BOX_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_BORDERLINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_BOUNDING_BOX_SQUIRCLE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_USER_SPACE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_CORNER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_USER_SPACE_SQUIRCLE_CORNER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_USER_SPACE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_BORDERLINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_LINEAR_USER_SPACE_SQUIRCLE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_BOUNDING_BOX)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_CORNER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_BOUNDING_BOX_SQUIRCLE_CORNER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_BOUNDING_BOX_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_BORDERLINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_BOUNDING_BOX_SQUIRCLE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_USER_SPACE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_CORNER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_USER_SPACE_SQUIRCLE_CORNER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_USER_SPACE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_BORDERLINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, GRADIENT_SHADER_RADIAL_USER_SPACE_SQUIRCLE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ROUNDED_CORNER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_SQUIRCLE_CORNER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ROUNDED_BORDERLINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_SQUIRCLE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_MASKING)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ROUNDED_CORNER_MASKING)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_SQUIRCLE_CORNER_MASKING)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_BORDERLINE_MASKING)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ROUNDED_BORDERLINE_MASKING)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_SQUIRCLE_BORDERLINE_MASKING)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ATLAS_DEFAULT_WRAP)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ATLAS_CUSTOM_WRAP)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_YUV_TO_RGB)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ROUNDED_CORNER_YUV_TO_RGB)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_SQUIRCLE_CORNER_YUV_TO_RGB)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_BORDERLINE_YUV_TO_RGB)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_TO_RGB)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_SQUIRCLE_BORDERLINE_YUV_TO_RGB)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_YUV_AND_RGB)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ROUNDED_CORNER_YUV_AND_RGB)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_SQUIRCLE_CORNER_YUV_AND_RGB)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_BORDERLINE_YUV_AND_RGB)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_AND_RGB)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, IMAGE_SHADER_SQUIRCLE_BORDERLINE_YUV_AND_RGB)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_ROUNDED_CORNER)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_SQUIRCLE_CORNER)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_ROUNDED_BORDERLINE)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_SQUIRCLE_BORDERLINE)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_MASKING)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_ROUNDED_CORNER_MASKING)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_SQUIRCLE_CORNER_MASKING)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_BORDERLINE_MASKING)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_ROUNDED_BORDERLINE_MASKING)
+ DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_SQUIRCLE_BORDERLINE_MASKING)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_ATLAS_DEFAULT_WRAP)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NATIVE_IMAGE_SHADER_ATLAS_CUSTOM_WRAP)
DALI_ENUM_TO_STRING_WITH_SCOPE(Toolkit::Internal::VisualFactoryCache::ShaderType, NINE_PATCH_SHADER)
// Corner radius
const char* const CORNER_RADIUS("cornerRadius");
const char* const CORNER_RADIUS_POLICY("cornerRadiusPolicy");
+const char* const CORNER_SQUARENESS("cornerSquareness");
// Color visual
const char* const BLUR_RADIUS_NAME("blurRadius");
// Corner radius
extern const char* const CORNER_RADIUS;
extern const char* const CORNER_RADIUS_POLICY;
+extern const char* const CORNER_SQUARENESS;
// Color visual
extern const char* const BLUR_RADIUS_NAME;
float defaultBorderlineWidth(0.0f);
Vector4 defaultBorderlineColor(0.0f, 0.0f, 0.0f, 1.0f);
float defaultBorderlineOffset(0.0f);
+ Vector4 defaultCornerSquareness(0.0f, 0.0f, 0.0f, 0.0f);
Vector4 sourceMixColor = findValueVector4(sourceMap, Dali::Toolkit::Visual::Property::MIX_COLOR, defaultMixColor);
Vector4 sourceCornerRadius = findValueVector4(sourceMap, Toolkit::DevelVisual::Property::CORNER_RADIUS, defaultCornerRadius);
float sourceBorderlineWidth = findValueFloat(sourceMap, Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, defaultBorderlineWidth);
Vector4 sourceBorderlineColor = findValueVector4(sourceMap, Toolkit::DevelVisual::Property::BORDERLINE_COLOR, defaultBorderlineColor);
float sourceBorderlineOffset = findValueFloat(sourceMap, Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, defaultBorderlineOffset);
+ Vector4 sourceCornerSquareness = findValueVector4(sourceMap, Toolkit::DevelVisual::Property::CORNER_SQUARENESS, defaultCornerSquareness);
Vector4 destinationMixColor = findValueVector4(destinationMap, Dali::Toolkit::Visual::Property::MIX_COLOR, defaultMixColor);
Vector4 destinationCornerRadius = findValueVector4(destinationMap, Toolkit::DevelVisual::Property::CORNER_RADIUS, defaultCornerRadius);
float destinationBorderlineWidth = findValueFloat(destinationMap, Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, defaultBorderlineWidth);
Vector4 destinationBorderlineColor = findValueVector4(destinationMap, Toolkit::DevelVisual::Property::BORDERLINE_COLOR, defaultBorderlineColor);
float destinationBorderlineOffset = findValueFloat(destinationMap, Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, defaultBorderlineOffset);
+ Vector4 destinationCornerSquareness = findValueVector4(destinationMap, Toolkit::DevelVisual::Property::CORNER_SQUARENESS, defaultCornerSquareness);
// If the value of the source Control and that of destination Control is different, the property should be transitioned.
if(sourceMixColor != destinationMixColor)
sourcePropertyMap.Add(Dali::Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, sourceBorderlineOffset);
destinationPropertyMap.Add(Dali::Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, destinationBorderlineOffset);
}
+
+ if(sourceCornerSquareness != destinationCornerSquareness)
+ {
+ sourcePropertyMap.Add(Dali::Toolkit::DevelVisual::Property::CORNER_SQUARENESS, sourceCornerSquareness);
+ destinationPropertyMap.Add(Dali::Toolkit::DevelVisual::Property::CORNER_SQUARENESS, destinationCornerSquareness);
+ }
}
Control& GetImplementation(Dali::Toolkit::Control& handle)
projects / platform / core / uifw / dali-toolkit.git / commitdiff