如何跟踪显示对象的“深度”或堆叠顺序？

Question

如何使用AS3跟踪显示对象的“深度”或堆栈顺序？

我想弄清楚，如果我的精灵是背后另有精灵......

Answer 1

container.getChildIndex(displayObject);

的指数，但只有这样才能告诉你它有多深，不一定在它前面有任何东西。

Answer 2

container.getChildIndex(child)应该这样做，它返回子

Answer 3

private function getDepth(clip:DisplayObject):uint 
{ 
    var depth:uint = 0; 
    var currentClip:DisplayObject = clip; 
    while (currentClip.parent && currentClip.parent != this) 
    { 
     depth++; 
     currentClip = currentClip.parent; 
    } 
    return depth; 
} 

Answer 4

函数比较两个DisplayObject实例进行，以确定哪一个是在显示列表上的更高的“深度”：

private function higher(a:DisplayObject, b:DisplayObject):DisplayObject 
{   
    // Parent chains 
    var ac:Array = [a]; 
    var bc:Array = [b]; 

    // Pointers to individual nodes 
    var an:DisplayObject = a.parent; 
    var bn:DisplayObject = b.parent; 

    while (an != null) { 
     ac.push(an); 

     an = an.parent; 
    } 

    while (bn != null) { 
     bc.push(bn); 

     bn = bn.parent; 
    } 

    var acl:int = ac.length; 
    var bcl:int = bc.length; 

    var n:int = Math.min(acl, bcl); 
    var i:int = 0; 

    for (; i < n; i++) { 
     an = ac[acl - i - 1]; 
     bn = bc[bcl - i - 1]; 

     // First uncommon ancestor 
     if (an != bn) 
      break; 
    } 

    var ca:DisplayObjectContainer = an.parent; 
    if (!ca) 
     return null; 

    if (ca.getChildIndex(an) > ca.getChildIndex(bn)) 
     return a; 
    else 
     return b; 
} 

注意：如果目的之一是不显示列表上，则函数返回null。您可以将其更改为返回其他对象。

你几乎可以肯定地优化这个，但这是第一次切割。

Answer 5

只是一个使用向量的Manish答案的重构版本，如果您调用较高（a，a.parent），将不会返回奇怪的结果。

父母（）可以用于其他用途太：

public function higher(a:DisplayObject, b:DisplayObject):DisplayObject 
{ 
    var aParents:Vector.<DisplayObject> = parents(a); 
    var bParents:Vector.<DisplayObject> = parents(b); 
    var commonDepth:int = Math.min(aParents.length, bParents.length); 
    for (var depth:int = 0; depth < commonDepth; depth++) 
     if (aParents[depth] != bParents[depth]) 
      break; 
    if (depth == 0 || depth == commonDepth) 
     return null; 
    var commonAncestor:DisplayObjectContainer = aParents[depth].parent; 
    if (commonAncestor.getChildIndex(aParents[depth]) > commonAncestor.getChildIndex(bParents[depth])) 
     return a; 
    else 
     return b; 
} 

private function parents(d:DisplayObject):Vector.<DisplayObject> 
{ 
    var result:Vector.<DisplayObject> = new Vector.<DisplayObject>; 
    while (d != null) 
    { 
     result.unshift(d); 
     d = d.parent; 
    } 
    return result; 
} 

Answer 6

这是一个什么样的版本Manish才做完jauboux的修订版。
即，当深度匹配时，从highestOf()添加null返回值。

/** 
* @param ifDepthsMatchReturnObjectA 
* @return Whichever DisplayObject is higher on the display list. 
*   Optionally returns `null` if they're at the same depth. 
*/ 
public function highestOf(a:DisplayObject, b:DisplayObject, ifDepthsMatchReturnObjectA:Boolean = false):DisplayObject 
{ 
    var aParents:Vector.<DisplayObject> = ancestorsOf(a); 
    var bParents:Vector.<DisplayObject> = ancestorsOf(b); 
    var commonDepth:int = Math.min(aParents.length, bParents.length); 
    for (var depth:int = 0; depth < commonDepth; depth++) 
     if (aParents[depth] != bParents[depth]) 
      break; 
    if (depth == 0 || depth == commonDepth) 
     return null; 
    var commonAncestor:DisplayObjectContainer = aParents[depth].parent; 
    var aDepthOnCommonAncestor:int = commonAncestor.getChildIndex(aParents[depth]); 
    var bDepthOnCommonAncestor:int = commonAncestor.getChildIndex(bParents[depth]); 
    if (aDepthOnCommonAncestor > bDepthOnCommonAncestor) 
     return a; 
    else if (aDepthOnCommonAncestor < bDepthOnCommonAncestor) 
     return b; 
    else 
     return ifDepthsMatchReturnObjectA ? a : null; 
} 

/** 
* @return Whether a is higher than b. 
*/ 
public function isHigher(a:DisplayObject, b:DisplayObject):Boolean 
{ 
    return highestOf(a, b) === a; 
} 

/** 
* @return All ancestors of given display. 
*/ 
private function ancestorsOf(display:DisplayObject):Vector.<DisplayObject> 
{ 
    var result:Vector.<DisplayObject> = new Vector.<DisplayObject>; 
    while (display != null) 
    { 
     result.unshift(display); 
     display = display.parent; 
    } 
    return result; 
}