mirror of
https://github.com/TerryCavanagh/VVVVVV.git
synced 2024-12-22 17:49:43 +01:00
8de93cb0f4
Originally, we were using just the hint, but this didn't work well for toggling VSync (see #831). Then I added SDL_RenderSetVSync to SDL, and used that instead for toggling, but we were still setting the hint on game startup. Now, to keep things consistent, and just to make sure we don't get any surprising behavior should things change in the future, this makes it so game startup uses SDL_RenderSetVSync too.
386 lines
9.9 KiB
C++
386 lines
9.9 KiB
C++
#define GAMESCREEN_DEFINITION
|
|
#include "Screen.h"
|
|
|
|
#include <SDL.h>
|
|
|
|
#include "Alloc.h"
|
|
#include "Constants.h"
|
|
#include "Exit.h"
|
|
#include "FileSystemUtils.h"
|
|
#include "Game.h"
|
|
#include "Graphics.h"
|
|
#include "GraphicsUtil.h"
|
|
#include "InterimVersion.h"
|
|
#include "Render.h"
|
|
#include "Vlogging.h"
|
|
|
|
void ScreenSettings_default(struct ScreenSettings* _this)
|
|
{
|
|
_this->windowDisplay = 0;
|
|
_this->windowWidth = SCREEN_WIDTH_PIXELS * 2;
|
|
_this->windowHeight = SCREEN_HEIGHT_PIXELS * 2;
|
|
_this->fullscreen = false;
|
|
_this->useVsync = true; // Now that uncapped is the default...
|
|
_this->scalingMode = SCALING_INTEGER;
|
|
_this->linearFilter = false;
|
|
_this->badSignal = false;
|
|
}
|
|
|
|
void Screen::init(const struct ScreenSettings* settings)
|
|
{
|
|
m_window = NULL;
|
|
m_renderer = NULL;
|
|
windowDisplay = settings->windowDisplay;
|
|
windowWidth = settings->windowWidth;
|
|
windowHeight = settings->windowHeight;
|
|
isWindowed = !settings->fullscreen;
|
|
scalingMode = settings->scalingMode;
|
|
isFiltered = settings->linearFilter;
|
|
badSignalEffect = settings->badSignal;
|
|
vsync = settings->useVsync;
|
|
|
|
// Uncomment this next line when you need to debug -flibit
|
|
// SDL_SetHintWithPriority(SDL_HINT_RENDER_DRIVER, "software", SDL_HINT_OVERRIDE);
|
|
|
|
m_window = SDL_CreateWindow(
|
|
"VVVVVV",
|
|
SDL_WINDOWPOS_CENTERED_DISPLAY(windowDisplay),
|
|
SDL_WINDOWPOS_CENTERED_DISPLAY(windowDisplay),
|
|
SCREEN_WIDTH_PIXELS * 2,
|
|
SCREEN_HEIGHT_PIXELS * 2,
|
|
SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI
|
|
);
|
|
|
|
if (m_window == NULL)
|
|
{
|
|
vlog_error("Could not create window: %s", SDL_GetError());
|
|
VVV_exit(1);
|
|
}
|
|
|
|
m_renderer = SDL_CreateRenderer(m_window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);
|
|
|
|
if (m_renderer == NULL)
|
|
{
|
|
vlog_error("Could not create renderer: %s", SDL_GetError());
|
|
VVV_exit(1);
|
|
}
|
|
|
|
SDL_RenderSetVSync(m_renderer, (int) vsync);
|
|
|
|
#ifdef INTERIM_VERSION_EXISTS
|
|
/* Branch name limits are ill-defined but on GitHub it's ~256 chars
|
|
* ( https://stackoverflow.com/a/24014513/ ).
|
|
* Really though, just don't use super long branch names. */
|
|
char title[256];
|
|
SDL_snprintf(title, sizeof(title), "VVVVVV [%s]", BRANCH_NAME);
|
|
SDL_SetWindowTitle(m_window, title);
|
|
#else
|
|
SDL_SetWindowTitle(m_window, "VVVVVV");
|
|
#endif
|
|
|
|
SDL_SetWindowMinimumSize(m_window, SCREEN_WIDTH_PIXELS, SCREEN_HEIGHT_PIXELS);
|
|
|
|
LoadIcon();
|
|
|
|
ResizeScreen(windowWidth, windowHeight);
|
|
}
|
|
|
|
void Screen::destroy(void)
|
|
{
|
|
/* Order matters! */
|
|
VVV_freefunc(SDL_DestroyRenderer, m_renderer);
|
|
VVV_freefunc(SDL_DestroyWindow, m_window);
|
|
}
|
|
|
|
void Screen::GetSettings(struct ScreenSettings* settings)
|
|
{
|
|
windowDisplay = SDL_GetWindowDisplayIndex(m_window);
|
|
if (windowDisplay < 0)
|
|
{
|
|
vlog_error("Error: could not get display index: %s", SDL_GetError());
|
|
windowDisplay = 0;
|
|
}
|
|
settings->windowDisplay = windowDisplay;
|
|
settings->windowWidth = windowWidth;
|
|
settings->windowHeight = windowHeight;
|
|
|
|
settings->fullscreen = !isWindowed;
|
|
settings->useVsync = vsync;
|
|
settings->scalingMode = scalingMode;
|
|
settings->linearFilter = isFiltered;
|
|
settings->badSignal = badSignalEffect;
|
|
}
|
|
|
|
#ifdef __APPLE__
|
|
/* Apple doesn't like icons anymore... */
|
|
void Screen::LoadIcon(void)
|
|
{
|
|
|
|
}
|
|
#else
|
|
SDL_Surface* LoadImageSurface(const char* filename);
|
|
|
|
void Screen::LoadIcon(void)
|
|
{
|
|
SDL_Surface* icon = LoadImageSurface("VVVVVV.png");
|
|
if (icon == NULL)
|
|
{
|
|
return;
|
|
}
|
|
SDL_SetWindowIcon(m_window, icon);
|
|
VVV_freefunc(SDL_FreeSurface, icon);
|
|
}
|
|
#endif /* __APPLE__ */
|
|
|
|
void Screen::ResizeScreen(int x, int y)
|
|
{
|
|
windowDisplay = SDL_GetWindowDisplayIndex(m_window);
|
|
if (windowDisplay < 0)
|
|
{
|
|
vlog_error("Error: could not get display index: %s", SDL_GetError());
|
|
windowDisplay = 0;
|
|
}
|
|
|
|
if (x != -1 && y != -1)
|
|
{
|
|
// This is a user resize!
|
|
windowWidth = x;
|
|
windowHeight = y;
|
|
}
|
|
|
|
if (!isWindowed || isForcedFullscreen())
|
|
{
|
|
int result = SDL_SetWindowFullscreen(m_window, SDL_WINDOW_FULLSCREEN_DESKTOP);
|
|
recacheTextures();
|
|
if (result != 0)
|
|
{
|
|
vlog_error("Error: could not set the game to fullscreen mode: %s", SDL_GetError());
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int result = SDL_SetWindowFullscreen(m_window, 0);
|
|
if (result != 0)
|
|
{
|
|
vlog_error("Error: could not set the game to windowed mode: %s", SDL_GetError());
|
|
}
|
|
else if (x != -1 && y != -1)
|
|
{
|
|
SDL_SetWindowSize(m_window, windowWidth, windowHeight);
|
|
SDL_SetWindowPosition(
|
|
m_window,
|
|
SDL_WINDOWPOS_CENTERED_DISPLAY(windowDisplay),
|
|
SDL_WINDOWPOS_CENTERED_DISPLAY(windowDisplay)
|
|
);
|
|
}
|
|
recacheTextures();
|
|
}
|
|
}
|
|
|
|
void Screen::ResizeToNearestMultiple(void)
|
|
{
|
|
int w, h;
|
|
GetScreenSize(&w, &h);
|
|
|
|
// Check aspect ratio first
|
|
bool using_width;
|
|
int usethisdimension, usethisratio;
|
|
|
|
if ((float) w / (float) h > 4.0 / 3.0)
|
|
{
|
|
// Width is bigger, so it's limited by height
|
|
usethisdimension = h;
|
|
usethisratio = SCREEN_HEIGHT_PIXELS;
|
|
using_width = false;
|
|
}
|
|
else
|
|
{
|
|
// Height is bigger, so it's limited by width. Or we're exactly 4:3 already
|
|
usethisdimension = w;
|
|
usethisratio = SCREEN_WIDTH_PIXELS;
|
|
using_width = true;
|
|
}
|
|
|
|
int floor = (usethisdimension / usethisratio) * usethisratio;
|
|
int ceiling = floor + usethisratio;
|
|
|
|
int final_dimension;
|
|
|
|
if (usethisdimension - floor < ceiling - usethisdimension)
|
|
{
|
|
// Floor is nearest
|
|
final_dimension = floor;
|
|
}
|
|
else
|
|
{
|
|
// Ceiling is nearest. Or we're exactly on a multiple already
|
|
final_dimension = ceiling;
|
|
}
|
|
|
|
if (final_dimension == 0)
|
|
{
|
|
// We're way too small!
|
|
ResizeScreen(SCREEN_WIDTH_PIXELS, SCREEN_HEIGHT_PIXELS);
|
|
return;
|
|
}
|
|
|
|
if (using_width)
|
|
{
|
|
ResizeScreen(final_dimension, final_dimension / 4 * 3);
|
|
}
|
|
else
|
|
{
|
|
ResizeScreen(final_dimension * 4 / 3, final_dimension);
|
|
}
|
|
}
|
|
|
|
void Screen::GetScreenSize(int* x, int* y)
|
|
{
|
|
if (SDL_GetRendererOutputSize(m_renderer, x, y) != 0)
|
|
{
|
|
vlog_error("Could not get window size: %s", SDL_GetError());
|
|
/* Initialize to safe defaults */
|
|
*x = SCREEN_WIDTH_PIXELS;
|
|
*y = SCREEN_HEIGHT_PIXELS;
|
|
}
|
|
}
|
|
|
|
void Screen::UpdateScaling(void)
|
|
{
|
|
int width;
|
|
int height;
|
|
if (scalingMode == SCALING_STRETCH)
|
|
{
|
|
GetScreenSize(&width, &height);
|
|
}
|
|
else
|
|
{
|
|
width = SCREEN_WIDTH_PIXELS;
|
|
height = SCREEN_HEIGHT_PIXELS;
|
|
}
|
|
int result = SDL_RenderSetLogicalSize(m_renderer, width, height);
|
|
if (result != 0)
|
|
{
|
|
vlog_error("Error: could not set logical size: %s", SDL_GetError());
|
|
return;
|
|
}
|
|
|
|
result = SDL_RenderSetIntegerScale(m_renderer, (SDL_bool) (scalingMode == SCALING_INTEGER));
|
|
if (result != 0)
|
|
{
|
|
vlog_error("Error: could not set scale: %s", SDL_GetError());
|
|
}
|
|
}
|
|
|
|
void Screen::RenderPresent(void)
|
|
{
|
|
/* In certain cases, the window size might mismatch with the logical size.
|
|
* So it's better to just always call this. */
|
|
UpdateScaling();
|
|
|
|
SDL_RenderPresent(m_renderer);
|
|
graphics.clear();
|
|
}
|
|
|
|
void Screen::toggleFullScreen(void)
|
|
{
|
|
isWindowed = !isWindowed;
|
|
ResizeScreen(windowWidth, windowHeight);
|
|
|
|
if (game.currentmenuname == Menu::graphicoptions)
|
|
{
|
|
/* Recreate menu to update "resize to nearest" */
|
|
game.createmenu(game.currentmenuname, true);
|
|
}
|
|
}
|
|
|
|
void Screen::toggleScalingMode(void)
|
|
{
|
|
scalingMode = (scalingMode + 1) % NUM_SCALING_MODES;
|
|
UpdateScaling();
|
|
}
|
|
|
|
void Screen::toggleLinearFilter(void)
|
|
{
|
|
isFiltered = !isFiltered;
|
|
|
|
SDL_DestroyTexture(graphics.gameTexture);
|
|
SDL_DestroyTexture(graphics.tempShakeTexture);
|
|
|
|
graphics.gameTexture = SDL_CreateTexture(
|
|
m_renderer,
|
|
SDL_PIXELFORMAT_ARGB8888,
|
|
SDL_TEXTUREACCESS_TARGET,
|
|
SCREEN_WIDTH_PIXELS,
|
|
SCREEN_HEIGHT_PIXELS
|
|
);
|
|
|
|
graphics.tempShakeTexture = SDL_CreateTexture(
|
|
m_renderer,
|
|
SDL_PIXELFORMAT_ARGB8888,
|
|
SDL_TEXTUREACCESS_TARGET,
|
|
SCREEN_WIDTH_PIXELS,
|
|
SCREEN_HEIGHT_PIXELS
|
|
);
|
|
|
|
if (graphics.gameTexture == NULL)
|
|
{
|
|
vlog_error("Could not create game texture: %s", SDL_GetError());
|
|
return;
|
|
}
|
|
|
|
if (graphics.tempShakeTexture == NULL)
|
|
{
|
|
vlog_error("Could not create temp shake texture: %s", SDL_GetError());
|
|
return;
|
|
}
|
|
|
|
SDL_SetTextureScaleMode(
|
|
graphics.gameTexture,
|
|
isFiltered ? SDL_ScaleModeLinear : SDL_ScaleModeNearest
|
|
);
|
|
|
|
SDL_SetTextureScaleMode(
|
|
graphics.tempShakeTexture,
|
|
isFiltered ? SDL_ScaleModeLinear : SDL_ScaleModeNearest
|
|
);
|
|
}
|
|
|
|
void Screen::toggleVSync(void)
|
|
{
|
|
vsync = !vsync;
|
|
SDL_RenderSetVSync(m_renderer, (int) vsync);
|
|
|
|
recacheTextures();
|
|
}
|
|
|
|
void Screen::recacheTextures(void)
|
|
{
|
|
// Fix for d3d9, which clears target textures sometimes (ex. toggling vsync, switching fullscreen, etc...)
|
|
|
|
// Signal cached textures to be redrawn fully
|
|
graphics.backgrounddrawn = false;
|
|
graphics.foregrounddrawn = false;
|
|
graphics.towerbg.tdrawback = true;
|
|
graphics.titlebg.tdrawback = true;
|
|
|
|
if (game.ingame_titlemode)
|
|
{
|
|
// Redraw the cached gameplay texture if we're in the in-game menu.
|
|
// Additionally, reset alpha so things don't jitter when re-entering gameplay.
|
|
float oldAlpha = graphics.alpha;
|
|
graphics.alpha = 0;
|
|
gamerender();
|
|
graphics.alpha = oldAlpha;
|
|
}
|
|
}
|
|
|
|
bool Screen::isForcedFullscreen(void)
|
|
{
|
|
/* This is just a check to see if we're on a desktop or tenfoot setup.
|
|
* If you're working on a tenfoot-only build, add a def that always
|
|
* returns true!
|
|
*/
|
|
return SDL_GetHintBoolean("SteamTenfoot", SDL_FALSE);
|
|
}
|