设置GLSL


这一节讲述在OpenGL中配置GLSL，假设你已经写好了顶点shader和像素shader。如果你还没有准备好，可以从如下网址获得相关内容：


http://www.3dshaders.com/home/


http://www.opengl.org/sdk/tools/ShaderDesigner/


http://developer.amd.com/archive/gpu/rendermonkey/pages/default.aspx


在OpenGL中，GLSL的shader使用的流程与C语言相似，每个shader类似一个C模块，首先需要单独编译（compile），然后一组编译好的shader连接（link）成一个完整程序。


这里将忽略ARB扩展，只列举OpenGL2.0的代码。建议使用GLEW库：


http://glew.sourceforge.net/

下面的代码检查OpenGL 2.0是否可用：
#include <GL/glew.h>

#include <GL/glut.h>


void main(int argc, char **argv)

{

glutInit(&argc, argv);

...

glewInit();


if (glewIsSupported("GL_VERSION_2_0"))

printf("Ready for OpenGL 2.0\n");

else

{

printf("OpenGL 2.0 not supported\n");

exit(1);

}

setShaders();


glutMainLoop();

}
下图显示了创建shader的必要步骤，函数的具体使用方法将在下面各小结描述：





创建shader
下图显示了创建shader的步骤：


首先创建一个对象作为shader的容器，这个创建函数将返回容器的句柄。

GLuint glCreateShader(GLenum shaderType);

参数：

·shaderType – GL_VERTEX_SHADER or GL_FRAGMENT_SHADER.

你可以创建许多shader，但记住所有的顶点shader只能有一个main函数，所有像素shader也一样。
下一步将添加源代码。shader的源代码是一个字符串数组，添加的语法如下：
void glShaderSource(GLuint shader, int numOfStrings, const char **strings, int *lenOfStrings);

参数：

·shader – the handler to the shader.

·numOfStrings – the number of strings in the array.

·strings – the array of strings.

·lenOfStrings – an array with the length of each string, or NULL, meaning that the strings are NULL terminated.
最后编译shader：
void glCompileShader(GLuint shader);

参数：

•shader – the handler to the shader.

创建程序
下图显示了获得一个可以运行的shader程序的步骤：



首先创建一个对象，作为程序的容器。此函数返回容器的句柄。
GLuint glCreateProgram(void);

你可以创建任意多个程序，在渲染时，可以在不同程序中切换，甚至在某帧返回固定功能流水线。比如你想用折射和反射shader绘制一个茶杯，然后回到固定功能生成立方体环境贴图（cube map）显示背景。
下面将把上一节编译的shader附加到刚刚创建的程序中。方法如下：
void glAttachShader(GLuint program, GLuint shader);

参数：

·program – the handler to the program.

·shader – the handler to the shader you want to attach.
如果同时有顶点shader和片断shader，你需要把它们都附加到程序中。你可以把多个相同类型（顶点或像素）的shader附加到一个程序中，如同一个C程序可以有多个模块一样，但它们只能有一个main函数。
你也可以把一个shader附加到多个程序，比如你想在不同程序中使用某个相同的shader。
最后一步是连接程序。方法如下：
void glLinkProgram(GLuint program);

参数：

·program – the handler to the program.
在连接操作之后，shader的源代码可以被修改并重编译，并不会影响到整个程序。
程序连接后，可以调用glUseProgram来使用程序。每个程序都分配了一个句柄，你可以事先连接多个程序以备使用。
void glUseProgram(GLuint prog);

参数：

·prog – the handler to the program you want to use, or zero to return to fixed functionality.
当一个程序被使用后，如果被再次连接，它将被自动替换并投入使用，所以没有必要再次调用上面这个函数。如果使用的参数为0，表示将使用固定功能流水线。
例子
下面的代码包含了上面描述的所有步骤，参数p,f,v是全局的GLuint型变量。
void setShaders()

{

char *vs,*fs;


v = glCreateShader(GL_VERTEX_SHADER);

f = glCreateShader(GL_FRAGMENT_SHADER); 


vs = textFileRead("toon.vert");

fs = textFileRead("toon.frag");


const char *vv = vs;

const char *ff = fs;


glShaderSource(v, 1, &vv, NULL);

glShaderSource(f, 1, &ff, NULL);


free(vs);free(fs);


glCompileShader(v);

glCompileShader(f);


p = glCreateProgram();


glAttachShader(p, v);

glAttachShader(p, f);


glLinkProgram(p);

glUseProgram(p);

}

