Blitter now hits the renderer directly

Author: photonstorm

src/gameobjects/blitter/BlitterWebGLRenderer.js

@@ -5,6 +5,7 @@
  */
 
 var GameObject = require('../GameObject');
+var Utils = require('../../renderer/webgl/Utils');
 
 /**
  * Renders this Game Object with the WebGL Renderer to the given Camera.
@@ -16,19 +17,107 @@ var GameObject = require('../GameObject');
  * @private
  *
  * @param {Phaser.Renderer.WebGL.WebGLRenderer} renderer - A reference to the current active WebGL renderer.
- * @param {Phaser.GameObjects.Blitter} gameObject - The Game Object being rendered in this call.
+ * @param {Phaser.GameObjects.Blitter} 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.
  * @param {Phaser.GameObjects.Components.TransformMatrix} parentMatrix - This transform matrix is defined if the game object is nested
  */
-var BlitterWebGLRenderer = function (renderer, gameObject, interpolationPercentage, camera, parentMatrix)
+var BlitterWebGLRenderer = function (renderer, src, interpolationPercentage, camera, parentMatrix)
 {
-    if (GameObject.RENDER_MASK !== gameObject.renderFlags || (gameObject.cameraFilter > 0 && (gameObject.cameraFilter & camera._id)))
+    if (GameObject.RENDER_MASK !== src.renderFlags || (src.cameraFilter > 0 && (src.cameraFilter & camera._id)))
     {
         return;
     }
 
-    this.pipeline.drawBlitter(gameObject, camera, parentMatrix);
+    var pipeline = this.pipeline;
+
+    renderer.setPipeline(pipeline);
+
+    var cameraScrollX = camera.scrollX * src.scrollFactorX;
+    var cameraScrollY = camera.scrollY * src.scrollFactorY;
+
+    var matrix = pipeline._tempCameraMatrix;
+
+    matrix.copyFrom(camera.matrix);
+
+    if (parentMatrix)
+    {
+        matrix.multiplyWithOffset(parentMatrix, -cameraScrollX, -cameraScrollY);
+
+        cameraScrollX = 0;
+        cameraScrollY = 0;
+    }
+
+    var list = src.getRenderList();
+    var blitterX = src.x - cameraScrollX;
+    var blitterY = src.y - cameraScrollY;
+    var prevTextureSourceIndex = -1;
+    var tintEffect = false;
+    var alpha = camera.alpha * src.alpha;
+    var getTint = Utils.getTintAppendFloatAlpha;
+    var roundPixels = camera.roundPixels;
+
+    for (var index = 0; index < list.length; index++)
+    {
+        var bob = list[index];
+        var frame = bob.frame;
+        var bobAlpha = bob.alpha * alpha;
+
+        if (bobAlpha === 0)
+        {
+            continue;
+        }
+
+        var width = frame.width;
+        var height = frame.height;
+
+        var x = blitterX + bob.x + frame.x;
+        var y = blitterY + bob.y + frame.y;
+
+        if (bob.flipX)
+        {
+            width *= -1;
+            x += frame.width;
+        }
+
+        if (bob.flipY)
+        {
+            height *= -1;
+            y += frame.height;
+        }
+
+        var xw = x + width;
+        var yh = y + height;
+
+        var tx0 = x * matrix.a + y * matrix.c + matrix.e;
+        var ty0 = x * matrix.b + y * matrix.d + matrix.f;
+        var tx1 = xw * matrix.a + yh * matrix.c + matrix.e;
+        var ty1 = xw * matrix.b + yh * matrix.d + matrix.f;
+
+        var tint = getTint(0xffffff, bobAlpha);
+        var uvs = frame.uvs;
+
+        //  Bind texture only if the Texture Source is different from before
+        if (frame.sourceIndex !== prevTextureSourceIndex)
+        {
+            pipeline.setTexture2D(frame.glTexture, 0);
+
+            prevTextureSourceIndex = frame.sourceIndex;
+        }
+
+        if (roundPixels)
+        {
+            tx0 |= 0;
+            ty0 |= 0;
+            tx1 |= 0;
+            ty1 |= 0;
+        }
+
+        if (pipeline.batchVertices(tx0, ty0, tx1, ty1, uvs, tint, tint, tint, tint, tintEffect))
+        {
+            prevTextureSourceIndex = -1;
+        }
+    }
 };
 
 module.exports = BlitterWebGLRenderer;