GLSL第一个程序

uniform vec3 lightposition;//光源位置 
uniform vec3 eyeposition;//相机位置 
uniform vec4 ambient;//环境光颜色 
uniform vec4 lightcolor;//光源颜色 
uniform float Ns;//高光系数 
uniform float attenuation;//光线的衰减系数 

varying vec4 color;//向片段着色其传递的参数 

void main() 
{
/*很多示例中都是利用uniform参数从应用程序中向shader里传递当前模型视图矩阵和模型视图投影矩阵，其实对于初学者来说，我们大可以先用GLSL的内建变量：gl_ModelViewMatrix和gl_ModelViewProjectionMatrix代替，而顶点坐标的变换则直接可以利用内建函数ftransform()实现。当然，如果你想自己传递这些参数也是可以的，后面会介绍一下。而gl_Vertex和gl_Normal则分别表示当前传入的顶点的物体坐标系坐标和表面法向量，gl_Position则是用来传输投影坐标系内顶点坐标的内建变量。注意内建变量是不用声明的，直接使用就行*/  
vec3 ECPosition = vec3(gl_ModelViewMatrix * gl_Vertex); 
vec3 N = normalize(gl_NormalMatrix * gl_Normal); 
vec3 L = normalize(lightposition - ECPosition); 
vec3 V = normalize(eyeposition - ECPosition); 
vec3 H = normalize(V + L); 

vec3 diffuse = lightcolor * max(dot(N , L) , 0); 
vec3 specular = lightcolor * pow(max(dot(N , H) , 0) , Ns) * attenuation; 

color = vec4(clamp((diffuse + specular) , 0.0 , 1.0) , 1.0); 
color = color + ambient; 

gl_Position = ftransform(); 
}

 

 

fragmentshader.txt

}

 

 

 

OpenGL代码：

头文件如下：

#pragma once
#include "GLFrame.h"
#include <gl\glew.h>
#include <gl\gl.h>
#include <gl\GLUT.H>
#include <cmath>
#include <iostream>

#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"glu32.lib")
#pragma comment(lib,"glut32.lib")
#pragma comment(lib,"glaux.lib")
#pragma comment(lib,"glew32.lib")
class CGraphics:GLApplication
{
public:
     ~CGraphics(void);
     bool Init();
     void Update(DWORD milliseconds);
     void Uninit();
     void Draw();
     CGraphics(const char * class_name, const char* form_title);

     GLchar* readShaderSource(const char* filename);
     int     installShaders(const GLchar *Vertex,const GLchar *Fragment);

     float m_angle;
private:
     friend class GLApplication;
};

 

实现文件.cpp：

#include "Graphics.h"
#include <gl\gl.h>                                                            /**< 包含OpenGL头文件 */
#include <gl\glu.h>                                                            
#include <gl\glaux.h>                                                       

GLfloat ambient[4] = {1.0 , 0.0 , 0.0 , 1.0}; 
GLfloat lightcolor[4] = {1.0 , 1.0 , 1.0 , 1.0}; 
GLfloat eyeposition[3] = {0.0 , 10.0 , 30.0}; 
GLfloat skycolor[3] = {0.7 , 0.7 , 1.0}; 
GLfloat groundcolor[3] = {0.2 , 0.2 , 0.2}; 
GLfloat Ns = 8; 
GLfloat attenuation = 0.1; 
GLfloat objectSize = 15.0; 
GLuint program; 
GLuint vShader , fShader; 

GLApplication * GLApplication::Create(const char * class_name)
{
     CGraphics * example = new CGraphics(class_name, "小练习-GLSL");
     return reinterpret_cast<GLApplication *>(example);
}

CGraphics::~CGraphics(void)
{
}

CGraphics::CGraphics(const char * class_name,const char* form_title):GLApplication(class_name,form_title)
{
     m_angle=0.0f;
}

bool CGraphics::Init()
{
     glClearColor(0.0f, 0.0f, 0.0f, 0.5f);                              
     glClearDepth(1.0f);                                                       
     glDepthFunc(GL_LEQUAL);                                                  
     glEnable(GL_DEPTH_TEST);                                             
     glShadeModel(GL_SMOOTH);                                             
     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);               

#pragma region 初始化glew
     GLenum err=glewInit();
     if(err!=GLEW_OK)
          MessageBox(NULL,"failed to init glew!","提示",MB_OK);
#pragma endregion

#pragma region 读取顶点着色器和片源着色器源程序
     const GLchar *vShaderSource = readShaderSource("vertexshader.txt"); 
     const GLchar *fShaderSource = readShaderSource("fragmentshader.txt"); 
#pragma endregion

     installShaders(vShaderSource,fShaderSource);
     return true;
}

