From b7769b595b297a4b371bbc09e01c99a47b7e5bf6 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: I33f70af964fa54036a2e9946be866f116e637853 --- 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 + .../offscreen-application.cpp | 102 +++++++++ .../adaptor-framework/offscreen-application.h | 158 ++++++++++++++ .../adaptor-framework/offscreen-window.cpp | 132 ++++++++++++ .../adaptor-framework/offscreen-window.h | 202 ++++++++++++++++++ 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 | 84 ++++++++ .../common/offscreen-application-impl.h | 147 +++++++++++++ .../common/offscreen-window-impl.cpp | 131 ++++++++++++ .../offscreen/common/offscreen-window-impl.h | 163 ++++++++++++++ dali/internal/offscreen/file.list | 5 + .../native-render-surface-ecore-wl.cpp | 30 ++- .../native-render-surface-ecore-wl.h | 5 + 25 files changed, 1192 insertions(+), 20 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 161d1de34..f779f50a8 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 5862cec12..2d41d2c8f 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 e1afc1e47..7add3a01e 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 aebd8b633..82f1a9531 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 a53da274e..a5329ff41 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 2469de786..34a69fac3 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 82643fa29..cdd43c4ff 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 2a908d048..ad505b6b6 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 c39c3bdd6..92a7fb9a6 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 000000000..49d98ec0c --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-application.cpp @@ -0,0 +1,102 @@ +/* + * 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< Internal::OffscreenApplication > 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< Internal::OffscreenApplication > impl = Internal::OffscreenApplication::New( 0, 0, surface, false, renderMode ); + + OffscreenApplication offscreenApplication = OffscreenApplication( impl.Get() ); + + return offscreenApplication; +} + +OffscreenApplication::OffscreenApplication() +{ +} + +OffscreenApplication::OffscreenApplication( const OffscreenApplication& offscreenApplication ) +: BaseHandle( offscreenApplication ) +{ +} + +OffscreenApplication& OffscreenApplication::operator=( const OffscreenApplication& offscreenApplication ) +{ + if( *this != offscreenApplication ) + { + BaseHandle::operator=( offscreenApplication ); + } + return *this; +} + +OffscreenApplication::~OffscreenApplication() +{ +} + +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 000000000..47d297ffe --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-application.h @@ -0,0 +1,158 @@ +#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: + + /** + * @brief Enumeration for the render mode + */ + enum class RenderMode + { + AUTO, // Scene is rendered automatically + MANUAL // Scene is rendered by RenderOnce() + }; + + typedef Signal OffscreenApplicationSignalType; + +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 + */ + OffscreenApplication( const OffscreenApplication& offscreenApplication ); + + /** + * @brief Assignment operator + */ + 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 Window handle + * @return The default Window + */ + 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 000000000..ffba8e65b --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-window.cpp @@ -0,0 +1,132 @@ +/* + * 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 +#include + +namespace Dali +{ +OffscreenWindow OffscreenWindow::New( uint16_t width, uint16_t height, bool isTranslucent ) +{ + Any surface; + IntrusivePtr< Internal::OffscreenWindow > impl = Internal::OffscreenWindow::New( width, height, surface, isTranslucent ); + OffscreenWindow window = OffscreenWindow( impl.Get() ); + impl->Initialize( false ); + + return window; +} + +OffscreenWindow OffscreenWindow::New( Any surface ) +{ + IntrusivePtr< Internal::OffscreenWindow > impl = Internal::OffscreenWindow::New( 0, 0, surface, false ); + OffscreenWindow window = OffscreenWindow( impl.Get() ); + impl->Initialize( false ); + + return window; +} + +OffscreenWindow::OffscreenWindow() +{ +} + +OffscreenWindow::OffscreenWindow( const OffscreenWindow& window ) +: BaseHandle( window ) +{ +} + +OffscreenWindow& OffscreenWindow::operator=( const OffscreenWindow& window ) +{ + if( *this != window ) + { + BaseHandle::operator=( window ); + } + return *this; +} + +OffscreenWindow::~OffscreenWindow() +{ +} + +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 000000000..d1fc78982 --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-window.h @@ -0,0 +1,202 @@ +#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 +#include + +// INTERNAL INCLUDES +#include + +namespace Dali +{ + +/** + * @addtogroup dali_adaptor_framework + * @{ + */ + +class Layer; + +namespace Internal +{ +class OffscreenWindow; +} + +class DALI_IMPORT_API OffscreenWindow : public Dali::BaseHandle +{ +public: + + typedef Uint16Pair WindowSize; + typedef Signal PostRenderSignalType; + +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 + */ + OffscreenWindow( const OffscreenWindow& window ); + + /** + * @brief Assignment operator + */ + 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 91c5cee2e..fdb16db1f 100755 --- a/dali/devel-api/file.list +++ b/dali/devel-api/file.list @@ -34,6 +34,8 @@ SET( devel_api_src_files ${adaptor_devel_api_dir}/adaptor-framework/thread-settings.cpp ${adaptor_devel_api_dir}/adaptor-framework/web-engine.cpp ${adaptor_devel_api_dir}/adaptor-framework/window-devel.cpp + ${adaptor_devel_api_dir}/adaptor-framework/offscreen-application.cpp + ${adaptor_devel_api_dir}/adaptor-framework/offscreen-window.cpp ) @@ -86,6 +88,8 @@ SET( devel_api_adaptor_framework_header_files ${adaptor_devel_api_dir}/adaptor-framework/window-devel.h ${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/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 4d4ef3728..05df78ae8 100644 --- a/dali/integration-api/adaptor-framework/native-render-surface.h +++ b/dali/integration-api/adaptor-framework/native-render-surface.h @@ -64,6 +64,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 /** diff --git a/dali/internal/adaptor/common/adaptor-impl.cpp b/dali/internal/adaptor/common/adaptor-impl.cpp index e6ae520a9..e75d15607 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 cf81f7ced..4749adb86 100755 --- 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 e6c373538..8f752efde 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 000000000..254f42f12 --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-application-impl.cpp @@ -0,0 +1,84 @@ +/* + * 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 + +using Dali::Internal::Adaptor::ThreadMode; +using RenderMode = Dali::OffscreenApplication::RenderMode; + +namespace Dali +{ + +namespace Internal +{ + +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(); + mInitSignal.Emit(); + mAdaptor->NotifySceneCreated(); +} + +void OffscreenApplication::Stop() +{ + // Stop the adaptor + mAdaptor->Stop(); + 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 000000000..fdd5fa8ff --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-application-impl.h @@ -0,0 +1,147 @@ +#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& ); + OffscreenApplication& operator=( OffscreenApplication& ); + +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 000000000..352438af6 --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-window-impl.cpp @@ -0,0 +1,131 @@ +/* + * 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 +{ + return GetNativeRenderSurface()->GetNativeRenderable(); +} + +NativeRenderSurface* OffscreenWindow::GetNativeRenderSurface() const +{ + return dynamic_cast< NativeRenderSurface* >( mSurface.get() ); +} + +void OffscreenWindow::OnPostRender() +{ + mPostRenderSignal.Emit( Dali::OffscreenWindow( this ), 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 000000000..95a7c5500 --- /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 000000000..e75b84761 --- /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 7ade18fc9..f6cf45632 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() ) ); @@ -226,6 +237,8 @@ void NativeRenderSurfaceEcoreWl::StartRender() bool NativeRenderSurfaceEcoreWl::PreRender( bool resizingSurface, const std::vector>& damagedRects, Rect& clippingRect ) { + MakeContextCurrent(); + auto eglGraphics = static_cast(mGraphics); if (eglGraphics) { @@ -264,7 +277,10 @@ void NativeRenderSurfaceEcoreWl::PostRender( bool renderToFbo, bool replacingSur } } - tbm_surface_internal_ref( mConsumeSurface ); + if ( mConsumeSurface ) + { + tbm_surface_internal_ref( mConsumeSurface ); + } if( replacingSurface ) { 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 ea9c6d7dd..71e182a4b 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 */ virtual void WaitUntilSurfaceReplaced() override; + /** + * @copydoc Dali::NativeRenderSurface::GetNativeRenderable() + */ + virtual Any GetNativeRenderable() override; + public: // from Dali::RenderSurfaceInterface /** -- 2.34.1