int main () { assert (restart_gl_log ()); assert (start_gl ()); // tell GL to only draw onto a pixel if the shape is closer to the viewer glEnable (GL_DEPTH_TEST); // enable depth-testing glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer" GLfloat points[] = { -0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f, 0.5f, 0.5f, 0.0f, 0.5f, 0.5f, 0.0f, -0.5f, 0.5f, 0.0f, -0.5f, -0.5f, 0.0f }; GLfloat texcoords[] = { 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f }; GLuint points_vbo; glGenBuffers (1, &points_vbo); glBindBuffer (GL_ARRAY_BUFFER, points_vbo); glBufferData (GL_ARRAY_BUFFER, 18 * sizeof (GLfloat), points, GL_STATIC_DRAW); GLuint texcoords_vbo; glGenBuffers (1, &texcoords_vbo); glBindBuffer (GL_ARRAY_BUFFER, texcoords_vbo); glBufferData (GL_ARRAY_BUFFER, 12 * sizeof (GLfloat), texcoords, GL_STATIC_DRAW); GLuint vao; glGenVertexArrays (1, &vao); glBindVertexArray (vao); glBindBuffer (GL_ARRAY_BUFFER, points_vbo); glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL); glBindBuffer (GL_ARRAY_BUFFER, texcoords_vbo); glVertexAttribPointer (1, 2, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray (0); glEnableVertexAttribArray (1); GLuint shader_programme = create_programme_from_files ( "test_vs.glsl", "test_fs.glsl"); #define ONE_DEG_IN_RAD (2.0 * M_PI) / 360.0 // 0.017444444 // input variables float near = 0.1f; // clipping plane float far = 100.0f; // clipping plane float fov = 67.0f * ONE_DEG_IN_RAD; // convert 67 degrees to radians float aspect = (float)g_gl_width / (float)g_gl_height; // aspect ratio // matrix components float range = tan (fov * 0.5f) * near; float Sx = (2.0f * near) / (range * aspect + range * aspect); float Sy = near / range; float Sz = -(far + near) / (far - near); float Pz = -(2.0f * far * near) / (far - near); GLfloat proj_mat[] = { Sx, 0.0f, 0.0f, 0.0f, 0.0f, Sy, 0.0f, 0.0f, 0.0f, 0.0f, Sz, -1.0f, 0.0f, 0.0f, Pz, 0.0f }; float cam_speed = 1.0f; // 1 unit per second float cam_yaw_speed = 10.0f; // 10 degrees per second float cam_pos[] = {0.0f, 0.0f, 2.0f}; // don't start at zero, or we will be too close float cam_yaw = 0.0f; // y-rotation in degrees mat4 T = translate (identity_mat4 (), vec3 (-cam_pos[0], -cam_pos[1], -cam_pos[2])); mat4 R = rotate_y_deg (identity_mat4 (), -cam_yaw); mat4 view_mat = R * T; int view_mat_location = glGetUniformLocation (shader_programme, "view"); glUseProgram (shader_programme); glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view_mat.m); int proj_mat_location = glGetUniformLocation (shader_programme, "proj"); glUseProgram (shader_programme); glUniformMatrix4fv (proj_mat_location, 1, GL_FALSE, proj_mat); // load texture GLuint tex; assert (load_texture ("skulluvmap.png", &tex)); glEnable (GL_CULL_FACE); // cull face glCullFace (GL_BACK); // cull back face glFrontFace (GL_CCW); // GL_CCW for counter clock-wise while (!glfwWindowShouldClose (g_window)) { static double previous_seconds = glfwGetTime (); double current_seconds = glfwGetTime (); double elapsed_seconds = current_seconds - previous_seconds; previous_seconds = current_seconds; _update_fps_counter (g_window); // wipe the drawing surface clear glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glViewport (0, 0, g_gl_width, g_gl_height); glUseProgram (shader_programme); glBindVertexArray (vao); // draw points 0-3 from the currently bound VAO with current in-use shader glDrawArrays (GL_TRIANGLES, 0, 6); // update other events like input handling glfwPollEvents (); if (GLFW_PRESS == glfwGetKey (g_window, GLFW_KEY_F11)) { assert (screencapture ()); } // control keys bool cam_moved = false; if (glfwGetKey (g_window, GLFW_KEY_A)) { cam_pos[0] -= cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_D)) { cam_pos[0] += cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_PAGE_UP)) { cam_pos[1] += cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_PAGE_DOWN)) { cam_pos[1] -= cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_W)) { cam_pos[2] -= cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_S)) { cam_pos[2] += cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_LEFT)) { cam_yaw += cam_yaw_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_RIGHT)) { cam_yaw -= cam_yaw_speed * elapsed_seconds; cam_moved = true; } // update view matrix if (cam_moved) { mat4 T = translate (identity_mat4 (), vec3 (-cam_pos[0], -cam_pos[1], -cam_pos[2])); // cam translation mat4 R = rotate_y_deg (identity_mat4 (), -cam_yaw); // mat4 view_mat = R * T; glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view_mat.m); } if (GLFW_PRESS == glfwGetKey (g_window, GLFW_KEY_ESCAPE)) { glfwSetWindowShouldClose (g_window, 1); } // put the stuff we've been drawing onto the display glfwSwapBuffers (g_window); } // close GL context and any other GLFW resources glfwTerminate(); return 0; }
int main(void) { _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON); _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON); int width = 800, height = 600; GLFWwindow* window; glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); window = glfwCreateWindow(width, height, "cpu-voxels", NULL, NULL); if (!window) { glfwTerminate(); return 1; } glfwMakeContextCurrent(window); glfwSwapInterval(0); glfwSetKeyCallback(window, key_callback); glfwSetMouseButtonCallback(window, mouse_button_callback); glfwSetCursorPosCallback(window, mouse_move_callback); glfwSetKeyCallback(window, key_callback); vec3 eye = vec3_create(0.0f, 0.0f, VOXEL_BRICK_SIZE * 4); vec3 center = vec3f(0.0f); vec3 up = vec3_create(0.0, 1.0, 0.0 ); orbit_camera_init(eye, center, up); // TODO: handle resize int dw, dh; glfwGetFramebufferSize(window, &dw, &dh); int stride = 3; int total = dw*dh*stride; uint8_t *data = malloc(total); vec3 ro; //, rd; mat4 m4inverted, view; mat4 projection; mat4_perspective( projection, M_PI/4.0, (float)width/(float)height, 0.1, 1000.0 ); GLuint texture[1]; #ifdef ENABLE_THREADS screen_area areas[TOTAL_THREADS]; threadpool thpool = thpool_init(TOTAL_THREADS); #else screen_area areas[1]; #endif glGenTextures(1, texture); float start = glfwGetTime(); int fps = 0; voxel_brick my_first_brick = voxel_brick_create(); // TODO: make this work when the brick lb corner is not oriented at 0,0,0 voxel_brick_position(my_first_brick, vec3f(0.0f)); voxel_brick_fill(my_first_brick, &brick_fill); while (!glfwWindowShouldClose(window)) { if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS) { orbit_camera_rotate(0, 0, -.1, 0); } if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS) { orbit_camera_rotate(0, 0, .1, 0); } if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS) { orbit_camera_rotate(0, 0, 0, .1); } if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS) { orbit_camera_rotate(0, 0, 0, -.1); } glfwGetFramebufferSize(window, &width, &height); float now = glfwGetTime(); if (now - start > 1) { unsigned long long total_rays = (fps * width * height); printf("fps: %i (%f Mrays/s)@%ix%i - %i threads\n", fps, total_rays/1000000.0, width, height, TOTAL_THREADS); start = now; fps = 0; } fps++; orbit_camera_view(view); ro = mat4_get_eye(view); mat4_mul(m4inverted, projection, view); mat4_invert(m4inverted, m4inverted); // compute 3 points so that we can interpolate instead of unprojecting // on every point vec3 rda, rdb, planeYPosition, dcol, drow; vec3 t0 = vec3_create(0, 0, 0), tx = vec3_create(1, 0, 0), ty = vec3_create(0, 1, 0); vec4 viewport = { 0, 0, width, height }; rda = orbit_camera_unproject(t0, viewport, m4inverted); rdb = orbit_camera_unproject(tx, viewport, m4inverted); planeYPosition = orbit_camera_unproject(ty, viewport, m4inverted); dcol = planeYPosition - rda; drow = rdb - rda; int i=0, bh = height; #ifdef ENABLE_THREADS bh = (height/TOTAL_THREADS); for (i; i<TOTAL_THREADS; i++) { #endif areas[i].dcol = dcol; areas[i].drow = drow; areas[i].pos = planeYPosition; areas[i].ro = ro; areas[i].x = 0; areas[i].y = i*bh; areas[i].width = width; areas[i].height = areas[i].y + (int)(bh); areas[i].screen_height = (int)(height); areas[i].stride = stride; areas[i].data = data; areas[i].render_id = i; areas[i].brick = my_first_brick; #ifdef ENABLE_THREADS thpool_add_work(thpool, (void *)render_screen_area, (void *)(&areas[i])); } thpool_wait(thpool); #else render_screen_area((void *)(&areas[i])); #endif #ifdef RENDER glViewport(0, 0, width, height); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glDisable(GL_CULL_FACE); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glScalef(1.0f, -1.0f, 1.0f); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture[0]); glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex2f( -1, -1); glTexCoord2f(1.0f, 0.0f); glVertex2f( 1, -1); glTexCoord2f(1.0f, 1.0f); glVertex2f( 1, 1); glTexCoord2f(0.0f, 1.0f); glVertex2f( -1, 1); glEnd(); glfwSwapBuffers(window); glDeleteTextures(1, &texture[0]); #endif glfwPollEvents(); } glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
int main() { /* Create GL Window */ if (!initWindow()) return -1; /* Initialise vertex buffers for cube */ CubeMap cubeMap; cubeMap.loadCubeMap("../textures/cubemaps/Yokohama/"); /* Load shaders needed */ Entity* box = new Entity(glm::vec3(0)); box->setShader(ShaderManager::loadShader("simpleReflect")); box->loadFromFile("../models/Cube.3ds"); rigidBodies.push_back(new RigidBody(box)); box = new Entity(glm::vec3(0,2,0)); box->setShader(ShaderManager::loadShader("simpleReflect")); box->loadFromFile("../models/Cube.3ds"); rigidBodies.push_back(new RigidBody(box)); std::cout << "some amazing feature has been added"; glEnable(GL_DEPTH_TEST); while (!glfwWindowShouldClose(window)) { /* Rendering Code */ // 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(); //do_rotation(); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glm::mat4 viewMatrix = glm::lookAt ( cameraPos, //where you are cameraPos + cameraFront, // what you are looking at, however we move, the camera keeps looking at the target direction cameraUp ); glm::mat4 projectionMatrix = glm::perspective( fov, (GLfloat)WIDTH/(GLfloat)HEIGHT, 0.1f, 1000.0f ); for(int i =0; i < rigidBodies.size(); i++) { //for(int j = 0; j < rigidBodies.size(); j++) //{ // if (i ==j) // continue; // //if(rigidBodies[i]->aabb->collies(rigidBodies[j]->aabb)) // //do something with shaders to indicate collision in broadphase //} rigidBodies[i]->Update(deltaTime); rigidBodies[i]->entity->getShader()->setUniformMatrix4fv("projectionMat", projectionMatrix); //cubeMap.getShader()->setUniformMatrix4fv("projectionMat", projectionMatrix); rigidBodies[i]->entity->getShader()->setUniformMatrix4fv("viewMat", viewMatrix); //cubeMap.getShader()->setUniformMatrix4fv("viewMat", viewMatrix); //dragonModel.getShader()->setUniformMatrix4fv("viewMat", view_mat); rigidBodies[i]->entity->getShader()->setUniformVector4fv("camPos", glm::vec4(cameraPos, 1.0f)); //glm:: vec3 cam_pos= glm::vec3 (cam_pos); //dragonModel.getShader()->setUniformVector4fv("camPos", glm::vec4(cam_pos, 1.0f)); //rigidBodies[i]->entity->getShader()->setUniformVector4fv("modelMat", rigidBodies[i]->entity->getModelMat()); rigidBodies[i]->entity->draw(); //rigidBodies[i]->ApplyGravity(); } glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); //cubeMap.drawSkyBox(); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_GEN_R); glfwSwapBuffers(window); glfwPollEvents(); } glfwTerminate(); return 0; }
/** The main function of the game demo. Handles the setup and main loop. \return a general error code. \ingroup SnakeGame */ int main() { // First, init/parse/load configuration. const std::vector<std::string> forceArgv = {"SnakeGame", "-c", "config.ini"}; RenderingConfig config(forceArgv); config.initialWidth = 800; config.initialHeight = 600; config.forceAspectRatio = true; GLFWwindow* window = Interface::initWindow("SnakeGame", config); if(!window){ return -1; } // Disable Imgui saving. ImGui::GetIO().IniFilename = NULL; Resources::manager().addResources("../../../resources/snakegame"); // Initialize random generator; Random::seed(); // Create the game main handler.. Game game(config); // Make sure the score file exists. if(!Resources::externalFileExists("./scores.sav")){ Resources::saveStringToExternalFile("./scores.sav", "\n"); } double timer = glfwGetTime(); double remainingTime = 0.0; const double dt = 1.0/120.0; // Small physics timestep. // Start the display/interaction loop. while (!glfwWindowShouldClose(window)) { // Update events (inputs,...). Input::manager().update(); // Start a new frame for the interface. Interface::beginFrame(); // We separate punctual events from the main physics/movement update loop. const Interface::Action actionToTake = game.update(); if(actionToTake != Interface::Action::None){ Interface::performWindowAction(window, config, actionToTake); // Due to the ordering between the update function and the fullscreen activation, we have to manually call resize here. // Another solution would be to check resizing before rendering, in the Game object. if(actionToTake == Interface::Action::Fullscreen){ game.resize((unsigned int)Input::manager().size()[0], (unsigned int)Input::manager().size()[1]); } // Update the config on disk, for next launch. Resources::saveStringToExternalFile("./config.ini", "# SnakeGame Config v1.0\n" + std::string(config.fullscreen ? "fullscreen\n" : "") + (!config.vsync ? "no-vsync" : "\n")); } // Compute the time elapsed since last frame double currentTime = glfwGetTime(); double frameTime = currentTime - timer; timer = currentTime; // Physics simulation // First avoid super high frametime by clamping. if(frameTime > 0.2){ frameTime = 0.2; } // Accumulate new frame time. remainingTime += frameTime; // Instead of bounding at dt, we lower our requirement (1 order of magnitude). while(remainingTime > 0.2*dt){ double deltaTime = fmin(remainingTime, dt); // Update physics and camera. game.physics(deltaTime); // Update timers. remainingTime -= deltaTime; } // Update the content of the window. game.draw(); // Then render the interface. Interface::endFrame(); //Display the result for the current rendering loop. glfwSwapBuffers(window); } // Clean the interface. Interface::clean(); // Clean other resources game.clean(); Resources::manager().clean(); // Close GL context and any other GLFW resources. glfwDestroyWindow(window); glfwTerminate(); return 0; }
// ---------------------------------------------------------------- display --- void display( GLFWwindow* window ) { glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); console_render( console ); glfwSwapBuffers( window ); }
void Window::display() { glfwSwapBuffers(window); }
void carSimulation(std::vector<Car*> cars, std::vector<Wall>* walls, std::vector<glm::vec3>* path, std::vector<double>* distances, GLFWwindow* window) { //TODO: Move this junk to main, or a common class GLuint programID = LoadShaders( "SimpleTransform.vertexshader", "SingleColor.fragmentshader" ); GLuint MatrixID = glGetUniformLocation(programID, "MVP"); GLuint ColorID = glGetUniformLocation(programID, "inColor"); GLuint carbuffer; GLuint carVAO; glGenBuffers(1, &carbuffer); glBindBuffer(GL_ARRAY_BUFFER, carbuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(carData), carData, GL_STATIC_DRAW); glGenVertexArrays(1, &carVAO); glBindVertexArray(carVAO); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); GLuint wallbuffer; GLuint wallVAO; glGenBuffers(1, &wallbuffer); glBindBuffer(GL_ARRAY_BUFFER, wallbuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(wallData), wallData, GL_STATIC_DRAW); glGenVertexArrays(1, &wallVAO); glBindVertexArray(wallVAO); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); GLuint linebuffer; GLuint lineVAO; glGenBuffers(1, &linebuffer); glBindBuffer(GL_ARRAY_BUFFER, linebuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(lineData), lineData, GL_STATIC_DRAW); glGenVertexArrays(1, &lineVAO); glBindVertexArray(lineVAO); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); glm::mat4 Projection = glm::ortho(-50.0,50.0,-50.0,50.0,0.0,100.0); // In world coordinates int nextPoint = 1; int nbFrames = 0; double StartTime = glfwGetTime(); double time = StartTime; double frameLastTime = StartTime; double oldTime = StartTime; printf("starting\n"); while(cars.size() > 0 && time < 60 * 1) { time = glfwGetTime() - StartTime; // Measure speed double currentTime = glfwGetTime(); nbFrames++; if ( currentTime - frameLastTime >= 1.0 ) { // printf and reset timer printf("%f ms/frame\n", 1000.0/double(nbFrames)); nbFrames = 0; frameLastTime += 1.0; } double now = glfwGetTime(); double deltaTime = now - oldTime; oldTime = now; //test position /* glm::vec3 distance = myCar.getCenter() - path.at(nextPoint); */ /* printf("Next: %i (%f)\n", nextPoint, glm::dot(distance, distance)); */ /* if(glm::dot(distance, distance) < distances.at(nextPoint)*distances.at(nextPoint)) { */ /* nextPoint++; */ /* if (nextPoint > path.size() - 1) { */ /* nextPoint = 0; */ /* } */ /* } */ /* std::vector<Car*> carList = Car::getCarList(); */ glClear( GL_COLOR_BUFFER_BIT ); //start drawing for(std::vector<Car*>::iterator it = cars.begin(); it != cars.end();) { int increment = 1; (*it)->update(deltaTime,*walls); double input[LINE_COUNT + 1]; //For biasing input[0] = 1.0; glm::mat4 carMatrix = Projection * Car::getCamera() * (*it)->getMatrix(); render(programID, MatrixID, ColorID, carbuffer, carVAO, carMatrix, CAR_COLOR); std::vector<DetectLine> lines = (*it)->getLineList(); int i = 0; for (std::vector<DetectLine>::iterator lIt = lines.begin(); lIt != lines.end(); lIt++) { renderLine(programID, MatrixID, ColorID, linebuffer, lineVAO, Projection * Car::getCamera() * lIt->getMatrix(), LINE_COLOR); double closest = -1; for (std::vector<Wall>::iterator wIt = walls->begin(); wIt != walls->end(); wIt++) { glm::mat4 wallMatrix = wIt->getMatrix(); glm::vec3 wallB = glm::vec3(wallMatrix * glm::vec4(1.0,0.0,0.0,1.0)); glm::vec3 wallA = glm::vec3(wallMatrix * glm::vec4(-1.0,0.0,0.0,1.0)); //printf("A:%s, B:%s\n", glm::to_string(wallA).c_str(), glm::to_string(wallB).c_str()); double out = 0; if (collisionLineLine(lIt->getCenter(), lIt->getEnd(), wallA , wallB, &out) == true) { if (closest == -1 || out < closest) { closest = out; } } } input[i+1] = closest; i++; /* printf("Closest:%f\n",closest); */ lIt->setDistance(closest); } NEAT::Organism* org = (*it)->getOrganism(); if (org) { NEAT::Network* net = org->net; net->load_sensors(input); if (!(net->activate())) return; std::vector<NEAT::NNode*>::iterator out_iter = net->outputs.begin(); double steering = (*out_iter)->activation; out_iter++; double accel = (*out_iter)->activation; (*it)->input(accel, steering); glm::vec3 distance = (*it)->getCenter() - path->at(nextPoint); glm::vec3 totalDistance = path->at(nextPoint-1) - path->at(nextPoint); double newFit = (*it)->pointDist + glm::dot(totalDistance, totalDistance)- glm::dot(distance, distance); //remember, distance is squared double deltaFit = org->fitness - newFit; if (deltaFit < 1 && deltaFit > -1) { /* printf("Stuck: %i\n", (*it)->stuckTimer); */ (*it)->stuckTimer += 1; if ((*it)->stuckTimer > 500) { delete (*it); it = cars.erase(it); increment = 0; } } else { (*it)->stuckTimer = 0; } org->fitness = newFit; if(glm::dot(distance, distance) < distances->at(nextPoint)*distances->at(nextPoint)) { (*it)->pointDist += glm::dot(distance, distance); nextPoint++; if (nextPoint > path->size() - 1) { nextPoint = 0; } } /* printf("Fitness: %f\n", org->fitness); */ } if (increment) it++; } for(int i = 0; i < walls->size(); i++) { glm::mat4 wallMatrix = Projection * Car::getCamera() * walls->at(i).getMatrix(); render(programID, MatrixID, ColorID, wallbuffer, wallVAO, wallMatrix, WALL_COLOR); } //finish drawing glfwSwapBuffers(window); glClear( GL_COLOR_BUFFER_BIT ); glfwPollEvents(); } //Done, clean up for(std::vector<Car*>::iterator it = cars.begin(); it != cars.end(); it++) { delete (*it); } cars.clear(); }
int main() { // glfw: initialize and configure // ------------------------------ glfwInit(); 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); // uncomment this statement to fix compilation on OS X // glfw window creation // -------------------- GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); if (window == NULL) { std::cout << "Failed to create GLFW window" << std::endl; glfwTerminate(); return -1; } glfwMakeContextCurrent(window); glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); // tell GLFW to capture our mouse glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // glad: load all OpenGL function pointers // --------------------------------------- if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { std::cout << "Failed to initialize GLAD" << std::endl; return -1; } // configure global opengl state // ----------------------------- glEnable(GL_DEPTH_TEST); // build and compile shaders // ------------------------- Shader shader("11.anti_aliasing.vs", "11.anti_aliasing.fs"); Shader screenShader("11.aa_post.vs", "11.aa_post.fs"); // set up vertex data (and buffer(s)) and configure vertex attributes // ------------------------------------------------------------------ float cubeVertices[] = { // positions -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f }; float quadVertices[] = { // vertex attributes for a quad that fills the entire screen in Normalized Device Coordinates. // positions // texCoords -1.0f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }; // setup cube VAO unsigned int cubeVAO, cubeVBO; glGenVertexArrays(1, &cubeVAO); glGenBuffers(1, &cubeVBO); glBindVertexArray(cubeVAO); glBindBuffer(GL_ARRAY_BUFFER, cubeVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), &cubeVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); // setup screen VAO unsigned int quadVAO, quadVBO; glGenVertexArrays(1, &quadVAO); glGenBuffers(1, &quadVBO); glBindVertexArray(quadVAO); glBindBuffer(GL_ARRAY_BUFFER, quadVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)(2 * sizeof(float))); // configure MSAA framebuffer // -------------------------- unsigned int framebuffer; glGenFramebuffers(1, &framebuffer); glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); // create a multisampled color attachment texture unsigned int textureColorBufferMultiSampled; glGenTextures(1, &textureColorBufferMultiSampled); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textureColorBufferMultiSampled); glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGB, SCR_WIDTH, SCR_HEIGHT, GL_TRUE); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, textureColorBufferMultiSampled, 0); // create a (also multisampled) renderbuffer object for depth and stencil attachments unsigned int rbo; glGenRenderbuffers(1, &rbo); glBindRenderbuffer(GL_RENDERBUFFER, rbo); glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_DEPTH24_STENCIL8, SCR_WIDTH, SCR_HEIGHT); glBindRenderbuffer(GL_RENDERBUFFER, 0); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) cout << "ERROR::FRAMEBUFFER:: Framebuffer is not complete!" << endl; glBindFramebuffer(GL_FRAMEBUFFER, 0); // configure second post-processing framebuffer unsigned int intermediateFBO; glGenFramebuffers(1, &intermediateFBO); glBindFramebuffer(GL_FRAMEBUFFER, intermediateFBO); // create a color attachment texture unsigned int screenTexture; glGenTextures(1, &screenTexture); glBindTexture(GL_TEXTURE_2D, screenTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, screenTexture, 0); // we only need a color buffer if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) cout << "ERROR::FRAMEBUFFER:: Intermediate framebuffer is not complete!" << endl; glBindFramebuffer(GL_FRAMEBUFFER, 0); // shader configuration // -------------------- shader.use(); screenShader.setInt("screenTexture", 0); // render loop // ----------- while (!glfwWindowShouldClose(window)) { // per-frame time logic // -------------------- float currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; // input // ----- processInput(window); // render // ------ glClearColor(0.1f, 0.1f, 0.1f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // 1. draw scene as normal in multisampled buffers glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); glClearColor(0.1f, 0.1f, 0.1f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); // set transformation matrices shader.use(); glm::mat4 projection = glm::perspective(camera.Zoom, (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 1000.0f); shader.setMat4("projection", projection); shader.setMat4("view", camera.GetViewMatrix()); shader.setMat4("model", glm::mat4()); glBindVertexArray(cubeVAO); glDrawArrays(GL_TRIANGLES, 0, 36); // 2. now blit multisampled buffer(s) to normal colorbuffer of intermediate FBO. Image is stored in screenTexture glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, intermediateFBO); glBlitFramebuffer(0, 0, SCR_WIDTH, SCR_HEIGHT, 0, 0, SCR_WIDTH, SCR_HEIGHT, GL_COLOR_BUFFER_BIT, GL_NEAREST); // 3. now render quad with scene's visuals as its texture image glBindFramebuffer(GL_FRAMEBUFFER, 0); glClearColor(1.0f, 1.0f, 1.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glDisable(GL_DEPTH_TEST); // draw Screen quad screenShader.use(); glBindVertexArray(quadVAO); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, screenTexture); // use the now resolved color attachment as the quad's texture glDrawArrays(GL_TRIANGLES, 0, 6); // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.) // ------------------------------------------------------------------------------- glfwSwapBuffers(window); glfwPollEvents(); } glfwTerminate(); return 0; }
int main() { glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", nullptr, nullptr); if (window == nullptr) { std::cerr << "Failed to create GLFW window" << std::endl; return -1; } glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { std::cout << "Failed to initialize GLEW" << std::endl; return -1; } glViewport(0, 0, 800, 600); GLfloat vertices[] = { -0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f }; GLuint VBO; glGenBuffers(1, &VBO); GLuint VAO; glGenVertexArrays(1, &VAO); glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GL_FLOAT), (GLvoid*)0); glEnableVertexAttribArray(0); glBindVertexArray(0); GLuint vertexShader; try { vertexShader = load_shader(vertex); } catch (std::exception e) { std::cerr << e.what() << std::endl; return -1; } GLuint fragmentShader; try { fragmentShader = load_shader(fragment); } catch (std::exception& e) { std::cerr << e.what() << std::endl; return -1; } GLuint shaderProgram; shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); GLint success; GLchar infoLog[512]; glGetShaderiv(shaderProgram, GL_LINK_STATUS, &success); if (!success) { glGetShaderInfoLog(shaderProgram, 512, NULL, infoLog); std::cerr << "ERROR: Shader linking failed\n" << infoLog << std::endl; return -1; } glUseProgram(shaderProgram); glDeleteShader(vertexShader); glDeleteShader(fragmentShader); std::cout << glGetString(GL_VERSION) << std::endl; while (!glfwWindowShouldClose(window)) { glfwPollEvents(); glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glBindVertexArray(VAO); glDrawArrays(GL_TRIANGLES, 0, 3); glBindVertexArray(0); glfwSwapBuffers(window); } glfwTerminate(); return 0; }
int main(int argc, char** argv) { int width, height, ch; int mode = GLFW_WINDOWED; GLFWwindow window; while ((ch = getopt(argc, argv, "fh")) != -1) { switch (ch) { case 'h': usage(); exit(EXIT_SUCCESS); case 'f': mode = GLFW_FULLSCREEN; break; default: usage(); exit(EXIT_FAILURE); } } if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW: %s\n", glfwErrorString(glfwGetError())); exit(EXIT_FAILURE); } if (mode == GLFW_FULLSCREEN) { GLFWvidmode desktop_mode; glfwGetDesktopMode(&desktop_mode); width = desktop_mode.width; height = desktop_mode.height; } else { width = 200; height = 200; } window = glfwCreateWindow(width, height, mode, "Gamma Test", NULL); if (!window) { glfwTerminate(); fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError())); exit(EXIT_FAILURE); } set_gamma(1.f); glfwMakeContextCurrent(window); glfwSwapInterval(1); glfwSetKeyCallback(window, key_callback); glfwSetWindowCloseCallback(window, window_close_callback); glfwSetWindowSizeCallback(window, size_callback); glMatrixMode(GL_PROJECTION); glOrtho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f); glMatrixMode(GL_MODELVIEW); glClearColor(0.5f, 0.5f, 0.5f, 0); while (!closed) { glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.8f, 0.2f, 0.4f); glRectf(-0.5f, -0.5f, 0.5f, 0.5f); glfwSwapBuffers(window); glfwPollEvents(); } glfwTerminate(); exit(EXIT_SUCCESS); }
// The MAIN function, from here we start the application and run the game loop int main(int argc, char **argv) { // 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); // 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(); // Load texture if (argc != 3) { std::cerr << "Usage: " << argv[0] << " image_path image_path2" << std::endl; exit(EXIT_FAILURE); } GLuint texture = load_texture(argv[1]); if (!texture) { std::cerr << "ERROR could not load image " << argv[1] << std::endl; exit(EXIT_FAILURE); } GLuint texture2 = load_texture(argv[2]); if (!texture2) { std::cerr << "ERROR could not laod image " << argv[2] << std::endl; exit(EXIT_FAILURE); } // Define the viewport dimensions glViewport(0, 0, WIDTH, HEIGHT); Shader ourShader("./shader.vert", "./shader.frag"); // Set up vertex data (and buffer(s)) and attribute pointers GLfloat vertices[] = { // Positions // Color // Texture Coords 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // Top Right 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // Bottom Right -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // Bottom Left -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, // Top Left }; GLuint indices[] = { 0, 1, 3, // First triangle 1, 2, 3, // Second triangle }; GLuint VBO, VAO, 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); // Positions glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); // Colors glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); // Texture coords glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); glEnableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, 0); // Note that this is allowed, the call to glVertexAttribPointer registered VBO as the currently bound vertex buffer object so afterwards we can safely unbind glBindVertexArray(0); // Unbind VAO (it's always a good thing to unbind any buffer/array to prevent strange bugs) // 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); // Draw our first triangle ourShader.use(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture); glUniform1i(glGetUniformLocation(ourShader.program_, "ourTexture1"), 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture2); glUniform1i(glGetUniformLocation(ourShader.program_, "ourTexture2"), 1); glBindVertexArray(VAO); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); 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 Window::swapBuffers() { glfwSwapBuffers(this->pGlfwWindow); }
// 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_ANY_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); // 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); // Build and compile our shader program // Vertex shader GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glCompileShader(vertexShader); // Check for compile time errors GLint success; GLchar infoLog[512]; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(vertexShader, 512, NULL, infoLog); std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl; } // Fragment shader GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); glCompileShader(fragmentShader); // Check for compile time errors glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog); std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl; } // Link shaders GLuint shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); // Check for linking errors glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success); if (!success) { glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog); std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl; } glDeleteShader(vertexShader); glDeleteShader(fragmentShader); // Set up vertex data (and buffer(s)) and attribute pointers GLfloat vertices[] = { -0.5f, -0.5f, 0.0f, // Left 0.5f, -0.5f, 0.0f, // Right -0.5f, 0.5f, 0.0f, 0.5f, 0.5f, 0.0f // Top }; GLuint indices[] = { 0,1,3, 3,2,0 }; GLuint VBO, VAO, 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); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); // Note that this is allowed, the call to glVertexAttribPointer registered VBO as the currently bound vertex buffer object so afterwards we can safely unbind glBindVertexArray(0); // Unbind VAO (it's always a good thing to unbind any buffer/array to prevent strange bugs) // 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); // Draw our first triangle glUseProgram(shaderProgram); glBindVertexArray(VAO); //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); 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); glDeleteBuffers(1, &EBO); // Terminate GLFW, clearing any resources allocated by GLFW. glfwTerminate(); return 0; }
int main(int argc, char** argv) { glfwInit(); glfwOpenWindow(WIDTH, HEIGHT, 8, 8, 8, 8, 32, 0, GLFW_WINDOW); // Setup OpenGL stuff glEnable(GL_DEPTH_TEST); glClearColor(0, 0, 0, 0); glViewport(0, 0, WIDTH, HEIGHT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(90.0, (float)WIDTH/(float)HEIGHT, 0.1, 10.0); glMatrixMode(GL_MODELVIEW); obj_model m(argv[1]); if (argc > 1 && argv[1]) { std::cout << "size is " << m.v.size() << std::endl; std::cout << "Vertex is " << m.v[0].a << "," << m.v[0].b << "," << m.v[0].c << std::endl; std::cout << "Vertex2is " << m.v[1].a << "," << m.v[1].b << "," << m.v[1].c << std::endl; } int running = 1; int jumping = 0; float rotZ = 0; float rotY = 0; float rotX = 0; float posnZ = 2; float posnY = 0; float posnX = 0; float velo = 0; const float GRAVITY = -0.005; const float LOOK_X_TOP = +M_PI/3.; const float LOOK_X_BOT = -M_PI/3.; float lookX = 0; /* in radians */ float lookY = 0; /* aka THETA, in radians */ while(running) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); /* Look around */ if (glfwGetKey('F')) lookX -= 0.02; if (glfwGetKey('R')) lookX += 0.02; if (lookX >= LOOK_X_TOP) lookX = LOOK_X_TOP; if (lookX <= LOOK_X_BOT) lookX = LOOK_X_BOT; glRotatef(-lookX * (180./M_PI), 1, 0, 0); if (glfwGetKey('H')) lookY -= 0.02; if (glfwGetKey('G')) lookY += 0.02; glRotatef(-lookY * (180./M_PI), 0, 1, 0); // Setup camera transformation if (glfwGetKey(GLFW_KEY_UP)) { posnX -= 0.01 * sin(lookY); posnZ -= 0.01 * cos(lookY); } if (glfwGetKey(GLFW_KEY_DOWN)) { posnX += 0.01 * sin(lookY); posnZ += 0.01 * cos(lookY); } if (glfwGetKey(GLFW_KEY_LEFT)) { posnX -= 0.01 * cos(lookY); posnZ += 0.01 * sin(lookY); } if (glfwGetKey(GLFW_KEY_RIGHT)) { posnX += 0.01 * cos(lookY); posnZ -= 0.01 * sin(lookY); } if (glfwGetKey(GLFW_KEY_SPACE)) { velo = 0.1; jumping = 1; } if (jumping) { posnY += velo; if (posnY >= 0) { velo += GRAVITY; } else { jumping = 0; posnY = 0; } } glTranslatef(-posnX, -posnY, -posnZ); // Setup model transformation if (glfwGetKey('Q')) rotZ += 0.2; if (glfwGetKey('E')) rotZ -= 0.2; if (glfwGetKey('A')) rotY += 0.2; if (glfwGetKey('D')) rotY -= 0.2; if (glfwGetKey('W')) rotX += 0.2; if (glfwGetKey('S')) rotX -= 0.2; glRotatef(rotZ, 0, 0, 1); glRotatef(rotY, 0, 1, 0); glRotatef(rotX, 1, 0, 0); // Draw! ////draw_cube(); draw_object(m); glfwSwapBuffers(); running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED); } }
int main() { // Init GLFW glfwInit(); // Set all the required options for GLFW glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // Create a GLFWwindow object that we can use for GLFW's functions GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "Fluid simulation", 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); initialize(); Shader vizualizeProgram("defaultVS.vs", "visualize.fs"); Shader advect("defaultVS.vs", "advect.fs"); Shader computeDivergence("defaultVS.vs", "computeDivergence.fs"); Shader makeGravity("defaultVS.vs", "gravityField.fs"); Shader jacobi("defaultVS.vs", "jacobi.fs"); Shader subtractGradient("defaultVS.vs", "subtractGradient.fs"); // Game loop while (!glfwWindowShouldClose(window)) { // Calculate deltatime of current frame GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; // Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions glfwPollEvents(); update(advect, computeDivergence, makeGravity, jacobi, subtractGradient); render(vizualizeProgram); // Swap the screen buffers glfwSwapBuffers(window); std::this_thread::sleep_for(std::chrono::milliseconds(10)); lastFrame = currentFrame; } // Terminate GLFW, clearing any resources allocated by GLFW. glfwTerminate(); return 0; }
int main() { glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpengL", nullptr, nullptr); if (window == nullptr) { std::cout << "Window not created\n"; glfwTerminate(); } else { std::cout << "The Window is created\n"; glfwMakeContextCurrent(window); } glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { std:: cout << "Failed to Initialize GLEW. Lol \n"; } glViewport(0,0,800,600); //Compile Shaders GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glCompileShader(vertexShader); GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); glCompileShader(fragmentShader); //Check for Compile Time errors while compiling shaders GLint success; GLchar infoLog[512]; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(vertexShader, 512, NULL, infoLog); std::cout << "Compilation of Vertex Shader Failed\n"; } glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(fragmentShader,512, NULL, infoLog); std::cout << "Compilation of Fragment Shader Failed\n"; } //Link Shaders GLuint shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); //Check for Linking Errors of Shaders glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success); if (!success) { glGetProgramInfoLog(shaderProgram,512, NULL, infoLog); std::cout << "Linkin of Shaders Failed\n"; } glDeleteShader(vertexShader); glDeleteShader(fragmentShader); GLfloat vertices[] = { +0.0f, +0.0f, +0.0f, -1.0f, +1.0f, +0.0f, +1.0f, +1.0f, +0.0f, +0.0f, +0.0f, +0.0f, -1.0f, -1.0f, +0.0f, +1.0f, -1.0f, +0.0f }; GLuint VBO; GLuint VAO; glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GL_FLOAT), (GLvoid*)0); glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); while(!glfwWindowShouldClose(window)) { glfwPollEvents(); glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glUseProgram(shaderProgram); glBindVertexArray(VAO); glDrawArrays(GL_TRIANGLES, 0, 6); glBindVertexArray(0); glfwSwapBuffers(window); } glDeleteVertexArrays(1, &VAO); glDeleteBuffers(1, &VBO); glfwTerminate(); return 0; }
//The main function int Main::start() { //Init if (init() == -1) { fprintf(stderr, "Could not initialise the program\n"); return -1; } //Create the scene Scene scene = Scene(window); Camera* camera = scene.getCamera(); camera->setFOV(45); //Create the loaders ModelLoader loader = ModelLoader(); TextureLoader textureLoader = TextureLoader(); //Create the models Model texturedModel = loader.loadToVao_OBJ_Textured("models/cube.obj", "textures/cube.bmp", glm::vec3(-3, 0, -5)); Model monkey = loader.loadToVao_OBJ("models/suzanne.obj", glm::vec3(0, 0, -5)); monkey.texture(textureLoader.loadBMP_custom("textures/suzanne texture.bmp")); monkey.setReflectivity(0.0); //Create an array of the same entities and add them to the scene std::vector<Entity> cubes; std::vector<glm::vec3> positions; int numOfCubes = 1000; Cube cubeTemp = Cube(); //Create the positions array for (int i = 0; i < numOfCubes; i++) { positions.insert(positions.end(), glm::vec3(rand() % 100, rand() % 100, rand() % 100)); } //Generate cloned cubes and put them at different positions cubes = cubeTemp.cloneEntity(positions); //Add the cubes to the entity map for (int i = 0; i < cubes.size(); i++) { scene.addEntity(&cubes[i]); } //Add the models to the scene scene.addModel(texturedModel); scene.addModel(monkey); //Create the onclick function auto onClick = []() { exit(0); }; //Create the UIs UIButton button = UIButton(0.06f, 0.05f, glm::vec2(1, -1), window, onClick); button.setAlignment(UIButton::ALIGN_BOTTOM_RIGHT); button.texture(textureLoader.loadBMP_custom("textures/Exit.bmp")); UIElement* ui = &button; //Add the UI scene.addPauseUI(ui); //Main loop while (!window.shouldClose()) { //Run the scene scene.run(); //Run the UI //Swap the buffers and poll events glfwSwapBuffers(window.getWindow()); glfwPollEvents(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } //Terminate glfw glfwTerminate(); return 0; }
int main() { adder::Polygon poly({{0, 0}, {144, 0}, {144, -72}, {72, -72}, {120, -48}, {48, -12}, {24, -24}, {72, -48}, {24 ,-72}, {0, -72}}, {256, 128}); std::vector<glm::vec3> colors = {{0.2, 0.0, 0.8}, {0.2, 0.0, 0.8}, {1.0, 0.0, 0.8}, {1.0, 1.0, 0.0}, {1.0, 0.0, 0.8}, {1.0, 0.0, 0.8}, {1.0, 0.0, 0.8}, {1.0, 0.0, 0.8}, {1.0, 0.0, 0.8}, {1.0, 0.0, 0.8}}; //poly.rotate(2*adder::PI/3, poly.get_pos()); adder::Body body(100, 100, -.1, poly); boa::GLData poly_gl_data(poly.vertices(), 6); poly_gl_data.set_attribute(3, colors); boa::init(3, 3, GL_FALSE); GLFWwindow* window = boa::create_window(640, 480, "BOA TEST"); glfwSetKeyCallback(window, key_callback); glEnable(GL_DEPTH_TEST); glClearColor(0.2, 0.5, 1.0, 0.0); //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Outline mode GLuint vertex_shader = boa::compile_shader("res/shaders/shader.vert", GL_VERTEX_SHADER); GLuint fragment_shader = boa::compile_shader("res/shaders/shader.frag", GL_FRAGMENT_SHADER); GLuint shader_program = boa::create_program({vertex_shader, fragment_shader}); glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); // Create vertex array object // The vertex array object stores the states of the vertex and index buffer // objects defined inside of it, allowing them to be easily reused again. // The vertex and index buffer objects store the vertex and index data on // the gpu, respectively. They are cleared automatically after each drawing // cycle, hence the need for the vertex array object. I think. // TODO: find some way to abstract this GLuint vao, vbo, ibo; glGenVertexArrays(1, &vao); glGenBuffers(1, &vbo); glGenBuffers(1, &ibo); glBindVertexArray(vao); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, poly_gl_data.get_verts_size(), poly_gl_data.get_vertices(), GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, poly_gl_data.get_indices_size(), poly_gl_data.get_indices(), GL_STATIC_DRAW); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); // Transformation matrices glm::mat4 model, view, projection; projection = glm::ortho(0.0f, 640.0f, 480.0f, 0.0f); while(!glfwWindowShouldClose(window)) { glfwPollEvents(); key_parse(); glUseProgram(shader_program); // Update view matrix with new camera position view = glm::translate(glm::mat4(), glm::vec3(camera_x, camera_y, 0.0f)); // Load uniforms glUniformMatrix4fv(glGetUniformLocation(shader_program, "view"), 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(glGetUniformLocation(shader_program, "projection"), 1, GL_FALSE, glm::value_ptr(projection)); glBindVertexArray(vao); // Render glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); model = glm::mat4(); glUniformMatrix4fv(glGetUniformLocation(shader_program, "model"), 1, GL_FALSE, glm::value_ptr(model)); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); glDrawElements(GL_TRIANGLES, poly_gl_data.get_num_elements(), GL_UNSIGNED_INT, 0); glBindVertexArray(0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glfwSwapBuffers(window); } glDeleteVertexArrays(1, &vao); glDeleteBuffers(1, &vbo); glfwDestroyWindow(window); glfwTerminate(); return 0; }
void GLViewImpl::swapBuffers() { if(_mainWindow) glfwSwapBuffers(_mainWindow); }
int main(int argc, char** argv) { GLFWwindow* window; int ch, iter; double dt; double last_update_time; int frame; float f; GLint uloc_modelview; GLint uloc_project; char* vertex_shader_path = NULL; char* fragment_shader_path = NULL; char* vertex_shader_src = NULL; char* fragment_shader_src = NULL; GLuint shader_program; while ((ch = getopt(argc, argv, "f:v:h")) != -1) { switch (ch) { case 'f': fragment_shader_path = optarg; break; case 'v': vertex_shader_path = optarg; break; case 'h': usage(); exit(EXIT_SUCCESS); default: usage(); exit(EXIT_FAILURE); } } if (fragment_shader_path) { vertex_shader_src = read_file_content(fragment_shader_path); if (!fragment_shader_src) { fprintf(stderr, "ERROR: unable to load fragment shader from '%s'\n", fragment_shader_path); exit(EXIT_FAILURE); } } if (vertex_shader_path) { vertex_shader_src = read_file_content(vertex_shader_path); if (!vertex_shader_src) { fprintf(stderr, "ERROR: unable to load vertex shader from '%s'\n", fragment_shader_path); exit(EXIT_FAILURE); } } if (!glfwInit()) { fprintf(stderr, "ERROR: Unable to initialize GLFW\n"); usage(); free(vertex_shader_src); free(fragment_shader_src); exit(EXIT_FAILURE); } glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_FALSE); window = glfwCreateWindow(800, 600, "GLFW OpenGL3 Heightmap demo", NULL, NULL); if (! window ) { fprintf(stderr, "ERROR: Unable to create the OpenGL context and associated window\n"); usage(); free(vertex_shader_src); free(fragment_shader_src); glfwTerminate(); exit(EXIT_FAILURE); } /* Register events callback */ glfwSetKeyCallback(window, key_callback); glfwMakeContextCurrent(window); if (GL_TRUE != init_opengl()) { fprintf(stderr, "ERROR: unable to resolve OpenGL function pointers\n"); free(vertex_shader_src); free(fragment_shader_src); glfwTerminate(); exit(EXIT_FAILURE); } /* Prepare opengl resources for rendering */ shader_program = make_shader_program(vertex_shader_src , fragment_shader_src); free(vertex_shader_src); free(fragment_shader_src); if (shader_program == 0u) { fprintf(stderr, "ERROR: during creation of the shader program\n"); usage(); glfwTerminate(); exit(EXIT_FAILURE); } pglUseProgram(shader_program); uloc_project = pglGetUniformLocation(shader_program, "project"); uloc_modelview = pglGetUniformLocation(shader_program, "modelview"); /* Compute the projection matrix */ f = 1.0f / tanf(view_angle / 2.0f); projection_matrix[0] = f / aspect_ratio; projection_matrix[5] = f; projection_matrix[10] = (z_far + z_near)/ (z_near - z_far); projection_matrix[11] = -1.0f; projection_matrix[14] = 2.0f * (z_far * z_near) / (z_near - z_far); pglUniformMatrix4fv(uloc_project, 1, GL_FALSE, projection_matrix); /* Set the camera position */ modelview_matrix[12] = -5.0f; modelview_matrix[13] = -5.0f; modelview_matrix[14] = -20.0f; pglUniformMatrix4fv(uloc_modelview, 1, GL_FALSE, modelview_matrix); /* Create mesh data */ init_map(); make_mesh(shader_program); /* Create vao + vbo to store the mesh */ /* Create the vbo to store all the information for the grid and the height */ /* setup the scene ready for rendering */ glViewport(0, 0, 800, 600); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); /* main loop */ frame = 0; iter = 0; dt = last_update_time = glfwGetTime(); while (!glfwWindowShouldClose(window)) { ++frame; /* render the next frame */ glClear(GL_COLOR_BUFFER_BIT); glDrawElements(GL_LINES, 2* MAP_NUM_LINES , GL_UNSIGNED_INT, 0); /* display and process events through callbacks */ glfwSwapBuffers(window); glfwPollEvents(); /* Check the frame rate and update the heightmap if needed */ dt = glfwGetTime(); if ((dt - last_update_time) > 0.2) { /* generate the next iteration of the heightmap */ if (iter < MAX_ITER) { update_map(NUM_ITER_AT_A_TIME); update_mesh(); iter += NUM_ITER_AT_A_TIME; } last_update_time = dt; frame = 0; } } glfwTerminate(); exit(EXIT_SUCCESS); }
int main(void) { // for application time calculations static GLfloat last = 0; GLfloat timer = glfwGetTime(); GLfloat start; start = timer; last = timer; // array of circles Circle circles[CIRCLE_NUM]; int length = CIRCLE_NUM; int i; int currentCircleIndex; // time to wait before moving the circle GLfloat sleep = 0.01; // total running time GLfloat total = TOTAL_TIME * 60; // 1 minutes has 60 seconds // output file name char text[] = "output.txt"; // output stream FILE * out = fopen(text, "w"); globalOut = out; //initialize the global variable chosenCircleIndex = 0; currentCircleIndex = chosenCircleIndex; currentCircle = &circles[currentCircleIndex]; srand(time(NULL)); initCircleArray(circles, length); glfwSetErrorCallback(error); if (!glfwInit() || out == NULL) { return -1; } window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "two_co", NULL, NULL); if (!window) { glfwTerminate(); return -1; } glfwMakeContextCurrent(window); glViewport(0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR); glfwSetCursor( window, cursor ); // set to null to reset cursor glfwSetKeyCallback(window, key_callback); glfwSetMouseButtonCallback(window, mouse_button_callback); while (timer - start < total && !glfwWindowShouldClose(window)) { glClear(GL_COLOR_BUFFER_BIT); timer = glfwGetTime(); writeToFile(out, circles[currentCircleIndex], timer, window); // whether we should change the color if (currentCircleIndex != chosenCircleIndex) { currentCircleIndex = chosenCircleIndex; // set all circle to blue for (i = 0; i < length; i++) { circles[i].colour[0] = 0; circles[i].colour[1] = 0; circles[i].colour[2] = 255; } // set green color to the chosen circle circles[currentCircleIndex].colour[0] = 0; circles[currentCircleIndex].colour[1] = 255; circles[currentCircleIndex].colour[2] = 0; currentCircle = &circles[currentCircleIndex]; } // whether we should move the circle if (timer - last > sleep) { last = timer; for (i = 0; i < length; i++) { moves(circles, length, i); drawCircle(circles[i]); } } else { for (i = 0; i < length; i++) { drawCircle(circles[i]); } } glfwSwapBuffers(window); glfwPollEvents(); } fclose(out); glfwDestroyWindow(window); glfwTerminate(); return 0; }
int main(int argc, char** argv) { if (!glfwInit()) // 初始化glfw库 { std::cout << "Error::GLFW could not initialize GLFW!" << std::endl; return -1; } // 开启OpenGL 3.3 core profile std::cout << "Start OpenGL core profile version 3.3" << std::endl; glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // 创建窗口 GLFWwindow* window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Demo of geometry shader", NULL, NULL); if (!window) { std::cout << "Error::GLFW could not create winddow!" << std::endl; glfwTerminate(); std::system("pause"); return -1; } // 创建的窗口的context指定为当前context glfwMakeContextCurrent(window); // 注册窗口键盘事件回调函数 glfwSetKeyCallback(window, key_callback); // 注册鼠标事件回调函数 glfwSetCursorPosCallback(window, mouse_move_callback); // 注册鼠标滚轮事件回调函数 glfwSetScrollCallback(window, mouse_scroll_callback); // 鼠标捕获 停留在程序内 glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // 初始化GLEW 获取OpenGL函数 glewExperimental = GL_TRUE; // 让glew获取所有拓展函数 GLenum status = glewInit(); if (status != GLEW_OK) { std::cout << "Error::GLEW glew version:" << glewGetString(GLEW_VERSION) << " error string:" << glewGetErrorString(status) << std::endl; glfwTerminate(); std::system("pause"); return -1; } // 设置视口参数 glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT); //Section1 顶点属性数据 // 指定顶点属性数据 顶点位置 GLfloat points[] = { -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, // 左上 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, // 右上 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, // 右下 -0.5f, -0.5f, 1.0f, 1.0f, 0.0f // 左下 }; // Section2 准备缓存对象 GLuint pointVAOId, pointVBOId; glGenVertexArrays(1, &pointVAOId); glGenBuffers(1, &pointVBOId); glBindVertexArray(pointVAOId); glBindBuffer(GL_ARRAY_BUFFER, pointVBOId); glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW); // 顶点位置数据 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GL_FLOAT), (GLvoid*)0); glEnableVertexAttribArray(0); // 顶点颜色数据 glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GL_FLOAT), (GLvoid*)(2 * sizeof(GL_FLOAT))); glEnableVertexAttribArray(1); glBindVertexArray(0); // Section3 准备着色器程序 Shader shader("scene.vertex", "scene.frag", "scene.gs"); // 添加了几何着色器 glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glDepthFunc(GL_LESS); glEnable(GL_PROGRAM_POINT_SIZE); // 启用在顶点着色器中指定点的大小 // 开始游戏主循环 while (!glfwWindowShouldClose(window)) { GLfloat currentFrame = (GLfloat)glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; glfwPollEvents(); // 处理例如鼠标 键盘等事件 do_movement(); // 根据用户操作情况 更新相机属性 // 设置colorBuffer颜色 glClearColor(0.18f, 0.04f, 0.14f, 1.0f); // 清除colorBuffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // 先绘制场景 演示几何着色器时 暂不使用MVP矩阵了 shader.use(); glBindVertexArray(pointVAOId); glDrawArrays(GL_POINTS, 0, 4); glBindVertexArray(0); glUseProgram(0); glfwSwapBuffers(window); // 交换缓存 } // 释放资源 glDeleteVertexArrays(1, &pointVAOId); glDeleteBuffers(1, &pointVBOId); glfwTerminate(); return 0; }
int FrameBuffer::enter() { glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); GLFWwindow* window = glfwCreateWindow(screenWidth, screenHeight, "LearnOpenGL", nullptr, nullptr); // Windowed glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); //glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // initialize GLEW to setup the OpenGL Function pointers glewExperimental = GL_TRUE; glewInit(); glViewport(0, 0, screenWidth, screenHeight); glDepthFunc(GL_LESS); Shader shader("../_ShaderSource/advanced/advanced.vs", "../_ShaderSource/advanced/advanced.frag"); Shader screenShader("../_ShaderSource/advanced/screen.vs", "../_ShaderSource/advanced/screen.frag"); #pragma region "object_initialization" // set the object data -buffers, -vertex attributes GLfloat cubeVertices[] = { // Positions // Texture Coords -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 }; GLfloat floorVertices[] = { // Positions // Texture Coords (note we set these higher than 1 that together with GL_REPEAT as texture wrapping mode will cause the floor texture to repeat) 5.0f, -0.5f, 5.0f, 2.0f, 0.0f, -5.0f, -0.5f, 5.0f, 0.0f, 0.0f, -5.0f, -0.5f, -5.0f, 0.0f, 2.0f, 5.0f, -0.5f, 5.0f, 2.0f, 0.0f, -5.0f, -0.5f, -5.0f, 0.0f, 2.0f, 5.0f, -0.5f, -5.0f, 2.0f, 2.0f }; GLfloat quadVertices[] = { // Vertex attributes for a quad // that fills the entire screen in Normalized Device Coordinates. // Positions // TexCoords -1.0f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }; GLuint cubeVAO; glGenVertexArrays(1, &cubeVAO); glBindVertexArray(cubeVAO); GLuint cubeVBO; glGenBuffers(1, &cubeVBO); glBindBuffer(GL_ARRAY_BUFFER, cubeVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), &cubeVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glBindVertexArray(0); GLuint floorVAO; glGenVertexArrays(1, &floorVAO); glBindVertexArray(floorVAO); GLuint floorVBO; glGenBuffers(1, &floorVBO); glBindBuffer(GL_ARRAY_BUFFER, floorVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(floorVertices), &floorVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glBindVertexArray(0); GLuint quadVAO; glGenVertexArrays(1, &quadVAO); glBindVertexArray(quadVAO); GLuint quadVBO; glGenBuffers(1, &quadVBO); glBindBuffer(GL_ARRAY_BUFFER, quadVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2 * sizeof(GLfloat))); glBindVertexArray(0); //load textures GLuint cubeTexture = loadTexture("../res/Textures/container.jpg"); GLuint floorTexture = loadTexture("../res/Textures/metal.png"); #pragma endregion // Framebuffers GLuint framebuffer; glGenFramebuffers(1, &framebuffer); glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); // Create a color attachment texture GLuint textureColorbuffer = generateAttachmentTexture(false, false); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureColorbuffer, 0); // Create a renderbuffer object for depth and stencil attachment GLuint rbo; glGenRenderbuffers(1, &rbo); glBindRenderbuffer(GL_RENDERBUFFER, rbo); // Use a single renderbuffer object for both a depth AND stencil buffer. glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, screenWidth, screenHeight); glBindRenderbuffer(GL_RENDERBUFFER, 0); // Now actually attach it glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo); // Now that we actually created the framebuffer and // added all attachments we want to check if it is actually complete now if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { std::cout << "ERROR::FRAMEBUFFER:: Framebuffer is not complete!" << std::endl; } glBindFramebuffer(GL_FRAMEBUFFER, 0); //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // game loop while (!glfwWindowShouldClose(window)) { GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; glfwPollEvents(); Do_Movement(); ////////////////////////////////////////////////////////////////////////// // bind to framebuffer and draw to color texture // as normally does ////////////////////////////////////////////////////////////////////////// glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); glClearColor(0.1f, 0.1f, 0.1f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); // set uniforms shader.Use(); glm::mat4 model; glm::mat4 view = camera.GetViewMatrix(); glm::mat4 projection = glm::perspective(camera.Zoom, (float)screenWidth / (float)screenHeight, 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)); // floor glBindVertexArray(floorVAO); glBindTexture(GL_TEXTURE_2D, floorTexture); model = glm::mat4(); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 6); glBindVertexArray(0); // cubes glBindVertexArray(cubeVAO); glBindTexture(GL_TEXTURE_2D, cubeTexture); model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 36); model = glm::mat4(); model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); ////////////////////////////////////////////////////////////////////////// // Bind to default framebuffer again and // draw the qued palne with attached screen texture ////////////////////////////////////////////////////////////////////////// glBindFramebuffer(GL_FRAMEBUFFER, 0); // Clear all relevant buffers glClearColor(1.0f, 1.0f, 1.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glDisable(GL_DEPTH_TEST); // Draw Screen screenShader.Use(); glBindVertexArray(quadVAO); glBindTexture(GL_TEXTURE_2D, textureColorbuffer); glDrawArrays(GL_TRIANGLES, 0, 6); glBindVertexArray(0); // swap the buffers glfwSwapBuffers(window); } // Clean up glDeleteFramebuffers(1, &framebuffer); glfwTerminate(); return 0; }
int main(int argc, const char * argv[]) { CommonSettings Settings; GLFWwindow *window = Settings.CreateWindow(); if (nullptr == window) { std::cout << "Create window failed." << std::endl; glfwTerminate(); return -1; } glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); GLfloat vertices[] = { 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, }; GLuint VAO, VBO; glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); GLuint lightVAO; glGenVertexArrays(1, &lightVAO); glBindVertexArray(lightVAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); #ifdef __APPLE__ string path = "/Basic Lighting/2/"; #else string path = "\\Basic Lighting\\2\\"; #endif ShaderReader shader(Settings.CCExercisesPath(path + "EX_L_BL_2.vs").c_str(), Settings.CCExercisesPath(path + "EX_L_BL_2.fs").c_str()); ShaderReader lightShader(Settings.CCExercisesPath(path + "EX_L_BL_2_light.vs").c_str(), Settings.CCExercisesPath(path + "EX_L_BL_2_light.fs").c_str()); glm::mat4 modelMat; glm::mat4 viewMat; glm::mat4 projMat; GLint width, height; glfwGetFramebufferSize(window, &width, &height); glm::vec3 lightPos(1.2f, 1.0f, 2.0f); glm::vec3 lightColor(1.0f, 1.0f, 1.0f); glm::vec3 objectColor(1.0f, 0.5f, 0.31f); shader.Use(); GLint modelLoc = glGetUniformLocation(shader.GetProgram(), "modelMat"); GLint viewLoc = glGetUniformLocation(shader.GetProgram(), "viewMat"); GLint projLoc = glGetUniformLocation(shader.GetProgram(), "projMat"); GLint lightColorLoc = glGetUniformLocation(shader.GetProgram(), "lightColor"); GLint objectColorLoc = glGetUniformLocation(shader.GetProgram(), "objectColor"); GLint lightPosLoc = glGetUniformLocation(shader.GetProgram(), "lightPos"); GLint viewPosLoc = glGetUniformLocation(shader.GetProgram(), "viewPos"); lightShader.Use(); GLint lightModelLoc = glGetUniformLocation(lightShader.GetProgram(), "modelMat"); GLint lightViewLoc = glGetUniformLocation(lightShader.GetProgram(), "viewMat"); GLint lightProjLoc = glGetUniformLocation(lightShader.GetProgram(), "projMat"); GLint lightLightColorLoc = glGetUniformLocation(lightShader.GetProgram(), "lightColor"); while (!glfwWindowShouldClose(window)) { glfwPollEvents(); do_movement(); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); GLfloat currentTime = glfwGetTime(); deltaTime = currentTime - lastFrame; lastFrame = currentTime; viewMat = cam.getViewMatrix(); projMat = glm::perspective(cam.getZoom(), (GLfloat)width / height, 0.1f, 100.0f); shader.Use(); modelMat = glm::mat4(); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(modelMat)); glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(viewMat)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projMat)); glUniform3f(lightColorLoc, lightColor.x, lightColor.y, lightColor.z); glUniform3f(objectColorLoc, objectColor.x, objectColor.y, objectColor.z); glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z); glUniform3f(viewPosLoc, cam.getPosition().x, cam.getPosition().y, cam.getPosition().z); glBindVertexArray(VAO); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); lightShader.Use(); modelMat = glm::mat4(); modelMat = glm::translate(modelMat, glm::vec3(lightPos.x, lightPos.y, lightPos.z)); modelMat = glm::scale(modelMat, glm::vec3(0.2f)); glUniformMatrix4fv(lightModelLoc, 1, GL_FALSE, glm::value_ptr(modelMat)); glUniformMatrix4fv(lightViewLoc, 1, GL_FALSE, glm::value_ptr(viewMat)); glUniformMatrix4fv(lightProjLoc, 1, GL_FALSE, glm::value_ptr(projMat)); glUniform3f(lightLightColorLoc, lightColor.x, lightColor.y, lightColor.z); glBindVertexArray(lightVAO); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); glfwSwapBuffers(window); } glfwTerminate(); return 0; }
int main( void ) { GLFWwindow *window; // Initialize the library if ( !glfwInit( ) ) { return -1; } // Create a windowed mode window and its OpenGL context window = glfwCreateWindow( SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World", NULL, NULL ); if ( !window ) { glfwTerminate( ); return -1; } // Make the window's context current glfwMakeContextCurrent( window ); glViewport( 0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT ); // specifies the part of the window to which OpenGL will draw (in pixels), convert from normalised to pixels glMatrixMode( GL_PROJECTION ); // projection matrix defines the properties of the camera that views the objects in the world coordinate frame. Here you typically set the zoom factor, aspect ratio and the near and far clipping planes glLoadIdentity( ); // replace the current matrix with the identity matrix and starts us a fresh because matrix transforms such as glOrpho and glRotate cumulate, basically puts us at (0, 0, 0) glOrtho( 0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1 ); // essentially set coordinate system glMatrixMode( GL_MODELVIEW ); // (default matrix mode) modelview matrix defines how your objects are transformed (meaning translation, rotation and scaling) in your world glLoadIdentity( ); // same as above comment GLfloat polygonVertices[] = { 320, 240, 0, 370, 290, 0, 420, 240, 0, 370, 190, 0 }; glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); // Loop until the user closes the window while ( !glfwWindowShouldClose( window ) ) { glClear( GL_COLOR_BUFFER_BIT ); // render OpenGL here glEnableClientState( GL_VERTEX_ARRAY ); glVertexPointer( 3, GL_FLOAT, 0, polygonVertices ); glDrawArrays( GL_TRIANGLE_FAN, 0, 4 ); glDisableClientState( GL_VERTEX_ARRAY ); // Swap front and back buffers glfwSwapBuffers( window ); // Poll for and process events glfwPollEvents( ); } glfwTerminate( ); return 0; }
//----------------------------------------------------------------------------- void SYS_Show() { glfwSwapBuffers(); }
int main() { std::cout << "Starting GLFW context, OpenGL 3.3.." << std::endl; if (!glfwInit()) { std::cout << "Failed to initialize GLFW" << std::endl; return -1; } glfwWindowHint(GLFW_SAMPLES, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "Tutorial", NULL, NULL); if (window == NULL) { std::cout << "Failed to create GLFW window" << std::endl; glfwTerminate(); return -1; } glfwMakeContextCurrent(window); glViewport(0, 0, WIDTH, HEIGHT); glEnable(GL_DEPTH_TEST); glfwSetKeyCallback(window, keyCallback); glfwSetCursorPosCallback(window, mouseCallback); glfwSetScrollCallback(window, scrollCallback); glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE); //-------------------- glewExperimental = true; // So GLEW uses more modern techniques for managing OpenGL functionality. if (glewInit() != GLEW_OK) { fprintf(stderr, "Failed to initialize GLEW!\n"); return -1; } Shader ourShader("VertexShader.txt", "FragmentShader.txt"); Shader lightShader("LampVertexShader.txt", "LampFragmentShader.txt"); //-------------------- 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 }; GLfloat lampVertices[] = { -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f }; //glm::vec3 cubePositions[] = { // glm::vec3(0.0f, 0.0f, 0.0f), // glm::vec3(2.0f, 5.0f, -5.0f), // glm::vec3(-1.5f, -2.2f, -2.5f), // glm::vec3(-3.8f, -2.0f, 6.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) //}; glm::vec3 cubePositions[] = { glm::vec3(-12.0f, 0.0f, 0.0f), glm::vec3(-10.0f, 0.0f, 0.0f), glm::vec3(-8.0f, 0.0f, 0.0f), glm::vec3(-6.0f, 0.0f, 0.0f), glm::vec3(-4.0f, 0.0f, 0.0f), glm::vec3(-2.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(2.0f, 0.0f, 0.0f), glm::vec3(4.0f, 0.0f, 0.0f), glm::vec3(6.0f, 0.0f, 0.0f), }; GLuint vertexBufferObject, vertexArrayObject, elementBufferObject; glGenVertexArrays(1, &vertexArrayObject); glGenBuffers(1, &vertexBufferObject); glBindVertexArray(vertexArrayObject); glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); // Position attribute glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); // Normal vectors glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*) (3*sizeof(GLfloat))); glEnableVertexAttribArray(1); // Texture coordinate attribute glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); glEnableVertexAttribArray(2); // Color attribute //glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); //glEnableVertexAttribArray(1); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); //-------------------- COLOR GLuint lightVAO, lightVBO; glGenVertexArrays(1, &lightVAO); glGenBuffers(1, &lightVBO); glBindBuffer(GL_ARRAY_BUFFER, lightVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(lampVertices), lampVertices, GL_STATIC_DRAW); glGenVertexArrays(1, &lightVAO); glBindVertexArray(lightVAO); glBindBuffer(GL_ARRAY_BUFFER, lightVBO); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glBindVertexArray(0); //-------------------- TEXTURE std::vector<unsigned char> file; std::vector<unsigned char> pixels; GLuint width, height; GLuint diffuseMap; glGenTextures(1, &diffuseMap); glBindTexture(GL_TEXTURE_2D, diffuseMap); // All upcoming GL_TEXTURE_2D operations now have effect on this texture object // Set the texture wrapping parameters glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT (usually basic wrapping method) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture filtering parameters glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Load image, create texture and generate mipmaps lodepng::load_file(file, "container2.png"); lodepng::decode(pixels, width, height, file.data(), file.size()); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data()); glGenerateMipmap(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture when done, so we won't accidentily mess up our texture. //-------------------- GLuint specularMap; file.clear(); pixels.clear(); glGenTextures(1, &specularMap); glBindTexture(GL_TEXTURE_2D, specularMap); lodepng::load_file(file, "container2_specular2.png"); lodepng::decode(pixels, width, height, file.data(), file.size()); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data()); glGenerateMipmap(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, 0); //-------------------- do { GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; glfwPollEvents(); doMovement(); glClearColor(0.2f, 0.2f, 0.2f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); lightPos.x = 1.0f + sin(glfwGetTime()) * 6.0f; lightPos.y = cos(glfwGetTime() / 2.0f) * 1.0f; //-------------------- ourShader.Use(); GLint lightColorLoc = glGetUniformLocation(ourShader.Program, "lightColor"); GLint lightPosLoc = glGetUniformLocation(ourShader.Program, "light.position"); GLint viewPosLoc = glGetUniformLocation(ourShader.Program, "viewPos"); glUniform3f(lightColorLoc, 1.0f, 0.5f, 1.0f); glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z); glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z); //---------- //GLint matAmbientLoc = glGetUniformLocation(ourShader.Program, "material.ambient"); //GLint matDiffuseLoc = glGetUniformLocation(ourShader.Program, "material.diffuse"); //GLint matSpecularLoc = glGetUniformLocation(ourShader.Program, "material.specular"); GLint matShineLoc = glGetUniformLocation(ourShader.Program, "material.shininess"); //glUniform3f(matAmbientLoc, 0.19225f, 0.19225f, 0.19225f); //glUniform3f(matDiffuseLoc, 0.50754f, 0.50754f, 0.50754f); glUniform1i(glGetUniformLocation(ourShader.Program, "material.diffuse"), 0); //glUniform3f(matSpecularLoc, 0.8f, 0.8f, 0.8f); glUniform1i(glGetUniformLocation(ourShader.Program, "material.specular"), 1); glUniform1f(matShineLoc, 128.0f * 0.2f); //---------- glm::vec3 lightColor; lightColor.x = sin(glfwGetTime() * 2.0f); lightColor.y = sin(glfwGetTime() * 0.7f); lightColor.z = sin(glfwGetTime() * 1.3f); glm::vec3 diffuseColor = lightColor * glm::vec3(1.0f); glm::vec3 ambientColor = diffuseColor * glm::vec3(1.0f); GLint lightAmbientLoc = glGetUniformLocation(ourShader.Program, "light.ambient"); GLint lightDiffuseLoc = glGetUniformLocation(ourShader.Program, "light.diffuse"); GLint lightSpecularLoc = glGetUniformLocation(ourShader.Program, "light.specular"); //glUniform3f(lightAmbientLoc, ambientColor.x, ambientColor.y, ambientColor.z); //glUniform3f(lightDiffuseLoc, diffuseColor.x, diffuseColor.y, diffuseColor.z); glUniform3f(lightAmbientLoc, 0.3f, 0.3f, 0.3f); glUniform3f(lightDiffuseLoc, 1.0f, 1.0f, 1.0f); glUniform3f(lightSpecularLoc, 1.0f, 1.0f, 1.0f); //-------------------- glm::mat4 view; view = camera.GetViewMatrix(); glm::mat4 projection; projection = glm::perspective(glm::radians(camera.Zoom), (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f); GLint viewLoc = glGetUniformLocation(ourShader.Program, "view"); GLint projLoc = glGetUniformLocation(ourShader.Program, "projection"); glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, diffuseMap); glUniform1i(glGetUniformLocation(ourShader.Program, "ourTexture1"), 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, specularMap); /*GLfloat timeValue = glfwGetTime(); GLfloat greenValue = (sin(timeValue) / 2) + 0.5; GLint vertexColorLocation = glGetUniformLocation(ourShader.Program, "ourColor"); glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.4f, 1.0f);*/ glBindVertexArray(vertexArrayObject); GLint modelLoc = glGetUniformLocation(ourShader.Program, "model"); for (GLuint i = 0; i < 10; i++) { glm::mat4 model; model = glm::translate(model, cubePositions[i]); GLfloat angle = 50.0f; //model = glm::rotate(model, i * (GLfloat)sin(glfwGetTime() / 10.0f), glm::vec3(1.0f, 0.2f * i, i)); //model = glm::scale(model, glm::vec3(0.1f * i)); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 36); } glBindVertexArray(0); lightShader.Use(); // Get location objects for the matrices on the lamp shader (these could be different on a different shader) modelLoc = glGetUniformLocation(lightShader.Program, "model"); viewLoc = glGetUniformLocation(lightShader.Program, "view"); projLoc = glGetUniformLocation(lightShader.Program, "projection"); // Set matrices glm::mat4 model; 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)); 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); glfwSwapBuffers(window); } while (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(window) == 0); glfwTerminate(); return 0; }
int main(){ Ui0 ui; FilterUiDrag filtdrag; if ( !glfwInit() ) { printf( "failed to initialize GLFW.\n" ); return -1; } glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); int _width = 500; int _height = 500; auto _window = glfwCreateWindow( _width, _height, "Render Window", nullptr, nullptr ); if ( !_window ) { return -1; } glfwMakeContextCurrent( _window ); if (gl3wInit()) { printf( "failed to initialize OpenGL\n" ); return -1; } print_info_opengl(); glEnable( GL_DEPTH_TEST ); glClearColor( 0, 0, 0, 1.0 ); std::cout << "InitGL::init invoked." << std::endl; ui.register_resource_to_monitor( _window ); std::list<IUi::character> characters{}; std::cout << "mouse coordinates" << std::endl; while(1){ glfwPollEvents(); ui.get_characters( characters ); for( auto & i : characters ){ if( IUi::input_type::MOUSE == i._input_type ){ if( IUi::mouse_character::LEFT == i._mouse_character ){ std::cout << "mouse L "; } else if( IUi::mouse_character::RIGHT == i._mouse_character ){ std::cout << "mouse R "; } else if( IUi::mouse_character::MID == i._mouse_character ){ std::cout << "mouse M "; } if( IUi::state::DOWN == i._state ){ std::cout << "down" << std::endl; } else if( IUi::state::UP == i._state ){ std::cout << "up" << std::endl; } } else if( IUi::input_type::KEY == i._input_type ){ std::cout << "key " << i._key_character << " "; if( IUi::state::DOWN == i._state ){ std::cout << "down" << std::endl; if( 'Q' == i._key_character ){ std::cout << "exit" << std::endl; return 0; } } else if( IUi::state::UP == i._state ){ std::cout << "up" << std::endl; } else if( IUi::state::REPEAT == i._state ){ std::cout << "repeat" << std::endl; } }else{ //MOUSE_COORD // std::cout << "x: " << i._coordinate._a << ", y: " << i._coordinate._b << std::endl; } } std::list<drag_coordinate> drag{}; filtdrag.process( drag, characters ); for( auto & i : drag ){ if( IUi::mouse_character::LEFT == i._mouse_character ){ std::cout << "drag: left, "; }else if( IUi::mouse_character::RIGHT == i._mouse_character ){ std::cout << "drag: right, "; }else if( IUi::mouse_character::MID == i._mouse_character ){ std::cout << "drag: mid, "; }else { continue; // std::cout << "drag: other, "; } std::cout << "x: " << i._coordinate_delta._a << ", y: " << i._coordinate_delta._b << std::endl; } characters.clear(); glfwSwapBuffers( _window ); std::this_thread::sleep_for(std::chrono::milliseconds(25)); } return 0; }
void CanvasGLFW::glSwapBuffers() { glfwSwapBuffers(glWindow_); }
int main() { if (!glfwInit()) { std::cout << "Error initializing GLFW\n"; return -1; } glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); if (!glfwOpenWindow(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT, 8, 8, 8, 0, 24, 0, GLFW_WINDOW)) { std::cout << "Error opening GLFW window\n"; glfwTerminate(); return -1; } glfwSetWindowTitle("The Maze 2!"); glfwDisable(GLFW_MOUSE_CURSOR); glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { std::cout << "Error initing GLEW\n"; glfwTerminate(); return -1; } TheMaze2 &maze = TheMaze2::getInstance(); maze.initGl(); maze.initVao(); maze.initVbo(); maze.initShaders(); maze.initAttributes(); maze.initTextures(); maze.addLight(25.0, 25.0, 0.0); maze.addLight(-55.0, 0.0, 0.0); maze.addSurface(0, 0, -5000); maze.addSurface(0, 0, 5000); // need to flip this maze.addWall(0, 0, 0); maze.addWall(0, 1000, 0); maze.addWall(0, 2000, 0); maze.addWall(2000, -20000, 0); maze.walls_[3]->setScale(3.0f); maze.walls_[3]->pos_.z_ = 10000; maze.addWalls(-70000, -70000, 0, 140, 140); maze.addWalls(70000, 70000, 0, -140, -140); maze.player_.pos_.x_ = 20000; maze.player_.pos_.y_ = 20000; double fps_timer = 0; glfwSetKeyCallback(TheMaze2::handleKeyInput); glfwSetMouseButtonCallback(TheMaze2::handleMouseButtonInput); glfwSetWindowSizeCallback(TheMaze2::handleWindowResize); double prev_time = glfwGetTime(); while (glfwGetWindowParam(GLFW_OPENED)) { double cur_time = glfwGetTime(); double time_delta = cur_time - prev_time; prev_time = cur_time; // print framerate fps_timer += time_delta; if (fps_timer > 1) { int fps = 1 / time_delta; std::cout << fps << "\r" << std::flush; fps_timer = 0; } // logic maze.handleMouseInput(time_delta); maze.handleMovement(time_delta); //maze.cleanupObjects(); // drawing glClearColor(0.8f, 0.8f, 0.85f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); maze.render(); glfwSwapBuffers(); int error = glGetError(); if (error != 0) { std::cout << "GL Error " << error << std::endl; //return -1; } } glfwTerminate(); return 0; }