// ***********************************************************************
// ***********************************************************************
//
// Print out the information log for a program object
//
static void printProgramInfoLog(GLuint program) {
int infologLength = 0;
int charsWritten = 0;
GLchar *infoLog;
printOpenGLError(); // Check for OpenGL errors
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infologLength);
printOpenGLError(); // Check for OpenGL errors
if (infologLength > 0)
{
infoLog = (GLchar *)malloc(infologLength);
if (infoLog == NULL)
{
printf("ERROR: Could not allocate InfoLog buffer\n");
exit(1);
}
glGetProgramInfoLog(program, infologLength, &charsWritten, infoLog);
printf("Program InfoLog:\n%s\n\n", infoLog);
free(infoLog);
}
printOpenGLError(); // Check for OpenGL errors
}
static void DS_Flush()
{
glUseProgram(DS_Shader);
glUniform2f(DS_ScreenSize, Game_Width, Game_Height);
glEnableVertexAttribArray(DS_Attribute_Pos);
glEnableVertexAttribArray(DS_Attribute_Color);
glVertexAttribPointer(DS_Attribute_Pos, 3,
GL_FLOAT, false,
0, DS_Vertices);
glVertexAttribPointer(DS_Attribute_Color, 4,
GL_FLOAT, false,
0, DS_VerticesColor);
glDrawArrays(GL_TRIANGLES, 0, DS_Vertices_Count);
printOpenGLError();
glDisableVertexAttribArray(DS_Attribute_Pos);
glDisableVertexAttribArray(DS_Attribute_Color);
glUseProgram(0);
printOpenGLError();
DS_Vertices_Count = 0;
}
/////////////////////////////////////////////////////////////////////////////
// Print out the information log for a shader object.
/////////////////////////////////////////////////////////////////////////////
static void printShaderInfoLog( GLuint shader )
{
int infologLength = 0;
int charsWritten = 0;
GLchar *infoLog;
printOpenGLError(); // Check for OpenGL errors.
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infologLength);
printOpenGLError(); // Check for OpenGL errors.
if (infologLength > 0)
{
infoLog = (GLchar *)malloc(infologLength);
if (infoLog == NULL)
{
printf("ERROR: Could not allocate InfoLog buffer.\n");
exit(1);
}
glGetShaderInfoLog(shader, infologLength, &charsWritten, infoLog);
if (strlen(infoLog) > 0) printf("Shader InfoLog:\n%s\n\n", infoLog);
free(infoLog);
}
printOpenGLError(); // Check for OpenGL errors.
}
void Obj3D::CreateVBO()
{
Vertex cubeVerts[] =
{
// Front face, bot left CW
{ { -.5f, -.5f, .5f, 1 }, { 0, 0, 1, 1 } },
{ { -.5f, .5f, .5f, 1 }, { 1, 0, 0, 1 } },
{ { .5f, .5f, .5f, 1 }, { 0, 1, 0, 1 } },
{ { .5f, -.5f, .5f, 1 }, { 1, 1, 0, 1 } },
// Back, bot left clockwise
{ { -.5f, -.5f, -.5f, 1 }, { 1, 1, 1, 1 } },
{ { -.5f, .5f, -.5f, 1 }, { 1, 0, 0, 1 } },
{ { .5f, .5f, -.5f, 1 }, { 1, 0, 1, 1 } },
{ { .5f, -.5f, -.5f, 1 }, { 0, 0, 1, 1 } }
};
// defines the order to draw vertices in
GLuint cubeIndices[] = {
0,2,1, 0,3,2,
4,3,0, 4,7,3,
4,1,5, 4,0,1,
3,6,2, 3,7,6,
1,6,5, 1,2,6,
7,5,6, 7,4,5
};
glUseProgram(m_renderInfo.ProgramId);
// Vertex array object (creates a place to store vertices)
glGenVertexArrays(1, &m_renderInfo.VaoId);
glBindVertexArray(m_renderInfo.VaoId);
printOpenGLError();
// Enables vertex shader attributes for use
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
// creates a buffer object to transfer vertices data to vertex array
// then buffers the data
glGenBuffers(1, &m_renderInfo.VboId);
glBindBuffer(GL_ARRAY_BUFFER, m_renderInfo.VboId);
glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVerts), cubeVerts, GL_STATIC_DRAW);
printOpenGLError();
// defines the data we just transferred to the gpu
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(cubeVerts[0]), (GLvoid*)0);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(cubeVerts[0]),
(GLvoid*)sizeof(cubeVerts[0].Position));
printOpenGLError();
// Determines the draw order of the vertices we transferred to gpu
glGenBuffers(1, &m_renderInfo.IndexBufferId);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_renderInfo.IndexBufferId);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cubeIndices), cubeIndices, GL_STATIC_DRAW);
printOpenGLError();
// Detaches vertex array
glBindVertexArray(0);
glUseProgram(0);
}
void XGLShader::printInfoLog(GLhandleARB obj)
{
int infologLength = 0;
int charsWritten = 0;
GLcharARB *infoLog;
printOpenGLError(); // Check for OpenGL errors
glGetObjectParameterivARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB,
(GLint*)&infologLength);
printOpenGLError(); // Check for OpenGL errors
if (infologLength > 0)
{
infoLog = (GLcharARB*)malloc(infologLength);
if (infoLog == NULL)
{
printf("ERROR: Could not allocate InfoLog buffer\n");
exit(1);
}
glGetInfoLogARB(obj, infologLength, (GLint*)&charsWritten, infoLog);
printf("InfoLog:\n%s\n\n", infoLog);
free(infoLog);
}
printOpenGLError(); // Check for OpenGL errors
}
void GLTexture::release()
{
printOpenGLError();
if(m_id > 0)
glDeleteTextures(1, &m_id );
printOpenGLError();
}
/* Print out the information log for a program object */
static void
printProgramInfoLog (GLuint program)
{
GLint infologLength = 0;
GLint charsWritten = 0;
char *infoLog;
printOpenGLError (); // Check for OpenGL errors
glGetProgramiv (program, GL_INFO_LOG_LENGTH, &infologLength);
printOpenGLError (); // Check for OpenGL errors
if (infologLength > 0)
{
infoLog = new char [infologLength];
if (infoLog == NULL)
{
debugOut( "ERROR: Could not allocate InfoLog buffer");
return;
}
glGetProgramInfoLog (program, infologLength, &charsWritten, infoLog);
debugOut( "Program InfoLog:\n%s\n\n", infoLog);
delete[] infoLog;
}
printOpenGLError (); // Check for OpenGL errors
}
void play(void)
{
updateAnim();
printOpenGLError();
glutPostRedisplay();
printOpenGLError();
}
// On successful return, the returned program object ID can be
// used to install the program as part of current state
// using glUseProgram(). Example:
//
// GLuint prog = makeShaderProgram( vertShaderStr, fragShaderStr,
// myBindAttribLocFunc );
// if ( prog != 0 )
// {
// glUseProgram( prog );
//
// // Set values of uniform variables only
// // after the prog has become current.
// glUniform3f( getUniLoc(prog, "LightPosition"), 10.0, 10.0, 15.0 );
// printOpenGLError();
// glUniform1f( getUniLoc(prog, "Density"), 16.0 );
// printOpenGLError();
// }
//
// Use glUseProgram(0) to restore the original vertex processing
// and fragement processing fixed functionalities.
//
/////////////////////////////////////////////////////////////////////////////
GLuint makeShaderProgram( const GLchar *vertShaderSrcStr,
const GLchar *fragShaderSrcStr,
void (*bindAttribLocFunc)( GLuint progObj ) )
{
GLuint vShader = 0, fShader = 0, prog = 0; // handles to objects.
GLint vCompiled, fCompiled; // status values.
GLint linked;
// Create and compile the vertex shader object.
if ( vertShaderSrcStr != NULL )
{
vShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vShader, 1, &vertShaderSrcStr, NULL);
glCompileShader(vShader);
printOpenGLError(); // Check for OpenGL errors.
glGetShaderiv(vShader, GL_COMPILE_STATUS, &vCompiled);
printShaderInfoLog(vShader);
if (!vCompiled ) return 0;
}
// Create and compile the fragment shader object.
if ( fragShaderSrcStr != NULL )
{
fShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fShader, 1, &fragShaderSrcStr, NULL);
glCompileShader(fShader);
printOpenGLError(); // Check for OpenGL errors.
glGetShaderiv(fShader, GL_COMPILE_STATUS, &fCompiled);
printShaderInfoLog(fShader);
if (!fCompiled ) return 0;
}
// Create a program object and attach the two compiled shaders.
prog = glCreateProgram();
if ( vertShaderSrcStr != NULL ) glAttachShader(prog, vShader);
if ( fragShaderSrcStr != NULL ) glAttachShader(prog, fShader);
// Flag shaders for deletion.
// They will only be actually deleted when the program object is deleted.
glDeleteShader(vShader);
glDeleteShader(fShader);
// If bindAttribLocFunc != NULL, then
// use a user-provided function to assign generic attribute
// locations/indicses to generic attribute names,
// otherwise, just let the linker do the assignment automatically.
if ( bindAttribLocFunc != NULL ) bindAttribLocFunc( prog );
// Link the program object.
glLinkProgram(prog);
printOpenGLError(); // Check for OpenGL errors.
glGetProgramiv(prog, GL_LINK_STATUS, &linked);
printProgramInfoLog(prog);
if (!linked) return 0;
return prog;
}
// ***********************************************************************
// ***********************************************************************
int installShaders( const GLchar *shVertex,
const GLchar *shFragment,
const int id) {
GLint vertCompiled;
GLint fragCompiled; // status values
// Create a vertex shader object and a fragment shader object
shaderVS = glCreateShader(GL_VERTEX_SHADER);
shaderFS = glCreateShader(GL_FRAGMENT_SHADER);
// Load source code strings into shaders
glShaderSource(shaderVS, 1, &shVertex, NULL);
glShaderSource(shaderFS, 1, &shFragment, NULL);
// Compile the vertex shader, and print out
// the compiler log file.
glCompileShader(shaderVS);
printOpenGLError(); // Check for OpenGL errors
glGetShaderiv(shaderVS, GL_COMPILE_STATUS, &vertCompiled);
printShaderInfoLog(shaderVS);
// Compile the fragment shader, and print out
// the compiler log file.
glCompileShader(shaderFS);
printOpenGLError(); // Check for OpenGL errors
glGetShaderiv(shaderFS, GL_COMPILE_STATUS, &fragCompiled);
printShaderInfoLog(shaderFS);
if (!vertCompiled || !fragCompiled)
return 0;
// Create a program object and attach the two compiled shaders
shaderProg[id] = glCreateProgram();
glAttachShader(shaderProg[id], shaderVS);
glAttachShader(shaderProg[id], shaderFS);
// Link the program object and print out the info log
glLinkProgram(shaderProg[id]);
printOpenGLError(); // Check for OpenGL errors
glGetProgramiv(shaderProg[id], GL_LINK_STATUS, &linked);
printProgramInfoLog(shaderProg[id]);
if (!linked)
return 0;
// Install program object as part of current state
glUseProgram(shaderProg[id]);
return 1;
}
int buildShaders (const char *vertexShader, const char *fragmentShader)
{
GLuint VS, FS, prog;
GLint vertCompiled, fragCompiled;
GLint linked;
// Create Shader Objects
VS = glCreateShader(GL_VERTEX_SHADER);
FS = glCreateShader(GL_FRAGMENT_SHADER);
// Load source code strings into shaders
glShaderSource(VS, 1, &vertexShader, NULL);
glShaderSource(FS, 1, &fragmentShader, NULL);
debugOut("Compiling vertex shader... \n");
// Compile vertex shader and print log
glCompileShader(VS);
printOpenGLError();
glGetShaderiv(VS, GL_COMPILE_STATUS, &vertCompiled);
printShaderInfoLog (VS);
debugOut("\nCompiling fragment shader... \n");
// Compile fragment shader and print log
glCompileShader(FS);
printOpenGLError();
glGetShaderiv(FS, GL_COMPILE_STATUS, &fragCompiled);
printShaderInfoLog (FS);
if (!vertCompiled || !fragCompiled)
return 0;
debugOut( "\nShaders compiled. \n");
// Create a program object and attach the two compiled shaders
prog = glCreateProgram();
glAttachShader(prog, VS);
glAttachShader(prog, FS);
// Clean up
glDeleteShader (VS);
glDeleteShader (FS);
// Link the program and print log
glLinkProgram(prog);
printOpenGLError();
glGetProgramiv(prog, GL_LINK_STATUS, &linked);
printProgramInfoLog(prog);
if (!linked)
return 0;
debugOut("Shader program linked. \n");
return prog;
}
static void LoadShaders()
{
log_info("Initializing shaders");
DS_Shader = Shader_LoadDefault();
printOpenGLError();
if(!glIsProgram(DS_Shader))
{
log_err("Android Default Shader didn't succeed in creating");
goto error;
}
DS_Attribute_Pos = glGetAttribLocation(DS_Shader, "vPosition");
DS_Attribute_Color = glGetAttribLocation(DS_Shader, "Color");
DS_ScreenSize = glGetUniformLocation(DS_Shader, "ScreenSize");
printOpenGLError();
IS_Shader = Shader_LoadImage();
IS_Attribute_Pos = glGetAttribLocation(IS_Shader, "a_position");
IS_Attribute_Text = glGetAttribLocation(IS_Shader, "a_texCoord");
IS_Uniform_ScreenSize = glGetUniformLocation(IS_Shader, "ScreenSize");
IS_Shader_uni2 = glGetUniformLocation(IS_Shader, "ColorBlend");
FS_Shader = Shader_loadCustom("attribute vec3 vertex;\n"
"attribute vec2 coords;\n"
"uniform vec2 ScreenSize;\n"
"varying vec2 TexCoords;\n"
"void main()\n"
"{\n"
"gl_Position = vec4(vertex.x/ScreenSize.x*2.0-1.0, vertex.y/ScreenSize.y*2.0-1.0, vertex.z / 10.0, 1.0);\n"
"TexCoords = coords;\n"
"}\n "
"\n ",
"precision mediump float;\n"
"varying vec2 TexCoords;\n"
"uniform sampler2D text;\n"
"uniform vec4 textColor;\n"
"void main()\n"
"{\n"
"vec4 sampled = vec4(1.0, 1.0, 1.0, texture2D(text, TexCoords).a);\n"
"gl_FragColor = textColor * sampled;\n"
"}\n ");
FS_Shader_Attrib = glGetAttribLocation(FS_Shader, "vertex");
FS_Shader_Attrib2 = glGetAttribLocation(FS_Shader, "coords");
FS_Shader_uni = glGetUniformLocation(FS_Shader, "ScreenSize");
FS_Shader_uni2 = glGetUniformLocation(FS_Shader, "textColor");
log_info("Done loading shader");
return;
error: Application_Error(); return;
}
bool Shader::SetShaderFile(char* sVSFileName, char* sFSFileName)
{
if (glIsProgram(m_Program))
{
CleanUp();
}
if (!ReadVertextShader(sVSFileName) || !ReadFragmentShader(sFSFileName))
{
return false;
}
GLint vertCompiled, fragCompiled; //状态值
GLint linked;
//创建shader对象
m_Vert = glCreateShader(GL_VERTEX_SHADER);
m_Frag = glCreateShader(GL_FRAGMENT_SHADER);
const GLchar *vv = m_VertexShader;
const GLchar *ff = m_FragmentShader;
//添加shader
glShaderSource(m_Vert,1,&vv,NULL);
glShaderSource(m_Frag,1,&ff,NULL);
//编译shader
glCompileShader(m_Vert);
printOpenGLError(); //检查OpenGL错误
//glGetObjectParameterivARB(m_Vert, GL_OBJECT_COMPILE_STATUS_ARB, &vertCompiled);
glGetShaderiv(m_Vert, GL_COMPILE_STATUS, &vertCompiled);
printShaderInfoLog(m_Vert);
glCompileShader(m_Frag);
printOpenGLError(); //检查OpenGL错误
//glGetObjectParameterivARB(m_Frag, GL_OBJECT_COMPILE_STATUS_ARB, &fragCompiled);
glGetShaderiv(m_Frag, GL_COMPILE_STATUS, &fragCompiled);
printShaderInfoLog(m_Frag);
if (!vertCompiled || !fragCompiled)
return false;
//创建程序对象
m_Program = glCreateProgram();
//绑定shader到程序对象
glAttachShader(m_Program,m_Vert);
glAttachShader(m_Program,m_Frag);
//链接程序
glLinkProgram(m_Program);
printOpenGLError(); //检查OpenGL错误
//glGetObjectParameterivARB(m_Program, GL_OBJECT_COMPILE_STATUS_ARB, &linked);
glGetProgramiv(m_Program, GL_LINK_STATUS, &linked);
printProgramInfoLog(m_Program);
if (!linked)
return false;
UseShader(true);
return true;
}
void Obj3D::DestroyShaders()
{
glDetachShader(m_renderInfo.ProgramId, m_renderInfo.FragmentShaderId);
glDetachShader(m_renderInfo.ProgramId, m_renderInfo.VertexShaderId);
printOpenGLError();
glDeleteShader(m_renderInfo.FragmentShaderId);
glDeleteShader(m_renderInfo.VertexShaderId);
printOpenGLError();
glDeleteProgram(m_renderInfo.ProgramId);
printOpenGLError();
}
void QglviewerRenderer::updateMatrix()
{
if(_pParent != NULL)
{
Matrix4f view, proj;
/*GLdouble m[4][4], p[4][4];
this->camera()->getProjectionMatrix(m[0]);
this->camera()->getModelViewMatrix(p[0]);
for(int y = 0; y < 4; ++y)
{
for(int x = 0; x < 4; ++x)
{
view[y][x] = m[y][x];
proj[y][x] = p[y][x];
}
}*/
glMatrixMode (GL_PROJECTION);
glGetFloatv(GL_PROJECTION_MATRIX , &(proj[0][0]));
printOpenGLError ();
glMatrixMode(GL_MODELVIEW);
glGetFloatv(GL_MODELVIEW_MATRIX ,&(view[0][0]));
_pParent->updateModelViewMatrix(&view, &proj);
}
}
GLuint
#else
unsigned int
#endif
createGLSLProgram(const char *vp_code,const char *fp_code)
{
// create program
#ifdef _WIN32
GLuint vp,fp;
int id;
#else
GLhandle vp,fp;
GLhandle id;
#endif
// id = glCreateProgramObjectARB();
printOpenGLError();
id = glCreateProgram();
// if vertex program code is given, compile it
if (vp_code) {
vp=loadGLSLShader(vp_code,GL_VERTEX_SHADER);
glAttachShader(id,vp);
}
// if fragment program code is given, compile it
if (fp_code) {
fp=loadGLSLShader(fp_code,GL_FRAGMENT_SHADER);
glAttachShader(id,fp);
}
// link compiled shaders
glLinkProgram(id);
// check link success
GLint linked;
/*
glGetObjectParameteriv(id,GL_OBJECT_LINK_STATUS_, &linked);
if (!linked) {
// there was an error => display
GLint maxLength;
glGetObjectParameteriv(id,GL_OBJECT_INFO_LOG_LENGTH_, &maxLength);
GLchar *infoLog=new GLchar[maxLength+1];
glGetInfoLog(id, maxLength, (GLsizei*)NULL, infoLog);
fprintf(stderr,"\n\n**** GLSL program failed to link ****\n%s",infoLog);
delete [](infoLog);
// exit on error
exit (0);
}
*/
// free compiled shaders (they are now embbeded into the program)
/*
if (vp_code) {
glDeleteObjectARB(vp);
}
if (fp_code) {
glDeleteObjectARB(fp);
}
*/
// set as current program
glUseProgram(id);
// done, return program id
return (id);
}
void GLTexture::draw()
{
use();
glPushAttrib(GL_VIEWPORT_BIT);
glViewport(0,0, m_width, m_height);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glMatrixMode (GL_PROJECTION);
glPushMatrix();
glLoadIdentity ();
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex2f(-1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex2f( 1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex2f( 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex2f(-1.0f, 1.0f);
glEnd();
glMatrixMode (GL_PROJECTION);
glPopMatrix();
glMatrixMode (GL_MODELVIEW);
glPopMatrix();
glPopAttrib();
unUse();
printOpenGLError();
}
void buffer_object::set_attrib_pointer(int index, int components, GLuint Type)
{
bind(GL_ARRAY_BUFFER_ARB);
glVertexAttribPointer(index, components, Type, GL_FALSE, 0, BUFFER_OFFSET(0));
//unbind();
printOpenGLError();
}
void Window_Create(struct Window **Window, char *Title, int Width, int Height)
{
log_info("Creating Window");
if (*Window == NULL)
(*Window) = malloc(sizeof(struct Window));
check_mem((*Window));
(*Window)->WINDOW_TITLE = Title;
(*Window)->WINDOW_WIDTH = Width;
(*Window)->WINDOW_HEIGHT = Height;
Game_Width = Width;
Game_Height = Height;
(*Window)->Running = true;
printOpenGLError();
log_info("Window has been created");
return;
error: Window_Free(Window);
Application_Error();
return;
}
void buffer_object::set_normal_pointer(GLuint Type)
{
bind(GL_ARRAY_BUFFER_ARB);
glNormalPointer(Type, 0, BUFFER_OFFSET(0));
//unbind();
printOpenGLError();
}
void buffer_object::set_color_pointer(int components, GLuint Type)
{
bind(GL_ARRAY_BUFFER_ARB);
glColorPointer(components, Type, 0, BUFFER_OFFSET(0));
//unbind();
printOpenGLError();
}
int main( int argc, char **argv )
{
int success = 0;
GLcharARB *VertexShaderSource, *FragmentShaderSource;
int error = 0;
if (Args(argc, argv) == FALSE)
exit(0);
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
glutInitWindowSize(500, 500);
window = glutCreateWindow( "Fire and Smoke" );
glutIdleFunc( play );
glutDisplayFunc( display );
glutKeyboardFunc( key );
glutReshapeFunc( reshape );
printOpenGLError();
if ( !isExtensionSupported( "GL_ARB_shader_objects" ) ||
!isExtensionSupported( "GL_ARB_fragment_shader" ) ||
!isExtensionSupported( "GL_ARB_vertex_shader" ) ||
!isExtensionSupported( "GL_ARB_shading_language_100" ) )
{
printf("OpenGL Shading Language extensions not available\n" );
return 1;
}
if( error )
{
printf( "ERROR from wglGetProcAddress\n" );
}
createPoints( numParticles );
glDepthFunc( GL_LESS );
glEnable( GL_DEPTH_TEST );
glClearColor( 0.0f, 0.67f, 0.94f, 1.0f );
ParticleTime = 0.0f;
readShaderSource( "smoke", &VertexShaderSource, &FragmentShaderSource );
success = installParticleShaders( VertexShaderSource, FragmentShaderSource );
if ( success )
{
glutMainLoop();
}
else
{
printf( "Error installing particle shaders" );
scanf( "%d", ParticleTime );
}
return 0;
}
void Obj3D::DestroyVBO()
{
UnbindForRender();
glDeleteBuffers(1, &m_renderInfo.IndexBufferId);
glDeleteBuffers(1, &m_renderInfo.VboId);
glDeleteVertexArrays(1, &m_renderInfo.VaoId);
printOpenGLError();
}
void Scene::draw()
{
glClearColor(0.2f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferObject);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (void*)48);
glDrawArrays(GL_TRIANGLES, 0, 3);
printOpenGLError();
glDisableVertexAttribArray(0);
printOpenGLError();
}
void Shader::install(const GLchar *vert_source, const GLchar *frag_source)
{
GLuint vertexShader, fragmentShader;
GLint compiled, linked;
program = glCreateProgram();
// Compile vertex shader
vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vert_source, NULL);
glCompileShader(vertexShader);
printOpenGLError();
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compiled);
printShaderInfoLog(vertexShader);
if (!compiled) {
printf("Error compiling the shader %s", vert_source);
exit(EXIT_FAILURE);
}
glAttachShader(program, vertexShader);
// Compile fragment shader if there is one
if (frag_source != NULL) {
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &frag_source, NULL);
glCompileShader(fragmentShader);
printOpenGLError();
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compiled);
printShaderInfoLog(fragmentShader);
if (!compiled) {
printf("Error compiling the shader %s", frag_source);
exit(EXIT_FAILURE);
}
glAttachShader(program, fragmentShader);
}
glLinkProgram(program);
printOpenGLError();
glGetProgramiv(program, GL_LINK_STATUS, &linked);
printProgramInfoLog(program);
}
static void FS_Flush() {
printOpenGLError();
glUseProgram(FS_Shader);
glUniform2f(FS_Shader_uni, Game_Width, Game_Height);
glEnableVertexAttribArray(FS_Shader_Attrib);
glEnableVertexAttribArray(FS_Shader_Attrib2);
glActiveTexture(GL_TEXTURE0);
for (int i = 0; i < FS_Texture_Count; i++) {
glBindTexture(GL_TEXTURE_2D, FS_Font_Image[i]);
// Update content of VBO memory
struct Vector4f Color = Vector4_Create(-1, -1, -1, -1);
for (int j = 0; j < FS_Vertices_Count[i]; j += 4) {
if (Color.x != FS_Color[i][j].x || Color.y != FS_Color[i][j].y
|| Color.z != FS_Color[i][j].z
|| Color.w != FS_Color[i][j].w) {
Color = FS_Color[i][j];
glUniform4f(FS_Shader_uni2, Color.x, Color.y, Color.z, Color.w);
}
IS_Vector[0] = FS_Vertices[i][j];
IS_Vector[1] = FS_Vertices[i][j + 1];
IS_Vector[2] = FS_Vertices[i][j + 2];
IS_Vector[3] = FS_Vertices[i][j + 2];
IS_Vector[4] = FS_Vertices[i][j];
IS_Vector[5] = FS_Vertices[i][j + 3];
glVertexAttribPointer(FS_Shader_Attrib, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), IS_Vector);
glVertexAttribPointer(FS_Shader_Attrib2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &IS_Vector[0].w);
// Render quad
glDrawArrays(GL_TRIANGLES, 0, 6);
}
}
glBindTexture(GL_TEXTURE_2D, 0);
glUseProgram(0);
FS_Texture_Count = 0;
glDisableVertexAttribArray(FS_Shader_Attrib);
glDisableVertexAttribArray(FS_Shader_Attrib2);
printOpenGLError();
}
GLint Shader::getUniLoc(GLuint program, const GLchar *name)
{
GLint loc;
loc = glGetUniformLocation(program, name);
if (loc == -1)
printf("uniform variates %s undefined! \n", name);
printOpenGLError(); // Check for OpenGL errors
return loc;
}
void Scene::init()
{
_shaderProgram = createShaderProgramWithFilenames("VertexColors.vert", "VertexColors.frag");
glUseProgram(_shaderProgram);
printOpenGLError();
// Initialize Vertex Buffer
glGenBuffers(1, &_vertexBufferObject);
glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferObject);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
printOpenGLError();
// Vertex array object
glGenVertexArrays(1, &_vertexArrayObject);
glBindVertexArray(_vertexArrayObject);
printOpenGLError();
}
void GLWidget::initializeGL() {
// upload texture
glEnable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glEnable(GL_POLYGON_SMOOTH);
glClearColor(1.0, 0, 1.0, 0);
_tex.create(_im->_image.data);
printOpenGLError();
}
static void IS_Flush() {
glUseProgram(IS_Shader);
glUniform2f(IS_Uniform_ScreenSize, Game_Width, Game_Height);
glEnableVertexAttribArray(IS_Attribute_Pos);
glEnableVertexAttribArray(IS_Attribute_Text);
for (int TextureID = 0; TextureID < IS_Texture_Count; TextureID++) {
glBindTexture(GL_TEXTURE_2D, IS_Texture[TextureID]);
struct Vector4f Blend = { -2, -2, -2, -2 };
for (int i = 0; i < IS_Vertices_Count[TextureID]; i += 4) {
IS_Vector[0] = IS_Vertices[TextureID][i];
IS_Vector[1] = IS_Vertices[TextureID][i + 1];
IS_Vector[2] = IS_Vertices[TextureID][i + 2];
IS_Vector[3] = IS_Vertices[TextureID][i + 2];
IS_Vector[4] = IS_Vertices[TextureID][i];
IS_Vector[5] = IS_Vertices[TextureID][i + 3];
glVertexAttribPointer(IS_Attribute_Pos, 3, GL_FLOAT, GL_FALSE, sizeof(struct Vector5f), IS_Vector);
glVertexAttribPointer(IS_Attribute_Text, 2, GL_FLOAT, GL_FALSE, sizeof(struct Vector5f), &IS_Vector[0].w);
if (Blend.x != IS_Blending[TextureID][i].x
|| Blend.y != IS_Blending[TextureID][i].y
|| Blend.z != IS_Blending[TextureID][i].z
|| Blend.w != IS_Blending[TextureID][i].w) {printOpenGLError();
glUniform4f(IS_Shader_uni2, IS_Blending[TextureID][i].x,
IS_Blending[TextureID][i].y,
IS_Blending[TextureID][i].z,
IS_Blending[TextureID][i].w);printOpenGLError();
Blend = IS_Blending[TextureID][i];
}
glDrawArrays(GL_TRIANGLES, 0, 6);
}
}
glDisableVertexAttribArray(IS_Attribute_Pos);
glDisableVertexAttribArray(IS_Attribute_Text);
printOpenGLError();
IS_Texture_Count = 0;
}
