shader.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos 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 3
 * of the License, or (at your option) any later version.
 *
 * xoreos 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 xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef GRAPHICS_SHADER_SHADER_H
#define GRAPHICS_SHADER_SHADER_H

#include <vector>
#include <map>

#include "src/common/ustring.h"
#include "src/common/singleton.h"
#include "src/common/mutex.h"

#include "src/graphics/texture.h"

#include "src/graphics/aurora/texturehandle.h"

#include "src/graphics/shader/shaderbuilder.h"

namespace Graphics {

namespace Shader {

enum ShaderVariableType {
    SHADER_FLOAT = 0,
    SHADER_VEC2,
    SHADER_VEC3,
    SHADER_VEC4,
    SHADER_INT,
    SHADER_IVEC2,
    SHADER_IVEC3,
    SHADER_IVEC4,
    SHADER_UINT,
    SHADER_UVEC2,
    SHADER_UVEC3,
    SHADER_UVEC4,
    SHADER_BOOL,
    SHADER_BVEC2,
    SHADER_BVEC3,
    SHADER_BVEC4,
    SHADER_MAT2,
    SHADER_MAT2X2,
    SHADER_MAT2X3,
    SHADER_MAT2X4,
    SHADER_MAT3,
    SHADER_MAT3X2,
    SHADER_MAT3X3,
    SHADER_MAT3X4,
    SHADER_MAT4,
    SHADER_MAT4X2,
    SHADER_MAT4X3,
    SHADER_MAT4X4,
    SHADER_SAMPLER1D,
    SHADER_SAMPLER2D,
    SHADER_SAMPLER3D,
    SHADER_SAMPLERCUBE,
    SHADER_SAMPLER1DSHADOW,
    SHADER_SAMPLER2DSHADOW,
    SHADER_SAMPLER1DARRAY,
    SHADER_SAMPLER2DARRAY,
    SHADER_SAMPLER1DARRAYSHADOW,
    SHADER_SAMPLER2DARRAYSHADOW,
    SHADER_SAMPLERBUFFER,
    SHADER_ISAMPLER1D,
    SHADER_ISAMPLER2D,
    SHADER_ISAMPLER3D,
    SHADER_ISAMPLERCUBE,
    SHADER_ISAMPLER1DARRAY,
    SHADER_ISAMPLER2DARRAY,
    SHADER_USAMPLER1D,
    SHADER_USAMPLER2D,
    SHADER_USAMPLER3D,
    SHADER_USAMPLERCUBE,
    SHADER_USAMPLER1DARRAY,
    SHADER_USAMPLER2DARRAY,
    SHADER_UNIFORM_BUFFER,
    SHADER_INVALID
};

enum ShaderType {
    SHADER_VERTEX = 0,
    SHADER_FRAGMENT
};

enum ShaderVertexAttrib {
    VERTEX_LOCATION    = 0,
    VERTEX_NORMAL      = 1,
    VERTEX_COLOR       = 2,
    VERTEX_TEXCOORD0   = 3,
    VERTEX_TEXCOORD1   = 4
};

enum ShaderUBOIndex {
    UBO_VIEW_MATRICES = 0,
    UBO_BONE_MATRICES = 1,
    UBO_SCREEN_INFO   = 2
};


struct ShaderUBO {
    GLuint index;
    GLuint glid;
    ShaderUBO() : index(0), glid(0) {}
    ShaderUBO(const ShaderUBO &src) : index(src.index), glid(src.glid) {}
    ShaderUBO(GLuint idx, GLuint gid) : index(idx), glid(gid) {}
    inline const ShaderUBO &operator=(const ShaderUBO &src) { index = src.index; glid = src.glid; return *this; }
};


struct ShaderSampler {
    Texture *texture;
    Graphics::Aurora::TextureHandle handle;
    uint32 unit;
    ShaderSampler() : texture(0), unit(0) {}
    ShaderSampler(Texture *t, uint32 u) : texture(t), unit(u) {}
};


class ShaderObject : public GLContainer {
public:
    struct ShaderObjectVariable {
        ShaderVariableType type;
        uint32 count;  // Number of variables (normally 1, but higher if an array is defined).
        Common::UString name;

