dali-scene3d/internal/controls/scene-view/scene-view-impl.cpp

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-scene3d/internal/controls/scene-view/scene-view-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali-toolkit/dali-toolkit.h>
  23 #include <dali-toolkit/devel-api/controls/control-devel.h>
  24 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  25 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  26 #include <dali-toolkit/public-api/image-loader/image-url.h>
  27 #include <dali-toolkit/public-api/image-loader/image.h>
  28 #include <dali/devel-api/actors/camera-actor-devel.h>
  29 #include <dali/devel-api/adaptor-framework/window-devel.h>
  30 #include <dali/devel-api/common/stage.h>
  31 #include <dali/devel-api/rendering/frame-buffer-devel.h>
  32 #include <dali/integration-api/adaptor-framework/adaptor.h>
  33 #include <dali/integration-api/debug.h>
  34 #include <dali/public-api/math/math-utils.h>
  35 #include <dali/public-api/object/type-registry-helper.h>
  36 #include <dali/public-api/object/type-registry.h>
  37 #include <string_view>
  38
  39 // INTERNAL INCLUDES
  40 #include <dali-scene3d/internal/controls/model/model-impl.h>
  41 #include <dali-scene3d/internal/graphics/builtin-shader-extern-gen.h>
  42 #include <dali-scene3d/internal/light/light-impl.h>
  43
  44 #include <dali/integration-api/debug.h>
  45
  46 using namespace Dali;
  47
  48 namespace Dali
  49 {
  50 namespace Scene3D
  51 {
  52 namespace Internal
  53 {
  54 namespace
  55 {
  56 BaseHandle Create()
  57 {
  58   return Scene3D::SceneView::New();
  59 }
  60
  61 // Setup properties, signals and actions using the type-registry.
  62 DALI_TYPE_REGISTRATION_BEGIN(Scene3D::SceneView, Toolkit::Control, Create);
  63 DALI_TYPE_REGISTRATION_END()
  64
  65 Property::Index   RENDERING_BUFFER    = Dali::Toolkit::Control::CONTROL_PROPERTY_END_INDEX + 1;
  66 constexpr int32_t DEFAULT_ORIENTATION = 0;
  67 constexpr int32_t INVALID_INDEX       = -1;
  68
  69 static constexpr std::string_view SKYBOX_INTENSITY_STRING = "uIntensity";
  70
  71 Dali::Actor CreateSkybox()
  72 {
  73   struct Vertex
  74   {
  75     Vector3 aPosition;
  76   };
  77
  78   Vertex skyboxVertices[] = {
  79     // back
  80     {Vector3(-1.0f, 1.0f, -1.0f)},
  81     {Vector3(-1.0f, -1.0f, -1.0f)},
  82     {Vector3(1.0f, -1.0f, -1.0f)},
  83     {Vector3(1.0f, -1.0f, -1.0f)},
  84     {Vector3(1.0f, 1.0f, -1.0f)},
  85     {Vector3(-1.0f, 1.0f, -1.0f)},
  86
  87     // left
  88     {Vector3(-1.0f, -1.0f, 1.0f)},
  89     {Vector3(-1.0f, -1.0f, -1.0f)},
  90     {Vector3(-1.0f, 1.0f, -1.0f)},
  91     {Vector3(-1.0f, 1.0f, -1.0f)},
  92     {Vector3(-1.0f, 1.0f, 1.0f)},
  93     {Vector3(-1.0f, -1.0f, 1.0f)},
  94
  95     // right
  96     {Vector3(1.0f, -1.0f, -1.0f)},
  97     {Vector3(1.0f, -1.0f, 1.0f)},
  98     {Vector3(1.0f, 1.0f, 1.0f)},
  99     {Vector3(1.0f, 1.0f, 1.0f)},
 100     {Vector3(1.0f, 1.0f, -1.0f)},
 101     {Vector3(1.0f, -1.0f, -1.0f)},
 102
 103     // front
 104     {Vector3(-1.0f, -1.0f, 1.0f)},
 105     {Vector3(-1.0f, 1.0f, 1.0f)},
 106     {Vector3(1.0f, 1.0f, 1.0f)},
 107     {Vector3(1.0f, 1.0f, 1.0f)},
 108     {Vector3(1.0f, -1.0f, 1.0f)},
 109     {Vector3(-1.0f, -1.0f, 1.0f)},
 110
 111     // botton
 112     {Vector3(-1.0f, 1.0f, -1.0f)},
 113     {Vector3(1.0f, 1.0f, -1.0f)},
 114     {Vector3(1.0f, 1.0f, 1.0f)},
 115     {Vector3(1.0f, 1.0f, 1.0f)},
 116     {Vector3(-1.0f, 1.0f, 1.0f)},
 117     {Vector3(-1.0f, 1.0f, -1.0f)},
 118
 119     // top
 120     {Vector3(-1.0f, -1.0f, -1.0f)},
 121     {Vector3(-1.0f, -1.0f, 1.0f)},
 122     {Vector3(1.0f, -1.0f, -1.0f)},
 123     {Vector3(1.0f, -1.0f, -1.0f)},
 124     {Vector3(-1.0f, -1.0f, 1.0f)},
 125     {Vector3(1.0f, -1.0f, 1.0f)}};
 126
 127   Dali::VertexBuffer vertexBuffer = Dali::VertexBuffer::New(Property::Map().Add("aPosition", Property::VECTOR3));
 128   vertexBuffer.SetData(skyboxVertices, sizeof(skyboxVertices) / sizeof(Vertex));
 129
 130   Dali::Geometry skyboxGeometry = Geometry::New();
 131   skyboxGeometry.AddVertexBuffer(vertexBuffer);
 132   skyboxGeometry.SetType(Geometry::TRIANGLES);
 133
 134   Dali::Shader   shaderSkybox = Shader::New(SHADER_SKYBOX_SHADER_VERT.data(), SHADER_SKYBOX_SHADER_FRAG.data());
 135   Dali::Renderer skyboxRenderer;
 136   skyboxRenderer = Renderer::New(skyboxGeometry, shaderSkybox);
 137   skyboxRenderer.SetProperty(Renderer::Property::DEPTH_INDEX, 2.0f);
 138   // Enables the depth test.
 139   skyboxRenderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON);
 140   // The fragment shader will run only is those pixels that have the max depth value.
 141   skyboxRenderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS_EQUAL);
 142
 143   Dali::Actor skyboxActor = Actor::New();
 144   skyboxActor.SetProperty(Dali::Actor::Property::NAME, "SkyBox");
 145   skyboxActor.SetProperty(Dali::Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 146   skyboxActor.SetProperty(Dali::Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
 147   skyboxActor.AddRenderer(skyboxRenderer);
 148   return skyboxActor;
 149 }
 150
 151 } // anonymous namespace
 152
 153 SceneView::SceneView()
 154 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
 155   mWindowOrientation(DEFAULT_ORIENTATION),
 156   mSkybox(),
 157   mSkyboxOrientation(Quaternion()),
 158   mSkyboxIntensity(1.0f),
 159   mShaderManager(new Scene3D::Loader::ShaderManager())
 160 {
 161 }
 162
 163 SceneView::~SceneView()
 164 {
 165   if(Dali::Adaptor::IsAvailable())
 166   {
 167     if(mIblDiffuseLoadTask)
 168     {
 169       Dali::AsyncTaskManager::Get().RemoveTask(mIblDiffuseLoadTask);
 170       mIblDiffuseLoadTask.Reset();
 171     }
 172     if(mIblSpecularLoadTask)
 173     {
 174       Dali::AsyncTaskManager::Get().RemoveTask(mIblSpecularLoadTask);
 175       mIblSpecularLoadTask.Reset();
 176     }
 177     if(mSkyboxLoadTask)
 178     {
 179       Dali::AsyncTaskManager::Get().RemoveTask(mSkyboxLoadTask);
 180       mSkyboxLoadTask.Reset();
 181     }
 182   }
 183 }
 184
 185 Dali::Scene3D::SceneView SceneView::New()
 186 {
 187   SceneView* impl = new SceneView();
 188
 189   Dali::Scene3D::SceneView handle = Dali::Scene3D::SceneView(*impl);
 190
 191   // Second-phase init of the implementation
 192   // This can only be done after the CustomActor connection has been made...
 193   impl->Initialize();
 194
 195   return handle;
 196 }
 197
 198 void SceneView::AddCamera(CameraActor camera)
 199 {
 200   if(camera)
 201   {
 202     if(mCameras.empty())
 203     {
 204       UpdateCamera(camera);
 205     }
 206     mCameras.push_back(camera);
 207   }
 208 }
 209
 210 void SceneView::RemoveCamera(CameraActor camera)
 211 {
 212   if(camera == mDefaultCamera)
 213   {
 214     DALI_LOG_ERROR("Default Camera cannot removed.\n");
 215     return;
 216   }
 217
 218   if(camera)
 219   {
 220     for(uint32_t i = 0; i < mCameras.size(); ++i)
 221     {
 222       if(mCameras[i] == camera)
 223       {
 224         mCameras.erase(mCameras.begin() + i);
 225         break;
 226       }
 227     }
 228
 229     if(mSelectedCamera == camera)
 230     {
 231       CameraActor newCurrentCamera = *mCameras.begin();
 232       UpdateCamera(newCurrentCamera);
 233     }
 234   }
 235 }
 236
 237 uint32_t SceneView::GetCameraCount() const
 238 {
 239   return mCameras.size();
 240 }
 241
 242 CameraActor SceneView::GetSelectedCamera() const
 243 {
 244   return mSelectedCamera;
 245 }
 246
 247 CameraActor SceneView::GetCamera(uint32_t index) const
 248 {
 249   if(index < mCameras.size())
 250   {
 251     return mCameras[index];
 252   }
 253   DALI_LOG_ERROR("Input index is out of bounds\n");
 254   return CameraActor();
 255 }
 256
 257 CameraActor SceneView::GetCamera(const std::string& name) const
 258 {
 259   CameraActor returnCamera;
 260   for(auto&& camera : mCameras)
 261   {
 262     if(camera.GetProperty<std::string>(Actor::Property::NAME) == name)
 263     {
 264       returnCamera = camera;
 265       break;
 266     }
 267   }
 268   return returnCamera;
 269 }
 270
 271 void SceneView::SelectCamera(uint32_t index)
 272 {
 273   UpdateCamera(GetCamera(index));
 274 }
 275
 276 void SceneView::SelectCamera(const std::string& name)
 277 {
 278   UpdateCamera(GetCamera(name));
 279 }
 280
 281 void SceneView::RegisterSceneItem(Scene3D::Internal::LightObserver* item)
 282 {
 283   if(item)
 284   {
 285     item->NotifyImageBasedLightTexture(mDiffuseTexture, mSpecularTexture, mIblScaleFactor, mSpecularMipmapLevels);
 286     mItems.push_back(item);
 287   }
 288 }
 289
 290 void SceneView::UnregisterSceneItem(Scene3D::Internal::LightObserver* item)
 291 {
 292   if(item)
 293   {
 294     for(uint32_t i = 0; i < mItems.size(); ++i)
 295     {
 296       if(mItems[i] == item)
 297       {
 298         mItems.erase(mItems.begin() + i);
 299         break;
 300       }
 301     }
 302   }
 303 }
 304
 305 void SceneView::SetImageBasedLightSource(const std::string& diffuseUrl, const std::string& specularUrl, float scaleFactor)
 306 {
 307   bool needIblReset = false;
 308   bool isOnScene    = Self().GetProperty<bool>(Dali::Actor::Property::CONNECTED_TO_SCENE);
 309   if(mDiffuseIblUrl != diffuseUrl)
 310   {
 311     mDiffuseIblUrl = diffuseUrl;
 312     if(mDiffuseIblUrl.empty())
 313     {
 314       needIblReset = true;
 315     }
 316     else
 317     {
 318       mIblDiffuseDirty         = true;
 319       mIblDiffuseResourceReady = false;
 320     }
 321   }
 322
 323   if(mSpecularIblUrl != specularUrl)
 324   {
 325     mSpecularIblUrl = specularUrl;
 326     if(mSpecularIblUrl.empty())
 327     {
 328       needIblReset = true;
 329     }
 330     else
 331     {
 332       mIblSpecularDirty         = true;
 333       mIblSpecularResourceReady = false;
 334     }
 335   }
 336
 337   // If one or both of diffuse url and specular url are empty,
 338   // we don't need to request to load texture.
 339   if(needIblReset)
 340   {
 341     if(mIblDiffuseLoadTask)
 342     {
 343       Dali::AsyncTaskManager::Get().RemoveTask(mIblDiffuseLoadTask);
 344       mIblDiffuseLoadTask.Reset();
 345     }
 346
 347     if(mIblSpecularLoadTask)
 348     {
 349       Dali::AsyncTaskManager::Get().RemoveTask(mIblSpecularLoadTask);
 350       mIblSpecularLoadTask.Reset();
 351     }
 352
 353     mIblDiffuseDirty          = false;
 354     mIblSpecularDirty         = false;
 355     mIblDiffuseResourceReady  = true;
 356     mIblSpecularResourceReady = true;
 357
 358     mDiffuseTexture.Reset();
 359     mSpecularTexture.Reset();
 360
 361     mSpecularMipmapLevels = 1u;
 362     NotifyImageBasedLightTextureChange();
 363   }
 364   else
 365   {
 366     if(isOnScene && mIblDiffuseDirty)
 367     {
 368       if(mIblDiffuseLoadTask)
 369       {
 370         Dali::AsyncTaskManager::Get().RemoveTask(mIblDiffuseLoadTask);
 371         mIblDiffuseLoadTask.Reset();
 372       }
 373       mIblDiffuseLoadTask = new EnvironmentMapLoadTask(mDiffuseIblUrl, Scene3D::EnvironmentMapType::CUBEMAP, MakeCallback(this, &SceneView::OnIblDiffuseLoadComplete));
 374       Dali::AsyncTaskManager::Get().AddTask(mIblDiffuseLoadTask);
 375       mIblDiffuseDirty = false;
 376     }
 377
 378     if(isOnScene && mIblSpecularDirty)
 379     {
 380       if(mIblSpecularLoadTask)
 381       {
 382         Dali::AsyncTaskManager::Get().RemoveTask(mIblSpecularLoadTask);
 383         mIblSpecularLoadTask.Reset();
 384       }
 385       mIblSpecularLoadTask = new EnvironmentMapLoadTask(mSpecularIblUrl, Scene3D::EnvironmentMapType::CUBEMAP, MakeCallback(this, &SceneView::OnIblSpecularLoadComplete));
 386       Dali::AsyncTaskManager::Get().AddTask(mIblSpecularLoadTask);
 387       mIblSpecularDirty = false;
 388     }
 389   }
 390
 391   if(!Dali::Equals(mIblScaleFactor, scaleFactor))
 392   {
 393     SetImageBasedLightScaleFactor(scaleFactor);
 394   }
 395
 396   // If diffuse and specular textures are already loaded, emits resource ready signal here.
 397   if(IsResourceReady())
 398   {
 399     Control::SetResourceReady();
 400   }
 401 }
 402
 403 void SceneView::SetImageBasedLightScaleFactor(float scaleFactor)
 404 {
 405   mIblScaleFactor = scaleFactor;
 406   for(auto&& item : mItems)
 407   {
 408     if(item)
 409     {
 410       item->NotifyImageBasedLightScaleFactor(scaleFactor);
 411     }
 412   }
 413 }
 414
 415 float SceneView::GetImageBasedLightScaleFactor() const
 416 {
 417   return mIblScaleFactor;
 418 }
 419
 420 void SceneView::AddLight(Scene3D::Light light)
 421 {
 422   bool enabled = mShaderManager->AddLight(light);
 423   mLights.push_back(std::make_pair(light, enabled));
 424 }
 425
 426 void SceneView::RemoveLight(Scene3D::Light light)
 427 {
 428   mShaderManager->RemoveLight(light);
 429   for(uint32_t i = 0; i < mLights.size(); ++i)
 430   {
 431     if(mLights[i].first == light)
 432     {
 433       mLights.erase(mLights.begin() + i);
 434       break;
 435     }
 436   }
 437
 438   if(mLights.size() > mShaderManager->GetLightCount())
 439   {
 440     for(auto && waitingLight : mLights)
 441     {
 442       if(waitingLight.second)
 443       {
 444         continue;
 445       }
 446
 447       waitingLight.second = mShaderManager->AddLight(waitingLight.first);
 448       break;
 449     }
 450   }
 451 }
 452
 453 uint32_t SceneView::GetActivatedLightCount() const
 454 {
 455   return mShaderManager->GetLightCount();
 456 }
 457
 458 void SceneView::UseFramebuffer(bool useFramebuffer)
 459 {
 460   if(mUseFrameBuffer != useFramebuffer)
 461   {
 462     mUseFrameBuffer = useFramebuffer;
 463     UpdateRenderTask();
 464   }
 465 }
 466
 467 bool SceneView::IsUsingFramebuffer() const
 468 {
 469   return mUseFrameBuffer;
 470 }
 471
 472 void SceneView::SetFramebufferMultiSamplingLevel(uint8_t multiSamplingLevel)
 473 {
 474   if(mFrameBufferMultiSamplingLevel != multiSamplingLevel)
 475   {
 476     mFrameBufferMultiSamplingLevel = multiSamplingLevel;
 477
 478     // Create new framebuffer with changed multiSamplingLevel.
 479     if(mRenderTask && mFrameBuffer && mTexture)
 480     {
 481       Vector3 size = Self().GetProperty<Vector3>(Dali::Actor::Property::SIZE);
 482
 483       mFrameBuffer = FrameBuffer::New(size.width, size.height, FrameBuffer::Attachment::DEPTH_STENCIL);
 484       mFrameBuffer.AttachColorTexture(mTexture);
 485       DevelFrameBuffer::SetMultiSamplingLevel(mFrameBuffer, mFrameBufferMultiSamplingLevel);
 486       mRenderTask.SetFrameBuffer(mFrameBuffer);
 487
 488       // Note : we don't need to create new visual since visual's url is depend on mTexture.
 489     }
 490   }
 491 }
 492
 493 uint8_t SceneView::GetFramebufferMultiSamplingLevel() const
 494 {
 495   return mFrameBufferMultiSamplingLevel;
 496 }
 497
 498 void SceneView::SetSkybox(const std::string& skyboxUrl)
 499 {
 500   if(mSkyboxUrl != skyboxUrl)
 501   {
 502     UpdateSkybox(skyboxUrl, mSkyboxEnvironmentMapType);
 503   }
 504 }
 505
 506 void SceneView::SetSkyboxEnvironmentMapType(Scene3D::EnvironmentMapType skyboxEnvironmentMapType)
 507 {
 508   if(mSkyboxEnvironmentMapType != skyboxEnvironmentMapType)
 509   {
 510     UpdateSkybox(mSkyboxUrl, skyboxEnvironmentMapType);
 511   }
 512 }
 513
 514 void SceneView::SetSkyboxIntensity(float intensity)
 515 {
 516   mSkyboxIntensity = intensity;
 517   if(intensity < 0)
 518   {
 519     DALI_LOG_ERROR("Intensity should be greater than or equal to 0.\n");
 520     mSkyboxIntensity = 0.0f;
 521   }
 522
 523   if(mSkybox)
 524   {
 525     mSkybox.RegisterProperty(SKYBOX_INTENSITY_STRING.data(), mSkyboxIntensity);
 526   }
 527 }
 528
 529 float SceneView::GetSkyboxIntensity() const
 530 {
 531   return mSkyboxIntensity;
 532 }
 533
 534 void SceneView::SetSkyboxOrientation(const Quaternion& orientation)
 535 {
 536   mSkyboxOrientation = orientation;
 537   if(mSkybox)
 538   {
 539     mSkybox.SetProperty(Dali::Actor::Property::ORIENTATION, orientation);
 540   }
 541 }
 542
 543 Quaternion SceneView::GetSkyboxOrientation() const
 544 {
 545   return mSkyboxOrientation;
 546 }
 547
 548 Dali::Scene3D::Loader::ShaderManagerPtr SceneView::GetShaderManager() const
 549 {
 550   return mShaderManager;
 551 }
 552
 553 ///////////////////////////////////////////////////////////
 554 //
 555 // Private methods
 556 //
 557
 558 void SceneView::OnSceneConnection(int depth)
 559 {
 560   // If diffuse and specular url is not valid, IBL does not need to be loaded.
 561   if(!mDiffuseIblUrl.empty() && !mSpecularIblUrl.empty())
 562   {
 563     SetImageBasedLightSource(mDiffuseIblUrl, mSpecularIblUrl, mIblScaleFactor);
 564   }
 565
 566   if(!mSkyboxUrl.empty())
 567   {
 568     UpdateSkybox(mSkyboxUrl, mSkyboxEnvironmentMapType);
 569   }
 570
 571   Window window = DevelWindow::Get(Self());
 572   if(window)
 573   {
 574     // Only for on-screen window
 575     window.ResizeSignal().Connect(this, &SceneView::OnWindowResized);
 576
 577     mWindow            = window;
 578     mWindowOrientation = DevelWindow::GetPhysicalOrientation(window);
 579   }
 580
 581   // On-screen / Off-screen window
 582   mSceneHolder = Integration::SceneHolder::Get(Self());
 583   if(mSceneHolder)
 584   {
 585     RenderTaskList taskList = mSceneHolder.GetRenderTaskList();
 586     mRenderTask             = taskList.CreateTask();
 587     mRenderTask.SetSourceActor(mRootLayer);
 588     mRenderTask.SetExclusive(true);
 589     mRenderTask.SetInputEnabled(true);
 590     mRenderTask.SetCullMode(false);
 591     mRenderTask.SetScreenToFrameBufferMappingActor(Self());
 592
 593     UpdateRenderTask();
 594   }
 595
 596   Control::OnSceneConnection(depth);
 597 }
 598
 599 void SceneView::OnSceneDisconnection()
 600 {
 601   mItems.clear();
 602
 603   Window window = mWindow.GetHandle();
 604   if(window)
 605   {
 606     window.ResizeSignal().Disconnect(this, &SceneView::OnWindowResized);
 607   }
 608   mWindow.Reset();
 609
 610   if(mSceneHolder)
 611   {
 612     if(mRenderTask)
 613     {
 614       RenderTaskList taskList = mSceneHolder.GetRenderTaskList();
 615       taskList.RemoveTask(mRenderTask);
 616       mRenderTask.Reset();
 617     }
 618     mSceneHolder.Reset();
 619   }
 620   mFrameBuffer.Reset();
 621
 622   Control::OnSceneDisconnection();
 623 }
 624
 625 void SceneView::OnInitialize()
 626 {
 627   Actor self = Self();
 628   mRootLayer = Layer::New();
 629   mRootLayer.SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
 630   mRootLayer.SetProperty(Layer::Property::DEPTH_TEST, true);
 631   // The models in the SceneView should be have independent coordinate with DALi default coordinate.
 632   mRootLayer.SetProperty(Dali::Actor::Property::INHERIT_POSITION, false);
 633   mRootLayer.SetProperty(Dali::Actor::Property::INHERIT_ORIENTATION, false);
 634   mRootLayer.SetProperty(Dali::Actor::Property::INHERIT_SCALE, false);
 635   self.Add(mRootLayer);
 636
 637   mDefaultCamera = Dali::CameraActor::New3DCamera();
 638   mDefaultCamera.SetProperty(Dali::Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 639   mDefaultCamera.SetProperty(Dali::Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
 640   AddCamera(mDefaultCamera);
 641   UpdateCamera(mDefaultCamera);
 642 }
 643
 644 void SceneView::OnChildAdd(Actor& child)
 645 {
 646   if(child != mRootLayer)
 647   {
 648     mRootLayer.Add(child);
 649   }
 650   Control::OnChildAdd(child);
 651 }
 652
 653 void SceneView::OnChildRemove(Actor& child)
 654 {
 655   mRootLayer.Remove(child);
 656   Control::OnChildRemove(child);
 657 }
 658
 659 float SceneView::GetHeightForWidth(float width)
 660 {
 661   Extents padding;
 662   padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 663   return Control::GetHeightForWidth(width) + padding.top + padding.bottom;
 664 }
 665
 666 float SceneView::GetWidthForHeight(float height)
 667 {
 668   Extents padding;
 669   padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
 670   return Control::GetWidthForHeight(height) + padding.start + padding.end;
 671 }
 672
 673 void SceneView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 674 {
 675   Control::OnRelayout(size, container);
 676   // Change canvas size of camera actor.
 677   UpdateRenderTask();
 678 }
 679
 680 bool SceneView::IsResourceReady() const
 681 {
 682   return mIblDiffuseResourceReady && mIblSpecularResourceReady && mSkyboxResourceReady;
 683 }
 684
 685 void SceneView::UpdateCamera(CameraActor camera)
 686 {
 687   if(camera)
 688   {
 689     if(mSelectedCamera && mSelectedCamera.GetParent())
 690     {
 691       mSelectedCamera.Unparent();
 692     }
 693     mRootLayer.Add(camera);
 694   }
 695
 696   mSelectedCamera = camera;
 697   UpdateRenderTask();
 698 }
 699
 700 void SceneView::UpdateRenderTask()
 701 {
 702   if(mRenderTask)
 703   {
 704     if(mSelectedCamera != mRenderTask.GetCameraActor())
 705     {
 706       mRenderTask.SetCameraActor(mSelectedCamera);
 707     }
 708
 709     Vector3     size        = Self().GetProperty<Vector3>(Dali::Actor::Property::SIZE);
 710     const float aspectRatio = size.width / size.height;
 711     mSelectedCamera.SetAspectRatio(aspectRatio);
 712
 713     if(mUseFrameBuffer)
 714     {
 715       Dali::FrameBuffer currentFrameBuffer = mRenderTask.GetFrameBuffer();
 716       if(!currentFrameBuffer ||
 717          !Dali::Equals(currentFrameBuffer.GetColorTexture().GetWidth(), size.width) ||
 718          !Dali::Equals(currentFrameBuffer.GetColorTexture().GetHeight(), size.height))
 719       {
 720         mRootLayer.SetProperty(Dali::Actor::Property::COLOR_MODE, ColorMode::USE_OWN_COLOR);
 721         mRenderTask.ResetViewportGuideActor();
 722         mRenderTask.SetViewport(Dali::Viewport(Vector4::ZERO));
 723
 724         // create offscreen buffer of new size to render our child actors to
 725         mTexture     = Dali::Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, unsigned(size.width), unsigned(size.height));
 726         mFrameBuffer = FrameBuffer::New(size.width, size.height, FrameBuffer::Attachment::DEPTH_STENCIL);
 727         mFrameBuffer.AttachColorTexture(mTexture);
 728         DevelFrameBuffer::SetMultiSamplingLevel(mFrameBuffer, mFrameBufferMultiSamplingLevel);
 729         Dali::Toolkit::ImageUrl imageUrl = Dali::Toolkit::Image::GenerateUrl(mFrameBuffer, 0u);
 730
 731         Property::Map imagePropertyMap;
 732         imagePropertyMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
 733         imagePropertyMap.Insert(Toolkit::ImageVisual::Property::URL, imageUrl.GetUrl());
 734         // To flip rendered scene without CameraActor::SetInvertYAxis() to avoid backface culling.
 735         imagePropertyMap.Insert(Toolkit::ImageVisual::Property::PIXEL_AREA, Vector4(0.0f, 1.0f, 1.0f, -1.0f));
 736         mVisual = Toolkit::VisualFactory::Get().CreateVisual(imagePropertyMap);
 737
 738         Toolkit::DevelControl::RegisterVisual(*this, RENDERING_BUFFER, mVisual);
 739
 740         mRenderTask.SetFrameBuffer(mFrameBuffer);
 741         mRenderTask.SetClearEnabled(true);
 742         mRenderTask.SetClearColor(Color::TRANSPARENT);
 743       }
 744     }
 745     else
 746     {
 747       mRenderTask.SetViewportGuideActor(Self());
 748       if(mRenderTask.GetFrameBuffer())
 749       {
 750         mRootLayer.SetProperty(Dali::Actor::Property::COLOR_MODE, ColorMode::USE_OWN_MULTIPLY_PARENT_ALPHA);
 751         FrameBuffer framebuffer;
 752         mRenderTask.SetFrameBuffer(framebuffer);
 753         mRenderTask.SetClearEnabled(false);
 754
 755         Toolkit::DevelControl::UnregisterVisual(*this, RENDERING_BUFFER);
 756
 757         mVisual.Reset();
 758         mFrameBuffer.Reset();
 759         mTexture.Reset();
 760       }
 761     }
 762
 763     RotateCamera();
 764   }
 765 }
 766
 767 void SceneView::OnWindowResized(Window window, Window::WindowSize size)
 768 {
 769   mWindowOrientation = DevelWindow::GetPhysicalOrientation(window);
 770   RotateCamera();
 771 }
 772
 773 void SceneView::RotateCamera()
 774 {
 775   if(mUseFrameBuffer)
 776   {
 777     DevelCameraActor::RotateProjection(mSelectedCamera, DEFAULT_ORIENTATION);
 778   }
 779   else
 780   {
 781     DevelCameraActor::RotateProjection(mSelectedCamera, mWindowOrientation);
 782   }
 783 }
 784
 785 void SceneView::UpdateSkybox(const std::string& skyboxUrl, Scene3D::EnvironmentMapType skyboxEnvironmentMapType)
 786 {
 787   bool isOnScene = Self().GetProperty<bool>(Dali::Actor::Property::CONNECTED_TO_SCENE);
 788   if(mSkyboxUrl != skyboxUrl || mSkyboxEnvironmentMapType != skyboxEnvironmentMapType)
 789   {
 790     mSkyboxDirty              = true;
 791     mSkyboxResourceReady      = false;
 792     mSkyboxUrl                = skyboxUrl;
 793     mSkyboxEnvironmentMapType = skyboxEnvironmentMapType;
 794   }
 795
 796   if(mSkyboxUrl.empty())
 797   {
 798     if(mSkyboxLoadTask)
 799     {
 800       Dali::AsyncTaskManager::Get().RemoveTask(mSkyboxLoadTask);
 801       mSkyboxLoadTask.Reset();
 802     }
 803
 804     if(mSkybox)
 805     {
 806       mSkybox.Unparent();
 807       mSkybox.Reset();
 808       mSkyboxTexture.Reset();
 809     }
 810
 811     mSkyboxDirty         = false;
 812     mSkyboxResourceReady = true;
 813   }
 814   else
 815   {
 816     if(isOnScene && mSkyboxDirty)
 817     {
 818       if(mSkyboxLoadTask)
 819       {
 820         Dali::AsyncTaskManager::Get().RemoveTask(mSkyboxLoadTask);
 821         mSkyboxLoadTask.Reset();
 822       }
 823
 824       mSkyboxLoadTask = new EnvironmentMapLoadTask(mSkyboxUrl, mSkyboxEnvironmentMapType, MakeCallback(this, &SceneView::OnSkyboxLoadComplete));
 825       Dali::AsyncTaskManager::Get().AddTask(mSkyboxLoadTask);
 826       mSkyboxDirty = false;
 827     }
 828   }
 829
 830   if(IsResourceReady())
 831   {
 832     Control::SetResourceReady();
 833   }
 834 }
 835
 836 void SceneView::OnSkyboxLoadComplete()
 837 {
 838   if(!mSkybox)
 839   {
 840     mSkybox = CreateSkybox();
 841     SetSkyboxIntensity(mSkyboxIntensity);
 842     SetSkyboxOrientation(mSkyboxOrientation);
 843     if(mRootLayer)
 844     {
 845       mRootLayer.Add(mSkybox);
 846     }
 847   }
 848
 849   mSkyboxResourceReady = true;
 850   if(IsResourceReady())
 851   {
 852     Control::SetResourceReady();
 853   }
 854
 855   mSkyboxTexture = mSkyboxLoadTask->GetLoadedTexture();
 856   Shader skyboxShader;
 857   if(mSkyboxLoadTask->GetEnvironmentMapType() == Scene3D::EnvironmentMapType::CUBEMAP)
 858   {
 859     skyboxShader = Shader::New(SHADER_SKYBOX_SHADER_VERT.data(), SHADER_SKYBOX_SHADER_FRAG.data());
 860   }
 861   else
 862   {
 863     skyboxShader = Shader::New(SHADER_SKYBOX_SHADER_VERT.data(), SHADER_SKYBOX_EQUIRECTANGULAR_SHADER_FRAG.data());
 864   }
 865
 866   Renderer skyboxRenderer = (mSkybox.GetRendererCount() > 0u) ? mSkybox.GetRendererAt(0u) : Renderer();
 867   if(skyboxRenderer)
 868   {
 869     Dali::TextureSet skyboxTextures = TextureSet::New();
 870     skyboxTextures.SetTexture(0, mSkyboxTexture);
 871     skyboxRenderer.SetTextures(skyboxTextures);
 872     skyboxRenderer.SetShader(skyboxShader);
 873   }
 874
 875   mSkyboxLoadTask.Reset();
 876 }
 877
 878 void SceneView::OnIblDiffuseLoadComplete()
 879 {
 880   mDiffuseTexture          = mIblDiffuseLoadTask->GetLoadedTexture();
 881   mIblDiffuseResourceReady = true;
 882   if(mIblDiffuseResourceReady && mIblSpecularResourceReady)
 883   {
 884     OnIblLoadComplete();
 885   }
 886   mIblDiffuseLoadTask.Reset();
 887 }
 888
 889 void SceneView::OnIblSpecularLoadComplete()
 890 {
 891   mSpecularTexture          = mIblSpecularLoadTask->GetLoadedTexture();
 892   mSpecularMipmapLevels     = mIblSpecularLoadTask->GetMipmapLevels();
 893   mIblSpecularResourceReady = true;
 894   if(mIblDiffuseResourceReady && mIblSpecularResourceReady)
 895   {
 896     OnIblLoadComplete();
 897   }
 898   mIblSpecularLoadTask.Reset();
 899 }
 900
 901 void SceneView::OnIblLoadComplete()
 902 {
 903   NotifyImageBasedLightTextureChange();
 904   if(IsResourceReady())
 905   {
 906     Control::SetResourceReady();
 907   }
 908 }
 909
 910 void SceneView::NotifyImageBasedLightTextureChange()
 911 {
 912   for(auto&& item : mItems)
 913   {
 914     if(item)
 915     {
 916       item->NotifyImageBasedLightTexture(mDiffuseTexture, mSpecularTexture, mIblScaleFactor, mSpecularMipmapLevels);
 917     }
 918   }
 919 }
 920
 921 } // namespace Internal
 922 } // namespace Scene3D
 923 } // namespace Dali