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