documentation accuracy update

Author: David Gillen

src/easeljs/display/StageGL.js

@@ -152,11 +152,11 @@ this.createjs = this.createjs||{};
 		this.vocalDebug = false;
 
 		/**
-		 * Specifies whether this instance is slaved to a {{#crossLink "BitmapCache"}}{{/crossLink}} or is its own master.
-		 * Controls whether final rendering output of a {{#crossLink "cacheDraw"}}{{/crossLink}} command is to the canvas
-		 * or a render texture. See the {{#crossLink "cache"}}{{/crossLink}} function documentation and read the code for
-		 * full implications and details of necessity. Enabled by default when BitmapCache's `useGL` is true.
-		 * NOTE: This method is mainly for internal use, though it may be useful for advanced uses.
+		 * Specifies whether this instance is slaved to a {{#crossLink "BitmapCache"}}{{/crossLink}} or draws independantly.
+		 * Necessary to control texture outputs and behaviours when caching. StageGL cache outputs will only render
+		 * properly for the StageGL that made them. See the {{#crossLink "cache"}}{{/crossLink}} function documentation
+		 * for more information. Enabled by default when BitmapCache's `useGL` is true.
+		 * NOTE: This property is mainly for internal use, though it may be useful for advanced uses.
 		 * @property isCacheControlled
 		 * @type {Boolean}
 		 * @default false

src/easeljs/filters/AberrationFilter.js

@@ -36,19 +36,21 @@
 
 // constructor:
 	/**
-	 * Seperates and pushes the different colour channels apart.
+	 * Separates and pushes each of the colour channels apart. I.E. shift the red channel slightly left.
+	 * Allows specifying the direction and the ammount it affects each channel. Great for computer glitches and VCR like
+	 * effects.
 	 *
 	 * See {{#crossLink "Filter"}}{{/crossLink}} for an more information on applying filters.
 	 * @class AberrationFilter
 	 * @extends Filter
 	 * @constructor
-	 * @param {Number} [xDir=0] Movement in x, specified in pixels.
-	 * @param {Number} [yDir=0] Movement in y, specified in pixels.
-	 * @param {Number} [redMultiplier=0] Multiplier for movement of the Red channel. Negative values allowed.
-	 * @param {Number} [greenMultiplier=0] Multiplier for movement of the Green channel. Negative values allowed.
-	 * @param {Number} [blueMultiplier=0] Multiplier for movement of the Blue channel. Negative values allowed.
+	 * @param {Number} [xDir=0] Movement in x at a multiplier of 1, specified in pixels.
+	 * @param {Number} [yDir=0] Movement in y at a multiplier of 1, specified in pixels.
+	 * @param {Number} [redMultiplier=0] Multiplier for the movement of the Red channel. Negative values allowed.
+	 * @param {Number} [greenMultiplier=0] Multiplier for the movement of the Green channel. Negative values allowed.
+	 * @param {Number} [blueMultiplier=0] Multiplier for the movement of the Blue channel. Negative values allowed.
 	 * @param {Number} [originalMix=0] Amount of original image to keep, 0-1.
-	 * @param {Boolean} [alphaMax=false] Calculate combined alpha using maximum value available.
+	 * @param {Boolean} [alphaMax=false] Calculate combined alpha using maximum alpha available. Creates a stronger image.
 	 **/
 	function AberrationFilter(xDir, yDir, redMultiplier, greenMultiplier, blueMultiplier, originalMix, alphaMax) {
 		this.Filter_constructor();

src/easeljs/filters/BitmapCache.js

@@ -53,8 +53,11 @@ this.createjs = this.createjs||{};
 	 * Caching is also a co-requisite for applying filters to prevent expensive filters running constantly without need,
 	 * and to physically enable some effects. The BitmapCache is also responsible for applying filters to objects and
 	 * reads each {{#crossLink "Filter"}}{{/crossLink}} due to this relationship. Real-time Filters are not recommended
-	 * performance wise when dealing with a Context2D canvas. For best performance and to still allow for some visual
-	 * effects use a compositeOperation when possible.
+	 * performance wise when dealing with a Context2D canvas. On a StageGL performance is better so the presence of a
+	 * filter will automatically create a cache if one is not made manually.
+	 *
+	 * Some visual effects can be achieved with a {{#crossLink "DisplayObject/compositeOperation:property"}}{{/crossLink}}
+	 * so check out that setting before settling on a filter.
 	 * @class BitmapCache
 	 * @constructor
 	 **/
@@ -352,8 +355,8 @@ this.createjs = this.createjs||{};
 	 * specifics of how to use the options object.
 	 *
 	 * - If options.useGL is set to "new" a StageGL is created and contained on this for use when rendering the cache.
-	 * - If options.useGL is set to "stage" if the current stage is a StageGL it will be used. If not then it will default to "new".
-	 * - If options.useGL is a StageGL instance it will not create one but use the one provided.
+	 * - If options.useGL is set to "stage" if the current stage is a StageGL it will be used. Must be added to a stage first to work.
+	 * - If options.useGL is a StageGL instance then it will use it to cache. Warning, caches made on one StageGL will not render on any other StageGL.
 	 * - If options.useGL is undefined a Context 2D cache will be performed.
 	 *
 	 * This means you can use any combination of StageGL and 2D with either, neither, or both the stage and cache being
@@ -382,16 +385,21 @@ this.createjs = this.createjs||{};
 	 *
 	 *     var stageGL = new createjs.StageGL();
 	 *     var bmp = new createjs.Bitmap(src);
-	 *     bmp.cache(0, 0, bmp.width, bmp.height, 1, {gl: "stage"});       // use our StageGL to cache
+	 *
+	 *     // option 1
+	 *     stageGL.addChild(bmp);
+	 *     bmp.cache(0, 0, bmp.width, bmp.height, 1, {gl: "stage"});       // when added to the display list we can look it up
+	 *     // option 2
+	 *     bmp.cache(0, 0, bmp.width, bmp.height, 1, {gl: stageGL});       // we can specify it explicitly if we add it later
+	 *     stageGL.addChild(bmp);
 	 *
 	 *     var shape = new createjs.Shape();
 	 *     shape.graphics.clear().fill("red").drawRect(0,0,20,20);
 	 *     shape.cache(0, 0, 20, 20, 1);                             // cannot use WebGL cache
 	 *
 	 * You may wish to create your own StageGL instance to control factors like clear color, transparency, AA, and
-	 * others. If you do, pass a new instance in instead of "true", the library will automatically set the
-	 * {{#crossLink "StageGL/isCacheControlled"}}{{/crossLink}} to true on your instance. This will trigger it to behave
-	 * correctly, and not assume your main context is WebGL.
+	 * others. If the specified stage is not rendering content and just the cache set{{#crossLink "StageGL/isCacheControlled"}}{{/crossLink}}
+	 * to true on your instance. This will trigger it to behave correctly for rendering your output.
 	 *
 	 * @public
 	 * @method BitmapCache.cache

src/easeljs/filters/Filter.js

@@ -39,9 +39,11 @@ this.createjs = this.createjs||{};
 
 // constructor:
 	/**
-	 * Base class that all filters should inherit from. Filters need to be applied to objects that have been cached using
-	 * the {{#crossLink "DisplayObject/cache"}}{{/crossLink}} method. If an object changes, please cache it again, or use
-	 * {{#crossLink "DisplayObject/updateCache"}}{{/crossLink}}. Note that the filters must be applied before caching.
+	 * Base class that all filters should inherit from. Appli
+	 *
+	 * When on a regular Stage apply the Filters and then cache the object using the {{#crossLink "DisplayObject/cache"}}{{/crossLink}} method.
+	 * When a cached object changes, please use {{#crossLink "DisplayObject/updateCache"}}{{/crossLink}}.
+	 * When on a StageGL simply setting content in the `.filters` array will trigger an automatic and constantly updated cache.
 	 *
 	 * <h4>Example</h4>
 	 *
@@ -58,6 +60,7 @@ this.createjs = this.createjs||{};
 	 * Any filter that consumes an external image stretches the image to cover the cached bounds. If this is an undesired
 	 * visual result, then use an intermediary cache to properly size and layout your data before passing it to a filter.
 	 *
+	 *
 	 * <h4>EaselJS Filters</h4>
 	 * EaselJS comes with a number of pre-built filters:
 	 * <ul>