Working my way through putting all the Tests back in and fixing issues as I go.

Author: photonstorm

Phaser/core/Group.ts

@@ -174,7 +174,7 @@ module Phaser {
         * Calls render on all members of this Group who have a status of visible=true and exists=true
         * You can also call Object.render directly, which will bypass the visible/exists check.
         */
-        public render(renderer:IRenderer, camera: Camera) {
+        public render(camera: Camera) {
 
             if (camera.isHidden(this) == true)
             {
@@ -201,17 +201,13 @@ module Phaser {
 
                 if (this._member != null && this._member.exists && this._member.visible && camera.isHidden(this._member) == false)
                 {
-                    //this._member.render.call(renderer, camera, this._member);
-                    //  call = context first, then parameters
                     if (this._member.type == Types.GROUP)
                     {
-                        //console.log('group rend');
-                        this._member.render.call(this._member, renderer, camera, this._member);
-                        //this._member.render.call(this, renderer, camera, this._member);
+                        this._member.render(camera);
                     }
                     else
                     {
-                        this._member.render.call(renderer, camera, this._member);
+                        this.game.renderer.renderGameObject(this._member);
                     }
                 }
             }
@@ -225,6 +221,7 @@ module Phaser {
             {
                 this.game.stage.context.restore();
             }
+
         }
 
         /**

Phaser/gameobjects/IGameObject.ts

@@ -32,7 +32,7 @@ module Phaser {
         /**
          * Reference to the Renderer.renderSprite method. Can be overriden by custom classes.
          */
-        render;
+        //render;
 
         /**
          * Controls if both <code>update</code> and render are called by the core game loop.

Phaser/gameobjects/ScrollZone.ts

@@ -31,7 +31,6 @@ module Phaser {
             super(game, x, y, key);
 
             this.type = Phaser.Types.SCROLLZONE;
-            this.render = game.renderer.renderScrollZone;
 
             this.regions = [];
 

Phaser/gameobjects/Sprite.ts

@@ -27,7 +27,6 @@ module Phaser {
 
             this.game = game;
             this.type = Phaser.Types.SPRITE;
-            this.render = game.renderer.renderSprite;
 
             this.exists = true;
             this.active = true;
@@ -42,6 +41,9 @@ module Phaser {
             this.y = y;
             this.z = 0; // not used yet
 
+            //  If a texture has been given the body will be set to that size, otherwise 16x16
+            this.body = new Phaser.Physics.Body(this, bodyType);
+
             this.animations = new Phaser.Components.AnimationManager(this);
             this.texture = new Phaser.Components.Texture(this, key);
             this.cameraBlacklist = [];
@@ -50,10 +52,6 @@ module Phaser {
             this.origin = new Phaser.Vec2(0, 0);
             this.scale = new Phaser.Vec2(1, 1);
             this.skew = new Phaser.Vec2(0, 0);
-
-            //  If a texture has been given the body will be set to that size, otherwise 16x16
-            this.body = new Phaser.Physics.Body(this, bodyType);
-
         }
 
         /**
@@ -66,11 +64,6 @@ module Phaser {
          */
         public type: number;
 
-        /**
-         * Reference to the Renderer.renderSprite method. Can be overriden by custom classes.
-         */
-        public render;
-
         /**
          * Controls if both <code>update</code> and render are called by the core game loop.
          */

Phaser/physics/Body.ts

@@ -270,9 +270,10 @@ module Phaser.Physics {
             this.parent.texture.context.fillStyle = color;
             this.parent.texture.context.fillText('Sprite: (' + this.parent.frameBounds.width + ' x ' + this.parent.frameBounds.height + ')', x, y);
             //this.parent.texture.context.fillText('x: ' + this._parent.frameBounds.x.toFixed(1) + ' y: ' + this._parent.frameBounds.y.toFixed(1) + ' rotation: ' + this._parent.rotation.toFixed(1), x, y + 14);
-            this.parent.texture.context.fillText('x: ' + this.bounds.x.toFixed(1) + ' y: ' + this.bounds.y.toFixed(1) + ' angle: ' + this.angle.toFixed(1), x, y + 14);
+            this.parent.texture.context.fillText('x: ' + this.bounds.x.toFixed(1) + ' y: ' + this.bounds.y.toFixed(1) + ' angle: ' + this.angle.toFixed(0), x, y + 14);
             this.parent.texture.context.fillText('vx: ' + this.velocity.x.toFixed(1) + ' vy: ' + this.velocity.y.toFixed(1), x, y + 28);
-            this.parent.texture.context.fillText('ax: ' + this.acceleration.x.toFixed(1) + ' ay: ' + this.acceleration.y.toFixed(1), x, y + 42);
+            this.parent.texture.context.fillText('acx: ' + this.acceleration.x.toFixed(1) + ' acy: ' + this.acceleration.y.toFixed(1), x, y + 42);
+            this.parent.texture.context.fillText('angVx: ' + this.angularVelocity.toFixed(1) + ' angAc: ' + this.angularAcceleration.toFixed(1), x, y + 56);
 
         }
 

Phaser/renderers/CanvasRenderer.ts

@@ -36,24 +36,67 @@ module Phaser {
         private _camera: Camera;
         private _groupLength: number;
 
+        private _count: number;
+
+        public renderTotal: number;
+
         public render() {
 
             //  Get a list of all the active cameras
 
             this._cameraList = this._game.world.getAllCameras();
 
+            this._count = 0;
+
             //  Then iterate through world.group on them all (where not blacklisted, etc)
             for (var c = 0; c < this._cameraList.length; c++)
             {
                 this._camera = this._cameraList[c];
 
                 this._camera.preRender();
 
-                this._game.world.group.render(this, this._camera);
+                this._game.world.group.render(this._camera);
 
                 this._camera.postRender();
             }
 
+            this.renderTotal = this._count;
+
+        }
+
+        public renderGameObject(object) {
+
+            if (object.type == Types.SPRITE)
+            {
+                this.renderSprite(this._camera, object);
+            }
+            else if (object.type == Types.SCROLLZONE)
+            {
+                this.renderScrollZone(this._camera, object);
+            }
+
+        }
+
+        /**
+         * Check whether this object is visible in a specific camera rectangle.
+         * @param camera {Rectangle} The rectangle you want to check.
+         * @return {boolean} Return true if bounds of this sprite intersects the given rectangle, otherwise return false.
+         */
+        public inCamera(camera: Camera, sprite: Sprite): bool {
+
+            //  Object fixed in place regardless of the camera scrolling? Then it's always visible
+            if (sprite.scrollFactor.x == 0 && sprite.scrollFactor.y == 0)
+            {
+                return true;
+            }
+
+            this._dx = sprite.frameBounds.x - camera.worldView.x;
+            this._dy = sprite.frameBounds.y - camera.worldView.y;
+            this._dw = sprite.frameBounds.width * sprite.scale.x;
+            this._dh = sprite.frameBounds.height * sprite.scale.y;
+
+            return (camera.worldView.right > this._dx) && (camera.worldView.x < this._dx + this._dw) && (camera.worldView.bottom > this._dy) && (camera.worldView.y < this._dy + this._dh);
+
         }
 
         /**
@@ -63,12 +106,13 @@ module Phaser {
          */
         public renderSprite(camera: Camera, sprite: Sprite): bool {
 
-            //  Render checks (needs inCamera check added)
-            if (sprite.scale.x == 0 || sprite.scale.y == 0 || sprite.texture.alpha < 0.1)
+            if (sprite.scale.x == 0 || sprite.scale.y == 0 || sprite.texture.alpha < 0.1 || this.inCamera(camera, sprite) == false)
             {
                 return false;
             }
 
+            this._count++;
+
             //  Reset our temp vars
             this._ga = -1;
             this._sx = 0;
@@ -193,12 +237,13 @@ module Phaser {
 
         public renderScrollZone(camera: Camera, scrollZone: ScrollZone): bool {
 
-            //  Render checks (needs inCamera check added)
-            if (scrollZone.scale.x == 0 || scrollZone.scale.y == 0 || scrollZone.texture.alpha < 0.1)
+            if (scrollZone.scale.x == 0 || scrollZone.scale.y == 0 || scrollZone.texture.alpha < 0.1 || this.inCamera(camera, scrollZone) == false)
             {
                 return false;
             }
 
+            this._count++;
+
             //  Reset our temp vars
             this._ga = -1;
             this._sx = 0;

Phaser/renderers/HeadlessRenderer.ts

@@ -17,6 +17,9 @@ module Phaser {
 
         public render() {}
 
+        public renderGameObject(object) {
+        }
+
         public renderSprite(camera: Camera, sprite: Sprite): bool {
             return true;
         }

Phaser/renderers/IRenderer.ts

@@ -5,6 +5,7 @@ module Phaser {
     export interface IRenderer {
 
         render();
+        renderGameObject(object);
         renderSprite(camera: Camera, sprite: Sprite): bool;
         renderScrollZone(camera: Camera, sprite: ScrollZone): bool;
 

Phaser/utils/SpriteUtils.ts

@@ -3,6 +3,7 @@
 /// <reference path="../core/Rectangle.ts" />
 /// <reference path="../core/Circle.ts" />
 /// <reference path="../gameobjects/Sprite.ts" />
+/// <reference path="RectangleUtils.ts" />
 
 /**
 * Phaser - SpriteUtils
@@ -154,28 +155,27 @@ module Phaser {
         *
         * @return   Whether or not the point overlaps this object.
         */
-        /*
-        static overlapsPoint(point: Point, inScreenSpace: bool = false, camera: Camera = null): bool {
+        static overlapsPoint(sprite: Sprite, point: Point, inScreenSpace: bool = false, camera: Camera = null): bool {
 
             if (!inScreenSpace)
             {
-                return (point.x > this.x) && (point.x < this.x + this.width) && (point.y > this.y) && (point.y < this.y + this.height);
+                return Phaser.RectangleUtils.containsPoint(sprite.body.bounds, point);
+                //return (point.x > sprite.x) && (point.x < sprite.x + sprite.width) && (point.y > sprite.y) && (point.y < sprite.y + sprite.height);
             }
 
             if (camera == null)
             {
-                camera = this._game.camera;
+                camera = sprite.game.camera;
             }
 
-            var X: number = point.x - camera.scroll.x;
-            var Y: number = point.y - camera.scroll.y;
+            //var x: number = point.x - camera.scroll.x;
+            //var y: number = point.y - camera.scroll.y;
 
-            this.getScreenXY(this._point, camera);
+            //this.getScreenXY(this._point, camera);
 
-            return (X > this._point.x) && (X < this._point.x + this.width) && (Y > this._point.y) && (Y < this._point.y + this.height);
+            //return (x > this._point.x) && (X < this._point.x + this.width) && (Y > this._point.y) && (Y < this._point.y + this.height);
 
         }
-        */
 
         /**
         * Check and see if this object is currently on screen.
@@ -240,28 +240,6 @@ module Phaser {
         }
         */
 
-        /**
-         * Check whether this object is visible in a specific camera rectangle.
-         * @param camera {Rectangle} The rectangle you want to check.
-         * @return {boolean} Return true if bounds of this sprite intersects the given rectangle, otherwise return false.
-         */
-        static inCamera(camera: Rectangle, cameraOffsetX: number, cameraOffsetY: number): bool {
-
-            //  Object fixed in place regardless of the camera scrolling? Then it's always visible
-            if (this.scrollFactor.x == 0 && this.scrollFactor.y == 0)
-            {
-                return true;
-            }
-
-            this._dx = (this.frameBounds.x - camera.x);
-            this._dy = (this.frameBounds.y - camera.y);
-            this._dw = this.frameBounds.width * this.scale.x;
-            this._dh = this.frameBounds.height * this.scale.y;
-
-            return (camera.right > this._dx) && (camera.x < this._dx + this._dw) && (camera.bottom > this._dy) && (camera.y < this._dy + this._dh);
-
-        }
-
         /**
         * Handy for reviving game objects.
         * Resets their existence flags and position.
@@ -283,6 +261,19 @@ module Phaser {
 
         }
 
+        static setOriginToCenter(sprite: Sprite, fromFrameBounds: bool = true, fromBody?: bool = false) {
+
+            if (fromFrameBounds)
+            {
+                sprite.origin.setTo(sprite.frameBounds.halfWidth, sprite.frameBounds.halfHeight);
+            }
+            else if (fromBody)
+            {
+                sprite.origin.setTo(sprite.body.bounds.halfWidth, sprite.body.bounds.halfHeight);
+            }
+
+        }
+
         /**
         * Set the world bounds that this GameObject can exist within. By default a GameObject can exist anywhere
         * in the world. But by setting the bounds (which are given in world dimensions, not screen dimensions)

README.md

@@ -52,6 +52,8 @@ V1.0.0
 * Removed Sprite.rotation - use Sprite.angle instead
 * Optimised separateX/Y and overlap so they don't use any temporary vars any more.
 * Added the new Physics.Body object to all Sprites. Used for all physics calculations in-game. Will be extended for Fixtures/Joints in future.
+* Added SpriteUtils.setOriginToCenter to quickly set the origin of a sprite based on either frameBounds or body.bounds
+
 
 
 V0.9.6