错误处理
调试shader是很困难的。目前还没有像printf这样的东西，虽然未来可能出现有调试功能的开发工具。
编译阶段的状态可以用如下函数获得：
void glGetShaderiv(GLuint object, GLenum type, int *param);

参数：

·object – the handler to the object. Either a shader or a program

·type – GL_COMPILE_STATUS.

·param – the return value, GL_TRUE if OK, GL_FALSE otherwise.
连接阶段的状态可以用如下函数获得：
void glGetProgramiv(GLuint object, GLenum type, int *param);

参数：

·object – the handler to the object. Either a shader or a program

·type – GL_LINK_STATUS.

·param – the return value, GL_TRUE if OK, GL_FALSE otherwise.
如果发生错误，就需要从InfoLog中找到更多的信息。这个日志保存了最后一次操作的信息，比如编译时的警告、错误，连接时发生的各种问题。这个日志甚至可以告诉你硬件是否支持你的shader。不幸的是InfoLog没有一个规范，所以不同的驱动/硬件可能产生不同的日志信息。
为了获得特定shader或程序的日志，可以使用如下程序：
void glGetShaderInfoLog(GLuint object, int maxLen, int *len, char *log);

void glGetProgramInfoLog(GLuint object, int maxLen, int *len, char *log);

参数：

·object – the handler to the object. Either a shader or a program

·maxLen – The maximum number of chars to retrieve from the InfoLog.

·len – returns the actual length of the retrieved InfoLog.

·log – The log itself.
GLSL规范有必要在这里进行一些改进：你必须知道接收InfoLog的长度。为了找到这个准确的值，使用下面的函数：
void glGetShaderiv(GLuint object, GLenum type, int *param);

void glGetProgramiv(GLuint object, GLenum type, int *param);

参数：

·object – the handler to the object. Either a shader or a program

·type – GL_INFO_LOG_LENGTH.

·param – the return value, the length of the InfoLog.
下面的函数可以用来打印InfoLog的内容：
void printShaderInfoLog(GLuint obj)

{

int infologLength = 0;

int charsWritten = 0;

char *infoLog;


glGetShaderiv(obj, GL_INFO_LOG_LENGTH,&infologLength);


if (infologLength > 0)

{

infoLog = (char *)malloc(infologLength);

glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog);

printf("%s\n",infoLog);

free(infoLog);

}

} 


void printProgramInfoLog(GLuint obj)

{

int infologLength = 0;

int charsWritten = 0;

char *infoLog;


glGetProgramiv(obj, GL_INFO_LOG_LENGTH,&infologLength);


if (infologLength > 0)

{

infoLog = (char *)malloc(infologLength);

glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog);

printf("%s\n",infoLog);

free(infoLog);

}

}

清理
前面的小节讲到了附加一个shader到一个程序中，这里的调用是将shader从程序中分离：
void glDetachShader(GLuint program, GLuint shader);

参数：

·program – The program to detach from.

·shader – The shader to detach.
注意，只有没有附加到任何程序的shader可以被删除，删除shader和程序的调用如下：
void glDeleteShader(GLuint id);

void glDeleteProgram(GLuint id);

参数：

·id – The hanuler of the shader or program to delete.
如果一个shader还附加在某个程序中，这个shader并不能真正删除，只能标记为删除。当这个shader从所有程序中分离之后，才会被最终删除。

GLSL版本以opengl3.3为分界线，opengl3.3及以上使用的是高版本着色器，以下则是低版本着色器。OSG是兼容OpenGL的所以着色器语言既能用OGL低版本也可以用高版本的。如下使用的两个例子



 1.使用OpenGL高版本着色器（OpenGL4.3） 

2.使用OpenGL低级版本着色器（OpenGL2.X）



 使用OpenGL高版本着色器（OpenGL4.3） 

#include <dtABC/application.h>
#include <dtUtil/nodeprintout.h>

#include <dtCore/object.h>
#include <dtCore/orbitmotionmodel.h>

#include <osg/shader>
#include <osg/Node>
#include <osgDB/ReadFile>
#include <osgDB/fileutils>
#include <osg/Geometry>
#include <osgViewer/viewer>

static char * vertexShader= {
        "#version 430 \n"
        "layout (location=0) in vec3 VertexPosition;\n"
        "layout (location=1) in vec4 VertexColor;\n"
        "uniform mat4 MVP;"
        "out vec4 Color;\n"
        "void main()\n"
        "{\n"
            "   Color = VertexColor;\n"
            "   gl_Position = MVP * vec4(VertexPosition,1.0);\n"
    "   }\n"
};

