WebGL using mixins.

photonstorm · photonstorm · commit fe92b4e38872 · 2016-10-05T01:25:06.000+01:00
diff --git a/build/config.php b/build/config.php
@@ -214,8 +214,6 @@
     <script src="$path/src/renderer/webgl/gameobjects/Container.js"></script>
     <script src="$path/src/renderer/webgl/gameobjects/Sprite.js"></script>
     <script src="$path/src/renderer/webgl/gameobjects/Stage.js"></script>
-    <script src="$path/src/renderer/webgl/gameobjects/Text.js"></script>
-    <script src="$path/src/renderer/webgl/gameobjects/Graphics.js"></script>
 
 
 EOL;
@@ -262,6 +260,7 @@
     <script src="$path/src/gameobjects/GraphicsData.js"></script>
     <script src="$path/src/gameobjects/Graphics.js"></script>
     <script src="$path/src/renderer/canvas/gameobjects/Graphics.js"></script>
+    <script src="$path/src/renderer/webgl/gameobjects/Graphics.js"></script>
 
 
 EOL;
@@ -281,6 +280,7 @@
         echo <<<EOL
     <script src="$path/src/gameobjects/Text.js"></script>
     <script src="$path/src/renderer/canvas/gameobjects/Text.js"></script>
+    <script src="$path/src/renderer/webgl/gameobjects/Text.js"></script>
 
 
 EOL;
diff --git a/src/renderer/webgl/WebGLRenderer.js b/src/renderer/webgl/WebGLRenderer.js
@@ -171,6 +171,17 @@ Phaser.Renderer.WebGL.prototype = {
             throw new Error('This browser does not support WebGL. Try using the Canvas renderer.');
         }
 
+        //  Mixin the renderer functions
+        for (var renderer in Phaser.Renderer.WebGL.GameObjects)
+        {
+            var types = Phaser.Renderer.WebGL.GameObjects[renderer].TYPES;
+
+            for (var i = 0; i < types.length; i++)
+            {
+                types[i].render = Phaser.Renderer.WebGL.GameObjects[renderer].render;
+            }
+        }
+
         this.gl.id = 0;
 
         var gl = this.gl;
