bool LinuxmotoSdlGraphicsManager::loadGFXMode() { debug("Game ScreenMode = %d*%d",_videoMode.screenWidth, _videoMode.screenHeight); if (_videoMode.screenWidth > 320 || _videoMode.screenHeight > 240) { _videoMode.aspectRatioCorrection = false; setGraphicsMode(GFX_HALF); debug("GraphicsMode set to HALF"); } else { setGraphicsMode(GFX_NORMAL); debug("GraphicsMode set to NORMAL"); } if (_videoMode.mode == GFX_HALF && !_overlayVisible) { _videoMode.overlayWidth = 320; _videoMode.overlayHeight = 240; _videoMode.fullscreen = true; } else { _videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor; _videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor; if (_videoMode.aspectRatioCorrection) _videoMode.overlayHeight = real2Aspect(_videoMode.overlayHeight); _videoMode.hardwareWidth = _videoMode.screenWidth * _videoMode.scaleFactor; _videoMode.hardwareHeight = effectiveScreenHeight(); } return SdlGraphicsManager::loadGFXMode(); }
bool OSystem_GPH::loadGFXMode() { if (_videoMode.screenWidth > 320 || _videoMode.screenHeight > 240) { _videoMode.aspectRatioCorrection = false; setGraphicsMode(GFX_HALF); printf("GFX_HALF\n"); } else { setGraphicsMode(GFX_NORMAL); printf("GFX_NORMAL\n"); } if ((_videoMode.mode == GFX_HALF) && !_overlayVisible) { _videoMode.overlayWidth = _videoMode.screenWidth / 2; _videoMode.overlayHeight = _videoMode.screenHeight / 2; _videoMode.fullscreen = true; } else { _videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor; _videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor; if (_videoMode.aspectRatioCorrection) _videoMode.overlayHeight = real2Aspect(_videoMode.overlayHeight); _videoMode.hardwareWidth = _videoMode.screenWidth * _videoMode.scaleFactor; _videoMode.hardwareHeight = effectiveScreenHeight(); } return OSystem_SDL::loadGFXMode(); }
void OSystem_Wii::initGfx() { _surface.w = 0; _surface.h = 0; _surface.pitch = 0; _surface.pixels = NULL; _surface.bytesPerPixel = 0; GX_InitVideo(); _overlayWidth = 640; _overlayHeight = 480; #ifndef GAMECUBE if (CONF_GetAspectRatio() && _fullscreen) _overlayHeight = 400; #endif _overlaySize = _overlayWidth * _overlayHeight * 2; _overlayPixels = (OverlayColor *) memalign(32, _overlaySize); _palette = (u16 *) memalign(32, 256 * 2); memset(_palette, 0, 256 * 2); _cursorPalette = (u16 *) memalign(32, 256 * 2); memset(_cursorPalette, 0, 256 * 2); _texture = (u16 *) memalign(32, 640 * 480 * 2); setGraphicsMode(_activeGraphicsMode); }
void OSystem_Wii::setFeatureState(Feature f, bool enable) { switch (f) { case kFeatureFullscreenMode: _fullscreen = enable; setGraphicsMode(_activeGraphicsMode); break; default: break; } }
bool OSystem::setGraphicsMode(const char *name) { if (!name) return false; // Special case for the 'default' filter if (!scumm_stricmp(name, "normal") || !scumm_stricmp(name, "default")) { return setGraphicsMode(getDefaultGraphicsMode()); } const GraphicsMode *gm = getSupportedGraphicsModes(); while (gm->name) { if (!scumm_stricmp(gm->name, name)) { return setGraphicsMode(gm->id); } gm++; } return false; }
void WINCESdlGraphicsManager::update_game_settings() { Common::String gameid(ConfMan.get("gameid")); // Finish panel initialization if (!_panelInitialized && !gameid.empty()) { CEGUI::Panel *panel; _panelInitialized = true; // Add the main panel panel = new CEGUI::Panel(0, 32); panel->setBackground(IMAGE_PANEL); // Save panel->add(NAME_ITEM_OPTIONS, new CEGUI::ItemAction(ITEM_OPTIONS, POCKET_ACTION_SAVE)); // Skip panel->add(NAME_ITEM_SKIP, new CEGUI::ItemAction(ITEM_SKIP, POCKET_ACTION_SKIP)); // sound panel->add(NAME_ITEM_SOUND, new CEGUI::ItemSwitch(ITEM_SOUND_OFF, ITEM_SOUND_ON, &OSystem_WINCE3::_soundMaster)); // bind keys panel->add(NAME_ITEM_BINDKEYS, new CEGUI::ItemAction(ITEM_BINDKEYS, POCKET_ACTION_BINDKEYS)); // portrait/landscape - screen dependent // FIXME : will still display the portrait/landscape icon when using a scaler (but will be disabled) if (ConfMan.hasKey("landscape")) { if (ConfMan.get("landscape")[0] > 57) { _newOrientation = _orientationLandscape = ConfMan.getBool("landscape"); //ConfMan.removeKey("landscape", ""); ConfMan.setInt("landscape", _orientationLandscape); } else _newOrientation = _orientationLandscape = ConfMan.getInt("landscape"); } else { _newOrientation = _orientationLandscape = 0; } panel->add(NAME_ITEM_ORIENTATION, new CEGUI::ItemSwitch(ITEM_VIEW_LANDSCAPE, ITEM_VIEW_PORTRAIT, &_newOrientation, 2)); _toolbarHandler.add(NAME_MAIN_PANEL, *panel); _toolbarHandler.setActive(NAME_MAIN_PANEL); _toolbarHandler.setVisible(true); if (_videoMode.mode == GFX_NORMAL && ConfMan.hasKey("landscape") && ConfMan.getInt("landscape")) { setGraphicsMode(GFX_NORMAL); hotswapGFXMode(); } if (_hasSmartphoneResolution) panel->setVisible(false); _saveToolbarState = true; } if (ConfMan.hasKey("no_doubletap_rightclick")) _noDoubleTapRMB = ConfMan.getBool("no_doubletap_rightclick"); if (ConfMan.hasKey("no_doubletap_paneltoggle")) _noDoubleTapPT = ConfMan.getBool("no_doubletap_paneltoggle"); }
void OSystem_SDL::endGFXTransaction(void) { // for each engine we run initCommonGFX() as first thing in the transaction // and initSize() is called later. If user runs launcher at 320x200 with // 2x overlay, setting to Nomral1x sclaler in that case will be suppressed // and backend is forced to 2x // // This leads to bad results such as 1280x960 window for 640x480 engines. // To prevent that we rerun setGraphicsMode() if there was 1x scaler request if (_transactionDetails.normal1xScaler) setGraphicsMode(GFX_NORMAL); assert (_transactionMode == kTransactionActive); _transactionMode = kTransactionCommit; if (_transactionDetails.modeChanged) setGraphicsMode(_transactionDetails.mode); if (_transactionDetails.sizeChanged) initSize(_transactionDetails.w, _transactionDetails.h); if (_transactionDetails.arChanged) setAspectRatioCorrection(_transactionDetails.ar); if (_transactionDetails.needUnload) { unloadGFXMode(); loadGFXMode(); clearOverlay(); } else { if (!_transactionDetails.fsChanged) { if (_transactionDetails.needHotswap) hotswapGFXMode(); else if (_transactionDetails.needUpdatescreen) internUpdateScreen(); } } if (_transactionDetails.fsChanged) setFullscreenMode(_transactionDetails.fs); _transactionMode = kTransactionNone; }
// --------- INICIALIZACION DEL JUEGO // bool TProfanationGame::init(void) { lb_init=false; if (!TMAGame::init()) return false; inputController.setNumControls(GKEY_MAX); loadConfiguration(); if (!setGraphicsMode(640/_REDUCE,480/_REDUCE,16,config_fullscreen)) return false; setWindowTitle("Abusimbel Profanation Deluxe"); setGameFPS(32); lb_init = true; // Cargamos los tipos de letras constantes en el juego // #ifdef SMALL_GAME fontMulti.load("Data/Fonts/FuenteMulti.png",10,15,gs_charset.length(),1,false,0); fontBlue.load("Data/Fonts/FuenteBlue.png",10,15,gs_charset.length(),1,false,0); #else fontMulti.load("Data/Fonts/FuenteMulti.png",20,30,gs_charset.length(),1,false,MAKERGBCOLOR(255,0,255)); fontBlue.load("Data/Fonts/FuenteBlue.png",20,30,gs_charset.length(),1,false,MAKERGBCOLOR(255,0,255)); #endif fontMulti.setCharacters(*gs_charset); fontBlue.setCharacters(*gs_charset); // Cargamos los sonidos // if (isSoundAvailable()) { setVolume(gi_volume); gsnd_Gota.load("Data/Sonidos/gota.wav"); gsnd_Roca.load("Data/Sonidos/roca.wav"); gsnd_Camina.load("Data/Sonidos/camina.wav"); gsnd_Salto.load("Data/Sonidos/salto.wav"); gsnd_Caida.load("Data/Sonidos/caida.wav"); gsnd_Tesoro.load("Data/Sonidos/tesoro.wav"); gsnd_Scroll.load("Data/Sonidos/scroll.wav"); gsnd_Teletransporte.load("Data/Sonidos/teletransporte.wav"); gsnd_Grito.load("Data/Sonidos/grito.wav"); } miRND.init(); // Establecemos el escenario inicial // setScene(new TESC_Seleccion_Idioma()); return true; }
bool DINGUXSdlGraphicsManager::loadGFXMode() { debug("Game ScreenMode = %d*%d", _videoMode.screenWidth, _videoMode.screenHeight); // Forcefully disable aspect ratio correction for games // which starts with a native 240px height resolution. // This fixes games with weird resolutions, like MM Nes (256x240) if (_videoMode.screenHeight == 240) { _videoMode.aspectRatioCorrection = false; } if (_videoMode.screenWidth > 320 || _videoMode.screenHeight > 240) { _videoMode.aspectRatioCorrection = false; setGraphicsMode(GFX_HALF); debug("GraphicsMode set to HALF"); } else { setGraphicsMode(GFX_NORMAL); debug("GraphicsMode set to NORMAL"); } if ((_videoMode.mode == GFX_HALF) && !_overlayVisible) { _videoMode.overlayWidth = _videoMode.screenWidth / 2; _videoMode.overlayHeight = _videoMode.screenHeight / 2; _videoMode.fullscreen = true; } else { _videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor; _videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor; if (_videoMode.aspectRatioCorrection) _videoMode.overlayHeight = real2Aspect(_videoMode.overlayHeight); _videoMode.hardwareWidth = _videoMode.screenWidth * _videoMode.scaleFactor; _videoMode.hardwareHeight = effectiveScreenHeight(); } return SurfaceSdlGraphicsManager::loadGFXMode(); }
bool GPHGraphicsManager::loadGFXMode() { // We don't offer anything other than fullscreen on GPH devices so let’s not even pretend. _videoMode.fullscreen = true; // Set the hardware stats to match the LCD. _videoMode.hardwareWidth = 320; _videoMode.hardwareHeight = 240; if (_videoMode.screenHeight != 200) _videoMode.aspectRatioCorrection = false; if (_videoMode.screenWidth > 320 || _videoMode.screenHeight > 240) { _videoMode.aspectRatioCorrection = false; setGraphicsMode(GFX_HALF); } else { setGraphicsMode(GFX_NORMAL); } if ((_videoMode.mode == GFX_HALF) && !_overlayVisible) { _videoMode.overlayWidth = _videoMode.screenWidth / 2; _videoMode.overlayHeight = _videoMode.screenHeight / 2; } else { _videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor; _videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor; if (_videoMode.aspectRatioCorrection) _videoMode.overlayHeight = real2Aspect(_videoMode.overlayHeight); } SurfaceSdlGraphicsManager::loadGFXMode(); // The old GP2X hacked SDL needs this after any call to SDL_SetVideoMode // and it does not hurt other devices. SDL_ShowCursor(SDL_DISABLE); return true; }
/********************************************************** * Theme setup/initialization *********************************************************/ bool ThemeEngine::init() { // reset everything and reload the graphics _initOk = false; _overlayFormat = _system->getOverlayFormat(); setGraphicsMode(_graphicsMode); if (_screen.pixels && _backBuffer.pixels) { _initOk = true; } // TODO: Instead of hard coding the font here, it should be possible // to specify the fonts to be used for each resolution in the theme XML. if (_screen.w >= 400 && _screen.h >= 300) { _font = FontMan.getFontByUsage(Graphics::FontManager::kBigGUIFont); } else { _font = FontMan.getFontByUsage(Graphics::FontManager::kGUIFont); } // Try to create a Common::Archive with the files of the theme. if (!_themeArchive && !_themeFile.empty()) { Common::FSNode node(_themeFile); if (node.isDirectory()) { _themeArchive = new Common::FSDirectory(node); } else if (_themeFile.matchString("*.zip", true)) { // TODO: Also use "node" directly? // Look for the zip file via SearchMan Common::ArchiveMemberPtr member = SearchMan.getMember(_themeFile); if (member) { _themeArchive = Common::makeZipArchive(member->createReadStream()); if (!_themeArchive) { warning("Failed to open Zip archive '%s'.", member->getDisplayName().c_str()); } } else { _themeArchive = Common::makeZipArchive(node); if (!_themeArchive) { warning("Failed to open Zip archive '%s'.", node.getPath().c_str()); } } } } // Load the theme // We pass the theme file here by default, so the user will // have a descriptive error message. The only exception will // be the builtin theme which has no filename. loadTheme(_themeFile.empty() ? _themeId : _themeFile); return ready(); }
bool DisplayManager::setGraphicsMode(const char *name) { DEBUG_ENTER_FUNC(); int i = 0; while (_supportedModes[i].name) { if (!strcmpi(_supportedModes[i].name, name)) { setGraphicsMode(_supportedModes[i].id); return true; } i++; } return false; }
void DINGUXSdlGraphicsManager::initSize(uint w, uint h) { assert(_transactionMode == kTransactionActive); // Avoid redundant res changes if ((int)w == _videoMode.screenWidth && (int)h == _videoMode.screenHeight) return; _videoMode.screenWidth = w; _videoMode.screenHeight = h; if (w > 320 || h > 240) { setGraphicsMode(GFX_HALF); setGraphicsModeIntern(); _window->toggleMouseGrab(); } _transactionDetails.sizeChanged = true; }
void GPHGraphicsManager::initSize(uint w, uint h, const Graphics::PixelFormat *format) { assert(_transactionMode == kTransactionActive); #ifdef USE_RGB_COLOR // Avoid redundant format changes Graphics::PixelFormat newFormat; if (!format) newFormat = Graphics::PixelFormat::createFormatCLUT8(); else newFormat = *format; assert(newFormat.bytesPerPixel > 0); if (newFormat != _videoMode.format) { _videoMode.format = newFormat; _transactionDetails.formatChanged = true; _screenFormat = newFormat; } #endif // Avoid redundant res changes if ((int)w == _videoMode.screenWidth && (int)h == _videoMode.screenHeight) return; _videoMode.screenWidth = w; _videoMode.screenHeight = h; if (w > 320 || h > 240) { setGraphicsMode(GFX_HALF); setGraphicsModeIntern(); _eventSource->toggleMouseGrab(); } _videoMode.overlayWidth = 320; _videoMode.overlayHeight = 240; _transactionDetails.sizeChanged = true; }
void OSystem_Wii::initSize(uint width, uint height) { if (_gameWidth != width || _gameHeight != height) { printf("initSize %u %u\n", width, height); assert((width <= 640) && (height <= 480)); _gameWidth = width; _gameHeight = height; if(_gamePixels) free(_gamePixels); _gamePixels = (u8 *) memalign(32, _gameWidth * _gameHeight); memset(_gamePixels, 0, _gameWidth * _gameHeight); if (!_overlayVisible) { _currentWidth = _gameWidth; _currentHeight = _gameHeight; updateEventScreenResolution(); } setGraphicsMode(_activeGraphicsMode); } }
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') { 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; }
void SurfaceSdlGraphicsManager::resetGraphicsScale() { setGraphicsMode(0); }
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; } }
void OSystem_SDL::handleScalerHotkeys(const SDL_KeyboardEvent &key) { // Ctrl-Alt-a toggles aspect ratio correction if (key.keysym.sym == 'a') { setFeatureState(kFeatureAspectRatioCorrection, !_adjustAspectRatio); #ifdef USE_OSD char buffer[128]; if (_adjustAspectRatio) sprintf(buffer, "Enabled aspect ratio correction\n%d x %d -> %d x %d", _screenWidth, _screenHeight, _hwscreen->w, _hwscreen->h ); else sprintf(buffer, "Disabled aspect ratio correction\n%d x %d -> %d x %d", _screenWidth, _screenHeight, _hwscreen->w, _hwscreen->h ); displayMessageOnOSD(buffer); #endif return; } int newMode = -1; int factor = _scaleFactor - 1; // Increase/decrease the scale factor if (key.keysym.sym == SDLK_EQUALS || key.keysym.sym == SDLK_PLUS || key.keysym.sym == SDLK_MINUS || key.keysym.sym == SDLK_KP_PLUS || key.keysym.sym == SDLK_KP_MINUS) { factor += (key.keysym.sym == SDLK_MINUS || key.keysym.sym == SDLK_KP_MINUS) ? -1 : +1; if (0 <= factor && factor <= 3) { newMode = s_gfxModeSwitchTable[_scalerType][factor]; } } const bool isNormalNumber = (SDLK_1 <= key.keysym.sym && key.keysym.sym <= SDLK_9); const bool isKeypadNumber = (SDLK_KP1 <= key.keysym.sym && key.keysym.sym <= SDLK_KP9); if (isNormalNumber || isKeypadNumber) { _scalerType = key.keysym.sym - (isNormalNumber ? SDLK_1 : SDLK_KP1); if (_scalerType >= ARRAYSIZE(s_gfxModeSwitchTable)) return; while (s_gfxModeSwitchTable[_scalerType][factor] < 0) { assert(factor > 0); factor--; } newMode = s_gfxModeSwitchTable[_scalerType][factor]; } if (newMode >= 0) { setGraphicsMode(newMode); #ifdef USE_OSD if (_osdSurface) { const char *newScalerName = 0; const GraphicsMode *g = getSupportedGraphicsModes(); while (g->name) { if (g->id == _mode) { newScalerName = g->description; break; } g++; } if (newScalerName) { char buffer[128]; sprintf(buffer, "Active graphics filter: %s\n%d x %d -> %d x %d", newScalerName, _screenWidth, _screenHeight, _hwscreen->w, _hwscreen->h ); displayMessageOnOSD(buffer); } } #endif } }