dali/internal/event/render-tasks/render-task-impl.cpp

   1 /*
   2  * Copyright (c) 2019 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/internal/event/render-tasks/render-task-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <cstring> // for strcmp
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/public-api/common/dali-common.h>
  26 #include <dali/public-api/object/type-registry.h>
  27 #include <dali/internal/event/common/event-thread-services.h>
  28 #include <dali/internal/event/actors/actor-impl.h>
  29 #include <dali/internal/event/actors/camera-actor-impl.h>
  30 #include <dali/internal/event/common/property-helper.h>
  31 #include <dali/internal/event/common/stage-impl.h>
  32 #include <dali/internal/event/common/scene-impl.h>
  33 #include <dali/internal/event/common/projection.h>
  34 #include <dali/internal/event/images/frame-buffer-image-impl.h>
  35 #include <dali/internal/update/nodes/node.h>
  36 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
  37
  38 #if defined(DEBUG_ENABLED)
  39 namespace
  40 {
  41 Debug::Filter* gLogRender = Debug::Filter::New(Debug::Concise, false, "LOG_RENDER_TASK");
  42 }
  43 #endif
  44
  45 namespace Dali
  46 {
  47
  48 namespace Internal
  49 {
  50
  51 namespace // For internal properties
  52 {
  53
  54 // Properties
  55
  56 //              Name                 Type     writable animatable constraint-input  enum for index-checking
  57 DALI_PROPERTY_TABLE_BEGIN
  58 DALI_PROPERTY( "viewportPosition",   VECTOR2,    true,    true,    true,    Dali::RenderTask::Property::VIEWPORT_POSITION )
  59 DALI_PROPERTY( "viewportSize",       VECTOR2,    true,    true,    true,    Dali::RenderTask::Property::VIEWPORT_SIZE     )
  60 DALI_PROPERTY( "clearColor",         VECTOR4,    true,    true,    true,    Dali::RenderTask::Property::CLEAR_COLOR       )
  61 DALI_PROPERTY( "requiresSync",       BOOLEAN,    true,    false,   false,   Dali::RenderTask::Property::REQUIRES_SYNC     )
  62 DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX, RenderTaskDefaultProperties )
  63
  64 // Signals
  65
  66 const char* const SIGNAL_FINISHED = "finished";
  67
  68 TypeRegistration mType( typeid( Dali::RenderTask ), typeid( Dali::BaseHandle ), NULL, RenderTaskDefaultProperties );
  69
  70 SignalConnectorType signalConnector1( mType, SIGNAL_FINISHED, &RenderTask::DoConnectSignal );
  71
  72 } // Unnamed namespace
  73
  74 RenderTaskPtr RenderTask::New( Actor* sourceActor, CameraActor* cameraActor, RenderTaskList& renderTaskList )
  75 {
  76   // create scene object first so it's guaranteed to exist for the event side
  77   auto sceneObject = SceneGraph::RenderTask::New();
  78
  79   // pass the pointer to base for message passing
  80   RenderTaskPtr task( new RenderTask( sceneObject, renderTaskList ) );
  81
  82   // transfer scene object ownership to update manager
  83   const SceneGraph::RenderTaskList& parentSceneObject = renderTaskList.GetSceneObject();
  84   OwnerPointer< SceneGraph::RenderTask > transferOwnership( sceneObject );
  85   AddTaskMessage( task->GetEventThreadServices(), parentSceneObject, transferOwnership );
  86
  87   // Set the default source & camera actors
  88   task->SetSourceActor( sourceActor );
  89   task->SetCameraActor( cameraActor );
  90
  91   // no need for additional messages as scene objects defaults match ours
  92   return task;
  93 }
  94
  95 void RenderTask::SetSourceActor( Actor* actor )
  96 {
  97   mSourceActor = actor;
  98   if ( mSourceActor )
  99   {
 100     SetSourceNodeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), &mSourceActor->GetNode() );
 101   }
 102   else
 103   {
 104     SetSourceNodeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), nullptr );
 105   }
 106
 107   // set the actor on exclusive container for hit testing
 108   mRenderTaskList.SetExclusive( this, mExclusive );
 109 }
 110
 111 Actor* RenderTask::GetSourceActor() const
 112 {
 113   return mSourceActor;
 114 }
 115
 116 void RenderTask::SetExclusive( bool exclusive )
 117 {
 118   if ( mExclusive != exclusive )
 119   {
 120     mExclusive = exclusive;
 121
 122     mRenderTaskList.SetExclusive( this, exclusive );
 123
 124     // scene object is being used in a separate thread; queue a message to set the value
 125     SetExclusiveMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), mExclusive );
 126   }
 127 }
 128
 129 bool RenderTask::IsExclusive() const
 130 {
 131   return mExclusive;
 132 }
 133
 134 void RenderTask::SetInputEnabled( bool enabled )
 135 {
 136   mInputEnabled = enabled;
 137 }
 138
 139 bool RenderTask::GetInputEnabled() const
 140 {
 141   return mInputEnabled;
 142 }
 143
 144 void RenderTask::SetCameraActor( CameraActor* cameraActor )
 145 {
 146   mCameraActor = cameraActor;
 147   if( mCameraActor )
 148   {
 149     SetCameraMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), &mCameraActor->GetNode(), mCameraActor->GetCamera() );
 150   }
 151   else
 152   {
 153     SetCameraMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), nullptr, nullptr );
 154   }
 155
 156   // set the actor on exclusive container for hit testing
 157   mRenderTaskList.SetExclusive( this, mExclusive );
 158 }
 159
 160 CameraActor* RenderTask::GetCameraActor() const
 161 {
 162   return mCameraActor;
 163 }
 164
 165 void RenderTask::SetTargetFrameBuffer( FrameBufferImagePtr image )
 166 {
 167   mFrameBufferImage = image;
 168   FrameBuffer* frameBufferPtr( NULL );
 169   if( image )
 170   {
 171     frameBufferPtr = image->GetFrameBuffer();
 172   }
 173
 174   SetFrameBuffer( frameBufferPtr );
 175 }
 176
 177 void RenderTask::SetFrameBuffer( FrameBufferPtr frameBuffer )
 178 {
 179   mFrameBuffer = frameBuffer;
 180   Render::FrameBuffer* renderFrameBufferPtr( NULL );
 181   if( frameBuffer )
 182   {
 183     renderFrameBufferPtr = mFrameBuffer->GetRenderObject();
 184   }
 185
 186   SetFrameBufferMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), renderFrameBufferPtr );
 187 }
 188
 189 FrameBuffer* RenderTask::GetFrameBuffer() const
 190 {
 191   return mFrameBuffer.Get();
 192 }
 193
 194 FrameBufferImage* RenderTask::GetTargetFrameBuffer() const
 195 {
 196   return mFrameBufferImage.Get();
 197 }
 198
 199 void RenderTask::SetScreenToFrameBufferFunction( ScreenToFrameBufferFunction conversionFunction )
 200 {
 201   mScreenToFrameBufferFunction = conversionFunction;
 202 }
 203
 204 RenderTask::ScreenToFrameBufferFunction RenderTask::GetScreenToFrameBufferFunction() const
 205 {
 206   return mScreenToFrameBufferFunction;
 207 }
 208
 209 void RenderTask::SetScreenToFrameBufferMappingActor( Dali::Actor& mappingActor )
 210 {
 211   mInputMappingActor = WeakHandle<Dali::Actor>( mappingActor );
 212 }
 213
 214 Dali::Actor RenderTask::GetScreenToFrameBufferMappingActor() const
 215 {
 216   return mInputMappingActor.GetHandle();
 217 }
 218
 219 void RenderTask::SetViewportPosition(const Vector2& value)
 220 {
 221   mViewportPosition = value;
 222
 223   BakeViewportPositionMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), value );
 224 }
 225
 226 Vector2 RenderTask::GetCurrentViewportPosition() const
 227 {
 228   return GetRenderTaskSceneObject().GetViewportPosition( GetEventThreadServices().GetEventBufferIndex() );
 229 }
 230
 231 void RenderTask::SetViewportSize(const Vector2& value)
 232 {
 233   mViewportSize = value;
 234
 235   BakeViewportSizeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), value );
 236 }
 237
 238 Vector2 RenderTask::GetCurrentViewportSize() const
 239 {
 240   return GetRenderTaskSceneObject().GetViewportSize( GetEventThreadServices().GetEventBufferIndex() );
 241 }
 242
 243 void RenderTask::SetViewport( const Viewport& viewport )
 244 {
 245   SetViewportPosition( Vector2( static_cast<float>( viewport.x ), static_cast<float>( viewport.y ) ) );
 246   SetViewportSize( Vector2( static_cast<float>( viewport.width ), static_cast<float>( viewport.height ) ) );
 247 }
 248
 249 void RenderTask::GetViewport( Viewport& viewPort ) const
 250 {
 251   BufferIndex bufferIndex = GetEventThreadServices().GetEventBufferIndex();
 252
 253   if( !GetRenderTaskSceneObject().GetViewportEnabled( bufferIndex ) )
 254   {
 255     if ( mFrameBufferImage )
 256     {
 257       viewPort.x = viewPort.y = 0;
 258       viewPort.width = mFrameBufferImage->GetWidth();
 259       viewPort.height = mFrameBufferImage->GetHeight();
 260     }
 261     else
 262     {
 263       Internal::Stage* stage = Internal::Stage::GetCurrent();
 264       if ( stage )
 265       {
 266         Vector2 size( stage->GetSize() );
 267         if ( mSourceActor && mSourceActor->OnStage() )
 268         {
 269           Scene& scene = mSourceActor->GetScene();
 270           size = scene.GetSize();
 271         }
 272
 273         viewPort.x = viewPort.y = 0;
 274         viewPort.width = static_cast<int32_t>( size.width ); // truncated
 275         viewPort.height = static_cast<int32_t>( size.height ); // truncated
 276       }
 277     }
 278   }
 279   else
 280   {
 281     const Vector2& position = GetRenderTaskSceneObject().GetViewportPosition(bufferIndex);
 282     const Vector2& size = GetRenderTaskSceneObject().GetViewportSize(bufferIndex);
 283     viewPort.x = static_cast<int32_t>( position.x ); // truncated
 284     viewPort.y = static_cast<int32_t>( position.y ); // truncated
 285     viewPort.width = static_cast<int32_t>( size.width ); // truncated
 286     viewPort.height = static_cast<int32_t>( size.height ); // truncated
 287   }
 288 }
 289
 290 void RenderTask::SetClearColor( const Vector4& color )
 291 {
 292   if ( mClearColor != color )
 293   {
 294     mClearColor = color;
 295
 296     // scene object is being used in a separate thread; queue a message to set the value
 297     BakeClearColorMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), color );
 298   }
 299 }
 300
 301 const Vector4& RenderTask::GetClearColor() const
 302 {
 303   return GetRenderTaskSceneObject().GetClearColor( GetEventThreadServices().GetEventBufferIndex() );
 304 }
 305
 306 void RenderTask::SetSyncRequired( bool requiresSync )
 307 {
 308   if( mRequiresSync != requiresSync )
 309   {
 310     mRequiresSync = requiresSync;
 311
 312     // scene object is being used in a separate thread; queue a message to set the value
 313     SetSyncRequiredMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), requiresSync );
 314   }
 315 }
 316
 317 bool RenderTask::IsSyncRequired() const
 318 {
 319   return mRequiresSync;
 320 }
 321
 322 void RenderTask::SetClearEnabled( bool enabled )
 323 {
 324   if ( mClearEnabled != enabled )
 325   {
 326     mClearEnabled = enabled;
 327
 328     // scene object is being used in a separate thread; queue a message to set the value
 329     SetClearEnabledMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), mClearEnabled );
 330   }
 331 }
 332
 333 bool RenderTask::GetClearEnabled() const
 334 {
 335   return mClearEnabled;
 336 }
 337
 338 void RenderTask::SetCullMode( bool mode )
 339 {
 340   if ( mCullMode != mode )
 341   {
 342     mCullMode = mode;
 343
 344     // scene object is being used in a separate thread; queue a message to set the value
 345     SetCullModeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), mCullMode );
 346   }
 347 }
 348
 349 bool RenderTask::GetCullMode() const
 350 {
 351   return mCullMode;
 352 }
 353
 354 void RenderTask::SetRefreshRate( uint32_t refreshRate )
 355 {
 356   DALI_LOG_TRACE_METHOD_FMT(gLogRender, "this:%p  rate:%d\n", this, refreshRate);
 357   DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::SetRefreshRate(this:%p, %d)\n", this, refreshRate);
 358
 359   mRefreshRate = refreshRate; // cached for GetRefreshRate()
 360
 361   // Note - even when refreshRate is the same as mRefreshRate, a message should be sent
 362
 363   // sceneObject is being used in a separate thread; queue a message to set the value
 364   SetRefreshRateMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), refreshRate );
 365 }
 366
 367 uint32_t RenderTask::GetRefreshRate() const
 368 {
 369   return mRefreshRate;
 370 }
 371
 372 bool RenderTask::IsHittable( Vector2& screenCoords ) const
 373 {
 374   // True when input is enabled, source & camera actor are valid
 375   bool inputEnabled( false );
 376
 377   Actor* sourceActor = GetSourceActor();
 378   CameraActor* cameraActor = GetCameraActor();
 379
 380   if ( mInputEnabled  &&
 381        nullptr != sourceActor &&
 382        sourceActor->OnStage() &&
 383        nullptr != cameraActor &&
 384        cameraActor->OnStage() )
 385   {
 386     // If the actors are rendered off-screen, then the screen coordinates must be converted
 387     // and the conversion function will tell us if they are inside or outside
 388     if ( TranslateCoordinates( screenCoords ) )
 389     {
 390       // This is a suitable render-task for input handling
 391       inputEnabled = true;
 392     }
 393   }
 394
 395   return inputEnabled;
 396 }
 397
 398 bool RenderTask::TranslateCoordinates( Vector2& screenCoords ) const
 399 {
 400   // return true for on-screen tasks
 401   bool inside( true );
 402   // If the actors are rendered off-screen, then the screen coordinates must be converted
 403   // the function should only be called for offscreen tasks
 404   Dali::Actor mappingActor = GetScreenToFrameBufferMappingActor();
 405
 406   if( mFrameBufferImage && mappingActor )
 407   {
 408     Internal::Actor* inputMappingActor = &GetImplementation( mappingActor );
 409     CameraActor* localCamera = GetCameraActor();
 410     StagePtr stage = Stage::GetCurrent();
 411     if ( stage )
 412     {
 413       Vector2 size( stage->GetSize() );
 414       CameraActor* defaultCamera( &stage->GetDefaultCameraActor() );
 415       if ( mSourceActor && mSourceActor->OnStage() )
 416       {
 417         Scene& scene = mSourceActor->GetScene();
 418         size = scene.GetSize();
 419         defaultCamera = &scene.GetDefaultCameraActor();
 420       }
 421
 422       if( localCamera )
 423       {
 424         Viewport viewport;
 425         viewport.x = viewport.y = 0;
 426         viewport.width = static_cast<int32_t>( size.width ); // truncated
 427         viewport.height = static_cast<int32_t>( size.height ); // truncated
 428
 429         float localX, localY;
 430         inside = inputMappingActor->ScreenToLocal(defaultCamera->GetViewMatrix(), defaultCamera->GetProjectionMatrix(), viewport, localX, localY, screenCoords.x, screenCoords.y);
 431         Vector3 actorSize = inputMappingActor->GetCurrentSize();
 432         if( inside && localX >= 0.f && localX <= actorSize.x && localY >= 0.f && localY <= actorSize.y)
 433         {
 434           screenCoords.x = localX;
 435           screenCoords.y = localY;
 436         }
 437         else
 438         {
 439           inside = false;
 440         }
 441       }
 442       else
 443       {
 444         inside = false;
 445       }
 446     }
 447   }
 448   else if ( mFrameBufferImage && mScreenToFrameBufferFunction )
 449   {
 450     inside = mScreenToFrameBufferFunction( screenCoords );
 451   }
 452   return inside;
 453 }
 454
 455 bool RenderTask::WorldToViewport(const Vector3 &position, float& viewportX, float& viewportY) const
 456 {
 457   CameraActor* cam = GetCameraActor();
 458
 459   Vector4 pos(position);
 460   pos.w = 1.0;
 461
 462   Vector4 viewportPosition;
 463
 464   Viewport viewport;
 465   GetViewport( viewport );
 466
 467   bool ok = ProjectFull(pos,
 468                         cam->GetViewMatrix(),
 469                         cam->GetProjectionMatrix(),
 470                         static_cast<float>( viewport.x ), // truncated
 471                         static_cast<float>( viewport.y ), // truncated
 472                         static_cast<float>( viewport.width ), // truncated
 473                         static_cast<float>( viewport.height ), // truncated
 474                         viewportPosition);
 475   if(ok)
 476   {
 477     viewportX = viewportPosition.x;
 478     viewportY = viewportPosition.y;
 479   }
 480
 481   return ok;
 482 }
 483
 484 bool RenderTask::ViewportToLocal(Actor* actor, float viewportX, float viewportY, float &localX, float &localY) const
 485 {
 486   return actor->ScreenToLocal( *this, localX, localY, viewportX, viewportY );
 487 }
 488
 489 const SceneGraph::RenderTask& RenderTask::GetRenderTaskSceneObject() const
 490 {
 491   return *static_cast<const SceneGraph::RenderTask*>( mUpdateObject );
 492 }
 493
 494 RenderTaskList& RenderTask::GetRenderTaskList() const
 495 {
 496   return mRenderTaskList;
 497 }
 498
 499 /********************************************************************************
 500  ********************************   PROPERTY METHODS   **************************
 501  ********************************************************************************/
 502
 503 void RenderTask::SetDefaultProperty( Property::Index index, const Property::Value& property )
 504 {
 505   switch ( index )
 506   {
 507     case Dali::RenderTask::Property::VIEWPORT_POSITION:
 508     {
 509       SetViewportPosition( property.Get<Vector2>() );
 510       break;
 511     }
 512     case Dali::RenderTask::Property::VIEWPORT_SIZE:
 513     {
 514       SetViewportSize( property.Get<Vector2>() );
 515       break;
 516     }
 517     case Dali::RenderTask::Property::CLEAR_COLOR:
 518     {
 519       SetClearColor( property.Get<Vector4>() );
 520       break;
 521     }
 522     case Dali::RenderTask::Property::REQUIRES_SYNC:
 523     {
 524       SetSyncRequired( property.Get<bool>() );
 525       break;
 526     }
 527     default:
 528     {
 529       // nothing to do
 530       break;
 531     }
 532   }
 533 }
 534
 535 Property::Value RenderTask::GetDefaultProperty(Property::Index index) const
 536 {
 537   Property::Value value;
 538
 539   switch ( index )
 540   {
 541     case Dali::RenderTask::Property::VIEWPORT_POSITION:
 542     {
 543       value = mViewportPosition;
 544       break;
 545     }
 546     case Dali::RenderTask::Property::VIEWPORT_SIZE:
 547     {
 548       value = mViewportSize;
 549       break;
 550     }
 551     case Dali::RenderTask::Property::CLEAR_COLOR:
 552     {
 553       value = mClearColor;
 554       break;
 555     }
 556     case Dali::RenderTask::Property::REQUIRES_SYNC:
 557     {
 558       value = IsSyncRequired();
 559       break;
 560     }
 561
 562     default:
 563     {
 564       DALI_ASSERT_ALWAYS(false && "RenderTask property index out of range"); // should not come here
 565       break;
 566     }
 567   }
 568
 569   return value;
 570 }
 571
 572 Property::Value RenderTask::GetDefaultPropertyCurrentValue( Property::Index index ) const
 573 {
 574   Property::Value value;
 575
 576   switch ( index )
 577   {
 578     case Dali::RenderTask::Property::VIEWPORT_POSITION:
 579     {
 580       value = GetCurrentViewportPosition();
 581       break;
 582     }
 583     case Dali::RenderTask::Property::VIEWPORT_SIZE:
 584     {
 585       value = GetCurrentViewportSize();
 586       break;
 587     }
 588     case Dali::RenderTask::Property::CLEAR_COLOR:
 589     {
 590       value = GetClearColor();
 591       break;
 592     }
 593     case Dali::RenderTask::Property::REQUIRES_SYNC:
 594     {
 595       value = IsSyncRequired();
 596       break;
 597     }
 598
 599     default:
 600     {
 601       DALI_ASSERT_ALWAYS(false && "RenderTask property index out of range"); // should not come here
 602       break;
 603     }
 604   }
 605
 606   return value;
 607 }
 608
 609 void RenderTask::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType )
 610 {
 611   switch( animationType )
 612   {
 613     case Animation::TO:
 614     case Animation::BETWEEN:
 615     {
 616       switch ( index )
 617       {
 618         case Dali::RenderTask::Property::VIEWPORT_POSITION:
 619         {
 620           value.Get( mViewportPosition );
 621           break;
 622         }
 623         case Dali::RenderTask::Property::VIEWPORT_SIZE:
 624         {
 625           value.Get( mViewportSize );
 626           break;
 627         }
 628         case Dali::RenderTask::Property::CLEAR_COLOR:
 629         {
 630           value.Get( mClearColor );
 631           break;
 632         }
 633         case Dali::RenderTask::Property::REQUIRES_SYNC:
 634         default:
 635         {
 636           // Nothing to do as not animatable
 637           break;
 638         }
 639       }
 640       break;
 641     }
 642
 643     case Animation::BY:
 644     {
 645       switch ( index )
 646       {
 647         case Dali::RenderTask::Property::VIEWPORT_POSITION:
 648         {
 649           AdjustValue< Vector2 >( mViewportPosition, value );
 650           break;
 651         }
 652         case Dali::RenderTask::Property::VIEWPORT_SIZE:
 653         {
 654           AdjustValue< Vector2 >( mViewportSize, value );
 655           break;
 656         }
 657         case Dali::RenderTask::Property::CLEAR_COLOR:
 658         {
 659           AdjustValue< Vector4 >( mClearColor, value );
 660           break;
 661         }
 662         case Dali::RenderTask::Property::REQUIRES_SYNC:
 663         default:
 664         {
 665           // Nothing to do as not animatable
 666           break;
 667         }
 668       }
 669       break;
 670     }
 671   }
 672 }
 673
 674 const SceneGraph::PropertyBase* RenderTask::GetSceneObjectAnimatableProperty( Property::Index index ) const
 675 {
 676   const SceneGraph::PropertyBase* property( NULL );
 677
 678   switch ( index )
 679   {
 680     case Dali::RenderTask::Property::VIEWPORT_POSITION:
 681     {
 682       property = &GetRenderTaskSceneObject().mViewportPosition;
 683       break;
 684     }
 685     case Dali::RenderTask::Property::VIEWPORT_SIZE:
 686     {
 687       property = &GetRenderTaskSceneObject().mViewportSize;
 688       break;
 689     }
 690     case Dali::RenderTask::Property::CLEAR_COLOR:
 691     {
 692       property = &GetRenderTaskSceneObject().mClearColor;
 693       break;
 694     }
 695     default:
 696     {
 697       break;
 698     }
 699   }
 700   if( !property )
 701   {
 702     // not our property, ask base
 703     property = Object::GetSceneObjectAnimatableProperty( index );
 704   }
 705
 706   return property;
 707 }
 708
 709 const PropertyInputImpl* RenderTask::GetSceneObjectInputProperty( Property::Index index ) const
 710 {
 711   // animatable properties are input as well, Object::GetSceneObjectInputProperty does the same so no need to call it
 712   return GetSceneObjectAnimatableProperty( index );
 713 }
 714
 715 bool RenderTask::HasFinished()
 716 {
 717   bool finished = false;
 718   const uint32_t counter = GetRenderTaskSceneObject().GetRenderedOnceCounter();
 719
 720   if( mRefreshOnceCounter < counter )
 721   {
 722     finished = true;
 723     mRefreshOnceCounter = counter;
 724   }
 725
 726   DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::HasFinished()=%s SCRT:%p  SC\n", finished?"T":"F", &GetRenderTaskSceneObject());
 727
 728   return finished;
 729 }
 730
 731 void RenderTask::EmitSignalFinish()
 732 {
 733   DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::EmitSignalFinish(this:%p)\n", this);
 734
 735   if( !mSignalFinished.Empty() )
 736   {
 737     Dali::RenderTask handle( this );
 738     mSignalFinished.Emit(handle );
 739   }
 740 }
 741
 742 Dali::RenderTask::RenderTaskSignalType& RenderTask::FinishedSignal()
 743 {
 744   return mSignalFinished;
 745 }
 746
 747 bool RenderTask::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 748 {
 749   bool connected( true );
 750   RenderTask* renderTask = static_cast< RenderTask* >(object); // TypeRegistry guarantees that this is the correct type.
 751
 752   if ( 0 == strcmp( signalName.c_str(), SIGNAL_FINISHED ) )
 753   {
 754     renderTask->FinishedSignal().Connect( tracker, functor );
 755   }
 756   else
 757   {
 758     // signalName does not match any signal
 759     connected = false;
 760   }
 761
 762   return connected;
 763 }
 764
 765 RenderTask::RenderTask( const SceneGraph::RenderTask* sceneObject, RenderTaskList& renderTaskList )
 766 : Object( sceneObject ),
 767   mSourceActor( nullptr ),
 768   mCameraActor( nullptr ),
 769   mInputMappingActor(),
 770   mRenderTaskList( renderTaskList ),
 771   mClearColor( Dali::RenderTask::DEFAULT_CLEAR_COLOR ),
 772   mViewportPosition( Vector2::ZERO ),
 773   mViewportSize( Vector2::ZERO ),
 774   mRefreshRate( Dali::RenderTask::DEFAULT_REFRESH_RATE ),
 775   mRefreshOnceCounter( 0u ),
 776   mScreenToFrameBufferFunction( Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION ),
 777   mExclusive( Dali::RenderTask::DEFAULT_EXCLUSIVE ),
 778   mInputEnabled( Dali::RenderTask::DEFAULT_INPUT_ENABLED ),
 779   mClearEnabled( Dali::RenderTask::DEFAULT_CLEAR_ENABLED ),
 780   mCullMode( Dali::RenderTask::DEFAULT_CULL_MODE ),
 781   mRequiresSync( false )
 782 {
 783   DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::RenderTask(this:%p)\n", this);
 784   // scene object handles observation of source and camera
 785 }
 786
 787 RenderTask::~RenderTask()
 788 {
 789   DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::~RenderTask(this:%p)\n", this);
 790   // scene object deletion is handled by our parent
 791   // scene object handles observation of source and camera
 792 }
 793
 794 } // namespace Internal
 795
 796 } // namespace Dali