void GLCanvas::drawVBOs(const glm::mat4 &ProjectionMatrix,const glm::mat4 &ViewMatrix,const glm::mat4 &ModelMatrix){
HandleGLError("enter GlCanvas::drawVBOs()");
if (!args->intersect_backfacing) {
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
} else {
glDisable(GL_CULL_FACE);
}
// prepare data to send to the shaders
glm::mat4 MVP = ProjectionMatrix * ViewMatrix * ModelMatrix;
glm::vec3 lightPos = glm::vec3(4,4,4);
glUniform3f(GLCanvas::LightID, lightPos.x, lightPos.y, lightPos.z);
glUniformMatrix4fv(GLCanvas::MatrixID, 1, GL_FALSE, &MVP[0][0]);
glUniformMatrix4fv(GLCanvas::ModelMatrixID, 1, GL_FALSE, &ModelMatrix[0][0]);
glUniformMatrix4fv(GLCanvas::ViewMatrixID, 1, GL_FALSE, &ViewMatrix[0][0]);
glUniform1i(GLCanvas::wireframeID, args->wireframe);
glUniform1i(GLCanvas::colormodeID, 0);
glUniform1i(GLCanvas::mytexture, /*GL_TEXTURE*/0);
radiosity->drawVBOs();
photon_mapping->drawVBOs();
RayTree::drawVBOs();
if (args->intersect_backfacing) {
glDisable(GL_CULL_FACE);
}
raytracer->drawVBOs();
if (args->intersect_backfacing) {
glEnable(GL_CULL_FACE);
}
HandleGLError("leaving GlCanvas::drawVBOs()");
}
void BoundingBox::setupVBOs() {
HandleGLError("bounding box setup VBOs enter");
float thickness = 0.001*glm::length(maximum-minimum);
glm::vec3& A = minimum;
glm::vec3& B = maximum;
glm::vec4 black(0,0,0,1);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(A.x,A.y,A.z),glm::vec3(A.x,A.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(A.x,A.y,B.z),glm::vec3(A.x,B.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(A.x,B.y,B.z),glm::vec3(A.x,B.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(A.x,B.y,A.z),glm::vec3(A.x,A.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(B.x,A.y,A.z),glm::vec3(B.x,A.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(B.x,A.y,B.z),glm::vec3(B.x,B.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(B.x,B.y,B.z),glm::vec3(B.x,B.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(B.x,B.y,A.z),glm::vec3(B.x,A.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(A.x,A.y,A.z),glm::vec3(B.x,A.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(A.x,A.y,B.z),glm::vec3(B.x,A.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(A.x,B.y,B.z),glm::vec3(B.x,B.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(bb_verts,bb_tri_indices,glm::vec3(A.x,B.y,A.z),glm::vec3(B.x,B.y,A.z),black,black,thickness,thickness);
glBindBuffer(GL_ARRAY_BUFFER,bb_verts_VBO);
glBufferData(GL_ARRAY_BUFFER,sizeof(VBOPosNormalColor)*bb_verts.size(),&bb_verts[0],GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,bb_tri_indices_VBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(VBOIndexedTri)*bb_tri_indices.size(),&bb_tri_indices[0],GL_STATIC_DRAW);
HandleGLError("bounding box setup VBOs finished");
}
void GLCanvas::initialize(ArgParser *_args, Mesh *_mesh,
RayTracer *_raytracer, Radiosity *_radiosity, PhotonMapping *_photon_mapping) {
args = _args;
mesh = _mesh;
raytracer = _raytracer;
radiosity = _radiosity;
photon_mapping = _photon_mapping;
// setup glut stuff
glutInitWindowSize(args->width, args->height);
glutInitWindowPosition(100,100);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGB);
glutCreateWindow("OpenGL Viewer");
HandleGLError("in glcanvas initialize");
#ifdef _WIN32
GLenum err = glewInit();
if (err != GLEW_OK) {
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
exit(1);
}
#endif
// basic rendering
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glShadeModel(GL_SMOOTH);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
glCullFace(GL_BACK);
glDisable(GL_CULL_FACE);
// Initialize callback functions
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(idle);
HandleGLError("finished glcanvas initialize");
RayTree::initializeVBOs();
if (radiosity) radiosity->initializeVBOs();
if (photon_mapping) photon_mapping->initializeVBOs();
RayTree::setupVBOs();
if (radiosity) radiosity->setupVBOs();
if (photon_mapping) photon_mapping->setupVBOs();
HandleGLError("finished glcanvas initialize");
// Enter the main rendering loop
glutMainLoop();
}
void PhotonMapping::initializeVBOs() {
HandleGLError("enter photonmapping initializevbos()");
glGenBuffers(1, &photon_direction_verts_VBO);
glGenBuffers(1, &photon_direction_indices_VBO);
glGenBuffers(1, &kdtree_verts_VBO);
glGenBuffers(1, &kdtree_edge_indices_VBO);
HandleGLError("leave photonmapping initializevbos()");
}
void GLCanvas::setupVBOs(){
HandleGLError("enter GLCanvas::setupVBOs()");
bbox.Set(*mesh->getBoundingBox());
bbox.setupVBOs();
radiosity->setupVBOs();
photon_mapping->setupVBOs();
HandleGLError("leaving GLCanvas::setupVBOs()");
}
void GLCanvas::InitShaders() {
std::cout << "initialize shaders" << std::endl;
CheckForGLSL();
program = glCreateProgramObjectARB();
vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
HandleGLError("Failed to create program or shader objects");
glAttachObjectARB(program,vertex_shader);
glAttachObjectARB(program,fragment_shader);
HandleGLError("Failed to attach shaders to program");
}
//Draws the buffers
void BoundingBox::drawVBOs(){
HandleGLError("draw VBOs a ");
glBindBuffer(GL_ARRAY_BUFFER,bb_verts_VBO);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3,GL_FLOAT,sizeof(VBOPos),BUFFER_OFFSET(0));
glLineWidth(1);
glColor3f(0,0,0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,bb_edge_indices_VBO);
HandleGLError("draw VBOS b ");
glDrawElements(GL_LINES, 24, GL_UNSIGNED_INT,0);
HandleGLError("draw VBOs c ");
glDisableClientState(GL_VERTEX_ARRAY);
}
void GLCanvas::display(void) {
glDrawBuffer(GL_BACK);
Vec3f bg = mesh->background_color;
// Clear the display buffer, set it to the background color
glClearColor(bg.r(),bg.g(),bg.b(),0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Set the camera parameters
mesh->camera->glInit(args->width, args->height);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
mesh->camera->glPlaceCamera();
InitLight(); // light will be a headlamp!
if (args->intersect_backfacing)
glDisable(GL_CULL_FACE);
else
glEnable(GL_CULL_FACE);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
// glCallList(display_list_index);
HandleGLError();
radiosity->drawVBOs();
photon_mapping->drawVBOs();
RayTree::drawVBOs();
// Swap the back buffer with the front buffer to display
// the scene
glutSwapBuffers();
}
void PhotonMapping::drawVBOs() {
HandleGLError("enter photonmapping drawvbos()");
glUniform1i(GLCanvas::colormodeID, 1);
if (args->render_photons && photon_direction_verts.size() > 0) {
glBindBuffer(GL_ARRAY_BUFFER,photon_direction_verts_VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,photon_direction_indices_VBO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)sizeof(glm::vec3) );
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2));
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2 + sizeof(glm::vec4)));
glDrawElements(GL_TRIANGLES,
photon_direction_indices.size()*3,
GL_UNSIGNED_INT, 0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
}
if (args->render_kdtree && kdtree_edge_indices.size() > 0) {
glBindBuffer(GL_ARRAY_BUFFER,kdtree_verts_VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,kdtree_edge_indices_VBO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)sizeof(glm::vec3) );
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2));
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2 + sizeof(glm::vec4)));
glDrawElements(GL_TRIANGLES,
kdtree_edge_indices.size()*3,
GL_UNSIGNED_INT, 0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
}
HandleGLError("leave photonmapping drawvbos()");
}
void CompileProgram(GLcharARB* sourcecode, GLhandleARB *shader) {
GLint logLength;
GLint compiled;
glShaderSourceARB(*shader,1,(const GLcharARB **)&sourcecode,0);
HandleGLError("Failed glShaderSourceARB");
glCompileShaderARB(*shader);
HandleGLError("Failed glCompileShaderARB");
glGetObjectParameterivARB(*shader,GL_OBJECT_COMPILE_STATUS_ARB,&compiled);
glGetObjectParameterivARB(*shader,GL_OBJECT_INFO_LOG_LENGTH_ARB,&logLength);
if (logLength) {
GLcharARB *log = (GLcharARB *)malloc(logLength+128);
glGetInfoLogARB(*shader, logLength, &logLength, log);
printf("Compile log: \n");
free (log);
}
if (!compiled) {
std::cout << "shader could not compile" << std::endl;
exit(0);
}
}
GLuint GLCanvas::LoadCompileLinkShaders() {
std::cout << "load, compile, & link shaders" << std::endl;
std::string v_string = ReadFile("shadows.vs");
char *v = (char*) v_string.c_str();
std::string f_string = ReadFile("shadows.fs");
char *f = (char*) f_string.c_str();
CompileProgram(v, &vertex_shader);
CompileProgram(f, &fragment_shader);
LinkProgram(program);
HandleGLError("Failed to compile or link shaders");
return glGetUniformLocationARB(program,"ShadowMap");
}
inline GLint GetGLUniformLocation(GLProgram program, const char *name)
{
glGetError();
GLint uniform = glGetUniformLocation(program.id, name);
GLenum error = glGetError();
if (error) {
log::ErrorLog("Error getting uniform %s from program %d\n", name,
program.id);
HandleGLError(error);
}
return uniform;
}
void GLCanvas::initializeVBOs(){
HandleGLError("enter initilizeVBOs()");
glGenVertexArrays(1, &render_VAO);
glBindVertexArray(render_VAO);
GLCanvas::MatrixID = glGetUniformLocation(GLCanvas::programID, "MVP");
GLCanvas::LightID = glGetUniformLocation(GLCanvas::programID, "LightPosition_worldspace");
GLCanvas::ViewMatrixID = glGetUniformLocation(GLCanvas::programID, "V");
GLCanvas::ModelMatrixID = glGetUniformLocation(GLCanvas::programID, "M");
GLCanvas::wireframeID = glGetUniformLocation(GLCanvas::programID, "wireframe");
GLCanvas::colormodeID = glGetUniformLocation(GLCanvas::programID, "colormode");
// FIXME: texture still buggy
GLCanvas::mytexture = glGetUniformLocation(GLCanvas::programID, "mytexture");
bbox.initializeVBOs();
RayTree::initializeVBOs();
radiosity->initializeVBOs();
raytracer->initializeVBOs();
photon_mapping->initializeVBOs();
HandleGLError("leaving initilizeVBOs()");
}
void BoundingBox::drawVBOs() {
HandleGLError("draw VBOs a ");
glBindBuffer(GL_ARRAY_BUFFER, bb_verts_VBO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)sizeof(glm::vec3) );
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bb_tri_indices_VBO);
glDrawElements(GL_TRIANGLES,
bb_tri_indices.size()*3,
GL_UNSIGNED_INT, 0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
}
void LinkProgram(GLhandleARB program) {
GLint logLength;
GLint linked;
glLinkProgramARB(program);
HandleGLError("Failed glLinkProgramARB");
glGetObjectParameterivARB(program,GL_OBJECT_LINK_STATUS_ARB,&linked);
glGetObjectParameterivARB(program,GL_OBJECT_INFO_LOG_LENGTH_ARB,&logLength);
if (logLength) {
GLint charsWritten;
GLcharARB *log = (GLcharARB*)malloc(logLength+128);
glGetInfoLogARB(program, logLength, &charsWritten, log);
printf("Link GetInfoLogARB:\n%s\n",log);
free (log);
}
if (!linked) {
std::cout << "shader did not link" << std::endl;
exit(0);
}
}
//binds data to VBO buffers
void BoundingBox::setupVBOs(){
HandleGLError("setup VBOs a ");
VBOPos bb_verts[8];
VBOIndexedEdge bb_edges[12];
bb_verts[0] = VBOPos(Vec(minimum.x(),minimum.y(),minimum.z()));
bb_verts[1] = VBOPos(Vec(minimum.x(),minimum.y(),maximum.z()));
bb_verts[2] = VBOPos(Vec(minimum.x(),maximum.y(),minimum.z()));
bb_verts[3] = VBOPos(Vec(minimum.x(),maximum.y(),maximum.z()));
bb_verts[4] = VBOPos(Vec(maximum.x(),minimum.y(),minimum.z()));
bb_verts[5] = VBOPos(Vec(maximum.x(),minimum.y(),maximum.z()));
bb_verts[6] = VBOPos(Vec(maximum.x(),maximum.y(),minimum.z()));
bb_verts[7] = VBOPos(Vec(maximum.x(),maximum.y(),maximum.z()));
bb_edges[ 0] = VBOIndexedEdge(0,1);
bb_edges[ 1] = VBOIndexedEdge(1,3);
bb_edges[ 2] = VBOIndexedEdge(3,2);
bb_edges[ 3] = VBOIndexedEdge(2,0);
bb_edges[ 4] = VBOIndexedEdge(0,4);
bb_edges[ 5] = VBOIndexedEdge(1,5);
bb_edges[ 6] = VBOIndexedEdge(2,6);
bb_edges[ 7] = VBOIndexedEdge(3,7);
bb_edges[ 8] = VBOIndexedEdge(4,5);
bb_edges[ 9] = VBOIndexedEdge(5,7);
bb_edges[10] = VBOIndexedEdge(7,6);
bb_edges[11] = VBOIndexedEdge(6,4);
HandleGLError("setup VBOs b ");
glBindBuffer(GL_ARRAY_BUFFER,bb_verts_VBO);
HandleGLError("setup VBOs c ");
glBufferData(GL_ARRAY_BUFFER,sizeof(VBOPos)*8,bb_verts,GL_STATIC_DRAW);
HandleGLError("setup VBOs d ");
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,bb_edge_indices_VBO);
HandleGLError("setup VBOs e ");
glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(VBOIndexedEdge)*12,bb_edges,GL_STATIC_DRAW);
HandleGLError("setup VBOs bf ");
}
void Mesh::drawVBOs() {
// scale it so it fits in the window
Vec3f center; bbox.getCenter(center);
float s = 1/bbox.maxDim();
glScalef(s,s,s);
glTranslatef(-center.x(),-center.y(),-center.z());
// setup the light
Vec3f light_position = LightPosition();
GLfloat position[4] = { float(light_position.x()),float(light_position.y()),float(light_position.z()),1 };
glLightfv(GL_LIGHT1, GL_POSITION, position);
// --------------------------
// Render Mesh
InsertColor(mesh_color);
glEnable(GL_TEXTURE_2D);
if (args->glsl_enabled) {
glUseProgramObjectARB(GLCanvas::program);
glActiveTexture(GL_TEXTURE0);
// Height Map
glActiveTexture(GL_TEXTURE0);
GLint mapLoc = glGetUniformLocationARB(GLCanvas::program, "terrainMap");
glBindTexture(GL_TEXTURE_2D, texture[0]);
glUniform1iARB(mapLoc, 0);
// Normal Map
glActiveTexture(GL_TEXTURE1);
GLint normLoc = glGetUniformLocationARB(GLCanvas::program, "normalMap");
glBindTexture(GL_TEXTURE_2D, texture[1]);
glUniform1iARB(normLoc, 1);
// Stone Texture
glActiveTexture(GL_TEXTURE2);
GLint stoneLoc = glGetUniformLocationARB(GLCanvas::program, "texStone");
glBindTexture(GL_TEXTURE_2D, texture[2]);
glUniform1iARB(stoneLoc, 2);
// Grass Texture
glActiveTexture(GL_TEXTURE3);
GLint grassLoc = glGetUniformLocationARB(GLCanvas::program, "texGrass");
glBindTexture(GL_TEXTURE_2D, texture[3]);
glUniform1iARB(grassLoc, 3);
// Snow Texture
glActiveTexture(GL_TEXTURE4);
GLint snowLoc = glGetUniformLocationARB(GLCanvas::program, "texSnow");
glBindTexture(GL_TEXTURE_2D, texture[4]);
glUniform1iARB(snowLoc, 4);
glActiveTexture(GL_TEXTURE0);
}
else {
glBindTexture(GL_TEXTURE_2D, texture[0]);
}
DrawMesh();
if (args->glsl_enabled) {
glUseProgramObjectARB(0);
}
glDisable(GL_TEXTURE_2D);
DrawPlateVisualization();
// -------------------------
// Render Light (for debugging)
glColor3f(1,1,0);
DrawLight();
HandleGLError();
}
void PhotonMapping::setupVBOs() {
HandleGLError("enter photonmapping setupvbos()");
photon_direction_verts.clear();
photon_direction_indices.clear();
kdtree_verts.clear();
kdtree_edge_indices.clear();
// initialize the data
BoundingBox *bb = mesh->getBoundingBox();
float max_dim = bb->maxDim();
if (kdtree == NULL) return;
std::vector<const KDTree*> todo;
todo.push_back(kdtree);
while (!todo.empty()) {
const KDTree *node = todo.back();
todo.pop_back();
if (node->isLeaf()) {
// initialize photon direction vbo
const std::vector<Photon> &photons = node->getPhotons();
int num_photons = photons.size();
for (int i = 0; i < num_photons; i++) {
const Photon &p = photons[i];
glm::vec3 energy = p.getEnergy()*float(args->num_photons_to_shoot);
glm::vec4 color(energy.x,energy.y,energy.z,1);
const glm::vec3 &position = p.getPosition();
glm::vec3 other = position - p.getDirectionFrom()*0.02f*max_dim;
addEdgeGeometry(photon_direction_verts,photon_direction_indices,
position,other,color,color,max_dim*0.0005f,0);
}
// initialize kdtree vbo
float thickness = 0.001*max_dim;
glm::vec3 A = node->getMin();
glm::vec3 B = node->getMax();
glm::vec4 black(1,0,0,1);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(A.x,A.y,A.z),glm::vec3(A.x,A.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(A.x,A.y,B.z),glm::vec3(A.x,B.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(A.x,B.y,B.z),glm::vec3(A.x,B.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(A.x,B.y,A.z),glm::vec3(A.x,A.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(B.x,A.y,A.z),glm::vec3(B.x,A.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(B.x,A.y,B.z),glm::vec3(B.x,B.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(B.x,B.y,B.z),glm::vec3(B.x,B.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(B.x,B.y,A.z),glm::vec3(B.x,A.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(A.x,A.y,A.z),glm::vec3(B.x,A.y,A.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(A.x,A.y,B.z),glm::vec3(B.x,A.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(A.x,B.y,B.z),glm::vec3(B.x,B.y,B.z),black,black,thickness,thickness);
addEdgeGeometry(kdtree_verts,kdtree_edge_indices,glm::vec3(A.x,B.y,A.z),glm::vec3(B.x,B.y,A.z),black,black,thickness,thickness);
} else {
todo.push_back(node->getChild1());
todo.push_back(node->getChild2());
}
}
// copy the data to each VBO
if (photon_direction_verts.size() > 0) {
glBindBuffer(GL_ARRAY_BUFFER,photon_direction_verts_VBO);
glBufferData(GL_ARRAY_BUFFER,
sizeof(VBOPosNormalColor) * photon_direction_verts.size(),
&photon_direction_verts[0],
GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,photon_direction_indices_VBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
sizeof(VBOIndexedTri) * photon_direction_indices.size(),
&photon_direction_indices[0], GL_STATIC_DRAW);
}
if (kdtree_verts.size() > 0) {
glBindBuffer(GL_ARRAY_BUFFER,kdtree_verts_VBO);
glBufferData(GL_ARRAY_BUFFER,
sizeof(VBOPosNormalColor) * kdtree_verts.size(),
&kdtree_verts[0],
GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,kdtree_edge_indices_VBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
sizeof(VBOIndexedTri) * kdtree_edge_indices.size(),
&kdtree_edge_indices[0], GL_STATIC_DRAW);
}
HandleGLError("leave photonmapping setupvbos()");
}
void Mesh::drawVBOs() {
// scale it so it fits in the window
Vec3f center; bbox.getCenter(center);
float s = 1/bbox.maxDim();
glScalef(s,s,s);
glTranslatef(-center.x(),-center.y(),-center.z());
// setup the light
Vec3f light_position = LightPosition();
GLfloat position[4] = { float(light_position.x()),float(light_position.y()),float(light_position.z()),1 };
glLightfv(GL_LIGHT1, GL_POSITION, position);
if (args->glsl_enabled) {
glEnable(GL_DEPTH_TEST);
glClearColor(0,0,0,1.0f);
glEnable(GL_CULL_FACE);
//glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
//BEGIN SHADOW FUN/////////////===================================
//First step: Render from the light POV to a FBO, story depth values only
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fboId); //Rendering offscreen
//Using the fixed pipeline to render to the depthbuffer
glUseProgramObjectARB(0);
// In the case we render the shadowmap to a higher resolution, the viewport must be modified accordingly.
glViewport(0,0,args->width * SHADOW_MAP_RATIO,args->height* SHADOW_MAP_RATIO);
// Clear previous frame values
glClear(GL_DEPTH_BUFFER_BIT);
//Disable color rendering, we only want to write to the Z-Buffer
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
//LIGHT POSITION==========================================================================================
setupMatrices(float(light_position.x()),float(light_position.y()),float(light_position.z()),
10,10,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,args->width/args->height,1.0f,1000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt((float)light_position.x(),(float)light_position.y(),(float)light_position.z(),0,0,0,0,1,0);
// Culling switching, rendering only backface, this is done to avoid self-shadowing
glCullFace(GL_FRONT);
//===========Draw the Things===================================================================================
InsertColor(floor_color);
DrawFloor();
//startTranslate(0,0,0);
//glutSolidCube(1);
InsertColor(mesh_color);
glUseProgramObjectARB(GLCanvas::program);
glColor3b(GLbyte(240-127), GLbyte(184-127), GLbyte(0-127));
DrawMesh(table, board_tri_verts_VBO);
DrawPieces(editBoard());
//endTranslate();
glUseProgramObjectARB(0);
//=============================================================================================================
//Save modelview/projection matrice into texture7, also add a biais
setTextureMatrix();
// Now rendering from the camera POV, using the FBO to generate shadows
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
glViewport(0,0,args->width,args->height);
//Enabling color write (previously disabled for light POV z-buffer rendering)
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Clear previous frame values
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Using the shadow shader
glUseProgramObjectARB(GLCanvas::program);
glUniform1iARB(shadowMapUniform,7);
glActiveTextureARB(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D,depthTextureId);
Vec3f cam_position = camera->camera_position;
Vec3f interest = camera->point_of_interest;
//CAMERA MATRIX=======================================================================================================
//setupMatrices(cam_pos[0],cam_pos[1],cam_pos[2],interest[0],interest[1],interest[2]);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,args->width/args->height,1.0f,1000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt((float)cam_position.x(),(float)cam_position.y(),(float)cam_position.z(),(float)interest.x(),(float)interest.y(),(float)interest.z(),0,1,0);
glCullFace(GL_BACK);
//============================Draw the things
InsertColor(floor_color);
DrawFloor();
//startTranslate(0,0,0);
//glutSolidCube(1);
InsertColor(mesh_color);
glUseProgramObjectARB(GLCanvas::program);
glColor3b(GLbyte(240-127), GLbyte(184-127), GLbyte(0-127));
DrawMesh(table, board_tri_verts_VBO);
DrawPieces(editBoard());
//endTranslate();
glUseProgramObjectARB(0);
//============================All the things
// DEBUG only. this piece of code draw the depth buffer onscreen
//*
glUseProgramObjectARB(0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-args->width/2,args->width/2,-args->height/2,args->height/2,1,20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4f(1,1,1,1);
glActiveTextureARB(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,depthTextureId);
glEnable(GL_TEXTURE_2D);
glTranslated(0,0,-1);
glBegin(GL_QUADS);
glTexCoord2d(0,0);glVertex3f(0,0,0);
glTexCoord2d(1,0);glVertex3f(args->width/2,0,0);
glTexCoord2d(1,1);glVertex3f(args->width/2,args->width/2,0);
glTexCoord2d(0,1);glVertex3f(0,args->height/2,0);
glEnd();
glDisable(GL_TEXTURE_2D);
//*/
//glutSwapBuffers();
glDisable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDepthMask(1);
//END SHADOW FUN//////////////////////////////////////////////////
}
else
{
InsertColor(floor_color);
DrawFloor();
InsertColor(mesh_color);
glColor3b(GLbyte(240-127), GLbyte(184-127), GLbyte(0-127));
DrawMesh(table, board_tri_verts_VBO);
if(args->board_control)
{
DrawControlMap();
}
DrawPieces(editBoard());
}
// -------------------------
// ADDITIONAL VISUALIZATIONS (for debugging)
glColor3f(1,1,0);
//DrawLight();
if (args->bounding_box) {
glColor3f(0,0,0);
bbox.drawVBOs();
}
HandleGLError();
}
void Fluid::setupVBOs() {
HandleGLError("in setup fluid VBOs");
fluid_particles.clear();
fluid_velocity_vis.clear();
fluid_face_velocity_vis.clear();
fluid_pressure_vis.clear();
fluid_cell_type_vis.clear();
// =====================================================================================
// setup the particles
// =====================================================================================
for (int x = 0; x < nx; x++) {
for (int y = 0; y < ny; y++) {
for (int z = 0; z < nz; z++) {
Cell *cell = getCell(x,y,z);
std::vector<FluidParticle*> &particles = cell->getParticles();
for (unsigned int iter = 0; iter < particles.size(); iter++) {
FluidParticle *p = particles[iter];
Vec3f v = p->getPosition();
fluid_particles.push_back(VBOPos(v));
}
}
}
}
// =====================================================================================
// visualize the velocity
// =====================================================================================
if (args->dense_velocity == 0) {
// one velocity vector per cell, at the centroid
for (int i = 0; i < nx; i++) {
for (int j = 0; j < ny; j++) {
for (int k = 0; k < nz; k++) {
Vec3f cell_center((i+0.5)*dx,(j+0.5)*dy,(k+0.5)*dz);
Vec3f direction(get_u_avg(i,j,k),get_v_avg(i,j,k),get_w_avg(i,j,k));
Vec3f pt2 = cell_center+100*args->timestep*direction;
fluid_velocity_vis.push_back(VBOPosColor(cell_center,Vec3f(1,0,0)));
fluid_velocity_vis.push_back(VBOPosColor(pt2,Vec3f(1,1,1)));
}
}
}
} else if (args->dense_velocity == 1) {
double z = nz*dz / 2.0;
for (double x = 0; x <= (nx+0.01)*dx; x+=0.25*dx) {
for (double y = 0; y <= (ny+0.01)*dy; y+=0.25*dy) {
Vec3f vel = getInterpolatedVelocity(Vec3f(x,y,z));
Vec3f pt1(x,y,z);
Vec3f pt2 = pt1 + 100*args->timestep*vel;
fluid_velocity_vis.push_back(VBOPosColor(pt1,Vec3f(1,0,0)));
fluid_velocity_vis.push_back(VBOPosColor(pt2,Vec3f(1,1,1)));
}
}
} else if (args->dense_velocity == 2) {
double y = ny*dy / 2.0;
for (double x = 0; x <= (nx+0.01)*dx; x+=0.25*dx) {
for (double z = 0; z <= (nz+0.01)*dz; z+=0.25*dz) {
Vec3f vel = getInterpolatedVelocity(Vec3f(x,y,z));
Vec3f pt1(x,y,z);
Vec3f pt2 = pt1 + 100*args->timestep*vel;
fluid_velocity_vis.push_back(VBOPosColor(pt1,Vec3f(1,0,0)));
fluid_velocity_vis.push_back(VBOPosColor(pt2,Vec3f(1,1,1)));
}
}
} else if (args->dense_velocity == 3) {
double x = nx*dx / 2.0;
for (double y = 0; y <= (ny+0.01)*dy; y+=0.25*dy) {
for (double z = 0; z <= (nz+0.01)*dz; z+=0.25*dz) {
Vec3f vel = getInterpolatedVelocity(Vec3f(x,y,z));
Vec3f pt1(x,y,z);
Vec3f pt2 = pt1 + 100*args->timestep*vel;
fluid_velocity_vis.push_back(VBOPosColor(pt1,Vec3f(1,0,0)));
fluid_velocity_vis.push_back(VBOPosColor(pt2,Vec3f(1,1,1)));
}
}
}
// =====================================================================================
// visualize the face velocity
// render stubby triangles to visualize the u, v, and w velocities between cell faces
// =====================================================================================
for (int i = 0; i < nx; i++) {
for (int j = 0; j < ny; j++) {
for (int k = 0; k < nz; k++) {
double dt = args->timestep;
double u = get_u_plus(i,j,k)*100*dt;
double v = get_v_plus(i,j,k)*100*dt;
double w = get_w_plus(i,j,k)*100*dt;
double x = i*dx;
double y = j*dy;
double z = k*dz;
if (u < -10*dt) {
Vec3f pts[5] = { Vec3f(x+dx+u,y+0.5*dy,z+0.5*dz),
Vec3f(x+dx,y+0.55*dy,z+0.55*dz),
Vec3f(x+dx,y+0.55*dy,z+0.45*dz),
Vec3f(x+dx,y+0.45*dy,z+0.45*dz),
Vec3f(x+dx,y+0.45*dy,z+0.55*dz) };
setupConeVBO(pts,Vec3f(1,0,0),fluid_face_velocity_vis);
} else if (u > 10*dt) {
Vec3f pts[5] = { Vec3f(x+dx+u,y+0.5*dy,z+0.5*dz),
Vec3f(x+dx,y+0.45*dy,z+0.45*dz),
Vec3f(x+dx,y+0.55*dy,z+0.45*dz),
Vec3f(x+dx,y+0.55*dy,z+0.55*dz),
Vec3f(x+dx,y+0.45*dy,z+0.55*dz) };
setupConeVBO(pts,Vec3f(1,0,0),fluid_face_velocity_vis);
}
if (v < -10*dt) {
Vec3f pts[5] = { Vec3f(x+0.5*dx,y+dy+v,z+0.5*dz),
Vec3f(x+0.45*dx,y+dy,z+0.45*dz),
Vec3f(x+0.55*dx,y+dy,z+0.45*dz),
Vec3f(x+0.55*dx,y+dy,z+0.55*dz),
Vec3f(x+0.45*dx,y+dy,z+0.55*dz) };
setupConeVBO(pts,Vec3f(0,1,0),fluid_face_velocity_vis);
} else if (v > 10*dt) {
Vec3f pts[5] = { Vec3f(x+0.5*dx,y+dy+v,z+0.5*dz),
Vec3f(x+0.55*dx,y+dy,z+0.55*dz),
Vec3f(x+0.55*dx,y+dy,z+0.45*dz),
Vec3f(x+0.45*dx,y+dy,z+0.45*dz),
Vec3f(x+0.45*dx,y+dy,z+0.55*dz) };
setupConeVBO(pts,Vec3f(0,1,0),fluid_face_velocity_vis);
}
if (w < -10*dt) {
Vec3f pts[5] = { Vec3f(x+0.5*dx,y+0.5*dy,z+dz+w),
Vec3f(x+0.55*dx,y+0.55*dy,z+dz),
Vec3f(x+0.55*dx,y+0.45*dy,z+dz),
Vec3f(x+0.45*dx,y+0.45*dy,z+dz),
Vec3f(x+0.45*dx,y+0.55*dy,z+dz) };
setupConeVBO(pts,Vec3f(0,0,1),fluid_face_velocity_vis);
} else if (w > 10*dt) {
Vec3f pts[5] = { Vec3f(x+0.5*dx,y+0.5*dy,z+dz+w),
Vec3f(x+0.45*dx,y+0.45*dy,z+dz),
Vec3f(x+0.55*dx,y+0.45*dy,z+dz),
Vec3f(x+0.55*dx,y+0.55*dy,z+dz),
Vec3f(x+0.45*dx,y+0.55*dy,z+dz) };
setupConeVBO(pts,Vec3f(0,0,1),fluid_face_velocity_vis);
}
}
}
}
// =====================================================================================
// visualize the cell pressure
// =====================================================================================
for (int i = 0; i < nx; i++) {
for (int j = 0; j < ny; j++) {
for (int k = 0; k < nz; k++) {
Vec3f pts[8] = { Vec3f((i+0.1)*dx,(j+0.1)*dy,(k+0.1)*dz),
Vec3f((i+0.1)*dx,(j+0.1)*dy,(k+0.9)*dz),
Vec3f((i+0.1)*dx,(j+0.9)*dy,(k+0.1)*dz),
Vec3f((i+0.1)*dx,(j+0.9)*dy,(k+0.9)*dz),
Vec3f((i+0.9)*dx,(j+0.1)*dy,(k+0.1)*dz),
Vec3f((i+0.9)*dx,(j+0.1)*dy,(k+0.9)*dz),
Vec3f((i+0.9)*dx,(j+0.9)*dy,(k+0.1)*dz),
Vec3f((i+0.9)*dx,(j+0.9)*dy,(k+0.9)*dz) };
double p = getCell(i,j,k)->getPressure();
p *= 0.1;
if (p > 1) p = 1;
if (p < -1) p = -1;
assert(p >= -1 && p <= 1);
Vec3f color;
if (p < 0) {
color = Vec3f(1+p,1+p,1);
} else {
color = Vec3f(1,1-p,1-p);
}
setupCubeVBO(pts,color,fluid_pressure_vis);
}
}
}
// =====================================================================================
// render the MAC cells (FULL, SURFACE, or EMPTY)
// =====================================================================================
for (int i = 0; i < nx; i++) {
for (int j = 0; j < ny; j++) {
for (int k = 0; k < nz; k++) {
Vec3f pts[8] = { Vec3f((i+0.1)*dx,(j+0.1)*dy,(k+0.1)*dz),
Vec3f((i+0.1)*dx,(j+0.1)*dy,(k+0.9)*dz),
Vec3f((i+0.1)*dx,(j+0.9)*dy,(k+0.1)*dz),
Vec3f((i+0.1)*dx,(j+0.9)*dy,(k+0.9)*dz),
Vec3f((i+0.9)*dx,(j+0.1)*dy,(k+0.1)*dz),
Vec3f((i+0.9)*dx,(j+0.1)*dy,(k+0.9)*dz),
Vec3f((i+0.9)*dx,(j+0.9)*dy,(k+0.1)*dz),
Vec3f((i+0.9)*dx,(j+0.9)*dy,(k+0.9)*dz) };
Cell *cell = getCell(i,j,k);
Vec3f color;
if (cell->getStatus() == CELL_FULL) {
color = Vec3f(1,0,0);
} else if (cell->getStatus() == CELL_SURFACE) {
color=Vec3f(0,0,1);
} else {
continue;
}
setupCubeVBO(pts,color,fluid_cell_type_vis);
}
}
}
// cleanup old buffer data (if any)
cleanupVBOs();
// copy the data to each VBO
glBindBuffer(GL_ARRAY_BUFFER,fluid_particles_VBO);
glBufferData(GL_ARRAY_BUFFER,sizeof(VBOPos)*fluid_particles.size(),&fluid_particles[0],GL_STATIC_DRAW);
if (fluid_velocity_vis.size() > 0) {
glBindBuffer(GL_ARRAY_BUFFER,fluid_velocity_vis_VBO);
glBufferData(GL_ARRAY_BUFFER,sizeof(VBOPosColor)*fluid_velocity_vis.size(),&fluid_velocity_vis[0],GL_STATIC_DRAW);
}
if (fluid_face_velocity_vis.size() > 0) {
glBindBuffer(GL_ARRAY_BUFFER,fluid_face_velocity_vis_VBO);
glBufferData(GL_ARRAY_BUFFER,sizeof(VBOPosNormalColor)*fluid_face_velocity_vis.size(),&fluid_face_velocity_vis[0],GL_STATIC_DRAW);
}
glBindBuffer(GL_ARRAY_BUFFER,fluid_pressure_vis_VBO);
glBufferData(GL_ARRAY_BUFFER,sizeof(VBOPosNormalColor)*fluid_pressure_vis.size(),&fluid_pressure_vis[0],GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER,fluid_cell_type_vis_VBO);
glBufferData(GL_ARRAY_BUFFER,sizeof(VBOPosNormalColor)*fluid_cell_type_vis.size(),&fluid_cell_type_vis[0],GL_STATIC_DRAW);
HandleGLError("leaving setup fluid");
// =====================================================================================
// setup a marching cubes representation of the surface
// =====================================================================================
for (int i = 0; i <= nx; i++) {
for (int j = 0; j <= ny; j++) {
for (int k = 0; k <= nz; k++) {
marchingCubes->set(i,j,k,interpolateIsovalue(Vec3f((i-0.5),(j-0.5),(k-0.5))));
}
}
}
marchingCubes->setupVBOs();
}
void Radiosity::drawVBOs() {
// =====================
// DRAW ALL THE POLYGONS
assert ((int)mesh_tri_indices.size() + (int)mesh_textured_tri_indices.size() == num_faces*4);
// render with Phong lighting?
if (args->render_mode == RENDER_MATERIALS) {
// yes
glUniform1i(GLCanvas::colormodeID, 1);
} else {
// no
glUniform1i(GLCanvas::colormodeID, 0);
}
// render untextured faces
glBindBuffer(GL_ARRAY_BUFFER,mesh_tri_verts_VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mesh_tri_indices_VBO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)sizeof(glm::vec3) );
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2));
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2 + sizeof(glm::vec4)));
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2 + sizeof(glm::vec4)*2));
glDrawElements(GL_TRIANGLES, mesh_tri_indices.size()*3,GL_UNSIGNED_INT, 0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
glDisableVertexAttribArray(4);
// render faces with textures
if (mesh_textured_tri_indices.size() > 0) {
// FIXME: there is something buggy with textures still
//glUniform1i(GLCanvas::colormodeID, 2);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, GLCanvas::textureID);
GLCanvas::mytexture = glGetUniformLocation(GLCanvas::programID, "mytexture");
glUniform1i(GLCanvas::mytexture, /*GL_TEXTURE*/0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mesh_textured_tri_indices_VBO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor),(void*)sizeof(glm::vec3) );
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2));
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2 + sizeof(glm::vec4)));
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 3, GL_FLOAT,GL_FALSE,sizeof(VBOPosNormalColor), (void*)(sizeof(glm::vec3)*2 + sizeof(glm::vec4)*2));
glDrawElements(GL_TRIANGLES, mesh_textured_tri_indices.size()*3, GL_UNSIGNED_INT, 0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
glDisableVertexAttribArray(4);
//glUniform1i(GLCanvas::colormodeID, 1);
}
HandleGLError();
}
void Radiosity::setupVBOs() {
HandleGLError("enter radiosity setupVBOs()");
mesh_tri_verts.clear();
mesh_tri_indices.clear();
mesh_textured_tri_indices.clear();
// initialize the data in each vector
int num_faces = mesh->numFaces();
assert (num_faces > 0);
for (int i = 0; i < num_faces; i++) {
Face *f = mesh->getFace(i);
Edge *e = f->getEdge();
glm::vec3 normal = f->computeNormal();
double avg_s = 0;
double avg_t = 0;
glm::vec3 avg_color(0,0,0);
int start = mesh_tri_verts.size();
// wireframe is normally black, except when it's the special
// patch, then the wireframe is red
glm::vec4 wireframe_color(0,0,0,0.5);
if (args->render_mode == RENDER_FORM_FACTORS && i == max_undistributed_patch) {
wireframe_color = glm::vec4(1,0,0,1);
}
// add the 4 corner vertices
for (int j = 0; j < 4; j++) {
glm::vec3 pos = ((*f)[j])->get();
double s = (*f)[j]->get_s();
double t = (*f)[j]->get_t();
glm::vec3 color = setupHelperForColor(f,i,j);
color = glm::vec3(linear_to_srgb(color.r),
linear_to_srgb(color.g),
linear_to_srgb(color.b));
avg_color += 0.25f * color;
mesh_tri_verts.push_back(VBOPosNormalColor(pos,normal,
glm::vec4(color.r,color.g,color.b,1.0),
wireframe_color,
s,t));
avg_s += 0.25 * s;
avg_t += 0.25 * t;
e = e->getNext();
}
// the centroid (for wireframe rendering)
glm::vec3 centroid = f->computeCentroid();
mesh_tri_verts.push_back(VBOPosNormalColor(centroid,normal,
glm::vec4(avg_color.r,avg_color.g,avg_color.b,1),
glm::vec4(1,1,1,1),
avg_s,avg_t));
if (f->getMaterial()->hasTextureMap()) {
mesh_textured_tri_indices.push_back(VBOIndexedTri(start+0,start+1,start+4));
mesh_textured_tri_indices.push_back(VBOIndexedTri(start+1,start+2,start+4));
mesh_textured_tri_indices.push_back(VBOIndexedTri(start+2,start+3,start+4));
mesh_textured_tri_indices.push_back(VBOIndexedTri(start+3,start+0,start+4));
} else {
mesh_tri_indices.push_back(VBOIndexedTri(start+0,start+1,start+4));
mesh_tri_indices.push_back(VBOIndexedTri(start+1,start+2,start+4));
mesh_tri_indices.push_back(VBOIndexedTri(start+2,start+3,start+4));
mesh_tri_indices.push_back(VBOIndexedTri(start+3,start+0,start+4));
}
}
assert ((int)mesh_tri_verts.size() == num_faces*5);
assert ((int)mesh_tri_indices.size() + (int)mesh_textured_tri_indices.size() == num_faces*4);
// copy the data to each VBO
glBindBuffer(GL_ARRAY_BUFFER,mesh_tri_verts_VBO);
glBufferData(GL_ARRAY_BUFFER,
sizeof(VBOPosNormalColor) * num_faces * 5,
&mesh_tri_verts[0],
GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mesh_tri_indices_VBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
sizeof(VBOIndexedTri) * mesh_tri_indices.size(),
&mesh_tri_indices[0], GL_STATIC_DRAW);
if (mesh_textured_tri_indices.size() > 0) {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mesh_textured_tri_indices_VBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
sizeof(VBOIndexedTri) * mesh_textured_tri_indices.size(),
&mesh_textured_tri_indices[0], GL_STATIC_DRAW);
}
HandleGLError("radiosity setupVBOs() just before texture");
// WARNING: this naive VBO implementation only allows a single texture
// FIXME: something still buggy about textures
int num_textured_materials = 0;
for (unsigned int mat = 0; mat < mesh->materials.size(); mat++) {
Material *m = mesh->materials[mat];
if (m->hasTextureMap()) {
// FIXME: old gl...
//glBindTexture(GL_TEXTURE_2D,m->getTextureID());
num_textured_materials++;
}
}
assert (num_textured_materials <= 1);
HandleGLError("leave radiosity setupVBOs()");
}
void Radiosity::Paint(ArgParser *args) {
// this offset prevents "z-fighting" bewteen the edges and faces
// the edges will always win.
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1.1,4.0);
if (args->render_mode == RENDER_MATERIALS) {
// draw the faces with OpenGL lighting, just to understand the geometry
// (the GL light has nothing to do with the surfaces that emit light!)
for ( int i = 0; i < num_faces; i++) {
Face *f = mesh->getFace(i);
Material *m = f->getMaterial();
Vec3f a = (*f)[0]->get();
Vec3f b = (*f)[1]->get();
Vec3f c = (*f)[2]->get();
Vec3f d = (*f)[3]->get();
Vec3f normal = f->computeNormal();
glNormal3f(normal.x(),normal.y(),normal.z());
if (!m->hasTextureMap()) {
Vec3f color = m->getDiffuseColor();
insertColor(color);
glBegin (GL_QUADS);
glVertex3f(a.x(),a.y(),a.z());
glVertex3f(b.x(),b.y(),b.z());
glVertex3f(c.x(),c.y(),c.z());
glVertex3f(d.x(),d.y(),d.z());
glEnd();
} else {
glEnable(GL_TEXTURE_2D);
glColor3f(1,1,1);
glBindTexture(GL_TEXTURE_2D,m->getTextureID());
glBegin (GL_QUADS);
glTexCoord2d((*f)[0]->get_s(),(*f)[0]->get_t());
glVertex3f(a.x(),a.y(),a.z());
glTexCoord2d((*f)[1]->get_s(),(*f)[1]->get_t());
glVertex3f(b.x(),b.y(),b.z());
glTexCoord2d((*f)[2]->get_s(),(*f)[2]->get_t());
glVertex3f(c.x(),c.y(),c.z());
glTexCoord2d((*f)[3]->get_s(),(*f)[3]->get_t());
glVertex3f(d.x(),d.y(),d.z());
glEnd();
glDisable(GL_TEXTURE_2D);
}
}
} else if (args->render_mode == RENDER_RADIANCE && args->interpolate == true) {
// interpolate the radiance values with neighboring faces having the same normal
glDisable(GL_LIGHTING);
glBegin (GL_QUADS);
for ( int i = 0; i < num_faces; i++) {
Face *f = mesh->getFace(i);
Vec3f a = (*f)[0]->get();
Vec3f b = (*f)[1]->get();
Vec3f c = (*f)[2]->get();
Vec3f d = (*f)[3]->get();
insertInterpolatedColor(i,f,(*f)[0]);
glVertex3f(a.x(),a.y(),a.z());
insertInterpolatedColor(i,f,(*f)[1]);
glVertex3f(b.x(),b.y(),b.z());
insertInterpolatedColor(i,f,(*f)[2]);
glVertex3f(c.x(),c.y(),c.z());
insertInterpolatedColor(i,f,(*f)[3]);
glVertex3f(d.x(),d.y(),d.z());
}
glEnd();
glEnable(GL_LIGHTING);
} else {
// for all other visualizations, just render the patch in a uniform color
glDisable(GL_LIGHTING);
glBegin (GL_QUADS);
for ( int i = 0; i < num_faces; i++) {
Face *f = mesh->getFace(i);
Vec3f color = whichVisualization(args->render_mode,f,i);
insertColor(color);
Vec3f a = (*f)[0]->get();
Vec3f b = (*f)[1]->get();
Vec3f c = (*f)[2]->get();
Vec3f d = (*f)[3]->get();
glVertex3f(a.x(),a.y(),a.z());
glVertex3f(b.x(),b.y(),b.z());
glVertex3f(c.x(),c.y(),c.z());
glVertex3f(d.x(),d.y(),d.z());
}
glEnd();
glEnable(GL_LIGHTING);
}
if (args->render_mode == RENDER_FORM_FACTORS) {
// render the form factors of the patch with the most undistributed light
glDisable(GL_LIGHTING);
glColor3f(1,0,0);
Face *t = mesh->getFace(max_undistributed_patch);
glLineWidth(3);
glBegin(GL_LINES);
Vec3f a = (*t)[0]->get();
Vec3f b = (*t)[1]->get();
Vec3f c = (*t)[2]->get();
Vec3f d = (*t)[3]->get();
glVertex3f(a.x(),a.y(),a.z());
glVertex3f(b.x(),b.y(),b.z());
glVertex3f(b.x(),b.y(),b.z());
glVertex3f(c.x(),c.y(),c.z());
glVertex3f(c.x(),c.y(),c.z());
glVertex3f(d.x(),d.y(),d.z());
glVertex3f(d.x(),d.y(),d.z());
glVertex3f(a.x(),a.y(),a.z());
glEnd();
glEnable(GL_LIGHTING);
}
glDisable(GL_POLYGON_OFFSET_FILL);
HandleGLError();
if (args->wireframe) {
mesh->PaintWireframe();
}
}
void GLCanvas::initialize(ArgParser *_args) {
args = _args;
Load();
glfwSetErrorCallback(error_callback);
// Initialize GLFW
if( !glfwInit() ) {
std::cerr << "ERROR: Failed to initialize GLFW" << std::endl;
exit(1);
}
// We will ask it to specifically open an OpenGL 3.2 context
glfwWindowHint(GLFW_SAMPLES, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// Create a GLFW window
window = glfwCreateWindow(args->width,args->height, "OpenGL viewer", NULL, NULL);
if (!window) {
std::cerr << "ERROR: Failed to open GLFW window" << std::endl;
glfwTerminate();
exit(1);
}
glfwMakeContextCurrent(window);
HandleGLError("in glcanvas first");
// Initialize GLEW
glewExperimental = true; // Needed for core profile
if (glewInit() != GLEW_OK) {
std::cerr << "ERROR: Failed to initialize GLEW" << std::endl;
glfwTerminate();
exit(1);
}
// there seems to be a "GL_INVALID_ENUM" error in glewInit that is a
// know issue, but can safely be ignored
HandleGLError("after glewInit()",true);
std::cout << "-------------------------------------------------------" << std::endl;
std::cout << "OpenGL Version: " << (char*)glGetString(GL_VERSION) << '\n';
std::cout << "-------------------------------------------------------" << std::endl;
// Initialize callback functions
glfwSetCursorPosCallback(GLCanvas::window,GLCanvas::mousemotionCB);
glfwSetMouseButtonCallback(GLCanvas::window,GLCanvas::mousebuttonCB);
glfwSetKeyCallback(GLCanvas::window,GLCanvas::keyboardCB);
programID = LoadShaders( args->path+"/render.vertexshader",
args->path+"/render.fragmentshader" );
GLCanvas::initializeVBOs();
GLCanvas::setupVBOs();
camera->glPlaceCamera();
HandleGLError("finished glcanvas initialize");
}