 [ResourceBundle("sparkEffects")]
 
 /**
- * This effect animates a transition between two bitmaps,
+ * The AnimateShaderTransition effect animates a transition between two bitmaps,
  * one representing the start state (<code>bitmapFrom</code>), and
  * the other representing the end state (<code>bitmapTo</code>).
  * 
- * <p>The animation is performed by running a Pixel Bender shader,
- * supplied by the <code>shader</code> property,
- * using the two bitmaps as input. If either bitmap is
+ * <p>The animation is performed by running a pixel-shader program,
+ * specified by the <code>shader</code> property,
+ * using the two bitmaps as input. 
+ * The bitmaps are represented by an instance of the flash.display.BitmapData class.
+ * You can create your own pixel-shader program 
+ * by using Adobe Pixel Bender Toolkit.</p>
+ *
+ * <p>If either bitmap is
  * not supplied, that value will be determined dynamically from
  * either the appropriate state of the target in a transition or, 
  * if the effect is not running in a transition, from the 

    public var bitmapTo:BitmapData;

    /**
     * The bytecode that a <code>Shader</code> object will use
     * for running the transition between the two bitmaps. This
     * property can be represented as either a ByteArray or as a
     * Class representing a ByteArray (which is what results 
     * when you embed a resource).
     * 
     * <p>The shader can have arbitrary functionality and inputs, but 
     * must, at a minimum, have three <code>image4</code> inputs.
     * The first input, which can be named anything, should go
     * unused by your shader code - it exists only to satisfy the
     * Flash requirement of assigning a filtered object to the
     * first input. Note that inputs that go completely unused in a
     * shader kernel may be optimized out, so your kernel code should
     * at least reference this input to keep it around.</p>
     * 
     * <p>There must be at least two other inputs
     * named <code>from</code> and <code>to</code> and one 
     * <code>float</code> parameter named <code>progress</code>, where
     * <code>from/to</code> are the before/after bitmaps, respectively,
     * and <code>progress</code> is the elapsed fraction of
     * the effect.</p>
     * 
     * <p>Also, there are two optional parameters, <code>width</code>
     * and <code>height</code>, which if they exist in the shader
     * will be automatically set to the width and height for the
     * effect instance target.</p>
     * 
     * <p>See the Pixel Bender Toolkit documentation for more
     * information on writing shaders for Flash.</p>
     * 
     * @example To play an effect that uses a fictional Pixel Bender pbj 
     * file MyShader.pbj, which takes a single <code>direction</code>
     * parameter, the calling code could do this:
     * @example <listing version="3.0">
     *   [Embed(source="MyShader.pbj", mimeType="application/octet-stream")]
     *   private var ShaderCodeClass:Class;
     *   var shaderEffect = new AnimateShaderTransition();
     *   shaderEffect.shaderCode = ShaderCodeClass;
     *   shaderEffect.shaderProperties = {direction : 1};</listing>
     * or in MXML code, this:<listing version="3.0">
     *   &lt;AnimateShaderTransition 
     *       shaderCode="&64;Embed(source='MyShader.pbj', mimeType='application/octet-stream')"
     *       shaderProperties="{{direction : 1}}}"/&gt;
     * </listing>
     * 
     * @see flash.display.Shader
     *  
     *  @langversion 3.0
     *  @playerversion Flash 10
     *  @playerversion AIR 1.5

    
    /**
     * The bitmap data representing the start state of this effect.
     * If this property is not set, it is calculated automatically
     * when the effect is played by taking a snapshot of the target
     * object, or by using a transparent bitmap if the object does not
     * exist in the start view state of a transition.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 10
