SimpleMesh::SimpleMesh(GLuint a_programId, int a_slicesNum, int a_meshType, float a_halfSize)
{
if(a_meshType == SPHERE)
glusCreateSpheref(&m_glusShape, a_halfSize, a_slicesNum);
else if(a_meshType == CUBE)
glusCreateCubef(&m_glusShape, a_halfSize);
else if(a_meshType == CUBE_OPEN)
glusCreateCubeOpenf(&m_glusShape, a_halfSize);
else if(a_meshType == PLANE)
{
if(a_slicesNum <= 2)
{
glusCreatePlanef(&m_glusShape, a_halfSize);
for(unsigned int i=0;i<2*m_glusShape.numberVertices;i++)
m_glusShape.texCoords[i] *= 2.0f;
}
else
glusCreatePlaneSlicedf(&m_glusShape, a_halfSize, a_slicesNum);
}
else if(a_meshType == TORUS)
glusCreateTorusf(&m_glusShape, 0.5f*a_halfSize, a_halfSize, a_slicesNum, 32*a_slicesNum);
else
glusCreateCubef(&m_glusShape, 1.0f);
CreateGPUData(a_programId);
}
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;
}
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;
}
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;
}
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;
}
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;
}
SimpleMesh::SimpleMesh(GLuint a_programId, int a_slicesNum, int a_meshType, float a_halfSize)
{
if(a_meshType == SPHERE)
glusCreateSpheref(&m_glusShape, a_halfSize, a_slicesNum);
else if(a_meshType == CUBE)
glusCreateCubef(&m_glusShape, a_halfSize);
else if(a_meshType == PLANE)
{
glusCreatePlanef(&m_glusShape, a_halfSize);
for(unsigned int i=0;i<2*m_glusShape.numberVertices;i++)
m_glusShape.texCoords[i] *= 2.0f;
}
else if(a_meshType == TORUS)
glusCreateTorusf(&m_glusShape, 0.5f*a_halfSize, a_halfSize, a_slicesNum, 32*a_slicesNum);
else
glusCreateCubef(&m_glusShape, 1.0f);
m_vertexPosBufferObject = 0;
m_vertexPosLocation = glGetAttribLocation(a_programId, "vertex");
m_vertexNormLocation = glGetAttribLocation(a_programId, "normal");
m_vertexTexCoordsLocation = glGetAttribLocation(a_programId, "texCoord");
GLint maxVertexAttributes = 0;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttributes);
// create buffers a,d fill them with data
// vertex positions
//
glGenBuffers(1, &m_vertexPosBufferObject); CHECK_GL_ERRORS;
glBindBuffer(GL_ARRAY_BUFFER, m_vertexPosBufferObject); CHECK_GL_ERRORS;
glBufferData(GL_ARRAY_BUFFER, m_glusShape.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) m_glusShape.vertices, GL_STATIC_DRAW); CHECK_GL_ERRORS;
// vertex normals
//
glGenBuffers(1, &m_vertexNormBufferObject); CHECK_GL_ERRORS;
glBindBuffer(GL_ARRAY_BUFFER, m_vertexNormBufferObject); CHECK_GL_ERRORS;
glBufferData(GL_ARRAY_BUFFER, m_glusShape.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) m_glusShape.normals, GL_STATIC_DRAW); CHECK_GL_ERRORS;
// vertex texture coordinates
//
glGenBuffers(1, &m_vertexTexCoordsBufferObject); CHECK_GL_ERRORS;
glBindBuffer(GL_ARRAY_BUFFER, m_vertexTexCoordsBufferObject); CHECK_GL_ERRORS;
glBufferData(GL_ARRAY_BUFFER, m_glusShape.numberVertices * 2 * sizeof(GLfloat), (GLfloat*) m_glusShape.texCoords, GL_STATIC_DRAW); CHECK_GL_ERRORS;
// index buffer
//
glGenBuffers(1, &m_indexBufferObject);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBufferObject);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_glusShape.numberIndices * sizeof(GLuint), (GLuint*)m_glusShape.indices, GL_STATIC_DRAW);
// create VAO and bind each buffer to appropriate "pointer", called vertex array attribute
//
glGenVertexArrays(1, &m_vertexArrayObject); CHECK_GL_ERRORS;
glBindVertexArray(m_vertexArrayObject); CHECK_GL_ERRORS;
if(m_vertexPosLocation < GLuint(maxVertexAttributes))
{
glBindBuffer(GL_ARRAY_BUFFER, m_vertexPosBufferObject); CHECK_GL_ERRORS;
glEnableVertexAttribArray(m_vertexPosLocation); CHECK_GL_ERRORS;
glVertexAttribPointer(m_vertexPosLocation, 4, GL_FLOAT, GL_FALSE, 0, 0); CHECK_GL_ERRORS;
}
if(m_vertexNormLocation < GLuint(maxVertexAttributes))
{
glBindBuffer(GL_ARRAY_BUFFER, m_vertexNormBufferObject); CHECK_GL_ERRORS;
glEnableVertexAttribArray(m_vertexNormLocation); CHECK_GL_ERRORS;
glVertexAttribPointer(m_vertexNormLocation, 3, GL_FLOAT, GL_FALSE, 0, 0); CHECK_GL_ERRORS;
}
if(m_vertexTexCoordsLocation < GLuint(maxVertexAttributes))
{
glBindBuffer(GL_ARRAY_BUFFER, m_vertexTexCoordsBufferObject); CHECK_GL_ERRORS;
glEnableVertexAttribArray(m_vertexTexCoordsLocation); CHECK_GL_ERRORS;
glVertexAttribPointer(m_vertexTexCoordsLocation, 2, GL_FLOAT, GL_FALSE, 0, 0); CHECK_GL_ERRORS;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBufferObject); CHECK_GL_ERRORS;
glBindVertexArray(0); // unbind VAO
}
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)
{
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;
}