        ShaderObjectVariable() : type(SHADER_INVALID), count(0), name() {}
        ShaderObjectVariable(const ShaderObjectVariable &src) : type(src.type), count(src.count), name(src.name) {}
        ShaderObjectVariable(ShaderVariableType t, uint32 cnt, const Common::UString &n) : type(t), count(cnt), name(n) {}

        inline const ShaderObjectVariable &operator=(const ShaderObjectVariable &src) { type = src.type; count = src.count; name = src.name; return *this; }
    };

    ShaderObject();

    uint32 usageCount;
    uint32 id;  // ID unique to a shader within its type (i.e unique across vertex shaders, or unique across fragment shaders). 0 is an invalid id.
    GLuint glid;  // Defaults to zero if not compiled.
    ShaderType type;  // Type of shader (typically vertex or fragment).
    Common::UString shaderString;

    std::vector<ShaderObject::ShaderObjectVariable> variablesSelf;
    std::vector<ShaderObject::ShaderObjectVariable> variablesCombined;
    std::vector<ShaderObject *> subObjects;

protected:
    void doRebuild();
    void doDestroy();
};

class ShaderProgram : public GLContainer {
public:
    ShaderProgram();

    ShaderObject *vertexObject;  // Vertex shader.
    ShaderObject *fragmentObject;  // Fragment shader.
    std::vector<GLint> vertexVariableLocations;
    std::vector<GLint> fragmentVariableLocations;
    uint64 id;  // Set to (vertex.id << 32) | fragment.id
    GLuint glid;
    uint32 usageCount;

    void bindAttribute(ShaderVertexAttrib attrib, const Common::UString &name) {
        glBindAttribLocation(glid, (GLuint)(attrib), name.c_str());
    }

    void queue() {
        addToQueue(kQueueNewShader);
    }

protected:
    void doRebuild();
    void doDestroy();
};

class ShaderManager : public Common::Singleton<ShaderManager> {
public:
    ShaderManager();
    ~ShaderManager();

    void init();
    void deinit();

    ShaderObject *getShaderObject(const Common::UString &name, ShaderType type);
    ShaderObject *getShaderObject(const Common::UString &name, const Common::UString &source, ShaderType type);

    void bindShaderVariable(ShaderObject::ShaderObjectVariable &var, GLint loc, const void *data);
    void bindShaderInstance(ShaderProgram *program, const void **vertexVariables, const void **fragmentVariables);

    ShaderProgram *getShaderProgram(ShaderObject *vertexObject, ShaderObject *fragmentObject);
    ShaderProgram *registerShaderProgram(ShaderObject *vertexObject, ShaderObject *fragmentObject);

    void genShaderVariableList(ShaderObject *obj, std::vector<ShaderObject::ShaderObjectVariable> &vars);

    // Takes a string, and returns the appropriate enum representing that type (e.g "vec4" => SHADER_VEC4).
    ShaderVariableType shaderstringToEnum(const Common::UString &stype);

private:
    void registerShaderAttachment(GLuint progid, ShaderObject *obj);

    void parseShaderVariables(const Common::UString &shaderString, std::vector<ShaderObject::ShaderObjectVariable> &variableList);

public:
    void genGLShader(ShaderObject *object);

    void genGLProgram(ShaderProgram *program);

private:
    uint32 _counterVID;
    uint32 _counterFID;
    std::map<Common::UString, Shader::ShaderObject *> _shaderObjectMap;
    std::vector<Shader::ShaderProgram *> _shaderProgramArray;

    Common::Mutex _shaderMutex;
    Common::Mutex _programMutex;
};

} // End of namespace Shader

} // End of namespace Graphics

#define ShaderMan Graphics::Shader::ShaderManager::instance()

#endif // GRAPHICS_SHADER_SHADER_H