You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
368 lines
11 KiB
368 lines
11 KiB
//======================================================================== |
|
// GLFW - An OpenGL library |
|
// Platform: X11 (Unix) |
|
// API version: 3.0 |
|
// WWW: http://www.glfw.org/ |
|
//------------------------------------------------------------------------ |
|
// Copyright (c) 2002-2006 Marcus Geelnard |
|
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org> |
|
// |
|
// This software is provided 'as-is', without any express or implied |
|
// warranty. In no event will the authors be held liable for any damages |
|
// arising from the use of this software. |
|
// |
|
// Permission is granted to anyone to use this software for any purpose, |
|
// including commercial applications, and to alter it and redistribute it |
|
// freely, subject to the following restrictions: |
|
// |
|
// 1. The origin of this software must not be misrepresented; you must not |
|
// claim that you wrote the original software. If you use this software |
|
// in a product, an acknowledgment in the product documentation would |
|
// be appreciated but is not required. |
|
// |
|
// 2. Altered source versions must be plainly marked as such, and must not |
|
// be misrepresented as being the original software. |
|
// |
|
// 3. This notice may not be removed or altered from any source |
|
// distribution. |
|
// |
|
//======================================================================== |
|
|
|
#include "internal.h" |
|
|
|
#include <limits.h> |
|
#include <stdlib.h> |
|
#include <string.h> |
|
|
|
|
|
static int calculateRefreshRate(const XRRModeInfo* mi) |
|
{ |
|
if (!mi->hTotal || !mi->vTotal) |
|
return 0; |
|
|
|
return (int) ((double) mi->dotClock / ((double) mi->hTotal * (double) mi->vTotal)); |
|
} |
|
|
|
static const XRRModeInfo* getModeInfo(const XRRScreenResources* sr, RRMode id) |
|
{ |
|
int i; |
|
|
|
for (i = 0; i < sr->nmode; i++) |
|
{ |
|
if (sr->modes[i].id == id) |
|
return sr->modes + i; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
|
|
////////////////////////////////////////////////////////////////////////// |
|
////// GLFW internal API ////// |
|
////////////////////////////////////////////////////////////////////////// |
|
|
|
// Set the current video mode for the specified monitor |
|
// |
|
void _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired) |
|
{ |
|
if (_glfw.x11.randr.available) |
|
{ |
|
int i; |
|
XRRScreenResources* sr; |
|
XRRCrtcInfo* ci; |
|
RRMode bestMode = 0; |
|
unsigned int leastSizeDiff = UINT_MAX, leastRateDiff = UINT_MAX; |
|
|
|
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root); |
|
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc); |
|
|
|
for (i = 0; i < sr->nmode; i++) |
|
{ |
|
XRRModeInfo* mi = sr->modes + i; |
|
|
|
if (mi->modeFlags & RR_Interlace) |
|
continue; |
|
|
|
const unsigned int sizeDiff = (mi->width - desired->width) * |
|
(mi->width - desired->width) + |
|
(mi->height - desired->height) * |
|
(mi->height - desired->height); |
|
|
|
const unsigned int rateDiff = abs(calculateRefreshRate(mi) - desired->refreshRate); |
|
|
|
if ((sizeDiff < leastSizeDiff) || |
|
(sizeDiff == leastSizeDiff && rateDiff < leastRateDiff)) |
|
{ |
|
bestMode = mi->id; |
|
leastSizeDiff = sizeDiff; |
|
leastRateDiff = rateDiff; |
|
} |
|
} |
|
|
|
monitor->x11.oldMode = ci->mode; |
|
|
|
XRRSetCrtcConfig(_glfw.x11.display, |
|
sr, monitor->x11.crtc, |
|
CurrentTime, |
|
ci->x, ci->y, |
|
bestMode, |
|
ci->rotation, |
|
ci->outputs, |
|
ci->noutput); |
|
|
|
XRRFreeCrtcInfo(ci); |
|
XRRFreeScreenResources(sr); |
|
} |
|
} |
|
|
|
// Restore the saved (original) video mode for the specified monitor |
|
// |
|
void _glfwRestoreVideoMode(_GLFWmonitor* monitor) |
|
{ |
|
if (_glfw.x11.randr.available) |
|
{ |
|
XRRScreenResources* sr; |
|
XRRCrtcInfo* ci; |
|
|
|
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root); |
|
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc); |
|
|
|
XRRSetCrtcConfig(_glfw.x11.display, |
|
sr, monitor->x11.crtc, |
|
CurrentTime, |
|
ci->x, ci->y, |
|
monitor->x11.oldMode, |
|
ci->rotation, |
|
ci->outputs, |
|
ci->noutput); |
|
|
|
XRRFreeCrtcInfo(ci); |
|
XRRFreeScreenResources(sr); |
|
} |
|
} |
|
|
|
|
|
////////////////////////////////////////////////////////////////////////// |
|
////// GLFW platform API ////// |
|
////////////////////////////////////////////////////////////////////////// |
|
|
|
_GLFWmonitor** _glfwPlatformGetMonitors(int* found) |
|
{ |
|
_GLFWmonitor** monitors = NULL; |
|
|
|
*found = 0; |
|
|
|
if (_glfw.x11.randr.available) |
|
{ |
|
int i; |
|
RROutput primary; |
|
XRRScreenResources* sr; |
|
|
|
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root); |
|
primary = XRRGetOutputPrimary(_glfw.x11.display, _glfw.x11.root); |
|
|
|
monitors = (_GLFWmonitor**) calloc(sr->noutput, sizeof(_GLFWmonitor*)); |
|
|
|
for (i = 0; i < sr->ncrtc; i++) |
|
{ |
|
int j; |
|
XRROutputInfo* oi; |
|
XRRCrtcInfo* ci; |
|
RROutput output; |
|
|
|
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, sr->crtcs[i]); |
|
output = ci->outputs[0]; |
|
|
|
for (j = 0; j < ci->noutput; j++) |
|
{ |
|
if (ci->outputs[j] == primary) |
|
{ |
|
output = primary; |
|
break; |
|
} |
|
} |
|
|
|
oi = XRRGetOutputInfo(_glfw.x11.display, sr, output); |
|
if (oi->connection != RR_Connected) |
|
{ |
|
XRRFreeOutputInfo(oi); |
|
XRRFreeCrtcInfo(ci); |
|
continue; |
|
} |
|
|
|
monitors[*found] = _glfwCreateMonitor(oi->name, |
|
oi->mm_width, oi->mm_height); |
|
|
|
monitors[*found]->x11.output = output; |
|
monitors[*found]->x11.crtc = oi->crtc; |
|
|
|
XRRFreeOutputInfo(oi); |
|
XRRFreeCrtcInfo(ci); |
|
|
|
(*found)++; |
|
} |
|
|
|
XRRFreeScreenResources(sr); |
|
|
|
for (i = 0; i < *found; i++) |
|
{ |
|
if (monitors[i]->x11.output == primary) |
|
{ |
|
_GLFWmonitor* temp = monitors[0]; |
|
monitors[0] = monitors[i]; |
|
monitors[i] = temp; |
|
break; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
monitors = (_GLFWmonitor**) calloc(1, sizeof(_GLFWmonitor*)); |
|
monitors[0] = _glfwCreateMonitor("Display", |
|
DisplayWidthMM(_glfw.x11.display, |
|
_glfw.x11.screen), |
|
DisplayHeightMM(_glfw.x11.display, |
|
_glfw.x11.screen)); |
|
*found = 1; |
|
} |
|
|
|
return monitors; |
|
} |
|
|
|
GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second) |
|
{ |
|
return first->x11.crtc == second->x11.crtc; |
|
} |
|
|
|
void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos) |
|
{ |
|
if (_glfw.x11.randr.available) |
|
{ |
|
XRRScreenResources* sr; |
|
XRRCrtcInfo* ci; |
|
|
|
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root); |
|
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc); |
|
|
|
if (xpos) |
|
*xpos = ci->x; |
|
if (ypos) |
|
*ypos = ci->y; |
|
|
|
XRRFreeCrtcInfo(ci); |
|
XRRFreeScreenResources(sr); |
|
} |
|
else |
|
{ |
|
if (xpos) |
|
*xpos = 0; |
|
if (ypos) |
|
*ypos = 0; |
|
} |
|
} |
|
|
|
GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found) |
|
{ |
|
GLFWvidmode* result; |
|
int depth, r, g, b; |
|
|
|
depth = DefaultDepth(_glfw.x11.display, _glfw.x11.screen); |
|
_glfwSplitBPP(depth, &r, &g, &b); |
|
|
|
*found = 0; |
|
|
|
// Build array of available resolutions |
|
|
|
if (_glfw.x11.randr.available) |
|
{ |
|
int i, j; |
|
XRRScreenResources* sr; |
|
XRROutputInfo* oi; |
|
|
|
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root); |
|
oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output); |
|
|
|
result = (GLFWvidmode*) malloc(sizeof(GLFWvidmode) * oi->nmode); |
|
|
|
for (i = 0; i < oi->nmode; i++) |
|
{ |
|
GLFWvidmode mode; |
|
const XRRModeInfo* mi = getModeInfo(sr, oi->modes[i]); |
|
|
|
mode.width = mi->width; |
|
mode.height = mi->height; |
|
mode.refreshRate = calculateRefreshRate(mi); |
|
|
|
for (j = 0; j < *found; j++) |
|
{ |
|
if (result[j].width == mode.width && |
|
result[j].height == mode.height && |
|
result[j].refreshRate == mode.refreshRate) |
|
{ |
|
break; |
|
} |
|
} |
|
|
|
if (j < *found) |
|
{ |
|
// This is a duplicate, so skip it |
|
continue; |
|
} |
|
|
|
mode.redBits = r; |
|
mode.greenBits = g; |
|
mode.blueBits = b; |
|
|
|
result[*found] = mode; |
|
(*found)++; |
|
} |
|
|
|
XRRFreeOutputInfo(oi); |
|
XRRFreeScreenResources(sr); |
|
} |
|
else |
|
{ |
|
*found = 1; |
|
|
|
result = (GLFWvidmode*) malloc(sizeof(GLFWvidmode)); |
|
|
|
result[0].width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen); |
|
result[0].height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen); |
|
result[0].redBits = r; |
|
result[0].greenBits = g; |
|
result[0].blueBits = b; |
|
result[0].refreshRate = 0; |
|
} |
|
|
|
return result; |
|
} |
|
|
|
void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode) |
|
{ |
|
if (_glfw.x11.randr.available) |
|
{ |
|
XRRScreenResources* sr; |
|
XRRCrtcInfo* ci; |
|
|
|
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root); |
|
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc); |
|
|
|
mode->width = ci->width; |
|
mode->height = ci->height; |
|
|
|
mode->refreshRate = calculateRefreshRate(getModeInfo(sr, ci->mode)); |
|
|
|
XRRFreeCrtcInfo(ci); |
|
XRRFreeScreenResources(sr); |
|
} |
|
else |
|
{ |
|
mode->width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen); |
|
mode->height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen); |
|
mode->refreshRate = 0; |
|
} |
|
|
|
_glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen), |
|
&mode->redBits, &mode->greenBits, &mode->blueBits); |
|
} |
|
|
|
|