// The MAIN function, from here we start our application and run our Game loop int main() { // Init GLFW glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", nullptr, nullptr); // Windowed glfwMakeContextCurrent(window); // Set the required callback functions glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); // Options glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // Initialize GLEW to setup the OpenGL Function pointers glewExperimental = GL_TRUE; glewInit(); // Define the viewport dimensions glViewport(0, 0, SCR_WIDTH*2, SCR_HEIGHT*2); // Setup some OpenGL options glEnable(GL_DEPTH_TEST); // Setup and compile our shaders Shader shader("shaders/advanced_lighting.vs", "shaders/advanced_lighting.frag"); GLfloat planeVertices[] = { // Positions // Normals // Texture Coords 8.0f, -0.5f, 8.0f, 0.0f, 1.0f, 0.0f, 5.0f, 0.0f, -8.0f, -0.5f, 8.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, -8.0f, -0.5f, -8.0f, 0.0f, 1.0f, 0.0f, 0.0f, 5.0f, 8.0f, -0.5f, 8.0f, 0.0f, 1.0f, 0.0f, 5.0f, 0.0f, -8.0f, -0.5f, -8.0f, 0.0f, 1.0f, 0.0f, 0.0f, 5.0f, 8.0f, -0.5f, -8.0f, 0.0f, 1.0f, 0.0f, 5.0f, 5.0f }; // Setup plane VAO GLuint planeVAO, planeVBO; glGenVertexArrays(1, &planeVAO); glGenBuffers(1, &planeVBO); glBindVertexArray(planeVAO); glBindBuffer(GL_ARRAY_BUFFER, planeVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), &planeVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); glBindVertexArray(0); // Light source glm::vec3 lightPos(0.0f, 0.0f, 0.0f); // Load textures GLuint floorTexture = loadTexture("resources/textures/wood.png"); /*-------------------Load models--------------------*/ Model ourModel("resources/objects/nanosuit/nanosuit.obj"); Shader model_shader("shaders/model_shader.vs", "shaders/model_shader.frag"); /*--------------------------------------------------*/ // Game loop while(!glfwWindowShouldClose(window)) { // Set frame time GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; // Check and call events glfwPollEvents(); Do_Movement(); // Clear the colorbuffer glClearColor(0.1f, 0.1f, 0.1f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Draw objects shader.Use(); glm::mat4 view = camera.GetViewMatrix(); glm::mat4 projection = glm::perspective(camera.Zoom, (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection)); // Set light uniforms glUniform3fv(glGetUniformLocation(shader.Program, "lightPos"), 1, &lightPos[0]); glUniform3fv(glGetUniformLocation(shader.Program, "viewPos"), 1, &camera.Position[0]); glUniform1i(glGetUniformLocation(shader.Program, "blinn"), blinn); // Floor glBindVertexArray(planeVAO); glBindTexture(GL_TEXTURE_2D, floorTexture); glDrawArrays(GL_TRIANGLES, 0, 6); glBindVertexArray(0); model_shader.Use(); // Transformation matrices glUniformMatrix4fv(glGetUniformLocation(model_shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection)); glUniformMatrix4fv(glGetUniformLocation(model_shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view)); // Draw the loaded model glm::mat4 model; //model = glm::translate(model, glm::vec3(0.0f, -1.75f, 0.0f)); // Translate it down a bit so it's at the center of the scene //model = glm::scale(model, glm::vec3(0.2f, 0.2f, 0.2f)); // It's a bit too big for our scene, so scale it down glUniformMatrix4fv(glGetUniformLocation(model_shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); ourModel.Draw(model_shader); //std::cout << (blinn ? "true" : "false") << std::endl; // Swap the buffers glfwSwapBuffers(window); } glfwTerminate(); return 0; }
/*!**************************************************************************** @Function InitView @Return bool true if no error occured @Description Code in InitView() will be called by PVRShell upon initialization or after a change in the rendering context. Used to initialize variables that are dependant on the rendering context (e.g. textures, vertex buffers, etc.) ******************************************************************************/ bool OGLES2StencilBuffer::InitView() { CPVRTString ErrorStr; /* Initialize VBO data */ m_Cylinder.LoadVbos(); m_Sphere.LoadVbos(); /* Load textures */ if (!LoadTextures(&ErrorStr)) { PVRShellSet(prefExitMessage, ErrorStr.c_str()); return false; } /* Load and compile the shaders & link programs */ if (!LoadShaders(&ErrorStr)) { PVRShellSet(prefExitMessage, ErrorStr.c_str()); return false; } // Set the sampler2D uniforms to corresponding texture units glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sTexture"), 0); // Is the screen rotated? bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen); /* Initialize Print3D */ if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n"); return false; } /* Set OpenGL ES render states needed for this training course */ // Enable backface culling and depth test glCullFace(GL_BACK); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); // Use a nice bright blue as clear colour glClearColor(0.6f, 0.8f, 1.0f, 1.0f); // Set stencil clear value glClearStencil(0); return true; }
void Uniform::set1i(GLint x) { glUniform1i(uniformLocation, x); }
void templateAppDraw(void) { glClearColor(0.5f, 0.5f, 0.5f, 1.0f); glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); gfx->set_matrix_mode(MODELVIEW_MATRIX); gfx->load_identity(); if (view_delta->x || view_delta->y) { if (view_delta->y) next_rotz -= view_delta->y; if (view_delta->x) { next_rotx -= view_delta->x; next_rotx = CLAMP(next_rotx, 0.0f, 90.0f); } view_delta->x = view_delta->y = 0.0f; } rotx = rotx * 0.9f + next_rotx * 0.1f; rotz = rotz * 0.9f + next_rotz * 0.1f; eye->x = center->x + distance * cosf(rotx * DEG_TO_RAD) * sinf(rotz * DEG_TO_RAD); eye->y = center->y - distance * cosf(rotx * DEG_TO_RAD) * cosf(rotz * DEG_TO_RAD); eye->z = center->z + distance * sinf(rotx * DEG_TO_RAD); rotx = rotx * 0.9f + next_rotx * 0.1f; rotz = rotz * 0.9f + next_rotz * 0.1f; center = maze->location; gfx->look_at(eye, center, up); if (double_tap) { /* Variable to hold the 3D location on the far plane of the frustum. */ vec3 location; /* This function converts a 2D point from the screen coordinates * to a 3D point in space. The return value is true or false, depending on * whether or not the query is successful. It's a GFX helper, but built * basically the same way as the standard gluUnproject * (http://www.opengl.org/sdk/docs/man/xhtml/gluUnproject.xml) * function. */ if (gfx->unproject(view_location->x, /* The origin of the OpenGLES color buffer is down * left, but its location for iOS and Android is up * left. To handle this situation, simply use the * viewport matrix height data (viewport_matrix[3]) * to readjust the Y location of the picking point * onscreen. */ viewport_matrix[3] - view_location->y, /* This parameter represents the depth that you want * to query, with 1 representing the far clipping * plane and 0 representing the near clipping plane. * In this case, you are only interested in the far * clipping plane value, which explains the value 1. */ 1.0f, gfx->get_modelview_matrix(), gfx->get_projection_matrix(), viewport_matrix, location)) { /* Now that you have the XYZ location on the far plane, you can * create the collision ray. Begin by creating the starting point, * which is basically the current camera eye position. */ btVector3 ray_from(eye->x, eye->y, eye->z), /* Translate the resulting location of GFX::unproject based on the * current eye location to make sure that the coordinate system * will fit with what the player currently sees onscreen. */ ray_to(location->x + eye->x, location->y + eye->y, location->z + eye->z); /* Create the collision ray. */ btCollisionWorld::ClosestRayResultCallback collision_ray(ray_from, ray_to); /* Launch the ray in space. */ dynamicsworld->rayTest(ray_from, ray_to, collision_ray); /* Check if the collision ray gets a hit, and check if the * collision object involved is the maze btRigidBody. */ if (collision_ray.hasHit() && collision_ray.m_collisionObject == maze->btrigidbody) { collision_ray.m_hitNormalWorld.normalize(); /* Check if the normal Z is pointing upward to make sure * the hit is on the floor of the maze. */ if (collision_ray.m_hitNormalWorld.z() == 1.0f) { /* Since you got a valid hit, it is time to create the * pathfinding query to send to Detour. First, assign * the current player location as the starting point of * the query. */ navigationpath_player.start_location = player->location; /* Then simply use the collision ray hit position XYZ as * the end point of the path query. */ navigationpath_player.end_location->x = collision_ray.m_hitPointWorld.x(); navigationpath_player.end_location->y = collision_ray.m_hitPointWorld.y(); navigationpath_player.end_location->z = collision_ray.m_hitPointWorld.z(); /* The query is ready to be sent to Detour, so send it over. * If Detour was able to find a path, the function will * return 1 and will store the way points information * inside the navigationpathdata_player variable; othewise * the function will return 0. */ if (navigation->get_path(&navigationpath_player, &navigationpathdata_player)) { player_next_point = 1; /* Loop while you've got some way points. Please note * that by default, the function will assign the number * of path_point_count to be the way points returned by * Detour. However, the function implementation added * another point which is the exact same end location * that you specified in your query. The reason is * that, most of the time, the ending point not exactly * on the mavigation mesh, so the library will return * the closest pont. Depending on what you want to * achieve, you may or may not want to use this extra * way point. But for this tutorial, you are going to * take it into consideration. */ for (int i=0; i!=navigationpathdata_player.path_point_count + 1; ++i) console_print("%d: %f %f %f\n", i, navigationpathdata_player.path_point_array[i]->x, navigationpathdata_player.path_point_array[i]->y, navigationpathdata_player.path_point_array[i]->z); printf("\n"); } } } } double_tap = 0; } if (navigationpathdata_player.path_point_count) { move_entity(player, // The player OBJMESH pointer. &navigationpathdata_player, // The player navigation path // structure. &player_next_point, // The way point the player is // moving towards. 3.0f); // The speed to use as factor // to the linear velocity of // the btRigidBody. } program->draw(); glUniform1i(program->get_uniform_location(TM_Diffuse_String), TM_Diffuse); for (auto objmesh=obj->objmesh.begin(); objmesh!=obj->objmesh.end(); ++objmesh) { gfx->push_matrix(); mat4 mat; objmesh->btrigidbody->getWorldTransform().getOpenGLMatrix(mat.m()); objmesh->location = vec3(mat[3], true); gfx->multiply_matrix(mat); glUniformMatrix4fv(program->get_uniform_location((char *)"MODELVIEWPROJECTIONMATRIX"), 1, GL_FALSE, gfx->get_modelview_projection_matrix().m()); objmesh->draw(); gfx->pop_matrix(); } navigation->draw(gfx); dynamicsworld->stepSimulation(1.0f / 60.0f); }
void outPut::drawTerrain(bool reinit) { static bool lastwfStatus(!_reg.WIREFRAME); if(lastwfStatus != _reg.WIREFRAME) { if(_reg.WIREFRAME) { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glLineWidth(1); } else { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); }} lastwfStatus = _reg.WIREFRAME; static bool init(true); static VA terrain; static GLuint buf_pos, buf_norm, buf_cost, buf_index; unsigned int nbVertices = _dimensions.x*_dimensions.y; unsigned int nbIndex = (_dimensions.x-1)*(_dimensions.y-1)*6; //nbIndex = nbVertices; /*Chaque vertex est associé à une maille qui 'coûte' 6 indices en mémoire : _ |\| -> deux triangles, avec 3 indices par triangle. On enlève une ligne et une colonne parce que ceux sur les côtés n'entrainent pas une maille. +- */ if(init || reinit) { gen_verticesMap(); drawNormals(true); glDeleteBuffers(1,&buf_pos); glDeleteBuffers(1,&buf_norm); glDeleteBuffers(1,&buf_cost); glDeleteBuffers(1,&buf_index); delete terrain.verticesA; delete terrain.normalsA; delete terrain.costsA; delete terrain.indexA; terrain.verticesA = new float[nbVertices*P_SIZE]; terrain.normalsA = new float[nbVertices*N_SIZE]; terrain.costsA = new int[nbVertices*C_SIZE]; terrain.indexA = new unsigned int[nbIndex]; ///Remplissage des tableaux de sommets et de coûts for(unsigned int i = 0; i < _dimensions.x; i++) { for(unsigned int j = 0; j < _dimensions.y; j++) { coords3d<float> vertex(0,0,0), normal(0,0,0); vertex = getVertex<float>(i,j); normal = _scene3d.normalMap[i][j]; int vertexPos = (i*_dimensions.y+j); terrain.verticesA[vertexPos*P_SIZE] = vertex.x; terrain.verticesA[vertexPos*P_SIZE+1] = vertex.y; terrain.verticesA[vertexPos*P_SIZE+2] = vertex.z; terrain.normalsA[vertexPos*P_SIZE] = normal.x; terrain.normalsA[vertexPos*P_SIZE+1] = normal.y; terrain.normalsA[vertexPos*P_SIZE+2] = normal.z; terrain.costsA[vertexPos*C_SIZE] = -1; } } ///Remplissage de l'index for(unsigned int i = 0; i < _dimensions.x-1; i++) { for(unsigned int j = 0; j < _dimensions.y-1; j++) { terrain.indexA[((i*(_dimensions.y-1))+j)*6] = i*_dimensions.y+j; terrain.indexA[((i*(_dimensions.y-1))+j)*6+2] = i*_dimensions.y+j+1; terrain.indexA[((i*(_dimensions.y-1))+j)*6+1] = (i+1)*_dimensions.y+j; terrain.indexA[((i*(_dimensions.y-1))+j)*6+3] = i*_dimensions.y+j+1; terrain.indexA[((i*(_dimensions.y-1))+j)*6+4] = (i+1)*_dimensions.y+j; terrain.indexA[((i*(_dimensions.y-1))+j)*6+5] = (i+1)*_dimensions.y+j+1; //cout << "\nindice max : " << ((i*(_dimensions.y-1))+j)*6+5 << " / " << nbIndex; } } /* creation de nos VBO+IBO */ glGenBuffers(1, &buf_pos); glGenBuffers(1, &buf_cost); glGenBuffers(1, &buf_norm); glGenBuffers(1, &buf_index); /* construction du VBO de positions */ glBindBuffer(GL_ARRAY_BUFFER, buf_pos); glBufferData(GL_ARRAY_BUFFER, (nbVertices*P_SIZE*sizeof *terrain.verticesA), NULL, GL_STREAM_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*P_SIZE*sizeof *terrain.verticesA), terrain.verticesA); /* construction du VBO de normales */ glBindBuffer(GL_ARRAY_BUFFER, buf_norm); glBufferData(GL_ARRAY_BUFFER, (nbVertices*N_SIZE*sizeof *terrain.normalsA), NULL, GL_STREAM_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*N_SIZE*sizeof *terrain.normalsA), terrain.normalsA); /* construction du VBO de coûts */ glBindBuffer(GL_ARRAY_BUFFER, buf_cost); glBufferData(GL_ARRAY_BUFFER, (nbVertices*C_SIZE*sizeof *terrain.costsA), NULL, GL_STREAM_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*C_SIZE*sizeof *terrain.costsA), terrain.costsA); /* construction du IBO */ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf_index); glBufferData(GL_ELEMENT_ARRAY_BUFFER, nbIndex * sizeof *terrain.indexA, NULL, GL_STREAM_DRAW); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, nbIndex * sizeof *terrain.indexA, terrain.indexA); //On debind les VBO+IBO glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); _maxValue = 1; // cout<<"\n(re)initialisation de l'affichage du terrain reussie\n"; init = false; _valueChanges.clear(); } drawAxis(); glBindBuffer(GL_ARRAY_BUFFER, buf_cost); for(unsigned int i = 0; i < _valueChanges.size(); ++i) { int newCost = _valueChanges[i].value; //newCost = 2; //std::cout << newCost << "/" << _maxValue << std::endl; glBufferSubData(GL_ARRAY_BUFFER, (_valueChanges[i].x*_dimensions.y + _valueChanges[i].y)*(sizeof newCost)*C_SIZE, (sizeof newCost), &newCost); //terrain.costsA[_valueChanges[i].x*_dimensions.y + _valueChanges[i].y] = newCost; } /* glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*C_SIZE*sizeof *terrain.costsA), terrain.costsA);*/ catchError("application de changements de couleur"); _valueChanges.clear(); glEnable(GL_DEPTH_TEST); if(_reg.DRAW_NORMALS) drawNormals(); glUseProgram(_sLight.getProgramID()); //Envoi des uniforms glUniform1i(uid_maxCost, _maxValue); catchError("Envoi de la valeur max"); glUniform3f(uid_defaultColor, _reg.UNIFORM_COLOR[0],_reg.UNIFORM_COLOR[1],_reg.UNIFORM_COLOR[2]); /* specification du buffer des positions de sommets */ glEnableVertexAttribArray(aID_position); glBindBuffer(GL_ARRAY_BUFFER, buf_pos); glVertexAttribPointer(aID_position, P_SIZE , GL_FLOAT, 0, 0, BUFFER_OFFSET(0) ); /* specification du buffer des normales de sommets */ glEnableVertexAttribArray(aID_normal); glBindBuffer(GL_ARRAY_BUFFER, buf_norm); glVertexAttribPointer(aID_normal, N_SIZE , GL_FLOAT, 0, 0, BUFFER_OFFSET(0) ); /* specification du buffer des coûts de sommets */ glEnableVertexAttribArray(aID_cost); glBindBuffer(GL_ARRAY_BUFFER, buf_cost); glVertexAttribIPointer(aID_cost, C_SIZE, GL_INT, 0, BUFFER_OFFSET(0)); /*Spécification de l'index*/ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf_index); glEnableClientState(GL_VERTEX_ARRAY); glDrawElements(GL_TRIANGLES, nbIndex, GL_UNSIGNED_INT, BUFFER_OFFSET(0)); glDisableVertexAttribArray(aID_position); glDisableVertexAttribArray(aID_normal); glDisableVertexAttribArray(aID_cost); //On debind les VBO+IBO glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glDisableVertexAttribArray(aID_position); glDisableVertexAttribArray(aID_normal); glDisableVertexAttribArray(aID_cost); glUseProgram(0); }
void myinit(void) { // Load shaders and use the resulting shader program GLuint program = InitShader( "vshader.glsl", "fshader.glsl" ); glUseProgram(program); // Generate vertex arrays for geometric shapes generateCube(program, &cubeData); generateSphere(program, &sphereData); generateCone(program, &coneData); generateCylinder(program, &cylData); uModelView = glGetUniformLocation( program, "ModelView" ); uProjection = glGetUniformLocation( program, "Projection" ); uView = glGetUniformLocation( program, "View" ); glClearColor( 0.1, 0.1, 0.2, 1.0 ); // dark blue background uAmbient = glGetUniformLocation( program, "AmbientProduct" ); uDiffuse = glGetUniformLocation( program, "DiffuseProduct" ); uSpecular = glGetUniformLocation( program, "SpecularProduct" ); uLightPos = glGetUniformLocation( program, "LightPosition" ); uShininess = glGetUniformLocation( program, "Shininess" ); uTex = glGetUniformLocation( program, "Tex" ); uEnableTex = glGetUniformLocation( program, "EnableTex" ); glUniform4f(uAmbient, 0.2f, 0.2f, 0.2f, 1.0f); glUniform4f(uDiffuse, 0.6f, 0.6f, 0.6f, 1.0f); glUniform4f(uSpecular, 0.2f, 0.2f, 0.2f, 1.0f); glUniform4f(uLightPos, 15.0f, 15.0f, 30.0f, 0.0f); glUniform1f(uShininess, 100.0f); glEnable(GL_DEPTH_TEST); TgaImage coolImage; if (!coolImage.loadTGA("challenge.tga")) { printf("Error loading image file\n"); exit(1); } TgaImage earthImage; if (!earthImage.loadTGA("earth.tga")) { printf("Error loading image file\n"); exit(1); } glGenTextures( 1, &texture_cube ); glBindTexture( GL_TEXTURE_2D, texture_cube ); glTexImage2D(GL_TEXTURE_2D, 0, 4, coolImage.width, coolImage.height, 0, (coolImage.byteCount == 3) ? GL_BGR : GL_BGRA, GL_UNSIGNED_BYTE, coolImage.data ); glGenerateMipmap(GL_TEXTURE_2D); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glGenTextures( 1, &texture_earth ); glBindTexture( GL_TEXTURE_2D, texture_earth ); glTexImage2D(GL_TEXTURE_2D, 0, 4, earthImage.width, earthImage.height, 0, (earthImage.byteCount == 3) ? GL_BGR : GL_BGRA, GL_UNSIGNED_BYTE, earthImage.data ); glGenerateMipmap(GL_TEXTURE_2D); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); //glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); //glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Set texture sampler variable to texture unit 0 // (set in glActiveTexture(GL_TEXTURE0)) glUniform1i( uTex, 0); Arcball = new BallData ; Ball_Init(Arcball); Ball_Place(Arcball,qOne,0.75); }
// ---------------------------------------------------------------- display --- void display( void ) { static int frame=0, time, timebase=0; static int count = 0; static GLuint texture = 0; if( !texture ) { texture = glGetUniformLocation( shader, "texture" ); } if( count == 0 && frame == 0 ) { printf( "Computing FPS with text generation and rendering at each frame...\n" ); printf( "Number of glyphs: %d\n", (int)wcslen(text)*line_count ); } frame++; time = glutGet( GLUT_ELAPSED_TIME ); if( time-timebase > (2500) ) { printf( "FPS : %.2f (%d frames in %.2f second, %.1f glyph/second)\n", frame*1000.0/(time-timebase), frame, (time-timebase)/1000.0, frame*1000.0/(time-timebase) * wcslen(text)*line_count ); timebase = time; frame = 0; ++count; if( count == 5 ) { printf( "\nComputing FPS with text rendering at each frame...\n" ); printf( "Number of glyphs: %d\n", (int)wcslen(text)*line_count ); } if( count > 9 ) { exit( EXIT_SUCCESS ); } } if( count < 5 ) { size_t i; vec4 color = {{0,0,0,1}}; vec2 pen = {{0,0}}; vertex_buffer_clear( buffer ); pen.y = -font->descender; for( i=0; i<line_count; ++i ) { pen.x = 10.0; add_text( buffer, font, text, &color, &pen ); pen.y += font->height - font->linegap; } } glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glBindTexture( GL_TEXTURE_2D, atlas->id ); glUseProgram( shader ); glUniform1i(texture, 0); vertex_buffer_render( buffer, GL_TRIANGLES ); glUseProgram( 0 ); glutSwapBuffers( ); }
// The MAIN function, from here we start the application and run the game loop int main() { // Init GLFW glfwInit(); // Set all the required options for GLFW glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // Create a GLFWwindow object that we can use for GLFW's functions GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr); glfwMakeContextCurrent(window); // Set the required callback functions glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); // GLFW Options glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions glewExperimental = GL_TRUE; // Initialize GLEW to setup the OpenGL Function pointers glewInit(); // Define the viewport dimensions glViewport(0, 0, WIDTH, HEIGHT); // OpenGL options glEnable(GL_DEPTH_TEST); // Build and compile our shader program Shader lightingShader("light_casters.vs", "light_casters.frag"); Shader lampShader("lamp.vs", "lamp.frag"); // Set up vertex data (and buffer(s)) and attribute pointers GLfloat vertices[] = { // Positions // Normals // Texture Coords -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f }; // Positions all containers glm::vec3 cubePositions[] = { glm::vec3( 0.0f, 0.0f, 0.0f), glm::vec3( 2.0f, 5.0f, -15.0f), glm::vec3(-1.5f, -2.2f, -2.5f), glm::vec3(-3.8f, -2.0f, -12.3f), glm::vec3( 2.4f, -0.4f, -3.5f), glm::vec3(-1.7f, 3.0f, -7.5f), glm::vec3( 1.3f, -2.0f, -2.5f), glm::vec3( 1.5f, 2.0f, -2.5f), glm::vec3( 1.5f, 0.2f, -1.5f), glm::vec3(-1.3f, 1.0f, -1.5f) }; // First, set the container's VAO (and VBO) GLuint VBO, containerVAO; glGenVertexArrays(1, &containerVAO); glGenBuffers(1, &VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBindVertexArray(containerVAO); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); glEnableVertexAttribArray(2); glBindVertexArray(0); // Then, we set the light's VAO (VBO stays the same. After all, the vertices are the same for the light object (also a 3D cube)) GLuint lightVAO; glGenVertexArrays(1, &lightVAO); glBindVertexArray(lightVAO); // We only need to bind to the VBO (to link it with glVertexAttribPointer), no need to fill it; the VBO's data already contains all we need. glBindBuffer(GL_ARRAY_BUFFER, VBO); // Set the vertex attributes (only position data for the lamp)) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); // Note that we skip over the other data in our buffer object (we don't need the normals/textures, only positions). glEnableVertexAttribArray(0); glBindVertexArray(0); // Load textures GLuint diffuseMap, specularMap, emissionMap; glGenTextures(1, &diffuseMap); glGenTextures(1, &specularMap); glGenTextures(1, &emissionMap); int width, height; unsigned char* image; // Diffuse map image = SOIL_load_image(FileSystem::getPath("resources/textures/container2.png").c_str(), &width, &height, 0, SOIL_LOAD_RGB); glBindTexture(GL_TEXTURE_2D, diffuseMap); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST); // Specular map image = SOIL_load_image(FileSystem::getPath("resources/textures/container2_specular.png").c_str(), &width, &height, 0, SOIL_LOAD_RGB); glBindTexture(GL_TEXTURE_2D, specularMap); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST); glBindTexture(GL_TEXTURE_2D, 0); // Set texture units lightingShader.Use(); glUniform1i(glGetUniformLocation(lightingShader.Program, "material.diffuse"), 0); glUniform1i(glGetUniformLocation(lightingShader.Program, "material.specular"), 1); // Game loop while (!glfwWindowShouldClose(window)) { // Calculate deltatime of current frame GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; // Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions glfwPollEvents(); do_movement(); // Clear the colorbuffer glClearColor(0.1f, 0.1f, 0.1f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Use cooresponding shader when setting uniforms/drawing objects lightingShader.Use(); GLint lightPosLoc = glGetUniformLocation(lightingShader.Program, "light.position"); GLint lightSpotdirLoc = glGetUniformLocation(lightingShader.Program, "light.direction"); GLint lightSpotCutOffLoc = glGetUniformLocation(lightingShader.Program, "light.cutOff"); GLint lightSpotOuterCutOffLoc = glGetUniformLocation(lightingShader.Program, "light.outerCutOff"); GLint viewPosLoc = glGetUniformLocation(lightingShader.Program, "viewPos"); glUniform3f(lightPosLoc, camera.Position.x, camera.Position.y, camera.Position.z); glUniform3f(lightSpotdirLoc, camera.Front.x, camera.Front.y, camera.Front.z); glUniform1f(lightSpotCutOffLoc, glm::cos(glm::radians(12.5f))); glUniform1f(lightSpotOuterCutOffLoc, glm::cos(glm::radians(17.5f))); glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z); // Set lights properties glUniform3f(glGetUniformLocation(lightingShader.Program, "light.ambient"), 0.1f, 0.1f, 0.1f); // We set the diffuse intensity a bit higher; note that the right lighting conditions differ with each lighting method and environment. // Each environment and lighting type requires some tweaking of these variables to get the best out of your environment. glUniform3f(glGetUniformLocation(lightingShader.Program, "light.diffuse"), 0.8f, 0.8f, 0.8f); glUniform3f(glGetUniformLocation(lightingShader.Program, "light.specular"), 1.0f, 1.0f, 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "light.constant"), 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "light.linear"), 0.09); glUniform1f(glGetUniformLocation(lightingShader.Program, "light.quadratic"), 0.032); // Set material properties glUniform1f(glGetUniformLocation(lightingShader.Program, "material.shininess"), 32.0f); // Create camera transformations glm::mat4 view; view = camera.GetViewMatrix(); glm::mat4 projection = glm::perspective(camera.Zoom, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f); // Get the uniform locations GLint modelLoc = glGetUniformLocation(lightingShader.Program, "model"); GLint viewLoc = glGetUniformLocation(lightingShader.Program, "view"); GLint projLoc = glGetUniformLocation(lightingShader.Program, "projection"); // Pass the matrices to the shader glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); // Bind diffuse map glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, diffuseMap); // Bind specular map glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, specularMap); // Draw the container (using container's vertex attributes) /*glBindVertexArray(containerVAO); glm::mat4 model; glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0);*/ // Draw 10 containers with the same VAO and VBO information; only their world space coordinates differ glm::mat4 model; glBindVertexArray(containerVAO); for (GLuint i = 0; i < 10; i++) { model = glm::mat4(); model = glm::translate(model, cubePositions[i]); GLfloat angle = 20.0f * i; model = glm::rotate(model, angle, glm::vec3(1.0f, 0.3f, 0.5f)); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 36); } glBindVertexArray(0); // Again, no need to draw the lamp object // Also draw the lamp object, again binding the appropriate shader //lampShader.Use(); //// Get location objects for the matrices on the lamp shader (these could be different on a different shader) //modelLoc = glGetUniformLocation(lampShader.Program, "model"); //viewLoc = glGetUniformLocation(lampShader.Program, "view"); //projLoc = glGetUniformLocation(lampShader.Program, "projection"); //// Set matrices //glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); //glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); //model = glm::mat4(); //model = glm::translate(model, lightPos); //model = glm::scale(model, glm::vec3(0.2f)); // Make it a smaller cube //glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); //// Draw the light object (using light's vertex attributes) //glBindVertexArray(lightVAO); //glDrawArrays(GL_TRIANGLES, 0, 36); //glBindVertexArray(0); // Swap the screen buffers glfwSwapBuffers(window); } // Terminate GLFW, clearing any resources allocated by GLFW. glfwTerminate(); return 0; }
void SSEffect::render(GLuint posVBO, GLuint colVBO, unsigned int num, RTPSSettings* settings, const Light* light,const Material* material, float scale, GLuint sceneTex, GLuint sceneDepthTex, GLuint framebuffer) { if(num==0) return; glPushAttrib(GL_ALL_ATTRIB_BITS); glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); currentDepthBuffer="depth"; bool blending = settings->GetSettingAs<bool>("blending","1"); //QT send 2 for check boxes when enable(due to the possiblity of adding a tristate option. //Apparently the default string-to-bool conversion is true for 1 and false otherwise //I need it to be false for 0 and true otherwise. //bool thickness = !settings->GetSettingAs<int>("thickness","1"); bool thickness = settings->GetSettingAs<bool>("thickness","1"); //perserve original buffer GLint buffer; glGetIntegerv(GL_DRAW_BUFFER,&buffer); glClearColor(0.0f,0.0f,0.0f,0.0f); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,m_fbos[0]); glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); glActiveTexture(GL_TEXTURE0); glDisable(GL_TEXTURE_2D); //Should probably conditionally create the thickness buffer as well. //Render Thickness buffer. if(thickness) { m_timers["render_thickness"]->start(); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); //give the fluid some thickness everywhere glClearColor(0.1f,0.1f,0.1f,1.0f); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"],0); //glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); glClear(GL_COLOR_BUFFER_BIT); renderPointsAsSpheres( m_shaderLibrary->shaders["sphereThicknessShader"].getProgram(),posVBO, colVBO, num,settings, light,material,scale); //renderPointsAsSpheres( m_shaderLibrary->shaders["sphereShader"].getProgram(),posVBO, colVBO, num,settings, light,material,scale); glFinish(); m_timers["render_thickness"]->stop(); m_timers["blur_thickness"]->start(); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness2"],0); GLuint program= m_shaderLibrary->shaders["fixedWidthGaussianShader"].getProgram(); glEnable(GL_TEXTURE_2D); float xdir[] = {1.0f/height,0.0f}; float ydir[] = {0.0f,1.0f/width}; glUseProgram(program); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]); glUniform1i( glGetUniformLocation(program, "imgTex"),0); glUniform2fv( glGetUniformLocation(program, "dTex"),1,xdir); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); RenderUtils::fullscreenQuad(); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"],0); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness2"]); glUniform2fv( glGetUniformLocation(program, "dTex"),1,ydir); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); RenderUtils::fullscreenQuad(); glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDisable(GL_TEXTURE_2D); glFinish(); m_timers["blur_thickness"]->stop(); } //glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,framebuffer); m_timers["render_spheres"]->start(); //Render Color and depth buffer of spheres. glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0); glEnable(GL_TEXTURE_2D); GLuint sphereProgram = m_shaderLibrary->shaders["sphereShader"].getProgram(); glBindTexture(GL_TEXTURE_2D,sceneDepthTex); glUseProgram(sphereProgram); glUniform1i(glGetUniformLocation(sphereProgram,"sceneDepth"),0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderPointsAsSpheres(sphereProgram,posVBO, colVBO, num,settings, light,material,scale); glFinish(); m_timers["render_spheres"]->stop(); //Smooth the depth texture to emulate a surface. m_timers["smooth_depth"]->start(); //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth2"],0); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth"]); currentDepthBuffer="depth2"; glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); smoothDepth(settings); glFinish(); m_timers["smooth_depth"]->stop(); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0); //Switch to the buffer that was written to in the smoothing step if(currentDepthBuffer=="depth2") currentDepthBuffer="depth"; else currentDepthBuffer="depth2"; glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); //if (blending) //{ //glDepthMask(GL_FALSE); // glEnable(GL_BLEND); // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //} glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"],0); m_timers["calculate_normals"]->start(); //Now we use the depth to normal shader which converts screenspace depth into //world coordinates and then computes lighting. glClear(GL_COLOR_BUFFER_BIT); GLuint normalProgram = m_shaderLibrary->shaders["depth2NormalShader"].getProgram(); glUseProgram(normalProgram); glUniform1i( glGetUniformLocation(normalProgram, "depthTex"),0); glUniform1f( glGetUniformLocation(normalProgram, "del_x"),1.0/((float)width)); glUniform1f( glGetUniformLocation(normalProgram, "del_y"),1.0/((float)height)); RenderUtils::fullscreenQuad(); glFinish(); m_timers["calculate_normals"]->stop(); m_timers["render_composite"]->start(); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0); GLuint compositeProgram = m_shaderLibrary->shaders["compositeFluidShader"].getProgram(); glUseProgram(compositeProgram); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"]); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D,sceneTex); glUniform1i( glGetUniformLocation(compositeProgram, "depthTex"),0); glUniform1i( glGetUniformLocation(compositeProgram, "normalTex"),1); glUniform1i( glGetUniformLocation(compositeProgram, "thicknessTex"),2); glUniform1i( glGetUniformLocation(compositeProgram, "sceneTex"),3); glUniform1f( glGetUniformLocation(compositeProgram, "gamma"),settings->GetSettingAs<float>("thickness_gamma","0.1")); //dout<<"Here"<<endl; if(material) { glUniform3fv(glGetUniformLocation(compositeProgram,"material.diffuse"),1,&material->diffuse.x); glUniform3fv(glGetUniformLocation(compositeProgram,"material.specular"),1,&material->specular.x); glUniform3fv(glGetUniformLocation(compositeProgram,"material.ambient"),1,&material->ambient.x); glUniform1fv(glGetUniformLocation(compositeProgram,"material.shininess"),1,&material->shininess); glUniform1fv(glGetUniformLocation(compositeProgram,"material.opacity"),1,&material->opacity); } else { Material defaultMat; defaultMat.ambient=float3(0.05f,0.075f,0.25f); defaultMat.diffuse=float3(0.05f,0.075f,0.25f); defaultMat.specular=float3(1.0f,1.f,1.0f); defaultMat.opacity=0.5; defaultMat.shininess=100; glUniform3fv(glGetUniformLocation(compositeProgram,"material.diffuse"),1,&defaultMat.diffuse.x); glUniform3fv(glGetUniformLocation(compositeProgram,"material.specular"),1,&defaultMat.specular.x); glUniform3fv(glGetUniformLocation(compositeProgram,"material.ambient"),1,&defaultMat.ambient.x); glUniform1fv(glGetUniformLocation(compositeProgram,"material.shininess"),1,&defaultMat.shininess); glUniform1fv(glGetUniformLocation(compositeProgram,"material.opacity"),1,&defaultMat.opacity); } if(light) { glUniform3fv(glGetUniformLocation(compositeProgram,"light.diffuse"),1,&light->diffuse.x); glUniform3fv(glGetUniformLocation(compositeProgram,"light.specular"),1,&light->specular.x); glUniform3fv(glGetUniformLocation(compositeProgram,"light.ambient"),1,&light->ambient.x); glUniform3fv(glGetUniformLocation(compositeProgram,"light.position"),1,&light->pos.x); } else { Light defaultLight; defaultLight.ambient = float3(0.2f,0.2f,0.2f); defaultLight.diffuse = float3(1.0f,1.0f,1.0f); defaultLight.specular = float3(1.0f,1.0f,1.0f); defaultLight.pos = float3(5.0f,10.0f,-5.0f); glUniform3fv(glGetUniformLocation(compositeProgram,"light.diffuse"),1,&defaultLight.diffuse.x); glUniform3fv(glGetUniformLocation(compositeProgram,"light.specular"),1,&defaultLight.specular.x); glUniform3fv(glGetUniformLocation(compositeProgram,"light.ambient"),1,&defaultLight.ambient.x); glUniform3fv(glGetUniformLocation(compositeProgram,"light.position"),1,&defaultLight.pos.x); } RenderUtils::fullscreenQuad(); glFinish(); m_timers["render_composite"]->stop(); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D,0); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D,0); //glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,framebuffer); m_timers["copy_to_fbo"]->start(); glDrawBuffer(buffer); glActiveTexture(GL_TEXTURE0); GLuint copyProgram = m_shaderLibrary->shaders["copyShader"].getProgram(); glUniform1i( glGetUniformLocation(copyProgram, "colorTex"),0); if(settings->GetSettingAs<bool>("render_composite","1")) { glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["Color"]); } else if(settings->GetSettingAs<bool>("render_normal","0")) { glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"]); copyProgram = m_shaderLibrary->shaders["copyInverseShader"].getProgram(); glUniform1i( glGetUniformLocation(copyProgram, "colorTex"),0); } else if(settings->GetSettingAs<bool>("render_depth","0")) { if(currentDepthBuffer=="depth2") glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth"]); else glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]); copyProgram = m_shaderLibrary->shaders["copyDepthColorShader"].getProgram(); glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0); } else if(settings->GetSettingAs<bool>("render_depth_smoothed","0")) { glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]); copyProgram = m_shaderLibrary->shaders["copyDepthColorShader"].getProgram(); glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0); } else if(settings->GetSettingAs<bool>("render_thickness","0")) { glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]); copyProgram = m_shaderLibrary->shaders["copyScalarShader"].getProgram(); glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0); } else { glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["Color"]); } //need to copy the contents to the back buffer. It's important that we copy the //depth as well. Otherwise anything drawn afterwards may incorrecly occlude the fluid. glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]); glUseProgram(copyProgram); glUniform1i( glGetUniformLocation(copyProgram, "depthTex"),1); RenderUtils::fullscreenQuad(); glFinish(); m_timers["copy_to_fbo"]->stop(); glUseProgram(0); glBindTexture(GL_TEXTURE_2D,0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D,0); //if (blending) //{ //glDisable(GL_BLEND); //} glPopAttrib(); glPopClientAttrib(); if (m_writeFramebuffers) { glFinish(); writeFramebufferTextures(); m_writeFramebuffers = false; } }
// The MAIN function, from here we start the application and run the game loop int main() { // Init GLFW glfwInit(); // Set all the required options for GLFW glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // On mac os, must have this config. glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Create a GLFWwindow object that we can use for GLFW's functions GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr); glfwMakeContextCurrent(window); // Set the required callback functions glfwSetKeyCallback(window, key_callback); // Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions glewExperimental = GL_TRUE; // Initialize GLEW to setup the OpenGL Function pointers glewInit(); // Define the viewport dimensions glViewport(0, 0, WIDTH, HEIGHT); glEnable(GL_DEPTH_TEST); // Build and compile our shader program ShaderProgram ourShader("/Users/Evan/Documents/XcodeWorkspace/OpenGLCoreStudy/OpenGLCoreStudy/TestCode/GLSL/First3DObjects.vsh", "/Users/Evan/Documents/XcodeWorkspace/OpenGLCoreStudy/OpenGLCoreStudy/TestCode/GLSL/First3DObjects.fsh"); // Set up vertex data (and buffer(s)) and attribute pointers GLfloat vertices[] = { -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, -0.5f, 0.5f, -0.5f, 1.0f, 1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f }; glm::vec3 cubePositions[] = { glm::vec3( 0.0f, 0.0f, 0.0f), glm::vec3( 2.0f, 5.0f, -15.0f), glm::vec3(-1.5f, -2.2f, -2.5f), glm::vec3(-3.8f, -2.0f, -12.3f), glm::vec3( 2.4f, -0.4f, -3.5f), glm::vec3(-1.7f, 3.0f, -7.5f), glm::vec3( 1.3f, -2.0f, -2.5f), glm::vec3( 1.5f, 2.0f, -2.5f), glm::vec3( 1.5f, 0.2f, -1.5f), glm::vec3(-1.3f, 1.0f, -1.5f) }; GLuint VBO, VAO; glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); // Position attribute glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); // TexCoord attribute glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(2); glBindVertexArray(0); // Unbind VAO // Load and create a texture GLuint texture1; GLuint texture2; // ==================== // Texture 1 // ==================== glGenTextures(1, &texture1); glBindTexture(GL_TEXTURE_2D, texture1); // All upcoming GL_TEXTURE_2D operations now have effect on our texture object // Set our texture parameters glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture filtering glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Load, create texture and generate mipmaps int width, height; unsigned char* image = SOIL_load_image("/Users/Evan/Documents/XcodeWorkspace/OpenGLCoreStudy/OpenGLCoreStudy/Resource/Image/container.jpg", &width, &height, 0, SOIL_LOAD_RGB); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture when done, so we won't accidentily mess up our texture. // =================== // Texture 2 // =================== glGenTextures(1, &texture2); glBindTexture(GL_TEXTURE_2D, texture2); // Set our texture parameters glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture filtering glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Load, create texture and generate mipmaps image = SOIL_load_image("/Users/Evan/Documents/XcodeWorkspace/OpenGLCoreStudy/OpenGLCoreStudy/Resource/Image/awesomeface.png", &width, &height, 0, SOIL_LOAD_RGB); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); glBindTexture(GL_TEXTURE_2D, 0); // Game loop while (!glfwWindowShouldClose(window)) { GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; // Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions glfwPollEvents(); do_movement(); // Render // Clear the colorbuffer glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Bind Textures using texture units glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture1); glUniform1i(glGetUniformLocation(ourShader.program, "ourTexture1"), 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture2); glUniform1i(glGetUniformLocation(ourShader.program, "ourTexture2"), 1); // Activate shader ourShader.useShader(); // Camera/View transformation glm::mat4 view; view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp); // Projection glm::mat4 projection; projection = glm::perspective(45.0f, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f); // Get the uniform locations GLint modelLoc = glGetUniformLocation(ourShader.program, "model"); GLint viewLoc = glGetUniformLocation(ourShader.program, "view"); GLint projLoc = glGetUniformLocation(ourShader.program, "projection"); // Pass the matrices to the shader glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); glBindVertexArray(VAO); for (GLuint i = 0; i < 10; i++) { // Calculate the model matrix for each object and pass it to shader before drawing glm::mat4 model; model = glm::translate(model, cubePositions[i]); GLfloat angle = 20.0f * i; model = glm::rotate(model, angle, glm::vec3(1.0f, 0.3f, 0.5f)); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 36); } glBindVertexArray(0); // Swap the screen buffers glfwSwapBuffers(window); } // Properly de-allocate all resources once they've outlived their purpose glDeleteVertexArrays(1, &VAO); glDeleteBuffers(1, &VBO); // Terminate GLFW, clearing any resources allocated by GLFW. glfwTerminate(); return 0; }
void display(void) { glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glColor3f(1.0f, 1.0f, 1.0f); if (ps.renderMode == 0) { int i; glColor3f(0.3f, 0.8f, 1.0f); glEnable(GL_BLEND); glEnable(GL_POINT_SMOOTH); glPointSize(5.0f); glBegin(GL_POINTS); for (i = 0; i < ps.pNum; i++) { // if(ps.p[i].phase == bubble) glColor3f(1.0f, 0.3f, 0.8f); else if(ps.p[i].phase == water) glColor3f(0.5f, 0.8f, 1.0f); else glColor3f(0.3f, 1.0f, 0.8f); glVertex2fv(&ps.p[i].pos.x); } glEnd(); glPointSize(1.0f); glDisable(GL_POINT_SMOOTH); glDisable(GL_BLEND); } else if (ps.renderMode > 0) { //glBindTexture(GL_TEXTURE_2D, waterTex); //glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, RENDER_SAMPLE, RENDER_SAMPLE, GL_RGBA, GL_FLOAT, ps.texture); //glEnable(GL_TEXTURE_2D); //glBegin(GL_QUADS); //glTexCoord2f(0.0f, 0.0f); //glVertex2f(0.0f, 0.0f); //glTexCoord2f(1.0f, 0.0f); //glVertex2f(1.0f, 0.0f); //glTexCoord2f(1.0f, 1.0f); //glVertex2f(1.0f, 1.0f); //glTexCoord2f(0.0f, 1.0f); //glVertex2f(0.0f, 1.0f); //glEnd(); //glDisable(GL_TEXTURE_2D); if (ps.renderMode == 2) { int i; glColor3f(0.3f, 0.8f, 1.0f); glEnable(GL_BLEND); glEnable(GL_LINE_SMOOTH); glLineWidth(1.5f); glBegin(GL_LINES); for (i = 0; i < ps.nLine0; i++) { glVertex2fv(&ps.line0[i].x); glVertex2fv(&ps.line1[i].x); } glEnd(); glColor3f(1.0f, 0.8f, 0.3f); glBegin(GL_LINES); for (i = 0; i < ps.nLine1; i++) { glVertex2fv(&ps.line2[i].x); glVertex2fv(&ps.line3[i].x); } glEnd(); glLineWidth(1.0f); glDisable(GL_LINE_SMOOTH); glDisable(GL_BLEND); } // if (ps.renderMode == 1) { //int i; //glColor3f(0.3f, 0.8f, 1.0f); //glEnable(GL_BLEND); //glEnable(GL_POINT_SMOOTH); //glPointSize(5.0f); //glBegin(GL_POINTS); //for (i = 0; i < ps.pNum; i++) // glVertex2fv(&ps.p[i].pos.x); //glEnd(); //glPointSize(1.0f); //glDisable(GL_POINT_SMOOTH); ////draw contour //glLineWidth(1.5f); //glBegin(GL_LINES); //for (i = 0; i < ps.nLine; i++) { // glVertex2fv(&ps.line0[i].x); // glVertex2fv(&ps.line1[i].x); //} //glEnd(); //glLineWidth(1.0f); //glDisable(GL_LINE_SMOOTH); //glDisable(GL_BLEND); //glEnable(GL_TEXTURE_2D); glUseProgram(programObject); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, waterTex); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, RENDER_SAMPLE, RENDER_SAMPLE, GL_RGBA, GL_FLOAT, ps.textureWater); waterLoc = glGetUniformLocation(programObject, "tex_water"); if(waterLoc >= 0) glUniform1i(waterLoc, 0); else printf("Uniform variable tex_water not found!\n"); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, iceTex); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, RENDER_SAMPLE, RENDER_SAMPLE, GL_RGBA, GL_FLOAT, ps.textureIce); iceLoc = glGetUniformLocation(programObject, "tex_ice"); if(iceLoc >= 0) glUniform1i(iceLoc, 1); else printf("Uniform variable tex_ice not found!\n"); glEnable(GL_TEXTURE_2D); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f); glTexCoord2f(1.0f, 0.0f); glVertex2f(1.0f, 0.0f); glTexCoord2f(1.0f, 1.0f); glVertex2f(1.0f, 1.0f); glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, 1.0f); glEnd(); //glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D); glActiveTexture(GL_TEXTURE0); glUseProgram(0); /*glBindTexture(GL_TEXTURE_2D, iceTex); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, RENDER_SAMPLE, RENDER_SAMPLE, GL_RGBA, GL_FLOAT, ps.textureIce); glEnable(GL_TEXTURE_2D); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f); glTexCoord2f(1.0f, 0.0f); glVertex2f(1.0f, 0.0f); glTexCoord2f(1.0f, 1.0f); glVertex2f(1.0f, 1.0f); glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, 1.0f); glEnd(); glDisable(GL_TEXTURE_2D);*/ //glColor3f(0.3f, 0.8f, 1.0f); glEnable(GL_BLEND); glEnable(GL_POINT_SMOOTH); glPointSize(10.0f); //glBegin(GL_POINTS); int i; for (i = 0; i < ps.pNum; i++) { // if(ps.p[i].phase == bubble) { //glPointSize(10.0f * ps.p[i].volume); glColor3f(1.0f, 1.0f, 1.0f); DrawCircle(ps.p[i].pos.x, ps.p[i].pos.y, 0.005 * ps.p[i].volume, 10); //glVertex2fv(&ps.p[i].pos.x); } } //glEnd(); glPointSize(1.0f); glDisable(GL_POINT_SMOOTH); glDisable(GL_BLEND); } } if (systemRunning) { //if (frameNum % 10 == 0) //screenShot(frameNum / 10); frameNum++; } renderText(); glutSwapBuffers(); }
void TextureLitMaterial::render(GameObject* pGameObject, Camera* pCamera) { if (!_diffuseTexture) return; _shader->use(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, _diffuseTexture->getId()); glUniform1i (_diffMapLoc, 0); glUniform1f(_diffuseTilingLoc, _diffuseTiling); if (normalMap) { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, _normalMapTexture->getId()); glUniform1i (_normalMapLoc, 1); glUniform1f(_normalTilingLoc, _normalTiling); } if (specularMap) { glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, _specularMapTexture->getId()); glUniform1i (_specMapLoc, 2); glUniform1f(_specularTilingLoc, _specularTiling); } if (Renderer::getShadowDepthMapFar()) { glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, Renderer::getShadowDepthMapFar()); glUniform1i (_depthMapLocFar, 3); } if (Renderer::getShadowDepthMapFar()) { glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, Renderer::getShadowDepthMapNear()); glUniform1i (_depthMapLocNear, 4); } if (Renderer::getShadowDepthMapMid()) { glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, Renderer::getShadowDepthMapMid()); glUniform1i (_depthMapLocMid, 5); } glUniform1f(_matSmoothLoc, _smoothness); glUniform1f(_matShineLoc, _shininess); glUniform1f(_matAmbLoc, _ambient); glUniform1f(_hasNormMapLoc, normalMap); glUniform1f(_hasSpecMapLoc, specularMap); //pass in light data int index = 0; DualLinkList<Light> list = Light::GetLightList(); DualLinkNode<Light>* cn = list.startNode; //GLfloat near_plane = 1.0f, far_plane = 25.0f; while(cn!=NULL && index < MGE_MAX_LIGHTS) { Light* light = (Light*)cn; if(!light->IsActive())//do not render with inactive lights { cn = cn->nextNode; continue; } string indexString ="LightArray[" + std::to_string(index) + "]"; GLuint loc; int lightType = light->getType(); if (lightType == MGE_LIGHT_DIRECTIONAL) { loc = _shader->getUniformLocation(indexString + ".type"); glUniform1i(loc,lightType); loc = _shader->getUniformLocation(indexString + ".color"); glUniform3fv(loc,1,glm::value_ptr(light->getColor())); loc = _shader->getUniformLocation(indexString + ".direction"); glUniform3fv(loc,1,glm::value_ptr(light->getDirection())); //loc = _shader->getUniformLocation(indexString + ".position"); //glUniform3fv(loc,1,glm::value_ptr(light->getLocalPosition())); glm::mat4 lightProjection, lightView; lightView = Light::GetDirectionalViewMatrix(); glm::mat4 lightSpaceMatrix; lightProjection = Renderer::GetFarShadowOrtho(); lightSpaceMatrix = lightProjection * lightView; glUniformMatrix4fv(_lightMatLocFar, 1, GL_FALSE, glm::value_ptr(lightSpaceMatrix)); lightProjection = Renderer::GetNearShadowOrtho(); lightSpaceMatrix = lightProjection * lightView; glUniformMatrix4fv(_lightMatLocNear, 1, GL_FALSE, glm::value_ptr(lightSpaceMatrix)); lightProjection = Renderer::GetMidShadowOrtho(); lightSpaceMatrix = lightProjection * lightView; glUniformMatrix4fv(_lightMatLocMid, 1, GL_FALSE, glm::value_ptr(lightSpaceMatrix)); ++index; } else if ((!pGameObject->ignoreNonDirLights) && lightType == MGE_LIGHT_POINT) { glm::vec3 lightPos = light->getWorldPosition(); float dist = glm::distance(lightPos, pGameObject->getWorldPosition()); if(dist > light->getFalloff() + pGameObject->GetRenderBound().radius) { cn = cn->nextNode; continue; } loc = _shader->getUniformLocation(indexString + ".type"); glUniform1i(loc,lightType); loc = _shader->getUniformLocation(indexString + ".color"); glUniform3fv(loc,1,glm::value_ptr(light->getColor())); loc = _shader->getUniformLocation(indexString + ".position"); glUniform3fv(loc,1,glm::value_ptr(lightPos)); loc = _shader->getUniformLocation(indexString + ".attenuation"); glUniform3fv(loc,1,glm::value_ptr(light->getAttenuation())); ++index; } //++index; cn = cn->nextNode; } glUniform1i(_shader->getUniformLocation("lightCount"),index); //set view pos glUniform3fv(_viewPosLoc, 1, glm::value_ptr(pCamera->getWorldPosition())); //color glUniform4fv(_colorLoc,1,glm::value_ptr(color)); //pass in all MVP matrices separately glUniformMatrix4fv ( _projMatLoc, 1, GL_FALSE, glm::value_ptr(pCamera->getProjection())); glUniformMatrix4fv ( _viewMatLoc, 1, GL_FALSE, glm::value_ptr(pCamera->getView())); glUniformMatrix4fv ( _modelMatLoc, 1, GL_FALSE, glm::value_ptr(pGameObject->getWorldTransform())); //now inform mesh of where to stream its data pGameObject->getMesh()->streamToOpenGL(0, 1, 2, 3); //glGetError(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); }
void Uniform1i::apply() { glUniform1i(location(), m_val); }
void Uniform::set1i(GLint value) { glUniform1i(location, value); }
static bool gl_glsl_compile_program( void *data, unsigned idx, void *program_data, struct shader_program_info *program_info) { glsl_shader_data_t *glsl = (glsl_shader_data_t*)data; struct shader_program_glsl_data *program = (struct shader_program_glsl_data*)program_data; GLuint prog = glCreateProgram(); if (!program) program = &glsl->prg[idx]; if (!prog) goto error; if (program_info->vertex) { RARCH_LOG("Found GLSL vertex shader.\n"); program->vprg = glCreateShader(GL_VERTEX_SHADER); if (!gl_glsl_compile_shader( glsl, program->vprg, "#define VERTEX\n#define PARAMETER_UNIFORM\n", program_info->vertex)) { RARCH_ERR("Failed to compile vertex shader #%u\n", idx); goto error; } glAttachShader(prog, program->vprg); } if (program_info->fragment) { RARCH_LOG("Found GLSL fragment shader.\n"); program->fprg = glCreateShader(GL_FRAGMENT_SHADER); if (!gl_glsl_compile_shader(glsl, program->fprg, "#define FRAGMENT\n#define PARAMETER_UNIFORM\n", program_info->fragment)) { RARCH_ERR("Failed to compile fragment shader #%u\n", idx); goto error; } glAttachShader(prog, program->fprg); } if (program_info->vertex || program_info->fragment) { RARCH_LOG("Linking GLSL program.\n"); if (!gl_glsl_link_program(prog)) goto error; /* Clean up dead memory. We're not going to relink the program. * Detaching first seems to kill some mobile drivers * (according to the intertubes anyways). */ if (program->vprg) glDeleteShader(program->vprg); if (program->fprg) glDeleteShader(program->fprg); program->vprg = 0; program->fprg = 0; glUseProgram(prog); glUniform1i(gl_glsl_get_uniform(glsl, prog, "Texture"), 0); glUseProgram(0); } program->id = prog; return true; error: RARCH_ERR("Failed to link program #%u.\n", idx); program->id = 0; return false; }
// OpenGL3 Render function. // (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop) // Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly, in order to be able to run within any OpenGL engine that doesn't do so. void ImGui_ImplGlfwGL3_RenderDrawData(ImDrawData* draw_data) { // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates) ImGuiIO& io = ImGui::GetIO(); int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x); int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y); if (fb_width == 0 || fb_height == 0) return; draw_data->ScaleClipRects(io.DisplayFramebufferScale); // Backup GL state GLenum last_active_texture; glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&last_active_texture); glActiveTexture(GL_TEXTURE0); GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program); GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); GLint last_sampler; glGetIntegerv(GL_SAMPLER_BINDING, &last_sampler); GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer); GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer); GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array); GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode); GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport); GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box); GLenum last_blend_src_rgb; glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&last_blend_src_rgb); GLenum last_blend_dst_rgb; glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&last_blend_dst_rgb); GLenum last_blend_src_alpha; glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&last_blend_src_alpha); GLenum last_blend_dst_alpha; glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&last_blend_dst_alpha); GLenum last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&last_blend_equation_rgb); GLenum last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&last_blend_equation_alpha); GLboolean last_enable_blend = glIsEnabled(GL_BLEND); GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE); GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST); GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST); // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glEnable(GL_SCISSOR_TEST); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Setup viewport, orthographic projection matrix glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height); const float ortho_projection[4][4] = { { 2.0f/io.DisplaySize.x, 0.0f, 0.0f, 0.0f }, { 0.0f, 2.0f/-io.DisplaySize.y, 0.0f, 0.0f }, { 0.0f, 0.0f, -1.0f, 0.0f }, {-1.0f, 1.0f, 0.0f, 1.0f }, }; glUseProgram(g_ShaderHandle); glUniform1i(g_AttribLocationTex, 0); glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]); glBindSampler(0, 0); // Rely on combined texture/sampler state. // Recreate the VAO every time // (This is to easily allow multiple GL contexts. VAO are not shared among GL contexts, and we don't track creation/deletion of windows so we don't have an obvious key to use to cache them.) GLuint vao_handle = 0; glGenVertexArrays(1, &vao_handle); glBindVertexArray(vao_handle); glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle); glEnableVertexAttribArray(g_AttribLocationPosition); glEnableVertexAttribArray(g_AttribLocationUV); glEnableVertexAttribArray(g_AttribLocationColor); glVertexAttribPointer(g_AttribLocationPosition, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, pos)); glVertexAttribPointer(g_AttribLocationUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, uv)); glVertexAttribPointer(g_AttribLocationColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, col)); // Draw for (int n = 0; n < draw_data->CmdListsCount; n++) { const ImDrawList* cmd_list = draw_data->CmdLists[n]; const ImDrawIdx* idx_buffer_offset = 0; glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle); glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.Size * sizeof(ImDrawVert), (const GLvoid*)cmd_list->VtxBuffer.Data, GL_STREAM_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx), (const GLvoid*)cmd_list->IdxBuffer.Data, GL_STREAM_DRAW); for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) { const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; if (pcmd->UserCallback) { pcmd->UserCallback(cmd_list, pcmd); } else { glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y)); glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset); } idx_buffer_offset += pcmd->ElemCount; } } glDeleteVertexArrays(1, &vao_handle); // Restore modified GL state glUseProgram(last_program); glBindTexture(GL_TEXTURE_2D, last_texture); glBindSampler(0, last_sampler); glActiveTexture(last_active_texture); glBindVertexArray(last_vertex_array); glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer); glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha); glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha); if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND); if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST); if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST); glPolygonMode(GL_FRONT_AND_BACK, (GLenum)last_polygon_mode[0]); glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]); glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]); }
GLvoid Program::setUniform(GLint location, GLint v0) { glUniform1i (location, v0); }
void SSEffect::smoothDepth( RTPSSettings* settings) { GLuint smoothingProgram; switch(settings->GetSettingAs<int>("filter_type","0")) { case NO_SMOOTHING: return; case SEPERABLE_GAUSSIAN_BLUR: smoothingProgram= m_shaderLibrary->shaders["gaussianBlurXShader"].getProgram(); glUseProgram(smoothingProgram); glUniform1i( glGetUniformLocation(smoothingProgram, "depthTex"),0); glUniform1f( glGetUniformLocation(smoothingProgram, "del_x"),1.0f/(float)width); glUniform1f( glGetUniformLocation(smoothingProgram, "falloff"),settings->GetSettingAs<float>("blur_falloff","1.0")); glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0")); RenderUtils::fullscreenQuad(); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); smoothingProgram= m_shaderLibrary->shaders["gaussianBlurYShader"].getProgram(); glUseProgram(smoothingProgram); glUniform1i( glGetUniformLocation(smoothingProgram, "depthTex"),0); glUniform1f( glGetUniformLocation(smoothingProgram, "del_y"),1.0f/(float)height); glUniform1f( glGetUniformLocation(smoothingProgram, "falloff"),settings->GetSettingAs<float>("blur_falloff","1.0")); glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0")); currentDepthBuffer="depth2"; break; case GAUSSIAN_BLUR: smoothingProgram= m_shaderLibrary->shaders["gaussianBlurShader"].getProgram(); glUseProgram(smoothingProgram); glUniform1i(glGetUniformLocation(smoothingProgram,"depthTex"),0); glUniform1f( glGetUniformLocation(smoothingProgram, "del_x"),1.0/((float)width)); glUniform1f( glGetUniformLocation(smoothingProgram, "del_y"),1.0/((float)height)); glUniform1f( glGetUniformLocation(smoothingProgram, "falloff"),settings->GetSettingAs<float>("blur_falloff","1.0")); glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0")); currentDepthBuffer="depth"; break; case BILATERAL_GAUSSIAN_BLUR: { smoothingProgram= m_shaderLibrary->shaders["bilateralGaussianBlurShader"].getProgram(); float xdir[] = {1.0f/height,0.0f}; float ydir[] = {0.0f,1.0f/width}; glUseProgram(smoothingProgram); glUniform1i( glGetUniformLocation(smoothingProgram, "depthTex"),0); glUniform2fv( glGetUniformLocation(smoothingProgram, "blurDir"),1,xdir); glUniform1f( glGetUniformLocation(smoothingProgram, "sig_range"),settings->GetSettingAs<float>("bilateral_range","0.01")); glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0")); RenderUtils::fullscreenQuad(); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0); //glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glUniform2fv( glGetUniformLocation(smoothingProgram, "blurDir"),1,ydir); //glUniform1f( glGetUniformLocation(smoothingProgram, "sig_range"),bilateralRange); //glUniform1f( glGetUniformLocation(glsl_program[BILATERAL_GAUSSIAN_SHADER], "sig"),filterRadius); currentDepthBuffer="depth2"; break; } case CURVATURE_FLOW: { //int numberIterations=settings->GetSettingAs<int>("curvature_flow_iterations","20"); smoothingProgram= m_shaderLibrary->shaders["curvatureFlowShader"].getProgram(); glUseProgram(smoothingProgram); int numberIterations=settings->GetSettingAs<int>("curvature_flow_iterations","1"); glUniform1i(glGetUniformLocation(smoothingProgram,"depthTex"),0); //glUniform1f(glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER],"width"),(float)window_width); //glUniform1f(glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER],"height"),(float)window_height); glUniform1f( glGetUniformLocation(smoothingProgram, "del_x"),1.0/((float)width)); glUniform1f( glGetUniformLocation(smoothingProgram, "del_y"),1.0/((float)height)); //glUniform1f( glGetUniformLocation(smoothingProgram, "h_x"),1.0/((float)width-1)); //glUniform1f( glGetUniformLocation(smoothingProgram, "h_y"),1.0/((float)height-1)); //glUniform1f( glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER], "focal_x"),focal_x); //glUniform1f( glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER], "focal_y"),focal_y); //glUniform1f( glGetUniformLocation(smoothingProgram, "dt"),1.0f/numberIterations); glUniform1f( glGetUniformLocation(smoothingProgram, "dt"),settings->GetSettingAs<float>("curvature_flow_dt","0.005")); //glUniform1f( glGetUniformLocation(smoothingProgram, "distance_threshold"), falloff); string curReadBuffer; for(unsigned int i = 0; i<numberIterations; i++) { glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); RenderUtils::fullscreenQuad(); if(i%2==0) { curReadBuffer = "depth2"; currentDepthBuffer="depth"; } else { curReadBuffer = "depth"; currentDepthBuffer="depth2"; } glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0); glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[curReadBuffer]); //glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0); } //currentDepthBuffer=curReadBuffer; glUseProgram(0); return; } default: break; } RenderUtils::fullscreenQuad(); glUseProgram(0); }
void TMD5Renderer::Render() { glUseProgram(shaderProgram); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture); assert( glGetError() ==GL_NO_ERROR ); diffuseLocation = glGetUniformLocation(shaderProgram, "diffuse"); assert( glGetError() ==GL_NO_ERROR ); glUniform1i(diffuseLocation, 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, normalTexture); assert( glGetError() ==GL_NO_ERROR ); int normalMapLocation = glGetUniformLocation(shaderProgram, "normalMap"); assert( glGetError() ==GL_NO_ERROR ); glUniform1i(normalMapLocation, 1); //glActiveTexture(GL_TEXTURE0); glBindAttribLocation(shaderProgram, 0, "vertex"); glBindAttribLocation(shaderProgram, 1, "uv"); assert( glGetError() ==GL_NO_ERROR ); #ifdef GL_ES_VERSION_2_0 glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices); assert( glGetError() == GL_NO_ERROR); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, uvs); assert( glGetError() == GL_NO_ERROR); glDrawArrays (GL_TRIANGLES, 0, vertexCount); assert( glGetError() == GL_NO_ERROR); #else bonesLocation = glGetUniformLocation(shaderProgram, "bones"); assert( bonesLocation!=-1); assert( glGetError() ==GL_NO_ERROR ); int count = md5Model->GetJointCount(); float matrices[count * 16]; memset(matrices, 0, sizeof(float)*count*16); float* ptr = matrices; for(int j=0;j<count;++j) { TMD5Joint* joint = md5Model->GetJoint(j); Matrix4 transform = joint->transform * joint->inverseBindPose; *ptr ++ = transform.m[0][0]; *ptr ++ = transform.m[1][0]; *ptr ++ = transform.m[2][0]; *ptr ++ = transform.m[3][0]; *ptr ++ = transform.m[0][1]; *ptr ++ = transform.m[1][1]; *ptr ++ = transform.m[2][1]; *ptr ++ = transform.m[3][1]; *ptr ++ = transform.m[0][2]; *ptr ++ = transform.m[1][2]; *ptr ++ = transform.m[2][2]; *ptr ++ = transform.m[3][2]; *ptr ++ = transform.m[0][3]; *ptr ++ = transform.m[1][3]; *ptr ++ = transform.m[2][3]; *ptr ++ = transform.m[3][3]; } //glUniform1i(boneCountLocation, count); assert( glGetError() == GL_NO_ERROR ); glUniformMatrix4fv(bonesLocation, count, GL_FALSE, matrices); assert( glGetError() == GL_NO_ERROR ); for(int m=0;m<md5Model->meshes.size();++m) { if( md5Model->meshes[m]->IsVisible() ) { TMD5Mesh* mesh = md5Model->meshes[m]; glBindVertexArray(vertexArrayObject[m]); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glEnableVertexAttribArray(3); glEnableVertexAttribArray(4); glEnableVertexAttribArray(5); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexVBO[m]); int indexCount = 3 * (int)mesh->mTriangles.size(); // Draw the triangles ! glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, (void*)0); assert( glGetError() == GL_NO_ERROR); } } #endif glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glDisableVertexAttribArray(3); glDisableVertexAttribArray(4); glDisableVertexAttribArray(5); glUseProgram(0); glBindVertexArray(0); }
void TextureShader::render(RenderState* rstate, RenderData* render_data, Material* material) { Mesh* mesh = render_data->mesh(); Texture* texture = material->getTexture("main_texture"); glm::vec3 color = material->getVec3("color"); float opacity = material->getFloat("opacity"); glm::vec4 material_ambient_color = material->getVec4("ambient_color"); glm::vec4 material_diffuse_color = material->getVec4("diffuse_color"); glm::vec4 material_specular_color = material->getVec4("specular_color"); float material_specular_exponent = material->getFloat("specular_exponent"); if (texture->getTarget() != GL_TEXTURE_2D) { std::string error = "TextureShader::render : texture with wrong target."; throw error; } bool use_light = false; Light* light; if (render_data->light_enabled()) { light = render_data->light(); if (light->enabled()) { use_light = true; } } mesh->generateVAO(); if (use_light) { GL(glUseProgram(program_light_->id())); } else { GL(glUseProgram(program_no_light_->id())); } GL(glActiveTexture (GL_TEXTURE0)); GL(glBindTexture(texture->getTarget(), texture->getId())); if (use_light) { glm::vec3 light_position = light->getVec3("world_position"); glm::vec4 light_ambient_intensity = light->getVec4("ambient_intensity"); glm::vec4 light_diffuse_intensity = light->getVec4("diffuse_intensity"); glm::vec4 light_specular_intensity = light->getVec4( "specular_intensity"); glUniformMatrix4fv(u_mvp_, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_mvp)); glUniformMatrix4fv(u_mv_, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_mv)); glUniformMatrix4fv(u_mv_it_, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_mv_it)); glUniform3f(u_light_pos_, light_position.x, light_position.y, light_position.z); glUniform1i(u_texture_, 0); glUniform3f(u_color_, color.r, color.g, color.b); glUniform1f(u_opacity_, opacity); glUniform4f(u_material_ambient_color_, material_ambient_color.r, material_ambient_color.g, material_ambient_color.b, material_ambient_color.a); glUniform4f(u_material_diffuse_color_, material_diffuse_color.r, material_diffuse_color.g, material_diffuse_color.b, material_diffuse_color.a); glUniform4f(u_material_specular_color_, material_specular_color.r, material_specular_color.g, material_specular_color.b, material_specular_color.a); glUniform1f(u_material_specular_exponent_, material_specular_exponent); glUniform4f(u_light_ambient_intensity_, light_ambient_intensity.r, light_ambient_intensity.g, light_ambient_intensity.b, light_ambient_intensity.a); glUniform4f(u_light_diffuse_intensity_, light_diffuse_intensity.r, light_diffuse_intensity.g, light_diffuse_intensity.b, light_diffuse_intensity.a); glUniform4f(u_light_specular_intensity_, light_specular_intensity.r, light_specular_intensity.g, light_specular_intensity.b, light_specular_intensity.a); glBindVertexArray(mesh->getVAOId()); } else { glUniformMatrix4fv(u_mvp_no_light_, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_mvp)); glUniform1i(u_texture_no_light_, 0); glUniform3f(u_color_no_light_, color.r, color.g, color.b); glUniform1f(u_opacity_no_light_, opacity); glBindVertexArray(mesh->getVAOId()); } GL(glDrawElements(render_data->draw_mode(), mesh->indices().size(), GL_UNSIGNED_SHORT, 0)); GL(glBindVertexArray(0)); checkGlError("TextureShader::render"); }
int main() { // INIT glfwSetErrorCallback( error_callback ); /* Initialize the library */ if ( !glfwInit() ) { return -1; } // must use exactly version 3 glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 3 ); glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3 ); glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE ); glfwWindowHint( GLFW_RESIZABLE, GL_FALSE ); /* Create a windowed mode window and its OpenGL context */ window = glfwCreateWindow( WIDTH, HEIGHT, "Hello World", NULL, NULL ); if ( !window ) { glfwTerminate(); return -1; } glfwMakeContextCurrent( window ); glfwSetKeyCallback( window, key_callback ); //glfwSetCursorPosCallback(window, cursor_position_callback); glfwSetScrollCallback(window, scroll_callback); glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); int count; //printf( "%s\n", glfwGetVideoModes( glfwGetPrimaryMonitor(), &count ) ); glewExperimental = GL_TRUE; if( glewInit() != GLEW_OK ) { fprintf( stderr, "glewInit() failed\n" ); } glViewport( 0, 0, WIDTH, HEIGHT ); glClearColor( 0.2f, 0.3f, 0.3f, 1.0f ); glEnable( GL_DEPTH_TEST ); // SHADER Shader shader( "./vertexShader.glsl", "./fragmentShader.glsl" ); // Set up vertex data (and buffer(s)) and attribute pointers GLfloat vertices[] = { -1.0f, -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, }; GLuint indices[] = { 0, 1, 2, 1, 2, 3, 1, 3, 5, 3, 5, 7, 4, 5, 7, 4, 6, 7, 0, 4, 6, 0, 2, 6, 2, 3, 7, 2, 6, 7, 0, 1, 5, 0, 4, 5 }; // vertex buffer object (VBO) // vertex array object (VAO) GLuint VAO, VBO, EBO; glGenVertexArrays( 1, &VAO ); glGenBuffers( 1, &VBO ); glGenBuffers( 1, &EBO ); // BIND the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s). glBindVertexArray( VAO ); glBindBuffer( GL_ARRAY_BUFFER, VBO ); glBufferData( GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW ); glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, EBO ); glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW ); // void glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer); // the 0 for index comes from location = 0 in the vertex shader glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0 ); glVertexAttribPointer( 1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)) ); glEnableVertexAttribArray( 0 ); glEnableVertexAttribArray( 1 ); glBindVertexArray( 0 ); stbi_set_flip_vertically_on_load(1); // TEXTURE GLuint texture; glGenTextures(1, &texture); //printf( "texture: %d\n", texture ); glBindTexture(GL_TEXTURE_2D, texture); // All upcoming GL_TEXTURE_2D operations now have effect on our texture object // Set our texture parameters glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture filtering glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Load, create texture and generate mipmaps int width, height, comp; unsigned char* image = stbi_load("./images/container.jpg", &width, &height, &comp, 3); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); stbi_image_free(image); glBindTexture(GL_TEXTURE_2D, 0); GLuint texture1; glGenTextures(1, &texture1); //printf( "texture1: %d\n", texture1 ); glBindTexture(GL_TEXTURE_2D, texture1); // Set our texture parameters glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture filtering glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Load, create texture and generate mipmaps image = stbi_load("./images/awesomeface.png", &width, &height, &comp, 3 ); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); stbi_image_free(image); glBindTexture(GL_TEXTURE_2D, 0); glm::mat4 projection; projection = glm::perspective( 45.0f, (GLfloat)WIDTH/HEIGHT, 0.1f, 100.0f ); /* for( int y = 0; y < 4; ++y ) { for( int x = 0; x < 4; ++x ) { printf( "%f ", test[x][y] ); } printf("\n"); } */ // Game loop while( !glfwWindowShouldClose( window ) ) { //for( int iter = 1; iter; --iter ) { glfwPollEvents(); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glActiveTexture( GL_TEXTURE0 ); glBindTexture(GL_TEXTURE_2D, texture); glUniform1i( glGetUniformLocation(shader.Program, "texture"), 0 ); glActiveTexture( GL_TEXTURE1 ); glBindTexture(GL_TEXTURE_2D, texture1); glUniform1i( glGetUniformLocation(shader.Program, "texture1"), 1 ); glUseProgram( shader.Program ); glm::mat4 models[2]; models[0] = glm::translate( models[0], glm::vec3( 4.0f, 4.0f, -10.0f ) ); //models[1] = glm::translate( models[1], glm::vec3( -4.0f, -4.0f, -10.0f ) ); models[1] = glm::scale( models[1], glm::vec3( 50.0f, 50.0f, 50.0f ) ); updateCamera(); //glm::mat4 rotatedView = camera[1] * camera[0] * view; printf( "rotation x %f, y %f, z %f\n", rotation.x, rotation.y, rotation.z ); glm::mat4 rotatedView; rotatedView = glm::rotate( rotatedView, rotation.x, glm::vec3(1, 0, 0) ) ; rotatedView = glm::rotate( rotatedView, rotation.y, glm::vec3(0, 1, 0) ) ; rotatedView = glm::rotate( rotatedView, rotation.z, glm::vec3(0, 0, 1) ) ; rotatedView *= view; //view = glm::translate( view, position ); //glm::mat4 rotatedView; //projection = glm::rotate( projection, glm::radians(cameraOrientation[1]), glm::vec3(1.0f, 0.0f, 0.0f) ); //projection = glm::rotate( projection, glm::radians(cameraOrientation[0]), glm::vec3(0.0f, 1.0f, 0.0f) ); //projection = projection * (cameraPosition / 10.0f); glUniformMatrix4fv( glGetUniformLocation(shader.Program, "view" ), 1, GL_FALSE, glm::value_ptr(rotatedView) ); glUniformMatrix4fv( glGetUniformLocation(shader.Program, "projection" ), 1, GL_FALSE, glm::value_ptr(projection) ); for( int numBoxes = 0; numBoxes < 3; ++numBoxes ) { glUniformMatrix4fv( glGetUniformLocation(shader.Program, "model" ), 1, GL_FALSE, glm::value_ptr(models[numBoxes]) ); glBindVertexArray( VAO ); //glDrawArrays( GL_TRIANGLES, 0, 3 ); glDrawElements( GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0 ); glBindVertexArray( 0 ); } glfwSwapBuffers( window ); fps(); printf("\n"); } glDeleteVertexArrays( 1, &VAO ); glDeleteBuffers( 1, &VBO ); glfwDestroyWindow( window ); glfwTerminate(); return 0; }
void AFK_EntityDisplayQueue::draw( AFK_ShaderProgram *shaderProgram, AFK_Jigsaw *vapourJigsaw, AFK_Jigsaw *edgeJigsaw, const AFK_3DEdgeShapeBase *baseShape, const AFK_ShapeSizes& sSizes) { size_t instanceCount = queue.size(); if (instanceCount == 0) return; if (!displayTBOSamplerLocation) { vapourJigsawPiecePitchLocation = glGetUniformLocation(shaderProgram->program, "VapourJigsawPiecePitch"); edgeJigsawPiecePitchLocation = glGetUniformLocation(shaderProgram->program, "EdgeJigsawPiecePitch"); jigsawDensityTexSamplerLocation = glGetUniformLocation(shaderProgram->program, "JigsawDensityTex"); jigsawNormalTexSamplerLocation = glGetUniformLocation(shaderProgram->program, "JigsawNormalTex"); jigsawOverlapTexSamplerLocation = glGetUniformLocation(shaderProgram->program, "JigsawOverlapTex"); displayTBOSamplerLocation = glGetUniformLocation(shaderProgram->program, "DisplayTBO"); } /* Jigsaw initialisation. */ Vec3<float> vapourJigsawPiecePitchSTR = vapourJigsaw->getPiecePitchSTR(); Vec2<float> edgeJigsawPiecePitchST = edgeJigsaw->getPiecePitchST(); glUniform3fv(vapourJigsawPiecePitchLocation, 1, &vapourJigsawPiecePitchSTR.v[0]); /* Subtlety: that's a piece pitch for the big 3x2 pieces that * correspond to each cube. However, 0-1 texture co-ordinates in * the base shape are for each *face*, so I need to divide the * pitch down: */ edgeJigsawPiecePitchST = afk_vec2<float>( edgeJigsawPiecePitchST.v[0] / 3.0f, edgeJigsawPiecePitchST.v[1] / 2.0f); glUniform2fv(edgeJigsawPiecePitchLocation, 1, &edgeJigsawPiecePitchST.v[0]); glActiveTexture(GL_TEXTURE0); vapourJigsaw->bindTexture(0); glUniform1i(jigsawDensityTexSamplerLocation, 0); glActiveTexture(GL_TEXTURE1); vapourJigsaw->bindTexture(1); glUniform1i(jigsawNormalTexSamplerLocation, 1); glActiveTexture(GL_TEXTURE2); edgeJigsaw->bindTexture(0); glUniform1i(jigsawOverlapTexSamplerLocation, 2); /* Set up the entity display texbuf. */ glActiveTexture(GL_TEXTURE3); if (!buf) glGenBuffers(1, &buf); glBindBuffer(GL_TEXTURE_BUFFER, buf); glBufferData( GL_TEXTURE_BUFFER, queue.size() * ENTITY_DISPLAY_UNIT_SIZE, queue.data(), GL_STREAM_DRAW); glTexBuffer( GL_TEXTURE_BUFFER, GL_RGBA32F, buf); AFK_GLCHK("entity display queue texBuffer") glUniform1i(displayTBOSamplerLocation, 3); #if AFK_GL_DEBUG shaderProgram->Validate(); #endif baseShape->draw(instanceCount); glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_3D, 0); glBindTexture(GL_TEXTURE_BUFFER, 0); }
void NTextInput::Draw(NCamera* View) { GenerateBuffers(); if (Texture == NULL || GetColor().w == 0) { return; } if (Shader == NULL) { glEnableClientState(GL_VERTEX_ARRAY); glBindBuffer(GL_ARRAY_BUFFER,Buffers[0]); glVertexPointer(2,GL_FLOAT,0,NULL); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glBindBuffer(GL_ARRAY_BUFFER,Buffers[1]); glTexCoordPointer(2,GL_FLOAT,0,NULL); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); if (Texture != NULL) { glBindTexture(GL_TEXTURE_2D,Texture->GetID()); } glMatrixMode(GL_PROJECTION); glLoadMatrixf(&View->GetOrthoMatrix()[0][0]); glMatrixMode(GL_MODELVIEW); glm::mat4 MVP = View->GetViewMatrix()*GetModelMatrix(); glLoadMatrixf(&MVP[0][0]); glColor4fv(&(GetColor()[0])); glDrawArrays(GL_QUADS,0,Verts.size()); glDisable(GL_TEXTURE_2D); glDisable(GL_BLEND); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); return; } glUseProgram(Shader->GetID()); glActiveTexture(GL_TEXTURE0); if (Texture != NULL) { glBindTexture(GL_TEXTURE_2D,Texture->GetID()); } glUniform1i(TextureLoc,0); glm::mat4 MVP = View->GetOrthoMatrix()*View->GetViewMatrix()*GetModelMatrix(); glUniformMatrix4fv(MatrixLoc,1,GL_FALSE,&MVP[0][0]); glUniform4fv(ColorLoc,1,&(GetColor()[0])); glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER,Buffers[0]); glVertexAttribPointer(0,2,GL_FLOAT,GL_FALSE,0,NULL); glEnableVertexAttribArray(1); glBindBuffer(GL_ARRAY_BUFFER,Buffers[1]); glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,0,NULL); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_TEXTURE_2D); glDrawArrays(GL_QUADS,0,Verts.size()); glDisable(GL_TEXTURE_2D); glDisable(GL_BLEND); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glUseProgram(0); }
void Font::DrawString(const Graphics& g, const Brush& brush, const string& s, int len, int x, int y, int w, int h, int flags){ int xx = x; int yy = y; int rr = x + w; int bb = y + h; //g.DrawRect(Pens::Blue, x, y, w, h); if(len < 0) len = s.length(); vector<int> ws, cs; int wi = 0, c = 0; for (int i = 0; i<len;){ char_type cc; int rs = READ_CHAR(&cc, s.c_str() + i, len-i); if (rs>0) i += rs; else break; bool n = cc == L'\n' || cc == 0x0085 || cc == 0x2028 || cc == 0x2029; //if (!n && cc != L'\r') PutChar(cc); int ww = n ? 0 : map[cc]->width; if ((flags & FontFlag_NoWrap) == 0 && (n || (w >= 0 && wi + ww>w))){ if (c == 0){ ws.push_back(ww); cs.push_back(1); wi = 0; c = 0; } else{ ws.push_back(wi); cs.push_back(c); wi = ww; c = 1; if (n){ wi = 0; } } } else { wi += ww; c++; } } if (c > 0){ ws.push_back(wi); cs.push_back(c); } int rh = cs.size()*face->size->metrics.y_ppem; // real height // vertical alignment switch ((flags >> 2) & 3) { case 1: yy += (h-rh) / 2; break; case 2: yy += h-rh; break; } //bool clip_not_whole = (flags & FontFlag_ClipNotWhole) != 0; glUniform1i(Program::CurrentShader()->useTex2, 1); int line = -1; int row = 0; yy -= face->size->metrics.y_ppem; for (int i = 0; i < len; ){ if (row == 0){ line++; xx = x; yy += face->size->metrics.y_ppem; switch (flags & 0x03) { case 1: xx += (w - ws[line]) / 2; break; case 2: xx += w - ws[line]; break; } } char_type cc; int rs = READ_CHAR(&cc, s.c_str() + i, len - i); if (rs>0) i += rs; else return; if (++row == cs[line]) row = 0; if (cc == L'\r') continue; bool n = cc == L'\n' || cc == 0x0085 || cc == 0x2028 || cc == 0x2029; // new line if (!n){ Char& c = *map[cc]; Rect& r = c.bounds; float ss = TEXTURE_SIZE; float L = r.Left() / ss; float T = ((int)r.Top() % TEXTURE_SIZE) / ss; float R = r.Right() / ss; float B = T + c.height / ss; float ps[] = { L, T, R, T, R, B, L, B }; glEnableVertexAttribArray(TEXCOORD_ATTRIB_LOC); glVertexAttribPointer(TEXCOORD_ATTRIB_LOC, 2, GL_FLOAT, GL_FALSE, 0, ps); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, textures[r.Top() / TEXTURE_SIZE]); glActiveTexture(GL_TEXTURE0); g.FillRect(brush, xx + c.left, yy - c.top, c.width, c.height); glDisableVertexAttribArray(TEXCOORD_ATTRIB_LOC); //glUniform1i(Program::CurrentShader()->useTex2, 0); //g.DrawRect(Pens::Green, xx + c.left, yy - c.top, c.width, c.height); //glUniform1i(Program::CurrentShader()->useTex2, 1); xx += c.width; } } glUniform1i(Program::CurrentShader()->useTex2, 0); }
// The MAIN function, from here we start the application and run the game loop int main() { // Init GLFW glfwInit( ); // Set all the required options for GLFW glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 3 ); glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3 ); glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE ); glfwWindowHint( GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE ); glfwWindowHint( GLFW_RESIZABLE, GL_FALSE ); // Create a GLFWwindow object that we can use for GLFW's functions GLFWwindow *window = glfwCreateWindow( WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr ); int screenWidth, screenHeight; glfwGetFramebufferSize( window, &screenWidth, &screenHeight ); if ( nullptr == window ) { std::cout << "Failed to create GLFW window" << std::endl; glfwTerminate( ); return EXIT_FAILURE; } glfwMakeContextCurrent( window ); // Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions glewExperimental = GL_TRUE; // Initialize GLEW to setup the OpenGL Function pointers if ( GLEW_OK != glewInit( ) ) { std::cout << "Failed to initialize GLEW" << std::endl; return EXIT_FAILURE; } // Define the viewport dimensions glViewport( 0, 0, screenWidth, screenHeight ); // Setup OpenGL options glEnable( GL_DEPTH_TEST ); // enable alpha support glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); // Build and compile our shader program Shader ourShader( "res/shaders/core.vs", "res/shaders/core.frag" ); // Set up vertex data (and buffer(s)) and attribute pointers // use with Orthographic Projection /* GLfloat vertices[] = { -0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 0.0f, 0.5f * 500, -0.5f * 500, -0.5f * 500, 1.0f, 0.0f, 0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f, 0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f, -0.5f * 500, 0.5f * 500, -0.5f * 500, 0.0f, 1.0f, -0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 0.0f, -0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f, 0.5f * 500, -0.5f * 500, 0.5f * 500, 1.0f, 0.0f, 0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 1.0f, 0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 1.0f, -0.5f * 500, 0.5f * 500, 0.5f * 500, 0.0f, 1.0f, -0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f, -0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f, -0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f, -0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f, -0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f, -0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f, -0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f, 0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f, 0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f, 0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f, 0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f, 0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f, 0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f, -0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f, 0.5f * 500, -0.5f * 500, -0.5f * 500, 1.0f, 1.0f, 0.5f * 500, -0.5f * 500, 0.5f * 500, 1.0f, 0.0f, 0.5f * 500, -0.5f * 500, 0.5f * 500, 1.0f, 0.0f, -0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f, -0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f, -0.5f * 500, 0.5f * 500, -0.5f * 500, 0.0f, 1.0f, 0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f, 0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f, 0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f, -0.5f * 500, 0.5f * 500, 0.5f * 500, 0.0f, 0.0f, -0.5f * 500, 0.5f * 500, -0.5f * 500, 0.0f, 1.0f }; */ // use with Perspective Projection GLfloat vertices[] = { -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, -0.5f, 0.5f, -0.5f, 1.0f, 1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f }; GLuint VBO, VAO; glGenVertexArrays( 1, &VAO ); glGenBuffers( 1, &VBO ); glBindVertexArray(VAO); glBindBuffer( GL_ARRAY_BUFFER, VBO ); glBufferData( GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW ); // Position attribute glVertexAttribPointer( 0, 3, GL_FLOAT , GL_FALSE, 5 * sizeof( GLfloat ), ( GLvoid * )0 ); glEnableVertexAttribArray( 0 ); // TexCoord attribute glVertexAttribPointer( 2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof( GLfloat ), ( GLvoid * )( 3 * sizeof( GLfloat ) ) ); glEnableVertexAttribArray( 2 ); glBindVertexArray( 0 ); // Unbind VAO // Load and create a texture GLuint texture; // ==================== // Texture // ==================== glGenTextures( 1, &texture ); glBindTexture( GL_TEXTURE_2D, texture ); // All upcoming GL_TEXTURE_2D operations now have effect on our texture object // Set our texture parameters glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); // Set texture wrapping to GL_REPEAT glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); // Set texture filtering glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); // Load, create texture and generate mipmaps int width, height; unsigned char *image = SOIL_load_image( "res/images/image1.jpg", &width, &height, 0, SOIL_LOAD_RGBA ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image ); glGenerateMipmap( GL_TEXTURE_2D ); SOIL_free_image_data( image ); glBindTexture( GL_TEXTURE_2D, 0 ); // Unbind texture when done, so we won't accidentily mess up our texture. glm::mat4 projection; projection = glm::perspective( 45.0f, ( GLfloat )screenWidth / ( GLfloat )screenHeight, 0.1f, 100.0f ); //projection = glm::ortho(0.0f, ( GLfloat )screenWidth, 0.0f, ( GLfloat )screenHeight, 0.1f, 1000.0f); // Game loop while ( !glfwWindowShouldClose( window ) ) { // Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions glfwPollEvents( ); // Render // Clear the colorbuffer glClearColor( 0.2f, 0.3f, 0.3f, 1.0f ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // Bind Textures using texture units glActiveTexture( GL_TEXTURE0 ); glBindTexture( GL_TEXTURE_2D, texture ); glUniform1i(glGetUniformLocation( ourShader.Program, "ourTexture1" ), 0 ); // Activate shader ourShader.Use( ); // Create transformations glm::mat4 model; glm::mat4 view; model = glm::rotate( model, ( GLfloat)glfwGetTime( ) * 1.0f, glm::vec3( 0.5f, 1.0f, 0.0f ) ); // use with perspective projection //model = glm::rotate( model, 0.5f, glm::vec3( 1.0f, 0.0f, 0.0f ) ); // use to compare orthographic and perspective projection //view = glm::translate( view, glm::vec3( screenWidth / 2, screenHeight / 2, -700.0f ) ); // use with orthographic projection view = glm::translate( view, glm::vec3( 0.0f, 0.0f, -3.0f ) ); // use with perspective projection // Get their uniform location GLint modelLoc = glGetUniformLocation( ourShader.Program, "model" ); GLint viewLoc = glGetUniformLocation( ourShader.Program, "view" ); GLint projLoc = glGetUniformLocation( ourShader.Program, "projection" ); // Pass them to the shaders glUniformMatrix4fv( modelLoc, 1, GL_FALSE, glm::value_ptr( model ) ); glUniformMatrix4fv( viewLoc, 1, GL_FALSE, glm::value_ptr( view ) ); glUniformMatrix4fv( projLoc, 1, GL_FALSE, glm::value_ptr( projection ) ); // Draw container glBindVertexArray( VAO ); glDrawArrays( GL_TRIANGLES, 0, 36 ); glBindVertexArray( 0 ); // Swap the screen buffers glfwSwapBuffers( window ); } // Properly de-allocate all resources once they've outlived their purpose glDeleteVertexArrays( 1, &VAO ); glDeleteBuffers( 1, &VBO ); // Terminate GLFW, clearing any resources allocated by GLFW. glfwTerminate( ); return EXIT_SUCCESS; }
GLUSboolean initBackground() { GLUStextfile vertexSource; GLUStextfile fragmentSource; GLUSshape background; glusFileLoadText("../Example15_ES/shader/Background.vert.glsl", &vertexSource); glusFileLoadText("../Example15_ES/shader/Background.frag.glsl", &fragmentSource); glusProgramBuildFromSource(&g_programBackground, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text); glusFileDestroyText(&vertexSource); glusFileDestroyText(&fragmentSource); // g_projectionMatrixBackgroundLocation = glGetUniformLocation(g_programBackground.program, "u_projectionMatrix"); g_modelViewMatrixBackgroundLocation = glGetUniformLocation(g_programBackground.program, "u_modelViewMatrix"); g_cubemapBackgroundLocation = glGetUniformLocation(g_programBackground.program, "u_cubemap"); g_vertexBackgroundLocation = glGetAttribLocation(g_programBackground.program, "a_vertex"); g_normalBackgroundLocation = glGetAttribLocation(g_programBackground.program, "a_normal"); // glBindVertexArray(0); // glusShapeCreateSpheref(&background, (GLfloat) (GLfloat) WATER_PLANE_LENGTH / 2.0f + 0.5f, 32); g_numberIndicesBackground = background.numberIndices; glGenBuffers(1, &g_verticesBackgroundVBO); glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO); glBufferData(GL_ARRAY_BUFFER, background.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) background.vertices, GL_STATIC_DRAW); glGenBuffers(1, &g_normalsBackgroundVBO); glBindBuffer(GL_ARRAY_BUFFER, g_normalsBackgroundVBO); glBufferData(GL_ARRAY_BUFFER, background.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) background.normals, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glGenBuffers(1, &g_indicesBackgroundVBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, background.numberIndices * sizeof(GLuint), (GLuint*) background.indices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glusShapeDestroyf(&background); // glUseProgram(g_programBackground.program); // We assume, that the parent program created the texture! glUniform1i(g_cubemapBackgroundLocation, 0); // glGenVertexArrays(1, &g_vaoBackground); glBindVertexArray(g_vaoBackground); glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO); glVertexAttribPointer(g_vertexBackgroundLocation, 4, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(g_vertexBackgroundLocation); glBindBuffer(GL_ARRAY_BUFFER, g_normalsBackgroundVBO); glVertexAttribPointer(g_normalBackgroundLocation, 3, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(g_normalBackgroundLocation); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO); return GLUS_TRUE; }
void GlslProg::uniform( const std::string &name, int data ) { GLint loc = getUniformLocation( name ); glUniform1i( loc, data ); }
void Shader::updateInt(const char* name, int v) { GLint x = findUniform(name); if (x != -1) glUniform1i(x,v); }
void GameWindow::SetUniform(uint32_t Uniform, int i) { glUniform1i(uniforms[Uniform], i); }
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure) // If text or lines are blurry when integrating ImGui in your engine: // - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f) void ImGui_ImplGlut_RenderDrawLists(ImDrawData* draw_data) { // Backup GL state GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program); GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer); GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer); GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array); GLint last_blend_src; glGetIntegerv(GL_BLEND_SRC, &last_blend_src); GLint last_blend_dst; glGetIntegerv(GL_BLEND_DST, &last_blend_dst); GLint last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, &last_blend_equation_rgb); GLint last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &last_blend_equation_alpha); GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport); GLboolean last_enable_blend = glIsEnabled(GL_BLEND); GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE); GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST); GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST); // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glEnable(GL_SCISSOR_TEST); glActiveTexture(GL_TEXTURE0); // Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays) ImGuiIO& io = ImGui::GetIO(); int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x); int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y); draw_data->ScaleClipRects(io.DisplayFramebufferScale); // Setup viewport, orthographic projection matrix glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height); const float ortho_projection[4][4] = { { 2.0f/io.DisplaySize.x, 0.0f, 0.0f, 0.0f }, { 0.0f, 2.0f/-io.DisplaySize.y, 0.0f, 0.0f }, { 0.0f, 0.0f, -1.0f, 0.0f }, {-1.0f, 1.0f, 0.0f, 1.0f }, }; glUseProgram(g_ShaderHandle); glUniform1i(g_AttribLocationTex, 0); glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]); glBindVertexArray(g_VaoHandle); for (int n = 0; n < draw_data->CmdListsCount; n++) { const ImDrawList* cmd_list = draw_data->CmdLists[n]; const ImDrawIdx* idx_buffer_offset = 0; glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle); glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.size() * sizeof(ImDrawVert), (GLvoid*)&cmd_list->VtxBuffer.front(), GL_STREAM_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx), (GLvoid*)&cmd_list->IdxBuffer.front(), GL_STREAM_DRAW); for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++) { if (pcmd->UserCallback) { pcmd->UserCallback(cmd_list, pcmd); } else { glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y)); glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset); } idx_buffer_offset += pcmd->ElemCount; } } // Restore modified GL state glUseProgram(last_program); glBindTexture(GL_TEXTURE_2D, last_texture); glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer); glBindVertexArray(last_vertex_array); glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha); glBlendFunc(last_blend_src, last_blend_dst); if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND); if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST); if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST); glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]); }