mirror of
git://source.winehq.org/git/wine.git
synced 2024-09-15 06:54:46 +00:00
wgl: Replace the GLXFBConfigIDs in the pixelformat list with real GLXFBConfigs.
This commit is contained in:
parent
cfd81827ac
commit
4a96be5a72
|
@ -128,10 +128,10 @@ struct WineGLInfo {
|
|||
};
|
||||
|
||||
typedef struct wine_glpixelformat {
|
||||
int iPixelFormat;
|
||||
int fbconfig;
|
||||
int fmt_index;
|
||||
BOOL offscreenOnly;
|
||||
int iPixelFormat;
|
||||
GLXFBConfig fbconfig;
|
||||
int fmt_id;
|
||||
BOOL offscreenOnly;
|
||||
} WineGLPixelFormat;
|
||||
|
||||
static Wine_GLContext *context_list;
|
||||
|
@ -817,7 +817,7 @@ static int ConvertAttribWGLtoGLX(const int* iWGLAttr, int* oGLXAttr, Wine_GLPBuf
|
|||
return nAttribs;
|
||||
}
|
||||
|
||||
static BOOL get_fbconfig_from_visualid(Display *display, Visual *visual, int *fmt_id, int *fmt_index)
|
||||
static BOOL get_fbconfig_from_visualid(Display *display, Visual *visual, GLXFBConfig *fbconfig, int *fmt_id)
|
||||
{
|
||||
GLXFBConfig* cfgs = NULL;
|
||||
int i;
|
||||
|
@ -848,9 +848,9 @@ static BOOL get_fbconfig_from_visualid(Display *display, Visual *visual, int *fm
|
|||
/* We are looking up the GLX index of our main visual and have found it :) */
|
||||
if(visualid == tmp_vis_id) {
|
||||
TRACE("Found FBCONFIG_ID 0x%x at index %d for VISUAL_ID 0x%x\n", tmp_fmt_id, i, tmp_vis_id);
|
||||
XFree(cfgs);
|
||||
*fbconfig = cfgs[i];
|
||||
*fmt_id = tmp_fmt_id;
|
||||
*fmt_index = i;
|
||||
XFree(cfgs);
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
@ -862,13 +862,13 @@ static BOOL get_fbconfig_from_visualid(Display *display, Visual *visual, int *fm
|
|||
|
||||
static BOOL init_formats(Display *display, int screen, Visual *visual)
|
||||
{
|
||||
int fmt_id, fmt_index;
|
||||
int tmp_vis_id, tmp_fmt_id, nCfgs, i;
|
||||
GLXFBConfig* cfgs = NULL;
|
||||
int fmt_id, tmp_vis_id, tmp_fmt_id, nCfgs, i;
|
||||
GLXFBConfig* cfgs;
|
||||
GLXFBConfig fbconfig;
|
||||
int nOffscreenFormats = 0;
|
||||
|
||||
/* Locate the fbconfig correspondig to our main visual */
|
||||
if(!get_fbconfig_from_visualid(display, visual, &fmt_id, &fmt_index)) {
|
||||
if(!get_fbconfig_from_visualid(display, visual, &fbconfig, &fmt_id)) {
|
||||
ERR("Can't get the FBCONFIG_ID for the main visual, expect problems!\n");
|
||||
return FALSE;
|
||||
}
|
||||
|
@ -885,8 +885,8 @@ static BOOL init_formats(Display *display, int screen, Visual *visual)
|
|||
/* We only have the single format of Wine's main visual */
|
||||
WineGLPixelFormatList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WineGLPixelFormat));
|
||||
WineGLPixelFormatList[0].iPixelFormat = 1;
|
||||
WineGLPixelFormatList[0].fbconfig = fmt_id;
|
||||
WineGLPixelFormatList[0].fmt_index = fmt_index;
|
||||
WineGLPixelFormatList[0].fbconfig = fbconfig;
|
||||
WineGLPixelFormatList[0].fmt_id = fmt_id;
|
||||
WineGLPixelFormatList[0].offscreenOnly = FALSE;
|
||||
WineGLPixelFormatListSize = 1;
|
||||
}
|
||||
|
@ -905,8 +905,8 @@ static BOOL init_formats(Display *display, int screen, Visual *visual)
|
|||
/* Allocate memory for all the offscreen pixelformats and the format of Wine's main visual */
|
||||
WineGLPixelFormatList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (1+nOffscreenFormats)*sizeof(WineGLPixelFormat));
|
||||
WineGLPixelFormatList[0].iPixelFormat = 1;
|
||||
WineGLPixelFormatList[0].fbconfig = fmt_id;
|
||||
WineGLPixelFormatList[0].fmt_index = fmt_index;
|
||||
WineGLPixelFormatList[0].fbconfig = fbconfig;
|
||||
WineGLPixelFormatList[0].fmt_id = fmt_id;
|
||||
WineGLPixelFormatList[0].offscreenOnly = FALSE;
|
||||
WineGLPixelFormatListSize = 1;
|
||||
|
||||
|
@ -919,9 +919,9 @@ static BOOL init_formats(Display *display, int screen, Visual *visual)
|
|||
if(tmp_vis_id == 0) {
|
||||
TRACE("Found offscreen format FBCONFIG_ID 0x%x corresponding to iPixelFormat %d at GLX index %d\n", tmp_fmt_id, WineGLPixelFormatListSize, i);
|
||||
WineGLPixelFormatList[WineGLPixelFormatListSize].iPixelFormat = WineGLPixelFormatListSize;
|
||||
WineGLPixelFormatList[WineGLPixelFormatListSize].fbconfig = tmp_fmt_id;
|
||||
WineGLPixelFormatList[WineGLPixelFormatListSize].fmt_index = i;
|
||||
WineGLPixelFormatList[0].offscreenOnly = TRUE;
|
||||
WineGLPixelFormatList[WineGLPixelFormatListSize].fbconfig = cfgs[i];
|
||||
WineGLPixelFormatList[WineGLPixelFormatListSize].fmt_id = tmp_fmt_id;
|
||||
WineGLPixelFormatList[WineGLPixelFormatListSize].offscreenOnly = TRUE;
|
||||
WineGLPixelFormatListSize++;
|
||||
}
|
||||
}
|
||||
|
@ -935,45 +935,44 @@ static BOOL init_formats(Display *display, int screen, Visual *visual)
|
|||
/* GLX can advertise dozens of different pixelformats including offscreen and onscreen ones.
|
||||
* In our WGL implementation we only support a subset of these formats namely the format of
|
||||
* Wine's main visual and offscreen formats (if they are available).
|
||||
* This function converts a WGL format to its corresponding GLX one. It returns the index (zero-based)
|
||||
* into the GLX FB config table and it returns the number of supported WGL formats in fmt_count.
|
||||
* This function converts a WGL format to its corresponding GLX one. It returns a WineGLPixelFormat
|
||||
* and it returns the number of supported WGL formats in fmt_count.
|
||||
*/
|
||||
static BOOL ConvertPixelFormatWGLtoGLX(Display *display, int iPixelFormat, BOOL AllowOffscreen, int *fmt_index, int *fmt_count)
|
||||
static WineGLPixelFormat* ConvertPixelFormatWGLtoGLX(Display *display, int iPixelFormat, BOOL AllowOffscreen, int *fmt_count)
|
||||
{
|
||||
int ret = FALSE;
|
||||
WineGLPixelFormat *res = NULL;
|
||||
|
||||
/* Init the list of pixel formats when we need it */
|
||||
if(!WineGLPixelFormatListSize)
|
||||
init_formats(display, DefaultScreen(display), visual);
|
||||
|
||||
/* Check if the pixelformat is valid. Note that it is legal to pass an invalid
|
||||
* iPixelFormat in case of probing the number of pixelformats.
|
||||
*/
|
||||
if((iPixelFormat <= 0) || (iPixelFormat > WineGLPixelFormatListSize)) {
|
||||
ERR("invalid iPixelFormat %d\n", iPixelFormat);
|
||||
ret = FALSE;
|
||||
*fmt_index = -1;
|
||||
|
||||
if(AllowOffscreen)
|
||||
*fmt_count = WineGLPixelFormatListSize;
|
||||
else
|
||||
*fmt_count = 1; /* Only show the format of our main visual */
|
||||
}
|
||||
else if(iPixelFormat == 1) {
|
||||
ret = TRUE;
|
||||
*fmt_index = WineGLPixelFormatList[0].fmt_index;
|
||||
res = &WineGLPixelFormatList[0];
|
||||
*fmt_count = 1; /* Only show the format of our main visual */
|
||||
}
|
||||
/* Limit the use of offscreen formats to WGL extension calls which pass AllowOffscreen = TRUE */
|
||||
else if((WineGLPixelFormatList[iPixelFormat-1].offscreenOnly == TRUE) && AllowOffscreen) {
|
||||
ret = TRUE;
|
||||
res = &WineGLPixelFormatList[iPixelFormat-1];
|
||||
*fmt_count = WineGLPixelFormatListSize;
|
||||
TRACE("Returning FBConfig_ID=%x for iPixelFormat=%d\n", WineGLPixelFormatList[iPixelFormat-1].fbconfig, iPixelFormat);
|
||||
TRACE("Returning FBConfig=%p for iPixelFormat=%d\n", res->fbconfig, iPixelFormat);
|
||||
}
|
||||
|
||||
TRACE("Number of returned pixelformats=%d\n", *fmt_count);
|
||||
return ret;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Search our internal pixelformat list for the WGL format corresponding to the given fbconfig */
|
||||
static int ConvertPixelFormatGLXtoWGL(Display *display, int fbconfig)
|
||||
static int ConvertPixelFormatGLXtoWGL(Display *display, int fmt_id)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
@ -982,12 +981,12 @@ static int ConvertPixelFormatGLXtoWGL(Display *display, int fbconfig)
|
|||
init_formats(display, DefaultScreen(display), visual);
|
||||
|
||||
for(i=0; i<WineGLPixelFormatListSize; i++) {
|
||||
if(WineGLPixelFormatList[i].fbconfig == fbconfig) {
|
||||
TRACE("Returning iPixelFormat %d for fbconfig 0x%x\n", WineGLPixelFormatList[i].iPixelFormat, fbconfig);
|
||||
if(WineGLPixelFormatList[i].fmt_id == fmt_id) {
|
||||
TRACE("Returning iPixelFormat %d for fmt_id 0x%x\n", WineGLPixelFormatList[i].iPixelFormat, fmt_id);
|
||||
return WineGLPixelFormatList[i].iPixelFormat;
|
||||
}
|
||||
}
|
||||
TRACE("No compatible format found for FBCONFIG_ID=0x%x\n", fbconfig);
|
||||
TRACE("No compatible format found for fmt_id 0x%x\n", fmt_id);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -998,11 +997,9 @@ static int ConvertPixelFormatGLXtoWGL(Display *display, int fbconfig)
|
|||
*/
|
||||
int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
|
||||
const PIXELFORMATDESCRIPTOR *ppfd) {
|
||||
GLXFBConfig* cfgs = NULL;
|
||||
WineGLPixelFormat *fmt;
|
||||
int ret = 0;
|
||||
int nCfgs = 0;
|
||||
int value = 0;
|
||||
int fmt_index = 0;
|
||||
|
||||
if (!has_opengl()) {
|
||||
ERR("No libGL on this box - disabling OpenGL support !\n");
|
||||
|
@ -1021,15 +1018,9 @@ int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
goto choose_exit;
|
||||
}
|
||||
|
||||
/* Get a list containing all supported FB configurations */
|
||||
cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
|
||||
if (NULL == cfgs || 0 == nCfgs) {
|
||||
ERR("glXGetFBConfigs returns NULL (glError: %d)\n", pglGetError());
|
||||
goto choose_exit;
|
||||
}
|
||||
|
||||
fmt = ConvertPixelFormatWGLtoGLX(gdi_display, 1 /* main visual */, FALSE /* offscreen */, &value);
|
||||
/* In case an fbconfig was found, check if it matches to the requirements of the ppfd */
|
||||
if(!ConvertPixelFormatWGLtoGLX(gdi_display, 1 /* main visual */, FALSE /* offscreen */, &fmt_index, &value)) {
|
||||
if(!fmt) {
|
||||
ERR("Can't find a matching FBCONFIG_ID for VISUAL_ID 0x%lx!\n", visual->visualid);
|
||||
} else {
|
||||
int dwFlags = 0;
|
||||
|
@ -1037,7 +1028,7 @@ int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
int value = 0;
|
||||
|
||||
/* Pixel type */
|
||||
pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_RENDER_TYPE, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RENDER_TYPE, &value);
|
||||
if (value & GLX_RGBA_BIT)
|
||||
iPixelType = PFD_TYPE_RGBA;
|
||||
else
|
||||
|
@ -1049,7 +1040,7 @@ int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
}
|
||||
|
||||
/* Doublebuffer */
|
||||
pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_DOUBLEBUFFER, &value); if (value) dwFlags |= PFD_DOUBLEBUFFER;
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DOUBLEBUFFER, &value); if (value) dwFlags |= PFD_DOUBLEBUFFER;
|
||||
if (!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) && (ppfd->dwFlags & PFD_DOUBLEBUFFER)) {
|
||||
if (!(dwFlags & PFD_DOUBLEBUFFER)) {
|
||||
TRACE("dbl buffer mismatch\n");
|
||||
|
@ -1058,7 +1049,7 @@ int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
}
|
||||
|
||||
/* Stereo */
|
||||
pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_STEREO, &value); if (value) dwFlags |= PFD_STEREO;
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STEREO, &value); if (value) dwFlags |= PFD_STEREO;
|
||||
if (!(ppfd->dwFlags & PFD_STEREO_DONTCARE) && (ppfd->dwFlags & PFD_STEREO)) {
|
||||
if (!(dwFlags & PFD_STEREO)) {
|
||||
TRACE("stereo mismatch\n");
|
||||
|
@ -1067,28 +1058,28 @@ int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
}
|
||||
|
||||
/* Alpha bits */
|
||||
pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_ALPHA_SIZE, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ALPHA_SIZE, &value);
|
||||
if (ppfd->iPixelType==PFD_TYPE_RGBA && ppfd->cAlphaBits && !value) {
|
||||
TRACE("alpha mismatch\n");
|
||||
goto choose_exit;
|
||||
}
|
||||
|
||||
/* Depth bits */
|
||||
pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_DEPTH_SIZE, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DEPTH_SIZE, &value);
|
||||
if (ppfd->cDepthBits && !value) {
|
||||
TRACE("depth mismatch\n");
|
||||
goto choose_exit;
|
||||
}
|
||||
|
||||
/* Stencil bits */
|
||||
pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_STENCIL_SIZE, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STENCIL_SIZE, &value);
|
||||
if (ppfd->cStencilBits && !value) {
|
||||
TRACE("stencil mismatch\n");
|
||||
goto choose_exit;
|
||||
}
|
||||
|
||||
/* Aux buffers */
|
||||
pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_AUX_BUFFERS, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_AUX_BUFFERS, &value);
|
||||
if (ppfd->cAuxBuffers && !value) {
|
||||
TRACE("aux mismatch\n");
|
||||
goto choose_exit;
|
||||
|
@ -1103,7 +1094,6 @@ choose_exit:
|
|||
if(!ret)
|
||||
TRACE("No matching mode was found returning 0\n");
|
||||
|
||||
if (NULL != cfgs) XFree(cfgs);
|
||||
wine_tsx11_unlock();
|
||||
return ret;
|
||||
}
|
||||
|
@ -1120,14 +1110,9 @@ int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
/*XVisualInfo *vis;*/
|
||||
int value;
|
||||
int rb,gb,bb,ab;
|
||||
|
||||
GLXFBConfig* cfgs = NULL;
|
||||
GLXFBConfig cur;
|
||||
int nCfgs = 0;
|
||||
WineGLPixelFormat *fmt;
|
||||
int ret = 0;
|
||||
int fmt_count = 0;
|
||||
int fmt_index = 0;
|
||||
BOOL res = FALSE;
|
||||
|
||||
if (!has_opengl()) {
|
||||
ERR("No libGL on this box - disabling OpenGL support !\n");
|
||||
|
@ -1136,29 +1121,13 @@ int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
|
||||
TRACE("(%p,%d,%d,%p)\n", physDev, iPixelFormat, nBytes, ppfd);
|
||||
|
||||
wine_tsx11_lock();
|
||||
cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
|
||||
wine_tsx11_unlock();
|
||||
|
||||
if (NULL == cfgs || 0 == nCfgs) {
|
||||
ERR("unexpected iPixelFormat(%d), returns NULL\n", iPixelFormat);
|
||||
return 0; /* unespected error */
|
||||
}
|
||||
|
||||
/* Look for the iPixelFormat in our list of supported formats. If it is supported we get the index in the FBConfig table and the number of supported formats back */
|
||||
res = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &fmt_index, &fmt_count);
|
||||
|
||||
fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &fmt_count);
|
||||
if (ppfd == NULL) {
|
||||
/* The application is only querying the number of visuals */
|
||||
wine_tsx11_lock();
|
||||
if (NULL != cfgs) XFree(cfgs);
|
||||
wine_tsx11_unlock();
|
||||
/* The application is only querying the number of pixelformats */
|
||||
return fmt_count;
|
||||
} else if(res == FALSE) {
|
||||
} else if(fmt == NULL) {
|
||||
WARN("unexpected iPixelFormat(%d): not >=1 and <=nFormats(%d), returning NULL!\n", iPixelFormat, fmt_count);
|
||||
wine_tsx11_lock();
|
||||
if (NULL != cfgs) XFree(cfgs);
|
||||
wine_tsx11_unlock();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -1169,7 +1138,6 @@ int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
}
|
||||
|
||||
ret = fmt_count;
|
||||
cur = cfgs[fmt_index];
|
||||
|
||||
memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
|
||||
ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
|
||||
|
@ -1181,30 +1149,30 @@ int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
|
||||
wine_tsx11_lock();
|
||||
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_CONFIG_CAVEAT, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_CONFIG_CAVEAT, &value);
|
||||
if(value == GLX_SLOW_CONFIG)
|
||||
ppfd->dwFlags |= PFD_GENERIC_ACCELERATED;
|
||||
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_DOUBLEBUFFER, &value); if (value) ppfd->dwFlags |= PFD_DOUBLEBUFFER;
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DOUBLEBUFFER, &value); if (value) ppfd->dwFlags |= PFD_DOUBLEBUFFER;
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
|
||||
|
||||
/* Pixel type */
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_RENDER_TYPE, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RENDER_TYPE, &value);
|
||||
if (value & GLX_RGBA_BIT)
|
||||
ppfd->iPixelType = PFD_TYPE_RGBA;
|
||||
else
|
||||
ppfd->iPixelType = PFD_TYPE_COLORINDEX;
|
||||
|
||||
/* Color bits */
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_BUFFER_SIZE, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BUFFER_SIZE, &value);
|
||||
ppfd->cColorBits = value;
|
||||
|
||||
/* Red, green, blue and alpha bits / shifts */
|
||||
if (ppfd->iPixelType == PFD_TYPE_RGBA) {
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_RED_SIZE, &rb);
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_GREEN_SIZE, &gb);
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_BLUE_SIZE, &bb);
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_ALPHA_SIZE, &ab);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RED_SIZE, &rb);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_GREEN_SIZE, &gb);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BLUE_SIZE, &bb);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ALPHA_SIZE, &ab);
|
||||
|
||||
ppfd->cRedBits = rb;
|
||||
ppfd->cRedShift = gb + bb + ab;
|
||||
|
@ -1227,11 +1195,11 @@ int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
/* Accums : to do ... */
|
||||
|
||||
/* Depth bits */
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_DEPTH_SIZE, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DEPTH_SIZE, &value);
|
||||
ppfd->cDepthBits = value;
|
||||
|
||||
/* stencil bits */
|
||||
pglXGetFBConfigAttrib(gdi_display, cur, GLX_STENCIL_SIZE, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STENCIL_SIZE, &value);
|
||||
ppfd->cStencilBits = value;
|
||||
|
||||
wine_tsx11_unlock();
|
||||
|
@ -1244,10 +1212,6 @@ int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
|
|||
dump_PIXELFORMATDESCRIPTOR(ppfd);
|
||||
}
|
||||
|
||||
wine_tsx11_lock();
|
||||
if (NULL != cfgs) XFree(cfgs);
|
||||
wine_tsx11_unlock();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -1270,7 +1234,7 @@ int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
|
|||
BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
|
||||
int iPixelFormat,
|
||||
const PIXELFORMATDESCRIPTOR *ppfd) {
|
||||
int fmt_index = 0;
|
||||
WineGLPixelFormat *fmt;
|
||||
int value;
|
||||
|
||||
TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
|
||||
|
@ -1281,7 +1245,8 @@ BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
|
|||
}
|
||||
|
||||
/* Check if iPixelFormat is in our list of supported formats to see if it is supported. */
|
||||
if(!ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &fmt_index, &value)) {
|
||||
fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &value);
|
||||
if(!fmt) {
|
||||
ERR("Invalid iPixelFormat: %d\n", iPixelFormat);
|
||||
return 0;
|
||||
}
|
||||
|
@ -1289,9 +1254,6 @@ BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
|
|||
physDev->current_pf = iPixelFormat;
|
||||
|
||||
if (TRACE_ON(opengl)) {
|
||||
int nCfgs_fmt = 0;
|
||||
GLXFBConfig* cfgs_fmt = NULL;
|
||||
GLXFBConfig cur_cfg;
|
||||
int gl_test = 0;
|
||||
|
||||
/*
|
||||
|
@ -1310,20 +1272,17 @@ BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
|
|||
pglXQueryDrawable(gdi_display, drawable, GLX_HEIGHT, (unsigned int*) &value);
|
||||
TRACE(" - HEIGHT as %d\n", tmp);
|
||||
*/
|
||||
cfgs_fmt = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs_fmt);
|
||||
cur_cfg = cfgs_fmt[fmt_index];
|
||||
gl_test = pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_FBCONFIG_ID, &value);
|
||||
gl_test = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_FBCONFIG_ID, &value);
|
||||
if (gl_test) {
|
||||
ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
|
||||
} else {
|
||||
TRACE(" FBConfig have :\n");
|
||||
TRACE(" - FBCONFIG_ID 0x%x\n", value);
|
||||
pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_VISUAL_ID, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_VISUAL_ID, &value);
|
||||
TRACE(" - VISUAL_ID 0x%x\n", value);
|
||||
pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_DRAWABLE_TYPE, &value);
|
||||
pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &value);
|
||||
TRACE(" - DRAWABLE_TYPE 0x%x\n", value);
|
||||
}
|
||||
XFree(cfgs_fmt);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
@ -1336,12 +1295,9 @@ BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
|
|||
HGLRC X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev)
|
||||
{
|
||||
Wine_GLContext *ret;
|
||||
GLXFBConfig* cfgs_fmt = NULL;
|
||||
GLXFBConfig cur_cfg;
|
||||
WineGLPixelFormat *fmt;
|
||||
int hdcPF = physDev->current_pf;
|
||||
int fmt_count = 0;
|
||||
int fmt_index = 0;
|
||||
int nCfgs_fmt = 0;
|
||||
int value = 0;
|
||||
int gl_test = 0;
|
||||
HDC hdc = physDev->hdc;
|
||||
|
@ -1356,35 +1312,27 @@ HGLRC X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev)
|
|||
/* First, get the visual in use by the X11DRV */
|
||||
if (!gdi_display) return 0;
|
||||
|
||||
fmt = ConvertPixelFormatWGLtoGLX(gdi_display, hdcPF, FALSE /* Offscreen */, &fmt_count);
|
||||
/* We can only render using the iPixelFormat (1) of Wine's Main visual, we need to get the corresponding GLX format.
|
||||
* If this fails something is very wrong on the system. */
|
||||
if(!ConvertPixelFormatWGLtoGLX(gdi_display, hdcPF, FALSE /* Offscreen */, &fmt_index, &fmt_count)) {
|
||||
if(!fmt) {
|
||||
ERR("Cannot get FB Config for main iPixelFormat 1, expect problems!\n");
|
||||
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cfgs_fmt = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs_fmt);
|
||||
if (NULL == cfgs_fmt || 0 == nCfgs_fmt) {
|
||||
ERR("Cannot get FB Configs, expect problems.\n");
|
||||
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (fmt_count < hdcPF) {
|
||||
ERR("(%p): unexpected pixelFormat(%d) > nFormats(%d), returns NULL\n", hdc, hdcPF, fmt_count);
|
||||
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cur_cfg = cfgs_fmt[fmt_index];
|
||||
gl_test = pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_FBCONFIG_ID, &value);
|
||||
gl_test = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_FBCONFIG_ID, &value);
|
||||
if (gl_test) {
|
||||
ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
|
||||
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
||||
return NULL;
|
||||
}
|
||||
XFree(cfgs_fmt);
|
||||
|
||||
/* The context will be allocated in the wglMakeCurrent call */
|
||||
wine_tsx11_lock();
|
||||
|
@ -1392,9 +1340,9 @@ HGLRC X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev)
|
|||
wine_tsx11_unlock();
|
||||
ret->hdc = hdc;
|
||||
ret->physDev = physDev;
|
||||
ret->fb_conf = cur_cfg;
|
||||
ret->fb_conf = fmt->fbconfig;
|
||||
/*ret->vis = vis;*/
|
||||
ret->vis = pglXGetVisualFromFBConfig(gdi_display, cur_cfg);
|
||||
ret->vis = pglXGetVisualFromFBConfig(gdi_display, fmt->fbconfig);
|
||||
|
||||
TRACE(" creating context %p (GL context creation delayed)\n", ret);
|
||||
return (HGLRC) ret;
|
||||
|
@ -1991,11 +1939,10 @@ static const char * WINAPI X11DRV_wglGetExtensionsStringARB(HDC hdc) {
|
|||
static HPBUFFERARB WINAPI X11DRV_wglCreatePbufferARB(HDC hdc, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList)
|
||||
{
|
||||
Wine_GLPBuffer* object = NULL;
|
||||
GLXFBConfig* cfgs = NULL;
|
||||
WineGLPixelFormat *fmt = NULL;
|
||||
int nCfgs = 0;
|
||||
int attribs[256];
|
||||
int nAttribs = 0;
|
||||
int fmt_index = 0;
|
||||
|
||||
TRACE("(%p, %d, %d, %d, %p)\n", hdc, iPixelFormat, iWidth, iHeight, piAttribList);
|
||||
|
||||
|
@ -2005,16 +1952,9 @@ static HPBUFFERARB WINAPI X11DRV_wglCreatePbufferARB(HDC hdc, int iPixelFormat,
|
|||
return NULL; /* unexpected error */
|
||||
}
|
||||
|
||||
cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
|
||||
|
||||
if (NULL == cfgs || 0 == nCfgs) {
|
||||
ERR("(%p): Cannot get FB Configs for iPixelFormat(%d), returns NULL\n", hdc, iPixelFormat);
|
||||
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
||||
return NULL; /* unexpected error */
|
||||
}
|
||||
|
||||
/* Convert the WGL pixelformat to a GLX format, if it fails then the format is invalid */
|
||||
if(!ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &fmt_index, &nCfgs)) {
|
||||
fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &nCfgs);
|
||||
if(!fmt) {
|
||||
ERR("(%p): unexpected iPixelFormat(%d) > nFormats(%d), returns NULL\n", hdc, iPixelFormat, nCfgs);
|
||||
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
||||
goto create_failed; /* unexpected error */
|
||||
|
@ -2157,20 +2097,16 @@ static HPBUFFERARB WINAPI X11DRV_wglCreatePbufferARB(HDC hdc, int iPixelFormat,
|
|||
}
|
||||
|
||||
PUSH1(attribs, None);
|
||||
object->drawable = pglXCreatePbuffer(gdi_display, cfgs[fmt_index], attribs);
|
||||
object->drawable = pglXCreatePbuffer(gdi_display, fmt->fbconfig, attribs);
|
||||
TRACE("new Pbuffer drawable as %p\n", (void*) object->drawable);
|
||||
if (!object->drawable) {
|
||||
SetLastError(ERROR_NO_SYSTEM_RESOURCES);
|
||||
goto create_failed; /* unexpected error */
|
||||
}
|
||||
TRACE("->(%p)\n", object);
|
||||
|
||||
/** free list */
|
||||
XFree(cfgs);
|
||||
return (HPBUFFERARB) object;
|
||||
|
||||
create_failed:
|
||||
if (NULL != cfgs) XFree(cfgs);
|
||||
HeapFree(GetProcessHeap(), 0, object);
|
||||
TRACE("->(FAILED)\n");
|
||||
return (HPBUFFERARB) NULL;
|
||||
|
@ -2443,14 +2379,11 @@ static GLboolean WINAPI X11DRV_wglChoosePixelFormatARB(HDC hdc, const int *piAtt
|
|||
static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues)
|
||||
{
|
||||
UINT i;
|
||||
GLXFBConfig* cfgs = NULL;
|
||||
GLXFBConfig curCfg = NULL;
|
||||
int nCfgs = 0;
|
||||
WineGLPixelFormat *fmt = NULL;
|
||||
int hTest;
|
||||
int tmp;
|
||||
int curGLXAttr = 0;
|
||||
int nWGLFormats = 0;
|
||||
int fmt_index = 0;
|
||||
|
||||
TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
|
||||
|
||||
|
@ -2459,16 +2392,11 @@ static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelF
|
|||
return GL_FALSE;
|
||||
}
|
||||
|
||||
cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
|
||||
if (NULL == cfgs) {
|
||||
ERR("no FB Configs found for display(%p)\n", gdi_display);
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
/* Convert the WGL pixelformat to a GLX one, if this fails then most likely the iPixelFormat isn't supoprted.
|
||||
* We don't have to fail yet as a program can specify an invaled iPixelFormat (lets say 0) if it wants to query
|
||||
* the number of supported WGL formats. Whether the iPixelFormat is valid is handled in the for-loop below. */
|
||||
if(!ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &fmt_index, &nWGLFormats)) {
|
||||
fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &nWGLFormats);
|
||||
if(!fmt) {
|
||||
WARN("Unable to convert iPixelFormat %d to a GLX one!\n", iPixelFormat);
|
||||
}
|
||||
|
||||
|
@ -2487,11 +2415,8 @@ static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelF
|
|||
|
||||
case WGL_ACCELERATION_ARB:
|
||||
curGLXAttr = GLX_CONFIG_CAVEAT;
|
||||
|
||||
if (nCfgs < iPixelFormat || 0 >= iPixelFormat) goto pix_error;
|
||||
curCfg = cfgs[iPixelFormat - 1];
|
||||
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, &tmp);
|
||||
if (!fmt) goto pix_error;
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
|
||||
if (hTest) goto get_error;
|
||||
switch (tmp) {
|
||||
case GLX_NONE: piValues[i] = WGL_FULL_ACCELERATION_ARB; break;
|
||||
|
@ -2505,11 +2430,8 @@ static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelF
|
|||
|
||||
case WGL_TRANSPARENT_ARB:
|
||||
curGLXAttr = GLX_TRANSPARENT_TYPE;
|
||||
/* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
|
||||
* supported WGLFormats and also check if the GLX fmt_index is valid. */
|
||||
if((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs)) goto pix_error;
|
||||
curCfg = cfgs[fmt_index];
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, &tmp);
|
||||
if (!fmt) goto pix_error;
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
|
||||
if (hTest) goto get_error;
|
||||
piValues[i] = GL_FALSE;
|
||||
if (GLX_NONE != tmp) piValues[i] = GL_TRUE;
|
||||
|
@ -2517,11 +2439,8 @@ static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelF
|
|||
|
||||
case WGL_PIXEL_TYPE_ARB:
|
||||
curGLXAttr = GLX_RENDER_TYPE;
|
||||
/* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
|
||||
* supported WGLFormats and also check if the GLX fmt_index is valid. */
|
||||
if((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs)) goto pix_error;
|
||||
curCfg = cfgs[fmt_index];
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, &tmp);
|
||||
if (!fmt) goto pix_error;
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
|
||||
if (hTest) goto get_error;
|
||||
TRACE("WGL_PIXEL_TYPE_ARB: GLX_RENDER_TYPE = 0x%x\n", tmp);
|
||||
if (tmp & GLX_RGBA_BIT) { piValues[i] = WGL_TYPE_RGBA_ARB; }
|
||||
|
@ -2536,14 +2455,11 @@ static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelF
|
|||
|
||||
case WGL_COLOR_BITS_ARB:
|
||||
/** see ConvertAttribWGLtoGLX for explain */
|
||||
/* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
|
||||
* supported WGLFormats and also check if the GLX fmt_index is valid. */
|
||||
if((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs)) goto pix_error;
|
||||
curCfg = cfgs[fmt_index];
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, GLX_BUFFER_SIZE, piValues + i);
|
||||
if (!fmt) goto pix_error;
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BUFFER_SIZE, piValues + i);
|
||||
if (hTest) goto get_error;
|
||||
TRACE("WGL_COLOR_BITS_ARB: GLX_BUFFER_SIZE = %d\n", piValues[i]);
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, GLX_ALPHA_SIZE, &tmp);
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ALPHA_SIZE, &tmp);
|
||||
if (hTest) goto get_error;
|
||||
TRACE("WGL_COLOR_BITS_ARB: GLX_ALPHA_SIZE = %d\n", tmp);
|
||||
piValues[i] = piValues[i] - tmp;
|
||||
|
@ -2564,17 +2480,14 @@ static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelF
|
|||
continue;
|
||||
}
|
||||
curGLXAttr = GLX_RENDER_TYPE;
|
||||
/* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
|
||||
* supported WGLFormats and also check if the GLX fmt_index is valid. */
|
||||
if((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs)) goto pix_error;
|
||||
curCfg = cfgs[fmt_index];
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, &tmp);
|
||||
if (!fmt) goto pix_error;
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
|
||||
if (hTest) goto get_error;
|
||||
if (GLX_COLOR_INDEX_BIT == tmp) {
|
||||
piValues[i] = GL_FALSE;
|
||||
continue;
|
||||
}
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, GLX_DRAWABLE_TYPE, &tmp);
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &tmp);
|
||||
if (hTest) goto get_error;
|
||||
piValues[i] = (tmp & GLX_PBUFFER_BIT) ? GL_TRUE : GL_FALSE;
|
||||
continue;
|
||||
|
@ -2613,7 +2526,7 @@ static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelF
|
|||
piValues[i] = GL_TRUE;
|
||||
continue;
|
||||
case WGL_DRAW_TO_PBUFFER_ARB:
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, GLX_DRAWABLE_TYPE, &tmp);
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &tmp);
|
||||
if (hTest) goto get_error;
|
||||
piValues[i] = (tmp & GLX_PBUFFER_BIT) ? GL_TRUE : GL_FALSE;
|
||||
continue;
|
||||
|
@ -2644,11 +2557,8 @@ static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelF
|
|||
* mean that the behavior could differ between different vendors (ATI, Nvidia, ..).
|
||||
*/
|
||||
if (0 != curGLXAttr && iPixelFormat != 0) {
|
||||
/* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
|
||||
* supported WGLFormats and also check if the GLX fmt_index is valid. */
|
||||
if((iPixelFormat > 0) && ((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs))) goto pix_error;
|
||||
curCfg = cfgs[fmt_index];
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, piValues + i);
|
||||
if (!fmt) goto pix_error;
|
||||
hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, piValues + i);
|
||||
if (hTest) goto get_error;
|
||||
curGLXAttr = 0;
|
||||
} else {
|
||||
|
@ -2659,12 +2569,10 @@ static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelF
|
|||
|
||||
get_error:
|
||||
ERR("(%p): unexpected failure on GetFBConfigAttrib(%x) returns FALSE\n", hdc, curGLXAttr);
|
||||
XFree(cfgs);
|
||||
return GL_FALSE;
|
||||
|
||||
pix_error:
|
||||
ERR("(%p): unexpected iPixelFormat(%d) vs nFormats(%d), returns FALSE\n", hdc, iPixelFormat, nCfgs);
|
||||
XFree(cfgs);
|
||||
ERR("(%p): unexpected iPixelFormat(%d) vs nFormats(%d), returns FALSE\n", hdc, iPixelFormat, nWGLFormats);
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in a new issue