~extremepopcorn/dhlib/dhlib_ep

/* <license>

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

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

 * </license> 

 */

package ui.anim.lib;

 

/**

 * A very simple Actor for demonstration purposes.

 *

 * Note: Actors reside in ".ahx" files and must be processed by the preprocessor --

 * the standard makefile does this.  Otherwise the command is:

 *              $DHLIB_ROOT/m4/m4haxe.sh --out Simple.hx --prepend $DHLIB_ROOT/lib/ui/anim/ActorDef.ihx Simple.ahx

 *

 * The actor is just a very specialized haXe class which uses many macros to assist

 * in its creation.  Inside the `DEFACTOR/ENDACTOR' pair is a normal haXe class and thus

 * any haxe code can be used.

 */

DEFACTOR(Simple)

 

        /* Parameters are available at construction time and used to control the look and behaviour

         * of the Actor.  These are not (currently) alterable after instantion -- at least from the caller,

         * the actor itself can do whatever with them.

         */

                

        // `PARAM' indicates a parameter, the first item is the name, the second one the type, and the

        // third one the default value, an optional fourth parameter specifies help documentation

        PARAM( speed, Float, 2.0, How fast we'll rotate )

        

        // The `ONINIT' handler is optional and it will be called whenever the Actor is first initalized --

        // part of the contructor

        ONINIT()

        {

        }

        

        

        // `VAR's are used to track member variables.  The use of a `VAR' as opposed to a normal

        // haXe definition allows proper default initialization/control

        VAR( angle, Float, 0 )

        

        // `SEQUENCE's define the behaviours available to an actor.  In this case we'll define

        // a "Still" sequence.  The `DEFAULT' keyword indicates this will be the sequence used by

        // the actor upon instantiation

        SEQUENCE(Still,DEFAULT)

        {

                //we could setup variables here.

        }

        ONSTEP()

        {

                //nothing is needed while stepping since we are "Still"

        }

        

        SEQUENCE(Rotate,NONE)

        {

        }

        ONSTEP()

        {

                //we'll simply increase our rotation based on our speed

                //notice that `VAR's are access directly, and `PARAM's are available in the "params" member

                // "elapsed" indicates how much time has passed, a Float expressed in seconds

                angle += params.speed * elapsed;

                

                //since we need redraw in order for our change to be visualized we call taintDraw. This

                //may seem obvious, but actors which combine other sprites, or use native Flash effects

                //may not need to redraw themselves to have the change visualized

                taintDraw();    

        }

        

        // the following construct indicates that our drawing surface will be scaled to the extents

        // (0.5,0.5) which is useful since then we'll be 1 wide/tall and can easily center ourselves on

        // (0,0) -- this is optional, if not specified an identity transform is used, in which case the

        // actor size is available as the parameter "actorSize"

        DRAWTRANSFORM_SCALE(0.5,0.5)

        

        // this will be called anytime the actor needs to be redrawn, either decided by the framework

        // or when tainted with "taintDraw"

        ONDRAW()

        {

                //the "gfx" variable contains the GraphicsX of our drawing surface.

                gfx.clear();

                

                //we'll draw a cyan line from the center to the angle we're at

                gfx.use( Pen.solid( 5, Color.rgb( 0, 1, 1 ) ) );

                gfx.moveTo( 0, 0 );

                gfx.lineTo( Math.cos( angle ), Math.sin( angle ) );

        }

        

ENDACTOR()