GLUSvoid reshape(GLUSint width, GLUSint height)
{
GLfloat modelMatrix[16];
GLfloat normalMatrix[9];
GLfloat viewMatrix[16];
GLfloat projectionMatrix[16];
GLfloat viewProjectionMatrix[16];
GLfloat modelViewProjectionMatrix[16];
glUseProgram(g_program.program);
glViewport(0, 0, width, height);
// For now, the grid is just on the "ground".
glusMatrix4x4Identityf(modelMatrix);
// This model matrix is a rigid body transform. So no need for the inverse, transposed matrix.
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelMatrix);
glusMatrix4x4Perspectivef(projectionMatrix, 40.0f, (GLfloat) width / (GLfloat) height, 1.0f, 100.0f);
glusMatrix4x4LookAtf(viewMatrix, 0.0f, 4.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glusMatrix4x4Multiplyf(viewProjectionMatrix, projectionMatrix, viewMatrix);
glusMatrix4x4Multiplyf(modelViewProjectionMatrix, viewProjectionMatrix, modelMatrix);
glUniformMatrix4fv(g_modelViewProjectionMatrixLocation, 1, GL_FALSE, modelViewProjectionMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glUseProgram(0);
reshapeSphere(viewProjectionMatrix);
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat angle = 0.0f;
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
glusMatrix4x4Identityf(modelViewMatrix);
glusMatrix4x4RotateRyf(modelViewMatrix, angle);
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelViewMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawArrays(GL_TRIANGLES, 0, g_numberVertices);
angle += 30.0f * time;
return GLUS_TRUE;
}
GLUSvoid GLUSAPIENTRY glusMatrix4x4RotateRzRxRyf(GLUSfloat matrix[16], const GLUSfloat anglez, const GLUSfloat anglex, const GLUSfloat angley)
{
GLUSfloat temp[16];
GLUSfloat rz = 2.0f * PIf * anglez / 360.0f;
GLUSfloat rx = 2.0f * PIf * anglex / 360.0f;
GLUSfloat ry = 2.0f * PIf * angley / 360.0f;
GLUSfloat sy = sinf(ry);
GLUSfloat cy = cosf(ry);
GLUSfloat sx = sinf(rx);
GLUSfloat cx = cosf(rx);
GLUSfloat sz = sinf(rz);
GLUSfloat cz = cosf(rz);
glusMatrix4x4Identityf(temp);
temp[0] = cy * cz - sx * sy * sz;
temp[1] = cz * sx * sy + cy * sz;
temp[2] = -cx * sy;
temp[4] = -cx * sz;
temp[5] = cx * cz;
temp[6] = sx;
temp[8] = cz * sy + cy * sx * sz;
temp[9] = -cy * cz * sx + sy * sz;
temp[10] = cx * cy;
glusMatrix4x4Multiplyf(matrix, matrix, temp);
}
GLUSvoid GLUSAPIENTRY glusMatrix4x4Rotatef(GLUSfloat matrix[16], const GLUSfloat angle, const GLUSfloat x, const GLUSfloat y, const GLUSfloat z)
{
GLUSfloat temp[16];
GLUSfloat s = sinf(2.0f * PIf * angle / 360.0f);
GLUSfloat c = cosf(2.0f * PIf * angle / 360.0f);
GLUSfloat vector[3] = { x, y, z };
GLUSfloat xn, yn, zn;
glusVector3Normalizef(vector);
xn = vector[0];
yn = vector[1];
zn = vector[2];
glusMatrix4x4Identityf(temp);
temp[0] = xn * xn * (1 - c) + c;
temp[1] = xn * yn * (1 - c) + zn * s;
temp[2] = xn * zn * (1 - c) - yn * s;
temp[4] = xn * yn * (1 - c) - zn * s;
temp[5] = yn * yn * (1 - c) + c;
temp[6] = yn * zn * (1 - c) + xn * s;
temp[8] = xn * zn * (1 - c) + yn * s;
temp[9] = yn * zn * (1 - c) - xn * s;
temp[10] = zn * zn * (1 - c) + c;
glusMatrix4x4Multiplyf(matrix, matrix, temp);
}
GLUSvoid reshape(GLUSint width, GLUSint height)
{
static GLfloat biasMatrix[] = { 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f };
GLfloat projectionMatrix[16];
g_width = width;
g_height = height;
//
glUseProgram(g_programShadow.program);
glusMatrix4x4Perspectivef(projectionMatrix, 40.0f, (GLfloat) g_shadowTextureSize / (GLfloat) g_shadowTextureSize, 1.0f, 100.0f);
glUniformMatrix4fv(g_projectionMatrixShadowLocation, 1, GL_FALSE, projectionMatrix);
glusMatrix4x4Identityf(g_shadowMatrix);
glusMatrix4x4Multiplyf(g_shadowMatrix, g_shadowMatrix, biasMatrix);
glusMatrix4x4Multiplyf(g_shadowMatrix, g_shadowMatrix, projectionMatrix);
//
glUseProgram(g_program.program);
glusMatrix4x4Perspectivef(projectionMatrix, 40.0f, (GLfloat) width / (GLfloat) height, 1.0f, 100.0f);
glUniformMatrix4fv(g_projectionMatrixLocation, 1, GL_FALSE, projectionMatrix);
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat angle = 0.0f;
GLfloat modelMatrix[16];
GLfloat normalMatrix[9];
// Calculate the model matrix ...
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4RotateRzRyRxf(modelMatrix, 0.0f, angle, -90.0f);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
// Calculate the normal matrix ...
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
//
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawElements(GL_PATCHES, g_numberIndicesPlane, GL_UNSIGNED_INT, 0);
//
angle += time * 45.0f;
return GLUS_TRUE;
}
GLUSvoid reshape(GLUSint width, GLUSint height)
{
GLfloat modelMatrix[16];
GLfloat normalMatrix[9];
GLfloat viewMatrix[16];
GLfloat modelViewProjectionMatrix[16];
glViewport(0, 0, width, height);
// Initialize with the identity matrix ...
glusMatrix4x4Identityf(modelMatrix);
// ... and rotate the cube at two axes that we do see some sides.
glusMatrix4x4RotateRzRxRyf(modelMatrix, 0.0f, 45.0f, 45.0f);
// This model matrix is a rigid body transform. So no need for the inverse, transposed matrix.
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelMatrix);
glusMatrix4x4Perspectivef(modelViewProjectionMatrix, 40.0f, (GLfloat) width / (GLfloat) height, 1.0f, 100.0f);
glusMatrix4x4LookAtf(viewMatrix, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
// Here we create the view projection matrix ...
glusMatrix4x4Multiplyf(modelViewProjectionMatrix, modelViewProjectionMatrix, viewMatrix);
// ... and now the final model view projection matrix.
glusMatrix4x4Multiplyf(modelViewProjectionMatrix, modelViewProjectionMatrix, modelMatrix);
glUniformMatrix4fv(g_modelViewProjectionMatrixLocation, 1, GL_FALSE, modelViewProjectionMatrix);
// Set the normal matrix.
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
}
GLUSboolean updateWavefront(GLUSfloat time)
{
static GLfloat angle = 0.0f;
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
glusMatrix4x4Identityf(modelViewMatrix);
glusMatrix4x4Translatef(modelViewMatrix, 0.0f, -1.5f, 0.0f);
glusMatrix4x4RotateRyf(modelViewMatrix, angle);
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelViewMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUseProgram(g_program.program);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glBindVertexArray(g_vao);
glDrawArrays(GL_TRIANGLES, 0, g_numberVertices);
angle += 30.0f * time;
return GLUS_TRUE;
}
GLUSboolean updateWavefront(GLUSfloat time, GLUSfloat modelMatrix[16])
{
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
GLfloat lightDirection[3];
// Note that the scale matrix is for flipping the model upside down.
glusMatrix4x4Identityf(modelViewMatrix);
glusMatrix4x4Multiplyf(modelViewMatrix, modelViewMatrix, modelMatrix);
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelViewMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
// Transform light to camera space, as it is currently in world space.
glusMatrix4x4MultiplyVector3f(lightDirection, g_viewMatrix, g_light->direction);
glUseProgram(g_program.program);
glUniform3fv(g_lightLocations.directionLocation, 1, lightDirection);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glBindVertexArray(g_vao);
glDrawArrays(GL_TRIANGLES, 0, g_numberVertices);
return GLUS_TRUE;
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat angle = 0.0f;
static GLuint zero = 0;
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
glusMatrix4x4Identityf(modelViewMatrix);
glusMatrix4x4RotateRyf(modelViewMatrix, angle);
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelViewMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUseProgram(g_program.program);
glBindVertexArray(g_vao);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
//
// Linked list rendering pass.
//
// Reset the atomic counter.
glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(GLuint), &zero);
// Reset the head pointers by copying the clear buffer into the texture.
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, g_clearBuffer);
glBindTexture(GL_TEXTURE_2D, g_headIndexTexture);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, GL_RED_INTEGER, GL_UNSIGNED_INT, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
//
glDrawArrays(GL_TRIANGLES, 0, g_numberVertices);
//
// Fullscreen quad rendering.
//
glUseProgram(g_blendFullscreenProgram.program);
glBindVertexArray(g_blendFullscreenVAO);
// Resolving and blending is happening in the shader.
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
angle += 30.0f * time;
return GLUS_TRUE;
}
GLUSvoid GLUSAPIENTRY glusMatrix4x4Translatef(GLUSfloat matrix[16], const GLUSfloat x, const GLUSfloat y, const GLUSfloat z)
{
GLUSfloat temp[16];
glusMatrix4x4Identityf(temp);
temp[12] = x;
temp[13] = y;
temp[14] = z;
glusMatrix4x4Multiplyf(matrix, matrix, temp);
}
GLUSvoid GLUSAPIENTRY glusMatrix4x4Scalef(GLUSfloat matrix[16], const GLUSfloat x, const GLUSfloat y, const GLUSfloat z)
{
GLUSfloat temp[16];
glusMatrix4x4Identityf(temp);
temp[0] = x;
temp[5] = y;
temp[10] = z;
glusMatrix4x4Multiplyf(matrix, matrix, temp);
}
GLUSvoid GLUSAPIENTRY glusMatrix4x4InverseRigidBodyf(GLUSfloat matrix[16])
{
GLUSfloat inverseRotation[16];
GLUSfloat inverseTranslation[16];
glusMatrix4x4Copyf(inverseRotation, matrix, GLUS_TRUE);
glusMatrix4x4Transposef(inverseRotation);
glusMatrix4x4Identityf(inverseTranslation);
inverseTranslation[12] = -matrix[12];
inverseTranslation[13] = -matrix[13];
inverseTranslation[14] = -matrix[14];
glusMatrix4x4Multiplyf(matrix, inverseRotation, inverseTranslation);
}
GLUSvoid reshape(GLUSint width, GLUSint height)
{
GLfloat modelMatrix[16];
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
GLfloat lightDirection[3];
reshapeWavefront(width, height);
//
glViewport(0, 0, width, height);
glusPerspectivef(g_projectionMatrix, 40.0f, (GLfloat)width / (GLfloat)height, 1.0f, 100.0f);
// Calculate the inverse. Needed for the SSAO shader to get from projection to view space.
glusMatrix4x4Copyf(g_inverseProjectionMatrix, g_projectionMatrix, GLUS_FALSE);
glusMatrix4x4Inversef(g_inverseProjectionMatrix);
glUseProgram(g_ssaoProgram.program);
glUniformMatrix4fv(g_ssaoInverseProjectionMatrixLocation, 1, GL_FALSE, g_inverseProjectionMatrix);
glUniformMatrix4fv(g_ssaoProjectionMatrixLocation, 1, GL_FALSE, g_projectionMatrix);
//
glusMatrix4x4Multiplyf(g_viewProjectionMatrix, g_projectionMatrix, g_viewMatrix);
glUseProgram(g_program.program);
glUniformMatrix4fv(g_viewProjectionMatrixLocation, 1, GL_FALSE, g_viewProjectionMatrix);
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4RotateRxf(modelMatrix, -90.0f);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
// Calculation is in camera space
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glusMatrix4x4MultiplyVector3f(lightDirection, g_viewMatrix, g_light.direction);
// Direction already normalized
glUniform3fv(g_lightDirectionLocation, 1, lightDirection);
}
GLUSvoid GLUSAPIENTRY glusMatrix4x4RotateRzf(GLUSfloat matrix[16], const GLUSfloat angle)
{
GLUSfloat temp[16];
GLUSfloat s = sinf(2.0f * PIf * angle / 360.0f);
GLUSfloat c = cosf(2.0f * PIf * angle / 360.0f);
glusMatrix4x4Identityf(temp);
temp[0] = c;
temp[1] = s;
temp[4] = -s;
temp[5] = c;
glusMatrix4x4Multiplyf(matrix, matrix, temp);
}
GLUSvoid GLUSAPIENTRY glusMatrix4x4Shearf(GLUSfloat matrix[16], const GLUSfloat shxy, const GLUSfloat shxz, const GLUSfloat shyx, const GLUSfloat shyz, const GLUSfloat shzx, const GLUSfloat shzy)
{
GLUSfloat temp[16];
glusMatrix4x4Identityf(temp);
temp[4] = shxy;
temp[8] = shxz;
temp[1] = shyx;
temp[9] = shyz;
temp[2] = shzx;
temp[6] = shzy;
glusMatrix4x4Multiplyf(matrix, matrix, temp);
}
GLUSboolean update(GLUSfloat time)
{
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
glusMatrix4x4Identityf(modelViewMatrix);
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelViewMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
//
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Normal rendering
glUseProgram(g_program.program);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glBindVertexArray(g_vao);
glDrawArrays(GL_TRIANGLES, 0, g_numberVertices);
// Fur rendering
// Do not write to depth, so no fur layer will be discarded.
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glUseProgram(g_programFur.program);
glUniformMatrix4fv(g_modelViewMatrixFurLocation, 1, GL_FALSE, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixFurLocation, 1, GL_FALSE, normalMatrix);
glBindVertexArray(g_vaoFur);
glDrawArrays(GL_TRIANGLES, 0, g_numberVertices);
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
return GLUS_TRUE;
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat angle = 0.0f;
static GLfloat erode = ERODE_START;
GLfloat modelMatrix[16];
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4RotateRyf(modelMatrix, angle);
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelMatrix);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, modelViewMatrix);
// The calculations are done in camera / view space. So pass the view matrix, which is a rigid body transform.
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
//
glUniform1f(g_erodeLocation, erode);
// Loop eroding
if (erode < ERODE_END)
{
erode = ERODE_START;
}
//
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawElements(GL_TRIANGLES, g_numberIndicesSphere, GL_UNSIGNED_INT, 0);
//
angle += time * 45.0f;
erode -= time * 0.1f;
return GLUS_TRUE;
}
GLUSboolean update(GLUSfloat time)
{
// Angle for rotation
static GLfloat angle = 0.0f;
// Matrix for the model
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
GLfloat viewMatrix[9];
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Calculate the model matrix ...
glusMatrix4x4Identityf(modelViewMatrix);
// ... by finally rotating the cube.
glusMatrix4x4RotateRzRxRyf(modelViewMatrix, 0.0f, 15.0f, angle);
// Create the model view matrix.
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelViewMatrix);
// Again, extract the normal matrix. Remember, so far the model view matrix (rotation part) is orthogonal.
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix4fv(g_modelViewMatrixLocation, 1, GL_FALSE, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
//
// Extract the rotation part of the view matrix.
glusMatrix4x4ExtractMatrix3x3f(viewMatrix, g_viewMatrix);
// Pass this matrix to the shader with the transpose flag. As the view matrix is orthogonal, the transposed is the inverse view matrix.
glUniformMatrix3fv(g_inverseViewMatrixLocation, 1, GL_TRUE, viewMatrix);
//
glDrawElements(GL_TRIANGLES, g_numberIndicesSphere, GL_UNSIGNED_INT, 0);
angle += 20.0f * time;
return GLUS_TRUE;
}
GLUSvoid reshape(GLUSint width, GLUSint height)
{
GLfloat modelMatrix[16];
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
GLfloat lightDirection[3];
g_width = width;
g_height = height;
reshapeWavefront(width, height);
//
glViewport(0, 0, width, height);
glusPerspectivef(g_viewProjectionMatrix, 40.0f, (GLfloat) width / (GLfloat) height, 1.0f, 100.0f);
glusMatrix4x4Multiplyf(g_viewProjectionMatrix, g_viewProjectionMatrix, g_viewMatrix);
glUseProgram(g_program.program);
glUniformMatrix4fv(g_viewProjectionMatrixLocation, 1, GL_FALSE, g_viewProjectionMatrix);
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4Translatef(modelMatrix, 0.0f, 0.0f, 3.0f);
glusMatrix4x4RotateRxf(modelMatrix, -90.0f);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
// Calculation is in camera space
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glusMatrix4x4MultiplyVector3f(lightDirection, g_viewMatrix, g_light.direction);
// Direction already normalized
glUniform3fv(g_lightDirectionLocation, 1, lightDirection);
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat angle = 0.0f;
GLfloat modelMatrix[16];
GLfloat normalMatrix[9];
// 90 degrees per second. Rotate the texture cube along the y axis (yaw).
angle += 90.0f * time;
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4RotateRzRxRyf(modelMatrix, 0.0f, 45.0f, angle);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
// Model matrix is a rigid body matrix.
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawElements(GL_TRIANGLES, g_numberIndicesSphere, GL_UNSIGNED_INT, 0);
return GLUS_TRUE;
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat angle = 0.0f;
GLfloat angleRadians;
GLfloat viewProjectionMatrix[16];
GLfloat viewMatrix[16];
GLfloat modelMatrix[16];
GLfloat normalMatrix[9];
GLfloat camera[4] = {0.0, 0.0, 0.0, 1.0};
angleRadians = glusDegToRadf(angle);
camera[0] = g_circleRadius * -sinf(angleRadians);
camera[2] = g_circleRadius * cosf(angleRadians);
// Circle with the camera around the origin by looking at it.
glusLookAtf(viewMatrix, camera[0], 0.0f, camera[2], 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glusMatrix4x4Multiplyf(viewProjectionMatrix, g_projectionMatrix, viewMatrix);
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4Translatef(modelMatrix, 0.0f, -0.5f, 0.0f);
glusMatrix4x4RotateRxf(modelMatrix, 45.0f);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelMatrix);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
// First render the background.
glUseProgram(g_programBackground.program);
glUniformMatrix4fv(g_viewProjectionMatrixBackgroundLocation, 1, GL_FALSE, viewProjectionMatrix);
glUniformMatrix4fv(g_modelMatrixBackgroundLocation, 1, GL_FALSE, modelMatrix);
glBindVertexArray(g_vaoBackground);
glFrontFace(GL_CW);
glDrawElements(GL_TRIANGLES, g_numberIndicesBackground, GL_UNSIGNED_INT, 0);
// Now render the sphere.
glUseProgram(g_program.program);
glUniformMatrix4fv(g_viewProjectionMatrixLocation, 1, GL_FALSE, viewProjectionMatrix);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glUniform4fv(g_cameraLocation, 1, camera);
glBindVertexArray(g_vao);
glFrontFace(GL_CCW);
glDrawElements(GL_TRIANGLES, g_numberIndicesSphere, GL_UNSIGNED_INT, 0);
// Increase the angle 30 degree per second.
angle += 30.0f * time;
return GLUS_TRUE;
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat angle = 0.0f;
GLfloat modelViewMatrix[16];
GLfloat viewMatrix[16];
GLfloat shadowProjectionMatrix[16];
GLfloat modelMatrix[16];
GLfloat normalMatrix[9];
// This shadow plane represents mathematically the background plane
GLfloat shadowPlane[4] = {0.0f, 0.0f, 1.0f, 5.0f};
glusMatrix4x4LookAtf(viewMatrix, g_cameraPosition[0], g_cameraPosition[1], g_cameraPosition[2], 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
// Render the scene.
//
glUseProgram(g_program.program);
glUniformMatrix4fv(g_viewMatrixLocation, 1, GL_FALSE, viewMatrix);
// Background Plane
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4Translatef(modelMatrix, 0.0f, 0.0f, -5.0f);
glusMatrix4x4Multiplyf(modelViewMatrix, viewMatrix, modelMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glUniform4f(g_colorLocation, 0.0f, 0.5f, 0.0f, 1.0f);
glBindVertexArray(g_vaoBackground);
glDrawElements(GL_TRIANGLES, g_numberIndicesBackground, GL_UNSIGNED_INT, 0);
//
// Render the planar shadow
//
glUseProgram(g_programShadow.program);
glUniformMatrix4fv(g_viewMatrixShadowLocation, 1, GL_FALSE, viewMatrix);
// Torus projected as a shadow
glusMatrix4x4PlanarShadowDirectionalLightf(shadowProjectionMatrix, shadowPlane, g_lightDirection);
glUniformMatrix4fv(g_shadowProjectionMatrixShadowLocation, 1, GL_FALSE, shadowProjectionMatrix);
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4RotateRzRxRyf(modelMatrix, 0.0f, 0.0f, angle);
glUniformMatrix4fv(g_modelMatrixShadowLocation, 1, GL_FALSE, modelMatrix);
glBindVertexArray(g_vaoShadow);
// Overwrite the background plane
glDisable(GL_DEPTH_TEST);
glDrawElements(GL_TRIANGLES, g_numberIndicesTorus, GL_UNSIGNED_INT, 0);
glEnable(GL_DEPTH_TEST);
// Torus with color
glUseProgram(g_program.program);
glusMatrix4x4Multiplyf(modelViewMatrix, viewMatrix, modelMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glUniform4f(g_colorLocation, 0.33f, 0.0f, 0.5f, 1.0f);
glBindVertexArray(g_vao);
glDrawElements(GL_TRIANGLES, g_numberIndicesTorus, GL_UNSIGNED_INT, 0);
//
angle += 20.0f * time;
return GLUS_TRUE;
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat angle = 0.0f;
GLfloat modelMatrix[16];
GLfloat modelViewMatrix[16];
GLfloat normalMatrix[9];
GLfloat planeMatrix[16];
GLfloat clippingPlane[4] = {0.0f, 0.0f, -1.0f, 0.0f};
GLfloat planeBecauseOfBug[4] = {0.0f, -1.0f, 0.0f, 100.0f};
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// Clipping plane
glusMatrix4x4Identityf(planeMatrix);
glusMatrix4x4RotateRyf(planeMatrix, angle);
glusMatrix4x4Translatef(planeMatrix, 0.0f, 0.25, 0.25f);
glusMatrix4x4RotateRxf(planeMatrix, -30.0f);
// For planes, we do need the inverse, transposed matrix.
glusMatrix4x4InverseRigidBodyf(planeMatrix);
glusMatrix4x4Transposef(planeMatrix);
glusMatrix4x4MultiplyPlanef(clippingPlane, planeMatrix, clippingPlane);
glUniform4fv(g_planeLocation, 1, clippingPlane);
// Sphere
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4RotateRyf(modelMatrix, angle);
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glBindVertexArray(g_vao);
// Always pass. The 0s are not used.
glStencilFunc(GL_ALWAYS, 0, 0);
// Visible elements gets twice inverted, because of the front and back face. So the value is 0.
// The clipped area only gets inverted by the back face. The front face is clipped, so no second invert is done. The final value is 255 (assume an 8bit stencil buffer).
glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
glEnable(GL_CLIP_DISTANCE0);
glDrawElements(GL_TRIANGLES, g_numberIndicesSphere, GL_UNSIGNED_INT, 0);
// Plane
// Use the model matrix from the sphere and add the plane transforms.
glusMatrix4x4Translatef(modelMatrix, 0.0f, 0.25, 0.25f);
glusMatrix4x4RotateRxf(modelMatrix, -30.0f);
glusMatrix4x4Multiplyf(modelViewMatrix, g_viewMatrix, modelMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glBindVertexArray(g_planeVAO);
// Render only, where 255 & 1 = 1 is set.
glStencilFunc(GL_EQUAL, 1, 1);
glDisable(GL_CLIP_DISTANCE0);
// Note: Bug in the AMD driver. The above disable is not working: "Values written into gl_ClipDistance for planes that are not enabled have no effect."
// For a workaround, I am setting a far plane, which does not clip anything.
glUniform4fv(g_planeLocation, 1, planeBecauseOfBug);
glDrawElements(GL_TRIANGLES, g_numberIndicesPlane, GL_UNSIGNED_INT, 0);
angle += 45.0f * time;
return GLUS_TRUE;
}
GLUSboolean GLUSAPIENTRY glusMatrix4x4Inversef(GLUSfloat matrix[16])
{
GLUSint i;
GLUSint column;
GLUSint row;
GLUSfloat copy[16];
//
// Copy the original matrix as we want to manipulate it
//
for (i = 0; i < 16; i++)
{
copy[i] = matrix[i];
}
glusMatrix4x4Identityf(matrix);
//
// Make triangle form
//
for (column = 0; column < 4; column++)
{
GLUSint row;
for (row = column; row < 4; row++)
{
//
// Is row all zero, then return false
//
if (glusIsRowZerof(copy, row))
{
return GLUS_FALSE;
}
//
// Divide, if not zero, by copy[column*4+row]
//
if (copy[column * 4 + row] != 0.0f)
{
glusDevideRowByf(matrix, copy, row, copy[column * 4 + row]);
}
}
//
// Is column all zero, then return false
//
if (glusIsColumnZerof(copy, column))
{
return GLUS_FALSE;
}
//
// Is pivot [column*4+column] = 0.0f
//
for (row = column + 1; row < 4; row++)
{
if (copy[column * 4 + row] == 1.0f)
{
//
// Swap with pivot row = column
//
glusSwapRowf(matrix, copy, column, row);
break;
}
}
for (row = column + 1; row < 4; row++)
{
//
// Subtract, [column*4+row] not zero, current row minus pivot row = column
//
if (copy[column * 4 + row] != 0.0f)
{
glusAddRowf(matrix, copy, row, column, -1.0f);
}
}
}
//
// Make diagonal form
//
for (column = 3; column >= 0; column--)
{
for (row = column - 1; row >= 0; row--)
{
//
// Subtract, if [column*4+row] not zero, current row minus pivot row = column with factor [column*4+row]
//
if (copy[column * 4 + row] != 0.0f)
{
glusAddRowf(matrix, copy, row, column, -copy[column * 4 + row]);
}
}
}
return GLUS_TRUE;
}
void Matrix4x4::identity()
{
glusMatrix4x4Identityf(m);
}
Matrix4x4::Matrix4x4()
{
glusMatrix4x4Identityf(m);
}
GLUSboolean update(GLUSfloat time)
{
// Bias needed to convert the from [-1;1] to [0;1]
GLfloat biasMatrix[16] = {0.5f, 0.0f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 0.5f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f};
// Frame buffer has another view port and so perspective projection. Needed for projected texturing of the mirror texture.
GLfloat viewProjectionBiasTextureMatrix[16];
// This matrix is used to flip the rendered object upside down.
GLfloat scaleMatrix[16];
// Store current width and height for later reseting.
GLuint width = g_width;
GLuint height = g_height;
//
// Upside down rendering to frame buffer.
//
glBindFramebuffer(GL_FRAMEBUFFER, g_fboMirrorTexture);
reshape(TEXTURE_WIDTH, TEXTURE_HEIGHT);
glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glusMatrix4x4Identityf(scaleMatrix);
glusMatrix4x4Scalef(scaleMatrix, 1.0f, -1.0f, 1.0f);
glFrontFace(GL_CW);
if (!updateWavefront(time, scaleMatrix))
{
return GLUS_FALSE;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Save the current projection matrix for later usage.
glusMatrix4x4Copyf(viewProjectionBiasTextureMatrix, g_viewProjectionMatrix, GLUS_FALSE);
glusMatrix4x4Multiplyf(viewProjectionBiasTextureMatrix, biasMatrix, viewProjectionBiasTextureMatrix);
//
// Scene rendering
//
reshape(width, height);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Normal rendering
glusMatrix4x4Identityf(scaleMatrix);
glFrontFace(GL_CCW);
if (!updateWavefront(time, scaleMatrix))
{
return GLUS_FALSE;
}
glUseProgram(g_program.program);
// This matrix is needed to calculate the vertices into the frame buffer render pass.
glUniformMatrix4fv(g_viewProjectionBiasTextureMatrixLocation, 1, GL_FALSE, viewProjectionBiasTextureMatrix);
glBindVertexArray(g_vao);
glDrawElements(GL_TRIANGLES, g_numberIndicesSphere, GL_UNSIGNED_INT, 0);
return GLUS_TRUE;
}
GLUSboolean init(GLUSvoid)
{
GLfloat lightDirection[3] = { 1.0f, 1.0f, 1.0f };
GLfloat color[4] = { 0.0f, 1.0f, 1.0f, 1.0f };
GLUStextfile computeSource;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLint i;
GLfloat matrix[16];
GLfloat* normals;
GLfloat distanceRest;
GLfloat distanceDiagonalRest;
GLfloat sphereCenter[4] = {0.0f, 0.0f, -0.01f, 1.0f};
GLfloat sphereRadius = 1.0f;
glusFileLoadText("../Example40/shader/cloth.comp.glsl", &computeSource);
glusProgramBuildComputeFromSource(&g_computeProgram, (const GLchar**) &computeSource.text);
glusFileDestroyText(&computeSource);
glusFileLoadText("../Example40/shader/cloth.vert.glsl", &vertexSource);
glusFileLoadText("../Example40/shader/cloth.frag.glsl", &fragmentSource);
glusProgramBuildFromSource(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
glusFileDestroyText(&vertexSource);
glusFileDestroyText(&fragmentSource);
//
g_verticesPerRowLocation = glGetUniformLocation(g_computeProgram.program, "u_verticesPerRow");
g_deltaTimeLocation = glGetUniformLocation(g_computeProgram.program, "u_deltaTime");
g_distanceRestLocation = glGetUniformLocation(g_computeProgram.program, "u_distanceRest");
g_distanceDiagonalRestLocation = glGetUniformLocation(g_computeProgram.program, "u_distanceDiagonalRest");
g_sphereCenterLocation = glGetUniformLocation(g_computeProgram.program, "u_sphereCenter");
g_sphereRadiusLocation = glGetUniformLocation(g_computeProgram.program, "u_sphereRadius");
g_modelViewProjectionMatrixLocation = glGetUniformLocation(g_program.program, "u_modelViewProjectionMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_lightDirectionLocation = glGetUniformLocation(g_program.program, "u_lightDirection");
g_colorLocation = glGetUniformLocation(g_program.program, "u_color");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
//
// Use a helper function to create a grid plane.
glusShapeCreateRectangularGridPlanef(&g_gridPlane, 2.0f, 2.0f, ROWS, ROWS, GLUS_FALSE);
// Use x, as only horizontal and vertical springs are used. Adapt this, if diagonal or a non square grid is used.
distanceRest = g_gridPlane.vertices[4] - g_gridPlane.vertices[0];
distanceDiagonalRest = sqrtf(2.0f * distanceRest * distanceRest);
// Rotate by 90 degrees, that the grid is in the x-z-plane.
glusMatrix4x4Identityf(matrix);
glusMatrix4x4Translatef(matrix, 0.0f, 1.1f, 0.0f);
glusMatrix4x4RotateRxf(matrix, -90.0f);
for (i = 0; i < g_gridPlane.numberVertices; i++)
{
glusMatrix4x4MultiplyPoint4f(&g_gridPlane.vertices[4 * i], matrix, &g_gridPlane.vertices[4 * i]);
}
g_numberIndicesPlane = g_gridPlane.numberIndices;
glGenBuffers(1, &g_indicesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, g_gridPlane.numberIndices * sizeof(GLuint), (GLuint*) g_gridPlane.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
//
normals = (GLfloat*)malloc(g_gridPlane.numberVertices * 4 * sizeof(GLfloat));
// Add one more GLfloat channel as padding for std430 layout.
glusPaddingConvertf(normals, g_gridPlane.normals, 3, 1, g_gridPlane.numberVertices);
free(g_gridPlane.normals);
g_gridPlane.normals = normals;
//
glGenBuffers(3, g_verticesBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, g_verticesBuffer[0]);
glBufferData(GL_SHADER_STORAGE_BUFFER, g_gridPlane.numberVertices * 4 * sizeof(GLfloat), g_gridPlane.vertices, GL_DYNAMIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, g_verticesBuffer[1]);
glBufferData(GL_SHADER_STORAGE_BUFFER, g_gridPlane.numberVertices * 4 * sizeof(GLfloat), g_gridPlane.vertices, GL_DYNAMIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, g_verticesBuffer[2]);
glBufferData(GL_SHADER_STORAGE_BUFFER, g_gridPlane.numberVertices * 4 * sizeof(GLfloat), 0, GL_DYNAMIC_DRAW);
glGenBuffers(1, &g_normalsBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, g_normalsBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, g_gridPlane.numberVertices * 4 * sizeof(GLfloat), g_gridPlane.normals, GL_DYNAMIC_DRAW);
//
glUseProgram(g_program.program);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsBuffer);
glVertexAttribPointer(g_normalLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBuffer[2]);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO);
glBindVertexArray(0);
//
glusVector3Normalizef(lightDirection);
glUniform3fv(g_lightDirectionLocation, 1, lightDirection);
glUniform4fv(g_colorLocation, 1, color);
glUseProgram(0);
//
glUseProgram(g_computeProgram.program);
glUniform1i(g_verticesPerRowLocation, ROWS + 1);
glUniform1f(g_distanceRestLocation, distanceRest);
glUniform1f(g_distanceDiagonalRestLocation, distanceDiagonalRest);
glUniform4fv(g_sphereCenterLocation, 1, sphereCenter);
glUniform1f(g_sphereRadiusLocation, sphereRadius);
glUseProgram(0);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
//
if (!initSphere(sphereCenter, sphereRadius, lightDirection))
{
return GLUS_FALSE;
}
return GLUS_TRUE;
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat angle = 0.0f;
GLfloat modelViewMatrix[16];
GLfloat viewMatrix[16];
GLfloat modelMatrix[16];
GLfloat normalMatrix[9];
// Render the scene.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
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);
glUniformMatrix4fv(g_viewMatrixLocation, 1, GL_FALSE, viewMatrix);
// Draw Color
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Plane
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4Translatef(modelMatrix, 0.0f, 0.0f, -5.0f);
glusMatrix4x4Multiplyf(modelViewMatrix, viewMatrix, modelMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glUniform4f(g_colorLocation, 0.0f, 0.5f, 0.0f, 1.0f);
glBindVertexArray(g_vaoPlane);
glDrawElements(GL_TRIANGLES, g_numberIndicesPlane, GL_UNSIGNED_INT, 0);
// Torus
glusMatrix4x4Identityf(modelMatrix);
glusMatrix4x4RotateRzRxRyf(modelMatrix, 0.0f, 0.0f, angle);
glusMatrix4x4Multiplyf(modelViewMatrix, viewMatrix, modelMatrix);
glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix);
glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix);
glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix);
glUniform4f(g_colorLocation, 0.33f, 0.0f, 0.5f, 1.0f);
glBindVertexArray(g_vao);
glDrawElements(GL_TRIANGLES_ADJACENCY, g_numberIndices, GL_UNSIGNED_INT, 0);
// Draw Shadow Volume
// Using zfail see http://joshbeam.com/articles/stenciled_shadow_volumes_in_opengl/
glEnable(GL_STENCIL_TEST);
glUseProgram(g_programShadowVolume.program);
glUniformMatrix4fv(g_viewMatrixShadowVolumeLocation, 1, GL_FALSE, viewMatrix);
glUniformMatrix4fv(g_modelMatrixShadowVolumeLocation, 1, GL_FALSE, modelMatrix);
// Only render to the stencil buffer
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthMask(GL_FALSE);
// Avoid ugly artifacts
glEnable(GL_POLYGON_OFFSET_FILL);
// Needed, as vertices in the back are extruded to infinity
glEnable(GL_DEPTH_CLAMP);
glBindVertexArray(g_vaoShadowVolume);
// Render the back faces ...
glCullFace(GL_FRONT);
glStencilFunc(GL_ALWAYS, 0x0, 0xff);
glStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
glDrawElements(GL_TRIANGLES_ADJACENCY, g_numberIndices, GL_UNSIGNED_INT, 0);
// ... and then the front faces
glCullFace(GL_BACK);
glStencilFunc(GL_ALWAYS, 0x0, 0xff);
glStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
glDrawElements(GL_TRIANGLES_ADJACENCY, g_numberIndices, GL_UNSIGNED_INT, 0);
// Reset
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDepthMask(GL_TRUE);
glDisable(GL_POLYGON_OFFSET_FILL);
glDisable(GL_DEPTH_CLAMP);
// Draw shadow by blending a black, half transparent plane
glUseProgram(g_programShadowPlane.program);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
// Only render, where the stencil buffer is not 0
glStencilFunc(GL_NOTEQUAL, 0x0, 0xff);
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
glBindVertexArray(g_vaoShadowPlane);
glDrawElements(GL_TRIANGLES, g_numberIndicesShadowPlane, GL_UNSIGNED_INT, 0);
glDisable(GL_BLEND);
glDisable(GL_STENCIL_TEST);
//
angle += 20.0f * time;
return GLUS_TRUE;
}
