Removed Overlay override from hit-test-algorithm
[platform/core/uifw/dali-core.git] / 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/math/vector2.h>
24 #include <dali/public-api/math/vector4.h>
25 #include <dali/integration-api/debug.h>
26 #include <dali/internal/event/actors/actor-impl.h>
27 #include <dali/internal/event/actors/camera-actor-impl.h>
28 #include <dali/internal/event/actors/image-actor-impl.h>
29 #include <dali/internal/event/actors/layer-impl.h>
30 #include <dali/internal/event/actors/layer-list.h>
31 #include <dali/internal/event/actors/renderable-actor-impl.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 {
175   HitActor hit;
176
177   if ( IsActorExclusiveToAnotherRenderTask( actor, renderTask, exclusives ) )
178   {
179     return hit;
180   }
181
182   // Children should inherit the stencil draw mode
183   bool isStencil = parentIsStencil;
184
185   if ( actor.GetDrawMode() == DrawMode::STENCIL && actor.IsVisible() )
186   {
187     isStencil = true;
188     stencilOnLayer = true;
189   }
190
191   // If we are a stencil or hittable...
192   if ( isStencil || hitCheck.IsActorHittable( &actor ) )
193   {
194     Vector3 size( actor.GetCurrentSize() );
195
196     if ( size.x > 0.0f && size.y > 0.0f &&          // Ensure the actor has a valid size.
197          actor.RaySphereTest( rayOrigin, rayDir ) ) // Perform quicker ray sphere test to see if our ray is close to the actor.
198     {
199       Vector4 hitPointLocal;
200       float distance;
201
202       // Finally, perform a more accurate ray test to see if our ray actually hits the actor.
203       if( actor.RayActorTest( rayOrigin, rayDir, hitPointLocal, distance ) )
204       {
205         if( distance >= nearClippingPlane && distance <= farClippingPlane )
206         {
207           // If the hit has happened on a stencil then register, but don't record as hit result
208           if ( isStencil )
209           {
210             stencilHit = true;
211           }
212           else
213           {
214             hit.actor = &actor;
215             hit.x = hitPointLocal.x;
216             hit.y = hitPointLocal.y;
217             hit.distance = distance;
218
219             // Is this actor an Image Actor or contains a renderer?
220             if ( ImageActor* imageActor = dynamic_cast< ImageActor* >( &actor ) )
221             {
222               hit.depth = imageActor->GetDepthIndex();
223             }
224             else
225             {
226               if ( actor.GetRendererCount() )
227               {
228                 hit.depth = actor.GetRendererAt( 0 ).GetCurrentDepthIndex();
229               }
230               else
231               {
232                 hit.depth = 0;
233               }
234             }
235           }
236         }
237       }
238     }
239   }
240
241   // 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
242   if ( isStencil && stencilHit  )
243   {
244     return hit;
245   }
246
247   // Find a child hit, until we run out of actors in the current layer.
248   HitActor childHit;
249   if( actor.GetChildCount() > 0 )
250   {
251     childHit.distance = std::numeric_limits<float>::max();
252     childHit.depth = std::numeric_limits<int>::min();
253     ActorContainer& children = actor.GetChildrenInternal();
254
255     // Hit test ALL children and calculate their distance.
256     bool parentIsRenderable = actor.IsRenderable();
257
258     for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
259     {
260       // Descend tree only if...
261       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
262            ( isStencil || hitCheck.DescendActorHierarchy( &GetImplementation( *iter ) ) ) ) // We are a stencil OR we can descend into child hierarchy
263       {
264         HitActor currentHit( HitTestWithinLayer(  GetImplementation(*iter),
265                                                   renderTask,
266                                                   exclusives,
267                                                   rayOrigin,
268                                                   rayDir,
269                                                   nearClippingPlane,
270                                                   farClippingPlane,
271                                                   hitCheck,
272                                                   stencilOnLayer,
273                                                   stencilHit,
274                                                   isStencil ) );
275
276         bool updateChildHit = false;
277         // If our ray casting hit, then check then if the hit actor's depth is greater that the favorite, it will be preferred
278         if ( currentHit.distance >= 0.0f )
279         {
280           if ( currentHit.depth > childHit.depth )
281           {
282             updateChildHit = true;
283           }
284
285           // If the hit actor's depth is equal to current favorite, then we check the distance and prefer the closer
286           else if ( currentHit.depth == childHit.depth )
287           {
288             if ( currentHit.distance < childHit.distance )
289             {
290               updateChildHit = true;
291             }
292           }
293         }
294
295         if ( updateChildHit )
296         {
297           if( !parentIsRenderable || currentHit.depth > hit.depth ||
298             ( currentHit.depth == hit.depth && currentHit.distance < hit.distance ) )
299             {
300               childHit = currentHit;
301             }
302         }
303       }
304     }
305   }
306   return ( childHit.actor ) ? childHit : hit;
307 }
308
309 /**
310  * Return true if actor is sourceActor or a descendent of sourceActor
311  */
312 bool IsWithinSourceActors( const Actor& sourceActor, const Actor& actor )
313 {
314   if ( &sourceActor == &actor )
315   {
316     return true;
317   }
318   else
319   {
320     Actor* parent = actor.GetParent();
321     if ( parent )
322     {
323       return IsWithinSourceActors( sourceActor, *parent );
324     }
325   }
326
327   // Not within source actors
328   return false;
329 }
330
331 /**
332  * Returns true if the layer and all of the layer's parents are visible and sensitive.
333  */
334 inline bool IsActuallyHittable( Layer& layer, const Vector2& screenCoordinates, const Vector2& stageSize, HitTestInterface& hitCheck )
335 {
336   bool hittable( true );
337
338   if(layer.IsClipping())
339   {
340     ClippingBox box = layer.GetClippingBox();
341
342     if( screenCoordinates.x < box.x ||
343         screenCoordinates.x > box.x + box.width ||
344         screenCoordinates.y < stageSize.y - (box.y + box.height) ||
345         screenCoordinates.y > stageSize.y - box.y)
346     {
347       // Not touchable if clipping is enabled in the layer and the screen coordinate is outside the clip region.
348       hittable = false;
349     }
350   }
351
352   if(hittable)
353   {
354     Actor* actor( &layer );
355
356     // Ensure that we can descend into the layer's (or any of its parent's) hierarchy.
357     while ( actor && hittable )
358     {
359       if ( ! hitCheck.DescendActorHierarchy( actor ) )
360       {
361         hittable = false;
362         break;
363       }
364       actor = actor->GetParent();
365     }
366   }
367
368   return hittable;
369 }
370
371 /**
372  * Gets the near and far clipping planes of the camera from which the scene is viewed in the render task.
373  */
374 void GetCameraClippingPlane( RenderTask& renderTask, float& nearClippingPlane, float& farClippingPlane )
375 {
376   CameraActor* cameraActor = renderTask.GetCameraActor();
377   nearClippingPlane = cameraActor->GetNearClippingPlane();
378   farClippingPlane = cameraActor->GetFarClippingPlane();
379 }
380
381 /**
382  * Hit test a RenderTask
383  */
384 bool HitTestRenderTask( const Vector< RenderTaskList::Exclusive >& exclusives,
385                         LayerList& layers,
386                         RenderTask& renderTask,
387                         Vector2 screenCoordinates,
388                         Results& results,
389                         HitTestInterface& hitCheck )
390 {
391   if ( renderTask.IsHittable( screenCoordinates ) )
392   {
393     Viewport viewport;
394     renderTask.GetViewport( viewport );
395     if( screenCoordinates.x < viewport.x ||
396         screenCoordinates.x > viewport.x + viewport.width ||
397         screenCoordinates.y < viewport.y ||
398         screenCoordinates.y > viewport.y + viewport.height )
399     {
400       // The screen coordinate is outside the viewport of render task. The viewport clips all layers.
401       return false;
402     }
403
404     float nearClippingPlane, farClippingPlane;
405     GetCameraClippingPlane(renderTask, nearClippingPlane, farClippingPlane);
406
407     // Determine the layer depth of the source actor
408     Actor* sourceActor( renderTask.GetSourceActor() );
409     if ( sourceActor )
410     {
411       Dali::Layer layer( sourceActor->GetLayer() );
412       if ( layer )
413       {
414         const unsigned int sourceActorDepth( layer.GetDepth() );
415
416         CameraActor* cameraActor = renderTask.GetCameraActor();
417         bool pickingPossible = cameraActor->BuildPickingRay(
418             screenCoordinates,
419             viewport,
420             results.rayOrigin,
421             results.rayDirection );
422         if( !pickingPossible )
423         {
424           return false;
425         }
426
427         // Hit test starting with the top layer, working towards the bottom layer.
428         HitActor hit;
429         bool stencilOnLayer = false;
430         bool stencilHit = false;
431         bool layerConsumesHit = false;
432         const Vector2& stageSize = Stage::GetCurrent()->GetSize();
433
434         for (int i=layers.GetLayerCount()-1; i>=0 && !(hit.actor); --i)
435         {
436           Layer* layer( layers.GetLayer(i) );
437           HitActor previousHit = hit;
438           stencilOnLayer = false;
439           stencilHit = false;
440
441           // Ensure layer is touchable (also checks whether ancestors are also touchable)
442           if ( IsActuallyHittable ( *layer, screenCoordinates, stageSize, hitCheck ) )
443           {
444             // Always hit-test the source actor; otherwise test whether the layer is below the source actor in the hierarchy
445             if ( sourceActorDepth == static_cast<unsigned int>(i) )
446             {
447               // Recursively hit test the source actor & children, without crossing into other layers.
448               hit = HitTestWithinLayer( *sourceActor,
449                                         renderTask,
450                                         exclusives,
451                                         results.rayOrigin,
452                                         results.rayDirection,
453                                         nearClippingPlane,
454                                         farClippingPlane,
455                                         hitCheck,
456                                         stencilOnLayer,
457                                         stencilHit,
458                                         false );
459             }
460             else if ( IsWithinSourceActors( *sourceActor, *layer ) )
461             {
462               // Recursively hit test all the actors, without crossing into other layers.
463               hit = HitTestWithinLayer( *layer,
464                                         renderTask,
465                                         exclusives,
466                                         results.rayOrigin,
467                                         results.rayDirection,
468                                         nearClippingPlane,
469                                         farClippingPlane,
470                                         hitCheck,
471                                         stencilOnLayer,
472                                         stencilHit,
473                                         false );
474             }
475
476             // If a stencil on this layer hasn't been hit, then discard hit results for this layer if our current hit actor is renderable
477             if ( stencilOnLayer && !stencilHit &&
478                  hit.actor && hit.actor->IsRenderable() )
479             {
480               hit = previousHit;
481             }
482
483             // If this layer is set to consume the hit, then do not check any layers behind it
484             if ( hitCheck.DoesLayerConsumeHit( layer ) )
485             {
486               layerConsumesHit = true;
487               break;
488             }
489           }
490         }
491         if ( hit.actor )
492         {
493           results.renderTask = Dali::RenderTask(&renderTask);
494           results.actor = Dali::Actor(hit.actor);
495           results.actorCoordinates.x = hit.x;
496           results.actorCoordinates.y = hit.y;
497           return true; // Success
498         }
499         else if ( layerConsumesHit )
500         {
501           return true; // Also success if layer is consuming the hit
502         }
503       }
504     }
505   }
506   return false;
507 }
508
509 /**
510  * Iterate through RenderTaskList and perform hit test.
511  *
512  * @return true if we have a hit, false otherwise
513  */
514 bool HitTestForEachRenderTask( LayerList& layers,
515                                RenderTaskList& taskList,
516                                const Vector2& screenCoordinates,
517                                Results& results,
518                                HitTestInterface& hitCheck )
519 {
520   RenderTaskList::RenderTaskContainer& tasks = taskList.GetTasks();
521   RenderTaskList::RenderTaskContainer::reverse_iterator endIter = tasks.rend();
522
523   const Vector< RenderTaskList::Exclusive >& exclusives = taskList.GetExclusivesList();
524
525   // Check onscreen tasks before offscreen ones, hit test order should be reverse of draw order (see ProcessRenderTasks() where offscreen tasks are drawn first).
526
527   // on screen
528   for ( RenderTaskList::RenderTaskContainer::reverse_iterator iter = tasks.rbegin(); endIter != iter; ++iter )
529   {
530     RenderTask& renderTask = GetImplementation( *iter );
531     Dali::FrameBufferImage frameBufferImage = renderTask.GetTargetFrameBuffer();
532
533     // Note that if frameBufferImage is NULL we are using the default (on screen) render target
534     if(frameBufferImage)
535     {
536       ResourceId id = GetImplementation(frameBufferImage).GetResourceId();
537
538       // on screen only
539       if(0 != id)
540       {
541         // Skip to next task
542         continue;
543       }
544     }
545
546     if ( HitTestRenderTask( exclusives, layers, renderTask, screenCoordinates, results, hitCheck ) )
547     {
548       // Return true when an actor is hit (or layer in our render-task consumes the hit)
549       return true; // don't bother checking off screen tasks
550     }
551   }
552
553   // off screen
554   for ( RenderTaskList::RenderTaskContainer::reverse_iterator iter = tasks.rbegin(); endIter != iter; ++iter )
555   {
556     RenderTask& renderTask = GetImplementation( *iter );
557     Dali::FrameBufferImage frameBufferImage = renderTask.GetTargetFrameBuffer();
558
559     // Note that if frameBufferImage is NULL we are using the default (on screen) render target
560     if(frameBufferImage)
561     {
562       ResourceId id = GetImplementation(frameBufferImage).GetResourceId();
563
564       // off screen only
565       if(0 == id)
566       {
567         // Skip to next task
568         continue;
569       }
570
571       if ( HitTestRenderTask( exclusives, layers, renderTask, screenCoordinates, results, hitCheck ) )
572       {
573         // Return true when an actor is hit (or a layer in our render-task consumes the hit)
574         return true;
575       }
576     }
577   }
578   return false;
579 }
580
581 } // unnamed namespace
582
583 bool HitTest( Stage& stage, const Vector2& screenCoordinates, Dali::HitTestAlgorithm::Results& results, Dali::HitTestAlgorithm::HitTestFunction func )
584 {
585   bool wasHit( false );
586   // Hit-test the regular on-stage actors
587   RenderTaskList& taskList = stage.GetRenderTaskList();
588   LayerList& layerList = stage.GetLayerList();
589
590   Results hitTestResults;
591   HitTestFunctionWrapper hitTestFunctionWrapper( func );
592   if (  HitTestForEachRenderTask( layerList, taskList, screenCoordinates, hitTestResults, hitTestFunctionWrapper ) )
593   {
594     results.actor = hitTestResults.actor;
595     results.actorCoordinates = hitTestResults.actorCoordinates;
596     wasHit = true;
597   }
598   return wasHit;
599 }
600
601 bool HitTest( Stage& stage, const Vector2& screenCoordinates, Results& results, HitTestInterface& hitTestInterface )
602 {
603   bool wasHit( false );
604
605   // Hit-test the system-overlay actors first
606   SystemOverlay* systemOverlay = stage.GetSystemOverlayInternal();
607
608   if ( systemOverlay )
609   {
610     RenderTaskList& overlayTaskList = systemOverlay->GetOverlayRenderTasks();
611     LayerList& overlayLayerList = systemOverlay->GetLayerList();
612
613     wasHit = HitTestForEachRenderTask( overlayLayerList, overlayTaskList, screenCoordinates, results, hitTestInterface );
614   }
615
616   // Hit-test the regular on-stage actors
617   if ( !wasHit )
618   {
619     RenderTaskList& taskList = stage.GetRenderTaskList();
620     LayerList& layerList = stage.GetLayerList();
621
622     wasHit = HitTestForEachRenderTask( layerList, taskList, screenCoordinates, results, hitTestInterface );
623   }
624   return wasHit;
625 }
626
627 bool HitTest( Stage& stage, const Vector2& screenCoordinates, Results& results )
628 {
629   ActorTouchableCheck actorTouchableCheck;
630   return HitTest( stage, screenCoordinates, results, actorTouchableCheck );
631 }
632
633 bool HitTest( Stage& stage, RenderTask& renderTask, const Vector2& screenCoordinates,
634               Dali::HitTestAlgorithm::Results& results, Dali::HitTestAlgorithm::HitTestFunction func )
635 {
636   bool wasHit( false );
637   Results hitTestResults;
638
639   const Vector< RenderTaskList::Exclusive >& exclusives = Stage::GetCurrent()->GetRenderTaskList().GetExclusivesList();
640   HitTestFunctionWrapper hitTestFunctionWrapper( func );
641   if ( HitTestRenderTask( exclusives, stage.GetLayerList(), renderTask, screenCoordinates, hitTestResults, hitTestFunctionWrapper ) )
642   {
643     results.actor = hitTestResults.actor;
644     results.actorCoordinates = hitTestResults.actorCoordinates;
645     wasHit = true;
646   }
647   return wasHit;
648 }
649
650 } // namespace HitTestAlgorithm
651
652 } // namespace Internal
653
654 } // namespace Dali