Revert "[Tizen] Revert "Support multiple window rendering""
authorJiyun Yang <ji.yang@samsung.com>
Mon, 25 Mar 2019 05:10:58 +0000 (14:10 +0900)
committerJiyun Yang <ji.yang@samsung.com>
Mon, 25 Mar 2019 05:10:58 +0000 (14:10 +0900)
This reverts commit 14502a507909174b52e486a0ee7516cb26e6ad45.

73 files changed:
automated-tests/src/dali-internal/CMakeLists.txt
automated-tests/src/dali-internal/utc-Dali-Internal-Core.cpp
automated-tests/src/dali/CMakeLists.txt
automated-tests/src/dali/dali-test-suite-utils/test-application.cpp
automated-tests/src/dali/dali-test-suite-utils/test-application.h
automated-tests/src/dali/dali-test-suite-utils/test-render-surface.cpp [new file with mode: 0644]
automated-tests/src/dali/dali-test-suite-utils/test-render-surface.h [new file with mode: 0644]
automated-tests/src/dali/utc-Dali-CameraActor.cpp
automated-tests/src/dali/utc-Dali-RenderTask.cpp
automated-tests/src/dali/utc-Dali-Scene.cpp [new file with mode: 0644]
automated-tests/src/dali/utc-Dali-Stage.cpp
build/tizen/dali-core/Makefile.am
dali/integration-api/CMakeLists.txt
dali/integration-api/core.cpp
dali/integration-api/core.h
dali/integration-api/file.list
dali/integration-api/render-surface.h [new file with mode: 0644]
dali/integration-api/scene.cpp [new file with mode: 0644]
dali/integration-api/scene.h [new file with mode: 0644]
dali/internal/CMakeLists.txt
dali/internal/common/core-impl.cpp
dali/internal/common/core-impl.h
dali/internal/event/actors/actor-impl.cpp
dali/internal/event/actors/actor-impl.h
dali/internal/event/actors/camera-actor-impl.cpp
dali/internal/event/actors/camera-actor-impl.h
dali/internal/event/actors/layer-impl.cpp
dali/internal/event/animation/animation-impl.cpp
dali/internal/event/animation/constraint-base.cpp
dali/internal/event/common/event-thread-services.cpp
dali/internal/event/common/event-thread-services.h
dali/internal/event/common/object-impl.cpp
dali/internal/event/common/property-buffer-impl.cpp
dali/internal/event/common/property-notification-impl.cpp
dali/internal/event/common/scene-impl.cpp [new file with mode: 0644]
dali/internal/event/common/scene-impl.h [new file with mode: 0644]
dali/internal/event/common/stage-impl.cpp
dali/internal/event/common/stage-impl.h
dali/internal/event/common/thread-local-storage.cpp
dali/internal/event/common/thread-local-storage.h
dali/internal/event/render-tasks/render-task-impl.cpp
dali/internal/event/render-tasks/render-task-impl.h
dali/internal/event/render-tasks/render-task-list-impl.cpp
dali/internal/event/render-tasks/render-task-list-impl.h
dali/internal/event/rendering/frame-buffer-impl.cpp
dali/internal/event/rendering/frame-buffer-impl.h
dali/internal/event/rendering/geometry-impl.cpp
dali/internal/event/rendering/sampler-impl.cpp
dali/internal/event/rendering/texture-impl.cpp
dali/internal/event/rendering/texture-set-impl.cpp
dali/internal/event/size-negotiation/relayout-controller-impl.cpp
dali/internal/event/size-negotiation/relayout-controller-impl.h
dali/internal/file.list
dali/internal/render/common/render-manager.cpp
dali/internal/render/gl-resources/gpu-buffer.cpp
dali/internal/render/gl-resources/gpu-buffer.h
dali/internal/render/renderers/render-frame-buffer.h
dali/internal/render/renderers/render-geometry.cpp
dali/internal/render/renderers/render-geometry.h
dali/internal/render/renderers/render-property-buffer.cpp
dali/internal/render/renderers/render-property-buffer.h
dali/internal/render/renderers/render-renderer.cpp
dali/internal/render/renderers/render-renderer.h
dali/internal/render/renderers/render-surface-frame-buffer.cpp [new file with mode: 0644]
dali/internal/render/renderers/render-surface-frame-buffer.h [new file with mode: 0644]
dali/internal/render/renderers/render-texture-frame-buffer.cpp [moved from dali/internal/render/renderers/render-frame-buffer.cpp with 74% similarity]
dali/internal/render/renderers/render-texture-frame-buffer.h [new file with mode: 0644]
dali/internal/render/shaders/program-controller.cpp
dali/internal/render/shaders/program-controller.h
dali/internal/update/manager/render-task-processor.cpp
dali/internal/update/render-tasks/scene-graph-render-task-list.h
dali/public-api/actors/camera-actor.h
dali/public-api/object/base-object.cpp

index 64b34e7..2566323 100644 (file)
@@ -26,6 +26,7 @@ LIST(APPEND TC_SOURCES
         ../dali/dali-test-suite-utils/test-native-image.cpp
         ../dali/dali-test-suite-utils/test-platform-abstraction.cpp
         ../dali/dali-test-suite-utils/test-render-controller.cpp
+        ../dali/dali-test-suite-utils/test-render-surface.cpp
         ../dali/dali-test-suite-utils/test-trace-call-stack.cpp
 )
 
index e12a27a..99c55b8 100644 (file)
@@ -66,35 +66,6 @@ public:
 
 } // anonymous namespace
 
-int UtcDaliCoreTopMargin(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::Integration::Core::SetTopMargin");
-
-  Stage stage = Stage::GetCurrent();
-
-  // Test Stage size without top-margin
-
-  const unsigned int initialWidth(  stage.GetSize().width );
-  const unsigned int initialHeight( stage.GetSize().height );
-
-  DALI_TEST_EQUALS( TestApplication::DEFAULT_SURFACE_WIDTH,  initialWidth,  TEST_LOCATION );
-  DALI_TEST_EQUALS( TestApplication::DEFAULT_SURFACE_HEIGHT, initialHeight, TEST_LOCATION );
-
-  // Retest with top-margin
-
-  unsigned int margin( 10 );
-  application.SetTopMargin( margin );
-
-  const unsigned int newWidth(  stage.GetSize().width );
-  const unsigned int newHeight( stage.GetSize().height );
-
-  DALI_TEST_EQUALS( TestApplication::DEFAULT_SURFACE_WIDTH,             newWidth,  TEST_LOCATION );
-  DALI_TEST_EQUALS( (TestApplication::DEFAULT_SURFACE_HEIGHT - margin), newHeight, TEST_LOCATION );
-
-  END_TEST;
-}
-
 int UtcDaliCoreProcessEvents(void)
 {
   TestApplication application;
index 288073d..62bad22 100644 (file)
@@ -77,6 +77,7 @@ SET(TC_SOURCES
         utc-Dali-RenderTaskList.cpp
         utc-Dali-ResourceImage.cpp
         utc-Dali-Sampler.cpp
+        utc-Dali-Scene.cpp
         utc-Dali-Scripting.cpp
         utc-Dali-Shader.cpp
         utc-Dali-SignalDelegate.cpp
@@ -115,6 +116,7 @@ LIST(APPEND TC_SOURCES
         dali-test-suite-utils/test-native-image.cpp
         dali-test-suite-utils/test-platform-abstraction.cpp
         dali-test-suite-utils/test-render-controller.cpp
+        dali-test-suite-utils/test-render-surface.cpp
         dali-test-suite-utils/test-trace-call-stack.cpp
 )
 
index c953f50..1562d27 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -54,8 +54,6 @@ void TestApplication::Initialize()
                                         Integration::StencilBufferAvailable::TRUE );
 
   mCore->ContextCreated();
-  mCore->SurfaceResized( mSurfaceWidth, mSurfaceHeight );
-  mCore->SetDpi( mDpi.x, mDpi.y );
 
   Dali::Integration::Log::LogFunction logFunction(&TestApplication::LogMessage);
   Dali::Integration::Log::InstallLogFunction(logFunction);
@@ -65,12 +63,22 @@ void TestApplication::Initialize()
 
   Dali::Integration::Trace::LogContext( true, "Test" );
 
+  mRenderSurface = new TestRenderSurface( Dali::PositionSize( 0, 0, mSurfaceWidth, mSurfaceHeight ) );
+  mScene = Dali::Integration::Scene::New( Vector2( static_cast<float>( mSurfaceWidth ), static_cast<float>( mSurfaceHeight ) ) );
+  mScene.SetSurface( *mRenderSurface );
+
+  mScene.SetDpi( Vector2( static_cast<float>( mDpi.x ), static_cast<float>( mDpi.y ) ) );
+
+  mCore->SurfaceResized( mRenderSurface );
+
   mCore->SceneCreated();
+  mCore->Initialize();
 }
 
 TestApplication::~TestApplication()
 {
   Dali::Integration::Log::UninstallLogFunction();
+  delete mRenderSurface;
   delete mCore;
 }
 
@@ -149,19 +157,6 @@ void TestApplication::SendNotification()
   mCore->ProcessEvents();
 }
 
-void TestApplication::SetSurfaceWidth( uint32_t width, uint32_t height )
-{
-  mSurfaceWidth = width;
-  mSurfaceHeight = height;
-
-  mCore->SurfaceResized( mSurfaceWidth, mSurfaceHeight );
-}
-
-void TestApplication::SetTopMargin( uint32_t margin )
-{
-  mCore->SetTopMargin( margin );
-}
-
 void TestApplication::DoUpdate( uint32_t intervalMilliseconds, const char* location )
 {
   if( GetUpdateStatus() == 0 &&
index d1e042d..fc2929c 100644 (file)
@@ -2,7 +2,7 @@
 #define __DALI_TEST_APPLICATION_H__
 
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
 #include "test-gl-sync-abstraction.h"
 #include "test-gl-abstraction.h"
 #include "test-render-controller.h"
+#include "test-render-surface.h"
 #include <dali/public-api/common/dali-common.h>
 #include <dali/integration-api/resource-policies.h>
 #include <dali/integration-api/trace.h>
+#include <dali/integration-api/scene.h>
 
 namespace Dali
 {
@@ -69,8 +71,6 @@ public:
   TestGestureManager& GetGestureManager();
   void ProcessEvent(const Integration::Event& event);
   void SendNotification();
-  void SetSurfaceWidth( uint32_t width, unsigned height );
-  void SetTopMargin( uint32_t margin );
   bool Render( uint32_t intervalMilliseconds = DEFAULT_RENDER_INTERVAL, const char* location=NULL );
   uint32_t GetUpdateStatus();
   bool UpdateOnly( uint32_t intervalMilliseconds = DEFAULT_RENDER_INTERVAL );
@@ -83,6 +83,11 @@ public:
     mLoggingEnabled = enabled;
   }
 
+  Integration::Scene GetScene() const
+  {
+    return mScene;
+  }
+
 private:
   void DoUpdate( uint32_t intervalMilliseconds, const char* location=NULL );
 
@@ -92,11 +97,13 @@ protected:
   TestGlAbstraction         mGlAbstraction;
   TestGlSyncAbstraction     mGlSyncAbstraction;
   TestGestureManager        mGestureManager;
+  TestRenderSurface*        mRenderSurface;
 
   Integration::UpdateStatus mStatus;
   Integration::RenderStatus mRenderStatus;
 
   Integration::Core* mCore;
+  Dali::Integration::Scene mScene;
 
   uint32_t mSurfaceWidth;
   uint32_t mSurfaceHeight;
diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-render-surface.cpp b/automated-tests/src/dali/dali-test-suite-utils/test-render-surface.cpp
new file mode 100644 (file)
index 0000000..332d77e
--- /dev/null
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "test-render-surface.h"
+
+namespace Dali
+{
+
+TestRenderSurface::TestRenderSurface( Dali::PositionSize positionSize )
+: mPositionSize( positionSize ),
+  mBackgroundColor()
+{
+}
+
+TestRenderSurface::~TestRenderSurface()
+{
+}
+
+Dali::PositionSize TestRenderSurface::GetPositionSize() const
+{
+  return mPositionSize;
+};
+
+void TestRenderSurface::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical )
+{
+  dpiHorizontal = dpiVertical = 96;
+};
+
+void TestRenderSurface::InitializeGraphics()
+{
+}
+
+void TestRenderSurface::CreateSurface()
+{
+}
+
+void TestRenderSurface::DestroySurface()
+{
+}
+
+bool TestRenderSurface::ReplaceGraphicsSurface()
+{
+  return false;
+}
+
+void TestRenderSurface::MoveResize( Dali::PositionSize positionSize )
+{
+  mPositionSize = positionSize;
+}
+
+void TestRenderSurface::StartRender()
+{
+}
+
+bool TestRenderSurface::PreRender( bool resizingSurface )
+{
+  return true;
+}
+
+void TestRenderSurface::PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface )
+{
+}
+
+void TestRenderSurface::StopRender()
+{
+}
+
+void TestRenderSurface::ReleaseLock()
+{
+}
+
+Dali::Integration::RenderSurface::Type TestRenderSurface::GetSurfaceType()
+{
+  return WINDOW_RENDER_SURFACE;
+}
+
+void TestRenderSurface::MakeContextCurrent()
+{
+}
+
+Integration::DepthBufferAvailable TestRenderSurface::GetDepthBufferRequired()
+{
+  return Integration::DepthBufferAvailable::TRUE;
+}
+
+Integration::StencilBufferAvailable TestRenderSurface::GetStencilBufferRequired()
+{
+  return Integration::StencilBufferAvailable::TRUE;
+}
+
+void TestRenderSurface::SetBackgroundColor( Vector4 color )
+{
+  mBackgroundColor = color;
+}
+
+Vector4 TestRenderSurface::GetBackgroundColor()
+{
+  return mBackgroundColor;
+}
+
+} // Namespace dali
diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-render-surface.h b/automated-tests/src/dali/dali-test-suite-utils/test-render-surface.h
new file mode 100644 (file)
index 0000000..fba89c2
--- /dev/null
@@ -0,0 +1,155 @@
+#ifndef TEST_REENDER_SURFACE_H
+#define TEST_REENDER_SURFACE_H
+
+/*
+ * Copyright (c) 2019 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 <dali/public-api/common/dali-common.h>
+#include <dali/integration-api/render-surface.h>
+
+namespace Dali
+{
+
+/**
+ * Concrete implementation of the RenderSurface class.
+ */
+class DALI_CORE_API TestRenderSurface : public Dali::Integration::RenderSurface
+{
+public:
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::RenderSurface
+   */
+  TestRenderSurface( Dali::PositionSize positionSize );
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::~RenderSurface
+   */
+  virtual ~TestRenderSurface();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::GetPositionSize
+   */
+  virtual Dali::PositionSize GetPositionSize() const;
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::GetDpi
+   */
+  virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical );
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::InitializeGraphics
+   */
+  virtual void InitializeGraphics();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::CreateSurface
+   */
+  virtual void CreateSurface();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::DestroySurface
+   */
+  virtual void DestroySurface();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::ReplaceGraphicsSurface
+   */
+  virtual bool ReplaceGraphicsSurface();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::MoveResize
+   */
+  virtual void MoveResize( Dali::PositionSize positionSize );
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::StartRender
+   */
+  virtual void StartRender();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::PreRender
+   */
+  virtual bool PreRender( bool resizingSurface );
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::PostRender
+   */
+  virtual void PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface );
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::StopRender
+   */
+  virtual void StopRender();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::ReleaseLock
+   */
+  virtual void ReleaseLock();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::GetSurfaceType
+   */
+  virtual Dali::Integration::RenderSurface::Type GetSurfaceType();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::MakeContextCurrent
+   */
+  virtual void MakeContextCurrent();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::GetDepthBufferRequired
+   */
+  virtual Integration::DepthBufferAvailable GetDepthBufferRequired();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::GetStencilBufferRequired
+   */
+  virtual Integration::StencilBufferAvailable GetStencilBufferRequired();
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::SetBackgroundColor
+   */
+  virtual void SetBackgroundColor( Vector4 color );
+
+  /**
+   * @copydoc Dali::Integration::RenderSurface::GetBackgroundColor
+   */
+  virtual Vector4 GetBackgroundColor();
+
+private:
+
+  /**
+   * @brief Undefined copy constructor. RenderSurface cannot be copied
+   */
+  TestRenderSurface( const TestRenderSurface& rhs );
+
+  /**
+   * @brief Undefined assignment operator. RenderSurface cannot be copied
+   */
+  TestRenderSurface& operator=( const TestRenderSurface& rhs );
+
+private:
+
+  Dali::PositionSize mPositionSize;
+  Vector4 mBackgroundColor;                                     ///< The background color of the surface
+};
+
+} // Dali
+
+#endif
index 415f6cf..ac726f7 100644 (file)
@@ -282,7 +282,7 @@ int UtcDaliCameraActorSetFieldOfViewP(void)
   CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   const float defaultFieldOfView = defaultCamera.GetFieldOfView();
 
-  CameraActor actor = CameraActor::New();
+  CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
 
   float fieldOfView = Math::PI / 3.0f;
@@ -303,7 +303,7 @@ int UtcDaliCameraActorSetFieldOfViewN(void)
   CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   const float defaultFieldOfView = defaultCamera.GetFieldOfView();
 
-  CameraActor actor = CameraActor::New();
+  CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
 
   float fieldOfView = Math::PI / 3.0f;
@@ -327,7 +327,7 @@ int UtcDaliCameraActorGetFieldOfViewP(void)
   const float cameraZ = 2.0f * std::max( size.width, size.height );
   const float expectedFieldOfView = 2.0f * std::atan( size.height * 0.5f / cameraZ );
 
-  CameraActor actor = CameraActor::New();
+  CameraActor actor = CameraActor::New( size );
   DALI_TEST_EQUALS( actor.GetFieldOfView(), expectedFieldOfView, TEST_LOCATION );
 
   float value;
@@ -364,7 +364,7 @@ int UtcDaliCameraActorSetAspectRatioP(void)
   TestApplication application;
   tet_infoline( "Testing Dali::CameraActor Set Aspect Ratio (P)" );
 
-  CameraActor actor = CameraActor::New();
+  CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   DALI_TEST_EQUALS( actor.GetAspectRatio(), static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT ), TEST_LOCATION );
 
   // Set an initial value to confirm a further set changes it.
@@ -407,7 +407,7 @@ int UtcDaliCameraActorGetAspectRatioP(void)
   TestApplication application;
   tet_infoline("Testing Dali::CameraActor Get Aspect Ratio");
 
-  CameraActor actor = CameraActor::New();
+  CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   float defaultAspect = static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT );
 
   DALI_TEST_EQUALS( actor.GetAspectRatio(), defaultAspect, TEST_LOCATION );
@@ -576,7 +576,7 @@ int UtcDaliCameraActorGetFarClippingPlaneP(void)
   TestApplication application;
   tet_infoline( "Testing Dali::CameraActor Get Far clipping plane (P)" );
 
-  CameraActor actor = CameraActor::New();
+  CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   float defaultValue = 800.0f + ( 0xFFFF >> 4 );
   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), defaultValue, TEST_LOCATION );
 
@@ -805,16 +805,14 @@ int UtcDaliCameraActorSetPerspectiveProjectionN(void)
   TestApplication application;
   tet_infoline( "Testing Dali::CameraActor::SetPerspectiveProjection (N)" );
 
-  Stage stage = Stage::GetCurrent();
-  Vector2 stageSize = stage.GetSize();
-
   CameraActor actor = CameraActor::New();
 
-  // Check that setting perspective projection without a size (using zero size) uses the stages size.
+  // Check that setting perspective projection without a size does not do anything.
   actor.SetPerspectiveProjection( Size::ZERO );
 
