GLUSboolean GLUSAPIENTRY glusBuildShaderProgramFromSource(GLUSshaderprogram* shaderProgram, const GLUSenum type, const GLUSchar** source)
{
GLUSint linked;
GLUSint logLength, charsWritten;
char* log;
if (!shaderProgram || !source)
{
return GLUS_FALSE;
}
shaderProgram->program = 0;
shaderProgram->compute = 0;
shaderProgram->vertex = 0;
shaderProgram->fragment = 0;
shaderProgram->program = glCreateShaderProgramv(type, 1, (const char**)source);
glGetProgramiv(shaderProgram->program, GL_LINK_STATUS, &linked);
if (!linked)
{
glGetProgramiv(shaderProgram->program, GL_INFO_LOG_LENGTH, &logLength);
log = (char*) malloc((size_t)logLength);
if (!log)
{
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
glGetProgramInfoLog(shaderProgram->program, logLength, &charsWritten, log);
glusLogPrint(GLUS_LOG_ERROR, "Shader program link error:");
glusLogPrint(GLUS_LOG_ERROR, "%s", log);
free(log);
shaderProgram->program = 0;
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
/**
* Function to clean up things.
*/
GLUSvoid terminate(GLUSvoid)
{
glBindTexture(GL_TEXTURE_2D, 0);
if (g_texture)
{
glDeleteTextures(1, &g_texture);
g_texture = 0;
}
//
glBindVertexArray(0);
if (g_vao)
{
glDeleteVertexArrays(1, &g_vao);
g_vao = 0;
}
//
glUseProgram(0);
glusDestroyProgram(&g_program);
}
/**
* Function to clean up things.
*/
GLUSvoid shutdown(GLUSvoid)
{
delete g_pFullScreenQuad;
// Delete shader program etc..
glusDestroyProgram(&g_program);
}
/**
* Function to clean up things.
*/
GLUSvoid terminate(GLUSvoid)
{
if (g_vertices)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_vertices);
g_vertices = 0;
}
if (g_normals)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_normals);
g_normals = 0;
}
if (g_indices)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_indices);
g_indices = 0;
}
// ToDo:
glDeleteVertexArrays(1, &g_vao);
// Delete shader program etc..
//g_shader.deleteAll();
glusDestroyProgram(&g_program);
}
GLUSvoid terminate(GLUSvoid)
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesVBO)
{
glDeleteBuffers(1, &g_verticesVBO);
g_verticesVBO = 0;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_indicesVBO)
{
glDeleteBuffers(1, &g_indicesVBO);
g_indicesVBO = 0;
}
glBindVertexArray(0);
if (g_vao)
{
glDeleteVertexArrays(1, &g_vao);
g_vao = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_program);
}
GLUSboolean GLUSAPIENTRY glusLinkProgram(GLUSshaderprogram* shaderProgram)
{
GLUSint linked;
GLUSint logLength, charsWritten;
char* log;
if (!shaderProgram)
{
return GLUS_FALSE;
}
glLinkProgram(shaderProgram->program);
glGetProgramiv(shaderProgram->program, GL_LINK_STATUS, &linked);
if (!linked)
{
glGetProgramiv(shaderProgram->program, GL_INFO_LOG_LENGTH, &logLength);
log = (char*) malloc((size_t)logLength);
if (!log)
{
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
glGetProgramInfoLog(shaderProgram->program, logLength, &charsWritten, log);
glusLogPrint(GLUS_LOG_ERROR, "Shader program link error:");
glusLogPrint(GLUS_LOG_ERROR, "%s", log);
free(log);
shaderProgram->program = 0;
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
return GLUS_TRUE;
}
GLUSvoid terminate(GLUSvoid)
{
glBindTexture(GL_TEXTURE_2D, 0);
if (g_texture)
{
glDeleteTextures(1, &g_texture);
g_texture = 0;
}
//
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
if (g_directionSSBO)
{
glDeleteBuffers(1, &g_directionSSBO);
g_directionSSBO = 0;
}
if (g_positionSSBO)
{
glDeleteBuffers(1, &g_positionSSBO);
g_positionSSBO = 0;
}
//
glBindVertexArray(0);
if (g_vao)
{
glDeleteVertexArrays(1, &g_vao);
g_vao = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_program);
glusDestroyProgram(&g_computeProgram);
}
/**
* Function to clean up things.
*/
GLUSvoid terminate(GLUSvoid)
{
if (g_vertices)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_vertices);
g_vertices = 0;
}
if (g_texture)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteTextures.xml
glDeleteTextures(1, &g_texture);
g_texture = 0;
}
if (g_lookupframebuffer[0])
{
// ToDo:
glDeleteFramebuffers(1, &g_lookupframebuffer[0]);
g_lookupframebuffer[0] = 0;
}
if (g_lookupframebuffer[1])
{
// ToDo:
glDeleteFramebuffers(1, &g_lookupframebuffer[1]);
g_lookupframebuffer[1] = 0;
}
if (g_lookuptexture[0])
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteTextures.xml
glDeleteTextures(1, &g_lookuptexture[0]);
g_lookuptexture[0] = 0;
}
if (g_lookuptexture[1])
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteTextures.xml
glDeleteTextures(1, &g_lookuptexture[1]);
g_lookuptexture[1] = 0;
}
// ToDo:
glDeleteVertexArrays(1, &g_vao);
// Delete shader program etc..
glusDestroyProgram(&g_program);
}
GLUSvoid terminate(GLUSvoid)
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesVBO)
{
glDeleteBuffers(1, &g_verticesVBO);
g_verticesVBO = 0;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_indicesVBO)
{
glDeleteBuffers(1, &g_indicesVBO);
g_indicesVBO = 0;
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
if (g_cubemap)
{
glDeleteTextures(1, &g_cubemap);
g_cubemap = 0;
}
glBindVertexArray(0);
if (g_vao)
{
glDeleteVertexArrays(1, &g_vao);
g_vao = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_program);
//
terminateBackground();
terminateWaterTexture();
}
GLUSvoid terminate(GLUSvoid)
{
glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, 0);
if (g_texture[0])
{
glDeleteTextures(1, &g_texture[0]);
g_texture[0] = 0;
}
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
if (g_texture[1])
{
glDeleteTextures(1, &g_texture[1]);
g_texture[1] = 0;
}
glBindTexture(GL_TEXTURE_2D, 0);
if (g_texture[2])
{
glDeleteTextures(1, &g_texture[2]);
g_texture[2] = 0;
}
//
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesModelVBO)
{
glDeleteBuffers(1, &g_verticesModelVBO);
g_verticesModelVBO = 0;
}
if (g_normalsModelVBO)
{
glDeleteBuffers(1, &g_normalsModelVBO);
g_normalsModelVBO = 0;
}
if (g_verticesBackgroundVBO)
{
glDeleteBuffers(1, &g_verticesBackgroundVBO);
g_verticesBackgroundVBO = 0;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_indicesBackgroundVBO)
{
glDeleteBuffers(1, &g_indicesBackgroundVBO);
g_indicesBackgroundVBO = 0;
}
glBindVertexArray(0);
if (g_modelVAO)
{
glDeleteVertexArrays(1, &g_modelVAO);
g_modelVAO = 0;
}
if (g_backgroundVAO)
{
glDeleteVertexArrays(1, &g_backgroundVAO);
g_backgroundVAO = 0;
}
if (g_fullscreenVAO)
{
glDeleteVertexArrays(1, &g_fullscreenVAO);
g_fullscreenVAO = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_modelProgram);
glusDestroyProgram(&g_backgroundProgram);
glusDestroyProgram(&g_fullscreenProgram);
//
glBindTexture(GL_TEXTURE_2D, 0);
if (g_fullscreenTexture)
{
glDeleteTextures(1, &g_fullscreenTexture);
g_fullscreenTexture = 0;
}
glBindRenderbuffer(GL_RENDERBUFFER, 0);
if (g_fullscreenDepthRenderbuffer)
{
glDeleteRenderbuffers(1, &g_fullscreenDepthRenderbuffer);
g_fullscreenDepthRenderbuffer = 0;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
if (g_fullscreenFBO)
{
glDeleteFramebuffers(1, &g_fullscreenFBO);
g_fullscreenFBO = 0;
}
}
GLUSvoid terminate(GLUSvoid)
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesVBO)
{
glDeleteBuffers(1, &g_verticesVBO);
g_verticesVBO = 0;
}
if (g_normalsVBO)
{
glDeleteBuffers(1, &g_normalsVBO);
g_normalsVBO = 0;
}
if (g_texCoordsVBO)
{
glDeleteBuffers(1, &g_texCoordsVBO);
g_texCoordsVBO = 0;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_indicesVBO)
{
glDeleteBuffers(1, &g_indicesVBO);
g_indicesVBO = 0;
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_texture)
{
glDeleteTextures(1, &g_texture);
g_texture = 0;
}
glBindVertexArray(0);
if (g_vao)
{
glDeleteVertexArrays(1, &g_vao);
g_vao = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_program);
//
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_mirrorTexture)
{
glDeleteTextures(1, &g_mirrorTexture);
g_mirrorTexture = 0;
}
glBindRenderbuffer(GL_RENDERBUFFER, 0);
if (g_depthMirrorTexture)
{
glDeleteRenderbuffers(1, &g_depthMirrorTexture);
g_depthMirrorTexture = 0;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
if (g_fboMirrorTexture)
{
glDeleteFramebuffers(1, &g_fboMirrorTexture);
g_fboMirrorTexture = 0;
}
terminateWavefront();
}
GLUSvoid terminate(GLUSvoid)
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesVBO)
{
glDeleteBuffers(1, &g_verticesVBO);
g_verticesVBO = 0;
}
if (g_tangentsVBO)
{
glDeleteBuffers(1, &g_tangentsVBO);
g_tangentsVBO = 0;
}
if (g_bitangentsVBO)
{
glDeleteBuffers(1, &g_bitangentsVBO);
g_bitangentsVBO = 0;
}
if (g_normalsVBO)
{
glDeleteBuffers(1, &g_normalsVBO);
g_normalsVBO = 0;
}
if (g_texCoordsVBO)
{
glDeleteBuffers(1, &g_texCoordsVBO);
g_texCoordsVBO = 0;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_indicesVBO)
{
glDeleteBuffers(1, &g_indicesVBO);
g_indicesVBO = 0;
}
if (g_texture)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
glDeleteTextures(1, &g_texture);
g_texture = 0;
}
if (g_normalMap)
{
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, 0);
glDeleteTextures(1, &g_normalMap);
g_normalMap = 0;
}
glBindVertexArray(0);
if (g_vao)
{
glDeleteVertexArrays(1, &g_vao);
g_vao = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_program);
}
/**
* Function to clean up things.
*/
GLUSvoid terminate(GLUSvoid)
{
if (g_vertices)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_vertices);
g_vertices = 0;
}
if (g_normals)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_normals);
g_normals = 0;
}
if (g_tangents)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_tangents);
g_tangents = 0;
}
if (g_texCoords)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_texCoords);
g_texCoords = 0;
}
if (g_indices)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_indices);
g_indices = 0;
}
if (g_texture)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteTextures.xml
glDeleteTextures(1, &g_texture);
g_texture = 0;
}
if (g_normalMap)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteTextures.xml
glDeleteTextures(1, &g_normalMap);
g_normalMap = 0;
}
// ToDo:
glDeleteVertexArrays(1, &g_vao);
// Delete shader program etc..
glusDestroyProgram(&g_program);
}
GLUSvoid terminate(GLUSvoid)
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesVBO)
{
glDeleteBuffers(1, &g_verticesVBO);
g_verticesVBO = 0;
}
if (g_normalsVBO)
{
glDeleteBuffers(1, &g_normalsVBO);
g_normalsVBO = 0;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_indicesVBO)
{
glDeleteBuffers(1, &g_indicesVBO);
g_indicesVBO = 0;
}
glBindVertexArray(0);
if (g_vao)
{
glDeleteVertexArrays(1, &g_vao);
g_vao = 0;
}
//
if (g_verticesPlaneVBO)
{
glDeleteBuffers(1, &g_verticesPlaneVBO);
g_verticesPlaneVBO = 0;
}
if (g_normalsPlaneVBO)
{
glDeleteBuffers(1, &g_normalsPlaneVBO);
g_normalsPlaneVBO = 0;
}
if (g_indicesPlaneVBO)
{
glDeleteBuffers(1, &g_indicesPlaneVBO);
g_indicesPlaneVBO = 0;
}
if (g_vaoPlane)
{
glDeleteVertexArrays(1, &g_vaoPlane);
g_vaoPlane = 0;
}
//
if (g_verticesShadowPlaneVBO)
{
glDeleteBuffers(1, &g_verticesShadowPlaneVBO);
g_verticesShadowPlaneVBO = 0;
}
if (g_indicesShadowPlaneVBO)
{
glDeleteBuffers(1, &g_indicesShadowPlaneVBO);
g_indicesShadowPlaneVBO = 0;
}
if (g_vaoShadowPlane)
{
glDeleteVertexArrays(1, &g_vaoShadowPlane);
g_vaoShadowPlane = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_program);
glusDestroyProgram(&g_programShadowVolume);
glusDestroyProgram(&g_programShadowPlane);
}
GLUSvoid terminate(GLUSvoid)
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesVBO)
{
glDeleteBuffers(1, &g_verticesVBO);
g_verticesVBO = 0;
}
if (g_normalsVBO)
{
glDeleteBuffers(1, &g_normalsVBO);
g_normalsVBO = 0;
}
if (g_texCoordsVBO)
{
glDeleteBuffers(1, &g_texCoordsVBO);
g_texCoordsVBO = 0;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_indicesVBO)
{
glDeleteBuffers(1, &g_indicesVBO);
g_indicesVBO = 0;
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_texture)
{
glDeleteTextures(1, &g_texture);
g_texture = 0;
}
glBindVertexArray(0);
if (g_vao)
{
glDeleteVertexArrays(1, &g_vao);
g_vao = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_program);
//
if (g_postprocessVerticesVBO)
{
glDeleteBuffers(1, &g_postprocessVerticesVBO);
g_postprocessVerticesVBO = 0;
}
if (g_postprocessTexCoordsVBO)
{
glDeleteBuffers(1, &g_postprocessTexCoordsVBO);
g_postprocessTexCoordsVBO = 0;
}
if (g_postprocessIndicesVBO)
{
glDeleteBuffers(1, &g_postprocessIndicesVBO);
g_postprocessIndicesVBO = 0;
}
if (g_ssaoVAO)
{
glDeleteVertexArrays(1, &g_ssaoVAO);
g_ssaoVAO = 0;
}
if (g_blurVAO)
{
glDeleteVertexArrays(1, &g_blurVAO);
g_blurVAO = 0;
}
glusDestroyProgram(&g_ssaoProgram);
glusDestroyProgram(&g_blurProgram);
//
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_ssaoTexture)
{
glDeleteTextures(1, &g_ssaoTexture);
g_ssaoTexture = 0;
}
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_ssaoNormalTexture)
{
glDeleteTextures(1, &g_ssaoNormalTexture);
g_ssaoNormalTexture = 0;
}
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_ssaoDepthTexture)
{
glDeleteTextures(1, &g_ssaoDepthTexture);
g_ssaoDepthTexture = 0;
}
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_ssaoRotationNoiseTexture)
{
glDeleteTextures(1, &g_ssaoRotationNoiseTexture);
g_ssaoRotationNoiseTexture = 0;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
if (g_ssaoFBO)
{
glDeleteFramebuffers(1, &g_ssaoFBO);
g_ssaoFBO = 0;
}
//
if (g_blurTexture)
{
glDeleteTextures(1, &g_blurTexture);
g_blurTexture = 0;
}
if (g_blurFBO)
{
glDeleteFramebuffers(1, &g_blurFBO);
g_blurFBO = 0;
}
//
terminateWavefront();
}
int main(int argc, char* argv[])
{
GLUSchar* output;
GLUSchar* extension;
GLUSchar fileType[MAX_FILETYPE_LENGTH];
GLUSchar buffer[MAX_FILENAME_LENGTH];
GLUSint roughnessSamples;
GLUSuint exponent;
GLUSuint samples;
GLUSint i, k, m, o, p, q, x, y, ouputLength;
GLUSboolean isHDR = GLUS_FALSE;
GLUStgaimage tgaOutput[2];
GLUShdrimage hdrOutput[2];
GLUSint length;
GLUSint lengthExponent;
GLUSint stride;
GLUSfloat offset, step, roughness;
GLUSfloat startVector[3] = { 1.0f, -1.0f, -1.0f };
GLUSfloat offsetVector[3];
GLUSfloat normalVector[3];
GLUSfloat* scanVectors;
GLUSfloat* colorBufferLambert;
GLUSfloat* colorBufferCookTorrance;
GLUSfloat matrix[9];
GLUStextfile computeSource;
GLUSshaderprogram computeProgram;
GLUSuint localSize = 16;
GLUSuint textureLambert;
GLUSuint textureCookTorrance;
GLUSuint scanVectorsSSBO;
GLUSint mLocation;
GLUSint samplesLocation;
GLUSint binaryFractionFactorLocation;
GLUSint roughnessLocation;
if (argc != 11)
{
printf("Usage: Panorama2CubeMap.exe [Pos X] [Neg X] [Pos Y] [Neg Y] [Pos Z] [Neg Z] [Output] [Roughness] [Samples 2^m] [Length 2^n]\n");
return -1;
}
//
output = argv[7];
ouputLength = strlen(output);
if (ouputLength >= MAX_FILENAME_LENGTH - (MAX_FILETYPE_LENGTH - 1) - SIDE_NAMING_LENGTH - ROUGHNESS_NAMING_LENGTH - TYPE_NAMING_LENGTH)
{
printf("Error: Output filename too long.\n");
return -1;
}
roughnessSamples = atoi(argv[8]);
if (roughnessSamples < 2 || roughnessSamples >= 100)
{
printf("Error: Invalid roughness value.\n");
return -1;
}
exponent = (GLUSuint)atoi(argv[9]);
if (exponent > 16)
{
printf("Error: Invalid samples value.\n");
return -1;
}
samples = 1 << exponent;
lengthExponent = (GLUSuint)atoi(argv[10]);
if (lengthExponent > 16)
{
printf("Error: Invalid length value.\n");
return -1;
}
length = 1 << lengthExponent;
if (roughnessSamples < 2 || roughnessSamples >= 100)
{
printf("Error: Invalid roughness value.\n");
return -1;
}
//
extension = strrchr(argv[1], '.');
if (extension == 0)
{
printf("Error: No file type found.\n");
return -1;
}
if (strlen(extension) != MAX_FILETYPE_LENGTH - 1)
{
printf("Error: Invalid file type.\n");
return -1;
}
// Copy includes NULL terminating character.
for (i = 0; i < MAX_FILETYPE_LENGTH ; i++)
{
fileType[i] = tolower(extension[i]);
}
stride = 1;
printf("Loading texture cube maps ... ");
if (strcmp(fileType, ".tga") == 0)
{
//
for (i = 0; i < 6; i++)
{
if (!glusLoadTgaImage(argv[1 + i], &g_tgaimage[i]))
{
printf("failed! TGA image could not be loaded.\n");
freeTgaImages(i);
return -1;
}
if (i > 0)
{
if (g_tgaimage[0].width != g_tgaimage[i].width || g_tgaimage[0].height != g_tgaimage[i].height)
{
printf("failed! TGA images do have different dimension.\n");
freeTgaImages(i + 1);
return -1;
}
}
else
{
if (g_tgaimage[0].width != g_tgaimage[i].height)
{
printf("failed! TGA images do have different dimension.\n");
freeTgaImages(1);
return -1;
}
}
}
if (g_tgaimage[0].format == GLUS_RGB)
{
stride = 3;
}
else if (g_tgaimage[0].format == GLUS_RGBA)
{
stride = 4;
}
//
tgaOutput[0] = g_tgaimage[0];
tgaOutput[0].width = length;
tgaOutput[0].height = length;
tgaOutput[0].data = (GLUSubyte*)malloc(length * length * stride * sizeof(GLUSubyte));
if (!tgaOutput[0].data)
{
printf("failed! TGA output image could not be created.\n");
freeTgaImages(6);
return -1;
}
tgaOutput[1] = g_tgaimage[0];
tgaOutput[1].width = length;
tgaOutput[1].height = length;
tgaOutput[1].data = (GLUSubyte*)malloc(length * length * stride * sizeof(GLUSubyte));
if (!tgaOutput[1].data)
{
printf("failed! TGA output image could not be created.\n");
freeTgaImages(6);
glusDestroyTgaImage(&tgaOutput[0]);
return -1;
}
}
else if (strcmp(fileType, ".hdr") == 0)
{
isHDR = GLUS_TRUE;
for (i = 0; i < 6; i++)
{
if (!glusLoadHdrImage(argv[1 + i], &g_hdrimage[i]))
{
printf("failed! HDR image could not be loaded.\n");
freeHdrImages(i);
return -1;
}
if (i > 0)
{
if (g_hdrimage[0].width != g_hdrimage[i].width || g_hdrimage[0].height != g_hdrimage[i].height)
{
printf("failed! HDR images do have different dimension.\n");
freeHdrImages(i + 1);
return -1;
}
}
else
{
if (g_hdrimage[0].width != g_hdrimage[i].height)
{
printf("failed! HDR images do have different dimension.\n");
freeHdrImages(1);
return -1;
}
}
}
stride = 3;
//
hdrOutput[0] = g_hdrimage[0];
hdrOutput[0].width = length;
hdrOutput[0].height = length;
hdrOutput[0].data = (GLUSfloat*)malloc(length * length * stride * sizeof(GLUSfloat));
if (!hdrOutput[0].data)
{
printf("failed! HDR output image could not be created.\n");
freeHdrImages(6);
return -1;
}
hdrOutput[1] = g_hdrimage[0];
hdrOutput[1].width = length;
hdrOutput[1].height = length;
hdrOutput[1].data = (GLUSfloat*)malloc(length * length * stride * sizeof(GLUSfloat));
if (!hdrOutput[1].data)
{
printf("failed! HDR output image could not be created.\n");
freeHdrImages(6);
glusDestroyHdrImage(&hdrOutput[1]);
return -1;
}
}
else
{
printf("failed. Unknown file type.\n");
return -1;
}
printf("completed!\n");
// Contains the vectors to scan and generate one side of the pre-filtered cube map.
scanVectors = (GLUSfloat*)malloc(length * length * (3 + 1) * sizeof(GLUSfloat));
if (!scanVectors)
{
printf("Error: Scan scanVectors could not be created.\n");
freeHdrImages(6);
return -1;
}
// Color buffer needed to gather the pixels from the texture.
colorBufferLambert = (GLUSfloat*)malloc(length * length * 4 * sizeof(GLUSfloat));
if (!colorBufferLambert)
{
printf("Error: Color buffer could not be created.\n");
freeHdrImages(6);
free(scanVectors);
return -1;
}
// Color buffer needed to gather the pixels from the texture.
colorBufferCookTorrance = (GLUSfloat*)malloc(length * length * 4 * sizeof(GLUSfloat));
if (!colorBufferCookTorrance)
{
printf("Error: Color buffer could not be created.\n");
freeHdrImages(6);
free(scanVectors);
free(colorBufferLambert);
return -1;
}
//
// Initialize OpenGL, as it is needed for the compute shader.
//
glusPrepareContext(4, 3, GLUS_FORWARD_COMPATIBLE_BIT);
if (!glusCreateWindow("GLUS Example Window", 512, 512, 0, 0, GLUS_FALSE))
{
printf("Could not create window!\n");
return -1;
}
if (!glusStartup())
{
return -1;
}
//
// Compute shader for pre-filtering.
//
glusLoadTextFile("../PreFilterCubeMap/shader/prefilter.comp.glsl", &computeSource);
glusBuildComputeProgramFromSource(&computeProgram, (const GLchar**)&computeSource.text);
glusDestroyTextFile(&computeSource);
//
mLocation = glGetUniformLocation(computeProgram.program, "u_m");
samplesLocation = glGetUniformLocation(computeProgram.program, "u_samples");
binaryFractionFactorLocation = glGetUniformLocation(computeProgram.program, "u_binaryFractionFactor");
roughnessLocation = glGetUniformLocation(computeProgram.program, "u_roughness");
//
glUseProgram(computeProgram.program);
//
//
//
// Create cube maps
if (isHDR)
{
createHdrCubeMap();
freeHdrImages(6);
}
else
{
createTgaCubeMap();
freeTgaImages(6);
}
// Prepare texture, where the pre-filtered image is stored: Lambert
glGenTextures(1, &textureLambert);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textureLambert);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, length, length, 0, GL_RGBA, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// see binding = 1 in the shader
glBindImageTexture(1, textureLambert, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
//
// Prepare texture, where the pre-filtered image is stored: Cook-Torrance
glGenTextures(1, &textureCookTorrance);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, textureCookTorrance);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, length, length, 0, GL_RGBA, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// see binding = 2 in the shader
glBindImageTexture(2, textureCookTorrance, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
//
//
//
step = 2.0f / (GLUSfloat)length;
offset = step * 0.5f;
// Prepare save name.
strcpy(buffer, output);
buffer[ouputLength + 0] = '_';
buffer[ouputLength + 4] = '_';
buffer[ouputLength + 6] = '_';
buffer[ouputLength + 9] = '_';
for (i = ouputLength + SIDE_NAMING_LENGTH + ROUGHNESS_NAMING_LENGTH + TYPE_NAMING_LENGTH; i < ouputLength + SIDE_NAMING_LENGTH + ROUGHNESS_NAMING_LENGTH + TYPE_NAMING_LENGTH + MAX_FILETYPE_LENGTH; i++)
{
buffer[i] = fileType[i - (ouputLength + SIDE_NAMING_LENGTH + ROUGHNESS_NAMING_LENGTH + TYPE_NAMING_LENGTH)];
}
//
// Setup scan vectors buffer for compute shader.
glGenBuffers(1, &scanVectorsSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, scanVectorsSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, length * length * (3 + 1) * sizeof(GLfloat), 0, GL_DYNAMIC_DRAW);
// see binding = 3 in the shader
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, scanVectorsSSBO);
// Setup m and samples for compute shader.
glUniform1ui(mLocation, exponent);
glUniform1ui(samplesLocation, samples);
// Results are in range [0.0 1.0] and not [0.0, 1.0[.
glUniform1f(binaryFractionFactorLocation, 1.0f / (powf(2.0f, (GLfloat)exponent) - 1.0f));
printf("Generating pre filtered cube maps ...\n");
for (i = 0; i < 6; i++)
{
printf("Side: %d\n", i);
switch (i)
{
case 0:
// Positive X
glusMatrix3x3Identityf(matrix);
buffer[ouputLength + 1] = 'P';
buffer[ouputLength + 2] = 'O';
buffer[ouputLength + 3] = 'S';
buffer[ouputLength + 5] = 'X';
break;
case 1:
// Negative X
glusMatrix3x3Identityf(matrix);
glusMatrix3x3RotateRyf(matrix, 180.0f);
buffer[ouputLength + 1] = 'N';
buffer[ouputLength + 2] = 'E';
buffer[ouputLength + 3] = 'G';
buffer[ouputLength + 5] = 'X';
break;
case 2:
// Positive Y
glusMatrix3x3Identityf(matrix);
glusMatrix3x3RotateRxf(matrix, 90.0f);
glusMatrix3x3RotateRyf(matrix, 90.0f);
buffer[ouputLength + 1] = 'P';
buffer[ouputLength + 2] = 'O';
buffer[ouputLength + 3] = 'S';
buffer[ouputLength + 5] = 'Y';
break;
case 3:
// Negative Y
glusMatrix3x3Identityf(matrix);
glusMatrix3x3RotateRxf(matrix, -90.0f);
glusMatrix3x3RotateRyf(matrix, 90.0f);
buffer[ouputLength + 1] = 'N';
buffer[ouputLength + 2] = 'E';
buffer[ouputLength + 3] = 'G';
buffer[ouputLength + 5] = 'Y';
break;
case 4:
// Positive Z
glusMatrix3x3Identityf(matrix);
glusMatrix3x3RotateRyf(matrix, -90.0f);
buffer[ouputLength + 1] = 'P';
buffer[ouputLength + 2] = 'O';
buffer[ouputLength + 3] = 'S';
buffer[ouputLength + 5] = 'Z';
break;
case 5:
// Negative Z
glusMatrix3x3Identityf(matrix);
glusMatrix3x3RotateRyf(matrix, 90.0f);
buffer[ouputLength + 1] = 'N';
buffer[ouputLength + 2] = 'E';
buffer[ouputLength + 3] = 'G';
buffer[ouputLength + 5] = 'Z';
break;
}
// Generate scan vectors
for (k = 0; k < length; k++)
{
for (m = 0; m < length; m++)
{
offsetVector[0] = 0.0f;
offsetVector[1] = offset + step * (GLUSfloat)k;
offsetVector[2] = offset + step * (GLUSfloat)m;
glusVector3AddVector3f(normalVector, startVector, offsetVector);
glusVector3Normalizef(normalVector);
glusMatrix3x3MultiplyVector3f(&scanVectors[k * length * (3 + 1) + m * (3 + 1)], matrix, normalVector);
}
}
// Upload scan vectors for each side.
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, length * length * (3 + 1) * sizeof(GLfloat), scanVectors);
// For all roughness levels
for (k = 0; k < roughnessSamples; k++)
{
// Calculate roughness ...
roughness = (GLUSfloat)k * 1.0f / (GLUSfloat)(roughnessSamples - 1);
printf("Roughness: %f\n", roughness);
// ... and set it up for compute shader.
glUniform1f(roughnessLocation, roughness);
// Run the compute shader, which is doing the pre-filtering.
glDispatchCompute(length / localSize, length / localSize, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textureLambert);
if (roughness == 0.0f)
{
// Compute shader stores result in given texture.
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, colorBufferLambert);
}
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, textureCookTorrance);
// Compute shader stores result in given texture.
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, colorBufferCookTorrance);
// Resolve
for (p = 0; p < length; p++)
{
for (q = 0; q < length; q++)
{
// Some of the textures need to be stored flipped and mirrored down.
switch (i)
{
case 0:
case 1:
case 4:
case 5:
// Positive X
// Negative X
// Positive Z
// Negative Z
x = length - 1 - q;
y = length - 1 - p;
break;
case 2:
case 3:
// Positive Y
// Negative Y
x = q;
y = p;
break;
}
for (o = 0; o < stride; o++)
{
if (isHDR)
{
if (roughness == 0.0f)
{
hdrOutput[0].data[p * length * stride + q * stride + o] = colorBufferLambert[y * length * 4 + x * 4 + o];
}
hdrOutput[1].data[p * length * stride + q * stride + o] = colorBufferCookTorrance[y * length * 4 + x * 4 + o];
}
else
{
if (roughness == 0.0f)
{
tgaOutput[0].data[p * length * stride + q * stride + o] = (GLUSubyte)glusClampf(colorBufferLambert[y * length * 4 + x * 4 + o] * 255.0f, 0.0f, 255.0f);
}
tgaOutput[1].data[p * length * stride + q * stride + o] = (GLUSubyte)glusClampf(colorBufferCookTorrance[y * length * 4 + x * 4 + o] * 255.0f, 0.0f, 255.0f);
}
}
}
}
// Construct save name depending on roughness level.
buffer[ouputLength + 7] = '0' + (k / 10);
buffer[ouputLength + 8] = '0' + (k % 10);
if (isHDR)
{
if (roughness == 0.0f)
{
buffer[ouputLength + 10] = 'd';
glusSaveHdrImage(buffer, &hdrOutput[0]);
}
buffer[ouputLength + 10] = 's';
glusSaveHdrImage(buffer, &hdrOutput[1]);
}
else if (roughness == 0.0f)
{
if (roughness == 0.0f)
{
buffer[ouputLength + 10] = 'd';
glusSaveTgaImage(buffer, &tgaOutput[0]);
}
buffer[ouputLength + 10] = 's';
glusSaveTgaImage(buffer, &tgaOutput[1]);
}
}
}
printf("completed!\n");
//
// Freeing resources
//
free(scanVectors);
free(colorBufferLambert);
free(colorBufferCookTorrance);
glusDestroyProgram(&computeProgram);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
if (g_cubemap)
{
glDeleteTextures(1, &g_cubemap);
g_cubemap = 0;
}
glBindTexture(GL_TEXTURE_2D, 0);
if (textureLambert)
{
glDeleteTextures(1, &textureLambert);
textureLambert = 0;
}
if (textureCookTorrance)
{
glDeleteTextures(1, &textureCookTorrance);
textureCookTorrance = 0;
}
if (isHDR)
{
glusDestroyHdrImage(&hdrOutput[0]);
glusDestroyHdrImage(&hdrOutput[1]);
}
else
{
glusDestroyTgaImage(&tgaOutput[0]);
glusDestroyTgaImage(&tgaOutput[1]);
}
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
if (scanVectorsSSBO)
{
glDeleteBuffers(1, &scanVectorsSSBO);
scanVectorsSSBO = 0;
}
//
// Shutdown OpenGL.
//
glusShutdown();
return 0;
}
/**
* Function to clean up things.
*/
GLUSvoid terminate(GLUSvoid)
{
if (g_vertices)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_vertices);
g_vertices = 0;
}
if (g_indices)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_indices);
g_indices = 0;
}
if (g_cubemap)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteTextures.xml
glDeleteTextures(1, &g_cubemap);
g_cubemap = 0;
}
// ToDo:
glDeleteVertexArrays(1, &g_vao);
// Delete shader program etc..
glusDestroyProgram(&g_program);
//
if (g_verticesBackground)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_verticesBackground);
g_verticesBackground = 0;
}
if (g_normalsBackground)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_normalsBackground);
g_normalsBackground = 0;
}
if (g_indicesBackground)
{
// http://www.opengl.org/sdk/docs/man/xhtml/glDeleteBuffers.xml
glDeleteBuffers(1, &g_indicesBackground);
g_indicesBackground = 0;
}
// ToDo:
glDeleteVertexArrays(1, &g_vaoBackground);
// Delete shader program etc..
glusDestroyProgram(&g_programBackground);
// Terminate the texture stuff.
terminateTexture();
}
GLUSboolean GLUSAPIENTRY glusCreateProgramFromSource(GLUSshaderprogram* shaderProgram, const GLUSchar** vertexSource, const GLUSchar** controlSource, const GLUSchar** evaluationSource, const GLUSchar** geometrySource, const GLUSchar** fragmentSource)
{
GLUSint compiled;
GLUSint logLength, charsWritten;
char* log;
if (!shaderProgram || !vertexSource || !fragmentSource)
{
return GLUS_FALSE;
}
shaderProgram->program = 0;
shaderProgram->compute = 0;
shaderProgram->vertex = 0;
shaderProgram->control = 0;
shaderProgram->evaluation = 0;
shaderProgram->geometry = 0;
shaderProgram->fragment = 0;
shaderProgram->vertex = glCreateShader(GLUS_VERTEX_SHADER);
glShaderSource(shaderProgram->vertex, 1, (const char**) vertexSource, 0);
glCompileShader(shaderProgram->vertex);
glGetShaderiv(shaderProgram->vertex, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
glGetShaderiv(shaderProgram->vertex, GL_INFO_LOG_LENGTH, &logLength);
log = (char*) malloc((size_t)logLength);
if (!log)
{
return GLUS_FALSE;
}
glGetShaderInfoLog(shaderProgram->vertex, logLength, &charsWritten, log);
glusLogPrint(GLUS_LOG_ERROR, "Vertex shader compile error:");
glusLogPrint(GLUS_LOG_ERROR, "%s", log);
free(log);
shaderProgram->vertex = 0;
return GLUS_FALSE;
}
if (controlSource)
{
shaderProgram->control = glCreateShader(GLUS_TESS_CONTROL_SHADER);
glShaderSource(shaderProgram->control, 1, (const char**) controlSource, 0);
glCompileShader(shaderProgram->control);
glGetShaderiv(shaderProgram->control, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
glGetShaderiv(shaderProgram->control, GL_INFO_LOG_LENGTH, &logLength);
log = (char*) malloc((size_t)logLength);
if (!log)
{
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
glGetShaderInfoLog(shaderProgram->control, logLength, &charsWritten, log);
glusLogPrint(GLUS_LOG_ERROR, "Control shader compile error:");
glusLogPrint(GLUS_LOG_ERROR, "%s", log);
free(log);
shaderProgram->control = 0;
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
}
if (evaluationSource)
{
shaderProgram->evaluation = glCreateShader(GLUS_TESS_EVALUATION_SHADER);
glShaderSource(shaderProgram->evaluation, 1, (const char**) evaluationSource, 0);
glCompileShader(shaderProgram->evaluation);
glGetShaderiv(shaderProgram->evaluation, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
glGetShaderiv(shaderProgram->evaluation, GL_INFO_LOG_LENGTH, &logLength);
log = (char*) malloc((size_t)logLength);
if (!log)
{
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
glGetShaderInfoLog(shaderProgram->evaluation, logLength, &charsWritten, log);
glusLogPrint(GLUS_LOG_ERROR, "Evaluation shader compile error:");
glusLogPrint(GLUS_LOG_ERROR, "%s", log);
free(log);
shaderProgram->evaluation = 0;
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
}
if (geometrySource)
{
shaderProgram->geometry = glCreateShader(GLUS_GEOMETRY_SHADER);
glShaderSource(shaderProgram->geometry, 1, (const char**) geometrySource, 0);
glCompileShader(shaderProgram->geometry);
glGetShaderiv(shaderProgram->geometry, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
glGetShaderiv(shaderProgram->geometry, GL_INFO_LOG_LENGTH, &logLength);
log = (char*) malloc((size_t)logLength);
if (!log)
{
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
glGetShaderInfoLog(shaderProgram->geometry, logLength, &charsWritten, log);
glusLogPrint(GLUS_LOG_ERROR, "Geometry shader compile error:");
glusLogPrint(GLUS_LOG_ERROR, "%s", log);
free(log);
shaderProgram->geometry = 0;
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
}
shaderProgram->fragment = glCreateShader(GLUS_FRAGMENT_SHADER);
glShaderSource(shaderProgram->fragment, 1, (const char**) fragmentSource, 0);
glCompileShader(shaderProgram->fragment);
glGetShaderiv(shaderProgram->fragment, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
glGetShaderiv(shaderProgram->fragment, GL_INFO_LOG_LENGTH, &logLength);
log = (char*) malloc((size_t)logLength);
if (!log)
{
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
glGetShaderInfoLog(shaderProgram->fragment, logLength, &charsWritten, log);
glusLogPrint(GLUS_LOG_ERROR, "Fragment shader compile error:");
glusLogPrint(GLUS_LOG_ERROR, "%s", log);
free(log);
shaderProgram->fragment = 0;
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
shaderProgram->program = glCreateProgram();
glAttachShader(shaderProgram->program, shaderProgram->vertex);
if (shaderProgram->control)
{
glAttachShader(shaderProgram->program, shaderProgram->control);
}
if (shaderProgram->evaluation)
{
glAttachShader(shaderProgram->program, shaderProgram->evaluation);
}
if (shaderProgram->geometry)
{
glAttachShader(shaderProgram->program, shaderProgram->geometry);
}
glAttachShader(shaderProgram->program, shaderProgram->fragment);
return GLUS_TRUE;
}
GLUSvoid terminate(GLUSvoid)
{
GLUSgroupList* groupWalker;
GLUSmaterialList* materialWalker;
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesPointLightVBO)
{
glDeleteBuffers(1, &g_verticesPointLightVBO);
g_verticesPointLightVBO = 0;
}
if (g_wavefront.verticesVBO)
{
glDeleteBuffers(1, &g_wavefront.verticesVBO);
g_wavefront.verticesVBO = 0;
}
if (g_wavefront.normalsVBO)
{
glDeleteBuffers(1, &g_wavefront.normalsVBO);
g_wavefront.normalsVBO = 0;
}
if (g_wavefront.texCoordsVBO)
{
glDeleteBuffers(1, &g_wavefront.texCoordsVBO);
g_wavefront.texCoordsVBO = 0;
}
glBindVertexArray(0);
if (g_vaoPointLight)
{
glDeleteVertexArrays(1, &g_vaoPointLight);
g_vaoPointLight = 0;
}
groupWalker = g_wavefront.groups;
while (groupWalker)
{
if (groupWalker->group.indicesVBO)
{
glDeleteBuffers(1, &groupWalker->group.indicesVBO);
groupWalker->group.indicesVBO = 0;
}
if (groupWalker->group.vao)
{
glDeleteVertexArrays(1, &groupWalker->group.vao);
groupWalker->group.vao = 0;
}
groupWalker = groupWalker->next;
}
materialWalker = g_wavefront.materials;
while (materialWalker)
{
if (materialWalker->material.diffuseTextureName)
{
glDeleteTextures(1, &materialWalker->material.diffuseTextureName);
materialWalker->material.diffuseTextureName = 0;
}
materialWalker = materialWalker->next;
}
glUseProgram(0);
glusDestroyProgram(&g_programDeferredShading);
glusDestroyProgram(&g_programPointLight);
glusDestroyGroupedObj(&g_wavefront);
//
//
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_dsDiffuseTexture)
{
glDeleteTextures(1, &g_dsDiffuseTexture);
g_dsDiffuseTexture = 0;
}
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_dsSpecularTexture)
{
glDeleteTextures(1, &g_dsSpecularTexture);
g_dsSpecularTexture = 0;
}
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_dsPositionTexture)
{
glDeleteTextures(1, &g_dsPositionTexture);
g_dsPositionTexture = 0;
}
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_dsNormalTexture)
{
glDeleteTextures(1, &g_dsNormalTexture);
g_dsNormalTexture = 0;
}
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_dsDepthTexture)
{
glDeleteTextures(1, &g_dsDepthTexture);
g_dsDepthTexture = 0;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
if (g_dsFBO)
{
glDeleteFramebuffers(1, &g_dsFBO);
g_dsFBO = 0;
}
}
GLUSvoid terminate(GLUSvoid)
{
// Pass one.
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesPassOneVBO)
{
glDeleteBuffers(1, &g_verticesPassOneVBO);
g_verticesPassOneVBO = 0;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_indicesPassOneVBO)
{
glDeleteBuffers(1, &g_indicesPassOneVBO);
g_indicesPassOneVBO = 0;
}
glBindVertexArray(0);
if (g_vaoPassOne)
{
glDeleteVertexArrays(1, &g_vaoPassOne);
g_vaoPassOne = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_programPassOne);
// Pass two.
if (g_verticesPassTwoVBO)
{
glDeleteBuffers(1, &g_verticesPassTwoVBO);
g_verticesPassTwoVBO = 0;
}
if (g_vaoPassTwo)
{
glDeleteVertexArrays(1, &g_vaoPassTwo);
g_vaoPassTwo = 0;
}
glusDestroyProgram(&g_shaderProgramPassTwo);
//
if (g_transformFeedbackQuery)
{
glDeleteQueries(1, &g_transformFeedbackQuery);
g_transformFeedbackQuery = 0;
}
//
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_RECTANGLE, 0);
if (g_heightMapTexture)
{
glDeleteTextures(1, &g_heightMapTexture);
g_heightMapTexture = 0;
}
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, 0);
if (g_colorMapTexture)
{
glDeleteTextures(1, &g_colorMapTexture);
g_colorMapTexture = 0;
}
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_RECTANGLE, 0);
if (g_normalMapTexture)
{
glDeleteTextures(1, &g_normalMapTexture);
g_normalMapTexture = 0;
}
}
GLUSvoid terminate(GLUSvoid)
{
glBindTexture(GL_TEXTURE_2D, 0);
if (g_shadowTexture)
{
glDeleteRenderbuffers(1, &g_shadowTexture);
g_shadowTexture = 0;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
if (g_fbo)
{
glDeleteFramebuffers(1, &g_fbo);
g_fbo = 0;
}
//
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (g_verticesVBO)
{
glDeleteBuffers(1, &g_verticesVBO);
g_verticesVBO = 0;
}
if (g_normalsVBO)
{
glDeleteBuffers(1, &g_normalsVBO);
g_normalsVBO = 0;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (g_indicesVBO)
{
glDeleteBuffers(1, &g_indicesVBO);
g_indicesVBO = 0;
}
glBindVertexArray(0);
if (g_vao)
{
glDeleteVertexArrays(1, &g_vao);
g_vao = 0;
}
//
if (g_verticesBackgroundVBO)
{
glDeleteBuffers(1, &g_verticesBackgroundVBO);
g_verticesBackgroundVBO = 0;
}
if (g_normalsBackgroundVBO)
{
glDeleteBuffers(1, &g_normalsBackgroundVBO);
g_normalsBackgroundVBO = 0;
}
if (g_indicesBackgroundVBO)
{
glDeleteBuffers(1, &g_indicesBackgroundVBO);
g_indicesBackgroundVBO = 0;
}
if (g_vaoBackground)
{
glDeleteVertexArrays(1, &g_vaoBackground);
g_vao = 0;
}
glUseProgram(0);
glusDestroyProgram(&g_program);
//
if (g_vaoShadow)
{
glDeleteVertexArrays(1, &g_vaoShadow);
g_vaoShadow = 0;
}
if (g_vaoShadowBackground)
{
glDeleteVertexArrays(1, &g_vaoShadowBackground);
g_vaoShadowBackground = 0;
}
glusDestroyProgram(&g_programShadow);
}
GLUSboolean GLUSAPIENTRY glusCreateProgramFromSource(GLUSshaderprogram* shaderProgram, const GLUSchar** vertexSource, const GLUSchar** fragmentSource)
{
GLUSint compiled;
GLUSint logLength, charsWritten;
char* log;
if (!shaderProgram || !vertexSource || !fragmentSource)
{
return GLUS_FALSE;
}
shaderProgram->program = 0;
shaderProgram->compute = 0;
shaderProgram->vertex = 0;
shaderProgram->fragment = 0;
shaderProgram->vertex = glCreateShader(GLUS_VERTEX_SHADER);
glShaderSource(shaderProgram->vertex, 1, (const char**) vertexSource, 0);
glCompileShader(shaderProgram->vertex);
glGetShaderiv(shaderProgram->vertex, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
glGetShaderiv(shaderProgram->vertex, GL_INFO_LOG_LENGTH, &logLength);
log = (char*) malloc((size_t)logLength);
if (!log)
{
return GLUS_FALSE;
}
glGetShaderInfoLog(shaderProgram->vertex, logLength, &charsWritten, log);
glusLogPrint(GLUS_LOG_ERROR, "Vertex shader compile error:");
glusLogPrint(GLUS_LOG_ERROR, "%s", log);
free(log);
shaderProgram->vertex = 0;
return GLUS_FALSE;
}
shaderProgram->fragment = glCreateShader(GLUS_FRAGMENT_SHADER);
glShaderSource(shaderProgram->fragment, 1, (const char**) fragmentSource, 0);
glCompileShader(shaderProgram->fragment);
glGetShaderiv(shaderProgram->fragment, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
glGetShaderiv(shaderProgram->fragment, GL_INFO_LOG_LENGTH, &logLength);
log = (char*) malloc((size_t)logLength);
if (!log)
{
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
glGetShaderInfoLog(shaderProgram->fragment, logLength, &charsWritten, log);
glusLogPrint(GLUS_LOG_ERROR, "Fragment shader compile error:");
glusLogPrint(GLUS_LOG_ERROR, "%s", log);
free(log);
shaderProgram->fragment = 0;
glusDestroyProgram(shaderProgram);
return GLUS_FALSE;
}
shaderProgram->program = glCreateProgram();
glAttachShader(shaderProgram->program, shaderProgram->vertex);
glAttachShader(shaderProgram->program, shaderProgram->fragment);
return GLUS_TRUE;
}
