Ejemplo n.º 1
0
bool SDL::getAllVideoModes(StringVect &modeList)
{
    std::set<std::string> modes;

    for (int display = 0; display < 100; display ++)
    {
        const int numModes = SDL_GetNumDisplayModes(display);
        if (numModes > 0)
        {
            logger->log("Modes for display %d", display);
            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;
}
Ejemplo n.º 2
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;
}
Ejemplo n.º 3
0
static void AddSupportedGraphicsModes(GraphicsDevice *device)
{
    // TODO: multiple window support?
    const int numDisplayModes = SDL_GetNumDisplayModes(0);
    if (numDisplayModes < 1)
    {
        LOG(LM_GFX, LL_ERROR, "no valid display modes: %s", SDL_GetError());
        return;
    }
    for (int i = 0; i < numDisplayModes; i++)
    {
        SDL_DisplayMode mode;
        if (SDL_GetDisplayMode(0, i, &mode) != 0)
        {
            LOG(LM_GFX, LL_ERROR, "cannot get display mode: %s",
                SDL_GetError());
            continue;
        }
        if (mode.w < 320 || mode.h < 240)
        {
            break;
        }
        AddGraphicsMode(device, mode.w, mode.h);
    }
}
Ejemplo n.º 4
0
	static int lua_SDL_GetDisplayModes(lutok::state& state){
		Lua_SDL_DisplayMode & dm = LOBJECT_INSTANCE(Lua_SDL_DisplayMode);
		Lua_SDL_Rect & r = LOBJECT_INSTANCE(Lua_SDL_Rect);

		state.new_table();// displays
		for (int display=0; display < SDL_GetNumVideoDisplays(); display++){
			state.push_integer(display+1);
			state.new_table(); //display
			int modes=1;
			state.push_literal("modes");
			state.new_table(); //modes
			for (int i=0; i<SDL_GetNumDisplayModes(display); i++){
				SDL_DisplayMode * mode = new SDL_DisplayMode;
				if (SDL_GetDisplayMode(display, i, mode) == 0){	
					state.push_integer(modes++);
					dm.push(mode);
					state.set_table();
				}else{
					delete mode;
				}
			}
			state.set_table();

			SDL_Rect * rect = new SDL_Rect;
			SDL_GetDisplayBounds(display, rect);
			
			state.push_literal("bounds");
			r.push(rect);
			state.set_table();

			state.set_table();
		}
		return 1;
	}
Ejemplo n.º 5
0
PODVector<IntVector2> Graphics::GetResolutions() const
{
    PODVector<IntVector2> ret;
    // Emscripten is not able to return a valid list
#ifndef __EMSCRIPTEN__
    unsigned numModes = (unsigned)SDL_GetNumDisplayModes(0);

    for (unsigned i = 0; i < numModes; ++i)
    {
        SDL_DisplayMode mode;
        SDL_GetDisplayMode(0, i, &mode);
        int width = mode.w;
        int height = mode.h;

        // Store mode if unique
        bool unique = true;
        for (unsigned j = 0; j < ret.Size(); ++j)
        {
            if (ret[j].x_ == width && ret[j].y_ == height)
            {
                unique = false;
                break;
            }
        }

        if (unique)
            ret.Push(IntVector2(width, height));
    }
#endif

    return ret;
}
Ejemplo n.º 6
0
		bool autoWindowSize(int& width, int& height) override {
			std::vector<WindowMode> res;
			int num_displays = SDL_GetNumVideoDisplays();
			if(num_displays < 0) {
				LOG_ERROR("Error enumerating number of displays: " << std::string(SDL_GetError()));
				return false;
			}
			for(int n = 0; n != num_displays; ++n) {
				SDL_Rect display_bounds;
				SDL_GetDisplayBounds(n, &display_bounds);
				int num_modes = SDL_GetNumDisplayModes(n);
				if(num_modes < 0) {
					LOG_ERROR("Error enumerating number of display modes for display " << n << ": " << std::string(SDL_GetError()));
					return false;
				}
				for(int m = 0; m != num_modes; ++m) {
					SDL_DisplayMode mode;
					int err = SDL_GetDisplayMode(n, m, &mode);
					if(err < 0) {
						LOG_ERROR("Couldn't get display mode information for display: " << n << " mode: " << m << " : " << std::string(SDL_GetError()));
					} else {
						WindowMode new_mode = { mode.w, mode.h, std::make_shared<SDLPixelFormat>(mode.format), mode.refresh_rate };
						res.emplace_back(new_mode);
						LOG_DEBUG("added mode w: " << mode.w << ", h: " << mode.h << ", refresh: " << mode.refresh_rate);
					}
				}
			}

			if(!res.empty()) {
				width = static_cast<int>(res.front().width * 0.8f);
				height = static_cast<int>(res.front().height * 0.8f);
				return true;
			}
			return false;
		}
Ejemplo n.º 7
0
/*
===============
GLimp_DetectAvailableModes
===============
*/
static bool GLimp_DetectAvailableModes(void)
{
	int i;
	char buf[ MAX_STRING_CHARS ] = { 0 };
	SDL_Rect modes[ 128 ];
	int numModes = 0;

	int display = SDL_GetWindowDisplayIndex( screen );
	SDL_DisplayMode windowMode;

	if( SDL_GetWindowDisplayMode( screen, &windowMode ) < 0 )
	{
		Com_Printf( "Couldn't get window display mode, no resolutions detected (%s).\n", SDL_GetError() );
		return false;
	}

	int numDisplayModes = SDL_GetNumDisplayModes( display );
	for( i = 0; i < numDisplayModes; i++ )
	{
		SDL_DisplayMode mode;

		if( SDL_GetDisplayMode( display, i, &mode ) < 0 )
			continue;

		if( !mode.w || !mode.h )
		{
			Com_Printf( "Display supports any resolution\n" );
			return true;
		}

		if( windowMode.format != mode.format )
			continue;

		modes[ numModes ].w = mode.w;
		modes[ numModes ].h = mode.h;
		numModes++;
	}

	if( numModes > 1 )
		qsort( modes, numModes, sizeof( SDL_Rect ), GLimp_CompareModes );

	for( i = 0; i < numModes; i++ )
	{
		const char *newModeString = va( "%ux%u ", modes[ i ].w, modes[ i ].h );

		if( strlen( newModeString ) < (int)sizeof( buf ) - strlen( buf ) )
			Q_strcat( buf, sizeof( buf ), newModeString );
		else
			Com_Printf( "Skipping mode %ux%x, buffer too small\n", modes[ i ].w, modes[ i ].h );
	}

	if( *buf )
	{
		buf[ strlen( buf ) - 1 ] = 0;
		Com_Printf( "Available modes: '%s'\n", buf );
		ri->Cvar_Set( "r_availableModes", buf );
	}

	return true;
}
Ejemplo n.º 8
0
void	VID_Init (void)
{
	int i;

	// Enumerate modes.
	vid_num_modes = SDL_min(VID_MAX_MODES, SDL_GetNumDisplayModes(0));
	
	for (i = 0; i < vid_num_modes; ++i)
	{
		SDL_DisplayMode mode = { 0 };
		SDL_GetDisplayMode(0, i, &mode);

		vid_modes[i].width = mode.w;
		vid_modes[i].height = mode.h;
	}

	qsort(&vid_modes[0], vid_num_modes, sizeof(vidmode_t), &CompareModes);

	/* Create the video variables so we know how to start the graphics drivers */
	vid_ref = Cvar_Get ("vid_ref", "gl", CVAR_ARCHIVE);
	vid_fullscreen = Cvar_Get ("vid_fullscreen", "0", CVAR_ARCHIVE);
	vid_gamma = Cvar_Get( "vid_gamma", "1", CVAR_ARCHIVE );

	/* Add some console commands that we want to handle */
	Cmd_AddCommand ("vid_restart", VID_Restart_f);
		
	/* Start the graphics mode and load refresh DLL */
	VID_CheckChanges();
}
Ejemplo n.º 9
0
void Window::SetMaxMinResolution( SDL_Window * window, int &min_width, int &min_height, int &max_width, int &max_height  ){
   if( window == NULL or window == nullptr ){
      return;
   }

   int DisplayIndex = SDL_GetWindowDisplayIndex( window );
   SDL_DisplayMode CurrentDisplayMode;

   if( SDL_GetDisplayMode( DisplayIndex, SDL_GetNumDisplayModes( DisplayIndex ) - 1, &CurrentDisplayMode ) == 0 ){
      min_width = CurrentDisplayMode.w;
      min_height = CurrentDisplayMode.h;
      logger << ( "[LOG] Minimal resolution: " + to_string( min_width ) + "x" + to_string( min_height ) );
   }
   else{
      logger << ( "[ERROR] SDL_GetDisplayMode: " + string( SDL_GetError() ) );
      return;
   }
   SDL_SetWindowMinimumSize( window, min_width, min_height );

   if( SDL_GetDisplayMode( DisplayIndex, 0, &CurrentDisplayMode ) == 0 ){
      max_width = CurrentDisplayMode.w;
      max_height = CurrentDisplayMode.h;
      logger << ( "[LOG] Maximal resolution: " + to_string( max_width ) + "x" + to_string( max_height ) );
   }
   else{
      logger << ( "[ERROR] SDL_GetDisplayMode: " + string( SDL_GetError() ) );
      return;
   }
   SDL_SetWindowMaximumSize( window, max_width, max_height );
}
Ejemplo n.º 10
0
Archivo: SDL_nine.c Proyecto: EoD/Xnine
static UINT WINAPI
d3dadapter9_GetAdapterModeCount( struct d3dadapter9 *This,
                                 UINT Adapter,
                                 D3DFORMAT Format )
{
    if (Adapter >= d3dadapter9_GetAdapterCount(This)) {
        WARN("Adapter %u does not exist.\n", Adapter);
        return 0;
    }
    if (FAILED(d3dadapter9_CheckDeviceFormat(This, Adapter, D3DDEVTYPE_HAL,
                                         Format, D3DUSAGE_RENDERTARGET,
                                         D3DRTYPE_SURFACE, Format))) {
        WARN("DeviceFormat not available.\n");
        return 0;
    }

    int NumMatchingModes = 0;
    int NumModes = SDL_GetNumDisplayModes(Adapter);
    int i;
    for (i=0;i<NumModes;i++) {
        SDL_DisplayMode mode;
        int err = SDL_GetDisplayMode(Adapter, i, &mode);
        if (err < 0) {
            WARN("SDL_GetDisplayMode returned an error: %s\n", SDL_GetError());
            return 0;
        }

        if (Format == ConvertFromSDL(mode.format))
            NumMatchingModes ++;
    }

    return NumMatchingModes;
}
Ejemplo n.º 11
0
std::vector<SDL_DisplayMode>
Display::get_fullscreen_video_modes()
{
  std::vector<SDL_DisplayMode> video_modes;

  int num_displays = SDL_GetNumVideoDisplays();
  log_info("number of displays: %1%", num_displays);

  for(int display = 0; display < num_displays; ++display)
  {
    int num_modes = SDL_GetNumDisplayModes(display);

    for (int i = 0; i < num_modes; ++i)
    {
      SDL_DisplayMode mode;
      if (SDL_GetDisplayMode(display, i, &mode) != 0)
      {
        log_error("failed to get display mode: %1%", SDL_GetError());
      }
      else
      {
        log_debug("%1%x%2%@%3% %4%", mode.w, mode.h, mode.refresh_rate, SDL_GetPixelFormatName(mode.format));
        video_modes.push_back(mode);
      }
    }
  }

  return video_modes;
}
Ejemplo n.º 12
0
std::vector<VideoMode> GetAvailableVideoModes()
{
	std::vector<VideoMode> modes;

	const int num_displays = SDL_GetNumVideoDisplays();
	for(int display_index = 0; display_index < num_displays; display_index++)
	{
		const int num_modes = SDL_GetNumDisplayModes(display_index);

		SDL_Rect display_bounds;
		SDL_GetDisplayBounds(display_index, &display_bounds);

		for (int display_mode = 0; display_mode < num_modes; display_mode++)
		{
			SDL_DisplayMode mode;
			SDL_GetDisplayMode(display_index, display_mode, &mode);
			// insert only if unique resolution
			if( modes.end()==std::find(modes.begin(), modes.end(), VideoMode(mode.w, mode.h)) ) {
				modes.push_back(VideoMode(mode.w, mode.h));
			}
		}
	}
	if( num_displays==0 ) {
		modes.push_back(VideoMode(800, 600));
	}
	return modes;
}
Ejemplo n.º 13
0
int32_t				get_display_mode(int32_t *wx, int32_t *wy)
{
	static int32_t		display_in_use = 0; /* Only using first display */
	int32_t				i;
	int32_t				display_mode_count;
	SDL_DisplayMode		mode;

	display_mode_count = SDL_GetNumDisplayModes(display_in_use);
	if (display_mode_count < 1)
		return (0);
	i = 0;
	while (i < display_mode_count)
	{
		if (SDL_GetDisplayMode(display_in_use, i, &mode) != 0)
		{
			SDL_Log("SDL_GetDisplayMode failed: %s", SDL_GetError());
			return (0);
		}
		if (i == 0)
		{
			*wx = mode.w;
			*wy = mode.h;
		}
		++i;
	}
	return (1);
}
Ejemplo n.º 14
0
static void BuildFullscreenModesList(void)
{
    screen_mode_t *m1;
    screen_mode_t *m2;
    screen_mode_t m;
    int display = 0;  // SDL2-TODO
    int num_modes;
    int i;

    // Free the existing modes list, if one exists

    if (screen_modes_fullscreen != NULL)
    {
        free(screen_modes_fullscreen);
    }

    num_modes = SDL_GetNumDisplayModes(display);
    screen_modes_fullscreen = calloc(num_modes, sizeof(screen_mode_t) + 1);

    for (i = 0; i < SDL_GetNumDisplayModes(display); ++i)
    {
        SDL_DisplayMode mode;

        SDL_GetDisplayMode(display, i, &mode);
        screen_modes_fullscreen[i].w = mode.w;
        screen_modes_fullscreen[i].h = mode.h;
        // SDL2-TODO: Deal with duplicate modes due to different pixel formats.
    }

    screen_modes_fullscreen[num_modes].w = 0;
    screen_modes_fullscreen[num_modes].h = 0;

    // Reverse the order of the modes list (smallest modes first)

    for (i=0; i<num_modes / 2; ++i)
    {
        m1 = &screen_modes_fullscreen[i];
        m2 = &screen_modes_fullscreen[num_modes - 1 - i];

        memcpy(&m, m1, sizeof(screen_mode_t));
        memcpy(m1, m2, sizeof(screen_mode_t));
        memcpy(m2, &m, sizeof(screen_mode_t));
    }

    num_screen_modes_fullscreen = num_modes;
}
Ejemplo n.º 15
0
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);
}
Ejemplo n.º 16
0
bool SDL2Window::initializeFramework() {
	
	arx_assert(s_mainWindow == NULL, "SDL only supports one window"); // TODO it supports multiple windows now!
	arx_assert(m_displayModes.empty());
	
	const char * headerVersion = ARX_STR(SDL_MAJOR_VERSION) "." ARX_STR(SDL_MINOR_VERSION)
	                             "." ARX_STR(SDL_PATCHLEVEL);
	CrashHandler::setVariable("SDL version (headers)", headerVersion);
	
	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) < 0) {
		LogError << "Failed to initialize SDL: " << SDL_GetError();
		return false;
	}
	
	#ifdef ARX_DEBUG
	// No SDL, this is more annoying than helpful!
	#if defined(SIGINT)
	signal(SIGINT, SIG_DFL);
	#endif
	#if defined(SIGTERM)
	signal(SIGTERM, SIG_DFL);
	#endif
	#endif
	
	SDL_version ver;
	SDL_GetVersion(&ver);
	std::ostringstream runtimeVersion;
	runtimeVersion << int(ver.major) << '.' << int(ver.minor) << '.' << int(ver.patch);
	CrashHandler::setVariable("SDL version (runtime)", runtimeVersion.str());
	LogInfo << "Using SDL " << runtimeVersion.str();
	
	int ndisplays = SDL_GetNumVideoDisplays();
	for(int display = 0; display < ndisplays; display++) {
		int modes = SDL_GetNumDisplayModes(display);
		for(int i = 0; i < modes; i++) {
			SDL_DisplayMode mode;
			if(SDL_GetDisplayMode(display, i, &mode) >= 0) {
				m_displayModes.push_back(Vec2i(mode.w, mode.h));
			}
		}
	}
	
	std::sort(m_displayModes.begin(), m_displayModes.end());
	m_displayModes.erase(std::unique(m_displayModes.begin(), m_displayModes.end()),
	                     m_displayModes.end());
	
	s_mainWindow = this;
	
	SDL_SetEventFilter(eventFilter, NULL);
	
	SDL_EventState(SDL_WINDOWEVENT, SDL_ENABLE);
	SDL_EventState(SDL_QUIT,        SDL_ENABLE);
	SDL_EventState(SDL_SYSWMEVENT,  SDL_IGNORE);
	SDL_EventState(SDL_USEREVENT,   SDL_IGNORE);
	
	return true;
}
Ejemplo n.º 17
0
/*
===============
GLimp_DetectAvailableModes
===============
*/
static void GLimp_DetectAvailableModes() {
    char buf[MAX_STRING_CHARS] = {0};
    SDL_Rect modes[128];
    int numModes = 0;
    int i;
    SDL_DisplayMode windowMode;
    int display;

    display = SDL_GetWindowDisplayIndex(window);

    if (SDL_GetWindowDisplayMode(window, &windowMode) < 0) {
        ri.Printf(PRINT_WARNING, "Couldn't get window display mode: %s\n", SDL_GetError());
        return;
    }

    for (i = 0; i < SDL_GetNumDisplayModes(display); i++) {
        SDL_DisplayMode mode;

        if (SDL_GetDisplayMode(display, i, &mode) < 0) {
            continue;
        }

        if (!mode.w || !mode.h) {
            ri.Printf(PRINT_ALL, "Display supports any resolution\n");
            return;
        }

        if (windowMode.format != mode.format ||
            windowMode.refresh_rate != mode.refresh_rate) {
            continue;
        }

        modes[numModes].w = mode.w;
        modes[numModes].h = mode.h;
        numModes++;
    }

    if (numModes > 1) {
        qsort(modes, numModes, sizeof(SDL_Rect), GLimp_CompareModes);
    }

    for (i = 0; i < numModes; i++) {
        const char* newModeString = va("%ux%u ", modes[i].w, modes[i].h);

        if (strlen(newModeString) < (int) sizeof(buf) - strlen(buf)) {
            Q_strcat(buf, sizeof(buf), newModeString);
        } else {
            ri.Printf(PRINT_WARNING, "Skipping mode %ux%x, buffer too small\n", modes[i].w, modes[i].h);
        }
    }

    if (*buf) {
        ri.Printf(PRINT_ALL, "Available modes: '%s'\n", buf);
        ri.Cvar_Set("r_availableModes", buf);
    }
}
Ejemplo n.º 18
0
	void SDLGameWindow::OutputDisplayModes()
	{
		int numModes = SDL_GetNumDisplayModes(0);
		for (int i = 0; i < numModes; i++)
		{
			SDL_DisplayMode mode;
			SDL_GetDisplayMode(0, i, &mode);
			DebugPrintF(VTEXT("DisplayMode[%i]: <W: %i, H: %i>\n"), i, mode.w, mode.h);
		}
	}
