GLProgram.h

#pragma once
#include <unordered_map>
#include "GLType.h"


namespace ParaEngine
{

    struct _hashUniformEntry;
    class GLProgram;

    typedef void(*GLInfoFunction)(GLuint program, GLenum pname, GLint* params);
    typedef void(*GLLogFunction) (GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog);


    struct VertexAttrib
    {
        GLuint index;
        GLint size;
        GLenum type;
        std::string name;
    };

    struct Uniform
    {
        GLint location;
        GLint size;
        GLenum type;
        std::string name;
    };

    class GLProgram : public CRefCountedOne
    {
        friend class GLProgramState;

    public:
        enum
        {
            VERTEX_ATTRIB_POSITION,
            VERTEX_ATTRIB_COLOR,
            VERTEX_ATTRIB_TEX_COORD,
            VERTEX_ATTRIB_NORMAL,
            VERTEX_ATTRIB_BLEND_WEIGHT,
            VERTEX_ATTRIB_BLEND_INDEX,

            VERTEX_ATTRIB_MAX,

            // backward compatibility
            VERTEX_ATTRIB_TEX_COORDS = VERTEX_ATTRIB_TEX_COORD,
        };

        enum
        {
            UNIFORM_P_MATRIX,
            UNIFORM_MV_MATRIX,
            UNIFORM_MVP_MATRIX,
            UNIFORM_TIME,
            UNIFORM_SIN_TIME,
            UNIFORM_COS_TIME,
            UNIFORM_RANDOM01,
            UNIFORM_SAMPLER0,
            UNIFORM_SAMPLER1,
            UNIFORM_SAMPLER2,
            UNIFORM_SAMPLER3,

            UNIFORM_MAX,
        };

        static const char* SHADER_NAME_POSITION_TEXTURE_COLOR;
        static const char* SHADER_NAME_POSITION_TEXTURE_COLOR_NO_MVP;
        static const char* SHADER_NAME_POSITION_TEXTURE_ALPHA_TEST;
        static const char* SHADER_NAME_POSITION_TEXTURE_ALPHA_TEST_NO_MV;
        static const char* SHADER_NAME_POSITION_COLOR;
        static const char* SHADER_NAME_POSITION_COLOR_NO_MVP;
        static const char* SHADER_NAME_POSITION_TEXTURE;
        static const char* SHADER_NAME_POSITION_TEXTURE_U_COLOR;
        static const char* SHADER_NAME_POSITION_TEXTURE_A8_COLOR;
        static const char* SHADER_NAME_POSITION_U_COLOR;
        static const char* SHADER_NAME_POSITION_LENGTH_TEXTURE_COLOR;

        static const char* SHADER_NAME_LABEL_NORMAL;
        static const char* SHADER_NAME_LABEL_OUTLINE;

        static const char* SHADER_NAME_LABEL_DISTANCEFIELD_NORMAL;
        static const char* SHADER_NAME_LABEL_DISTANCEFIELD_GLOW;

        //3D
        static const char* SHADER_3D_POSITION;
        static const char* SHADER_3D_POSITION_TEXTURE;
        static const char* SHADER_3D_SKINPOSITION_TEXTURE;

        // uniform names
        static const char* UNIFORM_NAME_P_MATRIX;
        static const char* UNIFORM_NAME_MV_MATRIX;
        static const char* UNIFORM_NAME_MVP_MATRIX;
        static const char* UNIFORM_NAME_TIME;
        static const char* UNIFORM_NAME_SIN_TIME;
        static const char* UNIFORM_NAME_COS_TIME;
        static const char* UNIFORM_NAME_RANDOM01;
        static const char* UNIFORM_NAME_SAMPLER0;
        static const char* UNIFORM_NAME_SAMPLER1;
        static const char* UNIFORM_NAME_SAMPLER2;
        static const char* UNIFORM_NAME_SAMPLER3;
        static const char* UNIFORM_NAME_ALPHA_TEST_VALUE;

        // Attribute names
        static const char* ATTRIBUTE_NAME_COLOR;
        static const char* ATTRIBUTE_NAME_POSITION;
        static const char* ATTRIBUTE_NAME_TEX_COORD;
        static const char* ATTRIBUTE_NAME_NORMAL;
        static const char* ATTRIBUTE_NAME_BLEND_WEIGHT;
        static const char* ATTRIBUTE_NAME_BLEND_INDEX;

        GLProgram();
        virtual ~GLProgram();
        static GLProgram* createWithByteArrays(const GLchar* vShaderByteArray, const GLchar* fShaderByteArray);
        bool initWithByteArrays(const GLchar* vShaderByteArray, const GLchar* fShaderByteArray);

