From b2449c0ab2798405d8fca9d8a1fd0db622d6af26 Mon Sep 17 00:00:00 2001 From: Daekwang Ryu Date: Thu, 20 Aug 2020 14:54:52 +0900 Subject: [PATCH] Add OffscreenApplication OffscreenApplication allows to make an application with a OffscreenWindow. You don't have to create a on-screen window. Change-Id: Ic418dce92ff1bf79f4be0a2ecb46e68784dbebe4 --- build/tizen/module-list.cmake | 3 + build/tizen/profiles/android-profile.cmake | 1 + build/tizen/profiles/common-profile.cmake | 1 + build/tizen/profiles/ivi-profile.cmake | 1 + build/tizen/profiles/mobile-profile.cmake | 1 + build/tizen/profiles/tv-profile.cmake | 1 + build/tizen/profiles/ubuntu-profile.cmake | 1 + build/tizen/profiles/wearable-profile.cmake | 1 + build/tizen/profiles/windows-profile.cmake | 1 + .../adaptor-framework/offscreen-application.cpp | 88 +++++++++ .../adaptor-framework/offscreen-application.h | 154 ++++++++++++++++ .../adaptor-framework/offscreen-window.cpp | 116 ++++++++++++ .../devel-api/adaptor-framework/offscreen-window.h | 197 +++++++++++++++++++++ dali/devel-api/file.list | 4 + .../adaptor-framework/native-render-surface.h | 6 + dali/internal/adaptor/common/adaptor-impl.cpp | 16 +- dali/internal/adaptor/common/adaptor-impl.h | 11 +- dali/internal/adaptor/common/adaptor.cpp | 5 +- .../common/offscreen-application-impl.cpp | 86 +++++++++ .../offscreen/common/offscreen-application-impl.h | 149 ++++++++++++++++ .../offscreen/common/offscreen-window-impl.cpp | 135 ++++++++++++++ .../offscreen/common/offscreen-window-impl.h | 163 +++++++++++++++++ dali/internal/offscreen/file.list | 5 + .../native-render-surface-ecore-wl.cpp | 98 ++++++---- .../tizen-wayland/native-render-surface-ecore-wl.h | 5 + 25 files changed, 1201 insertions(+), 48 deletions(-) create mode 100644 dali/devel-api/adaptor-framework/offscreen-application.cpp create mode 100644 dali/devel-api/adaptor-framework/offscreen-application.h create mode 100644 dali/devel-api/adaptor-framework/offscreen-window.cpp create mode 100644 dali/devel-api/adaptor-framework/offscreen-window.h create mode 100644 dali/internal/offscreen/common/offscreen-application-impl.cpp create mode 100644 dali/internal/offscreen/common/offscreen-application-impl.h create mode 100644 dali/internal/offscreen/common/offscreen-window-impl.cpp create mode 100644 dali/internal/offscreen/common/offscreen-window-impl.h create mode 100644 dali/internal/offscreen/file.list diff --git a/build/tizen/module-list.cmake b/build/tizen/module-list.cmake index 161d1de..f779f50 100644 --- a/build/tizen/module-list.cmake +++ b/build/tizen/module-list.cmake @@ -28,6 +28,9 @@ include( ${ADAPTOR_ROOT}/dali/internal/legacy/file.list ) SET( adaptor_network_dir ${ADAPTOR_ROOT}/dali/internal/network ) include( ${ADAPTOR_ROOT}/dali/internal/network/file.list ) +SET( adaptor_offscreen_dir ${ADAPTOR_ROOT}/dali/internal/offscreen ) +include( ${ADAPTOR_ROOT}/dali/internal/offscreen/file.list ) + SET( adaptor_sensor_dir ${ADAPTOR_ROOT}/dali/internal/sensor ) include( ${ADAPTOR_ROOT}/dali/internal/sensor/file.list ) diff --git a/build/tizen/profiles/android-profile.cmake b/build/tizen/profiles/android-profile.cmake index 5862cec..2d41d2c 100644 --- a/build/tizen/profiles/android-profile.cmake +++ b/build/tizen/profiles/android-profile.cmake @@ -24,6 +24,7 @@ SET( SOURCES ${adaptor_integration_api_android_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} ${adaptor_public_api_src_files} ${adaptor_sensor_common_src_files} ${adaptor_sensor_android_src_files} diff --git a/build/tizen/profiles/common-profile.cmake b/build/tizen/profiles/common-profile.cmake index e1afc1e..7add3a0 100644 --- a/build/tizen/profiles/common-profile.cmake +++ b/build/tizen/profiles/common-profile.cmake @@ -23,6 +23,7 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} ${adaptor_public_api_src_files} ${adaptor_sensor_common_src_files} ${adaptor_sensor_tizen_src_files} diff --git a/build/tizen/profiles/ivi-profile.cmake b/build/tizen/profiles/ivi-profile.cmake index aebd8b6..82f1a95 100644 --- a/build/tizen/profiles/ivi-profile.cmake +++ b/build/tizen/profiles/ivi-profile.cmake @@ -24,6 +24,7 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} ${adaptor_public_api_src_files} ${adaptor_sensor_common_src_files} ${adaptor_sensor_tizen_src_files} diff --git a/build/tizen/profiles/mobile-profile.cmake b/build/tizen/profiles/mobile-profile.cmake index a53da27..a5329ff 100644 --- a/build/tizen/profiles/mobile-profile.cmake +++ b/build/tizen/profiles/mobile-profile.cmake @@ -23,6 +23,7 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} ${adaptor_public_api_src_files} ${adaptor_sensor_common_src_files} ${adaptor_sensor_tizen_src_files} diff --git a/build/tizen/profiles/tv-profile.cmake b/build/tizen/profiles/tv-profile.cmake index 2469de7..34a69fa 100644 --- a/build/tizen/profiles/tv-profile.cmake +++ b/build/tizen/profiles/tv-profile.cmake @@ -23,6 +23,7 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} ${adaptor_public_api_src_files} ${adaptor_sensor_common_src_files} ${adaptor_sensor_tizen_src_files} diff --git a/build/tizen/profiles/ubuntu-profile.cmake b/build/tizen/profiles/ubuntu-profile.cmake index 82643fa..cdd43c4 100644 --- a/build/tizen/profiles/ubuntu-profile.cmake +++ b/build/tizen/profiles/ubuntu-profile.cmake @@ -22,6 +22,7 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} ${adaptor_public_api_src_files} ${adaptor_sensor_common_src_files} ${adaptor_sensor_ubuntu_src_files} diff --git a/build/tizen/profiles/wearable-profile.cmake b/build/tizen/profiles/wearable-profile.cmake index 2a908d0..ad505b6 100644 --- a/build/tizen/profiles/wearable-profile.cmake +++ b/build/tizen/profiles/wearable-profile.cmake @@ -24,6 +24,7 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} ${adaptor_public_api_src_files} ${adaptor_sensor_common_src_files} ${adaptor_sensor_tizen_src_files} diff --git a/build/tizen/profiles/windows-profile.cmake b/build/tizen/profiles/windows-profile.cmake index c39c3bd..92a7fb9 100644 --- a/build/tizen/profiles/windows-profile.cmake +++ b/build/tizen/profiles/windows-profile.cmake @@ -17,6 +17,7 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} ${adaptor_public_api_src_files} ${adaptor_sensor_common_src_files} ${adaptor_styling_common_src_files} diff --git a/dali/devel-api/adaptor-framework/offscreen-application.cpp b/dali/devel-api/adaptor-framework/offscreen-application.cpp new file mode 100644 index 0000000..30d2c96 --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-application.cpp @@ -0,0 +1,88 @@ +/* + * 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. + * + */ + +// CLASS HEADER +#include + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +OffscreenApplication OffscreenApplication::New(uint16_t width, uint16_t height, bool isTranslucent, OffscreenApplication::RenderMode renderMode) +{ + Dali::Any surface; + IntrusivePtr impl = Internal::OffscreenApplication::New(width, height, surface, isTranslucent, renderMode); + + OffscreenApplication offscreenApplication = OffscreenApplication(impl.Get()); + + return offscreenApplication; +} + +OffscreenApplication OffscreenApplication::New(Dali::Any surface, OffscreenApplication::RenderMode renderMode) +{ + IntrusivePtr impl = Internal::OffscreenApplication::New(0, 0, surface, false, renderMode); + + OffscreenApplication offscreenApplication = OffscreenApplication(impl.Get()); + + return offscreenApplication; +} + +OffscreenApplication::OffscreenApplication() = default; + +OffscreenApplication::OffscreenApplication(const OffscreenApplication& offscreenApplication) = default; + +OffscreenApplication& OffscreenApplication::operator=(const OffscreenApplication& offscreenApplication) = default; + +OffscreenApplication::~OffscreenApplication() = default; + +void OffscreenApplication::Start() +{ + Internal::GetImplementation(*this).Start(); +} + +void OffscreenApplication::Stop() +{ + Internal::GetImplementation(*this).Stop(); +} + +Dali::OffscreenWindow OffscreenApplication::GetWindow() +{ + return Internal::GetImplementation(*this).GetWindow(); +} + +void OffscreenApplication::RenderOnce() +{ + Internal::GetImplementation(*this).RenderOnce(); +} + +OffscreenApplication::OffscreenApplicationSignalType& OffscreenApplication::InitSignal() +{ + return Internal::GetImplementation(*this).InitSignal(); +} + +OffscreenApplication::OffscreenApplicationSignalType& OffscreenApplication::TerminateSignal() +{ + return Internal::GetImplementation(*this).TerminateSignal(); +} + +OffscreenApplication::OffscreenApplication(Internal::OffscreenApplication* offscreenApplication) +: BaseHandle(offscreenApplication) +{ +} + +} // namespace Dali diff --git a/dali/devel-api/adaptor-framework/offscreen-application.h b/dali/devel-api/adaptor-framework/offscreen-application.h new file mode 100644 index 0000000..3daa735 --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-application.h @@ -0,0 +1,154 @@ +#ifndef DALI_OFFSCREEN_APPLICATION_H +#define DALI_OFFSCREEN_APPLICATION_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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +namespace Dali +{ +/** + * @addtogroup dali_adaptor_framework + * @{ + */ + +class OffscreenWindow; + +namespace Internal +{ +class OffscreenApplication; +} + +/** + * @brief Appliations can draw UI on offscreen surface with the OffscreenApplication. + * When you use a OffscreenApplication, you don't have to create a Window. + */ +class DALI_IMPORT_API OffscreenApplication : public Dali::BaseHandle +{ +public: + using OffscreenApplicationSignalType = Signal; + + /** + * @brief Enumeration for the render mode + */ + enum class RenderMode + { + AUTO, // Scene is rendered automatically + MANUAL // Scene is rendered by RenderOnce() + }; + +public: + /** + * @brief This is the constructor of OffscreenApplication + * + * @param[in] width The initial width of the default OffscreenWindow + * @param[in] height The initial height of the default OffscreenWindow + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + * @param[in] renderMode The RenderMode of the OffscreenApplication + */ + static OffscreenApplication New(uint16_t width, uint16_t height, bool isTranslucent, RenderMode renderMode = RenderMode::AUTO); + + /** + * @brief This is the constructor of OffscreenApplication + * + * @param[in] surface The native surface handle to create the OffscreenWindow + * @param[in] renderMode The RenderMode of the OffscreenApplication + */ + static OffscreenApplication New(Dali::Any surface, RenderMode renderMode = RenderMode::AUTO); + + /** + * @brief Constructs an empty handle + */ + OffscreenApplication(); + + /** + * @brief Copy constructor + * + * @param [in] offscreenApplication A reference to the copied handle + */ + OffscreenApplication(const OffscreenApplication& offscreenApplication); + + /** + * @brief Assignment operator + * + * @param [in] offscreenApplication A reference to the copied handle + * @return A reference to this + */ + OffscreenApplication& operator=(const OffscreenApplication& offscreenApplication); + + /** + * @brief Destructor + */ + ~OffscreenApplication(); + +public: + /** + * @brief Starts the OffscreenApplication (rendering, event handling, etc) + */ + void Start(); + + /** + * @brief Stops the OffscreenApplication + */ + void Stop(); + + /** + * @brief Get the default OffscreenWindow handle + * @return The default OffscreenWindow + */ + OffscreenWindow GetWindow(); + + /** + * @brief Renders once more even if we're paused + */ + void RenderOnce(); + +public: // Signals + /** + * @brief Signal to notify the client when the application is ready to be initialized + * + * @note OffscreenApplication::Start() should be called to be initialized + * + * @return The signal + */ + OffscreenApplicationSignalType& InitSignal(); + + /** + * @brief Signal to notify the user when the application is about to be terminated + * + * @return The signal + */ + OffscreenApplicationSignalType& TerminateSignal(); + +public: // Not intended for application developers + /** + * @brief Internal constructor + */ + explicit DALI_INTERNAL OffscreenApplication(Internal::OffscreenApplication* offscreenApplication); +}; + +/** + * @} + */ + +} // namespace Dali + +#endif // DALI_OFFSCREEN_APPLICATION_H diff --git a/dali/devel-api/adaptor-framework/offscreen-window.cpp b/dali/devel-api/adaptor-framework/offscreen-window.cpp new file mode 100644 index 0000000..020eca4 --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-window.cpp @@ -0,0 +1,116 @@ +/* + * 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. + * + */ + +// CLASS HEADER +#include + +// EXTENRAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +OffscreenWindow OffscreenWindow::New(uint16_t width, uint16_t height, bool isTranslucent) +{ + Any surface; + IntrusivePtr impl = Internal::OffscreenWindow::New(width, height, surface, isTranslucent); + OffscreenWindow window = OffscreenWindow(impl.Get()); + impl->Initialize(false); + + return window; +} + +OffscreenWindow OffscreenWindow::New(Any surface) +{ + IntrusivePtr impl = Internal::OffscreenWindow::New(0, 0, surface, false); + OffscreenWindow window = OffscreenWindow(impl.Get()); + impl->Initialize(false); + + return window; +} + +OffscreenWindow::OffscreenWindow() = default; + +OffscreenWindow::OffscreenWindow(const OffscreenWindow& window) = default; + +OffscreenWindow& OffscreenWindow::operator=(const OffscreenWindow& window) = default; + +OffscreenWindow::~OffscreenWindow() = default; + +void OffscreenWindow::Add(Actor actor) +{ + Internal::GetImplementation(*this).Add(actor); +} + +void OffscreenWindow::Remove(Actor actor) +{ + Internal::GetImplementation(*this).Remove(actor); +} + +void OffscreenWindow::SetBackgroundColor(const Vector4& color) +{ + Internal::GetImplementation(*this).SetBackgroundColor(color); +} + +Vector4 OffscreenWindow::GetBackgroundColor() const +{ + return Internal::GetImplementation(*this).GetBackgroundColor(); +} + +Layer OffscreenWindow::GetRootLayer() const +{ + return Internal::GetImplementation(*this).GetRootLayer(); +} + +uint32_t OffscreenWindow::GetLayerCount() const +{ + return Internal::GetImplementation(*this).GetLayerCount(); +} + +Layer OffscreenWindow::GetLayer(uint32_t depth) const +{ + return Internal::GetImplementation(*this).GetLayer(depth); +} + +OffscreenWindow::WindowSize OffscreenWindow::GetSize() const +{ + return Internal::GetImplementation(*this).GetSize(); +} + +Any OffscreenWindow::GetNativeHandle() const +{ + return Internal::GetImplementation(*this).GetNativeHandle(); +} + +Uint16Pair OffscreenWindow::GetDpi() const +{ + return Internal::GetImplementation(*this).GetDpi(); +} + +OffscreenWindow::PostRenderSignalType& OffscreenWindow::PostRenderSignal() +{ + return Internal::GetImplementation(*this).PostRenderSignal(); +} + +OffscreenWindow::OffscreenWindow(Internal::OffscreenWindow* window) +: BaseHandle(window) +{ +} + +} // namespace Dali diff --git a/dali/devel-api/adaptor-framework/offscreen-window.h b/dali/devel-api/adaptor-framework/offscreen-window.h new file mode 100644 index 0000000..23386cd --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-window.h @@ -0,0 +1,197 @@ +#ifndef DALI_OFFSCREEN_WINDOW_H +#define DALI_OFFSCREEN_WINDOW_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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include + +namespace Dali +{ +/** + * @addtogroup dali_adaptor_framework + * @{ + */ + +class Layer; + +namespace Internal +{ +class OffscreenWindow; +} + +class DALI_IMPORT_API OffscreenWindow : public Dali::BaseHandle +{ +public: + using WindowSize = Uint16Pair; + using PostRenderSignalType = Signal; + +public: + /** + * @brief Creates an initialized handle to a new OffscreenWindow + * @note You should hold the returned handle. If you missed the handle, the OffscreenWindow will be released + * + * @param[in] width The initial width of the OffscreenWindow + * @param[in] height The initial height of the OffscreenWindow + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + static OffscreenWindow New(uint16_t width, uint16_t height, bool isTranslucent); + + /** + * @brief Creates an initialized handle to a new OffscreenWindow + * @note You should hold the returned handle. If you missed the handle, the OffscreenWindow will be released + * + * @param[in] surface The native surface handle of your platform + */ + static OffscreenWindow New(Any surface); + + /** + * @brief Constructs an empty handle + */ + OffscreenWindow(); + + /** + * @brief Copy constructor + * + * @param [in] window A reference to the copied handle + */ + OffscreenWindow(const OffscreenWindow& window); + + /** + * @brief Assignment operator + * + * @param [in] window A reference to the copied handle + * @return A reference to this + */ + OffscreenWindow& operator=(const OffscreenWindow& window); + + /** + * @brief Destructor + */ + ~OffscreenWindow(); + +public: + /** + * @brief Adds a child Actor to the OffscreenWindow. + * + * The child will be referenced. + * + * @param[in] actor The child + * @pre The actor has been initialized. + * @pre The actor does not have a parent. + */ + void Add(Actor actor); + + /** + * @brief Removes a child Actor from the OffscreenWindow. + * + * The child will be unreferenced. + * + * @param[in] actor The child + * @pre The actor has been added to the OffscreenWindow. + */ + void Remove(Actor actor); + + /** + * @brief Sets the background color of the OffscreenWindow. + * + * @param[in] color The new background color + */ + void SetBackgroundColor(const Vector4& color); + + /** + * @brief Gets the background color of the OffscreenWindow. + * + * @return The background color + */ + Vector4 GetBackgroundColor() const; + + /** + * @brief Returns the root Layer of the OffscreenWindow. + * + * @return The root layer + */ + Layer GetRootLayer() const; + + /** + * @brief Queries the number of on-scene layers. + * + * Note that a default layer is always provided (count >= 1). + * + * @return The number of layers + */ + uint32_t GetLayerCount() const; + + /** + * @brief Retrieves the layer at a specified depth in the OffscreenWindow. + * + * @param[in] depth The depth + * @return The layer found at the given depth + * @pre Depth is less than layer count; see GetLayerCount(). + */ + Layer GetLayer(uint32_t depth) const; + + /** + * @brief Returns the size of the OffscreenWindow in pixels as a Vector. + * + * The x component will be the width of the OffscreenWindow in pixels. + * The y component will be the height of the OffscreenWindow in pixels. + * + * @return The size of the OffscreenWindow as a Vector + */ + WindowSize GetSize() const; + + /** + * @brief Gets the native handle. + * @note When users call this function, it wraps the actual type used by the underlying system. + * @return The native handle or an empty handle + */ + Any GetNativeHandle() const; + + /** + * @brief Retrieves the DPI of the window. + * + * @return The DPI of the window + */ + Uint16Pair GetDpi() const; + +public: // Signals + /** + * @brief This signal is emitted when the OffscreenWindow is rendered. + * + * @return The signal + */ + PostRenderSignalType& PostRenderSignal(); + +public: // Not intended for application developers + /** + * @brief Internal constructor + */ + explicit DALI_INTERNAL OffscreenWindow(Internal::OffscreenWindow* window); +}; + +/** + * @} + */ + +} // namespace Dali + +#endif // DALI_OFFSCREEN_WINDOW_H diff --git a/dali/devel-api/file.list b/dali/devel-api/file.list index bfbccb5..40f393c 100755 --- a/dali/devel-api/file.list +++ b/dali/devel-api/file.list @@ -35,6 +35,8 @@ SET( devel_api_src_files ${adaptor_devel_api_dir}/adaptor-framework/web-engine.cpp ${adaptor_devel_api_dir}/adaptor-framework/window-devel.cpp ${adaptor_devel_api_dir}/adaptor-framework/gl-window.cpp + ${adaptor_devel_api_dir}/adaptor-framework/offscreen-application.cpp + ${adaptor_devel_api_dir}/adaptor-framework/offscreen-window.cpp ) @@ -88,6 +90,8 @@ SET( devel_api_adaptor_framework_header_files ${adaptor_devel_api_dir}/adaptor-framework/component-application.h ${adaptor_devel_api_dir}/adaptor-framework/video-sync-mode.h ${adaptor_devel_api_dir}/adaptor-framework/gl-window.h + ${adaptor_devel_api_dir}/adaptor-framework/offscreen-application.h + ${adaptor_devel_api_dir}/adaptor-framework/offscreen-window.h ) diff --git a/dali/integration-api/adaptor-framework/native-render-surface.h b/dali/integration-api/adaptor-framework/native-render-surface.h index a42d8fc..cca13ea 100644 --- a/dali/integration-api/adaptor-framework/native-render-surface.h +++ b/dali/integration-api/adaptor-framework/native-render-surface.h @@ -61,6 +61,12 @@ public: // API */ virtual void WaitUntilSurfaceReplaced() = 0; + /** + * @brief Get the native renderable handle + * @return The native renderable handle + */ + virtual Any GetNativeRenderable() = 0; + private: // from NativeRenderSurface /** * @brief Create a renderable diff --git a/dali/internal/adaptor/common/adaptor-impl.cpp b/dali/internal/adaptor/common/adaptor-impl.cpp index e6ae520..e75d156 100755 --- a/dali/internal/adaptor/common/adaptor-impl.cpp +++ b/dali/internal/adaptor/common/adaptor-impl.cpp @@ -96,10 +96,10 @@ thread_local Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer } // unnamed namespace -Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, EnvironmentOptions* environmentOptions ) +Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, EnvironmentOptions* environmentOptions, ThreadMode threadMode ) { Dali::Adaptor* adaptor = new Dali::Adaptor; - Adaptor* impl = new Adaptor( window, *adaptor, surface, environmentOptions ); + Adaptor* impl = new Adaptor( window, *adaptor, surface, environmentOptions, threadMode ); adaptor->mImpl = impl; Dali::Internal::Adaptor::AdaptorBuilder* mAdaptorBuilder = new AdaptorBuilder(); @@ -114,15 +114,15 @@ Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::Render Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, EnvironmentOptions* environmentOptions ) { Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( window ); - Dali::Adaptor* adaptor = New( window, windowImpl.GetSurface(), environmentOptions ); + Dali::Adaptor* adaptor = New( window, windowImpl.GetSurface(), environmentOptions, ThreadMode::NORMAL ); windowImpl.SetAdaptor( *adaptor ); return adaptor; } -Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, EnvironmentOptions* environmentOptions ) +Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, EnvironmentOptions* environmentOptions, ThreadMode threadMode ) { Dali::Adaptor* adaptor = new Dali::Adaptor; // Public adaptor - Adaptor* impl = new Adaptor( window, *adaptor, surface, environmentOptions ); // Impl adaptor + Adaptor* impl = new Adaptor( window, *adaptor, surface, environmentOptions, threadMode ); // Impl adaptor adaptor->mImpl = impl; impl->Initialize( graphicsFactory ); @@ -133,7 +133,7 @@ Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, EnvironmentOptions* environmentOptions ) { Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( window ); - Dali::Adaptor* adaptor = New( graphicsFactory, window, windowImpl.GetSurface(), environmentOptions ); + Dali::Adaptor* adaptor = New( graphicsFactory, window, windowImpl.GetSurface(), environmentOptions, ThreadMode::NORMAL ); windowImpl.SetAdaptor( *adaptor ); return adaptor; } // Called first @@ -1177,7 +1177,7 @@ Dali::ObjectRegistry Adaptor::GetObjectRegistry() const return registry; } -Adaptor::Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions) +Adaptor::Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions, ThreadMode threadMode ) : mResizedSignal(), mLanguageChangedSignal(), mWindowCreatedSignal(), @@ -1203,7 +1203,7 @@ Adaptor::Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, mSystemTracer(), mObjectProfiler( nullptr ), mSocketFactory(), - mThreadMode( ThreadMode::NORMAL ), + mThreadMode( threadMode ), mEnvironmentOptionsOwned( environmentOptions ? false : true /* If not provided then we own the object */ ), mUseRemoteSurface( false ), mRootLayoutDirection( Dali::LayoutDirection::LEFT_TO_RIGHT ) diff --git a/dali/internal/adaptor/common/adaptor-impl.h b/dali/internal/adaptor/common/adaptor-impl.h index a62bede..6394b3a 100644 --- a/dali/internal/adaptor/common/adaptor-impl.h +++ b/dali/internal/adaptor/common/adaptor-impl.h @@ -101,10 +101,12 @@ public: * - Pixmap, adaptor will use existing Pixmap to draw on to * - Window, adaptor will use existing Window to draw on to * @param[in] environmentOptions A pointer to the environment options. If NULL then one is created. + * @param[in] threadMode The thread mode */ static Dali::Adaptor* New( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface* surface, - EnvironmentOptions* environmentOptions ); + EnvironmentOptions* environmentOptions, + ThreadMode threadMode ); /** * Creates a New Adaptor @@ -122,11 +124,13 @@ public: * - Pixmap, adaptor will use existing Pixmap to draw on to * - Window, adaptor will use existing Window to draw on to * @param[in] environmentOptions A pointer to the environment options. If NULL then one is created. + * @param[in] threadMode The thread mode */ static Dali::Adaptor* New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface* surface, - EnvironmentOptions* environmentOptions ); + EnvironmentOptions* environmentOptions, + ThreadMode threadMode ); /** * Creates a New Adaptor @@ -624,8 +628,9 @@ private: * - Pixmap, adaptor will use existing Pixmap to draw on to * - Window, adaptor will use existing Window to draw on to * @param[in] environmentOptions A pointer to the environment options. If NULL then one is created. + * @param[in] threadMode The ThreadMode of the Adaptor */ - Adaptor( Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions ); + Adaptor( Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions, ThreadMode threadMode ); private: // Types diff --git a/dali/internal/adaptor/common/adaptor.cpp b/dali/internal/adaptor/common/adaptor.cpp index e6c3735..8f752ef 100644 --- a/dali/internal/adaptor/common/adaptor.cpp +++ b/dali/internal/adaptor/common/adaptor.cpp @@ -29,6 +29,7 @@ #include #include #include +#include namespace Dali { @@ -44,7 +45,7 @@ Adaptor& Adaptor::New( Window window, const Dali::RenderSurfaceInterface& surfac { Internal::Adaptor::SceneHolder* sceneHolder = &Dali::GetImplementation( window ); Dali::RenderSurfaceInterface* pSurface = const_cast(&surface); - Adaptor* adaptor = Internal::Adaptor::Adaptor::New( Dali::Integration::SceneHolder( sceneHolder ), pSurface, NULL ); + Adaptor* adaptor = Internal::Adaptor::Adaptor::New( Dali::Integration::SceneHolder( sceneHolder ), pSurface, NULL, Dali::Internal::Adaptor::ThreadMode::NORMAL ); return *adaptor; } @@ -57,7 +58,7 @@ Adaptor& Adaptor::New( Dali::Integration::SceneHolder window ) Adaptor& Adaptor::New( Dali::Integration::SceneHolder window, const Dali::RenderSurfaceInterface& surface ) { Dali::RenderSurfaceInterface* pSurface = const_cast(&surface); - Adaptor* adaptor = Internal::Adaptor::Adaptor::New( window, pSurface, NULL ); + Adaptor* adaptor = Internal::Adaptor::Adaptor::New( window, pSurface, NULL, Dali::Internal::Adaptor::ThreadMode::NORMAL ); return *adaptor; } diff --git a/dali/internal/offscreen/common/offscreen-application-impl.cpp b/dali/internal/offscreen/common/offscreen-application-impl.cpp new file mode 100644 index 0000000..396dbc4 --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-application-impl.cpp @@ -0,0 +1,86 @@ +/* + * 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. + * + */ + +// CLASS HEADER +#include + +// INTERNAL INCLUDES +#include +#include +#include +#include +#include + +namespace Dali +{ + +namespace Internal +{ + +using RenderMode = Dali::OffscreenApplication::RenderMode; + +IntrusivePtr< OffscreenApplication > OffscreenApplication::New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent, RenderMode renderMode ) +{ + IntrusivePtr< OffscreenApplication > offscreenApplication = new OffscreenApplication( width, height, surface, isTranslucent, renderMode ); + return offscreenApplication; +} + +OffscreenApplication::OffscreenApplication( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent, RenderMode renderMode ) +{ + // Generate a default window + IntrusivePtr< Internal::OffscreenWindow > impl = Internal::OffscreenWindow::New( width, height, surface, isTranslucent ); + mDefaultWindow = Dali::OffscreenWindow( impl.Get() ); + + mAdaptor.reset( Dali::Internal::Adaptor::Adaptor::New( Dali::Integration::SceneHolder( impl.Get() ), impl->GetSurface(), NULL, + renderMode == RenderMode::AUTO ? Dali::Internal::Adaptor::ThreadMode::NORMAL : Dali::Internal::Adaptor::ThreadMode::RUN_IF_REQUESTED ) ); + + // Initialize default window + impl->Initialize( true ); +} + +void OffscreenApplication::Start() +{ + // Start the adaptor + mAdaptor->Start(); + + Dali::OffscreenApplication handle( this ); + mInitSignal.Emit(); + mAdaptor->NotifySceneCreated(); +} + +void OffscreenApplication::Stop() +{ + // Stop the adaptor + mAdaptor->Stop(); + + Dali::OffscreenApplication handle( this ); + mTerminateSignal.Emit(); +} + +Dali::OffscreenWindow OffscreenApplication::GetWindow() +{ + return mDefaultWindow; +} + +void OffscreenApplication::RenderOnce() +{ + mAdaptor->RenderOnce(); +} + +} // namespace Internal + +} // namespace Dali diff --git a/dali/internal/offscreen/common/offscreen-application-impl.h b/dali/internal/offscreen/common/offscreen-application-impl.h new file mode 100644 index 0000000..22c5f9e --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-application-impl.h @@ -0,0 +1,149 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_APPLICATION_IMPL_H +#define DALI_INTERNAL_OFFSCREEN_APPLICATION_IMPL_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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include +#include +#include + +namespace Dali +{ +class Adaptor; + +namespace Internal +{ + +/** + * Implementation of the OffscreenApplication class. + */ +class OffscreenApplication : public BaseObject +{ +public: + + using OffscreenApplicationSignalType = Dali::OffscreenApplication::OffscreenApplicationSignalType; + + /** + * @brief Create a new OffscreenApplication + * @param[in] width The width of the default OffscreenWindow + * @param[in] height The height of the default OffscreenWindow + * @param[in] surface The native surface handle to create the default OffscreenWindow + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + * @param[in] renderMode The RenderMode of the OffscreenApplication + */ + static IntrusivePtr New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent, Dali::OffscreenApplication::RenderMode renderMode); + +public: + + /** + * Destructor + */ + virtual ~OffscreenApplication() = default; + + /** + * @copydoc Dali::OffscreenApplication::Start() + */ + void Start(); + + /** + * @copydoc Dali::OffscreenApplication::Stop() + */ + void Stop(); + + /** + * @copydoc Dali::OffscreenApplication::GetDefaultWindow() + */ + Dali::OffscreenWindow GetWindow(); + + /** + * @copydoc Dali::OffscreenApplication::RenderOnce() + */ + void RenderOnce(); + +public: // Signals + + /** + * @copydoc Dali::OffscreenApplication::InitSignal() + */ + OffscreenApplicationSignalType& InitSignal() + { + return mInitSignal; + } + + /** + * @copydoc Dali::OffscreenApplication::TerminateSignal() + */ + OffscreenApplicationSignalType& TerminateSignal() + { + return mTerminateSignal; + } + +private: + /** + * Private constructor + * @param[in] width The width of the OffscreenWindow + * @param[in] height The height of the OffscreenApplication + * @param[in] surface The native surface handle to create the default OffscreenWindow + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + * @param[in] renderMode The RenderMode of the OffscreenApplication + */ + OffscreenApplication( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent, Dali::OffscreenApplication::RenderMode renderMode ); + + // Undefined + OffscreenApplication( const OffscreenApplication& ) = delete; + OffscreenApplication& operator=( OffscreenApplication& ) = delete; + OffscreenApplication& operator=( const OffscreenApplication& ) = delete; + OffscreenApplication& operator=( OffscreenApplication&& ) = delete; + +private: + std::unique_ptr< Dali::Adaptor > mAdaptor; + Dali::OffscreenWindow mDefaultWindow; + + OffscreenApplicationSignalType mInitSignal; + OffscreenApplicationSignalType mTerminateSignal; +}; + +inline OffscreenApplication& GetImplementation( Dali::OffscreenApplication& offscreenApplication ) +{ + DALI_ASSERT_ALWAYS( offscreenApplication && "OffscreenApplication handle is empty" ); + + BaseObject& handle = offscreenApplication.GetBaseObject(); + + return static_cast( handle ); +} + +inline const OffscreenApplication& GetImplementation( const Dali::OffscreenApplication& offscreenApplication ) +{ + DALI_ASSERT_ALWAYS( offscreenApplication && "OffscreenApplication handle is empty" ); + + const BaseObject& handle = offscreenApplication.GetBaseObject(); + + return static_cast( handle ); +} + +} // namespace Internal + +} // namespace Dali + +#endif // DALI_INTERNAL_OFFSCREEN_APPLICATION_IMPL_H diff --git a/dali/internal/offscreen/common/offscreen-window-impl.cpp b/dali/internal/offscreen/common/offscreen-window-impl.cpp new file mode 100644 index 0000000..ab818ad --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-window-impl.cpp @@ -0,0 +1,135 @@ +/* + * 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. + * + */ + +// CLASS HEADER +#include + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include +#include +#include +#include +#include + +namespace Dali +{ + +namespace Internal +{ + +OffscreenWindow* OffscreenWindow::New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +{ + OffscreenWindow* window = new OffscreenWindow( width, height, surface, isTranslucent ); + return window; +} + +OffscreenWindow::OffscreenWindow( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +: mRenderNotification() +{ + // Create surface + mSurface = std::unique_ptr< RenderSurfaceInterface >( CreateNativeSurface( SurfaceSize( width, height ), surface, isTranslucent ) ); +} + +void OffscreenWindow::Initialize( bool isDefaultWindow ) +{ + if( isDefaultWindow ) + { + Initialize(); + return; + } + + Dali::Integration::SceneHolder sceneHolderHandler = Dali::Integration::SceneHolder( this ); + Dali::Adaptor::Get().AddWindow( sceneHolderHandler ); + + Initialize(); +} + +void OffscreenWindow::Initialize() +{ + // Connect callback to be notified when the surface is rendered + TriggerEventFactory triggerEventFactory; + + mRenderNotification = std::unique_ptr< TriggerEventInterface >( triggerEventFactory.CreateTriggerEvent( MakeCallback( this, &OffscreenWindow::OnPostRender ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER ) ); + + NativeRenderSurface* surface = GetNativeRenderSurface(); + + if( !surface ) + { + return; + } + + surface->SetRenderNotification( mRenderNotification.get() ); +} + +OffscreenWindow::~OffscreenWindow() +{ + NativeRenderSurface* surface = GetNativeRenderSurface(); + + if( surface ) + { + // To prevent notification triggering in NativeRenderSurface::PostRender while deleting SceneHolder + surface->SetRenderNotification( nullptr ); + } +} + +uint32_t OffscreenWindow::GetLayerCount() const +{ + return mScene.GetLayerCount(); +} + +Dali::Layer OffscreenWindow::GetLayer( uint32_t depth ) const +{ + return mScene.GetLayer( depth ); +} + +OffscreenWindow::WindowSize OffscreenWindow::GetSize() const +{ + Size size = mScene.GetSize(); + + return OffscreenWindow::WindowSize( static_cast( size.width ), static_cast( size.height ) ); +} + +Dali::Any OffscreenWindow::GetNativeHandle() const +{ + NativeRenderSurface* surface = GetNativeRenderSurface(); + DALI_ASSERT_ALWAYS( surface && "surface handle is empty" ); + + return surface->GetNativeRenderable(); +} + +NativeRenderSurface* OffscreenWindow::GetNativeRenderSurface() const +{ + return dynamic_cast< NativeRenderSurface* >( mSurface.get() ); +} + +void OffscreenWindow::OnPostRender() +{ + Dali::OffscreenWindow handle( this ); + mPostRenderSignal.Emit( handle, GetNativeHandle() ); +} + +OffscreenWindow::PostRenderSignalType& OffscreenWindow::PostRenderSignal() +{ + return mPostRenderSignal; +} + +} // namespace Internal + +} // namespace Dali diff --git a/dali/internal/offscreen/common/offscreen-window-impl.h b/dali/internal/offscreen/common/offscreen-window-impl.h new file mode 100644 index 0000000..95a7c55 --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-window-impl.h @@ -0,0 +1,163 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_H +#define DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include +#include + +namespace Dali +{ +class Adaptor; +class Layer; +class NativeRenderSurface; +class TriggerEventInterface; + +namespace Internal +{ + +/** + * Implementation of the OffscreenWindow class. + */ +class OffscreenWindow : public Dali::Internal::Adaptor::SceneHolder, + public ConnectionTracker +{ +public: + using WindowSize = Dali::OffscreenWindow::WindowSize; + using PostRenderSignalType = Dali::OffscreenWindow::PostRenderSignalType; + + /** + * @brief Create a new OffscreenWindow + * + * @param[in] width The initial width of the OffscreenWindow + * @param[in] height The initial height of the OffscreenWindow + * @param[in] surface The native surface handle of your platform + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + static OffscreenWindow* New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + + OffscreenWindow() = default; + +public: + + /** + * Destructor + */ + ~OffscreenWindow(); + + /** + * @copydoc Dali::OffscreenWindow::GetLayerCount + */ + uint32_t GetLayerCount() const; + + /** + * @copydoc Dali::OffscreenWindow::GetLayer + */ + Dali::Layer GetLayer( uint32_t depth ) const; + + /** + * @copydoc Dali::OffscreenWindow::GetSize + */ + WindowSize GetSize() const; + + /** + * @copydoc Dali::OffscreenWindow::GetNativeHandle + */ + Any GetNativeHandle() const override; + + /* + * @brief Initialize the OffscreenWindow + * @param[in] isDefaultWindow Whether the OffscreenWindow is a default one or not + */ + void Initialize( bool isDefaultWindow ); + +public: // Signals + + /** + * @copydoc Dali::OffscreenWindow::PostRenderSignal + */ + PostRenderSignalType& PostRenderSignal(); + +private: + /** + * This function is called after drawing by dali. + */ + void OnPostRender(); + + /** + * @brief Get the native render surface + * @return The render surface + */ + NativeRenderSurface* GetNativeRenderSurface() const; + +private: + + /** + * Private constructor + * + * @param[in] width The initial width of the OffscreenWindow + * @param[in] height The initial height of the OffscreenWindow + * @param[in] surface The native surface handle + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + OffscreenWindow( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + + // Undefined + OffscreenWindow( const OffscreenWindow& ); + OffscreenWindow& operator=( OffscreenWindow& ); + + /* + * @brief Initialize the OffscreenWindow (for internal use) + */ + void Initialize(); + +private: + + std::unique_ptr< TriggerEventInterface > mRenderNotification; + PostRenderSignalType mPostRenderSignal; +}; + +inline OffscreenWindow& GetImplementation( Dali::OffscreenWindow& offscreenWindow ) +{ + DALI_ASSERT_ALWAYS( offscreenWindow && "Dali::OffscreenWindow handle is empty" ); + + BaseObject& handle = offscreenWindow.GetBaseObject(); + + return static_cast( handle ); +} + +inline const OffscreenWindow& GetImplementation( const Dali::OffscreenWindow& offscreenWindow ) +{ + DALI_ASSERT_ALWAYS( offscreenWindow && "Dali::OffscreenWindow handle is empty" ); + + const BaseObject& handle = offscreenWindow.GetBaseObject(); + + return static_cast( handle ); +} + +} // namespace Internal + +} // namespace Dali + +#endif // DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_H diff --git a/dali/internal/offscreen/file.list b/dali/internal/offscreen/file.list new file mode 100644 index 0000000..e75b847 --- /dev/null +++ b/dali/internal/offscreen/file.list @@ -0,0 +1,5 @@ +# module: offscreen, backend: common +SET( adaptor_offscreen_common_src_files + ${adaptor_offscreen_dir}/common/offscreen-application-impl.cpp + ${adaptor_offscreen_dir}/common/offscreen-window-impl.cpp +) diff --git a/dali/internal/window-system/tizen-wayland/native-render-surface-ecore-wl.cpp b/dali/internal/window-system/tizen-wayland/native-render-surface-ecore-wl.cpp index 2aaa623..7b7f923 100644 --- a/dali/internal/window-system/tizen-wayland/native-render-surface-ecore-wl.cpp +++ b/dali/internal/window-system/tizen-wayland/native-render-surface-ecore-wl.cpp @@ -54,14 +54,11 @@ Debug::Filter* gNativeSurfaceLogFilter = Debug::Filter::New(Debug::Verbose, fals } // unnamed namespace NativeRenderSurfaceEcoreWl::NativeRenderSurfaceEcoreWl( SurfaceSize surfaceSize, Any surface, bool isTransparent ) -: mSurfaceSize( surfaceSize ), - mRenderNotification( NULL ), +: mRenderNotification( NULL ), mGraphics( NULL ), mEGL( nullptr ), mEGLSurface( nullptr ), mEGLContext( nullptr ), - mColorDepth( isTransparent ? COLOR_DEPTH_32 : COLOR_DEPTH_24 ), - mTbmFormat( isTransparent ? TBM_FORMAT_ARGB8888 : TBM_FORMAT_RGB888 ), mOwnSurface( false ), mDrawableCompleted( false ), mTbmQueue( NULL ), @@ -72,13 +69,22 @@ NativeRenderSurfaceEcoreWl::NativeRenderSurfaceEcoreWl( SurfaceSize surfaceSize, if( surface.Empty() ) { + mSurfaceSize = surfaceSize; + mColorDepth = isTransparent ? COLOR_DEPTH_32 : COLOR_DEPTH_24; + mTbmFormat = isTransparent ? TBM_FORMAT_ARGB8888 : TBM_FORMAT_RGB888; CreateNativeRenderable(); } else { - // check we have a valid type - DALI_ASSERT_ALWAYS( ( surface.GetType() == typeid (tbm_surface_queue_h) ) && "Surface type is invalid" ); mTbmQueue = AnyCast< tbm_surface_queue_h >( surface ); + + uint16_t width = static_cast( tbm_surface_queue_get_width( mTbmQueue ) ); + uint16_t height = static_cast( tbm_surface_queue_get_height( mTbmQueue ) ); + mSurfaceSize = SurfaceSize( width, height ); + + mTbmFormat = tbm_surface_queue_get_format( mTbmQueue ); + + mColorDepth = ( mTbmFormat == TBM_FORMAT_ARGB8888 ) ? COLOR_DEPTH_32 : COLOR_DEPTH_24; } } @@ -126,6 +132,11 @@ void NativeRenderSurfaceEcoreWl::WaitUntilSurfaceReplaced() mDrawableCompleted = false; } +Any NativeRenderSurfaceEcoreWl::GetNativeRenderable() +{ + return mTbmQueue; +} + PositionSize NativeRenderSurfaceEcoreWl::GetPositionSize() const { return PositionSize( 0, 0, static_cast( mSurfaceSize.GetWidth() ), static_cast( mSurfaceSize.GetHeight() ) ); @@ -239,45 +250,62 @@ void NativeRenderSurfaceEcoreWl::PostRender( bool renderToFbo, bool replacingSur eglImpl.SwapBuffers( mEGLSurface, damagedRects ); } - if( mThreadSynchronization ) + //TODO: Move calling tbm_surface_queue_acruie to OffscreenWindow and Scene in EvasPlugin + if ( mOwnSurface ) { - mThreadSynchronization->PostRenderStarted(); - } + if( mThreadSynchronization ) + { + mThreadSynchronization->PostRenderStarted(); + } - if( tbm_surface_queue_can_acquire( mTbmQueue, 1 ) ) - { - if( tbm_surface_queue_acquire( mTbmQueue, &mConsumeSurface ) != TBM_SURFACE_QUEUE_ERROR_NONE ) + if( tbm_surface_queue_can_acquire( mTbmQueue, 1 ) ) { - DALI_LOG_ERROR( "Failed to acquire a tbm_surface\n" ); - return; + if( tbm_surface_queue_acquire( mTbmQueue, &mConsumeSurface ) != TBM_SURFACE_QUEUE_ERROR_NONE ) + { + DALI_LOG_ERROR( "Failed to acquire a tbm_surface\n" ); + return; + } } - } - tbm_surface_internal_ref( mConsumeSurface ); + if ( mConsumeSurface ) + { + tbm_surface_internal_ref( mConsumeSurface ); + } - if( replacingSurface ) - { - ConditionalWait::ScopedLock lock( mTbmSurfaceCondition ); - mDrawableCompleted = true; - mTbmSurfaceCondition.Notify( lock ); - } + if( replacingSurface ) + { + ConditionalWait::ScopedLock lock( mTbmSurfaceCondition ); + mDrawableCompleted = true; + mTbmSurfaceCondition.Notify( lock ); + } - // create damage for client applications which wish to know the update timing - if( !replacingSurface && mRenderNotification ) - { - // use notification trigger - // Tell the event-thread to render the tbm_surface - mRenderNotification->Trigger(); - } + // create damage for client applications which wish to know the update timing + if( !replacingSurface && mRenderNotification ) + { + // use notification trigger + // Tell the event-thread to render the tbm_surface + mRenderNotification->Trigger(); + } - if( mThreadSynchronization ) + if( mThreadSynchronization ) + { + // wait until the event-thread completed to use the tbm_surface + mThreadSynchronization->PostRenderWaitForCompletion(); + } + + // release the consumed surface after post render was completed + ReleaseDrawable(); + } + else { - // wait until the event-thread completed to use the tbm_surface - mThreadSynchronization->PostRenderWaitForCompletion(); + // create damage for client applications which wish to know the update timing + if( !replacingSurface && mRenderNotification ) + { + // use notification trigger + // Tell the event-thread to render the tbm_surface + mRenderNotification->Trigger(); + } } - - // release the consumed surface after post render was completed - ReleaseDrawable(); } void NativeRenderSurfaceEcoreWl::StopRender() diff --git a/dali/internal/window-system/tizen-wayland/native-render-surface-ecore-wl.h b/dali/internal/window-system/tizen-wayland/native-render-surface-ecore-wl.h index ea01567..d21ed86 100644 --- a/dali/internal/window-system/tizen-wayland/native-render-surface-ecore-wl.h +++ b/dali/internal/window-system/tizen-wayland/native-render-surface-ecore-wl.h @@ -72,6 +72,11 @@ public: // from WindowRenderSurface */ void WaitUntilSurfaceReplaced() override; + /** + * @copydoc Dali::NativeRenderSurface::GetNativeRenderable() + */ + virtual Any GetNativeRenderable() override; + public: // from Dali::RenderSurfaceInterface /** -- 2.7.4