Ejemplo n.º 19
0
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;
}
Ejemplo n.º 20
0
Archivo: SDL_nine.c Proyecto: EoD/Xnine
static HRESULT WINAPI
d3dadapter9_EnumAdapterModes( struct d3dadapter9 *This,
                              UINT Adapter,
                              D3DFORMAT Format,
                              UINT ModeIndex,
                              D3DDISPLAYMODE *pMode )
{
    HRESULT hr;

    if (Adapter >= d3dadapter9_GetAdapterCount(This)) {
        WARN("Adapter %u does not exist.\n", Adapter);
        return D3DERR_INVALIDCALL;
    }
    if (!pMode) {
        WARN("pMode is NULL.\n");
        return D3DERR_INVALIDCALL;
    }

    hr = d3dadapter9_CheckDeviceFormat(This, Adapter, D3DDEVTYPE_HAL,
                                   Format, D3DUSAGE_RENDERTARGET,
                                   D3DRTYPE_SURFACE, Format);
    if (FAILED(hr)) {
        TRACE("DeviceFormat not available.\n");
        return hr;
    }

    int IndexMatchingModes = 0;
    int NumModes = SDL_GetNumDisplayModes(Adapter);
    int i;
    for (i=0;i<NumModes;i++) {
        SDL_DisplayMode mode;
        int err = SDL_GetDisplayMode(Adapter, i, &mode);
        if (err < 0) {
            WARN("SDL_GetDisplayMode returned an error: %s\n", SDL_GetError());
            return D3DERR_INVALIDCALL;
        }

        if (Format != ConvertFromSDL(mode.format))
            continue;

        if (IndexMatchingModes == ModeIndex) {
            TRACE("DiplayMode: %dx%d@%dHz, d3dformat=%d\n", mode.w, mode.h, mode.refresh_rate, Format);
            pMode->Width = mode.w;
            pMode->Height = mode.h;
            pMode->RefreshRate = mode.refresh_rate;
            pMode->Format = Format;

            return D3D_OK;
        }
        IndexMatchingModes ++;
    }

    WARN("invalid mode for format %d on adapter %d: %d\n", Format, Adapter, ModeIndex);
    return D3DERR_INVALIDCALL;
}
Ejemplo n.º 21
0
static void VID_SetupModeList(void)
{
	int i;

	Q_free(modelist);

	modelist_count = SDL_GetNumDisplayModes(0);
	modelist = Q_calloc(modelist_count, sizeof(*modelist));

	for (i = 0; i < modelist_count; i++) {
		SDL_GetDisplayMode(0, i, &modelist[i]);
	}
}
Ejemplo n.º 22
0
		Display ( unsigned int index):
		index(index) {
			name = SDL_GetDisplayName(index);
			
			int numDisplayModes = SDL_GetNumDisplayModes(index);
			
			for (int i = 0; i < numDisplayModes; ++i) {
				SDL_DisplayMode displayMode;
				if (SDL_GetDisplayMode(index, i, &displayMode) != -1) {
					displayModes.push_back(DisplayMode(i, displayMode));
				}
			}
		}
