dali-toolkit/internal/graphics/builtin-shader-extern-gen.h
dali-scene3d/internal/graphics/generated/*
dali-scene3d/internal/graphics/builtin-shader-extern-gen.h
-automated-tests/resources/overwritable-image.jpg
\ No newline at end of file
+automated-tests/resources/overwritable-image.jpg
+dali-toolkit/internal/gles-addon/generated/*
+dali-toolkit/internal/gles-addon/builtin-shader-extern-gen.h
${TEST_HARNESS_DIR}/dummy-control.cpp
${TEST_HARNESS_DIR}/mesh-builder.cpp
${TEST_HARNESS_DIR}/test-actor-utils.cpp
+ ${TEST_HARNESS_DIR}/test-addon-manager.cpp
${TEST_HARNESS_DIR}/test-animation-data.cpp
${TEST_HARNESS_DIR}/test-application.cpp
${TEST_HARNESS_DIR}/test-button.cpp
/*
- * 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.
// test harness headers before dali headers.
#include <dali-physics/dali-physics.h>
#include <dali-toolkit-test-suite-utils.h>
+#include <test-addon-manager.h>
#include <toolkit-event-thread-callback.h>
#include <dali-toolkit/devel-api/controls/alignment/alignment.h>
int UtcDaliPhysics2DAdaptorCreateDebugLayer(void)
{
ToolkitTestApplication application;
- Matrix transform(true);
+ Test::AddOnManager::Initialize(); // DebugLayer requires GLES addon so initialize the manager
+
+ Matrix transform(true);
transform.SetIdentityAndScale(Vector3(2.0f, 2.0f, 1.0f));
Uint16Pair size(640, 480);
auto scene = application.GetScene();
END_TEST;
}
+int UtcDaliPhysics2DAdaptorCreateDebugLayerN(void)
+{
+ ToolkitTestApplication application;
+ // DebugLayer requires GLES addon so don't initialize the manager so it's not loaded. This should cause us to throw.
+
+ Matrix transform(true);
+ transform.SetIdentityAndScale(Vector3(2.0f, 2.0f, 1.0f));
+ Uint16Pair size(640, 480);
+ auto scene = application.GetScene();
+
+ PhysicsAdaptor adaptor = PhysicsAdaptor::New(transform, size);
+ Actor rootActor = adaptor.GetRootActor();
+ scene.Add(rootActor);
+ Window window = DevelWindow::Get(rootActor);
+
+ try
+ {
+ Layer layer = adaptor.CreateDebugLayer(window);
+ DALI_TEST_CHECK(false); // Should not get here.
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true);
+ }
+
+ END_TEST;
+}
+
int UtcDaliPhysics2DAdaptorTranslateToPhysicsSpace1(void)
{
ToolkitTestApplication application;
${TEST_HARNESS_DIR}/dummy-control.cpp
${TEST_HARNESS_DIR}/mesh-builder.cpp
${TEST_HARNESS_DIR}/test-actor-utils.cpp
+ ${TEST_HARNESS_DIR}/test-addon-manager.cpp
${TEST_HARNESS_DIR}/test-animation-data.cpp
${TEST_HARNESS_DIR}/test-application.cpp
${TEST_HARNESS_DIR}/test-button.cpp
/*
- * 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.
// test harness headers before dali headers.
#include <dali-physics/dali-physics.h>
#include <dali-toolkit-test-suite-utils.h>
+#include <test-addon-manager.h>
#include <toolkit-event-thread-callback.h>
#include <dali-toolkit/devel-api/controls/alignment/alignment.h>
int UtcDaliPhysics3DAdaptorCreateDebugLayer(void)
{
ToolkitTestApplication application;
- Matrix transform(true);
+ Test::AddOnManager::Initialize(); // DebugLayer requires GLES addon so initialize the manager
+
+ Matrix transform(true);
transform.SetIdentityAndScale(Vector3(2.0f, 2.0f, 2.0f));
Uint16Pair size(640, 480);
auto scene = application.GetScene();
END_TEST;
}
+int UtcDaliPhysics3DAdaptorCreateDebugLayerN(void)
+{
+ ToolkitTestApplication application;
+ // DebugLayer requires GLES addon so don't initialize the manager so it's not loaded. This should cause us to throw.
+
+ Matrix transform(true);
+ transform.SetIdentityAndScale(Vector3(2.0f, 2.0f, 2.0f));
+ Uint16Pair size(640, 480);
+ auto scene = application.GetScene();
+
+ PhysicsAdaptor adaptor = PhysicsAdaptor::New(transform, size);
+ Actor rootActor = adaptor.GetRootActor();
+ scene.Add(rootActor);
+ Window window = DevelWindow::Get(rootActor);
+
+ try
+ {
+ Layer layer = adaptor.CreateDebugLayer(window);
+ DALI_TEST_CHECK(false); // Should not get here.
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true);
+ }
+
+ END_TEST;
+}
+
int UtcDaliPhysics3DAdaptorTranslateToPhysicsSpace1(void)
{
ToolkitTestApplication application;
../dali-toolkit/dali-toolkit-test-utils/dummy-control.cpp
../dali-toolkit/dali-toolkit-test-utils/mesh-builder.cpp
../dali-toolkit/dali-toolkit-test-utils/test-actor-utils.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-addon-manager.cpp
../dali-toolkit/dali-toolkit-test-utils/test-animation-data.cpp
../dali-toolkit/dali-toolkit-test-utils/test-application.cpp
../dali-toolkit/dali-toolkit-test-utils/test-button.cpp
../dali-toolkit/dali-toolkit-test-utils/test-native-image.cpp
dali-toolkit-test-utils/toolkit-text-utils.cpp
dali-toolkit-test-utils/dummy-visual.cpp
- dali-toolkit-test-utils/test-addon-manager.cpp
)
IF(ELDBUS_AVAILABLE)
+++ /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.
- *
- */
-
-#include "test-addon-manager.h"
-
-#include <dali-test-suite-utils.h>
-#include <dlfcn.h>
-
-#include <cstring>
-
-#ifndef ADDON_LIBS_PATH
-#define ADDON_LIBS_PATH ""
-#endif
-
-namespace Dali
-{
-namespace Test
-{
-std::vector<std::string> AddOnManager::EnumerateAddOns()
-{
- std::string listFileName(ADDON_LIBS_PATH);
- listFileName += "/addons.txt";
-
- // Read list of available test addons
- tet_printf("Enumerating addons, file: %s\n", listFileName.c_str());
- std::vector<std::string> addons{};
- auto* fin = fopen(listFileName.c_str(), "r");
- char* lineBuf = new char[256];
- memset(lineBuf, 0, 256);
- size_t n = 256;
- while(getline(&lineBuf, &n, fin) > 0)
- {
- char* c = lineBuf;
- while(*c)
- {
- if(*c == '\n' || *c == '\r')
- {
- *c = 0;
- break;
- }
- ++c;
- }
- tet_printf("Adding %s\n", lineBuf);
- addons.emplace_back(lineBuf);
- memset(lineBuf, 0, 256);
- }
- fclose(fin);
- delete[] lineBuf;
- std::vector<std::string> retval{};
- // Open addons
- for(auto& name : addons)
- {
- std::string path(ADDON_LIBS_PATH);
- path += "/";
- path += name;
-
- mAddOnCache.emplace_back();
- mAddOnCache.back().handle = dlopen(path.c_str(), RTLD_DEEPBIND | RTLD_LAZY);
- if(!mAddOnCache.back().handle)
- {
- mAddOnCache.back().valid = false;
- tet_printf("Can't open addon lib: %s\n", path.c_str());
- continue;
- }
- // Here addon must self register
- if(!mAddOnCache.back().valid)
- {
- puts("Addon invalid!");
- }
- else
- {
- tet_printf("Valid AddOn: %s\n", mAddOnCache.back().name.c_str());
- retval.emplace_back(mAddOnCache.back().name);
- }
- }
-
- return retval;
-
- /**
- * Check for self-registering addons
- */
-}
-
-void AddOnManager::RegisterAddOnDispatchTable(const AddOnDispatchTable* dispatchTable)
-{
- // Register the dispatch table
- auto& entry = mAddOnCache.back();
- entry.name = dispatchTable->name;
- tet_printf("Registering AddOn: %s\n", entry.name.c_str());
- entry.GetGlobalProc = dispatchTable->GetGlobalProc;
- entry.GetInstanceProc = dispatchTable->GetInstanceProc;
- entry.GetAddOnInfo = dispatchTable->GetAddOnInfo;
- entry.OnStart = dispatchTable->OnStart;
- entry.OnStop = dispatchTable->OnStop;
- entry.OnPause = dispatchTable->OnPause;
- entry.OnResume = dispatchTable->OnResume;
- entry.valid = true;
-}
-
-bool AddOnManager::GetAddOnInfo(const std::string& name, AddOnInfo& info)
-{
- auto retval = false;
- std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&retval, name, &info](AddOnCacheEntry& entry) {
- if(entry.name == name)
- {
- entry.GetAddOnInfo(info);
- retval = true;
- return true;
- }
- return false;
- });
- return retval;
-}
-
-std::vector<AddOnLibrary> AddOnManager::LoadAddOns(const std::vector<std::string>& addonNames)
-{
- if(mAddOnCache.empty())
- {
- EnumerateAddOns();
- }
-
- std::vector<AddOnLibrary> retval{};
- for(auto& name : addonNames)
- {
- size_t index = 0;
- auto iter = std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&retval, name, &index](AddOnCacheEntry& entry) {
- index++;
- if(entry.name == name)
- {
- return true;
- }
- return false;
- });
- if(iter != mAddOnCache.end())
- {
- retval.emplace_back(*reinterpret_cast<void**>(&index));
- }
- else
- {
- retval.emplace_back(nullptr);
- }
- }
-
- return retval;
-}
-
-AddOnLibrary AddOnManager::LoadAddOn(const std::string& addonName, const std::string& libraryName)
-{
- AddOnLibrary addOnLibrary = nullptr;
- size_t index = 0;
- auto iter = std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&addonName, &index](AddOnCacheEntry& entry) {
- index++;
- return (entry.name == addonName);
- });
-
- if(iter != mAddOnCache.end())
- {
- addOnLibrary = reinterpret_cast<void*>(index);
- }
- else
- {
- mAddOnCache.emplace_back();
- mAddOnCache.back().handle = dlopen(libraryName.c_str(), RTLD_DEEPBIND | RTLD_LAZY);
- if(!mAddOnCache.back().handle)
- {
- mAddOnCache.back().valid = false;
- tet_printf("Can't open addon lib: %s\n", libraryName.c_str());
- }
- // Here addon must self register
- if(!mAddOnCache.back().valid)
- {
- puts("Addon invalid!");
- }
- else
- {
- tet_printf("Valid AddOn: %s\n", mAddOnCache.back().name.c_str());
- addOnLibrary = reinterpret_cast<void*>(mAddOnCache.size());
- }
- }
-
- return addOnLibrary;
-}
-
-void* AddOnManager::GetGlobalProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName)
-{
- auto index = *reinterpret_cast<const size_t*>(&addOnLibrary);
- return mAddOnCache[index - 1].GetGlobalProc(procName);
-}
-
-void* AddOnManager::GetInstanceProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName)
-{
- auto index = *reinterpret_cast<const size_t*>(&addOnLibrary);
- return mAddOnCache[index - 1].GetInstanceProc(procName);
-}
-
-void AddOnManager::Start()
-{
- for(auto& entry : mAddOnCache)
- {
- if(entry.OnStart)
- {
- entry.OnStart();
- }
- }
-}
-
-void AddOnManager::Resume()
-{
- for(auto& entry : mAddOnCache)
- {
- if(entry.OnResume)
- {
- entry.OnResume();
- }
- }
-}
-
-void AddOnManager::Stop()
-{
- for(auto& entry : mAddOnCache)
- {
- if(entry.OnStop)
- {
- entry.OnStop();
- }
- }
-}
-
-void AddOnManager::Pause()
-{
- for(auto& entry : mAddOnCache)
- {
- if(entry.OnPause)
- {
- entry.OnPause();
- }
- }
-}
-
-} // namespace Test
-} // namespace Dali
+++ /dev/null
-#ifndef TEST_ADDON_MANAGER_H
-#define TEST_ADDON_MANAGER_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.
- *
- */
-
-#include <dali/integration-api/addon-manager.h>
-#include <dali/public-api/common/vector-wrapper.h>
-
-#include <string>
-
-namespace Dali
-{
-namespace Test
-{
-class AddOnManager : public Dali::Integration::AddOnManager
-{
-public:
- /**
- * @brief Constructor, initialised by the Adaptor
- */
- AddOnManager() = default;
-
- /**
- * @brief Destructor
- */
- ~AddOnManager() override = default;
-
- std::vector<std::string> EnumerateAddOns() override;
-
- bool GetAddOnInfo(const std::string& name, AddOnInfo& info) override;
-
- std::vector<AddOnLibrary> LoadAddOns(const std::vector<std::string>& addonNames) override;
-
- AddOnLibrary LoadAddOn(const std::string& addonName, const std::string& libraryName) override;
-
- void* GetGlobalProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName) override;
-
- void* GetInstanceProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName) override;
-
- void RegisterAddOnDispatchTable(const AddOnDispatchTable* dispatchTable) override;
-
- void Start() override;
-
- void Resume() override;
-
- void Stop() override;
-
- void Pause() override;
-
- struct AddOnCacheEntry
- {
- std::string name{};
- AddOnInfo info{};
-
- // library handle
- void* handle{nullptr};
-
- // main function pointers
- void (*GetAddOnInfo)(AddOnInfo&) = nullptr; ///< Returns AddOnInfo structure
- void* (*GetInstanceProc)(const char*) = nullptr; ///< Returns pointer of instance function (member funtion)
- void* (*GetGlobalProc)(const char*) = nullptr; ///< Returns pointer of global function (non-member function)
-
- void (*OnStart)() = nullptr;
- void (*OnResume)() = nullptr;
- void (*OnPause)() = nullptr;
- void (*OnStop)() = nullptr;
-
- bool valid = false;
- };
-
- std::vector<AddOnCacheEntry> mAddOnCache;
-};
-} // Namespace Test
-} // namespace Dali
-
-#endif // TEST_ADDON_MANAGER_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.
*
*/
-#include <iostream>
#include <stdlib.h>
+#include <iostream>
#include <dali-toolkit-test-suite-utils.h>
#include <dali-toolkit/dali-toolkit.h>
-#include "dali-toolkit-test-utils/test-addon-manager.h"
+#include <test-addon-manager.h>
#include <toolkit-event-thread-callback.h>
using namespace Dali::Toolkit::Internal;
namespace
{
-
-const char* TEST_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/application-icon-20.png";
-const char* TEST_IMAGE_FILE_NAME_9 = TEST_RESOURCE_DIR "/heartsframe.9.png";
-const char* TEST_IMAGE_FILE_NAME2_9 = TEST_RESOURCE_DIR "/button-up.9.png";
-int CountFunctionCalls( const std::vector<std::string>& callstack, const std::string& function )
+const char* TEST_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/application-icon-20.png";
+const char* TEST_IMAGE_FILE_NAME_9 = TEST_RESOURCE_DIR "/heartsframe.9.png";
+const char* TEST_IMAGE_FILE_NAME2_9 = TEST_RESOURCE_DIR "/button-up.9.png";
+int CountFunctionCalls(const std::vector<std::string>& callstack, const std::string& function)
{
int counter = 0;
- std::find_if( callstack.begin(), callstack.end(), [&counter, &function]( const std::string& item )
- {
- if( item == function )
+ std::find_if(callstack.begin(), callstack.end(), [&counter, &function](const std::string& item) {
+ if(item == function)
{
counter++;
}
return counter;
}
-}
+} // namespace
int UtcRenderingAddOnTestP(void)
{
- Dali::Integration::AddOnManager* addOnManager = new Dali::Test::AddOnManager();
+ Dali::Integration::AddOnManager* addOnManager = new Test::AddOnManager();
bool valid = addOnManager->Get() != nullptr;
- DALI_TEST_EQUALS( valid, true, TEST_LOCATION );
- auto addon = addOnManager->GetAddOn( "oo-rendering" );
- auto GetCallStack = addOnManager->GetGlobalProc<std::vector<std::string>(bool)>( addon, "GetCallStack" );
+ DALI_TEST_EQUALS(valid, true, TEST_LOCATION);
+ auto addon = addOnManager->GetAddOn("oo-rendering");
+ auto GetCallStack = addOnManager->GetGlobalProc<std::vector<std::string>(bool)>(addon, "GetCallStack");
ToolkitTestApplication application;
- tet_infoline( "UtcRenderingAddOnTestP" );
+ tet_infoline("UtcRenderingAddOnTestP");
// Load regular image view
- auto imageView = Dali::Toolkit::ImageView::New( TEST_IMAGE_FILE_NAME );
- imageView.SetProperty( Actor::Property::SIZE, Vector2( 400.f, 60.f ) );
- imageView.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- imageView.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+ auto imageView = Dali::Toolkit::ImageView::New(TEST_IMAGE_FILE_NAME);
+ imageView.SetProperty(Actor::Property::SIZE, Vector2(400.f, 60.f));
+ imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
// Load npatch image view
- auto imageView2 = Dali::Toolkit::ImageView::New( TEST_IMAGE_FILE_NAME_9 );
- imageView2.SetProperty( Actor::Property::SIZE, Vector2( 400.f, 60.f ) );
- imageView2.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- imageView2.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+ auto imageView2 = Dali::Toolkit::ImageView::New(TEST_IMAGE_FILE_NAME_9);
+ imageView2.SetProperty(Actor::Property::SIZE, Vector2(400.f, 60.f));
+ imageView2.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ imageView2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
// Load npatch image view
- auto imageView3 = Dali::Toolkit::ImageView::New( TEST_IMAGE_FILE_NAME2_9 );
- imageView3.SetProperty( Actor::Property::SIZE, Vector2( 400.f, 60.f ) );
- imageView3.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- imageView3.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+ auto imageView3 = Dali::Toolkit::ImageView::New(TEST_IMAGE_FILE_NAME2_9);
+ imageView3.SetProperty(Actor::Property::SIZE, Vector2(400.f, 60.f));
+ imageView3.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ imageView3.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
- application.GetScene().Add( imageView );
- application.GetScene().Add( imageView2 );
- application.GetScene().Add( imageView3 );
+ application.GetScene().Add(imageView);
+ application.GetScene().Add(imageView2);
+ application.GetScene().Add(imageView3);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( ::Test::WaitForEventThreadTrigger( 3 ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(::Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
application.SendNotification();
application.Render();
auto callstack = GetCallStack(true);
- DALI_TEST_EQUALS( CountFunctionCalls( callstack, "GetGeometry" ), 2, TEST_LOCATION);
- DALI_TEST_EQUALS( CountFunctionCalls( callstack, "CreateGeometry" ), 1, TEST_LOCATION);
- DALI_TEST_EQUALS( CountFunctionCalls( callstack, "CreateGeometryGrid" ), 2, TEST_LOCATION);
- DALI_TEST_EQUALS( CountFunctionCalls( callstack, "BuildNPatch" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(CountFunctionCalls(callstack, "GetGeometry"), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(CountFunctionCalls(callstack, "CreateGeometry"), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(CountFunctionCalls(callstack, "CreateGeometryGrid"), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(CountFunctionCalls(callstack, "BuildNPatch"), 2, TEST_LOCATION);
delete addOnManager;
dali-toolkit-test-utils/dummy-control.cpp
dali-toolkit-test-utils/mesh-builder.cpp
dali-toolkit-test-utils/test-actor-utils.cpp
+ dali-toolkit-test-utils/test-addon-manager.cpp
dali-toolkit-test-utils/test-animation-data.cpp
dali-toolkit-test-utils/test-application.cpp
dali-toolkit-test-utils/test-button.cpp
--- /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.
+ *
+ */
+
+#include "test-addon-manager.h"
+
+#include <dali-test-suite-utils.h>
+#include <dlfcn.h>
+#include <memory>
+
+#include <cstring>
+
+#ifndef ADDON_LIBS_PATH
+#define ADDON_LIBS_PATH ""
+#endif
+
+namespace Test
+{
+using namespace Dali;
+
+void AddOnManager::Initialize()
+{
+ // Only create an instance if we haven't created one already
+ if(!AddOnManager::Get())
+ {
+ static std::unique_ptr<AddOnManager> sAddonManager(new AddOnManager);
+ // Memory will be freed upon test completion
+ }
+}
+
+std::vector<std::string> AddOnManager::EnumerateAddOns()
+{
+ std::string listFileName(ADDON_LIBS_PATH);
+ listFileName += "/addons.txt";
+
+ // Read list of available test addons
+ tet_printf("Enumerating addons, file: %s\n", listFileName.c_str());
+ std::vector<std::string> addons{};
+ auto* fin = fopen(listFileName.c_str(), "r");
+ char* lineBuf = new char[256];
+ memset(lineBuf, 0, 256);
+ size_t n = 256;
+ while(getline(&lineBuf, &n, fin) > 0)
+ {
+ char* c = lineBuf;
+ while(*c)
+ {
+ if(*c == '\n' || *c == '\r')
+ {
+ *c = 0;
+ break;
+ }
+ ++c;
+ }
+ tet_printf("Adding %s\n", lineBuf);
+ addons.emplace_back(lineBuf);
+ memset(lineBuf, 0, 256);
+ }
+ fclose(fin);
+ delete[] lineBuf;
+ std::vector<std::string> retval{};
+ // Open addons
+ for(auto& name : addons)
+ {
+ std::string path(ADDON_LIBS_PATH);
+ path += "/";
+ path += name;
+
+ mAddOnCache.emplace_back();
+ mAddOnCache.back().handle = dlopen(path.c_str(), RTLD_DEEPBIND | RTLD_LAZY);
+ if(!mAddOnCache.back().handle)
+ {
+ mAddOnCache.back().valid = false;
+ tet_printf("Can't open addon lib: %s\n", path.c_str());
+ continue;
+ }
+ // Here addon must self register
+ if(!mAddOnCache.back().valid)
+ {
+ puts("Addon invalid!");
+ }
+ else
+ {
+ tet_printf("Valid AddOn: %s\n", mAddOnCache.back().name.c_str());
+ retval.emplace_back(mAddOnCache.back().name);
+ }
+ }
+
+ return retval;
+
+ /**
+ * Check for self-registering addons
+ */
+}
+
+void AddOnManager::RegisterAddOnDispatchTable(const AddOnDispatchTable* dispatchTable)
+{
+ // Register the dispatch table
+ auto& entry = mAddOnCache.back();
+ entry.name = dispatchTable->name;
+ tet_printf("Registering AddOn: %s\n", entry.name.c_str());
+ entry.GetGlobalProc = dispatchTable->GetGlobalProc;
+ entry.GetInstanceProc = dispatchTable->GetInstanceProc;
+ entry.GetAddOnInfo = dispatchTable->GetAddOnInfo;
+ entry.OnStart = dispatchTable->OnStart;
+ entry.OnStop = dispatchTable->OnStop;
+ entry.OnPause = dispatchTable->OnPause;
+ entry.OnResume = dispatchTable->OnResume;
+ entry.valid = true;
+}
+
+bool AddOnManager::GetAddOnInfo(const std::string& name, AddOnInfo& info)
+{
+ auto retval = false;
+ std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&retval, name, &info](AddOnCacheEntry& entry) {
+ if(entry.name == name)
+ {
+ entry.GetAddOnInfo(info);
+ retval = true;
+ return true;
+ }
+ return false;
+ });
+ return retval;
+}
+
+std::vector<AddOnLibrary> AddOnManager::LoadAddOns(const std::vector<std::string>& addonNames)
+{
+ if(mAddOnCache.empty())
+ {
+ EnumerateAddOns();
+ }
+
+ std::vector<AddOnLibrary> retval{};
+ for(auto& name : addonNames)
+ {
+ size_t index = 0;
+ auto iter = std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&retval, name, &index](AddOnCacheEntry& entry) {
+ index++;
+ if(entry.name == name)
+ {
+ return true;
+ }
+ return false;
+ });
+ if(iter != mAddOnCache.end())
+ {
+ retval.emplace_back(*reinterpret_cast<void**>(&index));
+ }
+ else
+ {
+ retval.emplace_back(nullptr);
+ }
+ }
+
+ return retval;
+}
+
+AddOnLibrary AddOnManager::LoadAddOn(const std::string& addonName, const std::string& libraryName)
+{
+ AddOnLibrary addOnLibrary = nullptr;
+ size_t index = 0;
+ auto iter = std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&addonName, &index](AddOnCacheEntry& entry) {
+ index++;
+ return (entry.name == addonName);
+ });
+
+ if(iter != mAddOnCache.end())
+ {
+ addOnLibrary = reinterpret_cast<void*>(index);
+ }
+ else
+ {
+ mAddOnCache.emplace_back();
+ mAddOnCache.back().handle = dlopen(libraryName.c_str(), RTLD_LAZY); // We want to override some called methods in test code so don't do a deepbind
+ if(!mAddOnCache.back().handle)
+ {
+ mAddOnCache.back().valid = false;
+ tet_printf("Can't open addon lib: %s\n", libraryName.c_str());
+ }
+ // Here addon must self register
+ if(!mAddOnCache.back().valid)
+ {
+ puts("Addon invalid!");
+ }
+ else
+ {
+ tet_printf("Valid AddOn: %s\n", mAddOnCache.back().name.c_str());
+ addOnLibrary = reinterpret_cast<void*>(mAddOnCache.size());
+ }
+ }
+
+ return addOnLibrary;
+}
+
+void* AddOnManager::GetGlobalProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName)
+{
+ auto index = *reinterpret_cast<const size_t*>(&addOnLibrary);
+ return mAddOnCache[index - 1].GetGlobalProc(procName);
+}
+
+void* AddOnManager::GetInstanceProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName)
+{
+ auto index = *reinterpret_cast<const size_t*>(&addOnLibrary);
+ return mAddOnCache[index - 1].GetInstanceProc(procName);
+}
+
+void AddOnManager::Start()
+{
+ for(auto& entry : mAddOnCache)
+ {
+ if(entry.OnStart)
+ {
+ entry.OnStart();
+ }
+ }
+}
+
+void AddOnManager::Resume()
+{
+ for(auto& entry : mAddOnCache)
+ {
+ if(entry.OnResume)
+ {
+ entry.OnResume();
+ }
+ }
+}
+
+void AddOnManager::Stop()
+{
+ for(auto& entry : mAddOnCache)
+ {
+ if(entry.OnStop)
+ {
+ entry.OnStop();
+ }
+ }
+}
+
+void AddOnManager::Pause()
+{
+ for(auto& entry : mAddOnCache)
+ {
+ if(entry.OnPause)
+ {
+ entry.OnPause();
+ }
+ }
+}
+
+} // namespace Test
--- /dev/null
+#ifndef TEST_ADDON_MANAGER_H
+#define TEST_ADDON_MANAGER_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.
+ *
+ */
+
+#include <dali/integration-api/addon-manager.h>
+#include <dali/public-api/common/vector-wrapper.h>
+
+#include <string>
+
+namespace Test
+{
+class AddOnManager : public Dali::Integration::AddOnManager
+{
+public:
+ /**
+ * Initializes the test addon manager so that it can be used by DALi.
+ */
+ static void Initialize();
+
+ /**
+ * @brief Constructor, initialised by the Adaptor
+ */
+ AddOnManager() = default;
+
+ /**
+ * @brief Destructor
+ */
+ ~AddOnManager() override = default;
+
+ std::vector<std::string> EnumerateAddOns() override;
+
+ bool GetAddOnInfo(const std::string& name, Dali::AddOnInfo& info) override;
+
+ std::vector<Dali::AddOnLibrary> LoadAddOns(const std::vector<std::string>& addonNames) override;
+
+ Dali::AddOnLibrary LoadAddOn(const std::string& addonName, const std::string& libraryName) override;
+
+ void* GetGlobalProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName) override;
+
+ void* GetInstanceProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName) override;
+
+ void RegisterAddOnDispatchTable(const Dali::AddOnDispatchTable* dispatchTable) override;
+
+ void Start() override;
+
+ void Resume() override;
+
+ void Stop() override;
+
+ void Pause() override;
+
+ struct AddOnCacheEntry
+ {
+ std::string name{};
+ Dali::AddOnInfo info{};
+
+ // library handle
+ void* handle{nullptr};
+
+ // main function pointers
+ void (*GetAddOnInfo)(Dali::AddOnInfo&) = nullptr; ///< Returns AddOnInfo structure
+ void* (*GetInstanceProc)(const char*) = nullptr; ///< Returns pointer of instance function (member funtion)
+ void* (*GetGlobalProc)(const char*) = nullptr; ///< Returns pointer of global function (non-member function)
+
+ void (*OnStart)() = nullptr;
+ void (*OnResume)() = nullptr;
+ void (*OnPause)() = nullptr;
+ void (*OnStop)() = nullptr;
+
+ bool valid = false;
+ };
+
+ std::vector<AddOnCacheEntry> mAddOnCache;
+};
+} // Namespace Test
+
+#endif // TEST_ADDON_MANAGER_H
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <thread>
#include <dali-toolkit-test-suite-utils.h>
+#include <test-addon-manager.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/public-api/controls/gl-view/gl-view.h>
using namespace Dali;
using namespace Dali::Toolkit;
-// Positive test case for a method
int UtcDaliGlViewNew(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline(" UtcDaliGlViewNew");
GlView view = GlView::New(GlView::ColorFormat::RGBA8888);
DALI_TEST_CHECK(view);
END_TEST;
}
-// Positive test case for a method
+int UtcDaliGlViewNewN(void)
+{
+ ToolkitTestApplication application;
+ // GlView requires GLES addon but don't initialize the manager which will mean the addon will not be loaded.
+ // We should throw
+
+ try
+ {
+ GlView view = GlView::New(GlView::ColorFormat::RGBA8888);
+ DALI_TEST_CHECK(false); // Should not get here!
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true);
+ }
+ END_TEST;
+}
+
int UtcDaliGlViewDownCast(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline(" UtcDaliGlViewDownCast");
GlView view = GlView::New(GlView::ColorFormat::RGB888);
int UtcDaliGlViewCopyAndAssignment(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewCopyAndAssignment");
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
int UtcDaliGlViewMoveAssignment(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewMoveAssignment");
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
int UtcDaliGlViewSetGraphicsConfigGles20N(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewSetGraphicsConfigGles20");
GlView view;
try
int UtcDaliGlViewSetGraphicsConfigGles30(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewSetGraphicsConfigGles30");
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
int UtcDaliGlViewRenderingMode(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewRenderingMode");
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
int UtcDaliGlViewOnSizeSet(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewOnSizeSet");
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
int UtcDaliGlViewRegisterGlCallbacksN(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewRegisterGlCallbacksN");
GlView view;
int UtcDaliGlViewSetResizeCallbackN(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewSetResizeCallback");
GlView view;
int UtcDaliGlViewRenderOnce(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewRenderOnce");
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
int UtcDaliGlViewWindowVisibilityChanged(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
tet_infoline("UtcDaliGlViewWindowVisibilityChanged");
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
application.GetScene().Add(view);
int UtcDaliGlViewOnScene(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
int UtcDaliGlViewControlVisibilityChanged(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
application.GetScene().Add(view);
int UtcDaliGlViewResize(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewResize");
GlView view = Toolkit::GlView::New(GlView::ColorFormat::RGB888);
#include <thread>
#include <dali-toolkit-test-suite-utils.h>
+#include <test-addon-manager.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/public-api/controls/gl-view/gl-view.h>
int UtcDaliGlViewDirectRenderingNew(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline(" UtcDaliGlViewDirectRenderingNew");
GlView view = GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGBA8888);
DALI_TEST_CHECK(view);
int UtcDaliGlViewDirectRenderingNewN(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline(" UtcDaliGlViewDirectRenderingNewN");
// Invalid backend mode
- GlView view = GlView::New(GlView::BackendMode(11111), GlView::ColorFormat::RGBA8888);
- DALI_TEST_CHECK(!view);
+ try
+ {
+ GlView view = GlView::New(GlView::BackendMode(11111), GlView::ColorFormat::RGBA8888);
+ DALI_TEST_CHECK(false); // Should not get here!
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true);
+ }
END_TEST;
}
int UtcDaliGlViewDirectRenderingDownCast(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline(" UtcDaliGlViewDirectRenderingDownCast");
GlView view = GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingCopyAndAssignment(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingCopyAndAssignment");
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingMoveAssignment(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingMoveAssignment");
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingSetGraphicsConfigGles20N(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingSetGraphicsConfigGles20");
GlView view;
try
int UtcDaliGlViewDirectRenderingSetGraphicsConfigGles30(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingSetGraphicsConfigGles30");
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingRenderingMode(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingRenderingMode");
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingOnSizeSet(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingOnSizeSet");
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingRegisterGlCallbacksN(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingRegisterGlCallbacksN");
GlView view;
int UtcDaliGlViewDirectRenderingSetResizeCallbackN(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingSetResizeCallback");
GlView view;
int UtcDaliGlViewDirectRenderingRenderOnce(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingRenderOnce");
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingWindowVisibilityChanged(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingWindowVisibilityChanged");
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
application.GetScene().Add(view);
int UtcDaliGlViewDirectRenderingOnScene(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingControlVisibilityChanged(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
application.GetScene().Add(view);
int UtcDaliGlViewDirectRenderingResize(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingResize");
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingDirectResize(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingResize");
GlView view = Toolkit::GlView::New(GlView::BackendMode::UNSAFE_DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingTerminateCallback(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline("UtcDaliGlViewDirectRenderingTerminateCallback");
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingTextureBinding(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingThreadedNew(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
+
tet_infoline(" UtcDaliGlViewDirectRenderingThreadedNew");
GlView view = GlView::New(GlView::BackendMode::DIRECT_RENDERING_THREADED, GlView::ColorFormat::RGBA8888);
DALI_TEST_CHECK(view);
int UtcDaliGlViewDirectRenderingThreadedOnScene(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING_THREADED, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingThreadedOnScene1(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING_THREADED, GlView::ColorFormat::RGB888);
int UtcDaliGlViewDirectRenderingThreadedOnScene2(void)
{
ToolkitTestApplication application;
+ Test::AddOnManager::Initialize(); // GlView requires GLES addon so initialize the manager
GlView view = Toolkit::GlView::New(GlView::BackendMode::DIRECT_RENDERING_THREADED, GlView::ColorFormat::RGB888);
OPTION(ENABLE_COVERAGE "Coverage" OFF)
OPTION(ENABLE_PKG_CONFIGURE "Use pkgconfig" ON)
OPTION(ENABLE_LINK_TEST "Enable the link test" ON)
-OPTION(ENABLE_VULKAN "Enable Vulkan instead of GLES" OFF)
OPTION(INSTALL_DOXYGEN_DOC "Install doxygen doc" ON)
OPTION(CONFIGURE_AUTOMATED_TESTS "Configure automated tests" ON)
OPTION(USE_DEFAULT_RESOURCE_DIR "Whether to use the default resource folders. Otherwise set environment variables for DALI_IMAGE_DIR, DALI_SOUND_DIR, DALI_STYLE_DIR, DALI_STYLE_IMAGE_DIR and DALI_DATA_READ_ONLY_DIR" ON)
SET(SHADER_SOURCE_DIR "${ROOT_SRC_DIR}/dali-toolkit/internal/graphics/shaders/")
SET(SHADER_GENERATED_DIR "${ROOT_SRC_DIR}/dali-toolkit/internal/graphics/generated")
+# Shaders for GLES Addon
+SET(GLES_ADDON_DIR ${ROOT_SRC_DIR}/dali-toolkit/internal/gles-addon/)
+SET(GLES_ADDON_SHADER_SOURCE_DIR "${GLES_ADDON_DIR}/shaders/")
+SET(GLES_ADDON_SHADER_GENERATED_DIR "${GLES_ADDON_DIR}/generated/")
+
SET(GENERATED_SHADER_DIR ${ROOT_SRC_DIR}/dali-toolkit/internal/graphics/)
SET_PROPERTY(DIRECTORY PROPERTY ADDITIONAL_MAKE_CLEAN_FILES
"${GENERATED_SHADER_DIR}/generated/"
- "${GENERATED_SHADER_DIR}/builtin-shader-extern-gen.h")
+ "${GENERATED_SHADER_DIR}/builtin-shader-extern-gen.h"
+ "${GLES_ADDON_SHADER_GENERATED_DIR}"
+ "${GLES_ADDON_DIR}/builtin-shader-extern-gen.h")
SET(SHADER_GENERATOR_NAME dali-shader-generator)
SET(SHADER_GENERATOR_SOURCES ${ROOT_SRC_DIR}/dali-toolkit/shader-generator/shader-generator.cpp)
SET(SOURCES ${SOURCES} ${BUILT_IN_SHADER_GEN_CPP})
+# Shaders for GLES Addon
+SET(GLES_ADDON_BUILT_IN_SHADER_GEN_CPP "${GLES_ADDON_SHADER_GENERATED_DIR}/builtin-shader-gen.cpp" )
+
+FILE(GLOB GLES_ADDON_SHADERS_SRC "${GLES_ADDON_SHADER_SOURCE_DIR}/*.vert" "${GLES_ADDON_SHADER_GENERATED_DIR}/*.frag" )
+ADD_CUSTOM_COMMAND(OUTPUT ${GLES_ADDON_BUILT_IN_SHADER_GEN_CPP}
+ DEPENDS ${SHADER_GENERATOR_NAME} ${GLES_ADDON_SHADERS_SRC}
+ COMMAND ${SHADER_GENERATOR_BINARY} ${GLES_ADDON_SHADER_SOURCE_DIR} ${GLES_ADDON_SHADER_GENERATED_DIR})
+
IF( WIN32 OR APPLE )
SET( DALICORE_LDFLAGS
"${DALICORE_LDFLAGS}"
FIND_PACKAGE( pthreads REQUIRED )
ENDIF()
-IF( NOT ENABLE_VULKAN)
- SET(SOURCES ${SOURCES}
- ${toolkit_internal_egl_src_files}
- ${public_api_egl_src_files}
- )
-ENDIF()
-
ADD_LIBRARY( ${name} ${LIBTYPE} ${SOURCES} )
SET(CUSTOM_COMPILE_OPTIONS "")
${ROOT_SRC_DIR}/automated-tests/CMakeLists.txt @ONLY )
ENDIF()
+SET(TOOLKIT_GLES_NAME "dali2-toolkit-gles")
+PKG_CHECK_MODULES(OPENGLES glesv2 egl)
+ADD_LIBRARY(${TOOLKIT_GLES_NAME}
+ ${LIBTYPE}
+ ${toolkit_internal_egl_src_files}
+ ${GLES_ADDON_BUILT_IN_SHADER_GEN_CPP}
+)
+target_compile_options(${TOOLKIT_GLES_NAME} PRIVATE ${CUSTOM_COMPILE_OPTIONS})
+TARGET_LINK_LIBRARIES(${TOOLKIT_GLES_NAME}
+ ${name}
+ ${DALICORE_LDFLAGS}
+ ${DALIADAPTOR_LDFLAGS}
+ ${COVERAGE}
+ ${OPENGLES_LDFLAGS}
+)
+INSTALL(TARGETS ${TOOLKIT_GLES_NAME} DESTINATION ${LIB_DIR})
# Configuration Messages
MESSAGE( STATUS "Configuration:\n" )
MESSAGE( STATUS "Export all symbols: " ${ENABLE_EXPORTALL} )
MESSAGE( STATUS "Coverage: " ${ENABLE_COVERAGE} )
MESSAGE( STATUS "Trace: " ${ENABLE_TRACE} )
-MESSAGE( STATUS "Vulkan: " ${ENABLE_VULKAN} )
MESSAGE( STATUS "Doxygen: " ${doxygenEnabled} )
MESSAGE( STATUS "Data Dir (Read/Write): " ${dataReadWriteDir} )
MESSAGE( STATUS "Data Dir (Read Only): " ${dataReadOnlyDir} )
include_directories(AFTER "${prefix_include_dir}")
MESSAGE(STATUS "2D sources: ${physics2d_src_files}")
+MESSAGE(STATUS "2D sources (GLES): ${physics2d_gles_src_files}")
+
MESSAGE(STATUS "3D sources: ${physics3d_src_files}")
+MESSAGE(STATUS "3D sources (GLES): ${physics3d_gles_src_files}")
-ADD_LIBRARY("${name}-2d" SHARED ${physics2d_src_files} )
-TARGET_LINK_LIBRARIES("${name}-2d" ${DALICORE_LDFLAGS}
+ADD_LIBRARY("${name}-2d" SHARED ${physics2d_src_files})
+TARGET_LINK_LIBRARIES("${name}-2d"
+ ${DALICORE_LDFLAGS}
dali2-toolkit
chipmunk
${COVERAGE})
TARGET_COMPILE_OPTIONS("${name}-2d" PUBLIC "-I${repo_root_dir}/dali-physics/third-party/chipmunk2d/include")
-ADD_LIBRARY("${name}-3d" SHARED ${physics3d_src_files} )
-TARGET_LINK_LIBRARIES("${name}-3d" ${DALICORE_LDFLAGS}
+ADD_LIBRARY("${name}-2d-gles" SHARED ${physics2d_gles_src_files})
+TARGET_LINK_LIBRARIES("${name}-2d-gles"
+ ${DALICORE_LDFLAGS}
+ ${DALIADAPTOR_LDFLAGS}
+ dali2-toolkit
+ chipmunk
+ ${COVERAGE})
+TARGET_COMPILE_OPTIONS("${name}-2d-gles" PUBLIC "-I${repo_root_dir}/dali-physics/third-party/chipmunk2d/include")
+
+ADD_LIBRARY("${name}-3d" SHARED ${physics3d_src_files})
+TARGET_LINK_LIBRARIES("${name}-3d"
+ ${DALICORE_LDFLAGS}
+ ${DALIADAPTOR_LDFLAGS}
dali2-toolkit
bullet3
${COVERAGE})
TARGET_COMPILE_OPTIONS("${name}-3d" PUBLIC "-I${repo_root_dir}/dali-physics/third-party/bullet3/src")
+ADD_LIBRARY("${name}-3d-gles" SHARED ${physics3d_gles_src_files})
+TARGET_LINK_LIBRARIES("${name}-3d-gles"
+ ${DALICORE_LDFLAGS}
+ ${DALIADAPTOR_LDFLAGS}
+ dali2-toolkit
+ bullet3
+ ${COVERAGE})
+TARGET_COMPILE_OPTIONS("${name}-3d-gles" PUBLIC "-I${repo_root_dir}/dali-physics/third-party/bullet3/src")
+
IF (ENABLE_PKG_CONFIGURE)
INSTALL(FILES
${CMAKE_CURRENT_BINARY_DIR}/${core_pkg_cfg_file_2d}
IF( INSTALL_CMAKE_MODULES )
MESSAGE(STATUS "Installing cmake modules & libs")
- SET_TARGET_PROPERTIES( ${name}-2d
+ SET_TARGET_PROPERTIES(${name}-2d
+ PROPERTIES
+ VERSION ${DALI_PHYSICS_VERSION}
+ SOVERSION ${${name}_VERSION_MAJOR}
+ CLEAN_DIRECT_OUPUT 1
+ )
+
+ SET_TARGET_PROPERTIES(${name}-2d-gles
+ PROPERTIES
+ VERSION ${DALI_PHYSICS_VERSION}
+ SOVERSION ${${name}_VERSION_MAJOR}
+ CLEAN_DIRECT_OUPUT 1
+ )
+
+ SET_TARGET_PROPERTIES(${name}-3d
PROPERTIES
VERSION ${DALI_PHYSICS_VERSION}
SOVERSION ${${name}_VERSION_MAJOR}
CLEAN_DIRECT_OUPUT 1
- )
+ )
- SET_TARGET_PROPERTIES( ${name}-3d
+ SET_TARGET_PROPERTIES(${name}-3d-gles
PROPERTIES
VERSION ${DALI_PHYSICS_VERSION}
SOVERSION ${${name}_VERSION_MAJOR}
CLEAN_DIRECT_OUPUT 1
- )
+ )
- IF( ENABLE_DEBUG )
+ IF(ENABLE_DEBUG)
SET( BIN_DIR "${BIN_DIR}/debug" )
SET( LIB_DIR "${LIB_DIR}/debug" )
ENDIF()
# Install library
- INSTALL( TARGETS ${name}-2d
+ INSTALL(TARGETS ${name}-2d
EXPORT ${name}-2d-targets
LIBRARY DESTINATION ${LIB_DIR}
ARCHIVE DESTINATION ${LIB_DIR}
RUNTIME DESTINATION ${BIN_DIR}
)
- INSTALL( TARGETS ${name}-3d
+ INSTALL(TARGETS ${name}-2d-gles
+ EXPORT ${name}-2d-gles-targets
+ LIBRARY DESTINATION ${LIB_DIR}
+ ARCHIVE DESTINATION ${LIB_DIR}
+ RUNTIME DESTINATION ${BIN_DIR}
+ )
+
+ INSTALL(TARGETS ${name}-3d
EXPORT ${name}-3d-targets
LIBRARY DESTINATION ${LIB_DIR}
ARCHIVE DESTINATION ${LIB_DIR}
RUNTIME DESTINATION ${BIN_DIR}
)
+ INSTALL(TARGETS ${name}-3d-gles
+ EXPORT ${name}-3d-gles-targets
+ LIBRARY DESTINATION ${LIB_DIR}
+ ARCHIVE DESTINATION ${LIB_DIR}
+ RUNTIME DESTINATION ${BIN_DIR}
+ )
+
# Install the cmake modules.
INSTALL(
EXPORT ${name}-2d-targets
ELSE()
MESSAGE(STATUS "Installing libs")
INSTALL( TARGETS ${name}-2d DESTINATION ${LIB_DIR} )
+ INSTALL( TARGETS ${name}-2d-gles DESTINATION ${LIB_DIR} )
INSTALL( TARGETS ${name}-3d DESTINATION ${LIB_DIR} )
-
+ INSTALL( TARGETS ${name}-3d-gles DESTINATION ${LIB_DIR} )
ENDIF()
# Install headers
#pragma once
/*
- * 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.
namespace Dali::Toolkit::Physics::Internal
{
-class PhysicsDebugRenderer;
-
class BulletPhysicsAdaptor : public PhysicsAdaptor
{
public:
--- /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.
+ */
+
+// External Includes
+#include <GLES3/gl3.h>
+#include <dali/devel-api/addons/addon-base.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/math/matrix.h>
+
+// Internal Includes
+#include <dali-physics/internal/physics-debug-renderer-gles.h>
+
+namespace Dali::Toolkit::Physics::Internal::Gles
+{
+struct DebugRenderer
+{
+ GLint mVertexLocation{-1};
+ GLint mVertexColourLocation{-1};
+ GLint mProjectionLocation{-1};
+ GLint mModelViewLocation{-1};
+ GLuint mBufferId{0u};
+ GLuint mProgramId{0u};
+};
+} // namespace Dali::Toolkit::Physics::Internal::Gles
+
+namespace
+{
+using DebugRenderer = Dali::Toolkit::Physics::Internal::Gles::DebugRenderer;
+const char* const DALI_PHYSICS_BULLET_GLES_ADDON_NAME("PhysicsBulletGlesAddOn");
+
+void PrepareShader(DebugRenderer& renderer)
+{
+ static const char glVertexShader[] =
+ "attribute vec4 vertexPosition;\n"
+ "attribute vec3 vertexColour;\n"
+ "varying vec3 fragColour;\n"
+ "uniform mat4 projection;\n"
+ "uniform mat4 modelView;\n"
+ "void main()\n"
+ "{\n"
+ " gl_Position = projection * modelView * vertexPosition;\n"
+ " fragColour = vertexColour;\n"
+ "}\n";
+
+ static const char glFragmentShader[] =
+ "precision mediump float;\n"
+ "varying vec3 fragColour;\n"
+ "void main()\n"
+ "{\n"
+ " gl_FragColor = vec4(fragColour, 1.0);\n"
+ "}\n";
+
+ renderer.mProgramId = Dali::Toolkit::Physics::Internal::Gles::CreateProgram(glVertexShader, glFragmentShader);
+}
+
+DebugRenderer* CreateGlesPhysicsDebugRenderer()
+{
+ return new DebugRenderer;
+}
+
+void DeleteGlesPhysicsDebugRenderer(DebugRenderer* renderer)
+{
+ delete renderer;
+}
+
+void SetViewport(int width, int height)
+{
+ glViewport(0, 0, width, height);
+}
+
+void Setup(DebugRenderer& renderer, int width, int height)
+{
+ PrepareShader(renderer);
+ renderer.mVertexLocation = glGetAttribLocation(renderer.mProgramId, "vertexPosition");
+ renderer.mVertexColourLocation = glGetAttribLocation(renderer.mProgramId, "vertexColour");
+ renderer.mProjectionLocation = glGetUniformLocation(renderer.mProgramId, "projection");
+ renderer.mModelViewLocation = glGetUniformLocation(renderer.mProgramId, "modelView");
+
+ glEnable(GL_DEPTH_TEST);
+ glViewport(0, 0, width, height);
+
+ glGenBuffers(1, &renderer.mBufferId);
+}
+
+void RenderLines(
+ DebugRenderer& renderer,
+ const void* data,
+ std::size_t dataSize,
+ int arrayCount,
+ const Dali::Matrix& modelViewMatrix,
+ const Dali::Matrix& projectionMatrix)
+{
+ glUseProgram(renderer.mProgramId);
+
+ glBindBuffer(GL_ARRAY_BUFFER, renderer.mBufferId);
+ glBufferData(GL_ARRAY_BUFFER, GLsizeiptr(dataSize), data, GL_STATIC_DRAW);
+
+ glVertexAttribPointer(renderer.mVertexLocation, 3, GL_FLOAT, GL_FALSE, 24, 0);
+ glEnableVertexAttribArray(renderer.mVertexLocation);
+ glVertexAttribPointer(renderer.mVertexColourLocation, 3, GL_FLOAT, GL_FALSE, 24, reinterpret_cast<const void*>(12));
+ glEnableVertexAttribArray(renderer.mVertexColourLocation);
+ glUniformMatrix4fv(renderer.mProjectionLocation, 1, GL_FALSE, projectionMatrix.AsFloat());
+ glUniformMatrix4fv(renderer.mModelViewLocation, 1, GL_FALSE, modelViewMatrix.AsFloat());
+
+ glDrawArrays(GL_LINES, 0, arrayCount);
+}
+} // unnamed namespace
+
+class PhysicsBulletGlesAddOn : public Dali::AddOns::AddOnBase
+{
+public:
+ void GetAddOnInfo(Dali::AddOnInfo& info) override
+ {
+ info.type = Dali::AddOnType::GENERIC;
+ info.name = DALI_PHYSICS_BULLET_GLES_ADDON_NAME;
+ info.version = Dali::DALI_ADDON_VERSION(1, 0, 0);
+ info.next = nullptr;
+ }
+
+ /**
+ * Dispatch table for global functions
+ * @return
+ */
+ Dali::AddOns::DispatchTable* GetGlobalDispatchTable() override
+ {
+ static Dali::AddOns::DispatchTable dispatchTable{};
+ if(dispatchTable.Empty())
+ {
+ dispatchTable["CreateGlesPhysicsDebugRenderer"] = CreateGlesPhysicsDebugRenderer;
+ dispatchTable["DeleteGlesPhysicsDebugRenderer"] = DeleteGlesPhysicsDebugRenderer;
+ dispatchTable["SetViewport"] = SetViewport;
+ dispatchTable["Setup"] = Setup;
+ dispatchTable["RenderLines"] = RenderLines;
+ }
+ return &dispatchTable;
+ }
+
+ /**
+ * Dispatch table for instance functions
+ * @return
+ */
+ Dali::AddOns::DispatchTable* GetInstanceDispatchTable() override
+ {
+ return nullptr;
+ }
+};
+
+REGISTER_ADDON_CLASS(PhysicsBulletGlesAddOn);
/*
- * 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.
#include <dali-physics/internal/bullet-impl/bullet-physics-debug-renderer.h>
// External Includes
-#include <dali/dali.h>
+#include <dali/devel-api/common/addon-binder.h>
+#include <dali/public-api/adaptor-framework/graphics-backend.h>
+#include <dali/public-api/math/degree.h>
+#include <dali/public-api/math/matrix.h>
+#include <dali/public-api/math/quaternion.h>
+#include <dali/public-api/math/radian.h>
+#include <dali/public-api/math/vector3.h>
+#include <dali/public-api/math/vector4.h>
// Internal Includes
#include <dali-physics/internal/physics-adaptor-impl.h>
using Dali::Vector3;
using Dali::Vector4;
-namespace
+namespace Dali::Toolkit::Physics::Internal
{
-GLuint LoadShader(GLenum shaderType, const char* shaderSource)
+namespace
{
- GLuint shader = glCreateShader(shaderType);
- if(shader != 0)
- {
- glShaderSource(shader, 1, &shaderSource, NULL);
- glCompileShader(shader);
- GLint compiled = 0;
- glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
- if(compiled != GL_TRUE)
- {
- GLint infoLen = 0;
- glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
-
- if(infoLen > 0)
- {
- std::vector<char> logBuffer;
- logBuffer.resize(infoLen + 1);
- glGetShaderInfoLog(shader, infoLen, NULL, &logBuffer[0]);
- fprintf(stderr, "%s\n", &logBuffer[0]);
- fflush(stderr);
-
- glDeleteShader(shader);
- shader = 0;
- }
- }
- }
- return shader;
-}
+const char* const DALI_PHYSICS_BULLET_GLES_SO("libdali2-physics-3d-gles.so");
+const char* const DALI_PHYSICS_BULLET_GLES_ADDON_NAME("PhysicsBulletGlesAddOn");
-GLuint CreateProgram(const char* vertexSource, const char* fragmentSource)
+struct PhysicsBulletGlesAddOn : public Dali::AddOn::AddOnBinder
{
- GLuint vertexShader = LoadShader(GL_VERTEX_SHADER, vertexSource);
- if(!vertexShader)
- {
- return 0;
- }
- GLuint fragmentShader = LoadShader(GL_FRAGMENT_SHADER, fragmentSource);
- if(!fragmentShader)
+ PhysicsBulletGlesAddOn()
+ : Dali::AddOn::AddOnBinder(DALI_PHYSICS_BULLET_GLES_ADDON_NAME, DALI_PHYSICS_BULLET_GLES_SO)
{
- return 0;
}
- GLuint program = glCreateProgram();
- if(program)
- {
- glAttachShader(program, vertexShader);
- glAttachShader(program, fragmentShader);
- glLinkProgram(program);
- GLint linkStatus = GL_FALSE;
- glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
- if(linkStatus != GL_TRUE)
- {
- GLint bufLength = 0;
- glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
- if(bufLength)
- {
- std::vector<char> logBuffer;
- logBuffer.resize(bufLength + 1);
- glGetProgramInfoLog(program, bufLength, NULL, &logBuffer[0]);
- fprintf(stderr, "%s\n", &logBuffer[0]);
- fflush(stderr);
- }
- glDeleteProgram(program);
- program = 0;
- }
- }
- return program;
-}
+
+ ~PhysicsBulletGlesAddOn() = default;
+
+ ADDON_BIND_FUNCTION(CreateGlesPhysicsDebugRenderer, Gles::DebugRenderer*());
+ ADDON_BIND_FUNCTION(DeleteGlesPhysicsDebugRenderer, void(Gles::DebugRenderer*));
+ ADDON_BIND_FUNCTION(SetViewport, void(int, int));
+ ADDON_BIND_FUNCTION(Setup, void(Gles::DebugRenderer&, int, int));
+ ADDON_BIND_FUNCTION(RenderLines, void(Gles::DebugRenderer&, const void*, std::size_t, int, const Dali::Matrix&, const Dali::Matrix&));
+};
+
+std::unique_ptr<PhysicsBulletGlesAddOn> gPhysicsBulletGlesAddOn;
} // namespace
-namespace Dali::Toolkit::Physics::Internal
-{
std::unique_ptr<PhysicsDebugRenderer> PhysicsDebugRenderer::New(uint32_t width, uint32_t height, Dali::CameraActor camera, PhysicsAdaptor* adaptor)
{
auto renderer = std::make_unique<PhysicsDebugRenderer>(width, height, camera, adaptor);
: mCamera(camera),
mWidth(width),
mHeight(height),
- mAdaptor(*adaptor),
- mVertexLocation(-1),
- mVertexColourLocation(-1),
- mProjectionLocation(-1),
- mModelViewLocation(-1),
- mBufferId(0u),
- mProgramId(0u)
+ mAdaptor(*adaptor)
{
+ if(Graphics::GetCurrentGraphicsBackend() == Graphics::Backend::GLES)
+ {
+ if(!gPhysicsBulletGlesAddOn)
+ {
+ gPhysicsBulletGlesAddOn.reset(new PhysicsBulletGlesAddOn);
+ }
+ DALI_ASSERT_ALWAYS(gPhysicsBulletGlesAddOn && "Cannot load the Bullet Debug Renderer Gles Addon\n");
+ mImpl = gPhysicsBulletGlesAddOn->CreateGlesPhysicsDebugRenderer();
+ }
}
-bool PhysicsDebugRenderer::OnRender(const Dali::RenderCallbackInput& input)
+PhysicsDebugRenderer::~PhysicsDebugRenderer()
{
- if(mState == State::INIT)
+ if(gPhysicsBulletGlesAddOn)
{
- Setup();
- mState = State::RENDER;
+ gPhysicsBulletGlesAddOn->DeleteGlesPhysicsDebugRenderer(mImpl);
+ mImpl = nullptr;
}
- glViewport(0, 0, mWidth, mHeight);
-
- RenderLines(input);
-
- return false;
}
-// Run on first invocation of callback
-void PhysicsDebugRenderer::Setup()
+bool PhysicsDebugRenderer::OnRender(const Dali::RenderCallbackInput& input)
{
- PrepareShader();
- mVertexLocation = glGetAttribLocation(mProgramId, "vertexPosition");
- mVertexColourLocation = glGetAttribLocation(mProgramId, "vertexColour");
- mProjectionLocation = glGetUniformLocation(mProgramId, "projection");
- mModelViewLocation = glGetUniformLocation(mProgramId, "modelView");
+ if(gPhysicsBulletGlesAddOn && mImpl)
+ {
+ if(mState == State::INIT)
+ {
+ gPhysicsBulletGlesAddOn->Setup(*mImpl, mWidth, mHeight);
+ mState = State::RENDER;
+ }
+ gPhysicsBulletGlesAddOn->SetViewport(mWidth, mHeight);
- glEnable(GL_DEPTH_TEST);
- glViewport(0, 0, mWidth, mHeight);
+ Render(input);
+ }
- glGenBuffers(1, &mBufferId);
+ return false;
}
void PhysicsDebugRenderer::UpdateWindowSize(Dali::Vector2 size)
mHeight = size.height;
}
-void PhysicsDebugRenderer::PrepareShader()
-{
- static const char glVertexShader[] =
- "attribute vec4 vertexPosition;\n"
- "attribute vec3 vertexColour;\n"
- "varying vec3 fragColour;\n"
- "uniform mat4 projection;\n"
- "uniform mat4 modelView;\n"
- "void main()\n"
- "{\n"
- " gl_Position = projection * modelView * vertexPosition;\n"
- " fragColour = vertexColour;\n"
- "}\n";
-
- static const char glFragmentShader[] =
- "precision mediump float;\n"
- "varying vec3 fragColour;\n"
- "void main()\n"
- "{\n"
- " gl_FragColor = vec4(fragColour, 1.0);\n"
- "}\n";
-
- mProgramId = CreateProgram(glVertexShader, glFragmentShader);
-}
-
-void PhysicsDebugRenderer::RenderLines(const Dali::RenderCallbackInput& input)
+void PhysicsDebugRenderer::Render(const Dali::RenderCallbackInput& input)
{
mModelViewMatrix.SetIdentity();
mProjectionMatrix = input.projection;
Matrix::Multiply(mModelViewMatrix, mModelViewMatrix, input.view);
- glUseProgram(mProgramId);
// In theory, input.clippingBox should tell us the actor position in clip-space.
// But, it appears to be bugged.
- glBindBuffer(GL_ARRAY_BUFFER, mBufferId);
- glBufferData(GL_ARRAY_BUFFER, GLsizeiptr(mLines.size() * sizeof(VertexLine)), &mLines[0], GL_STATIC_DRAW);
-
- glVertexAttribPointer(mVertexLocation, 3, GL_FLOAT, GL_FALSE, 24, 0);
- glEnableVertexAttribArray(mVertexLocation);
- glVertexAttribPointer(mVertexColourLocation, 3, GL_FLOAT, GL_FALSE, 24, reinterpret_cast<const void*>(12));
- glEnableVertexAttribArray(mVertexColourLocation);
- glUniformMatrix4fv(mProjectionLocation, 1, GL_FALSE, mProjectionMatrix.AsFloat());
- glUniformMatrix4fv(mModelViewLocation, 1, GL_FALSE, mModelViewMatrix.AsFloat());
+ if(gPhysicsBulletGlesAddOn && mImpl)
+ {
+ gPhysicsBulletGlesAddOn->RenderLines(
+ *mImpl,
+ &mLines[0],
+ mLines.size() * sizeof(VertexLine),
+ mLines.size(),
+ mModelViewMatrix,
+ mProjectionMatrix);
+ }
- glDrawArrays(GL_LINES, 0, mLines.size());
mLines.clear();
}
#pragma once
/*
- * 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.
*/
// External includes
-#include <GLES3/gl3.h>
#include <LinearMath/btIDebugDraw.h>
#include <dali/dali.h>
namespace Dali::Toolkit::Physics::Internal
{
+namespace Gles
+{
+struct DebugRenderer;
+}
+
class PhysicsAdaptor;
class PhysicsDebugRenderer : public btIDebugDraw
*/
PhysicsDebugRenderer(uint32_t width, uint32_t height, Dali::CameraActor camera, PhysicsAdaptor* adaptor);
+ /**
+ * Destructor
+ */
+ ~PhysicsDebugRenderer() override;
+
public: // Inherited from btIDebugDraw
// Assume this is called during FrameCallback (i.e. in update manager, rather than during render...)
// Generate stack of lines... render, then clear stack.
private:
bool OnRender(const Dali::RenderCallbackInput& input);
- void Setup();
- void PrepareShader();
- void RenderLines(const Dali::RenderCallbackInput& input);
+ void Render(const Dali::RenderCallbackInput& input);
private:
CameraActor mCamera;
};
std::vector<VertexLine> mLines;
- Dali::Matrix mModelViewMatrix;
- Dali::Matrix mViewMatrix;
- Dali::Matrix mProjectionMatrix;
+ Dali::Matrix mModelViewMatrix;
+ Dali::Matrix mViewMatrix;
+ Dali::Matrix mProjectionMatrix;
+
int mWidth;
int mHeight;
PhysicsAdaptor& mAdaptor;
- GLint mVertexLocation;
- GLint mVertexColourLocation;
- GLint mProjectionLocation;
- GLint mModelViewLocation;
- GLuint mBufferId;
- GLuint mProgramId;
+
+ Gles::DebugRenderer* mImpl{nullptr};
};
} // namespace Dali::Toolkit::Physics::Internal
/*
- * 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.
GetRootActor()[Actor::Property::SIZE] = Vector3(worldSize.GetWidth(), worldSize.GetHeight(), 0);
auto world = static_cast<ChipmunkPhysicsWorld*>(mPhysicsWorld.get());
- if(world->HasDebugRenderer())
+ if(world->HasDebugRenderer() && mDebugActor)
{
Actor layer = mDebugActor.GetParent();
layer[Actor::Property::SIZE] = Vector3(worldSize);
--- /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.
+ */
+
+// External Includes
+#include <GLES3/gl3.h>
+#include <dali/devel-api/addons/addon-base.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/math/matrix.h>
+
+// Internal Includes
+#include <dali-physics/internal/physics-debug-renderer-gles.h>
+
+namespace Dali::Toolkit::Physics::Internal::Gles
+{
+struct DebugRenderer
+{
+ GLint mPositionLocation{-1};
+ GLint mUvsLocation{-1};
+ GLint mRadiusLocation{-1};
+ GLint mFillColourLocation{-1};
+ GLint mOutlineColourLocation{-1};
+ GLint mProjectionLocation{-1};
+ GLint mModelViewLocation{-1};
+ GLuint mIndexBufferId{0u};
+ GLuint mVertexBufferId{0u};
+ GLuint mProgramId{0u};
+};
+} // namespace Dali::Toolkit::Physics::Internal::Gles
+
+namespace
+{
+using DebugRenderer = Dali::Toolkit::Physics::Internal::Gles::DebugRenderer;
+const char* const DALI_PHYSICS_CHIPMUNK_GLES_ADDON_NAME("PhysicsChipmunkGlesAddOn");
+
+void PrepareShader(DebugRenderer& renderer)
+{
+ static const char glVertexShader[] =
+ "#version 300 es\n"
+ "in vec2 position;\n"
+ "in vec2 uvs;\n"
+ "in float radius;\n"
+ "in vec4 fillColor;\n"
+ "in vec4 outlineColor;\n"
+ "out vec2 v_uvs;\n"
+ "out vec4 v_fill;\n"
+ "out vec4 v_outline;\n"
+ "uniform mat4 projection;\n"
+ "uniform mat4 modelView;\n"
+ "void main()\n"
+ "{\n"
+ " gl_Position = projection * modelView * vec4(position.xy+radius*uvs, 0.0, 1.0);\n"
+ " v_uvs=uvs;\n"
+ " v_fill = fillColor;\n"
+ " v_fill.rgb *= v_fill.a;\n"
+ " v_outline = outlineColor;\n"
+ " v_outline.a *= v_outline.a;\n"
+ "}\n";
+
+ static const char glFragmentShader[] =
+ "#version 300 es\n"
+ "precision mediump float;\n"
+ "in vec2 v_uvs;\n"
+ "in vec4 v_fill;\n"
+ "in vec4 v_outline;\n"
+ "out vec4 fragColor;\n"
+ "void main()\n"
+ "{\n"
+ " float len=length(v_uvs);\n"
+ " float fw = length(vec2(dFdx(len), dFdy(len)));\n"
+ " float mask=smoothstep(-1.0, fw-1.0, -len);\n"
+ " float outline=1.0-fw;\n"
+ " float outline_mask=smoothstep(outline-fw, outline, len);\n"
+ " vec4 color = v_fill + (v_outline - v_fill*v_outline.a)*outline_mask;\n"
+ " fragColor = color*mask;\n"
+ "}\n";
+
+ renderer.mProgramId = Dali::Toolkit::Physics::Internal::Gles::CreateProgram(glVertexShader, glFragmentShader);
+}
+
+DebugRenderer* CreateGlesPhysicsDebugRenderer()
+{
+ return new DebugRenderer;
+}
+
+void DeleteGlesPhysicsDebugRenderer(DebugRenderer* renderer)
+{
+ delete renderer;
+}
+
+void SetViewport(int width, int height)
+{
+ glViewport(0, 0, width, height);
+}
+
+void Setup(DebugRenderer& renderer, int width, int height)
+{
+ PrepareShader(renderer);
+ renderer.mPositionLocation = glGetAttribLocation(renderer.mProgramId, "position");
+ renderer.mUvsLocation = glGetAttribLocation(renderer.mProgramId, "uvs");
+ renderer.mRadiusLocation = glGetAttribLocation(renderer.mProgramId, "radius");
+ renderer.mFillColourLocation = glGetAttribLocation(renderer.mProgramId, "fillColor");
+ renderer.mOutlineColourLocation = glGetAttribLocation(renderer.mProgramId, "outlineColor");
+
+ renderer.mProjectionLocation = glGetUniformLocation(renderer.mProgramId, "projection");
+ renderer.mModelViewLocation = glGetUniformLocation(renderer.mProgramId, "modelView");
+
+ glEnable(GL_DEPTH_TEST);
+ glViewport(0, 0, width, height);
+
+ glGenBuffers(1, &renderer.mIndexBufferId);
+ glGenBuffers(1, &renderer.mVertexBufferId);
+}
+
+void RenderLines(
+ DebugRenderer& renderer,
+ const void* indicesData,
+ std::size_t indicesDataSize,
+ int indicesCount,
+ const void* verticesData,
+ std::size_t verticesDataSize,
+ const Dali::Matrix& modelViewMatrix,
+ const Dali::Matrix& projectionMatrix)
+{
+ glUseProgram(renderer.mProgramId);
+
+ // In theory, input.clippingBox should tell us the actor position in clip-space.
+ // But, it appears to be bugged.
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, renderer.mIndexBufferId);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(indicesDataSize), indicesData, GL_STATIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, renderer.mVertexBufferId);
+ glBufferData(GL_ARRAY_BUFFER, GLsizeiptr(verticesDataSize), verticesData, GL_STATIC_DRAW);
+
+ GLint stride = 52; // 4*(2 + 2 + 1 + 4 + 4) = 4*13=52
+ glVertexAttribPointer(renderer.mPositionLocation, 2, GL_FLOAT, GL_FALSE, stride, 0);
+ glEnableVertexAttribArray(renderer.mPositionLocation);
+
+ glVertexAttribPointer(renderer.mUvsLocation, 2, GL_FLOAT, GL_FALSE, stride, (const void*)8);
+ glEnableVertexAttribArray(renderer.mUvsLocation);
+
+ glVertexAttribPointer(renderer.mRadiusLocation, 1, GL_FLOAT, GL_FALSE, stride, (const void*)16);
+ glEnableVertexAttribArray(renderer.mRadiusLocation);
+
+ glVertexAttribPointer(renderer.mFillColourLocation, 4, GL_FLOAT, GL_FALSE, stride, reinterpret_cast<const void*>(20));
+ glEnableVertexAttribArray(renderer.mFillColourLocation);
+ glVertexAttribPointer(renderer.mOutlineColourLocation, 4, GL_FLOAT, GL_FALSE, stride, reinterpret_cast<const void*>(36));
+ glEnableVertexAttribArray(renderer.mOutlineColourLocation);
+
+ glUniformMatrix4fv(renderer.mProjectionLocation, 1, GL_FALSE, projectionMatrix.AsFloat());
+ glUniformMatrix4fv(renderer.mModelViewLocation, 1, GL_FALSE, modelViewMatrix.AsFloat());
+
+ glDrawElements(GL_TRIANGLES, indicesCount, GL_UNSIGNED_SHORT, 0);
+}
+
+} // unnamed namespace
+
+class PhysicsChipmunkGlesAddOn : public Dali::AddOns::AddOnBase
+{
+public:
+ void GetAddOnInfo(Dali::AddOnInfo& info) override
+ {
+ info.type = Dali::AddOnType::GENERIC;
+ info.name = DALI_PHYSICS_CHIPMUNK_GLES_ADDON_NAME;
+ info.version = Dali::DALI_ADDON_VERSION(1, 0, 0);
+ info.next = nullptr;
+ }
+
+ /**
+ * Dispatch table for global functions
+ * @return
+ */
+ Dali::AddOns::DispatchTable* GetGlobalDispatchTable() override
+ {
+ static Dali::AddOns::DispatchTable dispatchTable{};
+ if(dispatchTable.Empty())
+ {
+ dispatchTable["CreateGlesPhysicsDebugRenderer"] = CreateGlesPhysicsDebugRenderer;
+ dispatchTable["DeleteGlesPhysicsDebugRenderer"] = DeleteGlesPhysicsDebugRenderer;
+ dispatchTable["SetViewport"] = SetViewport;
+ dispatchTable["Setup"] = Setup;
+ dispatchTable["RenderLines"] = RenderLines;
+ }
+ return &dispatchTable;
+ }
+
+ /**
+ * Dispatch table for instance functions
+ * @return
+ */
+ Dali::AddOns::DispatchTable* GetInstanceDispatchTable() override
+ {
+ return nullptr;
+ }
+};
+
+REGISTER_ADDON_CLASS(PhysicsChipmunkGlesAddOn);
/*
- * 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.
* limitations under the License.
*/
+// External Includes
#include <chipmunk/chipmunk.h>
+#include <dali/devel-api/common/addon-binder.h>
+#include <dali/public-api/adaptor-framework/graphics-backend.h>
+
+// Internal Includes
#include <dali-physics/internal/chipmunk-impl/chipmunk-physics-adaptor-impl.h>
#include <dali-physics/internal/chipmunk-impl/chipmunk-physics-debug-renderer.h>
-namespace
+namespace Dali::Toolkit::Physics::Internal
{
-GLuint LoadShader(GLenum shaderType, const char* shaderSource)
+namespace
{
- GLuint shader = glCreateShader(shaderType);
- if(shader != 0)
- {
- glShaderSource(shader, 1, &shaderSource, NULL);
- glCompileShader(shader);
- GLint compiled = 0;
- glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
- if(compiled != GL_TRUE)
- {
- GLint infoLen = 0;
- glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
-
- if(infoLen > 0)
- {
- std::vector<char> logBuffer;
- logBuffer.resize(infoLen + 1);
- glGetShaderInfoLog(shader, infoLen, NULL, &logBuffer[0]);
- fprintf(stderr, "%s\n", &logBuffer[0]);
- fflush(stderr);
-
- glDeleteShader(shader);
- shader = 0;
- }
- }
- }
- return shader;
-}
+const char* const DALI_PHYSICS_CHIPMUNK_GLES_SO("libdali2-physics-2d-gles.so");
+const char* const DALI_PHYSICS_CHIPMUNK_GLES_ADDON_NAME("PhysicsChipmunkGlesAddOn");
-GLuint CreateProgram(const char* vertexSource, const char* fragmentSource)
+struct PhysicsChipmunkGlesAddOn : public Dali::AddOn::AddOnBinder
{
- GLuint vertexShader = LoadShader(GL_VERTEX_SHADER, vertexSource);
- if(!vertexShader)
- {
- return 0;
- }
- GLuint fragmentShader = LoadShader(GL_FRAGMENT_SHADER, fragmentSource);
- if(!fragmentShader)
- {
- return 0;
- }
- GLuint program = glCreateProgram();
- if(program)
+ PhysicsChipmunkGlesAddOn()
+ : Dali::AddOn::AddOnBinder(DALI_PHYSICS_CHIPMUNK_GLES_ADDON_NAME, DALI_PHYSICS_CHIPMUNK_GLES_SO)
{
- glAttachShader(program, vertexShader);
- glAttachShader(program, fragmentShader);
- glLinkProgram(program);
- GLint linkStatus = GL_FALSE;
- glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
- if(linkStatus != GL_TRUE)
- {
- GLint bufLength = 0;
- glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
- if(bufLength)
- {
- std::vector<char> logBuffer;
- logBuffer.resize(bufLength + 1);
- glGetProgramInfoLog(program, bufLength, NULL, &logBuffer[0]);
- fprintf(stderr, "%s\n", &logBuffer[0]);
- fflush(stderr);
- }
- glDeleteProgram(program);
- program = 0;
- }
}
- return program;
-}
+
+ ~PhysicsChipmunkGlesAddOn() = default;
+
+ ADDON_BIND_FUNCTION(CreateGlesPhysicsDebugRenderer, Gles::DebugRenderer*());
+ ADDON_BIND_FUNCTION(DeleteGlesPhysicsDebugRenderer, void(Gles::DebugRenderer*));
+ ADDON_BIND_FUNCTION(SetViewport, void(int, int));
+ ADDON_BIND_FUNCTION(Setup, void(Gles::DebugRenderer&, int, int));
+ ADDON_BIND_FUNCTION(RenderLines, void(Gles::DebugRenderer&, const void*, std::size_t, int, const void*, std::size_t, const Dali::Matrix&, const Dali::Matrix&));
+};
+
+std::unique_ptr<PhysicsChipmunkGlesAddOn> gPhysicsChipmunkGlesAddOn;
} // namespace
-namespace Dali::Toolkit::Physics::Internal
-{
static void DebugDrawCircleImpl(cpVect pos, cpFloat angle, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer data)
{
auto debugRenderer = static_cast<PhysicsDebugRenderer*>(data);
: mCamera(camera),
mWidth(width),
mHeight(height),
- mAdaptor(*adaptor),
- mPositionLocation(-1),
- mUvsLocation(-1),
- mRadiusLocation(-1),
- mFillColourLocation(-1),
- mOutlineColourLocation(-1),
- mProjectionLocation(-1),
- mModelViewLocation(-1),
- mIndexBufferId(0u),
- mVertexBufferId(0u),
- mProgramId(0u)
+ mAdaptor(*adaptor)
{
mDebugDrawOptions.drawCircle = DebugDrawCircleImpl;
mDebugDrawOptions.drawSegment = DebugDrawSegmentImpl;
mDebugDrawOptions.constraintColor = cpSpaceDebugColor{0.5f, 0.5f, 0.5f, 0.9f};
mDebugDrawOptions.collisionPointColor = cpSpaceDebugColor{1.0f, 0.0f, 0.0f, 1.0f};
mDebugDrawOptions.data = this;
+
+ if(Graphics::GetCurrentGraphicsBackend() == Graphics::Backend::GLES)
+ {
+ if(!gPhysicsChipmunkGlesAddOn)
+ {
+ gPhysicsChipmunkGlesAddOn.reset(new PhysicsChipmunkGlesAddOn);
+ }
+ DALI_ASSERT_ALWAYS(gPhysicsChipmunkGlesAddOn && "Cannot load the Chipmunk Debug Renderer Gles Addon\n");
+ mImpl = gPhysicsChipmunkGlesAddOn->CreateGlesPhysicsDebugRenderer();
+ }
+}
+
+PhysicsDebugRenderer::~PhysicsDebugRenderer()
+{
+ if(gPhysicsChipmunkGlesAddOn)
+ {
+ gPhysicsChipmunkGlesAddOn->DeleteGlesPhysicsDebugRenderer(mImpl);
+ mImpl = nullptr;
+ }
}
bool PhysicsDebugRenderer::OnRender(const Dali::RenderCallbackInput& input)
{
if(mState == State::INIT)
{
- Setup();
+ if(gPhysicsChipmunkGlesAddOn && mImpl)
+ {
+ gPhysicsChipmunkGlesAddOn->Setup(*mImpl, mWidth, mHeight);
+ }
mState = State::RENDER;
}
- glViewport(0, 0, mWidth, mHeight);
- RenderLines(input);
+ if(gPhysicsChipmunkGlesAddOn)
+ {
+ gPhysicsChipmunkGlesAddOn->SetViewport(mWidth, mHeight);
+ }
+ Render(input);
return false;
}
-// Run on first invocation of callback
-void PhysicsDebugRenderer::Setup()
-{
- PrepareShader();
- mPositionLocation = glGetAttribLocation(mProgramId, "position");
- mUvsLocation = glGetAttribLocation(mProgramId, "uvs");
- mRadiusLocation = glGetAttribLocation(mProgramId, "radius");
- mFillColourLocation = glGetAttribLocation(mProgramId, "fillColor");
- mOutlineColourLocation = glGetAttribLocation(mProgramId, "outlineColor");
-
- mProjectionLocation = glGetUniformLocation(mProgramId, "projection");
- mModelViewLocation = glGetUniformLocation(mProgramId, "modelView");
-
- glEnable(GL_DEPTH_TEST);
- glViewport(0, 0, mWidth, mHeight);
-
- glGenBuffers(1, &mIndexBufferId);
- glGenBuffers(1, &mVertexBufferId);
-}
-
void PhysicsDebugRenderer::UpdateWindowSize(Dali::Vector2 size)
{
mWidth = size.width;
mHeight = size.height;
}
-void PhysicsDebugRenderer::PrepareShader()
-{
- static const char glVertexShader[] =
- "#version 300 es\n"
- "in vec2 position;\n"
- "in vec2 uvs;\n"
- "in float radius;\n"
- "in vec4 fillColor;\n"
- "in vec4 outlineColor;\n"
- "out vec2 v_uvs;\n"
- "out vec4 v_fill;\n"
- "out vec4 v_outline;\n"
- "uniform mat4 projection;\n"
- "uniform mat4 modelView;\n"
- "void main()\n"
- "{\n"
- " gl_Position = projection * modelView * vec4(position.xy+radius*uvs, 0.0, 1.0);\n"
- " v_uvs=uvs;\n"
- " v_fill = fillColor;\n"
- " v_fill.rgb *= v_fill.a;\n"
- " v_outline = outlineColor;\n"
- " v_outline.a *= v_outline.a;\n"
- "}\n";
-
- static const char glFragmentShader[] =
- "#version 300 es\n"
- "precision mediump float;\n"
- "in vec2 v_uvs;\n"
- "in vec4 v_fill;\n"
- "in vec4 v_outline;\n"
- "out vec4 fragColor;\n"
- "void main()\n"
- "{\n"
- " float len=length(v_uvs);\n"
- " float fw = length(vec2(dFdx(len), dFdy(len)));\n"
- " float mask=smoothstep(-1.0, fw-1.0, -len);\n"
- " float outline=1.0-fw;\n"
- " float outline_mask=smoothstep(outline-fw, outline, len);\n"
- " vec4 color = v_fill + (v_outline - v_fill*v_outline.a)*outline_mask;\n"
- " fragColor = color*mask;\n"
- "}\n";
-
- mProgramId = CreateProgram(glVertexShader, glFragmentShader);
-}
-
-void PhysicsDebugRenderer::RenderLines(const Dali::RenderCallbackInput& input)
+void PhysicsDebugRenderer::Render(const Dali::RenderCallbackInput& input)
{
mModelViewMatrix.SetIdentity();
mProjectionMatrix = input.projection;
Matrix::Multiply(mModelViewMatrix, mModelViewMatrix, input.view);
- glUseProgram(mProgramId);
// In theory, input.clippingBox should tell us the actor position in clip-space.
// But, it appears to be bugged.
- glEnable(GL_BLEND);
- glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBufferId);
- glBufferData(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(mIndices.size() * sizeof(uint16_t)), &mIndices[0], GL_STATIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER, mVertexBufferId);
- glBufferData(GL_ARRAY_BUFFER, GLsizeiptr(mVertices.size() * sizeof(Vertex)), &mVertices[0], GL_STATIC_DRAW);
- GLint stride = 52; // 4*(2 + 2 + 1 + 4 + 4) = 4*13=52
- glVertexAttribPointer(mPositionLocation, 2, GL_FLOAT, GL_FALSE, stride, 0);
- glEnableVertexAttribArray(mPositionLocation);
-
- glVertexAttribPointer(mUvsLocation, 2, GL_FLOAT, GL_FALSE, stride, (const void*)8);
- glEnableVertexAttribArray(mUvsLocation);
-
- glVertexAttribPointer(mRadiusLocation, 1, GL_FLOAT, GL_FALSE, stride, (const void*)16);
- glEnableVertexAttribArray(mRadiusLocation);
-
- glVertexAttribPointer(mFillColourLocation, 4, GL_FLOAT, GL_FALSE, stride, reinterpret_cast<const void*>(20));
- glEnableVertexAttribArray(mFillColourLocation);
- glVertexAttribPointer(mOutlineColourLocation, 4, GL_FLOAT, GL_FALSE, stride, reinterpret_cast<const void*>(36));
- glEnableVertexAttribArray(mOutlineColourLocation);
-
- glUniformMatrix4fv(mProjectionLocation, 1, GL_FALSE, mProjectionMatrix.AsFloat());
- glUniformMatrix4fv(mModelViewLocation, 1, GL_FALSE, mModelViewMatrix.AsFloat());
+ if(gPhysicsChipmunkGlesAddOn && mImpl)
+ {
+ gPhysicsChipmunkGlesAddOn->RenderLines(
+ *mImpl,
+ &mIndices[0],
+ mIndices.size() * sizeof(uint16_t),
+ mIndices.size(),
+ &mVertices[0],
+ mVertices.size() * sizeof(Vertex),
+ mModelViewMatrix,
+ mProjectionMatrix);
+ }
- glDrawElements(GL_TRIANGLES, mIndices.size(), GL_UNSIGNED_SHORT, 0);
mIndices.clear();
mVertices.clear();
}
#pragma once
/*
- * 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.
* limitations under the License.
*/
-#include <GLES3/gl3.h>
#include <chipmunk/chipmunk.h>
#include <dali/dali.h>
namespace Dali::Toolkit::Physics::Internal
{
+namespace Gles
+{
+struct DebugRenderer;
+}
+
class PhysicsAdaptor;
class PhysicsDebugRenderer
*/
PhysicsDebugRenderer(uint32_t width, uint32_t height, Dali::CameraActor camera, PhysicsAdaptor* adaptor);
+ /**
+ * Destructor
+ */
+ ~PhysicsDebugRenderer();
+
/**
* Get the drawing options struct ( construct only )
*/
bool OnRender(const Dali::RenderCallbackInput& input);
void Setup();
void PrepareShader();
- void RenderLines(const Dali::RenderCallbackInput& input);
+ void Render(const Dali::RenderCallbackInput& input);
Vertex* PushVertices(uint32_t vertexCount, uint32_t indexCount, const uint16_t* indices);
Vertex MakeVertex(cpVect pos, float u, float v, float r, Vector4 fill, Vector4 outline);
int mHeight;
PhysicsAdaptor& mAdaptor;
- float mPointLineScale{2.0f};
- GLint mPositionLocation;
- GLint mUvsLocation;
- GLint mRadiusLocation;
- GLint mFillColourLocation;
- GLint mOutlineColourLocation;
- GLint mProjectionLocation;
- GLint mModelViewLocation;
- GLuint mIndexBufferId;
- GLuint mVertexBufferId;
- GLuint mProgramId;
+ float mPointLineScale{2.0f};
+
+ Gles::DebugRenderer* mImpl{nullptr};
};
} // namespace Dali::Toolkit::Physics::Internal
${physics_internal_dir}/physics-world-impl.cpp
)
+set(physics2d_gles_src_files
+ ${physics2d_internal_dir}/chipmunk-physics-debug-renderer-gles.cpp
+ ${physics_internal_dir}/physics-debug-renderer-gles.cpp
+)
+
set(physics3d_src_files ${physics_src_files}
${physics3d_internal_dir}/bullet-physics-actor-impl.cpp
${physics3d_internal_dir}/bullet-physics-adaptor-impl.cpp
${physics_internal_dir}/physics-adaptor-impl.cpp
${physics_internal_dir}/physics-world-impl.cpp
)
+
+set(physics3d_gles_src_files
+ ${physics3d_internal_dir}/bullet-physics-debug-renderer-gles.cpp
+ ${physics_internal_dir}/physics-debug-renderer-gles.cpp
+)
--- /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.
+ */
+
+// Header
+#include <dali-physics/internal/physics-debug-renderer-gles.h>
+
+// External Includes
+#include <GLES3/gl3.h>
+#include <cstdio>
+#include <vector>
+
+namespace Dali::Toolkit::Physics::Internal::Gles
+{
+namespace
+{
+GLuint LoadShader(GLenum shaderType, const char* shaderSource)
+{
+ GLuint shader = glCreateShader(shaderType);
+ if(shader != 0)
+ {
+ glShaderSource(shader, 1, &shaderSource, NULL);
+ glCompileShader(shader);
+ GLint compiled = 0;
+ glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ if(compiled != GL_TRUE)
+ {
+ GLint infoLen = 0;
+ glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+
+ if(infoLen > 0)
+ {
+ std::vector<char> logBuffer;
+ logBuffer.resize(infoLen + 1);
+ glGetShaderInfoLog(shader, infoLen, NULL, &logBuffer[0]);
+ fprintf(stderr, "%s\n", &logBuffer[0]);
+ fflush(stderr);
+
+ glDeleteShader(shader);
+ shader = 0;
+ }
+ }
+ }
+ return shader;
+}
+} // unnamed namespace
+
+GLuint CreateProgram(const char* vertexSource, const char* fragmentSource)
+{
+ GLuint vertexShader = LoadShader(GL_VERTEX_SHADER, vertexSource);
+ if(!vertexShader)
+ {
+ return 0;
+ }
+ GLuint fragmentShader = LoadShader(GL_FRAGMENT_SHADER, fragmentSource);
+ if(!fragmentShader)
+ {
+ return 0;
+ }
+ GLuint program = glCreateProgram();
+ if(program)
+ {
+ glAttachShader(program, vertexShader);
+ glAttachShader(program, fragmentShader);
+ glLinkProgram(program);
+ GLint linkStatus = GL_FALSE;
+ glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+ if(linkStatus != GL_TRUE)
+ {
+ GLint bufLength = 0;
+ glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
+ if(bufLength)
+ {
+ std::vector<char> logBuffer;
+ logBuffer.resize(bufLength + 1);
+ glGetProgramInfoLog(program, bufLength, NULL, &logBuffer[0]);
+ fprintf(stderr, "%s\n", &logBuffer[0]);
+ fflush(stderr);
+ }
+ glDeleteProgram(program);
+ program = 0;
+ }
+ }
+ return program;
+}
+
+} // namespace Dali::Toolkit::Physics::Internal::Gles
--- /dev/null
+#pragma once
+
+/*
+ * 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 <GLES3/gl3.h>
+
+namespace Dali::Toolkit::Physics::Internal::Gles
+{
+/**
+ * Given the vertex and the fragment source, compiles them and creates the program.
+ * @param vertexSource The vertex shader
+ * @param fragmentSource The fragment shader
+ * @return The program ID.
+ */
+GLuint CreateProgram(const char* vertexSource, const char* fragmentSource);
+} // namespace Dali::Toolkit::Physics::Internal::Gles
#include <dali/public-api/rendering/texture.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
+#include <dali-toolkit/internal/gles-addon/builtin-shader-extern-gen.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
namespace Dali
GlView::GlView(Dali::Toolkit::GlView::ColorFormat colorFormat)
: Dali::Toolkit::Internal::GlViewImpl(Toolkit::GlView::BackendMode::EGL_IMAGE_OFFSCREEN_RENDERING),
- mRenderThread(nullptr),
- mNativeImageQueue(nullptr),
- mRenderingMode(Toolkit::GlView::RenderingMode::CONTINUOUS),
- mColorFormat(colorFormat),
- mDepth(false),
- mStencil(false),
- mMSAA(0)
+ mColorFormat(colorFormat)
{
}
}
}
-Dali::Toolkit::GlView::RenderingMode GlView::GetRenderingMode() const
-{
- return mRenderingMode;
-}
-
void GlView::RenderOnce()
{
if(mRenderThread)
Actor self = Self();
if(mRenderThread)
{
- if(visible && DevelWindow::Get(self).IsVisible())
+ auto window = DevelWindow::Get(self);
+ if(visible && window && window.IsVisible())
{
mRenderThread->Resume();
}
#define DALI_TOOLKIT_INTERNAL_GL_VIEW_H
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/**
* @copydoc Dali::Toolkit::GlView::GetRenderingMode()
*/
- Dali::Toolkit::GlView::RenderingMode GetRenderingMode() const override;
+ Dali::Toolkit::GlView::RenderingMode GetRenderingMode() const override
+ {
+ return mRenderingMode;
+ }
/**
* @copydoc Dali::Toolkit::GlView::RenderOnce()
private:
std::unique_ptr<GlViewRenderThread> mRenderThread;
Dali::NativeImageSourceQueuePtr mNativeImageQueue;
- Dali::Toolkit::GlView::RenderingMode mRenderingMode;
- Dali::Toolkit::GlView::ColorFormat mColorFormat;
-
- bool mDepth;
- bool mStencil;
- int mMSAA;
+ Dali::Toolkit::GlView::RenderingMode mRenderingMode{Toolkit::GlView::RenderingMode::CONTINUOUS};
+ Dali::Toolkit::GlView::ColorFormat mColorFormat{Toolkit::GlView::ColorFormat::RGB888};
+ bool mDepth{false};
+ bool mStencil{false};
+ int mMSAA{0};
};
} // namespace Internal
${toolkit_src_dir}/controls/gl-view/drawable-view-native-renderer.cpp
${toolkit_src_dir}/controls/gl-view/gl-view-impl.cpp
${toolkit_src_dir}/controls/gl-view/gl-view-render-thread.cpp
+ ${toolkit_src_dir}/gles-addon/gles-addon.cpp
)
SET( SOURCES ${SOURCES}
--- /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.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/addons/addon-base.h>
+#include <dali/integration-api/debug.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/controls/gl-view/drawable-view-impl.h>
+#include <dali-toolkit/internal/controls/gl-view/gl-view-impl.h>
+#include <dali-toolkit/public-api/controls/gl-view/gl-view.h>
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+using BackendMode = GlView::BackendMode;
+using GlViewImpl = Dali::Toolkit::Internal::GlViewImpl;
+
+namespace
+{
+const char* const DALI_TOOLKIT_GLES_ADDON_NAME("ToolkitGlesAddOn");
+
+GlView GlViewNew(BackendMode backendMode, GlView::ColorFormat colorFormat)
+{
+ switch(backendMode)
+ {
+ case BackendMode::DIRECT_RENDERING:
+ case BackendMode::DIRECT_RENDERING_THREADED:
+ case BackendMode::UNSAFE_DIRECT_RENDERING:
+ {
+ return Toolkit::Internal::DrawableView::New(backendMode);
+ }
+ case BackendMode::EGL_IMAGE_OFFSCREEN_RENDERING:
+ {
+ return Toolkit::Internal::GlView::New(colorFormat);
+ }
+ default:
+ {
+ DALI_ABORT("Invalid BackendMode");
+ }
+ }
+}
+
+void GlViewRegisterGlCallbacks(
+ GlViewImpl&& glView,
+ CallbackBase* initCallback,
+ CallbackBase* renderFrameCallback,
+ CallbackBase* terminateCallback)
+{
+ glView.RegisterGlCallbacks(initCallback, renderFrameCallback, terminateCallback);
+}
+
+void GlViewSetResizeCallback(GlViewImpl& glViewImpl, CallbackBase* resizeCallback)
+{
+ glViewImpl.SetResizeCallback(resizeCallback);
+}
+
+bool GlViewSetGraphicsConfig(
+ GlViewImpl& glViewImpl,
+ bool depth,
+ bool stencil,
+ int msaa,
+ GlView::GraphicsApiVersion version)
+{
+ return glViewImpl.SetGraphicsConfig(depth, stencil, msaa, version);
+}
+
+void GlViewSetRenderingMode(GlViewImpl& glViewImpl, GlView::RenderingMode mode)
+{
+ glViewImpl.SetRenderingMode(mode);
+}
+
+GlView::RenderingMode GlViewGetRenderingMode(const GlViewImpl&& glViewImpl)
+{
+ return glViewImpl.GetRenderingMode();
+}
+
+BackendMode GlViewGetBackendMode(const GlViewImpl&& glViewImpl)
+{
+ return glViewImpl.GetBackendMode();
+}
+
+void GlViewRenderOnce(GlViewImpl&& glViewImpl)
+{
+ glViewImpl.RenderOnce();
+}
+
+void GlViewBindTextureResources(GlViewImpl&& glViewImpl, std::vector<Dali::Texture> textures)
+{
+ glViewImpl.BindTextureResources(std::move(textures));
+}
+} // unnamed namespace
+
+class ToolkitGlesAddOn : public Dali::AddOns::AddOnBase
+{
+public:
+ void GetAddOnInfo(Dali::AddOnInfo& info) override
+ {
+ info.type = Dali::AddOnType::GENERIC;
+ info.name = DALI_TOOLKIT_GLES_ADDON_NAME;
+ info.version = Dali::DALI_ADDON_VERSION(1, 0, 0);
+ info.next = nullptr;
+ }
+
+ /**
+ * Dispatch table for global functions
+ * @return
+ */
+ Dali::AddOns::DispatchTable* GetGlobalDispatchTable() override
+ {
+ static Dali::AddOns::DispatchTable dispatchTable{};
+ if(dispatchTable.Empty())
+ {
+ dispatchTable["GlViewNew"] = GlViewNew;
+ dispatchTable["GlViewRegisterGlCallbacks"] = GlViewRegisterGlCallbacks;
+ dispatchTable["GlViewSetResizeCallback"] = GlViewSetResizeCallback;
+ dispatchTable["GlViewSetGraphicsConfig"] = GlViewSetGraphicsConfig;
+ dispatchTable["GlViewSetRenderingMode"] = GlViewSetRenderingMode;
+ dispatchTable["GlViewGetRenderingMode"] = GlViewGetRenderingMode;
+ dispatchTable["GlViewGetBackendMode"] = GlViewGetBackendMode;
+ dispatchTable["GlViewRenderOnce"] = GlViewRenderOnce;
+ dispatchTable["GlViewBindTextureResources"] = GlViewBindTextureResources;
+ }
+ return &dispatchTable;
+ }
+
+ /**
+ * Dispatch table for instance functions
+ * @return
+ */
+ Dali::AddOns::DispatchTable* GetInstanceDispatchTable() override
+ {
+ return nullptr;
+ }
+};
+
+REGISTER_ADDON_CLASS(ToolkitGlesAddOn);
--- /dev/null
+//@name gl-view.frag
+
+//@version 100
+INPUT mediump vec2 vTexCoord;
+UNIFORM samplerExternalOES sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
+
+void main()
+{
+ gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
+}
\ No newline at end of file
--- /dev/null
+//@name gl-view.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump vec3 uSize;
+};
+OUTPUT mediump vec2 vTexCoord;
+
+void main()
+{
+ vec4 position = vec4(aPosition, 0.0, 1.0) * vec4(uSize, 1.0);
+ vTexCoord = aPosition + vec2(0.5);
+ gl_Position = uMvpMatrix * position;
+}
\ No newline at end of file
+++ /dev/null
-//@name gl-view.frag
-
-//@version 100
-INPUT mediump vec2 vTexCoord;
-UNIFORM samplerExternalOES sTexture;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
-
-void main()
-{
- gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
-}
\ No newline at end of file
+++ /dev/null
-//@name gl-view.vert
-
-//@version 100
-
-INPUT mediump vec2 aPosition;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump vec3 uSize;
-};
-OUTPUT mediump vec2 vTexCoord;
-
-void main()
-{
- vec4 position = vec4(aPosition, 0.0, 1.0) * vec4(uSize, 1.0);
- vTexCoord = aPosition + vec2(0.5);
- gl_Position = uMvpMatrix * position;
-}
\ No newline at end of file
#include <dali-toolkit/public-api/controls/gl-view/gl-view.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/controls/gl-view/drawable-view-impl.h>
#include <dali-toolkit/internal/controls/gl-view/gl-view-impl.h>
+// EXTERNAL INCLUDES
+#include <dali/devel-api/common/addon-binder.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/adaptor-framework/graphics-backend.h>
+#include <dlfcn.h>
+#include <memory>
+
namespace Dali::Toolkit
{
+namespace
+{
+const char* const DALI_TOOLKIT_GLES_SO("libdali2-toolkit-gles.so");
+const char* const DALI_TOOLKIT_GLES_ADDON_NAME("ToolkitGlesAddOn");
+
+struct ToolkitGlesAddOn : public Dali::AddOn::AddOnBinder
+{
+ ToolkitGlesAddOn()
+ : Dali::AddOn::AddOnBinder(DALI_TOOLKIT_GLES_ADDON_NAME, DALI_TOOLKIT_GLES_SO)
+ {
+ }
+ ~ToolkitGlesAddOn() = default;
+
+ ADDON_BIND_FUNCTION(GlViewNew, GlView(GlView::BackendMode, GlView::ColorFormat));
+ ADDON_BIND_FUNCTION(GlViewRegisterGlCallbacks, void(Internal::GlViewImpl&, CallbackBase*, CallbackBase*, CallbackBase*));
+ ADDON_BIND_FUNCTION(GlViewSetResizeCallback, void(Internal::GlViewImpl&, CallbackBase*));
+ ADDON_BIND_FUNCTION(GlViewSetGraphicsConfig, bool(Internal::GlViewImpl&, bool, bool, int, GlView::GraphicsApiVersion));
+ ADDON_BIND_FUNCTION(GlViewSetRenderingMode, void(Internal::GlViewImpl&, GlView::RenderingMode));
+ ADDON_BIND_FUNCTION(GlViewGetRenderingMode, GlView::RenderingMode(const Internal::GlViewImpl&));
+ ADDON_BIND_FUNCTION(GlViewGetBackendMode, GlView::BackendMode(const Internal::GlViewImpl&));
+ ADDON_BIND_FUNCTION(GlViewRenderOnce, void(Internal::GlViewImpl&));
+ ADDON_BIND_FUNCTION(GlViewBindTextureResources, void(Internal::GlViewImpl&, std::vector<Dali::Texture>));
+};
+
+std::unique_ptr<ToolkitGlesAddOn> gToolkitGlesAddon;
+} // namespace
+
GlView::GlView() = default;
GlView::GlView(const GlView& GlView) = default;
GlView GlView::New(ColorFormat colorFormat)
{
- // This function is backward compatible and always returns
- // backend based on NativeImage.
- return Internal::GlView::New(colorFormat);
+ return New(BackendMode::EGL_IMAGE_OFFSCREEN_RENDERING, colorFormat);
}
GlView GlView::New(BackendMode backendMode, ColorFormat colorFormat)
{
- switch(backendMode)
+ if(Graphics::GetCurrentGraphicsBackend() == Graphics::Backend::GLES)
{
- case BackendMode::DIRECT_RENDERING:
- case BackendMode::DIRECT_RENDERING_THREADED:
- case BackendMode::UNSAFE_DIRECT_RENDERING:
- {
- return Internal::DrawableView::New(backendMode);
- }
- case BackendMode::EGL_IMAGE_OFFSCREEN_RENDERING:
- {
- return Internal::GlView::New(colorFormat);
- }
- default:
+ if(!gToolkitGlesAddon)
{
- DALI_ASSERT_ALWAYS("Invalid BackendMode");
+ gToolkitGlesAddon.reset(new ToolkitGlesAddOn);
}
+ DALI_ASSERT_ALWAYS(gToolkitGlesAddon && "Cannot load the GlView Addon\n");
+ return gToolkitGlesAddon->GlViewNew(backendMode, colorFormat);
}
- return {};
+ DALI_ABORT("Current Graphics Backend does not support GlView\n");
}
GlView GlView::DownCast(BaseHandle handle)
void GlView::RegisterGlCallbacks(CallbackBase* initCallback, CallbackBase* renderFrameCallback, CallbackBase* terminateCallback)
{
- Dali::Toolkit::GetImpl(*this).RegisterGlCallbacks(initCallback, renderFrameCallback, terminateCallback);
+ Internal::GlViewImpl& impl = GetImpl(*this); // Get Impl here to catch uninitialized usage
+ if(gToolkitGlesAddon)
+ {
+ gToolkitGlesAddon->GlViewRegisterGlCallbacks(impl, initCallback, renderFrameCallback, terminateCallback);
+ }
}
void GlView::SetResizeCallback(CallbackBase* resizeCallback)
{
- Dali::Toolkit::GetImpl(*this).SetResizeCallback(resizeCallback);
+ Internal::GlViewImpl& impl = GetImpl(*this); // Get Impl here to catch uninitialized usage
+ if(gToolkitGlesAddon)
+ {
+ gToolkitGlesAddon->GlViewSetResizeCallback(impl, resizeCallback);
+ }
}
bool GlView::SetGraphicsConfig(bool depth, bool stencil, int msaa, GraphicsApiVersion version)
{
- return Dali::Toolkit::GetImpl(*this).SetGraphicsConfig(depth, stencil, msaa, version);
+ Internal::GlViewImpl& impl = GetImpl(*this); // Get Impl here to catch uninitialized usage
+ return gToolkitGlesAddon ? gToolkitGlesAddon->GlViewSetGraphicsConfig(impl, depth, stencil, msaa, version) : false;
}
void GlView::SetRenderingMode(RenderingMode mode)
{
- Dali::Toolkit::GetImpl(*this).SetRenderingMode(mode);
+ Internal::GlViewImpl& impl = GetImpl(*this);
+ if(gToolkitGlesAddon)
+ {
+ gToolkitGlesAddon->GlViewSetRenderingMode(impl, mode);
+ }
}
Dali::Toolkit::GlView::RenderingMode GlView::GetRenderingMode() const
{
- return Dali::Toolkit::GetImpl(*this).GetRenderingMode();
+ const Internal::GlViewImpl& impl = GetImpl(*this); // Get Impl here to catch uninitialized usage
+ return gToolkitGlesAddon ? gToolkitGlesAddon->GlViewGetRenderingMode(impl) : RenderingMode::CONTINUOUS;
}
Dali::Toolkit::GlView::BackendMode GlView::GetBackendMode() const
{
- return Dali::Toolkit::GetImpl(*this).GetBackendMode();
+ const Internal::GlViewImpl& impl = GetImpl(*this); // Get Impl here to catch uninitialized usage
+ return gToolkitGlesAddon ? gToolkitGlesAddon->GlViewGetBackendMode(impl) : BackendMode::DEFAULT;
}
void GlView::RenderOnce()
{
- Dali::Toolkit::GetImpl(*this).RenderOnce();
+ Internal::GlViewImpl& impl = GetImpl(*this); // Get Impl here to catch uninitialized usage
+ if(gToolkitGlesAddon)
+ {
+ gToolkitGlesAddon->GlViewRenderOnce(impl);
+ }
}
void GlView::BindTextureResources(std::vector<Dali::Texture> textures)
{
- Dali::Toolkit::GetImpl(*this).BindTextureResources(std::move(textures));
+ Internal::GlViewImpl& impl = GetImpl(*this); // Get Impl here to catch uninitialized usage
+ if(gToolkitGlesAddon)
+ {
+ gToolkitGlesAddon->GlViewBindTextureResources(impl, std::move(textures));
+ }
}
GlView::GlView(Internal::GlViewImpl& implementation)
*
* @SINCE_2_0.45
*/
- DALI_INTERNAL GlView(Internal::GlViewImpl& implementation);
+ GlView(Internal::GlViewImpl& implementation);
/**
* @brief Allows the creation of this GlView from an Internal::CustomActor pointer.
*
* @SINCE_2_0.45
*/
- DALI_INTERNAL GlView(Dali::Internal::CustomActor* internal);
+ GlView(Dali::Internal::CustomActor* internal);
/// @endcond
};
${public_api_src_dir}/controls/buttons/push-button.cpp
${public_api_src_dir}/controls/buttons/radio-button.cpp
${public_api_src_dir}/controls/flex-container/flex-container.cpp
+ ${public_api_src_dir}/controls/gl-view/gl-view.cpp
${public_api_src_dir}/controls/image-view/image-view.cpp
${public_api_src_dir}/controls/model3d-view/model3d-view.cpp
${public_api_src_dir}/controls/progress-bar/progress-bar.cpp
${public_api_src_dir}/enums.cpp
)
-SET(public_api_egl_src_files
- ${public_api_src_dir}/controls/gl-view/gl-view.cpp
-)
-
# Add public header files here
SET( public_api_header_files
${public_api_src_dir}/dali-toolkit-version.h
-DCMAKE_INSTALL_PREFIX=%{_prefix} \
-DCMAKE_INSTALL_LIBDIR=%{_libdir} \
-DCMAKE_INSTALL_INCLUDEDIR=%{_includedir} \
- -DENABLE_I18N=ON
+ -DENABLE_I18N=ON \
+ .
make %{?jobs:-j%jobs}
%endif
%defattr(-,root,root,-)
%{_libdir}/libdali2-toolkit.so*
+%{_libdir}/libdali2-toolkit-gles.so*
%license LICENSE
%files devel
%defattr(-,root,root,-)
%{_libdir}/libchipmunk.so*
%{_libdir}/libdali2-physics-2d.so*
+%{_libdir}/libdali2-physics-2d-gles.so*
%license LICENSE
%files -n %{dali2_physics2d}-devel
%defattr(-,root,root,-)
%{_libdir}/libbullet3.so*
%{_libdir}/libdali2-physics-3d.so*
+%{_libdir}/libdali2-physics-3d-gles.so*
%license LICENSE
%files -n %{dali2_physics3d}-devel
%files -n %{dali2_usdloader}-devel
%defattr(-,root,root,-)
%{_libdir}/pkgconfig/dali2-usd-loader.pc
-%endif
\ No newline at end of file
+%endif
projects / platform / core / uifw / dali-toolkit.git / commitdiff