static char * fragShader ={
        "#version 430 \n"
        "in vec4 Color;\n"
        "layout (location=0) out vec4 FragColor;\n"
        "void main() {\n"
        "   FragColor = Color;//vec4(0.5,0.5,0.5,0.4);\n"
        "}\n"
};
osg::Node *  CreateNode()
{
        osg::Geode * geode = new osg::Geode;
         osg::Geometry* polyGeom = new osg::Geometry();
        osg::Vec3Array* vertices = new osg::Vec3Array();
        vertices->push_back(osg::Vec3(-5,0,0));
        vertices->push_back(osg::Vec3(5,0,0));
        vertices->push_back(osg::Vec3(0,0,5));
        //polyGeom->setVertexArray(vertices);


        osg::ref_ptr<osg::Vec4Array> colorsArray = new osg::Vec4Array;
        colorsArray->push_back(osg::Vec4(1.0f,0.0f,0.0f,1.0f));
        colorsArray->push_back(osg::Vec4(0.0f,0.0f,1.0f,1.0f));
        colorsArray->push_back(osg::Vec4(0.0f,1.0f,0.0f,1.0f));
    //  polyGeom->setColorArray(colorsArray.get());
        //polyGeom->setColorBinding(osg::Geometry::BIND_PER_VERTEX);

        polyGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::TRIANGLES,0,3));

        /*
        The osg::Geometry class uses the setVertexAttribArray() and
        setVertexAttribBinding() methods to bind vertex attributes to shaders. They should
        be provided per vertex. GLSL's built-in vertex attributes include the gl_Position, gl_
        Normal, and gl_MultiTexCoord* variables. However, you may still specify your own
        vertex attributes, such as tangents or vertex weights.
        Try declaring an attribute in the vertex shader and make use of the osg::Geometry's vertex
        attribute arrays. Another important task that you need to perform is to bind the external
        attribute array and the GLSL attribute, with the help of the addBindAttribLocation()
        method of osg::Program. It has a name and an index parameter, the first of which
        indicates the attribute name in the shader source code, and the second should correspond
        to the input index value of setVertexAttribArray().
        */
        polyGeom->setVertexAttribArray(0,vertices);
        polyGeom->setVertexAttribBinding(0, osg::Geometry::BIND_PER_VERTEX);
        polyGeom->setVertexAttribArray(1,colorsArray.get());    
        polyGeom->setVertexAttribBinding(1, osg::Geometry::BIND_PER_VERTEX);

        geode->addDrawable(polyGeom);
        return geode; 
}

class MVPCallback: public osg::Uniform::Callback
{
public:
        MVPCallback(osg::Camera * camera):mCamera(camera){
        }
         virtual void operator()( osg::Uniform* uniform, osg::NodeVisitor* nv){
                 osg::Matrix modelView = mCamera->getViewMatrix();
                 osg::Matrix projectM = mCamera->getProjectionMatrix();
                 uniform->set(modelView * projectM);
         }

private:
        osg::Camera * mCamera;
};
int main(int argc, char *argv[]) {   

        osgViewer::Viewer viewer;

        osg::Group * root = new osg::Group;
        osg::ref_ptr<osg::Node>node = CreateNode();

        osg::StateSet * ss = node->getOrCreateStateSet();
        osg::Program * program = new osg::Program;
        program->addBindFragDataLocation("VertexPosition",0);
        program->addBindFragDataLocation("VertexColor",1);

        osg::Shader * vS = new osg::Shader(osg::Shader::FRAGMENT,fragShader); 
        osg::Shader * fS = new osg::Shader(osg::Shader::VERTEX,vertexShader); 
        osg::Uniform* MVPUniform = new osg::Uniform( "MVP",osg::Matrix());
        MVPUniform->setUpdateCallback(new MVPCallback(viewer.getCamera()));
        ss->addUniform(MVPUniform);//对应的Program和Uniform要加到同一个Node下的StateSet中
        program->addShader(vS);
        program->addShader(fS);
        ss->setAttributeAndModes(program,osg::StateAttribute::ON);

        root->addChild(node); 
        viewer.setSceneData(root);

        viewer.run();

        return 0;
}


 使用OpenGL低级版本着色器（OpenGL2.X） 




#include <osg/Node>
#include <osgViewer/Viewer>
#include <osg/Program>
#include <osgDB/ReadFile>
#include <osg/Shader>
#include <osgViewer/ViewerEventHandlers>