Ejemplo n.º 23
0
Vector<SDL_DisplayMode> Renderer::EnumerateDisplayModes() const
{
    // Enumerate available video modes
    Vector<SDL_DisplayMode> displayModes;
    int count = SDL_GetNumDisplayModes(0);
    for (int i = 0; i < count; ++i)
    {
        SDL_DisplayMode mode;
        SDL_GetDisplayMode(0, i, &mode);
        displayModes.push_back(mode);
    }
    return displayModes;
}
Ejemplo n.º 24
0
//--------------------------------------------------------------------------------------------
bool SDLX_Get_Screen_Info( SDLX_screen_info_t& psi, bool make_report )
{
    Uint32 init_flags = 0;
    SDL_Window *window;

    init_flags = SDL_WasInit( SDL_INIT_EVERYTHING );
    if ( 0 == init_flags )
    {
        if ( make_report ) Log::get().message("ERROR: SDLX_Get_Screen_Info() called before initializing SDL\n");
        return false;
    }
    else if ( HAS_NO_BITS( init_flags, SDL_INIT_VIDEO ) )
    {
        if ( make_report ) Log::get().message("ERROR: SDLX_Get_Screen_Info() called before initializing SDL video driver\n");
        return false;
    }

    // store the screen info for everyone to use
    window = Ego::GraphicsSystem::window;
	psi.window = window;
    SDL_GetWindowSize(window, &(psi.x), &(psi.y));
    SDLX_GetDrawableSize(window, &(psi.drawWidth), &(psi.drawHeight));

    // Grab all the available video modes
    psi.video_mode_list.clear();
    
    int displayNum = SDL_GetWindowDisplayIndex(window);
    int numDisplayModes = SDL_GetNumDisplayModes(displayNum);
    
    for (int i = 0; i < numDisplayModes; i++) {
        SDL_DisplayMode mode;
        SDL_GetDisplayMode(displayNum, i, &mode);
        psi.video_mode_list.push_back(mode);
    }
    
    // log the video driver info
    psi.szDriver = SDL_GetCurrentVideoDriver();

    // grab all SDL_GL_* attributes
    SDLX_sdl_gl_attrib_t::download(psi.gl_att);

    // translate the surface flags into the bitfield
    SDLX_sdl_video_flags_t::download(psi.flags, SDL_GetWindowFlags(window));

    if (make_report)
    {
        SDLX_screen_info_t::report(psi);
    }
    return true;
}
Ejemplo n.º 25
0
/*
===============
GLimp_DetectAvailableModes
===============
*/
static void GLimp_DetectAvailableModes(void)
{
	char buf[ MAX_STRING_CHARS ] = { 0 };
	//SDL_Rect **modes;
	int numModes;
	int i;
	SDL_DisplayMode displayMode;
	/*modes = SDL_ListModes( NULL, SDL_OPENGL | SDL_FULLSCREEN );

	if( !modes )
	{
		ri.Printf( PRINT_WARNING, "Can't get list of available modes\n" );
		return;
	}

	if( modes == (SDL_Rect **)-1 )*/
	if( (numModes = SDL_GetNumDisplayModes( 0 )) <= 0 )//FIXME: Use SDL_GetWindowDisplayIndex instead of 0?
	{
		ri.Printf( PRINT_DEVELOPER, "Display supports any resolution\n" );
		return; // can set any resolution
	}

	/*for( numModes = 0; modes[ numModes ]; numModes++ );

	if(numModes > 1)
		qsort( modes+1, numModes-1, sizeof( SDL_Rect* ), GLimp_CompareModes );*/

	for( i = 0; i < numModes; i++ )
	{
		const char *newModeString;
		if( SDL_GetDisplayMode( 0, i, &displayMode ) != 0 ) {
			break;
		}
		newModeString = va( "%ux%u ", displayMode.w, displayMode.h );

		if( strlen( newModeString ) < (int)sizeof( buf ) - strlen( buf ) )
			Q_strcat( buf, sizeof( buf ), newModeString );
		else
			ri.Printf( PRINT_WARNING, "Skipping mode %ux%x, buffer too small\n", displayMode.w, displayMode.h );
	}

	if( *buf )
	{
		buf[ strlen( buf ) - 1 ] = 0;
		ri.Printf( PRINT_DEVELOPER, "Available modes: '%s'\n", buf );
		ri.Cvar_Set( "r_availableModes", buf );
	}
}
Ejemplo n.º 26
0
/*static*/ void Display::EnumerateDisplayModes( Array<SDisplayMode>& DisplayModes )
{
	DisplayModes.Clear();

#if BUILD_WINDOWS_NO_SDL
	DEVMODE	DevMode;
	uint	ModeIndex	= 0;
	BOOL	Valid		= TRUE;
	for( ; Valid; ++ModeIndex )
	{
		Valid = EnumDisplaySettings( NULL, ModeIndex, &DevMode );

		// Some users have problems if their refresh rate is set to 59 Hz. Maybe I should reconsider this?
		if( DevMode.dmBitsPerPel == 32 )
		{
			SDisplayMode Mode;
			Mode.Width	= DevMode.dmPelsWidth;
			Mode.Height	= DevMode.dmPelsHeight;
			DisplayModes.PushBackUnique( Mode );
		}
	}
#endif
#if BUILD_SDL
	PRINTF( "Enumerating SDL display modes...\n" );
	const int NumDisplays		= SDL_GetNumVideoDisplays();
	for( int DisplayIndex = 0; DisplayIndex < NumDisplays; ++DisplayIndex )
	{
		const int NumModes = SDL_GetNumDisplayModes( DisplayIndex );
		for( int ModeIndex = 0; ModeIndex < NumModes; ++ModeIndex )
		{
			SDL_DisplayMode DisplayMode;
			SDL_GetDisplayMode( DisplayIndex, ModeIndex, &DisplayMode );

			if( SDL_BYTESPERPIXEL( DisplayMode.format ) == 4 )
			{
				SDisplayMode Mode;
				Mode.Width	= DisplayMode.w;
				Mode.Height	= DisplayMode.h;
				DisplayModes.PushBackUnique( Mode );

				PRINTF( "Enumerated mode %dx%d\n", Mode.Width, Mode.Height );
			}
		}
	}
#endif

	ASSERT( DisplayModes.Size() );
}
Ejemplo n.º 27
0
		SDL_DisplayMode mode_auto_select()
		{
			SDL_DisplayMode mode;

			//uncomment out when support for SDL_GetWindowDisplayIndex stabilizes.
			const int display_index = 0; //SDL_GetWindowDisplayIndex(graphics::get_window());
			SDL_GetDesktopDisplayMode(display_index, &mode);

			if(preferences::fullscreen()) {
				return mode;
			}

			std::cerr << "CURRENT MODE IS " << mode.w << "x" << mode.h << "\n";

			SDL_DisplayMode best_mode = mode;
			if(preferences::fullscreen() == false && mode.w > 1024 && mode.h > 768) {
				const int nmodes = SDL_GetNumDisplayModes(display_index);
				for(int n = 0; n != nmodes; ++n) {
					SDL_DisplayMode candidate_mode;
					const int nvalue = SDL_GetDisplayMode(display_index, n, &candidate_mode);
					if(nvalue != 0) {
						std::cerr << "ERROR QUERYING DISPLAY INFO: " << SDL_GetError() << "\n";
						continue;
					}

					const float MinReduction = 0.9f;

					if(candidate_mode.w < mode.w && candidate_mode.h < mode.w 
						&& candidate_mode.w < mode.w*MinReduction 
						&& candidate_mode.h < mode.h*MinReduction 
						&& (candidate_mode.w >= best_mode.w 
						&& candidate_mode.h >= best_mode.h 
						|| best_mode.w == mode.w && best_mode.h == mode.h)) {
						std::cerr << "BETTER MODE IS " << candidate_mode.w << "x" << candidate_mode.h << "\n";
						best_mode = candidate_mode;
					} else {
						std::cerr << "REJECTED MODE IS " << candidate_mode.w << "x" << candidate_mode.h << "\n";
					}
				}
			}

			if(best_mode.w < g_min_window_width || best_mode.h < g_min_window_height) {
				best_mode.w = g_min_window_width;
				best_mode.h = g_min_window_height;
			}

			return best_mode;
		}
