GLSL记录(1)-实时旋转的三角形

    main.cpp:

#include <iostream>
#include"shadertool.h"
#include"glm/glm.hpp"
//using namespace std;
#include"glm/gtc/matrix_transform.hpp"

using glm::mat4;
using glm::vec3;

#define PI 3.1415926

GLuint vaoHandle;
GLuint programHandle;
float angle = 30.0f * PI/180.0f;//转换为弧度制

//we create and populate the vertex buffer objects for each attribute
float positionData[] = {
-0.8f, -0.8f, .0f,
0.8f, -0.8f, 0.0f,
0.0f, 0.8f, 0.0f
};

float colorData[] = {
1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f
};

void changeSize(int w,int h)
{
if(h==0)
{
h=1;
}
float ratio=1.0*w/h;

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glViewport(0,0,w,h);
gluPerspective(45,ratio,1,1000);
glMatrixMode(GL_MODELVIEW);
}

void renderScene(void)
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
angle += 0.01f;
mat4 rotationMatrix = glm::rotate( mat4(1.0f),angle,vec3(0.0f,0.0f,1.0f));
GLuint location = glGetUniformLocation( programHandle, "RotationMatrix");
if(location >= 0)
{
//printf("yes...........\n");
glUniformMatrix4fv( location, 1, GL_FALSE, &rotationMatrix[0][0]);
}
else
{
printf("no...........\n");
}

//in the render func,we bind to the vertex array obj and call glDrawArrays to initiate rendering
glBindVertexArray(vaoHandle);
glDrawArrays(GL_TRIANGLES,0,3);
glutSwapBuffers();
}

void processNormalKeys(unsigned char key,int x,int y)
{
if(key==27)
{
exit(0);
}
}

void setShaders()
{
char* vs_code = LoadShaderFromFile("z_basic.vert");
char* fs_code = LoadShaderFromFile("z_basic.frag");

GLuint v = glCreateShader(GL_VERTEX_SHADER);//create shader obj,返回一个handle
GLuint f = glCreateShader(GL_FRAGMENT_SHADER);

const char* ff = fs_code;
const char* vv = vs_code;
/*
load the source code into shader obj,第三个参数可以是一个字符串数组，可以载入多个文件string
第二个参数是表示string array 的size,one string ,so 1.
最后一个参数表示each source code string is terminated by a null character.
一旦这个函数返回后，表明source code 已经被成功加载在opengl的内部内存，因此，之前的用来存储shader code的字符串变量
可以被释放掉了
*/
glShaderSource(v,1,&vv,NULL);
glShaderSource(f,1,&ff,NULL); //
//free the source code
free(vs_code);
free(fs_code);
//next step:
//compile shader and log error
CompileShader(v,0);
CompileShader(f,1);
//final step : shaders must be linked togehter into a shader program object.
programHandle = glCreateProgram();//create a empty program obj

glAttachShader(programHandle,f);
glAttachShader(programHandle,v);
//link.can use glGetProgramiv to query status(GL_TRUE/GL_FALSE)->glGetProgramiv(GL_LINK_STATUS)
glLinkProgram(programHandle);
//install the program into the opengl pipeline
glUseProgram(programHandle);
//

}
void InitGL(int argc,char* argv[])
{
//
glutInit(&argc,argv); //初始化glut,必须调用，复制黏贴这句话即可
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE ); //设置显示方式，RGB、双缓冲
glutInitWindowPosition(100,100); //位置
glutInitWindowSize(400,400);//窗口大小
glutCreateWindow("GLSL FUN!"); //创建窗口，设置标题
glutDisplayFunc(renderScene); // 当绘制窗口时调用myDisplay
glutIdleFunc(renderScene);
glutReshapeFunc(changeSize);
glutKeyboardFunc(processNormalKeys);
glEnable(GL_DEPTH_TEST);
glClearColor(1.0,1.0,1.0,1.0);//清除颜色设置为白色，这样glclear后面clear color就用白色clear
glewInit();
//