        static GLProgram* createWithFilenames(const std::string& vShaderFilename, const std::string& fShaderFilename);
        bool initWithFilenames(const std::string& vShaderFilename, const std::string& fShaderFilename);

        //void bindUniform(std::string uniformName, int value);
        Uniform* getUniform(const std::string& name);
        VertexAttrib* getVertexAttrib(const std::string& name);

        void bindAttribLocation(const std::string& attributeName, GLuint index) const;

        GLint getAttribLocation(const std::string& attributeName) const;

        GLint getUniformLocation(const std::string& attributeName) const;

        bool link();
        void use();
        void updateUniforms();

        GLint getUniformLocationForName(const char* name) const;

        void setUniformLocationWith1i(GLint location, GLint i1);

        void setUniformLocationWith2i(GLint location, GLint i1, GLint i2);

        void setUniformLocationWith3i(GLint location, GLint i1, GLint i2, GLint i3);

        void setUniformLocationWith4i(GLint location, GLint i1, GLint i2, GLint i3, GLint i4);

        void setUniformLocationWith2iv(GLint location, GLint* ints, unsigned int numberOfArrays);

        void setUniformLocationWith3iv(GLint location, GLint* ints, unsigned int numberOfArrays);

        void setUniformLocationWith4iv(GLint location, GLint* ints, unsigned int numberOfArrays);

        void setUniformLocationWith1f(GLint location, GLfloat f1);

        void setUniformLocationWith2f(GLint location, GLfloat f1, GLfloat f2);

        void setUniformLocationWith3f(GLint location, GLfloat f1, GLfloat f2, GLfloat f3);

        void setUniformLocationWith4f(GLint location, GLfloat f1, GLfloat f2, GLfloat f3, GLfloat f4);

        void setUniformLocationWith2fv(GLint location, const GLfloat* floats, unsigned int numberOfArrays);

        void setUniformLocationWith3fv(GLint location, const GLfloat* floats, unsigned int numberOfArrays);

        void setUniformLocationWith4fv(GLint location, const GLfloat* floats, unsigned int numberOfArrays);

        void setUniformLocationWithMatrix2fv(GLint location, const GLfloat* matrixArray, unsigned int numberOfMatrices);

        void setUniformLocationWithMatrix3fv(GLint location, const GLfloat* matrixArray, unsigned int numberOfMatrices);

        void setUniformLocationWithMatrix4fv(GLint location, const GLfloat* matrixArray, unsigned int numberOfMatrices);



        // Attribute

        std::string getVertexShaderLog() const;

        std::string getFragmentShaderLog() const;

        std::string getProgramLog() const;

        // reload all shaders, this function is designed for android
        // when opengl context lost, so don't call it.
        void reset();

        inline const GLuint getProgram() const { return _program; }

        // DEPRECATED
        bool initWithVertexShaderByteArray(const GLchar* vertexByteArray, const GLchar* fragByteArray)
        {
            return initWithByteArrays(vertexByteArray, fragByteArray);
        }
        bool initWithVertexShaderFilename(const std::string &vertexFilename, const std::string& fragFilename)
        {
            return initWithFilenames(vertexFilename, fragFilename);
        }
        void addAttribute(const std::string &attributeName, GLuint index) const { return bindAttribLocation(attributeName, index); }


    protected:
        bool updateUniformLocation(GLint location, const GLvoid* data, unsigned int bytes);


        void bindPredefinedVertexAttribs();
        void parseVertexAttribs();
        void parseUniforms();

        bool compileShader(GLuint * shader, GLenum type, const GLchar* source);
        std::string logForOpenGLObject(GLuint object, GLInfoFunction infoFunc, GLLogFunction logFunc) const;

        GLuint            _program;
        GLuint            _vertShader;
        GLuint            _fragShader;
        GLint             _builtInUniforms[UNIFORM_MAX];
        struct _hashUniformEntry* _hashForUniforms;
        bool              _hasShaderCompiler;



        struct flag_struct {
            unsigned int usesTime : 1;
            unsigned int usesMVP : 1;
            unsigned int usesMV : 1;
            unsigned int usesP : 1;
            unsigned int usesRandom : 1;

            // handy way to initialize the bitfield
            flag_struct() { memset(this, 0, sizeof(*this)); }
        } _flags;

        std::unordered_map<std::string, Uniform> _userUniforms;
        std::unordered_map<std::string, VertexAttrib> _vertexAttribs;
    };
}