sdl2helper.cpp

Go to the documentation of this file.

/*
 * The ManaPlus Client
 * Copyright (C) 2013-2019 The ManaPlus Developers
 * Copyright (C) 2019-2021 Andrei Karas
 *
 * This file is part of The ManaPlus Client.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifdef USE_SDL2
 
#include "utils/sdl2helper.h"
 
#include "logger.h"
 
#include "utils/foreach.h"
#include "utils/sdl2logger.h"
#include "utils/stringutils.h"
 
#include <algorithm>
 
PRAGMA48(GCC diagnostic push)
PRAGMA48(GCC diagnostic ignored "-Wshadow")
#include <SDL_events.h>
#include <SDL_hints.h>
#include <SDL_render.h>
#include <SDL_syswm.h>
PRAGMA48(GCC diagnostic pop)
 
#include "debug.h"
 
bool SDL::getAllVideoModes(StringVect &modeList)
{
 std::set<std::string> modes;
 const int numDisplays = SDL_GetNumVideoDisplays();
 for (int display = 0; display < numDisplays; display ++)
 {
 const int numModes = SDL_GetNumDisplayModes(display);
 if (numModes > 0)
 {
 for (int f = 0; f < numModes; f ++)
 {
 SDL_DisplayMode mode;
 SDL_GetDisplayMode(display, f, &mode);
 const int w = mode.w;
 const int h = mode.h;
 logger->log("%dx%dx%d", w, h, mode.refresh_rate);
 modes.insert(strprintf("%dx%d", w, h));
 }
 }
 }
 FOR_EACH (std::set<std::string>::const_iterator, it, modes)
 modeList.push_back(*it);
 return true;
}
 
void SDL::SetWindowTitle(SDL_Window *const window, const char *const title)
{
 SDL_SetWindowTitle(window, title);
}
 
void SDL::SetWindowIcon(SDL_Window *const window, SDL_Surface *const icon)
{
 SDL_SetWindowIcon(window, icon);
}
 
void SDL::grabInput(SDL_Window *const window, const bool grab)
{
 SDL_SetWindowGrab(window, grab ? SDL_TRUE : SDL_FALSE);
}
 
void SDL::setGamma(SDL_Window *const window, const float gamma)
{
 SDL_SetWindowBrightness(window, gamma);
}
 
void SDL::setVsync(const int val)
{
 SDL_GL_SetSwapInterval(val);
}
 
bool SDL::getWindowWMInfo(SDL_Window *const window, SDL_SysWMinfo *const info)
{
 return SDL_GetWindowWMInfo(window, info);
}
 
SDL_Thread *SDL::createThread(SDL_ThreadFunction fn,
 const char *restrict const name,
 void *restrict const data)
{
 return SDL_CreateThread(fn, name, data);
}
 
void *SDL::createGLContext(SDL_Window *const window,
 const int major,
 const int minor,
 const int profile)
{
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile);
// SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
 SDL_ClearError();
 void *context = SDL_GL_CreateContext(window);
 if (context == nullptr)
 {
 logger->log("Error to switch to context %d.%d: %s",
 major,
 minor,
 SDL_GetError());
 }
 if (context == nullptr && (major > 3 || (major == 3 && minor > 3)))
 {
 logger->log("Try fallback to OpenGL 3.3 context");
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
 SDL_ClearError();
 context = SDL_GL_CreateContext(window);
 if (context == nullptr)
 {
 logger->log("Error to switch to context 3.3: %s",
 SDL_GetError());
 }
 if (context == nullptr && profile == 0x01)
 {
 logger->log("Try fallback to OpenGL 3.3 compatibility context");
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, 0x02);
 SDL_ClearError();
 context = SDL_GL_CreateContext(window);
 if (context == nullptr)
 {
 logger->log("Error to switch to compatibility context 3.3: %s",
 SDL_GetError());
 }
 }
 }
 if (context == nullptr && (major > 3 || (major == 3 && minor > 0)))
 {
 logger->log("Error to switch to core context %d.%d: %s",
 major,
 minor,
 SDL_GetError());
 logger->log("Try fallback to OpenGL 3.0 core context");
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile);
 context = SDL_GL_CreateContext(window);
 if (context == nullptr)
 {
 logger->log("Error to switch to core context 3.0: %s",
 SDL_GetError());
 }
 }
 if (context == nullptr && (major > 2 || (major == 2 && minor > 1)))
 {
 logger->log("Try fallback to OpenGL 2.1 compatibility context");
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
 SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, 0x02);
 context = SDL_GL_CreateContext(window);
 if (context == nullptr)
 {
 logger->log("Error to switch to compatibility context 2.1: %s",
 SDL_GetError());
 }
 }
 if (context == nullptr)
 {
 logger->log("Cant find working context.");
 }
 return context;
}
 
void SDL::makeCurrentContext(void *const context A_UNUSED)
{
}
 
void SDL::initLogger()
{
 SDL2Logger::init();
}
 
void SDL::setLogLevel(const int level)
{
 SDL2Logger::setLogLevel(level);
}
 
void SDL::WaitThread(SDL_Thread *const thread)
{
 if (thread != nullptr)
 SDL_WaitThread(thread, nullptr);
}
 
bool SDL::PollEvent(SDL_Event *event)
{
 SDL_PumpEvents();
 return SDL_PeepEvents(event,
 1,
 SDL_GETEVENT,
 SDL_FIRSTEVENT,
 SDL_LASTEVENT) > 0;
}
 
void SDL::allowScreenSaver(const bool allow)
{
 if (allow)
 {
#if SDL_VERSION_ATLEAST(2, 0, 2)
 SDL_SetHintWithPriority(SDL_HINT_VIDEO_ALLOW_SCREENSAVER,
 "1",
 SDL_HINT_NORMAL);
#endif // SDL_VERSION_ATLEAST(2, 0, 2)
 SDL_EnableScreenSaver();
 }
 else
 {
#if SDL_VERSION_ATLEAST(2, 0, 2)
 SDL_SetHintWithPriority(SDL_HINT_VIDEO_ALLOW_SCREENSAVER,
 "0",
 SDL_HINT_NORMAL);
#endif // SDL_VERSION_ATLEAST(2, 0, 2)
 SDL_DisableScreenSaver();
 }
}
 
void SDL::getRenderers(StringVect &list,
 const std::string &currentRenderer)
{
 SDL_RendererInfo info;
 const int num = SDL_GetNumRenderDrivers();
 for (int f = 0; f < num; f ++)
 {
 if (!SDL_GetRenderDriverInfo(f, &info))
 list.push_back(info.name);
 }
 if (!currentRenderer.empty())
 {
 bool found(false);
 FOR_EACH (StringVectCIter, it, list)
 {
 if (*it == currentRenderer)
 {
 found = true;
 break;
 }
 }
 if (!found)
 list.push_back(currentRenderer);
 }
 std::sort(list.begin(), list.end());
}
 
void SDL::setRendererHint(const std::string &driver)
{
 if (!driver.empty())
 {
 SDL_SetHintWithPriority(SDL_HINT_RENDER_DRIVER,
 driver.c_str(),
 SDL_HINT_NORMAL);
 }
}
 
#endif // USE_SDL2