void
DirectFB_QuitModes(_THIS)
{
SDL_DisplayMode tmode;
int i;
for (i = 0; i < _this->num_displays; ++i) {
SDL_VideoDisplay *display = &_this->displays[i];
DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;
SDL_GetDesktopDisplayMode(i, &tmode);
tmode.format = SDL_PIXELFORMAT_UNKNOWN;
DirectFB_SetDisplayMode(_this, display, &tmode);
SDL_GetDesktopDisplayMode(i, &tmode);
DirectFB_SetDisplayMode(_this, display, &tmode);
if (dispdata->layer) {
SDL_DFB_CHECK(dispdata->
layer->SetCooperativeLevel(dispdata->layer,
DLSCL_ADMINISTRATIVE));
SDL_DFB_CHECK(dispdata->
layer->SetCursorOpacity(dispdata->layer, 0x00));
SDL_DFB_CHECK(dispdata->
layer->SetCooperativeLevel(dispdata->layer,
DLSCL_SHARED));
}
SDL_DFB_RELEASE(dispdata->layer);
SDL_DFB_RELEASE(dispdata->vidlayer);
}
}
/**
* Constructeur qui ouvre une fenêtre avec la SDL et définit le contexte.
* La fenêtre est destinée à être remplie par des visites,
* puis mise à jour par un appel à render.
*/
OpenGLVisiteur::OpenGLVisiteur(bool fullscreen_):
fullscreen(fullscreen_)
{
SDL_DisplayMode dm;
SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER);
if (SDL_GetDesktopDisplayMode(0, &dm) != 0) {
SDL_Log("SDL_GetDesktopDisplayMode failed: %s", SDL_GetError());
exit(EXIT_FAILURE);
}
if(fullscreen){
screenWidth=dm.w;
screenHeight=dm.h;
}else{
screenWidth=800;
screenHeight=600;
}
window=SDL_CreateWindow
("2eme affichage",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
screenWidth,
screenHeight,
SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN|
(fullscreen?SDL_WINDOW_FULLSCREEN_DESKTOP:0));
context= SDL_GL_CreateContext(window);
draws=glGenLists(1);
glNewList(1,GL_COMPILE);
glColor3f(1,0,0);
}
int
SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags)
{
int i, actual_bpp = 0;
if (!SDL_GetVideoDevice()) {
return 0;
}
if (!(flags & SDL_FULLSCREEN)) {
SDL_DisplayMode mode;
SDL_GetDesktopDisplayMode(GetVideoDisplay(), &mode);
return SDL_BITSPERPIXEL(mode.format);
}
for (i = 0; i < SDL_GetNumDisplayModes(GetVideoDisplay()); ++i) {
SDL_DisplayMode mode;
SDL_GetDisplayMode(GetVideoDisplay(), i, &mode);
if (!mode.w || !mode.h || (width == mode.w && height == mode.h)) {
if (!mode.format) {
return bpp;
}
if (SDL_BITSPERPIXEL(mode.format) >= (Uint32) bpp) {
actual_bpp = SDL_BITSPERPIXEL(mode.format);
}
}
}
return actual_bpp;
}
static int set_sdl_video_size(unsigned short int w, unsigned short int h)
{
if (window)
SDL_DestroyWindow(window);
if (!w || !h) {
w = 640;
h = 480;
if (flags & SDL_WINDOW_FULLSCREEN) {
SDL_DisplayMode mode;
if (!SDL_GetDesktopDisplayMode(0, &mode)) {
w = mode.w;
h = mode.h;
} else
log_e("SDL_GetDesktopDisplayMode: %s",
SDL_GetError());
}
}
log_i("%ux%u", w, h);
window = SDL_CreateWindow("greedy",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
w, h, flags);
if (!window)
log_p("SDL_CreateWindow: %s", SDL_GetError());
SDL_Delay(50);
return 0;
}
/**
* Returns the dimensions of the main display on this system.
* \return The dimension of the main display.
*/
void GHOST_SystemSDL::getAllDisplayDimensions(GHOST_TUns32 &width, GHOST_TUns32 &height) const
{
SDL_DisplayMode mode;
SDL_GetDesktopDisplayMode(0, &mode); /* note, always 0 display */
width = mode.w;
height = mode.h;
}
void fs_ml_toggle_fullscreen() {
fs_log("fs_ml_toggle_fullscreen\n");
#ifdef USE_SDL2
if (g_fs_emu_video_fullscreen_mode == FULLSCREEN_WINDOW) {
fs_emu_warning("Cannot toggle fullscreen with fullscreen-mode=window");
return;
}
int display_index = 0;
SDL_DisplayMode mode;
memset(&mode, 0, sizeof(SDL_DisplayMode));
if (SDL_GetDesktopDisplayMode(display_index, &mode) == 0) {
SDL_SetWindowDisplayMode(g_fs_ml_window, &mode);
}
g_fs_emu_video_fullscreen = !g_fs_emu_video_fullscreen;
int flags = 0;
if (g_fs_emu_video_fullscreen) {
if (g_fs_emu_video_fullscreen_mode == FULLSCREEN_DESKTOP) {
flags = SDL_WINDOW_FULLSCREEN_DESKTOP;
}
else {
flags = SDL_WINDOW_FULLSCREEN;
}
}
SDL_SetWindowFullscreen(g_fs_ml_window, flags);
#else
g_fs_emu_video_fullscreen = !g_fs_emu_video_fullscreen;
destroy_opengl_state();
set_video_mode();
recreate_opengl_state();
#endif
}
QRect StreamingPreferences::getDesktopResolution(int displayIndex)
{
if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
SDL_GetError());
return QRect();
}
if (displayIndex >= SDL_GetNumVideoDisplays()) {
SDL_QuitSubSystem(SDL_INIT_VIDEO);
return QRect();
}
SDL_DisplayMode mode;
int err = SDL_GetDesktopDisplayMode(displayIndex, &mode);
SDL_QuitSubSystem(SDL_INIT_VIDEO);
if (err == 0) {
return QRect(0, 0, mode.w, mode.h);
}
else {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"SDL_GetDesktopDisplayMode() failed: %s",
SDL_GetError());
return QRect();
}
}
static bool CreateWindow (int width, int height, int bpp, TLN_WindowFlags flags, char* file_overlay)
{
SDL_DisplayMode mode;
SDL_Surface* surface = NULL;
int factor;
int rflags;
char quality;
Uint32 format = 0;
if (SDL_Init (SDL_INIT_VIDEO|SDL_INIT_JOYSTICK) != 0)
return false;
/* obtiene tamaño escritorio y tamaño máximo de ventana*/
SDL_GetDesktopDisplayMode (0, &mode);
if (!(flags & CWF_FULLSCREEN))
{
factor = (flags >> 2) & 0x07;
if (!factor)
{
factor = 1;
while (width*(factor + 1) < mode.w && height*(factor + 1) < mode.h && factor < 3)
factor++;
}
wnd_width = width*factor;
wnd_height = height*factor;
dstrect.x = 0;
dstrect.y = 0;
dstrect.w = wnd_width;
dstrect.h = wnd_height;
}
static void VID_SetupResolution(void)
{
SDL_DisplayMode display_mode;
if (r_fullscreen.integer == 1) {
if ((!vid_width.integer || !vid_height.integer)) {
if (!SDL_GetDesktopDisplayMode(0, &display_mode)) {
glConfig.vidWidth = display_mode.w;
glConfig.vidHeight = display_mode.h;
} else {
glConfig.vidWidth = 1024;
glConfig.vidHeight = 768;
Cvar_LatchedSetValue(&vid_width, 1024); // Try some default if nothing is set and we failed
Cvar_LatchedSetValue(&vid_height, 768); // to get desktop resolution
Com_Printf("warning: failed to get desktop resolution, using 1024x768 failsafe\n");
}
} else {
glConfig.vidWidth = bound(320, vid_width.integer, vid_width.integer);
glConfig.vidHeight = bound(200, vid_height.integer, vid_height.integer);
}
} else {
if (!vid_win_width.integer || !vid_win_height.integer) {
Cvar_LatchedSetValue(&vid_win_width, 640);
Cvar_LatchedSetValue(&vid_win_height, 480);
}
glConfig.vidWidth = bound(320, vid_win_width.integer, vid_win_width.integer);
glConfig.vidHeight = bound(200, vid_win_height.integer, vid_win_height.integer);
}
}
void SDL2Window::changeMode(DisplayMode mode, bool makeFullscreen) {
if(!m_window) {
m_size = mode.resolution;
m_fullscreen = makeFullscreen;
return;
}
if(m_fullscreen == makeFullscreen && m_size == mode.resolution) {
return;
}
bool wasFullscreen = m_fullscreen;
m_renderer->beforeResize(wasFullscreen || makeFullscreen);
if(makeFullscreen) {
if(mode.resolution != Vec2i_ZERO) {
SDL_DisplayMode sdlmode;
SDL_DisplayMode requested;
requested.driverdata = NULL;
requested.format = 0;
requested.refresh_rate = 0;
requested.w = mode.resolution.x;
requested.h = mode.resolution.y;
int display = SDL_GetWindowDisplayIndex(m_window);
if(!SDL_GetClosestDisplayMode(display, &requested, &sdlmode)) {
if(SDL_GetDesktopDisplayMode(display, &sdlmode)) {
return;
}
}
if(SDL_SetWindowDisplayMode(m_window, &sdlmode) < 0) {
return;
}
}
}
Uint32 flags = getSDLFlagsForMode(mode.resolution, makeFullscreen);
if(SDL_SetWindowFullscreen(m_window, flags) < 0) {
return;
}
if(!makeFullscreen) {
SDL_SetWindowSize(m_window, mode.resolution.x, mode.resolution.y);
}
if(wasFullscreen != makeFullscreen) {
onToggleFullscreen(makeFullscreen);
}
if(makeFullscreen) {
// SDL regrettably sends resize events when a fullscreen window is minimized.
// Because of that we ignore all size change events when fullscreen.
// Instead, handle the size change here.
updateSize();
}
tick();
}
QSize SDLInteraction::getCurrentResolution()
{
SDL_DisplayMode mode;
SDL_GetDesktopDisplayMode(0, &mode);
return QSize(mode.w, mode.h);
}
VideoMode VideoMode::getDesktopMode()
{
SDL_DisplayMode dm;
if (SDL_GetDesktopDisplayMode(0, &dm) != 0)
return {};
return {(u32)dm.w, (u32)dm.h, SDL_BITSPERPIXEL(dm.format)};
}
bool Window::fullscreen()
{
SDL_DisplayMode dm;
SDL_GetDesktopDisplayMode(0, &dm);
SDL_SetWindowDisplayMode(window, &dm);
SDL_SetWindowFullscreen(window, !(SDL_GetWindowFlags(window)&SDL_WINDOW_FULLSCREEN));
return true;
}
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);
}
Coord2i getStartingResolution(int display)
{
SDL_DisplayMode mode;
if(SDL_GetDesktopDisplayMode(display, &mode) == 0)
{
return{mode.w, mode.h};
}
throw std::runtime_error("Could not get the initial resolution of display " + std::to_string(display) + ". ");
}
void SDLPlatform::getDesktopResolution( Resolution & _resolution ) const
{
SDL_DisplayMode dm;
if (SDL_GetDesktopDisplayMode(0, &dm) == 0)
{
_resolution.setWidth(static_cast<uint32_t>(dm.w));
_resolution.setHeight(static_cast<uint32_t>(dm.h));
}
}
/*
* VID_GetDefaultMode
*/
bool VID_GetDefaultMode( int *width, int *height )
{
SDL_DisplayMode mode;
SDL_GetDesktopDisplayMode( 0, &mode );
*width = mode.w;
*height = mode.h;
return true;
}
WindowMode getDisplaySize() const override {
SDL_DisplayMode new_mode;
int display_index = 0;
if(window_ != nullptr) {
display_index = SDL_GetWindowDisplayIndex(window_.get());
}
SDL_GetDesktopDisplayMode(display_index, &new_mode);
WindowMode mode = { new_mode.w, new_mode.h, std::make_shared<SDLPixelFormat>(new_mode.format), new_mode.refresh_rate };
return mode;
}
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;
}
//No settings file found
Renderer::Renderer(MaterialManager* const mM, ShaderManager* const sM): mManager{mM},sManager{sM},openglContext{} {
SDL_DisplayMode desktop;
SDL_Init(SDL_INIT_VIDEO);
SDL_GetDesktopDisplayMode(0,&desktop);
createContext(desktop.w,desktop.h,true,1);
initialize();
guiInitialize();
}
Display::Display(float &WIDTH, float &HEIGHT, std::string title, bool fullscreen)
{
SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetSwapInterval(0);
SDL_ShowCursor(0);
if(fullscreen){
SDL_DisplayMode dm;
if (SDL_GetDesktopDisplayMode(0, &dm) != 0){
SDL_Log("SDL_GetDesktopDisplayMode failed: %s", SDL_GetError());
}
this->width = dm.w;
this->height = dm.h;
WIDTH = this->width;
HEIGHT = this->height;
}else{
this->width = WIDTH;
this->height = HEIGHT;
}
window = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIDTH, HEIGHT, SDL_WINDOW_OPENGL | (fullscreen ? SDL_WINDOW_FULLSCREEN : SDL_WINDOW_RESIZABLE));
glContext = SDL_GL_CreateContext(window);
GLenum status = glewInit();
if(status != GLEW_OK){
std::cerr << "Glew failed to initialize !" << std::endl;
}
isWindowClosed = false;
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0.0f, 0.0f, WIDTH, HEIGHT);
lastFrameTime = SDL_GetTicks();
oneFrameDuration = 1000.0f / (float)MAX_FPS;
}
IntVector2 Graphics::GetDesktopResolution() const
{
#if !defined(__ANDROID__) && !defined(IOS)
SDL_DisplayMode mode;
SDL_GetDesktopDisplayMode(0, &mode);
return IntVector2(mode.w, mode.h);
#else
// SDL_GetDesktopDisplayMode() may not work correctly on mobile platforms. Rather return the window size
return IntVector2(width_, height_);
#endif
}
static int get_refresh_rate(SDL_Window * win) {
SDL_DisplayMode mode;
int displayIndex = SDL_GetWindowDisplayIndex(win);
if (SDL_GetDesktopDisplayMode(displayIndex, &mode) != 0 ) {
return 0;
} else {
return mode.refresh_rate;
}
}
static uint32_t getRefreshRate(SDL_Window* window) {
int displayIndex = SDL_GetWindowDisplayIndex(window);
SDL_DisplayMode displayMode; //stores refresh rate
if(SDL_GetDesktopDisplayMode(displayIndex, &displayMode) != 0
&& displayMode.refresh_rate != 0) {
return displayMode.refresh_rate;
}
return DEFAULT_REFRESH_RATE;
}
// Use SDL to determine desktop size
void _Config::SetDefaultFullscreenSize() {
if(Config.FullscreenSize != glm::ivec2(0))
return;
SDL_DisplayMode DisplayMode;
if(SDL_GetDesktopDisplayMode(0, &DisplayMode) != 0)
Config.FullscreenSize = DEFAULT_WINDOW_SIZE;
else
Config.FullscreenSize = glm::ivec2(DisplayMode.w, DisplayMode.h);
Config.Save();
}
void ToggleFullscreen(photon_window &window){
window.fullscreen = !window.fullscreen;
if(window.fullscreen){
SDL_DisplayMode mode;
SDL_GetDesktopDisplayMode(0, &mode);
SDL_SetWindowDisplayMode(window.window_SDL, &mode);
}
SDL_SetWindowFullscreen(window.window_SDL, SDL_bool(window.fullscreen));
PrintToLog("INFO: Window toggled fullscreen.");
}
static int lua_SDL_GetDesktopDisplayMode(lutok::state& state){
Lua_SDL_DisplayMode & dm = LOBJECT_INSTANCE(Lua_SDL_DisplayMode);
SDL_DisplayMode * mode = new SDL_DisplayMode;
if (SDL_GetDesktopDisplayMode(state.to_integer(1), mode) == 0){
dm.push(mode);
return 1;
}else{
delete mode;
return 0;
}
}
void ProcessEvent(OpenBlox::OBGame* gameInst, SDL_Event event){
switch(event.type){
case SDL_MOUSEMOTION: {
SDL_MouseMotionEvent motion = event.motion;
gameInst->mouseMove(QPoint(motion.x, motion.y));
break;
}
case SDL_MOUSEBUTTONDOWN: {
SDL_MouseButtonEvent btn = event.button;
gameInst->mousePress(btn.button, QPoint(btn.x, btn.y));
break;
}
case SDL_KEYDOWN: {
SDL_KeyboardEvent keyEvt = event.key;
SDL_Keysym key = keyEvt.keysym;
#ifndef OPENBLOX_STUDIO
if(key.sym == SDLK_F11){
if((SDL_GetWindowFlags(OpenBlox::mw) & SDL_WINDOW_FULLSCREEN) == SDL_WINDOW_FULLSCREEN){
SDL_SetWindowFullscreen(OpenBlox::mw, 0);
}else{
SDL_DisplayMode dm;
if(SDL_GetDesktopDisplayMode(SDL_GetWindowDisplayIndex(OpenBlox::mw), &dm) == 0){
SDL_SetWindowDisplayMode(OpenBlox::mw, &dm);
}
SDL_SetWindowFullscreen(OpenBlox::mw, SDL_WINDOW_FULLSCREEN);
}
}
#endif
break;
}
case SDL_KEYUP: {
SDL_KeyboardEvent keyEvt = event.key;
SDL_Keysym key = keyEvt.keysym;
Q_UNUSED(key)
break;
}
case SDL_WINDOWEVENT: {
SDL_WindowEvent wevt = event.window;
switch(wevt.event){
case SDL_WINDOWEVENT_RESIZED: {
gameInst->resized();
}
}
break;
}
case SDL_QUIT: {
shouldQuit = true;
break;
}
}
}
//----------------------------------------------------------------------------//
Window::Window(SDL_Window* _window) :
m_window(_window),
m_width(0),
m_height(0),
m_isOpened(true)
{
ASSERT(_window != nullptr);
SDL_DisplayMode _dm;
SDL_GetDesktopDisplayMode(0, &_dm);
SDL_SetWindowSize(m_window, (_dm.w >> 2) * 3, (_dm.h >> 2) * 3);
SDL_SetWindowPosition(m_window, _dm.w >> 3, _dm.h >> 3);
}
static void init_monitors(void)
{
sdl_monitor_info **tailptr;
// make a list of monitors
sdl_monitor_list = NULL;
tailptr = &sdl_monitor_list;
#if (SDLMAME_SDL2)
{
int i;
mame_printf_verbose("Enter init_monitors\n");
for (i = 0; i < SDL_GetNumVideoDisplays(); i++)
{
sdl_monitor_info *monitor;
SDL_DisplayMode dmode;
// allocate a new monitor info
monitor = global_alloc_clear(sdl_monitor_info);
snprintf(monitor->monitor_device, sizeof(monitor->monitor_device)-1, "%s%d", SDLOPTION_SCREEN,i);
SDL_GetDesktopDisplayMode(i, &dmode);
monitor->monitor_width = dmode.w;
monitor->monitor_height = dmode.h;
monitor->center_width = dmode.w;
monitor->center_height = dmode.h;
monitor->handle = i;
// guess the aspect ratio assuming square pixels
monitor->aspect = (float)(dmode.w) / (float)(dmode.h);
mame_printf_verbose("Adding monitor %s (%d x %d)\n", monitor->monitor_device, dmode.w, dmode.h);
// save the primary monitor handle
if (i == 0)
primary_monitor = monitor;
// hook us into the list
*tailptr = monitor;
tailptr = &monitor->next;
}
}
mame_printf_verbose("Leave init_monitors\n");
#elif defined(SDLMAME_WIN32)
EnumDisplayMonitors(NULL, NULL, monitor_enum_callback, (LPARAM)&tailptr);
#else
add_primary_monitor((void *)&tailptr);
#endif
}
