ShaderManager.hpp

/*
 * Stellarium Scenery3d Plug-in
 *
 * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
 *
 * 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 _SHADERMANAGER_HPP_
#define _SHADERMANAGER_HPP_
#include "OBJ.hpp"
#include "StelOpenGL.hpp"
#include "S3DEnum.hpp"

#include <QMap>

class QOpenGLShaderProgram;

struct GlobalShaderParameters
{
    bool openglES; //true if we work with an OGL ES2 context, may have to adapt shaders
    bool shadowTransform;
    bool pixelLighting;
    bool bump;
    bool shadows;
    S3DEnum::ShadowFilterQuality shadowFilterQuality;
    bool pcss;
    bool geometryShader;
    bool torchLight;
    //for now, only 1 or 4 really supported
    int frustumSplits;
    bool hwShadowSamplers;
};

class ShaderMgr
{
public:
    ShaderMgr();
    ~ShaderMgr();

    enum ATTLOC
    {
        ATTLOC_VERTEX,
        ATTLOC_NORMAL,
        ATTLOC_TEXCOORD,
        ATTLOC_TANGENT,
        ATTLOC_BITANGENT
    };

    enum UNIFORM
    {
        UNIFORM_MAT_MODELVIEW,
        UNIFORM_MAT_PROJECTION,
        UNIFORM_MAT_MVP,
        UNIFORM_MAT_NORMAL,
        UNIFORM_MAT_SHADOW0,
        UNIFORM_MAT_SHADOW1,
        UNIFORM_MAT_SHADOW2,
        UNIFORM_MAT_SHADOW3,
        UNIFORM_MAT_CUBEMVP,

        UNIFORM_TEX_DIFFUSE,
        UNIFORM_TEX_EMISSIVE,
        UNIFORM_TEX_BUMP,
        UNIFORM_TEX_HEIGHT,
        UNIFORM_TEX_SHADOW0,
        UNIFORM_TEX_SHADOW1,
        UNIFORM_TEX_SHADOW2,
        UNIFORM_TEX_SHADOW3,

        UNIFORM_MTL_SHININESS,
        UNIFORM_MTL_ALPHA,

        UNIFORM_MIX_AMBIENT,
        UNIFORM_MIX_DIFFUSE,
        UNIFORM_MIX_SPECULAR,
        UNIFORM_MIX_TORCHDIFFUSE,
        UNIFORM_MIX_EMISSIVE,

        UNIFORM_LIGHT_DIRECTION_VIEW,
        UNIFORM_TORCH_ATTENUATION,

        UNIFORM_VEC_COLOR,
        UNIFORM_VEC_SPLITDATA,
        UNIFORM_VEC_LIGHTORTHOSCALE,
        UNIFORM_FLOAT_ALPHA_THRESH,
    };

    inline QOpenGLShaderProgram* getShader(const GlobalShaderParameters &globals, const OBJ::Material *mat = NULL);

    inline QOpenGLShaderProgram* getDebugShader();

    inline QOpenGLShaderProgram* getCubeShader();

    inline QOpenGLShaderProgram* getTextureShader();

    inline GLint uniformLocation(const QOpenGLShaderProgram* shad,UNIFORM uni);

    void clearCache();

private:
    typedef QMap<QString,UNIFORM> t_UniformStrings;
    static t_UniformStrings uniformStrings;

    //A Bitflag enum which contains features that shaders can implement, and which this manager can dynamically select
    enum FeatureFlags
    {
        INVALID     = 0,
        //Transform-only shader (all flags off) (use for depth-only render), should be mutually exclusive with SHADING
        TRANSFORM   = (1<<0),
        //The shader has some sort of light-dependent color output, should be mutually exclusive with TRANSFORM
        SHADING     = (1<<1),
        //Per-pixel lighting
        PIXEL_LIGHTING  = (1<<2),
        //Shader applies shadows from shadow maps
        SHADOWS         = (1<<3),
        //Shader applies bump/normal maps
        BUMP            = (1<<4),
        //Shader applies height maps (in addition to bump map)
        HEIGHT          = (1<<5),
        //Shader applies alpha testing (w. fragment discard)
        ALPHATEST   = (1<<6),
        //Shader filters shadows
        SHADOW_FILTER   = (1<<7),
        //shader filters shadows (higher quality)
        SHADOW_FILTER_HQ = (1<<8),
        //uses specular material
        MAT_SPECULAR    = (1<<9),
        //has diffuse texture. On its own (i.e. esp. without SHADING) it defines the basic texture shader.
        MAT_DIFFUSETEX  = (1<<10),
        //has emissive texture
        MAT_EMISSIVETEX = (1<<11),
        //needs geometry shader cubemapping
        GEOMETRY_SHADER = (1<<12),
        //shader performs cubemap lookup
        CUBEMAP     = (1<<13),
        //shader performs blending, otherwise it is expected to output alpha 1.0
        //it is required for correct blending for our cubemapping
        BLENDING    = (1<<14),
        //shader uses an additional point light positioned at the camera that performs additional diffuse illumination
        TORCH       = (1<<15),
        //debug shader for AABBs/Frustums
        DEBUG       = (1<<16),
        //PCSS shadow filtering
        PCSS        = (1<<17),
        //only a single shadow frustum is used
        SINGLE_SHADOW_FRUSTUM  = (1<<18),
        //set if opengl es2
        OGL_ES2     = (1<<19),
        //true if shadow samplers (shadow2d) should be used for shadow maps instead of normal samplers (texture2d)
        HW_SHADOW_SAMPLERS = (1<<20)
    };

    typedef QMap<QString,FeatureFlags> t_FeatureFlagStrings;
    static t_FeatureFlagStrings featureFlagsStrings;

    QString getVShaderName(uint flags);
    QString getGShaderName(uint flags);
    QString getFShaderName(uint flags);
    QOpenGLShaderProgram* findOrLoadShader(uint flags);
    bool preprocessShader(const QString& fileName, const uint flags, QByteArray& processedSource);
    //compiles and links the shader with this specified source code
    bool loadShader(QOpenGLShaderProgram& program, const QByteArray& vShader, const QByteArray& gShader, const QByteArray& fShader);
    void buildUniformCache(QOpenGLShaderProgram& program);

    typedef QHash<uint,QOpenGLShaderProgram*> t_ShaderCache;
    t_ShaderCache m_shaderCache;

    typedef QHash<QByteArray,QOpenGLShaderProgram*> t_ShaderContentCache;
    t_ShaderContentCache m_shaderContentCache;

    typedef QHash<UNIFORM,GLuint> t_UniformCacheEntry;
    typedef QHash<const QOpenGLShaderProgram*, t_UniformCacheEntry> t_UniformCache;
    t_UniformCache m_uniformCache;
};

QOpenGLShaderProgram* ShaderMgr::getShader(const GlobalShaderParameters& globals,const OBJ::Material* mat)
{
    //Build bitflags from bools. Some stuff requires pixelLighting to be enabled, so check it too.

    uint flags = INVALID;
    if(globals.openglES) flags|=OGL_ES2;
    if(!globals.shadowTransform)
    {
        flags |= SHADING;
        if(globals.pixelLighting)            flags|= PIXEL_LIGHTING;
        if(globals.pixelLighting && globals.shadows) flags|= SHADOWS;
        if(globals.pixelLighting && globals.shadows && globals.shadowFilterQuality>S3DEnum::SFQ_HARDWARE) flags|= SHADOW_FILTER;
        if(globals.pixelLighting && globals.shadows && globals.shadowFilterQuality>S3DEnum::SFQ_LOW_HARDWARE) flags|= SHADOW_FILTER_HQ;
        if(globals.pixelLighting && globals.shadows && !globals.hwShadowSamplers && (globals.shadowFilterQuality == S3DEnum::SFQ_LOW || globals.shadowFilterQuality == S3DEnum::SFQ_HIGH) && globals.pcss) flags|= PCSS;
        if(globals.hwShadowSamplers) flags|=HW_SHADOW_SAMPLERS;
        if(globals.geometryShader) flags|= GEOMETRY_SHADER;
        if(globals.torchLight) flags|= TORCH;
        if(globals.frustumSplits == 1) flags|= SINGLE_SHADOW_FRUSTUM;
    }
    else
    {
        flags |= TRANSFORM;
    }

    if(mat)
    {
        if(mat->alphatest && mat->texture && mat->texture->hasAlphaChannel()) //alpha test needs diffuse texture, otherwise it would not make sense
            flags|= ALPHATEST;
        if(mat->hasSpecularity)
            flags|= MAT_SPECULAR;
        if(mat->hasTransparency)
            flags|= BLENDING;
        if(mat->texture)
            flags|= MAT_DIFFUSETEX;
        if(mat->emissive_texture)
            flags|= MAT_EMISSIVETEX;
        if(mat->bump_texture && globals.bump && globals.pixelLighting)
            flags|= BUMP;
        if(mat->height_texture && globals.bump && globals.pixelLighting)
            flags|= HEIGHT;
    }

    return findOrLoadShader(flags);
}

QOpenGLShaderProgram* ShaderMgr::getDebugShader()
{
    return findOrLoadShader(DEBUG);
}

QOpenGLShaderProgram* ShaderMgr::getCubeShader()
{
    return findOrLoadShader(CUBEMAP);
}

QOpenGLShaderProgram* ShaderMgr::getTextureShader()
{
    return findOrLoadShader(MAT_DIFFUSETEX);
}

GLint ShaderMgr::uniformLocation(const QOpenGLShaderProgram *shad, UNIFORM uni)
{
    t_UniformCache::iterator it = m_uniformCache.find(shad);
    if(it!=m_uniformCache.end())
    {
        return it.value().value(uni,-1);
    }
    return -1;
}

#endif