../dali/dali-test-suite-utils/dali-test-suite-utils.cpp
../dali/dali-test-suite-utils/test-application.cpp
../dali/dali-test-suite-utils/test-gl-abstraction.cpp
- ../dali/dali-test-suite-utils/test-gl-sync-abstraction.cpp
../dali/dali-test-suite-utils/test-graphics-buffer.cpp
../dali/dali-test-suite-utils/test-graphics-command-buffer.cpp
../dali/dali-test-suite-utils/test-graphics-controller.cpp
../dali/dali-test-suite-utils/test-graphics-sampler.cpp
../dali/dali-test-suite-utils/test-graphics-shader.cpp
../dali/dali-test-suite-utils/test-graphics-texture.cpp
+ ../dali/dali-test-suite-utils/test-graphics-sync-impl.cpp
+ ../dali/dali-test-suite-utils/test-graphics-sync-object.cpp
../dali/dali-test-suite-utils/test-native-image.cpp
../dali/dali-test-suite-utils/test-platform-abstraction.cpp
../dali/dali-test-suite-utils/test-render-controller.cpp
dali-test-suite-utils/test-application.cpp
dali-test-suite-utils/test-gesture-generator.cpp
dali-test-suite-utils/test-gl-abstraction.cpp
- dali-test-suite-utils/test-gl-sync-abstraction.cpp
dali-test-suite-utils/test-graphics-buffer.cpp
dali-test-suite-utils/test-graphics-command-buffer.cpp
dali-test-suite-utils/test-graphics-controller.cpp
dali-test-suite-utils/test-graphics-shader.cpp
dali-test-suite-utils/test-graphics-texture.cpp
dali-test-suite-utils/test-graphics-sampler.cpp
+ dali-test-suite-utils/test-graphics-sync-impl.cpp
+ dali-test-suite-utils/test-graphics-sync-object.cpp
dali-test-suite-utils/test-native-image.cpp
dali-test-suite-utils/test-platform-abstraction.cpp
dali-test-suite-utils/test-render-controller.cpp
return static_cast<TestGlAbstraction&>(mGraphicsController.GetGlAbstraction());
}
-TestGlSyncAbstraction& TestApplication::GetGlSyncAbstraction()
+TestGlContextHelperAbstraction& TestApplication::GetGlContextHelperAbstraction()
{
- return static_cast<TestGlSyncAbstraction&>(mGraphicsController.GetGlSyncAbstraction());
+ return static_cast<TestGlContextHelperAbstraction&>(mGraphicsController.GetGlContextHelperAbstraction());
}
-TestGlContextHelperAbstraction& TestApplication::GetGlContextHelperAbstraction()
+TestGraphicsSyncImplementation& TestApplication::GetGraphicsSyncImpl()
{
- return static_cast<TestGlContextHelperAbstraction&>(mGraphicsController.GetGlContextHelperAbstraction());
+ return static_cast<TestGraphicsSyncImplementation&>(mGraphicsController.GetGraphicsSyncImpl());
}
void TestApplication::ProcessEvent(const Integration::Event& event)
TestGraphicsController& GetGraphicsController();
TestGlAbstraction& GetGlAbstraction();
- TestGlSyncAbstraction& GetGlSyncAbstraction();
TestGlContextHelperAbstraction& GetGlContextHelperAbstraction();
+ TestGraphicsSyncImplementation& GetGraphicsSyncImpl();
void ProcessEvent(const Integration::Event& event);
void SendNotification();
+++ /dev/null
-/*
- * Copyright (c) 2014 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-gl-sync-abstraction.h"
-
-namespace Dali
-{
-TestSyncObject::TestSyncObject(TraceCallStack& trace)
-: synced(false),
- mTrace(trace)
-{
-}
-
-TestSyncObject::~TestSyncObject()
-{
-}
-
-bool TestSyncObject::IsSynced()
-{
- mTrace.PushCall("SyncObject::IsSynced", ""); // Trace the method
- return synced;
-}
-
-TestGlSyncAbstraction::TestGlSyncAbstraction()
-{
- Initialize();
-}
-
-/**
- * Destructor
- */
-TestGlSyncAbstraction::~TestGlSyncAbstraction()
-{
- for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
- {
- delete *iter;
- }
-}
-
-/**
- * Initialize the sync objects - clear down the map
- */
-void TestGlSyncAbstraction::Initialize()
-{
- mSyncObjects.clear();
-}
-
-/**
- * Create a sync object
- * @return the sync object
- */
-Integration::GlSyncAbstraction::SyncObject* TestGlSyncAbstraction::CreateSyncObject()
-{
- mTrace.PushCall("CreateSyncObject", ""); // Trace the method
-
- TestSyncObject* syncObject = new TestSyncObject(mTrace);
- mSyncObjects.push_back(syncObject);
- return syncObject;
-}
-
-/**
- * Destroy a sync object
- * @param[in] syncObject The object to destroy
- */
-void TestGlSyncAbstraction::DestroySyncObject(Integration::GlSyncAbstraction::SyncObject* syncObject)
-{
- std::stringstream out;
- out << syncObject;
- mTrace.PushCall("DestroySyncObject", out.str()); // Trace the method
-
- for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
- {
- if(*iter == syncObject)
- {
- delete *iter;
- mSyncObjects.erase(iter);
- break;
- }
- }
-}
-
-Integration::GlSyncAbstraction::SyncObject* TestGlSyncAbstraction::GetLastSyncObject()
-{
- if(!mSyncObjects.empty())
- {
- return mSyncObjects.back();
- }
- return NULL;
-}
-
-/**
- * Test method to trigger the object sync behaviour.
- * @param[in]
- * @param[in] sync The sync value to set
- */
-void TestGlSyncAbstraction::SetObjectSynced(Integration::GlSyncAbstraction::SyncObject* syncObject, bool sync)
-{
- TestSyncObject* testSyncObject = static_cast<TestSyncObject*>(syncObject);
- testSyncObject->synced = sync;
-}
-
-/**
- * Turn trace on
- */
-void TestGlSyncAbstraction::EnableTrace(bool enable)
-{
- mTrace.Enable(enable);
-}
-
-/**
- * Reset the trace callstack
- */
-void TestGlSyncAbstraction::ResetTrace()
-{
- mTrace.Reset();
-}
-
-/**
- * Get the trace object (allows test case to find methods on it)
- */
-TraceCallStack& TestGlSyncAbstraction::GetTrace()
-{
- return mTrace;
-}
-
-int32_t TestGlSyncAbstraction::GetNumberOfSyncObjects()
-{
- return static_cast<int32_t>(mSyncObjects.size());
-}
-
-} // namespace Dali
+++ /dev/null
-#ifndef TEST_GL_SYNC_ABSTRACTION_H
-#define TEST_GL_SYNC_ABSTRACTION_H
-
-/*
- * Copyright (c) 2021 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 <map>
-#include <sstream>
-#include <string>
-
-// INTERNAL INCLUDES
-#include <dali/integration-api/core.h>
-#include <dali/integration-api/gl-sync-abstraction.h>
-
-#include "test-trace-call-stack.h"
-
-namespace Dali
-{
-class DALI_CORE_API TestSyncObject : public Integration::GlSyncAbstraction::SyncObject
-{
-public:
- TestSyncObject(TraceCallStack& trace);
- ~TestSyncObject() override;
- bool IsSynced() override;
- bool synced;
- TraceCallStack& mTrace;
-};
-
-/**
- * Class to emulate the GL sync functions with tracing
- */
-class DALI_CORE_API TestGlSyncAbstraction : public Integration::GlSyncAbstraction
-{
-public:
- /**
- * Constructor
- */
- TestGlSyncAbstraction();
-
- /**
- * Destructor
- */
- ~TestGlSyncAbstraction() override;
-
- /**
- * Initialize the sync objects - clear down the map
- */
- void Initialize();
-
- /**
- * Create a sync object
- * @return the sync object
- */
- Integration::GlSyncAbstraction::SyncObject* CreateSyncObject() override;
-
- /**
- * Destroy a sync object
- * @param[in] syncObject The object to destroy
- */
- void DestroySyncObject(Integration::GlSyncAbstraction::SyncObject* syncObject) override;
-
-public: // TEST FUNCTIONS
- Integration::GlSyncAbstraction::SyncObject* GetLastSyncObject();
-
- /**
- * Test method to trigger the object sync behaviour.
- * @param[in]
- * @param[in] sync The sync value to set
- */
- void SetObjectSynced(Integration::GlSyncAbstraction::SyncObject* syncObject, bool sync);
-
- /**
- * Turn trace on
- */
- void EnableTrace(bool enable);
-
- /**
- * Reset the trace callstack
- */
- void ResetTrace();
-
- /**
- * Get the trace object (allows test case to find methods on it)
- */
- TraceCallStack& GetTrace();
-
- /**
- * Get the number of sync objects
- *
- * @return the number of sync objects
- */
- int32_t GetNumberOfSyncObjects();
-
-private:
- TestGlSyncAbstraction(const TestGlSyncAbstraction&); ///< Undefined
- TestGlSyncAbstraction& operator=(const TestGlSyncAbstraction&); ///< Undefined
-
- typedef std::vector<TestSyncObject*> SyncContainer;
- typedef SyncContainer::iterator SyncIter;
- SyncContainer mSyncObjects; ///< The sync objects
- TraceCallStack mTrace{true, "gl"}; ///< the trace call stack for testing
-};
-
-} // namespace Dali
-
-#endif // TEST_GL_SYNC_ABSTRACTION_H
struct
{
+ Graphics::SyncObject* syncObject;
} endRenderPass;
struct
* dependencies (for example, to know when target texture is ready
* before passing it to another render pass).
*/
- void EndRenderPass() override
+ void EndRenderPass(Graphics::SyncObject* syncObject) override
{
- mCallStack.PushCall("EndRenderPass", "");
+ mCommands.emplace_back(CommandType::END_RENDER_PASS);
+ auto& cmd = mCommands.back();
+
+ cmd.data.endRenderPass.syncObject = syncObject;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["syncObject"] << std::hex << syncObject;
+ mCallStack.PushCall("EndRenderPass", namedParams.str(), namedParams);
}
void ExecuteCommandBuffers(std::vector<const CommandBuffer*>&& commandBuffers) override
#include "test-graphics-render-target.h"
#include "test-graphics-sampler.h"
#include "test-graphics-shader.h"
+#include "test-graphics-sync-object.h"
#include "test-graphics-texture.h"
#include <dali/integration-api/gl-defines.h>
}
case CommandType::END_RENDER_PASS:
{
+ if(cmd.data.endRenderPass.syncObject != nullptr)
+ {
+ auto syncObject = Uncast<TestGraphicsSyncObject>(cmd.data.endRenderPass.syncObject);
+ syncObject->InitializeResource(); // create the sync object.
+ }
break;
}
}
return Graphics::MakeUnique<TestGraphicsRenderTarget>(mGl, renderTargetCreateInfo);
}
+Graphics::UniquePtr<Graphics::SyncObject> TestGraphicsController::CreateSyncObject(
+ const Graphics::SyncObjectCreateInfo& syncObjectCreateInfo,
+ Graphics::UniquePtr<Graphics::SyncObject>&& oldSyncObject)
+{
+ mCallStack.PushCall("CreateSyncObject", "");
+ return Graphics::MakeUnique<TestGraphicsSyncObject>(mGraphicsSyncImpl, syncObjectCreateInfo);
+}
+
Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo)
{
mCallStack.PushCall("MapBufferRange", "");
#include <dali/graphics-api/graphics-controller.h>
#include "test-gl-abstraction.h"
#include "test-gl-context-helper-abstraction.h"
-#include "test-gl-sync-abstraction.h"
#include "test-graphics-command-buffer.h"
#include "test-graphics-program.h"
#include "test-graphics-reflection.h"
+#include "test-graphics-sync-impl.h"
namespace Dali
{
return const_cast<T*>(static_cast<const T*>(object));
}
+template<typename T>
+T* Uncast(const Graphics::SyncObject* object)
+{
+ return const_cast<T*>(static_cast<const T*>(object));
+}
+
class TestGraphicsController : public Dali::Graphics::Controller
{
public:
return mGl;
}
- Integration::GlSyncAbstraction& GetGlSyncAbstraction() override
+ Integration::GlContextHelperAbstraction& GetGlContextHelperAbstraction() override
{
- return mGlSyncAbstraction;
+ return mGlContextHelperAbstraction;
}
- Integration::GlContextHelperAbstraction& GetGlContextHelperAbstraction() override
+ TestGraphicsSyncImplementation& GetGraphicsSyncImpl()
{
- return mGlContextHelperAbstraction;
+ return mGraphicsSyncImpl;
}
void SubmitCommandBuffers(const Graphics::SubmitInfo& submitInfo) override;
*/
Graphics::UniquePtr<Graphics::RenderTarget> CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget) override;
+ /**
+ * @brief Creates new sync object
+ * Could add timeout etc to createinfo... but nah.
+ *
+ * @return pointer to the SyncObject
+ */
+ Graphics::UniquePtr<Graphics::SyncObject> CreateSyncObject(const Graphics::SyncObjectCreateInfo& syncObjectCreateInfo,
+ Graphics::UniquePtr<Graphics::SyncObject>&& oldSyncObject) override;
+
/**
* @brief Maps memory associated with Buffer object
*
* @param[in] mapInfo Filled details of mapped resource
*
- * @return Returns pointer to Memory object or Graphicsnullptr on error
+ * @return Returns pointer to Memory object or nullptr on error
*/
Graphics::UniquePtr<Graphics::Memory> MapBufferRange(const Graphics::MapBufferInfo& mapInfo) override;
mutable std::vector<Graphics::SubmitInfo> mSubmitStack;
TestGlAbstraction mGl;
- TestGlSyncAbstraction mGlSyncAbstraction;
+ TestGraphicsSyncImplementation mGraphicsSyncImpl;
TestGlContextHelperAbstraction mGlContextHelperAbstraction;
bool isDiscardQueueEmptyResult{true};
--- /dev/null
+/*
+ * Copyright (c) 2014 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-graphics-sync-impl.h"
+
+namespace Dali
+{
+TestSyncObject::TestSyncObject(Dali::TraceCallStack& trace)
+
+: synced(false),
+ mTrace(trace)
+{
+ mTrace.PushCall("TestSyncObject cons", ""); // Trace the method
+}
+
+TestSyncObject::~TestSyncObject()
+{
+ mTrace.PushCall("TestSyncObject dstr", ""); // Trace the method
+}
+
+bool TestSyncObject::IsSynced()
+{
+ mTrace.PushCall("SyncObject::IsSynced", ""); // Trace the method
+ return synced;
+}
+
+TestGraphicsSyncImplementation::TestGraphicsSyncImplementation()
+{
+ Initialize();
+}
+
+/**
+ * Destructor
+ */
+TestGraphicsSyncImplementation::~TestGraphicsSyncImplementation()
+{
+ for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
+ {
+ delete *iter;
+ }
+}
+
+/**
+ * Initialize the sync objects
+ */
+void TestGraphicsSyncImplementation::Initialize()
+{
+ mSyncObjects.clear();
+}
+
+Integration::GraphicsSyncAbstraction::SyncObject* TestGraphicsSyncImplementation::CreateSyncObject()
+{
+ mTrace.PushCall("CreateSyncObject", ""); // Trace the method
+
+ TestSyncObject* syncObject = new TestSyncObject(mTrace);
+ mSyncObjects.push_back(syncObject);
+ return syncObject;
+}
+
+/**
+ * Destroy a sync object
+ * @param[in] syncObject The object to destroy
+ */
+void TestGraphicsSyncImplementation::DestroySyncObject(Integration::GraphicsSyncAbstraction::SyncObject* syncObject)
+{
+ std::stringstream out;
+ out << syncObject;
+ mTrace.PushCall("DestroySyncObject", out.str()); // Trace the method
+
+ for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
+ {
+ if(*iter == syncObject)
+ {
+ delete *iter;
+ mSyncObjects.erase(iter);
+ break;
+ }
+ }
+}
+
+Integration::GraphicsSyncAbstraction::SyncObject* TestGraphicsSyncImplementation::GetLastSyncObject()
+{
+ if(!mSyncObjects.empty())
+ {
+ return mSyncObjects.back();
+ }
+ return NULL;
+}
+
+/**
+ * Test method to trigger the object sync behaviour.
+ * @param[in]
+ * @param[in] sync The sync value to set
+ */
+void TestGraphicsSyncImplementation::SetObjectSynced(Integration::GraphicsSyncAbstraction::SyncObject* syncObject, bool sync)
+{
+ TestSyncObject* testSyncObject = static_cast<TestSyncObject*>(syncObject);
+ testSyncObject->synced = sync;
+}
+
+/**
+ * Turn trace on
+ */
+void TestGraphicsSyncImplementation::EnableTrace(bool enable)
+{
+ mTrace.Enable(enable);
+}
+
+/**
+ * Reset the trace callstack
+ */
+void TestGraphicsSyncImplementation::ResetTrace()
+{
+ mTrace.Reset();
+}
+
+/**
+ * Get the trace object (allows test case to find methods on it)
+ */
+TraceCallStack& TestGraphicsSyncImplementation::GetTrace()
+{
+ return mTrace;
+}
+
+int32_t TestGraphicsSyncImplementation::GetNumberOfSyncObjects()
+{
+ return static_cast<int32_t>(mSyncObjects.size());
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef TEST_SYNC_IMPLEMENTATION_H
+#define TEST_SYNC_IMPLEMENTATION_H
+
+/*
+ * Copyright (c) 2021 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 <map>
+#include <sstream>
+#include <string>
+
+// INTERNAL INCLUDES
+#include <dali/graphics-api/graphics-sync-object-create-info.h>
+#include <dali/graphics-api/graphics-sync-object.h>
+#include <dali/integration-api/core.h>
+#include <dali/integration-api/graphics-sync-abstraction.h>
+
+#include "test-trace-call-stack.h"
+
+namespace Dali
+{
+class TestGraphicsSyncImplementation;
+
+class TestSyncObject : public Integration::GraphicsSyncAbstraction::SyncObject
+{
+public:
+ TestSyncObject(TraceCallStack& trace);
+ ~TestSyncObject() override;
+ bool IsSynced() override;
+ bool synced;
+ TraceCallStack& mTrace;
+};
+
+/**
+ * Class to emulate the gpu sync functions with tracing
+ */
+class TestGraphicsSyncImplementation : public Integration::GraphicsSyncAbstraction
+{
+public:
+ /**
+ * Constructor
+ */
+ TestGraphicsSyncImplementation();
+
+ /**
+ * Destructor
+ */
+ virtual ~TestGraphicsSyncImplementation();
+
+ /**
+ * Initialize the sync objects
+ */
+ void Initialize();
+
+ /**
+ * Create a sync object that can be polled
+ */
+ GraphicsSyncAbstraction::SyncObject* CreateSyncObject() override;
+
+ /**
+ * Destroy a sync object
+ */
+ void DestroySyncObject(GraphicsSyncAbstraction::SyncObject* syncObject) override;
+
+public: // TEST FUNCTIONS
+ GraphicsSyncAbstraction::SyncObject* GetLastSyncObject();
+
+ /**
+ * Test method to trigger the object sync behaviour.
+ * @param[in]
+ * @param[in] sync The sync value to set
+ */
+ void SetObjectSynced(GraphicsSyncAbstraction::SyncObject* syncObject, bool sync);
+
+ /**
+ * Turn trace on
+ */
+ void EnableTrace(bool enable);
+
+ /**
+ * Reset the trace callstack
+ */
+ void ResetTrace();
+
+ /**
+ * Get the trace object (allows test case to find methods on it)
+ */
+ TraceCallStack& GetTrace();
+
+ /**
+ * Get the number of sync objects
+ *
+ * @return the number of sync objects
+ */
+ int32_t GetNumberOfSyncObjects();
+
+ TestGraphicsSyncImplementation(const TestGraphicsSyncImplementation&) = delete;
+ TestGraphicsSyncImplementation& operator=(const TestGraphicsSyncImplementation&) = delete;
+
+private:
+ typedef std::vector<TestSyncObject*> SyncContainer;
+ typedef SyncContainer::iterator SyncIter;
+ SyncContainer mSyncObjects; ///< The sync objects
+ TraceCallStack mTrace{true, "gl"}; ///< the trace call stack for testing
+};
+
+} // namespace Dali
+
+#endif // TEST_GL_SYNC_ABSTRACTION_H
--- /dev/null
+/*
+ * Copyright (c) 2021 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-graphics-sync-object.h"
+
+namespace Dali
+{
+TestGraphicsSyncObject::TestGraphicsSyncObject(TestGraphicsSyncImplementation& syncImpl, const Graphics::SyncObjectCreateInfo& createInfo)
+: mSyncImplementation(syncImpl),
+ mSyncObject(nullptr),
+ mCreateInfo(createInfo)
+{
+}
+
+TestGraphicsSyncObject::~TestGraphicsSyncObject()
+{
+ mSyncImplementation.DestroySyncObject(mSyncObject);
+}
+
+void TestGraphicsSyncObject::InitializeResource()
+{
+ mSyncObject = static_cast<TestSyncObject*>(mSyncImplementation.CreateSyncObject());
+}
+
+bool TestGraphicsSyncObject::IsSynced()
+{
+ bool synced = false;
+ if(mSyncObject)
+ {
+ synced = mSyncObject->IsSynced();
+ }
+ return synced;
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_TEST_GRAPHICS_SYNC_OBJECT_H_
+#define DALI_TEST_GRAPHICS_SYNC_OBJECT_H_
+
+/*
+ * Copyright (c) 2021 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/graphics-api/graphics-sync-object-create-info.h>
+#include <dali/graphics-api/graphics-sync-object.h>
+
+#include <test-graphics-sync-impl.h>
+
+namespace Dali
+{
+class TestGraphicsSyncObject : public Graphics::SyncObject
+{
+public:
+ TestGraphicsSyncObject(TestGraphicsSyncImplementation& syncImpl, const Graphics::SyncObjectCreateInfo& createInfo);
+ ~TestGraphicsSyncObject() override;
+ void InitializeResource();
+ bool IsSynced() override;
+
+public:
+ TestGraphicsSyncImplementation& mSyncImplementation;
+ TestSyncObject* mSyncObject;
+ Graphics::SyncObjectCreateInfo mCreateInfo;
+};
+
+} // namespace Dali
+
+#endif //DALI_TEST_GRAPHICS_SYNC_OBJECT_H
tet_infoline("Testing RenderTask::SignalFinished()");
application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ auto& sync = application.GetGraphicsSyncImpl();
CameraActor offscreenCameraActor = CameraActor::New();
application.SendNotification();
DALI_TEST_CHECK(!finished);
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
DALI_TEST_CHECK(lastSyncObj != NULL);
application.Render();
// SETUP AN OFFSCREEN RENDER TASK
application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ auto& sync = application.GetGraphicsSyncImpl();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
DALI_TEST_CHECK(lastSyncObj != NULL);
sync.SetObjectSynced(lastSyncObj, true);
// SETUP AN OFFSCREEN RENDER TASK
application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ auto& sync = application.GetGraphicsSyncImpl();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
DALI_TEST_CHECK(lastSyncObj != NULL);
sync.SetObjectSynced(lastSyncObj, true);
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ auto& sync = application.GetGraphicsSyncImpl();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
// drawn sig finished Keep updating
DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
DALI_TEST_CHECK(lastSyncObj != NULL);
sync.SetObjectSynced(lastSyncObj, true);
// SETUP AN OFFSCREEN RENDER TASK
application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ auto& sync = application.GetGraphicsSyncImpl();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
// FAILS drawn sig finished Keep updating
DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
DALI_TEST_CHECK(lastSyncObj != NULL);
sync.SetObjectSynced(lastSyncObj, true);
application.SendNotification();
DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ auto& sync = application.GetGraphicsSyncImpl();
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
DALI_TEST_CHECK(lastSyncObj == NULL);
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
tet_infoline("Testing RenderTask::FinishInvisibleSourceActor()");
application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ auto& sync = application.GetGraphicsSyncImpl();
CameraActor offscreenCameraActor = CameraActor::New();
application.SendNotification();
DALI_TEST_CHECK(!finished);
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
DALI_TEST_CHECK(lastSyncObj != NULL);
application.Render();
linker-test.cpp
${DALI_TEST_SUITE_DIR}/test-application.cpp
${DALI_TEST_SUITE_DIR}/test-gl-abstraction.cpp
- ${DALI_TEST_SUITE_DIR}/test-gl-sync-abstraction.cpp
+ ${DALI_TEST_SUITE_DIR}/test-graphics-sync-impl.cpp
+ ${DALI_TEST_SUITE_DIR}/test-graphics-sync-object.cpp
${DALI_TEST_SUITE_DIR}/test-graphics-buffer.cpp
${DALI_TEST_SUITE_DIR}/test-graphics-command-buffer.cpp
${DALI_TEST_SUITE_DIR}/test-graphics-controller.cpp
${graphics_src_dir}/graphics-sampler.h
${graphics_src_dir}/graphics-shader-create-info.h
${graphics_src_dir}/graphics-shader.h
+ ${graphics_src_dir}/graphics-sync-object-create-info.h
+ ${graphics_src_dir}/graphics-sync-object.h
${graphics_src_dir}/graphics-texture-create-info.h
${graphics_src_dir}/graphics-texture.h
${graphics_src_dir}/graphics-types.h
{
class Buffer;
class Pipeline;
-class Texture;
-class Sampler;
class RenderTarget;
class RenderPass;
+class Sampler;
+class SyncObject;
+class Texture;
/**
* @brief Uniform buffer bindings.
* the Controller may use end RP marker in order to resolve resource
* dependencies (for example, to know when target texture is ready
* before passing it to another render pass).
+ *
+ * The caller may query the sync object to determine when this render
+ * pass has actually finished on the GPU.
+ *
+ * @param[in] syncObject If non-null, this object will ensure an
+ * appropriate fence sync object is created after the render pass is
+ * executed.
*/
- virtual void EndRenderPass() = 0;
+ virtual void EndRenderPass(Graphics::SyncObject* syncObject) = 0;
/**
* @brief Executes a list of secondary command buffers
#include "graphics-render-target-create-info.h"
#include "graphics-sampler-create-info.h"
#include "graphics-shader-create-info.h"
+#include "graphics-sync-object-create-info.h"
#include "graphics-texture-create-info.h"
namespace Dali
namespace Integration
{
class GlAbstraction;
-class GlSyncAbstraction;
class GlContextHelperAbstraction;
} // namespace Integration
namespace Graphics
{
-class CommandBuffer;
class Command;
-class RenderTarget;
-class RenderPass;
+class CommandBuffer;
class Buffer;
-class Texture;
-class Shader;
class Framebuffer;
+class Memory;
class Pipeline;
+class RenderPass;
+class RenderTarget;
class Sampler;
-class Memory;
+class Shader;
+class SyncObject;
+class Texture;
/**
* @brief Controller class controls render loop
public:
// Temporary until graphics api is complete
virtual Integration::GlAbstraction& GetGlAbstraction() = 0;
- virtual Integration::GlSyncAbstraction& GetGlSyncAbstraction() = 0;
virtual Integration::GlContextHelperAbstraction& GetGlContextHelperAbstraction() = 0;
/**
*/
virtual UniquePtr<RenderTarget> CreateRenderTarget(const RenderTargetCreateInfo& renderTargetCreateInfo, UniquePtr<RenderTarget>&& oldRenderTarget) = 0;
+ /**
+ * Create a synchronisation object.
+ *
+ * @return A pointer to an opaque sync object
+ * @param[in] syncObjectCreateInfo The valid SyncObjectCreateInfo structure
+ * @param[in] oldSyncObject The valid pointer to the old object or nullptr. The object will be reused or destroyed.
+ */
+ virtual UniquePtr<SyncObject> CreateSyncObject(const SyncObjectCreateInfo& syncObjectCreateInfo,
+ UniquePtr<SyncObject>&& oldSyncObject) = 0;
+
/**
* @brief Maps memory associated with Buffer object
*
} // Namespace Graphics
} // Namespace Dali
-#endif
\ No newline at end of file
+#endif
--- /dev/null
+#ifndef DALI_GRAPHICS_SYNC_OBJECT_CREATE_INFO_H
+#define DALI_GRAPHICS_SYNC_OBJECT_CREATE_INFO_H
+
+/*
+ * Copyright (c) 2021 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 <memory>
+
+// INTERNAL INCLUDES
+#include "graphics-sync-object.h"
+#include "graphics-types.h"
+
+namespace Dali
+{
+namespace Graphics
+{
+/**
+ * @brief Interface class for SyncObjectCreateInfo types in the graphics API.
+ */
+struct SyncObjectCreateInfo
+{
+ /**
+ * @brief Sets pointer to the extension
+ *
+ * The pointer to the extension must be set either to nullptr
+ * or to the valid structure. The structures may create
+ * a chain. The last structure in a chain must point at
+ * nullptr.
+ *
+ * @param[in] value pointer to the valid extension structure
+ * @return reference to this structure
+ */
+ auto& SetNextExtension(ExtensionCreateInfo* value)
+ {
+ nextExtension = value;
+ return *this;
+ }
+
+ GraphicsStructureType type{GraphicsStructureType::SYNC_OBJECT_CREATE_INFO_STRUCT};
+ ExtensionCreateInfo* nextExtension{nullptr};
+
+ const AllocationCallbacks* allocationCallbacks{nullptr};
+};
+
+} // namespace Graphics
+} // namespace Dali
+
+#endif // DALI_GRAPHICS_SYNC_OBJECT_CREATE_INFO
--- /dev/null
+#ifndef DALI_GRAPHICS_API_GRAPHICS_SYNC_OBJECT_H
+#define DALI_GRAPHICS_API_GRAPHICS_SYNC_OBJECT_H
+
+/*
+ * Copyright (c) 2021 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.
+ */
+
+namespace Dali::Graphics
+{
+class SyncObject
+{
+public:
+ SyncObject() = default;
+ virtual ~SyncObject() = default;
+
+ // Definitely not copyable:
+ SyncObject(const SyncObject&) = delete;
+ SyncObject& operator=(const SyncObject&) = delete;
+
+ /**
+ * Determine if the synchronisation object has been signalled.
+ *
+ * @return false if the sync object has not been signalled, true if it has been signalled (and
+ * can now be destroyed)
+ */
+ virtual bool IsSynced() = 0;
+
+protected:
+ SyncObject(SyncObject&&) = default;
+ SyncObject& operator=(SyncObject&&) = default;
+};
+
+} // namespace Dali::Graphics
+
+#endif //DALI_GRAPHICS_API_GRAPHICS_SYNC_OBJECT_H
SAMPLER_CREATE_INFO_STRUCT,
SHADER_CREATE_INFO_STRUCT,
TEXTURE_CREATE_INFO_STRUCT,
- RENDER_TARGET_CREATE_INFO_STRUCT
+ RENDER_TARGET_CREATE_INFO_STRUCT,
+ SYNC_OBJECT_CREATE_INFO_STRUCT
};
/**
${platform_abstraction_src_dir}/resource-types.h
${platform_abstraction_src_dir}/gl-abstraction.h
${platform_abstraction_src_dir}/gl-defines.h
- ${platform_abstraction_src_dir}/gl-sync-abstraction.h
${platform_abstraction_src_dir}/gl-context-helper-abstraction.h
+ ${platform_abstraction_src_dir}/graphics-sync-abstraction.h
${platform_abstraction_src_dir}/render-controller.h
${platform_abstraction_src_dir}/platform-abstraction.h
${platform_abstraction_src_dir}/processor-interface.h
+++ /dev/null
-#ifndef DALI_INTEGRATION_GL_SYNC_ABSTRACTION_H
-#define DALI_INTEGRATION_GL_SYNC_ABSTRACTION_H
-
-/*
- * Copyright (c) 2020 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/public-api/common/dali-common.h>
-
-namespace Dali
-{
-namespace Integration
-{
-/**
- * This abstraction defines an API for syncing CPU with GPU.
- * A typical use case is to determine when GL draw calls have finished drawing
- * to a framebuffer.
- */
-class GlSyncAbstraction
-{
-protected:
- /**
- * Virtual protected destructor, no deletion through this interface
- */
- virtual ~GlSyncAbstraction() = default;
-
-public:
- class SyncObject
- {
- protected:
- /**
- * Virtual protected destructor, no deletion through this interface. This prevents
- * Core from deleting SyncObjects - only Adaptor implementation is able to delete
- * them.
- */
- virtual ~SyncObject() = default;
-
- public:
- /**
- * Determine if the synchronisation object has been signalled.
- * @return false if the sync object has not been signalled, true if it has been signalled (and
- * can now be destroyed)
- */
- virtual bool IsSynced() = 0;
- };
-
- /**
- * Create a synchronisation object based on the resource id, typically that of
- * a framebuffer texture. It can then be polled using the same resource id.
- * @return A pointer to an opaque sync object
- */
- virtual SyncObject* CreateSyncObject() = 0;
-
- /**
- * Destroy the synchronisation object.
- * @param[in] syncObject The sync object to destroy
- */
- virtual void DestroySyncObject(SyncObject* syncObject) = 0;
-};
-
-} // namespace Integration
-} // namespace Dali
-
-#endif // DALI_INTEGRATION_GL_SYNC_ABSTRACTION_H
--- /dev/null
+#ifndef DALI_INTEGRATION_GRAPHICS_SYNC_ABSTRACTION_H
+#define DALI_INTEGRATION_GRAPHICS_SYNC_ABSTRACTION_H
+
+/*
+ * Copyright (c) 2021 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/public-api/common/dali-common.h>
+
+namespace Dali
+{
+namespace Integration
+{
+/**
+ * This abstraction defines an API for syncing CPU with GPU.
+ * A typical use case is to determine when GL draw calls have finished drawing
+ * to a framebuffer.
+ */
+class GraphicsSyncAbstraction
+{
+protected:
+ /**
+ * Virtual protected destructor, no deletion through this interface
+ */
+ virtual ~GraphicsSyncAbstraction() = default;
+
+public:
+ class SyncObject
+ {
+ protected:
+ /**
+ * Virtual protected destructor, no deletion through this interface. This prevents
+ * Core from deleting SyncObjects - only Adaptor implementation is able to delete
+ * them.
+ */
+ virtual ~SyncObject() = default;
+
+ public:
+ /**
+ * Determine if the synchronisation object has been signalled.
+ * @return false if the sync object has not been signalled, true if it has been signalled (and
+ * can now be destroyed)
+ */
+ virtual bool IsSynced() = 0;
+ };
+
+ /**
+ * Create a synchronisation object based on the resource id, typically that of
+ * a framebuffer texture. It can then be polled using the same resource id.
+ * @return A pointer to an opaque sync object
+ */
+ virtual SyncObject* CreateSyncObject() = 0;
+
+ /**
+ * Destroy the synchronisation object.
+ * @param[in] syncObject The sync object to destroy
+ */
+ virtual void DestroySyncObject(SyncObject* syncObject) = 0;
+};
+
+} // namespace Integration
+} // namespace Dali
+
+#endif // DALI_INTEGRATION_GRAPHICS_SYNC_ABSTRACTION_H
#include <dali/integration-api/debug.h>
#include <dali/integration-api/events/event.h>
#include <dali/integration-api/gl-context-helper-abstraction.h>
-#include <dali/integration-api/gl-sync-abstraction.h>
#include <dali/integration-api/platform-abstraction.h>
#include <dali/integration-api/processor-interface.h>
#include <dali/integration-api/render-controller.h>
using Integration::Event;
using Integration::GlAbstraction;
using Integration::GlContextHelperAbstraction;
-using Integration::GlSyncAbstraction;
using Integration::PlatformAbstraction;
using Integration::RenderController;
using Integration::RenderStatus;
}
}
+ Graphics::SyncObject* syncObject{nullptr};
+ // If the render instruction has an associated render tracker (owned separately)
+ // and framebuffer, create a one shot sync object, and use it to determine when
+ // the render pass has finished executing on GPU.
if(instruction.mRenderTracker && instruction.mFrameBuffer)
{
- // This will create a sync object every frame this render tracker
- // is alive (though it should be now be created only for
- // render-once render tasks)
- // @todo Add syncing to Graphics API
- instruction.mRenderTracker->CreateSyncObject(mImpl->graphicsController.GetGlSyncAbstraction());
- instruction.mRenderTracker = nullptr; // Only create once.
+ syncObject = instruction.mRenderTracker->CreateSyncObject(mImpl->graphicsController);
+ instruction.mRenderTracker = nullptr;
}
-
- // End render pass
- mainCommandBuffer->EndRenderPass();
+ mainCommandBuffer->EndRenderPass(syncObject);
}
mImpl->renderAlgorithms.SubmitCommandBuffer();
namespace Integration
{
class GlAbstraction;
-class GlSyncAbstraction;
class GlContextHelperAbstraction;
class RenderStatus;
class Scene;
#include <dali/internal/render/common/render-tracker.h>
// INTERNAL INCLUDES
-#include <dali/integration-api/gl-sync-abstraction.h>
+#include <dali/graphics-api/graphics-sync-object-create-info.h>
#include <dali/internal/render/common/render-tracker-debug.h>
// EXTERNAL INCLUDES
namespace Render
{
RenderTracker::RenderTracker()
-: mGlSyncAbstraction(nullptr),
+: mGraphicsController(nullptr),
mSyncObject(nullptr),
mSyncTrigger(0)
{
RenderTracker::~RenderTracker()
{
TRACKER_LOG(Debug::Verbose);
- if(mSyncObject)
- {
- mGlSyncAbstraction->DestroySyncObject(mSyncObject);
- mSyncObject = nullptr;
- }
+ mSyncObject.reset(nullptr); // Will destroy sync object immediately
}
-void RenderTracker::CreateSyncObject(Integration::GlSyncAbstraction& glSyncAbstraction)
+Graphics::SyncObject* RenderTracker::CreateSyncObject(Graphics::Controller& graphicsController)
{
- mGlSyncAbstraction = &glSyncAbstraction;
+ mGraphicsController = &graphicsController;
+
TRACKER_LOG(Debug::General);
- // Destroy any previous sync object
- if(mSyncObject)
- {
- mGlSyncAbstraction->DestroySyncObject(mSyncObject);
- mSyncObject = nullptr;
- }
ResetSyncFlag();
- mSyncObject = mGlSyncAbstraction->CreateSyncObject();
+ mSyncObject = mGraphicsController->CreateSyncObject(Graphics::SyncObjectCreateInfo{}, std::move(mSyncObject));
+ return mSyncObject.get();
}
void RenderTracker::PollSyncObject()
if(mSyncObject && mSyncObject->IsSynced())
{
SetSyncFlag();
- mGlSyncAbstraction->DestroySyncObject(mSyncObject);
- mSyncObject = nullptr;
+ mSyncObject.reset();
TRACKER_LOG_FMT(Debug::General, " Synced\n");
return;
*
*/
-#include <dali/integration-api/gl-sync-abstraction.h>
+#include <dali/graphics-api/graphics-controller.h>
#include <dali/internal/common/message.h>
namespace Dali
/**
* Creates a sync object for this tracker. Will delete any existing sync object.
+ *
+ * @param[in] graphicsController The graphics subsystem
*/
- void CreateSyncObject(Integration::GlSyncAbstraction& glSyncAbstraction);
+ Graphics::SyncObject* CreateSyncObject(Graphics::Controller& graphicsController);
/**
* Check the GL Sync objects. This is called from Render Thread.
void SetSyncFlag();
private:
- Integration::GlSyncAbstraction* mGlSyncAbstraction; // The sync abstraction
- Integration::GlSyncAbstraction::SyncObject* mSyncObject; // Associated sync object
- volatile int mSyncTrigger; // Trigger that update thread can read
+ Graphics::Controller* mGraphicsController; ///< The graphics subsystem
+ Graphics::UniquePtr<Graphics::SyncObject> mSyncObject; ///< Associated sync object
+ volatile int mSyncTrigger; ///< Trigger that update thread can read
};
} // namespace Render
namespace Integration
{
-class GlSyncAbstraction;
class RenderController;
} // namespace Integration
projects / platform / core / uifw / dali-core.git / commitdiff