shapeRenderer.h

Go to the documentation of this file.

#ifndef SHAPERENDERER_H
#define SHAPERENDERER_H
 
#include <jGL/shape.h>
#include <jGL/shader.h>
#include <jGL/priorityStore.h>
 
#include <unordered_map>
#include <map>
#include <string>
#include <iterator>
#include <vector>
#include <algorithm>
 
#include <chrono>
 
namespace jGL
{
 
    typedef std::string ShapeId;
 
    class ShapeRenderer : public PriorityStore<Shape>
    {
 
    public:
 
        struct UpdateInfo
        {
            UpdateInfo()
            : xytheta(true), scale(true), colour(true)
            {}
 
            bool xytheta, scale, colour;
        };
 
        ShapeRenderer(size_t sizeHint = 8)
        : PriorityStore(sizeHint), shader(nullptr)
        {}
 
        ShapeRenderer(std::shared_ptr<Shader> shader, size_t sizeHint = 8)
        : PriorityStore(sizeHint), shader(shader)
        {}
 
        Shape & getShape(ShapeId id) { return this->operator[](id); }
 
        const Transform * getTransform(ShapeId id) { return getShape(id).transform; }
        const glm::vec4 * getColour(ShapeId id) { return getShape(id).colour; }
 
        virtual void draw
        (
            std::shared_ptr<Shader> shader,
            std::multimap<RenderPriority,ShapeId> & ids,
            UpdateInfo info = UpdateInfo()
        )
        {
            std::vector<std::pair<Info, Shape>> shapes = vectorise(ids);
            draw(shader, shapes, info);
        }
 
        virtual void draw
        (
            std::multimap<RenderPriority, ShapeId> & ids,
            UpdateInfo info = UpdateInfo()
        )
        {
            std::vector<std::pair<Info, Shape>> shapes = vectorise(ids);
            draw(shader, shapes, info);
        }
 
        virtual void draw
        (
            std::shared_ptr<Shader> shader,
            UpdateInfo info = UpdateInfo()
        )
        {
            draw(shader, cache, info);
        }
 
        virtual void draw
        (
            UpdateInfo info = UpdateInfo()
        )
        {
            draw(shader, cache, info);
        }
 
        bool hasId(const ShapeId id) const { return idToElement.find(id) != idToElement.end(); }
 
        virtual void setProjection(glm::mat4 p) {projection = p;}
 
    protected:
 
        virtual void draw
        (
            std::shared_ptr<Shader> shader,
            std::vector<std::pair<Info, Shape>> & shapes,
            UpdateInfo info = UpdateInfo()
        ) = 0;
 
        std::shared_ptr<Shader> shader;
 
        glm::mat4 projection = glm::mat4(0.0f);
 
    };
}
 
#endif /* SHAPERENDERER_H */