Ejemplo n.º 28
0
void CApplication::initVideoModes()
{
    SDL_DisplayMode mode;

    int numDisplay = SDL_GetNumVideoDisplays();

    for( int i = 0; i < numDisplay; ++i )
    {
        int displayModes = SDL_GetNumDisplayModes(0);
        for( int j = 0; j < displayModes; ++j )
        {
            SDL_GetDisplayMode(i, j, &mode);
            m_DisplayModes[i+1].push_back(mode);
        }
    }
}
Ejemplo n.º 29
0
Archivo: glue.c Proyecto: GWRon/sdl.mod
int bbSDLGraphicsGraphicsModes( int display, int *imodes,int maxcount ) {
	SDL_DisplayMode mode;
	int count,i;

	count = SDL_GetNumDisplayModes(display);
	if (count>maxcount) count=maxcount;
	for (i=0;i<count;i++) {
		SDL_GetDisplayMode(display, i, &mode);

		*imodes++=mode.w;
		*imodes++=mode.h;
		*imodes++=SDL_BITSPERPIXEL(mode.format);
		*imodes++=mode.refresh_rate;
	}
	return count;
}
Ejemplo n.º 30
0
QStringList SDLInteraction::getResolutions() const
{
    QStringList result;

    int modesNumber = SDL_GetNumDisplayModes(0);
    SDL_DisplayMode mode;

    for(int i = 0; i < modesNumber; ++i)
    {
        SDL_GetDisplayMode(0, i, &mode);

        if ((mode.w >= 640) && (mode.h >= 480))
            result << QString("%1x%2").arg(mode.w).arg(mode.h);
    }

    return result;
}