*/
#include <dali-test-suite-utils.h>
+#include <dali/integration-api/shader-integ.h>
#include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
#include <dali/internal/event/common/thread-local-storage.h>
#include <dali/internal/event/effects/shader-factory.h>
END_TEST;
}
+int UtcDaliShaderWithPrefixTestVersion2(void)
+{
+ TestApplication application;
+
+ tet_infoline("Test same case of UtcDaliShaderWithPrefixTestVersion with integration api");
+
+ std::string vertexShader =
+ "//@version 100\n"
+ "some code\n";
+ std::string fragmentShader =
+ "//@version 101\n"
+ "some code\n";
+
+ // Get prefix from graphics config.
+ auto vertexPrefix = application.GetGlAbstraction().GetVertexShaderPrefix();
+ auto fragmentPrefix = application.GetGlAbstraction().GetFragmentShaderPrefix();
+
+ // And use GenerateTaggedShaderPrefix from integration-api.
+ vertexPrefix = Dali::Integration::GenerateTaggedShaderPrefix(vertexPrefix);
+ fragmentPrefix = Dali::Integration::GenerateTaggedShaderPrefix(fragmentPrefix);
+
+ Dali::Shader shader = Dali::Shader::New(
+ vertexPrefix + vertexShader,
+ fragmentPrefix + fragmentShader);
+
+ DALI_TEST_EQUALS(vertexPrefix.substr(0, 20), "//@legacy-prefix-end", TEST_LOCATION);
+ DALI_TEST_EQUALS(fragmentPrefix.substr(0, 20), "//@legacy-prefix-end", TEST_LOCATION);
+
+ // Test version number in the shader data
+ Dali::Internal::ThreadLocalStorage& tls = Dali::Internal::ThreadLocalStorage::Get();
+ Dali::Internal::ShaderFactory& shaderFactory = tls.GetShaderFactory();
+ size_t shaderHash;
+ Internal::ShaderDataPtr shaderData = shaderFactory.Load(vertexShader, fragmentShader, {}, {}, "", shaderHash);
+
+ bool dataValid = (shaderData != nullptr);
+ DALI_TEST_EQUALS(dataValid, true, TEST_LOCATION);
+
+ DALI_TEST_EQUALS(shaderData->GetVertexShaderVersion(), 100, TEST_LOCATION);
+ DALI_TEST_EQUALS(shaderData->GetFragmentShaderVersion(), 101, TEST_LOCATION);
+
+ END_TEST;
+}
+
int UtcDaliInternalShaderSaveAndLoad01(void)
{
TestApplication application;
float TestCalculateChildSizeBase(const Dali::Actor& child, Dali::Dimension::Type dimension);
bool TestRelayoutDependentOnChildrenBase(Dali::Dimension::Type dimension);
+ void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward) override
+ {
+ }
+
public:
Dali::Property::Index mDaliProperty;
std::vector<std::string> mMethodsCalled;
{
return false;
}
+
+ void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward) override
+ {
+ }
};
} //namespace Impl
return texture;
}
+bool TestGraphicsController::HasClipMatrix() const
+{
+ return true;
+}
+
+const Matrix& TestGraphicsController::GetClipMatrix() const
+{
+ // This matrix transforms from GL -> Vulkan clip space
+ constexpr float VULKAN_CLIP_MATRIX_DATA[] = {
+ 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f, 0.0f, 0.0f, 0.0f, 0.5f, 1.0f};
+ static const Matrix VULKAN_CLIP_MATRIX(VULKAN_CLIP_MATRIX_DATA);
+ static const Matrix IDENTITY = Matrix::IDENTITY;
+
+ // For now, return IDENTITY to stay in GL clip space.
+ // @todo Add test toggle
+ return IDENTITY;
+}
+
} // namespace Dali
*/
Graphics::UniquePtr<Graphics::Texture> ReleaseTextureFromResourceId(uint32_t resourceId) override;
+ bool HasClipMatrix() const override;
+ const Matrix& GetClipMatrix() const override;
+
public: // Test Functions
void SetAutoAttrCreation(bool v)
{
uint32_t elementStrideInBytes)
{
TestGraphicsReflection::TestUniformInfo info;
- info.name = std::move(name);
- info.type = type;
- info.uniformClass = Graphics::UniformClass::UNIFORM;
- info.numElements = elementCount;
- info.locations = {0};
- info.bufferIndex = 0; // this will update when AddCustomUniformBlock called
-
- auto retval= GetUniformBufferArrayStrideAndTypeSize(info, elementStrideInBytes);
+ info.name = std::move(name);
+ info.type = type;
+ info.uniformClass = Graphics::UniformClass::UNIFORM;
+ info.numElements = elementCount;
+ info.locations = {0};
+ info.bufferIndex = 0; // this will update when AddCustomUniformBlock called
+
+ auto retval = GetUniformBufferArrayStrideAndTypeSize(info, elementStrideInBytes);
info.elementStride = std::max(retval.first, retval.second);
info.offsets = {blockInfo.size};
blockInfo.size += (elementCount == 0 ? 1 : elementCount) * std::max(retval.first, retval.second);
} // namespace Dali
-#endif //TEST_GRAPHICS_CONTROLLER_H
+#endif // TEST_GRAPHICS_CONTROLLER_H
/*
- * Copyright (c) 2020 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.
}
};
+class WorkerThreadWaitUntilN : public Thread
+{
+public:
+ WorkerThreadWaitUntilN()
+ : Thread()
+ {
+ auto now = std::chrono::steady_clock::now();
+ auto waitDuration = std::chrono::milliseconds(100); // 0.1 second
+
+ mWaitUntilTimePoint = std::chrono::time_point_cast<ConditionalWait::TimePoint::duration>(now + waitDuration);
+ }
+
+ virtual void Run()
+ {
+ ConditionalWait::ScopedLock lock(*gConditionalWait);
+
+ gConditionalWait->WaitUntil(lock, mWaitUntilTimePoint);
+ }
+
+private:
+ ConditionalWait::TimePoint mWaitUntilTimePoint;
+};
+
} // namespace
int UtcConditionalWait1P(void)
END_TEST;
}
+int UtcConditionalWaitUntilP1(void)
+{
+ tet_infoline("Testing ConditionalWait - scenario: waituntil now + 100 ms - with 4 threads. No notify");
+
+ auto utcStartTime = std::chrono::steady_clock::now();
+
+ // initialize values
+ gConditionalWait = new ConditionalWait();
+
+ WorkerThreadWaitUntilN thread1;
+ thread1.Start();
+ WorkerThreadWaitUntilN thread2;
+ thread2.Start();
+ WorkerThreadWaitUntilN thread3;
+ thread3.Start();
+ WorkerThreadWaitUntilN thread4;
+ thread4.Start();
+
+ // Let we check thread join well without any notification
+
+ thread1.Join();
+ thread2.Join();
+ thread3.Join();
+ thread4.Join();
+
+ DALI_TEST_EQUALS(0u, gConditionalWait->GetWaitCount(), TEST_LOCATION);
+
+ auto utcFinishedTime = std::chrono::steady_clock::now();
+
+ // Check thread join spened at least 100ms
+ auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(utcFinishedTime - utcStartTime).count();
+
+ DALI_TEST_GREATER(elapsedTime, static_cast<int64_t>(100 - 1), TEST_LOCATION); // 100ms is the minimum time for the threads to wait
+
+ delete gConditionalWait;
+ END_TEST;
+}
+
+int UtcConditionalWaitUntilP2(void)
+{
+ tet_infoline("Testing ConditionalWait - scenario: waituntil now + 100 ms - notify with 4 threads");
+
+ // initialize values
+ gConditionalWait = new ConditionalWait();
+
+ WorkerThreadWaitUntilN thread1;
+ thread1.Start();
+ WorkerThreadWaitUntilN thread2;
+ thread2.Start();
+ WorkerThreadWaitUntilN thread3;
+ thread3.Start();
+ WorkerThreadWaitUntilN thread4;
+ thread4.Start();
+
+ // Notify with scoped lock
+ {
+ ConditionalWait::ScopedLock lock(*gConditionalWait);
+ gConditionalWait->Notify(lock);
+ }
+
+ thread1.Join();
+ thread2.Join();
+ thread3.Join();
+ thread4.Join();
+
+ DALI_TEST_EQUALS(0u, gConditionalWait->GetWaitCount(), TEST_LOCATION);
+
+ delete gConditionalWait;
+ END_TEST;
+}
+
int UtcConditionalWaitNonCopyable(void)
{
// we want to make sure that ConditionalWait is not copyable (its copy constructor is not defined)
virtual void OnLayoutNegotiated(float size, Dimension::Type dimension)
{
}
+
+ void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward) override
+ {
+ }
};
} // namespace Impl
struct UnregisteredCustomActor : public Dali::CustomActor
END_TEST;
}
+
+namespace Impl
+{
+
+class OffScreenCustomActor : public UnregisteredCustomActor
+{
+public:
+ void OnSceneConnection(int depth) override
+ {
+ tet_printf("tyty : %d\n", GetOffScreenRenderableType());
+ Dali::Integration::Scene scene = Dali::Integration::Scene::Get(Self());
+ if(scene)
+ {
+ mScene = scene;
+ RenderTaskList taskList = scene.GetRenderTaskList();
+ mForwardRenderTask = taskList.CreateTask();
+ mBackwardRenderTask = taskList.CreateTask();
+ FrameBuffer forwardFrameBuffer = FrameBuffer::New(1, 1);
+ FrameBuffer backwardFrameBuffer = FrameBuffer::New(1, 1);
+
+ mForwardRenderTask.SetFrameBuffer(forwardFrameBuffer);
+ mBackwardRenderTask.SetFrameBuffer(backwardFrameBuffer);
+ }
+ }
+
+ void OnSceneDisconnection() override
+ {
+ Dali::Integration::Scene scene = mScene.GetHandle();
+ if(scene)
+ {
+ RenderTaskList taskList = scene.GetRenderTaskList();
+ taskList.RemoveTask(mForwardRenderTask);
+ taskList.RemoveTask(mBackwardRenderTask);
+ }
+ mForwardRenderTask.Reset();
+ mBackwardRenderTask.Reset();
+ mScene.Reset();
+ }
+
+ void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward) override
+ {
+ tasks.clear();
+ if(isForward && GetOffScreenRenderableType() & OffScreenRenderable::Type::FORWARD && mForwardRenderTask)
+ {
+ tasks.push_back(mForwardRenderTask);
+ }
+ if(!isForward && GetOffScreenRenderableType() & OffScreenRenderable::Type::BACKWARD && mBackwardRenderTask)
+ {
+ tasks.push_back(mBackwardRenderTask);
+ }
+ }
+
+ Dali::WeakHandle<Dali::Integration::Scene> mScene;
+ Dali::RenderTask mForwardRenderTask;
+ Dali::RenderTask mBackwardRenderTask;
+};
+
+} // namespace Impl
+
+class OffScreenCustomActor : public UnregisteredCustomActor
+{
+public:
+ static OffScreenCustomActor New(OffScreenRenderable::Type type)
+ {
+ Impl::OffScreenCustomActor* impl = new Impl::OffScreenCustomActor;
+ OffScreenCustomActor custom(*impl, type); // takes ownership
+ return custom;
+ }
+ OffScreenCustomActor()
+ {
+ }
+ ~OffScreenCustomActor()
+ {
+ }
+ OffScreenCustomActor(Internal::CustomActor* impl)
+ : UnregisteredCustomActor(impl)
+ {
+ }
+ OffScreenCustomActor(Impl::OffScreenCustomActor& impl, OffScreenRenderable::Type type)
+ : UnregisteredCustomActor(impl)
+ {
+ mImpl = &impl;
+ mImpl->SetOffScreenRenderableType(type);
+ }
+ Dali::RenderTask GetForwardRenderTask()
+ {
+ return mImpl->mForwardRenderTask;
+ }
+ Dali::RenderTask GetBackwardRenderTask()
+ {
+ return mImpl->mBackwardRenderTask;
+ }
+ OffScreenRenderable::Type GetOffScreenRenderableType()
+ {
+ tet_printf("type : %d\n", mImpl->GetOffScreenRenderableType());
+ return mImpl->GetOffScreenRenderableType();
+ }
+
+ Impl::OffScreenCustomActor* mImpl;
+};
+
+int UtcDaliCustomActorReordering(void)
+{
+ TestApplication application; // Need the type registry
+
+ DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 1, TEST_LOCATION);
+
+ /**
+ * Al
+ * / \
+ * Bb Cl
+ * / \ / \
+ * D Efb Jb K
+ * / \
+ * Fb Gf
+ * / \
+ * H I
+ *
+ * A, C are Layer. C has smaller Depth value than A.
+ * B, E, F, G, and J are OffScreenCustomActor.
+ * B, F, and J are Type BACKWARD.
+ * E and G are Type FORWARD.
+ *
+ * After reordering, The order of OrderIndex of each RenderTask becomes
+ * G(Forward) - F(Backward) - E(Forward) - J(BACKWARD) - B(BACKWARD) - E(BACKWARD)
+ */
+
+ Layer A_layer = Layer::New();
+ OffScreenCustomActor B_offScreenCustomActor = OffScreenCustomActor::New(OffScreenRenderable::Type::BACKWARD);
+ Layer C_layer = Layer::New();
+ Actor D_actor = Actor::New();
+ OffScreenCustomActor E_offScreenCustomActor = OffScreenCustomActor::New(OffScreenRenderable::Type::BOTH);
+ OffScreenCustomActor F_offScreenCustomActor = OffScreenCustomActor::New(OffScreenRenderable::Type::BACKWARD);
+ OffScreenCustomActor G_offScreenCustomActor = OffScreenCustomActor::New(OffScreenRenderable::Type::FORWARD);
+ Actor H_actor = Actor::New();
+ Actor I_actor = Actor::New();
+ OffScreenCustomActor J_offScreenCustomActor = OffScreenCustomActor::New(OffScreenRenderable::Type::BACKWARD);
+
+ A_layer.Add(B_offScreenCustomActor);
+ A_layer.Add(C_layer);
+ B_offScreenCustomActor.Add(D_actor);
+ B_offScreenCustomActor.Add(E_offScreenCustomActor);
+ E_offScreenCustomActor.Add(F_offScreenCustomActor);
+ E_offScreenCustomActor.Add(G_offScreenCustomActor);
+ G_offScreenCustomActor.Add(H_actor);
+ G_offScreenCustomActor.Add(I_actor);
+ C_layer.Add(J_offScreenCustomActor);
+
+ DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 1, TEST_LOCATION);
+ tet_printf("task cnt before : %d\n", application.GetScene().GetRenderTaskList().GetTaskCount());
+
+ application.GetScene().Add(A_layer);
+
+ DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 11, TEST_LOCATION);
+
+ C_layer.MoveBelow(A_layer);
+
+ application.GetScene().GetRenderTaskList().GetTaskCount();
+
+ tet_printf("task cnt after : %d\n", application.GetScene().GetRenderTaskList().GetTaskCount());
+ tet_printf("c depth : %d, a depth : %d\n", C_layer.GetProperty<int>(Dali::Layer::Property::DEPTH), A_layer.GetProperty<int>(Dali::Layer::Property::DEPTH));
+ tet_printf("c id : %d, a id : %d\n", C_layer.GetProperty<int>(Dali::Actor::Property::ID), A_layer.GetProperty<int>(Dali::Actor::Property::ID));
+
+ DALI_TEST_CHECK(C_layer.GetProperty<int>(Dali::Layer::Property::DEPTH) < A_layer.GetProperty<int>(Dali::Layer::Property::DEPTH));
+
+ application.SendNotification();
+
+ tet_printf("B task order F : %d, task order B : %d\n", B_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex(), B_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+ tet_printf("E task order F : %d, task order B : %d\n", E_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex(), E_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+ tet_printf("F task order F : %d, task order B : %d\n", F_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex(), F_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+ tet_printf("G task order F : %d, task order B : %d\n", G_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex(), G_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+ tet_printf("J task order F : %d, task order B : %d\n", J_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex(), J_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+
+ DALI_TEST_CHECK(G_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex() < F_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+ DALI_TEST_CHECK(F_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex() < E_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex());
+ DALI_TEST_CHECK(E_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex() < J_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+ DALI_TEST_CHECK(J_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex() < B_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+ DALI_TEST_CHECK(B_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex() < E_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+
+ END_TEST;
+}
\ No newline at end of file
RenderTask renderTask1 = renderTaskList.CreateTask();
application.SendNotification();
- uint32_t answer1[2] = {0u, 0u};
+ int32_t answer1[2] = {INT32_MIN, 0};
DALI_TEST_EQUALS(2, renderTaskList.GetTaskCount(), TEST_LOCATION);
for(uint32_t i = 0; i < 2; ++i)
{
RenderTask renderTask2 = renderTaskList.CreateTask();
application.SendNotification();
- int32_t answer2[3] = {0u, 0u, 0u};
+ int32_t answer2[3] = {INT32_MIN, 0, 0};
DALI_TEST_EQUALS(3, renderTaskList.GetTaskCount(), TEST_LOCATION);
for(uint32_t i = 0; i < 3; ++i)
{
RenderTask renderTask3 = renderTaskList.CreateTask();
application.SendNotification();
- int32_t answer3[4] = {0u, 0u, 0u, 0u};
+ int32_t answer3[4] = {INT32_MIN, 0, 0, 0};
DALI_TEST_EQUALS(4, renderTaskList.GetTaskCount(), TEST_LOCATION);
for(uint32_t i = 0; i < 4; ++i)
{
renderTask1.SetOrderIndex(3);
application.SendNotification();
- int32_t answer4[4] = {0u, 0u, 0u, 3u};
+ int32_t answer4[4] = {INT32_MIN, 0, 0, 3};
for(uint32_t i = 0; i < 4; ++i)
{
DALI_TEST_EQUALS(answer4[i], renderTaskList.GetTask(i).GetOrderIndex(), TEST_LOCATION);
renderTask2.SetOrderIndex(7);
application.SendNotification();
- int32_t answer5[4] = {0u, 0u, 3u, 7u};
+ int32_t answer5[4] = {INT32_MIN, 0, 3, 7};
for(uint32_t i = 0; i < 4; ++i)
{
DALI_TEST_EQUALS(answer5[i], renderTaskList.GetTask(i).GetOrderIndex(), TEST_LOCATION);
scene.GetOverlayLayer();
application.SendNotification();
DALI_TEST_EQUALS(5, renderTaskList.GetTaskCount(), TEST_LOCATION);
- int32_t answer6[5] = {0u, 0u, 3u, 7u, INT32_MAX};
+ int32_t answer6[5] = {INT32_MIN, 0, 3, 7, INT32_MAX};
for(uint32_t i = 0; i < 5; ++i)
{
DALI_TEST_EQUALS(answer6[i], renderTaskList.GetTask(i).GetOrderIndex(), TEST_LOCATION);
renderTask3.SetOrderIndex(4);
application.SendNotification();
- int32_t answer7[5] = {0u, 3u, 4u, 7u, INT32_MAX};
+ int32_t answer7[5] = {INT32_MIN, 3, 4, 7, INT32_MAX};
for(uint32_t i = 0; i < 5; ++i)
{
DALI_TEST_EQUALS(answer7[i], renderTaskList.GetTask(i).GetOrderIndex(), TEST_LOCATION);
renderTask2.SetOrderIndex(2);
application.SendNotification();
- int32_t answer8[5] = {0u, 2u, 3u, 4u, INT32_MAX};
+ int32_t answer8[5] = {INT32_MIN, 2, 3, 4, INT32_MAX};
for(uint32_t i = 0; i < 5; ++i)
{
DALI_TEST_EQUALS(answer8[i], renderTaskList.GetTask(i).GetOrderIndex(), TEST_LOCATION);
return false;
}
+ void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward) override
+ {
+ }
+
public:
SignalType mSignal;
};
return false;
}
+ void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward) override
+ {
+ }
+
public:
SignalType mSignal;
};
my $opt_man=0;
my $opt_vk_version="1.3.280.1";
my $opt_vulkan=undef;
-my $VULKAN_ENV="";
+my $opt_usd=0;
GetOptions("create" => \$opt_create,
"envfile=s" => \$opt_envfile,
"setenv" => \$opt_setenv,
"help" => \$opt_help,
"vulkan:s" => \$opt_vulkan,
+ "usd" => \$opt_usd,
"man" => \$opt_man) or pod2usage(2);
pod2usage(1) if $opt_help;
}
################################################################################
-sub vulkan_env
+sub download_archive
{
+ my ($archive, $url, $download_info) = @_;
+
+ # Avoid excessive downloading of the same file
+ if(! -e "/tmp/$archive")
+ {
+ print "Downloading $download_info\nfrom: $url\n";
+ system('wget','-P','/tmp',$url);
+ die "Can't download archive" if(! -e "/tmp/$archive");
+ }
+}
+
+sub untar_archive
+{
+ my $archive=shift;
+ system('tar','-xf',"/tmp/$archive", '--checkpoint=5000', '--checkpoint-action=ttyout=.');
}
sub install_vulkan
{
my $archive="vulkansdk-linux-x86_64-${opt_vk_version}.tar.xz";
my $url="https://sdk.lunarg.com/sdk/download/${opt_vk_version}/linux/$archive";
-
- # Avoid excessive downloading of the same file
- if(! -e "/tmp/$archive")
- {
- print "Downloading Vulkan SDK version ${opt_vk_version}\nfrom: $url\n";
- system('wget','-P','/tmp',$url);
- die "Can't download archive" if(! -e "/tmp/$archive");
- }
+ download_archive($archive, $url, "Vulkan SDK version ${opt_vk_version}");
my $vulkan_install_path="$root_path/vulkan";
- print "Unpacking archive\n";
+ print "Unpacking vulkan archive\n";
mkpath($vulkan_install_path);
chdir($vulkan_install_path);
- system('tar','-xf',"/tmp/$archive", '--checkpoint=5000', '--checkpoint-action=ttyout=.');
+ untar_archive($archive);
print("\n");
chdir("$root_path/..");
}
}
+sub install_usd
+{
+ if($opt_usd)
+ {
+ my $boost_archive="boost-1.84.0.tar.gz";
+ my $boost_url="https://github.com/boostorg/boost/releases/download/boost-1.84.0/$boost_archive";
+ download_archive($boost_archive, $boost_url, "Boost");
+
+ my $tbb_archive="2019_U9.tar.gz";
+ my $tbb_url="https://github.com/oneapi-src/oneTBB/archive/refs/tags/$tbb_archive";
+ download_archive($tbb_archive, $tbb_url, "LibTBB");
+
+ my $openusd_archive="32-bit-arm-and-tizen-support.tar.gz";
+ my $openusd_url="https://github.com/dalihub/OpenUSD/archive/refs/tags/$openusd_archive";
+ download_archive($openusd_archive, $openusd_url, "OpenUSD");
+
+ my $usd_install_path=$install_path;
+ my $usd_source_path="$src_path/usd";
+
+ print "Unpacking Boost, TBB & OpenUSD archives\n";
+ mkpath($usd_source_path);
+ chdir($usd_source_path);
+ untar_archive($boost_archive);
+ untar_archive($tbb_archive);
+ untar_archive($openusd_archive);
+
+ mkpath("$usd_install_path/lib");
+ mkpath("$usd_install_path/include");
+
+ my $boost_source_path="$usd_source_path/boost-1.84.0";
+ print "Building Boost\n";
+ chdir("$boost_source_path");
+ system('cmake',"-DCMAKE_INSTALL_PREFIX=$usd_install_path", '.');
+ system('make','-j8','install');
+
+ my $tbb_source_path="$usd_source_path/oneTBB-2019_U9";
+ print "Building TBB\n";
+ chdir("$tbb_source_path");
+ system('make','-j8');
+ my $tbbBuildFolder=`make info | grep tbb_build_prefix | cut -d= -f 2`;
+ chomp($tbbBuildFolder);
+ $tbbBuildFolder=$tbbBuildFolder . "_release";
+ print "$tbbBuildFolder Hello";
+ system("install -m 644 ./build/$tbbBuildFolder/*.so* $usd_install_path/lib/");
+ system('cp','-rf','include/tbb',"$usd_install_path/include/");
+
+ my $openusd_source_path="$usd_source_path/OpenUSD-32-bit-arm-and-tizen-support";
+ print "Building USD\n";
+ chdir("$openusd_source_path");
+ system('cmake',
+ '-DPXR_ENABLE_PYTHON_SUPPORT=OFF',
+ '-DPXR_ENABLE_PTEX_SUPPORT=OFF',
+ '-DPXR_ENABLE_OPENVDB_SUPPORT=OFF',
+ '-DPXR_ENABLE_HDF5_SUPPORT=OFF',
+ '-DPXR_ENABLE_MATERIALX_SUPPORT=OFF',
+ '-DPXR_BUILD_IMAGING=OFF',
+ '-DPXR_BUILD_USD_IMAGING=OFF',
+ '-DPXR_BUILD_USDVIEW=OFF',
+ '-DPXR_BUILD_DOCUMENTATION=OFF',
+ '-DPXR_BUILD_HTML_DOCUMENTATION=OFF',
+ '-DPXR_BUILD_PYTHON_DOCUMENTATION=OFF',
+ '-DPXR_BUILD_TESTS=OFF',
+ '-DPXR_BUILD_EXAMPLES=OFF',
+ '-DPXR_BUILD_TUTORIALS=OFF',
+ '-DPXR_BUILD_USD_TOOLS=OFF',
+ '-DPXR_BUILD_MAYAPY_TESTS=OFF',
+ '-DPXR_BUILD_ANIMX_TESTS=OFF',
+ "-DTBB_ROOT_DIR=$usd_install_path",
+ "-DBOOST_ROOT=$usd_install_path",
+ "-DCMAKE_INSTALL_PREFIX=$usd_install_path",
+ '.'
+ );
+ system('make','-j8','install');
+
+ print("\n");
+ chdir("$root_path/..");
+ }
+}
sub check_system_package
{
{
print "Attempting to build $pkg\n";
# from https://www.eriksmistad.no/getting-started-with-google-test-on-ubuntu/
- run_command("cd /usr/src/gtest; sudo cmake CMakeLists.txt; sudo make; sudo cp *.a /usr/lib; cd -;");
+ run_command("cd /usr/src/gtest; sudo cmake CMakeLists.txt; sudo make; sudo cp lib/*.a /usr/lib; cd -;");
}
}
}
check_source_packages();
install_vulkan();
+ install_usd();
create_setenv();
}
elsif($opt_setenv)
number. Adds several .pc files into dali-env/opt/lib/pkg-config directory,
and requires a new environment file to be written.
+=item B<-u|--usd>
+
+Installs the OpenUSD library and its dependencies.
+
=item B<-h|--help>
Display this help
/*
- * Copyright (c) 2020 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.
void ConditionalWait::Notify(const ScopedLock& scope)
{
// Scope must be locked:
- DALI_ASSERT_DEBUG(&scope.GetLockedWait() == this);
+ DALI_ASSERT_ALWAYS(&scope.GetLockedWait() == this);
volatile unsigned int previousCount = mImpl->count;
void ConditionalWait::Wait(const ScopedLock& scope)
{
// Scope must be locked:
- DALI_ASSERT_DEBUG(&scope.GetLockedWait() == this);
+ DALI_ASSERT_ALWAYS(&scope.GetLockedWait() == this);
++(mImpl->count);
// passed in will unlock it in the caller.
}
+void ConditionalWait::WaitUntil(const ScopedLock& scope, ConditionalWait::TimePoint timePoint)
+{
+ // Scope must be locked:
+ DALI_ASSERT_ALWAYS(&scope.GetLockedWait() == this);
+
+ ++(mImpl->count);
+
+ // conditional wait may wake up without anyone calling Notify
+ do
+ {
+ // wait while condition changes
+ if(mImpl->condition.wait_until(scope.mImpl->lock, timePoint) == std::cv_status::timeout)
+ {
+ // Pass-through for this wait request.
+ // Note that we should not wake-up other wait requests.
+ if(mImpl->count > 0u)
+ {
+ --mImpl->count;
+ }
+ }
+ } while(0 != mImpl->count);
+
+ // We return with our mutex locked safe in the knowledge that the ScopedLock
+ // passed in will unlock it in the caller.
+}
+
unsigned int ConditionalWait::GetWaitCount() const
{
return mImpl->count;
#define DALI_CONDITIONAL_WAIT_H
/*
- * Copyright (c) 2020 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.
*
*/
+// EXTERNAL INCLUDES
+#include <chrono> ///< for std::chrono::time_point
+
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
const ScopedLock& operator=(const ScopedLock&);
};
+ using TimePoint = std::chrono::time_point<std::chrono::steady_clock>;
+
/**
* @brief Constructor, creates the internal synchronization objects
*/
*/
void Wait(const ScopedLock& scope);
+ /**
+ * @brief Wait until specific time point or another thread to notify us when the condition is true and we can continue
+ *
+ * Will always block current thread until Notify is called.
+ * Assumes that the ScopedLock object passed in has already locked the internal state of
+ * this object. Releases the lock while waiting and re-acquires it when returning
+ * from the wait.
+ * @param[in] scope A pre-existing lock on the internal state of this object.
+ * @param[in] timePoint Maximum time point to wait.
+ * @pre scope must have been passed this ConditionalWait during its construction.
+ */
+ void WaitUntil(const ScopedLock& scope, TimePoint timePoint);
+
/**
* @brief Return the count of threads waiting for this conditional
* @return count of waits
*/
virtual UniquePtr<Graphics::Texture> ReleaseTextureFromResourceId(uint32_t resourceId) = 0;
+ /**
+ * @brief Determine if the backend needs to multiply the projection matrix by a clip matrix
+ *
+ * @return TRUE if the graphics backend requires an alternative clip matrix
+ */
+ virtual bool HasClipMatrix() const = 0;
+
+ /**
+ * @brief Get the alternative clipping matrix.
+ *
+ * @return the clipping matrix
+ */
+ virtual const Matrix& GetClipMatrix() const = 0;
+
protected:
/**
* Creates controller
float width = 0.0f;
float height = 0.0f;
float minDepth = 0.0f;
- float maxDepth = 0.0f;
+ float maxDepth = 1.0f;
};
/**
${platform_abstraction_src_dir}/profiling.cpp
${platform_abstraction_src_dir}/render-task-list-integ.cpp
${platform_abstraction_src_dir}/scene.cpp
+ ${platform_abstraction_src_dir}/shader-integ.cpp
${platform_abstraction_src_dir}/testing.cpp
${platform_abstraction_src_dir}/texture-integ.cpp
${platform_abstraction_src_dir}/trace.cpp
${platform_abstraction_src_dir}/resource-policies.h
${platform_abstraction_src_dir}/resource-types.h
${platform_abstraction_src_dir}/scene.h
+ ${platform_abstraction_src_dir}/shader-integ.h
${platform_abstraction_src_dir}/testing.h
${platform_abstraction_src_dir}/texture-integ.h
${platform_abstraction_src_dir}/trace.h
--- /dev/null
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// FILE HEADER
+#include <dali/integration-api/shader-integ.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/event/rendering/shader-impl.h>
+
+namespace Dali::Integration
+{
+std::string GenerateTaggedShaderPrefix(const std::string& shaderPrefix)
+{
+ return Dali::Internal::Shader::GenerateTaggedShaderPrefix(shaderPrefix);
+}
+} // namespace Dali::Integration
--- /dev/null
+#ifndef DALI_SHADER_INTEG_H
+#define DALI_SHADER_INTEG_H
+
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <string> // std::string
+
+// INTERNAL INCLUDES
+#include <dali/public-api/rendering/shader.h>
+
+namespace Dali::Integration
+{
+/**
+ * @brief Generates tag 'legacy-prefix-end' with end position of
+ * prefix text to make shader code parsing easier.
+ *
+ * @SINCE_2_3.43
+ * @return Generated string with tag.
+ */
+DALI_CORE_API std::string GenerateTaggedShaderPrefix(const std::string& shaderPrefix);
+
+} // namespace Dali::Integration
+
+#endif // DALI_SHADER_INTEG_H
scene->RebuildDepthTree();
}
+ // process events in all scenes
+ for(auto scene : scenes)
+ {
+ auto& renderTaskList = scene->GetRenderTaskList();
+ renderTaskList.ReorderTasks(scene->GetLayerList());
+ }
+
// Flush any queued messages for the update-thread
const bool messagesToProcess = mUpdateManager->FlushQueue();
{
if(mProcessorsOnce[mProcessorOnceIndex].Count() != 0)
{
- DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSORS_ONCE", [&](std::ostringstream& oss) {
- oss << "[" << mProcessorOnceIndex << ":" << mProcessorsOnce[mProcessorOnceIndex].Count() << "]";
- });
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSORS_ONCE", [&](std::ostringstream& oss)
+ { oss << "[" << mProcessorOnceIndex << ":" << mProcessorsOnce[mProcessorOnceIndex].Count() << "]"; });
// Swap processor index.
uint32_t currentIndex = mProcessorOnceIndex;
// Clear once processor.
mProcessorsOnce[currentIndex].Clear();
- DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSORS_ONCE", [&](std::ostringstream& oss) {
+ DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSORS_ONCE", [&](std::ostringstream& oss)
+ {
oss << "[" << currentIndex;
if(mProcessorUnregistered)
{
oss << ", processor changed";
}
- oss << "]";
- });
+ oss << "]"; });
}
if(mProcessors.Count() != 0)
{
- DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSORS", [&](std::ostringstream& oss) {
- oss << "[" << mProcessors.Count() << "]";
- });
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSORS", [&](std::ostringstream& oss)
+ { oss << "[" << mProcessors.Count() << "]"; });
// Copy processor pointers to prevent changes to vector affecting loop iterator.
Dali::Vector<Integration::Processor*> processors(mProcessors);
{
if(!mProcessorUnregistered)
{
- DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSOR", [&](std::ostringstream& oss) {
- oss << "[" << processor->GetProcessorName() << "]";
- });
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSOR", [&](std::ostringstream& oss)
+ { oss << "[" << processor->GetProcessorName() << "]"; });
processor->Process(false);
- DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSOR", [&](std::ostringstream& oss) {
- oss << "[" << processor->GetProcessorName() << "]";
- });
+ DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSOR", [&](std::ostringstream& oss)
+ { oss << "[" << processor->GetProcessorName() << "]"; });
}
else
{
auto iter = std::find(mProcessors.Begin(), mProcessors.End(), processor);
if(iter != mProcessors.End())
{
- DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSOR", [&](std::ostringstream& oss) {
- oss << "[" << processor->GetProcessorName() << "]";
- });
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSOR", [&](std::ostringstream& oss)
+ { oss << "[" << processor->GetProcessorName() << "]"; });
processor->Process(false);
- DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSOR", [&](std::ostringstream& oss) {
- oss << "[" << processor->GetProcessorName() << "]";
- });
+ DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSOR", [&](std::ostringstream& oss)
+ { oss << "[" << processor->GetProcessorName() << "]"; });
}
}
}
}
- DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSORS", [&](std::ostringstream& oss) {
+ DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_PROCESSORS", [&](std::ostringstream& oss)
+ {
oss << "[" << mProcessors.Count();
if(mProcessorUnregistered)
{
oss << ", processor changed";
}
- oss << "]";
- });
+ oss << "]"; });
}
}
{
if(mPostProcessorsOnce[mPostProcessorOnceIndex].Count() != 0)
{
- DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS_ONCE", [&](std::ostringstream& oss) {
- oss << "[" << mPostProcessorOnceIndex << ":" << mPostProcessorsOnce[mPostProcessorOnceIndex].Count() << "]";
- });
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS_ONCE", [&](std::ostringstream& oss)
+ { oss << "[" << mPostProcessorOnceIndex << ":" << mPostProcessorsOnce[mPostProcessorOnceIndex].Count() << "]"; });
// Swap processor index.
uint32_t currentIndex = mPostProcessorOnceIndex;
// Clear once processor.
mPostProcessorsOnce[currentIndex].Clear();
- DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS_ONCE", [&](std::ostringstream& oss) {
+ DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS_ONCE", [&](std::ostringstream& oss)
+ {
oss << "[" << currentIndex;
if(mPostProcessorUnregistered)
{
oss << ", processor changed";
}
- oss << "]";
- });
+ oss << "]"; });
}
if(mPostProcessors.Count() != 0)
{
- DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS", [&](std::ostringstream& oss) {
- oss << "[" << mPostProcessors.Count() << "]";
- });
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS", [&](std::ostringstream& oss)
+ { oss << "[" << mPostProcessors.Count() << "]"; });
// Copy processor pointers to prevent changes to vector affecting loop iterator.
Dali::Vector<Integration::Processor*> processors(mPostProcessors);
{
if(!mPostProcessorUnregistered)
{
- DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSOR", [&](std::ostringstream& oss) {
- oss << "[" << processor->GetProcessorName() << "]";
- });
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSOR", [&](std::ostringstream& oss)
+ { oss << "[" << processor->GetProcessorName() << "]"; });
processor->Process(true);
- DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSOR", [&](std::ostringstream& oss) {
- oss << "[" << processor->GetProcessorName() << "]";
- });
+ DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSOR", [&](std::ostringstream& oss)
+ { oss << "[" << processor->GetProcessorName() << "]"; });
}
else
{
auto iter = std::find(mPostProcessors.Begin(), mPostProcessors.End(), processor);
if(iter != mPostProcessors.End())
{
- DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSOR", [&](std::ostringstream& oss) {
- oss << "[" << processor->GetProcessorName() << "]";
- });
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSOR", [&](std::ostringstream& oss)
+ { oss << "[" << processor->GetProcessorName() << "]"; });
processor->Process(true);
- DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSOR", [&](std::ostringstream& oss) {
- oss << "[" << processor->GetProcessorName() << "]";
- });
+ DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSOR", [&](std::ostringstream& oss)
+ { oss << "[" << processor->GetProcessorName() << "]"; });
}
}
}
}
- DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS", [&](std::ostringstream& oss) {
+ DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS", [&](std::ostringstream& oss)
+ {
oss << "[" << mPostProcessors.Count();
if(mPostProcessorUnregistered)
{
oss << ", processor changed";
}
- oss << "]";
- });
+ oss << "]"; });
}
}
/*
- * Copyright (c) 2023 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.
uint16_t width; ///< image width in pixels
uint16_t height; ///< image height in pixels
- ScalingMode scaling : 3; ///< scaling option, ShrinkToFit is default
- FilterMode filtering : 4; ///< filtering option. Box is the default
+ ScalingMode scaling : 4; ///< scaling option, ShrinkToFit is default
+ FilterMode filtering : 5; ///< filtering option. Box is the default
bool mOrientationCorrection : 1; ///< If true, image pixels are reordered according to orientation metadata on load.
};
return mParentImpl.ChildOrderChangedSignal();
}
+void Actor::GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward)
+{
+}
+
+void Actor::SetOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType)
+{
+ mOffScreenRenderableType = offScreenRenderableType;
+}
+
+OffScreenRenderable::Type Actor::GetOffScreenRenderableType() const
+{
+ return mOffScreenRenderableType;
+}
+
+void Actor::RequestRenderTaskReorder()
+{
+ if(mScene && GetOffScreenRenderableType() != OffScreenRenderable::Type::NONE)
+ {
+ mScene->GetRenderTaskList().RequestReorder();
+ }
+}
+
Actor::Actor(DerivedType derivedType, const SceneGraph::Node& node)
: Object(&node),
mParentImpl(*this),
mColorMode(Node::DEFAULT_COLOR_MODE),
mClippingMode(ClippingMode::DISABLED),
mHoverState(PointState::FINISHED),
- mBlendEquation(DevelBlendEquation::ADD)
+ mBlendEquation(DevelBlendEquation::ADD),
+ mOffScreenRenderableType(OffScreenRenderable::Type::NONE)
{
}
#include <string>
// INTERNAL INCLUDES
-#include <dali/public-api/actors/actor.h>
-#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/common/vector-wrapper.h>
-#include <dali/public-api/events/gesture.h>
-#include <dali/public-api/math/viewport.h>
-#include <dali/public-api/object/ref-object.h>
-#include <dali/public-api/size-negotiation/relayout-container.h>
-
#include <dali/devel-api/actors/actor-devel.h>
#include <dali/devel-api/rendering/renderer-devel.h>
-
#include <dali/integration-api/events/touch-event-integ.h>
-
#include <dali/internal/common/const-string.h>
#include <dali/internal/common/internal-constants.h>
#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/event/common/object-impl.h>
#include <dali/internal/event/common/stage-def.h>
#include <dali/internal/update/nodes/node-declarations.h>
+#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/public-api/events/gesture.h>
+#include <dali/public-api/math/viewport.h>
+#include <dali/public-api/object/ref-object.h>
+#include <dali/public-api/render-tasks/render-task.h>
+#include <dali/public-api/size-negotiation/relayout-container.h>
namespace Dali
{
{
}
+public:
+ // For Internal RenderTask Ordering
+
+ /**
+ * @brief Retrieves the off-screen RenderTasks associated with the Actor.
+ * This method returns the internal RenderTasks held by the Actor. This tasks are
+ * used for off-screen rendering, and the system will assign order index to each
+ * tasks based on the render order.
+ *
+ * Actor with a non-NONE OffScreenRenderableType should override this method to
+ * provide their render tasks.
+ *
+ * @param[out] tasks A list of RenderTasks to be populated with the Actor's forward
+ * or backward off-screen RenderTask.
+ * @param[in] isForward Indicates whether to retrieve forward (true) or backward (false)
+ * RenderTasks.
+ */
+ virtual void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward);
+
+ /**
+ * @brief Sets OffScreenRenderableType of this Actor.
+ * This method is called by child class to set type itself.
+ *
+ * @param[in] offScreenRenderableType OffScreenRenderableType for this Actor.
+ * It could be one of NONE, FORWARD, BACKWARD, and BOTH.
+ */
+ void SetOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType);
+
+ /**
+ * @brief Retrieves OffScreenRenderableType of this Actor.
+ *
+ * @return OffScreenRenderableType for this Actor.
+ */
+ OffScreenRenderable::Type GetOffScreenRenderableType() const;
+
+ /**
+ * @brief Requests RenderTask reordering when the offscreen properties of this Actor are changed.
+ */
+ void RequestRenderTaskReorder();
+
protected:
enum DerivedType
{
private:
static ActorContainer mNullChildren; ///< Empty container (shared by all actors, returned by GetChildren() const)
+ // OffScreenRenderable
+ OffScreenRenderable::Type mOffScreenRenderableType;
+
struct PropertyHandler;
struct SiblingHandler;
mOwner.mLayer3DParentsCount = static_cast<uint16_t>(layer3DParentsCount); // overflow ignored, not expected in practice
mOwner.ConnectToSceneGraph();
+ mOwner.RequestRenderTaskReorder();
+
// Notification for internal derived classes
mOwner.OnSceneConnectionInternal();
mImpl->OnSizeAnimation(animationHandle, targetSize);
}
+ void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward)
+ {
+ mImpl->GetOffScreenRenderTasks(tasks, isForward);
+ }
+
/**
* @copydoc Internal::Actor::OnRelayout
*/
// Create the default render-task and ensure clear is enabled on it to show the background color
RenderTaskPtr renderTask = mRenderTaskList->CreateTask(mRootLayer.Get(), mDefaultCamera.Get());
+ renderTask->SetOrderIndex(INT32_MIN);
renderTask->SetClearEnabled(true);
// Create scene graph object
{
const char* VERSION_SEPARATOR = "-";
const char* SHADER_SUFFIX = ".dali-bin";
+
+constexpr uint32_t MAXIMUM_STRING_SHADER_DATA_CACHE_CLEAN_THRESHOLD = 128u;
} // namespace
namespace Dali
}
else
{
+ if(DALI_UNLIKELY(mTotalStringCachedShadersCount >= MAXIMUM_STRING_SHADER_DATA_CACHE_CLEAN_THRESHOLD))
+ {
+ // Reset string cache, to avoid memory leak problem.
+ ResetStringShaderData();
+ }
auto& cacheList = mShaderStringCache[shaderHash]; ///< Get or create a new cache list.
// Ignore shaderdata with string if it already exists:
}
shaderData.Reference();
cacheList.PushBack(&shaderData);
+
+ ++mTotalStringCachedShadersCount;
DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "CACHED NON-BINARY SHADER FOR HASH: %u, HINT: %d, TAG: %u\n", shaderHash, static_cast<int>(shaderData.GetHints()), shaderData.GetRenderPassTag());
}
}
// Reduce reference before erase
(*iter)->Unreference();
cacheList.Erase(iter);
+
+ --mTotalStringCachedShadersCount;
break;
}
}
}
}
+void ShaderFactory::ResetStringShaderData()
+{
+ DALI_LOG_RELEASE_INFO("Trigger StringShaderData GC. shader : [%u]\n", mTotalStringCachedShadersCount);
+ for(auto&& iter : mShaderStringCache)
+ {
+ auto& cacheList = iter.second;
+ for(auto&& shaderData : cacheList)
+ {
+ shaderData->Unreference();
+ }
+ }
+
+ // Reset cache after unreference.
+ mShaderStringCache.clear();
+
+ mTotalStringCachedShadersCount = 0u;
+ DALI_LOG_RELEASE_INFO("StringShaderData GC done\n");
+}
+
} // namespace Internal
} // namespace Dali
*/
void RemoveStringShaderData(Internal::ShaderData& shaderData);
+ /**
+ * @brief Remove all the string shader data from the cache.
+ */
+ void ResetStringShaderData();
+
// Undefined
ShaderFactory(const ShaderFactory&) = delete;
ShaderCacheContainer mShaderBinaryCache; ///< Cache of pre-compiled shaders.
ShaderCacheContainer mShaderStringCache; ///< Cache of non-pre-compiled shaders. (TODO : Could we clean up this cache by user management?)
+ uint32_t mTotalStringCachedShadersCount{0u}; ///< Total number of cached shaders that are not pre-compiled.
+
}; // class ShaderFactory
inline MessageBase* ShaderCompiledMessage(ShaderSaver& factory, Internal::ShaderDataPtr shaderData)
{
namespace Internal
{
+
+typedef std::vector<Actor*> OffScreenRenderableContainer;
+typedef std::pair<Actor*, OffScreenRenderableContainer> ForwardOffScreenRenderableSubTree;
+typedef std::vector<ForwardOffScreenRenderableSubTree> OffScreenRenderableData;
+
namespace
{
static constexpr uint32_t ORDER_INDEX_OVERLAY_RENDER_TASK = INT32_MAX;
mIsRequestedToSortTask = false;
}
+bool IsWithinSourceActors(const Actor& sourceActor, Actor& actor)
+{
+ bool isInside = false;
+ Actor* currentActor = &actor;
+ while(currentActor)
+ {
+ if(&sourceActor == currentActor)
+ {
+ isInside = true;
+ break;
+ }
+
+ if(currentActor->GetOffScreenRenderableType() & OffScreenRenderable::Type::FORWARD)
+ {
+ isInside = false;
+ break;
+ }
+ currentActor = currentActor->GetParent();
+ }
+ return isInside;
+}
+
+void FindOffScreenRenderableWithinSubTree(Actor& rootActor, Actor& actor, uint32_t subTreeIndex, std::vector<Actor*>& onScreenSources, OffScreenRenderableData& renderableData, std::vector<bool>& traverseFinished)
+{
+ if(&actor != renderableData[subTreeIndex].first)
+ {
+
+ // New BACKWARD OffScreen Renderable
+ if(actor.GetOffScreenRenderableType() & OffScreenRenderable::Type::BACKWARD)
+ {
+ renderableData[subTreeIndex].second.push_back(&actor);
+ }
+
+ // New FORWARD OffScreen Renderable. It makes new subTree.
+ if(actor.GetOffScreenRenderableType() & OffScreenRenderable::Type::FORWARD)
+ {
+ ForwardOffScreenRenderableSubTree newSubTree;
+ newSubTree.first = &actor;
+ renderableData.push_back(newSubTree);
+ traverseFinished.push_back(false);
+ return;
+ }
+
+ // OnScreen Source and its child will be traversed by next loop.
+ if(std::find(onScreenSources.begin(), onScreenSources.end(), &actor) != onScreenSources.end())
+ {
+ return;
+ }
+
+ if(rootActor.GetId() != actor.GetId() && actor.GetLayer().GetProperty<int32_t>(Dali::Actor::Property::ID) == static_cast<int32_t>(actor.GetId()))
+ {
+ return;
+ }
+ }
+
+ uint32_t childCount = actor.GetChildCount();
+ for(uint32_t i = 0; i < childCount; ++i)
+ {
+ auto child = actor.GetChildAt(i);
+ FindOffScreenRenderableWithinSubTree(rootActor, *(child.Get()), subTreeIndex, onScreenSources, renderableData, traverseFinished);
+ }
+}
+
+void RenderTaskList::ReorderTasks(Dali::Internal::LayerList& layerList)
+{
+ if(mIsRequestedToReorderTask)
+ {
+ std::vector<bool> traverseFinished;
+ OffScreenRenderableData renderableData;
+ uint32_t layerCount = layerList.GetLayerCount();
+ uint32_t taskCount = GetTaskCount();
+ std::vector<Actor*> onScreenSources;
+ for(uint32_t i = 0; i < taskCount; ++i)
+ {
+ auto renderTask = GetTask(i);
+ if(!renderTask->GetFrameBuffer())
+ {
+ onScreenSources.push_back(renderTask->GetSourceActor());
+ }
+ }
+
+ for(uint32_t i = 0; i < taskCount; ++i)
+ {
+ auto renderTask = GetTask(i);
+ if(renderTask->GetFrameBuffer())
+ {
+ continue;
+ }
+
+ auto* sourceActor = renderTask->GetSourceActor();
+ ForwardOffScreenRenderableSubTree subTree;
+ subTree.first = sourceActor;
+ renderableData.push_back(subTree);
+ traverseFinished.push_back(false);
+
+ uint32_t currentSubTreeIndex = 0;
+ Actor* root = subTree.first;
+ while(root)
+ {
+ Dali::Layer sourceLayer = root->GetLayer();
+ const uint32_t sourceLayerDepth = sourceLayer.GetProperty<int32_t>(Dali::Layer::Property::DEPTH);
+ for(uint32_t currentLayerIndex = 0; currentLayerIndex < layerCount; ++currentLayerIndex)
+ {
+ auto* layer = layerList.GetLayer(currentLayerIndex);
+ Dali::Internal::Actor* rootActor = nullptr;
+ if(sourceLayerDepth == currentLayerIndex)
+ {
+ rootActor = root;
+ }
+ else
+ {
+ if(!IsWithinSourceActors(*root, *layer))
+ {
+ continue;
+ }
+ rootActor = layer;
+ }
+ FindOffScreenRenderableWithinSubTree(*rootActor, *rootActor, currentSubTreeIndex, onScreenSources, renderableData, traverseFinished);
+ }
+
+ traverseFinished[currentSubTreeIndex] = true;
+
+ root = nullptr;
+ for(currentSubTreeIndex = 0; currentSubTreeIndex < traverseFinished.size(); ++currentSubTreeIndex)
+ {
+ if(!traverseFinished[currentSubTreeIndex])
+ {
+ root = renderableData[currentSubTreeIndex].first;
+ break;
+ }
+ }
+ }
+ }
+
+ // Default Task should have the lowest OrderIndex number.
+ int32_t orderIndex = GetTask(0u)->GetOrderIndex();
+ uint32_t subTreeCount = renderableData.size();
+ for(uint32_t i = subTreeCount - 1; i < subTreeCount; --i)
+ {
+ auto subTree = renderableData[i];
+ for(auto&& actor : subTree.second)
+ {
+ std::vector<Dali::RenderTask> tasks;
+ actor->GetOffScreenRenderTasks(tasks, false);
+ for(auto&& task : tasks)
+ {
+ GetImplementation(task).SetOrderIndex(orderIndex++);
+ }
+ }
+
+ if(subTree.first && subTree.first->GetOffScreenRenderableType() & OffScreenRenderable::Type::FORWARD)
+ {
+ std::vector<Dali::RenderTask> tasks;
+ subTree.first->GetOffScreenRenderTasks(tasks, true);
+ for(auto&& task : tasks)
+ {
+ GetImplementation(task).SetOrderIndex(orderIndex++);
+ }
+ }
+ }
+
+ SortTasks();
+ }
+ mIsRequestedToReorderTask = false;
+}
+
RenderTaskList::RenderTaskList()
: mEventThreadServices(EventThreadServices::Get()),
mDefaults(*Stage::GetCurrent()),
#include <dali/public-api/object/base-object.h>
#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/internal/event/actors/layer-list.h>
#include <dali/internal/event/common/complete-notification-interface.h>
#include <dali/internal/event/common/scene-graph-notifier-interface-mapper.h>
#include <dali/internal/event/events/actor-observer.h>
*/
void SortTasks();
+ /**
+ * @brief Requests to reorder the RenderTasks of this RenderTaskList.
+ */
+ void RequestReorder()
+ {
+ mIsRequestedToReorderTask = true;
+ }
+
+ /**
+ * @brief Reorder RenderTasks along the priority of OffScreenRenderableType of each Actor.
+ *
+ * @param[in] layerList layerList that used for tasks reordering.
+ */
+ void ReorderTasks(Dali::Internal::LayerList& layerList);
+
/**
* Provide notification signals for a "Finished" render task.
* This method should be called in the event-thread
RenderTaskPtr mOverlayRenderTask{nullptr};
bool mIsRequestedToSortTask{false};
+ bool mIsRequestedToReorderTask{false};
};
} // namespace Internal
std::string Shader::GetVertexShaderPrefix()
{
Dali::Internal::ThreadLocalStorage& tls = Dali::Internal::ThreadLocalStorage::Get();
- return tls.GetVertexShaderPrefix();
+ return GenerateTaggedShaderPrefix(tls.GetVertexShaderPrefix());
}
std::string Shader::GetFragmentShaderPrefix()
{
Dali::Internal::ThreadLocalStorage& tls = Dali::Internal::ThreadLocalStorage::Get();
- return tls.GetFragmentShaderPrefix();
+ return GenerateTaggedShaderPrefix(tls.GetFragmentShaderPrefix());
}
std::string Shader::GenerateTaggedShaderPrefix(const std::string& shaderPrefix)
/**
* Generates tag 'legacy-prefix-end' with end position of
* prefix text to make shader code parsing easier.
- * Function is public to be testable
+ * Function is public to be testable and integration api.
*/
static std::string GenerateTaggedShaderPrefix(const std::string& shaderPrefix);
};
{
namespace
{
+
struct GraphicsDepthCompareOp
{
constexpr explicit GraphicsDepthCompareOp(DepthFunction::Type compareOp)
inline Graphics::Viewport ViewportFromClippingBox(const Uint16Pair& sceneSize, ClippingBox clippingBox, int orientation)
{
- Graphics::Viewport viewport{static_cast<float>(clippingBox.x), static_cast<float>(clippingBox.y), static_cast<float>(clippingBox.width), static_cast<float>(clippingBox.height), 0.0f, 0.0f};
+ Graphics::Viewport viewport{static_cast<float>(clippingBox.x), static_cast<float>(clippingBox.y), static_cast<float>(clippingBox.width), static_cast<float>(clippingBox.height), 0.0f, 1.0f};
if(orientation == 90 || orientation == 270)
{
viewport.x = sceneSize.GetX() - (clippingBox.x + clippingBox.width);
viewport.y = sceneSize.GetY() - (clippingBox.y + clippingBox.height);
}
+ viewport.minDepth = 0;
+ viewport.maxDepth = 1;
return viewport;
}
// Add root clipping rect (set manually for Render function by partial update for example)
// on the bottom of the stack
+ Graphics::Viewport graphicsViewport = ViewportFromClippingBox(sceneSize, mViewportRectangle, 0);
if(!rootClippingRect.IsEmpty())
{
- Graphics::Viewport graphicsViewport = ViewportFromClippingBox(sceneSize, mViewportRectangle, 0);
secondaryCommandBuffer.SetScissorTestEnable(true);
secondaryCommandBuffer.SetScissor(Rect2DFromRect(rootClippingRect, orientation, graphicsViewport));
mScissorStack.push_back(rootClippingRect);
else if(!renderList.IsClipping())
{
secondaryCommandBuffer.SetScissorTestEnable(false);
+ //@todo Vk requires a scissor to be set, as we have turned on dynamic state scissor in the pipelines.
+ secondaryCommandBuffer.SetScissor(Rect2DFromClippingBox(mViewportRectangle, orientation, graphicsViewport));
mScissorStack.push_back(mViewportRectangle);
}
if(renderList.IsClipping())
{
- Graphics::Viewport graphicsViewport = ViewportFromClippingBox(sceneSize, mViewportRectangle, 0);
secondaryCommandBuffer.SetScissorTestEnable(true);
const ClippingBox& layerScissorBox = renderList.GetClippingBox();
secondaryCommandBuffer.SetScissor(Rect2DFromClippingBox(layerScissorBox, orientation, graphicsViewport));
// Prepare Render::Renderer Render for this secondary command buffer.
Renderer::PrepareCommandBuffer();
+ // Modify by the clip matrix if necessary (transforms from GL clip space to alternative clip space)
+ Matrix clippedProjectionMatrix(projectionMatrix);
+ if(mGraphicsController.HasClipMatrix())
+ {
+ Matrix::Multiply(clippedProjectionMatrix, projectionMatrix, mGraphicsController.GetClipMatrix());
+ }
+
// Loop through all RenderItems in the RenderList, set up any prerequisites to render them, then perform the render.
for(uint32_t index = 0u; index < count; ++index)
{
for(auto queue = 0u; queue < MAX_QUEUE; ++queue)
{
// Render the item. It will write into the command buffer everything it has to render
- item.mRenderer->Render(secondaryCommandBuffer, bufferIndex, *item.mNode, item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mScale, item.mSize, !item.mIsOpaque, instruction, renderTarget, queue);
+ item.mRenderer->Render(secondaryCommandBuffer, bufferIndex, *item.mNode, item.mModelMatrix, item.mModelViewMatrix, viewMatrix, clippedProjectionMatrix, item.mScale, item.mSize, !item.mIsOpaque, instruction, renderTarget, queue);
}
}
}
{
iter->type = Graphics::ResourceType::PROGRAM;
iter->programBinding = &item.second;
+ ++iter;
}
}
scissorArea,
currentClearValues);
- mainCommandBuffer->SetViewport({float(viewportRect.x),
- float(viewportRect.y),
- float(viewportRect.width),
- float(viewportRect.height)});
+ // Note, don't set the viewport/scissor on the primary command buffer.
mImpl->renderAlgorithms.ProcessRenderInstruction(
instruction,
if(targetsToPresent.size() > 0u)
{
- DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_RENDER_FINISHED", [&](std::ostringstream& oss) { oss << "[" << targetsToPresent.size() << "]"; });
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_RENDER_FINISHED", [&](std::ostringstream& oss)
+ { oss << "[" << targetsToPresent.size() << "]"; });
}
// Flush UBOs
} // namespace LayoutDirection
+/**
+ * @brief Enumeration for the OffScreenRenderable of the Actor
+ * @SINCE_2_3.43
+ */
+namespace OffScreenRenderable
+{
+enum Type
+{
+ NONE = 0, // The Actor has no OffScreenRenderables. @SINCE_2_3.43
+ FORWARD = 1, // The Actor has RenderTasks those need reorder. And the Tasks will draw Actors those placed in front of the Actor. @SINCE_2_3.43
+ BACKWARD = 2, // The Actor has RenderTasks those need reorder, And the Tasks will draw Actors those placed behinde of the Actor. @SINCE_2_3.43
+ BOTH = FORWARD | BACKWARD, // The Actor has RenderTasks for the both of FORWARD and BACKWARD. @SINCE_2_3.43
+};
+} // namespace OffScreenRenderables
+
/**
* @}
*/
{
}
+void CustomActorImpl::SetOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType)
+{
+ mOwner->SetOffScreenRenderableType(offScreenRenderableType);
+}
+
+OffScreenRenderable::Type CustomActorImpl::GetOffScreenRenderableType()
+{
+ return mOwner->GetOffScreenRenderableType();
+}
+
+void CustomActorImpl::RequestRenderTaskReorder()
+{
+ mOwner->RequestRenderTaskReorder();
+}
+
CustomActorImpl::CustomActorImpl(ActorFlags flags)
: mOwner(nullptr),
mFlags(flags)
// INTERNAL INCLUDES
#include <dali/public-api/actors/actor-enumerations.h>
+#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/math/compile-time-math.h>
#include <dali/public-api/object/property.h>
#include <dali/public-api/object/ref-object.h>
+#include <dali/public-api/render-tasks/render-task.h>
namespace Dali
{
class CustomActor;
}
-class Actor;
class Animation;
class CustomActor;
class CustomActorImpl;
*/
virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize) = 0;
+ /**
+ * @brief Retrieves the off-screen RenderTasks associated with the Actor.
+ * This method returns the internal RenderTasks held by the Actor. This tasks are
+ * used for off-screen rendering, and the system will assign order index to each
+ * tasks based on the render order.
+ *
+ * Actor with a non-NONE OffScreenRenderableType should override this method to
+ * provide their render tasks.
+ *
+ * @SINCE_2_3.43
+ * @param[out] tasks A list of RenderTasks to be populated with the Actor's forward
+ * or backward off-screen RenderTask.
+ * @param[in] isForward Indicates whether to retrieve forward (true) or backward (false)
+ * RenderTasks.
+ */
+ virtual void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward) = 0;
+
+ /**
+ * @brief Sets OffScreenRenderableType of this Actor.
+ * This method is called by child class to set type itself.
+ *
+ * @SINCE_2_3.43
+ * @param[in] offScreenRenderableType OffScreenRenderableType for this Actor.
+ * It could be one of NONE, FORWARD, BACKWARD, and BOTH.
+ */
+ void SetOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType);
+
+ /**
+ * @brief Retrieves OffScreenRenderableType of this Actor.
+ *
+ * @SINCE_2_3.43
+ * @return OffScreenRenderableType for this Actor.
+ */
+ OffScreenRenderable::Type GetOffScreenRenderableType();
+
+ /**
+ * @brief Requests RenderTask reordering when the offscreen properties of this Actor are changed.
+ * @SINCE_2_3.43
+ */
+ void RequestRenderTaskReorder();
+
/**
* @brief Called after the size negotiation has been finished for this control.
*
{
const uint32_t CORE_MAJOR_VERSION = 2;
const uint32_t CORE_MINOR_VERSION = 3;
-const uint32_t CORE_MICRO_VERSION = 42;
+const uint32_t CORE_MICRO_VERSION = 44;
const char* const CORE_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
#define DALI_IMAGE_OPERATIONS_H
/*
- * Copyright (c) 2020 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.
namespace SamplingMode
{
/**
- * @brief Enumeration for SamplingMode type.
- * @SINCE_1_0.0
- */
+ * @brief Enumeration for SamplingMode type.
+ * @SINCE_1_0.0
+ */
enum Type
{
BOX, ///< Iteratively box filter to generate an image of 1/2, 1/4,
/// is enabled, the borders of the image may be trimmed to
/// match the aspect ratio of the desired dimensions.
/// @SINCE_1_0.0
- DONT_CARE ///< For caching algorithms where a client strongly prefers a
+ DONT_CARE, ///< For caching algorithms where a client strongly prefers a
/// cache-hit to reuse a cached image.
/// @SINCE_1_0.0
+ LANCZOS, ///< Use filter with Lanczos resample algorithm.
+ /// @SINCE_2_3.43
+ BOX_THEN_LANCZOS, ///< Iteratively box filter to generate an image of 1/2, 1/4,
+ /// 1/8 etc width and height and approximately the desired
+ /// size, then apply Lanczos resample algorithm.
+ /// @SINCE_2_3.43
};
const Type DEFAULT = BOX;
} // namespace SamplingMode
Name: dali2
Summary: DALi 3D Engine
-Version: 2.3.42
+Version: 2.3.44
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-core.git / commitdiff