/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene3d/public-api/loader/camera-parameters.h"
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/actors/camera-actor-devel.h>
#include <string_view>
+#include "dali-scene3d/public-api/loader/camera-parameters.h"
using namespace Dali;
using namespace Dali::Scene3D::Loader;
int UtcDaliCameraParameters(void)
{
- Quaternion qView = Quaternion(Radian(Degree(180.f)), Vector3::YAXIS);
+ Quaternion qView = Quaternion(Radian(Degree(180.f)), Vector3::YAXIS);
CameraParameters camParams;
camParams.matrix.SetTransformComponents(Vector3::ONE * 2.f,
- qView,
- Vector3::ZAXIS * -100.f);
- camParams.orthographicSize = Vector4{ -1.f, 1.f, -1.f, 1.f };
- camParams.yFov = Radian(M_PI * .5).radian;
- camParams.zNear = 1.f;
- camParams.zFar = 1000.f;
+ qView,
+ Vector3::ZAXIS * -100.f);
+ camParams.orthographicSize = 3.0f;
+ camParams.aspectRatio = 1.0f;
+ camParams.yFov = Degree(Radian(M_PI * .5)).degree;
+ camParams.zNear = 1.f;
+ camParams.zFar = 1000.f;
- Vector3 scale;
+ Vector3 scale;
Quaternion orientation;
- Vector3 position;
+ Vector3 position;
camParams.CalculateTransformComponents(position, orientation, scale);
DALI_TEST_EQUAL(scale, Vector3::ONE * 2.f);
DALI_TEST_EQUAL(orientation, Quaternion::IDENTITY); // 2 180 degrees rotations along y
DALI_TEST_EQUAL(position, Vector3::ZAXIS * -100.f);
TestApplication app;
- CameraActor camera = CameraActor::New();
- for (auto i : { false, true })
+ CameraActor camera = CameraActor::New();
+ for(auto i : {false, true})
{
camParams.isPerspective = i;
- auto viewProjection = camParams.GetViewProjection();
- Matrix view{ false };
+ auto viewProjection = camParams.GetViewProjection();
+ Matrix view{false};
Matrix::Multiply(view, Matrix(qView), camParams.matrix);
view.Invert();
DALI_TEST_EQUAL(viewProjection.GetView(), view);
DALI_TEST_EQUAL(camera.GetProperty(Actor::Property::POSITION).Get<Vector3>(), position);
DALI_TEST_EQUAL(camera.GetProperty(Actor::Property::ORIENTATION).Get<Quaternion>(), orientation);
DALI_TEST_EQUAL(camera.GetProperty(Actor::Property::SCALE).Get<Vector3>(), scale);
+
+ if(camParams.isPerspective)
+ {
+ DALI_TEST_EQUAL(camera.GetProperty(Dali::CameraActor::Property::FIELD_OF_VIEW).Get<float>(), Radian(Degree(camParams.yFov)).radian);
+ }
+ else
+ {
+ DALI_TEST_EQUAL(camera.GetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE).Get<float>(), camParams.orthographicSize);
+ }
}
END_TEST;
Scene3D::SceneView view = Scene3D::SceneView::New();
renderTaskCount = application.GetScene().GetRenderTaskList().GetTaskCount();
- DALI_TEST_EQUALS(2u, renderTaskCount, TEST_LOCATION);
-
- RenderTask renderTask = application.GetScene().GetRenderTaskList().GetTask(1u);
- CameraActor camera = renderTask.GetCameraActor();
+ DALI_TEST_EQUALS(1u, renderTaskCount, TEST_LOCATION);
application.GetScene().Add(view);
application.SendNotification();
application.Render();
+
+ renderTaskCount = application.GetScene().GetRenderTaskList().GetTaskCount();
+ DALI_TEST_EQUALS(2u, renderTaskCount, TEST_LOCATION);
+
+ RenderTask renderTask = application.GetScene().GetRenderTaskList().GetTask(1u);
+ CameraActor camera = renderTask.GetCameraActor();
+
CameraActor defaultCamera = renderTask.GetCameraActor();
DALI_TEST_CHECK(defaultCamera);
DALI_TEST_EQUALS(camera, defaultCamera, TEST_LOCATION);
END_TEST;
}
+
+int UtcDaliSceneViewCreateAndRemoveRenderTask(void)
+{
+ ToolkitTestApplication application;
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+
+ uint32_t renderTaskCount = taskList.GetTaskCount();
+
+ Scene3D::SceneView view = Scene3D::SceneView::New();
+ view.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+
+ DALI_TEST_EQUALS(renderTaskCount, application.GetScene().GetRenderTaskList().GetTaskCount(), TEST_LOCATION);
+
+ application.GetScene().Add(view);
+
+ DALI_TEST_EQUALS(renderTaskCount + 1, application.GetScene().GetRenderTaskList().GetTaskCount(), TEST_LOCATION);
+
+ view.Unparent();
+
+ DALI_TEST_EQUALS(renderTaskCount, application.GetScene().GetRenderTaskList().GetTaskCount(), TEST_LOCATION);
+
+ END_TEST;
+}
};
// Default New
+ // Note: TextField and TextEditor have TextSelectionPopup
tet_infoline( "Check whether ControlStyleChangeSignal connected in default New\n");
checkup(1, Control::New());
checkup(1, ImageView::New());
checkup(1, ImageView::New("url", Dali::ImageDimensions(32u, 32u)));
checkup(1, TextLabel::New());
checkup(1, TextLabel::New("text"));
+ checkup(2, TextField::New());
+ checkup(2, TextEditor::New());
// New with additional behaviour, but enable style change signals
tet_infoline( "Check whether ControlStyleChangeSignal connected in non-disable style change signals\n");
checkup(1, TextLabel::New(Toolkit::Control::ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT, "text"));
checkup(1, TextLabel::New(Toolkit::Control::ControlBehaviour::DISABLE_SIZE_NEGOTIATION));
checkup(1, TextLabel::New(Toolkit::Control::ControlBehaviour::DISABLE_SIZE_NEGOTIATION, "text"));
+ checkup(2, TextField::New(Toolkit::Control::ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT));
+ checkup(2, TextField::New(Toolkit::Control::ControlBehaviour::DISABLE_SIZE_NEGOTIATION));
+ checkup(2, TextEditor::New(Toolkit::Control::ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT));
+ checkup(2, TextEditor::New(Toolkit::Control::ControlBehaviour::DISABLE_SIZE_NEGOTIATION));
// New with additional behaviour, so disable style change signals
tet_infoline( "Check whether ControlStyleChangeSignal did not connected\n");
checkup(0, ImageView::New(Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, "url", Dali::ImageDimensions(32u, 32u)));
checkup(0, TextLabel::New(Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS));
checkup(0, TextLabel::New(Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, "text"));
+ checkup(1, TextField::New(Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS));
+ checkup(1, TextEditor::New(Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS));
END_TEST;
}
return Graphics::MemoryRequirements{};
}
-const Graphics::TextureProperties& TestGraphicsController::GetTextureProperties(const Graphics::Texture& texture)
+Graphics::TextureProperties TestGraphicsController::GetTextureProperties(const Graphics::Texture& texture)
{
static Graphics::TextureProperties textureProperties{};
mCallStack.PushCall("GetTextureProperties", "");
#define TEST_GRAPHICS_CONTROLLER_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @return Returns the TextureProperties object
*/
- const Graphics::TextureProperties& GetTextureProperties(const Graphics::Texture& texture) override;
+ Graphics::TextureProperties GetTextureProperties(const Graphics::Texture& texture) override;
/**
* @brief Returns the reflection of the given program
Dali::RenderSurfaceInterface& GetRenderSurface();
+ Dali::RenderTaskList GetRenderTaskList();
+
protected:
TestRenderSurface mRenderSurface;
#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <toolkit-adaptor-impl.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
using AdaptorImpl = Dali::Internal::Adaptor::Adaptor;
return mRenderSurface;
}
+Dali::RenderTaskList SceneHolder::GetRenderTaskList()
+{
+ return mScene.GetRenderTaskList();
+}
+
} // namespace Adaptor
} // namespace Internal
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/object/base-object.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
#define DALI_WINDOW_H
#include <dali/integration-api/adaptor-framework/adaptor.h>
return GetImplementation(*this).TouchedSignal();
}
+Dali::RenderTaskList Window::GetRenderTaskList()
+{
+ return GetImplementation(*this).GetRenderTaskList();
+}
+
namespace DevelWindow
{
Window Get(Actor actor)
KeyEventSignalType& KeyEventSignal();
TouchEventSignalType& TouchedSignal();
ResizeSignalType& ResizeSignal();
+ Dali::RenderTaskList GetRenderTaskList();
public:
explicit Window(Internal::Adaptor::Window* window);
#include <dali/devel-api/adaptor-framework/window-devel.h>
#include <dali/public-api/signals/render-callback.h>
-
using namespace Dali;
using namespace Dali::Toolkit;
-
// Positive test case for a method
int UtcDaliGlViewDirectRenderingNew(void)
{
namespace DirectRenderingCode
{
-
// Internal callback function
-void glInit(void)
+void glInit(Dali::RenderCallbackInput& input)
{
}
-int glRenderFrame(void)
+int glRenderFrame(Dali::RenderCallbackInput& input)
{
static unsigned int retFlag = 0;
return retFlag++;
}
-void glTerminate(void)
+int gBoundTextureCount = 0;
+
+int glRenderFrameWithTextures(Dali::RenderCallbackInput& input)
{
+ gBoundTextureCount = input.textureBindings.size();
+ return 1;
}
+void glTerminate(Dali::RenderCallbackInput& input)
+{
+}
// Internal callback function
void glInitMT(Dali::RenderCallbackInput& input)
{
}
-}
+} // namespace DirectRenderingCode
int UtcDaliGlViewDirectRenderingRegisterGlCallbacksN(void)
{
application.SendNotification();
application.Render();
-
-
//To GlViewRenderThread can recognize Resize signal the main thread have to sleep.
std::this_thread::sleep_for(std::chrono::milliseconds(100));
END_TEST;
}
+int UtcDaliGlViewDirectRenderingTextureBinding(void)
+{
+ ToolkitTestApplication application;
+
+ GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
+
+ view.SetRenderingMode(GlView::RenderingMode::CONTINUOUS);
+ view.SetGraphicsConfig(true, true, 0, GlView::GraphicsApiVersion::GLES_VERSION_2_0);
+ view.RegisterGlCallbacks(Dali::MakeCallback(DirectRenderingCode::glInit), Dali::MakeCallback(DirectRenderingCode::glRenderFrameWithTextures), Dali::MakeCallback(DirectRenderingCode::glTerminate));
+ view.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ view.SetProperty(Actor::Property::SIZE, Vector2(360.0f, 360.0f));
+
+ // Set size on the actor (half the window size to show that glClear() and scissor test work together)
+ view.SetProperty(Actor::Property::SIZE, Size(100, 100));
+ view.SetProperty(Actor::Property::POSITION, Vector2(0, 0));
+
+ application.GetScene().Add(view);
+
+ // Prepare texture 1
+ Texture texture1 = Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 512, 512);
+ auto* data1 = reinterpret_cast<uint8_t*>(malloc(512 * 512 * 4));
+ PixelData pixelData1 = PixelData::New(data1, 512 * 512 * 4, 512, 512, Pixel::Format::RGBA8888, PixelData::ReleaseFunction::FREE);
+ texture1.Upload(pixelData1);
+
+ // Prepare texture 2
+ Texture texture2 = Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 512, 512);
+ auto* data2 = reinterpret_cast<uint8_t*>(malloc(512 * 512 * 4));
+ PixelData pixelData2 = PixelData::New(data2, 512 * 512 * 4, 512, 512, Pixel::Format::RGBA8888, PixelData::ReleaseFunction::FREE);
+ texture2.Upload(pixelData2);
+
+ std::vector<Texture> texturesToBind;
+ texturesToBind.push_back(texture1);
+ texturesToBind.push_back(texture2);
+
+ view.BindTextureResources(texturesToBind);
+
+ DirectRenderingCode::gBoundTextureCount = 0;
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS(DirectRenderingCode::gBoundTextureCount, texturesToBind.size(), TEST_LOCATION);
+
+ END_TEST;
+}
+
// Positive test case for a method
int UtcDaliGlViewDirectRenderingThreadedNew(void)
{
// Set size on the actor (half the window size to show that glClear() and scissor test work together)
view.SetProperty(Actor::Property::SIZE, Size(100, 100));
- view.SetProperty(Actor::Property::POSITION, Vector2(0,0));
+ view.SetProperty(Actor::Property::POSITION, Vector2(0, 0));
- while( DirectRenderingCode::gDRFramesRendered < 1 )
+ while(DirectRenderingCode::gDRFramesRendered < 1)
{
application.SendNotification();
application.Render();
extern "C" bool gDirectRenderingFailCreateShader;
extern "C" bool gDirectRenderingFailCreateProgram;
-
int UtcDaliGlViewDirectRenderingThreadedOnScene1(void)
{
ToolkitTestApplication application;
// Set size on the actor (half the window size to show that glClear() and scissor test work together)
view.SetProperty(Actor::Property::SIZE, Size(100, 100));
- view.SetProperty(Actor::Property::POSITION, Vector2(0,0));
+ view.SetProperty(Actor::Property::POSITION, Vector2(0, 0));
- while( DirectRenderingCode::gDRFramesRendered < 1 )
+ while(DirectRenderingCode::gDRFramesRendered < 1)
{
application.SendNotification();
application.Render();
// Set size on the actor (half the window size to show that glClear() and scissor test work together)
view.SetProperty(Actor::Property::SIZE, Size(100, 100));
- view.SetProperty(Actor::Property::POSITION, Vector2(0,0));
+ view.SetProperty(Actor::Property::POSITION, Vector2(0, 0));
- while( DirectRenderingCode::gDRFramesRendered < 1 )
+ while(DirectRenderingCode::gDRFramesRendered < 1)
{
application.SendNotification();
application.Render();
const bool enabled = label.GetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL).Get<bool>();
DALI_TEST_CHECK(!enabled);
-
label.SetProperty(TextLabel::Property::MULTI_LINE, false);
label.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 1);
label.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 9999.0f);
END_TEST;
}
+int UtcDaliToolkitTextlabelTextFitStressTest(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline(" UtcDaliToolkitTextlabelTextFitStressTest");
+ TextLabel label = TextLabel::New();
+ Vector2 size(460.0f, 100.0f);
+ label.SetProperty(Actor::Property::SIZE, size);
+ label.SetProperty(TextLabel::Property::TEXT, "Hello world");
+
+ // connect to the text git changed signal.
+ ConnectionTracker* testTracker = new ConnectionTracker();
+ DevelTextLabel::TextFitChangedSignal(label).Connect(&TestTextFitChangedCallback);
+ bool textFitChangedSignal = false;
+ label.ConnectSignal(testTracker, "textFitChanged", CallbackFunctor(&textFitChangedSignal));
+ gTextFitChangedCallBackCalled = false;
+
+ // check point size with veryvery big range
+ Property::Map textFitMapSet;
+ textFitMapSet["enable"] = true;
+ textFitMapSet["minSize"] = 10.f;
+ textFitMapSet["maxSize"] = 10000.f;
+ textFitMapSet["stepSize"] = -1.0f;
+ textFitMapSet["fontSizeType"] = "pointSize";
+
+ label.SetProperty(Toolkit::DevelTextLabel::Property::TEXT_FIT, textFitMapSet);
+ label.SetProperty(TextLabel::Property::POINT_SIZE, 120.f);
+
+ application.GetScene().Add(label);
+
+ application.SendNotification();
+ application.Render();
+
+ const Vector3 EXPECTED_NATURAL_SIZE(450.0f, 96.0f, 0.0f);
+ DALI_TEST_EQUALS(EXPECTED_NATURAL_SIZE, label.GetNaturalSize(), TEST_LOCATION);
+
+ DALI_TEST_CHECK(gTextFitChangedCallBackCalled);
+ DALI_TEST_CHECK(textFitChangedSignal);
+
+ END_TEST;
+}
+
int UtcDaliToolkitTextlabelMaxTextureSet(void)
{
ToolkitTestApplication application;
application.SendNotification();
application.Render();
-
END_TEST;
}
END_TEST;
}
-
int utcDaliTextLabelGeometryNullPtr(void)
{
ToolkitTestApplication application;
{Vector3(-1.0f, -1.0f, 1.0f)},
{Vector3(1.0f, -1.0f, 1.0f)}};
- Dali::Shader shaderSkybox = Shader::New(SHADER_SKYBOX_SHADER_VERT.data(), SHADER_SKYBOX_SHADER_FRAG.data());
- Dali::VertexBuffer vertexBuffer = Dali::VertexBuffer::New(Property::Map().Add("aPosition", Property::VECTOR3));
+ Dali::Shader shaderSkybox = Shader::New(SHADER_SKYBOX_SHADER_VERT.data(), SHADER_SKYBOX_SHADER_FRAG.data());
+ Dali::VertexBuffer vertexBuffer = Dali::VertexBuffer::New(Property::Map().Add("aPosition", Property::VECTOR3));
vertexBuffer.SetData(skyboxVertices, sizeof(skyboxVertices) / sizeof(Vertex));
Dali::Geometry skyboxGeometry = Geometry::New();
skyboxGeometry.AddVertexBuffer(vertexBuffer);
skyboxGeometry.SetType(Geometry::TRIANGLES);
- Dali::Texture skyboxTexture = Dali::Scene3D::Loader::LoadCubeMap(skyboxUrl);
+ Dali::Texture skyboxTexture = Dali::Scene3D::Loader::LoadCubeMap(skyboxUrl);
Dali::TextureSet skyboxTextures = TextureSet::New();
skyboxTextures.SetTexture(0, skyboxTexture);
void SceneView::OnSceneConnection(int depth)
{
- UpdateRenderTask();
-
Window window = DevelWindow::Get(Self());
if(window)
{
window.ResizeSignal().Connect(this, &SceneView::OnWindowResized);
+ RenderTaskList taskList = window.GetRenderTaskList();
+ mRenderTask = taskList.CreateTask();
+ mRenderTask.SetSourceActor(mRootLayer);
+ mRenderTask.SetExclusive(true);
+ mRenderTask.SetInputEnabled(true);
+ mRenderTask.SetCullMode(false);
+ mRenderTask.SetScreenToFrameBufferMappingActor(Self());
+
+ UpdateRenderTask();
+ mWindow = window;
}
Control::OnSceneConnection(depth);
{
mItems.clear();
- Window window = DevelWindow::Get(Self());
+ Window window = mWindow.GetHandle();
if(window)
{
window.ResizeSignal().Disconnect(this, &SceneView::OnWindowResized);
+ RenderTaskList taskList = window.GetRenderTaskList();
+ if(mRenderTask)
+ {
+ taskList.RemoveTask(mRenderTask);
+ mRenderTarget.Reset();
+ }
}
+ mWindow.Reset();
Control::OnSceneDisconnection();
}
mRootLayer.SetProperty(Dali::Actor::Property::INHERIT_SCALE, false);
self.Add(mRootLayer);
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- mRenderTask = taskList.CreateTask();
- mRenderTask.SetSourceActor(mRootLayer);
- mRenderTask.SetExclusive(true);
- mRenderTask.SetInputEnabled(true);
- mRenderTask.SetCullMode(false);
- mRenderTask.SetScreenToFrameBufferMappingActor(Self());
-
mDefaultCamera = Dali::CameraActor::New();
mDefaultCamera.SetProperty(Dali::Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
mDefaultCamera.SetProperty(Dali::Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
Vector3 size = Self().GetProperty<Vector3>(Dali::Actor::Property::SIZE);
const float aspectRatio = size.width / size.height;
mSelectedCamera.SetAspectRatio(aspectRatio);
- const bool projectionVertical = mSelectedCamera.GetProperty<int>(Dali::DevelCameraActor::Property::PROJECTION_DIRECTION) == Dali::DevelCameraActor::VERTICAL;
-
- // if projectionVertical, Top / Bottom is +-ve to keep consistency with orthographic values
- // else, Left / Right is +-ve to keep consistency with orthographic values
- const float orthographicSize = DALI_LIKELY(projectionVertical) ? mSelectedCamera[Dali::CameraActor::Property::TOP_PLANE_DISTANCE] : mSelectedCamera[Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE];
- const float halfHeight = DALI_LIKELY(projectionVertical) ? orthographicSize : orthographicSize / aspectRatio;
- const float halfWidth = DALI_LIKELY(projectionVertical) ? orthographicSize * aspectRatio : orthographicSize;
-
- mSelectedCamera[Dali::CameraActor::Property::LEFT_PLANE_DISTANCE] = -halfWidth;
- mSelectedCamera[Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE] = halfWidth;
- mSelectedCamera[Dali::CameraActor::Property::TOP_PLANE_DISTANCE] = halfHeight;
- mSelectedCamera[Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE] = -halfHeight;
if(mUseFrameBuffer)
{
void OnWindowResized(Window window, Window::WindowSize size);
/**
- * @brief Update camera's projection orientation according to the screen orientation.
+ * @brief Updates camera's projection orientation according to the screen orientation.
*/
void RotateCamera();
/////////////////////////////////////////////////////////////
// FrameBuffer and Rendertask to render child objects as a 3D Scene
+ Dali::WeakHandle<Dali::Window> mWindow;
CameraActor mDefaultCamera;
CameraActor mSelectedCamera;
std::vector<CameraActor> mCameras;
*/
#include "dali-scene3d/public-api/loader/camera-parameters.h"
#include "dali-scene3d/public-api/loader/utils.h"
+#include "dali/devel-api/actors/camera-actor-devel.h"
#include "dali/integration-api/debug.h"
#include "dali/public-api/actors/camera-actor.h"
#include "dali/public-api/math/quaternion.h"
else
{
Orthographic(viewProjection.GetProjection(),
- orthographicSize.x,
- orthographicSize.y,
- orthographicSize.z,
- orthographicSize.w,
+ -orthographicSize * aspectRatio,
+ orthographicSize * aspectRatio,
+ orthographicSize,
+ -orthographicSize,
zNear,
zFar,
true);
else
{
camera.SetProjectionMode(Camera::ORTHOGRAPHIC_PROJECTION);
- camera.SetOrthographicProjection(orthographicSize.x,
- orthographicSize.y,
- orthographicSize.z,
- orthographicSize.w,
- zNear,
- zFar);
+ camera.SetNearClippingPlane(zNear);
+ camera.SetFarClippingPlane(zFar);
+ camera.SetAspectRatio(aspectRatio);
+ camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, orthographicSize);
}
// model
{
struct DALI_SCENE3D_API CameraParameters
{
- Matrix matrix = Matrix::IDENTITY;
- Vector4 orthographicSize = Vector4{-1.f, 1.f, 1.f, -1.f};
- float yFov = 60.f;
- float zNear = 0.1f;
- float zFar = 1000.f;
- bool isPerspective = true;
+ Matrix matrix = Matrix::IDENTITY;
+ float orthographicSize = 1.f;
+ float aspectRatio = 1.f;
+ float yFov = 60.f;
+ float zNear = 0.1f;
+ float zFar = 1000.f;
+ bool isPerspective = true;
/**
* @return The view-projection matrix of the camera.
void DliLoader::Impl::ParseSceneInternal(Index iScene, const Toolkit::TreeNode* tnScenes, const Toolkit::TreeNode* tnNodes, LoadParams& params)
{
- auto getSceneRootIdx = [tnScenes, tnNodes](Index iScene)
- {
+ auto getSceneRootIdx = [tnScenes, tnNodes](Index iScene) {
auto tn = GetNthChild(tnScenes, iScene); // now a "scene" object
if(!tn)
{
{
if(const TreeNode* jsonCameras = mParser.GetRoot()->GetChild("cameras"))
{
+ float dummyFloatArray[4];
+
cameras.resize(jsonCameras->Size());
auto iCamera = cameras.begin();
for(auto i0 = jsonCameras->CBegin(), i1 = jsonCameras->CEnd(); i0 != i1; ++i0)
ReadFloat(jsonCamera.GetChild("fov"), iCamera->yFov);
ReadFloat(jsonCamera.GetChild("near"), iCamera->zNear);
ReadFloat(jsonCamera.GetChild("far"), iCamera->zFar);
- if(ReadVector(jsonCamera.GetChild("orthographic"), iCamera->orthographicSize.AsFloat(), 4u))
+ if(ReadVector(jsonCamera.GetChild("orthographic"), dummyFloatArray, 4u))
{
iCamera->isPerspective = false;
+
+ iCamera->orthographicSize = dummyFloatArray[2] * 0.5f;
+ iCamera->aspectRatio = dummyFloatArray[1] / dummyFloatArray[2];
}
if(auto jsonMatrix = jsonCamera.GetChild("matrix"))
else
{
auto& ortho = camera.mOrthographic;
- camParams.orthographicSize = Vector4(-ortho.mXMag, ortho.mXMag, ortho.mYMag, -ortho.mYMag) * .5f;
+ camParams.orthographicSize = ortho.mYMag * .5f;
+ camParams.aspectRatio = ortho.mXMag / ortho.mYMag;
camParams.zNear = ortho.mZNear;
camParams.zFar = ortho.mZFar;
}
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
{
Dali::Toolkit::GlView DrawableView::New(GlView::BackendMode backendMode)
{
- auto* impl = new DrawableView(backendMode);
+ auto* impl = new DrawableView(backendMode);
Dali::Toolkit::GlView handle = Dali::Toolkit::GlView(*impl);
impl->Initialize();
return handle;
}
DrawableView::DrawableView(GlView::BackendMode backendMode)
-: Dali::Toolkit::Internal::GlViewImpl( backendMode),
+: Dali::Toolkit::Internal::GlViewImpl(backendMode),
mRenderingMode(Toolkit::GlView::RenderingMode::CONTINUOUS),
mDepth(false),
mStencil(false),
mMSAA(0)
{
- mRenderCallback = RenderCallback::New( this, &DrawableView::OnRenderCallback);
+ mRenderCallback = RenderCallback::New(this, &DrawableView::OnRenderCallback);
// Create NativeRenderer
Dali::Internal::NativeRendererCreateInfo createInfo;
createInfo.maxOffscreenBuffers = 2u;
- createInfo.threadEnabled = (backendMode == GlView::BackendMode::DIRECT_RENDERING_THREADED);
- createInfo.presentationMode = Dali::Internal::NativeRendererCreateInfo::PresentationMode::FIFO;
- mNativeRenderer = std::make_unique<Dali::Internal::DrawableViewNativeRenderer>(createInfo);
+ createInfo.threadEnabled = (backendMode == GlView::BackendMode::DIRECT_RENDERING_THREADED);
+ createInfo.presentationMode = Dali::Internal::NativeRendererCreateInfo::PresentationMode::FIFO;
+ mNativeRenderer = std::make_unique<Dali::Internal::DrawableViewNativeRenderer>(createInfo);
}
DrawableView::~DrawableView() = default;
void DrawableView::RegisterGlCallbacks(CallbackBase* initCallback, CallbackBase* renderFrameCallback, CallbackBase* terminateCallback)
{
- mNativeRenderer->RegisterGlCallbacks( initCallback, renderFrameCallback, terminateCallback );
+ mNativeRenderer->RegisterGlCallbacks(initCallback, renderFrameCallback, terminateCallback);
}
void DrawableView::SetResizeCallback(CallbackBase* resizeCallback)
{
- mOnResizeCallback.reset( resizeCallback );
+ mOnResizeCallback.reset(resizeCallback);
}
bool DrawableView::SetGraphicsConfig(bool depth, bool stencil, int msaa, Dali::Toolkit::GlView::GraphicsApiVersion version)
// feature.
}
+void DrawableView::BindTextureResources(std::vector<Dali::Texture> textures)
+{
+ mRenderCallback->BindTextureResources(std::move(textures));
+}
+
void DrawableView::OnInitialize()
{
AddRenderer();
// If the callbacks are set then schedule execution of resize callback
if(mRenderCallback && mNativeRenderer)
{
- mNativeRenderer->Resize( uint32_t(targetSize.width), uint32_t(targetSize.height));
+ mNativeRenderer->Resize(uint32_t(targetSize.width), uint32_t(targetSize.height));
mSurfaceResized = true;
}
}
void DrawableView::AddRenderer()
{
Actor self = Self();
- Renderer renderer = Renderer::New( *mRenderCallback );
+ Renderer renderer = Renderer::New(*mRenderCallback);
self.AddRenderer(renderer);
}
-bool DrawableView::OnRenderCallback( const RenderCallbackInput& renderCallbackInput )
+bool DrawableView::OnRenderCallback(const RenderCallbackInput& renderCallbackInput)
{
if(mNativeRenderer)
{
- mNativeRenderer->PushRenderCallbackInputData( renderCallbackInput );
+ mNativeRenderer->PushRenderCallbackInputData(renderCallbackInput);
}
// Init state
- if( mCurrentViewState == ViewState::INIT )
+ if(mCurrentViewState == ViewState::INIT)
{
mNativeRenderer->InvokeGlInitCallback(renderCallbackInput);
mCurrentViewState = ViewState::RENDER;
if(mSurfaceResized)
{
- mNativeRenderer->Resize( uint32_t(mSurfaceSize.width), uint32_t(mSurfaceSize.height) );
+ mNativeRenderer->Resize(uint32_t(mSurfaceSize.width), uint32_t(mSurfaceSize.height));
mSurfaceResized = false;
}
- if( mCurrentViewState == ViewState::RENDER )
+ if(mCurrentViewState == ViewState::RENDER)
{
// The mSurfaceResized is set by another thread so atomic check must be provided
- bool expected{ true };
- if(mSurfaceResized.compare_exchange_weak( expected, false,
- std::memory_order_release,
- std::memory_order_relaxed
- ) && mOnResizeCallback)
+ bool expected{true};
+ if(mSurfaceResized.compare_exchange_weak(expected, false, std::memory_order_release, std::memory_order_relaxed) && mOnResizeCallback)
{
CallbackBase::Execute(*mOnResizeCallback, static_cast<int>(mSurfaceSize.x), static_cast<int>(mSurfaceSize.y));
}
return true;
}
-} // namespace Dali
+} // namespace Dali::Toolkit::Internal
#include "gl-view-interface-impl.h"
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/controls/gl-view/gl-view-interface-impl.h>
#include <dali-toolkit/internal/controls/gl-view/drawable-view-native-renderer.h>
+#include <dali-toolkit/internal/controls/gl-view/gl-view-interface-impl.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/gl-view/gl-view.h>
virtual ~DrawableView();
public:
-
/**
* @brief Creates GlView interface object using DrawableView implementation
*
/**
* @copydoc Dali::Toolkit::GlView::RenderOnce()
*/
- void RenderOnce();
+ void RenderOnce() override;
+
+ /**
+ * @copydoc Dali::Toolkit::GlView::BindTextureResources()
+ */
+ void BindTextureResources(std::vector<Dali::Texture> textures) override;
private: // From Control
/**
void AddRenderer();
private:
-
- bool OnRenderCallback( const RenderCallbackInput& renderCallbackInput );
+ bool OnRenderCallback(const RenderCallbackInput& renderCallbackInput);
private:
Dali::Toolkit::GlView::RenderingMode mRenderingMode;
} // namespace Internal
-} // namespace Dali
+} // namespace Dali::Toolkit
#endif // DALI_TOOLKIT_INTERNAL_DRAWABLE_VIEW_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
{
Dali::Toolkit::GlView GlView::New(Dali::Toolkit::GlView::ColorFormat colorFormat)
{
- auto* impl = new Dali::Toolkit::Internal::GlView(colorFormat);
+ auto* impl = new Dali::Toolkit::Internal::GlView(colorFormat);
Dali::Toolkit::GlView handle = Dali::Toolkit::GlView(*impl);
impl->Initialize();
return handle;
}
GlView::GlView(Dali::Toolkit::GlView::ColorFormat colorFormat)
-: Dali::Toolkit::Internal::GlViewImpl( Toolkit::GlView::BackendMode::EGL_IMAGE_OFFSCREEN_RENDERING ),
+: Dali::Toolkit::Internal::GlViewImpl(Toolkit::GlView::BackendMode::EGL_IMAGE_OFFSCREEN_RENDERING),
mRenderThread(nullptr),
mNativeImageQueue(nullptr),
mRenderingMode(Toolkit::GlView::RenderingMode::CONTINUOUS),
}
}
+void GlView::BindTextureResources(std::vector<Dali::Texture> textures)
+{
+ // Not supported in the indirect mode
+}
+
void GlView::OnInitialize()
{
//Create NativeImageSourceQueue with the size of 1,1
#define DALI_TOOLKIT_INTERNAL_GL_VIEW_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/public-api/rendering/shader.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/controls/gl-view/gl-view-render-thread.h>
#include <dali-toolkit/internal/controls/gl-view/gl-view-interface-impl.h>
+#include <dali-toolkit/internal/controls/gl-view/gl-view-render-thread.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/gl-view/gl-view.h>
-
namespace Dali::Toolkit
{
class GlView;
*/
void RenderOnce() override;
+ /**
+ * @copydoc Dali::Toolkit::GlView::BindTextureResources()
+ */
+ void BindTextureResources(std::vector<Dali::Texture> textures) override;
+
private: // From Control
/**
* @copydoc Toolkit::Control::OnInitialize()
} // namespace Internal
-} // namespace Dali
+} // namespace Dali::Toolkit
#endif // DALI_TOOLKIT_INTERNAL_GL_VIEW_H
class GlViewImpl : public Dali::Toolkit::Internal::Control
{
protected:
-
virtual ~GlViewImpl() = default;
public:
-
/**
* Construct a new GlView.
*/
- explicit GlViewImpl( GlView::BackendMode backendMode ) :
- Control(ControlBehaviour(0u | ACTOR_BEHAVIOUR_DEFAULT | DISABLE_STYLE_CHANGE_SIGNALS)),
+ explicit GlViewImpl(GlView::BackendMode backendMode)
+ : Control(ControlBehaviour(0u | ACTOR_BEHAVIOUR_DEFAULT | DISABLE_STYLE_CHANGE_SIGNALS)),
mBackendMode(backendMode)
{
}
*/
virtual void RenderOnce() = 0;
+ /**
+ * @copydoc Dali::Toolkit::GlView::BindTextureResources()
+ */
+ virtual void BindTextureResources(std::vector<Dali::Texture> textures) = 0;
+
private: // From Control
/**
* @copydoc Toolkit::Control::OnInitialize()
virtual void OnSceneDisconnection() override = 0;
protected:
-
- GlView::BackendMode mBackendMode { GlView::BackendMode::DEFAULT }; ///< Implementation backend mode (DirectRendering, EGL image)
+ GlView::BackendMode mBackendMode{GlView::BackendMode::DEFAULT}; ///< Implementation backend mode (DirectRendering, EGL image)
};
} // namespace Internal
return static_cast<const Dali::Toolkit::Internal::GlViewImpl&>(impl);
}
-} // namespace Dali
+} // namespace Dali::Toolkit
#endif // DALI_TOOLKIT_INTERNAL_GL_VIEW_IMPL_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// EXTERNAL INCLUDES
#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
+#include <dali/devel-api/actors/camera-actor-devel.h>
#include <dali/devel-api/adaptor-framework/file-stream.h>
#include <dali/devel-api/adaptor-framework/image-loading.h>
#include <dali/integration-api/debug.h>
template<typename T>
bool ReadBinFile(Vector<T>& dataBuffer, std::string url, int32_t offset, int32_t count)
{
- size_t readCount = 0;
+ size_t readCount = 0;
Dali::FileStream fileStream(url, FileStream::READ | FileStream::BINARY);
FILE* fp = fileStream.GetFile();
if(fp)
if(cameraInfo.type == "orthographic")
{
LoadOrthoGraphic((*cameraIter).second, cameraInfo);
- float xMag_2 = cameraInfo.orthographic.xmag / 2.0;
- float yMag_2 = cameraInfo.orthographic.ymag / 2.0;
- cameraActor.SetOrthographicProjection(-xMag_2, xMag_2, yMag_2, -yMag_2, cameraInfo.orthographic.znear, cameraInfo.orthographic.zfar);
+ float xMag_2 = cameraInfo.orthographic.xmag / 2.0;
+ float yMag_2 = cameraInfo.orthographic.ymag / 2.0;
+ const float aspect = xMag_2 / yMag_2;
+
+ cameraActor.SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION);
+ cameraActor.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, yMag_2);
+
+ cameraActor.SetNearClippingPlane(cameraInfo.orthographic.znear);
+ if(cameraInfo.orthographic.zfar > 0.0)
+ {
+ cameraActor.SetFarClippingPlane(cameraInfo.orthographic.zfar);
+ }
+ if(aspect > 0.0f) // Avoid divide-by-zero logic
+ {
+ cameraActor.SetAspectRatio(aspect);
+ }
}
else if(cameraInfo.type == "perspective")
{
actor.SetProperty(Actor::Property::POSITION, translation);
float hasLightSource = static_cast<float>(!!(scene3dView.GetLightType() & (Toolkit::Scene3dView::LightType::POINT_LIGHT | Toolkit::Scene3dView::LightType::DIRECTIONAL_LIGHT)));
- float isPointLight = static_cast<float>(!!(scene3dView.GetLightType() & Toolkit::Scene3dView::LightType::POINT_LIGHT));
+ float isPointLight = static_cast<float>(!!(scene3dView.GetLightType() & Toolkit::Scene3dView::LightType::POINT_LIGHT));
shader.RegisterProperty("uHasLightSource", hasLightSource);
shader.RegisterProperty("uIsPointLight", isPointLight);
shader.RegisterProperty("uLightVector", scene3dView.GetLightVector());
} // namespace
-Toolkit::TextEditor TextEditor::New()
+Toolkit::TextEditor TextEditor::New(ControlBehaviour additionalBehaviour)
{
// Create the implementation, temporarily owned by this handle on stack
- IntrusivePtr<TextEditor> impl = new TextEditor();
+ IntrusivePtr<TextEditor> impl = new TextEditor(additionalBehaviour);
// Pass ownership to CustomActor handle
Toolkit::TextEditor handle(*impl);
mController->ChangedLayoutDirection();
}
-TextEditor::TextEditor()
-: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
+TextEditor::TextEditor(ControlBehaviour additionalBehaviour)
+: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehaviour)),
mAnimationPeriod(0.0f, 0.0f),
mIdleCallback(NULL),
mAlignmentOffset(0.f),
public:
/**
* @copydoc Dali::Toollkit::TextEditor::New()
+ * @param[in] additionalBehaviour custom behavior flags for this TextEditor. Default is CONTROL_BEHAVIOUR_DEFAULT
*/
- static Toolkit::TextEditor New();
+ static Toolkit::TextEditor New(ControlBehaviour additionalBehaviour = ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT);
// Properties
/**
* Construct a new TextEditor.
+ *
+ * @param[in] additionalBehaviour additional behaviour flags for this TextEditor
*/
- TextEditor();
+ TextEditor(ControlBehaviour additionalBehaviour);
/**
* A reference counted object may only be deleted by calling Unreference()
} // namespace
-Toolkit::TextField TextField::New()
+Toolkit::TextField TextField::New(ControlBehaviour additionalBehaviour)
{
// Create the implementation, temporarily owned by this handle on stack
- IntrusivePtr<TextField> impl = new TextField();
+ IntrusivePtr<TextField> impl = new TextField(additionalBehaviour);
// Pass ownership to CustomActor handle
Toolkit::TextField handle(*impl);
mIdleCallback = NULL;
}
-TextField::TextField()
-: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
+TextField::TextField(ControlBehaviour additionalBehaviour)
+: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehaviour)),
mIdleCallback(NULL),
mAlignmentOffset(0.f),
mRenderingBackend(DEFAULT_RENDERING_BACKEND),
public:
/**
* @copydoc Dali::Toollkit::TextField::New()
+ * @param[in] additionalBehaviour custom behavior flags for this TextField. Default is CONTROL_BEHAVIOUR_DEFAULT
*/
- static Toolkit::TextField New();
+ static Toolkit::TextField New(ControlBehaviour additionalBehaviour = ControlBehaviour::CONTROL_BEHAVIOUR_DEFAULT);
// Properties
/**
* Construct a new TextField.
+ *
+ * @param[in] additionalBehaviour additional behaviour flags for this TextField
*/
- TextField();
+ TextField(ControlBehaviour additionalBehaviour);
/**
* A reference counted object may only be deleted by calling Unreference()
CommonTextUtils::SynchronizeTextAnchorsInParent(Self(), mController, mAnchorActors);
}
-TextLabel::TextLabel(ControlBehaviour additionalBehavior)
-: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehavior)),
+TextLabel::TextLabel(ControlBehaviour additionalBehaviour)
+: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehaviour)),
mRenderingBackend(DEFAULT_RENDERING_BACKEND),
mTextUpdateNeeded(false),
mLastAutoScrollEnabled(false)
#include <limits>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/text/layouts/layout-parameters.h>
#include <dali-toolkit/internal/text/controller/text-controller-event-handler.h>
#include <dali-toolkit/internal/text/controller/text-controller-impl.h>
+#include <dali-toolkit/internal/text/layouts/layout-parameters.h>
namespace
{
float currentFitPointSize = impl.mFontDefaults->mFitPointSize;
model->mElideEnabled = false;
- Vector<float> pointSizeArray;
// check zero value
if(pointInterval < 1.f)
{
impl.mTextFitStepSize = pointInterval = 1.0f;
}
+ uint32_t pointSizeRange = static_cast<uint32_t>(ceil((maxPointSize - minPointSize) / pointInterval));
- pointSizeArray.Reserve(static_cast<unsigned int>(ceil((maxPointSize - minPointSize) / pointInterval)));
-
- for(float i = minPointSize; i < maxPointSize; i += pointInterval)
+ // Ensure minPointSize + pointSizeRange * pointInverval >= maxPointSize
+ while(minPointSize + static_cast<float>(pointSizeRange) * pointInterval < maxPointSize)
{
- pointSizeArray.PushBack(i);
+ ++pointSizeRange;
}
- pointSizeArray.PushBack(maxPointSize);
-
- int bestSizeIndex = 0;
- int min = bestSizeIndex + 1;
- int max = pointSizeArray.Size() - 1;
- while(min <= max)
+ uint32_t bestSizeIndex = 0;
+ uint32_t minIndex = bestSizeIndex + 1u;
+ uint32_t maxIndex = pointSizeRange + 1u;
+
+ bool bestSizeUpdatedLatest = false;
+ // Find best size as binary search.
+ // Range format as [l r). (left closed, right opened)
+ // It mean, we already check all i < l is valid, and r <= i is invalid.
+ // Below binary search will check m = (l+r)/2 point.
+ // Search area sperate as [l m) or [m+1 r)
+ //
+ // Basically, we can assume that 0 (minPointSize) is always valid.
+ // Now, we will check [1 pointSizeRange] range s.t. pointSizeRange mean the maxPointSize
+ while(minIndex < maxIndex)
{
- int destI = (min + max) / 2;
+ uint32_t testIndex = minIndex + ((maxIndex - minIndex) >> 1u);
+ const float testPointSize = std::min(maxPointSize, minPointSize + static_cast<float>(testIndex) * pointInterval);
- if(CheckForTextFit(controller, pointSizeArray[destI], layoutSize))
+ if(CheckForTextFit(controller, testPointSize, layoutSize))
{
- bestSizeIndex = min;
- min = destI + 1;
+ bestSizeUpdatedLatest = true;
+
+ bestSizeIndex = testIndex;
+ minIndex = testIndex + 1u;
}
else
{
- max = destI - 1;
- bestSizeIndex = max;
+ bestSizeUpdatedLatest = false;
+ maxIndex = testIndex;
}
}
+ const float bestPointSize = std::min(maxPointSize, minPointSize + static_cast<float>(bestSizeIndex) * pointInterval);
+
+ // Best point size was not updated. re-run so the TextFit should be fitted really.
+ if(!bestSizeUpdatedLatest)
+ {
+ CheckForTextFit(controller, bestPointSize, layoutSize);
+ }
model->mElideEnabled = actualellipsis;
- if(currentFitPointSize != pointSizeArray[bestSizeIndex])
+ if(currentFitPointSize != bestPointSize)
{
impl.mTextFitChanged = true;
}
- impl.mFontDefaults->mFitPointSize = pointSizeArray[bestSizeIndex];
+ impl.mFontDefaults->mFitPointSize = bestPointSize;
impl.mFontDefaults->sizeDefined = true;
impl.ClearFontData();
}
// If the frame of frameIndex was already loaded, load batch from the last frame of queue
if(!mQueue.IsEmpty())
{
- batchFrameIndex = (mQueue.Back().mUrlIndex + 1) % mImageUrls.size();
+ batchFrameIndex = (mQueue.Back().mUrlIndex + 1) % static_cast<uint32_t>(mImageUrls.size());
}
LoadBatch(batchFrameIndex);
}
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace Dali::Toolkit
{
-
GlView::GlView() = default;
GlView::GlView(const GlView& GlView) = default;
{
// This function is backward compatible and always returns
// backend based on NativeImage.
- return Internal::GlView::New( colorFormat );
+ return Internal::GlView::New(colorFormat);
}
GlView GlView::New(BackendMode backendMode, ColorFormat colorFormat)
Dali::Toolkit::GetImpl(*this).RenderOnce();
}
+void GlView::BindTextureResources(std::vector<Dali::Texture> textures)
+{
+ Dali::Toolkit::GetImpl(*this).BindTextureResources(std::move(textures));
+}
+
GlView::GlView(Internal::GlViewImpl& implementation)
: Control(implementation)
{
VerifyCustomActorPointer<Internal::GlViewImpl>(internal);
}
-} // namespace Dali
+} // namespace Dali::Toolkit
#ifndef DALI_TOOLKIT_GL_VIEW_H
#define DALI_TOOLKIT_GL_VIEW_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
*/
+// EXTERNAL INCLUDES
+#include <dali/public-api/rendering/texture.h>
+
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
class DALI_TOOLKIT_API GlView : public Dali::Toolkit::Control
{
public:
-
/**
* @brief Implementation backend mode
*
*/
void RenderOnce();
+ /**
+ * @brief Binds DALi textures to the callback
+ *
+ * The textures that are bound to the callback will be passed upon
+ * callback execution providing native handles (like GL name) so they
+ * can be used alongside with custom GL code.
+ *
+ * Binding texture does not affect lifecycle and it's up to the client-side
+ * to make sure the resource is alive when used inside the callback.
+ *
+ * @param[in] textures List of DALi textures to be bound to the callback
+ *
+ * @note It only supported only in the GlView::BackendMode::DIRECT_RENDERING.
+ *
+ * @SINCE_2_2.2
+ */
+ void BindTextureResources(std::vector<Dali::Texture> textures);
+
public: // Not intended for application developers
/// @cond internal
/**
return Internal::TextEditor::New();
}
+TextEditor TextEditor::New(ControlBehaviour additionalBehaviour)
+{
+ return Internal::TextEditor::New(static_cast<Toolkit::Internal::Control::ControlBehaviour>(additionalBehaviour));
+}
+
TextEditor::TextEditor()
{
}
New();
/**
+ * @brief Creates the TextEditor control with additional behaviour.
+ *
+ * @SINCE_2_2.3
+ * @param[in] additionalBehaviour Additional control behaviour
+ * @return A handle to the TextEditor control
+ */
+ static TextEditor New(ControlBehaviour additionalBehaviour);
+
+ /**
* @brief Creates an empty handle.
*
* @SINCE_1_1.37
return Internal::TextField::New();
}
+TextField TextField::New(ControlBehaviour additionalBehaviour)
+{
+ return Internal::TextField::New(static_cast<Toolkit::Internal::Control::ControlBehaviour>(additionalBehaviour));
+}
+
TextField::TextField()
{
}
static TextField New();
/**
+ * @brief Creates the TextField control with additional behaviour.
+ *
+ * @SINCE_2_2.3
+ * @param[in] additionalBehaviour Additional control behaviour
+ * @return A handle to the TextField control
+ */
+ static TextField New(ControlBehaviour additionalBehaviour);
+
+ /**
* @brief Creates an empty handle.
* @SINCE_1_0.0
*/
static TextLabel New(const std::string& text);
/**
- * @brief Creates the TextLabel control with additional behavior.
+ * @brief Creates the TextLabel control with additional behaviour.
*
* @SINCE_2_1.8
* @param[in] additionalBehaviour Additional control behaviour
static TextLabel New(ControlBehaviour additionalBehaviour);
/**
- * @brief Creates the TextLabel control with additional behavior.
+ * @brief Creates the TextLabel control with additional behaviour.
*
* @SINCE_2_1.8
* @param[in] additionalBehaviour Additional control behaviour
{
const unsigned int TOOLKIT_MAJOR_VERSION = 2;
const unsigned int TOOLKIT_MINOR_VERSION = 2;
-const unsigned int TOOLKIT_MICRO_VERSION = 1;
+const unsigned int TOOLKIT_MICRO_VERSION = 2;
const char* const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-toolkit
Summary: Dali 3D engine Toolkit
-Version: 2.2.1
+Version: 2.2.2
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff