Shader.h

Go to the documentation of this file.

//Luke Lenhart, 2010
//See /docs/License.txt for details on how this code may be used.

#pragma once

#include "../base/Setup.h"

#ifdef MPMA_COMPILE_GFX

#include "../base/Types.h"
#include "../base/ReferenceCount.h"
#include "../base/File.h"
#include "../gfxsetup/GL.h"
#include "../gfxsetup/Extensions.h"
#include <string>
#include <vector>

#ifdef MPMA_COMPILE_GEO
    #include "../geo/Geo.h"
#endif

namespace GFX
{
    class UniformVariable
    {
    public:
        inline operator GLint() const { return location; }

        inline bool Exists() const { return location!=-1; }

        inline void SetFloat1(float f0) { glUniform1fARB(*this, f0); } 
        inline void SetFloat2(float f0, float f1) { glUniform2fARB(*this, f0, f1); } 
        inline void SetFloat3(float f0, float f1, float f2) { glUniform3fARB(*this, f0, f1, f2); } 
        inline void SetFloat4(float f0, float f1, float f2, float f3) { glUniform4fARB(*this, f0, f1, f2, f3); } 

        inline void SetFloat1(const float *f, GLsizei arrayCount=1) { glUniform1fvARB(*this, arrayCount, f); } 
        inline void SetFloat2(const float *f, GLsizei arrayCount=1) { glUniform2fvARB(*this, arrayCount, f); } 
        inline void SetFloat3(const float *f, GLsizei arrayCount=1) { glUniform3fvARB(*this, arrayCount, f); } 
        inline void SetFloat4(const float *f, GLsizei arrayCount=1) { glUniform4fvARB(*this, arrayCount, f); } 

        inline void SetInt1(int i0) { glUniform1iARB(*this, i0); } 
        inline void SetInt2(int i0, int i1) { glUniform2iARB(*this, i0, i1); } 
        inline void SetInt3(int i0, int i1, int i2) { glUniform3iARB(*this, i0, i1, i2); } 
        inline void SetInt4(int i0, int i1, int i2, int i3) { glUniform4iARB(*this, i0, i1, i2, i3); } 

        inline void SetInt1(const int *i, GLsizei arrayCount=1) { glUniform1ivARB(*this, arrayCount, i); } 
        inline void SetInt2(const int *i, GLsizei arrayCount=1) { glUniform2ivARB(*this, arrayCount, i); } 
        inline void SetInt3(const int *i, GLsizei arrayCount=1) { glUniform3ivARB(*this, arrayCount, i); } 
        inline void SetInt4(const int *i, GLsizei arrayCount=1) { glUniform4ivARB(*this, arrayCount, i); } 

        inline void SetMatrix2x2(const float *m, bool transpose=false, GLsizei arrayCount=1) { glUniformMatrix2fvARB(*this, arrayCount, transpose, m); } 
        //inline void SetMatrix2x3(const float *m, bool transpose=false, GLsizei arrayCount=1) { glUniformMatrix2x3fvARB(*this, arrayCount, transpose, m); } //may enable later
        //inline void SetMatrix2x4(const float *m, bool transpose=false, GLsizei arrayCount=1) { glUniformMatrix2x4fvARB(*this, arrayCount, transpose, m); } //may enable later
        //inline void SetMatrix3x2(const float *m, bool transpose=false, GLsizei arrayCount=1) { glUniformMatrix3x2fvARB(*this, arrayCount, transpose, m); } //may enable later
        inline void SetMatrix3x3(const float *m, bool transpose=false, GLsizei arrayCount=1) { glUniformMatrix3fvARB(*this, arrayCount, transpose, m); } 
        //inline void SetMatrix3x4(const float *m, bool transpose=false, GLsizei arrayCount=1) { glUniformMatrix3x4fvARB(*this, arrayCount, transpose, m); } //may enable later
        //inline void SetMatrix4x2(const float *m, bool transpose=false, GLsizei arrayCount=1) { glUniformMatrix4x2fvARB(*this, arrayCount, transpose, m); } //may enable later
        //inline void SetMatrix4x3(const float *m, bool transpose=false, GLsizei arrayCount=1) { glUniformMatrix4x3fvARB(*this, arrayCount, transpose, m); } //may enable later
        inline void SetMatrix4x4(const float *m, bool transpose=false, GLsizei arrayCount=1) { glUniformMatrix4fvARB(*this, arrayCount, transpose, m); } 

        inline void SetTextureStage(int stage) { SetInt1(stage); }
        
#ifdef MPMA_COMPILE_GEO
        inline void SetVector2(const GEO::Vector2 &v) { SetFloat2(&v[0]); } 
        inline void SetVector3(const GEO::Vector3 &v) { SetFloat3(&v[0]); } 
        inline void SetVector4(const GEO::Vector4 &v) { SetFloat4(&v[0]); } 

        inline void SetMatrix2x2(const GEO::Matrix2 &m, bool transpose=false) { SetMatrix2x2(&m[0][0], transpose); } 
        inline void SetMatrix3x3(const GEO::Matrix3 &m, bool transpose=false) { SetMatrix3x3(&m[0][0], transpose); } 
        inline void SetMatrix4x4(const GEO::Matrix4 &m, bool transpose=false) { SetMatrix4x4(&m[0][0], transpose); } 
#endif

    private:
        inline UniformVariable(GLint loc): location(loc) {}

        GLint location;
        friend class ShaderProgram;
    };

    // --

    struct ShaderCodeData
    {
        GLuint object;
        std::vector<MPMA::Filename> origFilenames;
        std::string compileMessages;

        inline ShaderCodeData(): object(0)
        {}
    };

    class ShaderCode: public MPMA::ReferenceCountedData<ShaderCodeData>
    {
    public:
        virtual ~ShaderCode();

        bool Create(GLenum shaderType); //<!GL_VERTEX_SHADER, GL_FRAGMENT_SHADER, or GL_GEOMETRY_SHADER_EXT

        void Free();

        bool Compile(GLenum shaderType, const std::string &code);
        bool Compile(GLenum shaderType, const std::vector<std::string> &codes);

        bool CompileFile(GLenum shaderType, const MPMA::Filename &file);
        bool CompileFiles(GLenum shaderType, const std::vector<MPMA::Filename> &files);

        inline const std::string& GetCompileMessages() const { return Data().compileMessages; }

        inline operator GLuint() const { return Data().object; }

    private:
        bool CompileInternal(const std::vector<std::string> &codes);
    };

    // --

    struct ShaderProgramData
    {
        GLuint object;
        std::string linkMessages;

        inline ShaderProgramData(): object(0)
        {}
    };

    class ShaderProgram: public MPMA::ReferenceCountedData<ShaderProgramData>
    {
    public:
        virtual ~ShaderProgram();

        bool Create();
        void Free();

        void AttachShader(const ShaderCode &code);
        void DetatchShader(const ShaderCode &code);
        bool Link();

        bool CreateAndLink(const std::vector<ShaderCode> &codes);
        bool CreateAndLink(const ShaderCode *codes, nuint count);

        inline const std::string& GetLinkMessages() const { return Data().linkMessages; }

        inline void Bind()
        {
            glUseProgram(*this);
        }

        inline void Unbind()
        {
            glUseProgram(0);
        }

        inline UniformVariable FindVariable(const std::string &name)
        {
            return UniformVariable(glGetUniformLocationARB(*this, name.c_str()));
        }

        inline operator GLuint() const { return Data().object; }
    };

    class AutoBindShaderProgram
    {
    public:
        inline AutoBindShaderProgram(ShaderProgram &shaderToBind): prog(shaderToBind) { prog.Bind(); }
        inline ~AutoBindShaderProgram() { prog.Unbind(); }

    private:
        ShaderProgram &prog;

        //prevent copying
        AutoBindShaderProgram(const AutoBindShaderProgram &o);
        bool operator=(const AutoBindShaderProgram &o);
    };
}

#endif //#ifdef MPMA_COMPILE_GFX