//1.创建
//create and populate the buffer objects
GLuint vboHandles[2];
glGenBuffers(2, vboHandles);
GLuint positionBufferHandle = vboHandles[0];
GLuint colorBufferHandle = vboHandles[1];
//2.
//populate the position buffer
glBindBuffer( GL_ARRAY_BUFFER, positionBufferHandle);
glBufferData( GL_ARRAY_BUFFER, 9 * sizeof(float), positionData, GL_STATIC_DRAW);
//populate color buffer
glBindBuffer( GL_ARRAY_BUFFER, colorBufferHandle);
//最后一个参数告诉我们这个数据是用来干嘛的，static表示不能再被修改
glBufferData( GL_ARRAY_BUFFER, 9 * sizeof(float), colorData, GL_STATIC_DRAW);
//3.create and set up the vertex array objects
glGenVertexArrays(1, &vaoHandle);
glBindVertexArray( vaoHandle );
//enable the vertex attribute arrays
glEnableVertexAttribArray(0);//vertex position
glEnableVertexAttribArray(1);//vertex color
//map index 0 to the position buffer
glBindBuffer( GL_ARRAY_BUFFER, positionBufferHandle);
glVertexAttribPointer(0,3,GL_FLOAT, GL_FALSE, 0 ,NULL);
//map index 1 to the color buffer
glBindBuffer(GL_ARRAY_BUFFER, colorBufferHandle);
glVertexAttribPointer(1,3,GL_FLOAT, GL_FALSE, 0 ,NULL);

}

int main(int argc,char* argv[])
{

//1.
InitGL(argc,argv);
//2.
setShaders();
//3.
// LogGLVersion();
glutMainLoop(); //消息循环
//

//check gl version

return 0;
}
着色器：
z_basic.vert:

#version 430
/*
the main opengl program refers to vertex attributes by associating each input variable with a generic attribute index.
those index are simply integers between 0 and GL_MAX_VERTEX_ATTRIBS - 1.
we can specify the relationship between these indices and the attributes using the layout qualifier.
*/
//input
layout (location=0) in vec3 VertexPosition;
layout (location=1) in vec3 VertexColor;
//output
out vec3 Color;

/*
uniform variables are uintended to used for data that may change relatively infrequently compared to per-vertex attributes.
uniform variables are well suited for the matrics used for modeling , viewing, and projective transformations.
*/
uniform mat4 RotationMatrix;

void main()
{
Color = VertexColor;
gl_Position = RotationMatrix * vec4 ( VertexPosition, 1.0);
}z_basic.frag:
#version 430

in vec3 Color;

layout (location = 0) out vec4 FragColor;

void main()

{

    FragColor = vec4(Color, 1.0);

}

shadertool.cpp:

#include"shadertool.h"

char* LoadShaderFromFile( char* fileName)
{
FILE *fp;
char* content = NULL;
int count= 0;
if( fileName != NULL)
{
fp = fopen(fileName,"rt");
if(fp != NULL)
{
fseek( fp, 0, SEEK_END);
count = ftell(fp);
rewind(fp);
if(count > 0)
{
content = (char*)malloc( sizeof(char)*(count + 1));
count = fread(content,sizeof(char),count,fp);
content[count] = '\0';
}
fclose(fp);
}
}
return content;
}
//compile shader and if error log it.
void CompileShader(GLuint s,int type)
{

glCompileShader(s); //编译shader
//get compile info and log it
GLint result;
//query compile status info by call this func.
glGetShaderiv( s, GL_COMPILE_STATUS, &result);
//if false , query the shader log
if( GL_FALSE == result)
{
if(type == 0 )
fprintf(stderr,"vertex shader compile failed\n");
else fprintf(stderr,"fragment shader compile failed\n");
GLint logLen;
glGetShaderiv( s, GL_INFO_LOG_LENGTH,&logLen);
if( logLen > 0)
{
char* log = new char[ logLen ];
GLsizei written;
glGetShaderInfoLog(s,logLen, &written, log);
fprintf( stderr, "shader log : \n%s",log);
delete[] log;//free the memeory
}
else
{
fprintf( stderr, "log length <= 0");
}

}

}
void LogGLVersion()
{
const GLubyte *renderer = glGetString(GL_RENDERER);
const GLubyte *vendor = glGetString(GL_VENDOR);
const GLubyte *version = glGetString(GL_VERSION);
const GLubyte *glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION);
GLint major, minor;
glGetIntegerv(GL_MAJOR_VERSION, &major);
glGetIntegerv(GL_MINOR_VERSION, &minor);

printf("GL Vendor :%s\n",vendor);
printf("GL Render :%s\n",renderer);
printf("GL Version string :%s\n",version);
printf("GL Version int :%d.%d\n",major,minor);
printf("GLSL Version :%s\n",glslVersion);
}


效果：