glslprogram.h

#ifndef _MGGLSLPROGRAM_H
#define _MGGLSLPROGRAM_H

class mgStaticGLAttrib;
class MGColor;
class mgGLSLProgram;

#include "mg/MGCL.h"
#include <string>
#include <glm/glm.hpp>
#include <iostream>
namespace mgGLSL{

// function ID
typedef enum {
    Primitive = 0,
    Texture = 11,
    gridTexture=12,
} DrawType;

typedef enum {
    standard=0,
    Select = 1,
    Analysis = 5,
} FuncType;

typedef enum {
    World = 0,
    NdcScreen=2,
    AnchorPoint = 3,
    AnchorPointScreen = 4,
}CoordinateType;

typedef enum {
    NoShading=0,
    Shading=1,
} ShadeMode;

typedef enum {
    ZebraVert = 0,
    ZebraHorizon = 1,
}ZebraType;


MG_DLL_DECLR void setColorAsSelectionName(unsigned name);

MG_DLL_DECLR void printOpenGLError(int errorCode);

MG_DLL_DECLR int checkForOpenGLError(const char*, int);
MG_DLL_DECLR void dumpGLInfo(bool dumpExtensions = false);

// get LightEnable (Shade On/Off)
MG_DLL_DECLR bool LightEnabled();

MG_DLL_DECLR void CALLBACK debugCallback(GLenum source,
                                           GLenum type,
                                           GLuint id,
                                           GLenum severity,
                                           GLsizei length,
                                           const GLchar* message,
                                           void* userParam);

MG_DLL_DECLR void initializeStaticGLAttribStack();
MG_DLL_DECLR std::stack<mgStaticGLAttrib>&  getStaticGLAttribStack();
MG_DLL_DECLR mgStaticGLAttrib& getCurrentStaticGLAttrib();
MG_DLL_DECLR void execStaticGLAttrib(const mgStaticGLAttrib& attrib);
MG_DLL_DECLR void execStaticColorAttrib(const MGColor& color);
MG_DLL_DECLR void execStaticColorAttrib(const float color[4]);
MG_DLL_DECLR void execStaticLineWidth(float lineWidth);
MG_DLL_DECLR void execStaticLineStipple(short int factor, GLuint pattern);
MG_DLL_DECLR void execLightMode(// set Light(Shading On/Off)
    int mode
);

MG_DLL_DECLR void pushStaticGLAttrib();
MG_DLL_DECLR void popStaticGLAttrib();

};



class MG_DLL_DECLR mgFuncTypeSwitcher{
public:
    mgFuncTypeSwitcher(mgGLSL::FuncType type);

    ~mgFuncTypeSwitcher();

private:
    mgGLSLProgram* m_pGLSL;//The current glsl program is save.
    int m_orgFuncType;//The original function type is save.
};



class MG_DLL_DECLR mgGLSLProgram{
public:

     typedef enum{
        VERTEX, FRAGMENT, GEOMETRY,
        TESS_CONTROL, TESS_EVALUATION
    } GLSLShaderType;

    //Vertex attrib変数定義用
    typedef enum {
        vPosition=0,
        vColor,
        vNormal,
        vTextureCoord
    } VertexAttribId;

    union SELECT_NAME{
        unsigned uiName;
        unsigned short usName[2];
        unsigned char ucName[4];//
    };

    mgGLSLProgram();
     ~mgGLSLProgram();

    bool compileShaderFromFile(const char* fileName, GLSLShaderType type);

    bool compileShaderFromString(const std::string& source, GLSLShaderType type);

    void freeProgram();

    bool link();

    void use();

    std::string& log();

    int getHandle();

    bool isLinked();

    void bindAttribLocation( GLuint location, const char * name);

    static void setCurrentGLSLProgram(mgGLSLProgram* glsl);

    static mgGLSLProgram* getCurrentGLSLProgram();

    void bindFragDataLocation( GLuint location, const char * name );

    int getvPositionLocation()const;
    int getvColorLocation()const;
    int getvNormalLocation()const;
    int getvTextureCoordLocation()const;

    // Uniform変数まわり
    GLint getUniformLocation(const char* name)const;
    GLint getUniformLocation(const std::string& name)const{
        return getUniformLocation(name.c_str());
    };

    // Uniformに値をセットする関数群。locが負の値のときはAssertを吐きます。
    // locのチェックを行ったうえでこれらの関数を呼び出してください。
    void setUniform( GLint loc, float x, float y, float z);
    void setUniform( GLint loc, const glm::vec3& v);
    void setUniform( GLint loc, const glm::vec4& v);
    void setUniform( GLint loc, const glm::mat4& m);
    void setUniform( GLint loc, const glm::mat3& m);
    void setUniform( GLint loc, float val);
    void setUniform( GLint loc, int val);
    void setUniform( GLint loc, bool val);

public:
    void printActiveUniforms();
    void printActiveAttribs();


