Added jsdocs

Author: photonstorm

src/gameobjects/blitter/Blitter.js

@@ -9,10 +9,17 @@ var GameObject = require('../GameObject');
 /**
  * A Blitter Game Object.
  *
- * The Blitter Game Object is a special type of Container, that contains Blitter.Bob objects.
- * These objects can be thought of as just texture frames with a position and nothing more.
- * Bobs don't have any update methods, or the ability to have children, or any kind of special effects.
- * They are essentially just super-fast texture frame renderers, and the Blitter object creates and manages them.
+ * The Blitter Game Object is a special kind of container that creates, updates and manages Bob objects.
+ * Bobs are designed for rendering speed rather than flexibility. They consist of a texture, or frame from a texture,
+ * a position and an alpha value. You cannot scale or rotate them. They use a batched drawing method for speed
+ * during rendering.
+ *
+ * A Blitter Game Object has one texture bound to it. Bobs created by the Blitter can use any Frame from this
+ * Texture to render with, but they cannot use any other Texture. It is this single texture-bind that allows
+ * them their speed.
+ *
+ * If you have a need to blast a large volume of frames around the screen then Blitter objects are well worth
+ * investigating. They are especially useful for using as a base for your own special effects systems.
  *
  * @class Blitter
  * @extends Phaser.GameObjects.GameObject

src/gameobjects/blitter/Bob.js

@@ -1,18 +1,30 @@
 var Class = require('../../utils/Class');
 
 /**
- * [description]
+ * A Bob Game Object.
+ *
+ * A Bob belongs to a Blitter Game Object. The Blitter is responsible for managing and rendering this object.
+ *
+ * A Bob has a position, alpha value and a frame from a texture that it uses to render with. You can also toggle
+ * the flipped and visible state of the Bob. The Frame the Bob uses to render can be changed dynamically, but it
+ * must be a Frame within the Texture used by the parent Blitter.
+ *
+ * Bob positions are relative to the Blitter parent. So if you move the Blitter parent, all Bob children will
+ * have their positions impacted by this change as well.
+ *
+ * You can manipulate Bob objects directly from your game code, but the creation and destruction of them should be
+ * handled via the Blitter parent.
  *
  * @class Bob
  * @memberOf Phaser.GameObjects.Blitter
  * @constructor
  * @since 3.0.0
  *
- * @param {Phaser.GameObjects.Blitter} blitter - [description]
- * @param {number} x - [description]
- * @param {number} y - [description]
- * @param {string|integer} frame - [description]
- * @param {boolean} visible - [description]
+ * @param {Phaser.GameObjects.Blitter} blitter - The parent Blitter object is responsible for updating this Bob.
+ * @param {number} x - The horizontal position of this Game Object in the world, relative to the parent Blitter position.
+ * @param {number} y - The vertical position of this Game Object in the world, relative to the parent Blitter position.
+ * @param {string|integer} frame - The Frame this Bob will render with, as defined in the Texture the parent Blitter is using.
+ * @param {boolean} visible - Should the Bob render visible or not to start with?
  */
 var Bob = new Class({
 

src/gameobjects/image/Image.js

@@ -4,7 +4,12 @@ var GameObject = require('../GameObject');
 var ImageRender = require('./ImageRender');
 
 /**
- * [description]
+ * An Image Game Object.
+ * 
+ * An Image is a light-weight Game Object useful for the display of static images in your game,
+ * such as logos, backgrounds, scenery or other non-animated elements. Images can have input
+ * events and physics bodies, or be tweened, tinted or scrolled. The main difference between an
+ * Image and a Sprite is that you cannot animate an Image as they do not have the Animation component.
  *
  * @class Image
  * @extends Phaser.GameObjects.GameObject
@@ -27,11 +32,11 @@ var ImageRender = require('./ImageRender');
  * @extends Phaser.GameObjects.Components.Transform
  * @extends Phaser.GameObjects.Components.Visible
  *
- * @param {Phaser.Scene} scene - [description]
- * @param {number} x - [description]
- * @param {number} y - [description]
- * @param {string} texture - [description]
- * @param {string|integer} frame - [description]
+ * @param {Phaser.Scene} scene - The Scene to which this Game Object belongs. A Game Object can only belong to one Scene at a time.
+ * @param {number} x - The horizontal position of this Game Object in the world.
+ * @param {number} y - The vertical position of this Game Object in the world.
+ * @param {string} texture - The key of the Texture this Game Object will use to render with, as stored in the Texture Manager.
+ * @param {string|integer} [frame] - An optional frame from the Texture this Game Object is rendering with.
  */
 var Image = new Class({
 

src/gameobjects/image/ImageFactory.js

@@ -9,10 +9,10 @@ var GameObjectFactory = require('../GameObjectFactory');
  * @method Phaser.GameObjects.GameObjectFactory#image
  * @since 3.0.0
  *
- * @param {number} x - The x position of the Game Object.
- * @param {number} y - The y position of the Game Object.
- * @param {string} key - The key of the Texture the Game Object will use.
- * @param {string|integer} [frame] - The Texture Frame the Game Object will use.
+ * @param {number} x - The horizontal position of this Game Object in the world.
+ * @param {number} y - The vertical position of this Game Object in the world.
+ * @param {string} texture - The key of the Texture this Game Object will use to render with, as stored in the Texture Manager.
+ * @param {string|integer} [frame] - An optional frame from the Texture this Game Object is rendering with.
  * 
  * @return {Phaser.GameObjects.Image} The Game Object that was created.
  */

src/gameobjects/sprite/Sprite.js

@@ -3,6 +3,45 @@ var Components = require('../components');
 var GameObject = require('../GameObject');
 var SpriteRender = require('./SpriteRender');
 
+/**
+ * A Sprite Game Object.
+ *
+ * A Sprite Game Object is used for the display of both static and animated images in your game.
+ * Sprites can have inpt events and physics bodies. They can also be tweened, tinted, scrolled
+ * and animated.
+ *
+ * The main difference between a Sprite and an Image Game Object is that you cannot animate Images.
+ * As such, Sprites take a fraction longer to process and have a larger API footprint due to the Animation
+ * Component. If you do not require animation then you can safely use Images to replace Sprites in all cases.
+ *
+ * @class Sprite
+ * @extends Phaser.GameObjects.GameObject
+ * @memberOf Phaser.GameObjects
+ * @constructor
+ * @since 3.0.0
+ *
+ * @extends Phaser.GameObjects.Components.Alpha
+ * @extends Phaser.GameObjects.Components.Animation
+ * @extends Phaser.GameObjects.Components.BlendMode
+ * @extends Phaser.GameObjects.Components.Depth
+ * @extends Phaser.GameObjects.Components.Flip
+ * @extends Phaser.GameObjects.Components.GetBounds
+ * @extends Phaser.GameObjects.Components.Origin
+ * @extends Phaser.GameObjects.Components.Pipeline
+ * @extends Phaser.GameObjects.Components.ScaleMode
+ * @extends Phaser.GameObjects.Components.ScrollFactor
+ * @extends Phaser.GameObjects.Components.Size
+ * @extends Phaser.GameObjects.Components.Texture
+ * @extends Phaser.GameObjects.Components.Tint
+ * @extends Phaser.GameObjects.Components.Transform
+ * @extends Phaser.GameObjects.Components.Visible
+ *
+ * @param {Phaser.Scene} scene - The Scene to which this Game Object belongs. A Game Object can only belong to one Scene at a time.
+ * @param {number} x - The horizontal position of this Game Object in the world.
+ * @param {number} y - The vertical position of this Game Object in the world.
+ * @param {string} texture - The key of the Texture this Game Object will use to render with, as stored in the Texture Manager.
+ * @param {string|integer} [frame] - An optional frame from the Texture this Game Object is rendering with.
+ */
 var Sprite = new Class({
 
     Extends: GameObject,
@@ -31,6 +70,13 @@ var Sprite = new Class({
     {
         GameObject.call(this, scene, 'Sprite');
 
+        /**
+         * [description]
+         *
+         * @name Phaser.GameObjects.Sprite#anims
+         * @type {[type]}
+         * @since 3.0.0
+         */
         this.anims = new Components.Animation(this);
 
         this.setTexture(texture, frame);
@@ -40,18 +86,47 @@ var Sprite = new Class({
         this.initPipeline('TextureTintPipeline');
     },
 
+    /**
+     * [description]
+     *
+     * @method Phaser.GameObjects.Sprite#preUpdate
+     * @since 3.0.0
+     *
+     * @param {number} time - [description]
+     * @param {number} delta - [description]
+     */
     preUpdate: function (time, delta)
     {
         this.anims.update(time, delta);
     },
 
+    /**
+     * [description]
+     *
+     * @method Phaser.GameObjects.Sprite#play
+     * @since 3.0.0
+     *
+     * @param {string} key - [description]
+     * @param {boolean} ignoreIfPlaying - [description]
+     * @param {integer|string} startFrame - [description]
+     *
+     * @return {[type]} [description]
+     */
     play: function (key, ignoreIfPlaying, startFrame)
     {
         this.anims.play(key, ignoreIfPlaying, startFrame);
 
         return this;
     },
 
+    /**
+     * [description]
+     *
+     * @method Phaser.GameObjects.Sprite#toJSON
+     * @since 3.0.0
+     *
+     * @return {object} [description]
+     */
     toJSON: function ()
     {
         var data = Components.ToJSON(this);

src/gameobjects/sprite/SpriteCanvasRenderer.js

@@ -1,5 +1,19 @@
 var GameObject = require('../GameObject');
 
+/**
+ * Renders this Game Object with the Canvas Renderer to the given Camera.
+ * The object will not render if any of its renderFlags are set or it is being actively filtered out by the Camera.
+ * This method should not be called directly. It is a utility function of the Render module.
+ *
+ * @method Phaser.GameObjects.Sprite#renderCanvas
+ * @since 3.0.0
+ * @private
+ *
+ * @param {Phaser.Renderer.CanvasRenderer} renderer - A reference to the current active Canvas renderer.
+ * @param {Phaser.GameObjects.Sprite} src - The Game Object being rendered in this call.
+ * @param {number} interpolationPercentage - Reserved for future use and custom pipelines.
+ * @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
+ */
 var SpriteCanvasRenderer = function (renderer, src, interpolationPercentage, camera)
 {
     if (GameObject.RENDER_MASK !== src.renderFlags || (src.cameraFilter > 0 && (src.cameraFilter & camera._id)))

src/gameobjects/sprite/SpriteCreator.js

@@ -4,8 +4,18 @@ var GameObjectCreator = require('../GameObjectCreator');
 var GetAdvancedValue = require('../../utils/object/GetAdvancedValue');
 var Sprite = require('./Sprite');
 
-//  When registering a factory function 'this' refers to the GameObjectCreator context.
-
+/**
+ * Creates a new Sprite Game Object and returns it.
+ *
+ * Note: This method will only be available if the Sprite Game Object has been built into Phaser.
+ *
+ * @method Phaser.GameObjects.GameObjectCreator#sprite
+ * @since 3.0.0
+ *
+ * @param {object} config - [description]
+ *
+ * @return {Phaser.GameObjects.Sprite} The Game Object that was created.
+ */
 GameObjectCreator.register('sprite', function (config)
 {
     var key = GetAdvancedValue(config, 'key', null);
@@ -23,3 +33,5 @@ GameObjectCreator.register('sprite', function (config)
 
     return sprite;
 });
+
+//  When registering a factory function 'this' refers to the GameObjectCreator context.

src/gameobjects/sprite/SpriteFactory.js

@@ -1,14 +1,21 @@
-var Sprite = require('./Sprite');
 var GameObjectFactory = require('../GameObjectFactory');
+var Sprite = require('./Sprite');
 
-//  When registering a factory function 'this' refers to the GameObjectFactory context.
-//  
-//  There are several properties available to use:
-//  
-//  this.scene - a reference to the Scene that owns the GameObjectFactory
-//  this.displayList - a reference to the Display List the Scene owns
-//  this.updateList - a reference to the Update List the Scene owns
-
+/**
+ * Creates a new Sprite Game Object and adds it to the Scene.
+ *
+ * Note: This method will only be available if the Sprite Game Object has been built into Phaser.
+ *
+ * @method Phaser.GameObjects.GameObjectFactory#sprite
+ * @since 3.0.0
+ *
+ * @param {number} x - The horizontal position of this Game Object in the world.
+ * @param {number} y - The vertical position of this Game Object in the world.
+ * @param {string} texture - The key of the Texture this Game Object will use to render with, as stored in the Texture Manager.
+ * @param {string|integer} [frame] - An optional frame from the Texture this Game Object is rendering with.
+ * 
+ * @return {Phaser.GameObjects.Sprite} The Game Object that was created.
+ */
 GameObjectFactory.register('sprite', function (x, y, key, frame)
 {
     var sprite = new Sprite(this.scene, x, y, key, frame);
@@ -18,3 +25,11 @@ GameObjectFactory.register('sprite', function (x, y, key, frame)
 
     return sprite;
 });
+
+//  When registering a factory function 'this' refers to the GameObjectFactory context.
+//  
+//  There are several properties available to use:
+//  
+//  this.scene - a reference to the Scene that owns the GameObjectFactory
+//  this.displayList - a reference to the Display List the Scene owns
+//  this.updateList - a reference to the Update List the Scene owns

src/gameobjects/sprite/SpriteWebGLRenderer.js

@@ -1,5 +1,19 @@
 var GameObject = require('../GameObject');
 
+/**
+ * Renders this Game Object with the WebGL Renderer to the given Camera.
+ * The object will not render if any of its renderFlags are set or it is being actively filtered out by the Camera.
+ * This method should not be called directly. It is a utility function of the Render module.
+ *
+ * @method Phaser.GameObjects.Sprite#renderWebGL
+ * @since 3.0.0
+ * @private
+ *
+ * @param {Phaser.Renderer.WebGLRenderer} renderer - A reference to the current active WebGL renderer.
+ * @param {Phaser.GameObjects.Sprite} src - The Game Object being rendered in this call.
+ * @param {number} interpolationPercentage - Reserved for future use and custom pipelines.
+ * @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
+ */
 var SpriteWebGLRenderer = function (renderer, src, interpolationPercentage, camera)
 {
     if (GameObject.RENDER_MASK !== src.renderFlags || (src.cameraFilter > 0 && (src.cameraFilter & camera._id)))