SimpleMesh::~SimpleMesh()
{
if(m_vertexPosBufferObject)
{
glDeleteBuffers(1, &m_vertexPosBufferObject);
m_vertexPosBufferObject = 0;
}
if(m_vertexNormBufferObject)
{
glDeleteVertexArrays(1, &m_vertexNormBufferObject);
m_vertexNormBufferObject = 0;
}
if(m_vertexTexCoordsBufferObject)
{
glDeleteVertexArrays(1, &m_vertexTexCoordsBufferObject);
m_vertexTexCoordsBufferObject = 0;
}
if(m_indexBufferObject)
{
glDeleteVertexArrays(1, &m_indexBufferObject);
m_indexBufferObject = 0;
}
if(m_vertexArrayObject)
{
glDeleteVertexArrays(1, &m_vertexArrayObject);
m_vertexArrayObject = 0;
}
glusDestroyShapef(&m_glusShape);
}
GLUSboolean GLUSAPIENTRY glusCreateCylinderf(GLUSshape* shape, const GLUSfloat halfExtend, const GLUSfloat radius, const GLUSushort numberSlices)
{
GLUSuint i, j;
GLUSuint numberVertices = (numberSlices + 2) * 2 + (numberSlices + 1) * 2;
GLUSuint numberIndices = numberSlices * 3 * 2 + numberSlices * 6;
GLUSfloat angleStep = (2.0f * GLUS_PI) / ((GLUSfloat) numberSlices);
GLUSuint indexIndices;
GLUSuint centerIndex;
GLUSuint indexCounter;
GLUSuint vertexCounter = 0;
if (numberSlices < 3 || numberVertices > GLUS_MAX_VERTICES || numberIndices > GLUS_MAX_INDICES)
{
return GLUS_FALSE;
}
if (!shape)
{
return GLUS_FALSE;
}
glusInitShapef(shape);
shape->numberVertices = numberVertices;
shape->numberIndices = numberIndices;
shape->vertices = (GLUSfloat*) malloc(4 * numberVertices * sizeof(GLUSfloat));
shape->normals = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->tangents = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->texCoords = (GLUSfloat*) malloc(2 * numberVertices * sizeof(GLUSfloat));
shape->indices = (GLUSushort*) malloc(numberIndices * sizeof(GLUSushort));
if (!glusCheckShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
// Center bottom
shape->vertices[vertexCounter * 4 + 0] = 0.0f;
shape->vertices[vertexCounter * 4 + 1] = -halfExtend;
shape->vertices[vertexCounter * 4 + 2] = 0.0f;
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = 0.0f;
shape->normals[vertexCounter * 3 + 1] = -1.0f;
shape->normals[vertexCounter * 3 + 2] = 0.0f;
shape->tangents[vertexCounter * 3 + 0] = 0.0f;
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = 1.0f;
shape->texCoords[vertexCounter * 2 + 0] = 0.0f;
shape->texCoords[vertexCounter * 2 + 1] = 0.0f;
vertexCounter++;
// Bottom
for (i = 0; i < (GLUSuint)(numberSlices + 1); i++)
{
GLUSfloat currentAngle = angleStep * (GLUSfloat)i;
shape->vertices[vertexCounter * 4 + 0] = cosf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 1] = -halfExtend;
shape->vertices[vertexCounter * 4 + 2] = -sinf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = 0.0f;
shape->normals[vertexCounter * 3 + 1] = -1.0f;
shape->normals[vertexCounter * 3 + 2] = 0.0f;
shape->tangents[vertexCounter * 3 + 0] = sinf(currentAngle);
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = cosf(currentAngle);
shape->texCoords[vertexCounter * 2 + 0] = 0.0f;
shape->texCoords[vertexCounter * 2 + 1] = 0.0f;
vertexCounter++;
}
// Center top
shape->vertices[vertexCounter * 4 + 0] = 0.0f;
shape->vertices[vertexCounter * 4 + 1] = halfExtend;
shape->vertices[vertexCounter * 4 + 2] = 0.0f;
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = 0.0f;
shape->normals[vertexCounter * 3 + 1] = 1.0f;
shape->normals[vertexCounter * 3 + 2] = 0.0f;
shape->tangents[vertexCounter * 3 + 0] = 0.0f;
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = -1.0f;
shape->texCoords[vertexCounter * 2 + 0] = 1.0f;
shape->texCoords[vertexCounter * 2 + 1] = 1.0f;
vertexCounter++;
// Top
for (i = 0; i < (GLUSuint)(numberSlices + 1); i++)
{
GLUSfloat currentAngle = angleStep * (GLUSfloat)i;
shape->vertices[vertexCounter * 4 + 0] = cosf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 1] = halfExtend;
shape->vertices[vertexCounter * 4 + 2] = -sinf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = 0.0f;
shape->normals[vertexCounter * 3 + 1] = 1.0f;
shape->normals[vertexCounter * 3 + 2] = 0.0f;
shape->tangents[vertexCounter * 3 + 0] = -sinf(currentAngle);
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = -cosf(currentAngle);
shape->texCoords[vertexCounter * 2 + 0] = 1.0f;
shape->texCoords[vertexCounter * 2 + 1] = 1.0f;
vertexCounter++;
}
for (i = 0; i < (GLUSuint)(numberSlices + 1); i++)
{
GLUSfloat currentAngle = angleStep * (GLUSfloat)i;
GLUSfloat sign = -1.0f;
for (j = 0; j < 2; j++)
{
shape->vertices[vertexCounter * 4 + 0] = cosf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 1] = halfExtend * sign;
shape->vertices[vertexCounter * 4 + 2] = -sinf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = cosf(currentAngle);
shape->normals[vertexCounter * 3 + 1] = 0.0f;
shape->normals[vertexCounter * 3 + 2] = -sinf(currentAngle);
shape->tangents[vertexCounter * 3 + 0] = -sinf(currentAngle);
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = -cosf(currentAngle);
shape->texCoords[vertexCounter * 2 + 0] = (GLUSfloat)i / (GLUSfloat)numberSlices;
shape->texCoords[vertexCounter * 2 + 1] = (sign + 1.0f) / 2.0f;
vertexCounter++;
sign = 1.0f;
}
}
indexIndices = 0;
// Bottom
centerIndex = 0;
indexCounter = 1;
for (i = 0; i < numberSlices; i++)
{
shape->indices[indexIndices++] = centerIndex;
shape->indices[indexIndices++] = indexCounter + 1;
shape->indices[indexIndices++] = indexCounter;
indexCounter++;
}
indexCounter++;
// Top
centerIndex = indexCounter;
indexCounter++;
for (i = 0; i < numberSlices; i++)
{
shape->indices[indexIndices++] = centerIndex;
shape->indices[indexIndices++] = indexCounter;
shape->indices[indexIndices++] = indexCounter + 1;
indexCounter++;
}
indexCounter++;
// Sides
for (i = 0; i < numberSlices; i++)
{
shape->indices[indexIndices++] = indexCounter;
shape->indices[indexIndices++] = indexCounter + 2;
shape->indices[indexIndices++] = indexCounter + 1;
shape->indices[indexIndices++] = indexCounter + 2;
shape->indices[indexIndices++] = indexCounter + 3;
shape->indices[indexIndices++] = indexCounter + 1;
indexCounter += 2;
}
if (!glusFinalizeShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLUSshape backgroundSphere;
GLUSshape wavefront;
// 6 sides of diffuse and specular; all roughness levels of specular.
GLUShdrimage image[6 * NUMBER_ROUGHNESS + 6];
// The look up table (LUT) is stored in a raw binary file.
GLUSbinaryfile rawimage;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLchar buffer[27] = "doge2/doge2_POS_X_00_s.hdr";
GLint i, k, m;
//
glusLoadTextFile("../Example33/shader/brdf.vert.glsl", &vertexSource);
glusLoadTextFile("../Example33/shader/brdf.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_modelProgram, (const GLchar**)&vertexSource.text, 0, 0, 0, (const GLchar**)&fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
g_viewProjectionMatrixModelLocation = glGetUniformLocation(g_modelProgram.program, "u_viewProjectionMatrix");
g_modelMatrixModelLocation = glGetUniformLocation(g_modelProgram.program, "u_modelMatrix");
g_normalMatrixModelLocation = glGetUniformLocation(g_modelProgram.program, "u_normalMatrix");
g_eyeModelLocation = glGetUniformLocation(g_modelProgram.program, "u_eye");
g_textureSpecularModelLocation = glGetUniformLocation(g_modelProgram.program, "u_textureSpecular");
g_textureDiffuseModelLocation = glGetUniformLocation(g_modelProgram.program, "u_textureDiffuse");
g_textureLUTModelLocation = glGetUniformLocation(g_modelProgram.program, "u_textureLUT");
g_colorMaterialModelLocation = glGetUniformLocation(g_modelProgram.program, "u_colorMaterial");
g_roughnessMaterialModelLocation = glGetUniformLocation(g_modelProgram.program, "u_roughnessMaterial");
g_roughnessScaleModelLocation = glGetUniformLocation(g_modelProgram.program, "u_roughnessScale");
g_R0MaterialModelLocation = glGetUniformLocation(g_modelProgram.program, "u_R0Material");
g_vertexModelLocation = glGetAttribLocation(g_modelProgram.program, "a_vertex");
g_normalModelLocation = glGetAttribLocation(g_modelProgram.program, "a_normal");
//
glusLoadTextFile("../Example33/shader/fullscreen.vert.glsl", &vertexSource);
glusLoadTextFile("../Example33/shader/fullscreen.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_fullscreenProgram, (const GLchar**)&vertexSource.text, 0, 0, 0, (const GLchar**)&fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_framebufferTextureFullscreenLocation = glGetUniformLocation(g_fullscreenProgram.program, "u_framebufferTexture");
g_msaaSamplesFullscreenLocation = glGetUniformLocation(g_fullscreenProgram.program, "u_msaaSamples");
g_exposureFullscreenLocation = glGetUniformLocation(g_fullscreenProgram.program, "u_exposure");
g_gammaFullscreenLocation = glGetUniformLocation(g_fullscreenProgram.program, "u_gamma");
//
//
glusLoadTextFile("../Example33/shader/background.vert.glsl", &vertexSource);
glusLoadTextFile("../Example33/shader/background.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_backgroundProgram, (const GLUSchar**)&vertexSource.text, 0, 0, 0, (const GLUSchar**)&fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_viewProjectionMatrixBackgroundLocation = glGetUniformLocation(g_backgroundProgram.program, "u_viewProjectionMatrix");
g_textureBackgroundLocation = glGetUniformLocation(g_backgroundProgram.program, "u_texture");
g_vertexBackgroundLocation = glGetAttribLocation(g_backgroundProgram.program, "a_vertex");
//
// Setting up the full screen frame buffer.
//
glGenTextures(1, &g_fullscreenTexture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, g_fullscreenTexture);
// Create MSAA texture.
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, MSAA_SAMPLES, GL_RGB32F, SCREEN_WIDTH, SCREEN_HEIGHT, GL_TRUE);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
// No need to access the depth buffer, so a render buffer is sufficient.
glGenRenderbuffers(1, &g_fullscreenDepthRenderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, g_fullscreenDepthRenderbuffer);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, MSAA_SAMPLES, GL_DEPTH_COMPONENT, SCREEN_WIDTH, SCREEN_HEIGHT);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
//
glGenFramebuffers(1, &g_fullscreenFBO);
glBindFramebuffer(GL_FRAMEBUFFER, g_fullscreenFBO);
// Attach the color buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, g_fullscreenTexture, 0);
// ... and the depth buffer.
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, g_fullscreenDepthRenderbuffer);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return GLUS_FALSE;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//
//
//
for (i = 0; i < 2; i++)
{
if (i == 0)
{
buffer[21] = 's';
}
else
{
buffer[21] = 'd';
}
for (k = 0; k < NUMBER_ROUGHNESS; k++)
{
if (i == 1 && k > 0)
{
continue;
}
buffer[18] = '0' + k / 10;
buffer[19] = '0' + k % 10;
for (m = 0; m < 6; m++)
{
if (m % 2 == 0)
{
buffer[12] = 'P';
buffer[13] = 'O';
buffer[14] = 'S';
}
else
{
buffer[12] = 'N';
buffer[13] = 'E';
buffer[14] = 'G';
}
switch (m)
{
case 0:
case 1:
buffer[16] = 'X';
break;
case 2:
case 3:
buffer[16] = 'Y';
break;
case 4:
case 5:
buffer[16] = 'Z';
break;
}
printf("Loading '%s' ...", buffer);
if (!glusLoadHdrImage(buffer, &image[i*NUMBER_ROUGHNESS*6 + k*6 + m]))
{
printf(" error!\n");
continue;
}
printf(" done.\n");
}
}
}
glGenTextures(1, &g_texture[0]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, g_texture[0]);
glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGB32F, image[0].width, image[0].height, 6*NUMBER_ROUGHNESS, 0, GL_RGB, GL_FLOAT, 0);
glusLogPrintError(GLUS_LOG_INFO, "glTexImage3D()");
for (i = 0; i < NUMBER_ROUGHNESS; i++)
{
for (k = 0; k < 6; k++)
{
glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 6*i + k, image[i*6 + k].width, image[i*6 + k].height, 1, image[i*6 + k].format, GL_FLOAT, image[i*6 + k].data);
glusLogPrintError(GLUS_LOG_INFO, "glTexSubImage3D() %d %d", i, k);
}
}
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, 0);
//
glGenTextures(1, &g_texture[1]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, g_texture[1]);
for (i = 0; i < 6; i++)
{
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, image[i + 6*NUMBER_ROUGHNESS].format, image[i + 6*NUMBER_ROUGHNESS].width, image[i + 6*NUMBER_ROUGHNESS].height, 0, image[i + 6*NUMBER_ROUGHNESS].format, GL_FLOAT, image[i + 6*NUMBER_ROUGHNESS].data);
glusLogPrintError(GLUS_LOG_INFO, "glTexImage2D() %d", i);
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
//
printf("Loading 'doge2/EnvironmentBRDF_1024.data' ...");
if (!glusLoadBinaryFile("doge2/EnvironmentBRDF_1024.data", &rawimage))
{
printf(" error!\n");
}
else
{
printf(" done.\n");
}
glGenTextures(1, &g_texture[2]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, g_texture[2]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RG32F, 1024, 1024, 0, GL_RG, GL_FLOAT, (GLfloat*)rawimage.binary);
glusLogPrintError(GLUS_LOG_INFO, "glTexImage2D()");
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
glusDestroyBinaryFile(&rawimage);
//
for (i = 0; i < 2; i++)
{
for (k = 0; k < NUMBER_ROUGHNESS; k++)
{
if (i == 1 && k > 0)
{
continue;
}
for (m = 0; m < 6; m++)
{
glusDestroyHdrImage(&image[i*NUMBER_ROUGHNESS*6 + k*6 + m]);
}
}
}
//
glusCreateSpheref(&backgroundSphere, 500.0f, 32);
g_numberIndicesBackground = backgroundSphere.numberIndices;
glGenBuffers(1, &g_verticesBackgroundVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
glBufferData(GL_ARRAY_BUFFER, backgroundSphere.numberVertices * 4 * sizeof(GLfloat), (GLfloat*)backgroundSphere.vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesBackgroundVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, backgroundSphere.numberIndices * sizeof(GLuint), (GLuint*)backgroundSphere.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&backgroundSphere);
//
//
// Use a helper function to load an wavefront object file.
glusLoadObjFile("venusm.obj", &wavefront);
g_numberVerticesModel = wavefront.numberVertices;
glGenBuffers(1, &g_verticesModelVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesModelVBO);
glBufferData(GL_ARRAY_BUFFER, wavefront.numberVertices * 4 * sizeof(GLfloat), (GLfloat*)wavefront.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsModelVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsModelVBO);
glBufferData(GL_ARRAY_BUFFER, wavefront.numberVertices * 3 * sizeof(GLfloat), (GLfloat*)wavefront.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glusDestroyShapef(&wavefront);
//
glUseProgram(g_modelProgram.program);
glUniform4fv(g_eyeModelLocation, 1, g_eye);
glUniform1i(g_textureSpecularModelLocation, 0);
glUniform1i(g_textureDiffuseModelLocation, 1);
glUniform1i(g_textureLUTModelLocation, 2);
glUniform1f(g_roughnessScaleModelLocation, (GLfloat)(NUMBER_ROUGHNESS - 1));
glGenVertexArrays(1, &g_modelVAO);
glBindVertexArray(g_modelVAO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesModelVBO);
glVertexAttribPointer(g_vertexModelLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexModelLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsModelVBO);
glVertexAttribPointer(g_normalModelLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalModelLocation);
//
glUseProgram(g_fullscreenProgram.program);
glUniform1i(g_framebufferTextureFullscreenLocation, 0);
glUniform1i(g_msaaSamplesFullscreenLocation, MSAA_SAMPLES);
glGenVertexArrays(1, &g_fullscreenVAO);
glBindVertexArray(g_fullscreenVAO);
//
glUseProgram(g_backgroundProgram.program);
glUniform1i(g_textureBackgroundLocation, 0);
glGenVertexArrays(1, &g_backgroundVAO);
glBindVertexArray(g_backgroundVAO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
glVertexAttribPointer(g_vertexBackgroundLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexBackgroundLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_CULL_FACE);
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLUStgaimage image;
GLUSshape plane;
//
glusLookAtf(g_viewMatrix, g_camera.eye[0], g_camera.eye[1], g_camera.eye[2], g_camera.center[0], g_camera.center[1], g_camera.center[2], g_camera.up[0], g_camera.up[1], g_camera.up[2]);
//
if (!initWavefront(g_viewMatrix, &g_light))
{
return GLUS_FALSE;
}
//
glusLoadTextFile("../Example19_ES/shader/basic_proj.vert.glsl", &vertexSource);
glusLoadTextFile("../Example19_ES/shader/texture_multi_proj.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
// Retrieve the uniform locations in the program.
g_viewProjectionMatrixLocation = glGetUniformLocation(g_program.program, "u_viewProjectionMatrix");
g_viewProjectionBiasTextureMatrixLocation = glGetUniformLocation(g_program.program, "u_viewProjectionBiasTextureMatrix");
g_modelMatrixLocation = glGetUniformLocation(g_program.program, "u_modelMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_lightDirectionLocation = glGetUniformLocation(g_program.program, "u_lightDirection");
g_repeatLocation = glGetUniformLocation(g_program.program, "u_repeat");
g_textureLocation = glGetUniformLocation(g_program.program, "u_texture");
g_mirrorTextureLocation = glGetUniformLocation(g_program.program, "u_mirrorTexture");
// Retrieve the attribute locations in the program.
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
g_texCoordLocation = glGetAttribLocation(g_program.program, "a_texCoord");
//
// Texture set up.
glusLoadTgaImage("ice.tga", &image);
glGenTextures(1, &g_texture);
glBindTexture(GL_TEXTURE_2D, g_texture);
glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
// Mipmap generation is now included in OpenGL 3 and above
glGenerateMipmap(GL_TEXTURE_2D);
// Trilinear filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, 0);
//
// Setting up the offscreen frame buffer.
//
glGenTextures(1, &g_mirrorTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, g_mirrorTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GLUS_RGB, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GLUS_RGB, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenRenderbuffers(1, &g_depthMirrorTexture);
glBindRenderbuffer(GL_RENDERBUFFER, g_depthMirrorTexture);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, TEXTURE_WIDTH, TEXTURE_HEIGHT);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
//
glGenFramebuffers(1, &g_fboMirrorTexture);
glBindFramebuffer(GL_FRAMEBUFFER, g_fboMirrorTexture);
// Attach the color buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_mirrorTexture, 0);
// ... and the depth buffer,
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, g_depthMirrorTexture);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return GLUS_FALSE;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//
//
//
glusCreatePlanef(&plane, 3.0f);
g_numberIndicesSphere = plane.numberIndices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) plane.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) plane.normals, GL_STATIC_DRAW);
glGenBuffers(1, &g_texCoordsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 2 * sizeof(GLfloat), (GLfloat*) plane.texCoords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane.numberIndices * sizeof(GLuint), (GLuint*) plane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&plane);
//
glUseProgram(g_program.program);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsVBO);
glVertexAttribPointer(g_texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_texCoordLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
//
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, g_texture);
glUniform1i(g_textureLocation, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, g_mirrorTexture);
glUniform1i(g_mirrorTextureLocation, 1);
// How many times the surface texture is repeated.
glUniform1f(g_repeatLocation, 6.0f);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepthf(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
return GLUS_TRUE;
}
static GLboolean glusCopyObjData(GLUSshape* shape, GLUSuint totalNumberVertices, GLUSfloat* triangleVertices, GLUSuint totalNumberNormals, GLUSfloat* triangleNormals, GLUSuint totalNumberTexCoords, GLUSfloat* triangleTexCoords)
{
GLUSuint indicesCounter = 0;
if (!shape || !triangleVertices || !triangleNormals || !triangleTexCoords)
{
return GLUS_FALSE;
}
shape->numberVertices = totalNumberVertices;
if (totalNumberVertices > 0)
{
shape->vertices = (GLUSfloat*)malloc(totalNumberVertices*4*sizeof(GLUSfloat));
if (shape->vertices == 0)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->vertices, triangleVertices, totalNumberVertices*4*sizeof(GLUSfloat));
}
if (totalNumberNormals > 0)
{
shape->normals = (GLUSfloat*)malloc(totalNumberNormals*3*sizeof(GLUSfloat));
if (shape->normals == 0)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->normals, triangleNormals, totalNumberNormals*3*sizeof(GLUSfloat));
}
if (totalNumberTexCoords > 0)
{
shape->texCoords = (GLUSfloat*)malloc(totalNumberTexCoords*2*sizeof(GLUSfloat));
if (shape->texCoords == 0)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->texCoords, triangleTexCoords, totalNumberTexCoords*2*sizeof(GLUSfloat));
}
// Just create the indices from the list of vertices.
shape->numberIndices = totalNumberVertices;
if (totalNumberVertices > 0)
{
shape->indices = (GLUSuint*)malloc(totalNumberVertices*sizeof(GLUSuint));
if (shape->indices == 0)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
for (indicesCounter = 0; indicesCounter < totalNumberVertices; indicesCounter++)
{
shape->indices[indicesCounter] = indicesCounter;
}
}
shape->mode = GL_TRIANGLES;
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLUSshape shadowPlane;
GLUSshape plane;
GLUSshape torus, torusWithAdjacency;
GLUStextfile vertexSource;
GLUStextfile geometrySource;
GLUStextfile fragmentSource;
GLfloat viewMatrix[16];
GLfloat lightDirection[3];
lightDirection[0] = g_lightDirection[0];
lightDirection[1] = g_lightDirection[1];
lightDirection[2] = g_lightDirection[2];
glusVector3Normalizef(lightDirection);
//
glusLoadTextFile("../Example22/shader/color.vert.glsl", &vertexSource);
glusLoadTextFile("../Example22/shader/color.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix");
g_viewMatrixLocation = glGetUniformLocation(g_program.program, "u_viewMatrix");
g_modelMatrixLocation = glGetUniformLocation(g_program.program, "u_modelMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_colorLocation = glGetUniformLocation(g_program.program, "u_shapeColor");
g_lightDirectionLocation = glGetUniformLocation(g_program.program, "u_lightDirection");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
//
glusLoadTextFile("../Example22/shader/shadowvolume.vert.glsl", &vertexSource);
glusLoadTextFile("../Example22/shader/shadowvolume.geom.glsl", &geometrySource);
glusLoadTextFile("../Example22/shader/shadowvolume.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_programShadowVolume, (const GLUSchar**) &vertexSource.text, 0, 0, (const GLUSchar**) &geometrySource.text, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&geometrySource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixShadowVolumeLocation = glGetUniformLocation(g_programShadowVolume.program, "u_projectionMatrix");
g_viewMatrixShadowVolumeLocation = glGetUniformLocation(g_programShadowVolume.program, "u_viewMatrix");
g_modelMatrixShadowVolumeLocation = glGetUniformLocation(g_programShadowVolume.program, "u_modelMatrix");
g_lightDirectionShadowVolumeLocation = glGetUniformLocation(g_programShadowVolume.program, "u_lightDirection");
g_vertexShadowVolumeLocation = glGetAttribLocation(g_programShadowVolume.program, "a_vertex");
//
glusLoadTextFile("../Example22/shader/shadow.vert.glsl", &vertexSource);
glusLoadTextFile("../Example22/shader/shadow.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_programShadowPlane, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_vertexShadowPlaneLocation = glGetAttribLocation(g_programShadowPlane.program, "a_vertex");
//
glusCreateTorusf(&torus, 0.5f, 1.0f, 32, 32);
glusCreateAdjacencyShapef(&torusWithAdjacency, &torus);
glusDestroyShapef(&torus);
g_numberIndices = torusWithAdjacency.numberIndices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, torusWithAdjacency.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) torusWithAdjacency.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, torusWithAdjacency.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) torusWithAdjacency.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, torusWithAdjacency.numberIndices * sizeof(GLuint), (GLuint*) torusWithAdjacency.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&torusWithAdjacency);
//
glusCreatePlanef(&plane, 10.0f);
g_numberIndicesPlane = plane.numberIndices;
glGenBuffers(1, &g_verticesPlaneVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPlaneVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) plane.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsPlaneVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsPlaneVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) plane.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesPlaneVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPlaneVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane.numberIndices * sizeof(GLuint), (GLuint*) plane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&plane);
//
// The plane extends from -1.0 to 1.0 for both sides. So when rendering in NDC, the plane is always fullscreen.
glusCreatePlanef(&shadowPlane, 1.0f);
g_numberIndicesShadowPlane = shadowPlane.numberIndices;
glGenBuffers(1, &g_verticesShadowPlaneVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesShadowPlaneVBO);
glBufferData(GL_ARRAY_BUFFER, shadowPlane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) shadowPlane.vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesShadowPlaneVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesShadowPlaneVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, shadowPlane.numberIndices * sizeof(GLuint), (GLuint*) shadowPlane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&shadowPlane);
//
glusLookAtf(viewMatrix, g_cameraPosition[0], g_cameraPosition[1], g_cameraPosition[2], 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
// Bring light from world to camera / view space
glusMatrix4x4MultiplyVector3f(lightDirection, viewMatrix, lightDirection);
glUseProgram(g_program.program);
glUniform3fv(g_lightDirectionLocation, 1, lightDirection);
//
glUseProgram(g_programShadowVolume.program);
glUniform3fv(g_lightDirectionShadowVolumeLocation, 1, lightDirection);
// Torus
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
// Shadow Volume
glGenVertexArrays(1, &g_vaoShadowVolume);
glBindVertexArray(g_vaoShadowVolume);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexShadowVolumeLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexShadowVolumeLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
// Plane
glGenVertexArrays(1, &g_vaoPlane);
glBindVertexArray(g_vaoPlane);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPlaneVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsPlaneVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPlaneVBO);
// Shadow Plane
glGenVertexArrays(1, &g_vaoShadowPlane);
glBindVertexArray(g_vaoShadowPlane);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesShadowPlaneVBO);
glVertexAttribPointer(g_vertexShadowPlaneLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexShadowPlaneLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesShadowPlaneVBO);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glClearStencil(0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPolygonOffset(0.0f, 100.0f);
return GLUS_TRUE;
}
SimpleMesh::~SimpleMesh()
{
DestroyGPUData();
glusDestroyShapef(&m_glusShape);
}
GLUSboolean initWavefront(GLUSfloat viewMatrix[16], struct LightProperties* light)
{
// Color material with white specular color.
struct MaterialProperties material = { { 0.0f, 1.0f, 1.0f, 1.0f }, { 0.0f, 1.0f, 1.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f }, 20.0f };
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLUSshape wavefrontObj;
g_viewMatrix = viewMatrix;
g_light = light;
//
glusLoadTextFile("../Example19_ES/shader/phong.vert.glsl", &vertexSource);
glusLoadTextFile("../Example19_ES/shader/phong.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix");
g_modelViewMatrixLocation = glGetUniformLocation(g_program.program, "u_modelViewMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_lightLocations.directionLocation = glGetUniformLocation(g_program.program, "u_light.direction");
g_lightLocations.ambientColorLocation = glGetUniformLocation(g_program.program, "u_light.ambientColor");
g_lightLocations.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_light.diffuseColor");
g_lightLocations.specularColorLocation = glGetUniformLocation(g_program.program, "u_light.specularColor");
g_material.ambientColorLocation = glGetUniformLocation(g_program.program, "u_material.ambientColor");
g_material.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_material.diffuseColor");
g_material.specularColorLocation = glGetUniformLocation(g_program.program, "u_material.specularColor");
g_material.specularExponentLocation = glGetUniformLocation(g_program.program, "u_material.specularExponent");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
//
// Use a helper function to load an wavefront object file.
glusLoadObjFile("monkey.obj", &wavefrontObj);
g_numberVertices = wavefrontObj.numberVertices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, wavefrontObj.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) wavefrontObj.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, wavefrontObj.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) wavefrontObj.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glusDestroyShapef(&wavefrontObj);
//
glUseProgram(g_program.program);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
//
glusVector3Normalizef(g_light->direction);
// Set up light ...
// Direction is set later
glUniform4fv(g_lightLocations.ambientColorLocation, 1, g_light->ambientColor);
glUniform4fv(g_lightLocations.diffuseColorLocation, 1, g_light->diffuseColor);
glUniform4fv(g_lightLocations.specularColorLocation, 1, g_light->specularColor);
// ... and material values.
glUniform4fv(g_material.ambientColorLocation, 1, material.ambientColor);
glUniform4fv(g_material.diffuseColorLocation, 1, material.diffuseColor);
glUniform4fv(g_material.specularColorLocation, 1, material.specularColor);
glUniform1f(g_material.specularExponentLocation, material.specularExponent);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepthf(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
return GLUS_TRUE;
}
GLUSboolean GLUSAPIENTRY glusCopyShapef(GLUSshape* shape, const GLUSshape* source)
{
GLUSuint stride = 4 + 3 + 3 + 3 + 2;
if (!shape || !source)
{
return GLUS_FALSE;
}
glusInitShapef(shape);
shape->numberVertices = source->numberVertices;
shape->numberIndices = source->numberIndices;
shape->mode = source->mode;
if (source->vertices)
{
shape->vertices = (GLUSfloat*) malloc(4 * source->numberVertices * sizeof(GLUSfloat));
if (!shape->vertices)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->vertices, source->vertices, 4 * source->numberVertices * sizeof(GLUSfloat));
}
if (source->normals)
{
shape->normals = (GLUSfloat*) malloc(3 * source->numberVertices * sizeof(GLUSfloat));
if (!shape->normals)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->normals, source->normals, 3 * source->numberVertices * sizeof(GLUSfloat));
}
if (source->tangents)
{
shape->tangents = (GLUSfloat*) malloc(3 * source->numberVertices * sizeof(GLUSfloat));
if (!shape->tangents)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->tangents, source->tangents, 3 * source->numberVertices * sizeof(GLUSfloat));
}
if (source->bitangents)
{
shape->bitangents = (GLUSfloat*) malloc(3 * source->numberVertices * sizeof(GLUSfloat));
if (!shape->bitangents)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->bitangents, source->bitangents, 3 * source->numberVertices * sizeof(GLUSfloat));
}
if (source->texCoords)
{
shape->texCoords = (GLUSfloat*) malloc(2 * source->numberVertices * sizeof(GLUSfloat));
if (!shape->texCoords)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->texCoords, source->texCoords, 2 * source->numberVertices * sizeof(GLUSfloat));
}
if (source->allAttributes)
{
shape->allAttributes = (GLUSfloat*) malloc(stride * source->numberVertices * sizeof(GLUSfloat));
if (!shape->allAttributes)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->allAttributes, source->allAttributes, stride * source->numberVertices * sizeof(GLUSfloat));
}
if (source->indices)
{
shape->indices = (GLUSushort*) malloc(source->numberIndices * sizeof(GLUSushort));
if (!shape->indices)
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->indices, source->indices, source->numberIndices * sizeof(GLUSushort));
}
return GLUS_TRUE;
}
GLUSboolean GLUSAPIENTRY glusCreateConef(GLUSshape* shape, const GLUSfloat halfExtend, const GLUSfloat radius, const GLUSushort numberSlices, const GLUSushort numberStacks)
{
GLUSuint i, j;
GLUSuint numberVertices = (numberSlices + 2) + (numberSlices + 1) * (numberStacks + 1);
GLUSuint numberIndices = numberSlices * 3 + numberSlices * 6 * numberStacks;
GLUSfloat angleStep = (2.0f * GLUS_PI) / ((GLUSfloat) numberSlices);
GLUSuint indexIndices;
GLUSuint centerIndex;
GLUSuint indexCounter;
GLUSuint vertexCounter = 0;
GLUSfloat h = 2.0f * halfExtend;
GLUSfloat r = radius;
GLUSfloat l = sqrtf(h*h + r*r);
if (numberSlices < 3 || numberStacks < 1 || numberVertices > GLUS_MAX_VERTICES || numberIndices > GLUS_MAX_INDICES)
{
return GLUS_FALSE;
}
if (!shape)
{
return GLUS_FALSE;
}
glusInitShapef(shape);
shape->numberVertices = numberVertices;
shape->numberIndices = numberIndices;
shape->vertices = (GLUSfloat*) malloc(4 * numberVertices * sizeof(GLUSfloat));
shape->normals = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->tangents = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->texCoords = (GLUSfloat*) malloc(2 * numberVertices * sizeof(GLUSfloat));
shape->indices = (GLUSushort*) malloc(numberIndices * sizeof(GLUSushort));
if (!glusCheckShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
// Center bottom
shape->vertices[vertexCounter * 4 + 0] = 0.0f;
shape->vertices[vertexCounter * 4 + 1] = -halfExtend;
shape->vertices[vertexCounter * 4 + 2] = 0.0f;
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = 0.0f;
shape->normals[vertexCounter * 3 + 1] = -1.0f;
shape->normals[vertexCounter * 3 + 2] = 0.0f;
shape->tangents[vertexCounter * 3 + 0] = 0.0f;
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = 1.0f;
shape->texCoords[vertexCounter * 2 + 0] = 0.0f;
shape->texCoords[vertexCounter * 2 + 1] = 0.0f;
vertexCounter++;
// Bottom
for (i = 0; i < (GLUSuint)(numberSlices + 1); i++)
{
GLUSfloat currentAngle = angleStep * (GLUSfloat)i;
shape->vertices[vertexCounter * 4 + 0] = cosf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 1] = -halfExtend;
shape->vertices[vertexCounter * 4 + 2] = -sinf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = 0.0f;
shape->normals[vertexCounter * 3 + 1] = -1.0f;
shape->normals[vertexCounter * 3 + 2] = 0.0f;
shape->tangents[vertexCounter * 3 + 0] = sinf(currentAngle);
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = cosf(currentAngle);
shape->texCoords[vertexCounter * 2 + 0] = 0.0f;
shape->texCoords[vertexCounter * 2 + 1] = 0.0f;
vertexCounter++;
}
for (j = 0; j < (GLUSuint)(numberStacks + 1); j++)
{
GLUSfloat level = (GLUSfloat)j / (GLUSfloat)numberStacks;
for (i = 0; i < (GLUSuint)(numberSlices + 1); i++)
{
GLUSfloat currentAngle = angleStep * (GLUSfloat)i;
shape->vertices[vertexCounter * 4 + 0] = cosf(currentAngle) * radius * (1.0f - level);
shape->vertices[vertexCounter * 4 + 1] = -halfExtend + 2.0f * halfExtend * level;
shape->vertices[vertexCounter * 4 + 2] = -sinf(currentAngle) * radius * (1.0f - level);
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = h / l * cosf(currentAngle);
shape->normals[vertexCounter * 3 + 1] = r / l;
shape->normals[vertexCounter * 3 + 2] = h / l * -sinf(currentAngle);
shape->tangents[vertexCounter * 3 + 0] = -sinf(currentAngle);
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = -cosf(currentAngle);
shape->texCoords[vertexCounter * 2 + 0] = (GLUSfloat)i / (GLUSfloat)numberSlices;
shape->texCoords[vertexCounter * 2 + 1] = level;
vertexCounter++;
}
}
indexIndices = 0;
// Bottom
centerIndex = 0;
indexCounter = 1;
for (i = 0; i < numberSlices; i++)
{
shape->indices[indexIndices++] = centerIndex;
shape->indices[indexIndices++] = indexCounter + 1;
shape->indices[indexIndices++] = indexCounter;
indexCounter++;
}
indexCounter++;
// Sides
for (j = 0; j < numberStacks; j++)
{
for (i = 0; i < numberSlices; i++)
{
shape->indices[indexIndices++] = indexCounter;
shape->indices[indexIndices++] = indexCounter + 1;
shape->indices[indexIndices++] = indexCounter + numberSlices + 1;
shape->indices[indexIndices++] = indexCounter + 1;
shape->indices[indexIndices++] = indexCounter + numberSlices + 2;
shape->indices[indexIndices++] = indexCounter + numberSlices + 1;
indexCounter++;
}
indexCounter++;
}
if (!glusFinalizeShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLUSshape background;
GLUSshape torus;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLfloat viewMatrix[16];
GLfloat lightDirection[3];
GLenum none[] = {GL_NONE};
lightDirection[0] = g_lightPosition[0];
lightDirection[1] = g_lightPosition[1];
lightDirection[2] = g_lightPosition[2];
glusVector3Normalizef(lightDirection);
//
glusLoadTextFile("../Example12_ES/shader/rendershadow.vert.glsl", &vertexSource);
glusLoadTextFile("../Example12_ES/shader/rendershadow.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_programShadow, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
glusLoadTextFile("../Example12_ES/shader/useshadow.vert.glsl", &vertexSource);
glusLoadTextFile("../Example12_ES/shader/useshadow.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixShadowLocation = glGetUniformLocation(g_programShadow.program, "u_projectionMatrix");
g_modelViewMatrixShadowLocation = glGetUniformLocation(g_programShadow.program, "u_modelViewMatrix");
g_vertexShadowLocation = glGetAttribLocation(g_programShadow.program, "a_vertex");
//
g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix");
g_viewMatrixLocation = glGetUniformLocation(g_program.program, "u_viewMatrix");
g_modelMatrixLocation = glGetUniformLocation(g_program.program, "u_modelMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_shadowMatrixLocation = glGetUniformLocation(g_program.program, "u_shadowMatrix");
g_shadowTextureLocation = glGetUniformLocation(g_program.program, "u_shadowTexture");
g_colorLocation = glGetUniformLocation(g_program.program, "u_shapeColor");
g_lightDirectionLocation = glGetUniformLocation(g_program.program, "u_lightDirection");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
//
glGenTextures(1, &g_shadowTexture);
glBindTexture(GL_TEXTURE_2D, g_shadowTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, g_shadowTextureSize, g_shadowTextureSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenFramebuffers(1, &g_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, g_fbo);
glDrawBuffers(1, none);
glReadBuffer(GL_NONE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, g_shadowTexture, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return GLUS_FALSE;
}
glClearDepthf(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//
glusCreateTorusf(&torus, 0.5f, 1.0f, 32, 32);
g_numberIndicesSphere = torus.numberIndices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, torus.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) torus.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, torus.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) torus.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, torus.numberIndices * sizeof(GLuint), (GLuint*) torus.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&torus);
//
glusCreatePlanef(&background, 10.0f);
g_numberIndicesBackground = background.numberIndices;
glGenBuffers(1, &g_verticesBackgroundVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
glBufferData(GL_ARRAY_BUFFER, background.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) background.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsBackgroundVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsBackgroundVBO);
glBufferData(GL_ARRAY_BUFFER, background.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) background.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesBackgroundVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, background.numberIndices * sizeof(GLuint), (GLuint*) background.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&background);
//
glUseProgram(g_program.program);
glusLookAtf(viewMatrix, g_cameraPosition[0], g_cameraPosition[1], g_cameraPosition[2], 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glusMatrix4x4MultiplyVector3f(lightDirection, viewMatrix, lightDirection);
glUniform3fv(g_lightDirectionLocation, 1, lightDirection);
glUniform1i(g_shadowTextureLocation, 0);
// Torus
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
// Plane
glGenVertexArrays(1, &g_vaoBackground);
glBindVertexArray(g_vaoBackground);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsBackgroundVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
//
glUseProgram(g_programShadow.program);
// Torus
glGenVertexArrays(1, &g_vaoShadow);
glBindVertexArray(g_vaoShadow);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexShadowLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexShadowLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
// Plane
glGenVertexArrays(1, &g_vaoShadowBackground);
glBindVertexArray(g_vaoShadowBackground);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
glVertexAttribPointer(g_vertexShadowLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexShadowLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepthf(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// Needed when rendering the shadow map. This will avoid artifacts.
glPolygonOffset(1.0f, 0.0f);
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLfloat viewMatrix[16];
GLfloat normalMatrix[9];
// This is a white light.
struct LightProperties light = { { 1.0f, 1.0f, 1.0f }, { 0.3f, 0.3f, 0.3f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } };
// Blue color material with white specular color.
struct MaterialProperties material = { { 0.0f, 0.0f, 1.0f, 1.0f }, { 0.0f, 0.0f, 1.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f }, 20.0f };
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLUSshape sphere;
glusLoadTextFile("../Example05/shader/phong.vert.glsl", &vertexSource);
glusLoadTextFile("../Example05/shader/phong.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix");
g_modelViewMatrixLocation = glGetUniformLocation(g_program.program, "u_modelViewMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_light.directionLocation = glGetUniformLocation(g_program.program, "u_light.direction");
g_light.ambientColorLocation = glGetUniformLocation(g_program.program, "u_light.ambientColor");
g_light.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_light.diffuseColor");
g_light.specularColorLocation = glGetUniformLocation(g_program.program, "u_light.specularColor");
g_material.ambientColorLocation = glGetUniformLocation(g_program.program, "u_material.ambientColor");
g_material.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_material.diffuseColor");
g_material.specularColorLocation = glGetUniformLocation(g_program.program, "u_material.specularColor");
g_material.specularExponentLocation = glGetUniformLocation(g_program.program, "u_material.specularExponent");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
//
// Use a helper function to create a sphere.
glusCreateSpheref(&sphere, 0.5f, 32);
g_numberIndices = sphere.numberIndices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, sphere.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) sphere.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, sphere.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) sphere.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sphere.numberIndices * sizeof(GLuint), (GLuint*) sphere.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&sphere);
//
glUseProgram(g_program.program);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
//
glusLookAtf(viewMatrix, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
// The calculations are done in camera / view space. So pass the view matrix, which is a rigid body transform.
glusMatrixExtract3x3f(normalMatrix, viewMatrix);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, viewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
//
glusVectorNormalizef(light.direction);
// Transform light to camera space, as it is currently in world space.
glusMatrixMultiplyVectorf(light.direction, viewMatrix, light.direction);
// Set up light ...
glUniform3fv(g_light.directionLocation, 1, light.direction);
glUniform4fv(g_light.ambientColorLocation, 1, light.ambientColor);
glUniform4fv(g_light.diffuseColorLocation, 1, light.diffuseColor);
glUniform4fv(g_light.specularColorLocation, 1, light.specularColor);
// ... and material values.
glUniform4fv(g_material.ambientColorLocation, 1, material.ambientColor);
glUniform4fv(g_material.diffuseColorLocation, 1, material.diffuseColor);
glUniform4fv(g_material.specularColorLocation, 1, material.specularColor);
glUniform1f(g_material.specularExponentLocation, material.specularExponent);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLUStgaimage image;
GLUSshape plane;
GLint i;
//
glusLookAtf(g_viewMatrix, g_camera.eye[0], g_camera.eye[1], g_camera.eye[2], g_camera.center[0], g_camera.center[1], g_camera.center[2], g_camera.up[0], g_camera.up[1], g_camera.up[2]);
//
if (!initWavefront(g_viewMatrix, &g_light))
{
return GLUS_FALSE;
}
//
glusLoadTextFile("../Example28/shader/texture.vert.glsl", &vertexSource);
glusLoadTextFile("../Example28/shader/texture.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**)&vertexSource.text, 0, 0, 0, (const GLUSchar**)&fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
// Retrieve the uniform locations in the program.
g_viewProjectionMatrixLocation = glGetUniformLocation(g_program.program, "u_viewProjectionMatrix");
g_modelMatrixLocation = glGetUniformLocation(g_program.program, "u_modelMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_lightDirectionLocation = glGetUniformLocation(g_program.program, "u_lightDirection");
g_repeatLocation = glGetUniformLocation(g_program.program, "u_repeat");
g_textureLocation = glGetUniformLocation(g_program.program, "u_texture");
// Retrieve the attribute locations in the program.
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
g_texCoordLocation = glGetAttribLocation(g_program.program, "a_texCoord");
//
// SSAO shader etc.
//
glusLoadTextFile("../Example28/shader/ssao.vert.glsl", &vertexSource);
glusLoadTextFile("../Example28/shader/ssao.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_ssaoProgram, (const GLUSchar**)&vertexSource.text, 0, 0, 0, (const GLUSchar**)&fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
// Retrieve the uniform locations in the program.
g_ssaoTextureLocation = glGetUniformLocation(g_ssaoProgram.program, "u_texture");
g_ssaoNormalTextureLocation = glGetUniformLocation(g_ssaoProgram.program, "u_normalTexture");
g_ssaoDepthTextureLocation = glGetUniformLocation(g_ssaoProgram.program, "u_depthTexture");
g_ssaoKernelLocation = glGetUniformLocation(g_ssaoProgram.program, "u_kernel");
g_ssaoRotationNoiseTextureLocation = glGetUniformLocation(g_ssaoProgram.program, "u_rotationNoiseTexture");
g_ssaoRotationNoiseScaleLocation = glGetUniformLocation(g_ssaoProgram.program, "u_rotationNoiseScale");
g_ssaoInverseProjectionMatrixLocation = glGetUniformLocation(g_ssaoProgram.program, "u_inverseProjectionMatrix");
g_ssaoProjectionMatrixLocation = glGetUniformLocation(g_ssaoProgram.program, "u_projectionMatrix");
g_ssaoRadiusLocation = glGetUniformLocation(g_ssaoProgram.program, "u_radius");
// Retrieve the attribute locations in the program.
g_ssaoVertexLocation = glGetAttribLocation(g_ssaoProgram.program, "a_vertex");
g_ssaoTexCoordLocation = glGetAttribLocation(g_ssaoProgram.program, "a_texCoord");
//
// Blur shader etc.
//
glusLoadTextFile("../Example28/shader/blur.vert.glsl", &vertexSource);
glusLoadTextFile("../Example28/shader/blur.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_blurProgram, (const GLUSchar**)&vertexSource.text, 0, 0, 0, (const GLUSchar**)&fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
// Retrieve the uniform locations in the program.
g_blurColorTextureLocation = glGetUniformLocation(g_blurProgram.program, "u_colorTexture");
g_blurSSAOTextureLocation = glGetUniformLocation(g_blurProgram.program, "u_ssaoTexture");
g_blurTexelStepLocation = glGetUniformLocation(g_blurProgram.program, "u_texelStep");
g_blurNoSSAOLocation = glGetUniformLocation(g_blurProgram.program, "u_noSSAO");
// Retrieve the attribute locations in the program.
g_blurVertexLocation = glGetAttribLocation(g_blurProgram.program, "a_vertex");
g_blurTexCoordLocation = glGetAttribLocation(g_blurProgram.program, "a_texCoord");
//
// Texture set up for the ground plane.
//
glusLoadTgaImage("wood_texture.tga", &image);
glGenTextures(1, &g_texture);
glBindTexture(GL_TEXTURE_2D, g_texture);
glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
// Mipmap generation is now included in OpenGL 3 and above
glGenerateMipmap(GL_TEXTURE_2D);
// Trilinear filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, 0);
//
// Setting up the SSAO frame buffer.
//
glGenTextures(1, &g_ssaoTexture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, g_ssaoTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GLUS_RGB, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GLUS_RGB, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenTextures(1, &g_ssaoNormalTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, g_ssaoNormalTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GLUS_RGB, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GLUS_RGB, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenTextures(1, &g_ssaoDepthTexture);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, g_ssaoDepthTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32F, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenFramebuffers(1, &g_ssaoFBO);
glBindFramebuffer(GL_FRAMEBUFFER, g_ssaoFBO);
// Attach the color buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_ssaoTexture, 0);
// Attach the normal buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, g_ssaoNormalTexture, 0);
// ... and the depth buffer,
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, g_ssaoDepthTexture, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return GLUS_FALSE;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//
// Setting up the blur frame buffer
//
glGenTextures(1, &g_blurTexture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, g_blurTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GLUS_RGB, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GLUS_RGB, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenFramebuffers(1, &g_blurFBO);
glBindFramebuffer(GL_FRAMEBUFFER, g_blurFBO);
// Attach the color buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_blurTexture, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return GLUS_FALSE;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//
// Ground plane setup.
//
glusCreatePlanef(&plane, 20.0f);
g_numberIndicesPlane = plane.numberIndices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*)plane.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 3 * sizeof(GLfloat), (GLfloat*)plane.normals, GL_STATIC_DRAW);
glGenBuffers(1, &g_texCoordsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 2 * sizeof(GLfloat), (GLfloat*)plane.texCoords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane.numberIndices * sizeof(GLuint), (GLuint*)plane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&plane);
//
glUseProgram(g_program.program);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsVBO);
glVertexAttribPointer(g_texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_texCoordLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBindVertexArray(0);
//
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, g_texture);
glUniform1i(g_textureLocation, 0);
// How many times the surface texture is repeated.
glUniform1f(g_repeatLocation, 6.0f);
//
// Post process plane setup.
//
glusCreatePlanef(&plane, 1.0f);
g_numberIndicesPostprocessPlane = plane.numberIndices;
glGenBuffers(1, &g_postprocessVerticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_postprocessVerticesVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*)plane.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_postprocessTexCoordsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_postprocessTexCoordsVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 2 * sizeof(GLfloat), (GLfloat*)plane.texCoords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_postprocessIndicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_postprocessIndicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane.numberIndices * sizeof(GLuint), (GLuint*)plane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&plane);
//
glUseProgram(g_ssaoProgram.program);
glGenVertexArrays(1, &g_ssaoVAO);
glBindVertexArray(g_ssaoVAO);
glBindBuffer(GL_ARRAY_BUFFER, g_postprocessVerticesVBO);
glVertexAttribPointer(g_ssaoVertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_ssaoVertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_postprocessTexCoordsVBO);
glVertexAttribPointer(g_ssaoTexCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_ssaoTexCoordLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_postprocessIndicesVBO);
glBindVertexArray(0);
//
glUniform1i(g_ssaoTextureLocation, 0);
glUniform1i(g_ssaoNormalTextureLocation, 1);
glUniform1i(g_ssaoDepthTextureLocation, 2);
glUniform1i(g_ssaoRotationNoiseTextureLocation, 3);
glUniform1f(g_ssaoRadiusLocation, SSAO_RADIUS);
//
// Create the Kernel for SSAO.
//
for (i = 0; i < KERNEL_SIZE; i++)
{
g_kernel[i * 3 + 0] = glusRandomUniformGetFloatf(-1.0f, 1.0f);
g_kernel[i * 3 + 1] = glusRandomUniformGetFloatf(-1.0f, 1.0f);
g_kernel[i * 3 + 2] = glusRandomUniformGetFloatf(0.0f, 1.0f); // Kernel hemisphere points to positive Z-Axis.
glusVector3Normalizef(&g_kernel[i * 3]); // Normalize, so included in the hemisphere.
GLfloat scale = (GLfloat)i / (GLfloat)KERNEL_SIZE; // Create a scale value between [0;1[ .
scale = glusClampf(scale * scale, 0.1f, 1.0f); // Adjust scale, that there are more values closer to the center of the g_kernel.
glusVector3MultiplyScalarf(&g_kernel[i * 3], &g_kernel[i * 3], scale);
}
// Pass g_kernel to shader
glUniform3fv(g_ssaoKernelLocation, KERNEL_SIZE, g_kernel);
//
// Create the rotation noise texture
//
for (i = 0; i < ROTATION_NOISE_SIZE; i++)
{
g_rotationNoise[i * 3 + 0] = glusRandomUniformGetFloatf(-1.0f, 1.0f);
g_rotationNoise[i * 3 + 1] = glusRandomUniformGetFloatf(-1.0f, 1.0f);
g_rotationNoise[i * 3 + 2] = 0.0f; // Rotate on x-y-plane, so z is zero.
glusVector3Normalizef(&g_rotationNoise[i * 3]); // Normalized rotation vector.
}
//
glGenTextures(1, &g_ssaoRotationNoiseTexture);
glBindTexture(GL_TEXTURE_2D, g_ssaoRotationNoiseTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, ROTATION_NOISE_SIDE_LENGTH, ROTATION_NOISE_SIDE_LENGTH, 0, GL_RGB, GL_FLOAT, g_rotationNoise);
// No filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, 0);
//
//
g_rotationNoiseScale[0] = (GLfloat)TEXTURE_WIDTH / (GLfloat)ROTATION_NOISE_SIDE_LENGTH;
g_rotationNoiseScale[1] = (GLfloat)TEXTURE_HEIGHT / (GLfloat)ROTATION_NOISE_SIDE_LENGTH;
// Pass the scale, as the rotation noise texture is repeated over the screen x / y times.
glUniform2fv(g_ssaoRotationNoiseScaleLocation, 1, g_rotationNoiseScale);
//
//
glUseProgram(g_blurProgram.program);
glGenVertexArrays(1, &g_blurVAO);
glBindVertexArray(g_blurVAO);
glBindBuffer(GL_ARRAY_BUFFER, g_postprocessVerticesVBO);
glVertexAttribPointer(g_blurVertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_blurVertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_postprocessTexCoordsVBO);
glVertexAttribPointer(g_blurTexCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_blurTexCoordLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_postprocessIndicesVBO);
glBindVertexArray(0);
//
glUniform1i(g_blurColorTextureLocation, 0);
glUniform1i(g_blurSSAOTextureLocation, 1);
g_texelStep[0] = 1.0f / (GLfloat)TEXTURE_WIDTH;
g_texelStep[1] = 1.0f / (GLfloat)TEXTURE_HEIGHT;
// Pass the value to step from one to another texel.
glUniform2fv(g_blurTexelStepLocation, 1, g_texelStep);
// Variable to toggle between SSAO on and off
glUniform1f(g_blurNoSSAOLocation, 0.0f);
//
// Basic OpenGL set up.
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
return GLUS_TRUE;
}
GLUSuint initWaterTexture(GLUSfloat waterPlaneLength)
{
GLfloat projectionMatrixWaterTexture[16];
GLfloat modelViewMatrixWaterTexture[16];
GLUSshape plane;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
glusLoadTextFile("../Example15/shader/WaterTexture.vert.glsl", &vertexSource);
glusLoadTextFile("../Example15/shader/WaterTexture.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_programWaterTexture, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_projectionMatrix");
g_modelViewMatrixWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_modelViewMatrix");
g_waterPlaneLengthWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_waterPlaneLength");
g_passedTimeWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_passedTime");
g_waveParametersWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_waveParameters");
g_waveDirectionsWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_waveDirections");
g_vertexWaterTextureLocation = glGetAttribLocation(g_programWaterTexture.program, "a_vertex");
g_texCoordWaterTextureLocation = glGetAttribLocation(g_programWaterTexture.program, "a_texCoord");
//
glGenTextures(1, &g_mirrorTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, g_mirrorTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GLUS_RGB, TEXTURE_SIZE, TEXTURE_SIZE, 0, GLUS_RGB, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenRenderbuffers(1, &g_depthMirrorTexture);
glBindRenderbuffer(GL_RENDERBUFFER, g_depthMirrorTexture);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, TEXTURE_SIZE, TEXTURE_SIZE);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
//
glGenFramebuffers(1, &g_fboWaterTexture);
glBindFramebuffer(GL_FRAMEBUFFER, g_fboWaterTexture);
// Attach the color buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_mirrorTexture, 0);
// ... and the depth buffer,
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, g_depthMirrorTexture);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return GLUS_FALSE;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//
glBindVertexArray(0);
//
glusCreatePlanef(&plane, TEXTURE_SIZE / 2.0f);
g_numberIndicesWaterTexture = plane.numberIndices;
glGenBuffers(1, &g_verticesWaterTextureVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesWaterTextureVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) plane.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_texCoordsWaterTextureVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsWaterTextureVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 2 * sizeof(GLfloat), (GLfloat*) plane.texCoords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesWaterTextureVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesWaterTextureVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane.numberIndices * sizeof(GLuint), (GLuint*) plane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&plane);
//
glUseProgram(g_programWaterTexture.program);
glusLookAtf(modelViewMatrixWaterTexture, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glUniformMatrix4fv(g_modelViewMatrixWaterTextureLocation, 1, GL_FALSE, modelViewMatrixWaterTexture);
glusOrthof(projectionMatrixWaterTexture, -(GLfloat) TEXTURE_SIZE / 2, (GLfloat) TEXTURE_SIZE / 2, -(GLfloat) TEXTURE_SIZE / 2, (GLfloat) TEXTURE_SIZE / 2, 1.0f, 100.0f);
glUniformMatrix4fv(g_projectionMatrixWaterTextureLocation, 1, GL_FALSE, projectionMatrixWaterTexture);
glUniform1f(g_waterPlaneLengthWaterTextureLocation, waterPlaneLength);
//
glGenVertexArrays(1, &g_vaoWaterTexture);
glBindVertexArray(g_vaoWaterTexture);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesWaterTextureVBO);
glVertexAttribPointer(g_vertexWaterTextureLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexWaterTextureLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsWaterTextureVBO);
glVertexAttribPointer(g_texCoordWaterTextureLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_texCoordWaterTextureLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesWaterTextureVBO);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
return g_mirrorTexture;
}
GLUSboolean init(GLUSvoid)
{
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLUStgaimage image;
GLUSgroupList* groupWalker;
GLUSmaterialList* materialWalker;
GLUSshape sphere;
//
// Each point light is rendered as a sphere.
//
glusLoadTextFile("../Example31/shader/point_light.vert.glsl", &vertexSource);
glusLoadTextFile("../Example31/shader/point_light.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_programPointLight, (const GLUSchar**)&vertexSource.text, 0, 0, 0, (const GLUSchar**)&fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixPointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_projectionMatrix");
g_viewMatrixPointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_viewMatrix");
g_modelMatrixPointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_modelMatrix");
g_positionMatrixPointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_positionMatrix");
g_biasMatrixPointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_biasMatrix");
g_radiusPointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_lightRadius");
g_diffusePointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_diffuse");
g_specularPointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_specular");
g_positionPointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_position");
g_normalPointLightLocation = glGetUniformLocation(g_programPointLight.program, "u_normal");
g_vertexPointLightLocation = glGetAttribLocation(g_programPointLight.program, "a_vertex");
// Use a helper function to create a cube.
glusCreateSpheref(&sphere, POINT_LIGHT_RADIUS, 32);
g_numberIndicesPointLight = sphere.numberIndices;
glGenBuffers(1, &g_verticesPointLightVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPointLightVBO);
// Transfer the vertices from CPU to GPU.
glBufferData(GL_ARRAY_BUFFER, sphere.numberVertices * 4 * sizeof(GLfloat), (GLfloat*)sphere.vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesPointLightVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPointLightVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sphere.numberIndices * sizeof(GLuint), (GLuint*)sphere.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&sphere);
glGenVertexArrays(1, &g_vaoPointLight);
glBindVertexArray(g_vaoPointLight);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPointLightVBO);
glVertexAttribPointer(g_vertexPointLightLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexPointLightLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPointLightVBO);
glBindVertexArray(0);
//
// The point lights are moving forth and back between the columns and rows.
// Here, a random position and moving direction of the point light is generated.
//
glusRandomSetSeed(13);
// Note: If more than 16 lights are used, make sure to store them in another matrix or buffer.
for (GLint i = 0; i < POINT_LIGHT_COUNT; i++)
{
g_positionMatrix[i] = glusRandomUniformGetFloatf(0.0f, (float)POINT_LIGHT_COUNT - 2.0f);
g_directionMatrix[i] = rand() % 2 == 0 ? 1.0f : -1.0f;
}
//
//
//
glusLoadTextFile("../Example31/shader/deferred_shading.vert.glsl", &vertexSource);
glusLoadTextFile("../Example31/shader/deferred_shading.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_programDeferredShading, (const GLUSchar**)&vertexSource.text, 0, 0, 0, (const GLUSchar**)&fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixLocation = glGetUniformLocation(g_programDeferredShading.program, "u_projectionMatrix");
g_viewMatrixLocation = glGetUniformLocation(g_programDeferredShading.program, "u_viewMatrix");
g_modelMatrixLocation = glGetUniformLocation(g_programDeferredShading.program, "u_modelMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_programDeferredShading.program, "u_normalMatrix");
g_material.diffuseColorLocation = glGetUniformLocation(g_programDeferredShading.program, "u_material.diffuseColor");
g_material.specularColorLocation = glGetUniformLocation(g_programDeferredShading.program, "u_material.specularColor");
g_material.specularExponentLocation = glGetUniformLocation(g_programDeferredShading.program, "u_material.specularExponent");
g_material.diffuseTextureLocation = glGetUniformLocation(g_programDeferredShading.program, "u_material.diffuseTexture");
g_useTextureLocation = glGetUniformLocation(g_programDeferredShading.program, "u_useTexture");
g_vertexLocation = glGetAttribLocation(g_programDeferredShading.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_programDeferredShading.program, "a_normal");
g_texCoordLocation = glGetAttribLocation(g_programDeferredShading.program, "a_texCoord");
//
// Use a helper function to load the wavefront object file.
//
glusLoadGroupedObjFile("ChessPawn.obj", &g_wavefront);
glGenBuffers(1, &g_wavefront.verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_wavefront.verticesVBO);
glBufferData(GL_ARRAY_BUFFER, g_wavefront.numberVertices * 4 * sizeof(GLfloat), (GLfloat*)g_wavefront.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_wavefront.normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_wavefront.normalsVBO);
glBufferData(GL_ARRAY_BUFFER, g_wavefront.numberVertices * 3 * sizeof(GLfloat), (GLfloat*)g_wavefront.normals, GL_STATIC_DRAW);
glGenBuffers(1, &g_wavefront.texCoordsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_wavefront.texCoordsVBO);
glBufferData(GL_ARRAY_BUFFER, g_wavefront.numberVertices * 2 * sizeof(GLfloat), (GLfloat*)g_wavefront.texCoords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
//
// Set up indices and the VAOs for each group
//
glUseProgram(g_programDeferredShading.program);
groupWalker = g_wavefront.groups;
while (groupWalker)
{
glGenBuffers(1, &groupWalker->group.indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, groupWalker->group.indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, groupWalker->group.numberIndices * sizeof(GLuint), (GLuint*)groupWalker->group.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
//
glGenVertexArrays(1, &groupWalker->group.vao);
glBindVertexArray(groupWalker->group.vao);
glBindBuffer(GL_ARRAY_BUFFER, g_wavefront.verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_wavefront.normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_wavefront.texCoordsVBO);
glVertexAttribPointer(g_texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_texCoordLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, groupWalker->group.indicesVBO);
glBindVertexArray(0);
groupWalker = groupWalker->next;
}
//
// Load the textures, if there are available
//
materialWalker = g_wavefront.materials;
while (materialWalker)
{
if (materialWalker->material.diffuseTextureFilename[0] != '\0')
{
// Load the image.
glusLoadTgaImage(materialWalker->material.diffuseTextureFilename, &image);
// Generate and bind a texture.
glGenTextures(1, &materialWalker->material.diffuseTextureName);
glBindTexture(GL_TEXTURE_2D, materialWalker->material.diffuseTextureName);
// Transfer the image data from the CPU to the GPU.
glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
// Setting the texture parameters.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
}
materialWalker = materialWalker->next;
}
//
// Setting up the deferred shading geometry buffer.
//
glGenTextures(1, &g_dsDiffuseTexture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, g_dsDiffuseTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenTextures(1, &g_dsSpecularTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, g_dsSpecularTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenTextures(1, &g_dsPositionTexture);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, g_dsPositionTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_RGBA, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenTextures(1, &g_dsNormalTexture);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, g_dsNormalTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_RGB, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//
glGenTextures(1, &g_dsDepthTexture);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, g_dsDepthTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE0);
//
glGenFramebuffers(1, &g_dsFBO);
glBindFramebuffer(GL_FRAMEBUFFER, g_dsFBO);
// Attach the color buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_dsDiffuseTexture, 0);
// Attach the normal buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, g_dsSpecularTexture, 0);
// Attach the color buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, g_dsPositionTexture, 0);
// Attach the normal buffer ...
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_2D, g_dsNormalTexture, 0);
// ... and the depth buffer,
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, g_dsDepthTexture, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return GLUS_FALSE;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//
//
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// The color buffer is accumulated for each light, so use this blend function when doing the lighting pass.
glBlendFunc(GL_ONE, GL_ONE);
return GLUS_TRUE;
}
GLUSboolean GLUSAPIENTRY glusCreateRectangularPlanef(GLUSshape* shape, const GLUSfloat horizontalExtend, const GLUSfloat verticalExtend)
{
GLUSuint i;
GLUSuint numberVertices = 4;
GLUSuint numberIndices = 6;
GLUSfloat xy_vertices[] = { -1.0f, -1.0f, 0.0f, +1.0f, +1.0f, -1.0f, 0.0f, +1.0f, -1.0f, +1.0f, 0.0f, +1.0f, +1.0f, +1.0f, 0.0f, +1.0f };
GLUSfloat xy_normals[] = { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f };
GLUSfloat xy_tangents[] = { 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f };
GLUSfloat xy_texCoords[] = { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f };
GLUSushort xy_indices[] = { 0, 1, 2, 1, 3, 2 };
if (!shape)
{
return GLUS_FALSE;
}
glusInitShapef(shape);
shape->numberVertices = numberVertices;
shape->numberIndices = numberIndices;
shape->vertices = (GLUSfloat*) malloc(4 * numberVertices * sizeof(GLUSfloat));
shape->normals = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->tangents = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->texCoords = (GLUSfloat*) malloc(2 * numberVertices * sizeof(GLUSfloat));
shape->indices = (GLUSushort*) malloc(numberIndices * sizeof(GLUSushort));
if (!glusCheckShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->vertices, xy_vertices, sizeof(xy_vertices));
for (i = 0; i < numberVertices; i++)
{
shape->vertices[i * 4 + 0] *= horizontalExtend;
shape->vertices[i * 4 + 1] *= verticalExtend;
}
memcpy(shape->normals, xy_normals, sizeof(xy_normals));
memcpy(shape->tangents, xy_tangents, sizeof(xy_tangents));
memcpy(shape->texCoords, xy_texCoords, sizeof(xy_texCoords));
memcpy(shape->indices, xy_indices, sizeof(xy_indices));
if (!glusFinalizeShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
/**
* Function for initialization.
*/
GLUSboolean init(GLUSvoid)
{
// Points of a triangle.
GLfloat* points = (GLfloat*)malloc(WATER_PLANE_LENGTH*WATER_PLANE_LENGTH*4*sizeof(GLfloat));
GLuint* indices = (GLuint*)malloc(WATER_PLANE_LENGTH*(WATER_PLANE_LENGTH-1)*2*sizeof(GLuint));
GLUSshape background;
GLUStgaimage image;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLuint x, z, i, k;
GLuint waterTexture;
for (z = 0; z < WATER_PLANE_LENGTH; z++)
{
for (x = 0; x < WATER_PLANE_LENGTH; x++)
{
points[(x+z*(WATER_PLANE_LENGTH))*4 + 0] = -(GLfloat)WATER_PLANE_LENGTH/2 + 0.5f + (GLfloat)x;
points[(x+z*(WATER_PLANE_LENGTH))*4 + 1] = 0.0f;
points[(x+z*(WATER_PLANE_LENGTH))*4 + 2] = +(GLfloat)WATER_PLANE_LENGTH/2 - 0.5f - (GLfloat)z;
points[(x+z*(WATER_PLANE_LENGTH))*4 + 3] = 1.0f;
}
}
for (k = 0; k < WATER_PLANE_LENGTH-1; k++)
{
for (i = 0; i < WATER_PLANE_LENGTH; i++)
{
if (k%2 == 0)
{
indices[(i+k*(WATER_PLANE_LENGTH))*2 + 0] = i + k*WATER_PLANE_LENGTH;
indices[(i+k*(WATER_PLANE_LENGTH))*2 + 1] = i + (k+1)*WATER_PLANE_LENGTH;
}
else
{
indices[(i+k*(WATER_PLANE_LENGTH))*2 + 0] = WATER_PLANE_LENGTH - 1 - i + k*WATER_PLANE_LENGTH;
indices[(i+k*(WATER_PLANE_LENGTH))*2 + 1] = WATER_PLANE_LENGTH - 1 - i + (k+1)*WATER_PLANE_LENGTH;
}
}
}
// Load the source of the vertex shader.
glusLoadTextFile("../src/Example14/Vertex.vs", &vertexSource);
// Load the source of the fragment shader.
glusLoadTextFile("../src/Example14/Fragment.fs", &fragmentSource);
// Build and ...
glusBuildProgram(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
// Destroy the text resource
glusDestroyTextFile(&vertexSource);
// Destroy the text resource
glusDestroyTextFile(&fragmentSource);
// ToDo:
glGenVertexArrays(1, &g_vao);
// ToDo:
glBindVertexArray(g_vao);
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_projectionLocation = glGetUniformLocation(g_program.program, "projectionMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_modelViewLocation = glGetUniformLocation(g_program.program, "modelViewMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_waterPlaneLengthLocation = glGetUniformLocation(g_program.program, "waterPlaneLength");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_inverseCameraLocation = glGetUniformLocation(g_program.program, "inverseCameraMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_cubemapLocation = glGetUniformLocation(g_program.program, "cubemap");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_waterLocation = glGetUniformLocation(g_program.program, "waterTexture");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_passedTimeLocation = glGetUniformLocation(g_program.program, "passedTime");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_waveParametersLocation = glGetUniformLocation(g_program.program, "waveParameters");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_waveDirectionsLocation = glGetUniformLocation(g_program.program, "waveDirections");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_vertexLocation = glGetAttribLocation(g_program.program, "vertex");
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, WATER_PLANE_LENGTH*WATER_PLANE_LENGTH * 4 * sizeof(GLfloat), (GLfloat*) points, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_indices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ELEMENT_ARRAY_BUFFER, WATER_PLANE_LENGTH*(WATER_PLANE_LENGTH-1) * 2 * sizeof(GLuint), (GLuint*) indices, GL_STATIC_DRAW);
//
free(points);
free(indices);
//
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/gentextures.html
glGenTextures(1, &g_cubemap);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html
glBindTexture(GL_TEXTURE_CUBE_MAP, g_cubemap);
glusLoadTgaImage("water_pos_x.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("water_neg_x.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("water_pos_y.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("water_neg_y.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("water_pos_z.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("water_neg_z.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
//
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_program.program);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniform1f(g_waterPlaneLengthLocation, (GLUSfloat)WATER_PLANE_LENGTH);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_vertexLocation);
// http://www.opengl.org/sdk/docs/man/xhtml/glActiveTexture.xml
glActiveTexture(GL_TEXTURE0);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html
glBindTexture(GL_TEXTURE_CUBE_MAP, g_cubemap);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniform1i(g_cubemapLocation, 0);
// Get the render buffer texture
waterTexture = initTexture((GLUSfloat)WATER_PLANE_LENGTH);
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_program.program);
// http://www.opengl.org/sdk/docs/man/xhtml/glActiveTexture.xml
glActiveTexture(GL_TEXTURE1);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html
glBindTexture(GL_TEXTURE_2D, waterTexture);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniform1i(g_waterLocation, 1);
//
// Load the source of the vertex shader.
glusLoadTextFile("../src/Example14/VertexBackground.vs", &vertexSource);
// Load the source of the fragment shader.
glusLoadTextFile("../src/Example14/FragmentBackground.fs", &fragmentSource);
// Build and ...
glusBuildProgram(&g_programBackground, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
// Destroy the text resource
glusDestroyTextFile(&vertexSource);
// Destroy the text resource
glusDestroyTextFile(&fragmentSource);
// ToDo:
glGenVertexArrays(1, &g_vaoBackground);
// ToDo:
glBindVertexArray(g_vaoBackground);
glusCreateSpheref(&background, (GLfloat)(GLfloat)WATER_PLANE_LENGTH/2.0f + 0.5f, 32);
g_numberIndicesBackground = background.numberIndices;
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_projectionLocationBackground = glGetUniformLocation(g_programBackground.program, "projectionMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_modelViewLocationBackground = glGetUniformLocation(g_programBackground.program, "modelViewMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_cubemapLocationBackground = glGetUniformLocation(g_programBackground.program, "cubemap");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_vertexLocationBackground = glGetAttribLocation(g_programBackground.program, "vertex");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_normalLocationBackground = glGetAttribLocation(g_programBackground.program, "normal");
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_verticesBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, background.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) background.vertices, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_normalsBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_normalsBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, background.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) background.normals, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_indicesBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ELEMENT_ARRAY_BUFFER, background.numberIndices * sizeof(GLuint), (GLuint*) background.indices, GL_STATIC_DRAW);
glusDestroyShapef(&background);
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_programBackground.program);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniformMatrix4fv(g_modelViewLocationBackground, 1, GL_FALSE, g_modelView);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_vertexLocationBackground, 4, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_vertexLocationBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_normalsBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_normalLocationBackground, 3, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_normalLocationBackground);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniform1i(g_cubemapLocationBackground, 0);
//
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clearcolor.html
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/cleardepth.html
glClearDepth(1.0f);
//http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html
glEnable( GL_DEPTH_TEST);
return GLUS_TRUE;
}
GLUSboolean GLUSAPIENTRY glusCreateRectangularGridPlanef(GLUSshape* shape, const GLUSfloat horizontalExtend, const GLUSfloat verticalExtend, const GLUSushort rows, const GLUSushort columns, const GLUSboolean triangleStrip)
{
GLUSuint i, currentRow, currentColumn;
GLUSuint numberVertices = (rows + 1) * (columns + 1);
GLUSuint numberIndices;
GLUSfloat x, y, s, t;
if (triangleStrip)
{
numberIndices = rows * 2 * (columns + 1);
}
else
{
numberIndices = rows * 6 * columns;
}
if (rows < 1 || columns < 1 || numberVertices > GLUS_MAX_VERTICES || numberIndices > GLUS_MAX_INDICES)
{
return GLUS_FALSE;
}
if (!shape)
{
return GLUS_FALSE;
}
glusInitShapef(shape);
if (triangleStrip)
{
shape->mode = GL_TRIANGLE_STRIP;
}
else
{
shape->mode = GL_TRIANGLES;
}
shape->numberVertices = numberVertices;
shape->numberIndices = numberIndices;
shape->vertices = (GLUSfloat*) malloc(4 * numberVertices * sizeof(GLUSfloat));
shape->normals = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->tangents = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->texCoords = (GLUSfloat*) malloc(2 * numberVertices * sizeof(GLUSfloat));
shape->indices = (GLUSushort*) malloc(numberIndices * sizeof(GLUSushort));
if (!glusCheckShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
for (i = 0; i < numberVertices; i++)
{
x = (GLUSfloat) (i % (columns + 1)) / (GLUSfloat) columns;
y = 1.0f - (GLUSfloat) (i / (columns + 1)) / (GLUSfloat) rows;
s = x;
t = y;
shape->vertices[i * 4 + 0] = horizontalExtend * (x - 0.5f);
shape->vertices[i * 4 + 1] = verticalExtend * (y - 0.5f);
shape->vertices[i * 4 + 2] = 0.0f;
shape->vertices[i * 4 + 3] = 1.0f;
shape->normals[i * 3 + 0] = 0.0f;
shape->normals[i * 3 + 1] = 0.0f;
shape->normals[i * 3 + 2] = 1.0f;
shape->tangents[i * 3 + 0] = 1.0f;
shape->tangents[i * 3 + 1] = 0.0f;
shape->tangents[i * 3 + 2] = 0.0f;
shape->texCoords[i * 2 + 0] = s;
shape->texCoords[i * 2 + 1] = t;
}
if (triangleStrip)
{
for (i = 0; i < (GLUSuint)(rows * (columns + 1)); i++)
{
currentColumn = i % (columns + 1);
currentRow = i / (columns + 1);
if (currentRow == 0)
{
// Left to right, top to bottom
shape->indices[i * 2] = currentColumn + currentRow * (columns + 1);
shape->indices[i * 2 + 1] = currentColumn + (currentRow + 1) * (columns + 1);
}
else
{
// Right to left, bottom to up
shape->indices[i * 2] = (columns - currentColumn) + (currentRow + 1) * (columns + 1);
shape->indices[i * 2 + 1] = (columns - currentColumn) + currentRow * (columns + 1);
}
}
}
else
{
for (i = 0; i < (GLUSuint)(rows * columns); i++)
{
currentColumn = i % columns;
currentRow = i / columns;
shape->indices[i * 6 + 0] = currentColumn + currentRow * (columns + 1);
shape->indices[i * 6 + 1] = currentColumn + (currentRow + 1) * (columns + 1);
shape->indices[i * 6 + 2] = (currentColumn + 1) + (currentRow + 1) * (columns + 1);
shape->indices[i * 6 + 3] = (currentColumn + 1) + (currentRow + 1) * (columns + 1);
shape->indices[i * 6 + 4] = (currentColumn + 1) + currentRow * (columns + 1);
shape->indices[i * 6 + 5] = currentColumn + currentRow * (columns + 1);
}
}
if (!glusFinalizeShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
// This is a white light.
struct LightProperties light = { { 1.0f, 1.0f, 1.0f }, { 0.3f, 0.3f, 0.3f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } };
// Blue color material with white specular color.
struct MaterialProperties material = { { 0.0f, 0.1f, 0.1f, 1.0f }, { 0.0f, 0.8f, 0.8f, 1.0f }, { 0.6f, 0.6f, 0.6f, 1.0f }, 60.0f };
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLUSshape sphere;
GLUSshape plane;
glusLoadTextFile("../Example18/shader/phong.vert.glsl", &vertexSource);
glusLoadTextFile("../Example18/shader/phong.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix");
g_viewMatrixLocation = glGetUniformLocation(g_program.program, "u_viewMatrix");
g_modelMatrixLocation = glGetUniformLocation(g_program.program, "u_modelMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_light.directionLocation = glGetUniformLocation(g_program.program, "u_light.direction");
g_light.ambientColorLocation = glGetUniformLocation(g_program.program, "u_light.ambientColor");
g_light.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_light.diffuseColor");
g_light.specularColorLocation = glGetUniformLocation(g_program.program, "u_light.specularColor");
g_material.ambientColorLocation = glGetUniformLocation(g_program.program, "u_material.ambientColor");
g_material.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_material.diffuseColor");
g_material.specularColorLocation = glGetUniformLocation(g_program.program, "u_material.specularColor");
g_material.specularExponentLocation = glGetUniformLocation(g_program.program, "u_material.specularExponent");
g_planeLocation = glGetUniformLocation(g_program.program, "u_plane");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
//
// Use a helper function to create a sphere.
glusCreateSpheref(&sphere, 0.5f, 64);
g_numberIndicesSphere = sphere.numberIndices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, sphere.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) sphere.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, sphere.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) sphere.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sphere.numberIndices * sizeof(GLuint), (GLuint*) sphere.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&sphere);
//
glusCreatePlanef(&plane, 0.5f);
g_numberIndicesPlane = plane.numberIndices;
glGenBuffers(1, &g_verticesPlaneVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPlaneVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) plane.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsPlaneVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsPlaneVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) plane.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesPlaneVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPlaneVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane.numberIndices * sizeof(GLuint), (GLuint*) plane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&plane);
//
glUseProgram(g_program.program);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
//
glGenVertexArrays(1, &g_planeVAO);
glBindVertexArray(g_planeVAO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesPlaneVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsPlaneVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPlaneVBO);
//
glusLookAtf(g_viewMatrix, 0.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glUniformMatrix4fv(g_viewMatrixLocation, 1, GL_FALSE, g_viewMatrix);
//
glusVector3Normalizef(light.direction);
// Transform light to camera space, as it is currently in world space.
glusMatrix4x4MultiplyVector3f(light.direction, g_viewMatrix, light.direction);
// Set up light ...
glUniform3fv(g_light.directionLocation, 1, light.direction);
glUniform4fv(g_light.ambientColorLocation, 1, light.ambientColor);
glUniform4fv(g_light.diffuseColorLocation, 1, light.diffuseColor);
glUniform4fv(g_light.specularColorLocation, 1, light.specularColor);
// ... and material values.
glUniform4fv(g_material.ambientColorLocation, 1, material.ambientColor);
glUniform4fv(g_material.diffuseColorLocation, 1, material.diffuseColor);
glUniform4fv(g_material.specularColorLocation, 1, material.specularColor);
glUniform1f(g_material.specularExponentLocation, material.specularExponent);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
// No back face culling, as we need it for the stencil algorithm.
// Enable the stencil test - mainly needed for the plane.
glEnable(GL_STENCIL_TEST);
return GLUS_TRUE;
}
GLUSboolean GLUSAPIENTRY glusCreateDiscf(GLUSshape* shape, const GLUSfloat radius, const GLUSushort numberSectors)
{
GLUSuint i;
GLUSuint numberVertices = numberSectors + 2;
GLUSuint numberIndices = numberSectors * 3;
GLUSfloat angleStep = (2.0f * GLUS_PI) / ((GLUSfloat) numberSectors);
GLUSuint indexIndices;
GLUSuint indexCounter;
GLUSuint vertexCounter = 0;
if (numberSectors < 3 || numberVertices > GLUS_MAX_VERTICES || numberIndices > GLUS_MAX_INDICES)
{
return GLUS_FALSE;
}
if (!shape)
{
return GLUS_FALSE;
}
glusInitShapef(shape);
shape->numberVertices = numberVertices;
shape->numberIndices = numberIndices;
shape->vertices = (GLUSfloat*) malloc(4 * numberVertices * sizeof(GLUSfloat));
shape->normals = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->tangents = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->texCoords = (GLUSfloat*) malloc(2 * numberVertices * sizeof(GLUSfloat));
shape->indices = (GLUSushort*) malloc(numberIndices * sizeof(GLUSushort));
if (!glusCheckShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
// Center
shape->vertices[vertexCounter * 4 + 0] = 0.0f;
shape->vertices[vertexCounter * 4 + 1] = 0.0f;
shape->vertices[vertexCounter * 4 + 2] = 0.0f;
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = 0.0f;
shape->normals[vertexCounter * 3 + 1] = 0.0f;
shape->normals[vertexCounter * 3 + 2] = 1.0f;
shape->tangents[vertexCounter * 3 + 0] = 1.0f;
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = 0.0f;
shape->texCoords[vertexCounter * 2 + 0] = 0.5f;
shape->texCoords[vertexCounter * 2 + 1] = 0.5f;
vertexCounter++;
for (i = 0; i < (GLUSuint)(numberSectors + 1); i++)
{
GLUSfloat currentAngle = angleStep * (GLUSfloat)i;
shape->vertices[vertexCounter * 4 + 0] = cosf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 1] = sinf(currentAngle) * radius;
shape->vertices[vertexCounter * 4 + 2] = 0.0f;
shape->vertices[vertexCounter * 4 + 3] = 1.0f;
shape->normals[vertexCounter * 3 + 0] = 0.0f;
shape->normals[vertexCounter * 3 + 1] = 0.0f;
shape->normals[vertexCounter * 3 + 2] = 1.0f;
shape->tangents[vertexCounter * 3 + 0] = 1.0f;
shape->tangents[vertexCounter * 3 + 1] = 0.0f;
shape->tangents[vertexCounter * 3 + 2] = 0.0f;
shape->texCoords[vertexCounter * 2 + 0] = 0.5f * cosf(currentAngle) * 0.5f;
shape->texCoords[vertexCounter * 2 + 1] = 0.5f * sinf(currentAngle) * 0.5f;
vertexCounter++;
}
indexIndices = 0;
// Bottom
indexCounter = 1;
for (i = 0; i < numberSectors; i++)
{
shape->indices[indexIndices++] = 0;
shape->indices[indexIndices++] = indexCounter;
shape->indices[indexIndices++] = indexCounter + 1;
indexCounter++;
}
if (!glusFinalizeShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
/**
* Function for initialization.
*/
GLUSboolean init(GLUSvoid)
{
GLUSshape sphere;
GLUStextfile vertexSource;
GLUStextfile geometrySource;
GLUStextfile fragmentSource;
// Load the source of the vertex shader.
glusLoadTextFile("../src/Example09/Vertex.vs", &vertexSource);
// Load the source of the geometry shader.
glusLoadTextFile("../src/Example09/Geometry.gs", &geometrySource);
// Load the source of the fragment shader.
glusLoadTextFile("../src/Example09/Fragment.fs", &fragmentSource);
// Build and ...
glusBuildProgram(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, (const GLUSchar**) &geometrySource.text, (const GLUSchar**) &fragmentSource.text);
// Destroy the text resource
glusDestroyTextFile(&vertexSource);
// Destroy the text resource
glusDestroyTextFile(&geometrySource);
// Destroy the text resource
glusDestroyTextFile(&fragmentSource);
// ToDo:
glGenVertexArrays(1, &g_vao);
// ToDo:
glBindVertexArray(g_vao);
glusCreateSpheref(&sphere, 1.0f, 32);
numberIndices = sphere.numberIndices;
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_projectionLocation = glGetUniformLocation(g_program.program, "projectionMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_modelViewLocation = glGetUniformLocation(g_program.program, "modelViewMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_vertexLocation = glGetAttribLocation(g_program.program, "vertex");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_normalLocation = glGetAttribLocation(g_program.program, "normal");
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, sphere.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) sphere.vertices, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_normals);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_normals);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, sphere.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) sphere.normals, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_indices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sphere.numberIndices * sizeof(GLuint), (GLuint*) sphere.indices, GL_STATIC_DRAW);
glusDestroyShapef(&sphere);
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_program.program);
// ... and the view matrix ...
glusLookAtf(g_modelView, 0.0f, 0.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniformMatrix4fv(g_modelViewLocation, 1, GL_FALSE, g_modelView);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_vertexLocation);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_normals);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_normalLocation);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clearcolor.html
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/cleardepth.html
glClearDepth(1.0f);
//http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html
glEnable( GL_DEPTH_TEST);
//http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html
glEnable( GL_CULL_FACE);
return GLUS_TRUE;
}
GLUSboolean GLUSAPIENTRY glusCreateCubef(GLUSshape* shape, const GLUSfloat halfExtend)
{
GLUSuint i;
GLUSuint numberVertices = 24;
GLUSuint numberIndices = 36;
GLUSfloat cubeVertices[] = { -1.0f, -1.0f, -1.0f, +1.0f, -1.0f, -1.0f, +1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, +1.0f, -1.0f, -1.0f, +1.0f,
-1.0f, +1.0f, -1.0f, +1.0f, -1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, -1.0f, +1.0f,
-1.0f, -1.0f, -1.0f, +1.0f, -1.0f, +1.0f, -1.0f, +1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, -1.0f, -1.0f, +1.0f,
-1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f,
-1.0f, -1.0f, -1.0f, +1.0f, -1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, +1.0f, -1.0f, +1.0f, -1.0f, +1.0f,
+1.0f, -1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, +1.0f, -1.0f, +1.0f };
GLUSfloat cubeNormals[] = { 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f,
0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f,
0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f,
0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f,
-1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
+1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f };
GLUSfloat cubeTangents[] = { +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f,
+1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f,
-1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
+1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f,
0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f, 0.0f, 0.0f, +1.0f,
0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f };
GLUSfloat cubeTexCoords[] =
{ 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f };
GLUSushort cubeIndices[] = { 0, 2, 1, 0, 3, 2, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 15, 14, 12, 14, 13, 16, 17, 18, 16, 18, 19, 20, 23, 22, 20, 22, 21 };
if (!shape)
{
return GLUS_FALSE;
}
glusInitShapef(shape);
shape->numberVertices = numberVertices;
shape->numberIndices = numberIndices;
shape->vertices = (GLUSfloat*) malloc(4 * numberVertices * sizeof(GLUSfloat));
shape->normals = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->tangents = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->texCoords = (GLUSfloat*) malloc(2 * numberVertices * sizeof(GLUSfloat));
shape->indices = (GLUSushort*) malloc(numberIndices * sizeof(GLUSushort));
if (!glusCheckShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
memcpy(shape->vertices, cubeVertices, sizeof(cubeVertices));
for (i = 0; i < numberVertices; i++)
{
shape->vertices[i * 4 + 0] *= halfExtend;
shape->vertices[i * 4 + 1] *= halfExtend;
shape->vertices[i * 4 + 2] *= halfExtend;
}
memcpy(shape->normals, cubeNormals, sizeof(cubeNormals));
memcpy(shape->tangents, cubeTangents, sizeof(cubeTangents));
memcpy(shape->texCoords, cubeTexCoords, sizeof(cubeTexCoords));
memcpy(shape->indices, cubeIndices, sizeof(cubeIndices));
if (!glusFinalizeShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLUSshape torus;
GLUSshape backgroundSphere;
GLUStgaimage image;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
glusLoadTextFile("../Example11_ES/shader/glass.vert.glsl", &vertexSource);
glusLoadTextFile("../Example11_ES/shader/glass.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
glusLoadTextFile("../Example11_ES/shader/background.vert.glsl", &vertexSource);
glusLoadTextFile("../Example11_ES/shader/background.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_programBackground, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_viewProjectionMatrixLocation = glGetUniformLocation(g_program.program, "u_viewProjectionMatrix");
g_modelMatrixLocation = glGetUniformLocation(g_program.program, "u_modelMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_cameraLocation = glGetUniformLocation(g_program.program, "u_camera");
g_cubemapLocation = glGetUniformLocation(g_program.program, "u_cubemap");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
//
g_viewProjectionMatrixBackgroundLocation = glGetUniformLocation(g_programBackground.program, "u_viewProjectionMatrix");
g_modelMatrixBackgroundLocation = glGetUniformLocation(g_programBackground.program, "u_modelMatrix");
g_cubemapBackgroundLocation = glGetUniformLocation(g_programBackground.program, "u_cubemap");
g_vertexBackgroundLocation = glGetAttribLocation(g_programBackground.program, "a_vertex");
//
glGenTextures(1, &g_cubemap);
glBindTexture(GL_TEXTURE_CUBE_MAP, g_cubemap);
glusLoadTgaImage("cm_pos_x.tga", &image);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_neg_x.tga", &image);
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_pos_y.tga", &image);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_neg_y.tga", &image);
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_pos_z.tga", &image);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glusLoadTgaImage("cm_neg_z.tga", &image);
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
//
glusCreateTorusf(&torus, 0.25f, 1.0f, 32, 32);
g_numberIndicesSphere = torus.numberIndices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, torus.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) torus.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, torus.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) torus.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, torus.numberIndices * sizeof(GLuint), (GLuint*) torus.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&torus);
//
glusCreateSpheref(&backgroundSphere, g_circleRadius, 32);
g_numberIndicesBackground = backgroundSphere.numberIndices;
glGenBuffers(1, &g_verticesBackgroundVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
glBufferData(GL_ARRAY_BUFFER, backgroundSphere.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) backgroundSphere.vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesBackgroundVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, backgroundSphere.numberIndices * sizeof(GLuint), (GLuint*) backgroundSphere.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&backgroundSphere);
//
glUseProgram(g_program.program);
glUniform1i(g_cubemapLocation, 0);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
//
glUseProgram(g_programBackground.program);
glUniform1i(g_cubemapBackgroundLocation, 0);
glGenVertexArrays(1, &g_vaoBackground);
glBindVertexArray(g_vaoBackground);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
glVertexAttribPointer(g_vertexBackgroundLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexBackgroundLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
//
glBindTexture(GL_TEXTURE_CUBE_MAP, g_cubemap);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepthf(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
return GLUS_TRUE;
}
GLUSboolean GLUSAPIENTRY glusCreateDomef(GLUSshape* shape, const GLUSfloat radius, const GLUSushort numberSlices)
{
GLUSuint i, j;
GLUSuint numberParallels = numberSlices / 4;
GLUSuint numberVertices = (numberParallels + 1) * (numberSlices + 1);
GLUSuint numberIndices = numberParallels * numberSlices * 6;
GLUSfloat angleStep = (2.0f * GLUS_PI) / ((GLUSfloat) numberSlices);
GLUSuint indexIndices;
// used later to help us calculating tangents vectors
GLUSfloat helpVector[3] = { 1.0f, 0.0f, 0.0f };
GLUSfloat helpQuaternion[4];
GLUSfloat helpMatrix[16];
if (numberSlices < 3 || numberVertices > GLUS_MAX_VERTICES || numberIndices > GLUS_MAX_INDICES)
{
return GLUS_FALSE;
}
if (!shape)
{
return GLUS_FALSE;
}
glusInitShapef(shape);
shape->numberVertices = numberVertices;
shape->numberIndices = numberIndices;
shape->vertices = (GLUSfloat*) malloc(4 * numberVertices * sizeof(GLUSfloat));
shape->normals = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->tangents = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->texCoords = (GLUSfloat*) malloc(2 * numberVertices * sizeof(GLUSfloat));
shape->indices = (GLUSushort*) malloc(numberIndices * sizeof(GLUSushort));
if (!glusCheckShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
for (i = 0; i < (GLUSuint)(numberParallels + 1); i++)
{
for (j = 0; j < (GLUSuint)(numberSlices + 1); j++)
{
GLUSuint vertexIndex = (i * (numberSlices + 1) + j) * 4;
GLUSuint normalIndex = (i * (numberSlices + 1) + j) * 3;
GLUSuint tangentIndex = (i * (numberSlices + 1) + j) * 3;
GLUSuint texCoordsIndex = (i * (numberSlices + 1) + j) * 2;
shape->vertices[vertexIndex + 0] = radius * sinf(angleStep * (GLUSfloat) i) * sinf(angleStep * (GLUSfloat) j);
shape->vertices[vertexIndex + 1] = radius * cosf(angleStep * (GLUSfloat) i);
shape->vertices[vertexIndex + 2] = radius * sinf(angleStep * (GLUSfloat) i) * cosf(angleStep * (GLUSfloat) j);
shape->vertices[vertexIndex + 3] = 1.0f;
shape->normals[normalIndex + 0] = shape->vertices[vertexIndex + 0] / radius;
shape->normals[normalIndex + 1] = shape->vertices[vertexIndex + 1] / radius;
shape->normals[normalIndex + 2] = shape->vertices[vertexIndex + 2] / radius;
shape->texCoords[texCoordsIndex + 0] = (GLUSfloat) j / (GLUSfloat) numberSlices;
shape->texCoords[texCoordsIndex + 1] = 1.0f - (GLUSfloat) i / (GLUSfloat) numberParallels;
// use quaternion to get the tangent vector
glusQuaternionRotateRyf(helpQuaternion, 360.0f * shape->texCoords[texCoordsIndex + 0]);
glusQuaternionGetMatrix4x4f(helpMatrix, helpQuaternion);
glusMatrix4x4MultiplyVector3f(&shape->tangents[tangentIndex], helpMatrix, helpVector);
}
}
indexIndices = 0;
for (i = 0; i < numberParallels; i++)
{
for (j = 0; j < numberSlices; j++)
{
shape->indices[indexIndices++] = i * (numberSlices + 1) + j;
shape->indices[indexIndices++] = (i + 1) * (numberSlices + 1) + j;
shape->indices[indexIndices++] = (i + 1) * (numberSlices + 1) + (j + 1);
shape->indices[indexIndices++] = i * (numberSlices + 1) + j;
shape->indices[indexIndices++] = (i + 1) * (numberSlices + 1) + (j + 1);
shape->indices[indexIndices++] = i * (numberSlices + 1) + (j + 1);
}
}
if (!glusFinalizeShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLUSshape plane;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLUStgaimage image;
GLfloat normalMatrix[9];
glusLoadTextFile("../Example07_ES/shader/normmap.vert.glsl", &vertexSource);
glusLoadTextFile("../Example07_ES/shader/normmap.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix");
g_modelViewMatrixLocation = glGetUniformLocation(g_program.program, "u_modelViewMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_lightDirectionLocation = glGetUniformLocation(g_program.program, "u_lightDirection");
// One texture for the color and one for the normals.
g_textureLocation = glGetUniformLocation(g_program.program, "u_texture");
g_normalMapLocation = glGetUniformLocation(g_program.program, "u_normalMap");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
// The tangent, bitangent and normal do define the tangent space. They are defined in object space, the inverse brings coordinates back to this tangent space.
g_tangentLocation = glGetAttribLocation(g_program.program, "a_tangent");
g_bitangentLocation = glGetAttribLocation(g_program.program, "a_bitangent");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
g_texCoordLocation = glGetAttribLocation(g_program.program, "a_texCoord");
//
glusLoadTgaImage("rock_color.tga", &image);
glGenTextures(1, &g_texture);
glBindTexture(GL_TEXTURE_2D, g_texture);
glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, 0);
glusLoadTgaImage("rock_normal.tga", &image);
glGenTextures(1, &g_normalMap);
glBindTexture(GL_TEXTURE_2D, g_normalMap);
glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, 0);
//
glusCreatePlanef(&plane, 1.5f);
g_numberIndicesPlane = plane.numberIndices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) plane.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_tangentsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_tangentsVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) plane.tangents, GL_STATIC_DRAW);
glGenBuffers(1, &g_bitangentsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_bitangentsVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) plane.bitangents, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) plane.normals, GL_STATIC_DRAW);
glGenBuffers(1, &g_texCoordsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 2 * sizeof(GLfloat), (GLfloat*) plane.texCoords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, g_numberIndicesPlane * sizeof(GLuint), (GLuint*) plane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&plane);
//
glUseProgram(g_program.program);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_tangentsVBO);
glVertexAttribPointer(g_tangentLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_tangentLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_bitangentsVBO);
glVertexAttribPointer(g_bitangentLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_bitangentLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsVBO);
glVertexAttribPointer(g_texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_texCoordLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
//
glusLookAtf(g_viewMatrix, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, g_viewMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, g_viewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
//
// Activate and bind first ...
glUniform1i(g_textureLocation, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, g_texture);
// .. and second texture.
glUniform1i(g_normalMapLocation, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, g_normalMap);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
return GLUS_TRUE;
}
/*
* @author Pablo Alonso-Villaverde Roza
* @author Norbert Nopper
*/
GLUSboolean GLUSAPIENTRY glusCreateTorusf(GLUSshape* shape, const GLUSfloat innerRadius, const GLUSfloat outerRadius, const GLUSushort numberSlices, const GLUSushort numberStacks)
{
// s, t = parametric values of the equations, in the range [0,1]
GLUSfloat s = 0;
GLUSfloat t = 0;
// sIncr, tIncr are increment values aplied to s and t on each loop iteration to generate the torus
GLUSfloat sIncr;
GLUSfloat tIncr;
// to store precomputed sin and cos values
GLUSfloat cos2PIs, sin2PIs, cos2PIt, sin2PIt;
GLUSuint numberVertices;
GLUSuint numberIndices;
// used later to help us calculating tangents vectors
GLUSfloat helpVector[3] = { 0.0f, 1.0f, 0.0f };
GLUSfloat helpQuaternion[4];
GLUSfloat helpMatrix[16];
// indices for each type of buffer (of vertices, indices, normals...)
GLUSuint indexVertices, indexNormals, indexTangents, indexTexCoords;
GLUSuint indexIndices;
// loop counters
GLUSuint sideCount, faceCount;
// used to generate the indices
GLUSuint v0, v1, v2, v3;
GLUSfloat torusRadius = (outerRadius - innerRadius) / 2.0f;
GLUSfloat centerRadius = outerRadius - torusRadius;
numberVertices = (numberStacks + 1) * (numberSlices + 1);
numberIndices = numberStacks * numberSlices * 2 * 3; // 2 triangles per face * 3 indices per triangle
if (numberSlices < 3 || numberStacks < 3 || numberVertices > GLUS_MAX_VERTICES || numberIndices > GLUS_MAX_INDICES)
{
return GLUS_FALSE;
}
if (!shape)
{
return GLUS_FALSE;
}
glusInitShapef(shape);
shape->numberVertices = numberVertices;
shape->numberIndices = numberIndices;
shape->vertices = (GLUSfloat*) malloc(4 * numberVertices * sizeof(GLUSfloat));
shape->normals = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->tangents = (GLUSfloat*) malloc(3 * numberVertices * sizeof(GLUSfloat));
shape->texCoords = (GLUSfloat*) malloc(2 * numberVertices * sizeof(GLUSfloat));
shape->indices = (GLUSushort*) malloc(numberIndices * sizeof(GLUSushort));
if (!glusCheckShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
sIncr = 1.0f / (GLUSfloat) numberSlices;
tIncr = 1.0f / (GLUSfloat) numberStacks;
// generate vertices and its attributes
for (sideCount = 0; sideCount <= numberSlices; ++sideCount, s += sIncr)
{
// precompute some values
cos2PIs = (GLUSfloat) cosf(2.0f * GLUS_PI * s);
sin2PIs = (GLUSfloat) sinf(2.0f * GLUS_PI * s);
t = 0.0f;
for (faceCount = 0; faceCount <= numberStacks; ++faceCount, t += tIncr)
{
// precompute some values
cos2PIt = (GLUSfloat) cosf(2.0f * GLUS_PI * t);
sin2PIt = (GLUSfloat) sinf(2.0f * GLUS_PI * t);
// generate vertex and stores it in the right position
indexVertices = ((sideCount * (numberStacks + 1)) + faceCount) * 4;
shape->vertices[indexVertices + 0] = (centerRadius + torusRadius * cos2PIt) * cos2PIs;
shape->vertices[indexVertices + 1] = (centerRadius + torusRadius * cos2PIt) * sin2PIs;
shape->vertices[indexVertices + 2] = torusRadius * sin2PIt;
shape->vertices[indexVertices + 3] = 1.0f;
// generate normal and stores it in the right position
// NOTE: cos (2PIx) = cos (x) and sin (2PIx) = sin (x) so, we can use this formula
// normal = {cos(2PIs)cos(2PIt) , sin(2PIs)cos(2PIt) ,sin(2PIt)}
indexNormals = ((sideCount * (numberStacks + 1)) + faceCount) * 3;
shape->normals[indexNormals + 0] = cos2PIs * cos2PIt;
shape->normals[indexNormals + 1] = sin2PIs * cos2PIt;
shape->normals[indexNormals + 2] = sin2PIt;
// generate texture coordinates and stores it in the right position
indexTexCoords = ((sideCount * (numberStacks + 1)) + faceCount) * 2;
shape->texCoords[indexTexCoords + 0] = s;
shape->texCoords[indexTexCoords + 1] = t;
// use quaternion to get the tangent vector
glusQuaternionRotateRzf(helpQuaternion, 360.0f * s);
glusQuaternionGetMatrix4x4f(helpMatrix, helpQuaternion);
indexTangents = ((sideCount * (numberStacks + 1)) + faceCount) * 3;
glusMatrix4x4MultiplyVector3f(&shape->tangents[indexTangents], helpMatrix, helpVector);
}
}
// generate indices
indexIndices = 0;
for (sideCount = 0; sideCount < numberSlices; ++sideCount)
{
for (faceCount = 0; faceCount < numberStacks; ++faceCount)
{
// get the number of the vertices for a face of the torus. They must be < numVertices
v0 = ((sideCount * (numberStacks + 1)) + faceCount);
v1 = (((sideCount + 1) * (numberStacks + 1)) + faceCount);
v2 = (((sideCount + 1) * (numberStacks + 1)) + (faceCount + 1));
v3 = ((sideCount * (numberStacks + 1)) + (faceCount + 1));
// first triangle of the face, counter clock wise winding
shape->indices[indexIndices++] = v0;
shape->indices[indexIndices++] = v1;
shape->indices[indexIndices++] = v2;
// second triangle of the face, counter clock wise winding
shape->indices[indexIndices++] = v0;
shape->indices[indexIndices++] = v2;
shape->indices[indexIndices++] = v3;
}
}
if (!glusFinalizeShapef(shape))
{
glusDestroyShapef(shape);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLfloat modelViewMatrix[16];
GLUSshape plane;
GLUSuint planeIndices[] = { 0, 1, 3, 2 };
GLUStextfile vertexSource;
GLUStextfile controlSource;
GLUStextfile evaluationSource;
GLUStextfile geometrySource;
GLUStextfile fragmentSource;
glusLoadTextFile("../Example13/shader/tessellation.vert.glsl", &vertexSource);
glusLoadTextFile("../Example13/shader/tessellation.cont.glsl", &controlSource);
glusLoadTextFile("../Example13/shader/tessellation.eval.glsl", &evaluationSource);
glusLoadTextFile("../Example13/shader/tessellation.geom.glsl", &geometrySource);
glusLoadTextFile("../Example13/shader/tessellation.frag.glsl", &fragmentSource);
glusBuildProgramFromSource(&g_program, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &controlSource.text, (const GLUSchar**) &evaluationSource.text, (const GLUSchar**) &geometrySource.text, (const GLUSchar**) &fragmentSource.text);
glusDestroyTextFile(&vertexSource);
glusDestroyTextFile(&controlSource);
glusDestroyTextFile(&evaluationSource);
glusDestroyTextFile(&geometrySource);
glusDestroyTextFile(&fragmentSource);
//
g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix");
g_modelViewMatrixLocation = glGetUniformLocation(g_program.program, "u_modelViewMatrix");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
//
glusCreatePlanef(&plane, 1.0f);
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) plane.vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, g_numberIndicesSphere * sizeof(GLuint), (GLuint*) planeIndices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusDestroyShapef(&plane);
//
glUseProgram(g_program.program);
// Calculate the view matrix ...
glusLookAtf(modelViewMatrix, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, modelViewMatrix);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable( GL_CULL_FACE);
// We work with 4 points per patch.
glPatchParameteri(GL_PATCH_VERTICES, 4);
return GLUS_TRUE;
}
/**
* Function for initialization.
*/
GLUSboolean init(GLUSvoid)
{
// Matrix for the model
GLfloat model[16];
GLUSshape cube;
GLUStgaimage image;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
// Load the source of the vertex shader.
glusLoadTextFile("../Example05/Vertex.vs", &vertexSource);
// Load the source of the fragment shader.
glusLoadTextFile("../Example05/Fragment.fs", &fragmentSource);
// Build and ...
glusBuildProgram(&g_program, (const GLUSchar**)&vertexSource.text, 0, (const GLUSchar**)&fragmentSource.text);
// Destroy the text resource
glusDestroyTextFile(&vertexSource);
// Destroy the text resource
glusDestroyTextFile(&fragmentSource);
// ToDo:
glGenVertexArrays(1, &g_vao);
// ToDo:
glBindVertexArray(g_vao);
glusCreateCubef(&cube, 0.5f);
numberIndices = cube.numberIndices;
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_projectionLocation = glGetUniformLocation(g_program.program, "projectionMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_modelViewLocation = glGetUniformLocation(g_program.program, "modelViewMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_textureLocation = glGetUniformLocation(g_program.program, "firstTexture");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_vertexLocation = glGetAttribLocation(g_program.program, "vertex");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_normalLocation = glGetAttribLocation(g_program.program, "normal");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_texCoordLocation = glGetAttribLocation(g_program.program, "texCoord");
// ToDo:
glBindFragDataLocation(g_program.program, 0, "fragColor");
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, cube.numberVertices*4*sizeof(GLfloat), (GLfloat*)cube.vertices, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_normals);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_normals);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, cube.numberVertices*3*sizeof(GLfloat), (GLfloat*)cube.normals, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_texCoords);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_texCoords);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, cube.numberVertices*2*sizeof(GLfloat), (GLfloat*)cube.texCoords, GL_STATIC_DRAW);
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_indices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ELEMENT_ARRAY_BUFFER, cube.numberIndices*sizeof(GLuint), (GLuint*)cube.indices, GL_STATIC_DRAW);
glusDestroyShapef(&cube);
glusLoadTgaImage("crate.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/gentextures.html
glGenTextures(1, &g_texture);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html
glBindTexture(GL_TEXTURE_2D, g_texture);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_program.program);
// Calculate the model matrix ...
glusLoadIdentityf(model);
glusRotateRzRyRxf(model, 30.0f, 30.0f, 0.0f);
// ... and the view matrix ...
glusLookAtf(g_modelView, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
// ... to get the final model view matrix
glusMultMatrixf(g_modelView, g_modelView, model);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniformMatrix4fv(g_modelViewLocation, 1, GL_FALSE, g_modelView);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_vertexLocation);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_normals);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_normalLocation);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_texCoords);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_texCoordLocation);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniform1i(g_textureLocation, 0);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clearcolor.html
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/cleardepth.html
glClearDepth(1.0f);
//http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html
glEnable(GL_DEPTH_TEST);
//http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html
glEnable(GL_CULL_FACE);
return GLUS_TRUE;
}
