/* * Activates a menu pointed by the function argument */ void fgActivateMenu( SFG_Window* window, int button ) { /* * We'll be referencing this menu a lot, so remember its address: */ SFG_Menu* menu = window->Menu[ button ]; /* * Mark the menu as active, so that it gets displayed: */ window->ActiveMenu = menu; menu->IsActive = GL_TRUE; fgState.ActiveMenus++; /* * Set up the initial menu position now: */ menu->X = window->State.MouseX + glutGet( GLUT_WINDOW_X ); menu->Y = window->State.MouseY + glutGet( GLUT_WINDOW_Y ); if( menu->X + menu->Width > glutGet ( GLUT_SCREEN_WIDTH ) ) menu->X -=menu->Width; if( menu->Y + menu->Height > glutGet ( GLUT_SCREEN_HEIGHT ) ) menu->Y -=menu->Height; fgSetWindow( menu->Window ); glutPositionWindow( menu->X, menu->Y ); glutReshapeWindow( menu->Width, menu->Height ); glutPopWindow( ); glutShowWindow( ); menu->Window->ActiveMenu = menu; }
void showSimulationWindow(bool show) { if (show) glutShowWindow(); else glutHideWindow(); }
/* We can't start an application that requires exclusive mode with system() if our GLUT window already has exclusive mode. Thus we must wait and perform the system() call after we know that the window no longer has exclusive mode. This is the only way to do it. */ void visibilityFunc(int state) { // If the window is finally f*****g gone... if(state == GLUT_NOT_VISIBLE) { // Stop the audio no matter what. audio::stopBGM(); // If the current Tile's state is above 1.0 (EXECUTE range) we execute the command. // The UI halts until that call is returned, at which point we remake the window // visible and set it to fullscreen if necessary. if(grid->getCurrent()->getIntendedState() == EXECUTE) { grid->getCurrent()->setState(ACTIVE); printf("\ncommand: %s\n", grid->getCurrent()->getCommand()); if(grid->getCurrent()->isSelectable()) { system(grid->getCurrent()->getCommand()); } glutShowWindow(); window::setFullScreen(c->fullscr); audio::startBGM(); } } if(state == GLUT_VISIBLE) { audio::startBGM(); } }
static int l_window_show(lua_State* L) { Window* win = l_checkWindow(L, 1); glutSetWindow(win->id); glutShowWindow(); return 0; }
int main(int argc, char **argv) { //initialize glut and parse command line arguments @ see glut documentation for more details glutInit(&argc, argv); //setting up the window display mode glutInitDisplayMode( GLUT_RGBA | //use a rgba target framebuffer GLUT_DEPTH | //create a depth (z-)buffer GLUT_DOUBLE | //create a front and back-buffer GLUT_MULTISAMPLE); //create a multi-sample framebuffer (use for fullscreen antialiasing) //setting up window pos and size glutInitWindowPosition(0, 0); glutInitWindowSize(800, 600); //create the window //from this point we can use the opengl api, because //glut has created a valid opengl context for us glutCreateWindow( "Hausaufgabe 2"); //init the application and all required resources if (!initApplication()) return EXIT_FAILURE; //register the required callback glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); // glutMouseFunc(mouse); //show the window glutShowWindow(); //enter mainloop which handle all window events glutMainLoop(); return EXIT_SUCCESS; }
static void KeyPressFunc(unsigned char Key, int x, int y) { switch (Key) { case 'F': case 'f': //toggle screenmode if (!fullscreen) { glutFullScreen(); fullscreen = true; } else if (fullscreen) { glutReshapeWindow(1500, 1000); glutPositionWindow(10, 30); fullscreen = false; } break; case 'H': case 'h': //toggle screenmode glutHideWindow(); break; case 'S': case 's': //toggle screenmode glutShowWindow(); break; case 27: // Escape key exit(1); } }
void display() { try { if (!disconnected) { // receive scenegraph and do rendering server->render(ract); OSGCompat::clearChangelist(); } else { SLOG << "Attempting to restart ClusterServer..." << endLog; // start server, wait for client to connect server->start(); glutShowWindow(); disconnected = false; } } catch(std::exception &e) { SLOG << "ERROR: " << e.what() << endLog; disconnected = true; // try to restart server server->stop(); //after glutHideWindow() control has to be given back to the glutloop for it to have an effect glutHideWindow(); } }
HRESULT CVideoMixerOpenGL::SetViewPortPri(RECT* prPort) { if(prPort==NULL) return E_POINTER; if((m_rViewPort .left == prPort->left)&& (m_rViewPort .top == prPort->top) && (m_rViewPort .right == prPort->right) && (m_rViewPort .bottom == prPort->bottom)) return S_OK; m_rViewPort = *prPort; glutReshapeWindow(prPort->right-prPort->left,prPort->bottom-prPort->top); glutPositionWindow(prPort->left,prPort->top ); if(m_pDMCP) { HRESULT hr = m_pDMCP->SetTargetRect(&m_rViewPort); if(FAILED(hr)) DP("[GFXPRESENT] SetTargetRect failed :0x%x \n",hr); m_bCanDisp = m_pDMCP->CanDisplay(FALSE); if(m_bShow && m_bCanDisp) glutShowWindow(); else glutHideWindow(); } return S_OK; }
void updateWindows(){ glui3->hide(); glutHideWindow(); glui2->set_main_gfx_window( main_window ); glutShowWindow(); if(game_option == 1){ game->player2->cpu = true; if(listbox1->get_int_val() == 1) game->player2->cpudiff = "easy"; else if(listbox1->get_int_val() == 2) game->player2->cpudiff = "medium"; else if(listbox1->get_int_val() == 3) game->player2->cpudiff = "hard"; } else if(game_option == 2){ game->player1->cpu = true; if(listbox1->get_int_val() == 1) game->player1->cpudiff = "easy"; else if(listbox1->get_int_val() == 2) game->player1->cpudiff = "medium"; else if(listbox1->get_int_val() == 3) game->player1->cpudiff = "hard"; } else if(game_option == 3){ game->player1->cpu = true; if(listbox1->get_int_val() == 1) game->player1->cpudiff = "easy"; else if(listbox1->get_int_val() == 2) game->player1->cpudiff = "medium"; else if(listbox1->get_int_val() == 3) game->player1->cpudiff = "hard"; game->player2->cpu = true; if(listbox2->get_int_val() == 1) game->player2->cpudiff = "easy"; else if(listbox2->get_int_val() == 2) game->player2->cpudiff = "medium"; else if(listbox2->get_int_val() == 3) game->player2->cpudiff = "hard"; } delete game->gameboard; game->addGameboard(new Gameboard(gameboard_size)); game->initializeSocket(game_option+1); //Contador int timeOption = time_box->get_int_val(); if(timeOption>0){ if (timeOption == 1) max_play_time = 60; //60 segundos else if (timeOption == 2) max_play_time = 30; //30 segundos else if (timeOption == 3) max_play_time = 15; //15 segundos if(!game->player1->cpu) game->clock->start_count(); } }
static void timer(int value) { if (value != 777) { printf("FAIL: unexpected timer value\n"); exit(1); } damage_expectation = 1; glutShowWindow(); }
void GlutViewer::show() { OpenGLViewer::show(); if (!visible) { glutShowWindow(); //Restore to set width & height glutReshapeWindow(width, height); } // Update title glutSetWindowTitle(title.c_str()); }
void display() { if(!running) { server->start(); running=true; glutShowWindow(); } /*! ignore rendering in zero sized windows */ if(!winWidth || !winHeight) return; try { OSG::FrameHandler::the()->frame(); OSG::commitChanges(); server->render(ract); // clear changelist from prototypes OSG::Thread::getCurrentChangeList()->clear(); } catch(OSG_STDEXCEPTION_NAMESPACE::exception &e) { if(exitOnError) { SLOG << e.what() << std::endl; printf("Exit on error %s",e.what()); try { cleanup(); } catch(...) { } exit(0); } else { window->clearPorts(); // try to restart server try { server->stop(); } catch(...) { } running=false; glutHideWindow(); } } }
void doSetWindowVisible(bool visible) { Window::Ptr window = getCurrentWindow(); if (window) { if (visible) { glutShowWindow(); window->onShow(); } else { glutHideWindow(); window->onHide(); } } }
HRESULT CVideoMixerOpenGL::Show(BOOL bShow) { if(m_bShow==bShow) return S_OK; m_bShow = bShow; if(m_bShow && m_bCanDisp) glutShowWindow(); else glutHideWindow(); return S_OK; }
// maybe_render() can be called directly by GLUT when a window is // uncovered, so we let that happen even if suspend_render is true. static void maybe_render() { int width, height; BOINC_STATUS boinc_status; if (visible && (current_graphics_mode != MODE_HIDE_GRAPHICS)) { width = glutGet(GLUT_WINDOW_WIDTH); height = glutGet(GLUT_WINDOW_HEIGHT); if (throttled_app_render(width, height, dtime())) { glutSwapBuffers(); #ifdef __APPLE__ switch (current_graphics_mode) { case MODE_WINDOW: MacGLUTFix(false); if (need_show) { glutShowWindow(); need_show = false; } break; case MODE_FULLSCREEN: case MODE_BLANKSCREEN: MacGLUTFix(true); if (need_show) { glutShowWindow(); need_show = false; } break; } #endif // Always render once after app is suspended in case app displays // different graphics when suspended, then stop rendering boinc_get_status(&boinc_status); if (boinc_status.suspended) suspend_render = true; } } }
/* * Activates a menu pointed by the function argument */ static void fghActivateMenu( SFG_Window* window, int button ) { int max_x, max_y; /* We'll be referencing this menu a lot, so remember its address: */ SFG_Menu* menu = window->Menu[ button ]; SFG_Window* current_window = fgStructure.CurrentWindow; /* If the menu is already active in another window, deactivate it there */ if ( menu->ParentWindow ) menu->ParentWindow->ActiveMenu = NULL ; /* Mark the menu as active, so that it gets displayed: */ window->ActiveMenu = menu; menu->IsActive = GL_TRUE; fghSetMenuParentWindow ( window, menu ); fgState.ActiveMenus++; /* Set up the initial menu position now: */ fghGetVMaxExtent(menu->ParentWindow, &max_x, &max_y); fgSetWindow( window ); menu->X = window->State.MouseX + glutGet( GLUT_WINDOW_X ); menu->Y = window->State.MouseY + glutGet( GLUT_WINDOW_Y ); if( menu->X + menu->Width > max_x ) menu->X -=menu->Width; if( menu->Y + menu->Height > max_y ) { menu->Y -=menu->Height; if( menu->Y < 0 ) menu->Y = 0; } menu->Window->State.MouseX = window->State.MouseX + glutGet( GLUT_WINDOW_X ) - menu->X; menu->Window->State.MouseY = window->State.MouseY + glutGet( GLUT_WINDOW_Y ) - menu->Y; fgSetWindow( menu->Window ); glutPositionWindow( menu->X, menu->Y ); glutReshapeWindow( menu->Width, menu->Height ); glutPopWindow( ); glutShowWindow( ); menu->Window->ActiveMenu = menu; fghCheckMenuStatus( menu ); fgSetWindow( current_window ); }
void Graphics::SetOpenGLContext(double proportion, int argc, char **argv) { gettimeofday(&changeFrame, NULL); glutInit(&argc, argv); int maxwidth = glutGet(GLUT_SCREEN_WIDTH); int maxheight = glutGet(GLUT_SCREEN_HEIGHT); windowHeight = maxheight - 100; windowWidth = windowHeight * proportion; glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowSize(windowWidth, windowHeight); glutInitWindowPosition((maxwidth - windowWidth) / 2, 0); glutCreateWindow("Repka"); glutShowWindow(); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); }
void registerWindowCallback::callback() { freeglutManager->windows[window->id] = window; glutSetWindow(window->id); glutDisplayFunc(freeglutManager_glutDisplayFunc); glutReshapeFunc(freeglutManager_glutReshapeFunc); glutKeyboardFunc(freeglutManager_glutKeyboardFunc); glutMouseFunc(freeglutManager_glutMouseFunc); glutMotionFunc(freeglutManager_glutMotionFunc); glutPassiveMotionFunc(freeglutManager_glutPassiveMotionFunc); glutVisibilityFunc(freeglutManager_glutVisibilityFunc); glutEntryFunc(freeglutManager_glutEntryFunc); glutSpecialFunc(freeglutManager_glutSpecialFunc); glutTimerFunc(2000, freeglutManager_RenderTimer, window->id); glutShowWindow(); waiting = false; }
int main(int argc, char **argv) { myAppState.appName = strdup(argv[0]); myAppState.triangleAreaInPixels=DEFAULT_TRIANGLE_AREA; myAppState.triangleType = DEFAULT_TRIANGLE_TYPE; myAppState.testDurationMS=DEFAULT_TEST_DURATION_MS; myAppState.imgWidth = DEFAULT_WIN_WIDTH; myAppState.imgHeight = DEFAULT_WIN_HEIGHT; myAppState.triangleLimit = DEFAULT_TRIANGLE_LIMIT; myAppState.vertexBufLimit = DEFAULT_VERTEXBUF_LIMIT; myAppState.textureSize = DEFAULT_TEXTURE_SIZE; myAppState.enableLighting = DEFAULT_LIGHTING_ENABLED; myAppState.enableColorMaterial = DEFAULT_COLOR_MATERIAL; myAppState.dumpFileName = strdup(DEFAULT_DUMP_FILE_NAME); myAppState.retainedModeEnabled = DEFAULT_RETAINED_MODE_ENABLED; myAppState.clearPerFrame = DEFAULT_CLEAR_PER_FRAME; myAppState.outlineMode = DEFAULT_OUTLINE_MODE_BOOL; glutInit(&argc, argv); parseArgs(argc, argv, &myAppState); glutInitWindowSize(myAppState.imgWidth, myAppState.imgHeight); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); { char buf[256]; sprintf(buf,"%s -- Lawrence Berkeley National Laboratory -- (C) 2009-2010", argv[0]); glutCreateWindow(buf); } Init(); glutDisplayFunc(Display); glutReshapeFunc(Reshape); glutKeyboardFunc(Key); glutShowWindow(); glutMainLoop(); return 0; }
///////////////////////////////////////////////////////// // dimensionsMess // ///////////////////////////////////////////////////////// void gemglutwindow :: dimensionsMess(unsigned int width, unsigned int height) { if (width <= 0) { error("width must be greater than 0"); return; } if (height <= 0 ) { error ("height must be greater than 0"); return; } m_width = width; m_height = height; if(makeCurrent()){ glutReshapeWindow(width, height); glutHideWindow();glutShowWindow(); glutPositionWindow(m_xoffset, m_yoffset); glutMainLoopEvent(); } }
bool EnvironmentDisplay::Init(int width_in, int height_in, char *title_in) { static bool initialized = false; int argc = 0; char **argv = 0; width = width_in; height = height_in; if(!initialized) { glutInit(&argc, argv); glutInitWindowPosition(0,0); glutInitWindowSize(width, height); initialized = true; } glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); window = glutCreateWindow(title_in); glClearColor(1.0,1.0,1.0,0); glutShowWindow(); return true; }
void set_mode(int mode) { if (mode == current_graphics_mode) { // Bring graphics window to front whenever user presses "Show graphics" if (mode == MODE_WINDOW) { #ifdef __APPLE__ BringAppToFront(); #else if (glut_is_freeglut && FREEGLUT_IS_INITIALIZED && (GLUT_HAVE_WINDOW > 0)) { // glutPopWindow(); glutShowWindow(); } #endif } return; } if (debug) fprintf(stderr, "set_mode(%d): current_mode = %d.\n", mode, current_graphics_mode); if (glut_is_initialized) { if (debug) fprintf(stderr, "Calling KillWindow(): win = %d\n", win); KillWindow(); if (debug) fprintf(stderr, "KillWindow() survived.\n"); } if (mode != MODE_HIDE_GRAPHICS) { if (debug) fprintf(stderr, "set_mode(): Calling make_new_window(%d)\n", mode); make_new_window(mode); if (debug) fprintf(stderr, "make_new_window() survived.\n"); } #ifdef __APPLE__ else HideThisApp(); #endif current_graphics_mode = mode; return; }
void freeglut::StartMainLoop() { running = true; if (MainLoopLock->TryLock() == wxMUTEX_NO_ERROR) { int tmpWindow = glutCreateWindow("GLEW init"); glutShowWindow(); initGlew(); std::cout << "OpenGL: " << glGetString(GL_VENDOR) << std::endl; std::cout << "OpenGL: " << glGetString(GL_RENDERER) << std::endl; std::cout << "OpenGL: " << glGetString(GL_VERSION) << std::endl; glutHideWindow(); glutDestroyWindow(tmpWindow); unsigned int displayMode = GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_STENCIL; glutInitDisplayMode (displayMode); glutInitContextVersion (3, 0); glutInitContextProfile(GLUT_CORE_PROFILE); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); while (running) { glutMainLoopEvent(); QueueLock->Lock(); if (!callbackQueue.empty()) { callbackQueue.front()->callback(); callbackQueue.pop(); } QueueLock->Unlock(); } for (std::map<int,freeglutWindow*>::iterator it=windows.begin(); it!=windows.end(); ++it) { glutDestroyWindow(it->first); } windows.clear(); MainLoopLock->Unlock(); } }
// // Standard glut idle function // void IdleFunc() { glutShowWindow (); glutPostRedisplay (); }
void CDrawing::ShowWindow() { glutShowWindow(); }
void GLUTDisplay2::run(PathTracer &pt) { ptr = &pt; unsigned int buffer_width = 960; unsigned int buffer_height = 540; glutInitWindowSize(buffer_width, buffer_height); glutInitWindowPosition(100, 100); glutCreateWindow("test"); // Initialize GLEW if (glewInit() != GLEW_OK) { cerr << "Failed to initialize GLEW" << endl; return; } try { // Set up scene cout << "setup camera" << endl; //SampleScene::InitialCameraData camera_data; // todo: get camera //ptr->initScene(camera_data); // Initialize camera according to scene params //m_camera = new PinholeCamera(camera_data.eye, camera_data.lookat, // camera_data.up, -1.0f, // hfov is ignored when using keep vertical // camera_data.vfov, PinholeCamera::KeepVertical); } catch (optix::Exception& e) { sutilReportError(e.getErrorString().c_str()); exit(2); } //cout << "make renderer" << endl; //renderer = new GLrenderer( pt.getOutputBuffer()->getGLBOId() ); cout << "init texture" << endl; glGenTextures(1, &m_texId); glBindTexture(GL_TEXTURE_2D, m_texId); // Change these to GL_LINEAR for super- or sub-sampling glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // GL_CLAMP_TO_EDGE for linear filtering, not relevant for nearest. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glBindTexture(GL_TEXTURE_2D, 0); // Initialize state glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0, 1, 0, 1, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glViewport(0, 0, buffer_width, buffer_height); cout << "begin glut loop" << endl; glutDisplayFunc(display); glutIdleFunc(idle); glutShowWindow(); glutReshapeWindow( buffer_width, buffer_height ); glutMainLoop(); }
void UnhideTimer(int window) { glutSetWindow(window); glutShowWindow(); }
/* * Private function to check for the current menu/sub menu activity state */ static GLboolean fghCheckMenuStatus( SFG_Window* window, SFG_Menu* menu ) { SFG_MenuEntry* menuEntry; int x, y; /* * First of all check any of the active sub menus... */ for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next ) { if( menuEntry->SubMenu && menuEntry->IsActive ) { /* * OK, have the sub-menu checked, too. If it returns GL_TRUE, it * will mean that it caught the mouse cursor and we do not need * to regenerate the activity list, and so our parents do... */ GLboolean return_status = fghCheckMenuStatus( window, menuEntry->SubMenu ); /* * Reactivate the submenu as the checkMenuStatus may have turned * it off if the mouse is in its parent menu entry. */ menuEntry->SubMenu->IsActive = GL_TRUE; if ( return_status ) return GL_TRUE; } } /* * That much about our sub menus, let's get to checking the current menu: */ x = window->State.MouseX; y = window->State.MouseY; for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next ) menuEntry->IsActive = GL_FALSE; menu->IsActive = GL_FALSE; /* * Check if the mouse cursor is contained within the current menu box */ if( ( x >= FREEGLUT_MENU_BORDER ) && ( x < menu->Width - FREEGLUT_MENU_BORDER ) && ( y >= FREEGLUT_MENU_BORDER ) && ( y < menu->Height - FREEGLUT_MENU_BORDER ) && ( window == menu->Window ) ) { int menuID = ( y - FREEGLUT_MENU_BORDER ) / FREEGLUT_MENU_HEIGHT; /* * The mouse cursor is somewhere over our box, check it out. */ menuEntry = fghFindMenuEntry( menu, menuID + 1 ); assert( menuEntry ); menuEntry->IsActive = GL_TRUE; menuEntry->Ordinal = menuID; /* * If this is not the same as the last active menu entry, deactivate * the previous entry. Specifically, if the previous active entry * was a submenu then deactivate it. */ if( menu->ActiveEntry && ( menuEntry != menu->ActiveEntry ) ) if( menu->ActiveEntry->SubMenu ) fgDeactivateSubMenu( menu->ActiveEntry ); menu->ActiveEntry = menuEntry; menu->IsActive = GL_TRUE; /* * OKi, we have marked that entry as active, but it would be also * nice to have its contents updated, in case it's a sub menu. * Also, ignore the return value of the check function: */ if( menuEntry->SubMenu ) { if ( ! menuEntry->SubMenu->IsActive ) { SFG_Window *current_window = fgStructure.Window; /* * Set up the initial menu position now... */ menuEntry->SubMenu->IsActive = GL_TRUE; /* * Set up the initial submenu position now: */ menuEntry->SubMenu->X = menu->X + menu->Width; menuEntry->SubMenu->Y = menu->Y + menuEntry->Ordinal * FREEGLUT_MENU_HEIGHT; if( menuEntry->SubMenu->X + menuEntry->SubMenu->Width > glutGet( GLUT_SCREEN_WIDTH ) ) menuEntry->SubMenu->X = menu->X - menuEntry->SubMenu->Width; if( menuEntry->SubMenu->Y + menuEntry->SubMenu->Height > glutGet( GLUT_SCREEN_HEIGHT ) ) menuEntry->SubMenu->Y -= ( menuEntry->SubMenu->Height - FREEGLUT_MENU_HEIGHT - 2 * FREEGLUT_MENU_BORDER ); fgSetWindow( menuEntry->SubMenu->Window ); glutPositionWindow( menuEntry->SubMenu->X, menuEntry->SubMenu->Y ); glutReshapeWindow( menuEntry->SubMenu->Width, menuEntry->SubMenu->Height ); glutPopWindow( ); glutShowWindow( ); menuEntry->SubMenu->Window->ActiveMenu = menuEntry->SubMenu; fgSetWindow( current_window ); } fghCheckMenuStatus( window, menuEntry->SubMenu ); /* * Activate it because its parent entry is active */ menuEntry->SubMenu->IsActive = GL_TRUE; } /* * Report back that we have caught the menu cursor */ return GL_TRUE; } /* * Looks like the menu cursor is somewhere else... */ return GL_FALSE; }
void key(unsigned char c, int w, int h) { int transP; printf("c=%d w=%d h=%d\n", c, w, h); switch (c) { case 'e': glutEstablishOverlay(); independent = 0; transP = glutLayerGet(GLUT_TRANSPARENT_INDEX); glClearIndex(transP); glutSetColor((transP + 1) % 2, 1.0, 1.0, 0.0); glIndexi((transP + 1) % 2); on = 1; break; case 'r': glutRemoveOverlay(); on = 0; break; case 'm': if (glutLayerGet(GLUT_HAS_OVERLAY)) { int pixel; GLfloat red, green, blue; transP = glutLayerGet(GLUT_TRANSPARENT_INDEX); pixel = (transP + 1) % 2; red = glutGetColor(pixel, GLUT_RED) + 0.2; if (red > 1.0) red = red - 1.0; green = glutGetColor(pixel, GLUT_GREEN) - 0.1; if (green > 1.0) green = green - 1.0; blue = glutGetColor(pixel, GLUT_BLUE) + 0.1; if (blue > 1.0) blue = blue - 1.0; glutSetColor(pixel, red, green, blue); } break; case 'h': glutSetWindow(hidden_w); glutHideWindow(); glutSetWindow(s2); glutHideWindow(); break; case 's': glutSetWindow(hidden_w); glutShowWindow(); glutSetWindow(s2); glutShowWindow(); break; case 'H': glutHideOverlay(); break; case 'S': glutShowOverlay(); break; case 'D': glutDestroyWindow(main_w); exit(0); break; case ' ': printf("overlay possible: %d\n", glutLayerGet(GLUT_OVERLAY_POSSIBLE)); printf("layer in use: %d\n", glutLayerGet(GLUT_LAYER_IN_USE)); printf("has overlay: %d\n", glutLayerGet(GLUT_HAS_OVERLAY)); printf("transparent index: %d\n", glutLayerGet(GLUT_TRANSPARENT_INDEX)); break; } }
//----------------------------------------------------------------------------- // show our glut window (set us first) //----------------------------------------------------------------------------- void GlutDisplay::show() { glutSetWindow(winId); glutShowWindow(); }