bool BaseApp::onKey(const uint key, const bool pressed){ //#if defined(DEBUG) && defined(WIN32) #ifdef WIN32 if (pressed && key == KEY_F12){ if (OpenClipboard(hwnd)){ EmptyClipboard(); char str[256]; int len = sprintf(str, "camPos = vec3(%.15ff, %.15ff, %.15ff);\r\nwx = %.15ff;\r\nwy = %.15ff;\r\n", camPos.x, camPos.y, camPos.z, wx, wy); HGLOBAL handle = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len + 1); char *mem = (char *) GlobalLock(handle); if (mem != NULL){ strcpy(mem, str); GlobalUnlock(handle); SetClipboardData(CF_TEXT, handle); } CloseClipboard(); } } #endif if (pressed && key == screenshotKey){ if (!saveScreenshot()){ ErrorMsg("Couldn't save screenshot"); } return true; } if (pressed && key == benchmarkKey){ if (benchMarkFile){ fclose(benchMarkFile); benchMarkFile = NULL; } else { benchMarkFile = fopen("Benchmark.xls", "w"); fprintf(benchMarkFile, "Frames/s\n"); } return true; } bool processed = false; if (!mouseCaptured){ if (widgets.goToFirst()){ do { Widget *widget = widgets.getCurrent(); if (widget->isVisible() || widget->isCapturing()){ widgets.moveCurrentToTop(); processed = widget->onKey(key, pressed); break; } } while (widgets.goToNext()); } } if (!processed){ if (pressed){ processed = true; if (key == KEY_ESCAPE){ if (!mouseCaptured || (fullscreen && mouseCaptured)){ closeWindow(true, true); } else { captureMouse(false); } } else if (key == fpsKey){ showFPS = !showFPS; } else if (key == resetKey){ resetCamera(); } else if (key == optionsKey){ if (configDialog->isVisible()){ configDialog->setVisible(false); if (keysDialog) keysDialog->setVisible(false); if (joystickDialog) joystickDialog->setVisible(false); } else { captureMouse(false); configDialog->setVisible(true); if (keysDialog) keysDialog->setVisible(true); if (joystickDialog) joystickDialog->setVisible(true); } } else { processed = false; } } } if (key < elementsOf(keys)) keys[key] = pressed; return processed; }
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) { switch (event.type) { case Common::EVENT_KEYUP: return isHotkey(event); case Common::EVENT_KEYDOWN: if (event.kbd.hasFlags(Common::KBD_ALT)) { if ( event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { // Alt-Return and Alt-Enter toggle full screen mode beginGFXTransaction(); setFeatureState(OSystem::kFeatureFullscreenMode, !getFeatureState(OSystem::kFeatureFullscreenMode)); endGFXTransaction(); #ifdef USE_OSD if (getFeatureState(OSystem::kFeatureFullscreenMode)) { displayMessageOnOSD(_("Fullscreen mode")); } else { displayMessageOnOSD(_("Windowed mode")); } #endif return true; } if (event.kbd.keycode == Common::KEYCODE_s) { // Alt-s creates a screenshot Common::String filename; for (int n = 0;; n++) { SDL_RWops *file; filename = Common::String::format("scummvm%05d.bmp", n); file = SDL_RWFromFile(filename.c_str(), "r"); if (!file) break; SDL_RWclose(file); } saveScreenshot(filename.c_str()); debug("Saved screenshot '%s'", filename.c_str()); return true; } } else if (event.kbd.hasFlags(Common::KBD_CTRL | Common::KBD_ALT)) { if ( event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_MINUS || event.kbd.keycode == Common::KEYCODE_KP_PLUS || event.kbd.keycode == Common::KEYCODE_KP_MINUS) { // Ctrl+Alt+Plus/Minus Increase/decrease the size const int direction = (event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_KP_PLUS) ? +1 : -1; if (getFeatureState(OSystem::kFeatureFullscreenMode)) { // In case we are in fullscreen we will choose the previous // or next mode. // In case no modes are available we do nothing. if (_fullscreenVideoModes.empty()) { return true; } // Look for the current mode. VideoModeArray::const_iterator i = Common::find(_fullscreenVideoModes.begin(), _fullscreenVideoModes.end(), VideoMode(_desiredFullscreenWidth, _desiredFullscreenHeight)); if (i == _fullscreenVideoModes.end()) { return true; } // Cycle through the modes in the specified direction. if (direction > 0) { ++i; if (i == _fullscreenVideoModes.end()) { i = _fullscreenVideoModes.begin(); } } else { if (i == _fullscreenVideoModes.begin()) { i = _fullscreenVideoModes.end(); } --i; } _desiredFullscreenWidth = i->width; _desiredFullscreenHeight = i->height; // Try to setup the mode. if (!setupMode(_lastRequestedWidth, _lastRequestedHeight)) { warning("OpenGLSdlGraphicsManager::notifyEvent: Fullscreen resize failed ('%s')", SDL_GetError()); g_system->quit(); } } else { // Calculate the next scaling setting. We approximate the // current scale setting in case the user resized the // window. Then we apply the direction change. int windowWidth = 0, windowHeight = 0; getWindowDimensions(&windowWidth, &windowHeight); _graphicsScale = MAX<int>(windowWidth / _lastRequestedWidth, windowHeight / _lastRequestedHeight); _graphicsScale = MAX<int>(_graphicsScale + direction, 1); // Since we overwrite a user resize here we reset its // flag here. This makes enabling AR smoother because it // will change the window size like in surface SDL. _gotResize = false; // Try to setup the mode. if (!setupMode(_lastRequestedWidth * _graphicsScale, _lastRequestedHeight * _graphicsScale)) { warning("OpenGLSdlGraphicsManager::notifyEvent: Window resize failed ('%s')", SDL_GetError()); g_system->quit(); } } #ifdef USE_OSD int windowWidth = 0, windowHeight = 0; getWindowDimensions(&windowWidth, &windowHeight); const Common::String osdMsg = Common::String::format(_("Resolution: %dx%d"), windowWidth, windowHeight); displayMessageOnOSD(osdMsg.c_str()); #endif return true; } else if (event.kbd.keycode == Common::KEYCODE_a) { // In case the user changed the window size manually we will // not change the window size again here. _ignoreLoadVideoMode = _gotResize; // Ctrl+Alt+a toggles the aspect ratio correction state. beginGFXTransaction(); setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection)); endGFXTransaction(); // Make sure we do not ignore the next resize. This // effectively checks whether loadVideoMode has been called. assert(!_ignoreLoadVideoMode); #ifdef USE_OSD if (getFeatureState(OSystem::kFeatureAspectRatioCorrection)) displayMessageOnOSD(_("Enabled aspect ratio correction")); else displayMessageOnOSD(_("Disabled aspect ratio correction")); #endif return true; } else if (event.kbd.keycode == Common::KEYCODE_f) { // Never ever try to resize the window when we simply want to enable or disable filtering. // This assures that the window size does not change. _ignoreLoadVideoMode = true; // Ctrl+Alt+f toggles filtering on/off beginGFXTransaction(); setFeatureState(OSystem::kFeatureFilteringMode, !getFeatureState(OSystem::kFeatureFilteringMode)); endGFXTransaction(); // Make sure we do not ignore the next resize. This // effectively checks whether loadVideoMode has been called. assert(!_ignoreLoadVideoMode); #ifdef USE_OSD if (getFeatureState(OSystem::kFeatureFilteringMode)) { displayMessageOnOSD(_("Filtering enabled")); } else { displayMessageOnOSD(_("Filtering disabled")); } #endif return true; } } // Fall through default: return false; } }
void cv::viz::InteractorStyle::OnKeyDown() { CV_Assert("Interactor style not initialized. Please call Initialize() before continuing" && init_); FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]); // Save the initial windows width/height if (win_size_[0] == -1 || win_size_[1] == -1) win_size_ = Vec2i(Interactor->GetRenderWindow()->GetSize()); bool alt = Interactor->GetAltKey() != 0; std::string key(Interactor->GetKeySym()); if (key.find("XF86ZoomIn") != std::string::npos) zoomIn(); else if (key.find("XF86ZoomOut") != std::string::npos) zoomOut(); switch (Interactor->GetKeyCode()) { case 'h': case 'H': { std::cout << "| Help:\n" "-------\n" " p, P : switch to a point-based representation\n" " w, W : switch to a wireframe-based representation (where available)\n" " s, S : switch to a surface-based representation (where available)\n" "\n" " j, J : take a .PNG snapshot of the current window view\n" " k, K : export scene to Wavefront .obj format\n" " ALT + k, K : export scene to VRML format\n" " c, C : display current camera/window parameters\n" " f, F : fly to point mode, hold the key and move mouse where to fly\n" "\n" " e, E : exit the interactor\n" " q, Q : stop and call VTK's TerminateApp\n" "\n" " +/- : increment/decrement overall point size\n" " +/- [+ ALT] : zoom in/out \n" "\n" " r, R [+ ALT] : reset camera [to viewpoint = {0, 0, 0} -> center_{x, y, z}]\n" "\n" " ALT + s, S : turn stereo mode on/off\n" " ALT + f, F : switch between maximized window mode and original size\n" "\n" << std::endl; break; } // Switch representation to points case 'p': case 'P': { vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors(); vtkCollectionSimpleIterator ait; for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); ) for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); ) { vtkActor* apart = vtkActor::SafeDownCast(path->GetLastNode()->GetViewProp()); apart->GetProperty()->SetRepresentationToPoints(); } break; } // Save a PNG snapshot case 'j': case 'J': saveScreenshot(cv::format("screenshot-%d.png", (unsigned int)time(0))); break; // Export scene as in obj or vrml format case 'k': case 'K': { String format = alt ? "scene-%d.vrml" : "scene-%d"; exportScene(cv::format(format.c_str(), (unsigned int)time(0))); break; } // display current camera settings/parameters case 'c': case 'C': { vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->GetActiveCamera(); Vec2d clip(cam->GetClippingRange()); Vec3d focal(cam->GetFocalPoint()), pos(cam->GetPosition()), view(cam->GetViewUp()); Vec2i win_pos(Interactor->GetRenderWindow()->GetPosition()); Vec2i win_size(Interactor->GetRenderWindow()->GetSize()); double angle = cam->GetViewAngle () / 180.0 * CV_PI; String data = cv::format("clip(%f,%f) focal(%f,%f,%f) pos(%f,%f,%f) view(%f,%f,%f) angle(%f) winsz(%d,%d) winpos(%d,%d)", clip[0], clip[1], focal[0], focal[1], focal[2], pos[0], pos[1], pos[2], view[0], view[1], view[2], angle, win_size[0], win_size[1], win_pos[0], win_pos[1]); std::cout << data.c_str() << std::endl; break; } case '=': { zoomIn(); break; } case 43: // KEY_PLUS { if (alt) zoomIn(); else { vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors(); vtkCollectionSimpleIterator ait; for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); ) for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); ) { vtkActor* apart = vtkActor::SafeDownCast(path->GetLastNode()->GetViewProp()); float psize = apart->GetProperty()->GetPointSize(); if (psize < 63.0f) apart->GetProperty()->SetPointSize(psize + 1.0f); } } break; } case 45: // KEY_MINUS { if (alt) zoomOut(); else { vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors(); vtkCollectionSimpleIterator ait; for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); ) for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); ) { vtkActor* apart = vtkActor::SafeDownCast(path->GetLastNode()->GetViewProp()); float psize = apart->GetProperty()->GetPointSize(); if (psize > 1.0f) apart->GetProperty()->SetPointSize(psize - 1.0f); } } break; } // Switch between maximize and original window size case 'f': case 'F': { if (alt) { Vec2i screen_size(Interactor->GetRenderWindow()->GetScreenSize()); Vec2i win_size(Interactor->GetRenderWindow()->GetSize()); // Is window size = max? if (win_size == max_win_size_) { Interactor->GetRenderWindow()->SetSize(win_size_.val); Interactor->GetRenderWindow()->SetPosition(win_pos_.val); Interactor->GetRenderWindow()->Render(); Interactor->Render(); } // Set to max else { win_pos_ = Vec2i(Interactor->GetRenderWindow()->GetPosition()); win_size_ = win_size; Interactor->GetRenderWindow()->SetSize(screen_size.val); Interactor->GetRenderWindow()->Render(); Interactor->Render(); max_win_size_ = Vec2i(Interactor->GetRenderWindow()->GetSize()); } } else { AnimState = VTKIS_ANIM_ON; Interactor->GetPicker()->Pick(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1], 0.0, CurrentRenderer); vtkSmartPointer<vtkAbstractPropPicker> picker = vtkAbstractPropPicker::SafeDownCast(Interactor->GetPicker()); if (picker) if (picker->GetPath()) Interactor->FlyTo(CurrentRenderer, picker->GetPickPosition()); AnimState = VTKIS_ANIM_OFF; } break; } // 's'/'S' w/out ALT case 's': case 'S': { if (alt) { vtkSmartPointer<vtkRenderWindow> window = Interactor->GetRenderWindow(); if (!window->GetStereoRender()) { static Vec2i red_blue(4, 3), magenta_green(2, 5); window->SetAnaglyphColorMask (stereo_anaglyph_mask_default_ ? red_blue.val : magenta_green.val); stereo_anaglyph_mask_default_ = !stereo_anaglyph_mask_default_; } window->SetStereoRender(!window->GetStereoRender()); Interactor->Render(); } else Superclass::OnKeyDown(); break; } case 'o': case 'O': { vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera(); cam->SetParallelProjection(!cam->GetParallelProjection()); CurrentRenderer->Render(); break; } // Overwrite the camera reset case 'r': case 'R': { if (!alt) { Superclass::OnKeyDown(); break; } WidgetActorMap::iterator it = widget_actor_map_->begin(); // it might be that some actors don't have a valid transformation set -> we skip them to avoid a seg fault. for (; it != widget_actor_map_->end(); ++it) { vtkProp3D * actor = vtkProp3D::SafeDownCast(it->second); if (actor && actor->GetUserMatrix()) break; } vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera(); // if a valid transformation was found, use it otherwise fall back to default view point. if (it != widget_actor_map_->end()) { vtkMatrix4x4* m = vtkProp3D::SafeDownCast(it->second)->GetUserMatrix(); cam->SetFocalPoint(m->GetElement(0, 3) - m->GetElement(0, 2), m->GetElement(1, 3) - m->GetElement(1, 2), m->GetElement(2, 3) - m->GetElement(2, 2)); cam->SetViewUp (m->GetElement(0, 1), m->GetElement(1, 1), m->GetElement(2, 1)); cam->SetPosition(m->GetElement(0, 3), m->GetElement(1, 3), m->GetElement(2, 3)); } else { cam->SetPosition(0, 0, 0); cam->SetFocalPoint(0, 0, 1); cam->SetViewUp(0, -1, 0); } // go to the next actor for the next key-press event. if (it != widget_actor_map_->end()) ++it; else it = widget_actor_map_->begin(); CurrentRenderer->SetActiveCamera(cam); CurrentRenderer->ResetCameraClippingRange(); CurrentRenderer->Render(); break; } case 'q': case 'Q': { Interactor->ExitCallback(); return; } default: { Superclass::OnKeyDown(); break; } } KeyboardEvent event(KeyboardEvent::KEY_DOWN, Interactor->GetKeySym(), Interactor->GetKeyCode(), getModifiers()); if (keyboardCallback_) keyboardCallback_(event, keyboard_callback_cookie_); Interactor->Render(); }
MainWindow::MainWindow() : QbWindow(config().geometry.mainWindow) { setObjectName("main-window"); setWindowTitle(string() << bsnesTitle << " v" << bsnesVersion); setCloseOnEscape(false); //menu bar #if defined(PLATFORM_OSX) menuBar = new QMenuBar(0); #else menuBar = new QMenuBar; #endif system = menuBar->addMenu("&System"); system_load = system->addAction("Load &Cartridge ..."); system_load->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial = system->addMenu("Load &Special"); system_loadSpecial->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial_bsxSlotted = system_loadSpecial->addAction("Load BS-X &Slotted Cartridge ..."); system_loadSpecial_bsxSlotted->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial_bsx = system_loadSpecial->addAction("Load &BS-X Cartridge ..."); system_loadSpecial_bsx->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial_sufamiTurbo = system_loadSpecial->addAction("Load Sufami &Turbo Cartridge ..."); system_loadSpecial_sufamiTurbo->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial_superGameBoy = system_loadSpecial->addAction("Load Super &Game Boy Cartridge ..."); system_loadSpecial_superGameBoy->setIcon(QIcon(":/16x16/document-open.png")); system->addSeparator(); system->addAction(system_power = new QbCheckAction("&Power", 0)); system_reset = system->addAction("&Reset"); system_reset->setIcon(QIcon(":/16x16/view-refresh.png")); system->addSeparator(); system_port1 = system->addMenu("Controller Port &1"); system_port1->setIcon(QIcon(":/16x16/input-gaming.png")); system_port1->addAction(system_port1_none = new QbRadioAction("&None", 0)); system_port1->addAction(system_port1_gamepad = new QbRadioAction("&Gamepad", 0)); system_port1->addAction(system_port1_asciipad = new QbRadioAction("&asciiPad", 0)); system_port1->addAction(system_port1_multitap = new QbRadioAction("&Multitap", 0)); system_port1->addAction(system_port1_mouse = new QbRadioAction("&Mouse", 0)); system_port2 = system->addMenu("Controller Port &2"); system_port2->setIcon(QIcon(":/16x16/input-gaming.png")); system_port2->addAction(system_port2_none = new QbRadioAction("&None", 0)); system_port2->addAction(system_port2_gamepad = new QbRadioAction("&Gamepad", 0)); system_port2->addAction(system_port2_asciipad = new QbRadioAction("&asciiPad", 0)); system_port2->addAction(system_port2_multitap = new QbRadioAction("&Multitap", 0)); system_port2->addAction(system_port2_mouse = new QbRadioAction("&Mouse", 0)); system_port2->addAction(system_port2_superscope = new QbRadioAction("&Super Scope", 0)); system_port2->addAction(system_port2_justifier = new QbRadioAction("&Justifier", 0)); system_port2->addAction(system_port2_justifiers = new QbRadioAction("Two &Justifiers", 0)); #if !defined(PLATFORM_OSX) system->addSeparator(); #endif system_exit = system->addAction("E&xit"); system_exit->setIcon(QIcon(":/16x16/process-stop.png")); system_exit->setMenuRole(QAction::QuitRole); settings = menuBar->addMenu("S&ettings"); settings_videoMode = settings->addMenu("Video &Mode"); settings_videoMode->setIcon(QIcon(":/16x16/video-display.png")); settings_videoMode->addAction(settings_videoMode_1x = new QbRadioAction("Scale &1x", 0)); settings_videoMode->addAction(settings_videoMode_2x = new QbRadioAction("Scale &2x", 0)); settings_videoMode->addAction(settings_videoMode_3x = new QbRadioAction("Scale &3x", 0)); settings_videoMode->addAction(settings_videoMode_4x = new QbRadioAction("Scale &4x", 0)); settings_videoMode->addAction(settings_videoMode_5x = new QbRadioAction("Scale &5x", 0)); settings_videoMode->addSeparator(); settings_videoMode->addAction(settings_videoMode_correctAspectRatio = new QbCheckAction("Correct &Aspect Ratio", 0)); settings_videoMode->addSeparator(); settings_videoMode->addAction(settings_videoMode_ntsc = new QbRadioAction("&NTSC", 0)); settings_videoMode->addAction(settings_videoMode_pal = new QbRadioAction("&PAL", 0)); if(filter.opened()) { settings_videoFilter = settings->addMenu("Video &Filter"); settings_videoFilter->setIcon(QIcon(":/16x16/image-x-generic.png")); settings_videoFilter_configure = settings_videoFilter->addAction("&Configure Active Filter ..."); settings_videoFilter_configure->setIcon(QIcon(":/16x16/preferences-desktop.png")); settings_videoFilter->addSeparator(); settings_videoFilter->addAction(settings_videoFilter_none = new QbRadioAction("&None", 0)); settings_videoFilter_list.add(settings_videoFilter_none); lstring filterlist; filterlist.split(";", filter.dl_supported()); for(unsigned i = 0; i < filterlist.size(); i++) { QbRadioAction *action = new QbRadioAction(filterlist[i], 0); settings_videoFilter->addAction(action); settings_videoFilter_list.add(action); } } settings->addAction(settings_smoothVideo = new QbCheckAction("&Smooth Video Output", 0)); settings->addSeparator(); settings->addAction(settings_muteAudio = new QbCheckAction("&Mute Audio Output", 0)); settings->addSeparator(); settings_emulationSpeed = settings->addMenu("Emulation &Speed"); settings_emulationSpeed->setIcon(QIcon(":/16x16/appointment-new.png")); settings_emulationSpeed->addAction(settings_emulationSpeed_slowest = new QbRadioAction("Slowest", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_slow = new QbRadioAction("Slow", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_normal = new QbRadioAction("Normal", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_fast = new QbRadioAction("Fast", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_fastest = new QbRadioAction("Fastest", 0)); settings_emulationSpeed->addSeparator(); settings_emulationSpeed->addAction(settings_emulationSpeed_syncVideo = new QbCheckAction("Sync &Video", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_syncAudio = new QbCheckAction("Sync &Audio", 0)); settings_configuration = settings->addAction("&Configuration ..."); settings_configuration->setIcon(QIcon(":/16x16/preferences-desktop.png")); settings_configuration->setMenuRole(QAction::PreferencesRole); tools = menuBar->addMenu("&Tools"); tools_movies = tools->addMenu("&Movies"); tools_movies->setIcon(QIcon(":/16x16/applications-multimedia.png")); tools_movies_play = tools_movies->addAction("Play Movie ..."); tools_movies_play->setIcon(QIcon(":/16x16/media-playback-start.png")); tools_movies_stop = tools_movies->addAction("Stop"); tools_movies_stop->setIcon(QIcon(":/16x16/media-playback-stop.png")); tools_movies_recordFromPowerOn = tools_movies->addAction("Record Movie (and restart system)"); tools_movies_recordFromPowerOn->setIcon(QIcon(":/16x16/media-record.png")); tools_movies_recordFromHere = tools_movies->addAction("Record Movie (starting from here)"); tools_movies_recordFromHere->setIcon(QIcon(":/16x16/media-record.png")); tools_captureScreenshot = tools->addAction("&Capture Screenshot"); tools_captureScreenshot->setIcon(QIcon(":/16x16/image-x-generic.png")); tools->addSeparator(); tools_dialog = tools->addAction("&Tools Dialog ..."); tools_dialog->setIcon(QIcon(":/16x16/preferences-desktop.png")); tools_debugger = tools->addAction("&Debugger ..."); tools_debugger->setIcon(QIcon(":/16x16/utilities-terminal.png")); #if !defined(DEBUGGER) tools_debugger->setVisible(false); #endif help = menuBar->addMenu("&Help"); help_documentation = help->addAction("&Documentation ..."); help_documentation->setIcon(QIcon(":/16x16/text-x-generic.png")); help_license = help->addAction("&License ..."); help_license->setIcon(QIcon(":/16x16/text-x-generic.png")); #if !defined(PLATFORM_OSX) help->addSeparator(); #endif help_about = help->addAction("&About ..."); help_about->setIcon(QIcon(":/16x16/help-browser.png")); help_about->setMenuRole(QAction::AboutRole); //canvas canvasContainer = new CanvasObject; canvasContainer->setAcceptDrops(true); { canvasContainer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); canvasContainer->setObjectName("backdrop"); canvasLayout = new QVBoxLayout; { canvasLayout->setMargin(0); canvasLayout->setAlignment(Qt::AlignCenter); canvas = new CanvasWidget; canvas->setAcceptDrops(true); canvas->setFocusPolicy(Qt::StrongFocus); canvas->setAttribute(Qt::WA_PaintOnScreen, true); //disable Qt painting on focus / resize QPalette palette; palette.setColor(QPalette::Window, QColor(0, 0, 0)); canvas->setPalette(palette); canvas->setAutoFillBackground(true); } canvasLayout->addWidget(canvas); } canvasContainer->setLayout(canvasLayout); //status bar statusBar = new QStatusBar; statusBar->showMessage(""); systemState = new QLabel; statusBar->addPermanentWidget(systemState); //layout layout = new QVBoxLayout; layout->setMargin(0); layout->setSpacing(0); #if !defined(PLATFORM_OSX) layout->addWidget(menuBar); #endif layout->addWidget(canvasContainer); layout->addWidget(statusBar); setLayout(layout); //slots connect(system_load, SIGNAL(triggered()), this, SLOT(loadCartridge())); connect(system_loadSpecial_bsxSlotted, SIGNAL(triggered()), this, SLOT(loadBsxSlottedCartridge())); connect(system_loadSpecial_bsx, SIGNAL(triggered()), this, SLOT(loadBsxCartridge())); connect(system_loadSpecial_sufamiTurbo, SIGNAL(triggered()), this, SLOT(loadSufamiTurboCartridge())); connect(system_loadSpecial_superGameBoy, SIGNAL(triggered()), this, SLOT(loadSuperGameBoyCartridge())); connect(system_power, SIGNAL(triggered()), this, SLOT(power())); connect(system_reset, SIGNAL(triggered()), this, SLOT(reset())); connect(system_port1_none, SIGNAL(triggered()), this, SLOT(setPort1None())); connect(system_port1_gamepad, SIGNAL(triggered()), this, SLOT(setPort1Gamepad())); connect(system_port1_asciipad, SIGNAL(triggered()), this, SLOT(setPort1Asciipad())); connect(system_port1_multitap, SIGNAL(triggered()), this, SLOT(setPort1Multitap())); connect(system_port1_mouse, SIGNAL(triggered()), this, SLOT(setPort1Mouse())); connect(system_port2_none, SIGNAL(triggered()), this, SLOT(setPort2None())); connect(system_port2_gamepad, SIGNAL(triggered()), this, SLOT(setPort2Gamepad())); connect(system_port2_asciipad, SIGNAL(triggered()), this, SLOT(setPort2Asciipad())); connect(system_port2_multitap, SIGNAL(triggered()), this, SLOT(setPort2Multitap())); connect(system_port2_mouse, SIGNAL(triggered()), this, SLOT(setPort2Mouse())); connect(system_port2_superscope, SIGNAL(triggered()), this, SLOT(setPort2SuperScope())); connect(system_port2_justifier, SIGNAL(triggered()), this, SLOT(setPort2Justifier())); connect(system_port2_justifiers, SIGNAL(triggered()), this, SLOT(setPort2Justifiers())); connect(system_exit, SIGNAL(triggered()), this, SLOT(quit())); connect(settings_videoMode_1x, SIGNAL(triggered()), this, SLOT(setVideoMode1x())); connect(settings_videoMode_2x, SIGNAL(triggered()), this, SLOT(setVideoMode2x())); connect(settings_videoMode_3x, SIGNAL(triggered()), this, SLOT(setVideoMode3x())); connect(settings_videoMode_4x, SIGNAL(triggered()), this, SLOT(setVideoMode4x())); connect(settings_videoMode_5x, SIGNAL(triggered()), this, SLOT(setVideoMode5x())); connect(settings_videoMode_correctAspectRatio, SIGNAL(triggered()), this, SLOT(toggleAspectCorrection())); connect(settings_videoMode_ntsc, SIGNAL(triggered()), this, SLOT(setVideoNtsc())); connect(settings_videoMode_pal, SIGNAL(triggered()), this, SLOT(setVideoPal())); if(filter.opened()) { connect(settings_videoFilter_configure, SIGNAL(triggered()), this, SLOT(configureFilter())); for(unsigned i = 0; i < settings_videoFilter_list.size(); i++) { connect(settings_videoFilter_list[i], SIGNAL(triggered()), this, SLOT(setFilter())); } } connect(settings_smoothVideo, SIGNAL(triggered()), this, SLOT(toggleSmoothVideo())); connect(settings_muteAudio, SIGNAL(triggered()), this, SLOT(muteAudio())); connect(settings_emulationSpeed_slowest, SIGNAL(triggered()), this, SLOT(setSpeedSlowest())); connect(settings_emulationSpeed_slow, SIGNAL(triggered()), this, SLOT(setSpeedSlow())); connect(settings_emulationSpeed_normal, SIGNAL(triggered()), this, SLOT(setSpeedNormal())); connect(settings_emulationSpeed_fast, SIGNAL(triggered()), this, SLOT(setSpeedFast())); connect(settings_emulationSpeed_fastest, SIGNAL(triggered()), this, SLOT(setSpeedFastest())); connect(settings_emulationSpeed_syncVideo, SIGNAL(triggered()), this, SLOT(syncVideo())); connect(settings_emulationSpeed_syncAudio, SIGNAL(triggered()), this, SLOT(syncAudio())); connect(settings_configuration, SIGNAL(triggered()), this, SLOT(showConfigWindow())); connect(tools_movies_play, SIGNAL(triggered()), this, SLOT(playMovie())); connect(tools_movies_stop, SIGNAL(triggered()), this, SLOT(stopMovie())); connect(tools_movies_recordFromPowerOn, SIGNAL(triggered()), this, SLOT(recordMovieFromPowerOn())); connect(tools_movies_recordFromHere, SIGNAL(triggered()), this, SLOT(recordMovieFromHere())); connect(tools_captureScreenshot, SIGNAL(triggered()), this, SLOT(saveScreenshot())); connect(tools_debugger, SIGNAL(triggered()), this, SLOT(showDebugger())); connect(tools_dialog, SIGNAL(triggered()), this, SLOT(showToolsDialog())); connect(help_documentation, SIGNAL(triggered()), this, SLOT(showDocumentation())); connect(help_license, SIGNAL(triggered()), this, SLOT(showLicense())); connect(help_about, SIGNAL(triggered()), this, SLOT(showAbout())); syncUi(); }
void doIdle() { char s[20]="picxxxx.ppm"; int i; // save screen to file s[3] = 48 + (sprite / 1000); s[4] = 48 + (sprite % 1000) / 100; s[5] = 48 + (sprite % 100 ) / 10; s[6] = 48 + sprite % 10; if (saveScreenToFile==1) { saveScreenshot(windowWidth, windowHeight, s); //saveScreenToFile=0; // save only once, change this if you want continuos image generation (i.e. animation) sprite++; } if (sprite >= 300) // allow only 300 snapshots { exit(0); } if (pause == 0) { // insert code which appropriately performs one step of the cube simulation: if (Integration[0] == 'E') { Euler(&jello); }else if (Integration[0] == 'R') { RK4(&jello); }else { exit(0); } } if (Fx == 1) { jello.Force.x += 1; Fx = 0; } if (Fx == -1) { jello.Force.x -= 1; Fx = 0; } if (Fy == 1) { jello.Force.y += 1; Fy = 0; } if (Fy == -1) { jello.Force.y -= 1; Fy = 0; } if (Fa == 1) { alpha += 1; Fa = 0; } if (Fa == -1) { if (alpha != 0) { alpha -= 1; Fa = 0; } } if (Fb == 1) { beta += 0.1; Fb = 0; } if (Fb == -1) { beta -= 0.1; Fb = 0; } if (PNoise == -1) { jello.Force.x = 0; jello.Force.y = -1; PNoise = 0; for (int i=0; i<particleNum; i++) { jello.v[i].x = 0; jello.v[i].y = 0; jello.v[i].z = 0; jello.a[i].x = 0; jello.a[i].y = 0; jello.a[i].z = 0; } } if (PNoise == 1) { srand(time(NULL)); PerlinNoise P; if (alpha == 0) { jello.Force.x = P.PerlinNoise1D(rand()%100, particleNum , 0.3); jello.Force.y = P.PerlinNoise1D(rand()%100, particleNum , 0.3); }else { jello.Force.x = P.PerlinNoise1D(rand()%100, particleNum , 0.3) * 20; jello.Force.y = P.PerlinNoise1D(rand()%100, particleNum , 0.3) * 20; } } //reset everything if (Fx == -5) { for (int i=0; i<particleNum; i++) { jello.v[i].x = 0; jello.v[i].y = 0; jello.v[i].z = 0; jello.a[i].x = 0; jello.a[i].y = 0; jello.a[i].z = 0; } jello.Force.x = 0; jello.Force.y = -1; alpha = 0; beta = 0; PNoise = 0; Fx = 0; } glutPostRedisplay(); }
void Emulator::on_actionScreenshot_triggered(bool checked) { saveScreenshot(); }
bool InputManager::handleKeyboardInput(const SDL_Event &event) { bool used = false; bool metaKeyHeld = false; // Key press events if (event.type == SDL_KEYDOWN) { if (setupWindow->isVisible() && keyboard.getNewKeyIndex() > keyboard.KEY_NO_VALUE) { keyboard.setNewKey((int) event.key.keysym.sym); keyboard.callbackNewKey(); keyboard.setNewKeyIndex(keyboard.KEY_NO_VALUE); return false; } // If the user is configuring the keys then don't respond. if (!keyboard.isEnabled()) return false; const int tKey = keyboard.getKeyIndex(event.key.keysym.sym); // Ignore input if either "ignore" key is pressed // Stops the character moving about if the user's window manager // uses "ignore+arrow key" to switch virtual desktops. if (keyboard.isKeyActive(keyboard.KEY_IGNORE_INPUT_1) || keyboard.isKeyActive(keyboard.KEY_IGNORE_INPUT_2)) { return false; } if (keyboard.isKeyLocked(event.key.keysym.sym)) return false; gcn::Window *requestedWindow = NULL; switch (tKey) { // In-game Help case KeyboardConfig::KEY_WINDOW_HELP: requestedWindow = helpDialog; break; // Quitting confirmation dialog case KeyboardConfig::KEY_QUIT: stateManager->promptForQuit(); used = true; break; case KeyboardConfig::KEY_WINDOW_DEBUG: requestedWindow = debugWindow; break; case KeyboardConfig::KEY_WINDOW_SETUP: requestedWindow = setupWindow; break; // Screenshot (picture, hence the p) case KeyboardConfig::KEY_SCREENSHOT: saveScreenshot(); used = true; break; } if (stateManager->isInGame()) { switch (tKey) { case KeyboardConfig::KEY_SCROLL_CHAT_UP: if (chatWindow && chatWindow->isVisible()) { chatWindow->scroll(-DEFAULT_CHAT_WINDOW_SCROLL); used = true; } break; case KeyboardConfig::KEY_SCROLL_CHAT_DOWN: if (chatWindow && chatWindow->isVisible()) { chatWindow->scroll(DEFAULT_CHAT_WINDOW_SCROLL); used = true; } break; case KeyboardConfig::KEY_WINDOW_STATUS: requestedWindow = statusWindow; break; case KeyboardConfig::KEY_WINDOW_INVENTORY: requestedWindow = inventoryWindow; break; case KeyboardConfig::KEY_WINDOW_EQUIPMENT: requestedWindow = equipmentWindow; break; case KeyboardConfig::KEY_WINDOW_SKILL: requestedWindow = skillDialog; break; case KeyboardConfig::KEY_WINDOW_MINIMAP: minimap->toggle(); break; case KeyboardConfig::KEY_WINDOW_CHAT: requestedWindow = chatWindow; break; case KeyboardConfig::KEY_WINDOW_EMOTE: requestedWindow = emoteWindow; break; case KeyboardConfig::KEY_WINDOW_ITEM_SHORTCUT: requestedWindow = itemShortcutWindow; break; case KeyboardConfig::KEY_WINDOW_EMOTE_SHORTCUT: requestedWindow = emoteShortcutWindow; break; // Hide certain windows case KeyboardConfig::KEY_HIDE_WINDOWS: statusWindow->hide(); inventoryWindow->hide(); equipmentWindow->hide(); skillDialog->hide(); chatWindow->hide(); itemShortcutWindow->hide(); setupWindow->hide(); debugWindow->hide(); emoteWindow->hide(); helpDialog->hide(); emoteShortcutWindow->hide(); minimap->hide(); used = true; break; // Find path to mouse (debug purpose) case KeyboardConfig::KEY_PATHFIND: viewport->toggleDebugPath(); used = true; break; default: break; } metaKeyHeld = keyboard.isKeyActive(keyboard.KEY_METAKEY); for (int i = 0; i <= SHORTCUTS; i++) { ShortcutHandler *shortcut = metaKeyHeld ? (ShortcutHandler *) emoteShortcut : (ShortcutHandler *) itemShortcut; const int offset = metaKeyHeld ? KeyboardConfig::KEY_EMOTE_SHORTCUT_1 : KeyboardConfig::KEY_ITEM_SHORTCUT_1; if (keyboard.isKeyActive(i + offset)) { shortcut->useShortcut(i); used = true; break; } } if (keyboard.isKeyActive(keyboard.KEY_TOGGLE_CHAT) && chatWindow) { chatWindow->requestChatFocus(); used = true; } // Player actions if (player_node && player_node->mAction != Being::DEAD) { Being *target = player_node->getTarget(); const Uint16 x = player_node->mX; const Uint16 y = player_node->mY; if (!keyboard.isKeyActive(keyboard.KEY_CLEAR_TARGET)) { Being::Type type = Being::INVALID; // Target the nearest monster if (keyboard.isKeyActive(keyboard.KEY_TARGET_MONSTER)) type = Being::MONSTER; // Target the nearest player else if (keyboard.isKeyActive(keyboard.KEY_TARGET_PLAYER)) type = Being::PLAYER; // Target the nearest npc else if (keyboard.isKeyActive(keyboard.KEY_TARGET_NPC)) type = Being::NPC; target = beingManager->findNearestLivingBeing(x, y, 20, type != Being::INVALID ? type : Being::UNKNOWN); if (type != Being::INVALID && !targetKeyHeld) { player_node->setTarget(target); targetKeyHeld = true; used = true; } else if (player_node->isAttacking()) target = NULL; if (keyboard.isKeyActive(keyboard.KEY_ATTACK) && target) { player_node->attack(player_node->getTarget() ? player_node->getTarget() : target, target->getType() != Being::NPC); used = true; } } // Stop attacking else if (keyboard.isKeyActive(keyboard.KEY_CLEAR_TARGET)) { player_node->stopAttack(); targetKeyHeld = false; } if (keyboard.isKeyActive(keyboard.KEY_BEING_MENU)) { target = player_node->getTarget(); if (!target) target = beingManager->findNearestLivingBeing(x, y, 20); if (target) { Map *map = viewport->getMap(); viewport->showPopup(target->mX * map->getTileWidth() - viewport->getCameraX() + (map->getTileWidth() / 2), target->mY * map->getTileHeight() - viewport->getCameraY(), target); } used = true; } switch (tKey) { case KeyboardConfig::KEY_PICKUP: { Uint16 x = player_node->mX; Uint16 y = player_node->mY; FloorItem *item = floorItemManager-> findNearestItem(x, y); if (item) player_node->pickUp(item); used = true; } break; // Player sit action case KeyboardConfig::KEY_SIT: player_node->toggleSit(); used = true; break; // Toggle accepting of incoming trade requests case KeyboardConfig::KEY_TRADE: { unsigned int deflt = player_relations.getDefault(); if (deflt & PlayerRelation::TRADE) { chatWindow->chatLog(_("Ignoring incoming " "trade requests"), Palette::SYSTEM); deflt &= ~PlayerRelation::TRADE; } else { chatWindow->chatLog(_("Accepting incoming " "trade requests"), Palette::SYSTEM); deflt |= PlayerRelation::TRADE; } player_relations.setDefault(deflt); used = true; } break; } } } if (requestedWindow) { requestedWindow->setVisible(!requestedWindow->isVisible()); used = true; } } else if (event.type == SDL_KEYUP) { const int tKey = keyboard.getKeyIndex(event.key.keysym.sym); // Stop protecting the target keys if (tKey == KeyboardConfig::KEY_TARGET_MONSTER || tKey == KeyboardConfig::KEY_TARGET_PLAYER || tKey == KeyboardConfig::KEY_TARGET_NPC) { targetKeyHeld = false; } } // At the moment, this is the only bit of logic left not assigned to a // specific SDL input poll, because it was causing continuous walking // without stopping. It would be better in the long run if this would get // fixed and then moved to one of them (in case we ever use other input // libraries. If everything is already grouped together, it'd be easier to // adapt to a new library, instead of having to rely on special cases) if (stateManager->isInGame() && player_node->mAction != Being::DEAD && !used) { unsigned char direction = 0; // Get the state of the keyboard keys keyboard.refreshActiveKeys(); // Translate pressed keys to movement and direction if (keyboard.isKeyActive(keyboard.KEY_MOVE_UP)) direction |= Being::UP; else if (keyboard.isKeyActive(keyboard.KEY_MOVE_DOWN)) direction |= Being::DOWN; if (keyboard.isKeyActive(keyboard.KEY_MOVE_LEFT)) direction |= Being::LEFT; else if (keyboard.isKeyActive(keyboard.KEY_MOVE_RIGHT)) direction |= Being::RIGHT; if (metaKeyHeld && direction != 0) player_node->setDirection(direction); else player_node->setWalkingDir(direction); } return used; }
void ScreenGrabber::saveScreenshot( const GLEWContext* context, const std::string& nameTemplate, int w, int h, int numBytes ) { saveScreenshot( context, nameTemplate, eq::fabric::PixelViewport( 0, 0, w, h ), numBytes ); }
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) { switch (event.type) { case Common::EVENT_KEYUP: return isHotkey(event); case Common::EVENT_KEYDOWN: if (event.kbd.hasFlags(Common::KBD_ALT)) { if ( event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { // Alt-Return and Alt-Enter toggle full screen mode beginGFXTransaction(); setFeatureState(OSystem::kFeatureFullscreenMode, !getFeatureState(OSystem::kFeatureFullscreenMode)); endGFXTransaction(); #ifdef USE_OSD if (getFeatureState(OSystem::kFeatureFullscreenMode)) { displayMessageOnOSD("Fullscreen mode"); } else { displayMessageOnOSD("Windowed mode"); } #endif return true; } if (event.kbd.keycode == Common::KEYCODE_s) { // Alt-s creates a screenshot Common::String filename; for (int n = 0;; n++) { SDL_RWops *file; filename = Common::String::format("scummvm%05d.bmp", n); file = SDL_RWFromFile(filename.c_str(), "r"); if (!file) break; SDL_RWclose(file); } saveScreenshot(filename.c_str()); debug("Saved screenshot '%s'", filename.c_str()); return true; } } else if (event.kbd.hasFlags(Common::KBD_CTRL | Common::KBD_ALT)) { if ( event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_MINUS || event.kbd.keycode == Common::KEYCODE_KP_PLUS || event.kbd.keycode == Common::KEYCODE_KP_MINUS) { // Ctrl+Alt+Plus/Minus Increase/decrease the size const int direction = (event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_KP_PLUS) ? +1 : -1; if (getFeatureState(OSystem::kFeatureFullscreenMode)) { // In case we are in fullscreen we will choose the previous // or next mode. // In case no modes are available we do nothing. if (_fullscreenVideoModes.empty()) { return true; } // Look for the current mode. VideoModeArray::const_iterator i = Common::find(_fullscreenVideoModes.begin(), _fullscreenVideoModes.end(), VideoMode(_desiredFullscreenWidth, _desiredFullscreenHeight)); if (i == _fullscreenVideoModes.end()) { return true; } // Cycle through the modes in the specified direction. if (direction > 0) { ++i; if (i == _fullscreenVideoModes.end()) { i = _fullscreenVideoModes.begin(); } } else { if (i == _fullscreenVideoModes.begin()) { i = _fullscreenVideoModes.end(); } --i; } _desiredFullscreenWidth = i->width; _desiredFullscreenHeight = i->height; // Try to setup the mode. if (!setupMode(_lastRequestedWidth, _lastRequestedHeight)) { warning("OpenGLSdlGraphicsManager::notifyEvent: Fullscreen resize failed ('%s')", SDL_GetError()); g_system->quit(); } } else { // Calculate the next scaling setting. We approximate the // current scale setting in case the user resized the // window. Then we apply the direction change. _graphicsScale = MAX<int>(_hwScreen->w / _lastRequestedWidth, _hwScreen->h / _lastRequestedHeight); _graphicsScale = MAX<int>(_graphicsScale + direction, 1); // Since we overwrite a user resize here we reset its // flag here. This makes enabling AR smoother because it // will change the window size like in surface SDL. _gotResize = false; // Try to setup the mode. if (!setupMode(_lastRequestedWidth * _graphicsScale, _lastRequestedHeight * _graphicsScale)) { warning("OpenGLSdlGraphicsManager::notifyEvent: Window resize failed ('%s')", SDL_GetError()); g_system->quit(); } } #ifdef USE_OSD const Common::String osdMsg = Common::String::format("Resolution: %dx%d", _hwScreen->w, _hwScreen->h); displayMessageOnOSD(osdMsg.c_str()); #endif return true; } else if (event.kbd.keycode == Common::KEYCODE_a) { // In case the user changed the window size manually we will // not change the window size again here. _ignoreLoadVideoMode = _gotResize; // Ctrl+Alt+a toggles the aspect ratio correction state. beginGFXTransaction(); setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection)); endGFXTransaction(); // Make sure we do not ignore the next resize. This // effectively checks whether loadVideoMode has been called. assert(!_ignoreLoadVideoMode); #ifdef USE_OSD Common::String osdMsg = "Aspect ratio correction: "; osdMsg += getFeatureState(OSystem::kFeatureAspectRatioCorrection) ? "enabled" : "disabled"; displayMessageOnOSD(osdMsg.c_str()); #endif return true; } else if (event.kbd.keycode == Common::KEYCODE_f) { // Ctrl+Alt+f toggles the graphics modes. // We are crazy we will allow the OpenGL base class to // introduce new graphics modes like shaders for special // filtering. If some other OpenGL subclass needs this, // we can think of refactoring this. int mode = getGraphicsMode(); const OSystem::GraphicsMode *supportedModes = getSupportedGraphicsModes(); const OSystem::GraphicsMode *modeDesc = nullptr; // Search the current mode. for (; supportedModes->name; ++supportedModes) { if (supportedModes->id == mode) { modeDesc = supportedModes; break; } } assert(modeDesc); // Try to use the next mode in the list. ++modeDesc; if (!modeDesc->name) { modeDesc = getSupportedGraphicsModes(); } // Never ever try to resize the window when we simply want to // switch the graphics mode. This assures that the window size // does not change. _ignoreLoadVideoMode = true; beginGFXTransaction(); setGraphicsMode(modeDesc->id); endGFXTransaction(); // Make sure we do not ignore the next resize. This // effectively checks whether loadVideoMode has been called. assert(!_ignoreLoadVideoMode); #ifdef USE_OSD const Common::String osdMsg = Common::String::format("Graphics mode: %s", _(modeDesc->description)); displayMessageOnOSD(osdMsg.c_str()); #endif return true; } } // Fall through default: return false; } }
int main(int argc, char *argv[]) { float td; long then, lastFrameTime, frames; long expireTextTimer; SDL_Event event; memset(&app, 0, sizeof(App)); memset(&dev, 0, sizeof(Dev)); handleLoggingArgs(argc, argv); atexit(cleanup); srand(time(NULL)); init18N(argc, argv); initLookups(); initSDL(); initGameSystem(); createScreenshotFolder(); if (fileExists(getSaveFilePath(SAVE_FILENAME))) { loadGame(); } handleMissionArgs(argc, argv); dev.fps = frames = td = 0; then = SDL_GetTicks(); lastFrameTime = SDL_GetTicks() + 1000; expireTextTimer = SDL_GetTicks() + (1000 * 10); while (1) { td += (SDL_GetTicks() - then); then = SDL_GetTicks(); while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_MOUSEMOTION: doMouseMotion(&event.motion); break; case SDL_MOUSEWHEEL: doMouseWheel(&event.wheel); break; case SDL_MOUSEBUTTONDOWN: doMouseDown(&event.button); break; case SDL_MOUSEBUTTONUP: doMouseUp(&event.button); break; case SDL_KEYDOWN: doKeyDown(&event.key); break; case SDL_KEYUP: doKeyUp(&event.key); break; case SDL_QUIT: exit(0); break; } } if (app.modalDialog.type != MD_NONE) { doModalDialog(); } while (td >= LOGIC_RATE) { /* let the delegate decide during logic() */ app.doTrophyAlerts = 0; app.delegate.logic(); td -= LOGIC_RATE; if (app.doTrophyAlerts) { doTrophyAlerts(); } if (app.resetTimeDelta) { td = 0; then = SDL_GetTicks(); app.resetTimeDelta = 0; } game.stats[STAT_TIME]++; } prepareScene(); app.delegate.draw(); if (app.doTrophyAlerts) { drawTrophyAlert(); } if (app.modalDialog.type != MD_NONE) { drawModalDialog(); } presentScene(); doDevKeys(); frames++; if (SDL_GetTicks() > lastFrameTime) { dev.fps = frames; frames = 0; lastFrameTime = SDL_GetTicks() + 1000; if (dev.takeScreenshots) { saveScreenshot(); } } if (isControl(CONTROL_SCREENSHOT)) { saveScreenshot(); clearControl(CONTROL_SCREENSHOT); } if (SDL_GetTicks() > expireTextTimer) { expireTexts(0); expireTextTimer = SDL_GetTicks() + (1000 * 10); } /* don't save more than once per request, and not in the middle of battle */ if (app.saveGame && battle.status != MS_IN_PROGRESS) { saveGame(); app.saveGame = 0; } /* always zero the mouse motion */ app.mouse.dx = app.mouse.dy = 0; SDL_Delay(1); } return 0; }
bool OSystem_IPOD::pollEvent(Event &event) { SDL_Event ev; int axis; byte b = 0; handleKbdMouse(); // If the screen mode changed, send an EVENT_SCREEN_CHANGED if (_modeChanged) { _modeChanged = false; event.type = EVENT_SCREEN_CHANGED; return true; } while(SDL_PollEvent(&ev)) { switch(ev.type) { case SDL_KEYDOWN:{ b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState()); // Alt-Return and Alt-Enter toggle full screen mode if (b == KBD_ALT && (ev.key.keysym.sym == SDLK_RETURN || ev.key.keysym.sym == SDLK_KP_ENTER)) { setFullscreenMode(!_fullscreen); #ifdef USE_OSD if (_fullscreen) displayMessageOnOSD("Fullscreen mode"); else displayMessageOnOSD("Windowed mode"); #endif break; } // Alt-S: Create a screenshot if (b == KBD_ALT && ev.key.keysym.sym == 's') { char filename[20]; for (int n = 0;; n++) { SDL_RWops *file; sprintf(filename, "scummvm%05d.bmp", n); file = SDL_RWFromFile(filename, "r"); if (!file) break; SDL_RWclose(file); } if (saveScreenshot(filename)) printf("Saved '%s'\n", filename); else printf("Could not save screenshot!\n"); break; } // Ctrl-m toggles mouse capture if (b == KBD_CTRL && ev.key.keysym.sym == 'm') { toggleMouseGrab(); break; } #ifdef MACOSX // On Macintosh', Cmd-Q quits if ((ev.key.keysym.mod & KMOD_META) && ev.key.keysym.sym == 'q') { event.type = EVENT_QUIT; return true; } #elif defined(UNIX) // On other unices, Control-Q quits if ((ev.key.keysym.mod & KMOD_CTRL) && ev.key.keysym.sym == 'q') { event.type = EVENT_QUIT; return true; } #else // Ctrl-z and Alt-X quit if ((b == KBD_CTRL && ev.key.keysym.sym == 'z') || (b == KBD_ALT && ev.key.keysym.sym == 'x')) { event.type = EVENT_QUIT; return true; } #endif // Ctrl-Alt-<key> will change the GFX mode if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) { handleScalerHotkeys(ev.key); break; } const bool event_complete = remapKey(ev,event); if (event_complete) return true; event.type = EVENT_KEYDOWN; event.kbd.keycode = ev.key.keysym.sym; event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode); return true; } case SDL_KEYUP: { const bool event_complete = remapKey(ev,event); if (event_complete) return true; event.type = EVENT_KEYUP; event.kbd.keycode = ev.key.keysym.sym; event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode); b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState()); // Ctrl-Alt-<key> will change the GFX mode if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) { // Swallow these key up events break; } return true; } case SDL_MOUSEMOTION: event.type = EVENT_MOUSEMOVE; fillMouseEvent(event, ev.motion.x, ev.motion.y); setMousePos(event.mouse.x, event.mouse.y); return true; case SDL_MOUSEBUTTONDOWN: if (ev.button.button == SDL_BUTTON_LEFT) event.type = EVENT_LBUTTONDOWN; else if (ev.button.button == SDL_BUTTON_RIGHT) event.type = EVENT_RBUTTONDOWN; #if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN) else if (ev.button.button == SDL_BUTTON_WHEELUP) event.type = EVENT_WHEELUP; else if (ev.button.button == SDL_BUTTON_WHEELDOWN) event.type = EVENT_WHEELDOWN; #endif else break; fillMouseEvent(event, ev.button.x, ev.button.y); return true; case SDL_MOUSEBUTTONUP: if (ev.button.button == SDL_BUTTON_LEFT) event.type = EVENT_LBUTTONUP; else if (ev.button.button == SDL_BUTTON_RIGHT) event.type = EVENT_RBUTTONUP; else break; fillMouseEvent(event, ev.button.x, ev.button.y); return true; case SDL_JOYBUTTONDOWN: if (ev.jbutton.button == JOY_BUT_LMOUSE) { event.type = EVENT_LBUTTONDOWN; fillMouseEvent(event, _km.x, _km.y); } else if (ev.jbutton.button == JOY_BUT_RMOUSE) { event.type = EVENT_RBUTTONDOWN; fillMouseEvent(event, _km.x, _km.y); } else { event.type = EVENT_KEYDOWN; switch (ev.jbutton.button) { case JOY_BUT_ESCAPE: event.kbd.keycode = SDLK_ESCAPE; event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0); break; case JOY_BUT_PERIOD: event.kbd.keycode = SDLK_PERIOD; event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0); break; case JOY_BUT_SPACE: event.kbd.keycode = SDLK_SPACE; event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0); break; case JOY_BUT_F5: event.kbd.keycode = SDLK_F5; event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0); break; } } return true; case SDL_JOYBUTTONUP: if (ev.jbutton.button == JOY_BUT_LMOUSE) { event.type = EVENT_LBUTTONUP; fillMouseEvent(event, _km.x, _km.y); } else if (ev.jbutton.button == JOY_BUT_RMOUSE) { event.type = EVENT_RBUTTONUP; fillMouseEvent(event, _km.x, _km.y); } else { event.type = EVENT_KEYUP; switch (ev.jbutton.button) { case JOY_BUT_ESCAPE: event.kbd.keycode = SDLK_ESCAPE; event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0); break; case JOY_BUT_PERIOD: event.kbd.keycode = SDLK_PERIOD; event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0); break; case JOY_BUT_SPACE: event.kbd.keycode = SDLK_SPACE; event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0); break; case JOY_BUT_F5: event.kbd.keycode = SDLK_F5; event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0); break; } } return true; case SDL_JOYAXISMOTION: axis = ev.jaxis.value; if ( axis > JOY_DEADZONE) { axis -= JOY_DEADZONE; event.type = EVENT_MOUSEMOVE; } else if ( axis < -JOY_DEADZONE ) { axis += JOY_DEADZONE; event.type = EVENT_MOUSEMOVE; } else axis = 0; if ( ev.jaxis.axis == JOY_XAXIS) { #ifdef JOY_ANALOG _km.x_vel = axis/2000; _km.x_down_count = 0; #else if (axis != 0) { _km.x_vel = (axis > 0) ? 1:-1; _km.x_down_count = 1; } else { _km.x_vel = 0; _km.x_down_count = 0; } #endif } else if (ev.jaxis.axis == JOY_YAXIS) { #ifndef JOY_INVERT_Y axis = -axis; #endif #ifdef JOY_ANALOG _km.y_vel = -axis / 2000; _km.y_down_count = 0; #else if (axis != 0) { _km.y_vel = (-axis > 0) ? 1: -1; _km.y_down_count = 1; } else { _km.y_vel = 0; _km.y_down_count = 0; } #endif } fillMouseEvent(event, _km.x, _km.y); return true; case SDL_VIDEOEXPOSE: _forceFull = true; break; case SDL_QUIT: event.type = EVENT_QUIT; return true; } } return false; }
/* doIdle - The idle-function that can be used to update the screen */ void doIdle() { if (g_bRayTrace) { g_ScreenBuffer[g_Y][g_X] = g_RayTrace.CalculatePixel (g_X, g_Y); //printf ("Drawing %d, %d\n", g_X, g_Y); // Move to the next pixel g_X++; if (g_X >= Scene::WINDOW_WIDTH) { // Move to the next row g_X = 0; g_Y++; /* You can uncomment the next line to see the raytrace "in-action" */ glutPostRedisplay(); } // Check for the end of the screen if (g_Y >= Scene::WINDOW_HEIGHT) { g_bRayTrace = false; glutPostRedisplay (); if (recording) { // ** Save frame std::string fileName ("frame_" + std::to_string(frame) +".jpg"); char *file = const_cast<char*>(fileName.c_str()); saveScreenshot(file); ++frame; // ** Move to the next position Vector dir = g_RayTrace.m_Scene.m_Camera.GetTarget() - g_RayTrace.m_Scene.m_Camera.GetPosition(); float tar_posDist = dir.Magnitude(); dir.Normalize(); Vector right = dir.Cross(g_RayTrace.m_Scene.m_Camera.GetUp()); Vector tempVec; float turnSpeed = 0.01f; // - Turn Left - // Simulate a Left-Turn by finding a position just a little to the left of the direction tempVec = dir - right * turnSpeed; tempVec.Normalize(); g_RayTrace.m_Scene.m_Camera.SetTarget(g_RayTrace.m_Scene.m_Camera.GetPosition() + tempVec * tar_posDist); // ** Start rendering again g_X = 0; g_Y = 0; g_bRayTrace = true; // ** Finish check if (frame > 650) { recording = false; g_bRayTrace = false; } } } } else { glutPostRedisplay (); } }
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) { switch ((int)event.type) { case Common::EVENT_KEYDOWN: if (event.kbd.hasFlags(Common::KBD_ALT)) { // Alt-Return and Alt-Enter toggle full screen mode if (event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { toggleFullScreen(0); return true; } // Alt-S create a screenshot if (event.kbd.keycode == 's') { char filename[20]; for (int n = 0;; n++) { SDL_RWops *file; sprintf(filename, "scummvm%05d.bmp", n); file = SDL_RWFromFile(filename, "r"); if (!file) break; SDL_RWclose(file); } if (saveScreenshot(filename)) debug("Saved screenshot '%s'", filename); else warning("Could not save screenshot"); return true; } } if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_ALT)) { // Ctrl-Alt-Return and Ctrl-Alt-Enter switch between full screen modes if (event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { toggleFullScreen(1); return true; } // Ctrl-Alt-a switch between display modes if (event.kbd.keycode == 'a') { beginGFXTransaction(); setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection)); endGFXTransaction(); #ifdef USE_OSD char buffer[128]; if (getFeatureState(OSystem::kFeatureAspectRatioCorrection)) sprintf(buffer, "Enabled aspect ratio correction\n%d x %d -> %d x %d", _videoMode.screenWidth, _videoMode.screenHeight, _hwscreen->w, _hwscreen->h); else sprintf(buffer, "Disabled aspect ratio correction\n%d x %d -> %d x %d", _videoMode.screenWidth, _videoMode.screenHeight, _hwscreen->w, _hwscreen->h); displayMessageOnOSD(buffer); #endif internUpdateScreen(); return true; } // Ctrl-Alt-f toggles antialiasing if (event.kbd.keycode == 'f') { beginGFXTransaction(); toggleAntialiasing(); endGFXTransaction(); #ifdef USE_OSD // TODO: This makes guesses about what internal antialiasing // modes we use, we might want to consider a better way of // displaying information to the user. if (getAntialiasingState()) displayMessageOnOSD("Active filter mode: Linear"); else displayMessageOnOSD("Active filter mode: Nearest"); #endif return true; } SDLKey sdlKey = (SDLKey)event.kbd.keycode; // Ctrl+Alt+Plus/Minus Increase/decrease the scale factor if ((sdlKey == SDLK_EQUALS || sdlKey == SDLK_PLUS || sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_PLUS || sdlKey == SDLK_KP_MINUS)) { int factor = getScale(); factor += (sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_MINUS) ? -1 : +1; if (0 < factor && factor < 4) { // Check if the desktop resolution has been detected if (_desktopWidth > 0 && _desktopHeight > 0) // If the new scale factor is too big, do not scale if (_videoMode.screenWidth * factor > _desktopWidth || _videoMode.screenHeight * factor > _desktopHeight) return false; beginGFXTransaction(); setScale(factor); endGFXTransaction(); #ifdef USE_OSD displayScaleChangedMsg(); #endif return true; } } const bool isNormalNumber = (SDLK_1 <= sdlKey && sdlKey <= SDLK_3); const bool isKeypadNumber = (SDLK_KP1 <= sdlKey && sdlKey <= SDLK_KP3); // Ctrl-Alt-<number key> will change the GFX mode if (isNormalNumber || isKeypadNumber) { if (sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1) <= 3) { #ifdef USE_OSD int lastMode = _videoMode.mode; #endif // We need to query the scale and set it up, because // setGraphicsMode sets the default scale to 2 int oldScale = getScale(); beginGFXTransaction(); setGraphicsMode(sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1)); setScale(oldScale); endGFXTransaction(); #ifdef USE_OSD if (lastMode != _videoMode.mode) displayModeChangedMsg(); #endif internUpdateScreen(); } } } if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_SHIFT)) { // Ctrl-Shift-Return and Ctrl-Shift-Enter switch backwards between full screen modes if (event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { toggleFullScreen(-1); return true; } } break; case Common::EVENT_KEYUP: return isHotkey(event); // HACK: Handle special SDL event // The new screen size is saved on the mouse event as part of HACK, // there is no common resize event. case OSystem_SDL::kSdlEventResize: // Do not resize if ignoring resize events. if (!_ignoreResizeFrames && !getFullscreenMode()) { bool scaleChanged = false; beginGFXTransaction(); _videoMode.hardwareWidth = event.mouse.x; _videoMode.hardwareHeight = event.mouse.y; if (_videoMode.mode != OpenGL::GFX_ORIGINAL) { _screenResized = true; calculateDisplaySize(_videoMode.hardwareWidth, _videoMode.hardwareHeight); } int scale = MIN(_videoMode.hardwareWidth / _videoMode.screenWidth, _videoMode.hardwareHeight / _videoMode.screenHeight); if (getScale() != scale) { scaleChanged = true; setScale(MAX(MIN(scale, 3), 1)); } if (_videoMode.mode == OpenGL::GFX_ORIGINAL) { calculateDisplaySize(_videoMode.hardwareWidth, _videoMode.hardwareHeight); } _transactionDetails.sizeChanged = true; endGFXTransaction(); #ifdef USE_OSD if (scaleChanged) displayScaleChangedMsg(); #endif } return true; default: break; } return OpenGLGraphicsManager::notifyEvent(event); }
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) { switch ((int)event.type) { case Common::EVENT_KEYDOWN: if (event.kbd.hasFlags(Common::KBD_ALT)) { // Alt-Return and Alt-Enter toggle full screen mode if (event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { toggleFullScreen(0); return true; } // Alt-S create a screenshot if (event.kbd.keycode == 's') { char filename[20]; for (int n = 0;; n++) { SDL_RWops *file; sprintf(filename, "scummvm%05d.bmp", n); file = SDL_RWFromFile(filename, "r"); if (!file) break; SDL_RWclose(file); } if (saveScreenshot(filename)) printf("Saved '%s'\n", filename); else printf("Could not save screenshot!\n"); return true; } } if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_ALT)) { // Ctrl-Alt-Return and Ctrl-Alt-Enter switch between full screen modes if (event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { toggleFullScreen(1); return true; } // Ctrl-Alt-a switch between display modes if (event.kbd.keycode == 'a') { beginGFXTransaction(); switchDisplayMode(-1); endGFXTransaction(); #ifdef USE_OSD displayModeChangedMsg(); #endif internUpdateScreen(); return true; } // Ctrl-Alt-f toggles antialiasing if (event.kbd.keycode == 'f') { beginGFXTransaction(); _videoMode.antialiasing = !_videoMode.antialiasing; _transactionDetails.filterChanged = true; endGFXTransaction(); #ifdef USE_OSD if (_videoMode.antialiasing) displayMessageOnOSD("Active filter mode: Linear"); else displayMessageOnOSD("Active filter mode: Nearest"); #endif return true; } SDLKey sdlKey = (SDLKey)event.kbd.keycode; // Ctrl+Alt+Plus/Minus Increase/decrease the scale factor if ((sdlKey == SDLK_EQUALS || sdlKey == SDLK_PLUS || sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_PLUS || sdlKey == SDLK_KP_MINUS)) { int factor = _videoMode.scaleFactor; factor += (sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_MINUS) ? -1 : +1; if (0 < factor && factor < 4) { // Check if the desktop resolution has been detected if (_desktopWidth > 0 && _desktopHeight > 0) // If the new scale factor is too big, do not scale if (_videoMode.screenWidth * factor > _desktopWidth || _videoMode.screenHeight * factor > _desktopHeight) return false; beginGFXTransaction(); setScale(factor); endGFXTransaction(); #ifdef USE_OSD displayScaleChangedMsg(); #endif return true; } } const bool isNormalNumber = (SDLK_1 <= sdlKey && sdlKey <= SDLK_4); const bool isKeypadNumber = (SDLK_KP1 <= sdlKey && sdlKey <= SDLK_KP4); // Ctrl-Alt-<number key> will change the GFX mode if (isNormalNumber || isKeypadNumber) { if (sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1) <= 4) { int lastMode = _videoMode.mode; beginGFXTransaction(); _videoMode.mode = sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1); _transactionDetails.needRefresh = true; _aspectRatioCorrection = false; endGFXTransaction(); #ifdef USE_OSD if (lastMode != _videoMode.mode) displayModeChangedMsg(); #endif internUpdateScreen(); } } } if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_SHIFT)) { // Ctrl-Shift-Return and Ctrl-Shift-Enter switch backwards between full screen modes if (event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { toggleFullScreen(-1); return true; } // Ctrl-Shift-a switch backwards between display modes if (event.kbd.keycode == 'a') { beginGFXTransaction(); switchDisplayMode(-2); endGFXTransaction(); #ifdef USE_OSD displayModeChangedMsg(); #endif internUpdateScreen(); return true; } } break; case Common::EVENT_KEYUP: return isHotkey(event); // HACK: Handle special SDL event // The new screen size is saved on the mouse event as part of HACK, // there is no common resize event. case OSystem_SDL::kSdlEventResize: // Do not resize if ignoring resize events. if (!_ignoreResizeFrames && !_videoMode.fullscreen) { bool scaleChanged = false; beginGFXTransaction(); _videoMode.hardwareWidth = event.mouse.x; _videoMode.hardwareHeight = event.mouse.y; if (_videoMode.mode != OpenGL::GFX_ORIGINAL) { _screenResized = true; calculateDisplaySize(_videoMode.hardwareWidth, _videoMode.hardwareHeight); } int scale = MIN(_videoMode.hardwareWidth / _videoMode.screenWidth, _videoMode.hardwareHeight / _videoMode.screenHeight); if (_videoMode.scaleFactor != scale) { scaleChanged = true; _videoMode.scaleFactor = MAX(MIN(scale, 3), 1); } if (_videoMode.mode == OpenGL::GFX_ORIGINAL) { calculateDisplaySize(_videoMode.hardwareWidth, _videoMode.hardwareHeight); } _transactionDetails.sizeChanged = true; endGFXTransaction(); #ifdef USE_OSD if (scaleChanged) displayScaleChangedMsg(); #endif } return true; default: break; } return OpenGLGraphicsManager::notifyEvent(event); }
MainWindow::MainWindow() : QbWindow(config.geometry.mainWindow) { setObjectName("main-window"); setWindowTitle(utf8() << bsnesTitle << " v" << bsnesVersion); //menu bar #if defined(PLATFORM_OSX) menuBar = new QMenuBar(0); #else menuBar = new QMenuBar; #endif system = menuBar->addMenu("System"); system_load = system->addAction("Load Cartridge ..."); system_load->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial = system->addMenu("Load Special"); system_loadSpecial->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial_bsxSlotted = system_loadSpecial->addAction("Load BS-X Slotted Cartridge ..."); system_loadSpecial_bsxSlotted->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial_bsx = system_loadSpecial->addAction("Load BS-X Cartridge ..."); system_loadSpecial_bsx->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial_sufamiTurbo = system_loadSpecial->addAction("Load Sufami Turbo Cartridge ..."); system_loadSpecial_sufamiTurbo->setIcon(QIcon(":/16x16/document-open.png")); system_loadSpecial_superGameBoy = system_loadSpecial->addAction("Load Super Game Boy Cartridge ..."); system_loadSpecial_superGameBoy->setIcon(QIcon(":/16x16/document-open.png")); system->addSeparator(); system->addAction(system_power = new QbCheckAction("Power", 0)); system_reset = system->addAction("Reset"); system_reset->setIcon(QIcon(":/16x16/view-refresh.png")); system->addSeparator(); system_port1 = system->addMenu("Controller Port 1"); system_port1->setIcon(QIcon(":/16x16/input-gaming.png")); system_port1->addAction(system_port1_none = new QbRadioAction("None", 0)); system_port1->addAction(system_port1_joypad = new QbRadioAction("Joypad", 0)); system_port1->addAction(system_port1_multitap = new QbRadioAction("Multitap", 0)); system_port1->addAction(system_port1_mouse = new QbRadioAction("Mouse", 0)); system_port2 = system->addMenu("Controller Port 2"); system_port2->setIcon(QIcon(":/16x16/input-gaming.png")); system_port2->addAction(system_port2_none = new QbRadioAction("None", 0)); system_port2->addAction(system_port2_joypad = new QbRadioAction("Joypad", 0)); system_port2->addAction(system_port2_multitap = new QbRadioAction("Multitap", 0)); system_port2->addAction(system_port2_mouse = new QbRadioAction("Mouse", 0)); system_port2->addAction(system_port2_superscope = new QbRadioAction("Super Scope", 0)); system_port2->addAction(system_port2_justifier = new QbRadioAction("Justifier", 0)); system_port2->addAction(system_port2_justifiers = new QbRadioAction("Two Justifiers", 0)); #if !defined(PLATFORM_OSX) system->addSeparator(); #endif system_exit = system->addAction("Exit"); system_exit->setIcon(QIcon(":/16x16/process-stop.png")); system_exit->setMenuRole(QAction::QuitRole); settings = menuBar->addMenu("Settings"); settings_videoMode = settings->addMenu("Video Mode"); settings_videoMode->setIcon(QIcon(":/16x16/video-display.png")); settings_videoMode->addAction(settings_videoMode_1x = new QbRadioAction("Scale 1x", 0)); settings_videoMode->addAction(settings_videoMode_2x = new QbRadioAction("Scale 2x", 0)); settings_videoMode->addAction(settings_videoMode_3x = new QbRadioAction("Scale 3x", 0)); settings_videoMode->addAction(settings_videoMode_4x = new QbRadioAction("Scale 4x", 0)); settings_videoMode->addAction(settings_videoMode_max = new QbRadioAction("Scale Max", 0)); settings_videoMode->addSeparator(); settings_videoMode->addAction(settings_videoMode_correctAspectRatio = new QbCheckAction("Correct Aspect Ratio", 0)); settings_videoMode->addAction(settings_videoMode_fullscreen = new QbCheckAction("Fullscreen", 0)); settings_videoMode->addSeparator(); settings_videoMode->addAction(settings_videoMode_ntsc = new QbRadioAction("NTSC", 0)); settings_videoMode->addAction(settings_videoMode_pal = new QbRadioAction("PAL", 0)); if(filter.opened()) { settings_videoFilter = settings->addMenu("Video Filter"); settings_videoFilter->setIcon(QIcon(":/16x16/image-x-generic.png")); settings_videoFilter_configure = settings_videoFilter->addAction("Configure Active Filter ..."); settings_videoFilter_configure->setIcon(QIcon(":/16x16/preferences-desktop.png")); settings_videoFilter->addSeparator(); settings_videoFilter->addAction(settings_videoFilter_none = new QbRadioAction("None", 0)); settings_videoFilter_list.add(settings_videoFilter_none); lstring filterlist; filterlist.split(";", filter.dl_supported()); for(unsigned i = 0; i < filterlist.size(); i++) { QbRadioAction *action = new QbRadioAction(utf8() << filterlist[i], 0); settings_videoFilter->addAction(action); settings_videoFilter_list.add(action); } } settings->addAction(settings_smoothVideo = new QbCheckAction("Smooth Video Output", 0)); settings->addSeparator(); settings->addAction(settings_muteAudio = new QbCheckAction("Mute Audio Output", 0)); settings->addSeparator(); settings_emulationSpeed = settings->addMenu("Emulation Speed"); settings_emulationSpeed->setIcon(QIcon(":/16x16/appointment-new.png")); settings_emulationSpeed->addAction(settings_emulationSpeed_slowest = new QbRadioAction("50%", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_slow = new QbRadioAction("75%", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_normal = new QbRadioAction("100%", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_fast = new QbRadioAction("150%", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_fastest = new QbRadioAction("200%", 0)); settings_emulationSpeed->addSeparator(); settings_emulationSpeed->addAction(settings_emulationSpeed_syncVideo = new QbCheckAction("Sync Video", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_syncAudio = new QbCheckAction("Sync Audio", 0)); settings_configuration = settings->addAction("Configuration ..."); settings_configuration->setIcon(QIcon(":/16x16/preferences-desktop.png")); settings_configuration->setMenuRole(QAction::PreferencesRole); tools = menuBar->addMenu("Tools"); tools_cheatEditor = tools->addAction("Cheat Editor ..."); tools_cheatEditor->setIcon(QIcon(":/16x16/accessories-text-editor.png")); tools_cheatFinder = tools->addAction("Cheat Finder ..."); tools_cheatFinder->setIcon(QIcon(":/16x16/system-search.png")); tools_stateManager = tools->addAction("State Manager ..."); tools_stateManager->setIcon(QIcon(":/16x16/system-file-manager.png")); tools->addSeparator(); tools_captureScreenshot = tools->addAction("Capture Screenshot"); tools_captureScreenshot->setIcon(QIcon(":/16x16/image-x-generic.png")); tools_debugger = tools->addAction("Debugger ..."); tools_debugger->setIcon(QIcon(":/16x16/utilities-terminal.png")); #if !defined(DEBUGGER) tools_debugger->setVisible(false); #endif help = menuBar->addMenu("Help"); help_documentation = help->addAction("Documentation ..."); help_documentation->setIcon(QIcon(":/16x16/text-x-generic.png")); help_license = help->addAction("License ..."); help_license->setIcon(QIcon(":/16x16/text-x-generic.png")); #if !defined(PLATFORM_OSX) help->addSeparator(); #endif help_about = help->addAction("About ..."); help_about->setIcon(QIcon(":/16x16/help-browser.png")); help_about->setMenuRole(QAction::AboutRole); //canvas canvasContainer = new CanvasObject; canvasContainer->setAcceptDrops(true); { canvasContainer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); canvasContainer->setObjectName("backdrop"); canvasLayout = new QVBoxLayout; { canvasLayout->setMargin(0); canvasLayout->setAlignment(Qt::AlignCenter); canvas = new CanvasWidget; canvas->setAcceptDrops(true); canvas->setFocusPolicy(Qt::StrongFocus); canvas->setAttribute(Qt::WA_PaintOnScreen, true); //disable Qt painting on focus / resize QPalette palette; palette.setColor(QPalette::Window, QColor(0, 0, 0)); canvas->setPalette(palette); canvas->setAutoFillBackground(true); } canvasLayout->addWidget(canvas); } canvasContainer->setLayout(canvasLayout); //status bar statusBar = new QStatusBar; statusBar->showMessage(""); systemState = new QLabel; statusBar->addPermanentWidget(systemState); //layout layout = new QVBoxLayout; layout->setMargin(0); layout->setSpacing(0); #if !defined(PLATFORM_OSX) layout->addWidget(menuBar); #endif layout->addWidget(canvasContainer); layout->addWidget(statusBar); setLayout(layout); //slots connect(system_load, SIGNAL(triggered()), this, SLOT(loadCartridge())); connect(system_loadSpecial_bsxSlotted, SIGNAL(triggered()), this, SLOT(loadBsxSlottedCartridge())); connect(system_loadSpecial_bsx, SIGNAL(triggered()), this, SLOT(loadBsxCartridge())); connect(system_loadSpecial_sufamiTurbo, SIGNAL(triggered()), this, SLOT(loadSufamiTurboCartridge())); connect(system_loadSpecial_superGameBoy, SIGNAL(triggered()), this, SLOT(loadSuperGameBoyCartridge())); connect(system_power, SIGNAL(triggered()), this, SLOT(power())); connect(system_reset, SIGNAL(triggered()), this, SLOT(reset())); connect(system_port1_none, SIGNAL(triggered()), this, SLOT(setPort1None())); connect(system_port1_joypad, SIGNAL(triggered()), this, SLOT(setPort1Joypad())); connect(system_port1_multitap, SIGNAL(triggered()), this, SLOT(setPort1Multitap())); connect(system_port1_mouse, SIGNAL(triggered()), this, SLOT(setPort1Mouse())); connect(system_port2_none, SIGNAL(triggered()), this, SLOT(setPort2None())); connect(system_port2_joypad, SIGNAL(triggered()), this, SLOT(setPort2Joypad())); connect(system_port2_multitap, SIGNAL(triggered()), this, SLOT(setPort2Multitap())); connect(system_port2_mouse, SIGNAL(triggered()), this, SLOT(setPort2Mouse())); connect(system_port2_superscope, SIGNAL(triggered()), this, SLOT(setPort2SuperScope())); connect(system_port2_justifier, SIGNAL(triggered()), this, SLOT(setPort2Justifier())); connect(system_port2_justifiers, SIGNAL(triggered()), this, SLOT(setPort2Justifiers())); connect(system_exit, SIGNAL(triggered()), this, SLOT(quit())); connect(settings_videoMode_1x, SIGNAL(triggered()), this, SLOT(setVideoMode1x())); connect(settings_videoMode_2x, SIGNAL(triggered()), this, SLOT(setVideoMode2x())); connect(settings_videoMode_3x, SIGNAL(triggered()), this, SLOT(setVideoMode3x())); connect(settings_videoMode_4x, SIGNAL(triggered()), this, SLOT(setVideoMode4x())); connect(settings_videoMode_max, SIGNAL(triggered()), this, SLOT(setVideoModeMax())); connect(settings_videoMode_correctAspectRatio, SIGNAL(triggered()), this, SLOT(toggleAspectCorrection())); connect(settings_videoMode_fullscreen, SIGNAL(triggered()), this, SLOT(toggleFullscreen())); connect(settings_videoMode_ntsc, SIGNAL(triggered()), this, SLOT(setVideoNtsc())); connect(settings_videoMode_pal, SIGNAL(triggered()), this, SLOT(setVideoPal())); if(filter.opened()) { connect(settings_videoFilter_configure, SIGNAL(triggered()), this, SLOT(configureFilter())); for(unsigned i = 0; i < settings_videoFilter_list.size(); i++) { connect(settings_videoFilter_list[i], SIGNAL(triggered()), this, SLOT(setFilter())); } } connect(settings_smoothVideo, SIGNAL(triggered()), this, SLOT(toggleSmoothVideo())); connect(settings_muteAudio, SIGNAL(triggered()), this, SLOT(muteAudio())); connect(settings_emulationSpeed_slowest, SIGNAL(triggered()), this, SLOT(setSpeedSlowest())); connect(settings_emulationSpeed_slow, SIGNAL(triggered()), this, SLOT(setSpeedSlow())); connect(settings_emulationSpeed_normal, SIGNAL(triggered()), this, SLOT(setSpeedNormal())); connect(settings_emulationSpeed_fast, SIGNAL(triggered()), this, SLOT(setSpeedFast())); connect(settings_emulationSpeed_fastest, SIGNAL(triggered()), this, SLOT(setSpeedFastest())); connect(settings_emulationSpeed_syncVideo, SIGNAL(triggered()), this, SLOT(syncVideo())); connect(settings_emulationSpeed_syncAudio, SIGNAL(triggered()), this, SLOT(syncAudio())); connect(settings_configuration, SIGNAL(triggered()), this, SLOT(showConfigWindow())); connect(tools_cheatEditor, SIGNAL(triggered()), this, SLOT(showCheatEditor())); connect(tools_cheatFinder, SIGNAL(triggered()), this, SLOT(showCheatFinder())); connect(tools_stateManager, SIGNAL(triggered()), this, SLOT(showStateManager())); connect(tools_captureScreenshot, SIGNAL(triggered()), this, SLOT(saveScreenshot())); connect(tools_debugger, SIGNAL(triggered()), this, SLOT(showDebugger())); connect(help_documentation, SIGNAL(triggered()), this, SLOT(showDocumentation())); connect(help_license, SIGNAL(triggered()), this, SLOT(showLicense())); connect(help_about, SIGNAL(triggered()), this, SLOT(showAbout())); syncUi(); }
MainWindow::MainWindow() { setObjectName("main-window"); setWindowTitle(string() << SNES::Info::Name << " v" << SNES::Info::Version); setCloseOnEscape(false); setGeometryString(&config().geometry.mainWindow); application.windowList.append(this); //menu bar #if defined(PLATFORM_OSX) menuBar = new QMenuBar(0); #else menuBar = new QMenuBar; #endif system = menuBar->addMenu("&System"); system_load = system->addAction("Load &Cartridge ..."); system_loadSpecial = system->addMenu("Load &Special"); system_loadSpecial_bsx = system_loadSpecial->addAction("Load &BS-X Cartridge ..."); system_loadSpecial_bsxSlotted = system_loadSpecial->addAction("Load BS-X &Slotted Cartridge ..."); system_loadSpecial_sufamiTurbo = system_loadSpecial->addAction("Load Sufami &Turbo Cartridge ..."); system_loadSpecial_superGameBoy = system_loadSpecial->addAction("Load Super &Game Boy Cartridge ..."); system_saveMemoryPack = system->addAction("Save Memory Pack ..."); system_saveMemoryPack->setVisible(false); system_reload = system->addAction("Re&load"); system->addSeparator(); system->addAction(system_power = new CheckAction("&Power", 0)); system_reset = system->addAction("&Reset"); system->addSeparator(); system_port1 = system->addMenu("Controller Port &1"); system_port1->addAction(system_port1_none = new RadioAction("&None", 0)); system_port1->addAction(system_port1_gamepad = new RadioAction("&Gamepad", 0)); system_port1->addAction(system_port1_asciipad = new RadioAction("&asciiPad", 0)); system_port1->addAction(system_port1_multitap = new RadioAction("&Multitap", 0)); system_port1->addAction(system_port1_mouse = new RadioAction("&Mouse", 0)); system_port1->addAction(system_port1_nttdatakeypad = new RadioAction("NTT Data &Keypad", 0)); system_port2 = system->addMenu("Controller Port &2"); system_port2->addAction(system_port2_none = new RadioAction("&None", 0)); system_port2->addAction(system_port2_gamepad = new RadioAction("&Gamepad", 0)); system_port2->addAction(system_port2_asciipad = new RadioAction("&asciiPad", 0)); system_port2->addAction(system_port2_multitap = new RadioAction("&Multitap", 0)); system_port2->addAction(system_port2_mouse = new RadioAction("&Mouse", 0)); system_port2->addAction(system_port2_superscope = new RadioAction("&Super Scope", 0)); system_port2->addAction(system_port2_justifier = new RadioAction("&Justifier", 0)); system_port2->addAction(system_port2_justifiers = new RadioAction("Two &Justifiers", 0)); #if !defined(PLATFORM_OSX) system->addSeparator(); #endif system_exit = system->addAction("E&xit"); system_exit->setMenuRole(QAction::QuitRole); settings = menuBar->addMenu("S&ettings"); settings_videoMode = settings->addMenu("Video &Mode"); settings_videoMode->addAction(settings_videoMode_1x = new RadioAction("Scale &1x", 0)); settings_videoMode->addAction(settings_videoMode_2x = new RadioAction("Scale &2x", 0)); settings_videoMode->addAction(settings_videoMode_3x = new RadioAction("Scale &3x", 0)); settings_videoMode->addAction(settings_videoMode_4x = new RadioAction("Scale &4x", 0)); settings_videoMode->addAction(settings_videoMode_5x = new RadioAction("Scale &5x", 0)); settings_videoMode->addAction(settings_videoMode_max_normal = new RadioAction("Scale Max - &Normal", 0)); settings_videoMode->addAction(settings_videoMode_max_wide = new RadioAction("Scale Max - &Wide", 0)); settings_videoMode->addAction(settings_videoMode_max_wideZoom = new RadioAction("Scale Max - Wide &Zoom", 0)); settings_videoMode->addSeparator(); settings_videoMode->addAction(settings_videoMode_correctAspectRatio = new CheckAction("Correct &Aspect Ratio", 0)); settings_videoMode->addSeparator(); settings_videoMode->addAction(settings_videoMode_ntsc = new RadioAction("&NTSC", 0)); settings_videoMode->addAction(settings_videoMode_pal = new RadioAction("&PAL", 0)); if(filter.opened()) { settings_videoFilter = settings->addMenu("Video &Filter"); settings_videoFilter_configure = settings_videoFilter->addAction("&Configure Active Filter ..."); settings_videoFilter->addSeparator(); settings_videoFilter->addAction(settings_videoFilter_none = new RadioAction("&None", 0)); settings_videoFilter_list.append(settings_videoFilter_none); lstring filterlist; filterlist.split(";", filter.dl_supported()); for(unsigned i = 0; i < filterlist.size(); i++) { RadioAction *action = new RadioAction(filterlist[i], 0); settings_videoFilter->addAction(action); settings_videoFilter_list.append(action); } } settings->addAction(settings_smoothVideo = new CheckAction("&Smooth Video Output", 0)); settings->addSeparator(); settings->addAction(settings_muteAudio = new CheckAction("&Mute Audio Output", 0)); settings->addSeparator(); settings_emulationSpeed = settings->addMenu("Emulation &Speed"); settings_emulationSpeed->addAction(settings_emulationSpeed_slowest = new RadioAction("Slowest", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_slow = new RadioAction("Slow", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_normal = new RadioAction("Normal", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_fast = new RadioAction("Fast", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_fastest = new RadioAction("Fastest", 0)); settings_emulationSpeed->addSeparator(); settings_emulationSpeed->addAction(settings_emulationSpeed_syncVideo = new CheckAction("Sync &Video", 0)); settings_emulationSpeed->addAction(settings_emulationSpeed_syncAudio = new CheckAction("Sync &Audio", 0)); settings_configuration = settings->addAction("&Configuration ..."); settings_configuration->setMenuRole(QAction::PreferencesRole); tools = menuBar->addMenu("&Tools"); tools_movies = tools->addMenu("&Movies"); tools_movies_play = tools_movies->addAction("Play Movie ..."); tools_movies_stop = tools_movies->addAction("Stop"); tools_movies_recordFromPowerOn = tools_movies->addAction("Record Movie (and restart system)"); tools_movies_recordFromHere = tools_movies->addAction("Record Movie (starting from here)"); tools_captureScreenshot = tools->addAction("&Capture Screenshot"); tools_captureSPC = tools->addAction("Capture &SPC Dump"); tools->addSeparator(); tools_loadState = tools->addMenu("&Load Quick State"); for(unsigned i = 0; i < 10; i++) { QAction *loadAction = new QAction(string("Slot ", i + 1), 0); loadAction->setData(i); connect(loadAction, SIGNAL(triggered()), this, SLOT(loadState())); tools_loadState->addAction(loadAction); } tools_saveState = tools->addMenu("&Save Quick State"); for(unsigned i = 0; i < 10; i++) { QAction *saveAction = new QAction(string("Slot ", i + 1), 0); saveAction->setData(i); connect(saveAction, SIGNAL(triggered()), this, SLOT(saveState())); tools_saveState->addAction(saveAction); } tools->addSeparator(); tools_cheatEditor = tools->addAction("Cheat &Editor ..."); tools_cheatFinder = tools->addAction("Cheat &Finder ..."); tools_stateManager = tools->addAction("&State Manager ..."); tools_effectToggle = tools->addAction("Effect &Toggle ..."); if(!SNES::PPU::SupportsLayerEnable && !SNES::DSP::SupportsChannelEnable) tools_effectToggle->setVisible(false); tools_manifestViewer = tools->addAction("&Manifest Viewer ..."); tools_soundViewer = tools->addAction("Sound &Viewer ..."); tools_debugger = tools->addAction("&Debugger ..."); #if !defined(DEBUGGER) tools_debugger->setVisible(false); #endif help = menuBar->addMenu("&Help"); help_documentation = help->addAction("&Documentation ..."); help_license = help->addAction("&License ..."); #if !defined(PLATFORM_OSX) help->addSeparator(); #endif help_about = help->addAction("&About ..."); help_about->setMenuRole(QAction::AboutRole); //canvas canvasContainer = new CanvasObject; canvasContainer->setAcceptDrops(true); { canvasContainer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); canvasContainer->setObjectName("backdrop"); canvasLayout = new QVBoxLayout; { canvasLayout->setMargin(0); canvasLayout->setAlignment(Qt::AlignCenter); canvas = new CanvasWidget; canvas->setAcceptDrops(true); canvas->setFocusPolicy(Qt::StrongFocus); canvas->setAttribute(Qt::WA_PaintOnScreen, true); //disable Qt painting on focus / resize canvas->setAttribute(Qt::WA_NoSystemBackground, true); } canvasLayout->addWidget(canvas); } canvasContainer->setLayout(canvasLayout); //status bar statusBar = new QStatusBar; statusBar->setSizeGripEnabled(false); statusBar->showMessage(""); systemState = new QLabel; statusBar->addPermanentWidget(systemState); //layout layout = new QVBoxLayout; layout->setMargin(0); layout->setSpacing(0); #if !defined(PLATFORM_OSX) layout->addWidget(menuBar); #endif layout->addWidget(canvasContainer); layout->addWidget(statusBar); setLayout(layout); //cursor hide timer cursorTimer = new QTimer(this); cursorTimer->setSingleShot(true); cursorTimer->setInterval(5*1000); //slots connect(system_load, SIGNAL(triggered()), this, SLOT(loadCartridge())); connect(system_reload, SIGNAL(triggered()), this, SLOT(reloadCartridge())); connect(system_loadSpecial_bsxSlotted, SIGNAL(triggered()), this, SLOT(loadBsxSlottedCartridge())); connect(system_loadSpecial_bsx, SIGNAL(triggered()), this, SLOT(loadBsxCartridge())); connect(system_loadSpecial_sufamiTurbo, SIGNAL(triggered()), this, SLOT(loadSufamiTurboCartridge())); connect(system_loadSpecial_superGameBoy, SIGNAL(triggered()), this, SLOT(loadSuperGameBoyCartridge())); connect(system_saveMemoryPack, SIGNAL(triggered()), this, SLOT(saveMemoryPack())); connect(system_power, SIGNAL(triggered()), this, SLOT(power())); connect(system_reset, SIGNAL(triggered()), this, SLOT(reset())); connect(system_port1_none, SIGNAL(triggered()), this, SLOT(setPort1None())); connect(system_port1_gamepad, SIGNAL(triggered()), this, SLOT(setPort1Gamepad())); connect(system_port1_asciipad, SIGNAL(triggered()), this, SLOT(setPort1Asciipad())); connect(system_port1_multitap, SIGNAL(triggered()), this, SLOT(setPort1Multitap())); connect(system_port1_mouse, SIGNAL(triggered()), this, SLOT(setPort1Mouse())); connect(system_port1_nttdatakeypad, SIGNAL(triggered()), this, SLOT(setPort1NTTDataKeypad())); connect(system_port2_none, SIGNAL(triggered()), this, SLOT(setPort2None())); connect(system_port2_gamepad, SIGNAL(triggered()), this, SLOT(setPort2Gamepad())); connect(system_port2_asciipad, SIGNAL(triggered()), this, SLOT(setPort2Asciipad())); connect(system_port2_multitap, SIGNAL(triggered()), this, SLOT(setPort2Multitap())); connect(system_port2_mouse, SIGNAL(triggered()), this, SLOT(setPort2Mouse())); connect(system_port2_superscope, SIGNAL(triggered()), this, SLOT(setPort2SuperScope())); connect(system_port2_justifier, SIGNAL(triggered()), this, SLOT(setPort2Justifier())); connect(system_port2_justifiers, SIGNAL(triggered()), this, SLOT(setPort2Justifiers())); connect(system_exit, SIGNAL(triggered()), this, SLOT(quit())); connect(settings_videoMode_1x, SIGNAL(triggered()), this, SLOT(setVideoMode1x())); connect(settings_videoMode_2x, SIGNAL(triggered()), this, SLOT(setVideoMode2x())); connect(settings_videoMode_3x, SIGNAL(triggered()), this, SLOT(setVideoMode3x())); connect(settings_videoMode_4x, SIGNAL(triggered()), this, SLOT(setVideoMode4x())); connect(settings_videoMode_5x, SIGNAL(triggered()), this, SLOT(setVideoMode5x())); connect(settings_videoMode_max_normal, SIGNAL(triggered()), this, SLOT(setVideoModeMaxNormal())); connect(settings_videoMode_max_wide, SIGNAL(triggered()), this, SLOT(setVideoModeMaxWide())); connect(settings_videoMode_max_wideZoom, SIGNAL(triggered()), this, SLOT(setVideoModeMaxWideZoom())); connect(settings_videoMode_correctAspectRatio, SIGNAL(triggered()), this, SLOT(toggleAspectCorrection())); connect(settings_videoMode_ntsc, SIGNAL(triggered()), this, SLOT(setVideoNtsc())); connect(settings_videoMode_pal, SIGNAL(triggered()), this, SLOT(setVideoPal())); if(filter.opened()) { connect(settings_videoFilter_configure, SIGNAL(triggered()), this, SLOT(configureFilter())); for(unsigned i = 0; i < settings_videoFilter_list.size(); i++) { connect(settings_videoFilter_list[i], SIGNAL(triggered()), this, SLOT(setFilter())); } } connect(settings_smoothVideo, SIGNAL(triggered()), this, SLOT(toggleSmoothVideo())); connect(settings_muteAudio, SIGNAL(triggered()), this, SLOT(muteAudio())); connect(settings_emulationSpeed_slowest, SIGNAL(triggered()), this, SLOT(setSpeedSlowest())); connect(settings_emulationSpeed_slow, SIGNAL(triggered()), this, SLOT(setSpeedSlow())); connect(settings_emulationSpeed_normal, SIGNAL(triggered()), this, SLOT(setSpeedNormal())); connect(settings_emulationSpeed_fast, SIGNAL(triggered()), this, SLOT(setSpeedFast())); connect(settings_emulationSpeed_fastest, SIGNAL(triggered()), this, SLOT(setSpeedFastest())); connect(settings_emulationSpeed_syncVideo, SIGNAL(triggered()), this, SLOT(syncVideo())); connect(settings_emulationSpeed_syncAudio, SIGNAL(triggered()), this, SLOT(syncAudio())); connect(settings_configuration, SIGNAL(triggered()), this, SLOT(showConfigWindow())); connect(tools_movies_play, SIGNAL(triggered()), this, SLOT(playMovie())); connect(tools_movies_stop, SIGNAL(triggered()), this, SLOT(stopMovie())); connect(tools_movies_recordFromPowerOn, SIGNAL(triggered()), this, SLOT(recordMovieFromPowerOn())); connect(tools_movies_recordFromHere, SIGNAL(triggered()), this, SLOT(recordMovieFromHere())); connect(tools_captureScreenshot, SIGNAL(triggered()), this, SLOT(saveScreenshot())); connect(tools_captureSPC, SIGNAL(triggered()), this, SLOT(saveSPC())); connect(tools_cheatEditor, SIGNAL(triggered()), this, SLOT(showCheatEditor())); connect(tools_cheatFinder, SIGNAL(triggered()), this, SLOT(showCheatFinder())); connect(tools_stateManager, SIGNAL(triggered()), this, SLOT(showStateManager())); connect(tools_effectToggle, SIGNAL(triggered()), this, SLOT(showEffectToggle())); connect(tools_manifestViewer, SIGNAL(triggered()), this, SLOT(showManifestViewer())); connect(tools_soundViewer, SIGNAL(triggered()), this, SLOT(showSoundViewer())); connect(tools_debugger, SIGNAL(triggered()), this, SLOT(showDebugger())); connect(help_documentation, SIGNAL(triggered()), this, SLOT(showDocumentation())); connect(help_license, SIGNAL(triggered()), this, SLOT(showLicense())); connect(help_about, SIGNAL(triggered()), this, SLOT(showAbout())); syncUi(); }
int RunGLTest (void) { #ifdef GL int mm=1; #else int mm = 0; #endif int mode=0; cam.x=0; cam.y=0; int bpp; int w = 200; int h = 200; int done = 0; int shrink=0; int grow=0; int gofullscreen=0; int mustresize = 1; int justresized = 0; xy ss = parsemodes(w,h,"mode",1,0,0); printf("wtf\n"); if (ss.x!=-1){w=ss.x;h=ss.y;}; SDL_Surface* s; #ifdef GL s=initsdl(w,h,&bpp,SDL_OPENGL #else gltextsdlsurface=s=initsdl(w,h,&bpp, #endif +0);printf("inito\n"); SDL_InitSubSystem( SDL_INIT_TIMER); SDL_EnableUNICODE(1); SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY/2, SDL_DEFAULT_REPEAT_INTERVAL*2); #ifdef GL newtermmsg=GetFileIntoCharPointer1("newtermmsg"); printf("pretty far\n"); wm(w,h); int down=0; glEnable(GL_BLEND); glShadeModel(GL_FLAT); glBlendFunc(GL_SRC_ALPHA, GL_ONE); glClearColor( 0.0, 0.0, 0.04, 0.0 ); glLineWidth(lv); #else gltextsdlsurface=s; #endif roteface *face1; roteface *activeface; face1=add_face(); activeface =face1 ; face1->next=add_face(); printf("still?\n"); add_terminal(face1); printf("2threaad\n"); loadl2(); struct state *nerv=0; #ifdef nerve nerv=nerverot_init(w,h); #endif int dirty=1; printf("mainloop descent commencing\n"); while( !done ) { lockterms(face1); if(dirty||faces_dirty(face1)) { dirty=0; facesclean(face1); #ifdef GL glClear(GL_COLOR_BUFFER_BIT); #else SDL_FillRect ( s, NULL, 0 ); #endif #ifndef GL #else if(nerv) { shownerv(nerv); dirty=1; } glPushMatrix(); glScalef(sx,sy,0.004); glTranslatef(cam.x,cam.y,0); #endif Uint8 * k; int integer; k=SDL_GetKeyState(&integer); if(k[SDLK_RCTRL]) focusline(activeface); int nf; switch(mode) { case 0: showfaces(face1); break; #ifdef GL case 1: krychlus(face1); break; #endif } #ifdef GL glPopMatrix(); #endif #ifndef GL SDL_UpdateRect(s,0,0,0,0); #else SDL_GL_SwapBuffers( ); #endif facesclean(face1); } #ifdef GL GLenum gl_error; gl_error = glGetError( ); if( gl_error != GL_NO_ERROR ) { if(gl_error==GL_STACK_OVERFLOW) printf("QUACK QUACK QUACK, OVERFLOVING STACK\n"); else if(gl_error==GL_INVALID_OPERATION) printf("INVALID OPERATION, PATIENT EXPLODED\n"); else fprintf( stderr, "testgl: OpenGL error: %d\n", gl_error ); } #endif char* sdl_error; sdl_error = SDL_GetError( ); if( sdl_error[0] != '\0' ) { fprintf(stderr, "testgl: SDL error '%s'\n", sdl_error); SDL_ClearError(); } SDL_TimerID x=0; if(dirty) x= SDL_AddTimer(55, NewTimerCallback, 0); unlockterms(face1); // printf("---------unlocked wating\n"); SDL_Event event; if(SDL_WaitEvent( &event )) { lockterms(face1); // printf("---------locked goooin %i\n", event.type); if(x)SDL_RemoveTimer(x);x=0; do { int mod=event.key.keysym.mod; int key=event.key.keysym.sym; Uint8 *keystate = SDL_GetKeyState(NULL); switch( event.type ) { #ifdef GL case SDL_MOUSEMOTION: if((SDL_BUTTON(1)|SDL_BUTTON(2))&SDL_GetMouseState(0,0)) { activeface->x+=event.motion.xrel; activeface->y+=event.motion.yrel; } if((SDL_BUTTON(3)|SDL_BUTTON(2))&SDL_GetMouseState(0,0)) { cam.x-=event.motion.xrel; cam.y-=event.motion.yrel; } break; #endif case SDL_KEYUP: { if ( (key == SDLK_RCTRL) ) { dirty=1; } } break; case SDL_KEYDOWN: if(mod&KMOD_RSHIFT&&(key==SDLK_PAGEUP||key==SDLK_PAGEDOWN)) { if(key==SDLK_PAGEUP) tscroll+=9; if(key==SDLK_PAGEDOWN) tscroll-=9; if(tscroll<0)tscroll=0; // printf("scroll:%i,logl:%i, log&%i, t:%i ,b:%i\n", tscroll,activeface->t->logl, activeface->t->log,activeface->t->scrolltop,activeface->t->scrollbottom); } else if(key==SDLK_RCTRL||mod&KMOD_RCTRL) { dirty=1; switch (key) { case SDLK_TAB: cycle(face1, &activeface); break; case SDLK_F2: gofullscreen=1; break; case SDLK_F3: rastio+=0.05; mustresize=1; dirty=1; break; case SDLK_F4: rastio-=0.05; mustresize=1; dirty=1; break; case SDLK_F5: sx-=0.001; sy+=0.001; break; case SDLK_F6: sx+=0.001; sy-=0.001; break; case SDLK_F7: savemode(w,h); break; case SDLK_F8: loadl2(); break; case SDLK_p: saveScreenshot(); break; #ifdef GL case SDLK_F9: lv-=1; glLineWidth(lv); break; case SDLK_F10: lv+=1; glLineWidth(lv); break; #endif case SDLK_F11: shrink=1; break; case SDLK_F12: grow=1; break; case SDLK_PAGEUP: mode++; if(mode>mm)mode= mm; break; case SDLK_INSERT: mode--; if(mode<0)mode= 0; break; case SDLK_END: resizooo(activeface, 0,1,keystate); break; case SDLK_HOME: resizooo(activeface, 0,-1,keystate); break; case SDLK_DELETE: resizooo(activeface, -1,0,keystate); break; case SDLK_PAGEDOWN: resizooo(activeface, 1,0,keystate); break; #ifdef nerve case SDLK_F1: if(nerv) { nerverot_free(nerv); dirty=1; nerv=0; } else { nerv=nerverot_init(w,h); dirty=1; } break; #endif } } else { if(activeface->t==0) { printf("debug messages r fun\n"); add_terminal(activeface); activeface->next=add_face(); } if ( (key >= SDLK_F1) && (key <= SDLK_F15) ) { char *k; if(asprintf(&k ,"kf%i", key-SDLK_F1+1)!=-1) { rote_vt_terminfo(activeface->t, k); free(k); } } else if ( (key == SDLK_SPACE) ) keyp(activeface,32); else #define magic(x) rote_vt_terminfo(activeface->t, x ) if ( (key == SDLK_BACKSPACE) ) magic( "kbs"); else if ( (key == SDLK_ESCAPE) ) keyp(activeface,27); else if ( (key == SDLK_LEFT) ) magic("kcub1"); else if ( (key == SDLK_RIGHT) ) magic( "kcuf1"); else if ( (key == SDLK_UP) ) magic( "kcuu1"); else if ( (key == SDLK_DOWN) ) magic( "kcud1"); else if ( (key == SDLK_END) ) magic( "kend"); else if ( (key == SDLK_HOME) ) magic("khome"); else if ( (key == SDLK_DELETE) ) magic( "kdch1"); else if ( (key == SDLK_PAGEDOWN) ) magic( "knp"); else if ( (key == SDLK_INSERT) ) magic( "kich1"); else if ( (key == SDLK_PAGEUP) ) magic ( "kpp" ); else if ( (key == SDLK_RETURN) ) keyp(activeface,10); else if( event.key.keysym.unicode && ( (event.key.keysym.unicode & 0xFF80) == 0 ) ) keyp(activeface, event.key.keysym.unicode); } break; case SDL_QUIT: done = 1; break; #ifndef GL case SDL_MOUSEBUTTONDOWN: rote_vt_mousedown(activeface->t,event.button.x/13, event.button.y/26); break; case SDL_MOUSEBUTTONUP: rote_vt_mouseup (activeface->t,event.button.x/13, event.button.y/26); break; case SDL_MOUSEMOTION: rote_vt_mousemove(activeface->t,event.button.x/13, event.button.y/26); break; #endif case SDL_VIDEORESIZE: { w=event.resize.w;h=event.resize.h; // printf("videoresize %i %i\n", w,h); dirty=1; if (s=SDL_SetVideoMode( w,h, bpp, s->flags ) ) // printf("hmm\n"); wm(w,h); if(!justresized) mustresize=1; justresized=0; } break; case SDL_USEREVENT: if(event.user.code==1) RemoveTerm(&activeface,&face1, event.user.data1); break; } } while (SDL_PollEvent(&event)); if (shrink||grow) { resize(&w,&h,&bpp,&s->flags,&shrink,&grow); wm(w,h); } if (mustresize) { mustresize=0; justresized=1; // if(activeface->t->cols!=event.resize.w/13/rastio|| // activeface->t->rows!=event.resize.h/26/rastio) //rote_vt_resize(activeface->t,event.resize.h/26/rastio ,event.resize.w/13/rastio); } if(gofullscreen) if(s->flags & SDL_FULLSCREEN ) { s=SDL_SetVideoMode( w,h, bpp, (s->flags & ~SDL_FULLSCREEN )); } else s=SDL_SetVideoMode( w,h, bpp, (s->flags | SDL_FULLSCREEN )); gofullscreen=0; unlockterms(face1); } } SDL_Quit( ); return(0); }
void idle(void*) { if (previousPlayButtonStatus == ON) { // it means we should measure the interval between two frames // if it is too tiny, we should slow down the motion performanceCounter.StopCounter(); double actualTimeCostOneFrame = performanceCounter.GetElapsedTime(); // in seconds // time spent on saving the screen in previous time-step should be excluded if (saveFileTimeCost > 0.0) actualTimeCostOneFrame -= saveFileTimeCost; framesIncrementDoublePrecision = actualTimeCostOneFrame * expectedFPS; } // start counter at the beginning of the new round if (playButton == ON) performanceCounter.StartCounter(); if(rewindButton == ON) { currentFrameIndex = 0; currentFrameIndexDoublePrecision = 0.0; for (int i = 0; i < displayer.GetNumSkeletons(); i++) { if (displayer.GetSkeletonMotion(i) != NULL) { Posture * initSkeleton = displayer.GetSkeletonMotion(i)->GetPosture(0); displayer.GetSkeleton(i)->setPosture(*initSkeleton); } } rewindButton = OFF; } // Initialization saveFileTimeCost = -1.0; if(playButton == ON) { if (saveScreenToFile == SAVE_CONTINUOUS) { saveFileTimeCounter.StartCounter(); CreateScreenFilename(SAVE_CONTINUOUS, saveScreenToFileContinuousCount, saveScreenToFileContinuousFilename); saveScreenshot(640, 480, saveScreenToFileContinuousFilename); printf("%s is saved to disk.\n", saveScreenToFileContinuousFilename); saveScreenToFileContinuousCount++; saveFileTimeCounter.StopCounter(); saveFileTimeCost = saveFileTimeCounter.GetElapsedTime(); } if (saveScreenToFile == SAVE_CONTINUOUS) { currentFrameIndexDoublePrecision += 1.0; } else { currentFrameIndexDoublePrecision += framesIncrementDoublePrecision; } currentFrameIndex = (int)currentFrameIndexDoublePrecision; if(currentFrameIndex >= maxFrames) { if (repeatButton == ON) { currentFrameIndex = 0; currentFrameIndexDoublePrecision = 0.0; } else // repeat button is OFF { currentFrameIndex = maxFrames - 1; currentFrameIndexDoublePrecision = currentFrameIndex; playButton = OFF; // important, especially in "recording" mode } } if (currentFrameIndex < 0) { currentFrameIndex = 0; currentFrameIndexDoublePrecision = 0.0; } SetSkeletonsToSpecifiedFrame(currentFrameIndex); frame_slider->value((double) currentFrameIndex + 1); } // if(playButton == ON) if (minusOneButton == ON) if (displayer.GetNumSkeletons() != 0) { currentFrameIndex--; if (currentFrameIndex < 0) currentFrameIndex = 0; frame_slider->value((double) currentFrameIndex + 1); SetSkeletonsToSpecifiedFrame(currentFrameIndex); if (saveScreenToFile == SAVE_CONTINUOUS) { CreateScreenFilename(SAVE_CONTINUOUS, saveScreenToFileContinuousCount, saveScreenToFileContinuousFilename); saveScreenshot(640, 480, saveScreenToFileContinuousFilename); printf("%s is saved to disk.\n", saveScreenToFileContinuousFilename); saveScreenToFileContinuousCount++; } minusOneButton = OFF; } if (plusOneButton == ON) { if (displayer.GetNumSkeletons() != 0) { currentFrameIndex++; if (currentFrameIndex >= maxFrames) currentFrameIndex = maxFrames - 1; frame_slider->value((double) currentFrameIndex + 1); SetSkeletonsToSpecifiedFrame(currentFrameIndex); if (saveScreenToFile == SAVE_CONTINUOUS) { CreateScreenFilename(SAVE_CONTINUOUS, saveScreenToFileContinuousCount, saveScreenToFileContinuousFilename); saveScreenshot(640, 480, saveScreenToFileContinuousFilename); printf("%s is saved to disk.\n", saveScreenToFileContinuousFilename); saveScreenToFileContinuousCount++; } plusOneButton = OFF; } } frame_slider->value((double)(currentFrameIndex + 1)); previousPlayButtonStatus = playButton; // Super important updating glwindow->redraw(); }
void MedeaTwoSunsWorldObserver::step() { if ( gWorld->getIterations() % ( int(MedeaTwoSunsSharedData::gEvaluationTime * MedeaTwoSunsSharedData::gSunLifetime) ) == 0 ) { gEnergyPoints[MedeaTwoSunsSharedData::gActiveSun].hide(); MedeaTwoSunsSharedData::gActiveSun = ( MedeaTwoSunsSharedData::gActiveSun + 1 ) % 2; std::cout << "\nActive Sun #" << MedeaTwoSunsSharedData::gActiveSun << "\n"; gEnergyPoints[MedeaTwoSunsSharedData::gActiveSun].display(); } // *** // * update iteration and generation counters + switch btw experimental setups if required // *** _lifeIterationCount++; if( _lifeIterationCount >= MedeaTwoSunsSharedData::gEvaluationTime ) // go to next generation. { // * monitoring: count number of active agents. int activeCount = 0; for ( int i = 0 ; i != gAgentCounter ; i++ ) { if ( (dynamic_cast<MedeaTwoSunsAgentWorldModel*>(gWorld->getAgent(i)->getWorldModel()))->getActiveStatus() == true ) activeCount++; } if ( !gVerbose ) { std::cout << "[" << activeCount << "]"; } gLogFile << "Info(" << gWorld->getIterations() << ") : active count is " << activeCount << std::endl; // * monitor and log orientation and distance to center for all agents // build heatmap int heatmapSize = 100; // arbitrary, but should be enough to get precise view int maxDistance = sqrt ( gAreaWidth*gAreaWidth + gAreaHeight*gAreaHeight ) / 2.0 ; // distance max to center. int *distanceHeatmap; distanceHeatmap = new int[heatmapSize]; int *orientationHeatmap; orientationHeatmap = new int[heatmapSize]; for (int i = 0 ; i != heatmapSize ; i++ ) { distanceHeatmap[i] = 0; orientationHeatmap[i] = 0; } double xRef = gAreaWidth / 2.0 ; double yRef = gAreaHeight / 2.0 ; for ( int i = 0 ; i != gAgentCounter ; i++ ) { MedeaTwoSunsAgentWorldModel *wm = (dynamic_cast<MedeaTwoSunsAgentWorldModel*>(gWorld->getAgent(i)->getWorldModel())); if ( wm->getActiveStatus() == true ) // only active agents { // monitor distance double dist = getEuclidianDistance( xRef, yRef, wm->_xReal, wm->_yReal ); int indexDist = (int)dist * heatmapSize / maxDistance; // normalize within heatmap bounds distanceHeatmap[indexDist]++; // monitor orientationHeatmap double orient = acos ( ( wm->_xReal - xRef ) / (double)dist ); if ( wm->_yReal - yRef > 0 ) // [trick] why ">0" ? : it should be <0, but as the 2D-display norm for the coordinate system origin is upper-left (and not bottom-left), the sign is inversed. { orient = -orient; } int indexOrient = ( orient + M_PI ) * heatmapSize / (2.0 * M_PI); orientationHeatmap[heatmapSize-1-((indexOrient+((heatmapSize*3)/4))%heatmapSize)]++; // index is such that list ordering is as follow: [South-West-North-East-South] //std::cout << "\n agent[" << wm->_xReal << "," << wm->_yReal << "](" << dist << "," << orient << ") -- " << wm->_xReal << ";" << xRef << ";" << ( ( wm->_xReal - xRef ) / (double)dist ) << ";" << acos ( ( wm->_xReal - xRef ) / (double)dist ); //debug } } //std::cout << "\n"; //debug // update log file std::string str_agentDistancesToRef =""; std::string str_agentOrientationsToRef = ""; for (int i = 0 ; i != heatmapSize ; i++ ) { str_agentDistancesToRef += convertToString(distanceHeatmap[i]); str_agentDistancesToRef += ","; str_agentOrientationsToRef += convertToString(orientationHeatmap[i]); str_agentOrientationsToRef += ","; } //gLogFile //std::cout << std::endl << std::endl;//debug //gLogFile << "Info(" << gWorld->getIterations() << ") : monitor distance to ref - " << (_generationCount+1) << "," << gAgentCounter << "," << str_agentDistancesToRef << std::endl; //gLogFile << "Info(" << gWorld->getIterations() << ") : monitor orientation to ref - " << (_generationCount+1) << "," << gAgentCounter << "," << str_agentOrientationsToRef << std::endl; for ( int i = 0 ; i != heatmapSize ; i++ ) { gLogFile << "monitorDistance: " << gAgentCounter << "," << (int)sqrt(gMaxRadioDistanceToSquare) << "," << (_generationCount+1) << "," << i << "," << distanceHeatmap[i] << std::endl; gLogFile << "monitorOrientation: " << gAgentCounter << "," << (int)sqrt(gMaxRadioDistanceToSquare) << "," << (_generationCount+1) << "," << i << "," << orientationHeatmap[i] << std::endl; } //gLogFile << "Info(" << gWorld->getIterations() << ") : monitor distance to ref - " << (_generationCount+1) << "," << gAgentCounter << "," << str_agentDistancesToRef << std::endl; //gLogFile << "Info(" << gWorld->getIterations() << ") : monitor orientation to ref - " << (_generationCount+1) << "," << gAgentCounter << "," << str_agentOrientationsToRef << std::endl; delete [] distanceHeatmap; delete [] orientationHeatmap; // * update iterations and generations counters _lifeIterationCount = 0; _generationCount++; // * Switch btw experiment setups, if required updateExperimentalSettings(); } // * Update environment status wrt. nature and availability of energy resources (update at each iteration) updateEnvironmentResources(); // * update energy level for each agents (ONLY active agents) updateAllAgentsEnergyLevel(); // prepape and take screenshot of ultimate iteration if ( gWorld->getIterations() == gMaxIt-2 ) { gDisplayMode = 0; gDisplaySensors = true; // prepape for next it. } else { if ( gWorld->getIterations() == gMaxIt-1 ) saveScreenshot("lastIteration"); } }
void pcl::visualization::PCLVisualizerInteractorStyle::OnKeyDown () { if (!init_) { pcl::console::print_error ("[PCLVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n"); return; } if (!rens_) { pcl::console::print_error ("[PCLVisualizerInteractorStyle] No renderer collection given! Use SetRendererCollection () before continuing.\n"); return; } FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]); if (wif_->GetInput () == NULL) { wif_->SetInput (Interactor->GetRenderWindow ()); wif_->Modified (); snapshot_writer_->Modified (); } // Save the initial windows width/height if (win_height_ == -1 || win_width_ == -1) { int *win_size = Interactor->GetRenderWindow ()->GetSize (); win_height_ = win_size[0]; win_width_ = win_size[1]; } // Get the status of special keys (Cltr+Alt+Shift) bool shift = Interactor->GetShiftKey (); bool ctrl = Interactor->GetControlKey (); bool alt = Interactor->GetAltKey (); bool keymod = false; switch (modifier_) { case INTERACTOR_KB_MOD_ALT: { keymod = alt; break; } case INTERACTOR_KB_MOD_CTRL: { keymod = ctrl; break; } case INTERACTOR_KB_MOD_SHIFT: { keymod = shift; break; } } // ---[ Check the rest of the key codes // Switch between point color/geometry handlers if (Interactor->GetKeySym () && Interactor->GetKeySym ()[0] >= '0' && Interactor->GetKeySym ()[0] <= '9') { CloudActorMap::iterator it; int index = Interactor->GetKeySym ()[0] - '0' - 1; if (index == -1) index = 9; // Add 10 more for CTRL+0..9 keys if (ctrl) index += 10; // Geometry ? if (keymod) { for (it = actors_->begin (); it != actors_->end (); ++it) { CloudActor *act = &(*it).second; if (index >= static_cast<int> (act->geometry_handlers.size ())) continue; // Save the geometry handler index for later usage act->geometry_handler_index_ = index; // Create the new geometry PointCloudGeometryHandler<sensor_msgs::PointCloud2>::ConstPtr geometry_handler = act->geometry_handlers[index]; // Use the handler to obtain the geometry vtkSmartPointer<vtkPoints> points; geometry_handler->getGeometry (points); // Set the vertices vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New (); for (vtkIdType i = 0; i < static_cast<vtkIdType> (points->GetNumberOfPoints ()); ++i) vertices->InsertNextCell (static_cast<vtkIdType>(1), &i); // Create the data vtkSmartPointer<vtkPolyData> data = vtkSmartPointer<vtkPolyData>::New (); data->SetPoints (points); data->SetVerts (vertices); // Modify the mapper if (use_vbos_) { vtkVertexBufferObjectMapper* mapper = static_cast<vtkVertexBufferObjectMapper*>(act->actor->GetMapper ()); mapper->SetInput (data); // Modify the actor act->actor->SetMapper (mapper); } else { vtkPolyDataMapper* mapper = static_cast<vtkPolyDataMapper*>(act->actor->GetMapper ()); mapper->SetInput (data); // Modify the actor act->actor->SetMapper (mapper); } act->actor->Modified (); } } else { for (it = actors_->begin (); it != actors_->end (); ++it) { CloudActor *act = &(*it).second; // Check for out of bounds if (index >= static_cast<int> (act->color_handlers.size ())) continue; // Save the color handler index for later usage act->color_handler_index_ = index; // Get the new color PointCloudColorHandler<sensor_msgs::PointCloud2>::ConstPtr color_handler = act->color_handlers[index]; vtkSmartPointer<vtkDataArray> scalars; color_handler->getColor (scalars); double minmax[2]; scalars->GetRange (minmax); // Update the data vtkPolyData *data = static_cast<vtkPolyData*>(act->actor->GetMapper ()->GetInput ()); data->GetPointData ()->SetScalars (scalars); data->Update (); // Modify the mapper if (use_vbos_) { vtkVertexBufferObjectMapper* mapper = static_cast<vtkVertexBufferObjectMapper*>(act->actor->GetMapper ()); mapper->SetScalarRange (minmax); mapper->SetScalarModeToUsePointData (); mapper->SetInput (data); // Modify the actor act->actor->SetMapper (mapper); } else { vtkPolyDataMapper* mapper = static_cast<vtkPolyDataMapper*>(act->actor->GetMapper ()); mapper->SetScalarRange (minmax); mapper->SetScalarModeToUsePointData (); mapper->SetInput (data); // Modify the actor act->actor->SetMapper (mapper); } act->actor->Modified (); } } Interactor->Render (); return; } std::string key (Interactor->GetKeySym ()); if (key.find ("XF86ZoomIn") != std::string::npos) zoomIn (); else if (key.find ("XF86ZoomOut") != std::string::npos) zoomOut (); switch (Interactor->GetKeyCode ()) { case 'h': case 'H': { pcl::console::print_info ("| Help:\n" "-------\n" " p, P : switch to a point-based representation\n" " w, W : switch to a wireframe-based representation (where available)\n" " s, S : switch to a surface-based representation (where available)\n" "\n" " j, J : take a .PNG snapshot of the current window view\n" " c, C : display current camera/window parameters\n" " f, F : fly to point mode\n" "\n" " e, E : exit the interactor\n" " q, Q : stop and call VTK's TerminateApp\n" "\n" " +/- : increment/decrement overall point size\n" " +/- [+ ALT] : zoom in/out \n" "\n" " g, G : display scale grid (on/off)\n" " u, U : display lookup table (on/off)\n" "\n" " r, R [+ ALT] : reset camera [to viewpoint = {0, 0, 0} -> center_{x, y, z}]\n" "\n" " ALT + s, S : turn stereo mode on/off\n" " ALT + f, F : switch between maximized window mode and original size\n" "\n" " l, L : list all available geometric and color handlers for the current actor map\n" " ALT + 0..9 [+ CTRL] : switch between different geometric handlers (where available)\n" " 0..9 [+ CTRL] : switch between different color handlers (where available)\n" "\n" " SHIFT + left click : select a point\n" ); break; } // Get the list of available handlers case 'l': case 'L': { // Iterate over the entire actors list and extract the geomotry/color handlers list for (CloudActorMap::iterator it = actors_->begin (); it != actors_->end (); ++it) { std::list<std::string> geometry_handlers_list, color_handlers_list; CloudActor *act = &(*it).second; for (size_t i = 0; i < act->geometry_handlers.size (); ++i) geometry_handlers_list.push_back (act->geometry_handlers[i]->getFieldName ()); for (size_t i = 0; i < act->color_handlers.size (); ++i) color_handlers_list.push_back (act->color_handlers[i]->getFieldName ()); if (!geometry_handlers_list.empty ()) { int i = 0; pcl::console::print_info ("List of available geometry handlers for actor "); pcl::console::print_value ("%s: ", (*it).first.c_str ()); for (std::list<std::string>::iterator git = geometry_handlers_list.begin (); git != geometry_handlers_list.end (); ++git) pcl::console::print_value ("%s(%d) ", (*git).c_str (), ++i); pcl::console::print_info ("\n"); } if (!color_handlers_list.empty ()) { int i = 0; pcl::console::print_info ("List of available color handlers for actor "); pcl::console::print_value ("%s: ", (*it).first.c_str ()); for (std::list<std::string>::iterator cit = color_handlers_list.begin (); cit != color_handlers_list.end (); ++cit) pcl::console::print_value ("%s(%d) ", (*cit).c_str (), ++i); pcl::console::print_info ("\n"); } } break; } // Switch representation to points case 'p': case 'P': { vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors (); vtkCollectionSimpleIterator ait; for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); ) { for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); ) { vtkSmartPointer<vtkActor> apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ()); apart->GetProperty ()->SetRepresentationToPoints (); } } break; } // Save a PNG snapshot with the current screen case 'j': case 'J': { char cam_fn[80], snapshot_fn[80]; unsigned t = static_cast<unsigned> (time (0)); sprintf (snapshot_fn, "screenshot-%d.png" , t); saveScreenshot (snapshot_fn); sprintf (cam_fn, "screenshot-%d.cam", t); ofstream ofs_cam; ofs_cam.open (cam_fn); vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera (); double clip[2], focal[3], pos[3], view[3]; cam->GetClippingRange (clip); cam->GetFocalPoint (focal); cam->GetPosition (pos); cam->GetViewUp (view); int *win_pos = Interactor->GetRenderWindow ()->GetPosition (); int *win_size = Interactor->GetRenderWindow ()->GetSize (); ofs_cam << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" << pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" << cam->GetViewAngle () / 180.0 * M_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1] << endl; ofs_cam.close (); pcl::console::print_info ("Screenshot (%s) and camera information (%s) successfully captured.\n", snapshot_fn, cam_fn); break; } // display current camera settings/parameters case 'c': case 'C': { vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera (); double clip[2], focal[3], pos[3], view[3]; cam->GetClippingRange (clip); cam->GetFocalPoint (focal); cam->GetPosition (pos); cam->GetViewUp (view); int *win_pos = Interactor->GetRenderWindow ()->GetPosition (); int *win_size = Interactor->GetRenderWindow ()->GetSize (); std::cerr << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" << pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" << cam->GetViewAngle () / 180.0 * M_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1] << endl; break; } case '=': { zoomIn(); break; } case 43: // KEY_PLUS { if(alt) zoomIn (); else { vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors (); vtkCollectionSimpleIterator ait; for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); ) { for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); ) { vtkSmartPointer<vtkActor> apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ()); float psize = apart->GetProperty ()->GetPointSize (); if (psize < 63.0f) apart->GetProperty ()->SetPointSize (psize + 1.0f); } } } break; } case 45: // KEY_MINUS { if(alt) zoomOut (); else { vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors (); vtkCollectionSimpleIterator ait; for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); ) { for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); ) { vtkSmartPointer<vtkActor> apart = static_cast<vtkActor*> (path->GetLastNode ()->GetViewProp ()); float psize = apart->GetProperty ()->GetPointSize (); if (psize > 1.0f) apart->GetProperty ()->SetPointSize (psize - 1.0f); } } } break; } // Switch between maximize and original window size case 'f': case 'F': { if (keymod) { // Get screen size int *temp = Interactor->GetRenderWindow ()->GetScreenSize (); int scr_size[2]; scr_size[0] = temp[0]; scr_size[1] = temp[1]; // Get window size temp = Interactor->GetRenderWindow ()->GetSize (); int win_size[2]; win_size[0] = temp[0]; win_size[1] = temp[1]; // Is window size = max? if (win_size[0] == max_win_height_ && win_size[1] == max_win_width_) { // Set the previously saved 'current' window size Interactor->GetRenderWindow ()->SetSize (win_height_, win_width_); // Set the previously saved window position Interactor->GetRenderWindow ()->SetPosition (win_pos_x_, win_pos_y_); Interactor->GetRenderWindow ()->Render (); Interactor->Render (); } // Set to max else { int *win_pos = Interactor->GetRenderWindow ()->GetPosition (); // Save the current window position win_pos_x_ = win_pos[0]; win_pos_y_ = win_pos[1]; // Save the current window size win_height_ = win_size[0]; win_width_ = win_size[1]; // Set the maximum window size Interactor->GetRenderWindow ()->SetSize (scr_size[0], scr_size[1]); Interactor->GetRenderWindow ()->Render (); Interactor->Render (); int *win_size = Interactor->GetRenderWindow ()->GetSize (); // Save the maximum window size max_win_height_ = win_size[0]; max_win_width_ = win_size[1]; } } else { AnimState = VTKIS_ANIM_ON; vtkAssemblyPath *path = NULL; Interactor->GetPicker ()->Pick (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1], 0.0, CurrentRenderer); vtkAbstractPropPicker *picker; if ((picker = vtkAbstractPropPicker::SafeDownCast (Interactor->GetPicker ()))) path = picker->GetPath (); if (path != NULL) Interactor->FlyTo (CurrentRenderer, picker->GetPickPosition ()); AnimState = VTKIS_ANIM_OFF; } break; } // 's'/'S' w/out ALT case 's': case 'S': { if (keymod) { int stereo_render = Interactor->GetRenderWindow ()->GetStereoRender (); if (!stereo_render) { if (stereo_anaglyph_mask_default_) { Interactor->GetRenderWindow ()->SetAnaglyphColorMask (4, 3); stereo_anaglyph_mask_default_ = false; } else { Interactor->GetRenderWindow ()->SetAnaglyphColorMask (2, 5); stereo_anaglyph_mask_default_ = true; } } Interactor->GetRenderWindow ()->SetStereoRender (!stereo_render); Interactor->GetRenderWindow ()->Render (); Interactor->Render (); } else Superclass::OnKeyDown (); break; } // Display a grid/scale over the screen case 'g': case 'G': { if (!grid_enabled_) { grid_actor_->TopAxisVisibilityOn (); CurrentRenderer->AddViewProp (grid_actor_); grid_enabled_ = true; } else { CurrentRenderer->RemoveViewProp (grid_actor_); grid_enabled_ = false; } break; } case 'o': case 'O': { vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera (); int flag = cam->GetParallelProjection (); cam->SetParallelProjection (!flag); CurrentRenderer->SetActiveCamera (cam); CurrentRenderer->Render (); break; } // Display a LUT actor on screen case 'u': case 'U': { CloudActorMap::iterator it; for (it = actors_->begin (); it != actors_->end (); ++it) { CloudActor *act = &(*it).second; vtkScalarsToColors* lut = act->actor->GetMapper ()->GetLookupTable (); lut_actor_->SetLookupTable (lut); lut_actor_->Modified (); } if (!lut_enabled_) { CurrentRenderer->AddActor (lut_actor_); lut_actor_->SetVisibility (true); lut_enabled_ = true; } else { CurrentRenderer->RemoveActor (lut_actor_); lut_enabled_ = false; } CurrentRenderer->Render (); break; } // Overwrite the camera reset case 'r': case 'R': { if (!keymod) { Superclass::OnKeyDown (); break; } vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera (); static CloudActorMap::iterator it = actors_->begin (); // it might be that some actors don't have a valid transformation set -> we skip them to avoid a seg fault. bool found_transformation = false; for (unsigned idx = 0; idx < actors_->size (); ++idx, ++it) { if (it == actors_->end ()) it = actors_->begin (); const CloudActor& actor = it->second; if (actor.viewpoint_transformation_.GetPointer ()) { found_transformation = true; break; } } // if a valid transformation was found, use it otherwise fall back to default view point. if (found_transformation) { const CloudActor& actor = it->second; cam->SetPosition (actor.viewpoint_transformation_->GetElement (0, 3), actor.viewpoint_transformation_->GetElement (1, 3), actor.viewpoint_transformation_->GetElement (2, 3)); cam->SetFocalPoint (actor.viewpoint_transformation_->GetElement (0, 3) - actor.viewpoint_transformation_->GetElement (0, 2), actor.viewpoint_transformation_->GetElement (1, 3) - actor.viewpoint_transformation_->GetElement (1, 2), actor.viewpoint_transformation_->GetElement (2, 3) - actor.viewpoint_transformation_->GetElement (2, 2)); cam->SetViewUp (actor.viewpoint_transformation_->GetElement (0, 1), actor.viewpoint_transformation_->GetElement (1, 1), actor.viewpoint_transformation_->GetElement (2, 1)); } else { cam->SetPosition (0, 0, 0); cam->SetFocalPoint (0, 0, 1); cam->SetViewUp (0, -1, 0); } // go to the next actor for the next key-press event. if (it != actors_->end ()) ++it; else it = actors_->begin (); CurrentRenderer->SetActiveCamera (cam); CurrentRenderer->ResetCameraClippingRange (); CurrentRenderer->Render (); break; } case 'q': case 'Q': { Interactor->ExitCallback (); return; } default: { Superclass::OnKeyDown (); break; } } KeyboardEvent event (true, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); keyboard_signal_ (event); rens_->Render (); Interactor->Render (); }
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) { switch ((int)event.type) { case Common::EVENT_KEYDOWN: if (event.kbd.hasFlags(Common::KBD_ALT)) { // Alt-Return and Alt-Enter toggle full screen mode if (event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { toggleFullScreen(0); return true; } // Alt-S create a screenshot if (event.kbd.keycode == 's') { Common::String filename; for (int n = 0;; n++) { SDL_RWops *file; filename = Common::String::format("scummvm%05d.bmp", n); file = SDL_RWFromFile(filename.c_str(), "r"); if (!file) break; SDL_RWclose(file); } if (saveScreenshot(filename.c_str())) debug("Saved screenshot '%s'", filename.c_str()); else warning("Could not save screenshot"); return true; } } if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_ALT)) { // Ctrl-Alt-Return and Ctrl-Alt-Enter switch between full screen modes if (event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { toggleFullScreen(1); return true; } // Ctrl-Alt-a switch between display modes if (event.kbd.keycode == 'a') { beginGFXTransaction(); setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection)); endGFXTransaction(); #ifdef USE_OSD Common::String osdMessage; if (getFeatureState(OSystem::kFeatureAspectRatioCorrection)) osdMessage = Common::String::format("%s\n%d x %d -> %d x %d", _("Enabled aspect ratio correction"), _videoMode.screenWidth, _videoMode.screenHeight, _hwscreen->w, _hwscreen->h); else osdMessage = Common::String::format("%s\n%d x %d -> %d x %d", _("Disabled aspect ratio correction"), _videoMode.screenWidth, _videoMode.screenHeight, _hwscreen->w, _hwscreen->h); displayMessageOnOSD(osdMessage.c_str()); #endif internUpdateScreen(); return true; } // Ctrl-Alt-f toggles antialiasing if (event.kbd.keycode == 'f') { beginGFXTransaction(); toggleAntialiasing(); endGFXTransaction(); #ifdef USE_OSD // TODO: This makes guesses about what internal antialiasing // modes we use, we might want to consider a better way of // displaying information to the user. if (getAntialiasingState()) displayMessageOnOSD(_("Active filter mode: Linear")); else displayMessageOnOSD(_("Active filter mode: Nearest")); #endif return true; } SDLKey sdlKey = (SDLKey)event.kbd.keycode; // Ctrl+Alt+Plus/Minus Increase/decrease the scale factor if ((sdlKey == SDLK_EQUALS || sdlKey == SDLK_PLUS || sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_PLUS || sdlKey == SDLK_KP_MINUS)) { int factor = getScale(); factor += (sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_MINUS) ? -1 : +1; if (0 < factor && factor < 4) { // Check if the desktop resolution has been detected if (_desktopWidth > 0 && _desktopHeight > 0) // If the new scale factor is too big, do not scale if (_videoMode.screenWidth * factor > _desktopWidth || _videoMode.screenHeight * factor > _desktopHeight) return false; beginGFXTransaction(); setScale(factor); endGFXTransaction(); #ifdef USE_OSD displayScaleChangedMsg(); #endif return true; } } const bool isNormalNumber = (SDLK_1 <= sdlKey && sdlKey <= SDLK_3); const bool isKeypadNumber = (SDLK_KP1 <= sdlKey && sdlKey <= SDLK_KP3); // Ctrl-Alt-<number key> will change the GFX mode if (isNormalNumber || isKeypadNumber) { if (sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1) <= 3) { #ifdef USE_OSD int lastMode = _videoMode.mode; #endif // We need to query the scale and set it up, because // setGraphicsMode sets the default scale to 2 int oldScale = getScale(); beginGFXTransaction(); setGraphicsMode(sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1)); setScale(oldScale); endGFXTransaction(); #ifdef USE_OSD if (lastMode != _videoMode.mode) displayModeChangedMsg(); #endif internUpdateScreen(); } } } if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_SHIFT)) { // Ctrl-Shift-Return and Ctrl-Shift-Enter switch backwards between full screen modes if (event.kbd.keycode == Common::KEYCODE_RETURN || event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) { toggleFullScreen(-1); return true; } } break; case Common::EVENT_KEYUP: return isHotkey(event); default: break; } return false; }
/** * This method is call on press of key */ void Visualizer::onKeyboard(unsigned char key, int, int) { if (key>='A' && key<='Z') key+='a'-'A'; /* convert upper char on lower */ switch (key) { /* press key */ case '1' : /* show vertex */ glPolygonMode(GL_FRONT, GL_POINT); glPolygonMode(GL_BACK, GL_POINT); glutPostRedisplay(); break; case '2' : /* show wireframe */ glPolygonMode(GL_FRONT, GL_LINE); glPolygonMode(GL_BACK, GL_LINE); glutPostRedisplay(); break; case '3' : /* show fill polygons */ glPolygonMode(GL_FRONT, GL_FILL); glPolygonMode(GL_BACK, GL_FILL); glutPostRedisplay(); break; case '5' : /* decrease vision angle */ if (fov>0) fov--; onReshape(WindowWidth, WindowHeight); glutPostRedisplay(); break; case '6' : if (fov<180) fov++; /* increase vision angle */ onReshape(WindowWidth, WindowHeight); glutPostRedisplay(); break; case '7' : /* zoom in trim plain */ if (line_width > 0) line_width -= 0.5; glLineWidth(line_width); glPointSize(line_width); onReshape(WindowWidth, WindowHeight); glutPostRedisplay(); break; case '8' : /* zoom out trim plain */ if (line_width < 10) line_width += 0.5; glLineWidth(line_width); glPointSize(line_width); onReshape(WindowWidth, WindowHeight); glutPostRedisplay(); break; case 's' : /* print to bitmap - screenshot */ saveScreenshot(screenshotFileName); break; case 27 : /* Escape */ case 'q' : exit(0); /* exit */ break; case 'm' : colorInput = INTERPOLATE_RADIOSITY; /* interpolate radiosity */ createCallList(); glutPostRedisplay(); break; case 'b' : colorInput = INTERPOLATE_RADIOSITY_RAW; /* interpolate radiosity */ createCallList(); glutPostRedisplay(); break; case 'v' : colorInput = RADIOSITY; /* radiosity */ createCallList(); glutPostRedisplay(); break; case 'n' : colorInput = RADIOSITY_LAST; /* radiosity */ createCallList(); glutPostRedisplay(); break; case 'z' : colorInput = REFLECTIVITY; /* reflectivity + emission */ createCallList(); glutPostRedisplay(); break; case 'x' : colorInput = EMISSION; /* reflectivity */ createCallList(); glutPostRedisplay(); break; case 'c' : colorInput = REFLECT_EMISS; /* emission */ createCallList(); glutPostRedisplay(); break; case 'f' : glutFullScreen(); /* fullscrean */ break; case 'w' : glutReshapeWindow(WindowWidth, WindowHeight); /* go back to window */ break; default: break; } }