    void EnableLights(bool bEnabled = true);
    bool LightEnabled();


    static const size_t MAX_ATTRIB_LOC = 20;
    //Last name of UNIFORM_ATTRIB_ID must be less than MAX_ATTRIB_LOC.
    typedef enum{
        modelViewProjMatrix=0,  // mat4
        modelViewMatrix,        // mat4
        projMatrix,             // mat4
        normalMatrix,           // mat3 

        ndcMarix,               // mat4
        ndcScaleMatrix,         // mat3
        dpiFactor,              // float

        FuncType,               // draw function(Draw/Select/Zebra Analysis) FuncTypeでEnum定義
        DrawType,               // func typeがDrawのときのみ有効 DrawTypeでEnum定義
        ShaderMode,             // int 0:NoShading 1:Shading

        CoordinateType,         // CoordinateType (World/NDC/AnchorPoint/AnchorPointScreen) CoordinateTypeでEnum定義

        texture2D,              // texture.
        pointSize,              // Vertexの表示サイズ。カーソルなどのPOINT_SPLITE表示に使う

        anchorPoint,            // AnchorPoint。Billboard表示(拡大。縮小してもサイズが変わらない描画)の基準点

        LightTwoSides,          // boolean True:TwoSide, False:片面
        ForceLight,             // falseのときは、有効なLightが無い場合は、NO_SHADINGモードで描画。

        ZebraAxis,              // ゼブラ方向 ZebraTypeで指定
        ZebraSize,              // ゼブラの幅。 ゼブラのステップ刻みは step(0.5f, fract(1.0f / ZebraSize * atan(r.y, r.x)));
    }UniformName;

    void setUniform( UniformName name, float x, float y, float z);
    void setUniform( UniformName name, const glm::vec3& v);
    void setUniform( UniformName name, const glm::vec4& v);
    void setUniform( UniformName name, const glm::mat4& m);
    void setUniform( UniformName name, const glm::mat3& m);
    void setUniform( UniformName name, float val);
    void setUniform( UniformName name, int val);
    void setUniform( UniformName name, bool val);

    // Lightまわり
    static const GLint LIGHT_NUM = 10;
    static const GLint PROP_NUM = 11;

    typedef enum {
        isEnabled=0,    // bool
        ambientColor,   // vec4 ambient Color
        diffuseColor,   // vec4 diffulse color
        specularColor,  // vec4 specular color
        position,       // vec4 position
        spotDirection,  // vec3
        spotExponent,   // float
        spotCutoff,     // float
        constantAttenuation,    // float
        linearAttenuation,      // float
        quadraticAttenuation    // float
    }LightProps;

    void setUniformLights( GLint lightNo, LightProps name, float x, float y, float z);
    void setUniformLights( GLint lightNo, LightProps name, const glm::vec3& v);
    void setUniformLights( GLint lightNo, LightProps name, const glm::vec4& v);
    void setUniformLights( GLint lightNo, LightProps name, const glm::mat4& m);
    void setUniformLights( GLint lightNo, LightProps name, const glm::mat3& m);
    void setUniformLights( GLint lightNo, LightProps name, float val);
    void setUniformLights( GLint lightNo, LightProps name, int val);
    void setUniformLights( GLint lightNo, LightProps name, bool val);

    void setOpenGLVersion();

    void getOpenGLVerion(GLint& major, GLint& minor)const;

    void printPrjMatrix();

    void printLightProps();

    void printLightProps(GLint lightNo);
    
    void setFuncType(mgGLSL::FuncType type);
    int getFuncType();

private:
    int  m_handle;
    GLint m_VersionMajor, m_VersionMinor;
    bool m_linked;
    std::string m_logString;
    static mgGLSLProgram* m_CurrrentGLSL;
    
    GLint m_uniform_locations[MAX_ATTRIB_LOC];

    GLint m_LightPropsIds[LIGHT_NUM][PROP_NUM];

    //m_uniform_locations[]に値をセットする(link()内の処理）
    void build_attribLocations();

    //m_uniform_locationsLights[]に値をセットする(ling()内の処理）
    void build_attribLocationsLight();

    int  getAttribLocation(const char* name)const;
    bool fileExists(const std::string& fileName)const;
};
 // end of DisplayHandling group

#endif // _MGGLSLPROGRAM_H