static char * vertexShader = {
    "varying vec4 color;\n"
    "void main(void ){\n"
        "color = gl_Vertex;\n"
        "gl_Position = gl_ModelViewProjectionMatrix*gl_Vertex;\n"
    "}\n"
};
static char * fragShader = {
    "varying vec4 color;\n"
    "void main(void){\n"
    "   gl_FragColor = clamp(color,0.0,1.0);\n"
    "}\n"
};
int main()
{
    osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer;
    osg::ref_ptr<osg::Node>node = osgDB::readNodeFile("glider.osg");


    osg::StateSet * ss = node->getOrCreateStateSet();
    osg::Program * program = new osg::Program;
    program->addShader(new osg::Shader(osg::Shader::FRAGMENT,fragShader));
    program->addShader(new osg::Shader(osg::Shader::VERTEX,vertexShader));
    ss->setAttributeAndModes(program,osg::StateAttribute::ON);

    viewer->addEventHandler(new osgViewer:: WindowSizeHandler);
    viewer->setSceneData(node.get());
    return viewer->run();
}

OpenGL中使用GLSL着色器步骤








    GLSL既适用于顶点着色器，也适用于片段着色器。


使用着色器对象的步骤：


1、创建着色器对象：

   GLuint glCreateShader(GLenum type);

//创建一个着色器对象，type值必须是GL_VERTEX_SHADER或GL_FRAGMENT_SHADER。error返回0

2、把着色器的源码与着色器对象相关联：

    glShaderSource(GLuint shader, GLsizei count, const GLChar** string, const GLint* length);

3、编译着色器对象的源码：

    void glCompileShader(GLuint shader);

   glGetShaderiv(GL_CIMPILE_STATUS);  //查询编译结果

   glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, char* infoLog);

4、创建一个空的着色器程序：

   Gluint glCreateProgram();   //if error, return 0;

5、把着色器对象连接到着色器程序：

   glAttachShader(GLuint program, GLuint shader);   //glDetachShader(program, shader);

6、把连接到着色器程序中的对象链接成一个可执行程序：

   voi glLinkProgram(GLuint program);

   glGetProgramiv(GL_LINK_STATUS);    //查询链接结果， GL_TRUE represent success

   glGetProgramInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, char* infoLog);

7、启动顶点或片段着色器程序：

   void glUseProgram(GLuint program);   //使用程序的对象句柄作为参数

eg:

GLuint shader,program;
GLuint compiled, linked;
const GLchar* shaderSrc[] = {
    "void main(){"
    "   gl_Position = gl_ModelViewProjectionMatrix *gl_Vertex;"
    "}"
};

shader = glCreateShader(GL_VERTEX_SHADER);

glShaderSource(shader, 1, shaderSrc, NULL);
glCompileShader(shader);

glGetShaderInfoLog(shader, GL_COMPILE_STATUS, &compiled);
if(!compiled){
    GLint length;
    GLchar* log;
    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
    log = (GLchar*)malloc(length);
    glGetShaderInfoLog(shader, length, &length, log);
    fprintf(stderr, "compile log = '%s '\n", log);
    free(log);
}

program =glCreateProgram();

glAttachShader(program, shader);
glLinkProgram(program);

glGetProgramiv(program, GL_LINK_STATUS, &linked);

if(linker){
    glUseProgram(program);
}else{
    GLint length;
    GLchar* log;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);

    log = (GLchar*)malloc(length);
    glGetProgramInfoLog(program, length, &length, log);
    fprintf(stderr, "link log = '%s ' \n", log);
    free(log);
}


删除着色器：
    void glDeleteShader(GLuint shader); //若正在被使用，标记为删除，使用完后删除

判断是否是否是有效的着色器程序名：

    GLboolean glIsProgram(GLuint program);  //GL_TRUE

验证一个着色器是否可在当前的OpenGL状态下执行：

    void glValidateProgram(GLuint program);
//若验证通过，GL_VALIDATE_STATUS被设置为GL_TRUE, 调用glGetProgramiv()查询GL_VALIDATE_STATUS的值。

原文是一个GLSL入门教程系列

