PrimitiveBatch.h

#ifndef PRIMITIVEBATCH_H_INCLUDED
#define PRIMITIVEBATCH_H_INCLUDED
 
#include "nta/SpriteBatch.h"
 
namespace nta {
    struct Primitive {
        Primitive(){}
        Primitive(const std::initializer_list<Vertex2D>& verts,
                  GLuint texID, float d) : depth(d), textureID(texID) {
            vertices.insert(vertices.begin(), verts.begin(), verts.end());
        }
        template<class Iterator>
        Primitive(Iterator first, Iterator last, GLuint texID, float d) : depth(d), textureID(texID) {
            vertices.insert(vertices.begin(), first, last);
        }
        Primitive(std::size_t numSides, crvec2 center, float sideLength,
                  crvec4 color, float orientation, float d) : depth(d), textureID(0) {
            std::vector<Vertex2D> verts;
            float theta = 2.*M_PI/numSides;
            float a = sideLength/glm::sqrt(2.-2.*glm::cos(theta));
            for (std::size_t i = 0; i < numSides; i++) {
                float angle = i*theta + orientation;
                glm::vec2 translate(glm::cos(angle), glm::sin(angle));
                verts.emplace_back(a * translate + center, color);
            }
            vertices.insert(vertices.begin(), std::begin(verts), std::end(verts));
        }
        ~Primitive() {
            depth = 0;
            textureID = 0;
            vertices.clear();
        }
        float depth;
        GLuint textureID;
        std::vector<Vertex2D> vertices;
    };
    class PrimitiveBatch {
    private:
        void createVertexArrayObject();
        void createRenderBatches();
        void sortPrimitives();
        static bool compareTexture(Primitive* lhs, Primitive* rhs);
        static bool comparePrimitive(Primitive* lhs, Primitive* rhs);
        static bool compareDepth(Primitive* lhs, Primitive* rhs);
        GLenum toPrimitiveType(unsigned int numVertices) const;
        std::vector<Primitive*> m_primitives;
        std::vector<RenderBatch> m_renderBatches;
        GLuint m_vao = 0;
        GLuint m_vbo = 0;
    public:
        PrimitiveBatch();
        ~PrimitiveBatch();
        int numPrimitives() const;
        void init();
        void begin();
        void end();
        void addPrimitive(Primitive* primitive);
        void addPrimitive(const std::initializer_list<Vertex2D>& vertices,
                          GLuint textureID = -1, float depth = NTA_DEFAULT_DEPTH);
        template<class Iterator>
        void addPrimitive(Iterator first, Iterator last, GLuint textureID = -1, 
                          float depth = NTA_DEFAULT_DEPTH);
        void addPrimitive(std::size_t numSides, crvec2 center = glm::vec2(0), float sideLength = 1.0,
                          crvec4 color = glm::vec4(1), float orientation = 0., 
                          float depth = NTA_DEFAULT_DEPTH);
        void render() const;
    };
    typedef PrimitiveBatch PrimBatch;
 
    template<class Iterator>
    void PrimitiveBatch::addPrimitive(Iterator first, Iterator last, GLuint textureID, float depth) {
        addPrimitive(new Primitive(first, last, textureID, depth));
    }
}
 
#endif // PRIMITIVEBATCH_H_INCLUDED