-  float nearClippingPlane = std::max( stageSize.width, stageSize.height );
-  float farClippingPlane = nearClippingPlane + static_cast<float>( 0xFFFF >> 4 );
+  // So the default values should be the same as defined in CameraActor
+  float nearClippingPlane = 800.0f;
+  float farClippingPlane = nearClippingPlane + 2.0f * nearClippingPlane;
 
   DALI_TEST_EQUALS( nearClippingPlane, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
   DALI_TEST_EQUALS( farClippingPlane, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
index 2d6f89c..f6697f0 100644 (file)
@@ -635,11 +635,16 @@ int UtcDaliRenderTaskSetExclusive(void)
 
   // Check that the actor1 was rendered
   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
-  DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
+  DALI_TEST_GREATER( boundTextures.size(), static_cast<std::vector<GLuint>::size_type>( 0 ), TEST_LOCATION );
 
   if ( boundTextures.size() )
   {
-    DALI_TEST_EQUALS( boundTextures[0], 8u/*unique to actor1*/, TEST_LOCATION );
+    int c = 0;
+    DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
+    if( boundTextures.size() > 1 )
+    {
+      DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
+    }
   }
 
   BufferImage img2 = BufferImage::New( 1,1 );
@@ -658,12 +663,17 @@ int UtcDaliRenderTaskSetExclusive(void)
   application.Render();
 
   // Check that the actors were rendered
-  DALI_TEST_EQUALS( boundTextures.size(), 2u, TEST_LOCATION );
+  DALI_TEST_GREATER( boundTextures.size(), static_cast<std::vector<GLuint>::size_type>( 1 ), TEST_LOCATION );
 
   if ( boundTextures.size() )
   {
-    DALI_TEST_EQUALS( boundTextures[0], 9u/*unique to actor2*/, TEST_LOCATION );
-    DALI_TEST_EQUALS( boundTextures[1], 8u/*unique to actor1*/, TEST_LOCATION );
+    int c = 0;
+    DALI_TEST_EQUALS( boundTextures[c++], 9u/*unique to actor2*/, TEST_LOCATION );
+    if( boundTextures.size() > 2 )
+    {
+      DALI_TEST_EQUALS( boundTextures[c++], 9u/*unique to actor1*/, TEST_LOCATION );
+    }
+    DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
   }
 
   BufferImage img3 = BufferImage::New( 1,1 );
@@ -682,13 +692,18 @@ int UtcDaliRenderTaskSetExclusive(void)
   application.Render();
 
   // Check that the actors were rendered
-  DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
+  DALI_TEST_GREATER( boundTextures.size(), static_cast<std::vector<GLuint>::size_type>( 2 ), TEST_LOCATION );
 
   if ( boundTextures.size() )
   {
-    DALI_TEST_EQUALS( boundTextures[0], 10u/*unique to actor3*/, TEST_LOCATION );
-    DALI_TEST_EQUALS( boundTextures[1], 9u/*unique to actor2*/, TEST_LOCATION );
-    DALI_TEST_EQUALS( boundTextures[2], 8u/*unique to actor1*/, TEST_LOCATION );
+    int c = 0;
+    DALI_TEST_EQUALS( boundTextures[c++], 10u/*unique to actor3*/, TEST_LOCATION );
+    if( boundTextures.size() > 3 )
+    {
+      DALI_TEST_EQUALS( boundTextures[c++], 10u/*unique to actor2*/, TEST_LOCATION );
+    }
+    DALI_TEST_EQUALS( boundTextures[c++], 9u/*unique to actor2*/, TEST_LOCATION );
+    DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
   }
 
   // Both actors are now connected to the root node
@@ -1104,9 +1119,9 @@ int UtcDaliRenderTaskGetFrameBufferN(void)
 
   RenderTask task = taskList.GetTask( 0u );
 
-  // By default render-tasks do not render off-screen
+  // A scene creates frame buffer by default
   FrameBuffer frameBuffer = task.GetFrameBuffer();
-  DALI_TEST_CHECK( !frameBuffer );
+  DALI_TEST_CHECK( frameBuffer );
 
   END_TEST;
 }
@@ -1879,7 +1894,7 @@ int UtcDaliRenderTaskContinuous01(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
 
   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
@@ -1917,7 +1932,7 @@ int UtcDaliRenderTaskContinuous02(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
 
   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
@@ -1957,7 +1972,7 @@ int UtcDaliRenderTaskContinuous03(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
   Stage::GetCurrent().Add(secondRootActor);
 
@@ -1995,7 +2010,7 @@ int UtcDaliRenderTaskContinuous04(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
   Actor secondRootActor = CreateRenderableActorFailed(application, "aFile.jpg");
   Stage::GetCurrent().Add(secondRootActor);
@@ -2026,7 +2041,7 @@ int UtcDaliRenderTaskOnce01(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
 
@@ -2064,7 +2079,7 @@ int UtcDaliRenderTaskOnce02(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
 
   Shader shader = CreateShader();
@@ -2112,7 +2127,7 @@ int UtcDaliRenderTaskOnce03(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
   Stage::GetCurrent().Add(secondRootActor);
@@ -2157,7 +2172,7 @@ int UtcDaliRenderTaskOnce04(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
 
   Shader shader = CreateShader();
@@ -2209,7 +2224,7 @@ int UtcDaliRenderTaskOnceNoSync01(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
   Stage::GetCurrent().Add(secondRootActor);
@@ -2239,7 +2254,7 @@ int UtcDaliRenderTaskOnceNoSync02(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
 
   Shader shader = CreateShader();
@@ -2283,7 +2298,7 @@ int UtcDaliRenderTaskOnceNoSync03(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
   Stage::GetCurrent().Add(secondRootActor);
@@ -2320,7 +2335,7 @@ int UtcDaliRenderTaskOnceNoSync04(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
 
   Shader shader = CreateShader();
@@ -2375,7 +2390,7 @@ int UtcDaliRenderTaskOnceNoSync05(void)
   Actor rootActor = Actor::New();
   Stage::GetCurrent().Add( rootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
   Actor secondRootActor = CreateRenderableActorFailed(application, "aFile.jpg");
   Stage::GetCurrent().Add(secondRootActor);
@@ -2415,7 +2430,7 @@ int UtcDaliRenderTaskOnceChain01(void)
   Actor defaultRootActor = Actor::New(); // Root for default RT
   Stage::GetCurrent().Add( defaultRootActor );
 
-  CameraActor offscreenCameraActor = CameraActor::New();
+  CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
   Stage::GetCurrent().Add( offscreenCameraActor );
   Actor firstRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
   Stage::GetCurrent().Add(firstRootActor);
diff --git a/automated-tests/src/dali/utc-Dali-Scene.cpp b/automated-tests/src/dali/utc-Dali-Scene.cpp
new file mode 100644 (file)
index 0000000..a8b706e
--- /dev/null
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/integration-api/scene.h>
+#include <dali-test-suite-utils.h>
+
+// Internal headers are allowed here
+
+int UtcDaliSceneAdd(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::Integration::Scene::Add");
+
+  Dali::Integration::Scene scene = application.GetScene();
+
+  Actor actor = Actor::New();
+  DALI_TEST_CHECK( !actor.OnStage() );
+
+  scene.Add( actor );
+  DALI_TEST_CHECK( actor.OnStage() );
+
+  END_TEST;
+}
+
+int UtcDaliSceneRemove(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::Integration::Scene::Remove");
+
+  Dali::Integration::Scene scene = application.GetScene();
+
+  Actor actor = Actor::New();
+  DALI_TEST_CHECK( !actor.OnStage() );
+
+  scene.Add( actor );
+  DALI_TEST_CHECK( actor.OnStage() );
+
+  scene.Remove(actor);
+  DALI_TEST_CHECK( !actor.OnStage() );
+
+  END_TEST;
+}
+
+int UtcDaliSceneGetSize(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::Integration::Scene::GetSize");
+
+  Dali::Integration::Scene scene = application.GetScene();
+  Size size = scene.GetSize();
+  DALI_TEST_EQUALS( TestApplication::DEFAULT_SURFACE_WIDTH, size.width, TEST_LOCATION );
+  DALI_TEST_EQUALS( TestApplication::DEFAULT_SURFACE_HEIGHT, size.height, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliSceneGetDpi(void)
+{
+  TestApplication application; // Initializes core DPI to default values
+
+  // Test that setting core DPI explicitly also sets up the scene's DPI.
+  Dali::Integration::Scene scene = application.GetScene();
+  scene.SetDpi( Vector2(200.0f, 180.0f) );
+  Vector2 dpi = scene.GetDpi();
+  DALI_TEST_EQUALS( dpi.x, 200.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS( dpi.y, 180.0f, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliSceneGetRenderTaskList(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::Integration::Scene::GetRenderTaskList");
+
+  Dali::Integration::Scene scene = application.GetScene();
+
+  // Check we get a valid instance.
+  const RenderTaskList& tasks = scene.GetRenderTaskList();
+
+  // There should be 1 task by default.
+  DALI_TEST_EQUALS( tasks.GetTaskCount(), 1u, TEST_LOCATION );
+
+  // RenderTaskList has it's own UTC tests.
+  // But we can confirm that GetRenderTaskList in Stage retrieves the same RenderTaskList each time.
+  RenderTask newTask = scene.GetRenderTaskList().CreateTask();
+
+  DALI_TEST_EQUALS( scene.GetRenderTaskList().GetTask( 1 ), newTask, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliSceneGetRootLayer(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::Integration::Scene::GetRootLayer");
+
+  Dali::Integration::Scene scene = application.GetScene();
+  Layer layer = scene.GetLayer( 0 );
+  DALI_TEST_CHECK( layer );
+
+  // Check that GetRootLayer() correctly retreived layer 0.
+  DALI_TEST_CHECK( scene.GetRootLayer() == layer );
+
+  END_TEST;
+}
+
+int UtcDaliSceneGetLayerCount(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::Integration::Scene::GetLayerCount");
+
+  Dali::Integration::Scene scene = application.GetScene();
+  // Initially we have a default layer
+  DALI_TEST_EQUALS( scene.GetLayerCount(), 1u, TEST_LOCATION );
+
+  Layer layer = Layer::New();
+  scene.Add( layer );
+
+  DALI_TEST_EQUALS( scene.GetLayerCount(), 2u, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliSceneGetLayer(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::Integration::Scene::GetLayer");
+
+  Dali::Integration::Scene scene = application.GetScene();
+
+  Layer rootLayer = scene.GetLayer( 0 );
+  DALI_TEST_CHECK( rootLayer );
+
+  Layer layer = Layer::New();
+  scene.Add( layer );
+
+  Layer sameLayer = scene.GetLayer( 1 );
+  DALI_TEST_CHECK( layer == sameLayer );
+
+  END_TEST;
+}
+
index 954957f..a3fb8f2 100755 (executable)
@@ -591,7 +591,8 @@ int UtcDaliStageGetDpiP2(void)
   TestApplication application; // Initializes core DPI to default values
 
   // Test that setting core DPI explicitly also sets up the Stage's DPI.
-  application.GetCore().SetDpi( 200, 180 );
+  Dali::Integration::Scene scene = application.GetScene();
+  scene.SetDpi( Vector2(200.0f, 180.0f) );
 
   Stage stage = Stage::GetCurrent();
   Vector2 dpi = stage.GetDpi();
index c9f9f07..9242d3b 100644 (file)
@@ -146,6 +146,7 @@ linker_test_SOURCES = linker-test.cpp  \
     ../../../automated-tests/src/dali/dali-test-suite-utils/test-application.cpp \
     ../../../automated-tests/src/dali/dali-test-suite-utils/test-platform-abstraction.cpp \
     ../../../automated-tests/src/dali/dali-test-suite-utils/test-render-controller.cpp \
+    ../../../automated-tests/src/dali/dali-test-suite-utils/test-render-surface.cpp \
     ../../../automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.cpp \
     ../../../automated-tests/src/dali/dali-test-suite-utils/test-gesture-manager.cpp \
     ../../../automated-tests/src/dali/dali-test-suite-utils/test-gl-sync-abstraction.cpp \
index 76346b5..a856c3b 100644 (file)
@@ -8,6 +8,7 @@ SET(SOURCES ${SOURCES}
   ${CMAKE_CURRENT_SOURCE_DIR}/input-options.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/lockless-buffer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/render-task-list-integ.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/scene.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/events/event.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/events/gesture-event.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/events/hover-event-integ.cpp
@@ -41,6 +42,7 @@ SET(INTEGRATION_API_HEADERS
   ${CMAKE_CURRENT_SOURCE_DIR}/platform-abstraction.h
   ${CMAKE_CURRENT_SOURCE_DIR}/lockless-buffer.h
   ${CMAKE_CURRENT_SOURCE_DIR}/render-task-list-integ.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/scene.h
 
   ${CMAKE_CURRENT_SOURCE_DIR}/events/event.h
   ${CMAKE_CURRENT_SOURCE_DIR}/events/gesture-event.h
index de8714f..b14df7c 100644 (file)
 
 // CLASS HEADER
 #include <dali/integration-api/core.h>
+#include <dali/integration-api/render-surface.h>
 
 // INTERNAL INCLUDES
 #include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
 #include <dali/integration-api/events/event.h>
 #include <dali/integration-api/gl-sync-abstraction.h>
 #include <dali/integration-api/processor-interface.h>
@@ -60,6 +63,11 @@ Core::~Core()
   delete mImpl;
 }
 
+void Core::Initialize()
+{
+  mImpl->Initialize();
+}
+
 ContextNotifierInterface* Core::GetContextNotifier()
 {
   return mImpl->GetContextNotifier();
@@ -80,19 +88,9 @@ void Core::RecoverFromContextLoss()
   mImpl->RecoverFromContextLoss();
 }
 
-void Core::SurfaceResized(uint32_t width, uint32_t height)
-{
-  mImpl->SurfaceResized(width, height);
-}
-
-void Core::SetTopMargin( uint32_t margin )
-{
-  mImpl->SetTopMargin(margin);
-}
-
-void Core::SetDpi( uint32_t dpiHorizontal, uint32_t dpiVertical)
+void Core::SurfaceResized( Integration::RenderSurface* surface )
 {
-  mImpl->SetDpi(dpiHorizontal, dpiVertical);
+  mImpl->SurfaceResized(surface);
 }
 
 void Core::SceneCreated()
index f7e11b7..45d7582 100644 (file)
@@ -30,6 +30,9 @@
 namespace Dali
 {
 
+class Layer;
+class RenderTaskList;
+
 namespace Internal
 {
 class Core;
@@ -44,6 +47,7 @@ class GlSyncAbstraction;
 class PlatformAbstraction;
 class Processor;
 class RenderController;
+class RenderSurface;
 struct Event;
 struct TouchData;
 
@@ -247,6 +251,11 @@ public:
    */
   ~Core();
 
+  /**
+   * Initialize the core
+   */
+  void Initialize();
+
   // GL Context Lifecycle
 
   /**
@@ -286,31 +295,9 @@ public:
    * This should be done at least once i.e. after the first call to ContextCreated().
    * The Core will use the surface size for camera calculations, and to set the GL viewport.
    * Multi-threading note: this method should be called from the main thread
-   * @param[in] width The new surface width.
-   * @param[in] height The new surface height.
-   */
-  void SurfaceResized( uint32_t width, uint32_t height );
-
-  /**
-   * Notify the Core about the top margin size.
-   * Available stage size is reduced by this size.
-   * The stage is located below the size at the top of the display
-   * It is mainly useful for indicator in mobile device
-   * @param[in] margin margin size
-   */
-  void SetTopMargin( uint32_t margin );
-
-  // Core setters
-
-  /**
-   * Notify the Core about the display's DPI values.
-   * This should be done after the display is initialized and a Core instance is created.
-   * The Core will use the DPI values for font rendering.
-   * Multi-threading note: this method should be called from the main thread
-   * @param[in] dpiHorizontal Horizontal DPI value.
-   * @param[in] dpiVertical   Vertical DPI value.
+   * @param[in] surface The resized surface
    */
-  void SetDpi( uint32_t dpiHorizontal, uint32_t dpiVertical );
+  void SurfaceResized( Integration::RenderSurface* surface );
 
   // Core Lifecycle
 
index e778e61..db6517c 100644 (file)
@@ -9,6 +9,7 @@ platform_abstraction_src_files = \
    $(platform_abstraction_src_dir)/input-options.cpp \
    $(platform_abstraction_src_dir)/lockless-buffer.cpp \
    $(platform_abstraction_src_dir)/render-task-list-integ.cpp \
+   $(platform_abstraction_src_dir)/scene.cpp \
    $(platform_abstraction_src_dir)/events/event.cpp \
    $(platform_abstraction_src_dir)/events/gesture-event.cpp \
    $(platform_abstraction_src_dir)/events/hover-event-integ.cpp \
@@ -42,7 +43,9 @@ platform_abstraction_header_files = \
    $(platform_abstraction_src_dir)/platform-abstraction.h \
    $(platform_abstraction_src_dir)/processor-interface.h \
    $(platform_abstraction_src_dir)/lockless-buffer.h \
-   $(platform_abstraction_src_dir)/render-task-list-integ.h
+   $(platform_abstraction_src_dir)/render-task-list-integ.h \
+   $(platform_abstraction_src_dir)/scene.h \
+   $(platform_abstraction_src_dir)/render-surface.h
 
 platform_abstraction_events_header_files = \
    $(platform_abstraction_src_dir)/events/event.h \
diff --git a/dali/integration-api/render-surface.h b/dali/integration-api/render-surface.h
new file mode 100644 (file)
index 0000000..17f22e9
--- /dev/null
@@ -0,0 +1,215 @@
+#ifndef DALI_RENDER_SURFACE_H
+#define DALI_RENDER_SURFACE_H
+
+/*
+ * Copyright (c) 2019 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 <dali/public-api/math/rect.h>
+#include <dali/public-api/math/vector4.h>
+#include <dali/public-api/object/any.h>
+#include <dali/public-api/common/view-mode.h>
+#include <dali/integration-api/core-enumerations.h>
+
+namespace Dali
+{
+
+class DisplayConnection;
+class ThreadSynchronizationInterface;
+
+namespace Internal
+{
+
+namespace Adaptor
+{
+
+class GraphicsInterface;
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+/**
+ * @brief The position and size of the render surface.
+ */
+typedef Dali::Rect<int> PositionSize;
+
+namespace Integration
+{
+
+class GlAbstraction;
+
+/**
+ * @brief Interface for a render surface onto which Dali draws.
+ *
+ * Dali::Adaptor requires a render surface to draw on to. This is
+ * usually a window in the native windowing system, or some other
+ * mapped pixel buffer.
+ *
+ * Dali::Application will automatically create a render surface using a window.
+ *
+ * The implementation of the factory method below should choose an appropriate
+ * implementation of RenderSurface for the given platform
+ */
+
+class DALI_CORE_API RenderSurface
+{
+public:
+
+  enum Type
+  {
+    WINDOW_RENDER_SURFACE,
+    PIXMAP_RENDER_SURFACE,
+    NATIVE_RENDER_SURFACE
+  };
+
+  /**
+   * @brief Constructor
+   * Inlined as this is a pure abstract interface
+   */
+  RenderSurface() {}
+
+  /**
+   * @brief Virtual Destructor.
+   * Inlined as this is a pure abstract interface
+   */
+  virtual ~RenderSurface() {}
+
+  /**
+   * @brief Return the size and position of the surface.
+   * @return The position and size
+   */
+  virtual PositionSize GetPositionSize() const = 0;
+
+  /**
+   * @brief Get DPI
+   * @param[out] dpiHorizontal set to the horizontal dpi
+   * @param[out] dpiVertical set to the vertical dpi
+   */
+  virtual void GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) = 0;
+
+  /**
+   * @brief InitializeGraphics the platform specific graphics surface interfaces
+   */
+  virtual void InitializeGraphics() = 0;
+
+  /**
+   * @brief Creates the Surface
+   */
+  virtual void CreateSurface() = 0;
+
+  /**
+   * @brief Destroys the Surface
+   */
+  virtual void DestroySurface() = 0;
+
+  /**
+   * @brief Replace the Surface
+   * @return true if context was lost
+   */
+  virtual bool ReplaceGraphicsSurface() = 0;
+
+  /**
+   * @brief Resizes the underlying surface.
+   * @param[in] The dimensions of the new position
+   */
+  virtual void MoveResize( Dali::PositionSize positionSize ) = 0;
+
+  /**
+   * @brief Called when Render thread has started
+   */
+  virtual void StartRender() = 0;
+
+  /**
+   * @brief Invoked by render thread before Core::Render
+   * If the operation fails, then Core::Render should not be called until there is
+   * a surface to render onto.
+   * @param[in] resizingSurface True if the surface is being resized
+   * @return True if the operation is successful, False if the operation failed
+   */
+  virtual bool PreRender( bool resizingSurface ) = 0;
+
+  /**
+   * @brief Invoked by render thread after Core::Render
+   * @param[in] renderToFbo True if render to FBO.
+   * @param[in] replacingSurface True if the surface is being replaced.
+   * @param[in] resizingSurface True if the surface is being resized.
+   */
+  virtual void PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface ) = 0;
+
+  /**
+   * @brief Invoked by render thread when the thread should be stop
+   */
+  virtual void StopRender() = 0;
+
+  /**
+   * @brief Invoked by Event Thread when the compositor lock should be released and rendering should resume.
+   */
+  virtual void ReleaseLock() = 0;
+
+  /**
+   * @brief Gets the surface type
+   */
+  virtual RenderSurface::Type GetSurfaceType() = 0;
+
+  /**
+   * @brief Makes the graphics context current
+   */
+  virtual void MakeContextCurrent() = 0;
+
+  /**
+   * @brief Gets whether the depth buffer is required
+   * @return TRUE if the depth buffer is required
+   */
+  virtual Integration::DepthBufferAvailable GetDepthBufferRequired() = 0;
+
+  /**
+   * @brief Gets whether the stencil buffer is required
+   * @return TRUE if the stencil buffer is required
+   */
+  virtual Integration::StencilBufferAvailable GetStencilBufferRequired() = 0;
+
+  /**
+   * @brief Sets the background color of the surface.
+   * @param[in] color The new background color
+   */
+  virtual void SetBackgroundColor(Vector4 color) = 0;
+
+  /**
+   * @brief Gets the background color of the surface.
+   * @return The background color
+   */
+  virtual Vector4 GetBackgroundColor() = 0;
+
+private:
+
+  /**
+   * @brief Undefined copy constructor. RenderSurface cannot be copied
+   */
+  RenderSurface( const RenderSurface& rhs ) = delete;
+
+  /**
+   * @brief Undefined assignment operator. RenderSurface cannot be copied
+   */
+  RenderSurface& operator=( const RenderSurface& rhs ) = delete;
+};
+
+} // namespace Integration
+
+} // namespace Dali
+
+#endif // DALI_RENDER_SURFACE_H
diff --git a/dali/integration-api/scene.cpp b/dali/integration-api/scene.cpp
new file mode 100644 (file)
index 0000000..717132c
--- /dev/null
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2019 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 <dali/integration-api/scene.h>
+
+// INTERNAL INCLUDES
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/internal/event/common/scene-impl.h>
+
+namespace Dali
+{
+
+namespace Integration
+{
+
+Scene Scene::New( Size size )
+{
+  Internal::ScenePtr internal = Internal::Scene::New( size );
+  return Scene(internal.Get());
+}
+
+Scene Scene::DownCast( BaseHandle handle )
+{
+  return Scene( dynamic_cast<Dali::Internal::Scene*>( handle.GetObjectPtr()) );
+}
+
+Scene::Scene()
+{
+}
+
+Scene::~Scene()
+{
+}
+
+Scene::Scene( const Scene& handle )
+:BaseHandle(handle)
+{
+}
+
+Scene::Scene( Internal::Scene* internal )
+: BaseHandle(internal)
+{
+}
+
+Scene& Scene::operator=( const Scene& rhs )
+{
+  BaseHandle::operator=(rhs);
+  return *this;
+}
+
+void Scene::Add( Actor& actor )
+{
+  GetImplementation(*this).Add( GetImplementation(actor) );
+}
+
+void Scene::Remove( Actor& actor )
+{
+  GetImplementation(*this).Remove( GetImplementation(actor) );
+}
+
+Size Scene::GetSize() const
+{
+  return GetImplementation(*this).GetSize();
+}
+
+void Scene::SetDpi( Vector2 dpi )
+{
+  GetImplementation(*this).SetDpi( dpi );
+}
+
+Vector2 Scene::GetDpi() const
+{
+  return GetImplementation(*this).GetDpi();
+}
+
+RenderTaskList Scene::GetRenderTaskList() const
+{
+  return RenderTaskList( &GetImplementation(*this).GetRenderTaskList() );
+}
+
+Layer Scene::GetRootLayer() const
+{
+  return GetImplementation(*this).GetRootLayer();
+}
+
+uint32_t Scene::GetLayerCount() const
+{
+  return GetImplementation(*this).GetLayerCount();
+}
+
+Layer Scene::GetLayer( uint32_t depth ) const
+{
+  return GetImplementation(*this).GetLayer( depth );
+}
+
+void Scene::SetSurface( Integration::RenderSurface& surface )
+{
+  GetImplementation(*this).SetSurface( surface );
+}
+
+} // Integration
+
+} // Dali
diff --git a/dali/integration-api/scene.h b/dali/integration-api/scene.h
new file mode 100644 (file)
index 0000000..83519b6
--- /dev/null
@@ -0,0 +1,195 @@
+#ifndef DALI_SCENE_H
+#define DALI_SCENE_H
+
+/*
+ * Copyright (c) 2019 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 <dali/public-api/object/handle.h>
+#include <dali/public-api/math/vector2.h>
+
+namespace Dali
+{
+
+class Actor;
+class Layer;
+class RenderTaskList;
+
+namespace Internal DALI_INTERNAL
+{
+  class Scene;
+}
+
+namespace Integration
+{
+
+class RenderSurface;
+
+/**
+ * @brief
+ *
+ * Scene creates a "world" that can be bound to a surface for rendering.
+ *
+ */
+class DALI_CORE_API Scene : public BaseHandle
+{
+public:
+
+  /**
+   * @brief Create an initialized Scene handle.
+   *
+   * @param[in] size The size of the scene in pixels as a Vector
+   *
+   * @return a handle to a newly allocated Dali resource.
+   */
+  static Scene New( Size size );
+
+  /**
+   * @brief Downcast an Object handle to Scene handle.
+   *
+   * If handle points to a Scene object the downcast produces
+   * valid handle. If not the returned handle is left uninitialized.
+   * @param[in] handle to An object
+   * @return handle to a Scene object or an uninitialized handle
+   */
+  static Scene DownCast( BaseHandle handle );
+
+  /**
+   * @brief Create an uninitialized Scene handle.
+   *
+   * This can be initialized with Scene::New(). Calling member
+   * functions with an uninitialized Dali::Object is not allowed.
+   */
+  Scene();
+
+  /**
+   * @brief Destructor
+   *
+   * This is non-virtual since derived Handle types must not contain data or virtual methods.
+   */
+  ~Scene();
+
+  /**
+   * @brief This copy constructor is required for (smart) pointer semantics.
+   *
+   * @param [in] handle A reference to the copied handle
+   */
+  Scene(const Scene& handle);
+
+  /**
+   * @brief This assignment operator is required for (smart) pointer semantics.
+   *
+   * @param [in] rhs  A reference to the copied handle
+   * @return A reference to this
+   */
+  Scene& operator=(const Scene& rhs);
+
+  /**
+   * @brief Adds a child Actor to the Scene.
+   *
+   * 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 Scene.
+   *
+   * The child will be unreferenced.
+   * @param[in] actor The child
+   * @pre The actor has been added to the stage.
+   */
+  void Remove(Actor& actor);
+
+  /**
+   * @brief Returns the size of the Scene in pixels as a Vector.
+   *
+   * The x component will be the width of the Scene in pixels.
+   * The y component will be the height of the Scene in pixels.
+   *
+   * @return The size of the Scene as a Vector
+   */
+  Size GetSize() const;
+
+  /**
+   * Sets horizontal and vertical pixels per inch value that is used by the display
+   * @param[in] dpi Horizontal and vertical dpi value
+   */
+  void SetDpi( Vector2 dpi );
+
+  /**
+   * @brief Retrieves the DPI of the display device to which the scene is connected.
+   *
+   * @return The horizontal and vertical DPI
+   */
+  Vector2 GetDpi() const;
+
+  /**
+   * @brief Retrieves the list of render-tasks.
+   *
+   * @return A valid handle to a RenderTaskList
+   */
+  Dali::RenderTaskList GetRenderTaskList() const;
+
+  /**
+   * @brief Returns the Scene's Root Layer.
+   *
+   * @return The root layer
+   */
+  Layer GetRootLayer() const;
+
+  /**
+   * @brief Queries the number of on-stage 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.
+   *
+   * @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 Binds the rendering surface to the scene
+   *
+   * @return The root layer
+   */
+  void SetSurface( Integration::RenderSurface& surface );
+
+public: // Not intended for application developers
+
+  /**
+   * @brief This constructor is used by Dali::New() methods.
+   *
+   * @param[in] scene A pointer to an internal Scene resource
+   */
+  explicit DALI_INTERNAL Scene(Internal::Scene* scene);
+};
+
+} // namespace Integration
+
+} // namespace Dali
+
+#endif // DALI_SCENE_H
index 38cfe06..47d1722 100644 (file)
@@ -36,6 +36,7 @@ SET(SOURCES ${SOURCES}
   ${CMAKE_CURRENT_SOURCE_DIR}/event/common/property-notification-impl.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/event/common/property-notification-manager.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/event/common/property-helper.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/event/common/scene-impl.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/event/common/stage-impl.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/event/common/thread-local-storage.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/event/common/type-info-impl.cpp
@@ -98,7 +99,8 @@ SET(SOURCES ${SOURCES}
   ${CMAKE_CURRENT_SOURCE_DIR}/render/gl-resources/gl-call-debug.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/render/gl-resources/gpu-buffer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/render/queue/render-queue.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/render/renderers/render-frame-buffer.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/render/renderers/render-texture-frame-buffer.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/render/renderers/render-surface-frame-buffer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/render/renderers/render-geometry.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/render/renderers/render-property-buffer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/render/renderers/render-renderer.cpp
index 7d6f523..4ddbc04 100644 (file)
@@ -26,6 +26,7 @@
 #include <dali/integration-api/platform-abstraction.h>
 #include <dali/integration-api/processor-interface.h>
 #include <dali/integration-api/render-controller.h>
+#include <dali/integration-api/render-surface.h>
 
 #include <dali/internal/event/actors/actor-impl.h>
 #include <dali/internal/event/animation/animation-playlist.h>
@@ -33,6 +34,7 @@
 #include <dali/internal/event/common/property-notification-manager.h>
 #include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/event/common/thread-local-storage.h>
+#include <dali/internal/event/common/event-thread-services.h>
 #include <dali/internal/event/common/type-registry-impl.h>
 #include <dali/internal/event/effects/shader-factory.h>
 #include <dali/internal/event/events/event-processor.h>
@@ -89,7 +91,8 @@ Core::Core( RenderController& renderController,
             Integration::StencilBufferAvailable stencilBufferAvailable )
 : mRenderController( renderController ),
   mPlatform(platform),
-  mProcessingEvent(false)
+  mProcessingEvent(false),
+  mForceNextUpdate( false )
 {
   // Create the thread local storage
   CreateThreadLocalStorage();
@@ -122,13 +125,13 @@ Core::Core( RenderController& renderController,
 
   mRenderManager->SetShaderSaver( *mUpdateManager );
 
-  mStage = IntrusivePtr<Stage>( Stage::New( *mAnimationPlaylist, *mPropertyNotificationManager, *mUpdateManager, *mNotificationManager, mRenderController ) );
+  mObjectRegistry = ObjectRegistry::New();
+
+  mStage = IntrusivePtr<Stage>( Stage::New( *mUpdateManager ) );
 
   // This must be called after stage is created but before stage initialization
   mRelayoutController = IntrusivePtr< RelayoutController >( new RelayoutController( mRenderController ) );
 
-  mStage->Initialize( renderToFboEnabled == Integration::RenderToFrameBuffer::TRUE );
-
   mGestureEventProcessor = new GestureEventProcessor( *mStage, *mUpdateManager, gestureManager, mRenderController );
   mEventProcessor = new EventProcessor( *mStage, *mNotificationManager, *mGestureEventProcessor );
 
@@ -154,17 +157,21 @@ Core::~Core()
     delete tls;
   }
 
+  mObjectRegistry.Reset();
+
   // Stop relayout requests being raised on stage destruction
   mRelayoutController.Reset();
 
-  // Clean-up stage - remove default camera and root layer
-  mStage->Uninitialize();
-
   // remove (last?) reference to stage
   mStage.Reset();
 
 }
 
+void Core::Initialize()
+{
+  mStage->Initialize( *mScenes[0] );
+}
+
 Integration::ContextNotifierInterface* Core::GetContextNotifier()
 {
   return mStage.Get();
@@ -187,27 +194,15 @@ void Core::ContextDestroyed()
   mRenderManager->ContextDestroyed();
 }
 
-void Core::SurfaceResized( uint32_t width, uint32_t height )
+void Core::SurfaceResized( Integration::RenderSurface* surface )
 {
-  mStage->SurfaceResized( static_cast<float>( width ), static_cast<float>( height ) );
-
-  // The stage-size may be less than surface-size (reduced by top-margin)
-  Vector2 size = mStage->GetSize();
-  mRelayoutController->SetStageSize( static_cast<uint32_t>( size.width ), static_cast<uint32_t>( size.height ) ); // values get truncated
-}
-
-void Core::SetTopMargin( uint32_t margin )
-{
-  mStage->SetTopMargin( margin );
-
-  // The stage-size may be less than surface-size (reduced by top-margin)
-  Vector2 size = mStage->GetSize();
-  mRelayoutController->SetStageSize( static_cast<uint32_t>( size.width ), static_cast<uint32_t>( size.height ) ); // values get truncated
-}
-
-void Core::SetDpi( uint32_t dpiHorizontal, uint32_t dpiVertical )
-{
-  mStage->SetDpi( Vector2( static_cast<float>( dpiHorizontal ), static_cast<float>( dpiVertical ) ) );
+  for( auto iter = mScenes.begin(); iter != mScenes.end(); ++iter )
+  {
+    if( (*iter)->GetSurface() == surface )
+    {
+      (*iter)->SetSurface( *surface );
+    }
+  }
 }
 
 void Core::Update( float elapsedSeconds, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds, Integration::UpdateStatus& status, bool renderToFboEnabled, bool isRenderingToFbo )
@@ -244,6 +239,12 @@ void Core::SceneCreated()
   mStage->EmitSceneCreatedSignal();
 
   mRelayoutController->OnApplicationSceneCreated();
+
+  for( auto iter = mScenes.begin(); iter != mScenes.end(); ++iter )
+  {
+    Dali::Actor sceneRootLayer = (*iter)->GetRootLayer();
+    mRelayoutController->RequestRelayoutTree( sceneRootLayer );
+  }
 }
 
 void Core::QueueEvent( const Integration::Event& event )
@@ -282,7 +283,10 @@ void Core::ProcessEvents()
 
 
   // Rebuild depth tree after event processing has finished
-  mStage->RebuildDepthTree();
+  for( auto iter = mScenes.begin(); iter != mScenes.end(); ++iter )
+  {
+    (*iter)->RebuildDepthTree();
+  }
 
   // Flush any queued messages for the update-thread
   const bool messagesToProcess = mUpdateManager->FlushQueue();
@@ -290,7 +294,7 @@ void Core::ProcessEvents()
   // Check if the touch or gestures require updates.
   const bool gestureNeedsUpdate = mGestureEventProcessor->NeedsUpdate();
   // Check if the next update is forced.
-  const bool forceUpdate = mStage->IsNextUpdateForced();
+  const bool forceUpdate = IsNextUpdateForced();
 
   if( messagesToProcess || gestureNeedsUpdate || forceUpdate )
   {
@@ -377,6 +381,40 @@ RelayoutController& Core::GetRelayoutController()
   return *(mRelayoutController.Get());
 }
 
+ObjectRegistry& Core::GetObjectRegistry() const
+{
+  return *(mObjectRegistry.Get());
+}
+
+EventThreadServices& Core::GetEventThreadServices()
+{
+  return *this;
+}
+
+PropertyNotificationManager& Core::GetPropertyNotificationManager() const
+{
+  return *(mPropertyNotificationManager);
+}
+
+AnimationPlaylist& Core::GetAnimationPlaylist() const
+{
+  return *(mAnimationPlaylist);
+}
+
+void Core::AddScene( Scene* scene )
+{
+  mScenes.push_back( scene );
+}
+
+void Core::RemoveScene( Scene* scene )
+{
+  auto iter = std::find( mScenes.begin(), mScenes.end(), scene );
+  if( iter != mScenes.end() )
+  {
+    mScenes.erase( iter );
+  }
+}
+
 void Core::CreateThreadLocalStorage()
 {
   // a pointer to the ThreadLocalStorage object will be stored in TLS
@@ -384,6 +422,45 @@ void Core::CreateThreadLocalStorage()
   new ThreadLocalStorage(this);
 }
 
+void Core::RegisterObject( Dali::BaseObject* object )
+{
+  mObjectRegistry = &ThreadLocalStorage::Get().GetObjectRegistry();
+  mObjectRegistry->RegisterObject( object );
+}
+
+void Core::UnregisterObject( Dali::BaseObject* object )
+{
+  mObjectRegistry = &ThreadLocalStorage::Get().GetObjectRegistry();
+  mObjectRegistry->UnregisterObject( object );
+}
+
+Integration::RenderController& Core::GetRenderController()
+{
+  return mRenderController;
+}
+
+uint32_t* Core::ReserveMessageSlot( uint32_t size, bool updateScene )
+{
+  return mUpdateManager->ReserveMessageSlot( size, updateScene );
+}
+
+BufferIndex Core::GetEventBufferIndex() const
+{
+  return mUpdateManager->GetEventBufferIndex();
+}
+
+void Core::ForceNextUpdate()
+{
+  mForceNextUpdate = true;
+}
+
+bool Core::IsNextUpdateForced()
+{
+  bool nextUpdateForced = mForceNextUpdate;
+  mForceNextUpdate = false;
+  return nextUpdateForced;
+}
+
 } // namespace Internal
 
 } // namespace Dali
index d4aa55f..bd94c43 100644 (file)
 #include <dali/integration-api/context-notifier.h>
 #include <dali/integration-api/core-enumerations.h>
 #include <dali/internal/common/owner-pointer.h>
+#include <dali/devel-api/common/owner-container.h>
 #include <dali/internal/event/animation/animation-playlist-declarations.h>
 #include <dali/internal/event/common/stage-def.h>
 #include <dali/integration-api/resource-policies.h>
+#include <dali/internal/event/common/scene-impl.h>
+#include <dali/internal/event/common/object-registry-impl.h>
 
 namespace Dali
 {
@@ -41,6 +44,7 @@ class GlAbstraction;
 class GlSyncAbstraction;
 class UpdateStatus;
 class RenderStatus;
+class RenderSurface;
 struct Event;
 struct TouchData;
 }
@@ -56,6 +60,7 @@ class GestureEventProcessor;
 class ShaderFactory;
 class TouchResampler;
 class RelayoutController;
+class EventThreadServices;
 
 namespace SceneGraph
 {
@@ -68,7 +73,7 @@ class RenderTaskProcessor;
 /**
  * Internal class for Dali::Integration::Core
  */
-class Core
+class Core : public EventThreadServices
 {
 public:
 
@@ -91,6 +96,11 @@ public:
   ~Core();
 
   /**
+   * @copydoc Dali::Integration::Core::Initialize()
+   */
+  void Initialize();
+
+  /**
    * @copydoc Dali::Integration::Core::GetContextNotifier()
    */
   Integration::ContextNotifierInterface* GetContextNotifier();
@@ -111,19 +121,9 @@ public:
   void RecoverFromContextLoss();
 
   /**
-   * @copydoc Dali::Integration::Core::SurfaceResized(uint32_t, uint32_t)
-   */
-  void SurfaceResized(uint32_t width, uint32_t height);
-
-  /**
-   * @copydoc Dali::Integration::Core::SetTopMargin( uint32_t margin )
+   * @copydoc Dali::Integration::Core::SurfaceResized(Integration::RenderSurface*)
    */
-  void SetTopMargin( uint32_t margin );
-
-  /**
-   * @copydoc Dali::Integration::Core::SetDpi(uint32_t, uint32_t)
-   */
-  void SetDpi(uint32_t dpiHorizontal, uint32_t dpiVertical);
+  void SurfaceResized( Integration::RenderSurface* surface );
 
   /**
    * @copydoc Dali::Integration::Core::SetMinimumFrameTimeInterval(uint32_t)
@@ -170,6 +170,58 @@ public:
    */
   void UnregisterProcessor( Dali::Integration::Processor& processor );
 
+  /**
+   * @copydoc Dali::Internal::ThreadLocalStorage::AddScene()
+   */
+  void AddScene( Scene* scene );
+
+  /**
+   * @copydoc Dali::Internal::ThreadLocalStorage::RemoveScene()
+   */
+  void RemoveScene( Scene* scene );
+
+public: // Implementation of EventThreadServices
+
+  /**
+   * @copydoc EventThreadServices::RegisterObject
+   */
+  void RegisterObject( BaseObject* object) override;
+
+  /**
+   * @copydoc EventThreadServices::UnregisterObject
+   */
+  void UnregisterObject( BaseObject* object) override;
+
+  /**
+   * @copydoc EventThreadServices::GetUpdateManager
+   */
+  SceneGraph::UpdateManager& GetUpdateManager() override;
+
+  /**
+   * @copydoc EventThreadServices::GetRenderController
+   */
+  Integration::RenderController& GetRenderController() override;
+
+  /**
+   * @copydoc EventThreadServices::ReserveMessageSlot
+   */
+  uint32_t* ReserveMessageSlot( uint32_t size, bool updateScene ) override;
+
+  /**
+   * @copydoc EventThreadServices::GetEventBufferIndex
+   */
+  BufferIndex GetEventBufferIndex() const override;
+
+  /**
+   * @copydoc EventThreadServices::ForceNextUpdate
+   */
+  void ForceNextUpdate() override;
+
+  /**
+   * @copydoc EventThreadServices::IsNextUpdateForced
+   */
+  bool IsNextUpdateForced() override;
+
 private:
   /**
    * Run each registered processor
@@ -191,12 +243,6 @@ private:
   Integration::PlatformAbstraction& GetPlatform();
 
   /**
-   * Returns the update manager.
-   * @return A reference to the update manager.
-   */
-  SceneGraph::UpdateManager& GetUpdateManager();
-
-  /**
    * Returns the render manager.
    * @return A reference to the render manager.
    */
@@ -226,13 +272,37 @@ private:
    */
   RelayoutController& GetRelayoutController();
 
+  /**
+   * @brief Gets the Object registry.
+   * @return A reference to the object registry
+   */
+  ObjectRegistry& GetObjectRegistry() const;
+
+  /**
+   * @brief Gets the event thread services.
+   * @return A reference to the event thread services
+   */
+  EventThreadServices& GetEventThreadServices();
+
+  /**
+   * @brief Gets the property notification manager.
+   * @return A reference to the property notification manager
+   */
+  PropertyNotificationManager& GetPropertyNotificationManager() const;
+
+  /**
+   * @brief Gets the animation play list.
+   * @return A reference to the animation play list
+   */
+  AnimationPlaylist& GetAnimationPlaylist() const;
+
 private:
 
   /**
    * Undefined copy and assignment operators
    */
-  Core(const Core& core);  // No definition
-  Core& operator=(const Core& core);  // No definition
+  Core(const Core& core) = delete;  // No definition
+  Core& operator=(const Core& core) = delete;  // No definition
 
   /**
    * Create Thread local storage
@@ -248,7 +318,6 @@ private:
   AnimationPlaylistOwner                    mAnimationPlaylist;           ///< For 'Fire and forget' animation support
   OwnerPointer<PropertyNotificationManager> mPropertyNotificationManager; ///< For safe signal emmision of property changed notifications
   IntrusivePtr< RelayoutController >        mRelayoutController;          ///< Size negotiation relayout controller
-  bool                                      mProcessingEvent  : 1;        ///< True during ProcessEvents()
 
   OwnerPointer<SceneGraph::RenderTaskProcessor> mRenderTaskProcessor;         ///< Handles the processing of render tasks
   OwnerPointer<SceneGraph::RenderManager>       mRenderManager;               ///< Render manager
@@ -260,6 +329,14 @@ private:
   OwnerPointer<EventProcessor>                  mEventProcessor;              ///< The event processor
   Dali::Vector<Integration::Processor*>         mProcessors;                  ///< Registered processors (not owned)
 
+  std::vector<ScenePtr>                         mScenes;                      ///< A container of scenes that bound to a surface for rendering, owned by Core
+
+  // The object registry
+  ObjectRegistryPtr                             mObjectRegistry;
+
+  bool                                      mProcessingEvent  : 1;        ///< True during ProcessEvents()
+  bool                                      mForceNextUpdate:1;           ///< True if the next rendering is really required.
+
   friend class ThreadLocalStorage;
 
 };
index d2b33c9..a3504e5 100644 (file)
@@ -42,6 +42,8 @@
 #include <dali/internal/event/common/property-helper.h>
 #include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/event/common/type-info-impl.h>
+#include <dali/internal/event/common/scene-impl.h>
+#include <dali/internal/event/common/thread-local-storage.h>
 #include <dali/internal/event/animation/constraint-impl.h>
 #include <dali/internal/event/common/projection.h>
 #include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
@@ -412,7 +414,8 @@ const SceneGraph::Node* Actor::CreateNode()
   // create node. Nodes are owned by the update manager
   SceneGraph::Node* node = SceneGraph::Node::New();
   OwnerPointer< SceneGraph::Node > transferOwnership( node );
-  AddNodeMessage( Stage::GetCurrent()->GetUpdateManager(), transferOwnership );
+  Internal::ThreadLocalStorage* tls = Internal::ThreadLocalStorage::GetInternal();
+  AddNodeMessage( tls->GetUpdateManager(), transferOwnership );
 
   return node;
 }
@@ -792,20 +795,19 @@ const Vector3& Actor::GetCurrentWorldPosition() const
 
 const Vector2 Actor::GetCurrentScreenPosition() const
 {
-  StagePtr stage = Stage::GetCurrent();
-  if( stage && OnStage() )
+  if( mScene && OnStage() )
   {
     Vector3 worldPosition =  GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
-    Vector3 cameraPosition = stage->GetDefaultCameraActor().GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
+    Vector3 cameraPosition = mScene->GetDefaultCameraActor().GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
     worldPosition -= cameraPosition;
 
     Vector3 actorSize = GetCurrentSize() * GetCurrentWorldScale();
-    Vector2 halfStageSize( stage->GetSize() * 0.5f ); // World position origin is center of stage
+    Vector2 halfSceneSize( mScene->GetSize() * 0.5f ); // World position origin is center of scene
     Vector3 halfActorSize( actorSize * 0.5f );
     Vector3 anchorPointOffSet = halfActorSize - actorSize * ( mPositionUsesAnchorPoint ? GetCurrentAnchorPoint() : AnchorPoint::TOP_LEFT );
 
-    return Vector2( halfStageSize.width + worldPosition.x - anchorPointOffSet.x,
-                    halfStageSize.height + worldPosition.y - anchorPointOffSet.y );
+    return Vector2( halfSceneSize.width + worldPosition.x - anchorPointOffSet.x,
+                    halfSceneSize.height + worldPosition.y - anchorPointOffSet.y );
   }
 
   return Vector2::ZERO;
@@ -1499,10 +1501,9 @@ DrawMode::Type Actor::GetDrawMode() const
 bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
 {
   // only valid when on-stage
-  StagePtr stage = Stage::GetCurrent();
-  if( stage && OnStage() )
+  if( mScene && OnStage() )
   {
-    const RenderTaskList& taskList = stage->GetRenderTaskList();
+    const RenderTaskList& taskList = mScene->GetRenderTaskList();
 
     Vector2 converted( screenX, screenY );
 
@@ -2002,6 +2003,7 @@ bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra
 
 Actor::Actor( DerivedType derivedType, const SceneGraph::Node& node )
 : Object( &node ),
+  mScene( nullptr ),
   mParent( NULL ),
   mChildren( NULL ),
   mRenderers( NULL ),
@@ -2100,10 +2102,9 @@ void Actor::ConnectToStage( uint32_t parentDepth )
   // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
   ActorContainer connectionList;
 
-  StagePtr stage = Stage::GetCurrent();
-  if( stage )
+  if( mScene )
   {
-    stage->RequestRebuildDepthTree();
+    mScene->RequestRebuildDepthTree();
   }
 
   // This stage is atomic i.e. not interrupted by user callbacks.
@@ -2140,6 +2141,7 @@ void Actor::RecursiveConnectToStage( ActorContainer& connectionList, uint32_t de
     ActorConstIter endIter = mChildren->end();
     for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
     {
+      (*iter)->SetScene( *mScene );
       (*iter)->RecursiveConnectToStage( connectionList, depth + 1 );
     }
   }
@@ -2194,10 +2196,9 @@ void Actor::DisconnectFromStage()
   // It protects us when the Actor hierachy is modified during OnStageDisconnectionExternal callbacks.
   ActorContainer disconnectionList;
 
-  StagePtr stage = Stage::GetCurrent();
-  if( stage )
+  if( mScene )
   {
-    stage->RequestRebuildDepthTree();
+    mScene->RequestRebuildDepthTree();
   }
 
   // This stage is atomic i.e. not interrupted by user callbacks
@@ -3410,6 +3411,8 @@ void Actor::SetParent( Actor* parent )
 
     mParent = parent;
 
+    mScene = parent->mScene;
+
     if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
          parent->OnStage() )
     {
@@ -3435,6 +3438,8 @@ void Actor::SetParent( Actor* parent )
       // Instruct each actor to discard pointers to the scene-graph
       DisconnectFromStage();
     }
+
+    mScene = nullptr;
   }
 }
 
@@ -4782,10 +4787,9 @@ void Actor::RequestRebuildDepthTree()
 {
   if( mIsOnStage )
   {
-    StagePtr stage = Stage::GetCurrent();
-    if( stage )
+    if( mScene )
     {
-      stage->RequestRebuildDepthTree();
+      mScene->RequestRebuildDepthTree();
     }
   }
 }
@@ -4969,6 +4973,16 @@ void Actor::LowerBelow( Internal::Actor& target )
   }
 }
 
+void Actor::SetScene( Scene& scene )
+{
+  mScene = &scene;
+}
+
+Scene& Actor::GetScene() const
+{
+  return *mScene;
+}
+
 void Actor::SetInheritLayoutDirection( bool inherit )
 {
   if( mInheritLayoutDirection != inherit )
index c98701a..9a27d81 100755 (executable)
@@ -54,6 +54,7 @@ class ActorGestureData;
 class Animation;
 class RenderTask;
 class Renderer;
+class Scene;
 
 typedef std::vector< ActorPtr > ActorContainer;
 typedef ActorContainer::iterator ActorIter;
@@ -1705,6 +1706,20 @@ public:
    */
   void LowerBelow( Internal::Actor& target );
 
+public:
+
+  /**
+   * Sets the scene which this actor is added to.
+   * @param[in] scene The scene
+   */
+  void SetScene( Scene& scene );
+
+  /**
+   * Gets the scene which this actor is added to.
+   * @return The scene
+   */
+  Scene& GetScene() const;
+
 private:
 
   struct SendMessage
@@ -1913,6 +1928,8 @@ private:
 
 protected:
 
+  Scene* mScene;                  ///< The scene the actor is added to
+
   Actor* mParent;                 ///< Each actor (except the root) can have one parent
   ActorContainer* mChildren;      ///< Container of referenced actors, lazily initialized
   RendererContainer* mRenderers;   ///< Renderer container
index 3d21383..ae63c9f 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
 #include <dali/integration-api/debug.h>
 #include <dali/internal/event/common/property-helper.h>
 #include <dali/internal/event/common/stage-impl.h>
+#include <dali/internal/event/common/scene-impl.h>
 #include <dali/internal/event/render-tasks/render-task-impl.h>
 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
 #include <dali/internal/event/common/projection.h>
+#include <dali/internal/event/common/thread-local-storage.h>
 #include <dali/internal/update/render-tasks/scene-graph-camera.h>
 
 namespace Dali
@@ -368,30 +370,18 @@ bool CameraActor::GetInvertYAxis() const
   return mInvertYAxis;
 }
 
-void CameraActor::SetPerspectiveProjection( const Size& size, const Vector2& stereoBias /* = Vector2::ZERO */ )
+void CameraActor::SetPerspectiveProjection( const Size& size )
 {
-  float width = size.width;
-  float height = size.height;
-
-  if( Size::ZERO == size )
-  {
-    StagePtr stage = Stage::GetCurrent();
-    if( stage )
-    {
-      const Size& stageSize = stage->GetSize();
-
-      width = stageSize.width;
-      height = stageSize.height;
-    }
-  }
-
-  if( ( width < Math::MACHINE_EPSILON_1000 ) || ( height < Math::MACHINE_EPSILON_1000 ) )
+  if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) )
   {
-    // On the stage initialization this method is called but the size has not been set.
-    // There is no point to set any value if width or height is zero.
+    // Not allowed to set the canvas size to be 0.
+    DALI_LOG_ERROR( "Canvas size can not be 0\n" );
     return;
   }
 
+  float width = size.width;
+  float height = size.height;
+
   float nearClippingPlane;
   float farClippingPlane;
   float cameraZ;
index dc017f8..1694ba3 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_INTERNAL_CAMERA_ACTOR_H
 
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -154,9 +154,8 @@ public:
 
   /**
    * @copydoc Dali::CameraActor::SetPerspectiveProjection()
-   * @param[in] stereoBias The frustum horizontal and vertical offset for stereoscopic cameras
    */
-  void SetPerspectiveProjection( const Size& size, const Vector2& stereoBias = Vector2::ZERO );
+  void SetPerspectiveProjection( const Size& size );
 
   /**
    * @copydoc Dali::CameraActor::SetOrthographicProjection(const Vector2& size);
index 033ee7b..8040640 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -26,7 +26,8 @@
 #include <dali/public-api/object/type-registry.h>
 #include <dali/internal/event/actors/layer-list.h>
 #include <dali/internal/event/common/property-helper.h>
-#include <dali/internal/event/common/stage-impl.h>
+#include <dali/internal/event/common/scene-impl.h>
+#include <dali/internal/event/common/event-thread-services.h>
 
 using Dali::Internal::SceneGraph::UpdateManager;
 
@@ -87,7 +88,7 @@ LayerPtr Layer::New()
   // create node, nodes are owned by UpdateManager
   SceneGraph::Layer* layerNode = SceneGraph::Layer::New();
   OwnerPointer< SceneGraph::Node > transferOwnership( layerNode );
-  AddNodeMessage( Stage::GetCurrent()->GetUpdateManager(), transferOwnership );
+  AddNodeMessage( EventThreadServices::Get().GetUpdateManager(), transferOwnership );
   LayerPtr layer( new Layer( Actor::LAYER, *layerNode ) );
 
   // Second-phase construction
@@ -257,10 +258,9 @@ void Layer::SetClippingBox(int x, int y, int width, int height)
     // Convert mClippingBox to GL based coordinates (from bottom-left)
     ClippingBox clippingBox( mClippingBox );
 
-    StagePtr stage = Stage::GetCurrent();
-    if( stage )
+    if( mScene )
     {
-      clippingBox.y = static_cast<int32_t>( stage->GetSize().height ) - clippingBox.y - clippingBox.height;
+      clippingBox.y = static_cast<int32_t>( mScene->GetSize().height ) - clippingBox.y - clippingBox.height;
 
       // layerNode is being used in a separate thread; queue a message to set the value
       SetClippingBoxMessage( GetEventThreadServices(), GetSceneLayerOnStage(), clippingBox );
index 587a96a..876ec29 100644 (file)
@@ -140,29 +140,19 @@ void ValidateParameters( Property::Type propertyType, Property::Type destination
 
 AnimationPtr Animation::New(float durationSeconds)
 {
-  Stage* stage = Stage::GetCurrent();
-
-  if( stage )
+  if( durationSeconds < 0.0f )
   {
-    AnimationPlaylist& playlist = stage->GetAnimationPlaylist();
-
-    if( durationSeconds < 0.0f )
-    {
-      DALI_LOG_WARNING("duration should be greater than 0.0f.\n");
-      durationSeconds = 0.0f;
-    }
+    DALI_LOG_WARNING("duration should be greater than 0.0f.\n");
+    durationSeconds = 0.0f;
+  }
 
-    AnimationPtr animation = new Animation( *stage, playlist, durationSeconds, DEFAULT_END_ACTION, DEFAULT_DISCONNECT_ACTION, DEFAULT_ALPHA_FUNCTION );
+  ThreadLocalStorage& tls = ThreadLocalStorage::Get();
+  AnimationPtr animation = new Animation( tls.GetEventThreadServices(), tls.GetAnimationPlaylist(), durationSeconds, DEFAULT_END_ACTION, DEFAULT_DISCONNECT_ACTION, DEFAULT_ALPHA_FUNCTION );
 
-    // Second-phase construction
-    animation->Initialize();
+  // Second-phase construction
+  animation->Initialize();
 
-    return animation;
-  }
-  else
-  {
-    return NULL;
-  }
+  return animation;
 }
 
 Animation::Animation( EventThreadServices& eventThreadServices, AnimationPlaylist& playlist, float durationSeconds, EndAction endAction, EndAction disconnectAction, AlphaFunction defaultAlpha )
index 8ebbd6e..c70b251 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -24,6 +24,7 @@
 #include <dali/internal/event/common/event-thread-services.h>
 #include <dali/internal/event/common/property-helper.h>
 #include <dali/internal/event/common/stage-impl.h>
+#include <dali/internal/update/animation/scene-graph-constraint-base.h>
 #include <dali/internal/update/common/animatable-property.h>
 #include <dali/internal/update/common/property-owner-messages.h>
 
@@ -54,7 +55,7 @@ inline void AddUnique( SceneGraph::PropertyOwnerContainer& propertyOwners, Scene
 } // unnamed namespace
 
 ConstraintBase::ConstraintBase( Object& object, Property::Index targetPropertyIndex, SourceContainer& sources )
-: mEventThreadServices( *Stage::GetCurrent() ),
+: mEventThreadServices( EventThreadServices::Get() ),
   mTargetObject( &object ),
   mSceneGraphConstraint( NULL ),
   mSources( sources ),
index 66e87e9..aa9e334 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -25,6 +25,11 @@ namespace Dali
 namespace Internal
 {
 
+EventThreadServices& EventThreadServices::Get()
+{
+  return ThreadLocalStorage::Get().GetEventThreadServices();
+}
+
 bool EventThreadServices::IsCoreRunning()
 {
   return ThreadLocalStorage::Created();
index 8089950..b6db047 100644 (file)
@@ -2,7 +2,7 @@
 #define __DALI_INTERNAL_EVENT_THREAD_SERVICES_H__
 
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -58,6 +58,12 @@ public:
   { }
 
   /**
+   * Get the EventThreadServices
+   * @return reference to the EventThreadServices
+   */
+  static EventThreadServices& Get();
+
+  /**
    * @brief Registers the object as created with the Object registry.
    *
    * @param[in] object to register
index 09e48c0..d6c5cea 100644 (file)
@@ -948,7 +948,7 @@ DevelHandle::PropertySetSignalType& Object::PropertySetSignal()
 }
 
 Object::Object( const SceneGraph::PropertyOwner* sceneObject )
-: mEventThreadServices( *Stage::GetCurrent() ),
+: mEventThreadServices( EventThreadServices::Get() ),
   mUpdateObject( sceneObject ),
   mTypeInfo( nullptr ),
   mConstraints( nullptr ),
index ecd9a69..c44df2c 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -20,7 +20,6 @@
 
 // INTERNAL INCLUDES
 #include <dali/public-api/rendering/property-buffer.h>
-#include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/update/manager/update-manager.h>
 
 namespace Dali
@@ -170,7 +169,7 @@ PropertyBuffer::~PropertyBuffer()
 }
 
 PropertyBuffer::PropertyBuffer()
-: mEventThreadServices( *Stage::GetCurrent() ),
+: mEventThreadServices( EventThreadServices::Get() ),
   mRenderObject( NULL ),
   mBufferFormatSize( 0 ),
   mSize( 0 )
index a261fa2..7e407ca 100644 (file)
@@ -46,21 +46,13 @@ PropertyNotificationPtr PropertyNotification::New(Property& target,
 
   UpdateManager& updateManager = tls.GetUpdateManager();
 
-  StagePtr stage = Stage::GetCurrent();
-  if( stage )
-  {
-    PropertyNotificationManager& propertyNotificationManager = stage->GetPropertyNotificationManager();
-    PropertyNotificationPtr propertyNotification = new PropertyNotification(updateManager,
-                                                                            propertyNotificationManager,
-                                                                            target,
-                                                                            componentIndex,
-                                                                            condition);
-    return propertyNotification;
-  }
-  else
-  {
-    return NULL;
-  }
+  PropertyNotificationManager& propertyNotificationManager = tls.GetPropertyNotificationManager();
+  PropertyNotificationPtr propertyNotification = new PropertyNotification(updateManager,
+                                                                          propertyNotificationManager,
+                                                                          target,
+                                                                          componentIndex,
+                                                                          condition);
+  return propertyNotification;
 }
 
 PropertyNotification::PropertyNotification( UpdateManager& updateManager,
diff --git a/dali/internal/event/common/scene-impl.cpp b/dali/internal/event/common/scene-impl.cpp
new file mode 100644 (file)
index 0000000..f68060e
--- /dev/null
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2019 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 <dali/internal/event/common/scene-impl.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/event/actors/layer-impl.h>
+#include <dali/internal/event/actors/layer-list.h>
+#include <dali/internal/event/actors/camera-actor-impl.h>
+#include <dali/internal/event/common/thread-local-storage.h>
+#include <dali/internal/event/render-tasks/render-task-list-impl.h>
+#include <dali/internal/event/render-tasks/render-task-impl.h>
+#include <dali/internal/event/common/object-registry-impl.h>
+#include <dali/internal/update/nodes/node.h>
+#include <dali/internal/update/manager/update-manager.h>
+#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/internal/event/rendering/frame-buffer-impl.h>
+#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
+
+using Dali::Internal::SceneGraph::Node;
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+namespace
+{
+
+const Vector4 DEFAULT_BACKGROUND_COLOR(0.0f, 0.0f, 0.0f, 1.0f); // Default background color
+
+} //Unnamed namespace
+
+ScenePtr Scene::New( Size size )
+{
+  ScenePtr scene = new Scene( size );
+
+  // Second-phase construction
+  scene->Initialize();
+
+  return scene;
+}
+
+Scene::Scene( Size size )
+: mSurface( nullptr ),
+  mSize( size ),
+  mSurfaceSize( Vector2::ZERO ),
+  mDpi( Vector2::ZERO ),
+  mDepthTreeDirty( false )
+{
+}
+
+Scene::~Scene()
+{
+  if( mDefaultCamera )
+  {
+    // its enough to release the handle so the object is released
+    // don't need to remove it from root actor as root actor will delete the object
+    mDefaultCamera.Reset();
+  }
+
+  if( mRootLayer )
+  {
+    // we are closing down so just delete the root, no point emit disconnect
+    // signals or send messages to update
+    mRootLayer.Reset();
+  }
+
+  if( mRenderTaskList )
+  {
+    mRenderTaskList.Reset();
+  }
+
+  if( ThreadLocalStorage::Created() )
+  {
+    ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
+    tls->RemoveScene( this );
+  }
+}
+
+void Scene::Initialize()
+{
+  ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
+
+  DALI_ASSERT_ALWAYS( tls && "Attempt to create scene before core exists!" );
+
+  tls->AddScene( this );
+
+  SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager();
+
+  // Create the ordered list of layers
+  mLayerList = LayerList::New( updateManager );
+
+  // The stage owns the default layer
+  mRootLayer = Layer::NewRoot( *mLayerList, updateManager );
+  mRootLayer->SetName("RootLayer");
+  mRootLayer->SetScene( *this );
+
+  // The root layer needs to have a fixed resize policy (as opposed to the default USE_NATURAL_SIZE).
+  // This stops actors parented to the stage having their relayout requests propagating
+  // up to the root layer, and down through other children unnecessarily.
+  mRootLayer->SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
+
+  // Create the default camera actor first; this is needed by the RenderTaskList
+  // The default camera attributes and position is such that children of the default layer,
+  // can be positioned at (0,0) and be at the top-left of the viewport.
+  mDefaultCamera = CameraActor::New( mSize );
+  mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
+  Add(*(mDefaultCamera.Get()));
+
+  // Create the list of render-tasks
+  mRenderTaskList = RenderTaskList::New();
+
+  // Create the default render-task
+  mRenderTaskList->CreateTask( mRootLayer.Get(), mDefaultCamera.Get() );
+}
+
+void Scene::Add(Actor& actor)
+{
+  mRootLayer->Add( actor );
+}
+
+void Scene::Remove(Actor& actor)
+{
+  mRootLayer->Remove( actor );
+}
+
+Size Scene::GetSize() const
+{
+  return mSize;
+}
+
+void Scene::SetDpi(Vector2 dpi)
+{
+  mDpi = dpi;
+}
+
+Vector2 Scene::GetDpi() const
+{
+  return mDpi;
+}
+
+RenderTaskList& Scene::GetRenderTaskList() const
+{
+  return *mRenderTaskList;
+}
+
+Dali::Layer Scene::GetRootLayer() const
+{
+  return Dali::Layer( mRootLayer.Get() );
+}
+
+LayerList& Scene::GetLayerList() const
+{
+  return *mLayerList;
+}
+
+uint32_t Scene::GetLayerCount() const
+{
+  return mLayerList->GetLayerCount();
+}
+
+Dali::Layer Scene::GetLayer( uint32_t depth ) const
+{
+  return Dali::Layer(mLayerList->GetLayer( depth ));
+}
+
+CameraActor& Scene::GetDefaultCameraActor()
+{
+  return *mDefaultCamera;
+}
+
+Actor& Scene::GetDefaultRootActor()
+{
+  return *mRootLayer;
+}
+
+void Scene::SetSurface( Integration::RenderSurface& surface )
+{
+  mSurface = &surface;
+  if ( mSurface )
+  {
+    mSurfaceSize.width = static_cast<float>( mSurface->GetPositionSize().width );
+    mSurfaceSize.height = static_cast<float>( mSurface->GetPositionSize().height );
+
+    mSize.width = mSurfaceSize.width;
+    mSize.height = mSurfaceSize.height;
+
+    // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
+    mDefaultCamera->SetPerspectiveProjection( mSurfaceSize );
+
+    mRootLayer->SetSize( mSize.width, mSize.height );
+
+    ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
+    SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager();
+    SetDefaultSurfaceRectMessage( updateManager, Rect<int32_t>( 0, 0, static_cast<int32_t>( mSurfaceSize.width ), static_cast<int32_t>( mSurfaceSize.height ) ) ); // truncated
+
+    RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask( 0u );
+
+    // if single render task to screen then set its viewport parameters
+    if( 1 == mRenderTaskList->GetTaskCount() )
+    {
+      if( !defaultRenderTask->GetTargetFrameBuffer() )
+      {
+        defaultRenderTask->SetViewport( Viewport( 0, 0, static_cast<int32_t>( mSurfaceSize.width ), static_cast<int32_t>( mSurfaceSize.height ) ) ); // truncated
+      }
+    }
+
+    mFrameBuffer = Dali::Internal::FrameBuffer::New( surface, Dali::FrameBuffer::Attachment::NONE );
+    defaultRenderTask->SetFrameBuffer( mFrameBuffer );
+  }
+}
+
+Integration::RenderSurface* Scene::GetSurface() const
+{
+  return mSurface;
+}
+
+void Scene::RequestRebuildDepthTree()
+{
+  mDepthTreeDirty = true;
+}
+
+void Scene::RebuildDepthTree()
+{
+  // If the depth tree needs rebuilding, do it in this frame only.
+  if( mDepthTreeDirty )
+  {
+    ActorPtr actor( mRootLayer.Get() );
+    actor->RebuildDepthTree();
+    mDepthTreeDirty = false;
+  }
+}
+
+void Scene::SetBackgroundColor(Vector4 color)
+{
+  if( mSurface )
+  {
+    mSurface->SetBackgroundColor( color );
+  }
+}
+
+Vector4 Scene::GetBackgroundColor() const
+{
+  return mSurface ? mSurface->GetBackgroundColor() : DEFAULT_BACKGROUND_COLOR;
+}
+
+
+} // Internal
+
+} // Dali
diff --git a/dali/internal/event/common/scene-impl.h b/dali/internal/event/common/scene-impl.h
new file mode 100644 (file)
index 0000000..1140b6a
--- /dev/null
@@ -0,0 +1,224 @@
+#ifndef DALI_INTERNAL_SCENE_H
+#define DALI_INTERNAL_SCENE_H
+
+/*
+ * Copyright (c) 2019 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 <dali/integration-api/scene.h>
+#include <dali/public-api/math/vector2.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/integration-api/render-surface.h>
+#include <dali/internal/common/owner-pointer.h>
+#include <dali/internal/event/actors/layer-impl.h>
+#include <dali/internal/event/render-tasks/render-task-defaults.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+class Layer;
+class LayerList;
+class CameraActor;
+class RenderTaskList;
+class FrameBuffer;
+
+using FrameBufferPtr = IntrusivePtr<FrameBuffer>;
+using ScenePtr = IntrusivePtr<Scene>;
+
+/**
+ * @brief Scene creates a "world" that can be bound to a surface for rendering.
+ */
+class Scene : public BaseObject, public RenderTaskDefaults
+{
+
+public:
+
+  /**
+   * @copydoc Dali::Integration::Scene::New
+   */
+  static ScenePtr New( Size size );
+
+  /**
+   * virtual destructor
+   */
+  virtual ~Scene();
+
+  /**
+   * @copydoc Dali::Integration::Scene::Add
+   */
+  void Add(Actor& actor);
+
+  /**
+   * @copydoc Dali::Integration::Scene::Remove
+   */
+  void Remove(Actor& actor);
+
+  /**
+   * @copydoc Dali::Integration::Scene::GetSize
+   */
+  Size GetSize() const;
+
+  /**
+   * @copydoc Dali::Integration::Scene::SetDpi
+   */
+  void SetDpi( Vector2 dpi );
+
+  /**
+   * @copydoc Dali::Integration::Scene::GetDpi
+   */
+  Vector2 GetDpi() const;
+
+  /**
+   * @copydoc Dali::Integration::Scene::GetRenderTaskList
+   */
+  RenderTaskList& GetRenderTaskList() const;
+
+  /**
+   * @copydoc Dali::Integration::Scene::GetRootLayer
+   */
+  Dali::Layer GetRootLayer() const;
+
+  /**
+   * @copydoc Dali::Integration::Scene::GetLayerCount
+   */
+  uint32_t GetLayerCount() const;
+
+  /**
+   * @copydoc Dali::Integration::Scene::GetLayer
+   */
+  Dali::Layer GetLayer(uint32_t depth) const;
+
+  /**
+   * @copydoc Dali::Integration::Scene::SetSurface
+   */
+  void SetSurface( Integration::RenderSurface& surface );
+
+  /**
+   * Retrieve the render surface the scene is binded to.
+   * @return The render surface.
+   */
+  Integration::RenderSurface* GetSurface() const;
+
+  /**
+   * Retrieve the ordered list of on-stage layers.
+   * @return The layer-list.
+   */
+  LayerList& GetLayerList() const;
+
+  /**
+   * Request that the depth tree is rebuilt
+   */
+  void RequestRebuildDepthTree();
+
+  /**
+   * Rebuilds the depth tree at the end of the event frame if
+   * it was requested this frame.
+   */
+  void RebuildDepthTree();
+
+  /**
+   * @brief Sets the background color of the render surface.
+   * @param[in] color The new background color
+   */
+  void SetBackgroundColor(Vector4 color);
+
+  /**
+   * @brief Gets the background color of the render surface.
+   * @return The background color
+   */
+  Vector4 GetBackgroundColor() const;
+
+public:
+
+  /**
+   * From RenderTaskDefaults; retrieve the default root actor.
+   * @return The default root actor.
+   */
+  virtual Actor& GetDefaultRootActor();
+
+  /**
+   * From RenderTaskDefaults; retrieve the default camera actor.
+   * @return The default camera actor.
+   */
+  virtual CameraActor& GetDefaultCameraActor();
+
+private:
+
+  // Constructor
+  Scene( Size size );
+
+  /**
+   * Second-phase constructor.
+   */
+  void Initialize();
+
+  // Undefined
+  Scene(const Scene&) = delete;
+
+  // Undefined
+  Scene& operator=(const Scene& rhs) = delete;
+
+private:
+
+  Integration::RenderSurface* mSurface;
+
+  // The scene-size may be different with the surface-size
+  Size mSize;
+  Size mSurfaceSize;
+
+  Vector2 mDpi;
+
+  LayerPtr mRootLayer;
+
+  // Ordered list of currently on-stage layers
+  OwnerPointer<LayerList> mLayerList;
+
+  IntrusivePtr<CameraActor> mDefaultCamera;
+
+  // The list of render-tasks
+  IntrusivePtr<RenderTaskList> mRenderTaskList;
+
+  // The frame buffer
+  FrameBufferPtr mFrameBuffer;
+
+  bool mDepthTreeDirty:1;  ///< True if the depth tree needs recalculating
+};
+
+} // Internal
+
+// Get impl of handle
+inline Internal::Scene& GetImplementation(Dali::Integration::Scene& scene)
+{
+  DALI_ASSERT_ALWAYS( scene && "Scene handle is empty" );
+  Dali::RefObject& object = scene.GetBaseObject();
+  return static_cast<Internal::Scene&>(object);
+}
+
+inline const Internal::Scene& GetImplementation(const Dali::Integration::Scene& scene)
+{
+  DALI_ASSERT_ALWAYS( scene && "Scene handle is empty" );
+  const Dali::RefObject& object = scene.GetBaseObject();
+  return static_cast<const Internal::Scene&>(object);
+}
+
+} // Dali
+
+#endif // DALI_INTERNAL_SCENE_H
index 8294cf8..54201e1 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -85,61 +85,15 @@ SignalConnectorType signalConnector9( mType, SIGNAL_TOUCH,                     &
 
 } // unnamed namespace
 
-StagePtr Stage::New( AnimationPlaylist& playlist,
-                     PropertyNotificationManager& propertyNotificationManager,
-                     SceneGraph::UpdateManager& updateManager,
-                     NotificationManager& notificationManager,
-                     Integration::RenderController& renderController )
+StagePtr Stage::New( SceneGraph::UpdateManager& updateManager )
 {
-  return StagePtr( new Stage( playlist, propertyNotificationManager, updateManager, notificationManager, renderController ) );
+  return StagePtr( new Stage( updateManager ) );
 }
 
-void Stage::Initialize( bool renderToFbo )
+void Stage::Initialize( Scene& scene )
 {
-  mRenderToFbo = renderToFbo;
-  mObjectRegistry = ObjectRegistry::New();
-
-  // Create the ordered list of layers
-  mLayerList = LayerList::New( mUpdateManager );
-
-  // The stage owns the default layer
-  mRootLayer = Layer::NewRoot( *mLayerList, mUpdateManager );
-  mRootLayer->SetName("RootLayer");
-  // The root layer needs to have a fixed resize policy (as opposed to the default USE_NATURAL_SIZE).
-  // This stops actors parented to the stage having their relayout requests propagating
-  // up to the root layer, and down through other children unnecessarily.
-  mRootLayer->SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
-
-  // Create the default camera actor first; this is needed by the RenderTaskList
-  CreateDefaultCameraActor();
-
-  // Create the list of render-tasks
-  mRenderTaskList = RenderTaskList::New();
-
-  // Create the default render-task (don't need the returned handle)
-  mRenderTaskList->CreateTask( mRootLayer.Get(), mDefaultCamera.Get() );
-}
-
-void Stage::Uninitialize()
-{
-  if( mDefaultCamera )
-  {
-    // its enough to release the handle so the object is released
-    // don't need to remove it from root actor as root actor will delete the object
-    mDefaultCamera.Reset();
-  }
-
-  if( mRootLayer )
-  {
-    // we are closing down so just delete the root, no point emit disconnect
-    // signals or send messages to update
-    mRootLayer.Reset();
-  }
-
-  if( mRenderTaskList )
-  {
-    mRenderTaskList.Reset();
-  }
+  mScene = &scene;
+  mScene->SetBackgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR );
 }
 
 StagePtr Stage::GetCurrent()
@@ -161,182 +115,78 @@ bool Stage::IsInstalled()
 
 ObjectRegistry& Stage::GetObjectRegistry()
 {
-  return *mObjectRegistry;
-}
-
-void Stage::RegisterObject( Dali::BaseObject* object )
-{
-  mObjectRegistry->RegisterObject( object );
-}
-
-void Stage::UnregisterObject( Dali::BaseObject* object )
-{
-  mObjectRegistry->UnregisterObject( object );
+  return ThreadLocalStorage::Get().GetObjectRegistry();
 }
 
 Layer& Stage::GetRootActor()
 {
-  return *mRootLayer;
-}
-
-AnimationPlaylist& Stage::GetAnimationPlaylist()
-{
-  return mAnimationPlaylist;
-}
-
-PropertyNotificationManager& Stage::GetPropertyNotificationManager()
-{
-  return mPropertyNotificationManager;
+  Dali::Layer rootLayer = GetRootLayer();
+  return GetImplementation( rootLayer );
 }
 
 void Stage::Add( Actor& actor )
 {
-  mRootLayer->Add( actor );
+  mScene->Add( actor );
 }
 
 void Stage::Remove( Actor& actor )
 {
-  mRootLayer->Remove( actor );
-}
-
-void Stage::SurfaceResized( float width, float height )
-{
-  if( ( fabsf( width - mSurfaceSize.width ) > Math::MACHINE_EPSILON_1000 ) || ( fabsf( height - mSurfaceSize.height ) > Math::MACHINE_EPSILON_1000 ) )
-  {
-    mSurfaceSize.width = width;
-    mSurfaceSize.height = height;
-
-    // Internally we want to report the actual size of the stage.
-    mSize.width = width;
-    mSize.height = height - static_cast<float>( mTopMargin );
-
-    // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
-    mDefaultCamera->SetPerspectiveProjection( mSurfaceSize );
-
-    // Adjust the camera height to allow for top-margin
-    SetDefaultCameraPosition();
-
-    mRootLayer->SetSize( mSize.width, mSize.height );
-
-    SetDefaultSurfaceRectMessage( mUpdateManager, Rect<int32_t>( 0, 0, static_cast<int32_t>( width ), static_cast<int32_t>( height ) ) ); // truncated
-
-    // if single render task to screen then set its viewport parameters
-    if( 1 == mRenderTaskList->GetTaskCount() )
-    {
-      RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask( 0u );
-
-      if(!defaultRenderTask->GetTargetFrameBuffer())
-      {
-        defaultRenderTask->SetViewport( Viewport( 0, 0, static_cast<int32_t>( width ), static_cast<int32_t>( height ) ) ); // truncated
-      }
-    }
-
-    if( mRenderToFbo )
-    {
-      Dali::FrameBuffer frameBuffer = Dali::FrameBuffer::New( static_cast<uint32_t>( width ), static_cast<uint32_t>( height ), Dali::FrameBuffer::Attachment::NONE );
-      Dali::Texture texture = Dali::Texture::New( Dali::TextureType::TEXTURE_2D, Dali::Pixel::RGB888, static_cast<uint32_t>( width ), static_cast<uint32_t>( height ) );
-      frameBuffer.AttachColorTexture( texture );
-
-      RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask( 0u );
-      defaultRenderTask->SetFrameBuffer( &GetImplementation( frameBuffer ) );
-    }
-  }
+  mScene->Remove( actor );
 }
 
 Vector2 Stage::GetSize() const
 {
-  return mSize;
-}
-
-void Stage::SetTopMargin( uint32_t margin )
-{
-  if (mTopMargin == margin)
-  {
-    return;
-  }
-  mTopMargin = margin;
-
-  mSize.width = mSurfaceSize.width;
-  mSize.height = mSurfaceSize.height - static_cast<float>( mTopMargin );
-
-  // Adjust the camera height to allow for top-margin
-  SetDefaultCameraPosition();
-
-  mRootLayer->SetSize( mSize.width, mSize.height );
+  return mScene->GetSize();
 }
 
 RenderTaskList& Stage::GetRenderTaskList() const
 {
-  return *mRenderTaskList;
-}
-
-void Stage::CreateDefaultCameraActor()
-{
-  // The default camera attributes and position is such that
-  // children of the default layer, can be positioned at (0,0) and
-  // be at the top-left of the viewport.
-  mDefaultCamera = CameraActor::New( Size::ZERO );
-  mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
-  Add(*(mDefaultCamera.Get()));
-}
-
-void Stage::SetDefaultCameraPosition()
-{
-  mDefaultCamera->SetY( -(static_cast<float>(mTopMargin) * 0.5f) );
+  return mScene->GetRenderTaskList();
 }
 
 Actor& Stage::GetDefaultRootActor()
 {
-  return *mRootLayer;
+  return mScene->GetDefaultRootActor();
 }
 
 CameraActor& Stage::GetDefaultCameraActor()
 {
-  return *mDefaultCamera;
+  return mScene->GetDefaultCameraActor();
 }
 
 uint32_t Stage::GetLayerCount() const
 {
-  return mLayerList->GetLayerCount();
+  return mScene->GetLayerCount();
 }
 
 Dali::Layer Stage::GetLayer( uint32_t depth ) const
 {
-  return Dali::Layer(mLayerList->GetLayer( depth ));
+  return mScene->GetLayer( depth );
 }
 
 Dali::Layer Stage::GetRootLayer() const
 {
-  return Dali::Layer( mRootLayer.Get() );
+  return mScene->GetRootLayer();
 }
 
 LayerList& Stage::GetLayerList()
 {
-  return *mLayerList;
+  return mScene->GetLayerList();
 }
 
 void Stage::SetBackgroundColor(Vector4 color)
 {
-  // Cache for public GetBackgroundColor()
-  mBackgroundColor = color;
-
-  // Send message to change color in next frame
-  SetBackgroundColorMessage( mUpdateManager, color );
+  mScene->SetBackgroundColor( color );
 }
 
 Vector4 Stage::GetBackgroundColor() const
 {
-  return mBackgroundColor;
+  return mScene->GetBackgroundColor();
 }
 
 Vector2 Stage::GetDpi() const
 {
-  return mDpi;
-}
-
-void Stage::SetDpi(Vector2 dpi)
-{
-  mDpi = dpi;
+  return mScene->GetDpi();
 }
 
 void Stage::KeepRendering( float durationSeconds )
@@ -520,42 +370,8 @@ void Stage::NotifyContextRegained()
   mContextRegainedSignal.Emit();
 }
 
-
-void Stage::RequestRebuildDepthTree()
-{
-  DALI_LOG_INFO(gLogFilter, Debug::General, "RequestRebuildDepthTree()\n");
-  mDepthTreeDirty = true;
-}
-
-void Stage::RebuildDepthTree()
-{
-  // If the depth tree needs rebuilding, do it in this frame only.
-  if( mDepthTreeDirty )
-  {
-    DALI_LOG_INFO(gLogFilter, Debug::Concise, "RebuildDepthTree() dirty:T\n");
-
-    ActorPtr actor( mRootLayer.Get() );
-    actor->RebuildDepthTree();
-    mDepthTreeDirty = false;
-  }
-}
-
-
-Stage::Stage( AnimationPlaylist& playlist,
-              PropertyNotificationManager& propertyNotificationManager,
-              SceneGraph::UpdateManager& updateManager,
-              NotificationManager& notificationManager,
-              Integration::RenderController& renderController )
-: mAnimationPlaylist( playlist ),
-  mPropertyNotificationManager( propertyNotificationManager ),
-  mUpdateManager( updateManager ),
-  mNotificationManager( notificationManager ),
-  mRenderController( renderController ),
-  mSize( Vector2::ZERO ),
-  mSurfaceSize( Vector2::ZERO ),
-  mBackgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
-  mTopMargin( 0 ),
-  mDpi( Vector2::ZERO ),
+Stage::Stage( SceneGraph::UpdateManager& updateManager )
+: mUpdateManager( updateManager ),
   mKeyEventSignal(),
   mKeyEventGeneratedSignal(),
   mEventProcessingFinishedSignal(),
@@ -565,43 +381,8 @@ Stage::Stage( AnimationPlaylist& playlist,
   mContextLostSignal(),
   mContextRegainedSignal(),
   mSceneCreatedSignal(),
-  mRenderingBehavior( DevelStage::Rendering::IF_REQUIRED ),
-  mDepthTreeDirty( false ),
-  mForceNextUpdate( false ),
-  mRenderToFbo( false )
-{
-}
-
-SceneGraph::UpdateManager& Stage::GetUpdateManager()
-{
-  return mUpdateManager;
-}
-
-Integration::RenderController& Stage::GetRenderController()
-{
-  return mRenderController;
-}
-
-uint32_t* Stage::ReserveMessageSlot( uint32_t size, bool updateScene )
-{
-  return mUpdateManager.ReserveMessageSlot( size, updateScene );
-}
-
-BufferIndex Stage::GetEventBufferIndex() const
-{
-  return mUpdateManager.GetEventBufferIndex();
-}
-
-void Stage::ForceNextUpdate()
-{
-  mForceNextUpdate = true;
-}
-
-bool Stage::IsNextUpdateForced()
+  mRenderingBehavior( DevelStage::Rendering::IF_REQUIRED )
 {
-  bool nextUpdateForced = mForceNextUpdate;
-  mForceNextUpdate = false;
-  return nextUpdateForced;
 }
 
 Stage::~Stage()
index 493c346..1f52431 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_INTERNAL_STAGE_H
 
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -60,38 +60,26 @@ class Layer;
 class LayerList;
 class CameraActor;
 class RenderTaskList;
+class Scene;
 
 /**
  * Implementation of Stage
  */
-class Stage : public BaseObject, public RenderTaskDefaults, public Integration::ContextNotifierInterface, public EventThreadServices
+class Stage : public BaseObject, public RenderTaskDefaults, public Integration::ContextNotifierInterface
 {
 public:
 
   /**
    * Create the stage
-   * @param[in] playlist for animations
-   * @param[in] propertyNotificationManager
    * @param[in] updateManager
-   * @param[in] notificationManager
-   * @param[in] renderController
    */
-  static StagePtr New( AnimationPlaylist& playlist,
-                       PropertyNotificationManager& propertyNotificationManager,
-                       SceneGraph::UpdateManager& updateManager,
-                       NotificationManager& notificationManager,
-                       Integration::RenderController& renderController );
+  static StagePtr New( SceneGraph::UpdateManager& updateManager );
 
   /**
    * Initialize the stage.
-   * @param[in] renderToFbo Whether to render into a Frame Buffer Object.
+   * @param[in] scene The default scene (for main window).
    */
-  void Initialize( bool renderToFbo );
-
-  /**
-   * Uninitialize the stage.
-   */
-  void Uninitialize();
+  void Initialize( Scene& scene );
 
   /**
    * @copydoc Dali::Stage::GetCurrent()
@@ -115,18 +103,6 @@ public:
    */
   Layer& GetRootActor();
 
-  /**
-   * Returns the animation playlist.
-   * @return reference to the animation playlist.
-   */
-  AnimationPlaylist& GetAnimationPlaylist();
-
-  /**
-   * Returns the property notification manager.
-   * @return reference to the property notification manager.
-   */
-  PropertyNotificationManager& GetPropertyNotificationManager();
-
   // Root actor accessors
 
   /**
@@ -140,22 +116,6 @@ public:
   void Remove( Actor& actor );
 
   /**
-   * Used to calculate the size of the stage and indirectly, the root actor.
-   * @param [in] width  The new surface width.
-   * @param [in] height The new surface height.
-   */
-  void SurfaceResized( float width, float height );
-
-  /**
-   * Sets the top margin size.
-   * Available stage size is reduced by this size.
-   * The stage is located below the size at the top of the display
-   * initial size is zero before it is assigned
-   * @param[in] margin margin size
-   */
-  void SetTopMargin( uint32_t margin );
-
-  /**
    * Returns the size of the Stage in pixels as a Vector.
    * The x component will be the width of the Stage in pixels
    * The y component will be the height of the Stage in pixels
@@ -169,16 +129,6 @@ public:
   RenderTaskList& GetRenderTaskList() const;
 
   /**
-   * Create a default camera actor
-   */
-  void CreateDefaultCameraActor();
-
-  /**
-   * Set position of default camera for current stage size
-   */
-  void SetDefaultCameraPosition();
-
-  /**
    * From RenderTaskDefaults; retrieve the default root actor.
    * @return The default root actor.
    */
@@ -213,27 +163,6 @@ public:
    */
   LayerList& GetLayerList();
 
-  // Keyboard stuff
-
-  /**
-   * As one virtual keyboard per stage, the stage will hold a pointer to the Actor currently
-   * set to receive keyboard input.
-   * @param[in] actor to receive keyboard input
-   */
-  void SetKeyboardFocusActor( Actor* actor );
-
-  /**
-   * Get the actor that is currently set to receive keyboard inputs
-   * @return Pointer to the actor set to receive keyboard inputs.
-   */
-  Actor* GetKeyboardFocusActor() const;
-
-  /**
-   * Removes the given actor from keyboard focus so it will no longer receive key events from keyboard.
-   * @param [in] actor which should be removed from focus.
-   */
-  void RemoveActorFromKeyFocus( Actor* actor );
-
   // Misc
 
   /**
@@ -252,17 +181,6 @@ public:
   Vector2 GetDpi() const;
 
   /**
-   * Sets horizontal and vertical pixels per inch value that is used by the display
-   * @param[in] dpi Horizontal and vertical dpi value
-   */
-  void SetDpi( Vector2 dpi );
-
-  NotificationManager& GetNotificationManager()
-  {
-    return mNotificationManager;
-  }
-
-  /**
    * @copydoc Dali::Stage::KeepRendering()
    */
   void KeepRendering( float durationSeconds );
@@ -393,69 +311,12 @@ private: // Implementation of ContextNotificationInterface:
    */
   virtual void NotifyContextRegained();
 
-public: // Implementation of EventThreadServices
-
-  /**
-   * @copydoc EventThreadServices::RegisterObject
-   */
-  virtual void RegisterObject( BaseObject* object);
-
-  /**
-   * @copydoc EventThreadServices::UnregisterObject
-   */
-  virtual void UnregisterObject( BaseObject* object);
-
-  /**
-   * @copydoc EventThreadServices::GetUpdateManager
-   */
-  virtual SceneGraph::UpdateManager& GetUpdateManager();
-
-  /**
-   * @copydoc EventThreadServices::GetRenderController
-   */
-  virtual Integration::RenderController& GetRenderController();
-
-  /**
-   * @copydoc EventThreadServices::ReserveMessageSlot
-   */
-  virtual uint32_t* ReserveMessageSlot( uint32_t size, bool updateScene );
-
-  /**
-   * @copydoc EventThreadServices::GetEventBufferIndex
-   */
-  virtual BufferIndex GetEventBufferIndex() const;
-
-  /**
-   * @copydoc EventThreadServices::ForceNextUpdate
-   */
-  virtual void ForceNextUpdate();
-
-  /**
-   * @copydoc EventThreadServices::IsNextUpdateForced
-   */
-  virtual bool IsNextUpdateForced();
-
-  /**
-   * Request that the depth tree is rebuilt
-   */
-  void RequestRebuildDepthTree();
-
-  /**
-   * Rebuilds the depth tree at the end of the event frame if
-   * it was requested this frame.
-   */
-  void RebuildDepthTree();
-
 private:
 
   /**
    * Protected constructor; see also Stage::New()
    */
-  Stage( AnimationPlaylist& playlist,
-         PropertyNotificationManager& propertyNotificationManager,
-         SceneGraph::UpdateManager& updateManager,
-         NotificationManager& notificationManager,
-         Integration::RenderController& renderController );
+  Stage( SceneGraph::UpdateManager& updateManager );
 
   /**
    * A reference counted object may only be deleted by calling Unreference()
@@ -464,39 +325,9 @@ private:
 
 private:
 
-  // For 'Fire and forget' animation support
-  AnimationPlaylist& mAnimationPlaylist;
-
-  PropertyNotificationManager& mPropertyNotificationManager;
-
   SceneGraph::UpdateManager& mUpdateManager;
 
-  NotificationManager& mNotificationManager;
-
-  Integration::RenderController& mRenderController;
-
-  // The stage-size may be less than surface-size (reduced by top-margin)
-  Vector2 mSize;
-  Vector2 mSurfaceSize;
-
-  // Cached for public GetBackgroundColor()
-  Vector4 mBackgroundColor;
-
-  LayerPtr mRootLayer;
-
-  // Ordered list of currently on-stage layers
-  OwnerPointer<LayerList> mLayerList;
-
-  IntrusivePtr<CameraActor> mDefaultCamera;
-
-  uint32_t mTopMargin;
-  Vector2 mDpi;
-
-  // The object registry
-  ObjectRegistryPtr mObjectRegistry;
-
-  // The list of render-tasks
-  IntrusivePtr<RenderTaskList> mRenderTaskList;
+  IntrusivePtr<Scene> mScene;
 
   // The key event signal
   Dali::Stage::KeyEventSignalType                 mKeyEventSignal;
@@ -518,10 +349,6 @@ private:
   Dali::Stage::SceneCreatedSignalType mSceneCreatedSignal;
 
   DevelStage::Rendering mRenderingBehavior; ///< The rendering behavior
-
-  bool mDepthTreeDirty:1;  ///< True if the depth tree needs recalculating
-  bool mForceNextUpdate:1; ///< True if the next rendering is really required.
-  bool mRenderToFbo:1;     ///< Whether to render to a Frame Buffer Object.
 };
 
 } // namespace Internal
index 559b833..1eab332 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -21,6 +21,7 @@
 // INTERNAL INCLUDES
 #include <dali/internal/common/core-impl.h>
 #include <dali/public-api/common/dali-common.h>
+#include <dali/internal/event/common/event-thread-services.h>
 
 namespace Dali
 {
@@ -103,6 +104,36 @@ RelayoutController& ThreadLocalStorage::GetRelayoutController()
   return mCore->GetRelayoutController();
 }
 
+ObjectRegistry& ThreadLocalStorage::GetObjectRegistry()
+{
+  return mCore->GetObjectRegistry();
+}
+
+EventThreadServices& ThreadLocalStorage::GetEventThreadServices()
+{
+  return mCore->GetEventThreadServices();
+}
+
+PropertyNotificationManager& ThreadLocalStorage::GetPropertyNotificationManager()
+{
+  return mCore->GetPropertyNotificationManager();
+}
+
+AnimationPlaylist& ThreadLocalStorage::GetAnimationPlaylist()
+{
+  return mCore->GetAnimationPlaylist();
+}
+
+void ThreadLocalStorage::AddScene( Scene* scene )
+{
+  mCore->AddScene( scene );
+}
+
+void ThreadLocalStorage::RemoveScene( Scene* scene )
+{
+  mCore->RemoveScene( scene );
+}
+
 } // namespace Internal
 
 } // namespace Dali
index 95b6c30..0e6e400 100644 (file)
@@ -2,7 +2,7 @@
 #define __DALI_INTERNAL_THREAD_LOCAL_STORAGE_H__
 
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -20,6 +20,7 @@
 
 // INTERNAL INCLUDES
 #include <dali/internal/event/common/stage-def.h>
+#include <dali/internal/event/common/scene-impl.h>
 
 namespace Dali
 {
@@ -39,6 +40,8 @@ class NotificationManager;
 class ShaderFactory;
 class GestureEventProcessor;
 class RelayoutController;
+class ObjectRegistry;
+class EventThreadServices;
 
 namespace SceneGraph
 {
@@ -131,6 +134,44 @@ public:
    */
   RelayoutController& GetRelayoutController();
 
+  /**
+   * Returns the Object registry.
+   * @return A reference to the Object registry
+   */
+  ObjectRegistry& GetObjectRegistry();
+
+  /**
+   * @brief Gets the event thread services.
+   * @return A reference to the event thread services
+   */
+  EventThreadServices& GetEventThreadServices();
+
+  /**
+   * @brief Gets the property notification manager.
+   * @return A reference to the property notification manager
+   */
+  PropertyNotificationManager& GetPropertyNotificationManager();
+
+  /**
+   * @brief Gets the animation play list.
+   * @return A reference to the animation play list
+   */
+  AnimationPlaylist& GetAnimationPlaylist();
+
+  /**
+   * Add a Scene to the Core.
+   * This is only used by the Scene to add itself to the core when the Scene is created.
+   * @param[in] scene The Scene.
+   */
+  void AddScene( Scene* scene );
+
+  /**
+   * Remove a Scene from the Core.
+   * This is only used by the Scene to remove itself from the core when the Scene is destroyed.
+   * @param[in] scene The Scene.
+   */
+  void RemoveScene( Scene* scene );
+
 private:
 
   Core* mCore;                                              ///< reference to core
index 14bc16b..aeec93f 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -32,7 +32,6 @@
 #include <dali/internal/event/common/projection.h>
 #include <dali/internal/event/images/frame-buffer-image-impl.h>
 #include <dali/internal/update/nodes/node.h>
-#include <dali/internal/event/render-tasks/render-task-list-impl.h>
 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
 
 #if defined(DEBUG_ENABLED)
@@ -71,14 +70,17 @@ SignalConnectorType signalConnector1( mType, SIGNAL_FINISHED, &RenderTask::DoCon
 
 } // Unnamed namespace
 
-RenderTaskPtr RenderTask::New( Actor* sourceActor, CameraActor* cameraActor, SceneGraph::RenderTaskList& parentSceneObject )
+RenderTaskPtr RenderTask::New( Actor* sourceActor, CameraActor* cameraActor, RenderTaskList& renderTaskList )
 {
   // create scene object first so it's guaranteed to exist for the event side
   auto sceneObject = SceneGraph::RenderTask::New();
-  OwnerPointer< SceneGraph::RenderTask > transferOwnership( sceneObject );
+
   // pass the pointer to base for message passing
-  RenderTaskPtr task( new RenderTask( sceneObject ) );
+  RenderTaskPtr task( new RenderTask( sceneObject, renderTaskList ) );
+
   // transfer scene object ownership to update manager
+  const SceneGraph::RenderTaskList& parentSceneObject = renderTaskList.GetSceneObject();
+  OwnerPointer< SceneGraph::RenderTask > transferOwnership( sceneObject );
   AddTaskMessage( task->GetEventThreadServices(), parentSceneObject, transferOwnership );
 
   // Set the default source & camera actors
@@ -100,12 +102,9 @@ void RenderTask::SetSourceActor( Actor* actor )
   {
     SetSourceNodeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), nullptr );
   }
+
   // set the actor on exclusive container for hit testing
-  const Stage* stage = Stage::GetCurrent();
-  if ( stage )
-  {
-    stage->GetRenderTaskList().SetExclusive( this, mExclusive );
-  }
+  mRenderTaskList.SetExclusive( this, mExclusive );
 }
 
 Actor* RenderTask::GetSourceActor() const
@@ -119,11 +118,7 @@ void RenderTask::SetExclusive( bool exclusive )
   {
     mExclusive = exclusive;
 
-    const Stage* stage = Stage::GetCurrent();
-    if ( stage )
-    {
-      stage->GetRenderTaskList().SetExclusive( this, exclusive );
-    }
+    mRenderTaskList.SetExclusive( this, exclusive );
 
     // scene object is being used in a separate thread; queue a message to set the value
     SetExclusiveMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), mExclusive );
@@ -156,6 +151,9 @@ void RenderTask::SetCameraActor( CameraActor* cameraActor )
   {
     SetCameraMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), nullptr, nullptr );
   }
+
+  // set the actor on exclusive container for hit testing
+  mRenderTaskList.SetExclusive( this, mExclusive );
 }
 
 CameraActor* RenderTask::GetCameraActor() const
@@ -521,7 +519,6 @@ Property::Value RenderTask::GetDefaultProperty(Property::Index index) const
 
   switch ( index )
   {
-
     case Dali::RenderTask::Property::VIEWPORT_POSITION:
     {
       value = mViewportPosition;
@@ -559,7 +556,6 @@ Property::Value RenderTask::GetDefaultPropertyCurrentValue( Property::Index inde
 
   switch ( index )
   {
-
     case Dali::RenderTask::Property::VIEWPORT_POSITION:
     {
       value = GetCurrentViewportPosition();
@@ -747,11 +743,12 @@ bool RenderTask::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface
   return connected;
 }
 
-RenderTask::RenderTask( const SceneGraph::RenderTask* sceneObject )
+RenderTask::RenderTask( const SceneGraph::RenderTask* sceneObject, RenderTaskList& renderTaskList )
 : Object( sceneObject ),
   mSourceActor( nullptr ),
   mCameraActor( nullptr ),
   mInputMappingActor(),
+  mRenderTaskList( renderTaskList ),
   mClearColor( Dali::RenderTask::DEFAULT_CLEAR_COLOR ),
   mViewportPosition( Vector2::ZERO ),
   mViewportSize( Vector2::ZERO ),
index de111d0..45e59ea 100644 (file)
@@ -2,7 +2,7 @@
 #define __DALI_INTERNAL_RENDER_TASK_H__
 
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -25,6 +25,7 @@
 #include <dali/internal/event/images/frame-buffer-image-impl.h>
 #include <dali/internal/event/common/object-impl.h>
 #include <dali/internal/event/rendering/frame-buffer-impl.h>
+#include <dali/internal/event/render-tasks/render-task-list-impl.h>
 
 namespace Dali
 {
@@ -35,6 +36,7 @@ namespace Internal
 class Actor;
 class CameraActor;
 class EventThreadServices;
+class RenderTaskList;
 
 namespace SceneGraph
 {
@@ -53,8 +55,13 @@ public:
 
   /**
    * Creates a new RenderTask.
+   *
+   * @param[in] sourceActor The source actor.
+   * @param[in] cameraActor The camera actor.
+   * @param[in] renderTaskList The render task list.
+   * @return The created render task
    */
-  static RenderTaskPtr New( Actor* sourceActor, CameraActor* cameraActor, SceneGraph::RenderTaskList& parentSceneObject );
+  static RenderTaskPtr New( Actor* sourceActor, CameraActor* cameraActor, RenderTaskList& renderTaskList );
 
   /**
    * @copydoc Dali::RenderTask::SetSourceActor()
@@ -319,9 +326,10 @@ protected:
   /**
    * Constructor.
    *
-   * @param sceneObject the scene graph object
+   * @param[in] sceneObject The scene graph object
+   * @param[in] renderTaskList The render task list
    */
-  RenderTask( const SceneGraph::RenderTask* sceneObject );
+  RenderTask( const SceneGraph::RenderTask* sceneObject, RenderTaskList& renderTaskList );
 
   /**
    * A reference counted object may only be deleted by calling Unreference()
@@ -339,6 +347,7 @@ private:
   Actor* mSourceActor; ///< Source actor, we cannot keep the actor alive so raw pointer.
   CameraActor* mCameraActor; ///< Camera actor, we cannot keep the actor alive so raw pointer.
   WeakHandle<Dali::Actor> mInputMappingActor; /// used to mapping screen to frame buffer coordinate, not kept alive by rendertask
+  RenderTaskList& mRenderTaskList; ///< The render task list
 
   Vector4 mClearColor;       ///< Optional clear color
 
index c3a40d6..eb4bbf6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -21,7 +21,6 @@
 // INTERNAL INCLUDES
 #include <dali/public-api/common/dali-common.h>
 #include <dali/internal/event/common/event-thread-services.h>
-#include <dali/internal/event/common/thread-local-storage.h>
 #include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/event/render-tasks/render-task-defaults.h>
 #include <dali/internal/event/render-tasks/render-task-impl.h>
@@ -60,7 +59,7 @@ RenderTaskPtr RenderTaskList::CreateTask()
 
 RenderTaskPtr RenderTaskList::CreateTask( Actor* sourceActor, CameraActor* cameraActor)
 {
-  RenderTaskPtr task = RenderTask::New( sourceActor, cameraActor, *mSceneObject );
+  RenderTaskPtr task = RenderTask::New( sourceActor, cameraActor, *this );
 
   mTasks.push_back( task );
 
@@ -135,7 +134,7 @@ void RenderTaskList::SetExclusive( RenderTask* task, bool exclusive )
 }
 
 RenderTaskList::RenderTaskList()
-: mEventThreadServices( *Stage::GetCurrent() ),
+: mEventThreadServices( EventThreadServices::Get() ),
   mDefaults( *Stage::GetCurrent() ),
   mSceneObject( nullptr )
 {
@@ -197,6 +196,11 @@ void RenderTaskList::RecoverFromContextLoss()
   }
 }
 
+const SceneGraph::RenderTaskList& RenderTaskList::GetSceneObject() const
+{
+  return *mSceneObject;
+}
+
 } // namespace Internal
 
 } // namespace Dali
index 55e37e8..9f203d8 100644 (file)
@@ -36,6 +36,7 @@ class RenderTaskDefaults;
 class Actor;
 class CameraActor;
 
+using RenderTaskPtr = IntrusivePtr<RenderTask>;
 class RenderTaskList;
 using RenderTaskListPtr = IntrusivePtr<RenderTaskList>;
 
@@ -139,6 +140,12 @@ public:
    */
   void RecoverFromContextLoss();
 
+  /**
+   * Retrieve the SceneGraph::RenderTaskList object.
+   * @return The RenderTaskList.
+   */
+  const SceneGraph::RenderTaskList& GetSceneObject() const;
+
 protected:
 
   /**
index ccfc8d0..fd5f4bf 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
 
 // INTERNAL INCLUDES
 #include <dali/internal/update/manager/update-manager.h>
-#include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/render/renderers/render-frame-buffer.h>
+#include <dali/internal/render/renderers/render-texture-frame-buffer.h>
+#include <dali/internal/render/renderers/render-surface-frame-buffer.h>
+#include <dali/integration-api/render-surface.h>
 
 namespace Dali
 {
@@ -35,6 +37,13 @@ FrameBufferPtr FrameBuffer::New( uint32_t width, uint32_t height, Mask attachmen
   return frameBuffer;
 }
 
+FrameBufferPtr FrameBuffer::New( Dali::Integration::RenderSurface& renderSurface, Mask attachments )
+{
+  Dali::PositionSize positionSize = renderSurface.GetPositionSize();
+  FrameBufferPtr frameBuffer( new FrameBuffer( positionSize.width, positionSize.height, attachments ) );
+  frameBuffer->Initialize( &renderSurface );
+  return frameBuffer;
+}
 
 Render::FrameBuffer* FrameBuffer::GetRenderObject() const
 {
@@ -42,38 +51,58 @@ Render::FrameBuffer* FrameBuffer::GetRenderObject() const
 }
 
 FrameBuffer::FrameBuffer( uint32_t width, uint32_t height, Mask attachments )
-: mEventThreadServices( *Stage::GetCurrent() ),
+: mEventThreadServices( EventThreadServices::Get() ),
   mRenderObject( NULL ),
   mColor( NULL ),
   mWidth( width ),
   mHeight( height ),
-  mAttachments( attachments )
+  mAttachments( attachments ),
+  mIsSurfaceBacked( false )
 {
 }
 
-void FrameBuffer::Initialize()
+void FrameBuffer::Initialize( Integration::RenderSurface* renderSurface )
 {
-  mRenderObject = new Render::FrameBuffer( mWidth, mHeight, mAttachments );
+  mIsSurfaceBacked = ( renderSurface != nullptr );
+
+  // If render surface backed, create a different scene object
+  // Make Render::FrameBuffer as a base class, and implement Render::TextureFrameBuffer & Render::WindowFrameBuffer
+  if ( mIsSurfaceBacked )
+  {
+    mRenderObject = new Render::SurfaceFrameBuffer( renderSurface );
+  }
+  else
+  {
+    mRenderObject = new Render::TextureFrameBuffer( mWidth, mHeight, mAttachments );
+  }
+
   AddFrameBuffer( mEventThreadServices.GetUpdateManager(), *mRenderObject );
 }
 
 void FrameBuffer::AttachColorTexture( TexturePtr texture, uint32_t mipmapLevel, uint32_t layer )
 {
-  if( ( texture->GetWidth() / ( 1u << mipmapLevel ) == mWidth ) &&
-      ( texture->GetHeight() / ( 1u << mipmapLevel ) == mHeight ) )
+  if ( mIsSurfaceBacked )
   {
-    mColor = texture;
-    AttachColorTextureToFrameBuffer( mEventThreadServices.GetUpdateManager(), *mRenderObject, texture->GetRenderObject(), mipmapLevel, layer );
+    DALI_LOG_ERROR( "Attempted to attach color texture to a render surface backed FrameBuffer \n" );
   }
   else
   {
-    DALI_LOG_ERROR( "Failed to attach color texture to FrameBuffer: Size mismatch \n" );
+    if( ( texture->GetWidth() / ( 1u << mipmapLevel ) == mWidth ) &&
+        ( texture->GetHeight() / ( 1u << mipmapLevel ) == mHeight ) )
+    {
+      mColor = texture;
+      AttachColorTextureToFrameBuffer( mEventThreadServices.GetUpdateManager(), *mRenderObject, texture->GetRenderObject(), mipmapLevel, layer );
+    }
+    else
+    {
+      DALI_LOG_ERROR( "Failed to attach color texture to FrameBuffer: Size mismatch \n" );
+    }
   }
 }
 
 Texture* FrameBuffer::GetColorTexture()
 {
-  return mColor.Get();
+  return mIsSurfaceBacked ? nullptr : mColor.Get();
 }
 
 FrameBuffer::~FrameBuffer()
index 9389193..3531c0f 100644 (file)
 
 namespace Dali
 {
+
+namespace Integration
+{
+class RenderSurface;
+}
+
 namespace Internal
 {
 namespace Render
@@ -55,6 +61,20 @@ public:
   static FrameBufferPtr New( uint32_t width, uint32_t height, Mask attachments );
 
   /**
+   * @brief Create a new FrameBuffer
+   *
+   * @param[in] renderSurface  The render surface
+   * @param[in] attachments    The attachments comprising the format of the FrameBuffer (bit-mask)
+   * @return A smart-pointer to the newly allocated Texture.
+   */
+  static FrameBufferPtr New( Dali::Integration::RenderSurface& renderSurface, Mask attachments );
+
+  /**
+   * A reference counted object may only be deleted by calling Unreference()
+   */
+  virtual ~FrameBuffer();
+
+  /**
    * @brief Get the FrameBuffer render object
    *
    * @return the FrameBuffer render object
@@ -84,15 +104,10 @@ private: // implementation
   /**
    * Second stage initialization of the Texture
    */
-  void Initialize();
+  void Initialize( Integration::RenderSurface* renderSurface = nullptr );
 
 protected:
 
-  /**
-   * A reference counted object may only be deleted by calling Unreference()
-   */
-  virtual ~FrameBuffer();
-
 private: // unimplemented methods
 
   FrameBuffer() = delete;
@@ -109,6 +124,8 @@ private: // data
   uint32_t mHeight;
   Mask mAttachments;                           ///< Bit-mask of type FrameBuffer::Attachment::Mask
 
+  bool mIsSurfaceBacked:1;
+
 };
 
 } // namespace Internal
index 0897c08..57469e5 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -20,7 +20,7 @@
 
 // INTERNAL INCLUDES
 #include <dali/public-api/object/type-registry.h>
-#include <dali/internal/event/common/stage-impl.h>
+
 #include <dali/internal/update/manager/update-manager.h>
 
 namespace Dali
@@ -88,7 +88,7 @@ const Render::Geometry* Geometry::GetRenderObject() const
 }
 
 Geometry::Geometry()
-: mEventThreadServices( *Stage::GetCurrent() ),
+: mEventThreadServices( EventThreadServices::Get() ),
   mRenderObject( NULL ),
   mType(Dali::Geometry::TRIANGLES)
 {
index d6e8af0..79d1185 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -58,7 +58,7 @@ Render::Sampler* Sampler::GetSamplerRenderObject()
 
 
 Sampler::Sampler()
-:mEventThreadServices( *Stage::GetCurrent() ),
+:mEventThreadServices( EventThreadServices::Get() ),
  mRenderObject( NULL )
 {
 }
index 3c3bbbd..3fb61f7 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -50,7 +50,7 @@ Render::Texture* Texture::GetRenderObject() const
 }
 
 Texture::Texture(TextureType::Type type, Pixel::Format format, ImageDimensions size )
-: mEventThreadServices( *Stage::GetCurrent() ),
+: mEventThreadServices( EventThreadServices::Get() ),
   mRenderObject( NULL ),
   mNativeImage(),
   mSize( size ),
@@ -60,7 +60,7 @@ Texture::Texture(TextureType::Type type, Pixel::Format format, ImageDimensions s
 }
 
 Texture::Texture( NativeImageInterfacePtr nativeImageInterface )
-: mEventThreadServices( *Stage::GetCurrent() ),
+: mEventThreadServices( EventThreadServices::Get() ),
   mRenderObject( NULL ),
   mNativeImage( nativeImageInterface ),
   mSize( nativeImageInterface->GetWidth(), nativeImageInterface->GetHeight() ),
index 349eaa6..7c562e4 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -20,7 +20,6 @@
 
 // INTERNAL INCLUDES
 #include <dali/public-api/object/type-registry.h>
-#include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/update/manager/update-manager.h>
 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
 
@@ -136,7 +135,7 @@ const SceneGraph::TextureSet* TextureSet::GetTextureSetSceneObject() const
 }
 
 TextureSet::TextureSet()
-:mEventThreadServices( *Stage::GetCurrent() ),
+:mEventThreadServices( EventThreadServices::Get() ),
  mSceneObject( NULL )
 {
 }
index 35190fe..87d8645 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -90,6 +90,7 @@ void PrintHierarchy()
   if ( gLogFilter->IsEnabledFor( Debug::Verbose ) )
   {
     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "---------- ROOT LAYER ----------\n" );
+
     PrintChildren( Stage::GetCurrent()->GetRootLayer(), 0 );
   }
 }
@@ -109,7 +110,6 @@ RelayoutController::RelayoutController( Integration::RenderController& controlle
   mRelayoutInfoAllocator(),
   mSlotDelegate( this ),
   mRelayoutStack( new MemoryPoolRelayoutContainer( mRelayoutInfoAllocator ) ),
-  mStageSize(), // zero initialized
   mRelayoutConnection( false ),
   mRelayoutFlag( false ),
   mEnabled( false ),
@@ -130,17 +130,12 @@ RelayoutController* RelayoutController::Get()
   return &ThreadLocalStorage::Get().GetRelayoutController();
 }
 
-void RelayoutController::SetStageSize( uint32_t width, uint32_t height )
-{
-  mStageSize.width = static_cast<float>( width );
-  mStageSize.height = static_cast<float>( height );
-}
-
-void RelayoutController::QueueActor( Dali::Actor& actor, RelayoutContainer& actors, Vector2 size )
+void RelayoutController::QueueActor( Internal::Actor* actor, RelayoutContainer& actors, Vector2 size )
 {
-  if( GetImplementation( actor ).RelayoutRequired() )
+  if( actor && actor->RelayoutRequired() )
   {
-    actors.Add( actor, size );
+    Dali::Actor actorHandle = Dali::Actor( actor );
+    actors.Add( actorHandle, size );
   }
 }
 
@@ -208,12 +203,6 @@ void RelayoutController::OnApplicationSceneCreated()
   // Open relayout controller to receive relayout requests
   mEnabled = true;
 
-  // Spread the dirty flag through whole tree - don't need to explicity
-  // add request on rootLayer as it will automatically be added below.
-  Dali::Stage stage = Dali::Stage::GetCurrent();
-  Dali::Actor rootLayer = stage.GetRootLayer();
-  RequestRelayoutTree( rootLayer );
-
   // Flag request for end of frame
   Request();
 }
@@ -374,7 +363,7 @@ void RelayoutController::PropagateFlags( Dali::Actor& actor, Dimension::Type dim
 
 void RelayoutController::AddRequest( Dali::Actor& actor )
 {
-  BaseObject* actorPtr = &GetImplementation( actor );
+  Internal::Actor* actorPtr = &GetImplementation( actor );
 
   // Only add the rootActor if it is not already recorded
   bool found = false;
@@ -395,7 +384,7 @@ void RelayoutController::AddRequest( Dali::Actor& actor )
 
 void RelayoutController::RemoveRequest( Dali::Actor& actor )
 {
-  BaseObject* actorPtr = &GetImplementation( actor );
+  Internal::Actor* actorPtr = &GetImplementation( actor );
 
   // Remove actor from dirty sub trees
   for( RawActorList::Iterator it = mDirtyLayoutSubTrees.Begin(), itEnd = mDirtyLayoutSubTrees.End(); it != itEnd; ++it )
@@ -414,8 +403,7 @@ void RelayoutController::Request()
 
   if( !mRelayoutConnection )
   {
-    Dali::Stage stage = Dali::Stage::GetCurrent();
-    stage.GetObjectRegistry().ObjectDestroyedSignal().Connect( mSlotDelegate, &RelayoutController::OnObjectDestroyed );
+    ThreadLocalStorage::Get().GetObjectRegistry().ObjectDestroyedSignal().Connect( mSlotDelegate, &RelayoutController::OnObjectDestroyed );
 
     mRelayoutConnection = true;
   }
@@ -441,19 +429,16 @@ void RelayoutController::Relayout()
     //    These controls are paired with the parent/stage size and added to the stack.
     for( RawActorList::Iterator it = mDirtyLayoutSubTrees.Begin(), itEnd = mDirtyLayoutSubTrees.End(); it != itEnd; ++it )
     {
-      BaseObject* dirtyActor = *it;
+      Internal::Actor* dirtyActor = *it;
 
       // Need to test if actor is valid (could have been deleted and had the pointer cleared)
       if( dirtyActor )
       {
-        // We know that BaseObject is a base class of Internal::Actor but need to instruct the compiler to do the cast
-        Dali::Actor actor = Dali::Actor( reinterpret_cast<Dali::Internal::Actor*>( dirtyActor ) );
-
         // Only negotiate actors that are on stage
-        if( actor.OnStage() )
+        if( dirtyActor->OnStage() )
         {
-          Dali::Actor parent = actor.GetParent();
-          QueueActor( actor, *mRelayoutStack, ( parent ) ? Vector2( parent.GetTargetSize() ) : mStageSize );
+          Internal::Actor* parent = dirtyActor->GetParent();
+          QueueActor( dirtyActor, *mRelayoutStack, ( parent ) ? Vector2( parent->GetTargetSize() ) : dirtyActor->GetScene().GetSize() );
         }
       }
     }
index 543ae66..5f7fb1f 100644 (file)
@@ -2,7 +2,7 @@
 #define __DALI_INTERNAL_RELAYOUT_CONTROLLER_IMPL_H__
 
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -68,13 +68,6 @@ public:
   static RelayoutController* Get();
 
   /**
-   * Set the stage size
-   * @param width of the stage
-   * @param height of the stage
-   */
-  void SetStageSize( uint32_t width, uint32_t height );
-
-  /**
    * @brief Request to relayout the given actor and all sub-actors of it.
    *
    * This flags the actor and all actors dependent on it for relayout. The actual
@@ -150,7 +143,7 @@ public: // CALLBACKS
 
 private:
 
-  typedef Dali::Vector< BaseObject* > RawActorList;
+  using RawActorList = Dali::Vector< Dali::Internal::Actor* >;
 
   /**
    * @brief Request for relayout. Relays out whole scene.
@@ -194,7 +187,7 @@ private:
    * @param[in] actors The container to add the actor to
    * @param[in] size The size that this actor should be
    */
-  void QueueActor( Dali::Actor& actor, RelayoutContainer& actors, Vector2 size );
+  void QueueActor( Internal::Actor* actor, RelayoutContainer& actors, Vector2 size );
 
   /**
    * @brief Find the given object in the list and null it out
@@ -205,8 +198,8 @@ private:
   void FindAndZero( const RawActorList& list, const Dali::RefObject* object );
 
   // Undefined
-  RelayoutController(const RelayoutController&);
-  RelayoutController& operator=(const RelayoutController&);
+  RelayoutController(const RelayoutController&) = delete;
+  RelayoutController& operator=(const RelayoutController&) = delete;
 
 private:
 
@@ -218,7 +211,6 @@ private:
   RawActorList mDirtyLayoutSubTrees;    ///< List of roots of sub trees that are dirty
   MemoryPoolRelayoutContainer* mRelayoutStack;  ///< Stack for relayouting
 
-  Vector2 mStageSize;              ///< size of the stage
   bool mRelayoutConnection : 1;    ///< Whether EventProcessingFinishedSignal signal is connected.
   bool mRelayoutFlag : 1;          ///< Relayout flag to avoid unnecessary calls
   bool mEnabled : 1;               ///< Initially disabled. Must be enabled at some point.
index 367a424..c007a04 100644 (file)
@@ -36,6 +36,7 @@ internal_src_files = \
   $(internal_src_dir)/event/common/property-notification-impl.cpp  \
   $(internal_src_dir)/event/common/property-notification-manager.cpp \
   $(internal_src_dir)/event/common/property-helper.cpp \
+  $(internal_src_dir)/event/common/scene-impl.cpp \
   $(internal_src_dir)/event/common/stage-impl.cpp \
   $(internal_src_dir)/event/common/thread-local-storage.cpp \
   $(internal_src_dir)/event/common/type-info-impl.cpp \
@@ -98,7 +99,8 @@ internal_src_files = \
   $(internal_src_dir)/render/gl-resources/gl-call-debug.cpp \
   $(internal_src_dir)/render/gl-resources/gpu-buffer.cpp \
   $(internal_src_dir)/render/queue/render-queue.cpp \
-  $(internal_src_dir)/render/renderers/render-frame-buffer.cpp \
+  $(internal_src_dir)/render/renderers/render-texture-frame-buffer.cpp \
+  $(internal_src_dir)/render/renderers/render-surface-frame-buffer.cpp \
   $(internal_src_dir)/render/renderers/render-geometry.cpp \
   $(internal_src_dir)/render/renderers/render-property-buffer.cpp \
   $(internal_src_dir)/render/renderers/render-renderer.cpp \
index e9e13e8..a69d02f 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -34,6 +34,8 @@
 #include <dali/internal/render/gl-resources/context.h>
 #include <dali/internal/render/queue/render-queue.h>
 #include <dali/internal/render/renderers/render-frame-buffer.h>
+#include <dali/internal/render/renderers/render-texture-frame-buffer.h>
+#include <dali/internal/render/renderers/render-surface-frame-buffer.h>
 #include <dali/internal/render/renderers/render-geometry.h>
 #include <dali/internal/render/renderers/render-renderer.h>
 #include <dali/internal/render/renderers/render-sampler.h>
@@ -58,6 +60,8 @@ struct RenderManager::Impl
         Integration::DepthBufferAvailable depthBufferAvailableParam,
         Integration::StencilBufferAvailable stencilBufferAvailableParam )
   : context( glAbstraction ),
+    currentContext( &context ),
+    glAbstraction( glAbstraction ),
     glSyncAbstraction( glSyncAbstraction ),
     renderQueue(),
     instructions(),
@@ -92,6 +96,17 @@ struct RenderManager::Impl
     mRenderTrackers.EraseObject( renderTracker );
   }
 
+  Context* CreateSurfaceContext()
+  {
+    surfaceContextContainer.PushBack( new Context( glAbstraction ) );
+    return surfaceContextContainer[ surfaceContextContainer.Count() - 1 ];
+  }
+
+  void DestroySurfaceContext( Context* surfaceContext )
+  {
+    surfaceContextContainer.EraseObject( surfaceContext );
+  }
+
   void UpdateTrackers()
   {
     for( auto&& iter : mRenderTrackers )
@@ -102,7 +117,10 @@ struct RenderManager::Impl
 
   // the order is important for destruction,
   // programs are owned by context at the moment.
-  Context                                   context;                 ///< holds the GL state
+  Context                                   context;                 ///< Holds the GL state of the share resource context
+  Context*                                  currentContext;          ///< Holds the GL state of the current context for rendering
+  OwnerContainer< Context* >                surfaceContextContainer; ///< List of owned contexts holding the GL state per surface
+  Integration::GlAbstraction&               glAbstraction;           ///< GL abstraction
   Integration::GlSyncAbstraction&           glSyncAbstraction;       ///< GL sync abstraction
   RenderQueue                               renderQueue;             ///< A message queue for receiving messages from the update-thread.
 
@@ -288,7 +306,14 @@ void RenderManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, u
 void RenderManager::AddFrameBuffer( Render::FrameBuffer* frameBuffer )
 {
   mImpl->frameBufferContainer.PushBack( frameBuffer );
-  frameBuffer->Initialize(mImpl->context);
+  if ( frameBuffer->IsSurfaceBacked() )
+  {
+    frameBuffer->Initialize( *mImpl->CreateSurfaceContext() );
+  }
+  else
+  {
+    frameBuffer->Initialize( mImpl->context );
+  }
 }
 
 void RenderManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer )
@@ -301,7 +326,15 @@ void RenderManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer )
     if ( iter == frameBuffer )
     {
       frameBuffer->Destroy( mImpl->context );
+
+      if ( frameBuffer->IsSurfaceBacked() )
+      {
+        auto surfaceFrameBuffer = static_cast<Render::SurfaceFrameBuffer*>( frameBuffer );
+        mImpl->DestroySurfaceContext( surfaceFrameBuffer->GetContext() );
+      }
+
       mImpl->frameBufferContainer.Erase( &iter ); // frameBuffer found; now destroy it
+
       break;
     }
   }
@@ -309,7 +342,11 @@ void RenderManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer )
 
 void RenderManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
 {
-  frameBuffer->AttachColorTexture( mImpl->context, texture, mipmapLevel, layer );
+  if ( !frameBuffer->IsSurfaceBacked() )
+  {
+    auto textureFrameBuffer = static_cast<Render::TextureFrameBuffer*>( frameBuffer );
+    textureFrameBuffer->AttachColorTexture( mImpl->context, texture, mipmapLevel, layer );
+  }
 }
 
 void RenderManager::AddPropertyBuffer( OwnerPointer< Render::PropertyBuffer >& propertyBuffer )
@@ -419,48 +456,50 @@ void RenderManager::Render( Integration::RenderStatus& status, bool forceClear )
     // Mark that we will require a post-render step to be performed (includes swap-buffers).
     status.SetNeedsPostRender( true );
 
-    // switch rendering to adaptor provided (default) buffer
-    mImpl->context.BindFramebuffer( GL_FRAMEBUFFER, 0u );
-
-    mImpl->context.Viewport( mImpl->defaultSurfaceRect.x,
-                             mImpl->defaultSurfaceRect.y,
-                             mImpl->defaultSurfaceRect.width,
-                             mImpl->defaultSurfaceRect.height );
-
-    mImpl->context.ClearColor( mImpl->backgroundColor.r,
-                               mImpl->backgroundColor.g,
-                               mImpl->backgroundColor.b,
-                               mImpl->backgroundColor.a );
-
-    // Clear the entire color, depth and stencil buffers for the default framebuffer, if required.
-    // It is important to clear all 3 buffers when they are being used, for performance on deferred renderers
-    // e.g. previously when the depth & stencil buffers were NOT cleared, it caused the DDK to exceed a "vertex count limit",
-    // and then stall. That problem is only noticeable when rendering a large number of vertices per frame.
-
-    mImpl->context.SetScissorTest( false );
-
-    GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
-
-    mImpl->context.ColorMask( true );
-
-    if( mImpl->depthBufferAvailable == Integration::DepthBufferAvailable::TRUE )
+    // Switch to the shared context
+    if ( mImpl->currentContext != &mImpl->context )
     {
-      mImpl->context.DepthMask( true );
-      clearMask |= GL_DEPTH_BUFFER_BIT;
+      mImpl->currentContext = &mImpl->context;
+      // Clear the current cached program when the context is switched
+      mImpl->programController.ClearCurrentProgram();
     }
 
-    if( mImpl->stencilBufferAvailable == Integration::StencilBufferAvailable::TRUE)
-    {
-      mImpl->context.ClearStencil( 0 );
-      mImpl->context.StencilMask( 0xFF ); // 8 bit stencil mask, all 1's
-      clearMask |= GL_STENCIL_BUFFER_BIT;
-    }
 
-    mImpl->context.Clear( clearMask, Context::FORCE_CLEAR );
+    // Upload the geometries
+    for( uint32_t i = 0; i < count; ++i )
+    {
+      RenderInstruction& instruction = mImpl->instructions.At( mImpl->renderBufferIndex, i );
 
-    // reset the program matrices for all programs once per frame
-    // this ensures we will set view and projection matrix once per program per camera
-    mImpl->programController.ResetProgramMatrices();
+      const Matrix* viewMatrix       = instruction.GetViewMatrix( mImpl->renderBufferIndex );
+      const Matrix* projectionMatrix = instruction.GetProjectionMatrix( mImpl->renderBufferIndex );
+
+      DALI_ASSERT_DEBUG( viewMatrix );
+      DALI_ASSERT_DEBUG( projectionMatrix );
+
+      if( viewMatrix && projectionMatrix )
+      {
+        const RenderListContainer::SizeType renderListCount = instruction.RenderListCount();
+
+        // Iterate through each render list.
+        for( RenderListContainer::SizeType index = 0; index < renderListCount; ++index )
+        {
+          const RenderList* renderList = instruction.GetRenderList( index );
+
+          if( renderList && !renderList->IsEmpty() )
+          {
+            const std::size_t itemCount = renderList->Count();
+            for( uint32_t itemIndex = 0u; itemIndex < itemCount; ++itemIndex )
+            {
+              const RenderItem& item = renderList->GetItem( itemIndex );
+              if( DALI_LIKELY( item.mRenderer ) )
+              {
+                item.mRenderer->Upload( *mImpl->currentContext );
+              }
+            }
+          }
+        }
+      }
+    }
 
     for( uint32_t i = 0; i < count; ++i )
     {
@@ -471,6 +510,10 @@ void RenderManager::Render( Integration::RenderStatus& status, bool forceClear )
 
     GLenum attachments[] = { GL_DEPTH, GL_STENCIL };
     mImpl->context.InvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments);
+    for ( auto&& context : mImpl->surfaceContextContainer )
+    {
+      context->InvalidateFramebuffer(GL_FRAMEBUFFER, 2, attachments);
+    }
 
     //Notify RenderGeometries that rendering has finished
     for ( auto&& iter : mImpl->geometryContainer )
@@ -508,63 +551,155 @@ void RenderManager::DoRender( RenderInstruction& instruction )
     clearColor = Dali::RenderTask::DEFAULT_CLEAR_COLOR;
   }
 
+  Rect<int32_t> surfaceRect = mImpl->defaultSurfaceRect;
+  Vector4 backgroundColor = mImpl->backgroundColor;
+  Integration::DepthBufferAvailable depthBufferAvailable = mImpl->depthBufferAvailable;
+  Integration::StencilBufferAvailable stencilBufferAvailable = mImpl->stencilBufferAvailable;
+
+  Render::SurfaceFrameBuffer* surfaceFrameBuffer = nullptr;
+  if ( ( instruction.mFrameBuffer != 0 ) && instruction.mFrameBuffer->IsSurfaceBacked() )
+  {
+    surfaceFrameBuffer = static_cast<Render::SurfaceFrameBuffer*>( instruction.mFrameBuffer );
+
+#if DALI_GLES_VERSION >= 30
+    Context* surfaceContext = surfaceFrameBuffer->GetContext();
+    if ( mImpl->currentContext != surfaceContext )
+    {
+      // Switch the correct context if rendering to a surface
+      mImpl->currentContext = surfaceContext;
+      // Clear the current cached program when the context is switched
+      mImpl->programController.ClearCurrentProgram();
+    }
+#endif
+
+    surfaceRect = Rect<int32_t>( 0, 0, static_cast<int32_t>( surfaceFrameBuffer->GetWidth() ), static_cast<int32_t>( surfaceFrameBuffer->GetHeight() ) );
+    backgroundColor = surfaceFrameBuffer->GetBackgroundColor();
+  }
+
+  DALI_ASSERT_DEBUG( mImpl->currentContext->IsGlContextCreated() );
+
+  // reset the program matrices for all programs once per frame
+  // this ensures we will set view and projection matrix once per program per camera
+  mImpl->programController.ResetProgramMatrices();
+
+  if( instruction.mFrameBuffer )
+  {
+    instruction.mFrameBuffer->Bind( *mImpl->currentContext );
+  }
+
+  mImpl->currentContext->Viewport( surfaceRect.x,
+                            surfaceRect.y,
+                            surfaceRect.width,
+                            surfaceRect.height );
+
+  mImpl->currentContext->ClearColor( backgroundColor.r,
+                              backgroundColor.g,
+                              backgroundColor.b,
+                              backgroundColor.a );
+
+  // Clear the entire color, depth and stencil buffers for the default framebuffer, if required.
+  // It is important to clear all 3 buffers when they are being used, for performance on deferred renderers
+  // e.g. previously when the depth & stencil buffers were NOT cleared, it caused the DDK to exceed a "vertex count limit",
+  // and then stall. That problem is only noticeable when rendering a large number of vertices per frame.
+
+  mImpl->currentContext->SetScissorTest( false );
+
+  GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
+
+  mImpl->currentContext->ColorMask( true );
+
+  if( depthBufferAvailable == Integration::DepthBufferAvailable::TRUE )
+  {
+    mImpl->currentContext->DepthMask( true );
+    clearMask |= GL_DEPTH_BUFFER_BIT;
+  }
+
+  if( stencilBufferAvailable == Integration::StencilBufferAvailable::TRUE)
+  {
+    mImpl->currentContext->ClearStencil( 0 );
+    mImpl->currentContext->StencilMask( 0xFF ); // 8 bit stencil mask, all 1's
+    clearMask |= GL_STENCIL_BUFFER_BIT;
+  }
+
+  mImpl->currentContext->Clear( clearMask, Context::FORCE_CLEAR );
+
   if( !instruction.mIgnoreRenderToFbo && ( instruction.mFrameBuffer != 0 ) )
   {
-    instruction.mFrameBuffer->Bind( mImpl->context );
-    if ( instruction.mIsViewportSet )
+    if ( instruction.mFrameBuffer->IsSurfaceBacked() ) // Surface rendering
     {
-      // For glViewport the lower-left corner is (0,0)
-      const int32_t y = ( instruction.mFrameBuffer->GetHeight() - instruction.mViewport.height ) - instruction.mViewport.y;
-      viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
+      if ( instruction.mIsViewportSet )
+      {
+        // For glViewport the lower-left corner is (0,0)
+        // For glViewport the lower-left corner is (0,0)
+        const int32_t y = ( surfaceRect.height - instruction.mViewport.height ) - instruction.mViewport.y;
+        viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
+      }
+      else
+      {
+        viewportRect = surfaceRect;
+      }
     }
-    else
+    else // Offscreen buffer rendering
     {
-      viewportRect.Set( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
+      if ( instruction.mIsViewportSet )
+      {
+        // For glViewport the lower-left corner is (0,0)
+        const int32_t y = ( instruction.mFrameBuffer->GetHeight() - instruction.mViewport.height ) - instruction.mViewport.y;
+        viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
+      }
+      else
+      {
+        viewportRect.Set( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
+      }
     }
   }
-  else // !(instruction.mOffscreenTexture)
+  else // No Offscreen frame buffer rendering
   {
-    // switch rendering to adaptor provided (default) buffer
-    mImpl->context.BindFramebuffer( GL_FRAMEBUFFER, 0 );
-
     // Check whether a viewport is specified, otherwise the full surface size is used
-    if ( instruction.mIsViewportSet )
+    if ( instruction.mFrameBuffer != 0 )
     {
-      // For glViewport the lower-left corner is (0,0)
-      const int32_t y = ( mImpl->defaultSurfaceRect.height - instruction.mViewport.height ) - instruction.mViewport.y;
-      viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
+      if ( instruction.mIsViewportSet )
+      {
+        // For glViewport the lower-left corner is (0,0)
+        const int32_t y = ( instruction.mFrameBuffer->GetHeight() - instruction.mViewport.height ) - instruction.mViewport.y;
+        viewportRect.Set( instruction.mViewport.x,  y, instruction.mViewport.width, instruction.mViewport.height );
+      }
+      else
+      {
+        viewportRect.Set( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
+      }
     }
     else
     {
-      viewportRect = mImpl->defaultSurfaceRect;
+      viewportRect = surfaceRect;
     }
   }
 
-  mImpl->context.Viewport(viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height);
+  mImpl->currentContext->Viewport(viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height);
 
   if ( instruction.mIsClearColorSet )
   {
-    mImpl->context.ClearColor( clearColor.r,
-                               clearColor.g,
-                               clearColor.b,
-                               clearColor.a );
+    mImpl->currentContext->ClearColor( clearColor.r,
+                                       clearColor.g,
+                                       clearColor.b,
+                                       clearColor.a );
 
     // Clear the viewport area only
-    mImpl->context.SetScissorTest( true );
-    mImpl->context.Scissor( viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height );
-    mImpl->context.ColorMask( true );
-    mImpl->context.Clear( GL_COLOR_BUFFER_BIT , Context::CHECK_CACHED_VALUES );
-    mImpl->context.SetScissorTest( false );
+    mImpl->currentContext->SetScissorTest( true );
+    mImpl->currentContext->Scissor( viewportRect.x, viewportRect.y, viewportRect.width, viewportRect.height );
+    mImpl->currentContext->ColorMask( true );
+    mImpl->currentContext->Clear( GL_COLOR_BUFFER_BIT , Context::CHECK_CACHED_VALUES );
+    mImpl->currentContext->SetScissorTest( false );
   }
 
   mImpl->renderAlgorithms.ProcessRenderInstruction(
       instruction,
-      mImpl->context,
+      *mImpl->currentContext,
       mImpl->renderBufferIndex,
-      mImpl->depthBufferAvailable,
-      mImpl->stencilBufferAvailable );
+      depthBufferAvailable,
+      stencilBufferAvailable );
 
-  if( instruction.mRenderTracker && ( instruction.mFrameBuffer != NULL ) )
+  if( instruction.mRenderTracker && ( instruction.mFrameBuffer != 0 ) )
   {
     // This will create a sync object every frame this render tracker
     // is alive (though it should be now be created only for
@@ -572,6 +707,11 @@ void RenderManager::DoRender( RenderInstruction& instruction )
     instruction.mRenderTracker->CreateSyncObject( mImpl->glSyncAbstraction );
     instruction.mRenderTracker = NULL; // Only create once.
   }
+
+  if ( surfaceFrameBuffer )
+  {
+    surfaceFrameBuffer->PostRender();
+  }
 }
 
 } // namespace SceneGraph
index 257b12a..9b8799f 100644 (file)
@@ -85,7 +85,7 @@ GpuBuffer::~GpuBuffer()
  * Creates or updates the buffer data depending on whether it
  * already exists or not.
  */
-void GpuBuffer::UpdateDataBuffer(GLsizeiptr size, const GLvoid *data, Usage usage, Target target)
+void GpuBuffer::UpdateDataBuffer(Context& context, GLsizeiptr size, const GLvoid *data, Usage usage, Target target)
 {
   DALI_ASSERT_DEBUG( size > 0 );
   mSize = size;
@@ -101,17 +101,17 @@ void GpuBuffer::UpdateDataBuffer(GLsizeiptr size, const GLvoid *data, Usage usag
   // make sure the buffer is bound, don't perform any checks because size may be zero
   if(ARRAY_BUFFER == target)
   {
-    mContext.BindArrayBuffer( mBufferId );
+    context.BindArrayBuffer( mBufferId );
   }
   else if(ELEMENT_ARRAY_BUFFER == target)
   {
     glTargetEnum = GL_ELEMENT_ARRAY_BUFFER;
-    mContext.BindElementArrayBuffer( mBufferId );
+    context.BindElementArrayBuffer( mBufferId );
   }
   else if(TRANSFORM_FEEDBACK_BUFFER == target)
   {
     glTargetEnum = GL_TRANSFORM_FEEDBACK_BUFFER;
-    mContext.BindTransformFeedbackBuffer( mBufferId );
+    context.BindTransformFeedbackBuffer( mBufferId );
   }
 
   // if the buffer has already been created, just update the data providing it fits
@@ -120,53 +120,53 @@ void GpuBuffer::UpdateDataBuffer(GLsizeiptr size, const GLvoid *data, Usage usag
     // if the data will fit in the existing buffer, just update it
     if (size <= mCapacity )
     {
-      mContext.BufferSubData( glTargetEnum, 0, size, data );
+      context.BufferSubData( glTargetEnum, 0, size, data );
     }
     else
     {
       // create a new buffer of the larger size,
       // gl should automatically deallocate the old buffer
-      mContext.BufferData( glTargetEnum, size, data, ModeAsGlEnum( usage ) );
+      context.BufferData( glTargetEnum, size, data, ModeAsGlEnum( usage ) );
       mCapacity = size;
     }
   }
   else
   {
     // create the buffer
-    mContext.BufferData( glTargetEnum, size, data, ModeAsGlEnum( usage ) );
+    context.BufferData( glTargetEnum, size, data, ModeAsGlEnum( usage ) );
     mBufferCreated = true;
     mCapacity = size;
   }
 
   if(ARRAY_BUFFER == target)
   {
-    mContext.BindArrayBuffer( 0 );
+    context.BindArrayBuffer( 0 );
   }
   else if(ELEMENT_ARRAY_BUFFER == target)
   {
-    mContext.BindElementArrayBuffer( 0 );
+    context.BindElementArrayBuffer( 0 );
   }
   else if(TRANSFORM_FEEDBACK_BUFFER == target)
   {
-    mContext.BindTransformFeedbackBuffer( 0 );
+    context.BindTransformFeedbackBuffer( 0 );
   }
 }
 
-void GpuBuffer::Bind(Target target) const
+void GpuBuffer::Bind(Context& context, Target target) const
 {
   DALI_ASSERT_DEBUG(mCapacity);
 
   if (target == ARRAY_BUFFER)
   {
-    mContext.BindArrayBuffer(mBufferId);
+    context.BindArrayBuffer(mBufferId);
   }
   else if (target == ELEMENT_ARRAY_BUFFER)
   {
-    mContext.BindElementArrayBuffer(mBufferId);
+    context.BindElementArrayBuffer(mBufferId);
   }
   else if (target == TRANSFORM_FEEDBACK_BUFFER)
   {
-    mContext.BindTransformFeedbackBuffer(mBufferId);
+    context.BindTransformFeedbackBuffer(mBufferId);
   }
 }
 
index 7c32719..662a180 100644 (file)
@@ -77,18 +77,21 @@ public:
   /**
    *
    * Creates or updates a buffer object and binds it to the target.
+   * @param context The context to bind the the buffer
    * @param size Specifies the size in bytes of the buffer object's new data store.
    * @param data pointer to the data to load
    * @param usage How the buffer will be used
    * @param target The target buffer to update
    */
-  void UpdateDataBuffer(GLsizeiptr size, const GLvoid *data, Usage usage, Target target);
+  void UpdateDataBuffer(Context& context, GLsizeiptr size, const GLvoid *data, Usage usage, Target target);
 
   /**
    * Bind the buffer object to the target
    * Will assert if the buffer size is zero
+   * @param context The context to bind the the buffer
+   * @param target The target buffer to bind
    */
-  void Bind(Target target) const;
+  void Bind(Context& context, Target target) const;
 
   /**
    * @return true if the GPU buffer is valid, i.e. its created and not empty
@@ -119,7 +122,7 @@ private:
 
 private: // Data
 
-  Context&           mContext;             ///< dali drawing context
+  Context&           mContext;             ///< shared context for dali drawing
   GLsizeiptr         mCapacity;            ///< buffer capacity
   GLsizeiptr         mSize;                ///< buffer size
   GLuint             mBufferId;            ///< buffer object name(id)
index 196630d..16d2a73 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_INTERNAL_RENDER_FRAME_BUFFER_H
 
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -29,80 +29,75 @@ namespace Internal
 {
 namespace Render
 {
-class Texture;
 
 class FrameBuffer
 {
 public:
 
-  using Mask = Dali::FrameBuffer::Attachment::Mask;
-
   /**
    * Constructor
-   * @param[in] width The width of the FrameBuffer
-   * @param[in] height The height of the FrameBuffer
-   * @param[in] attachments The attachments comprising the format of the FrameBuffer (bit-mask)
    */
-  FrameBuffer( uint32_t width, uint32_t height, Mask attachments );
+  FrameBuffer() {};
 
   /**
    * Destructor
    */
-  ~FrameBuffer();
+  virtual ~FrameBuffer() {};
 
   /**
    * Creates a FrameBuffer object in the GPU.
    * @param[in] context The GL context
    */
-  void Initialize(Context& context);
+  virtual void Initialize( Context& context ) = 0;
 
   /**
    * Deletes the framebuffer object from the GPU
    * @param[in] context The GL context
    */
-  void Destroy( Context& context );
+  virtual void Destroy( Context& context ) = 0;
 
   /**
    * Called by RenderManager to inform the framebuffer that the context has been destroyed
    */
-  void GlContextDestroyed();
-
-  /**
-   * @brief Attach a texture for color rendering. Valid only for Framebuffers with COLOR attachments.
-   * param[in] context The GL context
-   * @param[in] texture The texture that will be used as output when rendering
-   * @param[in] mipmapLevel The mipmap of the texture to be attached
-   * @param[in] layer Indicates which layer of a cube map or array texture to attach. Unused for 2D textures
-   */
-  void AttachColorTexture( Context& context, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer );
+  virtual void GlContextDestroyed() = 0;
 
   /**
    * @brief Bind the framebuffer
    * @param[in] context The GL context
    */
-  void Bind( Context& context );
+  virtual void Bind( Context& context ) = 0;
 
   /**
    * @brief Get the width of the FrameBuffer
    * @return The width of the framebuffer
    */
-  uint32_t GetWidth() const;
+  virtual uint32_t GetWidth() const = 0;
 
   /**
    * @brief Get the height of the FrameBuffer
    * @return The height of the framebuffer
    */
-  uint32_t GetHeight() const;
+  virtual uint32_t GetHeight() const = 0;
+
+  /**
+   * @brief Check whether the FrameBuffer is backed by a render surface
+   * @return True if the FrameBuffer is backed by a render surface
+   */
+  virtual bool IsSurfaceBacked() = 0;
 
 private:
 
-  GLuint mId;
-  GLuint mDepthBuffer;
-  GLuint mStencilBuffer;
-  uint32_t mWidth;
-  uint32_t mHeight;
-};
+  /**
+   * @brief Undefined copy constructor. FrameBuffer cannot be copied
+   */
+  FrameBuffer( const FrameBuffer& rhs ) = delete;
 
+  /**
+   * @brief Undefined assignment operator. FrameBuffer cannot be copied
+   */
+  FrameBuffer& operator=( const FrameBuffer& rhs ) = delete;
+
+};
 
 } // namespace Render
 
index afc96ba..17ba522 100644 (file)
@@ -109,12 +109,7 @@ void Geometry::OnRenderFinished()
   mAttributesChanged = false;
 }
 
-void Geometry::UploadAndDraw(
-    Context& context,
-    BufferIndex bufferIndex,
-    Vector<GLint>& attributeLocation,
-    uint32_t elementBufferOffset,
-    uint32_t elementBufferCount )
+void Geometry::Upload( Context& context )
 {
   if( !mHasBeenUpdated )
   {
@@ -133,7 +128,7 @@ void Geometry::UploadAndDraw(
         }
 
         uint32_t bufferSize = static_cast<uint32_t>( sizeof( uint16_t ) * mIndices.Size() );
-        mIndexBuffer->UpdateDataBuffer( bufferSize, &mIndices[0], GpuBuffer::STATIC_DRAW, GpuBuffer::ELEMENT_ARRAY_BUFFER );
+        mIndexBuffer->UpdateDataBuffer( context, bufferSize, &mIndices[0], GpuBuffer::STATIC_DRAW, GpuBuffer::ELEMENT_ARRAY_BUFFER );
       }
 
       mIndicesChanged = false;
@@ -150,13 +145,21 @@ void Geometry::UploadAndDraw(
 
     mHasBeenUpdated = true;
   }
+}
 
+void Geometry::Draw(
+    Context& context,
+    BufferIndex bufferIndex,
+    Vector<GLint>& attributeLocation,
+    uint32_t elementBufferOffset,
+    uint32_t elementBufferCount )
+{
   //Bind buffers to attribute locations
   uint32_t base = 0u;
   const uint32_t vertexBufferCount = static_cast<uint32_t>( mVertexBuffers.Count() );
   for( uint32_t i = 0; i < vertexBufferCount; ++i )
   {
-    mVertexBuffers[i]->BindBuffer( GpuBuffer::ARRAY_BUFFER );
+    mVertexBuffers[i]->BindBuffer( context, GpuBuffer::ARRAY_BUFFER );
     base += mVertexBuffers[i]->EnableVertexAttributes( context, attributeLocation, base );
   }
 
@@ -223,7 +226,7 @@ void Geometry::UploadAndDraw(
   if( mIndexBuffer && geometryGLType != GL_POINTS )
   {
     //Indexed draw call
-    mIndexBuffer->Bind( GpuBuffer::ELEMENT_ARRAY_BUFFER );
+    mIndexBuffer->Bind( context, GpuBuffer::ELEMENT_ARRAY_BUFFER );
     // numIndices truncated, no value loss happening in practice
     context.DrawElements( geometryGLType, static_cast<GLsizei>( numIndices ), GL_UNSIGNED_SHORT, reinterpret_cast<void*>( firstIndexOffset ) );
   }
index 4e12e1c..f08cbce 100644 (file)
@@ -116,19 +116,24 @@ public:
   }
 
   /**
-   * Upload the geometry if it has changed, set up the attributes and perform
-   * the Draw call corresponding to the geometry type
+   * Upload the geometry if it has changed
+   * @param[in] context The GL context
+   */
+  void Upload( Context& context );
+
+  /**
+   * Set up the attributes and perform the Draw call corresponding to the geometry type
    * @param[in] context The GL context
    * @param[in] bufferIndex The current buffer index
    * @param[in] attributeLocation The location for the attributes in the shader
    * @param[in] elementBufferOffset The index of first element to draw if index buffer bound
    * @param[in] elementBufferCount Number of elements to draw if index buffer bound, uses whole buffer when 0
    */
-  void UploadAndDraw(Context& context,
-                     BufferIndex bufferIndex,
-                     Vector<GLint>& attributeLocation,
-                     uint32_t elementBufferOffset,
-                     uint32_t elementBufferCount );
+  void Draw(Context& context,
+            BufferIndex bufferIndex,
+            Vector<GLint>& attributeLocation,
+            uint32_t elementBufferOffset,
+            uint32_t elementBufferCount );
 
 private:
 
index 5197837..5976020 100644 (file)
@@ -160,7 +160,7 @@ bool PropertyBuffer::Update( Context& context )
     if ( mGpuBuffer )
     {
       DALI_ASSERT_DEBUG( mSize && "No data in the property buffer!" );
-      mGpuBuffer->UpdateDataBuffer( GetDataSize(), &((*mData)[0]), GpuBuffer::STATIC_DRAW, GpuBuffer::ARRAY_BUFFER );
+      mGpuBuffer->UpdateDataBuffer( context, GetDataSize(), &((*mData)[0]), GpuBuffer::STATIC_DRAW, GpuBuffer::ARRAY_BUFFER );
     }
 
     mDataChanged = false;
@@ -169,11 +169,11 @@ bool PropertyBuffer::Update( Context& context )
   return true;
 }
 
-void PropertyBuffer::BindBuffer(GpuBuffer::Target target)
+void PropertyBuffer::BindBuffer( Context& context, GpuBuffer::Target target )
 {
   if(mGpuBuffer)
   {
-    mGpuBuffer->Bind(target);
+    mGpuBuffer->Bind(context, target);
   }
 }
 
index 436bd06..13771f5 100644 (file)
@@ -89,9 +89,10 @@ public:
 
   /**
    * @brief Bind the property buffer
+   * @param context The context to bind the the buffer
    * @param[in] target The binding point
    */
-  void BindBuffer(GpuBuffer::Target target);
+  void BindBuffer( Context& context, GpuBuffer::Target target );
 
   /**
    * Perform the upload of the buffer only when requiered
index 4beee2e..2222abd 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -506,6 +506,11 @@ StencilOperation::Type Renderer::GetStencilOperationOnZPass() const
   return mStencilParameters.stencilOperationOnZPass;
 }
 
+void Renderer::Upload( Context& context )
+{
+  mGeometry->Upload( context );
+}
+
 void Renderer::Render( Context& context,
                        BufferIndex bufferIndex,
                        const SceneGraph::NodeDataProvider& node,
@@ -564,11 +569,11 @@ void Renderer::Render( Context& context,
       mUpdateAttributesLocation = false;
     }
 
-    mGeometry->UploadAndDraw( context,
-                              bufferIndex,
-                              mAttributesLocation,
-                              mIndexedDrawFirstElement,
-                              mIndexedDrawElementsCount );
+    mGeometry->Draw( context,
+                     bufferIndex,
+                     mAttributesLocation,
+                     mIndexedDrawFirstElement,
+                     mIndexedDrawElementsCount );
   }
 }
 
index 1f8d99e..66e33aa 100755 (executable)
@@ -2,7 +2,7 @@
 #define DALI_INTERNAL_RENDER_RENDERER_H
 
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -335,6 +335,12 @@ public:
   StencilOperation::Type GetStencilOperationOnZPass() const;
 
   /**
+   * Called to upload during RenderManager::Render().
+   * @param[in] context The context used for uploading
+   */
+  void Upload( Context& context );
+
+  /**
    * Called to render during RenderManager::Render().
    * @param[in] context The context used for rendering
    * @param[in] bufferIndex The index of the previous update buffer.
diff --git a/dali/internal/render/renderers/render-surface-frame-buffer.cpp b/dali/internal/render/renderers/render-surface-frame-buffer.cpp
new file mode 100644 (file)
index 0000000..7cc38bb
--- /dev/null
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2019 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 <dali/internal/render/renderers/render-surface-frame-buffer.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/render/renderers/render-texture.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Render
+{
+
+SurfaceFrameBuffer::SurfaceFrameBuffer( Integration::RenderSurface* surface )
+: FrameBuffer(),
+  mSurface( surface ),
+  mContext( nullptr )
+{
+}
+
+SurfaceFrameBuffer::~SurfaceFrameBuffer()
+{}
+
+void SurfaceFrameBuffer::Destroy( Context& context )
+{
+}
+
+void SurfaceFrameBuffer::GlContextDestroyed()
+{
+  if ( mContext )
+  {
+    mContext->GlContextDestroyed();
+  }
+}
+
+void SurfaceFrameBuffer::Initialize(Context& context)
+{
+  mContext = &context;
+  mContext->GlContextCreated();
+  mSurface->InitializeGraphics();
+}
+
+void SurfaceFrameBuffer::Bind( Context& context )
+{
+  mSurface->PreRender( false );
+  context.BindFramebuffer( GL_FRAMEBUFFER, 0u );
+}
+
+uint32_t SurfaceFrameBuffer::GetWidth() const
+{
+  return mSurface->GetPositionSize().width;
+}
+
+uint32_t SurfaceFrameBuffer::GetHeight() const
+{
+  return mSurface->GetPositionSize().height;
+}
+
+void SurfaceFrameBuffer::PostRender()
+{
+  mSurface->PostRender( false, false, false );
+}
+
+Context* SurfaceFrameBuffer::GetContext()
+{
+  return mContext;
+}
+
+Integration::DepthBufferAvailable SurfaceFrameBuffer::GetDepthBufferRequired()
+{
+  return mSurface->GetDepthBufferRequired();
+}
+
+Integration::StencilBufferAvailable SurfaceFrameBuffer::GetStencilBufferRequired()
+{
+  return mSurface->GetStencilBufferRequired();
+}
+
+Vector4 SurfaceFrameBuffer::GetBackgroundColor()
+{
+  return mSurface->GetBackgroundColor();
+}
+
+} //Render
+
+} //Internal
+
+} //Dali
diff --git a/dali/internal/render/renderers/render-surface-frame-buffer.h b/dali/internal/render/renderers/render-surface-frame-buffer.h
new file mode 100644 (file)
index 0000000..576ea65
--- /dev/null
@@ -0,0 +1,130 @@
+#ifndef DALI_INTERNAL_RENDER_SURFACE_FRAME_BUFFER_H
+#define DALI_INTERNAL_RENDER_SURFACE_FRAME_BUFFER_H
+
+/*
+ * Copyright (c) 2019 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 <dali/internal/render/renderers/render-frame-buffer.h>
+#include <dali/integration-api/render-surface.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+class Context;
+
+namespace Render
+{
+
+class SurfaceFrameBuffer : public FrameBuffer
+{
+public:
+
+  /**
+   * Constructor
+   * @param[in] surface The render surface
+   */
+  SurfaceFrameBuffer( Integration::RenderSurface* surface );
+
+  /**
+   * Destructor
+   */
+  virtual ~SurfaceFrameBuffer();
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::Initialize()
+   */
+  void Initialize( Context& context ) override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::Destroy()
+   */
+  void Destroy( Context& context ) override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::GlContextDestroyed()
+   */
+  void GlContextDestroyed() override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::Bind()
+   */
+  void Bind( Context& context ) override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::GetWidth()
+   */
+  uint32_t GetWidth() const override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::GetHeight()
+   */
+  uint32_t GetHeight() const override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::IsSurfaceBacked()
+   */
+  bool IsSurfaceBacked() override { return true; };
+
+public:
+
+  /**
+   * Called after this frame buffer is rendered in the render manager
+   */
+  void PostRender();
+
+  /**
+   * Gets the context holding the GL state of rendering for the surface
+   * @return the context
+   */
+  Context* GetContext();
+
+  /**
+   * @brief Gets whether the depth buffer is required
+   * @return TRUE if the depth buffer is required
+   */
+  Integration::DepthBufferAvailable GetDepthBufferRequired();
+
+  /**
+   * @brief Gets whether the stencil buffer is required
+   * @return TRUE if the stencil buffer is required
+   */
+  Integration::StencilBufferAvailable GetStencilBufferRequired();
+
+  /**
+   * @brief Gets the background color of the surface.
+   * @return The background color
+   */
+  Vector4 GetBackgroundColor();
+
+private:
+
+  Integration::RenderSurface* mSurface;   ///< The render surface
+  Context*                    mContext;   ///< The context holding the GL state of rendering for the surface backed frame buffer
+};
+
+
+} // namespace Render
+
+} // namespace Internal
+
+} // namespace Dali
+
+
+#endif // DALI_INTERNAL_RENDER_SURFACE_FRAME_BUFFER_H
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -15,7 +15,7 @@
  */
 
 // CLASS HEADER
-#include <dali/internal/render/renderers/render-frame-buffer.h>
+#include <dali/internal/render/renderers/render-texture-frame-buffer.h>
 
 // INTERNAL INCLUDES
 #include <dali/internal/render/renderers/render-texture.h>
@@ -27,19 +27,20 @@ namespace Internal
 namespace Render
 {
 
-FrameBuffer::FrameBuffer( uint32_t width, uint32_t height, Mask attachments )
-:mId( 0u ),
- mDepthBuffer( attachments & Dali::FrameBuffer::Attachment::DEPTH ),
- mStencilBuffer( attachments & Dali::FrameBuffer::Attachment::STENCIL ),
- mWidth( width ),
- mHeight( height )
+TextureFrameBuffer::TextureFrameBuffer( uint32_t width, uint32_t height, Mask attachments )
+: FrameBuffer(),
+  mId( 0u ),
+  mDepthBuffer( attachments & Dali::FrameBuffer::Attachment::DEPTH ),
+  mStencilBuffer( attachments & Dali::FrameBuffer::Attachment::STENCIL ),
+  mWidth( width ),
+  mHeight( height )
 {
 }
 
-FrameBuffer::~FrameBuffer()
+TextureFrameBuffer::~TextureFrameBuffer()
 {}
 
-void FrameBuffer::Destroy( Context& context )
+void TextureFrameBuffer::Destroy( Context& context )
 {
   if( mId )
   {
@@ -47,12 +48,12 @@ void FrameBuffer::Destroy( Context& context )
   }
 }
 
-void FrameBuffer::GlContextDestroyed()
+void TextureFrameBuffer::GlContextDestroyed()
 {
   mId = 0u;
 }
 
-void FrameBuffer::Initialize(Context& context)
+void TextureFrameBuffer::Initialize(Context& context)
 {
   context.GenFramebuffers( 1, &mId );
   context.BindFramebuffer( GL_FRAMEBUFFER, mId );
@@ -78,7 +79,7 @@ void FrameBuffer::Initialize(Context& context)
   context.BindFramebuffer( GL_FRAMEBUFFER, 0 );
 }
 
-void FrameBuffer::AttachColorTexture( Context& context, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
+void TextureFrameBuffer::AttachColorTexture( Context& context, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
 {
   context.BindFramebuffer( GL_FRAMEBUFFER, mId );
 
@@ -103,17 +104,17 @@ void FrameBuffer::AttachColorTexture( Context& context, Render::Texture* texture
   context.BindFramebuffer( GL_FRAMEBUFFER, 0 );
 }
 
-void FrameBuffer::Bind( Context& context )
+void TextureFrameBuffer::Bind( Context& context )
 {
   context.BindFramebuffer( GL_FRAMEBUFFER, mId );
 }
 
-uint32_t FrameBuffer::GetWidth() const
+uint32_t TextureFrameBuffer::GetWidth() const
 {
   return mWidth;
 }
 
-uint32_t FrameBuffer::GetHeight() const
+uint32_t TextureFrameBuffer::GetHeight() const
 {
   return mHeight;
 }
diff --git a/dali/internal/render/renderers/render-texture-frame-buffer.h b/dali/internal/render/renderers/render-texture-frame-buffer.h
new file mode 100644 (file)
index 0000000..021890f
--- /dev/null
@@ -0,0 +1,111 @@
+#ifndef DALI_INTERNAL_RENDER_TEXTURE_FRAME_BUFFER_H
+#define DALI_INTERNAL_RENDER_TEXTURE_FRAME_BUFFER_H
+
+/*
+ * Copyright (c) 2019 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 <dali/internal/render/renderers/render-frame-buffer.h>
+
+namespace Dali
+{
+using Mask = Dali::FrameBuffer::Attachment::Mask;
+
+namespace Internal
+{
+namespace Render
+{
+class Texture;
+
+class TextureFrameBuffer : public FrameBuffer
+{
+public:
+
+  /**
+   * Constructor
+   * @param[in] width The width of the FrameBuffer
+   * @param[in] height The height of the FrameBuffer
+   * @param[in] attachments The attachments comprising the format of the FrameBuffer (bit-mask)
+   */
+  TextureFrameBuffer( uint32_t width, uint32_t height, Mask attachments );
+
+  /**
+   * Destructor
+   */
+  virtual ~TextureFrameBuffer();
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::Initialize()
+   */
+  void Initialize( Context& context ) override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::Destroy()
+   */
+  void Destroy( Context& context ) override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::GlContextDestroyed()
+   */
+  void GlContextDestroyed() override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::Bind()
+   */
+  void Bind( Context& context ) override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::GetWidth()
+   */
+  uint32_t GetWidth() const override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::GetHeight()
+   */
+  uint32_t GetHeight() const override;
+
+  /**
+   * @copydoc Dali::Internal::Renderer::FrameBuffer::IsSurfaceBacked()
+   */
+  bool IsSurfaceBacked() override { return false; };
+
+  /**
+   * @brief Attach a texture for color rendering. Valid only for Framebuffers with COLOR attachments.
+   * param[in] context The GL context
+   * @param[in] texture The texture that will be used as output when rendering
+   * @param[in] mipmapLevel The mipmap of the texture to be attached
+   * @param[in] layer Indicates which layer of a cube map or array texture to attach. Unused for 2D textures
+   */
+  void AttachColorTexture( Context& context, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer );
+
+private:
+
+  GLuint mId;
+  GLuint mDepthBuffer;
+  GLuint mStencilBuffer;
+  uint32_t mWidth;
+  uint32_t mHeight;
+};
+
+
+} // namespace Render
+
+} // namespace Internal
+
+} // namespace Dali
+
+
+#endif // DALI_INTERNAL_RENDER_TEXTURE_FRAME_BUFFER_H
index cde611d..87c268e 100644 (file)
@@ -155,6 +155,11 @@ void ProgramController::SetShaderSaver( ShaderSaver& shaderSaver )
   mShaderSaver = &shaderSaver;
 }
 
+void ProgramController::ClearCurrentProgram()
+{
+  SetCurrentProgram( nullptr );
+}
+
 } // namespace Internal
 
 } // namespace Dali
index 9c3945e..25c40ca 100644 (file)
@@ -124,6 +124,11 @@ public: // API
    */
   void SetShaderSaver( ShaderSaver& shaderSaver );
 
+  /**
+   * Clear current cached program
+   */
+  void ClearCurrentProgram();
+
 private: // From ProgramCache
 
   /**
index 1e12967..6c30d58 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -237,8 +237,9 @@ bool ProcessTasks( BufferIndex updateBufferIndex,
     const bool isDefaultRenderTask = isFirstRenderTask;
     isFirstRenderTask = false;
 
-    if( ( !renderToFboEnabled && ( ( !processOffscreen && hasFrameBuffer ) ||
-                                   ( processOffscreen && !hasFrameBuffer ) ) ) ||
+    const bool isSurfaceBacked = hasFrameBuffer && renderTask.GetFrameBuffer()->IsSurfaceBacked();
+    if( ( !renderToFboEnabled && ( ( !processOffscreen && hasFrameBuffer && !isSurfaceBacked ) ||
+                                   ( processOffscreen && ( !hasFrameBuffer || isSurfaceBacked ) ) ) ) ||
         ( renderToFboEnabled && ( ( processOffscreen && !hasFrameBuffer ) ||
                                   ( isDefaultRenderTask && processOffscreen ) ||
                                   ( !isDefaultRenderTask && !processOffscreen && hasFrameBuffer ) ) ) ||
index 116ccd3..bf96442 100644 (file)
@@ -135,7 +135,7 @@ private:
 
 // Messages for RenderTaskList
 
-inline void AddTaskMessage( EventThreadServices& eventThreadServices, RenderTaskList& list, OwnerPointer< RenderTask >& task )
+inline void AddTaskMessage( EventThreadServices& eventThreadServices, const RenderTaskList& list, OwnerPointer< RenderTask >& task )
 {
   // Message has ownership of the RenderTask while in transit from event -> update
   typedef MessageValue1< RenderTaskList, OwnerPointer< RenderTask > > LocalType;
@@ -147,7 +147,7 @@ inline void AddTaskMessage( EventThreadServices& eventThreadServices, RenderTask
   new (slot) LocalType( &list, &RenderTaskList::AddTask, task );
 }
 
-inline void RemoveTaskMessage( EventThreadServices& eventThreadServices, RenderTaskList& list, const RenderTask& constTask )
+inline void RemoveTaskMessage( EventThreadServices& eventThreadServices, const RenderTaskList& list, const RenderTask& constTask )
 {
   // Scene graph thread can destroy this object.
   RenderTask& task = const_cast< RenderTask& >( constTask );
index 401a0e1..36cfeef 100644 (file)
@@ -135,7 +135,8 @@ public:
   /**
    * @brief Creates a CameraActor object.
    *
-   * Sets the default camera perspective projection for the stage's size. @see SetPerspectiveProjection().
+   * @note No default camera perspective projection is set by this method. @see SetPerspectiveProjection().
+   *
    * @SINCE_1_0.0
    * @return The newly created camera actor
    */
@@ -332,12 +333,9 @@ public:
    * and the Z position of the actor based on the canvas size so that 1 unit in
    * XY (z=0) plane is 1 pixel on screen.
    *
-   * If the canvas size is ZERO, it sets the default camera perspective
-   * projection for the stage's size.
-   *
    * @SINCE_1_0.0
    * @param[in] size The canvas size
-   * @pre If size is non ZERO, \e width and \e height must be greater than zero.
+   * @pre The canvas size must be greater than zero.
    *
    */
   void SetPerspectiveProjection( const Size& size );
index 362bde2..243fe27 100644 (file)
@@ -24,6 +24,7 @@
 #include <dali/internal/event/common/object-registry-impl.h>
 #include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/event/common/type-registry-impl.h>
+#include <dali/internal/event/common/thread-local-storage.h>
 
 namespace Dali
 {
@@ -38,20 +39,21 @@ BaseObject::~BaseObject()
 
 void BaseObject::RegisterObject()
 {
-  Internal::Stage* stage = Internal::Stage::GetCurrent();
-  if( stage )
+  Internal::ThreadLocalStorage* tls = Internal::ThreadLocalStorage::GetInternal();
+  if ( tls )
   {
-    stage->RegisterObject( this );
+    tls->GetEventThreadServices().RegisterObject( this );
   }
 }
 
 void BaseObject::UnregisterObject()
 {
+  Internal::ThreadLocalStorage* tls = Internal::ThreadLocalStorage::GetInternal();
+
   // Guard to allow handle destruction after Core has been destroyed
-  Internal::Stage* stage = Internal::Stage::GetCurrent();
-  if( stage )
+  if( tls )
   {
-    stage->UnregisterObject( this );
+    tls->GetEventThreadServices().UnregisterObject( this );
   }
 }