dali/internal/event/events/hit-test-algorithm-impl.cpp

   1 /*
   2  * Copyright (c) 2014 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/events/hit-test-algorithm-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/integration-api/system-overlay.h>
  23 #include <dali/public-api/actors/layer.h>
  24 #include <dali/public-api/math/vector2.h>
  25 #include <dali/public-api/math/vector4.h>
  26 #include <dali/integration-api/debug.h>
  27 #include <dali/internal/event/actors/actor-impl.h>
  28 #include <dali/internal/event/actors/camera-actor-impl.h>
  29 #include <dali/internal/event/actors/image-actor-impl.h>
  30 #include <dali/internal/event/actors/layer-impl.h>
  31 #include <dali/internal/event/actors/layer-list.h>
  32 #include <dali/internal/event/common/system-overlay-impl.h>
  33 #include <dali/internal/event/common/stage-impl.h>
  34 #include <dali/internal/event/common/projection.h>
  35 #include <dali/internal/event/images/frame-buffer-image-impl.h>
  36 #include <dali/internal/event/render-tasks/render-task-impl.h>
  37 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
  38
  39 namespace Dali
  40 {
  41
  42 namespace Internal
  43 {
  44
  45 namespace HitTestAlgorithm
  46 {
  47
  48 namespace
  49 {
  50
  51 struct HitActor
  52 {
  53   HitActor()
  54   : actor( NULL ),
  55     x( 0 ),
  56     y( 0 ),
  57     distance( std::numeric_limits<float>::max() ),
  58     depth( std::numeric_limits<int>::min() )
  59   {
  60   }
  61
  62   Actor *actor;                         ///< the actor hit. (if actor hit, then initialised)
  63   float x;                              ///< x position of hit (only valid if actor valid)
  64   float y;                              ///< y position of hit (only valid if actor valid)
  65   float distance;                       ///< distance from ray origin to hit actor
  66   int depth;                            ///< depth index of this actor
  67
  68 };
  69
  70 /**
  71  * Creates an Actor handle so that a HitTestFunction provided via the public API can be called.
  72  */
  73 struct HitTestFunctionWrapper : public HitTestInterface
  74 {
  75   /**
  76    * Constructor
  77    *
  78    * @param[in] func HitTestFunction to call with an Actor handle.
  79    */
  80   HitTestFunctionWrapper( Dali::HitTestAlgorithm::HitTestFunction func )
  81   : mFunc( func )
  82   {
  83   }
  84
  85   virtual bool IsActorHittable( Actor* actor )
  86   {
  87     return mFunc( Dali::Actor( actor ), Dali::HitTestAlgorithm::CHECK_ACTOR );
  88   }
  89
  90   virtual bool DescendActorHierarchy( Actor* actor )
  91   {
  92     return mFunc( Dali::Actor( actor ), Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE );
  93   }
  94
  95   virtual bool DoesLayerConsumeHit( Layer* layer )
  96   {
  97     // Layer::IsTouchConsumed() focuses on touch only. Here we are a wrapper for the public-api
  98     // where the caller may want to check for something completely different.
  99     // TODO: Should provide a means to let caller decide. For now do not allow layers to consume
 100     return false;
 101   }
 102
 103   Dali::HitTestAlgorithm::HitTestFunction mFunc;
 104 };
 105
 106 /**
 107  * Used in the hit-test algorithm to check whether the actor is touchable.
 108  * It is used by the touch event processor.
 109  */
 110 struct ActorTouchableCheck : public HitTestInterface
 111 {
 112   virtual bool IsActorHittable( Actor* actor )
 113   {
 114     return actor->GetTouchRequired() && // Does the Application or derived actor type require a touch event?
 115            actor->IsHittable();         // Is actor sensitive, visible and on the scene?
 116   }
 117
 118   virtual bool DescendActorHierarchy( Actor* actor )
 119   {
 120     return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
 121            actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
 122   }
 123
 124   virtual bool DoesLayerConsumeHit( Layer* layer )
 125   {
 126     return layer->IsTouchConsumed();
 127   }
 128 };
 129
 130 /**
 131  * Check to see if the actor we're about to hit test is exclusively owned by another rendertask?
 132  */
 133 bool IsActorExclusiveToAnotherRenderTask( const Actor& actor,
 134                                           const RenderTask& renderTask,
 135                                           const Vector< RenderTaskList::Exclusive >& exclusives )
 136
 137 {
 138   if ( exclusives.Size() )
 139   {
 140     for ( Vector< RenderTaskList::Exclusive >::Iterator exclusiveIt = exclusives.Begin(); exclusives.End() != exclusiveIt; ++exclusiveIt )
 141     {
 142       if ( exclusiveIt->renderTaskPtr != &renderTask )
 143       {
 144         if ( exclusiveIt->actorPtr == &actor )
 145         {
 146           return true;
 147         }
 148       }
 149     }
 150   }
 151   return false;
 152 }
 153
 154 /**
 155  * Recursively hit test all the actors, without crossing into other layers.
 156  * This algorithm performs a Depth-First-Search (DFS) on all Actors within Layer.
 157  * Hit-Testing each Actor, noting the distance from the Ray-Origin (3D origin
 158  * of touch vector). The closest Hit-Tested Actor is that which is returned.
 159  * Exceptions to this rule are:
 160  * - When comparing against renderable parents, if Actor is the same distance
 161  * or closer than it's renderable parent, then it takes priority.
 162  */
 163 HitActor HitTestWithinLayer( Actor& actor,
 164                              const RenderTask& renderTask,
 165                              const Vector< RenderTaskList::Exclusive >& exclusives,
 166                              const Vector4& rayOrigin,
 167                              const Vector4& rayDir,
 168                              float& nearClippingPlane,
 169                              float& farClippingPlane,
 170                              HitTestInterface& hitCheck,
 171                              bool& stencilOnLayer,
 172                              bool& stencilHit,
 173                              bool parentIsStencil,
 174                              bool layerIs3d )
 175 {
 176   HitActor hit;
 177
 178   if ( IsActorExclusiveToAnotherRenderTask( actor, renderTask, exclusives ) )
 179   {
 180     return hit;
 181   }
 182
 183   // Children should inherit the stencil draw mode
 184   bool isStencil = parentIsStencil;
 185
 186   if ( actor.GetDrawMode() == DrawMode::STENCIL && actor.IsVisible() )
 187   {
 188     isStencil = true;
 189     stencilOnLayer = true;
 190   }
 191
 192   // If we are a stencil or hittable...
 193   if ( isStencil || hitCheck.IsActorHittable( &actor ) )
 194   {
 195     Vector3 size( actor.GetCurrentSize() );
 196
 197     if ( size.x > 0.0f && size.y > 0.0f &&          // Ensure the actor has a valid size.
 198          actor.RaySphereTest( rayOrigin, rayDir ) ) // Perform quicker ray sphere test to see if our ray is close to the actor.
 199     {
 200       Vector4 hitPointLocal;
 201       float distance;
 202
 203       // Finally, perform a more accurate ray test to see if our ray actually hits the actor.
 204       if( actor.RayActorTest( rayOrigin, rayDir, hitPointLocal, distance ) )
 205       {
 206         if( distance >= nearClippingPlane && distance <= farClippingPlane )
 207         {
 208           // If the hit has happened on a stencil then register, but don't record as hit result
 209           if ( isStencil )
 210           {
 211             stencilHit = true;
 212           }
 213           else
 214           {
 215             hit.actor = &actor;
 216             hit.x = hitPointLocal.x;
 217             hit.y = hitPointLocal.y;
 218             hit.distance = distance;
 219             hit.depth = actor.GetHierarchyDepth() * Dali::Layer::TREE_DEPTH_MULTIPLIER;
 220
 221             // Is this actor an Image Actor or contains a renderer?
 222             if ( ImageActor* imageActor = dynamic_cast< ImageActor* >( &actor ) )
 223             {
 224               hit.depth += imageActor->GetDepthIndex();
 225             }
 226             else if ( actor.GetRendererCount() )
 227             {
 228               hit.depth += actor.GetRendererAt( 0 ).GetDepthIndex();
 229             }
 230           }
 231         }
 232       }
 233     }
 234   }
 235
 236   // If we are a stencil (or a child of a stencil) and we have already ascertained that the stencil has been hit then there is no need to hit-test the children of this stencil-actor
 237   if ( isStencil && stencilHit  )
 238   {
 239     return hit;
 240   }
 241
 242   // Find a child hit, until we run out of actors in the current layer.
 243   HitActor childHit;
 244   if( actor.GetChildCount() > 0 )
 245   {
 246     childHit.distance = std::numeric_limits<float>::max();
 247     childHit.depth = std::numeric_limits<int>::min();
 248     ActorContainer& children = actor.GetChildrenInternal();
 249
 250     // Hit test ALL children and calculate their distance.
 251     bool parentIsRenderable = actor.IsRenderable();
 252
 253     for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
 254     {
 255       // Descend tree only if...
 256       if ( !(*iter)->IsLayer() &&    // Child is NOT a layer, hit testing current layer only or Child is not a layer and we've inherited the stencil draw mode
 257            ( isStencil || hitCheck.DescendActorHierarchy( ( *iter ).Get() ) ) ) // We are a stencil OR we can descend into child hierarchy
 258       {
 259         HitActor currentHit( HitTestWithinLayer(  (*iter->Get()),
 260                                                   renderTask,
 261                                                   exclusives,
 262                                                   rayOrigin,
 263                                                   rayDir,
 264                                                   nearClippingPlane,
 265                                                   farClippingPlane,
 266                                                   hitCheck,
 267                                                   stencilOnLayer,
 268                                                   stencilHit,
 269                                                   isStencil,
 270                                                   layerIs3d) );
 271
 272         bool updateChildHit = false;
 273         if ( currentHit.distance >= 0.0f )
 274         {
 275           if( layerIs3d )
 276           {
 277             updateChildHit = ( ( currentHit.depth > childHit.depth ) ||
 278                 ( ( currentHit.depth == childHit.depth ) && ( currentHit.distance < childHit.distance ) ) );
 279           }
 280           else
 281           {
 282             updateChildHit = currentHit.depth >= childHit.depth;
 283           }
 284         }
 285
 286         if ( updateChildHit )
 287         {
 288           if( !parentIsRenderable || currentHit.depth > hit.depth ||
 289             ( layerIs3d && ( currentHit.depth == hit.depth && currentHit.distance < hit.distance )) )
 290             {
 291               childHit = currentHit;
 292             }
 293         }
 294       }
 295     }
 296   }
 297   return ( childHit.actor ) ? childHit : hit;
 298 }
 299
 300 /**
 301  * Return true if actor is sourceActor or a descendent of sourceActor
 302  */
 303 bool IsWithinSourceActors( const Actor& sourceActor, const Actor& actor )
 304 {
 305   if ( &sourceActor == &actor )
 306   {
 307     return true;
 308   }
 309   else
 310   {
 311     Actor* parent = actor.GetParent();
 312     if ( parent )
 313     {
 314       return IsWithinSourceActors( sourceActor, *parent );
 315     }
 316   }
 317
 318   // Not within source actors
 319   return false;
 320 }
 321
 322 /**
 323  * Returns true if the layer and all of the layer's parents are visible and sensitive.
 324  */
 325 inline bool IsActuallyHittable( Layer& layer, const Vector2& screenCoordinates, const Vector2& stageSize, HitTestInterface& hitCheck )
 326 {
 327   bool hittable( true );
 328
 329   if(layer.IsClipping())
 330   {
 331     ClippingBox box = layer.GetClippingBox();
 332
 333     if( screenCoordinates.x < box.x ||
 334         screenCoordinates.x > box.x + box.width ||
 335         screenCoordinates.y < stageSize.y - (box.y + box.height) ||
 336         screenCoordinates.y > stageSize.y - box.y)
 337     {
 338       // Not touchable if clipping is enabled in the layer and the screen coordinate is outside the clip region.
 339       hittable = false;
 340     }
 341   }
 342
 343   if(hittable)
 344   {
 345     Actor* actor( &layer );
 346
 347     // Ensure that we can descend into the layer's (or any of its parent's) hierarchy.
 348     while ( actor && hittable )
 349     {
 350       if ( ! hitCheck.DescendActorHierarchy( actor ) )
 351       {
 352         hittable = false;
 353         break;
 354       }
 355       actor = actor->GetParent();
 356     }
 357   }
 358
 359   return hittable;
 360 }
 361
 362 /**
 363  * Gets the near and far clipping planes of the camera from which the scene is viewed in the render task.
 364  */
 365 void GetCameraClippingPlane( RenderTask& renderTask, float& nearClippingPlane, float& farClippingPlane )
 366 {
 367   CameraActor* cameraActor = renderTask.GetCameraActor();
 368   nearClippingPlane = cameraActor->GetNearClippingPlane();
 369   farClippingPlane = cameraActor->GetFarClippingPlane();
 370 }
 371
 372 /**
 373  * Hit test a RenderTask
 374  */
 375 bool HitTestRenderTask( const Vector< RenderTaskList::Exclusive >& exclusives,
 376                         Stage& stage,
 377                         LayerList& layers,
 378                         RenderTask& renderTask,
 379                         Vector2 screenCoordinates,
 380                         Results& results,
 381                         HitTestInterface& hitCheck )
 382 {
 383   if ( renderTask.IsHittable( screenCoordinates ) )
 384   {
 385     Viewport viewport;
 386     renderTask.GetViewport( viewport );
 387     if( screenCoordinates.x < viewport.x ||
 388         screenCoordinates.x > viewport.x + viewport.width ||
 389         screenCoordinates.y < viewport.y ||
 390         screenCoordinates.y > viewport.y + viewport.height )
 391     {
 392       // The screen coordinate is outside the viewport of render task. The viewport clips all layers.
 393       return false;
 394     }
 395
 396     float nearClippingPlane, farClippingPlane;
 397     GetCameraClippingPlane(renderTask, nearClippingPlane, farClippingPlane);
 398
 399     // Determine the layer depth of the source actor
 400     Actor* sourceActor( renderTask.GetSourceActor() );
 401     if ( sourceActor )
 402     {
 403       Dali::Layer layer( sourceActor->GetLayer() );
 404       if ( layer )
 405       {
 406         const unsigned int sourceActorDepth( layer.GetDepth() );
 407
 408         CameraActor* cameraActor = renderTask.GetCameraActor();
 409         bool pickingPossible = cameraActor->BuildPickingRay(
 410             screenCoordinates,
 411             viewport,
 412             results.rayOrigin,
 413             results.rayDirection );
 414         if( !pickingPossible )
 415         {
 416           return false;
 417         }
 418
 419         // Hit test starting with the top layer, working towards the bottom layer.
 420         HitActor hit;
 421         bool stencilOnLayer = false;
 422         bool stencilHit = false;
 423         bool layerConsumesHit = false;
 424
 425         const Vector2& stageSize = stage.GetSize();
 426
 427         for (int i=layers.GetLayerCount()-1; i>=0 && !(hit.actor); --i)
 428         {
 429           Layer* layer( layers.GetLayer(i) );
 430           HitActor previousHit = hit;
 431           stencilOnLayer = false;
 432           stencilHit = false;
 433
 434           // Ensure layer is touchable (also checks whether ancestors are also touchable)
 435           if ( IsActuallyHittable ( *layer, screenCoordinates, stageSize, hitCheck ) )
 436           {
 437             // Always hit-test the source actor; otherwise test whether the layer is below the source actor in the hierarchy
 438             if ( sourceActorDepth == static_cast<unsigned int>(i) )
 439             {
 440               // Recursively hit test the source actor & children, without crossing into other layers.
 441               hit = HitTestWithinLayer( *sourceActor,
 442                                         renderTask,
 443                                         exclusives,
 444                                         results.rayOrigin,
 445                                         results.rayDirection,
 446                                         nearClippingPlane,
 447                                         farClippingPlane,
 448                                         hitCheck,
 449                                         stencilOnLayer,
 450                                         stencilHit,
 451                                         false,
 452                                         layer->GetBehavior() == Dali::Layer::LAYER_3D);
 453             }
 454             else if ( IsWithinSourceActors( *sourceActor, *layer ) )
 455             {
 456               // Recursively hit test all the actors, without crossing into other layers.
 457               hit = HitTestWithinLayer( *layer,
 458                                         renderTask,
 459                                         exclusives,
 460                                         results.rayOrigin,
 461                                         results.rayDirection,
 462                                         nearClippingPlane,
 463                                         farClippingPlane,
 464                                         hitCheck,
 465                                         stencilOnLayer,
 466                                         stencilHit,
 467                                         false,
 468                                         layer->GetBehavior() == Dali::Layer::LAYER_3D);
 469             }
 470
 471             // If a stencil on this layer hasn't been hit, then discard hit results for this layer if our current hit actor is renderable
 472             if ( stencilOnLayer && !stencilHit &&
 473                  hit.actor && hit.actor->IsRenderable() )
 474             {
 475               hit = previousHit;
 476             }
 477
 478             // If this layer is set to consume the hit, then do not check any layers behind it
 479             if ( hitCheck.DoesLayerConsumeHit( layer ) )
 480             {
 481               layerConsumesHit = true;
 482               break;
 483             }
 484           }
 485         }
 486         if ( hit.actor )
 487         {
 488           results.renderTask = Dali::RenderTask(&renderTask);
 489           results.actor = Dali::Actor(hit.actor);
 490           results.actorCoordinates.x = hit.x;
 491           results.actorCoordinates.y = hit.y;
 492           return true; // Success
 493         }
 494         else if ( layerConsumesHit )
 495         {
 496           return true; // Also success if layer is consuming the hit
 497         }
 498       }
 499     }
 500   }
 501   return false;
 502 }
 503
 504 /**
 505  * Iterate through RenderTaskList and perform hit test.
 506  *
 507  * @return true if we have a hit, false otherwise
 508  */
 509 bool HitTestForEachRenderTask( Stage& stage,
 510                                LayerList& layers,
 511                                RenderTaskList& taskList,
 512                                const Vector2& screenCoordinates,
 513                                Results& results,
 514                                HitTestInterface& hitCheck )
 515 {
 516   RenderTaskList::RenderTaskContainer& tasks = taskList.GetTasks();
 517   RenderTaskList::RenderTaskContainer::reverse_iterator endIter = tasks.rend();
 518
 519   const Vector< RenderTaskList::Exclusive >& exclusives = taskList.GetExclusivesList();
 520
 521   // Check onscreen tasks before offscreen ones, hit test order should be reverse of draw order (see ProcessRenderTasks() where offscreen tasks are drawn first).
 522
 523   // on screen
 524   for ( RenderTaskList::RenderTaskContainer::reverse_iterator iter = tasks.rbegin(); endIter != iter; ++iter )
 525   {
 526     RenderTask& renderTask = GetImplementation( *iter );
 527     Dali::FrameBufferImage frameBufferImage = renderTask.GetTargetFrameBuffer();
 528
 529     // Note that if frameBufferImage is NULL we are using the default (on screen) render target
 530     if(frameBufferImage)
 531     {
 532       ResourceId id = GetImplementation(frameBufferImage).GetResourceId();
 533
 534       // on screen only
 535       if(0 != id)
 536       {
 537         // Skip to next task
 538         continue;
 539       }
 540     }
 541
 542     if ( HitTestRenderTask( exclusives, stage, layers, renderTask, screenCoordinates, results, hitCheck ) )
 543     {
 544       // Return true when an actor is hit (or layer in our render-task consumes the hit)
 545       return true; // don't bother checking off screen tasks
 546     }
 547   }
 548
 549   // off screen
 550   for ( RenderTaskList::RenderTaskContainer::reverse_iterator iter = tasks.rbegin(); endIter != iter; ++iter )
 551   {
 552     RenderTask& renderTask = GetImplementation( *iter );
 553     Dali::FrameBufferImage frameBufferImage = renderTask.GetTargetFrameBuffer();
 554
 555     // Note that if frameBufferImage is NULL we are using the default (on screen) render target
 556     if(frameBufferImage)
 557     {
 558       ResourceId id = GetImplementation(frameBufferImage).GetResourceId();
 559
 560       // off screen only
 561       if(0 == id)
 562       {
 563         // Skip to next task
 564         continue;
 565       }
 566
 567       if ( HitTestRenderTask( exclusives, stage, layers, renderTask, screenCoordinates, results, hitCheck ) )
 568       {
 569         // Return true when an actor is hit (or a layer in our render-task consumes the hit)
 570         return true;
 571       }
 572     }
 573   }
 574   return false;
 575 }
 576
 577 } // unnamed namespace
 578
 579 bool HitTest( Stage& stage, const Vector2& screenCoordinates, Dali::HitTestAlgorithm::Results& results, Dali::HitTestAlgorithm::HitTestFunction func )
 580 {
 581   bool wasHit( false );
 582   // Hit-test the regular on-stage actors
 583   RenderTaskList& taskList = stage.GetRenderTaskList();
 584   LayerList& layerList = stage.GetLayerList();
 585
 586   Results hitTestResults;
 587   HitTestFunctionWrapper hitTestFunctionWrapper( func );
 588   if (  HitTestForEachRenderTask( stage, layerList, taskList, screenCoordinates, hitTestResults, hitTestFunctionWrapper ) )
 589   {
 590     results.actor = hitTestResults.actor;
 591     results.actorCoordinates = hitTestResults.actorCoordinates;
 592     wasHit = true;
 593   }
 594   return wasHit;
 595 }
 596
 597 bool HitTest( Stage& stage, const Vector2& screenCoordinates, Results& results, HitTestInterface& hitTestInterface )
 598 {
 599   bool wasHit( false );
 600
 601   // Hit-test the system-overlay actors first
 602   SystemOverlay* systemOverlay = stage.GetSystemOverlayInternal();
 603
 604   if ( systemOverlay )
 605   {
 606     RenderTaskList& overlayTaskList = systemOverlay->GetOverlayRenderTasks();
 607     LayerList& overlayLayerList = systemOverlay->GetLayerList();
 608
 609     wasHit = HitTestForEachRenderTask( stage, overlayLayerList, overlayTaskList, screenCoordinates, results, hitTestInterface );
 610   }
 611
 612   // Hit-test the regular on-stage actors
 613   if ( !wasHit )
 614   {
 615     RenderTaskList& taskList = stage.GetRenderTaskList();
 616     LayerList& layerList = stage.GetLayerList();
 617
 618     wasHit = HitTestForEachRenderTask( stage, layerList, taskList, screenCoordinates, results, hitTestInterface );
 619   }
 620   return wasHit;
 621 }
 622
 623 bool HitTest( Stage& stage, const Vector2& screenCoordinates, Results& results )
 624 {
 625   ActorTouchableCheck actorTouchableCheck;
 626   return HitTest( stage, screenCoordinates, results, actorTouchableCheck );
 627 }
 628
 629 bool HitTest( Stage& stage, RenderTask& renderTask, const Vector2& screenCoordinates,
 630               Dali::HitTestAlgorithm::Results& results, Dali::HitTestAlgorithm::HitTestFunction func )
 631 {
 632   bool wasHit( false );
 633   Results hitTestResults;
 634
 635   const Vector< RenderTaskList::Exclusive >& exclusives = stage.GetRenderTaskList().GetExclusivesList();
 636   HitTestFunctionWrapper hitTestFunctionWrapper( func );
 637   if ( HitTestRenderTask( exclusives, stage, stage.GetLayerList(), renderTask, screenCoordinates, hitTestResults, hitTestFunctionWrapper ) )
 638   {
 639     results.actor = hitTestResults.actor;
 640     results.actorCoordinates = hitTestResults.actorCoordinates;
 641     wasHit = true;
 642   }
 643   return wasHit;
 644 }
 645
 646 } // namespace HitTestAlgorithm
 647
 648 } // namespace Internal
 649
 650 } // namespace Dali