void createMeshVAO(const Mesh &mesh, cgtk::GLSLProgram &program, MeshVAO *meshVAO)
{
// Create the actual vertex array object (VAO) for the mesh
glGenVertexArrays(1, &(meshVAO->vao));
glBindVertexArray(meshVAO->vao);
// Generate and populate a VBO for the vertices
glGenBuffers(1, &(meshVAO->vertexVBO));
glBindBuffer(GL_ARRAY_BUFFER, meshVAO->vertexVBO);
glBufferData(GL_ARRAY_BUFFER, mesh.vertices.size() * sizeof(mesh.vertices[0]),
mesh.vertices.data(), GL_STATIC_DRAW);
glEnableVertexAttribArray(program.getAttribLocation("a_position"));
glVertexAttribPointer(program.getAttribLocation("a_position"),
3, GL_FLOAT, GL_FALSE, 0, NULL);
// Generate and populate a VBO for the vertex normals
glGenBuffers(1, &(meshVAO->normalVBO));
glBindBuffer(GL_ARRAY_BUFFER, meshVAO->normalVBO);
glBufferData(GL_ARRAY_BUFFER, mesh.normals.size() * sizeof(mesh.normals[0]),
mesh.normals.data(), GL_STATIC_DRAW);
glEnableVertexAttribArray(program.getAttribLocation("a_normal"));
glVertexAttribPointer(program.getAttribLocation("a_normal"),
3, GL_FLOAT, GL_FALSE, 0, NULL);
// Generate and populate a VBO for the element indices
glGenBuffers(1, &(meshVAO->indexVBO));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshVAO->indexVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, mesh.indices.size() * sizeof(mesh.indices[0]),
mesh.indices.data(), GL_STATIC_DRAW);
meshVAO->numIndices = mesh.indices.size();
glBindVertexArray(0); // unbind the VAO
}
// MODIFY THIS FUNCTION
void drawMesh(cgtk::GLSLProgram &program, const MeshVAO &meshVAO)
{
program.enable();
// al=1;
globals.program.setUniform1f("u_al",al);
globals.program.setUniform1f("u_dl",dl);
globals.program.setUniform1f("u_sl",sl);
globals.program.setUniform1f("u_gamma",gam);
globals.program.setUniform1f("u_invert",inv);
// globals.program.setUniform1f("u_zoom",zoom);
// Define the model, view, and projection matrices here
glm::mat4 model = glm::mat4(1.0f);
glm::mat4 view = glm::lookAt(glm::vec3(0.0f,0.0f,6.0f),
glm::vec3(0.0f,1.0f,0.0f),
glm::vec3(0.0f,0.0f,1.0f));
glm::mat4 projection = glm::perspective(zoom*10.5f,1.0f,3.0f,8.0f);
// Construct the ModelViewProjection, ModelView, and normal
// matrices here and pass them as uniform variables to the shader
// program
glm::mat4 MV = view*model;
globals.program.setUniformMatrix4f("u_MV",MV);
glm::mat4 MVP = projection*view*model;
globals.program.setUniformMatrix4f("u_MVP",MVP);
glm::mat4 NM = glm::transpose(glm::inverse(MV));
globals.program.setUniformMatrix4f("u_NM", NM);
// Set up the light source and material properties and pass them
// as uniform variables to the shader program, along with the
// flags (uniform int variables) used for toggling on/off
// different parts of the rendering
glm::vec3 LP(0.0,0.0,8.0);
globals.program.setUniform3f("u_LP", LP);
glm::vec3 LC(1.0,1.0,1.0);
globals.program.setUniform3f("u_LC", LC);
glm::vec3 DC(1.0,1.0,0);
glm::vec3 AC=glm::vec3(1.0,0,1.0);
glm::vec3 SC(0,1.0,1.0);
globals.program.setUniform3f("u_DC", DC);
globals.program.setUniform3f("u_AC", AC);
globals.program.setUniform3f("u_SC", SC);
float SP = 1.0;
// globals.program.setUniform1f("u_SP", SP);
glBindVertexArray(meshVAO.vao);
glDrawElements(GL_TRIANGLES, meshVAO.numIndices, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
program.disable();
}
void drawSkyBox(cgtk::GLSLProgram &program){
glDepthMask(GL_FALSE);
// Bind Skybox and DrawCa
program.enable(); // glUseProgram()
// Pass uniforms /////////////
glm::mat4 model = glm::mat4(1.0f);
glm::mat4 trackMatrix = globals.trackball.getRotationMatrix();
model = trackMatrix;
glm::mat4 view = glm::mat4(1.0f);
glm::mat4 projection = glm::mat4(1.0f);
projection = projection = glm::perspective(globals.zoomFactor*45.0f,
1.0f, 0.1f, 100.0f);
view = glm::lookAt(glm::vec3(0.0f, 0.01f, 5.0f), glm::vec3(0),
glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 MVPmatrix = projection * view * model;
glm::mat4 u_mv = view * model;
program.setUniformMatrix4f("u_projection", glm::mat4(projection));
program.setUniformMatrix4f("u_view", glm::mat4(view));
program.setUniform1i("u_cubemap", globals.cubemap_sky_box);
program.setUniformMatrix4f("u_mvp", glm::mat4(MVPmatrix));
//////////////////////////////
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_sky_box);
glBindVertexArray(globals.skyboxVAO);
//glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0); // not sure about 36
glDrawArrays(GL_TRIANGLES, 0, 108);
glBindVertexArray(0);
program.disable();
glDepthMask(GL_TRUE);
}
// MODIFY THIS FUNCTION
void drawMesh(cgtk::GLSLProgram &program, const MeshVAO &meshVAO)
{
program.enable();
// Define the model, view, and projection matrices here
glm::mat4 model = glm::mat4(1.0f);
glm::mat4 view = glm::mat4(1.0f);
glm::mat4 projection = glm::mat4(1.0f);
// Construct the ModelViewProjection, ModelView, and normal
// matrices here and pass them (along with the model matrix) as
// uniform variables to the shader program
view = glm::lookAt(glm::vec3(0.0f,0.01f,5.0f),glm::vec3(0),glm::vec3(0.0f,1.0f,0.0f));
if(!globals.ortho_switch) {
projection = glm::perspective(globals.zoomFactor*45.0f, 1.0f, 0.1f, 100.0f);
}
else {
projection = glm::ortho(globals.zoomFactor*-5.0, globals.zoomFactor*5.0, globals.zoomFactor*-5.0, globals.zoomFactor*5.0, 0.1, 100.0);
}
glm::mat4 trackMatrix = globals.trackball.getRotationMatrix();
model = trackMatrix;
glm::mat4 MVPmatrix = projection * view * model;
glm::mat4 u_mv = view * model;
globals.program.setUniformMatrix4f("MVPmatrix", glm::mat4(MVPmatrix));
globals.program.setUniformMatrix4f("u_mv", u_mv);
globals.program.setUniform3f("light_position",globals.light_position);
globals.program.setUniform3f("light_color",globals.light_color);
globals.program.setUniform3f("ambient_color",globals.ambient_color);
globals.program.setUniform3f("diffuse_color",globals.diffuse_color);
globals.program.setUniform3f("specular_color",globals.specular_color);
globals.program.setUniform1f("specular_power",420.0);
globals.program.setUniform1i("ambient_switch",globals.ambient_switch);
globals.program.setUniform1i("diffuse_switch",globals.diffuse_switch);
globals.program.setUniform1i("specular_switch",globals.specular_switch);
globals.program.setUniform1i("gamma_swtich",globals.gamma_swtich);
globals.program.setUniform1i("invert_switch",globals.invert_switch);
globals.program.setUniform1i("normals_switch",globals.normals_switch);
// Select the active texture unit and bind the cubemap texture
// Pass the number of the active texture unit as a uniform int
// variable to the shader program
// bind mesh and draw
if (globals.newText != globals.oldText){
switch (globals.newText){
case 8:
glActiveTexture(GL_TEXTURE8);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_7);
globals.program.setUniform1i("u_cubemap", globals.cubemap_7);
break;
case 7:
glActiveTexture(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_6);
globals.program.setUniform1i("u_cubemap", globals.cubemap_6);
break;
case 6:
glActiveTexture(GL_TEXTURE6);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_5);
globals.program.setUniform1i("u_cubemap", globals.cubemap_5);
break;
case 5:
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_4);
globals.program.setUniform1i("u_cubemap", globals.cubemap_4);
break;
case 4:
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_3);
globals.program.setUniform1i("u_cubemap", globals.cubemap_3);
break;
case 3:
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_2);
globals.program.setUniform1i("u_cubemap", globals.cubemap_2);
break;
case 2:
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_1);
globals.program.setUniform1i("u_cubemap", globals.cubemap_1);
break;
/* Using TEXTURE1 for sky box
case 1:
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_0);
globals.program.setUniform1i("u_cubemap", globals.cubemap_0);
break;*/
default:
break;
}
globals.oldText = globals.newText;
}
glBindVertexArray(meshVAO.vao);
glDrawElements(GL_TRIANGLES, meshVAO.numIndices, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
// Background Colour
//glClearColor(globals.bg_color[0],globals.bg_color[1],globals.bg_color[2], 1.0);
program.disable();
/**/
#pragma region Draw sky box in DrawMesh
globals.program_sky_box.enable();
/**/
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, globals.cubemap_sky_box);
globals.program_sky_box.setUniformMatrix4f("u_projection", glm::mat4(projection));
globals.program_sky_box.setUniformMatrix4f("u_view", glm::mat4(view));
globals.program_sky_box.setUniform1i("u_cubemap", globals.cubemap_sky_box);
globals.program_sky_box.setUniformMatrix4f("u_mvp", glm::mat4(MVPmatrix));
glBindVertexArray(globals.skyboxVAO);
//glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0);
glDrawArrays(GL_TRIANGLES, 0, 108);
glBindVertexArray(0);
globals.program_sky_box.disable();
#pragma endregion
}
// MODIFY THIS FUNCTION
void drawMesh(cgtk::GLSLProgram &program, const MeshVAO &meshVAO)
{
glm::mat4 model = globals.trackball.getRotationMatrix() * glm::mat4(1.0f);
glm::mat4 view = glm::lookAt(glm::vec3(0.0f, 0.0f, 1.5f), glm::vec3(0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 projection = glm::perspective(90.0f+globals.zoomfactor, (float) globals.width/globals.height, 0.1f, 100.0f);
glm::mat4 mvp = projection * view * model;
glm::mat4 mv = view * model;
program.enable();
program.setUniformMatrix4f("mvp", mvp);
program.setUniformMatrix4f("view", view);
program.setUniformMatrix4f("model", model);
program.setUniform3f("lightDir", globals.lightDir);
program.setUniform3f("eye_position", glm::vec3(0.0f, 0.0f, 1.5f));
program.setUniform1f("material_kd", globals.material_kd);
program.setUniform1f("outline_intensity", globals.outline_intensity);
program.setUniform3f("diffuseColor", globals.diffuseColor);
program.setUniform3f("ambientColor", globals.ambientColor);
program.setUniform3f("outlineColor", globals.outlineColor);
program.setUniform1i("colorlvl", globals.colorlvl);
glBindVertexArray(meshVAO.vao);
glDrawElements(GL_TRIANGLES, meshVAO.numIndices, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
program.disable();
}