StelQGLGLSLShader.hpp

/*
 * Stellarium
 * Copyright (C) 2012 Ferdinand Majerech
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _STELQGLGLSLSHADER_HPP_
#define _STELQGLGLSLSHADER_HPP_

#include <QGLShader>
#include <QGLShaderProgram>
#include <QMap>
#include <QtOpenGL>

#include "StelGLSLShader.hpp"
#include "StelGLUtilityFunctions.hpp"


typedef float RAW_GL_MATRIX [4][4];

class StelQGLGLSLShader : public StelGLSLShader
{
private:
    struct OptionalShader
    {
        bool enabled;
        QGLShader* shader;
    };

    enum State
    {
        State_Unlocked,
        State_Modified,
        State_Built,
    };

    enum UniformType
    {
        UniformType_none  = 0,
        UniformType_float = 1,
        UniformType_vec2  = 2,
        UniformType_vec3  = 3,
        UniformType_vec4  = 4,
        UniformType_mat4  = 5,
        UniformType_bool  = 6,
        UniformType_int   = 7,
        UniformType_max   = 8
    };

    static const unsigned int UNIFORM_STORAGE = 512;

    static const int MAX_UNIFORMS = 32;

    static int UNIFORM_SIZES[UniformType_max];

public:
    StelQGLGLSLShader(class StelQGL2Renderer* renderer, bool internal);

    virtual ~StelQGLGLSLShader()
    {
        Q_ASSERT_X(!bound, Q_FUNC_INFO,
                   "Forgot to release() a bound shader before destroying");
        foreach(QGLShader* shader, defaultVertexShaders)  {delete shader;}
        foreach(OptionalShader shader, namedVertexShaders){delete shader.shader;}
        foreach(QGLShader* shader, defaultFragmentShaders){delete shader;}
        foreach(QGLShaderProgram* program, programCache)  {delete program;}
    }

    virtual bool addVertexShader(const QString& source);
    
    virtual bool addFragmentShader(const QString& source);

    virtual bool build();

    virtual QString log() const
    {
        return aggregatedLog + ((NULL == program) ? QString() : program->log());
    }

    virtual void unlock()
    {
        switch(state)
        {
            case State_Unlocked:
            case State_Modified:
                return;
            case State_Built:
                state = State_Unlocked;
                return;
        }
    }

    virtual bool addVertexShader(const QString& name, const QString& source);

    virtual bool hasVertexShader(const QString& name) const
    {
        return namedVertexShaders.contains(name);
    }

    virtual void enableVertexShader(const QString& name)
    {
        Q_ASSERT_X(namedVertexShaders.contains(name), Q_FUNC_INFO, 
                   "Trying to enable a vertex shader with an unknown name");
        Q_ASSERT_X(state == State_Unlocked || state == State_Modified, Q_FUNC_INFO, 
                   "Can't enable a vertex shader after the shader has been built");

        OptionalShader& shader(namedVertexShaders[name]);
        if(shader.enabled) {return;}
        shader.enabled = true;
        state = State_Modified;
    }

    virtual void disableVertexShader(const QString& name)
    {
        Q_ASSERT_X(namedVertexShaders.contains(name), Q_FUNC_INFO, 
                   "Trying to disable a vertex shader with an unknown name");
        Q_ASSERT_X(state == State_Unlocked || state == State_Modified, Q_FUNC_INFO, 
                   "Can't disable a vertex shader after the shader has been built");

        OptionalShader& shader(namedVertexShaders[name]);
        if(!shader.enabled) {return;}
        shader.enabled = false;
        state = State_Modified;
    }

    virtual void bind();

    virtual void release();

    virtual void useUnprojectedPositionAttribute()
    {
        useUnprojectedPosition_ = true;
    }

    QGLShaderProgram& getProgram()
    {
        Q_ASSERT_X(bound && state == State_Built,
                   Q_FUNC_INFO, "Trying to use an unbound shader for drawing");
        return *program;
    }

    bool useUnprojectedPosition() const
    {
        return useUnprojectedPosition_;
    }

    void uploadUniforms()
    {
        Q_ASSERT_X(bound && state == State_Built, Q_FUNC_INFO, 
                   "uploadUniforms called on a shader that is not bound");
        void * const * data = uniformStorage;
        for (int u = 0; u < uniformCount; u++) 
        {
            const UniformType type = static_cast<UniformType>(uniformTypes[u]);
            switch(type)
            {
                case UniformType_float:
                {
                    const float& value(*reinterpret_cast<const float* const>(data));
                    program->setUniformValue(uniformNames[u], value);
                    break;
                }
                case UniformType_vec2:
                {
                    const Vec2f& v(*reinterpret_cast<const Vec2f* const>(data));
                    program->setUniformValue(uniformNames[u], v[0], v[1]);
                    break;
                }
                case UniformType_vec3:
                {
                    const Vec3f& v(*reinterpret_cast<const Vec3f* const>(data));
                    program->setUniformValue(uniformNames[u], v[0], v[1], v[2]);
                    break;
                }
                case UniformType_vec4:
                {
                    const Vec4f& v(*reinterpret_cast<const Vec4f* const>(data));
                    program->setUniformValue(uniformNames[u], v[0], v[1], v[2], v[3]);
                    break;
                }
                case UniformType_mat4:
                {
                    const RAW_GL_MATRIX& m(*reinterpret_cast<const RAW_GL_MATRIX* const>(data));
                    program->setUniformValue(uniformNames[u], m);
                    break;
                }
                case UniformType_bool:
                {
                    const bool& value(*reinterpret_cast<const bool* const>(data));
                    program->setUniformValue(uniformNames[u], value);
                    break;
                }
                case UniformType_int:
                {
                    const int& value(*reinterpret_cast<const int* const>(data));
                    program->setUniformValue(uniformNames[u], value);
                    break;
                }
                default:
                    Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown or invalid uniform type");
            }
            data += UNIFORM_SIZES[type];
        }
    }

    void pushUniformStorage()
    {
        Q_ASSERT_X(bound && state == State_Built, Q_FUNC_INFO,
                   "pushUniformStorage() called when the shader is not bound");
        Q_ASSERT_X(uniformStorageStackSize < MAX_UNIFORMS - 1, Q_FUNC_INFO,
                   "Too many uniform storage stack pushes");
        uniformStorageUsedStack[uniformStorageStackSize] = uniformStorageUsed;
        uniformCountStack[uniformStorageStackSize]       = uniformCount;
        ++uniformStorageStackSize;
    }

    void popUniformStorage()
    {
        Q_ASSERT_X(bound && state == State_Built, Q_FUNC_INFO,
                   "popUniformStorage() called when the shader is not bound");
        Q_ASSERT_X(uniformStorageStackSize >= 1, Q_FUNC_INFO,
                   "Too many uniform storage stack pops (nothing left to pop)");
        --uniformStorageStackSize;
        uniformStorageUsed    = uniformStorageUsedStack[uniformStorageStackSize];
        uniformCount       = uniformCountStack[uniformStorageStackSize];
    }

    void clearUniforms()
    {
        Q_ASSERT_X(bound && state == State_Built, Q_FUNC_INFO,
                   "clearUniforms() called when the shader is not bound");
        // We don't zero out the storage - we'll overwrite it as we add new uniforms.
        uniformStorageUsed = uniformCount = uniformStorageStackSize = 0;
    }

protected:
    class StelQGL2Renderer* renderer;

    QVector<QGLShader*> defaultVertexShaders;

    QMap<QString, OptionalShader> namedVertexShaders;

    // There are no namedFragmentShaders, but they can be added if/when needed.
    QVector<QGLShader*> defaultFragmentShaders;

    QMap<uintptr_t, QGLShaderProgram*> programCache;

    QGLShaderProgram* program;

    QString aggregatedLog;

    State state;

    bool bound;

    bool useUnprojectedPosition_;

    const bool internal;

    void* uniformStorage [UNIFORM_STORAGE / sizeof(void*)];

    unsigned char uniformTypes [MAX_UNIFORMS];   

    const char* uniformNames [MAX_UNIFORMS];

    int uniformStorageUsed;

    int uniformCount;

    unsigned int uniformStorageUsedStack[MAX_UNIFORMS];

    unsigned char uniformCountStack[MAX_UNIFORMS];

    int uniformStorageStackSize;

    void* setUniformValue_helper(const char* const name, const enum UniformType kind)
    {
        Q_ASSERT_X(bound, Q_FUNC_INFO,
                   "Trying to set a uniform value with an unbound shader");
        Q_ASSERT_X(uniformCount < MAX_UNIFORMS, Q_FUNC_INFO, "Too many uniforms");
        Q_ASSERT_X((unsigned)(uniformStorageUsed + UNIFORM_SIZES[kind]) < (UNIFORM_STORAGE / sizeof uniformStorage[0]), Q_FUNC_INFO,
                   "Uniform storage exceeded");
        void* ret = static_cast<void*>(&uniformStorage[uniformStorageUsed]);
        uniformNames[uniformCount] = name;
        uniformTypes[uniformCount++] = kind;
        uniformStorageUsed += UNIFORM_SIZES[kind];
        return ret;
    }

    virtual void setUniformValue_(const char* const name, const float value)
    {
        *static_cast<float*>(setUniformValue_helper(name, UniformType_float)) = value;
    }

    virtual void setUniformValue_(const char* const name, const Vec2f value)
    {
        *static_cast<Vec2f*>(setUniformValue_helper(name, UniformType_vec2)) = value;
    }

    virtual void setUniformValue_(const char* const name, const Vec3f& value)
    {
        *static_cast<Vec3f*>(setUniformValue_helper(name, UniformType_vec3)) = value;
    }

    virtual void setUniformValue_(const char* const name, const Vec4f& value)
    {
        *static_cast<Vec4f*>(setUniformValue_helper(name, UniformType_vec4)) = value;
    }

    virtual void setUniformValue_(const char* const name, const Mat4f& m)
    {
        *static_cast<Mat4f*>(setUniformValue_helper(name, UniformType_mat4)) = m;
    }

    virtual void setUniformValue_(const char* const name, const bool value)
    {
        *static_cast<bool*>(setUniformValue_helper(name, UniformType_bool)) = value;
    }

    virtual void setUniformValue_(const char* const name, const int value)
    {
        *static_cast<int*>(setUniformValue_helper(name, UniformType_int)) = value;
    }

private:
    QGLShaderProgram* getProgramFromCache();

    QGLShader* createVertexShader(const QString& source);
};

#endif // _STELQGLGLSLSHADER_HPP_