// INTERNAL INCLUDES
#include <dali/integration-api/system-overlay.h>
+#include <dali/public-api/actors/layer.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector4.h>
#include <dali/integration-api/debug.h>
#include <dali/internal/event/actors/image-actor-impl.h>
#include <dali/internal/event/actors/layer-impl.h>
#include <dali/internal/event/actors/layer-list.h>
-#include <dali/internal/event/actors/renderable-actor-impl.h>
#include <dali/internal/event/common/system-overlay-impl.h>
#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/event/common/projection.h>
HitTestInterface& hitCheck,
bool& stencilOnLayer,
bool& stencilHit,
- bool parentIsStencil )
+ bool parentIsStencil,
+ bool layerIs3d )
{
HitActor hit;
hit.x = hitPointLocal.x;
hit.y = hitPointLocal.y;
hit.distance = distance;
+ hit.depth = actor.GetHierarchyDepth() * Dali::Layer::TREE_DEPTH_MULTIPLIER;
// Is this actor an Image Actor or contains a renderer?
if ( ImageActor* imageActor = dynamic_cast< ImageActor* >( &actor ) )
{
- hit.depth = imageActor->GetDepthIndex();
+ hit.depth += imageActor->GetDepthIndex();
}
- else
+ else if ( actor.GetRendererCount() )
{
- if ( actor.GetRendererCount() )
- {
- hit.depth = actor.GetRendererAt( 0 ).GetDepthIndex();
- }
- else
- {
- hit.depth = 0;
- }
+ hit.depth += actor.GetRendererAt( 0 ).GetDepthIndex();
}
}
}
for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
{
// Descend tree only if...
- 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
- ( isStencil || hitCheck.DescendActorHierarchy( &GetImplementation( *iter ) ) ) ) // We are a stencil OR we can descend into child hierarchy
+ 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
+ ( isStencil || hitCheck.DescendActorHierarchy( ( *iter ).Get() ) ) ) // We are a stencil OR we can descend into child hierarchy
{
- HitActor currentHit( HitTestWithinLayer( GetImplementation(*iter),
+ HitActor currentHit( HitTestWithinLayer( (*iter->Get()),
renderTask,
exclusives,
rayOrigin,
hitCheck,
stencilOnLayer,
stencilHit,
- isStencil ) );
+ isStencil,
+ layerIs3d) );
bool updateChildHit = false;
- // If our ray casting hit, then check then if the hit actor's depth is greater that the favorite, it will be preferred
if ( currentHit.distance >= 0.0f )
{
- if ( currentHit.depth > childHit.depth )
+ if( layerIs3d )
{
- updateChildHit = true;
+ updateChildHit = ( ( currentHit.depth > childHit.depth ) ||
+ ( ( currentHit.depth == childHit.depth ) && ( currentHit.distance < childHit.distance ) ) );
}
-
- // If the hit actor's depth is equal to current favorite, then we check the distance and prefer the closer
- else if ( currentHit.depth == childHit.depth )
+ else
{
- if ( currentHit.distance < childHit.distance )
- {
- updateChildHit = true;
- }
+ updateChildHit = currentHit.depth >= childHit.depth;
}
}
if ( updateChildHit )
{
if( !parentIsRenderable || currentHit.depth > hit.depth ||
- ( currentHit.depth == hit.depth && currentHit.distance < hit.distance ) )
+ ( layerIs3d && ( currentHit.depth == hit.depth && currentHit.distance < hit.distance )) )
{
childHit = currentHit;
}
* Hit test a RenderTask
*/
bool HitTestRenderTask( const Vector< RenderTaskList::Exclusive >& exclusives,
+ Stage& stage,
LayerList& layers,
RenderTask& renderTask,
Vector2 screenCoordinates,
bool stencilOnLayer = false;
bool stencilHit = false;
bool layerConsumesHit = false;
- const Vector2& stageSize = Stage::GetCurrent()->GetSize();
+
+ const Vector2& stageSize = stage.GetSize();
for (int i=layers.GetLayerCount()-1; i>=0 && !(hit.actor); --i)
{
hitCheck,
stencilOnLayer,
stencilHit,
- false );
+ false,
+ layer->GetBehavior() == Dali::Layer::LAYER_3D);
}
else if ( IsWithinSourceActors( *sourceActor, *layer ) )
{
hitCheck,
stencilOnLayer,
stencilHit,
- false );
+ false,
+ layer->GetBehavior() == Dali::Layer::LAYER_3D);
}
// If a stencil on this layer hasn't been hit, then discard hit results for this layer if our current hit actor is renderable
*
* @return true if we have a hit, false otherwise
*/
-bool HitTestForEachRenderTask( LayerList& layers,
+bool HitTestForEachRenderTask( Stage& stage,
+ LayerList& layers,
RenderTaskList& taskList,
const Vector2& screenCoordinates,
Results& results,
}
}
- if ( HitTestRenderTask( exclusives, layers, renderTask, screenCoordinates, results, hitCheck ) )
+ if ( HitTestRenderTask( exclusives, stage, layers, renderTask, screenCoordinates, results, hitCheck ) )
{
// Return true when an actor is hit (or layer in our render-task consumes the hit)
return true; // don't bother checking off screen tasks
continue;
}
- if ( HitTestRenderTask( exclusives, layers, renderTask, screenCoordinates, results, hitCheck ) )
+ if ( HitTestRenderTask( exclusives, stage, layers, renderTask, screenCoordinates, results, hitCheck ) )
{
// Return true when an actor is hit (or a layer in our render-task consumes the hit)
return true;
Results hitTestResults;
HitTestFunctionWrapper hitTestFunctionWrapper( func );
- if ( HitTestForEachRenderTask( layerList, taskList, screenCoordinates, hitTestResults, hitTestFunctionWrapper ) )
+ if ( HitTestForEachRenderTask( stage, layerList, taskList, screenCoordinates, hitTestResults, hitTestFunctionWrapper ) )
{
results.actor = hitTestResults.actor;
results.actorCoordinates = hitTestResults.actorCoordinates;
RenderTaskList& overlayTaskList = systemOverlay->GetOverlayRenderTasks();
LayerList& overlayLayerList = systemOverlay->GetLayerList();
- wasHit = HitTestForEachRenderTask( overlayLayerList, overlayTaskList, screenCoordinates, results, hitTestInterface );
+ wasHit = HitTestForEachRenderTask( stage, overlayLayerList, overlayTaskList, screenCoordinates, results, hitTestInterface );
}
// Hit-test the regular on-stage actors
RenderTaskList& taskList = stage.GetRenderTaskList();
LayerList& layerList = stage.GetLayerList();
- wasHit = HitTestForEachRenderTask( layerList, taskList, screenCoordinates, results, hitTestInterface );
+ wasHit = HitTestForEachRenderTask( stage, layerList, taskList, screenCoordinates, results, hitTestInterface );
}
return wasHit;
}
bool wasHit( false );
Results hitTestResults;
- const Vector< RenderTaskList::Exclusive >& exclusives = Stage::GetCurrent()->GetRenderTaskList().GetExclusivesList();
+ const Vector< RenderTaskList::Exclusive >& exclusives = stage.GetRenderTaskList().GetExclusivesList();
HitTestFunctionWrapper hitTestFunctionWrapper( func );
- if ( HitTestRenderTask( exclusives, stage.GetLayerList(), renderTask, screenCoordinates, hitTestResults, hitTestFunctionWrapper ) )
+ if ( HitTestRenderTask( exclusives, stage, stage.GetLayerList(), renderTask, screenCoordinates, hitTestResults, hitTestFunctionWrapper ) )
{
results.actor = hitTestResults.actor;
results.actorCoordinates = hitTestResults.actorCoordinates;
projects / platform / core / uifw / dali-core.git / blobdiff