A tiny object being masked by a huge shape will cause getBounds() to return the extents of… the mask, not the visible object.  It gets even better if your object happens to move beyond the masked area–thus making it totally invisible.  Now getBounds() exapands to include the area of the giant mask plus that of the tiny object, which is no longer being drawn to the screen at all.

In fact, there appears to be no built-in method for reliably determining the actual screen area a MovieClip is occupying.  Do we call this a bug, or was it really meant to work this way???

I decided to try writing a handy dandy function to remedy this problem, and in so doing discovered another serious limitation involving masks.  When you create an arrangement of layers in the Flash IDE with, let’s say three or four objects being masked by one mask, you’ve done something that apparently is only possible with the Flash IDE, and not with AS3.  If you have a look at the .mask property of each of those masked objects, they’ll all be set to NULL.  There’s no sign of any masking going on, as far as ActionScript is concerned.  Suppose you manually set the .mask property of one of those three or four masked objects?  The result is that all the other objects will be unmasked.  Using the .mask property strictly pairs one mask to one display object.  So now you’ve got to find a way of duplicating your mask, so each object has its own mask…! 

Well, nonetheless I wrote my own routine: getVisibility() which reliably tracks down whatever is actually visible, and nothing more.  It’s reliable, that is, as long as you manually set your masks in code–one mask for each object.  If a better solution exists, I’d like to know about it.  For now, here’s a little demo of my function versus AS3’s native functions…

(Please open the article to see the flash file or player.)

There’s only one error I can detect in the result of getVisibility() …When objects are rotated, their visibility is based upon a rotated bounding box, rather than the precise shape of the object.  Still, this gets us considerably closer to a solution.

The .fla can be downloaded HERE.  Here’s the code for my getVisibility() function…

function getVisibility(obj:DisplayObject):Rectangle {
 
	var vis:Rectangle;
 
	if (obj.parent == null) return new Rectangle();
 
	if (obj is DisplayObjectContainer) {
		vis = getChildVisibility(obj, obj.parent);
	} else {
		vis = obj.getBounds(obj.parent);
	}
 
	// Is the DisplayObject masked?
	if (obj.mask != null) {
		vis = vis.intersection(obj.mask.getBounds(obj.parent));
	}
 
	// Is the DisplayObject partly or completely off-stage?
	vis = vis.intersection(obj.stage.getBounds(obj.parent));
 
	return vis;
}
 
function getChildVisibility(obj:*, target:DisplayObjectContainer):Rectangle {
 
	var vis:Rectangle = new Rectangle();
	var child:DisplayObject;
	var childRect:Rectangle;
	var i:uint;
 
	for (i = 1; i <= obj.numChildren; i++) {
		child = obj.getChildAt(i-1);
 
		if (child != null) {
			if (child.visible) {
				if (child is DisplayObjectContainer) {
					childRect = getChildVisibility(child, target);
				} else {
					childRect = child.getBounds(target);
				}
				if (child.mask != null) {
					childRect = childRect.intersection(child.mask.getBounds(target));
				}
				vis = vis.union(childRect);
			}
		}
	}
	return vis;
}