void display()
{
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(g_pPlaneMesh && g_pCylinderMesh)
{
glutil::MatrixStack modelMatrix;
modelMatrix.SetMatrix(g_viewPole.CalcMatrix());
glm::vec4 lightDirCameraSpace = modelMatrix.Top() * g_lightDirection;
ProgramData &whiteDiffuse = g_bShowAmbient ? g_WhiteAmbDiffuseColor : g_WhiteDiffuseColor;
ProgramData &vertexDiffuse = g_bShowAmbient ? g_VertexAmbDiffuseColor : g_VertexDiffuseColor;
if(g_bShowAmbient)
{
glUseProgram(whiteDiffuse.theProgram);
glUniform4f(whiteDiffuse.lightIntensityUnif, 0.8f, 0.8f, 0.8f, 1.0f);
glUniform4f(whiteDiffuse.ambientIntensityUnif, 0.2f, 0.2f, 0.2f, 1.0f);
glUseProgram(vertexDiffuse.theProgram);
glUniform4f(vertexDiffuse.lightIntensityUnif, 0.8f, 0.8f, 0.8f, 1.0f);
glUniform4f(vertexDiffuse.ambientIntensityUnif, 0.2f, 0.2f, 0.2f, 1.0f);
}
else
{
glUseProgram(whiteDiffuse.theProgram);
glUniform4f(whiteDiffuse.lightIntensityUnif, 1.0f, 1.0f, 1.0f, 1.0f);
glUseProgram(vertexDiffuse.theProgram);
glUniform4f(vertexDiffuse.lightIntensityUnif, 1.0f, 1.0f, 1.0f, 1.0f);
}
glUseProgram(whiteDiffuse.theProgram);
glUniform3fv(whiteDiffuse.dirToLightUnif, 1, glm::value_ptr(lightDirCameraSpace));
glUseProgram(vertexDiffuse.theProgram);
glUniform3fv(vertexDiffuse.dirToLightUnif, 1, glm::value_ptr(lightDirCameraSpace));
glUseProgram(0);
{
glutil::PushStack push(modelMatrix);
//Render the ground plane.
{
glutil::PushStack push(modelMatrix);
glUseProgram(whiteDiffuse.theProgram);
glUniformMatrix4fv(whiteDiffuse.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
glm::mat3 normMatrix(modelMatrix.Top());
glUniformMatrix3fv(whiteDiffuse.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
g_pPlaneMesh->Render();
glUseProgram(0);
}
//Render the Cylinder
{
glutil::PushStack push(modelMatrix);
modelMatrix.ApplyMatrix(g_objtPole.CalcMatrix());
if(g_bDrawColoredCyl)
{
glUseProgram(vertexDiffuse.theProgram);
glUniformMatrix4fv(vertexDiffuse.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
glm::mat3 normMatrix(modelMatrix.Top());
glUniformMatrix3fv(vertexDiffuse.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
g_pCylinderMesh->Render("lit-color");
}
else
{
glUseProgram(whiteDiffuse.theProgram);
glUniformMatrix4fv(whiteDiffuse.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
glm::mat3 normMatrix(modelMatrix.Top());
glUniformMatrix3fv(whiteDiffuse.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
g_pCylinderMesh->Render("lit");
}
glUseProgram(0);
}
}
}
glutSwapBuffers();
}
//--------------------------------------------------------------
void ofShader::setUniform3fv(const string & name, const float* v, int count) const{
if(bLoaded) {
int loc = getUniformLocation(name);
if (loc != -1) glUniform3fv(loc, count, v);
}
}
//OpenGL Loop Logic
void glLoop() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/*gModelMat = glm::rotate(gModelMat, -0.01f, glm::vec3(0.f, 0.f, 1.f));
glUniformMatrix4fv(gModelMatLoc, 1, GL_FALSE, glm::value_ptr(gModelMat));*/
glBindFramebuffer(GL_FRAMEBUFFER, gShadowFbo);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(gShadowProg);
glBindVertexArray(gShadowVao);
glViewport(0, 0, SHADOW_DEPTH_TEXTURE_SIZE, SHADOW_DEPTH_TEXTURE_SIZE);
glClearDepth(1.0f);
glClear(GL_DEPTH_BUFFER_BIT);
glUniformMatrix4fv(gShadowViewMatLoc, 1, GL_FALSE, glm::value_ptr(gShadowViewMat));
glUniformMatrix4fv(gShadowProjMatLoc, 1, GL_FALSE, glm::value_ptr(gShadowProjMat));
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(2.f, 4.f);
for (auto& e: gSceneGraph) {
glUniformMatrix4fv(gShadowModelMatLoc, 1, GL_FALSE, glm::value_ptr(e.modelMat));
glBindBuffer(GL_ARRAY_BUFFER, e.glPosBuf);
glVertexAttribPointer(gShadowPosLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glDrawArrays(GL_TRIANGLES, 0, e.vertCount);
}
glDisable(GL_POLYGON_OFFSET_FILL);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, gScreenWidth * 2, gScreenHeight * 2);
// Renders Scene to gFilterSceneTexture
glBindFramebuffer(GL_FRAMEBUFFER, gFilterSceneFbo);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(gRenderProg);
glBindVertexArray(gVao);
for (auto& e: gSceneGraph) {
glUniformMatrix4fv(gModelMatLoc, 1, GL_FALSE, glm::value_ptr(e.modelMat));
glUniform3fv(gAmbientLoc, 1, glm::value_ptr(e.ambientColor));
glUniform3fv(gDiffuseLoc, 1, glm::value_ptr(e.diffuseColor));
glUniform3fv(gSpecularLoc, 1, glm::value_ptr(e.specularColor));
glUniform1f(gShininessLoc, e.shininess);
glUniform1f(gSpecStrengthLoc, e.specStrength);
glUniform1i(gIsTexturedLoc, e.isTextured);
glUniform1i(gTexUnitLoc, e.glTexUnit);
glUniform4fv(gColorLoc, 1, glm::value_ptr(e.objColor));
glBindBuffer(GL_ARRAY_BUFFER, e.glPosBuf);
glVertexAttribPointer(gPosLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glBindBuffer(GL_ARRAY_BUFFER, e.glTexCoordBuf);
glVertexAttribPointer(gTexCoordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
glBindBuffer(GL_ARRAY_BUFFER, e.glNormBuf);
glVertexAttribPointer(gNormLoc, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glDrawArrays(GL_TRIANGLES, 0, e.vertCount);
}
glUseProgram(gScreenProg);
glBindVertexArray(gScreenVao);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Low luminance discard pass. Results stored in gFilterLumTexture
glBindFramebuffer(GL_FRAMEBUFFER, gFilterLumFbo);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(gFilterProg);
glUniform1i(gFilterPassLoc, 1);
glBindVertexArray(gFilterVao);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Vertical pass of gaussian filter. Results stored in gFilterBlurTexture
glViewport(0, 0, gScreenWidth * 2, gScreenHeight * 2);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, gFilterLumTexture); // Texture obtained from scene rendering
glActiveTexture(GL_TEXTURE0);
glBindFramebuffer(GL_FRAMEBUFFER, gFilterBlurFbo);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(gFilterProg);
glUniform1i(gFilterPassLoc, 2);
glBindVertexArray(gFilterVao);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Horizontal pass of gaussian filter. Rendered to default framebuffer (screen)
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, gFilterBlurTexture); // Texture obtained from pass 1 of gaussian filter
glActiveTexture(GL_TEXTURE0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(gFilterProg);
glUniform1i(gFilterPassLoc, 3);
glBindVertexArray(gFilterVao);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
/*
=============
RB_ARB2_CreateDrawInteractions
=============
*/
void RB_GLSL_CreateDrawInteractions( const drawSurf_t *surf ) {
if ( !surf ) {
return;
}
// perform setup here that will be constant for all interactions
GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHMASK | backEnd.depthFunc );
//GL_Cull(CT_TWO_SIDED);
qglEnableClientState(GL_VERTEX_ARRAY);
//qglDisableClientState(GL_VERTEX_ARRAY);
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
glUseProgram(program);
float modelMatrix[16];
myGlMultMatrix( surf->space->modelViewMatrix, backEnd.viewDef->projectionMatrix, modelMatrix);
glUniformMatrix4fv(wvp, 1, GL_FALSE, &modelMatrix[0] );
//glUniformMatrix4fv(wvp1, 1, GL_FALSE, &surf->space->modelViewMatrix[0] );
//const float* mat = backEnd.viewDef->projectionMatrix;
//glUniformMatrix4fv(wvp, 1, GL_FALSE, &mat[0] );
// enable the vertex arrays
glEnableVertexAttribArray( 1 );
glEnableVertexAttribArray( 2 );
glEnableVertexAttribArray( 3 );
glEnableVertexAttribArray( 4 );
glEnableVertexAttribArray( 5 );
glEnableVertexAttribArray( 6 );
// texture 0 is the normalization cube map for the vector towards the light
glActiveTexture(GL_TEXTURE0);
backEnd.glState.currenttmu = 0;
if ( backEnd.vLight->lightShader->IsAmbientLight() ) {
globalImages->ambientNormalMap->Bind();
} else {
globalImages->normalCubeMapImage->Bind();
}
// texture 6 is the specular lookup table
glActiveTexture(GL_TEXTURE6);
backEnd.glState.currenttmu = 6;
if ( r_testARBProgram.GetBool() ) {
globalImages->specular2DTableImage->Bind(); // variable specularity in alpha channel
} else {
globalImages->specularTableImage->Bind();
}
for ( ; surf ; surf=surf->nextOnLight ) {
// set the vertex pointers
idDrawVert *ac = (idDrawVert *)vertexCache.Position( surf->geo->ambientCache );
qglVertexPointer( 3, GL_FLOAT, sizeof( idDrawVert ), ac->xyz.ToFloatPtr() );
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->xyz.ToFloatPtr());
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->st.ToFloatPtr());
glVertexAttribPointer(3, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof(idDrawVert), ac->color);
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->normal.ToFloatPtr());
glVertexAttribPointer(5, 3, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->tangents[0].ToFloatPtr());
glVertexAttribPointer(6, 3, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->tangents[1].ToFloatPtr());
idVec4 localLight;
R_GlobalPointToLocal( surf->space->modelMatrix, backEnd.vLight->globalLightOrigin, localLight.ToVec3() );
localLight.w = 0.0f;
glUniform3fv(lightOrgin, 1, localLight.ToFloatPtr());
//glDrawElements(GL_TRIANGLES, surf->geo->numIndexes, GL_UNSIGNED_SHORT, surf->geo->indexes);
// this may cause RB_ARB2_DrawInteraction to be exacuted multiple
// times with different colors and images if the surface or light have multiple layers
RB_CreateSingleDrawInteractions( surf, RB_GLSL_DrawInteraction );
}
glDisableVertexAttribArray( 1 );
glDisableVertexAttribArray( 2 );
glDisableVertexAttribArray( 3 );
glDisableVertexAttribArray( 4 );
glDisableVertexAttribArray( 5 );
glDisableVertexAttribArray( 6 );
// disable features
glActiveTexture( GL_TEXTURE6 );
backEnd.glState.currenttmu = 6;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE5 );
backEnd.glState.currenttmu = 5;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE4 );
backEnd.glState.currenttmu = 4;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE3 );
backEnd.glState.currenttmu = 3;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE2 );
backEnd.glState.currenttmu = 2;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE1 );
backEnd.glState.currenttmu = 1;
globalImages->BindNull();
glUseProgram(0);
backEnd.glState.currenttmu = -1;
GL_SelectTexture(0 );
}
void PezRender()
{
#define Instances 7
Matrix4 Model[Instances];
Model[0] = M4MakeRotationY(Globals.Theta);
Model[1] = M4Mul(M4Mul(
M4MakeTranslation((Vector3){0, 0, 0.6}),
M4MakeScale(V3MakeFromScalar(0.25))),
M4MakeRotationX(Pi/2)
);
Model[2] = Model[3] = Model[4] = Model[1];
Model[1] = M4Mul(M4MakeRotationY(Globals.Theta), Model[1]);
Model[2] = M4Mul(M4MakeRotationY(Globals.Theta + Pi/2), Model[2]);
Model[3] = M4Mul(M4MakeRotationY(Globals.Theta - Pi/2), Model[3]);
Model[4] = M4Mul(M4MakeRotationY(Globals.Theta + Pi), Model[4]);
Model[5] = M4Mul(M4Mul(
M4MakeScale(V3MakeFromScalar(0.5)),
M4MakeTranslation((Vector3){0, 1.25, 0})),
M4MakeRotationY(-Globals.Theta)
);
Model[6] = M4Mul(M4Mul(
M4MakeScale(V3MakeFromScalar(0.5)),
M4MakeTranslation((Vector3){0, -1.25, 0})),
M4MakeRotationY(-Globals.Theta)
);
Vector3 LightPosition = {0.5, 0.25, 1.0}; // world space
Vector3 EyePosition = {0, 0, 1}; // world space
Matrix4 MVP[Instances];
Vector3 Lhat[Instances];
Vector3 Hhat[Instances];
for (int i = 0; i < Instances; i++) {
Matrix4 mv = M4Mul(Globals.View, Model[i]);
MVP[i] = M4Mul(Globals.Projection, mv);
Matrix3 m = M3Transpose(M4GetUpper3x3(Model[i]));
Lhat[i] = M3MulV3(m, V3Normalize(LightPosition)); // object space
Vector3 Eye = M3MulV3(m, V3Normalize(EyePosition)); // object space
Hhat[i] = V3Normalize(V3Add(Lhat[i], Eye));
}
int instanceCount = Instances;
MeshPod* mesh = &Globals.Cylinder;
glBindFramebuffer(GL_FRAMEBUFFER, Globals.FboHandle);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glUseProgram(Globals.LitProgram);
glUniform3f(u("SpecularMaterial"), 0.4, 0.4, 0.4);
glUniform4f(u("FrontMaterial"), 0, 0, 1, 1);
glUniform4f(u("BackMaterial"), 0.5, 0.5, 0, 1);
glUniform3fv(u("Hhat"), Instances, &Hhat[0].x);
glUniform3fv(u("Lhat"), Instances, &Lhat[0].x);
glUniformMatrix4fv(u("ModelviewProjection"), Instances, 0, (float*) &MVP[0]);
glBindVertexArray(mesh->FillVao);
glDrawElementsInstanced(GL_TRIANGLES, mesh->FillIndexCount, GL_UNSIGNED_SHORT, 0, instanceCount);
glUseProgram(Globals.SimpleProgram);
glUniform4f(u("Color"), 0, 0, 0, 1);
glUniformMatrix4fv(u("ModelviewProjection"), Instances, 0, (float*) &MVP[0]);
glDepthMask(GL_FALSE);
glBindVertexArray(mesh->LineVao);
glDrawElementsInstanced(GL_LINES, mesh->LineIndexCount, GL_UNSIGNED_SHORT, 0, instanceCount);
glDepthMask(GL_TRUE);
glDisable(GL_DEPTH_TEST);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glUseProgram(Globals.QuadProgram);
glBindTexture(GL_TEXTURE_2D, Globals.FboTexture);
glBindVertexArray(Globals.Grid.FillVao);
glDrawElements(GL_TRIANGLES, Globals.Grid.FillIndexCount, GL_UNSIGNED_SHORT, 0);
if (1) {
glUseProgram(Globals.GridProgram);
glBindVertexArray(Globals.Grid.LineVao);
glDrawElements(GL_LINES, Globals.Grid.LineIndexCount, GL_UNSIGNED_SHORT, 0);
}
glBindTexture(GL_TEXTURE_2D, 0);
}
void UniformImplementation_Legacy::set(const Program * program, const GLint location, const std::vector<glm::vec3> & value) const
{
program->use();
glUniform3fv(location, static_cast<GLint>(value.size()), reinterpret_cast<const float*>(value.data()));
}
void shader_gles3::uniform(const char* name, const float3* arg1, const size_t& count) const {
A2E_CHECK_UNIFORM_EXISTENCE(name);
A2E_CHECK_UNIFORM_TYPE(name, GL_FLOAT_VEC3);
glUniform3fv(A2E_SHADER_GET_UNIFORM_POSITION(name), (GLsizei)count, (GLfloat*)arg1);
}
void Shader::SetUniform(const std::string& name, const vec3 vector)
{
glUniform3fv(GetUniformLocation(name), 1, Math::GetDataPtr(vector));
}
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;
}
void processFn(struct fnargs* args) {
switch (args->fn) {
case glfnUNDEFINED:
abort(); // bad glfn
break;
case glfnActiveTexture:
glActiveTexture((GLenum)args->a0);
break;
case glfnAttachShader:
glAttachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnBindAttribLocation:
glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2);
free((void*)args->a2);
break;
case glfnBindBuffer:
glBindBuffer((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnBindFramebuffer:
glBindFramebuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindRenderbuffer:
glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindTexture:
glBindTexture((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBlendColor:
glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnBlendEquation:
glBlendEquation((GLenum)args->a0);
break;
case glfnBlendEquationSeparate:
glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFunc:
glBlendFunc((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFuncSeparate:
glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnBufferData:
glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2, (GLenum)args->a3);
break;
case glfnBufferSubData:
glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)args->a3);
break;
case glfnCheckFramebufferStatus:
ret = glCheckFramebufferStatus((GLenum)args->a0);
break;
case glfnClear:
glClear((GLenum)args->a0);
break;
case glfnClearColor:
glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnClearDepthf:
glClearDepthf(*(GLfloat*)&args->a0);
break;
case glfnClearStencil:
glClearStencil((GLint)args->a0);
break;
case glfnColorMask:
glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3);
break;
case glfnCompileShader:
glCompileShader((GLint)args->a0);
break;
case glfnCompressedTexImage2D:
glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)args->a7);
break;
case glfnCompressedTexSubImage2D:
glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)args->a8);
break;
case glfnCopyTexImage2D:
glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCopyTexSubImage2D:
glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCreateProgram:
ret = glCreateProgram();
break;
case glfnCreateShader:
ret = glCreateShader((GLenum)args->a0);
break;
case glfnCullFace:
glCullFace((GLenum)args->a0);
break;
case glfnDeleteBuffer:
glDeleteBuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteFramebuffer:
glDeleteFramebuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteProgram:
glDeleteProgram((GLint)args->a0);
break;
case glfnDeleteRenderbuffer:
glDeleteRenderbuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteShader:
glDeleteShader((GLint)args->a0);
break;
case glfnDeleteTexture:
glDeleteTextures(1, (const GLuint*)(&args->a0));
break;
case glfnDepthFunc:
glDepthFunc((GLenum)args->a0);
break;
case glfnDepthMask:
glDepthMask((GLboolean)args->a0);
break;
case glfnDepthRangef:
glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnDetachShader:
glDetachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnDisable:
glDisable((GLenum)args->a0);
break;
case glfnDisableVertexAttribArray:
glDisableVertexAttribArray((GLint)args->a0);
break;
case glfnDrawArrays:
glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnDrawElements:
glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3);
break;
case glfnEnable:
glEnable((GLenum)args->a0);
break;
case glfnEnableVertexAttribArray:
glEnableVertexAttribArray((GLint)args->a0);
break;
case glfnFinish:
glFinish();
break;
case glfnFlush:
glFlush();
break;
case glfnFramebufferRenderbuffer:
glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3);
break;
case glfnFramebufferTexture2D:
glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnFrontFace:
glFrontFace((GLenum)args->a0);
break;
case glfnGenBuffer:
glGenBuffers(1, (GLuint*)&ret);
break;
case glfnGenFramebuffer:
glGenFramebuffers(1, (GLuint*)&ret);
break;
case glfnGenRenderbuffer:
glGenRenderbuffers(1, (GLuint*)&ret);
break;
case glfnGenTexture:
glGenTextures(1, (GLuint*)&ret);
break;
case glfnGenerateMipmap:
glGenerateMipmap((GLenum)args->a0);
break;
case glfnGetActiveAttrib:
glGetActiveAttrib(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)args->a4,
(GLenum*)args->a5,
(GLchar*)args->a6);
break;
case glfnGetActiveUniform:
glGetActiveUniform(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)args->a4,
(GLenum*)args->a5,
(GLchar*)args->a6);
break;
case glfnGetAttachedShaders:
glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLuint*)args->a3);
break;
case glfnGetAttribLocation:
ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1);
free((void*)args->a1);
break;
case glfnGetBooleanv:
glGetBooleanv((GLenum)args->a0, (GLboolean*)args->a1);
break;
case glfnGetBufferParameteri:
glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetFloatv:
glGetFloatv((GLenum)args->a0, (GLfloat*)args->a1);
break;
case glfnGetIntegerv:
glGetIntegerv((GLenum)args->a0, (GLint*)args->a1);
break;
case glfnGetError:
ret = glGetError();
break;
case glfnGetFramebufferAttachmentParameteriv:
glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret);
break;
case glfnGetProgramiv:
glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetProgramInfoLog:
glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3);
break;
case glfnGetRenderbufferParameteriv:
glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderiv:
glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderInfoLog:
glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3);
break;
case glfnGetShaderPrecisionFormat:
glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2, (GLint*)args->a3);
break;
case glfnGetShaderSource:
glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3);
break;
case glfnGetString:
ret = (uintptr_t)glGetString((GLenum)args->a0);
break;
case glfnGetTexParameterfv:
glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2);
break;
case glfnGetTexParameteriv:
glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2);
break;
case glfnGetUniformfv:
glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)args->a2);
break;
case glfnGetUniformiv:
glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)args->a2);
break;
case glfnGetUniformLocation:
ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1);
free((void*)args->a1);
break;
case glfnGetVertexAttribfv:
glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)args->a2);
break;
case glfnGetVertexAttribiv:
glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)args->a2);
break;
case glfnHint:
glHint((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnIsBuffer:
ret = glIsBuffer((GLint)args->a0);
break;
case glfnIsEnabled:
ret = glIsEnabled((GLenum)args->a0);
break;
case glfnIsFramebuffer:
ret = glIsFramebuffer((GLint)args->a0);
break;
case glfnIsProgram:
ret = glIsProgram((GLint)args->a0);
break;
case glfnIsRenderbuffer:
ret = glIsRenderbuffer((GLint)args->a0);
break;
case glfnIsShader:
ret = glIsShader((GLint)args->a0);
break;
case glfnIsTexture:
ret = glIsTexture((GLint)args->a0);
break;
case glfnLineWidth:
glLineWidth(*(GLfloat*)&args->a0);
break;
case glfnLinkProgram:
glLinkProgram((GLint)args->a0);
break;
case glfnPixelStorei:
glPixelStorei((GLenum)args->a0, (GLint)args->a1);
break;
case glfnPolygonOffset:
glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnReadPixels:
glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)args->a6);
break;
case glfnReleaseShaderCompiler:
glReleaseShaderCompiler();
break;
case glfnRenderbufferStorage:
glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnSampleCoverage:
glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1);
break;
case glfnScissor:
glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnShaderSource:
#if defined(os_ios) || defined(os_osx)
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL);
#else
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL);
#endif
free(*(void**)args->a2);
free((void*)args->a2);
break;
case glfnStencilFunc:
glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2);
break;
case glfnStencilFuncSeparate:
glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3);
break;
case glfnStencilMask:
glStencilMask((GLuint)args->a0);
break;
case glfnStencilMaskSeparate:
glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnStencilOp:
glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2);
break;
case glfnStencilOpSeparate:
glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnTexImage2D:
glTexImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLsizei)args->a3,
(GLsizei)args->a4,
0, // border
(GLenum)args->a5,
(GLenum)args->a6,
(const GLvoid*)args->a7);
break;
case glfnTexSubImage2D:
glTexSubImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLint)args->a3,
(GLsizei)args->a4,
(GLsizei)args->a5,
(GLenum)args->a6,
(GLenum)args->a7,
(const GLvoid*)args->a8);
break;
case glfnTexParameterf:
glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2);
break;
case glfnTexParameterfv:
glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2);
break;
case glfnTexParameteri:
glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2);
break;
case glfnTexParameteriv:
glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2);
break;
case glfnUniform1f:
glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnUniform1fv:
glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform1i:
glUniform1i((GLint)args->a0, (GLint)args->a1);
break;
case glfnUniform1iv:
glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform2f:
glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnUniform2fv:
glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform2i:
glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnUniform2iv:
glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform3f:
glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnUniform3fv:
glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform3i:
glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnUniform3iv:
glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform4f:
glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnUniform4fv:
glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform4i:
glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnUniform4iv:
glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniformMatrix2fv:
glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2);
break;
case glfnUniformMatrix3fv:
glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2);
break;
case glfnUniformMatrix4fv:
glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2);
break;
case glfnUseProgram:
glUseProgram((GLint)args->a0);
break;
case glfnValidateProgram:
glValidateProgram((GLint)args->a0);
break;
case glfnVertexAttrib1f:
glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnVertexAttrib1fv:
glVertexAttrib1fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttrib2f:
glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnVertexAttrib2fv:
glVertexAttrib2fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttrib3f:
glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnVertexAttrib3fv:
glVertexAttrib3fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttrib4f:
glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnVertexAttrib4fv:
glVertexAttrib4fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttribPointer:
glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5);
break;
case glfnViewport:
glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
}
}
void hge::shader::SunShader::setSunDirection(const glm::vec3 &sunDirection)
{
glUniform3fv(sunLightDirectionUniformLocation, 1, glm::value_ptr(sunDirection));
}
inline void operator=(const std::tr1::array<GLfloat, 3>& val)
{
glUseProgramObjectARB(_programHandle);
glUniform3fv(_uniformHandle, 1, &(val[0]));
}
void opengl_display()
{
static double start = get_time();
float t = get_time()-start;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
t *= 25.f;
// background_world.rotate_y(t);
background_world = statue_world;
vec3 eye = vec3(0,0,distance_z);
view.look_at(eye, vec3(0,0,0), vec3(0,1,0));
//render background
wvp = projection * background_world;
if(background_mesh.program != NULL)
{
glUseProgram(background_mesh.program->get_program());
glUniformMatrix4fv(background_mesh.wvp_loc, 1, GL_FALSE, &wvp[0]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, background_mesh.texs_idxs[0]);
glUniform1i(background_mesh.texs_locs[0], 0);
glUniformMatrix4fv(background_mesh.wvp_loc, 1, GL_FALSE, &wvp[0]);
background_mesh.draw();
}
//render statue
env_inv_world = background_world.inverse();
wvp = projection * view;
wvp *= statue_world;
eye = env_inv_world * eye;
if(statue_mesh.program != NULL)
{
glUseProgram(statue_mesh.program->get_program());
glUniformMatrix4fv(statue_mesh.wvp_loc, 1, GL_FALSE, &wvp[0]);
glUniformMatrix4fv(statue_mesh.world_loc, 1, GL_FALSE, &statue_world[0]);
glUniformMatrix4fv(statue_mesh.env_inv_world_loc, 1,GL_FALSE, &env_inv_world[0]);
glUniform3fv(statue_mesh.eye_loc, 1, &eye.x);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, statue_mesh.texs_idxs[0]);
glUniform1i(statue_mesh.texs_locs[0], 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, statue_mesh.texs_idxs[1]);
glUniform1i(statue_mesh.texs_locs[1], 1);
statue_mesh.draw();
}
}
/*
Inits the shader program for this object
*/
void GLSphereBlue::initShader(void)
{
#ifdef _WIN32
// This loads the shader program from a file
_program = LoadAndCreateShaderProgram("../data/shaders/bluesphere.vs", "../data/shaders/bluesphere.vs");
#else
// This loads the shader program from a file
_program = LoadAndCreateShaderProgram("/Users/geethanjalijeevanatham/Desktop/Helloworld/myopenGL/model/testing/assignment2/Problem2/Problem2/data/shaders/bluesphere.vs", "/Users/geethanjalijeevanatham/Desktop/Helloworld/myopenGL/model/testing/assignment2/Problem2/Problem2/data/shaders/bluesphere.fs");
#endif
glUseProgram(_program);
///////////////////////////////////////////////////////////////////////////////////////////////
// Vertex information / names
glBindAttribLocation(_program, 0, "in_Position");
glBindAttribLocation(_program, 1, "in_Normal");
glBindAttribLocation(_program, 2, "in_Color");
///////////////////////////////////////////////////////////////////////////////////////////////
// Define the model view matrix.
_modelMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f)); // Create our model matrix which will halve the size of our model
_projectionMatrixLocation = glGetUniformLocation(_program, "projectionMatrixBox"); // Get the location of our projection matrix in the shader
_viewMatrixLocation = glGetUniformLocation(_program, "viewMatrixBox"); // Get the location of our view matrix in the shader
_modelMatrixLocation = glGetUniformLocation(_program, "modelMatrixBox"); // Get the location of our model matrix in the shader
_inverseViewMatrixLocation = glGetUniformLocation(_program, "inverseViewMatrix");
glUniformMatrix4fv(_projectionMatrixLocation, 1, GL_FALSE, &projectionMatrix()[0][0] ); // Send our projection matrix to the shader
glUniformMatrix4fv(_viewMatrixLocation, 1, GL_FALSE, &viewMatrix()[0][0]); // Send our view matrix to the shader
glUniformMatrix4fv(_modelMatrixLocation, 1, GL_FALSE, &_modelMatrix[0][0]); // Send our model matrix to the shader
glUniformMatrix4fv(_inverseViewMatrixLocation, 1, GL_FALSE, &invRotatedViewMatrix()[0][0]);
///////////////////////////////////////////////////////////////////////////////////////////////
// Material
_material._diffuse_material = glm::vec3(0.0, 0.0, 1.0);
_material._ambient_material = glm::vec3(0.0, 0.0, 1.0);
_material._specular_material = glm::vec3(1.0, 1.0, 1.0);
_material._shininess = 150.0;
_material._ambientColorPos = glGetUniformLocation(_program, "ambient_color");
_material._diffuseColorPos = glGetUniformLocation(_program, "diffuse_color");
_material._specularColorPos = glGetUniformLocation(_program, "specular_color");
_material._shininessIdx = glGetUniformLocation(_program, "shininess");
// Send the material to your shader program
glUniform3fv(_material._ambientColorPos, 1, &_material._ambient_material[0] );
glUniform3fv(_material._diffuseColorPos, 1, &_material._diffuse_material[0]);
glUniform3fv(_material._specularColorPos, 1, &_material._specular_material[0]);
glUniform1f(_material._shininessIdx, _material._shininess);
///////////////////////////////////////////////////////////////////////////////////////////////
// Light
// define the position of the light and send the light position to your shader program
_light_source4._lightPos = glm::vec4(1.5,0.0,2.0,0.0);
_light_source4._ambient_intensity = 0.0;
_light_source4._specular_intensity = 0.0;
_light_source4._diffuse_intensity = 1.0;
_light_source4._attenuation_coeff = 0.02;
// Read all the index values from the shader program
_light_source4._ambientIdx = glGetUniformLocation(_program, "ambient_intensity");
_light_source4._diffuseIdx = glGetUniformLocation(_program, "diffuse_intensity");
_light_source4._specularIdx = glGetUniformLocation(_program, "specular_intensity");
_light_source4._attenuation_coeffIdx = glGetUniformLocation(_program, "attenuationCoefficient");
_light_source4._lightPosIdx = glGetUniformLocation(_program, "light_position");
// Send the light information to your shader program
glUniform1f(_light_source4._ambientIdx, _light_source4._ambient_intensity );
glUniform1f(_light_source4._diffuseIdx, _light_source4._diffuse_intensity);
glUniform1f(_light_source4._specularIdx, _light_source4._specular_intensity);
glUniform1f(_light_source4._attenuation_coeffIdx, _light_source4._attenuation_coeff);
glUniform4fv(_light_source4._lightPosIdx, 1, &_light_source4._lightPos[0]);
glUseProgram(0);
}
void SCE_RSetProgramParam3fv (SCEint idx, size_t size, const float *val)
{
glUniform3fv (idx, size, val);
}
void ShaderGL::SetFloat3(UINT uniform, float* data, UINT count)
{
glUniform3fv(mUniformsGL[uniform], count, data);
}
/**
* \brief drawText, render 2D text on the screen (Orthogonal Projection)
* @param str, text string.
* @param pos, 2D position on screen, TODO support Z as priority for future reference, but for now not used
* @param rgba, text color
* @param tick time elapsed
* @return float width of text string.
*/
float RenderText::drawText(const char*str, glm::vec3 &pos, glm::vec4 &rgba, float tick)
{
// checkGLError("RenderText::DrawText Should be ok!");
float width = 0;
m_pos = pos;
int num = strlen(str);
glm::vec4 *vertices = 0;
glDisable(GL_DEPTH_TEST);
glm::mat4 m = glm::ortho(0.0f, static_cast<float>(m_width),static_cast<float>(m_height),0.0f,-200.0f,1000.0f);
// Use the font class to build the vertex array from the sentence text and sentence draw location.
// Create the vertex array.
m_scaleZ = -m_scaleZ;
vertices = getVertices(str, false, &width); // note uses m_pos creates or retrieves existing vertex buffer from a cache table
m_scaleZ = -m_scaleZ;
TextShader &shader= m_textShader;
glEnable (GL_BLEND);
m_blendType = BL_ADDITIVE;
switch (m_blendType)
{
case BL_ADDITIVE: // Additive
glBlendFunc(GL_ONE, GL_ONE);
// glBlendFunc( GL_DST_ALPHA, GL_ONE_MINUS_SRC_COLOR ); // very good additive
break;
case BL_TRANSLUCENT: // Requires alpha
glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Texture uses alpha
break;
case BL_SUBTRACTIVE:
//glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
glBlendFunc( GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA ); //subtractive black => max
// glBlendFunc(GL_ZERO, GL_SRC_ALPHA); // needs alpha
// glBlendFunc(GL_ZERO, GL_SRC_COLOR);
break;
case BL_TRANSPARENT:
glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
break;
}
// Use the program object
glUseProgram(shader.mShader);
checkGLError("RenderText::DrawText glUseProgram (Text)");
// 1. create buffers tri array for simplicity? so that every tri can be handled separately or with a new index buffer could be expensive though???
// Load the vertex data
glVertexAttribPointer(shader.mAttribVtxLoc, 4, GL_FLOAT, GL_FALSE, sizeof(float)*4, &vertices[0].x);
checkGLError("RenderText::DrawText glVertexAttribPointer (V)");
glEnableVertexAttribArray(shader.mAttribVtxLoc);
checkGLError("RenderText::DrawText glEnableVertexAttribArray (V)");
glActiveTexture(GL_TEXTURE0 + 0);
checkGLError("RenderText::DrawText glActiveTexture");
glBindTexture(GL_TEXTURE_2D, m_font->GetTexture(0));
checkGLError("glBindTexture");
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
checkGLError("glTexParameteri");
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
checkGLError("glTexParameteri");
glUniform1i(shader.mTexture, 0 ); // Texture Unit 0
checkGLError("RenderText::DrawText glUniform1i");
// Once per frame
glUniform1f(shader.mTimeLoc, tick);
checkGLError("RenderText::DrawText glUniform1f");
glUniform2f(shader.mResolutionLoc, 1.0f/(float)m_width, 1.0f/(float)m_height);
checkGLError("RenderText::DrawText glUniform2f");
glUniformMatrix4fv(shader.mMatrixPVW, 1, GL_FALSE, &m[0][0]);
checkGLError("RenderText::DrawText glUniformMatrix4fv");
glm::vec3 sv(1.0f, 1.0f, 1.0f);
glUniform3fv(shader.mScaleV,1, (float *)&sv.x); // mScale location => variable "ScaleV" in vertex shader
checkGLError("RenderText::DrawText glUniformMatrix3fv");
glm::vec4 color = rgba;
glUniform4fv(shader.mColor,1, (float *)&color.x);
checkGLError("RenderText::DrawText glUniformMatrix4fv");
glm::vec4 TPos(0.0f,0.0f,m_pos.z, 1.0f);
glUniform4fv(shader.mTPos, 1, (float *)&TPos.x);
checkGLError("RenderText::DrawText glUniformMatrix4fv");
glDrawArrays(GL_TRIANGLES, 0, 6*num);
checkGLError("RenderText::DrawText glDrawArrays");
// Clean-up
glDisableVertexAttribArray(shader.mAttribVtxLoc);
checkGLError("RenderText::DrawText glDisableVertexAttribArray (Vtx)");
glBindTexture(GL_TEXTURE_2D, 0);
glUseProgram(0);
checkGLError("RenderText::DrawText glUseProgram(0)");
releaseVertices(vertices, false);
glDisable(GL_BLEND);
return width; // Generate a buffer for the vertices
}
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, 1.0f, 0.0f, 1.0f }, { 0.0f, 1.0f, 0.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f }, 20.0f };
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLUSshape wavefrontObj;
glusFileLoadText("../Example16/shader/phong.vert.glsl", &vertexSource);
glusFileLoadText("../Example16/shader/phong.frag.glsl", &fragmentSource);
glusProgramBuildFromSource(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text);
glusFileDestroyText(&vertexSource);
glusFileDestroyText(&fragmentSource);
//
g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix");
g_modelViewMatrixLocation = glGetUniformLocation(g_program.program, "u_modelViewMatrix");
g_normalMatrixLocation = glGetUniformLocation(g_program.program, "u_normalMatrix");
g_light.directionLocation = glGetUniformLocation(g_program.program, "u_light.direction");
g_light.ambientColorLocation = glGetUniformLocation(g_program.program, "u_light.ambientColor");
g_light.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_light.diffuseColor");
g_light.specularColorLocation = glGetUniformLocation(g_program.program, "u_light.specularColor");
g_material.ambientColorLocation = glGetUniformLocation(g_program.program, "u_material.ambientColor");
g_material.diffuseColorLocation = glGetUniformLocation(g_program.program, "u_material.diffuseColor");
g_material.specularColorLocation = glGetUniformLocation(g_program.program, "u_material.specularColor");
g_material.specularExponentLocation = glGetUniformLocation(g_program.program, "u_material.specularExponent");
g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex");
g_normalLocation = glGetAttribLocation(g_program.program, "a_normal");
//
// Use a helper function to load an wavefront object file.
glusShapeLoadWavefront("monkey.obj", &wavefrontObj);
g_numberVertices = wavefrontObj.numberVertices;
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glBufferData(GL_ARRAY_BUFFER, wavefrontObj.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) wavefrontObj.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glBufferData(GL_ARRAY_BUFFER, wavefrontObj.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) wavefrontObj.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glusShapeDestroyf(&wavefrontObj);
//
glUseProgram(g_program.program);
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsVBO);
glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalLocation);
//
glusMatrix4x4LookAtf(g_viewMatrix, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
//
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);
glEnable(GL_CULL_FACE);
return GLUS_TRUE;
}
void UniformImplementation_Legacy::set(const Program * program, const GLint location, const glm::vec3 & value) const
{
program->use();
glUniform3fv(location, 1, glm::value_ptr(value));
}
void Shader::setUniform3fv( int iUniformLocation, int iCount, float * pValue)
{
/// Need to Activate the shader before, but we are not doing it
/// in here to save computation time (if we are setting several variable at the same time)
glUniform3fv( iUniformLocation, iCount, pValue);
}
/*!****************************************************************************
@Function RenderScene
@Return bool true if no error occurred
@Description Main rendering loop function of the program. The shell will
call this function every frame.
eglSwapBuffers() will be performed by PVRShell automatically.
PVRShell will also manage important OS events.
Will also manage relevant OS events. The user has access to
these events through an abstraction layer provided by PVRShell.
******************************************************************************/
bool OGLES2MagicLantern::RenderScene()
{
PVRTMat4 mLightWorld;
// Clear the color and depth buffer.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Time based animation and locks the app to 60 FPS.
// Uses the shell function PVRShellGetTime() to get the time in milliseconds.
unsigned long ulTime = PVRShellGetTime();
unsigned long ulDeltaTime = ulTime - m_ulTimePrev;
m_ulTimePrev = ulTime;
m_fFrame += (float)ulDeltaTime * (60.0f/1000.0f);
// Create an animation for the the position and rotation of the light-ball.
m_LightPosition.x = cos(m_fFrame/140.0f)*60.0f;
m_LightPosition.z = sin(m_fFrame/70.0f)*60.0f - 40.0f;
m_LightPosition.y = sin(m_fFrame/100.0f)*20.0f;
mLightWorld = PVRTMat4::Translation(m_LightPosition.x, m_LightPosition.y-10, m_LightPosition.z);
mLightWorld *= PVRTMat4::RotationX(m_fFrame/540.0f);
mLightWorld *= PVRTMat4::RotationZ(m_fFrame/370.0f);
// To draw a scene, you must go through all the MeshNodes and draw the referenced meshes.
for (unsigned int i = 0; i < m_Scene.nNumMeshNode; ++i)
{
SPODNode& Node = m_Scene.pNode[i];
// Get the current effect from the material ID. The list of IDs was built in LoadPFX()
GLuint uiFXID = m_puiMaterialEffectID[Node.nIdxMaterial];
// Use the loaded effect (Vertex and Fragment shader)
// And also bind all textures in the effect.
m_pFX[uiFXID]->Activate();
// Set the blend mode
// Based in the info stored in the material by PVRShaman.
// We check whether the blend mode is 'opaque' (ONE,ZERO).
// Otherwise we enable blending and set the corresponding operations.
if (m_Scene.pMaterial[Node.nIdxMaterial].eBlendSrcRGB == ePODBlendFunc_ONE && m_Scene.pMaterial[Node.nIdxMaterial].eBlendDstRGB == ePODBlendFunc_ZERO)
{
glDisable(GL_BLEND);
}
else
{
glEnable(GL_BLEND);
glBlendFunc(m_Scene.pMaterial[Node.nIdxMaterial].eBlendSrcRGB, m_Scene.pMaterial[Node.nIdxMaterial].eBlendDstRGB);
}
// Now process PVRShaman semantics and set-up the associated uniforms.
const CPVRTArray<SPVRTPFXUniform>& Uniforms = m_pFX[uiFXID]->GetUniformArray();
for(unsigned int j = 0; j < Uniforms.GetSize() ; ++j)
{
switch(Uniforms[j].nSemantic)
{
case ePVRTPFX_UsWORLDVIEWPROJECTION:
{
PVRTMat4 mWVP;
// The whole scene (except the ball) is static.
// The POD file was saved with 'word space' coordinates so there is no need to apply the
// transformation matrices for the meshes, just the identity.
// If you are exporting animation you will need to set the corresponding mesh
// transformation matrix here (see IntroducingPOD training course).
PVRTMat4 mWorld = PVRTMat4::Identity();
// Check whether the current effect is the sphere and set up the word matrix with the sphere animation.
if (m_ppEffectParser->GetEffect(uiFXID).Name == c_SphereEffectName)
{
mWorld = mLightWorld;
}
// Pass the model-view-projection matrix (MVP) to the shader to transform the vertices.
PVRTMat4 mModelView;
mModelView = m_mView * mWorld;
mWVP = m_mProjection * mModelView;
glUniformMatrix4fv(Uniforms[j].nLocation, 1, GL_FALSE, mWVP.f);
}
break;
case ePVRTPFX_UsWORLDIT:
{
// Passes the inverse transpose of the light rotation matrix.
// This is needed to transform the light direction (from the light to each vertex)
// and it will give us a three component texture vector to map the cubemap texture.
PVRTMat3 mLightModelIT = PVRTMat3(mLightWorld).inverse().transpose();
glUniformMatrix3fv(Uniforms[j].nLocation, 1, GL_FALSE, mLightModelIT.f);
}
break;
case ePVRTPFX_UsLIGHTPOSWORLD:
{
glUniform3f(Uniforms[j].nLocation, m_LightPosition.x, m_LightPosition.y, m_LightPosition.z);
}
break;
case ePVRTPFX_UsLIGHTCOLOR:
{
// Some color variation here to make it more interesting.
float afLightColor[] = { 1.0f, sin(m_fFrame/300.0f)*0.3f+0.7f, cos(m_fFrame/400.0f)*0.3f+0.7f};
glUniform3fv(Uniforms[j].nLocation, 1, afLightColor );
}
break;
}
}
// Now that all transformation matrices and the materials are ready,
// call a function to actually draw the mesh.
// We need to pass the current effect to process 'attributes' properly.
DrawMesh(i, m_pFX[uiFXID]);
}
// Displays the demo name using the tools. For a detailed explanation, see the training course IntroducingPVRTools.
m_Print3D.DisplayDefaultTitle("Magic Lantern", "", ePVRTPrint3DSDKLogo);
m_Print3D.Flush();
return true;
}
// The MAIN function, from here we start our application and run our Game loop
int main()
{
// Init GLFW
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", nullptr, nullptr); // Windowed
glfwMakeContextCurrent(window);
// Set the required callback functions
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
// Options
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// Initialize GLEW to setup the OpenGL Function pointers
glewExperimental = GL_TRUE;
glewInit();
// Define the viewport dimensions
glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);
// Setup some OpenGL options
glEnable(GL_DEPTH_TEST);
// Setup and compile our shaders
Shader shader("parallax_mapping.vs", "parallax_mapping.frag");
// Load textures
GLuint diffuseMap = loadTexture("../../../resources/textures/bricks2.jpg");
GLuint normalMap = loadTexture("../../../resources/textures/bricks2_normal.jpg");
GLuint heightMap = loadTexture("../../../resources/textures/bricks2_disp.jpg");
//GLuint diffuseMap = loadTexture("../../../resources/textures/wood.png");
//GLuint normalMap = loadTexture("../../../resources/textures/toy_box_normal.png");
//GLuint heightMap = loadTexture("../../../resources/textures/toy_box_disp.png");
// Set texture units
shader.Use();
glUniform1i(glGetUniformLocation(shader.Program, "diffuseMap"), 0);
glUniform1i(glGetUniformLocation(shader.Program, "normalMap"), 1);
glUniform1i(glGetUniformLocation(shader.Program, "depthMap"), 2);
// Light position
glm::vec3 lightPos(0.5f, 1.0f, 0.3f);
// Game loop
while (!glfwWindowShouldClose(window))
{
// Set frame time
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check and call events
glfwPollEvents();
Do_Movement();
// Clear the colorbuffer
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Configure view/projection matrices
shader.Use();
glm::mat4 view = camera.GetViewMatrix();
glm::mat4 projection = glm::perspective(camera.Zoom, (GLfloat)SCR_WIDTH / (GLfloat)SCR_HEIGHT, 0.1f, 100.0f);
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
// Render normal-mapped quad
glm::mat4 model;
//model = glm::rotate(model, (GLfloat)glfwGetTime() * -10, glm::normalize(glm::vec3(1.0, 0.0, 1.0))); // Rotates the quad to show parallax mapping works in all directions
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
glUniform3fv(glGetUniformLocation(shader.Program, "lightPos"), 1, &lightPos[0]);
glUniform3fv(glGetUniformLocation(shader.Program, "viewPos"), 1, &camera.Position[0]);
glUniform1f(glGetUniformLocation(shader.Program, "height_scale"), height_scale);
glUniform1i(glGetUniformLocation(shader.Program, "parallax"), parallax_mapping);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, diffuseMap);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, normalMap);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, heightMap);
RenderQuad();
// render light source (simply renders a smaller plane at the light's position for debugging/visualization)
model = glm::mat4();
model = glm::translate(model, lightPos);
model = glm::scale(model, glm::vec3(0.1f));
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
//RenderQuad();
// Swap the buffers
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
/*
==================
RB_ARB2_DrawInteraction
==================
*/
void RB_GLSL_DrawInteraction( const drawInteraction_t *din ) {
// load all the vertex program parameters
glUniform3fv(viewOrgin, 1, din->localViewOrigin.ToFloatPtr());
glUniform4fv(lightProjS, 1, din->lightProjection[0].ToFloatPtr());
glUniform4fv(lightProjT, 1, din->lightProjection[1].ToFloatPtr());
glUniform4fv(lightProjQ, 1, din->lightProjection[2].ToFloatPtr());
glUniform4fv(lightFallOffS, 1, din->lightProjection[3].ToFloatPtr());
glUniform4fv(bumpMatrixS, 1, din->bumpMatrix[0].ToFloatPtr());
glUniform4fv(bumpMatrixT, 1, din->bumpMatrix[1].ToFloatPtr());
glUniform4fv(diffuseMatrixS, 1, din->diffuseMatrix[0].ToFloatPtr());
glUniform4fv(diffuseMatrixT, 1, din->diffuseMatrix[1].ToFloatPtr());
glUniform4fv(specularMatrixS, 1, din->specularMatrix[0].ToFloatPtr());
glUniform4fv(specularMatrixT, 1, din->specularMatrix[1].ToFloatPtr());
static const float zero[4] = { 0, 0, 0, 0 };
static const float one[4] = { 1, 1, 1, 1 };
static const float negOne[4] = { -1, -1, -1, -1 };
switch ( din->vertexColor ) {
case SVC_IGNORE:
glUniform4fv(colorModulate, 1, zero);
glUniform4fv(colorAdd, 1, one);
break;
case SVC_MODULATE:
glUniform4fv(colorModulate, 1, one);
glUniform4fv(colorAdd, 1, zero);
break;
case SVC_INVERSE_MODULATE:
glUniform4fv(colorModulate, 1, negOne);
glUniform4fv(colorAdd, 1, one);
break;
}
glUniform4fv(diffuseColor, 1, din->diffuseColor.ToFloatPtr());
glUniform4fv(specularColor, 1, din->specularColor.ToFloatPtr());
// texture 1 will be the per-surface bump map
glActiveTexture(GL_TEXTURE1);
backEnd.glState.currenttmu = 1;
din->bumpImage->Bind();
// texture 2 will be the light falloff texture
glActiveTexture(GL_TEXTURE2);
backEnd.glState.currenttmu = 2;
din->lightFalloffImage->Bind();
// texture 3 will be the light projection texture
glActiveTexture(GL_TEXTURE3);
backEnd.glState.currenttmu = 3;
din->lightImage->Bind();
// texture 4 is the per-surface diffuse map
glActiveTexture(GL_TEXTURE4);
backEnd.glState.currenttmu = 4;
din->diffuseImage->Bind();
// texture 5 is the per-surface specular map
glActiveTexture(GL_TEXTURE5);
backEnd.glState.currenttmu = 5;
din->specularImage->Bind();
RB_DrawElementsWithCounters( din->surf->geo );
}
void display(void)
{
printError("pre display");
static float time = 0;
// clear the screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Upload camera matrix
mat4 cameraMatrix = lookAt(cameraPos.x, cameraPos.y, cameraPos.z, targetPos.x, targetPos.y, targetPos.z, upVector.x, upVector.y, upVector.z);
// Skybox
glDisable(GL_DEPTH_TEST);
mat4 scale = S(100, 100, 100);
mat4 skybox_matrix = cameraMatrix;
skybox_matrix.m[3] = 0;
skybox_matrix.m[7] = 0;
skybox_matrix.m[11] = 0;
skybox_matrix.m[15] = 1;
// Upload time
glUniform1f(glGetUniformLocation(program, "gTime"), time);
// Default camera for all other renders except the skybox
glUniformMatrix4fv(glGetUniformLocation(program, "gView"), 1, GL_TRUE, skybox_matrix.m);
glUniformMatrix4fv(glGetUniformLocation(program, "gWorld"), 1, GL_TRUE, scale.m);
glUniform1i(glGetUniformLocation(program, "skybox_active"), 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, skybox_texture);
DrawModel(skybox, program, "InPosL", "InNormalL", "InTex");
glUniform1i(glGetUniformLocation(program, "skybox_active"), 0);
glEnable(GL_DEPTH_TEST);
// Default camera for all other renders except the skybox
glUniformMatrix4fv(glGetUniformLocation(program, "gView"), 1, GL_TRUE, cameraMatrix.m);
// Eye position
GLfloat eyePos[] = { cameraPos.x, cameraPos.y, cameraPos.z };
glUniform3fv(glGetUniformLocation(program, "gEyePosW"), 1, eyePos);
// Ground (multitextured)
scale = S(10, 10, 10);
glUniformMatrix4fv(glGetUniformLocation(program, "gWorld"), 1, GL_TRUE, scale.m);
glUniform1i(glGetUniformLocation(program, "multitexturing"), 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, grass_texture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, conc_texture);
DrawModel(ground, program, "InPosL", "InNormalL", "InTex");
glUniform1i(glGetUniformLocation(program, "multitexturing"), 0);
// Castle
scale = S(1, 1, 1);
mat4 trans = T(0, 0, 50);
glBindTexture(GL_TEXTURE_2D, conc_texture);
glUniformMatrix4fv(glGetUniformLocation(program, "gWorld"), 1, GL_TRUE, Mult(trans, scale).m);
DrawModel(castle, program, "InPosL", "InNormalL", "InTex");
// Windmill
render_windmill(&windmill, program, time);
glutSwapBuffers();
time += 0.01;
}
void ParticleRenderer2D::drawParticles(
uint32_t count,
const glm::vec2* positionArray,
const float* massArray,
const glm::vec3* colorArray,
unsigned int * instrumentArray,
int * lifetimeArray,
float size,
float volume) {
// Active la gestion de la transparence
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_DEPTH_TEST);
glUseProgram(m_ProgramID);
glBindVertexArray(m_VAOID);
glm::vec3 bassColor = m_band[Instrument::bass].giveColor(soundManager->scaleVolume(volume));
glm::vec3 drumsColor = m_band[Instrument::drums].giveColor(soundManager->scaleVolume(volume));
glm::vec3 guitarAColor = m_band[Instrument::guitarA].giveColor(soundManager->scaleVolume(volume));
glm::vec3 guitarBColor = m_band[Instrument::guitarB].giveColor(soundManager->scaleVolume(volume));
// Dessine chacune des particules
for(uint32_t i = 0; i < count; ++i) {
if(soundManager->getMaxVolume() > 0) {
// renvoyer la bonne couleur en fonction de l'instrument de la particule
//~ glm::vec3 color = Instrument::giveColor(glm::vec3(0.), soundManager->scaleVolume(volume));
glm::vec3 color;
float coef = float(lifetimeArray[i]) / 100.f;
//~ std::cout << "coef : " << coef << std::endl;
switch(instrumentArray[i]){
case Instrument::bass:
color = bassColor*coef;
break;
case Instrument::drums:
color = drumsColor*coef;
break;
case Instrument::guitarA:
color = guitarAColor*coef;
break;
case Instrument::guitarB:
color = guitarBColor*coef;
break;
default:
color = glm::vec3(1.)*coef;
break;
};
glUniform3fv(m_uParticleColor, 1, glm::value_ptr(color));
} else {
glUniform3fv(m_uParticleColor, 1, glm::value_ptr(colorArray[i]));
}
glUniform2fv(m_uParticlePosition, 1, glm::value_ptr(positionArray[i]));
glUniform1f(m_uParticleScale, m_fMassScale * size);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
glBindVertexArray(0);
glDisable(GL_BLEND);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform3fv(JNIEnv *env, jclass clazz, jint location, jint count, jlong values, jlong function_pointer) {
const GLfloat *values_address = (const GLfloat *)(intptr_t)values;
glUniform3fvPROC glUniform3fv = (glUniform3fvPROC)((intptr_t)function_pointer);
glUniform3fv(location, count, values_address);
}
//OpenGL Initialization Logic
void glInit() {
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_POLYGON_OFFSET_LINE);
glPolygonOffset(-1.f, -1.0f);
glEnable(GL_MULTISAMPLE);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
int samples, bufs;
glGetIntegerv(GL_SAMPLE_BUFFERS, &bufs);
glGetIntegerv(GL_SAMPLES, &samples);
printf("Multisampling buffers: %d, samples: %d\n", bufs, samples);
glm::vec3 coneDir = {0.f, -1.f, -1.f};
glm::vec4 lightPos = {0.f, 30.f, 30.f, 1.f};
glm::mat4 scaleBiasMat = {{0.5f, 0.f, 0.f, 0.f}, {0.f, 0.5f, 0.f, 0.f}, {0.f, 0.f, 0.5f, 0.f}, {0.5f, 0.5f, 0.5f, 1.f}};
GLuint TeapotTexture;
int imgWidth, imgHeight, imgComp;
gTexImage = stbi_load("texture.jpg", &imgWidth, &imgHeight, &imgComp, STBI_rgb);
glGenTextures(1, &TeapotTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, TeapotTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
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);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imgWidth, imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, gTexImage);
glActiveTexture(GL_TEXTURE0);
//Screen Shader
gScreenProg = glCreateProgram();
gScreenVS = CreateShader(GL_VERTEX_SHADER, "screen.vert");
gScreenFS = CreateShader(GL_FRAGMENT_SHADER, "screen.frag");
glAttachShader(gScreenProg, gScreenVS);
glAttachShader(gScreenProg, gScreenFS);
glLinkProgram(gScreenProg);
glUseProgram(gScreenProg);
glm::vec3 screenColor = {1.f, 1.f, 1.f};
GLint screenColorLoc = glGetUniformLocation(gScreenProg, "uColor");
glUniform3fv(screenColorLoc, 1, glm::value_ptr(screenColor));
glGenVertexArrays(1, &gScreenVao);
glBindVertexArray(gScreenVao);
glGenBuffers(1, &gScreenPosBuf);
glBindBuffer(GL_ARRAY_BUFFER, gScreenPosBuf);
glm::vec4 screenPosData[] = {{-0.8f, -0.5f, 0.f, 1.f}, {-0.8f, -0.8f, 0.f, 1.f}, {-0.5f, -0.5f, 0.f, 1.f}, {-0.5f, -0.5f, 0.f, 1.f}, {-0.8f, -0.8f, 0.f, 1.f}, {-0.5f, -0.8f, 0.f, 1.f}};
glBufferData(GL_ARRAY_BUFFER, 6 * 4 * sizeof(float), &screenPosData[0], GL_STATIC_DRAW);
GLint screenPosLoc = glGetAttribLocation(gScreenProg, "vPosition");
glEnableVertexAttribArray(screenPosLoc);
glBindBuffer(GL_ARRAY_BUFFER, gScreenPosBuf);
glVertexAttribPointer(screenPosLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL);
//Shadow Map Creation
gShadowProg = glCreateProgram();
gShadowVS = CreateShader(GL_VERTEX_SHADER, "shadow.vert");
gShadowFS = CreateShader(GL_FRAGMENT_SHADER, "shadow.frag");
glAttachShader(gShadowProg, gShadowVS);
glAttachShader(gShadowProg, gShadowFS);
glLinkProgram(gShadowProg);
glUseProgram(gShadowProg);
glGenFramebuffers(1, &gShadowFbo);
glBindFramebuffer(GL_FRAMEBUFFER, gShadowFbo);
glDrawBuffer(GL_NONE);
glGenTextures(1, &gShadowTexture);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, gShadowTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_DEPTH_TEXTURE_SIZE, SHADOW_DEPTH_TEXTURE_SIZE, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
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_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glActiveTexture(GL_TEXTURE0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, gShadowTexture, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
gShadowViewMat = glm::lookAt(glm::vec3(lightPos), glm::vec3(lightPos) + coneDir, glm::vec3(0, 1, 0));
gShadowProjMat = glm::frustum(-1.f, 1.f, -1.f, 1.f, 1.f, SHADOW_FRUSTRUM_DEPTH);
gShadowModelMatLoc = glGetUniformLocation(gShadowProg, "uModelMat");
gShadowViewMatLoc = glGetUniformLocation(gShadowProg, "uViewMat");
glUniformMatrix4fv(gShadowViewMatLoc, 1, GL_FALSE, glm::value_ptr(gShadowViewMat));
gShadowProjMatLoc = glGetUniformLocation(gShadowProg, "uProjMat");
glUniformMatrix4fv(gShadowProjMatLoc, 1, GL_FALSE, glm::value_ptr(gShadowProjMat));
glGenVertexArrays(1, &gShadowVao);
glBindVertexArray(gShadowVao);
gShadowPosLoc = glGetAttribLocation(gShadowProg, "vPosition");
glEnableVertexAttribArray(gShadowPosLoc);
//Program Creation
gRenderProg = glCreateProgram();
gRenderVS = CreateShader(GL_VERTEX_SHADER, "shader.vert");
gRenderFS = CreateShader(GL_FRAGMENT_SHADER, "shader.frag");
glAttachShader(gRenderProg, gRenderVS);
glAttachShader(gRenderProg, gRenderFS);
glLinkProgram(gRenderProg);
glUseProgram(gRenderProg);
//Texture
//Uniforms
gModelMatLoc = glGetUniformLocation(gRenderProg, "uModelMat");
gModelMat = glm::rotate(glm::mat4(1.f), -1.57f, glm::vec3(1.f, 0.f, 0.f));
glUniformMatrix4fv(gModelMatLoc, 1, GL_FALSE, glm::value_ptr(gModelMat));
gViewMatLoc = glGetUniformLocation(gRenderProg, "uViewMat");
glm::mat4 viewMat = glm::mat4(1.f);
viewMat = glm::rotate(glm::mat4(1.f), 0.7f, glm::vec3(1.f, 0.f, 0.f)) * viewMat;
viewMat = glm::translate(glm::mat4(1.f), glm::vec3(0.f, 0.f, -50.f)) * viewMat;
glUniformMatrix4fv(gViewMatLoc, 1, GL_FALSE, glm::value_ptr(viewMat));
gProjMatLoc = glGetUniformLocation(gRenderProg, "uProjMat");
glm::mat4 projMat = glm::perspective(45.f, (float)gScreenWidth / (float)gScreenHeight, PROJ_NEAR, PROJ_FAR);
glUniformMatrix4fv(gProjMatLoc, 1, GL_FALSE, glm::value_ptr(projMat));
gScaleBiasMatLoc = glGetUniformLocation(gRenderProg, "uScaleBiasMat");
glUniformMatrix4fv(gScaleBiasMatLoc, 1, GL_FALSE, glm::value_ptr(scaleBiasMat));
gShadowMatLoc = glGetUniformLocation(gRenderProg, "uShadowMat");
glm::mat4 shadowMat = gShadowProjMat * gShadowViewMat;
glUniformMatrix4fv(gShadowMatLoc, 1, GL_FALSE, glm::value_ptr(shadowMat));
gTexUnitLoc = glGetUniformLocation(gRenderProg, "uTexUnit");
glUniform1i(gTexUnitLoc, 0);
gIsTexturedLoc = glGetUniformLocation(gRenderProg, "uIsTextured");
glUniform1i(gIsTexturedLoc, 1);
gColorLoc = glGetUniformLocation(gRenderProg, "uColor");
glm::vec4 color = {1.0f, 0.f, 0.f, 1.f};
glUniform4fv(gColorLoc, 1, glm::value_ptr(color));
gAmbientLoc = glGetUniformLocation(gRenderProg, "uAmbient");
glm::vec3 ambVec = {0.3f, 0.3f, 0.3f};
glUniform3fv(gAmbientLoc, 1, glm::value_ptr(ambVec));
gDiffuseLoc = glGetUniformLocation(gRenderProg, "uDiffuse");
glm::vec3 difVec = {0.5f, 0.f, 0.f};
glUniform3fv(gDiffuseLoc, 1, glm::value_ptr(difVec));
gSpecularLoc = glGetUniformLocation(gRenderProg, "uSpecular");
glm::vec3 specVec = {1.f, 1.f, 1.f};
glUniform3fv(gSpecularLoc, 1, glm::value_ptr(specVec));
gShininessLoc = glGetUniformLocation(gRenderProg, "uShininess");
float shininess = 20.0f;
glUniform1f(gShininessLoc, shininess);
gLightPosLoc = glGetUniformLocation(gRenderProg, "uLightPos");
glUniform4fv(gLightPosLoc, 1, glm::value_ptr(lightPos));
gSpecStrengthLoc = glGetUniformLocation(gRenderProg, "uSpecStrength");
float strength = 3.f;
glUniform1f(gSpecStrengthLoc, strength);
gConstAttenuationLoc = glGetUniformLocation(gRenderProg, "uConstAttenuation");
float constAttenuation = 1.f;
glUniform1f(gConstAttenuationLoc, constAttenuation);
gLinearAttenuationLoc = glGetUniformLocation(gRenderProg, "uLinearAttenuation");
float linearAttenuation = 0.05f;
glUniform1f(gLinearAttenuationLoc, linearAttenuation);
gConeDirectionLoc = glGetUniformLocation(gRenderProg, "uConeDirection");
glUniform3fv(gConeDirectionLoc, 1, glm::value_ptr(coneDir));
gConeAngleLoc = glGetUniformLocation(gRenderProg, "uConeAngle");
float coneAngle = 0.8f;
glUniform1f(gConeAngleLoc, coneAngle);
gSpotExponentLoc = glGetUniformLocation(gRenderProg, "uSpotExponent");
float spotExponent = 1.0f;
glUniform1f(gSpotExponentLoc, spotExponent);
gAmbientSkyLoc = glGetUniformLocation(gRenderProg, "uAmbientSky");
glm::vec3 ambientSky = {0.3f, 0.3f, 0.3f};
glUniform3fv(gAmbientSkyLoc, 1, glm::value_ptr(ambientSky));
gAmbientGroundLoc = glGetUniformLocation(gRenderProg, "uAmbientGround");
glm::vec3 ambientGround = {0.1f, 0.1f, 0.1f};
glUniform3fv(gAmbientGroundLoc, 1, glm::value_ptr(ambientGround));
gDepthTextureLoc = glGetUniformLocation(gRenderProg, "uDepthTexture");
glUniform1i(gDepthTextureLoc, 2);
gProjectorDepthTextureLoc = glGetUniformLocation(gRenderProg, "uProjectorDepthTexture");
glUniform1i(gProjectorDepthTextureLoc, 3);
//Vertex Array Object
glGenVertexArrays(1, &gVao);
glBindVertexArray(gVao);
//Vertex Attribute Specification
gPosLoc = glGetAttribLocation(gRenderProg, "vPosition");
glEnableVertexAttribArray(gPosLoc);
gTexCoordLoc = glGetAttribLocation(gRenderProg, "vTexCoord");
glEnableVertexAttribArray(gTexCoordLoc);
gNormLoc = glGetAttribLocation(gRenderProg, "vNormal");
glEnableVertexAttribArray(gNormLoc);
//Floor
gFloorObj.modelMat = glm::mat4(1.f);
GLuint floorBuffers[3];
glGenBuffers(3, &floorBuffers[0]);
glBindBuffer(GL_ARRAY_BUFFER, floorBuffers[0]);
glm::vec4 floorPosData[] = {{-60.f, 0.f, -30.f, 1.f}, {-60, 0.f, 30.f, 1.f}, {60.f, 0.f, -30.f, 1.f}, {60.f, 0.f, -30.f, 1.f}, {-60.f, 0.f, 30.f, 1.f}, {60.f, 0.f, 30.f, 1.f}};
glBufferData(GL_ARRAY_BUFFER, 4 * 6 * sizeof(float), &floorPosData[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, floorBuffers[1]);
glm::vec2 floorTexCoordData[] = {{0.f, 0.f}, {0.f, 1.f}, {1.f, 0.f}, {1.f, 0.f}, {0.f, 1.f}, {1.f, 1.f}};
glBufferData(GL_ARRAY_BUFFER, 2 * 6 * sizeof(float), &floorTexCoordData[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, floorBuffers[2]);
glm::vec3 floorNormData[] = {{0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}};
glBufferData(GL_ARRAY_BUFFER, 3 * 6 * sizeof(float), &floorNormData[0], GL_STATIC_DRAW);
gFloorObj.glPosBuf = floorBuffers[0];
gFloorObj.glTexCoordBuf = floorBuffers[1];
gFloorObj.glNormBuf = floorBuffers[2];
gFloorObj.vertCount = 6;
gFloorObj.ambientColor = {0.3f, 0.3f, 0.3f};
//gFloorObj.ambientColor = {1.f, 1.f, 1.f};
gFloorObj.diffuseColor = {0.5f, 0.5f, 0.5f};
gFloorObj.specularColor = {1.f, 1.f, 1.f};
gFloorObj.shininess = 20.f;
gFloorObj.specStrength = 0.f;
gFloorObj.isTextured = false;
gFloorObj.objColor = {0.5f, 0.5f, 0.5f, 1.f};
//gFloorObj.objColor = {1.f, 1.f, 1.f, 1.f};
gFloorObj.glTexture = TeapotTexture;
gFloorObj.glTexUnit = 0;
//Teapot
gTeapotObj.modelMat = glm::rotate(glm::mat4(1.f), -1.57f, glm::vec3(1.f, 0.f, 0.f));
GLuint TeapotBuffers[3];
glGenBuffers(3, &TeapotBuffers[0]);
glBindBuffer(GL_ARRAY_BUFFER, TeapotBuffers[0]);
glBufferData(GL_ARRAY_BUFFER, teapot.m_Info.vertCount * 4 * sizeof(float), &teapot.m_Info.v[0], GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, TeapotBuffers[1]);
glBufferData(GL_ARRAY_BUFFER, teapot.m_Info.vertCount * 2 * sizeof(float), &teapot.m_Info.vt[0], GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, TeapotBuffers[2]);
glBufferData(GL_ARRAY_BUFFER, teapot.m_Info.vertCount * 3 * sizeof(float), &teapot.m_Info.vn[0], GL_STREAM_DRAW);
gTeapotObj.glPosBuf = TeapotBuffers[0];
gTeapotObj.glTexCoordBuf = TeapotBuffers[1];
gTeapotObj.glNormBuf = TeapotBuffers[2];
gTeapotObj.vertCount = teapot.m_Info.vertCount;
gTeapotObj.ambientColor = {0.3f, 0.3f, 0.3f};
gTeapotObj.diffuseColor = {0.8f, 0.f, 0.f};
gTeapotObj.specularColor = {1.f, 1.f, 1.f};
gTeapotObj.shininess = 20.f;
gTeapotObj.specStrength = 5.f;
gTeapotObj.isTextured = true;
gTeapotObj.objColor = {0.1f, 0.f, 0.f, 1.f};
gTeapotObj.glTexture = TeapotTexture;
gTeapotObj.glTexUnit = 1;
gSceneGraph.push_back(gTeapotObj);
gSceneGraph.push_back(gFloorObj);
gFilterProg = glCreateProgram();
gFilterVS = CreateShader(GL_VERTEX_SHADER, "bloom.vert");
gFilterFS = CreateShader(GL_FRAGMENT_SHADER, "bloom.frag");
glAttachShader(gFilterProg, gFilterVS);
glAttachShader(gFilterProg, gFilterFS);
glLinkProgram(gFilterProg);
glUseProgram(gFilterProg);
gFilterRenderTextureLoc = glGetUniformLocation(gFilterProg, "uRenderTexture");
glUniform1i(gFilterRenderTextureLoc, 3);
// Swap textures in shader by binding texture to tex unit 4 (GL_TEXTURE3)
gFilterTextureLoc = glGetUniformLocation(gFilterProg, "uTexture");
glUniform1i(gFilterTextureLoc, 4);
gFilterWidthLoc = glGetUniformLocation(gFilterProg, "uScreenWidth");
glUniform1i(gFilterWidthLoc, gScreenWidth * 2);
gFilterHeightLoc = glGetUniformLocation(gFilterProg, "uScreenHeight");
glUniform1i(gFilterHeightLoc, gScreenHeight * 2);
gFilterPassLoc = glGetUniformLocation(gFilterProg, "uPass");
glUniform1i(gFilterPassLoc, 1);
gFilterLumThresholdLoc = glGetUniformLocation(gFilterProg, "uLumThreshold");
glUniform1f(gFilterLumThresholdLoc, 0.75f);
// Calculates the weights of the gaussian function
float weights[20];
float sum = 0.f;
float sigma = 5.f;
weights[0] = gauss(0, sigma);
sum += weights[0];
for (int i = 1; i < 20; i++) {
weights[i] = gauss(i, sigma);
sum += 2 * weights[i];
}
for (int i = 0; i < 20; i++) {
weights[i] = weights[i] / sum; // Normalizes weights: sum of weights equals 1
}
gFilterWeightsLoc = glGetUniformLocation(gFilterProg, "uWeights");
glUniform1fv(gFilterWeightsLoc, 20, weights);
glGenBuffers(1, &gFilterPosBuf);
glBindBuffer(GL_ARRAY_BUFFER, gFilterPosBuf);
glm::vec4 filterPosData[] = {{-1.f, 1.f, 0.f, 1.f}, {-1.f, -1.f, 0.f, 1.f}, {1.f, 1.f, 0.f, 1.f}, {1.f, 1.f, 0.f, 1.f}, {-1.f, -1.f, 0.f, 1.f}, {1.f, -1.f, 0.f, 1.f}};
glBufferData(GL_ARRAY_BUFFER, 6 * 4 * sizeof(float), &filterPosData[0], GL_STATIC_DRAW);
glGenBuffers(1, &gFilterTexCoordBuf);
glBindBuffer(GL_ARRAY_BUFFER, gFilterTexCoordBuf);
glm::vec2 filterTexCoordData[] = {{0.f, 1.f}, {0.f, 0.f}, {1.f, 1.f}, {1.f, 1.f}, {0.f, 0.f}, {1.f, 0.f}};
glBufferData(GL_ARRAY_BUFFER, 6 * 2 * sizeof(float), &filterTexCoordData[0], GL_STATIC_DRAW);
glGenVertexArrays(1, &gFilterVao);
glBindVertexArray(gFilterVao);
gFilterPosBufLoc = glGetAttribLocation(gFilterProg, "vPosition");
glEnableVertexAttribArray(gFilterPosBufLoc);
glBindBuffer(GL_ARRAY_BUFFER, gFilterPosBuf);
glVertexAttribPointer(gFilterPosBufLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL);
gFilterTexCoordBufLoc = glGetAttribLocation(gFilterProg, "vTexCoord");
glEnableVertexAttribArray(gFilterTexCoordBufLoc);
glBindBuffer(GL_ARRAY_BUFFER, gFilterTexCoordBuf);
glVertexAttribPointer(gFilterTexCoordBufLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
// Scene rendered to gFilterSceneTexture
glGenFramebuffers(1, &gFilterSceneFbo);
glBindFramebuffer(GL_FRAMEBUFFER, gFilterSceneFbo);
glGenTextures(1, &gFilterSceneTexture);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, gFilterSceneTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, gScreenWidth * 2, gScreenHeight * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
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_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glActiveTexture(GL_TEXTURE0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gFilterSceneTexture, 0);
glGenRenderbuffers(1, &gFilterSceneRbo);
glBindRenderbuffer(GL_RENDERBUFFER, gFilterSceneRbo);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, gScreenWidth * 2, gScreenHeight * 2);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, gFilterSceneRbo);
GLenum drawModes[1] = {GL_COLOR_ATTACHMENT0};
glDrawBuffers(1, drawModes);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Results of low luminance discard stored in gFilterLumTexture
glGenFramebuffers(1, &gFilterLumFbo);
glBindFramebuffer(GL_FRAMEBUFFER, gFilterLumFbo);
glGenTextures(1, &gFilterLumTexture);
glBindTexture(GL_TEXTURE_2D, gFilterLumTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, gScreenWidth * 2, gScreenHeight * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
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_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gFilterLumTexture, 0);
GLenum lumDrawModes[1] = {GL_COLOR_ATTACHMENT0};
glDrawBuffers(1, lumDrawModes);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Results of gaussian filter pass1 stored in gFilterPassTexture (depth buffer not needed)
glGenFramebuffers(1, &gFilterBlurFbo);
glBindFramebuffer(GL_FRAMEBUFFER, gFilterBlurFbo);
glGenTextures(1, &gFilterBlurTexture);
glBindTexture(GL_TEXTURE_2D, gFilterBlurTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, gScreenWidth * 2, gScreenHeight * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
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_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gFilterBlurTexture, 0);
GLenum passDrawModes[1] = {GL_COLOR_ATTACHMENT0};
glDrawBuffers(1, passDrawModes);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
int main()
{
int width = 640;
int height = 480;
if(glfwInit() == GL_FALSE)
{
std::cerr << "failed to init GLFW" << std::endl;
return 1;
}
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 4);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
// create a window
if(glfwOpenWindow(width, height, 0, 0, 0, 8, 24, 8, GLFW_WINDOW) == GL_FALSE)
{
std::cerr << "failed to open window" << std::endl;
glfwTerminate();
return 1;
}
// setup windows close callback
glfwSetWindowCloseCallback(closedWindow);
if (gl3wInit())
{
std::cerr << "failed to init GL3W" << std::endl;
glfwCloseWindow();
glfwTerminate();
return 1;
}
// shader source code
// the vertex shader simply passes through data
std::string vertex_source =
"#version 430\n"
"layout(location = 0) in vec4 vposition;\n"
"void main() {\n"
" gl_Position = vposition;\n"
"}\n";
// the geometry shader creates the billboard quads
std::string geometry_source =
"#version 430\n"
"uniform mat4 View;\n"
"uniform mat4 Projection;\n"
"layout (points) in;\n"
"layout (triangle_strip, max_vertices = 4) out;\n"
"out vec2 txcoord;\n"
"void main() {\n"
" vec4 pos = View*gl_in[0].gl_Position;\n"
" txcoord = vec2(-1,-1);\n"
" gl_Position = Projection*(pos+0.2*vec4(txcoord,0,0));\n"
" EmitVertex();\n"
" txcoord = vec2( 1,-1);\n"
" gl_Position = Projection*(pos+0.2*vec4(txcoord,0,0));\n"
" EmitVertex();\n"
" txcoord = vec2(-1, 1);\n"
" gl_Position = Projection*(pos+0.2*vec4(txcoord,0,0));\n"
" EmitVertex();\n"
" txcoord = vec2( 1, 1);\n"
" gl_Position = Projection*(pos+0.2*vec4(txcoord,0,0));\n"
" EmitVertex();\n"
"}\n";
// the fragment shader creates a bell like radial color distribution
std::string fragment_source =
"#version 330\n"
"in vec2 txcoord;\n"
"layout(location = 0) out vec4 FragColor;\n"
"void main() {\n"
" float s = 0.2*(1/(1+15.*dot(txcoord, txcoord))-1/16.);\n"
" FragColor = s*vec4(0.3,0.3,1.0,1);\n"
"}\n";
// program and shader handles
GLuint shader_program, vertex_shader, geometry_shader, fragment_shader;
// we need these to properly pass the strings
const char *source;
int length;
// create and compiler vertex shader
vertex_shader = glCreateShader(GL_VERTEX_SHADER);
source = vertex_source.c_str();
length = vertex_source.size();
glShaderSource(vertex_shader, 1, &source, &length);
glCompileShader(vertex_shader);
if(!check_shader_compile_status(vertex_shader))
{
return 1;
}
// create and compiler geometry shader
geometry_shader = glCreateShader(GL_GEOMETRY_SHADER);
source = geometry_source.c_str();
length = geometry_source.size();
glShaderSource(geometry_shader, 1, &source, &length);
glCompileShader(geometry_shader);
if(!check_shader_compile_status(geometry_shader))
{
return 1;
}
// create and compiler fragment shader
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
source = fragment_source.c_str();
length = fragment_source.size();
glShaderSource(fragment_shader, 1, &source, &length);
glCompileShader(fragment_shader);
if(!check_shader_compile_status(fragment_shader))
{
return 1;
}
// create program
shader_program = glCreateProgram();
// attach shaders
glAttachShader(shader_program, vertex_shader);
glAttachShader(shader_program, geometry_shader);
glAttachShader(shader_program, fragment_shader);
// link the program and check for errors
glLinkProgram(shader_program);
check_program_link_status(shader_program);
// obtain location of projection uniform
GLint View_location = glGetUniformLocation(shader_program, "View");
GLint Projection_location = glGetUniformLocation(shader_program, "Projection");
std::string compute_source =
"#version 430\n"
"layout(local_size_x=256) in;\n"
"uniform vec3 center[3];\n"
"uniform float radius[3];\n"
"uniform vec3 g;\n"
"uniform float dt;\n"
"uniform float bounce;\n"
"uniform int seed;\n"
"uniform layout(rgba32f) imageBuffer particles;\n"
"float hash(int x) {\n"
" x = x*1235167 + int(gl_GlobalInvocationID)*948737 + seed*9284365;\n"
" x = (x >> 13) ^ x;\n"
" return ((x * (x * x * 60493 + 19990303) + 1376312589) & 0x7fffffff)/float(0x7fffffff-1);\n"
"}\n"
"void main() {\n"
" int index = int(gl_GlobalInvocationID);\n"
" vec3 inposition = imageLoad(particles, 2*index).xyz;\n"
" vec3 invelocity = imageLoad(particles, 2*index+1).xyz;\n"
" vec3 outvelocity = invelocity;\n"
" for(int j = 0;j<3;++j) {\n"
" vec3 diff = inposition-center[j];\n"
" float dist = length(diff);\n"
" float vdot = dot(diff, invelocity);\n"
" if(dist<radius[j] && vdot<0.0)\n"
" outvelocity -= bounce*diff*vdot/(dist*dist);\n"
" }\n"
" outvelocity += dt*g;\n"
" vec3 outposition = inposition + dt*outvelocity;\n"
" if(outposition.y < -30.0)\n"
" {\n"
" outvelocity = vec3(0,0,0);\n"
" outposition = 0.5-vec3(hash(3*index+0),hash(3*index+1),hash(3*index+2));\n"
" outposition = vec3(0,20,0) + 5.0*outposition;\n"
" }\n"
" imageStore(particles, 2*index, vec4(outposition,1));\n"
" imageStore(particles, 2*index+1, vec4(outvelocity,1));\n"
"}\n";
// program and shader handles
GLuint compute_program, compute_shader;
// create and compiler vertex shader
compute_shader = glCreateShader(GL_COMPUTE_SHADER);
source = compute_source.c_str();
length = compute_source.size();
glShaderSource(compute_shader, 1, &source, &length);
glCompileShader(compute_shader);
if(!check_shader_compile_status(compute_shader))
{
return 1;
}
// create program
compute_program = glCreateProgram();
// attach shaders
glAttachShader(compute_program, compute_shader);
// link the program and check for errors
glLinkProgram(compute_program);
check_program_link_status(compute_program);
GLint center_location = glGetUniformLocation(compute_program, "center");
GLint radius_location = glGetUniformLocation(compute_program, "radius");
GLint g_location = glGetUniformLocation(compute_program, "g");
GLint dt_location = glGetUniformLocation(compute_program, "dt");
GLint bounce_location = glGetUniformLocation(compute_program, "bounce");
GLint seed_location = glGetUniformLocation(compute_program, "seed");
GLint particles_location = glGetUniformLocation(compute_program, "particles");
const int particles = 128*1024;
// randomly place particles in a cube
std::vector<glm::vec4> vertexData(2*particles);
for(int i = 0;i<particles;++i)
{
// initial position
vertexData[2*i+0] = glm::vec4(
0.5f-float(std::rand())/RAND_MAX,
0.5f-float(std::rand())/RAND_MAX,
0.5f-float(std::rand())/RAND_MAX,
0
);
vertexData[2*i+0] = glm::vec4(0.0f,20.0f,0.0f,1) + 5.0f*vertexData[2*i+0];
// initial velocity
vertexData[2*i+1] = glm::vec4(0,0,0,0);
}
// generate vbos and vaos
GLuint vao, vbo;
glGenVertexArrays(1, &vao);
glGenBuffers(1, &vbo);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// fill with initial data
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec4)*vertexData.size(), &vertexData[0], GL_STATIC_DRAW);
// set up generic attrib pointers
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 8*sizeof(GLfloat), (char*)0 + 0*sizeof(GLfloat));
// set up generic attrib pointers
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 8*sizeof(GLfloat), (char*)0 + 4*sizeof(GLfloat));
// "unbind" vao
glBindVertexArray(0);
// texture handle
GLuint buffer_texture;
// generate and bind the buffer texture
glGenTextures(1, &buffer_texture);
glBindTexture(GL_TEXTURE_BUFFER, buffer_texture);
// tell the buffer texture to use
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, vbo);
// we are blending so no depth testing
glDisable(GL_DEPTH_TEST);
// enable blending
glEnable(GL_BLEND);
// and set the blend function to result = 1*source + 1*destination
glBlendFunc(GL_ONE, GL_ONE);
// define spheres for the particles to bounce off
const int spheres = 3;
glm::vec3 center[spheres];
float radius[spheres];
center[0] = glm::vec3(0,12,1);
radius[0] = 3;
center[1] = glm::vec3(-3,0,0);
radius[1] = 7;
center[2] = glm::vec3(5,-10,0);
radius[2] = 12;
// physical parameters
float dt = 1.0f/60.0f;
glm::vec3 g(0.0f, -9.81f, 0.0f);
float bounce = 1.2f; // inelastic: 1.0f, elastic: 2.0f
int current_buffer=0;
running = true;
while(running)
{
// get the time in seconds
float t = glfwGetTime();
// terminate on excape
if(glfwGetKey(GLFW_KEY_ESC))
{
running = false;
}
// use the transform shader program
glUseProgram(compute_program);
// set the uniforms
glUniform3fv(center_location, 3, reinterpret_cast<GLfloat*>(center));
glUniform1fv(radius_location, 3, reinterpret_cast<GLfloat*>(radius));
glUniform3fv(g_location, 1, glm::value_ptr(g));
glUniform1f(dt_location, dt);
glUniform1f(bounce_location, bounce);
glUniform1i(seed_location, std::rand());
glBindImageTexture(0, buffer_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
glUniform1i(particles_location, 0);
glDispatchCompute(particles/256, 1, 1);
// clear first
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// use the shader program
glUseProgram(shader_program);
// calculate ViewProjection matrix
glm::mat4 Projection = glm::perspective(90.0f, 4.0f / 3.0f, 0.1f, 100.f);
// translate the world/view position
glm::mat4 View = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -30.0f));
// make the camera rotate around the origin
View = glm::rotate(View, 30.0f, glm::vec3(1.0f, 0.0f, 0.0f));
View = glm::rotate(View, -22.5f*t, glm::vec3(0.0f, 1.0f, 0.0f));
// set the uniform
glUniformMatrix4fv(View_location, 1, GL_FALSE, glm::value_ptr(View));
glUniformMatrix4fv(Projection_location, 1, GL_FALSE, glm::value_ptr(Projection));
// bind the current vao
glBindVertexArray(vao);
// draw
glDrawArrays(GL_POINTS, 0, particles);
// check for errors
GLenum error = glGetError();
if(error != GL_NO_ERROR)
{
std::cerr << gluErrorString(error);
running = false;
}
// finally swap buffers
glfwSwapBuffers();
}
// delete the created objects
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &vbo);
glDeleteTextures(1, &buffer_texture);
glDetachShader(shader_program, vertex_shader);
glDetachShader(shader_program, geometry_shader);
glDetachShader(shader_program, fragment_shader);
glDeleteShader(vertex_shader);
glDeleteShader(geometry_shader);
glDeleteShader(fragment_shader);
glDeleteProgram(shader_program);
glDetachShader(compute_program, compute_shader);
glDeleteShader(compute_shader);
glDeleteProgram(compute_program);
glfwCloseWindow();
glfwTerminate();
return 0;
}
void TheMaze2::render() {
glEnableVertexAttribArray(position_attr_);
glEnableVertexAttribArray(normal_attr_);
glEnableVertexAttribArray(text_coord_attr_);
glEnableVertexAttribArray(color_attr_);
player_.updateModelMatrix();
//player_.model_matrix_ = glm::inverse(player_.model_matrix_);
glUniformMatrix4fv(view_uni_, 1, GL_FALSE, glm::value_ptr(player_.model_matrix_));
int light_count = light_positions_ws_.size();
glUniform1i(light_count_uni_, light_count);
// convert each light position to camera space
glm::vec3 light_pos_cs[16];
for (int i = 0; i < light_count; i++) {
glm::vec3 light_pos_ws = light_positions_ws_[i];
light_pos_cs[i] = (glm::vec3)(player_.model_matrix_ * glm::vec4(light_pos_ws, 1.0));
}
glUniform3fv(light_pos_cs_uni_, light_count, glm::value_ptr(light_pos_cs[0]));
for (Surface *sf : surfaces_) {
sf->updateModelMatrix();
glUniformMatrix4fv(vert_model_uni_, 1, GL_FALSE, glm::value_ptr(sf->model_matrix_));
glUniformMatrix4fv(norm_model_uni_, 1, GL_FALSE, glm::value_ptr(sf->model_matrix_));
glUniform1i(text_samp_uni_, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, wall_text_);
glDrawElements(GL_TRIANGLES, sf->ebo_count_, GL_UNSIGNED_SHORT, sf->ebo_pos_);
}
for (Model *ws : walls_) {
ws->updateModelMatrix();
glUniformMatrix4fv(vert_model_uni_, 1, GL_FALSE, glm::value_ptr(ws->model_matrix_));
glUniformMatrix4fv(norm_model_uni_, 1, GL_FALSE, glm::value_ptr(ws->model_matrix_));
glUniform1i(text_samp_uni_, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, wall_text_);
glDrawElements(GL_TRIANGLES, ws->ebo_count_, GL_UNSIGNED_SHORT, ws->ebo_pos_);
}
for (Projectile *proj : projectiles_) {
proj->updateModelMatrix();
glUniformMatrix4fv(vert_model_uni_, 1, GL_FALSE, glm::value_ptr(proj->model_matrix_));
glUniformMatrix4fv(norm_model_uni_, 1, GL_FALSE, glm::value_ptr(proj->model_matrix_));
glUniform1i(text_samp_uni_, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, wall_text_);
glDrawElements(GL_TRIANGLES, proj->ebo_count_, GL_UNSIGNED_SHORT, proj->ebo_pos_);
}
glDisableVertexAttribArray(position_attr_);
glDisableVertexAttribArray(normal_attr_);
glDisableVertexAttribArray(text_coord_attr_);
glDisableVertexAttribArray(color_attr_);
}
void PVScene::draw(int x, int y, int w, int h) {
static float time = 0.0f;
time += 0.01f;
viewMatrix = lookAtLH(float3(cosf(time) * 5, 2, sinf(time) * 5), float3(0, 0, 0), float3(0, 1, 0));
float4x4 viewProjectionMatrix = projectionMatrix * viewMatrix;
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindVertexArray(vertexArray);
shader->bind();
GLuint viewProjectionLocation = shader->getUniformLocation("viewProjection");
glUniformMatrix4fv(viewProjectionLocation, 1, true, &viewProjectionMatrix.m[0][0]);
GLuint lightColorLocation = shader->getUniformLocation("lightColor");
GLuint lightPositionLocation = shader->getUniformLocation("lightPosition");
GLuint numLightsLocation = shader->getUniformLocation("numLights");
float lightPositions[3 * 4];
float lightColors[3 * 4];
int numLights = lights.size();
if (numLights > 4)
numLights = 4;
for (int i = 0; i < numLights; i++) {
PVLight *light = lights[i];
float3 lightPosition = light->getPosition();
float3 lightColor = light->getColor();
lightPositions[i * 3 + 0] = lightPosition.x;
lightPositions[i * 3 + 1] = lightPosition.y;
lightPositions[i * 3 + 2] = lightPosition.z;
lightColors[i * 3 + 0] = lightColor.x;
lightColors[i * 3 + 1] = lightColor.y;
lightColors[i * 3 + 2] = lightColor.z;
}
glUniform3fv(lightPositionLocation, numLights, lightPositions);
glUniform3fv(lightColorLocation, numLights, lightColors);
glUniform1i(numLightsLocation, numLights);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
glViewport(x, y, w, h);
for (PVMesh *mesh : meshes)
mesh->draw(shader);
glDisable(GL_CULL_FACE);
glActiveTexture(GL_TEXTURE0);
glDisable(GL_DEPTH_TEST);
glUseProgram(0);
glBindVertexArray(0);
GLCHECK();
}