@@ -362,7 +373,7 @@ Phaser.Renderer.WebGL.prototype = {
         this.offset.x = this.game.camera._shake.x;
         this.offset.y = this.game.camera._shake.y;
 
-        // this.renderSession.blendModeManager.setBlendMode(PIXI.blendModes.NORMAL);
+        this.setBlendMode(this.blendModes.NORMAL);
 
         //  Reset draw count
         this.drawCount = 0;
@@ -374,7 +385,7 @@ Phaser.Renderer.WebGL.prototype = {
 
         // this.filterManager.begin();
 
-        stage.render(this);
+        stage.render(this, stage);
 
         this.spriteBatch.end();
 
diff --git a/src/renderer/webgl/gameobjects/Container.js b/src/renderer/webgl/gameobjects/Container.js
@@ -5,50 +5,56 @@
 */
 Phaser.Renderer.WebGL.GameObjects.Container = {
 
-    render: function (renderer)
+    TYPES: [
+        Phaser.Group.prototype,
+        PIXI.DisplayObjectContainer.prototype
+    ],
+
+    render: function (renderer, src)
     {
-        if (this.visible === false || this.alpha === 0 || this.children.length === 0)
+        if (src.visible === false || src.alpha === 0 || src.children.length === 0)
         {
             return;
         }
 
-        if (this._cacheAsBitmap)
+        if (src._cacheAsBitmap)
         {
-            return this.renderCachedSprite(renderer);
+            return Phaser.Renderer.WebGL.GameObjects.Container.renderCachedSprite(renderer, src);
         }
     
         var i;
 
-        if (this._mask || this._filters)
+        if (src._mask || src._filters)
         {
             // push filter first as we need to ensure the stencil buffer is correct for any masking
-            if (this._filters)
+            if (src._filters)
             {
                 renderer.spriteBatch.flush();
-                renderer.filterManager.pushFilter(this._filterBlock);
+                renderer.filterManager.pushFilter(src._filterBlock);
             }
 
-            if (this._mask)
+            if (src._mask)
             {
                 renderer.spriteBatch.stop();
-                renderer.pushMask(this.mask);
+                renderer.pushMask(src.mask);
                 renderer.spriteBatch.start();
             }
 
             // simple render children!
-            for (i = 0; i < this.children.length; i++)
+            for (i = 0; i < src.children.length; i++)
             {
-                this.children[i].render(renderer);
+                var child = src.children[i];
+                child.render(renderer, child);
             }
 
             renderer.spriteBatch.stop();
 
-            if (this._mask)
+            if (src._mask)
             {
-                renderer.popMask(this._mask);
+                renderer.popMask(src._mask);
             }
 
-            if (this._filters)
+            if (src._filters)
             {
                 renderer.filterManager.popFilter();
             }
@@ -58,15 +64,16 @@ Phaser.Renderer.WebGL.GameObjects.Container = {
         else
         {
             // simple render children!
-            for (i = 0; i < this.children.length; i++)
+            for (i = 0; i < src.children.length; i++)
             {
-                this.children[i].render(renderer);
+                var child = src.children[i];
+                child.render(renderer, child);
             }
         }
 
     },
 
-    renderCachedSprite: function (renderer)
+    renderCachedSprite: function (renderer, src)
     {
         //  TODO
         return renderer;
diff --git a/src/renderer/webgl/gameobjects/Graphics.js b/src/renderer/webgl/gameobjects/Graphics.js
@@ -5,29 +5,31 @@
 */
 Phaser.Renderer.WebGL.GameObjects.Graphics = {
 
-    render: function (renderer)
-    {
-        var local = Phaser.Renderer.Canvas.GameObjects.Graphics;
+    TYPES: [
+        Phaser.Graphics.prototype
+    ],
 
-        if (this.visible === false || this.alpha === 0 || this.isMask === true)
+    render: function (renderer, src)
+    {
+        if (src.visible === false || src.alpha === 0 || src.isMask === true)
         {
             return;
         }
 
-        if (this._cacheAsBitmap)
+        if (src._cacheAsBitmap)
         {
-            if (this.dirty || this.cachedSpriteDirty)
+            if (src.dirty || src.cachedSpriteDirty)
             {
-                this._generateCachedSprite();
+                src._generateCachedSprite();
        
                 // we will also need to update the texture on the gpu too!
-                this.updateCachedSpriteTexture();
+                src.updateCachedSpriteTexture();
 
-                this.cachedSpriteDirty = false;
-                this.dirty = false;
+                src.cachedSpriteDirty = false;
+                src.dirty = false;
             }
 
-            this._cachedSprite.worldAlpha = this.worldAlpha;
+            src._cachedSprite.worldAlpha = src.worldAlpha;
 
             // PIXI.Sprite.prototype._renderWebGL.call(this._cachedSprite, renderSession);
 
@@ -36,59 +38,60 @@ Phaser.Renderer.WebGL.GameObjects.Graphics = {
         else
         {
             renderer.spriteBatch.stop();
-            renderer.setBlendMode(this.blendMode);
+            renderer.setBlendMode(src.blendMode);
 
-            if (this._mask)
+            if (src._mask)
             {
-                renderer.pushMask(this._mask);
+                renderer.pushMask(src._mask);
             }
 
-            if (this._filters)
+            if (src._filters)
             {
-                renderer.filterManager.pushFilter(this._filterBlock);
+                renderer.filterManager.pushFilter(src._filterBlock);
             }
           
             // check blend mode
-            if (this.blendMode !== renderer.spriteBatch.currentBlendMode)
+            if (src.blendMode !== renderer.spriteBatch.currentBlendMode)
             {
-                renderer.spriteBatch.currentBlendMode = this.blendMode;
+                renderer.spriteBatch.currentBlendMode = src.blendMode;
 
                 var blendModeWebGL = renderer.blendModes[renderer.spriteBatch.currentBlendMode];
 
                 renderer.spriteBatch.gl.blendFunc(blendModeWebGL[0], blendModeWebGL[1]);
             }
             
             // check if the webgl graphic needs to be updated
-            if (this.webGLDirty)
+            if (src.webGLDirty)
             {
-                this.dirty = true;
-                this.webGLDirty = false;
+                src.dirty = true;
+                src.webGLDirty = false;
             }
             
             //  Merge with this class
             // PIXI.WebGLGraphics.renderGraphics(this, renderSession);
             
             // only render if it has children!
-            if (this.children.length)
+            if (src.children.length)
             {
                 renderer.spriteBatch.start();
 
-                for (var i = 0; i < this.children.length; i++)
+                for (var i = 0; i < src.children.length; i++)
                 {
-                    this.children[i].render(renderer);
+                    var child = src.children[i];
+                    child.render(renderer, child);
                 }
 
                 renderer.spriteBatch.stop();
             }
 
-            if (this._filters)
+            if (src._filters)
             {
                 renderer.filterManager.popFilter();
             }
 
-            if (this._mask)
+            if (src._mask)
             {
-                renderer.popMask(this.mask);
+                renderer.popMask(src.mask);
             }
               
             renderer.drawCount++;
diff --git a/src/renderer/webgl/gameobjects/Sprite.js b/src/renderer/webgl/gameobjects/Sprite.js
@@ -5,10 +5,16 @@
 */
 Phaser.Renderer.WebGL.GameObjects.Sprite = {
 
-    render: function (renderer)
+    TYPES: [
+        Phaser.Sprite.prototype,
+        Phaser.Image.prototype,
+        PIXI.Sprite.prototype
+    ],
+
+    render: function (renderer, src)
     {
         // If the sprite is not visible or the alpha is 0 then no need to render this element
-        if (!this.visible || this.alpha === 0 || !this.renderable)
+        if (!src.visible || src.alpha === 0 || !src.renderable)
         {
             return;
         }
@@ -18,42 +24,43 @@ Phaser.Renderer.WebGL.GameObjects.Sprite = {
         var i;
 
         //  Would be good to get this down to 1 check, or even none.
-        if (this._mask || this._filters)
+        if (src._mask || src._filters)
         {
             var spriteBatch = renderer.spriteBatch;
 
             // push filter first as we need to ensure the stencil buffer is correct for any masking
-            if (this._filters)
+            if (src._filters)
             {
                 spriteBatch.flush();
-                renderer.filterManager.pushFilter(this._filterBlock);
+                renderer.filterManager.pushFilter(src._filterBlock);
             }
 
-            if (this._mask)
+            if (src._mask)
             {
                 spriteBatch.stop();
-                renderer.pushMask(this.mask);
+                renderer.pushMask(src.mask);
                 spriteBatch.start();
             }
 
             // add this sprite to the batch
-            spriteBatch.render(this);
+            spriteBatch.render(src);
 
             // now loop through the children and make sure they get rendered
             for (i = 0; i < this.children.length; i++)
             {
-                this.children[i].render(renderer);
+                var child = src.children[i];
+                child.render(renderer, child);
             }
 
             // time to stop the sprite batch as either a mask element or a filter draw will happen next
             spriteBatch.stop();
 
-            if (this._mask)
+            if (src._mask)
             {
-                renderer.popMask(this._mask);
+                renderer.popMask(src._mask);
             }
 
-            if (this._filters)
+            if (src._filters)
             {
                 renderer.filterManager.popFilter();
             }
@@ -62,12 +69,13 @@ Phaser.Renderer.WebGL.GameObjects.Sprite = {
         }
         else
         {
-            renderer.spriteBatch.render(this);
+            renderer.spriteBatch.render(src);
 
             //  Render children!
-            for (i = 0; i < this.children.length; i++)
+            for (i = 0; i < src.children.length; i++)
             {
-                this.children[i].render(renderer);
+                var child = src.children[i];
+                child.render(renderer, child);
             }
         }
     }
diff --git a/src/renderer/webgl/gameobjects/Stage.js b/src/renderer/webgl/gameobjects/Stage.js
diff --git a/src/renderer/webgl/gameobjects/Text.js b/src/renderer/webgl/gameobjects/Text.js

Original file line number	Diff line number	Diff line change
`@@ -5,50 +5,56 @@`
`5`	`5`	`*/`
`6`	`6`	`Phaser.Renderer.WebGL.GameObjects.Container = {`
`7`	`7`
`8`		`- render: function (renderer)`
	`8`	`+ TYPES: [`
	`9`	`+ Phaser.Group.prototype,`
	`10`	`+ PIXI.DisplayObjectContainer.prototype`
	`11`	`+ ],`
	`12`	`+`
	`13`	`+ render: function (renderer, src)`
`9`	`14`	`{`
`10`		`- if (this.visible === false \|\| this.alpha === 0 \|\| this.children.length === 0)`
	`15`	`+ if (src.visible === false \|\| src.alpha === 0 \|\| src.children.length === 0)`
`11`	`16`	`{`
`12`	`17`	`return;`
`13`	`18`	`}`
`14`	`19`
`15`		`- if (this._cacheAsBitmap)`
	`20`	`+ if (src._cacheAsBitmap)`
`16`	`21`	`{`
`17`		`- return this.renderCachedSprite(renderer);`
	`22`	`+ return Phaser.Renderer.WebGL.GameObjects.Container.renderCachedSprite(renderer, src);`
`18`	`23`	`}`
`19`	`24`
`20`	`25`	`var i;`
`21`	`26`
`22`		`- if (this._mask \|\| this._filters)`
	`27`	`+ if (src._mask \|\| src._filters)`
`23`	`28`	`{`
`24`	`29`	`// push filter first as we need to ensure the stencil buffer is correct for any masking`
`25`		`- if (this._filters)`
	`30`	`+ if (src._filters)`
`26`	`31`	`{`
`27`	`32`	`renderer.spriteBatch.flush();`
`28`		`- renderer.filterManager.pushFilter(this._filterBlock);`
	`33`	`+ renderer.filterManager.pushFilter(src._filterBlock);`
`29`	`34`	`}`
`30`	`35`
`31`		`- if (this._mask)`
	`36`	`+ if (src._mask)`
`32`	`37`	`{`
`33`	`38`	`renderer.spriteBatch.stop();`
`34`		`- renderer.pushMask(this.mask);`
	`39`	`+ renderer.pushMask(src.mask);`
`35`	`40`	`renderer.spriteBatch.start();`
`36`	`41`	`}`
`37`	`42`
`38`	`43`	`// simple render children!`
`39`		`- for (i = 0; i < this.children.length; i++)`
	`44`	`+ for (i = 0; i < src.children.length; i++)`
`40`	`45`	`{`
`41`		`- this.children[i].render(renderer);`
	`46`	`+ var child = src.children[i];`
	`47`	`+ child.render(renderer, child);`
`42`	`48`	`}`
`43`	`49`
`44`	`50`	`renderer.spriteBatch.stop();`
`45`	`51`
`46`		`- if (this._mask)`
	`52`	`+ if (src._mask)`
`47`	`53`	`{`
`48`		`- renderer.popMask(this._mask);`
	`54`	`+ renderer.popMask(src._mask);`
`49`	`55`	`}`
`50`	`56`
`51`		`- if (this._filters)`
	`57`	`+ if (src._filters)`
`52`	`58`	`{`
`53`	`59`	`renderer.filterManager.popFilter();`
`54`	`60`	`}`
`@@ -58,15 +64,16 @@ Phaser.Renderer.WebGL.GameObjects.Container = {`
`58`	`64`	`else`
`59`	`65`	`{`
`60`	`66`	`// simple render children!`
`61`		`- for (i = 0; i < this.children.length; i++)`
	`67`	`+ for (i = 0; i < src.children.length; i++)`
`62`	`68`	`{`
`63`		`- this.children[i].render(renderer);`
	`69`	`+ var child = src.children[i];`
	`70`	`+ child.render(renderer, child);`
`64`	`71`	`}`
`65`	`72`	`}`
`66`	`73`
`67`	`74`	`},`
`68`	`75`
`69`		`- renderCachedSprite: function (renderer)`
	`76`	`+ renderCachedSprite: function (renderer, src)`
`70`	`77`	`{`
`71`	`78`	`// TODO`
`72`	`79`	`return renderer;`
Original file line number	Diff line number	Diff line change
`@@ -5,29 +5,31 @@`
`5`	`5`	`*/`
`6`	`6`	`Phaser.Renderer.WebGL.GameObjects.Graphics = {`
`7`	`7`
`8`		`- render: function (renderer)`
`9`		`- {`
`10`		`- var local = Phaser.Renderer.Canvas.GameObjects.Graphics;`
	`8`	`+ TYPES: [`
	`9`	`+ Phaser.Graphics.prototype`
	`10`	`+ ],`
`11`	`11`
`12`		`- if (this.visible === false \|\| this.alpha === 0 \|\| this.isMask === true)`
	`12`	`+ render: function (renderer, src)`
	`13`	`+ {`
	`14`	`+ if (src.visible === false \|\| src.alpha === 0 \|\| src.isMask === true)`
`13`	`15`	`{`
`14`	`16`	`return;`
`15`	`17`	`}`
`16`	`18`
`17`		`- if (this._cacheAsBitmap)`
	`19`	`+ if (src._cacheAsBitmap)`
`18`	`20`	`{`
`19`		`- if (this.dirty \|\| this.cachedSpriteDirty)`
	`21`	`+ if (src.dirty \|\| src.cachedSpriteDirty)`
`20`	`22`	`{`
`21`		`- this._generateCachedSprite();`
	`23`	`+ src._generateCachedSprite();`
`22`	`24`
`23`	`25`	`// we will also need to update the texture on the gpu too!`
`24`		`- this.updateCachedSpriteTexture();`
	`26`	`+ src.updateCachedSpriteTexture();`
`25`	`27`
`26`		`- this.cachedSpriteDirty = false;`
`27`		`- this.dirty = false;`
	`28`	`+ src.cachedSpriteDirty = false;`
	`29`	`+ src.dirty = false;`
`28`	`30`	`}`
`29`	`31`
`30`		`- this._cachedSprite.worldAlpha = this.worldAlpha;`
	`32`	`+ src._cachedSprite.worldAlpha = src.worldAlpha;`
`31`	`33`
`32`	`34`	`// PIXI.Sprite.prototype._renderWebGL.call(this._cachedSprite, renderSession);`
`33`	`35`
`@@ -36,59 +38,60 @@ Phaser.Renderer.WebGL.GameObjects.Graphics = {`
`36`	`38`	`else`
`37`	`39`	`{`
`38`	`40`	`renderer.spriteBatch.stop();`
`39`		`- renderer.setBlendMode(this.blendMode);`
	`41`	`+ renderer.setBlendMode(src.blendMode);`
`40`	`42`
`41`		`- if (this._mask)`
	`43`	`+ if (src._mask)`
`42`	`44`	`{`
`43`		`- renderer.pushMask(this._mask);`
	`45`	`+ renderer.pushMask(src._mask);`
`44`	`46`	`}`
`45`	`47`
`46`		`- if (this._filters)`
	`48`	`+ if (src._filters)`
`47`	`49`	`{`
`48`		`- renderer.filterManager.pushFilter(this._filterBlock);`
	`50`	`+ renderer.filterManager.pushFilter(src._filterBlock);`
`49`	`51`	`}`
`50`	`52`
`51`	`53`	`// check blend mode`
`52`		`- if (this.blendMode !== renderer.spriteBatch.currentBlendMode)`
	`54`	`+ if (src.blendMode !== renderer.spriteBatch.currentBlendMode)`
`53`	`55`	`{`
`54`		`- renderer.spriteBatch.currentBlendMode = this.blendMode;`
	`56`	`+ renderer.spriteBatch.currentBlendMode = src.blendMode;`
`55`	`57`
`56`	`58`	`var blendModeWebGL = renderer.blendModes[renderer.spriteBatch.currentBlendMode];`
`57`	`59`
`58`	`60`	`renderer.spriteBatch.gl.blendFunc(blendModeWebGL[0], blendModeWebGL[1]);`
`59`	`61`	`}`
`60`	`62`
`61`	`63`	`// check if the webgl graphic needs to be updated`
`62`		`- if (this.webGLDirty)`
	`64`	`+ if (src.webGLDirty)`
`63`	`65`	`{`
`64`		`- this.dirty = true;`
`65`		`- this.webGLDirty = false;`
	`66`	`+ src.dirty = true;`
	`67`	`+ src.webGLDirty = false;`
`66`	`68`	`}`
`67`	`69`
`68`	`70`	`// Merge with this class`
`69`	`71`	`// PIXI.WebGLGraphics.renderGraphics(this, renderSession);`
`70`	`72`
`71`	`73`	`// only render if it has children!`
`72`		`- if (this.children.length)`
	`74`	`+ if (src.children.length)`
`73`	`75`	`{`
`74`	`76`	`renderer.spriteBatch.start();`
`75`	`77`
`76`		`- for (var i = 0; i < this.children.length; i++)`
	`78`	`+ for (var i = 0; i < src.children.length; i++)`
`77`	`79`	`{`
`78`		`- this.children[i].render(renderer);`
	`80`	`+ var child = src.children[i];`
	`81`	`+ child.render(renderer, child);`
`79`	`82`	`}`
`80`	`83`
`81`	`84`	`renderer.spriteBatch.stop();`
`82`	`85`	`}`
`83`	`86`
`84`		`- if (this._filters)`
	`87`	`+ if (src._filters)`
`85`	`88`	`{`
`86`	`89`	`renderer.filterManager.popFilter();`
`87`	`90`	`}`
`88`	`91`
`89`		`- if (this._mask)`
	`92`	`+ if (src._mask)`
`90`	`93`	`{`
`91`		`- renderer.popMask(this.mask);`
	`94`	`+ renderer.popMask(src.mask);`
`92`	`95`	`}`
`93`	`96`
`94`	`97`	`renderer.drawCount++;`
Original file line number	Diff line number	Diff line change
`@@ -5,10 +5,16 @@`
`5`	`5`	`*/`
`6`	`6`	`Phaser.Renderer.WebGL.GameObjects.Sprite = {`
`7`	`7`
`8`		`- render: function (renderer)`
	`8`	`+ TYPES: [`
	`9`	`+ Phaser.Sprite.prototype,`
	`10`	`+ Phaser.Image.prototype,`
	`11`	`+ PIXI.Sprite.prototype`
	`12`	`+ ],`
	`13`	`+`
	`14`	`+ render: function (renderer, src)`
`9`	`15`	`{`
`10`	`16`	`// If the sprite is not visible or the alpha is 0 then no need to render this element`
`11`		`- if (!this.visible \|\| this.alpha === 0 \|\| !this.renderable)`
	`17`	`+ if (!src.visible \|\| src.alpha === 0 \|\| !src.renderable)`
`12`	`18`	`{`
`13`	`19`	`return;`
`14`	`20`	`}`
`@@ -18,42 +24,43 @@ Phaser.Renderer.WebGL.GameObjects.Sprite = {`
`18`	`24`	`var i;`
`19`	`25`
`20`	`26`	`// Would be good to get this down to 1 check, or even none.`
`21`		`- if (this._mask \|\| this._filters)`
	`27`	`+ if (src._mask \|\| src._filters)`
`22`	`28`	`{`
`23`	`29`	`var spriteBatch = renderer.spriteBatch;`
`24`	`30`
`25`	`31`	`// push filter first as we need to ensure the stencil buffer is correct for any masking`
`26`		`- if (this._filters)`
	`32`	`+ if (src._filters)`
`27`	`33`	`{`
`28`	`34`	`spriteBatch.flush();`
`29`		`- renderer.filterManager.pushFilter(this._filterBlock);`
	`35`	`+ renderer.filterManager.pushFilter(src._filterBlock);`
`30`	`36`	`}`
`31`	`37`
`32`		`- if (this._mask)`
	`38`	`+ if (src._mask)`
`33`	`39`	`{`
`34`	`40`	`spriteBatch.stop();`
`35`		`- renderer.pushMask(this.mask);`
	`41`	`+ renderer.pushMask(src.mask);`
`36`	`42`	`spriteBatch.start();`
`37`	`43`	`}`
`38`	`44`
`39`	`45`	`// add this sprite to the batch`
`40`		`- spriteBatch.render(this);`
	`46`	`+ spriteBatch.render(src);`
`41`	`47`
`42`	`48`	`// now loop through the children and make sure they get rendered`
`43`	`49`	`for (i = 0; i < this.children.length; i++)`
`44`	`50`	`{`
`45`		`- this.children[i].render(renderer);`
	`51`	`+ var child = src.children[i];`
	`52`	`+ child.render(renderer, child);`
`46`	`53`	`}`
`47`	`54`
`48`	`55`	`// time to stop the sprite batch as either a mask element or a filter draw will happen next`
`49`	`56`	`spriteBatch.stop();`
`50`	`57`
`51`		`- if (this._mask)`
	`58`	`+ if (src._mask)`
`52`	`59`	`{`
`53`		`- renderer.popMask(this._mask);`
	`60`	`+ renderer.popMask(src._mask);`
`54`	`61`	`}`
`55`	`62`
`56`		`- if (this._filters)`
	`63`	`+ if (src._filters)`
`57`	`64`	`{`
`58`	`65`	`renderer.filterManager.popFilter();`
`59`	`66`	`}`
`@@ -62,12 +69,13 @@ Phaser.Renderer.WebGL.GameObjects.Sprite = {`
`62`	`69`	`}`
`63`	`70`	`else`
`64`	`71`	`{`
`65`		`- renderer.spriteBatch.render(this);`
	`72`	`+ renderer.spriteBatch.render(src);`
`66`	`73`
`67`	`74`	`// Render children!`
`68`		`- for (i = 0; i < this.children.length; i++)`
	`75`	`+ for (i = 0; i < src.children.length; i++)`
`69`	`76`	`{`
`70`		`- this.children[i].render(renderer);`
	`77`	`+ var child = src.children[i];`
	`78`	`+ child.render(renderer, child);`
`71`	`79`	`}`
`72`	`80`	`}`
`73`	`81`	`}`