设置GLSL
这一节讲述在OpenGL中配置GLSL，假设你已经写好了顶点shader和像素shader。如果你还没有准备好，可以从如下网址获得相关内容：
http://www.3dshaders.com/home/
http://www.opengl.org/sdk/tools/ShaderDesigner/
http://developer.amd.com/archive/gpu/rendermonkey/pages/default.aspx
在OpenGL中，GLSL的shader使用的流程与C语言相似，每个shader类似一个C模块，首先需要单独编译（compile），然后一组编译好的shader连接（link）成一个完整程序。
这里将忽略ARB扩展，只列举OpenGL2.0的代码。建议使用GLEW库：
http://glew.sourceforge.net/
下面的代码检查OpenGL 2.0是否可用：
[cpp] view plain copy
#include <GL/glew.h>  
#include <GL/glut.h>  
  
void main(int argc, char **argv)  
{  
    glutInit(&argc, argv);  
    ...  
    glewInit();  
  
    if (glewIsSupported("GL_VERSION_2_0"))  
        printf("Ready for OpenGL 2.0\n");  
    else  
    {  
        printf("OpenGL 2.0 not supported\n");  
        exit(1);  
    }  
    setShaders();  
  
    glutMainLoop();  
}  
下图显示了创建shader的必要步骤，函数的具体使用方法将在下面各小结描述：

创建shader
下图显示了创建shader的步骤：

首先创建一个对象作为shader的容器，这个创建函数将返回容器的句柄。
[cpp] view plain copy
GLuint glCreateShader(GLenum shaderType);  
参数：  
·shaderType – GL_VERTEX_SHADER or GL_FRAGMENT_SHADER.  
你可以创建许多shader，但记住所有的顶点shader只能有一个main函数，所有像素shader也一样。
下一步将添加源代码。shader的源代码是一个字符串数组，添加的语法如下：
[cpp] view plain copy
void glShaderSource(GLuint shader, int numOfStrings, const char **strings, int *lenOfStrings);  
参数：  
·shader – the handler to the shader.  
·numOfStrings – the number of strings in the array.  
·strings – the array of strings.  
·lenOfStrings – an array with the length of each string, or NULL, meaning that the strings are NULL terminated.  
最后编译shader：
[cpp] view plain copy
void glCompileShader(GLuint shader);  
参数：  
•shader – the handler to the shader.  

创建程序
下图显示了获得一个可以运行的shader程序的步骤：

首先创建一个对象，作为程序的容器。此函数返回容器的句柄。
[cpp] view plain copy
GLuint glCreateProgram(void);  
你可以创建任意多个程序，在渲染时，可以在不同程序中切换，甚至在某帧返回固定功能流水线。比如你想用折射和反射shader绘制一个茶杯，然后回到固定功能生成立方体环境贴图（cube map）显示背景。
下面将把上一节编译的shader附加到刚刚创建的程序中。方法如下：
[cpp] view plain copy
void glAttachShader(GLuint program, GLuint shader);  
参数：  
·program – the handler to the program.  
·shader – the handler to the shader you want to attach.  
如果同时有顶点shader和片断shader，你需要把它们都附加到程序中。你可以把多个相同类型（顶点或像素）的shader附加到一个程序中，如同一个C程序可以有多个模块一样，但它们只能有一个main函数。
你也可以把一个shader附加到多个程序，比如你想在不同程序中使用某个相同的shader。
最后一步是连接程序。方法如下：
[cpp] view plain copy
void glLinkProgram(GLuint program);  
参数：  
·program – the handler to the program.  
在连接操作之后，shader的源代码可以被修改并重编译，并不会影响到整个程序。
程序连接后，可以调用glUseProgram来使用程序。每个程序都分配了一个句柄，你可以事先连接多个程序以备使用。
[cpp] view plain copy
void glUseProgram(GLuint prog);  
参数：  
·prog – the handler to the program you want to use, or zero to return to fixed functionality.  
当一个程序被使用后，如果被再次连接，它将被自动替换并投入使用，所以没有必要再次调用上面这个函数。如果使用的参数为0，表示将使用固定功能流水线。
 例子
下面的代码包含了上面描述的所有步骤，参数p,f,v是全局的GLuint型变量。
[cpp] view plain copy
void setShaders()  
{  
    char *vs,*fs;  
  
    v = glCreateShader(GL_VERTEX_SHADER);  
    f = glCreateShader(GL_FRAGMENT_SHADER);    
  
    vs = textFileRead("toon.vert");  
    fs = textFileRead("toon.frag");  
  
    const char *vv = vs;  
    const char *ff = fs;  
  
    glShaderSource(v, 1, &vv, NULL);  
    glShaderSource(f, 1, &ff, NULL);  
  
    free(vs);free(fs);  
  
    glCompileShader(v);  
    glCompileShader(f);  
  
    p = glCreateProgram();  
  
    glAttachShader(p, v);  
    glAttachShader(p, f);  
  
    glLinkProgram(p);  
    glUseProgram(p);  
}  
GLUT版的完整例子如下：
http://lighthouse3d.com/wptest/wp-content/uploads/2011/03/glutglsl_2.0.zip
完整例子中包含了shader代码及文本文件读入程序。
 
