Importing text engine

Author: arielm

common/quad/QuadBatch.cpp

@@ -0,0 +1,42 @@
+#include "common/quad/QuadBatch.h"
+
+namespace chr
+{
+  namespace gl
+  {
+    void QuadBatch::clear()
+    {
+      vertexBuffer.clear();
+      colorBuffer.clear();
+    }
+
+    void QuadBatch::pack()
+    {
+      vertices.shrink_to_fit();
+      colors.shrink_to_fit();
+    }
+
+    void QuadBatch::flush(const ShaderProgram &shaderProgram, Buffer<GLushort> &indexBuffer, bool useColor)
+    {
+      if (!empty())
+      {
+        vertexBuffer.bind(shaderProgram);
+
+        if (useColor)
+        {
+          colorBuffer.bind(shaderProgram);
+        }
+
+        indexBuffer.bind(shaderProgram);
+        indexBuffer.draw(GL_TRIANGLES, size() * 6);
+
+        vertexBuffer.unbind(shaderProgram);
+
+        if (useColor)
+        {
+          colorBuffer.unbind(shaderProgram);
+        }
+      }
+    }
+  }
+}

common/quad/QuadBatch.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "chr/gl/Matrix.h"
+#include "chr/gl/Buffer.h"
+
+namespace chr
+{
+  namespace gl
+  {
+    class QuadBatch
+    {
+    public:
+      Buffer<Vertex<XYZ.UV>> vertexBuffer;
+      Buffer<Vertex<RGBA>> colorBuffer;
+
+      std::vector<Vertex<XYZ.UV>> &vertices;
+      std::vector<Vertex<RGBA>> &colors;
+
+      QuadBatch()
+      :
+      vertices(vertexBuffer->storage),
+      colors(colorBuffer->storage)
+      {}
+
+      void clear();
+      void pack();
+      void flush(const ShaderProgram &shader, Buffer<GLushort> &indexBuffer, bool useColor = false);
+
+      inline int size() const
+      {
+        return vertices.size() >> 2;
+      }
+
+      inline bool empty() const
+      {
+        return vertices.empty();
+      }
+
+      inline void addQuad(const Matrix &matrix, const Quad<XYZ.UV> &quad)
+      {
+        matrix.addTransformedQuad(quad, vertices);
+      }
+
+      inline void addQuad(const Quad<XYZ.UV> &quad, float z = 0)
+      {
+        vertices.emplace_back(quad.x1, quad.y1, z, quad.u1, quad.v1);
+        vertices.emplace_back(quad.x2, quad.y1, z, quad.u2, quad.v1);
+        vertices.emplace_back(quad.x2, quad.y2, z, quad.u2, quad.v2);
+        vertices.emplace_back(quad.x1, quad.y2, z, quad.u1, quad.v2);
+      }
+
+      inline void addColor(const glm::vec4 &color)
+      {
+        colors.emplace_back(color);
+        colors.emplace_back(color);
+        colors.emplace_back(color);
+        colors.emplace_back(color);
+      }
+    };
+  }
+}

common/quad/QuadBatchMap.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "common/quad/QuadBatch.h"
+
+#include <map>
+#include <memory>
+
+namespace chr
+{
+    namespace gl
+    {
+        template<typename T> class QuadBatchMap
+        {
+        public:
+            std::map<T*, std::unique_ptr<QuadBatch>> map;
+            
+            QuadBatchMap() = default;
+            QuadBatchMap(const QuadBatchMap &other) = delete; // QuadBatchMap CAN'T BE COPIED (I.E. BECAUSE OF THE map OF unique_ptr)
+            
+            void clear()
+            {
+                for (auto &it : map)
+                {
+                    it.second->clear();
+                }
+            }
+            
+            void pack()
+            {
+                for (auto it = map.begin(); it != map.end();)
+                {
+                    if (it->second->empty())
+                    {
+                        it = map.erase(it);
+                    }
+                    else
+                    {
+                        it->second->pack();
+                        ++it;
+                    }
+                }
+            }
+
+            QuadBatch* getBatch(T *texture)
+            {
+                auto it = map.find(texture);
+                
+                if (it == map.end())
+                {
+                    auto batch = new QuadBatch;
+                    map.emplace(texture, std::unique_ptr<QuadBatch>(batch));
+                    
+                    return batch;
+                }
+                else
+                {
+                    return it->second.get();
+                }
+            }
+            
+            void flush(const ShaderProgram &shader, Buffer<GLushort> &indexBuffer, bool useColor = false) const
+            {
+                for (auto &it : map)
+                {
+                    it.first->bind(); // RELOADS THE TEXTURE, IF NECESSARY
+                    it.second->flush(shader, indexBuffer, useColor);
+                    it.first->unbind();
+                }
+            }
+        };
+    }
+}