GLchar* CGraphics::readShaderSource(const char* filename)
{
     GLchar *shader;
     FILE *fp;
     fp=fopen(filename,"rt+");
     if(!fp)
          MessageBox(NULL,"error","提示",MB_OK);
#pragma region 获取文件长度
     rewind(fp);
     fseek(fp,0,SEEK_END);
     int len=ftell(fp);//返回当前文件指针的位置
#pragma endregion
     rewind(fp); //回到文件开头
     fseek(fp,0,SEEK_SET);
     shader=(GLchar*)malloc(sizeof(char)*(len+1));
     memset(shader,0,len+1);
     fread(shader,sizeof(char),len,fp);
     fclose(fp);
     return shader;
}

int CGraphics::installShaders(const GLchar *Vertex, const GLchar *Fragment)
{
    GLint vertCompiled, fragCompiled;    // status values
    GLint linked;
    // Create a vertex shader object and a fragment shader object
    vShader = glCreateShader(GL_VERTEX_SHADER);
    fShader = glCreateShader(GL_FRAGMENT_SHADER);

    // Load source code strings into shaders
    glShaderSource(vShader, 1, (const char **)&Vertex, NULL);
    glShaderSource(fShader, 1, (const char **)&Fragment, NULL);

    // Compile the brick vertex shader, and print out
    // the compiler log file.
    glCompileShader(vShader);
    glGetShaderiv(vShader, GL_COMPILE_STATUS, &vertCompiled);

    // Compile the brick vertex shader, and print out
    // the compiler log file.
    glCompileShader(fShader);
    glGetShaderiv(fShader, GL_COMPILE_STATUS, &fragCompiled);

    if (!vertCompiled || !fragCompiled)
         MessageBox(NULL,"error","提示",MB_OK);

    // Create a program object and attach the two compiled shaders
    program = glCreateProgram();
    glAttachShader(program, vShader);
    glAttachShader(program, fShader);

    // Link the program object and print out the info log
    glLinkProgram(program);

    glGetProgramiv(program, GL_LINK_STATUS, &linked);
    if (!linked)
        MessageBox(NULL,"error","提示",MB_OK);

#pragma region 编译信息,警告或错误(可以注释掉)
    int infologlength;
    int charswrriten;
    char *infolog;
     // Install program object as part of current state
    glGetShaderiv(vShader,GL_INFO_LOG_LENGTH,&infologlength);
    infolog=(char*)malloc(infologlength);
    glGetShaderInfoLog(vShader,infologlength,&charswrriten,infolog);
    MessageBox(NULL,infolog,"提示",MB_OK);
    glGetShaderiv(fShader,GL_INFO_LOG_LENGTH,&infologlength);
    infolog=(char*)malloc(infologlength);
    glGetShaderInfoLog(fShader,infologlength,&charswrriten,infolog);
    MessageBox(NULL,infolog,"提示",MB_OK);
#pragma endregion
   //以上的代码被注释起来，作用是获得shader编译后的错误报告，用于调试，由于已经调试成功，这里就不需要这些代码了
    return 1;
}

void CGraphics::Draw()
{
     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
     
     /*这里是程序比较重要的地方：向给shader中的uniform变量赋值。注意赋值函数使用的位置，只有当一个program启用的时候，里面的uniform变量才会被分配索引，所以过早的对uniform变量赋值会长生错误。同时注意函数的格式*/ 
     glUseProgram(program); 
     glUniform3f(glGetUniformLocation(program , "lightposition") , 30.0 , 30.0 , 30.0); 
     glUniform3f(glGetUniformLocation(program , "eyeposition") , eyeposition[0] , eyeposition[1] , eyeposition[2]); 
     glUniform4f(glGetUniformLocation(program , "ambient") , ambient[0] , ambient[1] , ambient[2] , ambient[3]); 
     glUniform4f(glGetUniformLocation(program , "lightcolor") , lightcolor[0] , lightcolor[1] , lightcolor[2] , lightcolor[3]); 
     glUniform1f(glGetUniformLocation(program , "Ns") , Ns); 
     glUniform1f(glGetUniformLocation(program , "attenuation") , attenuation); 
     /*刚开始我以为要利用shader进行渲染就要必须将模型变为一个一个顶点信息向shader中传入，但其实并不是这样，我们同样可以利用glut的内建模型或者自己动手载入模型，和平时一样。同时注意一点，glut的一些内建模型只包含平面法线，没有纹理坐标，所以在后面我们给模型添加纹理的时候有些就无法显示出纹理*/ 
     glPushMatrix();
          glTranslatef(0.0f,0.0f,-50.0f);
          glRotated(m_angle,0.0f,1.0f,0.0f);
          glutSolidTeapot(objectSize);
     glPopMatrix();
}

void CGraphics::Uninit()
{

}

void CGraphics::Update(DWORD milliseconds)
{
     m_angle=m_angle+0.5f;
     if (m_angle>=1440.0f)
     {
          m_angle=0.0f;
     }
}