renderpass.h

#ifndef RENDERPASS_H
#define RENDERPASS_H

#include <QOpenGLFunctions>

#define SI_POSITION 0
#define SI_ELLIPSE_U 1
#define SI_ELLIPSE_V 2
#define SI_COLOR 3

#define GL Globals::gl

class RenderPass {
public:
    RenderPass();

    virtual ~RenderPass();

    virtual void render() = 0;

    virtual void cleanup() = 0;

    virtual void updateResolution() = 0;

    virtual void removeInput() = 0;

    static void cleanupHelpers();
protected:
    static bool loadShader(std::string &path, GLuint id);
    static bool noGlErrors();
    static bool checkFbo();
    static void drawUnitQuad();
private:
    static GLuint unitQuadVao, unitQuadVbo;

    static bool textFileRead(std::string &file, std::string &into);
    static void printInfoLog(GLint id, bool program);
    static void generateUnitQuad();

    class Channel {
    public:
        Channel();
        virtual ~Channel();

        bool isActive();

        void setActive(bool active);

        void registerAsReceiver();

        void unregisterAsReceiver();
    private:
        unsigned char receiverCounter;
        bool active;
    };
protected:
    template<class C> bool helperMultiChannelContains(std::list<C*> &list, C &channel) {
        std::list<C*>::iterator iter = list.begin();
        while (iter != list.end()) {
            if (*iter == &channel)
                return true;
            ++iter;
        }
        return false;
    }
    template<class C> void helperMultiChannelAdd(std::list<C*> &list, C &channel) {
        if (channel.isActive() && !helperMultiChannelContains(list, channel)) {
            list.push_back(&channel);
            channel.registerAsReceiver();
        }
    }
    template<class C> bool helperMultiChannelRemove(std::list<C*> &list, C &channel) {
        std::list<C*>::iterator iter = list.begin();
        while (iter != list.end()) {
            if (*iter == &channel) {
                channel.unregisterAsReceiver();
                list.erase(iter);
                return true;
            }
            ++iter;
        }
        return false;
    }
    template<class C> void helperMultiChannelClean(std::list<C*> &list) {
        std::list<C*>::iterator iter = list.begin();
        while (iter != list.end()) {
            if (!(*iter)->isActive()) {
                (*iter)->unregisterAsReceiver();
                iter = list.erase(iter);
            } else
                ++iter;
        }
    }
    template<class C> void helperMultiChannelClear(std::list<C*> &list) {
        std::list<C*>::iterator iter = list.begin();
        while (iter != list.end()) {
            (*iter)->unregisterAsReceiver();
            ++iter;
        }
        list.clear();
    }

public:
    class VaoChannel: public Channel {
    public:
        struct vao {
            GLuint id, size;
            QMatrix4x4 *modelMat;
        };

        VaoChannel(vao sentVao);

        vao *getVao();
    private:
        vao sentVao;
    };

    class TextureChannel: public Channel {
    public:
        TextureChannel();
        ~TextureChannel();

        GLuint getID();

        void reserveTexture(unsigned int x, unsigned int y, bool floatPrecision);

        void reserveDepthTexture(unsigned int x, unsigned int y);

        void freeTexture();
    private:
        GLuint id;
    };
};

#endif // RENDERPASS_H