~extremepopcorn/dhlib/dhlib_ep

/* <license>

 * This file is part of the dis-Emi-A HaXe Library. Copyright (c) edA-qa mort-ora-y

 * For full copyright and license information please refer to doc/license.txt.

 * </license> 

 */

package flashx;

 

import flash.display.DisplayObject;

import flash.display.Stage;

import flash.display.BitmapData;

import flash.display.BitmapDataChannel;

import flash.geom.Point;

import flash.geom.Rectangle;

 

/**

 * Performs collisions on specific MovieClips and sprites.  This needs to be

 * attached to a particular stage in order to work with sprites on that stage.

 *

 * This only supports a Bool hit condition, if a version is needed to judge

 * the degree of overlap then a color transform / blend mode version could

 * be done and use getColorBoundsRect to determine the size of the 

 * overlapping area.

 */

class ObjectCollider

{

        var stage : Stage;

        var alpha : Float;

        var filters : Bool;

        

        var objx1 : RenderCache;

        var objx2 : RenderCache;

        

        /**

         * Creates a new collider for the given stage

         *

         * @param       astage  [in,keep] in whcih stage the comparisions are done

         * @param       aalpha  [in] what alpha level match is considered a collision

         * @param       afilters        [in] use filters in comparision (otherwise they are stripped for comparison)

         */

        public function new( astage : Stage, ?aalpha : Null<Float>, ?afilters : Null<Bool> )

        {

                alpha = if( aalpha == null ) 0.5 else aalpha;

                filters = if( afilters == null ) true else afilters;

                stage = astage;

                

                objx1 = new RenderCache( );

                objx2 = new RenderCache( );

        }

        

        public function createCollisionBitmaps( s1 : DisplayObject, s2 : DisplayObject, forContain : Bool ) : { a : BitmapData, b : BitmapData }

        {

                //get the real bounds of each item

                var r1 = s1.getBounds( stage );

                var r2 = s2.getBounds( stage );

                var intr = r1.intersection( r2 );

                

                objx1.useFilters = filters;

                var bd1 = objx1.renderBitmap( s1, intr, forContain, false );

                objx2.useFilters = filters;

                var bd2 = objx2.renderBitmap( s2, intr, false, false );

                

                return { a : bd1, b: bd2 };

        }

        

        static var originPoint = new Point();

        public function checkCollision( bd1 : BitmapData, bd2 : BitmapData, alpha : Float ) : Bool

        {

                //accounts for about 15% of time in comparison, smaller cached sizes would likely help

                var a = Math.round( alpha * 0xff );

                return bd1.hitTest( originPoint, a, bd2, originPoint, a );

        }

        

        /**

         * Do the two display objects overlap (using pixel tests per-pixel

         */

        public function doCollide( s1 : DisplayObject, s2 : DisplayObject ) : Bool

        {

                //short-track checking if bounding boxes don't collide

                if( !s1.hitTestObject( s2 ) )

                        return false;

                        

                var bits = createCollisionBitmaps( s1, s2, false );

                var ret = checkCollision( bits.a, bits.b, alpha );

                //might as well use this function... (don't, since we cache them now)

                //bits.a.dispose();

                //bits.b.dispose();

                return ret;

        }

        

        /**

         * @param       bd1     [in] a bitmap prepared for contains checking as with "forContain" in createCollisionBitmaps

         * @param       bd2     [in] the bitmap to check if in first bitmap

         */

        public function checkContain( bd1 : BitmapData, bd2 : BitmapData, alpha : Float ) :  Bool

        {

                //The Flash Documentation/fucntions are just plain wrong.  Almost all of the BitmapData

                //functions only apply to those pixels which are not transparent.  The other pixels are completely

                //ignored, even if you actually want to work with them -- this makes working with the alpha

                //channel very very difficult and confusing...

                

                //we copy an arbitrary channel to the ALPHA channel (since the source should be grayscale)

                //this means the transparency of this image is now the inverse of the original image

                bd1.copyChannel( bd1, bd1.rect, new Point(0,0), BitmapDataChannel.BLUE, BitmapDataChannel.ALPHA );

                var a = Math.round( alpha * 0xff );

                var hit = !bd1.hitTest( originPoint, a, bd2, originPoint, a );

 

                return  hit;

        }

        

        /**

         * Does the entire bounds of s2 reside with s1?

         */

        public function aBoxContainsB( s1 : DisplayObject, s2 : DisplayObject ) : Bool

        {

                var r1 = s1.getBounds( stage );

                var r2 = s2.getBounds( stage );

                return r1.containsRect( r2 );

        }

        

        /**

         * Does the first object completely contain the second object

         */

        public function aContainsB( s1 : DisplayObject, s2 : DisplayObject ) : Bool

        {

                if( !aBoxContainsB( s1, s2 ) )

                        return false;

                        

                var bits = createCollisionBitmaps( s1, s2, true );

                return checkContain( bits.a, bits.b, alpha );

        }

}