Mesh WebGL Renderer

Author: bitnenfer

v3/src/gameobjects/mesh/Mesh.js

@@ -34,8 +34,13 @@ var Mesh = new Class({
         this.setSizeToFrame();
         this.setOrigin();
 
-        this.vertices = vertices;
-        this.uv = uv;
+        if (vertices.length !== uv.length)
+        {
+            throw new Error('Phaser: Vertex count must match UV count');
+        }
+
+        this.vertices = new Float32Array(vertices);
+        this.uv = new Float32Array(uv);
     }
 
 });

v3/src/gameobjects/mesh/MeshWebGLRenderer.js

@@ -4,6 +4,7 @@ var MeshWebGLRenderer = function (renderer, src, interpolationPercentage, camera
     {
         return;
     }
+    renderer.spriteBatch.addMesh(src, camera);
 };
 
 module.exports = MeshWebGLRenderer

v3/src/renderer/webgl/renderers/spritebatch/SpriteBatch.js

@@ -44,6 +44,7 @@ var SpriteBatch = function (game, gl, manager)
     this.manager = manager;
     this.dirty = false;
     this.drawIndexed = true;
+    this.lastDrawIndexed = true;
     this.vertexCount = 0;
 
     this.init(this.glContext);
@@ -95,6 +96,11 @@ SpriteBatch.prototype = {
 
     shouldFlush: function ()
     {
+        if (this.drawIndexed != this.lastDrawIndexed)
+        {
+            this.lastDrawIndexed = this.drawIndexed;
+            return true;
+        }
         return false;
     },
 
@@ -123,7 +129,7 @@ SpriteBatch.prototype = {
         var gl = this.glContext;
         var vertexDataBuffer = this.vertexDataBuffer;
 
-        if (this.elementCount === 0)
+        if (this.elementCount === 0 && this.vertexCount === 0)
         {
             return;
         }
@@ -191,7 +197,100 @@ SpriteBatch.prototype = {
 
     addMesh: function (gameObject, camera)
     {
+        var tempMatrix = this.tempMatrix;
+        var frame = gameObject.frame;
+        var vertexDataBuffer = this.vertexDataBuffer;
+        var vertexBufferObjectF32 = vertexDataBuffer.floatView;
+        var vertexBufferObjectU32 = vertexDataBuffer.uintView;
+        var vertexOffset = 0;
+        var translateX = gameObject.x - camera.scrollX;
+        var translateY = gameObject.y - camera.scrollY;
+        var scaleX = gameObject.scaleX;
+        var scaleY = gameObject.scaleY;
+        var rotation = -gameObject.rotation;
+        var tempMatrixMatrix = tempMatrix.matrix;
+        var cameraMatrix = camera.matrix.matrix;
+        var mva, mvb, mvc, mvd, mve, mvf, tx0, ty0, tx1, ty1, tx2, ty2, tx3, ty3;
+        var sra, srb, src, srd, sre, srf, cma, cmb, cmc, cmd, cme, cmf;
+        var alpha = gameObject.alpha;
+        var vertices = gameObject.vertices;
+        var uv = gameObject.uv;
+        var length = vertices.length;
+        var totalVertices = (length / 2)|0;
+
+        tempMatrix.applyITRS(translateX, translateY, rotation, scaleX, scaleY);
+
+        sra = tempMatrixMatrix[0];
+        srb = tempMatrixMatrix[1];
+        src = tempMatrixMatrix[2];
+        srd = tempMatrixMatrix[3];
+        sre = tempMatrixMatrix[4];
+        srf = tempMatrixMatrix[5];
+
+        cma = cameraMatrix[0];
+        cmb = cameraMatrix[1];
+        cmc = cameraMatrix[2];
+        cmd = cameraMatrix[3];
+        cme = cameraMatrix[4];
+        cmf = cameraMatrix[5];
+
+        mva = sra * cma + srb * cmc;
+        mvb = sra * cmb + srb * cmd;
+        mvc = src * cma + srd * cmc;
+        mvd = src * cmb + srd * cmd;
+        mve = sre * cma + srf * cmc + cme;
+        mvf = sre * cmb + srf * cmd + cmf; 
+        
+        this.drawIndexed = false;
+        this.manager.setRenderer(this, frame.texture.source[frame.sourceIndex].glTexture, gameObject.renderTarget);
+        this.vertexCount += totalVertices;
+
+        vertexOffset = vertexDataBuffer.allocate(totalVertices * 6);
+
+        for (var index = 0; index < length; index += 2)
+        {
+            var x = vertices[index + 0];
+            var y = vertices[index + 1];
+            var tx = x * mva + y * mvc + mve;
+            var ty = x * mvb + y * mvd + mvf;
+            vertexBufferObjectF32[vertexOffset++] = tx;
+            vertexBufferObjectF32[vertexOffset++] = ty;
+            vertexBufferObjectF32[vertexOffset++] = uv[index + 0];
+            vertexBufferObjectF32[vertexOffset++] = uv[index + 1];
+            vertexBufferObjectU32[vertexOffset++] = 0xFFFFFF;
+            vertexBufferObjectF32[vertexOffset++] = alpha;
+        }
 
+        /*vertexOffset = vertexDataBuffer.allocate(24);
+        this.vertexCount += 6;
+        
+        vertexBufferObjectF32[vertexOffset++] = tx0;
+        vertexBufferObjectF32[vertexOffset++] = ty0;
+        vertexBufferObjectF32[vertexOffset++] = uvs.x0;
+        vertexBufferObjectF32[vertexOffset++] = uvs.y0;
+        vertexBufferObjectU32[vertexOffset++] = 0xFFFFFF; //vertexColor.topLeft;
+        vertexBufferObjectF32[vertexOffset++] = alpha;
+
+        vertexBufferObjectF32[vertexOffset++] = tx1;
+        vertexBufferObjectF32[vertexOffset++] = ty1;
+        vertexBufferObjectF32[vertexOffset++] = uvs.x1;
+        vertexBufferObjectF32[vertexOffset++] = uvs.y1;
+        vertexBufferObjectU32[vertexOffset++] = 0xFFFFFF; //vertexColor.bottomLeft;
+        vertexBufferObjectF32[vertexOffset++] = alpha;
+
+        vertexBufferObjectF32[vertexOffset++] = tx2;
+        vertexBufferObjectF32[vertexOffset++] = ty2;
+        vertexBufferObjectF32[vertexOffset++] = uvs.x2;
+        vertexBufferObjectF32[vertexOffset++] = uvs.y2;
+        vertexBufferObjectU32[vertexOffset++] = 0xFFFFFF; //vertexColor.bottomRight;
+        vertexBufferObjectF32[vertexOffset++] = alpha;
+
+        vertexBufferObjectF32[vertexOffset++] = tx3;
+        vertexBufferObjectF32[vertexOffset++] = ty3;
+        vertexBufferObjectF32[vertexOffset++] = uvs.x3;
+        vertexBufferObjectF32[vertexOffset++] = uvs.y3;
+        vertexBufferObjectU32[vertexOffset++] = 0xFFFFFF; //vertexColor.topRight;
+        vertexBufferObjectF32[vertexOffset++] = alpha;*/
     },
 
     addSpriteTexture: function (gameObject, camera, texture, textureWidth, textureHeight)
@@ -251,6 +350,7 @@ SpriteBatch.prototype = {
         tx3 = xw * mva + y * mvc + mve;
         ty3 = xw * mvb + y * mvd + mvf;
 
+        this.drawIndexed = true;
         this.manager.setRenderer(this, texture, gameObject.renderTarget);
         vertexOffset = vertexDataBuffer.allocate(24);
         this.elementCount += 6;
@@ -346,6 +446,7 @@ SpriteBatch.prototype = {
         tx3 = xw * mva + y * mvc + mve;
         ty3 = xw * mvb + y * mvd + mvf;
 
+        this.drawIndexed = true;
         this.manager.setRenderer(this, frame.texture.source[frame.sourceIndex].glTexture, gameObject.renderTarget);
         vertexOffset = vertexDataBuffer.allocate(24);
         this.elementCount += 6;