//function to render scene given the combined modelview projection matrix //and a shader void DrawScene(const glm::mat4& MVP, GLSLShader& shader) { //enable alpha blending with over compositing glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //bind the cube vertex array object glBindVertexArray(cubeVAOID); //bind the shader shader.Use(); //for all cubes for(int k=-1;k<=1;k++) { for(int j=-1;j<=1;j++) { int index =0; for(int i=-1;i<=1;i++) { GL_CHECK_ERRORS //set the modelling transformation and shader uniforms glm::mat4 T = glm::translate(glm::mat4(1), glm::vec3(i*2,j*2,k*2)); glUniform4fv(shader("vColor"),1, &(box_colors[index++].x)); glUniformMatrix4fv(shader("MVP"), 1, GL_FALSE, glm::value_ptr(MVP*R*T)); //draw the cube glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, 0); GL_CHECK_ERRORS } } } //unbind shader shader.UnUse(); //unbind vertex array object glBindVertexArray(0); }
//display callback void OnRender() { //get the elapse time time = glutGet(GLUT_ELAPSED_TIME)/1000.0f * SPEED; //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set teh camera viewing transformation glm::mat4 T = glm::translate(glm::mat4(1.0f),glm::vec3(0.0f, 0.0f, dist)); glm::mat4 Rx = glm::rotate(T, rX, glm::vec3(1.0f, 0.0f, 0.0f)); glm::mat4 MV = glm::rotate(Rx, rY, glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat4 MVP = P*MV; //bind the shader shader.Use(); //set the shader uniforms glUniformMatrix4fv(shader("MVP"), 1, GL_FALSE, glm::value_ptr(MVP)); glUniform1f(shader("time"), time); //draw the mesh triangles glDrawElements(GL_TRIANGLES, TOTAL_INDICES, GL_UNSIGNED_SHORT, 0); //unbind the shader shader.UnUse(); //swap front and back buffers to show the rendered result glutSwapBuffers(); }
//display function void OnRender() { //clear colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the camera transform glm::mat4 T = glm::translate(glm::mat4(1.0f),glm::vec3(0.0f, 0.0f, dist)); glm::mat4 Rx = glm::rotate(T, rX, glm::vec3(1.0f, 0.0f, 0.0f)); glm::mat4 Ry = glm::rotate(Rx, rY, glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat4 MV = Ry; glm::mat4 MVP = P*MV; //since we have kept the terrain vertex array object bound //it is still bound to the context so we can directly call draw element //which will draw vertices from the bound vertex array object //bind the terrain shader shader.Use(); //pass shader uniforms glUniformMatrix4fv(shader("MVP"), 1, GL_FALSE, glm::value_ptr(MVP)); //draw terrain mesh glDrawElements(GL_TRIANGLES, TOTAL_INDICES, GL_UNSIGNED_INT, 0); //unbind shader shader.UnUse(); //swap front and back buffers to show the rendered result glutSwapBuffers(); }
void onInit() { //tex = loadImage("../textures/texture.png"); tex = loadImage("../textures/dots.png"); tex2 = loadImage("../textures/dots.png"); ctv = new CTextureViewer(0, "../shaders/textureViewer.vs", "../shaders/textureViewer.frag"); ctv->setTexture(tex); ctv->setTexture2(tex2); hist.LoadFromFile(GL_VERTEX_SHADER, "../shaders/histogram.vs"); hist.LoadFromFile(GL_FRAGMENT_SHADER, "../shaders/histogram.frag"); hist.CreateAndLinkProgram(); hist.Use(); //Create uniforms and attributes (filled later) hist.AddAttribute("vPosition"); hist.AddUniform("tex"); hist.AddUniform("textureWidth"); hist.AddUniform("textureHeight"); hist.UnUse(); initTex(); initPointVBO(); initHistogramFBO(); }
//renders sphere using the render shader void DrawSphere(const glm::mat4& mvp) { renderShader.Use(); glBindVertexArray(sphereVAOID); glUniformMatrix4fv(renderShader("MVP"), 1, GL_FALSE, glm::value_ptr(mvp)); glDrawElements(GL_TRIANGLES, total_sphere_indices,GL_UNSIGNED_SHORT,0); renderShader.UnUse(); }
void DrawCloth() { renderShader.Use(); glBindVertexArray(clothVAOID); glUniformMatrix4fv(renderShader("MVP"), 1, GL_FALSE, glm::value_ptr(mMVP)); glDrawElements(GL_TRIANGLES, indices.size(),GL_UNSIGNED_SHORT,0); //glBindVertexArray(0); renderShader.UnUse(); }
void DrawGrid() { renderShader.Use(); glBindVertexArray(gridVAOID); glUniformMatrix4fv(renderShader("MVP"), 1, GL_FALSE, glm::value_ptr(mMVP)); glDrawElements(GL_LINES, grid_indices.size(),GL_UNSIGNED_SHORT,0); glBindVertexArray(0); renderShader.UnUse(); }
void computeHistogram() { glViewport(0, 0, WIDTH, HEIGHT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClearColor(0.0, 0.0, 0.0, 0.0); glDisable(GL_DEPTH_TEST); //Enable blending glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); //Additive glBlendEquation(GL_FUNC_ADD); hist.Use(); glBindBuffer(GL_ARRAY_BUFFER, HistogramVBO); glVertexAttribPointer(hist["vPosition"], 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GL_FLOAT), (void*)0); glEnableVertexAttribArray(hist["vPosition"]); glUniform1i(hist("tex"), 0); glUniform1f(hist("textureWidth"), (float)WIDTH); glUniform1f(hist("textureHeight"), (float)HEIGHT); glBindFramebuffer(GL_FRAMEBUFFER, FBO); //glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Compute histogram glDrawArrays(GL_POINTS, 0, WIDTH*HEIGHT); glBindBuffer(GL_ARRAY_BUFFER, 0); hist.UnUse(); //Disable blending glDisable(GL_BLEND); float hPixels[256]; glReadPixels(0, 0, 256, 1, GL_BLUE, GL_FLOAT, hPixels); int sum = 0; if (printed != 0) { cout << "\n\n-----------\n\n"; for(int j = 0; j < 256; j++) { //if((j % 3) == 0) cout << j << ":" << hPixels[j] << endl; sum += hPixels[j]; } cout << endl << sum << endl; printed--; } glBindFramebuffer(GL_FRAMEBUFFER, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); }
//display callback function void OnRender() { GL_CHECK_ERRORS //clear colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the camera transform glm::mat4 T = glm::translate(glm::mat4(1.0f),glm::vec3(0.0f, 0.0f, dist)); glm::mat4 Rx = glm::rotate(T, rX, glm::vec3(1.0f, 0.0f, 0.0f)); glm::mat4 MV = glm::rotate(Rx, rY, glm::vec3(0.0f, 1.0f, 0.0f)); //1) Render scene from the light's POV //enable rendering to FBO glBindFramebuffer(GL_FRAMEBUFFER,fboID); //clear depth buffer glClear(GL_DEPTH_BUFFER_BIT); //reset viewport to the shadow map texture size glViewport(0,0,SHADOWMAP_WIDTH, SHADOWMAP_HEIGHT); //enable front face culling glCullFace(GL_FRONT); //draw scene from the point of view of light DrawScene(MV_L, P_L); //enable back face culling glCullFace(GL_BACK); //restore normal rendering path //unbind FBO, set the default back buffer and reset the viewport to screen size glBindFramebuffer(GL_FRAMEBUFFER,0); glDrawBuffer(GL_BACK_LEFT); glViewport(0,0,WIDTH, HEIGHT); //2) Render scene from point of view of eye DrawScene(MV, P, 0 ); //bind light gizmo vertex array object glBindVertexArray(lightVAOID); { //set the flat shader flatshader.Use(); //set the light's transform and render 3 lines glm::mat4 T = glm::translate(glm::mat4(1), lightPosOS); glUniformMatrix4fv(flatshader("MVP"), 1, GL_FALSE, glm::value_ptr(P*MV*T)); glDrawArrays(GL_LINES, 0, 6); //unbind shader flatshader.UnUse(); } //unbind the vertex array object glBindVertexArray(0); //swap front and back buffers to show the rendered result glutSwapBuffers(); }
void OnRender() { glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT); GL_CHECK_ERRORS shader.Use(); drawDefaultBox(); shader.UnUse(); glutSwapBuffers(); }
void DrawClothPoints() { particleShader.Use(); //glBindVertexArray(clothVAOID); glUniform1i(particleShader("selected_index"), selected_index); glUniformMatrix4fv(particleShader("MV"), 1, GL_FALSE, glm::value_ptr(mMV)); glUniformMatrix4fv(particleShader("MVP"), 1, GL_FALSE, glm::value_ptr(mMVP)); //draw the masses last glDrawArrays(GL_POINTS, 0, total_points); glBindVertexArray(0); particleShader.UnUse(); }
//display function void OnRender() { //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //bind shader shader.Use(); //draw the full screen quad glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0); //unbind shader shader.UnUse(); //swap front and back buffers to show the rendered result glutSwapBuffers(); }
void InitShaders(void) { shader.LoadFromFile(GL_VERTEX_SHADER, "../CGE_solarsystem/shader.vert"); shader.LoadFromFile(GL_FRAGMENT_SHADER, "../CGE_solarsystem/shader.frag"); shader.CreateAndLinkProgram(); shader.Use(); shader.AddAttribute("vVertex"); shader.AddAttribute("vUV"); shader.AddUniform("MVP"); shader.AddUniform("textureMap"); glUniform1i(shader("textureMap"), 0); shader.UnUse(); GL_CHECK_ERRORS }
void OnRender() { glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glm::mat4 T = glm::translate(glm::mat4(1.0f),glm::vec3(0.0f, 0.0f, dist)); glm::mat4 Rx = glm::rotate(T, rX, glm::vec3(1.0f, 0.0f, 0.0f)); glm::mat4 Ry = glm::rotate(Rx, rY, glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat4 MV = Ry; glm::mat4 MVP = P*MV; //glBindVertexArray(vaoID); shader.Use(); glUniformMatrix4fv(shader("MVP"), 1, GL_FALSE, glm::value_ptr(MVP)); glDrawElements(GL_TRIANGLES, TOTAL_INDICES, GL_UNSIGNED_INT, 0); shader.UnUse(); //glBindVertexArray(0); glutSwapBuffers(); }
//display callback function void OnRender() { GL_CHECK_ERRORS //set the camera transform glm::mat4 Tr = glm::translate(glm::mat4(1.0f),glm::vec3(0.0f, 0.0f, dist)); glm::mat4 Rx = glm::rotate(Tr, rX, glm::vec3(1.0f, 0.0f, 0.0f)); glm::mat4 MV = glm::rotate(Rx, rY, glm::vec3(0.0f, 1.0f, 0.0f)); //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //get the combined modelview projection matrix glm::mat4 MVP = P*MV; //render the grid object grid->Render(glm::value_ptr(MVP)); //set the modelling transform to move the marhing result to origin glm::mat4 T = glm::translate(glm::mat4(1), glm::vec3(-0.5,-0.5,-0.5)); //if rendering mode set to wireframe we set the front and back //polygon mode to line if(bWireframe) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); //set the volume marcher vertex array object glBindVertexArray(volumeMarcherVAO); //bind the shader shader.Use(); //set the shader uniforms glUniformMatrix4fv(shader("MVP"), 1, GL_FALSE, glm::value_ptr(MVP*T)); //render the triangles glDrawArrays(GL_TRIANGLES, 0, marcher->GetTotalVertices()); //unbind the shader shader.UnUse(); //restore the default polygon mode if(bWireframe) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); //swap front and back buffers to show the rendered result glutSwapBuffers(); }
//display callback function void OnRender() { GL_CHECK_ERRORS //set the camera transform glm::mat4 Tr = glm::translate(glm::mat4(1.0f),glm::vec3(0.0f, 0.0f, dist)); glm::mat4 Rx = glm::rotate(Tr, rX, glm::vec3(1.0f, 0.0f, 0.0f)); glm::mat4 MV = glm::rotate(Rx, rY, glm::vec3(0.0f, 1.0f, 0.0f)); //get the camera position glm::vec3 camPos = glm::vec3(glm::inverse(MV)*glm::vec4(0,0,0,1)); //clear colour and depth buffer glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //get the combined modelview projection matrix glm::mat4 MVP = P*MV; //render grid grid->Render(glm::value_ptr(MVP)); //enable blending and bind the cube vertex array object glEnable(GL_BLEND); glBindVertexArray(cubeVAOID); //bind the raycasting shader shader.Use(); //pass shader uniforms glUniformMatrix4fv(shader("MVP"), 1, GL_FALSE, glm::value_ptr(MVP)); glUniform3fv(shader("camPos"), 1, &(camPos.x)); //render the cube glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, 0); //unbind the raycasting shader shader.UnUse(); //disable blending glDisable(GL_BLEND); //swap front and back buffers to show the rendered result glutSwapBuffers(); }
//display callback function void OnRender() { //clear colour and depth buffer glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the camera transformation glm::mat4 T = glm::translate(glm::mat4(1.0f),glm::vec3(0.0f, 0.0f, dist)); glm::mat4 Rx = glm::rotate(T, rX, glm::vec3(1.0f, 0.0f, 0.0f)); glm::mat4 V = glm::rotate(Rx, rY, glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat4 PV = P*V; //bind the shader shader.Use(); //set the shader uniforms glUniformMatrix4fv(shader("PV"), 1, GL_FALSE, glm::value_ptr(PV)); glUniform1i(shader("sub_divisions"), sub_divisions); //render instanced geometry glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0, 4); //unbind shader shader.UnUse(); //swap front and back buffers to show the rendered result glutSwapBuffers(); }
void OnInit() { GL_CHECK_ERRORS //setup shader shader.LoadFromFile(GL_VERTEX_SHADER, "shaders/shader.vert"); shader.LoadFromFile(GL_GEOMETRY_SHADER, "shaders/shader.geom"); shader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/shader.frag"); shader.CreateAndLinkProgram(); shader.Use(); shader.AddAttribute("vVertex"); shader.AddUniform("heightMapTexture"); shader.AddUniform("scale"); shader.AddUniform("half_scale"); shader.AddUniform("HALF_TERRAIN_SIZE"); shader.AddUniform("MVP"); glUniform1i(shader("heightMapTexture"), 0); glUniform2i(shader("HALF_TERRAIN_SIZE"), TERRAIN_WIDTH>>1, TERRAIN_DEPTH>>1); glUniform1f(shader("scale"), scale); glUniform1f(shader("half_scale"), half_scale); shader.UnUse(); GL_CHECK_ERRORS //setup geometry //fill indices array GLuint* id=&indices[0]; int i=0, j=0; //setup vertices int count = 0; for( j=0;j<TERRAIN_DEPTH;j++) { for( i=0;i<TERRAIN_WIDTH;i++) { /* vertices[count] = glm::vec3( ( (float(i)/(TERRAIN_WIDTH-1))*2.0f-1)*TERRAIN_HALF_WIDTH, (pData[count]/255.0f)*scale-half_scale, ( (float(j)/(TERRAIN_DEPTH-1))*2.0-1)*TERRAIN_HALF_DEPTH); */ vertices[count] = glm::vec3( (float(i)/(TERRAIN_WIDTH-1)), 0, (float(j)/(TERRAIN_DEPTH-1))); count++; } } for (i = 0; i < TERRAIN_DEPTH-1; i++) { for (j = 0; j < TERRAIN_WIDTH-1; j++) { int i0 = j+ i*TERRAIN_WIDTH; int i1 = i0+1; int i2 = i0+TERRAIN_WIDTH; int i3 = i2+1; *id++ = i0; *id++ = i2; *id++ = i1; *id++ = i1; *id++ = i2; *id++ = i3; } } GL_CHECK_ERRORS //setup vao and vbo stuff glGenVertexArrays(1, &vaoID); glGenBuffers(1, &vboVerticesID); glGenBuffers(1, &vboIndicesID); glBindVertexArray(vaoID); glBindBuffer (GL_ARRAY_BUFFER, vboVerticesID); glBufferData (GL_ARRAY_BUFFER, sizeof(vertices), &vertices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS glEnableVertexAttribArray(shader["vVertex"]); glVertexAttribPointer(shader["vVertex"], 3, GL_FLOAT, GL_FALSE,0,0); GL_CHECK_ERRORS glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), &indices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //load the heightmap texture using SOIL int texture_width = 0, texture_height = 0, format=0; GLubyte* pData = SOIL_load_image(filename.c_str(), &texture_width, &texture_height, &format, SOIL_LOAD_L); //setup OpenGL texture glGenTextures(1, &heightMapTextureID); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, heightMapTextureID); 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); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, texture_width, texture_height, 0, GL_RED, GL_UNSIGNED_BYTE, pData); free(pData); GL_CHECK_ERRORS glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); GL_CHECK_ERRORS cout<<"Initialization successfull"<<endl; }
//scene rendering function void DrawScene(const glm::mat4& View, const glm::mat4& Proj, int isLightPass = 1) { GL_CHECK_ERRORS //bind the current shader shader.Use(); //render plane first glBindVertexArray(planeVAOID); { //set the shader uniforms glUniform3fv(shader("light_position"),1, &(lightPosOS.x)); glUniformMatrix4fv(shader("S"), 1, GL_FALSE, glm::value_ptr(S)); glUniformMatrix4fv(shader("M"), 1, GL_FALSE, glm::value_ptr(glm::mat4(1))); glUniform1i(shader("bIsLightPass"), isLightPass); glUniformMatrix4fv(shader("MVP"), 1, GL_FALSE, glm::value_ptr(Proj*View)); glUniformMatrix4fv(shader("MV"), 1, GL_FALSE, glm::value_ptr(View)); glUniformMatrix3fv(shader("N"), 1, GL_FALSE, glm::value_ptr(glm::inverseTranspose(glm::mat3(View)))); glUniform3f(shader("diffuse_color"), 1.0f,1.0f,1.0f); //draw plane triangles glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0); } //render the cube glBindVertexArray(cubeVAOID); { //set the cube's transform glm::mat4 T = glm::translate(glm::mat4(1), glm::vec3(-1,1,0)); glm::mat4 M = T; glm::mat4 MV = View*M; glm::mat4 MVP = Proj*MV; //pass shader uniforms glUniformMatrix4fv(shader("S"), 1, GL_FALSE, glm::value_ptr(S)); glUniformMatrix4fv(shader("M"), 1, GL_FALSE, glm::value_ptr(M)); glUniformMatrix4fv(shader("MVP"), 1, GL_FALSE, glm::value_ptr(MVP)); glUniformMatrix4fv(shader("MV"), 1, GL_FALSE, glm::value_ptr(MV)); glUniformMatrix3fv(shader("N"), 1, GL_FALSE, glm::value_ptr(glm::inverseTranspose(glm::mat3(MV)))); glUniform3f(shader("diffuse_color"), 1.0f,0.0f,0.0f); //draw cube triangles glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, 0); } //render the sphere glBindVertexArray(sphereVAOID); { //set the sphere's transform glm::mat4 T = glm::translate(glm::mat4(1), glm::vec3(1,1,0)); glm::mat4 M = T; glm::mat4 MV = View*M; glm::mat4 MVP = Proj*MV; //set the shader uniforms glUniformMatrix4fv(shader("S"), 1, GL_FALSE, glm::value_ptr(S)); glUniformMatrix4fv(shader("M"), 1, GL_FALSE, glm::value_ptr(M)); glUniformMatrix4fv(shader("MVP"), 1, GL_FALSE, glm::value_ptr(MVP)); glUniformMatrix4fv(shader("MV"), 1, GL_FALSE, glm::value_ptr(MV)); glUniformMatrix3fv(shader("N"), 1, GL_FALSE, glm::value_ptr(glm::inverseTranspose(glm::mat3(MV)))); glUniform3f(shader("diffuse_color"), 0.0f, 0.0f, 1.0f); //draw sphere triangles glDrawElements(GL_TRIANGLES, totalSphereTriangles, GL_UNSIGNED_SHORT, 0); } //unbind shader shader.UnUse(); GL_CHECK_ERRORS }
//OpenGL initialization void OnInit() { //load the flat shader flatshader.LoadFromFile(GL_VERTEX_SHADER, "shaders/shader.vert"); flatshader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/shader.frag"); //compile and link shader flatshader.CreateAndLinkProgram(); flatshader.Use(); //add attributes and uniforms flatshader.AddAttribute("vVertex"); flatshader.AddUniform("MVP"); flatshader.UnUse(); //load the shadow mapping shader shader.LoadFromFile(GL_VERTEX_SHADER, "shaders/PointLightShadowMapped.vert"); shader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/PointLightShadowMapped.frag"); //compile and link shader shader.CreateAndLinkProgram(); shader.Use(); //add attributes and uniforms shader.AddAttribute("vVertex"); shader.AddAttribute("vNormal"); shader.AddUniform("MVP"); shader.AddUniform("MV"); shader.AddUniform("M"); shader.AddUniform("N"); shader.AddUniform("S"); shader.AddUniform("light_position"); shader.AddUniform("diffuse_color"); shader.AddUniform("bIsLightPass"); shader.AddUniform("shadowMap"); //pass value of constant uniforms at initialization glUniform1i(shader("shadowMap"),0); shader.UnUse(); GL_CHECK_ERRORS //setup sphere geometry CreateSphere(1.0f,10,10, vertices, indices); //setup sphere vao and vbo stuff glGenVertexArrays(1, &sphereVAOID); glGenBuffers(1, &sphereVerticesVBO); glGenBuffers(1, &sphereIndicesVBO); glBindVertexArray(sphereVAOID); glBindBuffer (GL_ARRAY_BUFFER, sphereVerticesVBO); //pass vertices to the buffer object glBufferData (GL_ARRAY_BUFFER, vertices.size()*sizeof(Vertex), &vertices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attribute array for position glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex),0); GL_CHECK_ERRORS //enable vertex attribute array for normal glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, normal))); GL_CHECK_ERRORS //pass sphere indices to element array buffer glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, sphereIndicesVBO); glBufferData (GL_ELEMENT_ARRAY_BUFFER, indices.size()*sizeof(GLushort), &indices[0], GL_STATIC_DRAW); //store the total number of sphere triangles totalSphereTriangles = indices.size(); //clear the vertices and indices vectors as we will reuse them //for cubes vertices.clear(); indices.clear(); //setup cube geometry CreateCube(2,vertices, indices); //setup cube vao and vbo stuff glGenVertexArrays(1, &cubeVAOID); glGenBuffers(1, &cubeVerticesVBO); glGenBuffers(1, &cubeIndicesVBO); glBindVertexArray(cubeVAOID); glBindBuffer (GL_ARRAY_BUFFER, cubeVerticesVBO); //pass vertices to the buffer object glBufferData (GL_ARRAY_BUFFER, vertices.size()*sizeof(Vertex), &vertices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attribute array for position glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex),0); GL_CHECK_ERRORS //enable vertex attribute array for normals glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, normal))); GL_CHECK_ERRORS //pass cube indices to element array buffer glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, cubeIndicesVBO); glBufferData (GL_ELEMENT_ARRAY_BUFFER, indices.size()*sizeof(GLushort), &indices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //clear the vertices and indices vectors as we will reuse them //for plane vertices.clear(); indices.clear(); //create a plane object CreatePlane(100,100,vertices, indices); //setup plane VAO and VBO glGenVertexArrays(1, &planeVAOID); glGenBuffers(1, &planeVerticesVBO); glGenBuffers(1, &planeIndicesVBO); glBindVertexArray(planeVAOID); glBindBuffer (GL_ARRAY_BUFFER, planeVerticesVBO); //pass vertices to the buffer object glBufferData (GL_ARRAY_BUFFER, vertices.size()*sizeof(Vertex), &vertices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attribute array for position glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex),0); GL_CHECK_ERRORS //enable vertex attribute array for normals glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, normal))); GL_CHECK_ERRORS //pass plane indices to element array buffer glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, planeIndicesVBO); glBufferData (GL_ELEMENT_ARRAY_BUFFER, indices.size()*sizeof(GLushort), &indices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //setup vao and vbo stuff for the light position crosshair glm::vec3 crossHairVertices[6]; crossHairVertices[0] = glm::vec3(-0.5f,0,0); crossHairVertices[1] = glm::vec3(0.5f,0,0); crossHairVertices[2] = glm::vec3(0, -0.5f,0); crossHairVertices[3] = glm::vec3(0, 0.5f,0); crossHairVertices[4] = glm::vec3(0,0, -0.5f); crossHairVertices[5] = glm::vec3(0,0, 0.5f); //setup light gizmo vertex array and buffer object glGenVertexArrays(1, &lightVAOID); glGenBuffers(1, &lightVerticesVBO); glBindVertexArray(lightVAOID); glBindBuffer (GL_ARRAY_BUFFER, lightVerticesVBO); //pass light crosshair gizmo vertices to buffer object glBufferData (GL_ARRAY_BUFFER, sizeof(crossHairVertices), &(crossHairVertices[0].x), GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attribute array for position glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0,0); GL_CHECK_ERRORS //get light position from spherical coordinates lightPosOS.x = radius * cos(theta)*sin(phi); lightPosOS.y = radius * cos(phi); lightPosOS.z = radius * sin(theta)*sin(phi); //setup the shadowmap texture glGenTextures(1, &shadowMapTexID); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, shadowMapTexID); //set texture parameters GLfloat border[4]={1,0,0,0}; glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_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); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_COMPARE_MODE,GL_COMPARE_REF_TO_TEXTURE); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_COMPARE_FUNC,GL_LEQUAL); glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_BORDER_COLOR,border); glTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT24,SHADOWMAP_WIDTH,SHADOWMAP_HEIGHT,0,GL_DEPTH_COMPONENT,GL_UNSIGNED_BYTE,NULL); //set up FBO to get the depth component glGenFramebuffers(1,&fboID); glBindFramebuffer(GL_FRAMEBUFFER,fboID); glFramebufferTexture2D(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D,shadowMapTexID,0); //check framebuffer completeness status GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); if(status == GL_FRAMEBUFFER_COMPLETE) { cout<<"FBO setup successful."<<endl; } else { cout<<"Problem in FBO setup."<<endl; } //unbind FBO glBindFramebuffer(GL_FRAMEBUFFER,0); //set the light MV, P and bias matrices MV_L = glm::lookAt(lightPosOS,glm::vec3(0,0,0),glm::vec3(0,1,0)); P_L = glm::perspective(glm::radians(50.0f),1.0f,1.0f, 25.0f); B = glm::scale(glm::translate(glm::mat4(1),glm::vec3(0.5,0.5,0.5)), glm::vec3(0.5,0.5,0.5)); BP = B*P_L; S = BP*MV_L; //enable depth testing and culling glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); cout<<"Initialization successfull"<<endl; }
//OpenGL initialization void OnInit() { //set the instance modeling matrix M[0] = glm::translate(glm::mat4(1), glm::vec3(-5,0,-5)); M[1] = glm::translate(M[0], glm::vec3(10,0,0)); M[2] = glm::translate(M[1], glm::vec3(0,0,10)); M[3] = glm::translate(M[2], glm::vec3(-10,0,0)); GL_CHECK_ERRORS //load the shader shader.LoadFromFile(GL_VERTEX_SHADER, "shaders/shader.vert"); shader.LoadFromFile(GL_GEOMETRY_SHADER, "shaders/shader.geom"); shader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/shader.frag"); //create and link shader shader.CreateAndLinkProgram(); shader.Use(); //add attribute and uniform shader.AddAttribute("vVertex"); shader.AddUniform("PV"); shader.AddUniform("M"); shader.AddUniform("sub_divisions"); //set values of constant uniforms at initialization glUniform1i(shader("sub_divisions"), sub_divisions); glUniformMatrix4fv(shader("M"), 4, GL_FALSE, glm::value_ptr(M[0])); shader.UnUse(); GL_CHECK_ERRORS //setup quad geometry //setup quad vertices vertices[0] = glm::vec3(-5,0,-5); vertices[1] = glm::vec3(-5,0,5); vertices[2] = glm::vec3(5,0,5); vertices[3] = glm::vec3(5,0,-5); //setup quad indices GLushort* id=&indices[0]; *id++ = 0; *id++ = 1; *id++ = 2; *id++ = 0; *id++ = 2; *id++ = 3; GL_CHECK_ERRORS //setup quad vao and vbo stuff glGenVertexArrays(1, &vaoID); glGenBuffers(1, &vboVerticesID); glGenBuffers(1, &vboIndicesID); glBindVertexArray(vaoID); glBindBuffer (GL_ARRAY_BUFFER, vboVerticesID); //pass the quad vertices to buffer object glBufferData (GL_ARRAY_BUFFER, sizeof(vertices), &vertices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attribute array for position glEnableVertexAttribArray(shader["vVertex"]); glVertexAttribPointer(shader["vVertex"], 3, GL_FLOAT, GL_FALSE,0,0); GL_CHECK_ERRORS //pass the quad indices to element array buffer glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), &indices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //set the polygon mode to render lines glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); GL_CHECK_ERRORS cout<<"Initialization successfull"<<endl; }
//display callback function void OnRender() { GL_CHECK_ERRORS //camera transformation glm::mat4 Tr = glm::translate(glm::mat4(1.0f),glm::vec3(0.0f, 0.0f, dist)); glm::mat4 Rx = glm::rotate(Tr, rX, glm::vec3(1.0f, 0.0f, 0.0f)); glm::mat4 MV = glm::rotate(Rx, rY, glm::vec3(0.0f, 1.0f, 0.0f)); //clear colour and depth buffer glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //get the combined modelview projection matrix glm::mat4 MVP = P*MV; //if we want to use depth peeling if(bShowDepthPeeling) { //bind the colour blending FBO glBindFramebuffer(GL_FRAMEBUFFER, colorBlenderFBOID); //set the first colour attachment as the draw buffer glDrawBuffer(GL_COLOR_ATTACHMENT0); //clear the colour and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // 1. In the first pass, we render normally with depth test enabled to get the nearest surface glEnable(GL_DEPTH_TEST); DrawScene(MVP, cubeShader); // 2. Depth peeling + blending pass int numLayers = (NUM_PASSES - 1) * 2; //for each pass for (int layer = 1; bUseOQ || layer < numLayers; layer++) { int currId = layer % 2; int prevId = 1 - currId; //bind the current FBO glBindFramebuffer(GL_FRAMEBUFFER, fbo[currId]); //set the first colour attachment as draw buffer glDrawBuffer(GL_COLOR_ATTACHMENT0); //set clear colour to black glClearColor(0, 0, 0, 0); //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //disbale blending and depth testing glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); //if we want to use occlusion query, we initiate it if (bUseOQ) { glBeginQuery(GL_SAMPLES_PASSED_ARB, queryId); } GL_CHECK_ERRORS //bind the depth texture from the previous step glBindTexture(GL_TEXTURE_RECTANGLE, depthTexID[prevId]); //render scene with the front to back peeling shader DrawScene(MVP, frontPeelShader); //if we initiated the occlusion query, we end it if (bUseOQ) { glEndQuery(GL_SAMPLES_PASSED_ARB); } GL_CHECK_ERRORS //bind the colour blender FBO glBindFramebuffer(GL_FRAMEBUFFER, colorBlenderFBOID); //render to its first colour attachment glDrawBuffer(GL_COLOR_ATTACHMENT0); //enable blending but disable depth testing glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); //change the blending equation to add glBlendEquation(GL_FUNC_ADD); //use separate blending function glBlendFuncSeparate(GL_DST_ALPHA, GL_ONE, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA); //bind the result from the previous iteration as texture glBindTexture(GL_TEXTURE_RECTANGLE, texID[currId]); //bind the blend shader and then draw a fullscreen quad blendShader.Use(); DrawFullScreenQuad(); blendShader.UnUse(); //disable blending glDisable(GL_BLEND); GL_CHECK_ERRORS //if we initiated the occlusion query, we get the query result //that is the total number of samples if (bUseOQ) { GLuint sample_count; glGetQueryObjectuiv(queryId, GL_QUERY_RESULT, &sample_count); if (sample_count == 0) { break; } } } GL_CHECK_ERRORS // 3. Final render pass //remove the FBO glBindFramebuffer(GL_FRAMEBUFFER, 0); //restore the default back buffer glDrawBuffer(GL_BACK_LEFT); //disable depth testing and blending glDisable(GL_DEPTH_TEST); glDisable(GL_BLEND); //bind the colour blender texture glBindTexture(GL_TEXTURE_RECTANGLE, colorBlenderTexID); //bind the final shader finalShader.Use(); //set shader uniforms glUniform4fv(finalShader("vBackgroundColor"), 1, &bg.x); //draw full screen quad DrawFullScreenQuad(); finalShader.UnUse(); } else {
//OpenGL initialization void OnInit() { GL_CHECK_ERRORS //create a uniform grid of size 20x20 in XZ plane grid = new CGrid(20,20); GL_CHECK_ERRORS //Load the raycasting shader shader.LoadFromFile(GL_VERTEX_SHADER, "shaders/raycaster.vert"); shader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/raycaster.frag"); //compile and link the shader shader.CreateAndLinkProgram(); shader.Use(); //add attributes and uniforms shader.AddAttribute("vVertex"); shader.AddUniform("MVP"); shader.AddUniform("volume"); shader.AddUniform("camPos"); shader.AddUniform("step_size"); //pass constant uniforms at initialization glUniform3f(shader("step_size"), 1.0f/XDIM, 1.0f/YDIM, 1.0f/ZDIM); glUniform1i(shader("volume"),0); shader.UnUse(); GL_CHECK_ERRORS //load volume data if(LoadVolume()) { std::cout<<"Volume data loaded successfully."<<std::endl; } else { std::cout<<"Cannot load volume data."<<std::endl; exit(EXIT_FAILURE); } //set background colour glClearColor(bg.r, bg.g, bg.b, bg.a); //setup unit cube vertex array and vertex buffer objects glGenVertexArrays(1, &cubeVAOID); glGenBuffers(1, &cubeVBOID); glGenBuffers(1, &cubeIndicesID); //unit cube vertices glm::vec3 vertices[8]= { glm::vec3(-0.5f,-0.5f,-0.5f), glm::vec3( 0.5f,-0.5f,-0.5f), glm::vec3( 0.5f, 0.5f,-0.5f), glm::vec3(-0.5f, 0.5f,-0.5f), glm::vec3(-0.5f,-0.5f, 0.5f), glm::vec3( 0.5f,-0.5f, 0.5f), glm::vec3( 0.5f, 0.5f, 0.5f), glm::vec3(-0.5f, 0.5f, 0.5f) }; //unit cube indices GLushort cubeIndices[36]= {0,5,4, 5,0,1, 3,7,6, 3,6,2, 7,4,6, 6,4,5, 2,1,3, 3,1,0, 3,0,7, 7,0,4, 6,5,2, 2,5,1 }; glBindVertexArray(cubeVAOID); glBindBuffer (GL_ARRAY_BUFFER, cubeVBOID); //pass cube vertices to buffer object memory glBufferData (GL_ARRAY_BUFFER, sizeof(vertices), &(vertices[0].x), GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attributre array for position glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,0,0); //pass indices to element array buffer glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, cubeIndicesID); glBufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof(cubeIndices), &cubeIndices[0], GL_STATIC_DRAW); glBindVertexArray(0); //enable depth test glEnable(GL_DEPTH_TEST); //set the over blending function glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); cout<<"Initialization successfull"<<endl; }
//OpenGL initialization function void OnInit() { GL_CHECK_ERRORS //initialize FBO initFBO(); //generate hardwre query glGenQueries(1, &queryId); //create a uniform grid of size 20x20 in XZ plane grid = new CGrid(20,20); GL_CHECK_ERRORS //generate the quad vertices glm::vec2 quadVerts[4]; quadVerts[0] = glm::vec2(0,0); quadVerts[1] = glm::vec2(1,0); quadVerts[2] = glm::vec2(1,1); quadVerts[3] = glm::vec2(0,1); //generate quad indices GLushort quadIndices[]={ 0,1,2,0,2,3}; //generate quad vertex array and vertex buffer objects glGenVertexArrays(1, &quadVAOID); glGenBuffers(1, &quadVBOID); glGenBuffers(1, &quadIndicesID); glBindVertexArray(quadVAOID); glBindBuffer (GL_ARRAY_BUFFER, quadVBOID); //pass quad vertices to buffer object memory glBufferData (GL_ARRAY_BUFFER, sizeof(quadVerts), &quadVerts[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attribute array for position glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE,0,0); //pass the quad indices to the element array buffer glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, quadIndicesID); glBufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof(quadIndices), &quadIndices[0], GL_STATIC_DRAW); //setup unit cube vertex array and vertex buffer objects glGenVertexArrays(1, &cubeVAOID); glGenBuffers(1, &cubeVBOID); glGenBuffers(1, &cubeIndicesID); //unit cube vertices glm::vec3 vertices[8]={ glm::vec3(-0.5f,-0.5f,-0.5f), glm::vec3( 0.5f,-0.5f,-0.5f), glm::vec3( 0.5f, 0.5f,-0.5f), glm::vec3(-0.5f, 0.5f,-0.5f), glm::vec3(-0.5f,-0.5f, 0.5f), glm::vec3( 0.5f,-0.5f, 0.5f), glm::vec3( 0.5f, 0.5f, 0.5f), glm::vec3(-0.5f, 0.5f, 0.5f)}; //unit cube indices GLushort cubeIndices[36]={0,5,4, 5,0,1, 3,7,6, 3,6,2, 7,4,6, 6,4,5, 2,1,3, 3,1,0, 3,0,7, 7,0,4, 6,5,2, 2,5,1}; glBindVertexArray(cubeVAOID); glBindBuffer (GL_ARRAY_BUFFER, cubeVBOID); //pass cube vertices to buffer object memory glBufferData (GL_ARRAY_BUFFER, sizeof(vertices), &(vertices[0].x), GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attributre array for position glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,0,0); //pass cube indices to element array buffer glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, cubeIndicesID); glBufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof(cubeIndices), &cubeIndices[0], GL_STATIC_DRAW); glBindVertexArray(0); //Load the cube shader cubeShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/cube_shader.vert"); cubeShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/cube_shader.frag"); //compile and link the shader cubeShader.CreateAndLinkProgram(); cubeShader.Use(); //add attributes and uniforms cubeShader.AddAttribute("vVertex"); cubeShader.AddUniform("MVP"); cubeShader.AddUniform("vColor"); cubeShader.UnUse(); //Load the front to back peeling shader frontPeelShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/front_peel.vert"); frontPeelShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/front_peel.frag"); //compile and link the shader frontPeelShader.CreateAndLinkProgram(); frontPeelShader.Use(); //add attributes and uniforms frontPeelShader.AddAttribute("vVertex"); frontPeelShader.AddUniform("MVP"); frontPeelShader.AddUniform("vColor"); frontPeelShader.AddUniform("depthTexture"); //pass constant uniforms at initialization glUniform1i(frontPeelShader("depthTexture"), 0); frontPeelShader.UnUse(); //Load the blending shader blendShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/blend.vert"); blendShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/blend.frag"); //compile and link the shader blendShader.CreateAndLinkProgram(); blendShader.Use(); //add attributes and uniforms blendShader.AddAttribute("vVertex"); blendShader.AddUniform("tempTexture"); //pass constant uniforms at initialization glUniform1i(blendShader("tempTexture"), 0); blendShader.UnUse(); //Load the final shader finalShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/blend.vert"); finalShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/final.frag"); //compile and link the shader finalShader.CreateAndLinkProgram(); finalShader.Use(); //add attributes and uniforms finalShader.AddAttribute("vVertex"); finalShader.AddUniform("colorTexture"); finalShader.AddUniform("vBackgroundColor"); //pass constant uniforms at initialization glUniform1i(finalShader("colorTexture"), 0); finalShader.UnUse(); cout<<"Initialization successfull"<<endl; }
//OpenGL initialization void OnInit() { //load the cubemap shader cubemapShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/cubemap.vert"); cubemapShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/cubemap.frag"); //compile and link shader cubemapShader.CreateAndLinkProgram(); cubemapShader.Use(); //add shader attribute and uniforms cubemapShader.AddAttribute("vVertex"); cubemapShader.AddAttribute("vNormal"); cubemapShader.AddUniform("MVP"); cubemapShader.AddUniform("eyePosition"); cubemapShader.AddUniform("cubeMap"); //set values of constant uniforms at initialization glUniform1i(cubemapShader("cubeMap"), 1); cubemapShader.UnUse(); GL_CHECK_ERRORS //setup sphere geometry createSphere(1,10,10); GL_CHECK_ERRORS //setup sphere vao and vbo stuff glGenVertexArrays(1, &sphereVAOID); glGenBuffers(1, &sphereVerticesVBO); glGenBuffers(1, &sphereIndicesVBO); glBindVertexArray(sphereVAOID); glBindBuffer (GL_ARRAY_BUFFER, sphereVerticesVBO); //pass vertices to the buffer object glBufferData (GL_ARRAY_BUFFER, vertices.size()*sizeof(Vertex), &vertices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attribute array for position glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex),0); GL_CHECK_ERRORS //enable vertex attribute array for normal glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, normal))); GL_CHECK_ERRORS //pass sphere indices to element array buffer glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, sphereIndicesVBO); glBufferData (GL_ELEMENT_ARRAY_BUFFER, indices.size()*sizeof(GLushort), &indices[0], GL_STATIC_DRAW); //generate the dynamic cubemap texture and bind to texture unit 1 glGenTextures(1, &dynamicCubeMapID); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_CUBE_MAP, dynamicCubeMapID); //set texture parameters glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); //for all 6 cubemap faces for (int face = 0; face < 6; face++) { //allocate a different texture for each face and assign to the cubemap texture target glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, GL_RGBA, CUBEMAP_SIZE, CUBEMAP_SIZE, 0, GL_RGBA, GL_FLOAT, NULL); } GL_CHECK_ERRORS //setup FBO glGenFramebuffers(1, &fboID); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboID); //setup render buffer object (RBO) glGenRenderbuffers(1, &rboID); glBindRenderbuffer(GL_RENDERBUFFER, rboID); //set the renderbuffer storage to have the same dimensions as the cubemap texture //also set the renderbuffer as the depth attachment of the FBO glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, CUBEMAP_SIZE, CUBEMAP_SIZE); glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fboID); //set the dynamic cubemap texture as the colour attachment of FBO glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, dynamicCubeMapID, 0); //check the framebuffer completeness status GLenum status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER); if(status != GL_FRAMEBUFFER_COMPLETE) { cerr<<"Frame buffer object setup error."<<endl; exit(EXIT_FAILURE); } else { cerr<<"FBO setup successfully."<<endl; } //unbind FBO glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); //unbind renderbuffer glBindRenderbuffer(GL_RENDERBUFFER, 0); GL_CHECK_ERRORS //create a grid object grid = new CGrid(); //create a unit cube object cube = new CUnitCube(glm::vec3(1,0,0)); GL_CHECK_ERRORS //enable depth testing and back face culling glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); cout<<"Initialization successfull"<<endl; }
//OpenGL initialization function void OnInit() { GL_CHECK_ERRORS //create a uniform grid of size 20x20 in XZ plane grid = new CGrid(20,20); GL_CHECK_ERRORS //create a new TetrahedraMarcher instance marcher = new TetrahedraMarcher(); //set the volume dataset dimensions marcher->SetVolumeDimensions(256,256,256); //load the volume dataset marcher->LoadVolume(volume_file); //set the isosurface value marcher->SetIsosurfaceValue(48); //set the number of sampling voxels marcher->SetNumSamplingVoxels(128,128,128); //begin tetrahedra marching marcher->MarchVolume(); //setup the volume marcher vertex array object and vertex buffer object glGenVertexArrays(1, &volumeMarcherVAO); glGenBuffers(1, &volumeMarcherVBO); glBindVertexArray(volumeMarcherVAO); glBindBuffer (GL_ARRAY_BUFFER, volumeMarcherVBO); //pass the obtained vertices from the tetrahedra marcher and pass to the //buffer object memory glBufferData (GL_ARRAY_BUFFER, marcher->GetTotalVertices()*sizeof(Vertex), marcher->GetVertexPointer(), GL_STATIC_DRAW); //enable vertex attribute array for position glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex),0); //enable vertex attribute array for normals glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,sizeof(Vertex),(const GLvoid*)offsetof(Vertex, normal)); GL_CHECK_ERRORS //load the shader shader.LoadFromFile(GL_VERTEX_SHADER, "shaders/marcher.vert"); shader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/marcher.frag"); //compile and link the shader program shader.CreateAndLinkProgram(); shader.Use(); //add attribute and uniform shader.AddAttribute("vVertex"); shader.AddAttribute("vNormal"); shader.AddUniform("MVP"); shader.UnUse(); GL_CHECK_ERRORS //set the background colour glClearColor(bg.r, bg.g, bg.b, bg.a); //enable depth test and culling glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); cout<<"Initialization successfull"<<endl; }
//OpenGL initialization void OnInit() { GL_CHECK_ERRORS //load shader shader.LoadFromFile(GL_VERTEX_SHADER, "shaders/shader.vert"); shader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/shader.frag"); //compile and link shader shader.CreateAndLinkProgram(); shader.Use(); //add attributes and uniforms shader.AddAttribute("vVertex"); shader.AddUniform("textureMap"); //pass values of constant uniforms at initialization glUniform1i(shader("textureMap"), 0); shader.UnUse(); GL_CHECK_ERRORS //setup quad geometry //setup quad vertices vertices[0] = glm::vec2(0.0,0.0); vertices[1] = glm::vec2(1.0,0.0); vertices[2] = glm::vec2(1.0,1.0); vertices[3] = glm::vec2(0.0,1.0); //fill quad indices array GLushort* id=&indices[0]; *id++ =0; *id++ =1; *id++ =2; *id++ =0; *id++ =2; *id++ =3; GL_CHECK_ERRORS //setup quad vao and vbo stuff glGenVertexArrays(1, &vaoID); glGenBuffers(1, &vboVerticesID); glGenBuffers(1, &vboIndicesID); glBindVertexArray(vaoID); glBindBuffer (GL_ARRAY_BUFFER, vboVerticesID); //pass quad vertices to buffer object glBufferData (GL_ARRAY_BUFFER, sizeof(vertices), &vertices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //enable vertex attribute array for position glEnableVertexAttribArray(shader["vVertex"]); glVertexAttribPointer(shader["vVertex"], 2, GL_FLOAT, GL_FALSE,0,0); GL_CHECK_ERRORS //pass quad indices to element array buffer glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), &indices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS //load the image using SOIL int texture_width = 0, texture_height = 0, channels=0; GLubyte* pData = SOIL_load_image(filename.c_str(), &texture_width, &texture_height, &channels, SOIL_LOAD_AUTO); if(pData == NULL) { cerr<<"Cannot load image: "<<filename.c_str()<<endl; exit(EXIT_FAILURE); } //vertically flip the image on Y axis since it is inverted int i,j; for( j = 0; j*2 < texture_height; ++j ) { int index1 = j * texture_width * channels; int index2 = (texture_height - 1 - j) * texture_width * channels; for( i = texture_width * channels; i > 0; --i ) { GLubyte temp = pData[index1]; pData[index1] = pData[index2]; pData[index2] = temp; ++index1; ++index2; } } //setup OpenGL texture and bind to texture unit 0 glGenTextures(1, &textureID); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textureID); //set texture parameters 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); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); //allocate texture glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, texture_width, texture_height, 0, GL_RGB, GL_UNSIGNED_BYTE, pData); //free SOIL image data SOIL_free_image_data(pData); GL_CHECK_ERRORS cout<<"Initialization successfull"<<endl; }
void InitGL() { glClearColor(1,1,1,1); glGenQueries(1, &query); glGenQueries(1, &t_query); texture_size_x = numX+1; texture_size_y = numY+1; CHECK_GL_ERRORS startTime = (float)glutGet(GLUT_ELAPSED_TIME); // get ticks per second QueryPerformanceFrequency(&frequency); // start timer QueryPerformanceCounter(&t1); size_t i=0, j=0, count=0; int l1=0, l2=0; int v = numY+1; int u = numX+1; printf("Total triangles: %3d\n",numX*numY*2); indices.resize( numX*numY*2*3); X.resize(total_points); X_last.resize(total_points); F.resize(total_points); //fill in positions for(int j=0;j<=numY;j++) { for(int i=0;i<=numX;i++) { X[count] = glm::vec4( ((float(i)/(u-1)) *2-1)* hsize, sizeX+1, ((float(j)/(v-1) )* sizeY),1); X_last[count] = X[count]; count++; } } //fill in indices GLushort* id=&indices[0]; for (int i = 0; i < numY; i++) { for (int j = 0; j < numX; j++) { int i0 = i * (numX+1) + j; int i1 = i0 + 1; int i2 = i0 + (numX+1); int i3 = i2 + 1; if ((j+i)%2) { *id++ = i0; *id++ = i2; *id++ = i1; *id++ = i1; *id++ = i2; *id++ = i3; } else { *id++ = i0; *id++ = i2; *id++ = i3; *id++ = i0; *id++ = i3; *id++ = i1; } } } glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glEnable(GL_CULL_FACE); glEnable(GL_LINE_SMOOTH); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glCullFace(GL_BACK); glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); //Disable vsync wglSwapIntervalEXT(0); // Setup springs // Horizontal for (l1 = 0; l1 < v; l1++) // v for (l2 = 0; l2 < (u - 1); l2++) { AddSpring((l1 * u) + l2,(l1 * u) + l2 + 1,KsStruct,KdStruct); } // Vertical for (l1 = 0; l1 < (u); l1++) for (l2 = 0; l2 < (v - 1); l2++) { AddSpring((l2 * u) + l1,((l2 + 1) * u) + l1,KsStruct,KdStruct); } // Shearing Springs for (l1 = 0; l1 < (v - 1); l1++) for (l2 = 0; l2 < (u - 1); l2++) { AddSpring((l1 * u) + l2,((l1 + 1) * u) + l2 + 1,KsShear,KdShear); AddSpring(((l1 + 1) * u) + l2,(l1 * u) + l2 + 1,KsShear,KdShear); } // Bend Springs for (l1 = 0; l1 < (v); l1++) { for (l2 = 0; l2 < (u - 2); l2++) { AddSpring((l1 * u) + l2,(l1 * u) + l2 + 2,KsBend,KdBend); } AddSpring((l1 * u) + (u - 3),(l1 * u) + (u - 1),KsBend,KdBend); } for (l1 = 0; l1 < (u); l1++) { for (l2 = 0; l2 < (v - 2); l2++) { AddSpring((l2 * u) + l1,((l2 + 2) * u) + l1,KsBend,KdBend); } AddSpring(((v - 3) * u) + l1,((v - 1) * u) + l1,KsBend,KdBend); } massSpringShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/Spring.vp"); particleShader.LoadFromFile(GL_VERTEX_SHADER,"shaders/Basic.vp"); particleShader.LoadFromFile(GL_FRAGMENT_SHADER,"shaders/Basic.fp"); renderShader.LoadFromFile(GL_VERTEX_SHADER,"shaders/Passthrough.vp"); renderShader.LoadFromFile(GL_FRAGMENT_SHADER,"shaders/Passthrough.fp"); massSpringShader.CreateAndLinkProgram(); massSpringShader.Use(); massSpringShader.AddAttribute("position_mass"); massSpringShader.AddAttribute("prev_position"); massSpringShader.AddUniform("tex_position_mass"); massSpringShader.AddUniform("tex_pre_position_mass"); massSpringShader.AddUniform("MVP"); massSpringShader.AddUniform("dt"); massSpringShader.AddUniform("gravity"); massSpringShader.AddUniform("ksStr"); massSpringShader.AddUniform("ksShr"); massSpringShader.AddUniform("ksBnd"); massSpringShader.AddUniform("kdStr"); massSpringShader.AddUniform("kdShr"); massSpringShader.AddUniform("kdBnd"); massSpringShader.AddUniform("DEFAULT_DAMPING"); massSpringShader.AddUniform("texsize_x"); massSpringShader.AddUniform("texsize_y"); massSpringShader.AddUniform("step"); massSpringShader.AddUniform("inv_cloth_size"); massSpringShader.AddUniform("ellipsoid"); glUniform1i(massSpringShader("tex_position_mass"), 0); glUniform1i(massSpringShader("tex_pre_position_mass"), 1); massSpringShader.UnUse(); CHECK_GL_ERRORS particleShader.CreateAndLinkProgram(); particleShader.Use(); particleShader.AddAttribute("position_mass"); particleShader.AddUniform("pointSize"); particleShader.AddUniform("MV"); particleShader.AddUniform("MVP"); particleShader.AddUniform("vColor"); particleShader.AddUniform("selected_index"); glUniform1f(particleShader("pointSize"), pointSize); glUniform4fv(particleShader("vColor"),1, vRed); particleShader.UnUse(); renderShader.CreateAndLinkProgram(); renderShader.Use(); renderShader.AddAttribute("position_mass"); renderShader.AddUniform("MVP"); renderShader.AddUniform("vColor"); glUniform4fv(renderShader("vColor"),1, vGray); renderShader.UnUse(); CHECK_GL_ERRORS //create vbo createVBO(); //setup transform feedback attributes glGenTransformFeedbacks(1, &tfID); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID); const char* varying_names[]={"out_position_mass", "out_prev_position"}; glTransformFeedbackVaryings(massSpringShader.GetProgram(), 2, varying_names, GL_SEPARATE_ATTRIBS); glLinkProgram(massSpringShader.GetProgram()); }
//display callback function void OnRender() { //increment the radius radius+=dx; //if radius is beyond limits, invert the movement direction if(radius<1 || radius>5) dx=-dx; GL_CHECK_ERRORS //clear colour buffer glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the camera transform glm::mat4 T = glm::translate(glm::mat4(1.0f),glm::vec3(0.0f, 0.0f, dist)); glm::mat4 Rx = glm::rotate(T, rX, glm::vec3(1.0f, 0.0f, 0.0f)); glm::mat4 MV = glm::rotate(Rx, rY, glm::vec3(0.0f, 1.0f, 0.0f)); //get the eye position eyePos.x = -(MV[0][0] * MV[3][0] + MV[0][1] * MV[3][1] + MV[0][2] * MV[3][2]); eyePos.y = -(MV[1][0] * MV[3][0] + MV[1][1] * MV[3][1] + MV[1][2] * MV[3][2]); eyePos.z = -(MV[2][0] * MV[3][0] + MV[2][1] * MV[3][1] + MV[2][2] * MV[3][2]); //p is to translate the sphere to bring it to the ground level glm::vec3 p=glm::vec3(0,1,0); //when rendering to the CUBEMAP texture, we move all of cubes by opposite amount //so that the projection is clearly visible T = glm::translate(glm::mat4(1), -p); //set the viewport to the size of the cube map texture glViewport(0,0,CUBEMAP_SIZE,CUBEMAP_SIZE); //bind the FBO glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboID); //set the GL_TEXTURE_CUBE_MAP_POSITIVE_X to the colour attachment of FBO glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, dynamicCubeMapID, 0); //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the virtual viewrer at the reflective object center and render the scene //using the cube map projection matrix and appropriate viewing settings glm::mat4 MV1 = glm::lookAt(glm::vec3(0),glm::vec3(1,0,0), glm::vec3(0,-1,0)); DrawScene( MV1*T, Pcubemap); //set the GL_TEXTURE_CUBE_MAP_NEGATIVE_X to the colour attachment of FBO glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, dynamicCubeMapID, 0); //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the virtual viewrer at the reflective object center and render the scene //using the cube map projection matrix and appropriate viewing settings glm::mat4 MV2 = glm::lookAt(glm::vec3(0),glm::vec3(-1,0,0), glm::vec3(0,-1,0)); DrawScene( MV2*T, Pcubemap); //set the GL_TEXTURE_CUBE_MAP_POSITIVE_Y to the colour attachment of FBO glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, dynamicCubeMapID, 0); //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the virtual viewrer at the reflective object center and render the scene //using the cube map projection matrix and appropriate viewing settings glm::mat4 MV3 = glm::lookAt(glm::vec3(0),glm::vec3(0,1,0), glm::vec3(1,0,0)); DrawScene( MV3*T, Pcubemap); //set the GL_TEXTURE_CUBE_MAP_NEGATIVE_Y to the colour attachment of FBO glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, dynamicCubeMapID, 0); //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the virtual viewrer at the reflective object center and render the scene //using the cube map projection matrix and appropriate viewing settings glm::mat4 MV4 = glm::lookAt(glm::vec3(0),glm::vec3(0,-1,0), glm::vec3(1,0,0)); DrawScene( MV4*T, Pcubemap); //set the GL_TEXTURE_CUBE_MAP_POSITIVE_Z to the colour attachment of FBO glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, dynamicCubeMapID, 0); //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the virtual viewrer at the reflective object center and render the scene //using the cube map projection matrix and appropriate viewing settings glm::mat4 MV5 = glm::lookAt(glm::vec3(0),glm::vec3(0,0,1), glm::vec3(0,-1,0)); DrawScene(MV5*T, Pcubemap); //set the GL_TEXTURE_CUBE_MAP_NEGATIVE_Z to the colour attachment of FBO glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, dynamicCubeMapID, 0); //clear the colour and depth buffers glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //set the virtual viewrer at the reflective object center and render the scene //using the cube map projection matrix and appropriate viewing settings glm::mat4 MV6 = glm::lookAt(glm::vec3(0),glm::vec3(0,0,-1), glm::vec3(0,-1,0)); DrawScene( MV6*T, Pcubemap); //unbind the FBO glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); //reset the default viewport glViewport(0,0,WIDTH,HEIGHT); //render scene from the camera point of view and projection matrix DrawScene(MV, P); //bind the sphere vertex array object glBindVertexArray(sphereVAOID); //use the cubemap shader to render the reflective sphere cubemapShader.Use(); //set the sphere transform T = glm::translate(glm::mat4(1), p); //set the shader uniforms glUniformMatrix4fv(cubemapShader("MVP"), 1, GL_FALSE, glm::value_ptr(P*(MV*T))); glUniform3fv(cubemapShader("eyePosition"), 1, glm::value_ptr(eyePos)); //draw the sphere triangles glDrawElements(GL_TRIANGLES,indices.size(),GL_UNSIGNED_SHORT,0); //unbind shader cubemapShader.UnUse(); //swap front and back buffers to show the rendered result glutSwapBuffers(); }
void RenderGPU_TF() { massSpringShader.Use(); glUniformMatrix4fv(massSpringShader("MVP"), 1, GL_FALSE, glm::value_ptr(mMVP)); glUniform1f(massSpringShader("dt"), timeStep); glUniform3fv(massSpringShader("gravity"),1,&gravity.x); glUniform1f(massSpringShader("ksStr"), KsStruct); glUniform1f(massSpringShader("ksShr"), KsShear); glUniform1f(massSpringShader("ksBnd"), KsBend); glUniform1f(massSpringShader("kdStr"), KdStruct/1000.0f); glUniform1f(massSpringShader("kdShr"), KdShear/1000.0f); glUniform1f(massSpringShader("kdBnd"), KdBend/1000.0f); glUniform1f(massSpringShader("DEFAULT_DAMPING"), DEFAULT_DAMPING); glUniform1i(massSpringShader("texsize_x"),texture_size_x); glUniform1i(massSpringShader("texsize_y"),texture_size_y); glUniform2f(massSpringShader("inv_cloth_size"),float(sizeX)/numX,float(sizeY)/numY); glUniform2f(massSpringShader("step"),1.0f/(texture_size_x-1.0f),1.0f/(texture_size_y-1.0f)); for(int i=0;i<NUM_ITER;i++) { glActiveTexture( GL_TEXTURE0); glBindTexture( GL_TEXTURE_BUFFER, texPosID[writeID]); glActiveTexture( GL_TEXTURE1); glBindTexture( GL_TEXTURE_BUFFER, texPrePosID[writeID]); glBindVertexArray( vaoUpdateID[writeID]); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vboID_Pos[readID]); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, vboID_PrePos[readID]); glEnable(GL_RASTERIZER_DISCARD); // disable rasterization glBeginQuery(GL_TIME_ELAPSED,t_query); glBeginTransformFeedback(GL_POINTS); glDrawArrays(GL_POINTS, 0, total_points); glEndTransformFeedback(); glEndQuery(GL_TIME_ELAPSED); glFlush(); glDisable(GL_RASTERIZER_DISCARD); int tmp = readID; readID=writeID; writeID = tmp; } // get the query result glGetQueryObjectui64v(t_query, GL_QUERY_RESULT, &elapsed_time); delta_time = elapsed_time / 1000000.0f; massSpringShader.UnUse(); CHECK_GL_ERRORS; glBindVertexArray(vaoRenderID[writeID]); glDisable(GL_DEPTH_TEST); renderShader.Use(); glUniformMatrix4fv(renderShader("MVP"), 1, GL_FALSE, glm::value_ptr(mMVP)); glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT,0); renderShader.UnUse(); glEnable(GL_DEPTH_TEST); if(bDisplayMasses) { particleShader.Use(); glUniform1i(particleShader("selected_index"), selected_index); glUniformMatrix4fv(particleShader("MV"), 1, GL_FALSE, glm::value_ptr(mMV)); glUniformMatrix4fv(particleShader("MVP"), 1, GL_FALSE, glm::value_ptr(mMVP)); //draw the masses last glDrawArrays(GL_POINTS, 0, total_points); //glDrawTransformFeedbackStream(GL_POINTS, tfID, 0); particleShader.UnUse(); } glBindVertexArray( 0); CHECK_GL_ERRORS }