+int32_t SceneView::Capture(Dali::CameraActor camera, const Vector2& size)
+{
+ if(size.x <= 0.0f || size.y <= 0.0f)
+ {
+ DALI_LOG_ERROR("The width and height should be positive.\n");
+ return INVALID_CAPTURE_ID;
+ }
+
+ uint32_t width = unsigned(size.width);
+ uint32_t height = unsigned(size.height);
+ if(width > Dali::GetMaxTextureSize() || height > Dali::GetMaxTextureSize())
+ {
+ DALI_LOG_ERROR("The input size is too large.\n");
+ return INVALID_CAPTURE_ID;
+ }
+
+ if(!mRootLayer.GetProperty<bool>(Dali::Actor::Property::CONNECTED_TO_SCENE))
+ {
+ DALI_LOG_ERROR("Current SceneView is not connected on scene tree\n");
+ return INVALID_CAPTURE_ID;
+ }
+
+ if(!camera.GetProperty<bool>(Dali::Actor::Property::CONNECTED_TO_SCENE))
+ {
+ mRootLayer.Add(camera);
+ }
+
+ std::shared_ptr<CaptureData> captureData = std::make_shared<CaptureData>();
+ captureData->mCaptureId = mCaptureId;
+ captureData->mCaptureTexture = Dali::Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ captureData->mCaptureFrameBuffer = Dali::FrameBuffer::New(captureData->mCaptureTexture.GetWidth(), captureData->mCaptureTexture.GetHeight(), Dali::FrameBuffer::Attachment::DEPTH_STENCIL);
+ DevelFrameBuffer::SetMultiSamplingLevel(captureData->mCaptureFrameBuffer, mFrameBufferMultiSamplingLevel);
+ captureData->mCaptureFrameBuffer.AttachColorTexture(captureData->mCaptureTexture);
+
+ RenderTaskList taskList = mSceneHolder.GetRenderTaskList();
+ captureData->mCaptureTask = taskList.CreateTask();
+ captureData->mCaptureTask.SetSourceActor(mRootLayer);
+ captureData->mCaptureTask.SetExclusive(true);
+ captureData->mCaptureTask.SetCullMode(false);
+ captureData->mCaptureTask.SetOrderIndex(SCENE_ORDER_INDEX + 1);
+ captureData->mCaptureTask.SetCameraActor(camera);
+ captureData->mCaptureTask.SetFrameBuffer(captureData->mCaptureFrameBuffer);
+ captureData->mCaptureTask.SetClearEnabled(true);
+ captureData->mCaptureTask.SetClearColor(Color::TRANSPARENT);
+ captureData->mCaptureTask.SetRefreshRate(Dali::RenderTask::REFRESH_ONCE);
+
+ captureData->mCaptureInvertCamera = Dali::CameraActor::New(size);
+ captureData->mCaptureInvertCamera.SetProperty(Dali::Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ captureData->mCaptureInvertCamera.SetProperty(Dali::Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ captureData->mCaptureInvertCamera.SetProperty(Dali::Actor::Property::POSITION_X, size.x / 2.0f);
+ captureData->mCaptureInvertCamera.SetProperty(Dali::Actor::Property::POSITION_Y, size.y / 2.0f);
+
+ captureData->mCaptureUrl = Dali::Toolkit::Image::GenerateUrl(captureData->mCaptureFrameBuffer, 0u);
+ captureData->mCaptureImageView = Dali::Toolkit::ImageView::New(captureData->mCaptureUrl.GetUrl());
+ captureData->mCaptureImageView.SetProperty(Dali::Actor::Property::SIZE, size);
+ captureData->mCaptureImageView.Add(captureData->mCaptureInvertCamera);
+
+ Window window = DevelWindow::Get(Self());
+ window.Add(captureData->mCaptureImageView);
+
+ captureData->mCaptureInvertTexture = Dali::Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ captureData->mCaptureInvertFrameBuffer = Dali::FrameBuffer::New(captureData->mCaptureInvertTexture.GetWidth(), captureData->mCaptureInvertTexture.GetHeight(), Dali::FrameBuffer::Attachment::DEPTH_STENCIL);
+ captureData->mCaptureInvertFrameBuffer.AttachColorTexture(captureData->mCaptureInvertTexture);
+
+ captureData->mCaptureInvertTask = taskList.CreateTask();
+ captureData->mCaptureInvertTask.SetSourceActor(captureData->mCaptureImageView);
+ captureData->mCaptureInvertTask.SetExclusive(true);
+ captureData->mCaptureInvertTask.SetCullMode(false);
+ captureData->mCaptureInvertTask.SetOrderIndex(SCENE_ORDER_INDEX + 2);
+ captureData->mCaptureInvertTask.SetCameraActor(captureData->mCaptureInvertCamera);
+ captureData->mCaptureInvertTask.SetFrameBuffer(captureData->mCaptureInvertFrameBuffer);
+ captureData->mCaptureInvertTask.SetClearEnabled(true);
+ captureData->mCaptureInvertTask.SetClearColor(Color::TRANSPARENT);
+ captureData->mCaptureInvertTask.SetRefreshRate(Dali::RenderTask::REFRESH_ONCE);
+ captureData->mCaptureInvertTask.FinishedSignal().Connect(this, &SceneView::OnCaptureFinished);
+
+ captureData->mStartTick = mTimerTickCount;
+
+ mCaptureContainer.push_back(std::make_pair(captureData->mCaptureInvertTask, captureData));
+
+ if(!mCaptureTimer)
+ {
+ mCaptureTimer = Dali::Timer::New(1000);
+ mCaptureTimer.TickSignal().Connect(this, &SceneView::OnTimeOut);
+ mCaptureTimer.Start();
+ }
+ return mCaptureId++;
+}
+
+Dali::Scene3D::SceneView::CaptureFinishedSignalType& SceneView::CaptureFinishedSignal()
+{
+ return mCaptureFinishedSignal;
+}
+
+Dali::Scene3D::Loader::ShaderManagerPtr SceneView::GetShaderManager() const
+{
+ return mShaderManager;
+}
+
+void SceneView::UpdateShadowUniform(Scene3D::Light light)
+{
+ mShaderManager->UpdateShadowUniform(light);
+}
+
+void SceneView::SetAlphaMaskUrl(std::string& alphaMaskUrl)
+{
+ if(mAlphaMaskUrl != alphaMaskUrl)
+ {
+ mAlphaMaskUrl = alphaMaskUrl;
+ mMaskingPropertyChanged = true;
+ UpdateRenderTask();
+ }
+}
+
+std::string SceneView::GetAlphaMaskUrl()
+{
+ return mAlphaMaskUrl;
+}
+
+void SceneView::SetMaskContentScaleFactor(float maskContentScaleFactor)
+{
+ if(mMaskContentScaleFactor != maskContentScaleFactor)
+ {
+ mMaskContentScaleFactor = maskContentScaleFactor;
+ mMaskingPropertyChanged = true;
+ UpdateRenderTask();
+ }
+}
+
+float SceneView::GetMaskContentScaleFactor()
+{
+ return mMaskContentScaleFactor;
+}
+
+void SceneView::EnableCropToMask(bool enableCropToMask)
+{
+ if(mCropToMask != enableCropToMask)
+ {
+ mCropToMask = enableCropToMask;
+ mMaskingPropertyChanged = true;
+ UpdateRenderTask();
+ }
+}
+
+bool SceneView::IsEnabledCropToMask()
+{
+ return mCropToMask;
+}
+
+Dali::RenderTask SceneView::GetRenderTask()
+{
+ return mRenderTask;
+}
+
+void SceneView::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
+{
+ Scene3D::SceneView sceneView = Scene3D::SceneView::DownCast(Dali::BaseHandle(object));
+
+ if(sceneView)
+ {
+ SceneView& sceneViewImpl(GetImpl(sceneView));
+
+ switch(index)
+ {
+ case Scene3D::SceneView::Property::ALPHA_MASK_URL:
+ {
+ std::string alphaMaskUrl = value.Get<std::string>();
+ sceneViewImpl.SetAlphaMaskUrl(alphaMaskUrl);
+ break;
+ }
+ case Scene3D::SceneView::Property::MASK_CONTENT_SCALE:
+ {
+ sceneViewImpl.SetMaskContentScaleFactor(value.Get<float>());
+ break;
+ }
+ case Scene3D::SceneView::Property::CROP_TO_MASK:
+ {
+ sceneViewImpl.EnableCropToMask(value.Get<bool>());
+ break;
+ }
+ }
+ }
+}
+
+Property::Value SceneView::GetProperty(BaseObject* object, Property::Index index)
+{
+ Property::Value value;
+
+ Scene3D::SceneView sceneView = Scene3D::SceneView::DownCast(Dali::BaseHandle(object));
+
+ if(sceneView)
+ {
+ SceneView& sceneViewImpl(GetImpl(sceneView));
+
+ switch(index)
+ {
+ case Scene3D::SceneView::Property::ALPHA_MASK_URL:
+ {
+ value = sceneViewImpl.GetAlphaMaskUrl();
+ break;
+ }
+ case Scene3D::SceneView::Property::MASK_CONTENT_SCALE:
+ {
+ value = sceneViewImpl.GetMaskContentScaleFactor();
+ break;
+ }
+ case Scene3D::SceneView::Property::CROP_TO_MASK:
+ {
+ value = sceneViewImpl.IsEnabledCropToMask();
+ break;
+ }
+ }
+ }
+ return value;
+}
+