From f6cdaa596a9139fb0fc671c29774c9ebb71b4c13 Mon Sep 17 00:00:00 2001 From: Heeyong Song Date: Thu, 28 May 2020 14:11:58 +0900 Subject: [PATCH] [Tizen] Add screen and client rotation itself function Change-Id: Ic64b73d53e8ce8a7cdb3690e9cb222e0983acb57 --- automated-tests/src/dali/utc-Dali-Scene.cpp | 10 ++- dali/integration-api/scene.cpp | 4 +- dali/integration-api/scene.h | 4 +- .../event/actors/camera-actor-impl.cpp | 6 ++ .../internal/event/actors/camera-actor-impl.h | 7 ++ dali/internal/event/common/scene-impl.cpp | 11 ++- dali/internal/event/common/scene-impl.h | 7 +- .../render/common/render-algorithms.cpp | 79 ++++++++++++++++--- .../render/common/render-algorithms.h | 12 +-- .../render/common/render-instruction.h | 2 +- .../internal/render/common/render-manager.cpp | 22 +++++- dali/internal/render/common/render-manager.h | 6 ++ .../update/manager/update-manager.cpp | 11 +++ dali/internal/update/manager/update-manager.h | 17 ++++ .../render-tasks/scene-graph-camera.cpp | 49 +++++++++++- .../update/render-tasks/scene-graph-camera.h | 25 ++++++ 16 files changed, 239 insertions(+), 33 deletions(-) diff --git a/automated-tests/src/dali/utc-Dali-Scene.cpp b/automated-tests/src/dali/utc-Dali-Scene.cpp index c2335ede9..359c11d9b 100644 --- a/automated-tests/src/dali/utc-Dali-Scene.cpp +++ b/automated-tests/src/dali/utc-Dali-Scene.cpp @@ -891,7 +891,8 @@ int UtcDaliSceneSurfaceResizedDefaultScene(void) // Resize the scene Vector2 newSize( 1000.0f, 2000.0f ); DALI_TEST_CHECK( stage.GetSize() != newSize ); - defaultScene.SurfaceResized( newSize.width, newSize.height ); + + defaultScene.SurfaceResized( newSize.width, newSize.height, 0, false ); DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION ); DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION ); @@ -934,7 +935,7 @@ int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void) Vector2 newSize( 1000.0f, 2000.0f ); std::string viewportParams( "0, 0, 1000, 2000" ); // to match newSize DALI_TEST_CHECK( stage.GetSize() != newSize ); - defaultScene.SurfaceResized( newSize.width, newSize.height ); + defaultScene.SurfaceResized( newSize.width, newSize.height, 0, false ); DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION ); DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION ); @@ -1005,7 +1006,7 @@ int UtcDaliSceneSurfaceResizedMultipleRenderTasks(void) Vector2 newSize( 1000.0f, 2000.0f ); std::string viewportParams( "0, 0, 1000, 2000" ); // to match newSize DALI_TEST_CHECK( stage.GetSize() != newSize ); - defaultScene.SurfaceResized( newSize.width, newSize.height ); + defaultScene.SurfaceResized( newSize.width, newSize.height, 0, false ); DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION ); DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION ); @@ -1045,7 +1046,8 @@ int UtcDaliSceneSurfaceResizedAdditionalScene(void) // Resize the surface and inform the scene accordingly Vector2 newSize( 1000.0f, 2000.0f ); DALI_TEST_CHECK( stage.GetSize() != newSize ); - scene.SurfaceResized( newSize.width, newSize.height ); + + scene.SurfaceResized( newSize.width, newSize.height, 0, false ); // Ensure the stage hasn't been resized DALI_TEST_EQUALS( stage.GetSize(), stageSize, TEST_LOCATION ); diff --git a/dali/integration-api/scene.cpp b/dali/integration-api/scene.cpp index c8bc91b6f..ac3f289e8 100644 --- a/dali/integration-api/scene.cpp +++ b/dali/integration-api/scene.cpp @@ -119,9 +119,9 @@ Layer Scene::GetLayer( uint32_t depth ) const return GetImplementation(*this).GetLayer( depth ); } -void Scene::SurfaceResized( float width, float height ) +void Scene::SurfaceResized( float width, float height, int orientation, bool forceUpdate ) { - GetImplementation( *this ).SurfaceResized( width, height ); + GetImplementation( *this ).SurfaceResized( width, height, orientation, forceUpdate ); } void Scene::SurfaceReplaced() diff --git a/dali/integration-api/scene.h b/dali/integration-api/scene.h index 9211ae18a..5258eeccb 100755 --- a/dali/integration-api/scene.h +++ b/dali/integration-api/scene.h @@ -199,8 +199,10 @@ public: * * @param[in] width The new width of the set surface * @param[in] height The new height of the set surface + * @param[in] orientation The orientation of the surface + * @param[in] forceUpdate The flag to update force */ - void SurfaceResized( float width, float height ); + void SurfaceResized( float width, float height, int orientation, bool forceUpdate ); /** * @brief Informs the scene that the surface has been replaced. diff --git a/dali/internal/event/actors/camera-actor-impl.cpp b/dali/internal/event/actors/camera-actor-impl.cpp index 86e8e8042..a0faef31a 100644 --- a/dali/internal/event/actors/camera-actor-impl.cpp +++ b/dali/internal/event/actors/camera-actor-impl.cpp @@ -531,6 +531,12 @@ const SceneGraph::Camera* CameraActor::GetCamera() const return mSceneObject; } +void CameraActor::RotateProjection( int rotationAngle ) +{ + // sceneObject is being used in a separate thread; queue a message to set + RotateProjectionMessage( GetEventThreadServices(), *mSceneObject, rotationAngle ); +} + void CameraActor::SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) { if(index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT) diff --git a/dali/internal/event/actors/camera-actor-impl.h b/dali/internal/event/actors/camera-actor-impl.h index e320d761f..faeb53fa6 100644 --- a/dali/internal/event/actors/camera-actor-impl.h +++ b/dali/internal/event/actors/camera-actor-impl.h @@ -204,6 +204,13 @@ public: */ const SceneGraph::Camera* GetCamera() const; + /** + * Rotate the projection. + * It is used in case that the target buffer direction is different from the window direction. + * @param [in] rotationAngle The rotation angle + */ + void RotateProjection( int rotationAngle ); + public: // properties /** diff --git a/dali/internal/event/common/scene-impl.cpp b/dali/internal/event/common/scene-impl.cpp index d7b80d647..5576d344c 100644 --- a/dali/internal/event/common/scene-impl.cpp +++ b/dali/internal/event/common/scene-impl.cpp @@ -64,6 +64,7 @@ Scene::Scene() mSize(), // Don't set the proper value here, this will be set when the surface is set later mDpi(), mBackgroundColor( DEFAULT_BACKGROUND_COLOR ), + mSurfaceOrientation( 0 ), mDepthTreeDirty( false ), mEventProcessor( *this, ThreadLocalStorage::GetInternal()->GetGestureEventProcessor() ) { @@ -137,7 +138,7 @@ void Scene::Initialize( Size size ) RenderTaskPtr renderTask = mRenderTaskList->CreateTask( mRootLayer.Get(), mDefaultCamera.Get() ); renderTask->SetClearEnabled(true); - SurfaceResized( size.width, size.height ); + SurfaceResized( size.width, size.height, mSurfaceOrientation, false ); // Create scene graph object mSceneObject = new SceneGraph::Scene(); @@ -205,23 +206,27 @@ Actor& Scene::GetDefaultRootActor() return *mRootLayer; } -void Scene::SurfaceResized( float width, float height ) +void Scene::SurfaceResized( float width, float height, int orientation, bool forceUpdate ) { - if( ( fabsf( mSize.width - width ) > Math::MACHINE_EPSILON_1 ) || ( fabsf( mSize.height - height ) > Math::MACHINE_EPSILON_1 ) ) + if( ( fabsf( mSize.width - width ) > Math::MACHINE_EPSILON_1 ) || ( fabsf( mSize.height - height ) > Math::MACHINE_EPSILON_1 ) + || ( orientation != mSurfaceOrientation ) || ( forceUpdate ) ) { Rect< int32_t > newSize( 0, 0, static_cast< int32_t >( width ), static_cast< int32_t >( height ) ); // truncated mSize.width = width; mSize.height = height; + mSurfaceOrientation = orientation; // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position. mDefaultCamera->SetPerspectiveProjection( mSize ); + mDefaultCamera->RotateProjection( mSurfaceOrientation ); mRootLayer->SetSize( mSize.width, mSize.height ); ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager(); SetDefaultSurfaceRectMessage( updateManager, newSize ); + SetDefaultSurfaceOrientationMessage( updateManager, mSurfaceOrientation ); // set default render-task viewport parameters RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask( 0u ); diff --git a/dali/internal/event/common/scene-impl.h b/dali/internal/event/common/scene-impl.h index 99a3e507c..ab55a3a09 100644 --- a/dali/internal/event/common/scene-impl.h +++ b/dali/internal/event/common/scene-impl.h @@ -123,8 +123,10 @@ public: * * @param[in] width The new width of the set surface * @param[in] height The new height of the set surface + * @param[in] orientation The orientation of the surface + * @param[in] forceUpdate The flag to update force */ - void SurfaceResized( float width, float height ); + void SurfaceResized( float width, float height, int orientation, bool forceUpdate ); /** * @copydoc Dali::Integration::Scene::SurfaceReplaced @@ -290,6 +292,9 @@ private: Vector4 mBackgroundColor; + // The SurfaceOrientation + int mSurfaceOrientation; + LayerPtr mRootLayer; // Ordered list of currently on-stage layers diff --git a/dali/internal/render/common/render-algorithms.cpp b/dali/internal/render/common/render-algorithms.cpp index 01bba0557..329d508e1 100644 --- a/dali/internal/render/common/render-algorithms.cpp +++ b/dali/internal/render/common/render-algorithms.cpp @@ -231,7 +231,7 @@ inline void SetupDepthBuffer( const RenderItem& item, Context& context, bool dep * @param[in] item The current RenderItem about to be rendered * @param[in] context The context */ -inline void RenderAlgorithms::SetupScissorClipping( const RenderItem& item, Context& context ) +inline void RenderAlgorithms::SetupScissorClipping( const RenderItem& item, Context& context, int orientation ) { // Get the number of child scissors in the stack (do not include layer or root box). size_t childStackDepth = mScissorStack.size() - 1u; @@ -292,7 +292,30 @@ inline void RenderAlgorithms::SetupScissorClipping( const RenderItem& item, Cont if( scissorEnabled ) { ClippingBox useScissorBox( mScissorStack.back() ); - context.Scissor( useScissorBox.x, useScissorBox.y, useScissorBox.width, useScissorBox.height ); + GLint x = useScissorBox.x; + GLint y = useScissorBox.y; + if( orientation == 90 ) + { + x = mViewportRectangle.height - (useScissorBox.y + useScissorBox.height); + y = useScissorBox.x; + context.Scissor( x, y, useScissorBox.height, useScissorBox.width ); + } + else if( orientation == 180 ) + { + x = mViewportRectangle.width - (useScissorBox.x + useScissorBox.width); + y = mViewportRectangle.height - (useScissorBox.y + useScissorBox.height); + context.Scissor( x, y, useScissorBox.width, useScissorBox.height ); + } + else if( orientation == 270 ) + { + x = useScissorBox.y; + y = mViewportRectangle.width - (useScissorBox.x + useScissorBox.width); + context.Scissor( x, y, useScissorBox.height, useScissorBox.width ); + } + else + { + context.Scissor( x, y, useScissorBox.width, useScissorBox.height ); + } } } } @@ -302,7 +325,8 @@ inline void RenderAlgorithms::SetupClipping( const RenderItem& item, bool& usedStencilBuffer, uint32_t& lastClippingDepth, uint32_t& lastClippingId, - Integration::StencilBufferAvailable stencilBufferAvailable ) + Integration::StencilBufferAvailable stencilBufferAvailable, + int orientation ) { RenderMode::Type renderMode = RenderMode::AUTO; const Renderer *renderer = item.mRenderer; @@ -324,7 +348,7 @@ inline void RenderAlgorithms::SetupClipping( const RenderItem& item, // As both scissor and stencil clips can be nested, we may be simultaneously traversing up the scissor tree, requiring a scissor to be un-done. Whilst simultaneously adding a new stencil clip. // We process both based on our current and old clipping depths for each mode. // Both methods with return rapidly if there is nothing to be done for that type of clipping. - SetupScissorClipping( item, context ); + SetupScissorClipping( item, context, orientation ); if( stencilBufferAvailable == Integration::StencilBufferAvailable::TRUE ) { @@ -391,8 +415,8 @@ inline void RenderAlgorithms::ProcessRenderList( const RenderList& renderList, Integration::DepthBufferAvailable depthBufferAvailable, Integration::StencilBufferAvailable stencilBufferAvailable, Vector& boundTextures, - const RenderInstruction& instruction - ) + const RenderInstruction& instruction, + int orientation ) { DALI_PRINT_RENDER_LIST( renderList ); @@ -409,13 +433,45 @@ inline void RenderAlgorithms::ProcessRenderList( const RenderList& renderList, mViewportRectangle = context.GetViewport(); mHasLayerScissor = false; + if( orientation == 90 || orientation == 270 ) + { + int temp = mViewportRectangle.width; + mViewportRectangle.width = mViewportRectangle.height; + mViewportRectangle.height = temp; + } + // Setup Scissor testing (for both viewport and per-node scissor) mScissorStack.clear(); if( renderList.IsClipping() ) { context.SetScissorTest( true ); const ClippingBox& layerScissorBox = renderList.GetClippingBox(); - context.Scissor( layerScissorBox.x, layerScissorBox.y, layerScissorBox.width, layerScissorBox.height ); + GLint x = layerScissorBox.x; + GLint y = layerScissorBox.y; + + if( orientation == 90 ) + { + x = mViewportRectangle.height - (layerScissorBox.y + layerScissorBox.height); + y = layerScissorBox.x; + context.Scissor( x, y, layerScissorBox.height, layerScissorBox.width ); + } + else if( orientation == 180 ) + { + x = mViewportRectangle.width - (layerScissorBox.x + layerScissorBox.width); + y = mViewportRectangle.height - (layerScissorBox.y + layerScissorBox.height); + context.Scissor( x, y, layerScissorBox.width, layerScissorBox.height ); + } + else if( orientation == 270 ) + { + x = layerScissorBox.y; + y = mViewportRectangle.width - (layerScissorBox.x + layerScissorBox.width); + context.Scissor( x, y, layerScissorBox.height, layerScissorBox.width ); + } + else + { + context.Scissor( x, y, layerScissorBox.width, layerScissorBox.height ); + } + mScissorStack.push_back( layerScissorBox ); mHasLayerScissor = true; } @@ -434,7 +490,7 @@ inline void RenderAlgorithms::ProcessRenderList( const RenderList& renderList, // Set up clipping based on both the Renderer and Actor APIs. // The Renderer API will be used if specified. If AUTO, the Actors automatic clipping feature will be used. - SetupClipping( item, context, usedStencilBuffer, lastClippingDepth, lastClippingId, stencilBufferAvailable ); + SetupClipping( item, context, usedStencilBuffer, lastClippingDepth, lastClippingId, stencilBufferAvailable, orientation ); if( DALI_LIKELY( item.mRenderer ) ) { @@ -466,7 +522,8 @@ void RenderAlgorithms::ProcessRenderInstruction( const RenderInstruction& instru BufferIndex bufferIndex, Integration::DepthBufferAvailable depthBufferAvailable, Integration::StencilBufferAvailable stencilBufferAvailable, - Vector& boundTextures ) + Vector& boundTextures, + int orientation ) { DALI_PRINT_RENDER_INSTRUCTION( instruction, bufferIndex ); @@ -496,8 +553,8 @@ void RenderAlgorithms::ProcessRenderInstruction( const RenderInstruction& instru depthBufferAvailable, stencilBufferAvailable, boundTextures, - instruction //added for reflection effect - ); + instruction, //added for reflection effect + orientation ); } } } diff --git a/dali/internal/render/common/render-algorithms.h b/dali/internal/render/common/render-algorithms.h index 26f434339..3a34f0253 100644 --- a/dali/internal/render/common/render-algorithms.h +++ b/dali/internal/render/common/render-algorithms.h @@ -65,7 +65,8 @@ class RenderAlgorithms BufferIndex bufferIndex, Integration::DepthBufferAvailable depthBufferAvailable, Integration::StencilBufferAvailable stencilBufferAvailable, - Vector& boundTextures ); + Vector& boundTextures, + int orientation); private: @@ -88,7 +89,7 @@ class RenderAlgorithms * @param[in] item The current RenderItem (about to be rendered) * @param[in] context The current Context */ - inline void SetupScissorClipping( const Dali::Internal::SceneGraph::RenderItem& item, Context& context ); + inline void SetupScissorClipping( const Dali::Internal::SceneGraph::RenderItem& item, Context& context, int orientation ); /** * @brief Set up the clipping based on the specified clipping settings. @@ -104,7 +105,8 @@ class RenderAlgorithms bool& usedStencilBuffer, uint32_t& lastClippingDepth, uint32_t& lastClippingId, - Integration::StencilBufferAvailable stencilBufferAvailable ); + Integration::StencilBufferAvailable stencilBufferAvailable, + int orientation ); /** * @brief Process a render-list. @@ -125,8 +127,8 @@ class RenderAlgorithms Integration::DepthBufferAvailable depthBufferAvailable, Integration::StencilBufferAvailable stencilBufferAvailable, Vector& boundTextures, - const Dali::Internal::SceneGraph::RenderInstruction& instruction // in the case of reflection, things like CullFace need to be adjusted for reflection world - ); + const Dali::Internal::SceneGraph::RenderInstruction& instruction, // in the case of reflection, things like CullFace need to be adjusted for reflection world + int orientation ); // Prevent copying: RenderAlgorithms( RenderAlgorithms& rhs ); diff --git a/dali/internal/render/common/render-instruction.h b/dali/internal/render/common/render-instruction.h index 11523215d..f40ec04fc 100644 --- a/dali/internal/render/common/render-instruction.h +++ b/dali/internal/render/common/render-instruction.h @@ -122,7 +122,7 @@ public: const Matrix* GetProjectionMatrix( BufferIndex index ) const { // inlined as this is called once per frame per render instruction - return &mCamera->GetProjectionMatrix( index ); + return &mCamera->GetFinalProjectionMatrix( index ); } // for reflection effect const Camera* GetCamera() const diff --git a/dali/internal/render/common/render-manager.cpp b/dali/internal/render/common/render-manager.cpp index 5a0d3c15c..2eb94ff56 100644 --- a/dali/internal/render/common/render-manager.cpp +++ b/dali/internal/render/common/render-manager.cpp @@ -89,7 +89,8 @@ struct RenderManager::Impl lastFrameWasRendered( false ), programController( glAbstraction ), depthBufferAvailable( depthBufferAvailableParam ), - stencilBufferAvailable( stencilBufferAvailableParam ) + stencilBufferAvailable( stencilBufferAvailableParam ), + defaultSurfaceOrientation( 0 ) { // Create thread pool with just one thread ( there may be a need to create more threads in the future ). threadPool = std::unique_ptr( new Dali::ThreadPool() ); @@ -180,6 +181,8 @@ struct RenderManager::Impl std::unique_ptr threadPool; ///< The thread pool Vector boundTextures; ///< The textures bound for rendering Vector textureDependencyList; ///< The dependency list of binded textures + int defaultSurfaceOrientation; ///< defaultSurfaceOrientation for the default surface we are rendering to + }; RenderManager* RenderManager::New( Integration::GlAbstraction& glAbstraction, @@ -261,6 +264,11 @@ void RenderManager::SetDefaultSurfaceRect(const Rect& rect) mImpl->defaultSurfaceRect = rect; } +void RenderManager::SetDefaultSurfaceOrientation( int orientation ) +{ + mImpl->defaultSurfaceOrientation = orientation; +} + void RenderManager::AddRenderer( OwnerPointer< Render::Renderer >& renderer ) { // Initialize the renderer as we are now in render thread @@ -601,6 +609,7 @@ void RenderManager::RenderScene( Integration::Scene& scene, bool renderToFbo ) Rect surfaceRect = mImpl->defaultSurfaceRect; Integration::DepthBufferAvailable depthBufferAvailable = mImpl->depthBufferAvailable; Integration::StencilBufferAvailable stencilBufferAvailable = mImpl->stencilBufferAvailable; + int surfaceOrientation = mImpl->defaultSurfaceOrientation; if ( instruction.mFrameBuffer ) { @@ -699,6 +708,7 @@ void RenderManager::RenderScene( Integration::Scene& scene, bool renderToFbo ) { viewportRect.Set( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() ); } + surfaceOrientation = 0; } else // No Offscreen frame buffer rendering { @@ -715,6 +725,13 @@ void RenderManager::RenderScene( Integration::Scene& scene, bool renderToFbo ) } } + if( surfaceOrientation == 90 || surfaceOrientation == 270 ) + { + int temp = viewportRect.width; + viewportRect.width = viewportRect.height; + viewportRect.height = temp; + } + bool clearFullFrameRect = true; if( instruction.mFrameBuffer != 0 ) { @@ -758,7 +775,8 @@ void RenderManager::RenderScene( Integration::Scene& scene, bool renderToFbo ) mImpl->renderBufferIndex, depthBufferAvailable, stencilBufferAvailable, - mImpl->boundTextures ); + mImpl->boundTextures, + surfaceOrientation ); // Synchronise the FBO/Texture access when there are multiple contexts if ( mImpl->currentContext->IsSurfacelessContextSupported() ) diff --git a/dali/internal/render/common/render-manager.h b/dali/internal/render/common/render-manager.h index 396495eae..d5d88fa92 100644 --- a/dali/internal/render/common/render-manager.h +++ b/dali/internal/render/common/render-manager.h @@ -130,6 +130,12 @@ public: */ void SetDefaultSurfaceRect( const Rect& rect ); + /** + * Returns the orintation for the default surface (probably the application window). + * @return Orientation for the surface. + */ + void SetDefaultSurfaceOrientation( int orientation ); + /** * Add a Renderer to the render manager. * @param[in] renderer The renderer to add. diff --git a/dali/internal/update/manager/update-manager.cpp b/dali/internal/update/manager/update-manager.cpp index f22e52f24..3f4173554 100644 --- a/dali/internal/update/manager/update-manager.cpp +++ b/dali/internal/update/manager/update-manager.cpp @@ -1153,6 +1153,17 @@ void UpdateManager::SurfaceReplaced( Scene* scene ) new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SurfaceReplaced, scene ); } +void UpdateManager::SetDefaultSurfaceOrientation( int orientation ) +{ + typedef MessageValue1< RenderManager, int > DerivedType; + + // Reserve some memory inside the render queue + unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + + // Construct message in the render queue memory; note that delete should not be called on the return value + new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetDefaultSurfaceOrientation, orientation ); +} + void UpdateManager::KeepRendering( float durationSeconds ) { mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds ); diff --git a/dali/internal/update/manager/update-manager.h b/dali/internal/update/manager/update-manager.h index f07a3be39..fdadd69c1 100644 --- a/dali/internal/update/manager/update-manager.h +++ b/dali/internal/update/manager/update-manager.h @@ -635,6 +635,12 @@ public: */ void SetDefaultSurfaceRect( const Rect& rect ); + /** + * Set the default surface orientation. + * @param[in] orientation The orientation value representing the surface. + */ + void SetDefaultSurfaceOrientation( int orientation ); + /** * @copydoc Dali::Stage::KeepRendering() */ @@ -1088,6 +1094,17 @@ inline void SurfaceReplacedMessage( UpdateManager& manager, const SceneGraph::Sc new (slot) LocalType( &manager, &UpdateManager::SurfaceReplaced, &scene ); } +inline void SetDefaultSurfaceOrientationMessage( UpdateManager& manager, int orientation ) +{ + typedef MessageValue1< UpdateManager, int > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) ); + + // Construct message in the message queue memory; note that delete should not be called on the return value + new (slot) LocalType( &manager, &UpdateManager::SetDefaultSurfaceOrientation, orientation ); +} + inline void KeepRenderingMessage( UpdateManager& manager, float durationSeconds ) { typedef MessageValue1< UpdateManager, float > LocalType; diff --git a/dali/internal/update/render-tasks/scene-graph-camera.cpp b/dali/internal/update/render-tasks/scene-graph-camera.cpp index 71a2d52f1..c3dc3c5fd 100644 --- a/dali/internal/update/render-tasks/scene-graph-camera.cpp +++ b/dali/internal/update/render-tasks/scene-graph-camera.cpp @@ -161,6 +161,7 @@ const Vector3 Camera::DEFAULT_TARGET_POSITION( 0.0f, 0.0f, 0.0f ); Camera::Camera() : mUpdateViewFlag( UPDATE_COUNT ), mUpdateProjectionFlag( UPDATE_COUNT ), + mProjectionRotation( 0 ), mNode( NULL ), mType( DEFAULT_TYPE ), mProjectionMode( DEFAULT_MODE ), @@ -176,7 +177,8 @@ Camera::Camera() mTargetPosition( DEFAULT_TARGET_POSITION ), mViewMatrix(), mProjectionMatrix(), - mInverseViewProjection( Matrix::IDENTITY ) + mInverseViewProjection( Matrix::IDENTITY ), + mFinalProjection( Matrix::IDENTITY ) { } @@ -265,8 +267,6 @@ void Camera::SetTargetPosition( const Vector3& targetPosition ) mUpdateViewFlag = UPDATE_COUNT; } - - void VectorReflectedByPlane(Vector4 &out, Vector4 &in, Vector4 &plane) { float d = float(2.0) * plane.Dot(in); @@ -328,6 +328,12 @@ void Camera::SetReflectByPlane( const Vector4& plane ) mUpdateViewFlag = UPDATE_COUNT; } +void Camera::RotateProjection( int rotationAngle ) +{ + mProjectionRotation = rotationAngle; + mUpdateViewFlag = UPDATE_COUNT; +} + const Matrix& Camera::GetProjectionMatrix( BufferIndex bufferIndex ) const { return mProjectionMatrix[ bufferIndex ]; @@ -343,6 +349,11 @@ const Matrix& Camera::GetInverseViewProjectionMatrix( BufferIndex bufferIndex ) return mInverseViewProjection[ bufferIndex ]; } +const Matrix& Camera::GetFinalProjectionMatrix( BufferIndex bufferIndex ) const +{ + return mFinalProjection[ bufferIndex ]; +} + const PropertyInputImpl* Camera::GetProjectionMatrix() const { return &mProjectionMatrix; @@ -652,6 +663,38 @@ uint32_t Camera::UpdateProjection( BufferIndex updateBufferIndex ) } mProjectionMatrix.SetDirty( updateBufferIndex ); + + Matrix &finalProjection = mFinalProjection[ updateBufferIndex ]; + finalProjection.SetIdentity(); + + Quaternion rotationAngle; + switch( mProjectionRotation ) + { + case 90: + { + rotationAngle = Quaternion( Dali::ANGLE_90, Vector3::ZAXIS ); + break; + } + case 180: + { + rotationAngle = Quaternion( Dali::ANGLE_180, Vector3::ZAXIS ); + break; + } + case 270: + { + rotationAngle = Quaternion( Dali::ANGLE_270, Vector3::ZAXIS ); + break; + } + default: + rotationAngle = Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ); + break; + } + + Matrix rotation; + rotation.SetIdentity(); + rotation.SetTransformComponents( Vector3( 1.0f, 1.0f, 1.0f ), rotationAngle, Vector3( 0.0f, 0.0f, 0.0f ) ); + + Matrix::Multiply( finalProjection, mProjectionMatrix.Get( updateBufferIndex ), rotation ); } --mUpdateProjectionFlag; } diff --git a/dali/internal/update/render-tasks/scene-graph-camera.h b/dali/internal/update/render-tasks/scene-graph-camera.h index a3bc173d4..7021b5a58 100644 --- a/dali/internal/update/render-tasks/scene-graph-camera.h +++ b/dali/internal/update/render-tasks/scene-graph-camera.h @@ -154,6 +154,11 @@ public: */ void SetFarClippingPlane( float farClippingPlane ); + /** + * @copydoc Dali::Internal::CameraActor::RotateProjection + */ + void RotateProjection( int rotationAngle ); + /** * @copydoc Dali::Internal::CameraActor::SetTarget */ @@ -217,6 +222,13 @@ public: */ const Matrix& GetInverseViewProjectionMatrix( BufferIndex bufferIndex ) const; + /** + * Retrieve the final projection-matrix; this is double buffered for input handling. + * @param[in] bufferIndex The buffer to read from. + * @return The projection-matrix that should be used to render. + */ + const Matrix& GetFinalProjectionMatrix( BufferIndex bufferIndex ) const; + /** * Retrieve the projection-matrix property querying interface. * @pre The camera is on-stage. @@ -289,6 +301,7 @@ private: uint32_t mUpdateViewFlag; ///< This is non-zero if the view matrix requires an update uint32_t mUpdateProjectionFlag; ///< This is non-zero if the projection matrix requires an update + int mProjectionRotation; ///< The rotaion angle of the projection const Node* mNode; ///< The node this scene graph camera belongs to public: // PROPERTIES @@ -317,6 +330,7 @@ public: // PROPERTIES DoubleBuffered< FrustumPlanes > mFrustum; ///< Clipping frustum; double buffered for input handling DoubleBuffered< Matrix > mInverseViewProjection; ///< Inverted viewprojection; double buffered for input handling + DoubleBuffered< Matrix > mFinalProjection; ///< Final projection matrix; double buffered for input handling }; @@ -454,6 +468,17 @@ inline void SetInvertYAxisMessage( EventThreadServices& eventThreadServices, con new (slot) LocalType( &camera, &Camera::SetInvertYAxis, parameter ); } +inline void RotateProjectionMessage( EventThreadServices& eventThreadServices, const Camera& camera, int parameter ) +{ + typedef MessageValue1< Camera, int > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + // Construct message in the message queue memory; note that delete should not be called on the return value + new (slot) LocalType( &camera, &Camera::RotateProjection, parameter ); +} + } // namespace SceneGraph } // namespace Internal -- 2.34.1