void gemglfw2window :: destroyMess(void) { if(makeCurrent()) { glfwCloseWindow(); } destroy(); }
static void key_callback(GLFWwindow window, int key, int action) { if (action != GLFW_PRESS) return; switch (key) { case GLFW_KEY_ESCAPE: glfwCloseWindow(window); break; case GLFW_KEY_V: if (control_is_down(window)) { const char* string; string = glfwGetClipboardString(window); if (string) printf("Clipboard contains \"%s\"\n", string); else printf("Clipboard does not contain a string\n"); } break; case GLFW_KEY_C: if (control_is_down(window)) { const char* string = "Hello GLFW World!"; glfwSetClipboardString(window, string); printf("Setting clipboard to \"%s\"\n", string); } break; } }
int _glfwPlatformTerminate( void ) { // Only the main thread is allowed to do this... if( GetCurrentThreadId() != _glfwThrd.First.WinID ) { return GL_FALSE; } // Close OpenGL window glfwCloseWindow(); // Kill thread package _glfwTerminateThreads(); // Enable system keys again (if they were disabled) glfwEnable( GLFW_SYSTEM_KEYS ); // Unload libraries (DLLs) _glfwFreeLibraries(); // Restore FOREGROUNDLOCKTIMEOUT system setting SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT, 0, (LPVOID) _glfwLibrary.Sys.foregroundLockTimeout, SPIF_SENDCHANGE ); return GL_TRUE; }
int _glfwPlatformTerminate( void ) { #ifdef _GLFW_HAS_PTHREAD // Only the main thread is allowed to do this... if( pthread_self() != _glfwThrd.First.PosixID ) { return GL_FALSE; } #endif // _GLFW_HAS_PTHREAD // Close OpenGL window glfwCloseWindow(); // Kill thread package _glfwTerminateThreads(); // Terminate display _glfwTerminateDisplay(); // Terminate joysticks _glfwTerminateJoysticks(); // Unload libGL.so if necessary #ifdef _GLFW_DLOPEN_LIBGL if( _glfwLibrary.Libs.libGL != NULL ) { dlclose( _glfwLibrary.Libs.libGL ); _glfwLibrary.Libs.libGL = NULL; } #endif return GL_TRUE; }
void OptionsDialog2::Click(void) { switch(fActiveElement) { case ActiveElement::NONE: break; case ActiveElement::MUSIC: Options::fgOptions.fMusicOn = !Options::fgOptions.fMusicOn; gSoundControl.SwitchMusicStatus(); break; case ActiveElement::PREVIOUS: dialog::Pop(); break; case ActiveElement::ADVANCED: this->Push(new AdvancedOptions); break; case ActiveElement::SAVEANDQUIT: Options::fgOptions.fNewPerformance = fNewPerfLevel; Options::fgOptions.fFullScreen = fNewFullScreen; glfwCloseWindow(); break; case ActiveElement::PING: gShowPing = !gShowPing; break; case ActiveElement::FULLSCREEN: fNewFullScreen = !fNewFullScreen; break; case ActiveElement::P1: fNewPerfLevel = 1; break; case ActiveElement::P2: fNewPerfLevel = 2; break; case ActiveElement::P3: fNewPerfLevel = 3; break; case ActiveElement::P4: fNewPerfLevel = 4; break; } }
Visualization::~Visualization() { if(m_bInitialized) { glDeleteTextures(1, &m_unTexture); glfwCloseWindow(); glfwTerminate(); } }
int main(int argc, char const **argv) { glfwInit(); glfwOpenWindow(800, 600, 8, 8, 8, 8, 16, 0, GLFW_WINDOW); glfwSetWindowSizeCallback(set_window_size); glfwSetKeyCallback(set_key); init(); int running = 1; while(running) { update(); update_keys(); draw(); glfwSwapBuffers(); running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED); glfwSleep(0.01); } terminate(); glfwCloseWindow(); glfwTerminate(); return 0; }
static void close_window(void) { double base = glfwGetTime(); glfwCloseWindow(); printf("Closing window took %0.3f seconds\n", glfwGetTime() - base); }
/* ============================================================================ * DestroyVIF: Releases any resources allocated for an VIF instance. * ========================================================================= */ void DestroyVIF(struct VIFController *controller) { glDeleteTextures(1, &controller->frameTexture); glfwCloseWindow(); glfwTerminate(); free(controller); }
int main( int argc, char** argv ) { // Initialize GLFW glfwInit(); if( !setupWindow( appWidth, appHeight, fullScreen ) ) return -1; // Initalize application and engine app = new Application( generatePath( argv[0], "../Content" ) ); if ( !app->init() ) { // Fake message box glfwCloseWindow(); glfwOpenWindow( 800, 16, 8, 8, 8, 8, 24, 8, GLFW_WINDOW ); glfwSetWindowTitle( "Unable to initalize engine - Make sure you have an OpenGL 2.0 compatible graphics card" ); glfwSleep( 5 ); std::cout << "Unable to initalize engine" << std::endl; std::cout << "Make sure you have an OpenGL 2.0 compatible graphics card"; glfwTerminate(); return -1; } app->resize( appWidth, appHeight ); TwWindowSize( appWidth, appHeight ); //glfwDisable( GLFW_MOUSE_CURSOR ); int frames = 0; float fps = 30.0f; t0 = glfwGetTime(); running = true; // Game loop while( running ) { // Calc FPS ++frames; if( frames >= 3 ) { double t = glfwGetTime(); fps = frames / (float)(t - t0); frames = 0; t0 = t; } // Render app->mainLoop( fps ); TwDraw(); glfwSwapBuffers(); } glfwEnable( GLFW_MOUSE_CURSOR ); // Quit app->release(); delete app; glfwTerminate(); return 0; }
// closes th window and shuts down the full framework void Application::Shutdown() { m_spriteBatch->End(); glfwCloseWindow(); glfwTerminate(); //delete m_font; //m_font = nullptr; }
void GLFWWindow::close() { if(!opened) return; glfwCloseWindow(); glfwTerminate(); opened = false; }
GLUSvoid GLUSAPIENTRY glusDestroyWindow(GLUSvoid) { glfwCloseWindow(); g_windowCreated = GLUS_FALSE; glfwTerminate(); g_initdone = GLUS_FALSE; }
OSStatus _glfwCommandHandler( EventHandlerCallRef handlerCallRef, EventRef event, void *userData ) { if( _glfwWin.SysKeysDisabled ) { // TO DO: give adequate UI feedback that this is the case return eventNotHandledErr; } HICommand command; if( GetEventParameter( event, kEventParamDirectObject, typeHICommand, NULL, sizeof( HICommand ), NULL, &command ) == noErr ) { switch( command.commandID ) { case kHICommandClose: case kHICommandQuit: { // Check if the program wants us to close the window if( _glfwWin.WindowCloseCallback ) { if( _glfwWin.WindowCloseCallback() ) { glfwCloseWindow(); } } else { glfwCloseWindow(); } return noErr; } } } return eventNotHandledErr; }
void wsScreen::close() { #if (WS_SCREEN_BACKEND == WS_BACKEND_X11) glXMakeCurrent(xDisp, None, NULL); glXDestroyContext(xDisp, context); XDestroyWindow(xDisp, win); XCloseDisplay(xDisp); #elif (WS_SCREEN_BACKEND == WS_BACKEND_GLFW) glfwCloseWindow(); #endif }
EM_BOOL resize_callback(int eventType, const EmscriptenUiEvent *e, void *userData) { int defWidth=e->windowInnerWidth; int defHeight=e->windowInnerHeight; printf("Resize:%d,%d\n",e->windowInnerWidth,e->windowInnerHeight); glfwCloseWindow(); initGL(defWidth,defHeight); //glfwSetWindowSize(defWidth,defHeight); s_applicationManager->surfaceChanged(defWidth,defHeight,(defWidth>defHeight)?90:0); }
void run_loop( std::unique_ptr<Example>& example, GLuint width, GLuint height ) { GLuint mouse_x = width / 2; GLuint mouse_y = height / 2; os::steady_clock os_clock; ExampleClock clock; while(true) { clock.Update(os_clock.seconds()); if(!example->Continue(clock)) break; example->Render(clock); glfwSwapBuffers(); int new_x, new_y; glfwGetWindowSize(&new_x, &new_y); if((int(width) != new_x) || (int(height) != new_y)) { if(new_x <= 0) new_x = 1; if(new_y <= 0) new_y = 1; width = GLuint(new_x); height = GLuint(new_y); example->Reshape(width, height); } glfwGetMousePos(&new_x, &new_y); if((int(mouse_x) != new_x) || (int(mouse_y) != new_y)) { if(new_x <= 0) new_x = 1; if(new_y <= 0) new_y = 1; mouse_x = GLuint(new_x); mouse_y = GLuint(new_y); example->MouseMove( mouse_x, height- mouse_y, width, height ); } if(glfwGetKey(GLFW_KEY_ESC)) { glfwCloseWindow(); break; } if(!glfwGetWindowParam(GLFW_OPENED)) break; } }
static void cb_key(int key, int press) { if (g_game) { g_game->onKeyEvent(key, press); } if (key == GLFW_KEY_ESC) { glfwCloseWindow(); } }
const char *render_scene(std::vector<DrawableObject*> &actors) { if (first_frame) { EntryCB cb = Callbacks.begin(); while (cb != Callbacks.end()) { if (cb->first != "idle") { std::cout<<cb->first<<": "<<cb->second->get_message()<<std::endl; } ++cb; } first_frame = false; } character_input = ' '; CurrentWindow = this; glClearColor(Color[0], Color[1], Color[2], 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); GLfloat light_ambient [] = { 0.4, 0.4, 0.4, 1.0 }; GLfloat light_diffuse [] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light_position[] = { 0.0, 0.0, 1.0, 0.0 }; glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glTranslated(Position[0], Position[1], Position[2]); glRotated(Orientation[0], 1, 0, 0); glRotated(Orientation[1], 0, 1, 0); glScaled(Scale[0], Scale[1], Scale[2]); for (std::vector<DrawableObject*>::iterator a=actors.begin(); a!=actors.end(); ++a) { DrawableObject *actor = *a; actor->draw(); } glFlush(); glfwSwapBuffers(); if (glfwGetKey(GLFW_KEY_ESC) || !glfwGetWindowParam(GLFW_OPENED)) { glfwCloseWindow(); return "terminate"; } CurrentWindow->exec_callback("idle"); return "continue"; }
// Callback function called by GLFW on key event void GLFWCALL OnKey(int glfwKey, int glfwAction) { if( !TwEventKeyGLFW(glfwKey, glfwAction) ) // Send event to AntTweakBar { if( glfwKey==GLFW_KEY_ESC && glfwAction==GLFW_PRESS ) // Want to quit? glfwCloseWindow(); else { // Event has not been handled // Do something if needed. } } }
//----------------------------------------------------------------------------- int main(int argc, char *argv[]) { int retval = -1; if (glfwInit() == GL_TRUE) { if (glfwOpenWindow(SYS_WIDTH, SYS_HEIGHT, 0, 0, 0, 0, 8, 0, SYS_FULLSCREEN ? GLFW_FULLSCREEN : GLFW_WINDOW) == GL_TRUE) /* rgba, depth, stencil */ { retval = Main(); glfwCloseWindow(); } glfwTerminate(); } return retval; }
void keyPressListener( int key, int action ) { if( !running ) return; if( action == GLFW_PRESS ) { int width = appWidth, height = appHeight; switch (key) { case GLFW_KEY_ESC: running = false; break; case GLFW_KEY_SPACE: app->keyPress( key, true ); break; case GLFW_KEY_F1: app->release(); glfwCloseWindow(); // Toggle fullscreen mode fullScreen = !fullScreen; if( fullScreen ) { GLFWvidmode mode; glfwGetDesktopMode( &mode ); // Use desktop resolution width = mode.Width; height = mode.Height; } if( !setupWindow( width, height, fullScreen ) ) { glfwTerminate(); exit( -1 ); } app->init(sceneFile); app->resize( width, height ); t0 = glfwGetTime(); break; default: app->keyPress( key, true ); } } if( key >= 0 ) app->keyPress( key, action == GLFW_PRESS ); }
void toggleFullScreen() { LOGD("toggleFullScreen()"); g_isFullScreen = !g_isFullScreen; //glfwTerminate(); glfwCloseWindow(); openWindow(g_isFullScreen); input_resetStates(); engine_unloadContent(); engine_loadContent(); }
// Callback function called by GLFW on key event void GLFWCALL OnKey(int glfwKey, int glfwAction) { if( glfwKey==GLFW_KEY_ESC && glfwAction==GLFW_PRESS ) // Want to quit? { glfwCloseWindow(); } else if( glfwGetKey(GLFW_KEY_SPACE) == GLFW_PRESS ) { camera = false; } else { // Event has not been handled // Do something if needed. } }
int _glfwPlatformTerminate( void ) { #ifdef _GLFW_HAS_PTHREAD // Only the main thread is allowed to do this... if( pthread_self() != _glfwThrd.First.PosixID ) { return GL_FALSE; } #endif // _GLFW_HAS_PTHREAD // Close OpenGL window glfwCloseWindow(); // Kill thread package terminateThreads(); return GL_TRUE; }
int _glfwPlatformTerminate( void ) { // Only the main thread is allowed to do this... // TODO // Close OpenGL window glfwCloseWindow(); // Terminate joysticks _glfwTerminateJoysticks(); // Kill timer _glfwTerminateTimer(); // Kill thread package _glfwTerminateThreads(); return GL_TRUE; }
static void key_callback(GLFWwindow window, int key, int action) { printf("%0.2f Key %s\n", glfwGetTime(), action == GLFW_PRESS ? "pressed" : "released"); if (action != GLFW_PRESS) return; switch (key) { case GLFW_KEY_SPACE: glfwIconifyWindow(window); break; case GLFW_KEY_ESCAPE: glfwCloseWindow(window); break; } }
int main(int argc, char** argv) { if(argc != 2) { std::cerr << "Usage: test file. Where file is a valid font\n"; } else { glfwInit(); glfwOpenWindow(800, 600, 8, 8, 8, 8, 0, 0, GLFW_WINDOW); GLFT_Font f; f.open(argv[1],24); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0, 800, 600, 0, -1.0, 1.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glDisable(GL_LIGHTING); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); do { glClear(GL_COLOR_BUFFER_BIT); f.drawText(0, 0, "drawText"); f.drawText(f.calcStringWidth("drawText"), f.getHeight(), "drawText 0x%X", 250); f.beginDraw(200, 200) << "beginDraw: " << 10 << f.endDraw(); glfwSwapBuffers(); } while(glfwGetWindowParam(GLFW_OPENED) && glfwGetKey(GLFW_KEY_ESC) != GLFW_PRESS); glfwCloseWindow(); glfwTerminate(); } }
void Root::setFullscreen(bool fullscr) { if( fullscreen == fullscr ) return; //no difference fullscreen = fullscr; glfwCloseWindow(); if(!glfwOpenWindow(windowWidth, windowHeight, 0, 0, 0, 0, 32, 0, (fullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW))) { LOG_ERROR("Could not re-create window. Closing now."); stopRendering(); return; } glfwSetWindowTitle("Arya"); glfwEnable(GLFW_MOUSE_CURSOR); glfwSetKeyCallback(keyCallback); glfwSetMouseButtonCallback(mouseButtonCallback); glfwSetMousePosCallback(mousePosCallback); glfwSetMouseWheelCallback(mouseWheelCallback); }
void _glfwPlatformPollEvents( void ) { int winclosed; // Process all pending window events winclosed = GL_FALSE; if( _glfwProcessEvents() ) { winclosed = GL_TRUE; } // Was there a window close request? if( winclosed && _glfwWin.WindowCloseCallback ) { // Check if the program wants us to close the window winclosed = _glfwWin.WindowCloseCallback(); } if( winclosed ) { glfwCloseWindow(); } }