错误处理
调试shader是很困难的。目前还没有像printf这样的东西，虽然未来可能出现有调试功能的开发工具。
编译阶段的状态可以用如下函数获得：
[cpp] view plain copy
void glGetShaderiv(GLuint object, GLenum type, int *param);  
参数：  
·object – the handler to the object. Either a shader or a program  
·type – GL_COMPILE_STATUS.  
·param – the return value, GL_TRUE if OK, GL_FALSE otherwise.  
连接阶段的状态可以用如下函数获得：
[cpp] view plain copy
void glGetProgramiv(GLuint object, GLenum type, int *param);  
参数：  
·object – the handler to the object. Either a shader or a program  
·type – GL_LINK_STATUS.  
·param – the return value, GL_TRUE if OK, GL_FALSE otherwise.  
如果发生错误，就需要从InfoLog中找到更多的信息。这个日志保存了最后一次操作的信息，比如编译时的警告、错误，连接时发生的各种问题。这个日志甚至可以告诉你硬件是否支持你的shader。不幸的是InfoLog没有一个规范，所以不同的驱动/硬件可能产生不同的日志信息。
为了获得特定shader或程序的日志，可以使用如下程序：
[cpp] view plain copy
void glGetShaderInfoLog(GLuint object, int maxLen, int *len, char *log);  
void glGetProgramInfoLog(GLuint object, int maxLen, int *len, char *log);  
参数：  
·object – the handler to the object. Either a shader or a program  
·maxLen – The maximum number of chars to retrieve from the InfoLog.  
·len – returns the actual length of the retrieved InfoLog.  
·log – The log itself.  
GLSL规范有必要在这里进行一些改进：你必须知道接收InfoLog的长度。为了找到这个准确的值，使用下面的函数：
[cpp] view plain copy
void glGetShaderiv(GLuint object, GLenum type, int *param);  
void glGetProgramiv(GLuint object, GLenum type, int *param);  
参数：  
·object – the handler to the object. Either a shader or a program  
·type – GL_INFO_LOG_LENGTH.  
·param – the return value, the length of the InfoLog.  
下面的函数可以用来打印InfoLog的内容：
[cpp] view plain copy
void printShaderInfoLog(GLuint obj)  
{  
    int infologLength = 0;  
    int charsWritten  = 0;  
    char *infoLog;  
   
    glGetShaderiv(obj, GL_INFO_LOG_LENGTH,&infologLength);  
   
    if (infologLength > 0)  
    {  
        infoLog = (char *)malloc(infologLength);  
        glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog);  
        printf("%s\n",infoLog);  
        free(infoLog);  
    }  
}   
  
void printProgramInfoLog(GLuint obj)  
{  
    int infologLength = 0;  
    int charsWritten  = 0;  
    char *infoLog;  
   
    glGetProgramiv(obj, GL_INFO_LOG_LENGTH,&infologLength);  
   
    if (infologLength > 0)  
    {  
        infoLog = (char *)malloc(infologLength);  
        glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog);  
        printf("%s\n",infoLog);  
        free(infoLog);  
    }  
}  

清理
前面的小节讲到了附加一个shader到一个程序中，这里的调用是将shader从程序中分离：
[cpp] view plain copy
void glDetachShader(GLuint program, GLuint shader);  
参数：  
·program – The program to detach from.  
·shader – The shader to detach.  
注意，只有没有附加到任何程序的shader可以被删除，删除shader和程序的调用如下：
[cpp] view plain copy
void glDeleteShader(GLuint id);  
void glDeleteProgram(GLuint id);  
参数：  
·id – The hanuler of the shader or program to delete.  
如果一个shader还附加在某个程序中，这个shader并不能真正删除，只能标记为删除。当这个shader从所有程序中分离之后，才会被最终删除。
转载地址: https://blog.csdn.net/racehorse/article/details/6616256
参考:
OpenGL & GLSL 教程（一）
 极客学院 初探 GLSL
OpenGL 初识着色语言