From: Joogab Yun Date: Tue, 1 Sep 2020 08:05:40 +0000 (+0900) Subject: [Tizen] Add OffscreenApplication X-Git-Tag: accepted/tizen/unified/20200903.151828~8 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git;a=commitdiff_plain;h=b64876820169d0d123ca39f2a42ef7599a1ca2b1 [Tizen] Add OffscreenApplication This reverts commit 12baf09c8d37b91b51933baf85a10fce4bdfa097. Change-Id: I62526c7e81a3e5b29a06b58365d197e911ecb06a --- 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..d220b58 100644 --- a/build/tizen/profiles/android-profile.cmake +++ b/build/tizen/profiles/android-profile.cmake @@ -24,6 +24,8 @@ SET( SOURCES ${adaptor_integration_api_android_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} + ${adaptor_offscreen_android_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..c47a3cf 100644 --- a/build/tizen/profiles/common-profile.cmake +++ b/build/tizen/profiles/common-profile.cmake @@ -23,6 +23,8 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} + ${adaptor_offscreen_tizen_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..7ec48e6 100644 --- a/build/tizen/profiles/ivi-profile.cmake +++ b/build/tizen/profiles/ivi-profile.cmake @@ -24,6 +24,8 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} + ${adaptor_offscreen_tizen_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..6907af4 100644 --- a/build/tizen/profiles/mobile-profile.cmake +++ b/build/tizen/profiles/mobile-profile.cmake @@ -23,6 +23,8 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} + ${adaptor_offscreen_tizen_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..38a21eb 100644 --- a/build/tizen/profiles/tv-profile.cmake +++ b/build/tizen/profiles/tv-profile.cmake @@ -23,6 +23,8 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} + ${adaptor_offscreen_tizen_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..5f2c7d4 100644 --- a/build/tizen/profiles/ubuntu-profile.cmake +++ b/build/tizen/profiles/ubuntu-profile.cmake @@ -22,6 +22,8 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} + ${adaptor_offscreen_ubuntu-x11_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..491f4a8 100644 --- a/build/tizen/profiles/wearable-profile.cmake +++ b/build/tizen/profiles/wearable-profile.cmake @@ -24,6 +24,8 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} + ${adaptor_offscreen_tizen_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..b59fc6f 100644 --- a/build/tizen/profiles/windows-profile.cmake +++ b/build/tizen/profiles/windows-profile.cmake @@ -17,6 +17,8 @@ SET( SOURCES ${adaptor_integration_api_src_files} ${adaptor_legacy_common_src_files} ${adaptor_network_common_src_files} + ${adaptor_offscreen_common_src_files} + ${adaptor_offscreen_windows_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..f5a522c --- /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, bool isTranslucent, OffscreenApplication::RenderMode renderMode ) +{ + IntrusivePtr< Internal::OffscreenApplication > impl = Internal::OffscreenApplication::New( 0, 0, surface, isTranslucent, 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 0000000..dd5eacb --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-application.h @@ -0,0 +1,156 @@ +#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: + + enum class RenderMode + { + AUTO, // UI is rendered automatically + MANUAL // UI 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] isTranslucent Whether the OffscreenWindow is translucent or not + * @param[in] renderMode The RenderMode of the OffscreenApplication + */ + static OffscreenApplication New( Dali::Any surface, bool isTranslucent, + 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 0000000..ab024a7 --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-window.cpp @@ -0,0 +1,130 @@ +/* + * 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. + * + */ + +// EXTENRAL INCLUDES +#include + +// INTERNAL INCLUDES +#include +#include +#include + +// CLASS HEADER +#include + +namespace Dali +{ +OffscreenWindow OffscreenWindow::New( uint16_t width, uint16_t height, bool isTranslucent ) +{ + auto windowFactory = Dali::Internal::GetOffscreenWindowFactory(); + Any surface; + IntrusivePtr < Internal::OffscreenWindow > impl = windowFactory->CreateOffscreenWindow( width, height, surface, isTranslucent ).release(); + OffscreenWindow window = OffscreenWindow( impl.Get() ); + impl->Initialize( false ); + + return window; +} + +OffscreenWindow OffscreenWindow::New( Any surface, bool isTranslucent ) +{ + auto windowFactory = Dali::Internal::GetOffscreenWindowFactory(); + IntrusivePtr < Internal::OffscreenWindow > impl = windowFactory->CreateOffscreenWindow( 0, 0, surface, isTranslucent ).release(); + 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(); +} + +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..bb279cb --- /dev/null +++ b/dali/devel-api/adaptor-framework/offscreen-window.h @@ -0,0 +1,196 @@ +#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 + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + static OffscreenWindow New( Any surface, bool isTranslucent ); + + /** + * @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; + +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 7c404a0..717cba9 100755 --- a/dali/devel-api/file.list +++ b/dali/devel-api/file.list @@ -37,6 +37,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 ) @@ -92,6 +94,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 4d4ef37..1efcfb3 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 surface handle + * @return The native surface handle + */ + virtual Any GetNativeHandle() = 0; + private: // from NativeRenderSurface /** diff --git a/dali/internal/adaptor/common/adaptor-impl.cpp b/dali/internal/adaptor/common/adaptor-impl.cpp index 5a65a8e..52b9eff 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, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) +Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, 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(); @@ -111,6 +111,13 @@ Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::Render return adaptor; } +Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) +{ + Dali::Adaptor* adaptor = New( window, surface, configuration, environmentOptions, ThreadMode::NORMAL ); + + return adaptor; +} + Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) { Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( window ); @@ -119,15 +126,22 @@ Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::Config return adaptor; } -Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) +Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, 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, configuration ); return adaptor; +} + +Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) +{ + Dali::Adaptor* adaptor = New( graphicsFactory, window, surface, configuration, environmentOptions, ThreadMode::NORMAL ); + + return adaptor; } // Called second Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) @@ -1177,7 +1191,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 +1217,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 ec5c645..7093fb7 100755 --- a/dali/internal/adaptor/common/adaptor-impl.h +++ b/dali/internal/adaptor/common/adaptor-impl.h @@ -102,6 +102,22 @@ public: * - Window, adaptor will use existing Window to draw on to * @param[in] configuration The context loss configuration ( to choose resource discard policy ) * @param[in] environmentOptions A pointer to the environment options. If NULL then one is created. + * @param[in] threadMode The mode of the Adaptor + */ + static Dali::Adaptor* New( Dali::Integration::SceneHolder window, + Dali::RenderSurfaceInterface* surface, + Dali::Configuration::ContextLoss configuration, + EnvironmentOptions* environmentOptions, + ThreadMode threadMode ); + + /** + * Creates a New Adaptor + * @param[in] window The window handle + * @param[in] surface A render surface can be one of the following + * - Pixmap, adaptor will use existing Pixmap to draw on to + * - Window, adaptor will use existing Window to draw on to + * @param[in] configuration The context loss configuration ( to choose resource discard policy ) + * @param[in] environmentOptions A pointer to the environment options. If NULL then one is created. */ static Dali::Adaptor* New( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface* surface, @@ -127,6 +143,24 @@ public: * - Window, adaptor will use existing Window to draw on to * @param[in] configuration The context loss configuration ( to choose resource discard policy ) * @param[in] environmentOptions A pointer to the environment options. If NULL then one is created. + * @param[in] threadMode The ThreadMode of the Adaptor + */ + static Dali::Adaptor* New( GraphicsFactory& graphicsFactory, + Dali::Integration::SceneHolder window, + Dali::RenderSurfaceInterface* surface, + Dali::Configuration::ContextLoss configuration, + EnvironmentOptions* environmentOptions, + ThreadMode threadMode ); + + /** + * Creates a New Adaptor + * @param[in] graphicsFactory A factory that creates the graphics interface + * @param[in] window The window handle + * @param[in] surface A render surface can be one of the following + * - Pixmap, adaptor will use existing Pixmap to draw on to + * - Window, adaptor will use existing Window to draw on to + * @param[in] configuration The context loss configuration ( to choose resource discard policy ) + * @param[in] environmentOptions A pointer to the environment options. If NULL then one is created. */ static Dali::Adaptor* New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, @@ -633,8 +667,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/offscreen/android/offscreen-window-factory-android.cpp b/dali/internal/offscreen/android/offscreen-window-factory-android.cpp new file mode 100644 index 0000000..0d851ca --- /dev/null +++ b/dali/internal/offscreen/android/offscreen-window-factory-android.cpp @@ -0,0 +1,40 @@ +/* + * 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 HEADERS +#include + +namespace Dali +{ +namespace Internal +{ + +std::unique_ptr< OffscreenWindow > OffscreenWindowFactoryAndroid::CreateOffscreenWindow( uint16_t width, uint16_t height, Any surface, bool isTranslucent ) +{ + return std::unique_ptr< OffscreenWindow >( OffscreenWindowAndroid::New( width, height, surface, isTranslucent ) ); +} + +std::unique_ptr< OffscreenWindowFactory > GetOffscreenWindowFactory() +{ + return std::unique_ptr< OffscreenWindowFactoryAndroid >( new OffscreenWindowFactoryAndroid() ); +} + +} // Internal +} // Dali diff --git a/dali/internal/offscreen/android/offscreen-window-factory-android.h b/dali/internal/offscreen/android/offscreen-window-factory-android.h new file mode 100644 index 0000000..f45b91c --- /dev/null +++ b/dali/internal/offscreen/android/offscreen-window-factory-android.h @@ -0,0 +1,47 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_ANDROID_H +#define DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_ANDROID_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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +namespace Internal +{ + +class OffscreenWindowFactoryAndroid : public OffscreenWindowFactory +{ +public: + + /** + * @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 tbm surface queue handle + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + std::unique_ptr< OffscreenWindow > CreateOffscreenWindow( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) override; +}; + +} // Internal +} // Dali + +#endif // DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_ANDROID_H diff --git a/dali/internal/offscreen/android/offscreen-window-impl-android.cpp b/dali/internal/offscreen/android/offscreen-window-impl-android.cpp new file mode 100644 index 0000000..9cf8480 --- /dev/null +++ b/dali/internal/offscreen/android/offscreen-window-impl-android.cpp @@ -0,0 +1,92 @@ +/* + * 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 + +// INTERNAL INCLUDES +#include + +// CLASS HEADER +#include + +namespace Dali +{ + +namespace Internal +{ + +OffscreenWindowAndroid* OffscreenWindowAndroid::New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +{ + OffscreenWindowAndroid* window = new OffscreenWindowAndroid( width, height, surface, isTranslucent ); + return window; +} + +OffscreenWindowAndroid::OffscreenWindowAndroid( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +: mIsTranslucent( isTranslucent ) +{ +} + +void OffscreenWindowAndroid::Initialize( bool isDefaultWindow ) +{ +} + +void OffscreenWindowAndroid::Initialize() +{ +} + +OffscreenWindowAndroid::~OffscreenWindowAndroid() +{ +} + +uint32_t OffscreenWindowAndroid::GetLayerCount() const +{ + return 0; +} + +Dali::Layer OffscreenWindowAndroid::GetLayer( uint32_t depth ) const +{ + return Dali::Layer(); +} + +OffscreenWindow::WindowSize OffscreenWindowAndroid::GetSize() const +{ + return OffscreenWindow::WindowSize(); +} + +Dali::Any OffscreenWindowAndroid::GetNativeHandle() const +{ + return Any(); +} + +NativeRenderSurface* OffscreenWindowAndroid::GetNativeRenderSurface() const +{ + return nullptr; +} + +void OffscreenWindowAndroid::OnPostRender() +{ +} + +OffscreenWindow::PostRenderSignalType& OffscreenWindowAndroid::PostRenderSignal() +{ + return mPostRenderSignal; +} + +} // namespace Internal + +} // namespace Dali diff --git a/dali/internal/offscreen/android/offscreen-window-impl-android.h b/dali/internal/offscreen/android/offscreen-window-impl-android.h new file mode 100644 index 0000000..10bcfa5 --- /dev/null +++ b/dali/internal/offscreen/android/offscreen-window-impl-android.h @@ -0,0 +1,123 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_ANDROID_H +#define DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_ANDROID_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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +class Adaptor; +class Layer; +class NativeRenderSurface; +class TriggerEventInterface; + +namespace Internal +{ + +class OffscreenWindowAndroid : public Dali::Internal::OffscreenWindow +{ +public: + + static OffscreenWindowAndroid* New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + +public: + + /** + * @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 + */ + Dali::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 + */ + OffscreenWindow::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 tbm surface queue handle + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + OffscreenWindowAndroid( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + + /** + * Destructor + */ + virtual ~OffscreenWindowAndroid(); + + // Undefined + OffscreenWindowAndroid( const OffscreenWindowAndroid& ); + OffscreenWindowAndroid& operator=( OffscreenWindowAndroid& ); + + /* + * @brief Initialize the OffscreenWindow (for internal use) + */ + void Initialize(); + +private: + + PostRenderSignalType mPostRenderSignal; + bool mIsTranslucent; +}; + +} // namespace Internal + +} // namespace Dali + +#endif // DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_ANDROID_H 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..f2a9ed1 --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-application-impl.cpp @@ -0,0 +1,93 @@ +/* + * 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 + +// CLASS HEADER +#include + +using Dali::Internal::Adaptor::ThreadMode; + +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 + auto windowFactory = Dali::Internal::GetOffscreenWindowFactory(); + IntrusivePtr windowPtr = windowFactory->CreateOffscreenWindow( width, height, surface, isTranslucent ).release(); + mDefaultWindow = Dali::OffscreenWindow( windowPtr.Get() ); + + mAdaptor = Dali::Internal::Adaptor::Adaptor::New( Dali::Integration::SceneHolder( windowPtr.Get() ), windowPtr->GetSurface(), + Configuration::APPLICATION_DOES_NOT_HANDLE_CONTEXT_LOSS, NULL, + renderMode == RenderMode::AUTO ? ThreadMode::NORMAL : ThreadMode::RUN_IF_REQUESTED ); + + // Initialize default window + windowPtr->Initialize( true ); +} + +OffscreenApplication::~OffscreenApplication() +{ + delete mAdaptor; + mAdaptor = nullptr; +} + +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 0000000..2fcada4 --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-application-impl.h @@ -0,0 +1,151 @@ +#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 +#include +#include + +// INTERNAL INCLUDES +#include +#include + +using RenderMode = Dali::OffscreenApplication::RenderMode; + +namespace Dali +{ +class Adaptor; + +namespace Internal +{ + +/** + * Implementation of the OffscreenApplication class. + */ +class OffscreenApplication : public BaseObject, + public ConnectionTracker +{ +public: + + typedef Dali::OffscreenApplication::OffscreenApplicationSignalType 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 + */ + static IntrusivePtr New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent, RenderMode renderMode); + +public: + + /** + * @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 + */ + OffscreenApplication( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent, RenderMode renderMode ); + + + /** + * Destructor + */ + virtual ~OffscreenApplication(); + + // Undefined + OffscreenApplication( const OffscreenApplication& ); + OffscreenApplication& operator=( OffscreenApplication& ); + +private: + 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-factory.h b/dali/internal/offscreen/common/offscreen-window-factory.h new file mode 100644 index 0000000..9e90db5 --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-window-factory.h @@ -0,0 +1,54 @@ +#ifndef DALI_OFFSCREEN_WINDOW_FACTORY_H +#define DALI_OFFSCREEN_WINDOW_FACTORY_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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +namespace Internal +{ + +class OffscreenWindow; + +class OffscreenWindowFactory +{ +public: + + OffscreenWindowFactory() = default; + virtual ~OffscreenWindowFactory() = default; + + /** + * @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 + */ + virtual std::unique_ptr< OffscreenWindow > CreateOffscreenWindow( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) = 0; +}; + +extern std::unique_ptr< OffscreenWindowFactory > GetOffscreenWindowFactory(); + +} // Internal +} // Dali + +#endif // DALI_OFFSCREEN_WINDOW_FACTORY_H 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..43b623d --- /dev/null +++ b/dali/internal/offscreen/common/offscreen-window-impl.h @@ -0,0 +1,152 @@ +#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 +#include + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +class Adaptor; +class Layer; +class NativeRenderSurface; + +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() = default; + + /** + * @copydoc Dali::OffscreenWindow::GetLayerCount + */ + virtual uint32_t GetLayerCount() const = 0; + + /** + * @copydoc Dali::OffscreenWindow::GetLayer + */ + virtual Dali::Layer GetLayer( uint32_t depth ) const= 0; + + /** + * @copydoc Dali::OffscreenWindow::GetSize + */ + virtual WindowSize GetSize() const= 0; + + /** + * @copydoc Dali::OffscreenWindow::GetNativeHandle + */ + virtual Any GetNativeHandle() const override = 0; + + /* + * @brief Initialize the OffscreenWindow + * @param[in] isDefaultWindow Whether the OffscreenWindow is a default one or not + */ + virtual void Initialize( bool isDefaultWindow ) = 0; + +public: // Signals + + /** + * @copydoc Dali::OffscreenWindow::PostRenderSignal + */ + virtual PostRenderSignalType& PostRenderSignal() = 0; + +private: + /** + * This function is called after drawing by dali. + */ + virtual void OnPostRender() = 0; + + /** + * @brief Get the native render surface + * @return The render surface + */ + virtual NativeRenderSurface* GetNativeRenderSurface() const = 0; + +private: + + // Undefined + OffscreenWindow( const OffscreenWindow& ); + OffscreenWindow& operator=( OffscreenWindow& ); + + /** + * This is for initialization of this OffscreenWindow in case it is created before adaptor is running. + */ + void OnPreInitOffscreenApplication(); + + /* + * @brief Initialize the OffscreenWindow (for internal use) + */ + void Initialize(); +}; + +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..3b6109f --- /dev/null +++ b/dali/internal/offscreen/file.list @@ -0,0 +1,30 @@ + +# module: offscreen, backend: common +SET( adaptor_offscreen_common_src_files + ${adaptor_offscreen_dir}/common/offscreen-application-impl.cpp +) + + +# module: offscreen, backend: tizen +SET( adaptor_offscreen_tizen_src_files + ${adaptor_offscreen_dir}/tizen/offscreen-window-impl-tizen.cpp + ${adaptor_offscreen_dir}/tizen/offscreen-window-factory-tizen.cpp +) + +# module: offscreen, backend: ubuntu-x11 +SET( adaptor_offscreen_ubuntu-x11_src_files + ${adaptor_offscreen_dir}/ubuntu-x11/offscreen-window-impl-x.cpp + ${adaptor_offscreen_dir}/ubuntu-x11/offscreen-window-factory-x.cpp +) + +# module: offscreen, backend: android +SET( adaptor_offscreen_android_src_files + ${adaptor_offscreen_dir}/android/offscreen-window-impl-android.cpp + ${adaptor_offscreen_dir}/android/offscreen-window-factory-android.cpp +) + +# module: offscreen, backend: windows +SET( adaptor_offscreen_windows_src_files + ${adaptor_offscreen_dir}/windows/offscreen-window-impl-win.cpp + ${adaptor_offscreen_dir}/windows/offscreen-window-factory-win.cpp +) diff --git a/dali/internal/offscreen/tizen/offscreen-window-factory-tizen.cpp b/dali/internal/offscreen/tizen/offscreen-window-factory-tizen.cpp new file mode 100644 index 0000000..dfcb7e6 --- /dev/null +++ b/dali/internal/offscreen/tizen/offscreen-window-factory-tizen.cpp @@ -0,0 +1,40 @@ +/* + * 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 HEADERS +#include + +namespace Dali +{ +namespace Internal +{ + +std::unique_ptr< OffscreenWindow > OffscreenWindowFactoryTizen::CreateOffscreenWindow( uint16_t width, uint16_t height, Any surface, bool isTranslucent ) +{ + return std::unique_ptr< OffscreenWindow >( OffscreenWindowTizen::New( width, height, surface, isTranslucent ) ); +} + +std::unique_ptr< OffscreenWindowFactory > GetOffscreenWindowFactory() +{ + return std::unique_ptr< OffscreenWindowFactoryTizen >( new OffscreenWindowFactoryTizen() ); +} + +} // Internal +} // Dali diff --git a/dali/internal/offscreen/tizen/offscreen-window-factory-tizen.h b/dali/internal/offscreen/tizen/offscreen-window-factory-tizen.h new file mode 100644 index 0000000..b4c0a0d --- /dev/null +++ b/dali/internal/offscreen/tizen/offscreen-window-factory-tizen.h @@ -0,0 +1,47 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_TIZEN_H +#define DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_TIZEN_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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +namespace Internal +{ + +class OffscreenWindowFactoryTizen : public OffscreenWindowFactory +{ +public: + + /** + * @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 tbm surface queue handle + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + std::unique_ptr< OffscreenWindow > CreateOffscreenWindow( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) override; +}; + +} // Internal +} // Dali + +#endif // DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_TIZEN_H diff --git a/dali/internal/offscreen/tizen/offscreen-window-impl-tizen.cpp b/dali/internal/offscreen/tizen/offscreen-window-impl-tizen.cpp new file mode 100644 index 0000000..a827560 --- /dev/null +++ b/dali/internal/offscreen/tizen/offscreen-window-impl-tizen.cpp @@ -0,0 +1,146 @@ +/* + * 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 +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +// CLASS HEADER +#include + +namespace Dali +{ + +namespace Internal +{ + +OffscreenWindowTizen* OffscreenWindowTizen::New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +{ + OffscreenWindowTizen* window = new OffscreenWindowTizen( width, height, surface, isTranslucent ); + return window; +} + +OffscreenWindowTizen::OffscreenWindowTizen( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +: mRenderNotification(), + mIsTranslucent( isTranslucent ) +{ + // Create surface + if ( surface.Empty() ) + { + mSurface = std::unique_ptr< RenderSurfaceInterface >( CreateNativeSurface( SurfaceSize( width, height ), surface, isTranslucent ) ); + } + else + { + width = static_cast( tbm_surface_queue_get_width( AnyCast< tbm_surface_queue_h > ( surface ) ) ); + height = static_cast( tbm_surface_queue_get_height( AnyCast< tbm_surface_queue_h > ( surface ) ) ); + mSurface = std::unique_ptr< RenderSurfaceInterface >( CreateNativeSurface( SurfaceSize( width, height ), surface, isTranslucent ) ); + } +} + +void OffscreenWindowTizen::Initialize( bool isDefaultWindow ) +{ + if( isDefaultWindow ) + { + Initialize(); + return; + } + + Dali::Integration::SceneHolder sceneHolderHandler = Dali::Integration::SceneHolder( this ); + Dali::Adaptor::Get().AddWindow( sceneHolderHandler ); + + Initialize(); +} + +void OffscreenWindowTizen::Initialize() +{ + // Connect callback to be notified when the surface is rendered + TriggerEventFactory triggerEventFactory; + + mRenderNotification = std::unique_ptr< TriggerEventInterface >( triggerEventFactory.CreateTriggerEvent( MakeCallback( this, &OffscreenWindowTizen::OnPostRender ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER ) ); + + NativeRenderSurface* surface = GetNativeRenderSurface(); + + if( !surface ) + { + return; + } + + surface->SetRenderNotification( mRenderNotification.get() ); +} + +OffscreenWindowTizen::~OffscreenWindowTizen() +{ + NativeRenderSurface* surface = GetNativeRenderSurface(); + + if( surface ) + { + // To prevent notification triggering in NativeRenderSurface::PostRender while deleting SceneHolder + surface->SetRenderNotification( nullptr ); + } +} + +uint32_t OffscreenWindowTizen::GetLayerCount() const +{ + return mScene.GetLayerCount(); +} + +Dali::Layer OffscreenWindowTizen::GetLayer( uint32_t depth ) const +{ + return mScene.GetLayer( depth ); +} + +OffscreenWindow::WindowSize OffscreenWindowTizen::GetSize() const +{ + Size size = mScene.GetSize(); + + return OffscreenWindow::WindowSize( static_cast( size.width ), static_cast( size.height ) ); +} + +Dali::Any OffscreenWindowTizen::GetNativeHandle() const +{ + return GetNativeRenderSurface()->GetNativeHandle(); +} + +NativeRenderSurface* OffscreenWindowTizen::GetNativeRenderSurface() const +{ + return dynamic_cast< NativeRenderSurface* >( mSurface.get() ); +} + +void OffscreenWindowTizen::OnPostRender() +{ + mPostRenderSignal.Emit( Dali::OffscreenWindow( this ), nullptr ); +} + +OffscreenWindow::PostRenderSignalType& OffscreenWindowTizen::PostRenderSignal() +{ + return mPostRenderSignal; +} + +} // namespace Internal + +} // namespace Dali diff --git a/dali/internal/offscreen/tizen/offscreen-window-impl-tizen.h b/dali/internal/offscreen/tizen/offscreen-window-impl-tizen.h new file mode 100644 index 0000000..076b09d --- /dev/null +++ b/dali/internal/offscreen/tizen/offscreen-window-impl-tizen.h @@ -0,0 +1,124 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_TIZEN_H +#define DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_TIZEN_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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +class Adaptor; +class Layer; +class NativeRenderSurface; +class TriggerEventInterface; + +namespace Internal +{ + +class OffscreenWindowTizen : public Dali::Internal::OffscreenWindow +{ +public: + + static OffscreenWindowTizen* New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + +public: + + /** + * @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 + */ + Dali::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 + */ + OffscreenWindow::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 tbm surface queue handle + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + OffscreenWindowTizen( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + + /** + * Destructor + */ + virtual ~OffscreenWindowTizen(); + + // Undefined + OffscreenWindowTizen( const OffscreenWindowTizen& ); + OffscreenWindowTizen& operator=( OffscreenWindowTizen& ); + + /* + * @brief Initialize the OffscreenWindow (for internal use) + */ + void Initialize(); + +private: + + std::unique_ptr< TriggerEventInterface > mRenderNotification; + PostRenderSignalType mPostRenderSignal; + bool mIsTranslucent; +}; + +} // namespace Internal + +} // namespace Dali + +#endif // DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_TIZEN_H diff --git a/dali/internal/offscreen/ubuntu-x11/offscreen-window-factory-x.cpp b/dali/internal/offscreen/ubuntu-x11/offscreen-window-factory-x.cpp new file mode 100644 index 0000000..8df3001 --- /dev/null +++ b/dali/internal/offscreen/ubuntu-x11/offscreen-window-factory-x.cpp @@ -0,0 +1,40 @@ +/* + * 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 HEADERS +#include + +namespace Dali +{ +namespace Internal +{ + +std::unique_ptr< OffscreenWindow > OffscreenWindowFactoryX::CreateOffscreenWindow( uint16_t width, uint16_t height, Any surface, bool isTranslucent ) +{ + return std::unique_ptr< OffscreenWindow >( OffscreenWindowX::New( width, height, surface, isTranslucent ) ); +} + +std::unique_ptr< OffscreenWindowFactory > GetOffscreenWindowFactory() +{ + return std::unique_ptr< OffscreenWindowFactoryX >( new OffscreenWindowFactoryX() ); +} + +} // Internal +} // Dali diff --git a/dali/internal/offscreen/ubuntu-x11/offscreen-window-factory-x.h b/dali/internal/offscreen/ubuntu-x11/offscreen-window-factory-x.h new file mode 100644 index 0000000..d3da19e --- /dev/null +++ b/dali/internal/offscreen/ubuntu-x11/offscreen-window-factory-x.h @@ -0,0 +1,47 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_X_H +#define DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_X_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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +namespace Internal +{ + +class OffscreenWindowFactoryX : public OffscreenWindowFactory +{ +public: + + /** + * @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 tbm surface queue handle + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + std::unique_ptr< OffscreenWindow > CreateOffscreenWindow( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) override; +}; + +} // Internal +} // Dali + +#endif // DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_X_H diff --git a/dali/internal/offscreen/ubuntu-x11/offscreen-window-impl-x.cpp b/dali/internal/offscreen/ubuntu-x11/offscreen-window-impl-x.cpp new file mode 100644 index 0000000..656bd77 --- /dev/null +++ b/dali/internal/offscreen/ubuntu-x11/offscreen-window-impl-x.cpp @@ -0,0 +1,92 @@ +/* + * 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 + +// INTERNAL INCLUDES +#include + +// CLASS HEADER +#include + +namespace Dali +{ + +namespace Internal +{ + +OffscreenWindowX* OffscreenWindowX::New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +{ + OffscreenWindowX* window = new OffscreenWindowX( width, height, surface, isTranslucent ); + return window; +} + +OffscreenWindowX::OffscreenWindowX( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +: mIsTranslucent( isTranslucent ) +{ +} + +void OffscreenWindowX::Initialize( bool isDefaultWindow ) +{ +} + +void OffscreenWindowX::Initialize() +{ +} + +OffscreenWindowX::~OffscreenWindowX() +{ +} + +uint32_t OffscreenWindowX::GetLayerCount() const +{ + return 0; +} + +Dali::Layer OffscreenWindowX::GetLayer( uint32_t depth ) const +{ + return Dali::Layer(); +} + +OffscreenWindow::WindowSize OffscreenWindowX::GetSize() const +{ + return OffscreenWindow::WindowSize(); +} + +Dali::Any OffscreenWindowX::GetNativeHandle() const +{ + return Any(); +} + +NativeRenderSurface* OffscreenWindowX::GetNativeRenderSurface() const +{ + return nullptr; +} + +void OffscreenWindowX::OnPostRender() +{ +} + +OffscreenWindow::PostRenderSignalType& OffscreenWindowX::PostRenderSignal() +{ + return mPostRenderSignal; +} + +} // namespace Internal + +} // namespace Dali diff --git a/dali/internal/offscreen/ubuntu-x11/offscreen-window-impl-x.h b/dali/internal/offscreen/ubuntu-x11/offscreen-window-impl-x.h new file mode 100644 index 0000000..aceca0b --- /dev/null +++ b/dali/internal/offscreen/ubuntu-x11/offscreen-window-impl-x.h @@ -0,0 +1,123 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_X_H +#define DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_X_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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +class Adaptor; +class Layer; +class NativeRenderSurface; +class TriggerEventInterface; + +namespace Internal +{ + +class OffscreenWindowX : public Dali::Internal::OffscreenWindow +{ +public: + + static OffscreenWindowX* New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + +public: + + /** + * @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 + */ + Dali::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 + */ + OffscreenWindow::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 tbm surface queue handle + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + OffscreenWindowX( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + + /** + * Destructor + */ + virtual ~OffscreenWindowX(); + + // Undefined + OffscreenWindowX( const OffscreenWindowX& ); + OffscreenWindowX& operator=( OffscreenWindowX& ); + + /* + * @brief Initialize the OffscreenWindow (for internal use) + */ + void Initialize(); + +private: + + PostRenderSignalType mPostRenderSignal; + bool mIsTranslucent; +}; + +} // namespace Internal + +} // namespace Dali + +#endif // DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_X_H diff --git a/dali/internal/offscreen/windows/offscreen-window-factory-win.cpp b/dali/internal/offscreen/windows/offscreen-window-factory-win.cpp new file mode 100644 index 0000000..cdfeb41 --- /dev/null +++ b/dali/internal/offscreen/windows/offscreen-window-factory-win.cpp @@ -0,0 +1,40 @@ +/* + * 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 HEADERS +#include + +namespace Dali +{ +namespace Internal +{ + +std::unique_ptr< OffscreenWindow > OffscreenWindowFactoryWin::CreateOffscreenWindow( uint16_t width, uint16_t height, Any surface, bool isTranslucent ) +{ + return std::unique_ptr< OffscreenWindow >( OffscreenWindowWin::New( width, height, surface, isTranslucent ) ); +} + +std::unique_ptr< OffscreenWindowFactory > GetOffscreenWindowFactory() +{ + return std::unique_ptr< OffscreenWindowFactoryWin >( new OffscreenWindowFactoryWin() ); +} + +} // Internal +} // Dali diff --git a/dali/internal/offscreen/windows/offscreen-window-factory-win.h b/dali/internal/offscreen/windows/offscreen-window-factory-win.h new file mode 100644 index 0000000..bd641ba --- /dev/null +++ b/dali/internal/offscreen/windows/offscreen-window-factory-win.h @@ -0,0 +1,47 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_WIN_H +#define DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_WIN_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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +namespace Internal +{ + +class OffscreenWindowFactoryAndroid : public OffscreenWindowFactory +{ +public: + + /** + * @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 tbm surface queue handle + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + std::unique_ptr< OffscreenWindow > CreateOffscreenWindow( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) override; +}; + +} // Internal +} // Dali + +#endif // DALI_INTERNAL_OFFSCREEN_WINDOW_FACTORY_WIN_H diff --git a/dali/internal/offscreen/windows/offscreen-window-impl-win.cpp b/dali/internal/offscreen/windows/offscreen-window-impl-win.cpp new file mode 100644 index 0000000..f97704e --- /dev/null +++ b/dali/internal/offscreen/windows/offscreen-window-impl-win.cpp @@ -0,0 +1,92 @@ +/* + * 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 + +// INTERNAL INCLUDES +#include + +// CLASS HEADER +#include + +namespace Dali +{ + +namespace Internal +{ + +OffscreenWindowWin* OffscreenWindowWin::New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +{ + OffscreenWindowWin* window = new OffscreenWindowWin( width, height, surface, isTranslucent ); + return window; +} + +OffscreenWindowWin::OffscreenWindowWin( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ) +: mIsTranslucent( isTranslucent ) +{ +} + +void OffscreenWindowWin::Initialize( bool isDefaultWindow ) +{ +} + +void OffscreenWindowWin::Initialize() +{ +} + +OffscreenWindowWin::~OffscreenWindowWin() +{ +} + +uint32_t OffscreenWindowWin::GetLayerCount() const +{ + return 0; +} + +Dali::Layer OffscreenWindowWin::GetLayer( uint32_t depth ) const +{ + return Dali::Layer(); +} + +OffscreenWindow::WindowSize OffscreenWindowWin::GetSize() const +{ + return OffscreenWindow::WindowSize(); +} + +Dali::Any OffscreenWindowWin::GetNativeHandle() const +{ + return Any(); +} + +NativeRenderSurface* OffscreenWindowWin::GetNativeRenderSurface() const +{ + return nullptr; +} + +void OffscreenWindowWin::OnPostRender() +{ +} + +OffscreenWindow::PostRenderSignalType& OffscreenWindowWin::PostRenderSignal() +{ + return mPostRenderSignal; +} + +} // namespace Internal + +} // namespace Dali diff --git a/dali/internal/offscreen/windows/offscreen-window-impl-win.h b/dali/internal/offscreen/windows/offscreen-window-impl-win.h new file mode 100644 index 0000000..d115948 --- /dev/null +++ b/dali/internal/offscreen/windows/offscreen-window-impl-win.h @@ -0,0 +1,123 @@ +#ifndef DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_WIN_H +#define DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_WIN_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. + * + */ + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +class Adaptor; +class Layer; +class NativeRenderSurface; +class TriggerEventInterface; + +namespace Internal +{ + +class OffscreenWindowWin : public Dali::Internal::OffscreenWindow +{ +public: + + static OffscreenWindowWin* New( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + +public: + + /** + * @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 + */ + Dali::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 + */ + OffscreenWindow::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 tbm surface queue handle + * @param[in] isTranslucent Whether the OffscreenWindow is translucent or not + */ + OffscreenWindowWin( uint16_t width, uint16_t height, Dali::Any surface, bool isTranslucent ); + + /** + * Destructor + */ + virtual ~OffscreenWindowWin(); + + // Undefined + OffscreenWindowWin( const OffscreenWindowWin& ); + OffscreenWindowWin& operator=( OffscreenWindowWin& ); + + /* + * @brief Initialize the OffscreenWindow (for internal use) + */ + void Initialize(); + +private: + + PostRenderSignalType mPostRenderSignal; + bool mIsTranslucent; +}; + +} // namespace Internal + +} // namespace Dali + +#endif // DALI_INTERNAL_OFFSCREEN_WINDOW_IMPL_WIN_H 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 ed5d8fb..15a603e 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 @@ -231,6 +231,8 @@ void NativeRenderSurfaceEcoreWl::StartRender() bool NativeRenderSurfaceEcoreWl::PreRender( bool resizingSurface, const std::vector>& damagedRects, Rect& clippingRect ) { + MakeContextCurrent(); + auto eglGraphics = static_cast(mGraphics); if (eglGraphics) { @@ -255,45 +257,62 @@ void NativeRenderSurfaceEcoreWl::PostRender( bool renderToFbo, bool replacingSur eglImpl.SwapBuffers( mEGLSurface, damagedRects ); } - if( mThreadSynchronization ) + 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() @@ -329,6 +348,11 @@ Integration::StencilBufferAvailable NativeRenderSurfaceEcoreWl::GetStencilBuffer return mGraphics ? mGraphics->GetStencilBufferRequired() : Integration::StencilBufferAvailable::FALSE; } +Any NativeRenderSurfaceEcoreWl::GetNativeHandle() +{ + return mTbmQueue; +} + void NativeRenderSurfaceEcoreWl::ReleaseLock() { if( mThreadSynchronization ) 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 3f2020b..2e0b091 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 @@ -160,6 +160,8 @@ public: // from Dali::RenderSurfaceInterface */ virtual Integration::StencilBufferAvailable GetStencilBufferRequired() override; + virtual Any GetNativeHandle() override; + private: /**