SGL_Window* SGL_CreateWindow(const char* title, int GLMajorVersion, int GLMinorVersion, int x, int y, int w, int h, Uint32 SDLflags)
{
#if defined(_WINDOWS)
SDL_DisplayMode targetMode;
if (SDL_GetCurrentDisplayMode(0, &targetMode))
{
return NULL;
}
SDL_DisplayMode closestMode;
SDL_GetClosestDisplayMode(0, &targetMode, &closestMode);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, GLMajorVersion);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, GLMinorVersion);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SGL_Window* window = SDL_malloc(sizeof(SGL_Window));
window->window = SDL_CreateWindow
(
title,
x, y,
w, h,
SDLflags
);
window->context = SDL_GL_CreateContext(window->window);
glewExperimental = GL_TRUE;
glewInit();
#elif defined(ANDROID)
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, GLMajorVersion > 3 ? GLMajorVersion : 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
SGL_Window* window = SDL_malloc(sizeof(SGL_Window));
SDL_DisplayMode displayMode;
if (SDL_GetCurrentDisplayMode(0, &displayMode))
{
return NULL;
}
window->window = SDL_CreateWindow
(
title,
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
displayMode.w, displayMode.h,
SDLflags
);
window->context = SDL_GL_CreateContext(window->window);
#endif
SDL_Log("----------------------------------------------------------------\n");
SDL_Log("Graphics Successfully Initialized For Window: %s\n", title);
SDL_Log("OpenGL Info\n");
SDL_Log(" Version: %s\n", glGetString(GL_VERSION));
SDL_Log(" Vendor: %s\n", glGetString(GL_VENDOR));
SDL_Log(" Renderer: %s\n", glGetString(GL_RENDERER));
SDL_Log(" Shading: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
SDL_Log("----------------------------------------------------------------\n");
SGL_SetWindowIcon(window, NULL);
return window;
}
/*
* Create a new window
* @param windowName is the window's title
* @param windowWidth is the window's width
* @param windowHeight is the window's height
* @param fullScreen specifies if the window is full screen or not
*/
void SDLInterface::createWindow(std::string windowName, int windowWidth, int windowHeight, bool fullScreen) {
_windowWidth = windowWidth;
_windowHeight = windowHeight;
//Update the window flags
Uint32 flags = SDL_WINDOW_SHOWN;
if (fullScreen) {
flags |= SDL_WINDOW_MAXIMIZED | SDL_WINDOW_BORDERLESS;
}
//Create a SDL window centered into the middle of the screen
_window = SDL_CreateWindow(windowName.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, _windowWidth, _windowHeight, flags);
//Declare display mode structure to be filled in. It will allow us to get the current resolution
SDL_DisplayMode current;
SDL_GetCurrentDisplayMode(0, ¤t);
_windowWidthFullScreen = current.w;
_windowHeightFullScreen = current.h;
// if the window creation succeeded create our renderer.
if (_window != 0) {
_renderer = SDL_CreateRenderer(_window, -1, SDL_RENDERER_PRESENTVSYNC);
// Set to black
setWindowBackgroundColor(0, 0, 0, 255);
}
else {
ErrorManagement::errorRunTime("[SDL Interface] A problem occurred when the window was created");
}
}
void SDLWindow::Initialize()
{
assert(((start_location.w > 0 && start_location.h > 0) || start_location.w == start_location.h),
"If a special resolution modifier is to be used, then both length and width must be equal.");
if (start_location == USE_CURRENT_RESOLUTION)
{
SDL_DisplayMode display_mode;
assert((SDL_GetCurrentDisplayMode(DISPLAY_NUMBER, &display_mode) == 0), SDL_GetError());
start_location.w = (double)display_mode.w;
start_location.h = (double)display_mode.h;
}
if (fullscreen)
{
SDL_CreateWindowAndRenderer(0, 0,
(SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_BORDERLESS),
&window, &write_to);
// Scale so the user's code doesn't know the difference.
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear"); // make the scaled rendering look smoother.
SDL_RenderSetLogicalSize(write_to, GfxRound(start_location.w), GfxRound(start_location.h));
}
else
{
SDL_CreateWindowAndRenderer(GfxRound(start_location.w), GfxRound(start_location.h), 0, &window, &write_to);
}
SDL_SetWindowTitle(this->window, this->title);
SDL_SetRenderDrawColor(write_to, fill.r, fill.g, fill.b, fill.a);
SDL_RenderClear(write_to);
SDL_RenderPresent(write_to);
}
static void wid_intro_settings_add_default_screen_modes (void)
{
int w;
int h;
#if SDL_MAJOR_VERSION == 2 /* { */
SDL_DisplayMode mode;
SDL_GetCurrentDisplayMode(0, &mode);
w = mode.w;
h = mode.h;
#else
const SDL_VideoInfo *info = SDL_GetVideoInfo();
w = info->current_w;
h = info->current_h;
#endif
char *tmp = dynprintf("%dx%d", w, h);
int j;
for (j = 0; j < WID_INTRO_MAX_VAL - 1; j++) {
if (!wid_intro_button_value_string
[WID_INTRO_SETTINGS_ROW_WINDOW][j]) {
wid_intro_button_value_string
[WID_INTRO_SETTINGS_ROW_WINDOW][j] = tmp;
break;
}
} /* } */
}
void cWindow::RenderAt( cSurface* pImage, cPosition pSource ) {
SDL_Rect Src, Dest;
Src.w = mScreenSize.mWidth;
Src.h = mScreenSize.mHeight;
Src.x = pSource.mX + 16;
Src.y = pSource.mY + 16;
Dest.w = GetWindowSize().mWidth;
Dest.h = GetWindowSize().mHeight;
if (mWindowMode) {
Dest.x = 0;
Dest.y = 0;
}
else {
SDL_DisplayMode current;
SDL_GetCurrentDisplayMode(0, ¤t);
Dest.x = (current.w - Dest.w) / 2;
Dest.y = (current.h - Dest.h) / 2;
}
pImage->draw();
SDL_RenderCopy( mRenderer, pImage->GetTexture(), &Src, &Dest );
}
void cWindow::RenderShrunk( cSurface* pImage ) {
SDL_Rect Src, Dest;
Src.w = pImage->GetWidth();
Src.h = pImage->GetHeight();
Src.x = 0;
Src.y = 0;
Dest.w = GetWindowSize().mWidth;
Dest.h = GetWindowSize().mHeight;
if (mWindowMode) {
Dest.x = 0;
Dest.y = 0;
}
else {
SDL_DisplayMode current;
SDL_GetCurrentDisplayMode(0, ¤t);
Dest.x = (current.w - Dest.w) / 2;
Dest.y = (current.h - Dest.h) / 2;
}
pImage->draw();
SDL_RenderCopy( mRenderer, pImage->GetTexture(), &Src, &Dest);
}
Vector2 getDesktopSize( int display_index )
{
SDL_DisplayMode current;
// Get current display mode of all displays.
int should_be_zero = SDL_GetCurrentDisplayMode(display_index, ¤t);
return Vector2( (float)current.w, (float)current.h );
}
static void GfxInfo_f(void)
{
SDL_DisplayMode current;
Com_Printf_State(PRINT_ALL, "\nGL_VENDOR: %s\n", glConfig.vendor_string );
Com_Printf_State(PRINT_ALL, "GL_RENDERER: %s\n", glConfig.renderer_string );
Com_Printf_State(PRINT_ALL, "GL_VERSION: %s\n", glConfig.version_string );
if (r_showextensions.value) {
Com_Printf_State(PRINT_ALL, "GL_EXTENSIONS: %s\n", glConfig.extensions_string);
}
Com_Printf_State(PRINT_ALL, "PIXELFORMAT: color(%d-bits) Z(%d-bit)\n stencil(%d-bits)\n", glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits);
if (SDL_GetCurrentDisplayMode(VID_DisplayNumber(r_fullscreen.value), ¤t) != 0) {
current.refresh_rate = 0; // print 0Hz if we run into problem fetching data
}
Com_Printf_State(PRINT_ALL, "MODE: %d x %d @ %d Hz ", current.w, current.h, current.refresh_rate);
if (r_fullscreen.integer) {
Com_Printf_State(PRINT_ALL, "[fullscreen]\n");
} else {
Com_Printf_State(PRINT_ALL, "[windowed]\n");
}
Com_Printf_State(PRINT_ALL, "CONRES: %d x %d\n", r_conwidth.integer, r_conheight.integer );
}
void Adafruit_NeoPixel::initializeSdl() {
if (sdlInitialized) return;
sdlInitialized = true;
if (SDL_Init(SDL_INIT_VIDEO) != 0) posixino.fatal("SDL init failed",3);
SDL_GetCurrentDisplayMode(SDL_DISPLAY,¤t);
calcDims();
window = SDL_CreateWindow(
"Posixino",
windowPosX,
windowPosY,
windowWidth,
windowHeight,
SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS
);
screenSurface = SDL_GetWindowSurface(window);
SDL_FillRect(screenSurface,NULL,0);
SDL_UpdateWindowSurface(window);
} // initializeSdl()
void Video::initialize(const std::string& name, const std::string& icon, Console& console)
{
console.printLine("\n===Video initialization===");
// Get current video mode
SDL_DisplayMode currentVideoMode;
if (SDL_GetCurrentDisplayMode(0, ¤tVideoMode))
{
D6_THROW(VideoException, std::string("Unable to determine current video mode: ") + SDL_GetError());
}
// Set graphics mode
view = ViewParameters(0.1f, 100.0f, 45.0f);
#ifdef D6_DEBUG
// Running fullscren makes switching to debugger problematic with SDL (focus is captured)
screen = ScreenParameters(1280, 900, 32, 0, false);
#else
screen = ScreenParameters(currentVideoMode.w, currentVideoMode.h, 32, 0, true);
#endif
window = createWindow(name, icon, screen, console);
glContext = createContext(screen, console);
SDL_ShowCursor(SDL_DISABLE);
setMode(Mode::Orthogonal);
}
void initSDL()
{
SDL_DisplayMode video_info;
int init_flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK;
if(SDL_Init(init_flags) < 0)
{
printf("SDL Failed to Init!!!! (%s)\n", SDL_GetError());
borExit(0);
}
SDL_ShowCursor(SDL_DISABLE);
atexit(SDL_Quit);
#ifdef LOADGL
if(SDL_GL_LoadLibrary(NULL) < 0)
{
printf("Warning: couldn't load OpenGL library (%s)\n", SDL_GetError());
}
#endif
SDL_GetCurrentDisplayMode(0, &video_info);
nativeWidth = video_info.w;
nativeHeight = video_info.h;
printf("debug:nativeWidth, nativeHeight, bpp, Hz %d, %d, %d, %d\n", nativeWidth, nativeHeight, SDL_BITSPERPIXEL(video_info.format), video_info.refresh_rate);
SDL_initFramerate(&framerate_manager);
SDL_setFramerate(&framerate_manager, 200);
}
bool RWindow::initializeSDL()
{
SDL_DisplayMode current;
if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
std::cerr << "Could not initialize SDL: " << SDL_GetError();
std::cerr << std::endl;
std::exit(1);
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
if(SDL_GetCurrentDisplayMode(0, ¤t) != 0)
{
// In case of error...
std::cerr << "Could not get display mode for video display: ";
std::cerr << SDL_GetError() << std::endl;
return false;
}
else
{
// Everything is normal
m_width = current.w;
m_height = current.h;
}
m_window = SDL_CreateWindow(
m_title.data(),
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
m_width, m_height,
SDL_WINDOW_OPENGL |
SDL_WINDOW_FULLSCREEN_DESKTOP |
SDL_WINDOW_HIDDEN);
if(m_window == nullptr)
{
std::cerr << "Could not iniialize SDL Window: " << SDL_GetError();
std::cerr << std::endl;
return false;
}
m_surface = SDL_GetWindowSurface(m_window);
m_context = SDL_GL_CreateContext(m_window);
//Init cursors
m_systemCursors[0] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
m_systemCursors[1] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_IBEAM);
m_systemCursors[2] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_WAIT);
m_systemCursors[3] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_NO);
m_systemCursors[4] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
for(unsigned i = 0; i < 4; ++i)
m_customCursors[i] = nullptr;
return true;
}
void GHOST_SystemSDL::getMainDisplayDimensions(GHOST_TUns32 &width, GHOST_TUns32 &height) const
{
SDL_DisplayMode mode;
SDL_GetCurrentDisplayMode(0, &mode); /* note, always 0 display */
width = mode.w;
height = mode.h;
}
static bool SetScreenParmsFullscreen( glimpParms_t parms )
{
SDL_DisplayMode m = {0};
int displayIdx = ScreenParmsHandleDisplayIndex( parms );
if( displayIdx < 0 )
return false;
// get current mode of display the window should be full-screened on
SDL_GetCurrentDisplayMode( displayIdx, &m );
// change settings in that display mode according to parms
// FIXME: check if refreshrate, width and height are supported?
// m.refresh_rate = parms.displayHz;
m.w = parms.width;
m.h = parms.height;
// set that displaymode
if( SDL_SetWindowDisplayMode( window, &m ) < 0 )
{
common->Warning( "Couldn't set window mode for fullscreen, reason: %s", SDL_GetError() );
return false;
}
// if we're currently not in fullscreen mode, we need to switch to fullscreen
if( !( SDL_GetWindowFlags( window ) & SDL_WINDOW_FULLSCREEN ) )
{
if( SDL_SetWindowFullscreen( window, SDL_TRUE ) < 0 )
{
common->Warning( "Couldn't switch to fullscreen mode, reason: %s!", SDL_GetError() );
return false;
}
}
return true;
}
void Game::initWindow()
{
if (config_->fullscreen) {
SDL_DisplayMode mode;
if (SDL_GetCurrentDisplayMode(0, &mode) == -1) {
std::stringstream message;
message << "Failed to get fullscreen display mode: "
<< SDL_GetError();
throw Error(message.str());
}
windowWidth_ = mode.w;
windowHeight_ = mode.h;
}
Uint32 flags = SDL_WINDOW_OPENGL;
if (config_->fullscreen) {
flags |= SDL_WINDOW_FULLSCREEN;
}
window_ = SDL_CreateWindow("Crust", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, windowWidth_,
windowHeight_, flags);
if (window_ == 0) {
std::stringstream message;
message << "Failed to create window: " << SDL_GetError();
throw Error(message.str());
}
if (config_->fullscreen) {
SDL_GetWindowSize(window_, &windowWidth_, &windowHeight_);
}
}
int SDL_COMPAT_GetBitsPerPixel(void)
{
int bpp;
SDL_DisplayMode mode;
SDL_GetCurrentDisplayMode(0, &mode);
bpp = SDL_BITSPERPIXEL(mode.format);
return (bpp==24)? 32 : bpp;
}
bool CheckAvailableVideoModes()
{
// Get available fullscreen/hardware modes
const int numDisplays = SDL_GetNumVideoDisplays();
SDL_DisplayMode ddm = {0, 0, 0, 0, nullptr};
SDL_DisplayMode cdm = {0, 0, 0, 0, nullptr};
// ddm is virtual, contains all displays in multi-monitor setups
// for fullscreen windows with non-native resolutions, ddm holds
// the original screen mode and cdm is the changed mode
SDL_GetDesktopDisplayMode(0, &ddm);
SDL_GetCurrentDisplayMode(0, &cdm);
LOG(
"[GL::%s] desktop={%ix%ix%ibpp@%iHz} current={%ix%ix%ibpp@%iHz}",
__func__,
ddm.w, ddm.h, SDL_BPP(ddm.format), ddm.refresh_rate,
cdm.w, cdm.h, SDL_BPP(cdm.format), cdm.refresh_rate
);
for (int k = 0; k < numDisplays; ++k) {
const int numModes = SDL_GetNumDisplayModes(k);
if (numModes <= 0) {
LOG("\tdisplay=%d bounds=N/A modes=N/A", k + 1);
continue;
}
SDL_DisplayMode cm = {0, 0, 0, 0, nullptr};
SDL_DisplayMode pm = {0, 0, 0, 0, nullptr};
SDL_Rect db;
SDL_GetDisplayBounds(k, &db);
LOG("\tdisplay=%d modes=%d bounds={x=%d, y=%d, w=%d, h=%d}", k + 1, numModes, db.x, db.y, db.w, db.h);
for (int i = 0; i < numModes; ++i) {
SDL_GetDisplayMode(k, i, &cm);
const float r0 = (cm.w * 9.0f) / cm.h;
const float r1 = (cm.w * 10.0f) / cm.h;
const float r2 = (cm.w * 16.0f) / cm.h;
// skip legacy (3:2, 4:3, 5:4, ...) and weird (10:6, ...) ratios
if (r0 != 16.0f && r1 != 16.0f && r2 != 25.0f)
continue;
// show only the largest refresh-rate and bit-depth per resolution
if (cm.w == pm.w && cm.h == pm.h && (SDL_BPP(cm.format) < SDL_BPP(pm.format) || cm.refresh_rate < pm.refresh_rate))
continue;
LOG("\t\t[%2i] %ix%ix%ibpp@%iHz", int(i + 1), cm.w, cm.h, SDL_BPP(cm.format), cm.refresh_rate);
pm = cm;
}
}
// we need at least 24bpp or window-creation will fail
return (SDL_BPP(ddm.format) >= 24);
}
void ZL_UpdateTPFLimit()
{
SDL_DisplayMode DisplayMode = { 0, 0, 0, 0, 0 };
SDL_GetCurrentDisplayMode(0, &DisplayMode);
if (!DisplayMode.refresh_rate) return;
bool UseVSync = (ZL_TPF_Limit && ZL_TPF_Limit == (unsigned int)((1000.0f / (float)DisplayMode.refresh_rate)-0.0495f));
SDL_GL_SetSwapInterval(UseVSync ? 1 : 0);
ZL_MainApplicationFlags = (UseVSync ? ZL_MainApplicationFlags & ~ZL_APPLICATION_NOVSYNC : ZL_MainApplicationFlags | ZL_APPLICATION_NOVSYNC);
}
Coord2i getCurrentResolution(int display)
{
SDL_DisplayMode mode;
if(SDL_GetCurrentDisplayMode(display, &mode) == 0)
{
return{mode.w, mode.h};
}
throw std::runtime_error("Could not get the current resolution of display " + std::to_string(display) + ". ");
}
MainGame::MainGame()
{
ConfigurationManager configManager(resourcePath() + "configuration.txt");
//if SDL fails, close program
if (SDL_Init(SDL_INIT_VIDEO)) throw std::logic_error("Failed to initialize SDL! " + std::string(SDL_GetError()));
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
if (configManager.GetItem<bool>("Multisampling"))
{
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, configManager.GetItem<int>("MultisampleBuffers"));
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, configManager.GetItem<int>("MultisampleSamples"));
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
SDL_DisplayMode mode; SDL_GetCurrentDisplayMode(0, &mode);
Uint32 windowFlags = SDL_WINDOW_OPENGL;
size_t width = configManager.GetItem<float>("WindowWidth"), height = configManager.GetItem<float>("WindowHeight");
if (configManager.GetItem<bool>("Fullscreen"))
{
// width = mode.w; height = mode.h;
windowFlags|=SDL_WINDOW_FULLSCREEN_DESKTOP;
}
window = SDL_CreateWindow("Genetic Algorithm", 0, 0, width, height, windowFlags);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetSwapInterval(1);
SDL_SetRelativeMouseMode(SDL_TRUE);
if (window==nullptr) throw std::logic_error("Window failed to be initialized");
SDL_GLContext context = SDL_GL_CreateContext(window);
if (context==nullptr) throw std::logic_error("SDL_GL could not be initialized!");
int cpuCount = SDL_GetCPUCount();
GLManager glManager(resourcePath() + "fragmentShader.glsl", resourcePath() + "vertexShader.glsl", configManager);
std::string fileLoc =resourcePath() + "performance.csv";
EvolutionSystem evolutionSystem(fileLoc, configManager, cpuCount);
Camera camera(configManager.GetItem<float>("WindowWidth"), configManager.GetItem<float>("WindowHeight"), configManager);
while (GameState!=GameState::EXIT)
{
Update(evolutionSystem);
camera.Update();
glManager.Programs[0].SetMatrix4("transformMatrix", glm::value_ptr(camera.GetTransformMatrix()));
Draw(evolutionSystem);
SDL_GL_SwapWindow(window);
HandleEvents(evolutionSystem,camera);
}
}
int
main(int argc, char *argv[])
{
SDL_DisplayMode mode;
int num_displays, dpy;
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
/* Load the SDL library */
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
return 1;
}
SDL_Log("Using video target '%s'.\n", SDL_GetCurrentVideoDriver());
num_displays = SDL_GetNumVideoDisplays();
SDL_Log("See %d displays.\n", num_displays);
for (dpy = 0; dpy < num_displays; dpy++) {
const int num_modes = SDL_GetNumDisplayModes(dpy);
SDL_Rect rect = { 0, 0, 0, 0 };
int m;
SDL_GetDisplayBounds(dpy, &rect);
SDL_Log("%d: \"%s\" (%dx%d, (%d, %d)), %d modes.\n", dpy, SDL_GetDisplayName(dpy), rect.w, rect.h, rect.x, rect.y, num_modes);
if (SDL_GetCurrentDisplayMode(dpy, &mode) == -1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " CURRENT: failed to query (%s)\n", SDL_GetError());
} else {
print_mode("CURRENT", &mode);
}
if (SDL_GetDesktopDisplayMode(dpy, &mode) == -1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " DESKTOP: failed to query (%s)\n", SDL_GetError());
} else {
print_mode("DESKTOP", &mode);
}
for (m = 0; m < num_modes; m++) {
if (SDL_GetDisplayMode(dpy, m, &mode) == -1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " MODE %d: failed to query (%s)\n", m, SDL_GetError());
} else {
char prefix[64];
SDL_snprintf(prefix, sizeof (prefix), " MODE %d", m);
print_mode(prefix, &mode);
}
}
SDL_Log("\n");
}
return 0;
}
int16 cWindow::CalculateFullscreenSize() {
SDL_DisplayMode current;
SDL_GetCurrentDisplayMode(0, ¤t);
int16 Multiplier = 1;
while ((mOriginalResolution.mWidth * Multiplier) <= current.w && (mOriginalResolution.mHeight * Multiplier) <= current.h ) {
++Multiplier;
}
return --Multiplier;
}
bool cWindow::CanChangeToMultiplier(const size_t pNewMultiplier) {
SDL_DisplayMode current;
SDL_GetCurrentDisplayMode(0, ¤t);
if ((mOriginalResolution.mWidth * pNewMultiplier >= (unsigned int) current.w ||
mOriginalResolution.mHeight * pNewMultiplier >= (unsigned int) current.h) ||
pNewMultiplier <= 0)
return false;
return true;
}
void cWindow::CalculateWindowSize() {
SDL_DisplayMode current;
SDL_GetCurrentDisplayMode(0, ¤t);
while ((mOriginalResolution.mWidth * mWindow_Multiplier) <= (unsigned int) (current.w / 2) &&
(mOriginalResolution.mHeight * mWindow_Multiplier) <= (unsigned int) (current.h / 2)) {
++mWindow_Multiplier;
}
SetWindowSize(mWindow_Multiplier);
}
Dimension2i GraphicsEngine::getMaximumWindowSize() {
SDL_DisplayMode current;
if (SDL_GetCurrentDisplayMode(0, ¤t) == 0) {
return Dimension2i(current.w, current.h);
}
else {
std::cout << "Failed to get window data" << std::endl;
std::cout << "GraphicsEngine::getMaximumWindowSize() -> return (0, 0)" << std::endl;
return Dimension2i(0, 0);
}
}
int query_display_mode(SDL_DisplayMode *display_mode){
SDL_DisplayMode current;
int i;
for(i = 0; i < SDL_GetNumVideoDisplays(); i++){
int result = SDL_GetCurrentDisplayMode(i,¤t);
if(result == 0){
*display_mode = current;
return 0;
}
}
return -1;
}
static int lua_SDL_GetCurrentDisplayMode(lutok::state& state){
Lua_SDL_DisplayMode & dm = LOBJECT_INSTANCE(Lua_SDL_DisplayMode);
SDL_DisplayMode * mode = new SDL_DisplayMode;
if (SDL_GetCurrentDisplayMode(state.to_integer(1), mode) == 0){
dm.push(mode);
return 1;
}else{
delete mode;
return 0;
}
}
void InfiLInitDisplays() {
uint32 sz = SDL_GetNumVideoDisplays();
disp_list.resize( sz );
for ( uint32 i=0;i<sz;i++ ) {
SDL_DisplayMode md;
SDL_GetCurrentDisplayMode( i, &md );
disp_list[i].format = md.format;
disp_list[i].width = md.w;
disp_list[i].height = md.h;
disp_list[i].refresh_rate = md.refresh_rate;
disp_list[i].driver = md.driverdata;
}
}
static void video_check_fullscreen_sanity(void) {
SDL_DisplayMode mode;
if(SDL_GetCurrentDisplayMode(SDL_GetWindowDisplayIndex(video.window), &mode)) {
log_warn("SDL_GetCurrentDisplayMode failed: %s", SDL_GetError());
return;
}
if(video.current.width != mode.w || video.current.height != mode.h) {
log_warn("BUG: window is not actually fullscreen after modesetting. Video mode: %ix%i, window size: %ix%i",
mode.w, mode.h, video.current.width, video.current.height);
}
}
Boolean Surface::create(String name, vec4 const& viewport, Boolean fullscreen)
{
# ifdef GLES
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, GLES);
// MSAA
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 16);
# else
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, GL);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
# endif
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
IntU flags=SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN;
# ifdef TARGET_OS_IPHONE
flags|=SDL_WINDOW_FULLSCREEN;
flags|=SDL_WINDOW_BORDERLESS;
flags|=SDL_WINDOW_RESIZABLE;
SDL_DisplayMode displayMode;
SDL_GetCurrentDisplayMode(0, &displayMode);
m_viewport.z=displayMode.w;
m_viewport.w=displayMode.h;
# else
if(fullscreen)
flags|=SDL_WINDOW_FULLSCREEN;
m_viewport=viewport;
# endif
m_window=SDL_CreateWindow(name.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, m_viewport.z, m_viewport.w, flags);
if(!m_window)
{
dbge3("Failed to initialize window [" << SDL_GetError() << "]");
return false;
}
createContext(name);
return true;
}
