int main(void) { GLFWwindow window; if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW: %s\n", glfwErrorString(glfwGetError())); exit(EXIT_FAILURE); } window = glfwOpenWindow(0, 0, GLFW_WINDOWED, "English 日本語 русский язык 官話", NULL); if (!window) { fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError())); exit(EXIT_FAILURE); } glfwSwapInterval(1); glfwSetWindowSizeCallback(window_size_callback); while (glfwIsWindow(window) == GL_TRUE) { glClear(GL_COLOR_BUFFER_BIT); glfwSwapBuffers(); glfwWaitEvents(); } exit(EXIT_SUCCESS); }
int main(void) { GLFWwindow* window; glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); window = glfwCreateWindow(400, 400, "English 日本語 русский язык 官話", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); gladLoadGL(glfwGetProcAddress); glfwSwapInterval(1); while (!glfwWindowShouldClose(window)) { glClear(GL_COLOR_BUFFER_BIT); glfwSwapBuffers(window); glfwWaitEvents(); } glfwTerminate(); exit(EXIT_SUCCESS); }
int main(int argc, char** argv) { int ch; GLFWwindow window; while ((ch = getopt(argc, argv, "h")) != -1) { switch (ch) { case 'h': usage(); exit(EXIT_SUCCESS); default: usage(); exit(EXIT_FAILURE); } } glfwSetErrorCallback(error_callback); if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW\n"); exit(EXIT_FAILURE); } window = glfwOpenWindow(0, 0, GLFW_WINDOWED, "Clipboard Test", NULL); if (!window) { glfwTerminate(); fprintf(stderr, "Failed to open GLFW window\n"); exit(EXIT_FAILURE); } glfwSwapInterval(1); glfwSetKeyCallback(key_callback); glfwSetWindowSizeCallback(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 (glfwIsWindow(window)) { glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.8f, 0.2f, 0.4f); glRectf(-0.5f, -0.5f, 0.5f, 0.5f); glfwSwapBuffers(); glfwWaitEvents(); } glfwTerminate(); exit(EXIT_SUCCESS); }
int main(void) { if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW\n"); exit(EXIT_FAILURE); } if (!open_window()) { fprintf(stderr, "Failed to open GLFW window\n"); exit(EXIT_FAILURE); } glClearColor(0.f, 0.f, 0.f, 0.f); while (glfwGetWindowParam(GLFW_OPENED)) { glClear(GL_COLOR_BUFFER_BIT); glfwSwapBuffers(); glfwWaitEvents(); } glfwTerminate(); exit(EXIT_SUCCESS); }
void Input::update(){ if(_minimized){ glfwWaitEvents(); } // Reset temporary state (first, last). for(unsigned int i = 0; i < GLFW_KEY_LAST+1; ++i){ _keys[i].first = false; _keys[i].last = false; } for(unsigned int i = 0; i < GLFW_MOUSE_BUTTON_LAST+1; ++i){ _mouseButtons[i].first = false; _mouseButtons[i].last = false; } _mouse.scroll = glm::vec2(0.0f,0.0f); _resized = false; // Update only the active joystick if it exists. _joystickConnected = false; _joystickDisconnected = false; if(_activeController >= 0){ _controllers[_activeController]->update(); } glfwPollEvents(); }
void run() { loadSceneFile(true); double lastTime = glfwGetTime(); // Loop until the user closes the window while (!glfwWindowShouldClose(main_window)) { double currentTime = glfwGetTime(); double delta = currentTime - lastTime; lastTime = currentTime; // Render map->update(delta); map->render(); // Swap front and back buffers glfwSwapBuffers(main_window); // Poll for and process events if (platform->isContinuousRendering()) { glfwPollEvents(); } else { glfwWaitEvents(); } } }
int main(void) { GLFWwindow* window; glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); window = glfwCreateWindow(640, 480, "Fullscreen focus", glfwGetPrimaryMonitor(), NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); glfwSwapInterval(1); glfwSetInputMode(window, GLFW_CURSOR_MODE, GLFW_CURSOR_NORMAL); glfwSetWindowFocusCallback(window, window_focus_callback); glfwSetKeyCallback(window, window_key_callback); while (!glfwWindowShouldClose(window)) { glClear(GL_COLOR_BUFFER_BIT); glfwSwapBuffers(window); glfwWaitEvents(); } glfwTerminate(); exit(EXIT_SUCCESS); }
int main(void) { int i, result; Thread threads[] = { { NULL, "Red", 1.f, 0.f, 0.f, 0 }, { NULL, "Green", 0.f, 1.f, 0.f, 0 }, { NULL, "Blue", 0.f, 0.f, 1.f, 0 } }; const int count = sizeof(threads) / sizeof(Thread); if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW: %s\n", glfwErrorString(glfwGetError())); exit(EXIT_FAILURE); } for (i = 0; i < count; i++) { glfwWindowHint(GLFW_POSITION_X, 200 + 250 * i); glfwWindowHint(GLFW_POSITION_Y, 200); threads[i].window = glfwCreateWindow(200, 200, GLFW_WINDOWED, threads[i].title, NULL); if (!threads[i].window) { fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError())); exit(EXIT_FAILURE); } if (thrd_create(&threads[i].id, thread_main, threads + i) != thrd_success) { fprintf(stderr, "Failed to create secondary thread\n"); exit(EXIT_FAILURE); } } while (running) { assert(glfwGetCurrentContext() == NULL); glfwWaitEvents(); for (i = 0; i < count; i++) { if (glfwGetWindowParam(threads[i].window, GLFW_CLOSE_REQUESTED)) running = GL_FALSE; } } for (i = 0; i < count; i++) thrd_join(threads[i].id, &result); exit(EXIT_SUCCESS); }
int main(int argc, char** argv) { int x, y, width; GLuint texture; glfwSetErrorCallback(error_callback, NULL); if (!glfwInit()) exit(EXIT_FAILURE); windows[0] = open_window("First", NULL, OFFSET, OFFSET); if (!windows[0]) { glfwTerminate(); exit(EXIT_FAILURE); } // This is the one and only time we create a texture // It is created inside the first context, created above // It will then be shared with the second context, created below texture = create_texture(); glfwGetWindowPos(windows[0], &x, &y); glfwGetWindowSize(windows[0], &width, NULL); // Put the second window to the right of the first one windows[1] = open_window("Second", windows[0], x + width + OFFSET, y); if (!windows[1]) { glfwTerminate(); exit(EXIT_FAILURE); } // Set drawing color for both contexts glfwMakeContextCurrent(windows[0]); glColor3f(0.6f, 0.f, 0.6f); glfwMakeContextCurrent(windows[1]); glColor3f(0.6f, 0.6f, 0.f); glfwMakeContextCurrent(windows[0]); while (!glfwWindowShouldClose(windows[0]) && !glfwWindowShouldClose(windows[1])) { glfwMakeContextCurrent(windows[0]); draw_quad(texture); glfwMakeContextCurrent(windows[1]); draw_quad(texture); glfwSwapBuffers(windows[0]); glfwSwapBuffers(windows[1]); glfwWaitEvents(); } glfwTerminate(); exit(EXIT_SUCCESS); }
void ctx_tick(struct context *ctx) { if (glfwGetWindowAttrib(ctx->win, GLFW_FOCUSED)) { glfwPollEvents(); } else { glfwWaitEvents(); } }
int main(void) { int i, result; Thread threads[] = { { NULL, "Red", 1.f, 0.f, 0.f, 0 }, { NULL, "Green", 0.f, 1.f, 0.f, 0 }, { NULL, "Blue", 0.f, 0.f, 1.f, 0 } }; const int count = sizeof(threads) / sizeof(Thread); glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); glfwWindowHint(GLFW_VISIBLE, GL_FALSE); for (i = 0; i < count; i++) { threads[i].window = glfwCreateWindow(200, 200, threads[i].title, NULL, NULL); if (!threads[i].window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwSetWindowPos(threads[i].window, 200 + 250 * i, 200); glfwShowWindow(threads[i].window); if (thrd_create(&threads[i].id, thread_main, threads + i) != thrd_success) { fprintf(stderr, "Failed to create secondary thread\n"); glfwTerminate(); exit(EXIT_FAILURE); } } while (running) { glfwWaitEvents(); for (i = 0; i < count; i++) { if (glfwWindowShouldClose(threads[i].window)) running = GL_FALSE; } } for (i = 0; i < count; i++) thrd_join(threads[i].id, &result); exit(EXIT_SUCCESS); }
int main(void) { GLFWwindow* window; int width, height; setlocale(LC_ALL, ""); glfwSetErrorCallback(error_callback); if (!glfwInit()) exit(EXIT_FAILURE); printf("Library initialized\n"); window = glfwCreateWindow(640, 480, "Event Linter", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } printf("Window opened\n"); glfwSetMonitorCallback(monitor_callback); glfwSetWindowPosCallback(window, window_pos_callback); glfwSetWindowSizeCallback(window, window_size_callback); glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); glfwSetWindowCloseCallback(window, window_close_callback); glfwSetWindowRefreshCallback(window, window_refresh_callback); glfwSetWindowFocusCallback(window, window_focus_callback); glfwSetWindowIconifyCallback(window, window_iconify_callback); glfwSetMouseButtonCallback(window, mouse_button_callback); glfwSetCursorPosCallback(window, cursor_position_callback); glfwSetCursorEnterCallback(window, cursor_enter_callback); glfwSetScrollCallback(window, scroll_callback); glfwSetKeyCallback(window, key_callback); glfwSetCharCallback(window, char_callback); glfwMakeContextCurrent(window); glfwSwapInterval(1); glfwGetWindowSize(window, &width, &height); printf("Window size should be %ix%i\n", width, height); printf("Main loop starting\n"); while (!glfwWindowShouldClose(window)) { glfwWaitEvents(); // Workaround for an issue with msvcrt and mintty fflush(stdout); } glfwTerminate(); exit(EXIT_SUCCESS); }
void mainloop(int refresh) { if (mainloop_active) throw std::runtime_error("Main loop is already running!"); mainloop_active = true; std::thread refresh_thread; if (refresh > 0) { /* If there are no mouse/keyboard events, try to refresh the view roughly every 50 ms (default); this is to support animations such as progress bars while keeping the system load reasonably low */ refresh_thread = std::thread( [refresh]() { std::chrono::milliseconds time(refresh); while (mainloop_active) { std::this_thread::sleep_for(time); glfwPostEmptyEvent(); } } ); } try { while (mainloop_active) { int numScreens = 0; for (auto kv : __nanogui_screens) { Screen *screen = kv.second; if (!screen->visible()) { continue; } else if (glfwWindowShouldClose(screen->glfwWindow())) { screen->setVisible(false); continue; } screen->drawAll(); numScreens++; } if (numScreens == 0) { /* Give up if there was nothing to draw */ mainloop_active = false; break; } /* Wait for mouse/keyboard or empty refresh events */ glfwWaitEvents(); } /* Process events once more */ glfwPollEvents(); } catch (const std::exception &e) { std::cerr << "Caught exception in main loop: " << e.what() << std::endl; leave(); } if (refresh > 0) refresh_thread.join(); }
JNIEXPORT void JNICALL Java_com_badlogic_jglfw_Glfw_glfwWaitEventsJni(JNIEnv* env, jclass clazz, jobject javaCallback) { //@line:831 glfwWaitEvents(); }
int main(int argc, char** argv) { int ch; GLFWwindow* window; while ((ch = getopt(argc, argv, "h")) != -1) { switch (ch) { case 'h': usage(); exit(EXIT_SUCCESS); default: usage(); exit(EXIT_FAILURE); } } glfwSetErrorCallback(error_callback); if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW\n"); exit(EXIT_FAILURE); } window = glfwCreateWindow(200, 200, "Clipboard Test", NULL, NULL); if (!window) { glfwTerminate(); fprintf(stderr, "Failed to open GLFW window\n"); exit(EXIT_FAILURE); } glfwMakeContextCurrent(window); gladLoadGLLoader((GLADloadproc) glfwGetProcAddress); glfwSwapInterval(1); glfwSetKeyCallback(window, key_callback); glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); glClearColor(0.5f, 0.5f, 0.5f, 0); while (!glfwWindowShouldClose(window)) { glClear(GL_COLOR_BUFFER_BIT); glfwSwapBuffers(window); glfwWaitEvents(); } glfwTerminate(); exit(EXIT_SUCCESS); }
void maybe_complete_pause(GLFWwindow *window) { /* In a finished app, there's usually still things to update and render when paused, but this function is good for initial prototyping / debugging. */ if (toggle_pause(window)) { while (!(glfwWindowShouldClose(window) || toggle_pause(window))) { glfwWaitEvents(); } } }
int main(void) { GLFWwindow window; int width, height; setlocale(LC_ALL, ""); if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW: %s\n", glfwErrorString(glfwGetError())); exit(EXIT_FAILURE); } printf("Library initialized\n"); glfwSetWindowSizeCallback(window_size_callback); glfwSetWindowCloseCallback(window_close_callback); glfwSetWindowRefreshCallback(window_refresh_callback); glfwSetWindowFocusCallback(window_focus_callback); glfwSetWindowIconifyCallback(window_iconify_callback); glfwSetMouseButtonCallback(mouse_button_callback); glfwSetCursorPosCallback(cursor_position_callback); glfwSetCursorEnterCallback(cursor_enter_callback); glfwSetScrollCallback(scroll_callback); glfwSetKeyCallback(key_callback); glfwSetCharCallback(char_callback); window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Event Linter", NULL); if (!window) { glfwTerminate(); fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError())); exit(EXIT_FAILURE); } printf("Window opened\n"); glfwMakeContextCurrent(window); glfwSwapInterval(1); glfwGetWindowSize(window, &width, &height); printf("Window size should be %ix%i\n", width, height); printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled"); printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled"); printf("Main loop starting\n"); while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED)) glfwWaitEvents(); glfwTerminate(); exit(EXIT_SUCCESS); }
int main(void) { GLFWwindow* window; // Initialise GLFW if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW\n"); exit(EXIT_FAILURE); } // Open OpenGL window window = glfwCreateWindow(500, 500, "Split view demo", NULL, NULL); if (!window) { fprintf(stderr, "Failed to open GLFW window\n"); glfwTerminate(); exit(EXIT_FAILURE); } // Set callback functions glfwSetFramebufferSizeCallback(window, framebufferSizeFun); glfwSetWindowRefreshCallback(window, windowRefreshFun); glfwSetCursorPosCallback(window, cursorPosFun); glfwSetMouseButtonCallback(window, mouseButtonFun); glfwSetKeyCallback(window, key_callback); // Enable vsync glfwMakeContextCurrent(window); glfwSwapInterval(1); glfwGetFramebufferSize(window, &width, &height); framebufferSizeFun(window, width, height); // Main loop for (;;) { // Only redraw if we need to if (do_redraw) windowRefreshFun(window); // Wait for new events glfwWaitEvents(); // Check if the window should be closed if (glfwWindowShouldClose(window)) break; } // Close OpenGL window and terminate GLFW glfwTerminate(); exit(EXIT_SUCCESS); }
//-------------------------------------------------------------- void testApp::draw(){ if (mode != MODE_ADDON ) { ofSetColor(100); logo.draw(64, 61,logo.getWidth(),logo.getHeight()); //ofSetColor(74,255,203); titleFont.drawString("PROJECT", 64 + logo.getWidth() + 25, 85); titleFont.drawString("GENERATOR", 64 + logo.getWidth() + 25, 117); } if (mode == 0){ for (int i = 0; i < buttons.size(); i++){ buttons[i].draw(); } generateButton.draw(); } else if (mode == 1){ panelCoreAddons.draw(); if (bHaveNonCoreAddons){ panelOtherAddons.draw(); } } else if (mode == 2){ panelPlatforms.draw(); } //cout << panelAddons.getShape().height << endl; if (mode == 1 ){ addonButton.draw(); ofRectangle rect = secondFont.getStringBoundingBox("select core and non-core addons to add", addonButton.topLeftAnchor.x-200, 60); ofSetColor(220,220,220); ofRect(rect.x-10, rect.y-10, rect.width+20, rect.height+20); ofSetColor(0,0,0); secondFont.drawString("select core and non-core addons to add", addonButton.topLeftAnchor.x-200, 60); } if (mode == 0){ ofFill(); ofSetColor(0 + 220 * (1-statusEnergy),0 + 220 * (1-statusEnergy),0 + 220 * (1-statusEnergy)); ofRect(0,ofGetHeight(), ofGetWidth(), -25); ofSetColor(255,255,255, 255 * statusEnergy); ofDrawBitmapString(status, 10,ofGetHeight()-8); } glfwWaitEvents(); }
// uiloop void ui_loop(const ym_string& filename, const ym_string& imfilename, yo_scene* scene, ysr_scene* rigid_scene, float dt, int w, int h, bool camera_lights, float amb, bool no_ui) { // view data view_params* view = init_view_params( filename, imfilename, scene, rigid_scene, dt, w, h, camera_lights, amb); // glfw if (!glfwInit()) exit(EXIT_FAILURE); GLFWwindow* window = glfwCreateWindow(view->w, view->h, "yshade", 0, 0); glfwMakeContextCurrent(window); glfwSetWindowUserPointer(window, view); // callbacks glfwSetCharCallback(window, text_callback); glfwSetWindowSizeCallback(window, window_size_callback); glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); glfwSetMouseButtonCallback(window, mouse_button_callback); glfwSetCursorPosCallback(window, mouse_pos_callback); glfwSetWindowRefreshCallback(window, window_refresh_callback); // init gl extensions #ifndef __APPLE__ if (glewInit() != GLEW_OK) exit(EXIT_FAILURE); #endif // init shade state view->shade_prog = yg_stdshader_make_program(); view->shade_txt.resize(scene->textures.size()); for (int i = 0; i < scene->textures.size(); i++) { yo_texture* txt = &scene->textures[i]; view->shade_txt[i] = yg_make_texture(txt->pixels.data(), txt->width, txt->height, txt->ncomp, false, true); } // ui loop while (!glfwWindowShouldClose(window)) { window_refresh_callback(window); if (view->simulating) { simulate_step(view); glfwPollEvents(); } else { glfwWaitEvents(); } } glfwDestroyWindow(window); glfwTerminate(); delete view; }
void GLFWView::run() { while (!glfwWindowShouldClose(window)) { glfwWaitEvents(); const bool dirty = !clean.test_and_set(); if (dirty) { const double started = glfwGetTime(); map->renderSync(); report(1000 * (glfwGetTime() - started)); if (benchmark) { map->update(mbgl::Update::Repaint); } } } }
int main(void) { setlocale(LC_ALL, ""); if (!glfwInit()) { fprintf(stderr, "Failed to initialize GLFW\n"); exit(1); } printf("Library initialized\n"); if (!glfwOpenWindow(0, 0, 0, 0, 0, 0, 0, 0, GLFW_WINDOW)) { glfwTerminate(); fprintf(stderr, "Failed to create GLFW window"); exit(1); } printf("Window opened\n"); glfwSetWindowTitle("Event Linter"); glfwSwapInterval(1); glfwSetWindowSizeCallback(window_size_callback); glfwSetWindowCloseCallback(window_close_callback); glfwSetWindowRefreshCallback(window_refresh_callback); glfwSetMouseButtonCallback(mouse_button_callback); glfwSetMousePosCallback(mouse_position_callback); glfwSetMouseWheelCallback(mouse_wheel_callback); glfwSetKeyCallback(key_callback); glfwSetCharCallback(char_callback); printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled"); printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled"); printf("Main loop starting\n"); while (glfwGetWindowParam(GLFW_OPENED) == GL_TRUE) { glfwWaitEvents(); glClear(GL_COLOR_BUFFER_BIT); glfwSwapBuffers(); } glfwTerminate(); exit(0); }
void app_window_run() { struct app_gl* app = g_app; ASSERT(g_app->wnd); while (!glfwWindowShouldClose(g_app->wnd)) { if (app->active || app->always_active) glfwPollEvents(); else glfwWaitEvents(); if (g_app->update_fn) g_app->update_fn(); } }
void GLFWView::run() { while (!glfwWindowShouldClose(window)) { glfwWaitEvents(); const bool dirty = !clean.test_and_set(); if (dirty) { const double started = glfwGetTime(); map->renderSync(); report(1000 * (glfwGetTime() - started)); if (benchmark) { map->setNeedsRepaint(); } map->nudgeTransitions(); } } }
void Application::run() { glClearColor(0.0f, 0.3f, 0.0f, 1.0f); while (!glfwWindowShouldClose(m_mainWindow)) { // Wait for events, saves processing power glfwWaitEvents(); // Render the content to the back buffer m_renderer->render(); // Swap the back and front buffers glfwSwapBuffers(m_mainWindow); } }
void GLFW_test2::join(){ while (1){ if (window == NULL){ break; } glfwWaitEvents(); if (glfwWindowShouldClose(window)){ std::cout << "CLOSE" << std::endl; break; } } glfwDestroyWindow(window); pthread_join(ctxt_thread, NULL); }
int GLFWView::run() { map->start(); while (!glfwWindowShouldClose(window)) { if (map->needsSwap()) { glfwSwapBuffers(window); map->swapped(); fps(); } glfwWaitEvents(); } map->stop(); return 0; }
void startGame() { GLFWwindow* Window = initWindow(); bool Clicked = false; GLuint VAO[2]; GLuint VBO[2]; GLuint LinesVBO[2]; glGenVertexArrays(2, VAO); CellList cellList = createCellList(); GLfloat* cellVertexArray = createCellVertexArray(cellVertexArray, cellList); GLfloat* cellColorArray = constructCellColorArray(cellColorArray, cellList, true); constructVO(VAO[0], VBO, cellVertexArray, cellColorArray); //constructLines(VAO[1], LinesVBO); createShaders(); glClearColor(1.0, 1.0, 1.0, 1.0); while (!glfwWindowShouldClose(Window)){ glClear(GL_COLOR_BUFFER_BIT); constructCellColorArray(cellColorArray, cellList, false); constructVO(VAO[0], VBO, cellVertexArray, cellColorArray); glBindVertexArray(VAO[0]); glDrawArrays(GL_TRIANGLES, 0, cellDim * cellDim * 12); glBindVertexArray(VAO[1]); //glDrawArrays(GL_LINES, 0, cellDim * 8); glfwSwapBuffers(Window); glfwWaitEvents(); if (glfwGetMouseButton(Window, GLFW_MOUSE_BUTTON_LEFT) == 1 && !Clicked){ Clicked = true; mouseClick(Window, cellList); } if (glfwGetMouseButton(Window, GLFW_MOUSE_BUTTON_LEFT) == 0 && Clicked) Clicked = false; } glfwDestroyWindow(Window); glfwTerminate(); }
// uiloop void ui_loop(int nimgs, view_img* imgs) { // view params view_params* view = init_view_params(nimgs, imgs); // window if (!glfwInit()) exit(EXIT_FAILURE); GLFWwindow* window = glfwCreateWindow(view->w, view->h, "imview", 0, 0); glfwMakeContextCurrent(window); glfwSetWindowUserPointer(window, view); // callbacks glfwSetCharCallback(window, text_callback); glfwSetWindowSizeCallback(window, window_size_callback); glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); glfwSetMouseButtonCallback(window, mouse_button_callback); glfwSetCursorPosCallback(window, mouse_pos_callback); glfwSetWindowRefreshCallback(window, window_refresh_callback); // init gl extensions #ifdef YG_USING_GLEW if (glewInit() != GLEW_OK) exit(EXIT_FAILURE); #endif // load textures for (int i = 0; i < nimgs; i++) { imgs[i].tex_glid = yg_make_texture(imgs[i].pixels, imgs[i].w, imgs[i].h, imgs[i].nc, true, false); } // ui loop while (!glfwWindowShouldClose(window)) { window_refresh_callback(window); glfwWaitEvents(); } glfwDestroyWindow(window); glfwTerminate(); free(view); }
int main(int argc, char **argv) { GLFWwindow *window = (GLFWwindow *) 0; mc_world world; mc_gc context; if (!glfwInit()) { mc_error(1, "GLFW error."); } atexit(glfwTerminate); glfwSetErrorCallback((GLFWerrorfun) mc_error); window = glfwCreateWindow(640, 480, "UntitledCraft", NULL, NULL); if (!window) { mc_error(1, "Window error."); } glfwMakeContextCurrent(window); if (!mc_graphics_init(&context)) { mc_error(1, "Context error."); } if (!mc_world_init(&world, (unsigned int) time(NULL))) { mc_error(1, "World."); } glfwPollEvents(); while (!glfwWindowShouldClose(window)) { mc_graphics_clear(&context); glfwSwapBuffers(window); glfwWaitEvents(); } return 0; }