/*
** VID_GetSysModes
*/
unsigned int VID_GetSysModes( vidmode_t *modes ) {
XRRScreenConfiguration *xrrConfig;
XRRScreenSize *xrrSizes;
Display *dpy;
Window root;
int num_sizes = 0, i;
dpy = XOpenDisplay( NULL );
if( dpy ) {
root = DefaultRootWindow( dpy );
xrrConfig = XRRGetScreenInfo( dpy, root );
xrrSizes = XRRConfigSizes( xrrConfig, &num_sizes );
if( modes ) {
for( i = 0; i < num_sizes; i++ ) {
modes[i].width = xrrSizes[i].width;
modes[i].height = xrrSizes[i].height;
}
}
XCloseDisplay( dpy );
}
return max( num_sizes, 0 );
}
/**
* Queries all the available modes in the display configuration.
*/
RRInfo() : _numSizes(0)
{
_conf = XRRGetScreenInfo(QX11Info::display(), QX11Info::appRootWindow());
if(!_conf) return; // Not available.
// Let's see which modes are available.
_sizes = XRRConfigSizes(_conf, &_numSizes);
for(int i = 0; i < _numSizes; ++i)
{
int numRates = 0;
short* rates = XRRConfigRates(_conf, i, &numRates);
for(int k = 0; k < numRates; k++)
{
DisplayMode mode;
de::zap(mode);
mode.width = _sizes[i].width;
mode.height = _sizes[i].height;
mode.depth = displayDepth;
mode.refreshRate = rates[k];
_modes.push_back(mode);
}
}
::Time prevConfTime;
_confTime = XRRConfigTimes(_conf, &prevConfTime);
}
/*
** VID_GetDisplaySize
*/
qboolean VID_GetDisplaySize( int *width, int *height )
{
XRRScreenConfiguration *xrrConfig;
XRRScreenSize *xrrSizes;
Display *dpy;
Window root;
Rotation rotation;
SizeID size_id;
int num_sizes;
dpy = XOpenDisplay( NULL );
if( dpy )
{
root = DefaultRootWindow( dpy );
xrrConfig = XRRGetScreenInfo( dpy, root );
xrrSizes = XRRConfigSizes( xrrConfig, &num_sizes );
size_id = XRRConfigCurrentConfiguration( xrrConfig, &rotation );
*width = xrrSizes[size_id].width;
*height = xrrSizes[size_id].height;
XCloseDisplay( dpy );
return qtrue;
}
return qfalse;
}
void RenderContextImplGLX::SetVideoModeImpl(const VideoMode& mode) {
if (xrandrSupported) {
Window rootWnd = RootWindow(display, screenIndex);
XRRScreenConfiguration *screenConfig = XRRGetScreenInfo(display,
rootWnd);
if (screenConfig) {
int size = -1;
int nsizes = 0;
XRRScreenSize* screenSize = XRRConfigSizes(screenConfig, &nsizes);
for (int i = 0; i < nsizes; ++i) {
if (mode.width == uint16(screenSize[i].width)
&& mode.height == uint16(screenSize[i].height)) {
size = i;
break;
}
}
if (size < 0)
// invalid mode
return;
Rotation current_rotation;
XRRConfigCurrentConfiguration(screenConfig, ¤t_rotation);
XRRSetScreenConfigAndRate(display, screenConfig, rootWnd, size,
current_rotation, mode.refreshRate, CurrentTime);
XRRFreeScreenConfigInfo(screenConfig);
Trace(String("Video mode changed to:") + VideoMode::ToString(mode));
}
}
}
const DisplayResVector& DisplayResX::GetVideoModes(void) const
{
if (m_video_modes.size())
return m_video_modes;
Display *display = NULL;
XRRScreenConfiguration *cfg = GetScreenConfig(display);
if (!cfg)
return m_video_modes;
int num_sizes, num_rates;
XRRScreenSize *sizes = NULL;
X11S(sizes = XRRConfigSizes(cfg, &num_sizes));
for (int i = 0; i < num_sizes; ++i)
{
short *rates = NULL;
X11S(rates = XRRRates(display, DefaultScreen(display), i, &num_rates));
DisplayResScreen scr(sizes[i].width, sizes[i].height,
sizes[i].mwidth, sizes[i].mheight,
rates, num_rates);
m_video_modes.push_back(scr);
}
m_video_modes_unsorted = m_video_modes;
sort(m_video_modes.begin(), m_video_modes.end());
X11L;
XRRFreeScreenConfigInfo(cfg);
XCloseDisplay(display);
X11U;
return m_video_modes;
}
uaw::ScreenSizeArray
uaw::ConcreteX11Connection::GetScreenSizes (ScreenConfig const &c) const
{
uaw::ScreenSizeArray array;
array.array = XRRConfigSizes (c.get (),
&array.num);
return array;
}
VideoMode VideoModeImpl::getDesktopMode()
{
VideoMode desktopMode;
// Open a connection with the X server
Display* display = OpenDisplay();
if (display)
{
// Retrieve the default screen number
int screen = DefaultScreen(display);
// Check if the XRandR extension is present
int version;
if (XQueryExtension(display, "RANDR", &version, &version, &version))
{
// Get the current configuration
XRRScreenConfiguration* config = XRRGetScreenInfo(display, RootWindow(display, screen));
if (config)
{
// Get the current video mode
Rotation currentRotation;
int currentMode = XRRConfigCurrentConfiguration(config, ¤tRotation);
// Get the available screen sizes
int nbSizes;
XRRScreenSize* sizes = XRRConfigSizes(config, &nbSizes);
if (sizes && (nbSizes > 0))
desktopMode = VideoMode(sizes[currentMode].width, sizes[currentMode].height, DefaultDepth(display, screen));
// Free the configuration instance
XRRFreeScreenConfigInfo(config);
}
else
{
// Failed to get the screen configuration
err() << "Failed to retrieve the screen configuration while trying to get the desktop video modes" << std::endl;
}
}
else
{
// XRandr extension is not supported : we cannot get the video modes
err() << "Failed to use the XRandR extension while trying to get the desktop video modes" << std::endl;
}
// Close the connection with the X server
CloseDisplay(display);
}
else
{
// We couldn't connect to the X server
err() << "Failed to connect to the X server while trying to get the desktop video modes" << std::endl;
}
return desktopMode;
}
int set_x11videomode(const x11videomode_t * xvidmode, x11screen_t * x11screen)
{
int err ;
XRRScreenConfiguration * screen_config = 0 ;
if (!isextxrandr_x11display(display_x11screen(x11screen))) {
err = ENOSYS ;
goto ONERR;
}
Display * sys_display = display_x11screen(x11screen)->sys_display ;
screen_config = XRRGetScreenInfo(sys_display, RootWindow(sys_display, number_x11screen(x11screen))) ;
if (!screen_config) {
err = ENOSYS ;
goto ONERR;
}
Rotation current_rotation ;
uint16_t current_size = XRRConfigCurrentConfiguration(screen_config, ¤t_rotation) ;
int sizes_count ;
XRRScreenSize * sizes = XRRConfigSizes(screen_config, &sizes_count) ;
if ( !sizes
|| (current_size >= sizes_count)) {
err = EOVERFLOW ;
goto ONERR;
}
if ( xvidmode->modeid > sizes_count
|| xvidmode->width_in_pixel != (uint32_t) sizes[xvidmode->modeid].width
|| xvidmode->height_in_pixel != (uint32_t) sizes[xvidmode->modeid].height) {
err = EINVAL ;
goto ONERR;
}
if (XRRSetScreenConfig( sys_display, screen_config,
RootWindow(sys_display, number_x11screen(x11screen)),
xvidmode->modeid, current_rotation, CurrentTime)) {
err = EOPNOTSUPP ;
goto ONERR;
}
XRRFreeScreenConfigInfo(screen_config) ;
return 0 ;
ONERR:
if (screen_config) {
XRRFreeScreenConfigInfo(screen_config) ;
}
TRACEEXIT_ERRLOG(err);
return err ;
}
////////////////////////////////////////////////////////////
/// Switch to fullscreen mode
////////////////////////////////////////////////////////////
void WindowImplX11::SwitchToFullscreen(const VideoMode& Mode)
{
// Check if the XRandR extension is present
int Version;
if (XQueryExtension(ourDisplay, "RANDR", &Version, &Version, &Version))
{
// Get the current configuration
XRRScreenConfiguration* Config = XRRGetScreenInfo(ourDisplay, RootWindow(ourDisplay, ourScreen));
if (Config)
{
// Get the current rotation
Rotation CurrentRotation;
myOldVideoMode = XRRConfigCurrentConfiguration(Config, &CurrentRotation);
// Get the available screen sizes
int NbSizes;
XRRScreenSize* Sizes = XRRConfigSizes(Config, &NbSizes);
if (Sizes && (NbSizes > 0))
{
// Search a matching size
for (int i = 0; i < NbSizes; ++i)
{
if ((Sizes[i].width == static_cast<int>(Mode.Width)) && (Sizes[i].height == static_cast<int>(Mode.Height)))
{
// Switch to fullscreen mode
XRRSetScreenConfig(ourDisplay, Config, RootWindow(ourDisplay, ourScreen), i, CurrentRotation, CurrentTime);
// Set "this" as the current fullscreen window
ourFullscreenWindow = this;
break;
}
}
}
// Free the configuration instance
XRRFreeScreenConfigInfo(Config);
}
else
{
// Failed to get the screen configuration
std::cerr << "Failed to get the current screen configuration for fullscreen mode, switching to windiw mode" << std::endl;
}
}
else
{
// XRandr extension is not supported : we cannot use fullscreen mode
std::cerr << "Fullscreen is not supported, switching to window mode" << std::endl;
}
}
bool next_x11videomodeiterator(x11videomode_iterator_t * xvidit, /*out*/x11videomode_t * xvidmode)
{
int count ;
XRRScreenSize * sizes ;
if (xvidit->nextindex >= xvidit->nrmodes) {
return false ;
}
sizes = XRRConfigSizes((XRRScreenConfiguration *)xvidit->config, &count) ;
init_x11videomode(xvidmode,
(unsigned)sizes[xvidit->nextindex].width,
(unsigned)sizes[xvidit->nextindex].height, xvidit->nextindex) ;
++ xvidit->nextindex ;
return true ;
}
int initcurrent_x11videomode(/*out*/x11videomode_t * current_xvidmode, x11screen_t * x11screen)
{
int err ;
XRRScreenConfiguration * screen_config = 0 ;
if (!isextxrandr_x11display(display_x11screen(x11screen))) {
err = ENOSYS ;
goto ONERR;
}
Display * sys_display = display_x11screen(x11screen)->sys_display ;
screen_config = XRRGetScreenInfo(sys_display, RootWindow(sys_display, number_x11screen(x11screen))) ;
if (!screen_config) {
err = ENOSYS ;
goto ONERR;
}
Rotation current_rotation ;
uint16_t current_size = XRRConfigCurrentConfiguration(screen_config, ¤t_rotation) ;
int sizes_count ;
XRRScreenSize * sizes = XRRConfigSizes(screen_config, &sizes_count) ;
if ( !sizes
|| (current_size >= sizes_count)) {
err = EOVERFLOW ;
goto ONERR;
}
current_xvidmode->modeid = current_size ;
current_xvidmode->width_in_pixel = (uint32_t) sizes[current_size].width ;
current_xvidmode->height_in_pixel = (uint32_t) sizes[current_size].height ;
XRRFreeScreenConfigInfo(screen_config) ;
return 0 ;
ONERR:
if (screen_config) {
XRRFreeScreenConfigInfo(screen_config) ;
}
TRACEEXIT_ERRLOG(err);
return err ;
}
XRandRToggler::XRandRToggler() :
config(XRRGetScreenInfo(QX11Info::display(), QX11Info::appRootWindow())),
originalResIndex(0),
fullResIndex(0),
rotation(0),
fullRateIndex(0),
originalRate(0),
isFull(false)
{
fullResIndex = originalResIndex = XRRConfigCurrentConfiguration(config, &rotation);
originalRate = XRRConfigCurrentRate(config);
int nSizes;
XRRScreenSize *randrSizes = XRRConfigSizes(config, &nSizes);
for (int i = 0; i < nSizes; ++i) {
ResInfo info;
info.w = randrSizes[i].width;
info.h = randrSizes[i].height;
int nHz;
short *rates = XRRConfigRates(config, i, &nHz);
for (int j = 0; j < nHz; ++j)
info.rates.push_back(rates[j] * 10);
infoVector.push_back(info);
}
{
unsigned i = 0;
while (i < infoVector[fullResIndex].rates.size() && infoVector[fullResIndex].rates[i] != originalRate * 10)
++i;
if (i == infoVector[fullResIndex].rates.size())
infoVector[fullResIndex].rates.push_back(originalRate * 10);
fullRateIndex = i;
}
}
const QRect XRandRToggler::fullScreenRect(const QWidget */*wdgt*/) const {
int w, h;
{
int nSizes = 0;
XRRScreenSize *randrSizes = XRRConfigSizes(config, &nSizes);
Rotation rot = rotation;
SizeID currentID = XRRConfigCurrentConfiguration(config, &rot);
if (currentID < nSizes) {
w = randrSizes[currentID].width;
h = randrSizes[currentID].height;
} else {
w = infoVector[fullResIndex].w;
h = infoVector[fullResIndex].h;
}
}
return QRect(0, 0, w, h);
}
/**
* This method first resets the current resolution using RandR to wake up
* the graphics driver, then sets the resolution requested if it is among
* those offered by the driver.
*/
static void setSize(Display *pDisplay, uint32_t cx, uint32_t cy)
{
XRRScreenConfiguration *pConfig;
XRRScreenSize *pSizes;
int cSizes;
pConfig = XRRGetScreenInfo(pDisplay, DefaultRootWindow(pDisplay));
/* Reset the current mode */
LogRelFlowFunc(("Setting size %ux%u\n", cx, cy));
if (pConfig)
{
pSizes = XRRConfigSizes(pConfig, &cSizes);
unsigned uDist = UINT32_MAX;
int iMode = -1;
for (int i = 0; i < cSizes; ++i)
{
#define VBCL_SQUARE(x) (x) * (x)
unsigned uThisDist = VBCL_SQUARE(pSizes[i].width - cx)
+ VBCL_SQUARE(pSizes[i].height - cy);
LogRelFlowFunc(("Found size %dx%d, distance %u\n", pSizes[i].width,
pSizes[i].height, uThisDist));
#undef VBCL_SQUARE
if (uThisDist < uDist)
{
uDist = uThisDist;
iMode = i;
}
}
if (iMode >= 0)
{
Time config_timestamp = 0;
XRRConfigTimes(pConfig, &config_timestamp);
LogRelFlowFunc(("Setting new size %d\n", iMode));
XRRSetScreenConfig(pDisplay, pConfig,
DefaultRootWindow(pDisplay), iMode,
RR_Rotate_0, config_timestamp);
}
XRRFreeScreenConfigInfo(pConfig);
}
}
int init_x11videomodeiterator(/*out*/x11videomode_iterator_t * xvidit, x11screen_t * x11screen)
{
int err ;
XRRScreenConfiguration * screen_config = 0 ;
if (!isextxrandr_x11display(display_x11screen(x11screen))) {
err = ENOSYS ;
goto ONERR;
}
Display * sys_display = display_x11screen(x11screen)->sys_display ;
screen_config = XRRGetScreenInfo(sys_display, RootWindow(sys_display, number_x11screen(x11screen))) ;
if (!screen_config) {
err = ENOSYS ;
goto ONERR;
}
int sizes_count ;
XRRScreenSize * sizes = XRRConfigSizes(screen_config, &sizes_count) ;
if ( !sizes
|| (UINT16_MAX < (unsigned)sizes_count)) {
err = EOVERFLOW ;
goto ONERR;
}
xvidit->nextindex = 0 ;
xvidit->nrmodes = (uint16_t) sizes_count ;
xvidit->config = screen_config ;
return 0 ;
ONERR:
if (screen_config) {
XRRFreeScreenConfigInfo(screen_config) ;
}
TRACEEXIT_ERRLOG(err);
return err ;
}
bool C4AbstractApp::SetVideoMode(int iXRes, int iYRes, unsigned int iColorDepth, unsigned int iRefreshRate, unsigned int iMonitor, bool fFullScreen)
{
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
if (!fFullScreen)
{
RestoreVideoMode();
if (iXRes != -1)
pWindow->SetSize(iXRes, iYRes);
return true;
}
if (Priv->xrandr_major_version >= 0 && !(iXRes == -1 && iYRes == -1))
{
// randr spec says to always get fresh info, so don't cache.
XRRScreenConfiguration * conf = XRRGetScreenInfo (dpy, pWindow->renderwnd);
if (Priv->xrandr_oldmode == -1)
Priv->xrandr_oldmode = XRRConfigCurrentConfiguration (conf, &Priv->xrandr_rot);
int n;
XRRScreenSize * sizes = XRRConfigSizes(conf, &n);
for (int i = 0; i < n; ++i)
{
if (int(sizes[i].width) == iXRes && int(sizes[i].height) == iYRes)
{
#ifdef _DEBUG
LogF("XRRSetScreenConfig %d", i);
#endif
fDspModeSet = XRRSetScreenConfig(dpy, conf, pWindow->renderwnd, i, Priv->xrandr_rot, CurrentTime) == RRSetConfigSuccess;
break;
}
}
XRRFreeScreenConfigInfo(conf);
}
gtk_window_fullscreen(GTK_WINDOW(pWindow->window));
return fDspModeSet || (iXRes == -1 && iYRes == -1);
#endif
}
JNIEXPORT jobjectArray JNICALL
Java_gnu_java_awt_peer_gtk_GdkScreenGraphicsDevice_nativeGetDisplayModes
(JNIEnv *env, jobject obj __attribute__((unused)), jobject gdkGraphicsEnv __attribute__((unused)))
{
#ifdef HAVE_XRANDR
GdkDisplay *display;
XRRScreenConfiguration *config;
XRRScreenSize *screenSizes;
int nsizes = 0, nrates = 0, i = 0;
jclass x11DisplayMode_class;
jmethodID x11DisplayMode_ctor;
jobjectArray array;
jobject instance;
short *rates;
jshortArray shortArray;
display = (GdkDisplay *) NSA_GET_DISPLAY_PTR(env, gdkGraphicsEnv);
gdk_threads_enter();
config = XRRGetScreenInfo (GDK_DISPLAY_XDISPLAY(display), GDK_ROOT_WINDOW());
screenSizes = XRRConfigSizes(config, &nsizes);
x11DisplayMode_class = (*env)->FindClass(env, "gnu/java/awt/peer/gtk/GdkScreenGraphicsDevice$X11DisplayMode");
x11DisplayMode_ctor = (*env)->GetMethodID(env, x11DisplayMode_class, "<init>", "(II[S)V");
array = (*env)->NewObjectArray(env, nsizes, x11DisplayMode_class, NULL);
for (; i < nsizes ; i++)
{
/* Retrieves refresh rate information. */
rates = XRRConfigRates(config, i, &nrates);
/* Create a Java short array and put them in. */
shortArray = (*env)->NewShortArray(env, nrates);
(*env)->SetShortArrayRegion(env, shortArray, 0, nrates, (jshort *) rates);
/* Create a GdkScreenGraphicsDevice.X11DisplayMode instance. */
instance = (*env)->NewObject(env,
x11DisplayMode_class,
x11DisplayMode_ctor,
screenSizes[i].width,
screenSizes[i].height,
shortArray);
/* Put it into the result array. */
(*env)->SetObjectArrayElement(env, array, i, instance);
}
/* Free everything acquired by xlib. */
XRRFreeScreenConfigInfo (config);
gdk_threads_leave();
return array;
#else
JCL_ThrowException(env,
"java/lang/InternalError",
"Method should not have been invoked.");
return NULL;
#endif
}
//-------------------------------------------------------------------------------------------------//
GLXGLSupport::GLXGLSupport() : mGLDisplay(0), mXDisplay(0)
{
// A connection that might be shared with the application for GL rendering:
mGLDisplay = getGLDisplay();
// A connection that is NOT shared to enable independent event processing:
mXDisplay = getXDisplay();
int dummy;
if (XQueryExtension(mXDisplay, "RANDR", &dummy, &dummy, &dummy))
{
XRRScreenConfiguration *screenConfig;
screenConfig = XRRGetScreenInfo(mXDisplay, DefaultRootWindow(mXDisplay));
if (screenConfig)
{
XRRScreenSize *screenSizes;
int nSizes = 0;
Rotation currentRotation;
int currentSizeID = XRRConfigCurrentConfiguration(screenConfig, ¤tRotation);
screenSizes = XRRConfigSizes(screenConfig, &nSizes);
mCurrentMode.first.first = screenSizes[currentSizeID].width;
mCurrentMode.first.second = screenSizes[currentSizeID].height;
mCurrentMode.second = XRRConfigCurrentRate(screenConfig);
mOriginalMode = mCurrentMode;
for(int sizeID = 0; sizeID < nSizes; sizeID++)
{
short *rates;
int nRates = 0;
rates = XRRConfigRates(screenConfig, sizeID, &nRates);
for (int rate = 0; rate < nRates; rate++)
{
VideoMode mode;
mode.first.first = screenSizes[sizeID].width;
mode.first.second = screenSizes[sizeID].height;
mode.second = rates[rate];
mVideoModes.push_back(mode);
}
}
XRRFreeScreenConfigInfo(screenConfig);
}
}
else
{
mCurrentMode.first.first = DisplayWidth(mXDisplay, DefaultScreen(mXDisplay));
mCurrentMode.first.second = DisplayHeight(mXDisplay, DefaultScreen(mXDisplay));
mCurrentMode.second = 0;
mOriginalMode = mCurrentMode;
mVideoModes.push_back(mCurrentMode);
}
GLXFBConfig *fbConfigs;
int config, nConfigs = 0;
fbConfigs = chooseFBConfig(NULL, &nConfigs);
for (config = 0; config < nConfigs; config++)
{
int caveat, samples;
getFBConfigAttrib (fbConfigs[config], GLX_CONFIG_CAVEAT, &caveat);
if (caveat != GLX_SLOW_CONFIG)
{
getFBConfigAttrib (fbConfigs[config], GLX_SAMPLES, &samples);
mSampleLevels.push_back(StringConverter::toString(samples));
}
}
XFree (fbConfigs);
remove_duplicates(mSampleLevels);
}
/*
* Remembers the current visual settings, so that
* we can change them and restore later...
*/
void fgPlatformRememberState( void )
{
int event_base, error_base;
/*
* Remember the current pointer location before going fullscreen
* for restoring it later:
*/
Window junk_window;
unsigned int junk_mask;
XQueryPointer(fgDisplay.pDisplay.Display, fgDisplay.pDisplay.RootWindow,
&junk_window, &junk_window,
&fgDisplay.pDisplay.DisplayPointerX, &fgDisplay.pDisplay.DisplayPointerY,
&fgDisplay.pDisplay.DisplayPointerX, &fgDisplay.pDisplay.DisplayPointerY, &junk_mask);
# ifdef HAVE_X11_EXTENSIONS_XRANDR_H
if(XRRQueryExtension(fgDisplay.pDisplay.Display, &event_base, &error_base)) {
XRRScreenConfiguration *xrr_config;
XRRScreenSize *ssizes;
Rotation rot;
int ssize_count, curr;
if((xrr_config = XRRGetScreenInfo(fgDisplay.pDisplay.Display, fgDisplay.pDisplay.RootWindow))) {
ssizes = XRRConfigSizes(xrr_config, &ssize_count);
curr = XRRConfigCurrentConfiguration(xrr_config, &rot);
fgDisplay.pDisplay.prev_xsz = ssizes[curr].width;
fgDisplay.pDisplay.prev_ysz = ssizes[curr].height;
fgDisplay.pDisplay.prev_refresh = -1;
# if ( RANDR_MAJOR > 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )
if(fgState.GameModeRefresh != -1) {
fgDisplay.pDisplay.prev_refresh = XRRConfigCurrentRate(xrr_config);
}
# endif
fgDisplay.pDisplay.prev_size_valid = 1;
XRRFreeScreenConfigInfo(xrr_config);
}
}
# endif
/*
* This highly depends on the XFree86 extensions,
* not approved as X Consortium standards
*/
# ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
if(!XF86VidModeQueryExtension(fgDisplay.pDisplay.Display, &event_base, &error_base)) {
return;
}
/*
* Remember the current ViewPort location of the screen to be able to
* restore the ViewPort on LeaveGameMode():
*/
if( !XF86VidModeGetViewPort(
fgDisplay.pDisplay.Display,
fgDisplay.pDisplay.Screen,
&fgDisplay.pDisplay.DisplayViewPortX,
&fgDisplay.pDisplay.DisplayViewPortY ) )
fgWarning( "XF86VidModeGetViewPort failed" );
/* Query the current display settings: */
fgDisplay.pDisplay.DisplayModeValid =
XF86VidModeGetModeLine(
fgDisplay.pDisplay.Display,
fgDisplay.pDisplay.Screen,
&fgDisplay.pDisplay.DisplayModeClock,
&fgDisplay.pDisplay.DisplayMode
);
if( !fgDisplay.pDisplay.DisplayModeValid )
fgWarning( "XF86VidModeGetModeLine failed" );
# endif
}
static int xrandr_resize(int xsz, int ysz, int rate, int just_checking)
{
#ifdef HAVE_X11_EXTENSIONS_XRANDR_H
int event_base, error_base, ver_major, ver_minor, use_rate;
XRRScreenConfiguration *xrr_config = 0;
Status result = -1;
/* must check at runtime for the availability of the extension */
if(!XRRQueryExtension(fgDisplay.Display, &event_base, &error_base)) {
return -1;
}
XRRQueryVersion(fgDisplay.Display, &ver_major, &ver_minor);
/* we only heed the rate if we CAN actually use it (Xrandr >= 1.1) and
* the user actually cares about it (rate > 0)
*/
use_rate = ( rate > 0 ) && ( ( ver_major >= 1 ) ||
( ( ver_major == 1 ) && ( ver_minor >= 1 ) ) );
/* this loop is only so that the whole thing will be repeated if someone
* else changes video mode between our query of the current information and
* the attempt to change it.
*/
do {
XRRScreenSize *ssizes;
short *rates;
Rotation rot;
int i, ssizes_count, rates_count, curr, res_idx = -1;
Time timestamp, cfg_timestamp;
if(xrr_config) {
XRRFreeScreenConfigInfo(xrr_config);
}
if(!(xrr_config = XRRGetScreenInfo(fgDisplay.Display, fgDisplay.RootWindow))) {
fgWarning("XRRGetScreenInfo failed");
break;
}
ssizes = XRRConfigSizes(xrr_config, &ssizes_count);
curr = XRRConfigCurrentConfiguration(xrr_config, &rot);
timestamp = XRRConfigTimes(xrr_config, &cfg_timestamp);
/* if either of xsz or ysz are unspecified, use the current values */
if(xsz <= 0)
xsz = fgState.GameModeSize.X = ssizes[curr].width;
if(ysz <= 0)
ysz = fgState.GameModeSize.Y = ssizes[curr].height;
if(xsz == ssizes[curr].width && ysz == ssizes[curr].height) {
/* no need to switch, we're already in the requested resolution */
res_idx = curr;
} else {
for(i=0; i<ssizes_count; i++) {
if(ssizes[i].width == xsz && ssizes[i].height == ysz) {
res_idx = i;
break; /* found it */
}
}
}
if(res_idx == -1)
break; /* no matching resolution */
#if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )
if(use_rate) {
rate = fgState.GameModeRefresh;
/* for the selected resolution, let's find out if there is
* a matching refresh rate available.
*/
rates = XRRConfigRates(xrr_config, res_idx, &rates_count);
for(i=0; i<rates_count; i++) {
if(rates[i] == rate) {
break;
}
}
if(i == rates_count) {
break; /* no matching rate */
}
}
#endif
if(just_checking) {
result = 0;
break;
}
#if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )
if(use_rate)
result = XRRSetScreenConfigAndRate(fgDisplay.Display, xrr_config,
fgDisplay.RootWindow, res_idx, rot, rate, timestamp);
else
#endif
result = XRRSetScreenConfig(fgDisplay.Display, xrr_config,
fgDisplay.RootWindow, res_idx, rot, timestamp);
} while(result == RRSetConfigInvalidTime);
if(xrr_config) {
XRRFreeScreenConfigInfo(xrr_config);
}
if(result == 0) {
return 0;
}
#endif /* HAVE_X11_EXTENSIONS_XRANDR_H */
return -1;
}
/*
* Remembers the current visual settings, so that
* we can change them and restore later...
*/
static void fghRememberState( void )
{
#if TARGET_HOST_POSIX_X11
int event_base, error_base;
/*
* Remember the current pointer location before going fullscreen
* for restoring it later:
*/
Window junk_window;
unsigned int junk_mask;
XQueryPointer(fgDisplay.Display, fgDisplay.RootWindow,
&junk_window, &junk_window,
&fgDisplay.DisplayPointerX, &fgDisplay.DisplayPointerY,
&fgDisplay.DisplayPointerX, &fgDisplay.DisplayPointerY, &junk_mask);
# ifdef HAVE_X11_EXTENSIONS_XRANDR_H
if(XRRQueryExtension(fgDisplay.Display, &event_base, &error_base)) {
XRRScreenConfiguration *xrr_config;
XRRScreenSize *ssizes;
Rotation rot;
int ssize_count, curr;
if((xrr_config = XRRGetScreenInfo(fgDisplay.Display, fgDisplay.RootWindow))) {
ssizes = XRRConfigSizes(xrr_config, &ssize_count);
curr = XRRConfigCurrentConfiguration(xrr_config, &rot);
fgDisplay.prev_xsz = ssizes[curr].width;
fgDisplay.prev_ysz = ssizes[curr].height;
fgDisplay.prev_refresh = -1;
# if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )
if(fgState.GameModeRefresh != -1) {
fgDisplay.prev_refresh = XRRConfigCurrentRate(xrr_config);
}
# endif
fgDisplay.prev_size_valid = 1;
XRRFreeScreenConfigInfo(xrr_config);
}
}
# endif
/*
* This highly depends on the XFree86 extensions,
* not approved as X Consortium standards
*/
# ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
if(!XF86VidModeQueryExtension(fgDisplay.Display, &event_base, &error_base)) {
return;
}
/*
* Remember the current ViewPort location of the screen to be able to
* restore the ViewPort on LeaveGameMode():
*/
if( !XF86VidModeGetViewPort(
fgDisplay.Display,
fgDisplay.Screen,
&fgDisplay.DisplayViewPortX,
&fgDisplay.DisplayViewPortY ) )
fgWarning( "XF86VidModeGetViewPort failed" );
/* Query the current display settings: */
fgDisplay.DisplayModeValid =
XF86VidModeGetModeLine(
fgDisplay.Display,
fgDisplay.Screen,
&fgDisplay.DisplayModeClock,
&fgDisplay.DisplayMode
);
if( !fgDisplay.DisplayModeValid )
fgWarning( "XF86VidModeGetModeLine failed" );
# endif
#elif TARGET_HOST_MS_WINDOWS
/* DEVMODE devMode; */
/* Grab the current desktop settings... */
/* hack to get around my stupid cross-gcc headers */
#define FREEGLUT_ENUM_CURRENT_SETTINGS -1
EnumDisplaySettings( fgDisplay.DisplayName, FREEGLUT_ENUM_CURRENT_SETTINGS,
&fgDisplay.DisplayMode );
/* Make sure we will be restoring all settings needed */
fgDisplay.DisplayMode.dmFields |=
DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFREQUENCY;
#endif
}
const DisplayResVector& DisplayResX::GetVideoModes(void) const
{
if (!m_videoModes.empty())
return m_videoModes;
MythXDisplay *display = NULL;
XRRScreenConfiguration *cfg = GetScreenConfig(display);
if (!cfg)
return m_videoModes;
int num_sizes, num_rates;
XRRScreenSize *sizes = NULL;
sizes = XRRConfigSizes(cfg, &num_sizes);
for (int i = 0; i < num_sizes; ++i)
{
short *rates = NULL;
rates = XRRRates(display->GetDisplay(), display->GetScreen(),
i, &num_rates);
DisplayResScreen scr(sizes[i].width, sizes[i].height,
sizes[i].mwidth, sizes[i].mheight,
rates, num_rates);
m_videoModes.push_back(scr);
}
t_screenrate screenmap;
int nvidiarate = GetNvidiaRates(screenmap);
if (nvidiarate > 0)
{
// Update existing DisplayResScreen vector, and update it with
// new frequencies
for (uint i = 0; i < m_videoModes.size(); i++)
{
DisplayResScreen scr = m_videoModes[i];
int w = scr.Width();
int h = scr.Height();
int mw = scr.Width_mm();
int mh = scr.Height_mm();
std::vector<double> newrates;
std::map<double, short> realRates;
const std::vector<double>& rates = scr.RefreshRates();
bool found = false;
for (std::vector<double>::const_iterator it = rates.begin();
it != rates.end(); ++it)
{
uint64_t key = DisplayResScreen::CalcKey(w, h, *it);
if (screenmap.find(key) != screenmap.end())
{
// Rate is defined in NV-CONTROL extension, use it
newrates.push_back(screenmap[key]);
realRates[screenmap[key]] = (int) round(*it);
found = true;
#if 0
LOG(VB_PLAYBACK, LOG_INFO,
QString("CustomRate Found, set %1x%2@%3 as %4Hz")
.arg(w) .arg(h) .arg(*it) .arg(screenmap[key]));
#endif
}
}
if (found)
{
m_videoModes.erase(m_videoModes.begin() + i);
std::sort(newrates.begin(), newrates.end());
m_videoModes.insert(m_videoModes.begin() + i,
DisplayResScreen(w, h, mw, mh, newrates,
realRates));
}
}
}
m_videoModesUnsorted = m_videoModes;
std::sort(m_videoModes.begin(), m_videoModes.end());
XRRFreeScreenConfigInfo(cfg);
delete display;
return m_videoModes;
}
static _GLFWvidsize* getResolutions(int* found)
{
int i, j;
_GLFWvidsize* result = NULL;
*found = 0;
// Build array of available resolutions
if (_glfwLibrary.X11.RandR.available)
{
#if defined(_GLFW_HAS_XRANDR)
XRRScreenConfiguration* sc;
XRRScreenSize* sizes;
sc = XRRGetScreenInfo(_glfwLibrary.X11.display, _glfwLibrary.X11.root);
sizes = XRRConfigSizes(sc, found);
result = (_GLFWvidsize*) malloc(sizeof(_GLFWvidsize) * *found);
for (i = 0; i < *found; i++)
{
result[i].width = sizes[i].width;
result[i].height = sizes[i].height;
}
XRRFreeScreenConfigInfo(sc);
#endif /*_GLFW_HAS_XRANDR*/
}
else if (_glfwLibrary.X11.VidMode.available)
{
#if defined(_GLFW_HAS_XF86VIDMODE)
XF86VidModeModeInfo** modes;
int modeCount;
XF86VidModeGetAllModeLines(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
&modeCount, &modes);
result = (_GLFWvidsize*) malloc(sizeof(_GLFWvidsize) * modeCount);
for (i = 0; i < modeCount; i++)
{
_GLFWvidsize size;
size.width = modes[i]->hdisplay;
size.height = modes[i]->vdisplay;
for (j = 0; j < *found; j++)
{
if (memcmp(result + j, &size, sizeof(_GLFWvidsize)) == 0)
break;
}
if (j < *found)
{
// This size is a duplicate, so skip it
continue;
}
result[*found] = size;
(*found)++;
}
XFree(modes);
#endif /*_GLFW_HAS_XF86VIDMODE*/
}
if (result == NULL)
{
*found = 1;
result = (_GLFWvidsize*) malloc(sizeof(_GLFWvidsize));
result[0].width = DisplayWidth(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen);
result[0].height = DisplayHeight(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen);
}
return result;
}
int _glfwGetClosestVideoMode(int* width, int* height, int* rate)
{
int i, match, bestmatch;
if (_glfwLibrary.X11.RandR.available)
{
#if defined(_GLFW_HAS_XRANDR)
int sizecount, bestsize;
int ratecount, bestrate;
short* ratelist;
XRRScreenConfiguration* sc;
XRRScreenSize* sizelist;
sc = XRRGetScreenInfo(_glfwLibrary.X11.display, _glfwLibrary.X11.root);
sizelist = XRRConfigSizes(sc, &sizecount);
// Find the best matching mode
bestsize = -1;
bestmatch = INT_MAX;
for (i = 0; i < sizecount; i++)
{
match = (*width - sizelist[i].width) *
(*width - sizelist[i].width) +
(*height - sizelist[i].height) *
(*height - sizelist[i].height);
if (match < bestmatch)
{
bestmatch = match;
bestsize = i;
}
}
if (bestsize != -1)
{
// Report width & height of best matching mode
*width = sizelist[bestsize].width;
*height = sizelist[bestsize].height;
if (*rate > 0)
{
ratelist = XRRConfigRates(sc, bestsize, &ratecount);
bestrate = -1;
bestmatch = INT_MAX;
for (i = 0; i < ratecount; i++)
{
match = abs(ratelist[i] - *rate);
if (match < bestmatch)
{
bestmatch = match;
bestrate = ratelist[i];
}
}
if (bestrate != -1)
*rate = bestrate;
}
}
XRRFreeScreenConfigInfo(sc);
if (bestsize != -1)
return bestsize;
#endif /*_GLFW_HAS_XRANDR*/
}
else if (_glfwLibrary.X11.VidMode.available)
{
#if defined(_GLFW_HAS_XF86VIDMODE)
XF86VidModeModeInfo** modelist;
int bestmode, modecount;
// Get a list of all available display modes
XF86VidModeGetAllModeLines(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
&modecount, &modelist);
// Find the best matching mode
bestmode = -1;
bestmatch = INT_MAX;
for (i = 0; i < modecount; i++)
{
match = (*width - modelist[i]->hdisplay) *
(*width - modelist[i]->hdisplay) +
(*height - modelist[i]->vdisplay) *
(*height - modelist[i]->vdisplay);
if (match < bestmatch)
{
bestmatch = match;
bestmode = i;
}
}
if (bestmode != -1)
{
// Report width & height of best matching mode
*width = modelist[bestmode]->hdisplay;
*height = modelist[bestmode]->vdisplay;
}
XFree(modelist);
if (bestmode != -1)
return bestmode;
#endif /*_GLFW_HAS_XF86VIDMODE*/
}
// Default: Simply use the screen resolution
*width = DisplayWidth(_glfwLibrary.X11.display, _glfwLibrary.X11.screen);
*height = DisplayHeight(_glfwLibrary.X11.display, _glfwLibrary.X11.screen);
return 0;
}
int
apply_transform (Display *display,
Window root,
RRCrtc crtcnum,
const char *input_name)
{
int ret;
ret = EXIT_SUCCESS;
if (ret != EXIT_FAILURE) {
XRRScreenConfiguration *sconf;
XRRScreenResources *res;
XRRCrtcInfo *crtc;
XRRCrtcTransformAttributes *transform;
Status status;
double amx[3][3];
double sina, cosa;
double hscale, vscale, hoffs, voffs;
XRRScreenSize *ssize;
int nsizes;
Rotation srot;
res = XRRGetScreenResourcesCurrent (display, root);
sconf = XRRGetScreenInfo (display, root);
ssize = XRRConfigSizes(sconf, &nsizes) + XRRConfigCurrentConfiguration (sconf, &srot);
crtc = XRRGetCrtcInfo (display, res, crtcnum);
if (verbose) {
fprintf (stderr, "Screen: (%u, %u) 0x%02x\n", ssize->width, ssize->height, srot);
fprintf (stderr, "CRTC: (%i, %i) (%u, %u) 0x%02x\n", crtc->x, crtc->y, crtc->width, crtc->height, crtc->rotation);
}
switch (srot) {
case RR_Rotate_0:
case RR_Rotate_180:
hscale = (double)crtc->width/(double)ssize->width;
vscale = (double)crtc->height/(double)ssize->height;
break;
case RR_Rotate_90:
case RR_Rotate_270:
hscale = (double)crtc->width/(double)ssize->height;
vscale = (double)crtc->height/(double)ssize->width;
break;
default:
ret = EXIT_FAILURE;
fprintf (stderr, "The screen rotation/reflection 0x%02x is not supported yet. Sorry.\n", srot);
}
switch (crtc->rotation) {
case RR_Rotate_0:
sina = 0;
cosa = 1;
hoffs = 0;
voffs = 0;
break;
case RR_Rotate_90:
sina = 1;
cosa = 0;
hoffs = 1;
voffs = 0;
break;
case RR_Rotate_180:
sina = 0;
cosa = -1;
hoffs = 1;
voffs = 1;
break;
case RR_Rotate_270:
sina = -1;
cosa = 0;
hoffs = 0;
voffs = 1;
break;
default:
ret = EXIT_FAILURE;
fprintf (stderr, "The rotation/reflection 0x%02x is not supported yet. Sorry.\n", crtc->rotation);
}
if (ret != EXIT_FAILURE) {
amx[0][0] = cosa*hscale;
amx[0][1] = -sina*hscale;
amx[0][2] = hoffs*hscale + crtc->x/ssize->width;
amx[1][0] = sina*vscale;
amx[1][1] = cosa*vscale;
amx[1][2] = voffs*vscale + crtc->y/ssize->height;
amx[2][0] = 0;
amx[2][1] = 0;
amx[2][2] = 1;
status = XRRGetCrtcTransform (display, crtcnum, &transform);
if (!status) {
fprintf (stderr, "Unable to get the current transformation\n");
ret = EXIT_FAILURE;
}
}
if (ret != EXIT_FAILURE) {
static char strmx[3][3][8];
static const char *args[11];
double mx[3][3];
int i, j;
for (j = 0; j < 3; j++) {
for (i = 0; i < 3; i++) {
XFixed fv = transform->currentTransform.matrix[j][i];
mx[j][i] = XFixedToDouble (fv);
}
}
args[0] = input_name;
args[1] = "Coordinate Transformation Matrix";
for (j = 0; j < 3; j++) {
for (i = 0; i < 3; i++) {
double v = mx[0][i]*amx[j][0] + mx[1][i]*amx[j][1] + mx[2][i]*amx[j][2];
snprintf (strmx[j][i], 8, "%8.6f", v);
args[2 + i + j*3] = strmx[j][i];
}
}
if (verbose) {
fprintf (stderr, "Debug: set-float-prop");
for (i = 0; i < 11; i++) {
fprintf (stderr, " %s", args[i]);
}
fprintf (stderr, "\n");
}
ret = set_float_prop(display, 11, args, "set-float-prop", ": error calling function, please report a bug.");
XFree (transform);
}
XRRFreeCrtcInfo (crtc);
XRRFreeScreenResources (res);
XRRFreeScreenConfigInfo (sconf);
}
return ret;
}
X11EGLSupport::X11EGLSupport()
{
mNativeDisplay = getNativeDisplay();
mGLDisplay = getGLDisplay();
int dummy;
if (XQueryExtension((Display*)mNativeDisplay, "RANDR", &dummy, &dummy, &dummy))
{
XRRScreenConfiguration *screenConfig;
mRandr = true;
screenConfig = XRRGetScreenInfo((Display*)mNativeDisplay, DefaultRootWindow((Display*)mNativeDisplay));
if (screenConfig)
{
XRRScreenSize *screenSizes;
int nSizes = 0;
Rotation currentRotation;
int currentSizeID = XRRConfigCurrentConfiguration(screenConfig, ¤tRotation);
screenSizes = XRRConfigSizes(screenConfig, &nSizes);
mCurrentMode.first.first = screenSizes[currentSizeID].width;
mCurrentMode.first.second = screenSizes[currentSizeID].height;
mCurrentMode.second = XRRConfigCurrentRate(screenConfig);
mOriginalMode = mCurrentMode;
for (int sizeID = 0; sizeID < nSizes; sizeID++)
{
short *rates;
int nRates = 0;
rates = XRRConfigRates(screenConfig, sizeID, &nRates);
for (int rate = 0; rate < nRates; rate++)
{
VideoMode mode;
mode.first.first = screenSizes[sizeID].width;
mode.first.second = screenSizes[sizeID].height;
mode.second = rates[rate];
mVideoModes.push_back(mode);
}
}
XRRFreeScreenConfigInfo(screenConfig);
}
}
else
{
mCurrentMode.first.first = DisplayWidth((Display*)mNativeDisplay, DefaultScreen(mNativeDisplay));
mCurrentMode.first.second = DisplayHeight((Display*)mNativeDisplay, DefaultScreen(mNativeDisplay));
mCurrentMode.second = 0;
mOriginalMode = mCurrentMode;
mVideoModes.push_back(mCurrentMode);
}
EGLConfig *glConfigs;
int config, nConfigs = 0;
glConfigs = chooseGLConfig(NULL, &nConfigs);
for (config = 0; config < nConfigs; config++)
{
int caveat, samples;
getGLConfigAttrib(glConfigs[config], EGL_CONFIG_CAVEAT, &caveat);
if (caveat != EGL_SLOW_CONFIG)
{
getGLConfigAttrib(glConfigs[config], EGL_SAMPLES, &samples);
mSampleLevels.push_back(StringConverter::toString(samples));
}
}
free(glConfigs);
removeDuplicates(mSampleLevels);
}
bool CIrrDeviceLinux::createWindow()
{
#ifdef _IRR_COMPILE_WITH_X11_
#ifdef _DEBUG
os::Printer::log("Creating X window...", ELL_INFORMATION);
XSetErrorHandler(IrrPrintXError);
#endif
display = XOpenDisplay(0);
if (!display)
{
os::Printer::log("Error: Need running XServer to start Irrlicht Engine.", ELL_ERROR);
os::Printer::log("Could not open display", XDisplayName(0), ELL_ERROR);
return false;
}
screennr = DefaultScreen(display);
// query extension
if (CreationParams.Fullscreen)
{
getVideoModeList();
#if defined(_IRR_LINUX_X11_VIDMODE_) || defined(_IRR_LINUX_X11_RANDR_)
s32 eventbase, errorbase;
s32 bestMode = -1;
#endif
#ifdef _IRR_LINUX_X11_VIDMODE_
if (XF86VidModeQueryExtension(display, &eventbase, &errorbase))
{
// enumerate video modes
s32 modeCount;
XF86VidModeModeInfo** modes;
XF86VidModeGetAllModeLines(display, screennr, &modeCount, &modes);
// find fitting mode
for (s32 i = 0; i<modeCount; ++i)
{
if (bestMode==-1 && modes[i]->hdisplay >= Width && modes[i]->vdisplay >= Height)
bestMode = i;
else if (bestMode!=-1 &&
modes[i]->hdisplay >= Width &&
modes[i]->vdisplay >= Height &&
modes[i]->hdisplay < modes[bestMode]->hdisplay &&
modes[i]->vdisplay < modes[bestMode]->vdisplay)
bestMode = i;
}
if (bestMode != -1)
{
os::Printer::log("Starting fullscreen mode...", ELL_INFORMATION);
XF86VidModeSwitchToMode(display, screennr, modes[bestMode]);
XF86VidModeSetViewPort(display, screennr, 0, 0);
UseXVidMode=true;
}
else
{
os::Printer::log("Could not find specified video mode, running windowed.", ELL_WARNING);
CreationParams.Fullscreen = false;
}
XFree(modes);
}
else
#endif
#ifdef _IRR_LINUX_X11_RANDR_
if (XRRQueryExtension(display, &eventbase, &errorbase))
{
s32 modeCount;
XRRScreenConfiguration *config=XRRGetScreenInfo(display,DefaultRootWindow(display));
XRRScreenSize *modes=XRRConfigSizes(config,&modeCount);
for (s32 i = 0; i<modeCount; ++i)
{
if (bestMode==-1 && (u32)modes[i].width >= Width && (u32)modes[i].height >= Height)
bestMode = i;
else if (bestMode!=-1 &&
(u32)modes[i].width >= Width &&
(u32)modes[i].height >= Height &&
modes[i].width < modes[bestMode].width &&
modes[i].height < modes[bestMode].height)
bestMode = i;
}
if (bestMode != -1)
{
XRRSetScreenConfig(display,config,DefaultRootWindow(display),bestMode,oldRandrRotation,CurrentTime);
UseXRandR=true;
}
XRRFreeScreenConfigInfo(config);
}
else
#endif
{
os::Printer::log("VidMode or RandR extension must be installed to allow Irrlicht "
"to switch to fullscreen mode. Running in windowed mode instead.", ELL_WARNING);
CreationParams.Fullscreen = false;
}
}
#ifdef _IRR_COMPILE_WITH_OPENGL_
GLXFBConfig glxFBConfig;
int major, minor;
bool isAvailableGLX=false;
if (CreationParams.DriverType==video::EDT_OPENGL)
{
isAvailableGLX=glXQueryExtension(display,&major,&minor);
if (isAvailableGLX && glXQueryVersion(display, &major, &minor))
{
if (major==1 && minor>2)
{
const int MAX_SAMPLES = 16;
// attribute array for the draw buffer
int visualAttrBuffer[] =
{
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_RED_SIZE, 4,
GLX_GREEN_SIZE, 4,
GLX_BLUE_SIZE, 4,
GLX_ALPHA_SIZE, CreationParams.WithAlphaChannel?1:0,
GLX_DEPTH_SIZE, CreationParams.ZBufferBits,
GLX_DOUBLEBUFFER, GL_TRUE,
GLX_STENCIL_SIZE, 1,
GLX_SAMPLE_BUFFERS_ARB, 1,
GLX_SAMPLES_ARB, MAX_SAMPLES,
None
};
GLXFBConfig *configList=0;
int nitems=0;
if (!CreationParams.AntiAlias)
{
visualAttrBuffer[17] = 0;
visualAttrBuffer[19] = 0;
}
if (CreationParams.Stencilbuffer)
{
configList=glXChooseFBConfig(display, screennr, visualAttrBuffer,&nitems);
if (!configList && CreationParams.AntiAlias)
{
while (!configList && (visualAttrBuffer[19]>1))
{
visualAttrBuffer[19] >>= 1;
configList=glXChooseFBConfig(display, screennr, visualAttrBuffer,&nitems);
}
if (!configList)
{
visualAttrBuffer[17] = 0;
visualAttrBuffer[19] = 0;
configList=glXChooseFBConfig(display, screennr, visualAttrBuffer,&nitems);
if (configList)
{
os::Printer::log("No FSAA available.", ELL_WARNING);
CreationParams.AntiAlias=false;
}
else
{
//reenable multisampling
visualAttrBuffer[17] = 1;
visualAttrBuffer[19] = MAX_SAMPLES;
}
}
}
}
// Next try without stencil buffer
if (!configList)
{
if (CreationParams.Stencilbuffer)
os::Printer::log("No stencilbuffer available, disabling stencil shadows.", ELL_WARNING);
CreationParams.Stencilbuffer = false;
visualAttrBuffer[15]=0;
configList=glXChooseFBConfig(display, screennr, visualAttrBuffer,&nitems);
if (!configList && CreationParams.AntiAlias)
{
while (!configList && (visualAttrBuffer[19]>1))
{
visualAttrBuffer[19] >>= 1;
configList=glXChooseFBConfig(display, screennr, visualAttrBuffer,&nitems);
}
if (!configList)
{
visualAttrBuffer[17] = 0;
visualAttrBuffer[19] = 0;
configList=glXChooseFBConfig(display, screennr, visualAttrBuffer,&nitems);
if (configList)
{
os::Printer::log("No FSAA available.", ELL_WARNING);
CreationParams.AntiAlias=false;
}
else
{
//reenable multisampling
visualAttrBuffer[17] = 1;
visualAttrBuffer[19] = MAX_SAMPLES;
}
}
}
}
// Next try without double buffer
if (!configList)
{
os::Printer::log("No doublebuffering available.", ELL_WARNING);
visualAttrBuffer[13] = GL_FALSE;
configList=glXChooseFBConfig(display, screennr, visualAttrBuffer,&nitems);
if (!configList && CreationParams.AntiAlias)
{
while (!configList && (visualAttrBuffer[19]>1))
{
visualAttrBuffer[19] >>= 1;
configList=glXChooseFBConfig(display, screennr, visualAttrBuffer,&nitems);
}
if (!configList)
{
visualAttrBuffer[17] = 0;
visualAttrBuffer[19] = 0;
configList=glXChooseFBConfig(display, screennr, visualAttrBuffer,&nitems);
if (configList)
{
os::Printer::log("No FSAA available.", ELL_WARNING);
CreationParams.AntiAlias=false;
}
else
{
//reenable multisampling
visualAttrBuffer[17] = 1;
visualAttrBuffer[19] = MAX_SAMPLES;
}
}
}
}
if (configList)
{
glxFBConfig=configList[0];
XFree(configList);
UseGLXWindow=true;
visual = glXGetVisualFromFBConfig(display,glxFBConfig);
}
}
std::vector<VideoMode> VideoModeImpl::getFullscreenModes()
{
std::vector<VideoMode> modes;
// Open a connection with the X server
Display* display = OpenDisplay();
if (display)
{
// Retrieve the default screen number
int screen = DefaultScreen(display);
// Check if the XRandR extension is present
int version;
if (XQueryExtension(display, "RANDR", &version, &version, &version))
{
// Get the current configuration
XRRScreenConfiguration* config = XRRGetScreenInfo(display, RootWindow(display, screen));
if (config)
{
// Get the available screen sizes
int nbSizes;
XRRScreenSize* sizes = XRRConfigSizes(config, &nbSizes);
if (sizes && (nbSizes > 0))
{
// Get the list of supported depths
int nbDepths = 0;
int* depths = XListDepths(display, screen, &nbDepths);
if (depths && (nbDepths > 0))
{
// Combine depths and sizes to fill the array of supported modes
for (int i = 0; i < nbDepths; ++i)
{
for (int j = 0; j < nbSizes; ++j)
{
// Convert to VideoMode
VideoMode mode(sizes[j].width, sizes[j].height, depths[i]);
// Add it only if it is not already in the array
if (std::find(modes.begin(), modes.end(), mode) == modes.end())
modes.push_back(mode);
}
}
// Free the array of depths
XFree(depths);
}
}
// Free the configuration instance
XRRFreeScreenConfigInfo(config);
}
else
{
// Failed to get the screen configuration
err() << "Failed to retrieve the screen configuration while trying to get the supported video modes" << std::endl;
}
}
else
{
// XRandr extension is not supported : we cannot get the video modes
err() << "Failed to use the XRandR extension while trying to get the supported video modes" << std::endl;
}
// Close the connection with the X server
CloseDisplay(display);
}
else
{
// We couldn't connect to the X server
err() << "Failed to connect to the X server while trying to get the supported video modes" << std::endl;
}
return modes;
}
Bool
SelectResolution(uint32 width,
uint32 height)
{
ResolutionInfoX11Type *resInfoX = &resolutionInfoX11;
XRRScreenConfiguration* xrrConfig;
XRRScreenSize *xrrSizes;
Rotation xrrCurRotation;
uint32 xrrNumSizes;
uint32 i;
uint32 bestFitIndex = 0;
uint64 bestFitSize = 0;
uint64 potentialSize;
Bool perfectMatch;
#ifndef NO_MULTIMON
if (resInfoX->canUseRandR12) {
xXineramaScreenInfo display;
display.x_org = 0;
display.y_org = 0;
display.width = width;
display.height = height;
return RandR12_SetTopology(resInfoX->display,
DefaultScreen(resInfoX->display),
resInfoX->rootWindow,
1, &display, width, height);
}
#endif
xrrConfig = XRRGetScreenInfo(resInfoX->display, resInfoX->rootWindow);
xrrSizes = XRRConfigSizes(xrrConfig, &xrrNumSizes);
bestFitIndex = XRRConfigCurrentConfiguration(xrrConfig, &xrrCurRotation);
/*
* Iterate thru the list finding the best fit that is still <= in both width
* and height.
*/
for (i = 0; i < xrrNumSizes; i++) {
potentialSize = xrrSizes[i].width * xrrSizes[i].height;
if (xrrSizes[i].width <= width && xrrSizes[i].height <= height &&
potentialSize > bestFitSize ) {
bestFitSize = potentialSize;
bestFitIndex = i;
}
}
if (bestFitSize > 0) {
Status rc;
g_debug("Setting guest resolution to: %dx%d (requested: %d, %d)\n",
xrrSizes[bestFitIndex].width, xrrSizes[bestFitIndex].height, width, height);
rc = XRRSetScreenConfig(resInfoX->display, xrrConfig, resInfoX->rootWindow,
bestFitIndex, xrrCurRotation, GDK_CURRENT_TIME);
g_debug("XRRSetScreenConfig returned %d (result: %dx%d)\n", rc,
xrrSizes[bestFitIndex].width, xrrSizes[bestFitIndex].height);
} else {
g_debug("Can't find a suitable guest resolution, ignoring request for %dx%d\n",
width, height);
}
perfectMatch = xrrSizes[bestFitIndex].width == width &&
xrrSizes[bestFitIndex].height == height;
XRRFreeScreenConfigInfo(xrrConfig);
return perfectMatch;
}
