1479 lines
43 KiB
C
Executable File
1479 lines
43 KiB
C
Executable File
/*
|
|
* GLX implementation that uses Windows OpenGL library
|
|
* (Indirect rendering path)
|
|
*
|
|
* Authors: Alexander Gottwald
|
|
*/
|
|
/*
|
|
* Portions of this file are copied from GL/apple/indirect.c,
|
|
* which contains the following copyright:
|
|
*
|
|
* Copyright (c) 2002 Greg Parker. All Rights Reserved.
|
|
* Copyright (c) 2002 Apple Computer, Inc.
|
|
*
|
|
* Portions of this file are copied from xf86glx.c,
|
|
* which contains the following copyright:
|
|
*
|
|
* Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name(s) of the above copyright
|
|
* holders shall not be used in advertising or otherwise to promote the sale,
|
|
* use or other dealings in this Software without prior written authorization.
|
|
*/
|
|
|
|
|
|
|
|
#include "glwindows.h"
|
|
#include <glcontextmodes.h>
|
|
|
|
#include "../../hw/xwin/winpriv.h"
|
|
|
|
#define GLWIN_DEBUG_HWND(hwnd) \
|
|
if (glWinDebugSettings.dumpHWND) { \
|
|
char buffer[1024]; \
|
|
if (GetWindowText(hwnd, buffer, sizeof(buffer))==0) *buffer=0; \
|
|
GLWIN_DEBUG_MSG("Got HWND %s (%p)\n", buffer, hwnd); \
|
|
}
|
|
|
|
|
|
/* ggs: needed to call back to glx with visual configs */
|
|
extern void GlxSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs, void **configprivs);
|
|
|
|
glWinDebugSettingsRec glWinDebugSettings = { 1, 0, 0, 0};
|
|
|
|
static void glWinInitDebugSettings(void)
|
|
{
|
|
char *envptr;
|
|
|
|
envptr = getenv("GLWIN_ENABLE_DEBUG");
|
|
if (envptr != NULL)
|
|
glWinDebugSettings.enableDebug = (atoi(envptr) == 1);
|
|
|
|
envptr = getenv("GLWIN_DUMP_PFD");
|
|
if (envptr != NULL)
|
|
glWinDebugSettings.dumpPFD = (atoi(envptr) == 1);
|
|
|
|
envptr = getenv("GLWIN_DUMP_HWND");
|
|
if (envptr != NULL)
|
|
glWinDebugSettings.dumpHWND = (atoi(envptr) == 1);
|
|
|
|
envptr = getenv("GLWIN_DUMP_DC");
|
|
if (envptr != NULL)
|
|
glWinDebugSettings.dumpDC = (atoi(envptr) == 1);
|
|
}
|
|
|
|
static char errorbuffer[1024];
|
|
const char *glWinErrorMessage(void)
|
|
{
|
|
if (!FormatMessage(
|
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
NULL,
|
|
GetLastError(),
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
(LPTSTR) &errorbuffer,
|
|
sizeof(errorbuffer),
|
|
NULL ))
|
|
{
|
|
snprintf(errorbuffer, sizeof(errorbuffer), "Unknown error in FormatMessage: %08x!\n", (unsigned)GetLastError());
|
|
}
|
|
return errorbuffer;
|
|
}
|
|
|
|
/*
|
|
* GLX implementation that uses Win32's OpenGL
|
|
*/
|
|
|
|
/*
|
|
* Server-side GLX uses these functions which are normally defined
|
|
* in the OpenGL SI.
|
|
*/
|
|
|
|
GLint __glEvalComputeK(GLenum target)
|
|
{
|
|
switch (target) {
|
|
case GL_MAP1_VERTEX_4:
|
|
case GL_MAP1_COLOR_4:
|
|
case GL_MAP1_TEXTURE_COORD_4:
|
|
case GL_MAP2_VERTEX_4:
|
|
case GL_MAP2_COLOR_4:
|
|
case GL_MAP2_TEXTURE_COORD_4:
|
|
return 4;
|
|
case GL_MAP1_VERTEX_3:
|
|
case GL_MAP1_TEXTURE_COORD_3:
|
|
case GL_MAP1_NORMAL:
|
|
case GL_MAP2_VERTEX_3:
|
|
case GL_MAP2_TEXTURE_COORD_3:
|
|
case GL_MAP2_NORMAL:
|
|
return 3;
|
|
case GL_MAP1_TEXTURE_COORD_2:
|
|
case GL_MAP2_TEXTURE_COORD_2:
|
|
return 2;
|
|
case GL_MAP1_TEXTURE_COORD_1:
|
|
case GL_MAP2_TEXTURE_COORD_1:
|
|
case GL_MAP1_INDEX:
|
|
case GL_MAP2_INDEX:
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
GLuint __glFloorLog2(GLuint val)
|
|
{
|
|
int c = 0;
|
|
|
|
while (val > 1) {
|
|
c++;
|
|
val >>= 1;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/* some prototypes */
|
|
static Bool glWinScreenProbe(int screen);
|
|
static Bool glWinInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
|
|
int *nvisualp, int *ndepthp,
|
|
int *rootDepthp, VisualID *defaultVisp,
|
|
unsigned long sizes, int bitsPerRGB);
|
|
static void glWinSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
|
|
void **privates);
|
|
static __GLinterface *glWinCreateContext(__GLimports *imports,
|
|
__GLcontextModes *mode,
|
|
__GLinterface *shareGC);
|
|
static void glWinCreateBuffer(__GLXdrawablePrivate *glxPriv);
|
|
static void glWinResetExtension(void);
|
|
|
|
/*
|
|
* This structure is statically allocated in the __glXScreens[]
|
|
* structure. This struct is not used anywhere other than in
|
|
* __glXScreenInit to initialize each of the active screens
|
|
* (__glXActiveScreens[]). Several of the fields must be initialized by
|
|
* the screenProbe routine before they are copied to the active screens
|
|
* struct. In particular, the contextCreate, pGlxVisual, numVisuals,
|
|
* and numUsableVisuals fields must be initialized.
|
|
*/
|
|
__GLXscreenInfo __glDDXScreenInfo = {
|
|
glWinScreenProbe, /* Must be generic and handle all screens */
|
|
glWinCreateContext, /* Substitute screen's createContext routine */
|
|
glWinCreateBuffer, /* Substitute screen's createBuffer routine */
|
|
NULL, /* Set up pGlxVisual in probe */
|
|
NULL, /* Set up pVisualPriv in probe */
|
|
0, /* Set up numVisuals in probe */
|
|
0, /* Set up numUsableVisuals in probe */
|
|
"Vendor String", /* GLXvendor is overwritten by __glXScreenInit */
|
|
"Version String", /* GLXversion is overwritten by __glXScreenInit */
|
|
"Extensions String", /* GLXextensions is overwritten by __glXScreenInit */
|
|
NULL /* WrappedPositionWindow is overwritten */
|
|
};
|
|
|
|
__GLXextensionInfo __glDDXExtensionInfo = {
|
|
GL_CORE_WINDOWS,
|
|
glWinResetExtension,
|
|
glWinInitVisuals,
|
|
glWinSetVisualConfigs
|
|
};
|
|
|
|
/* prototypes */
|
|
|
|
static GLboolean glWinDestroyContext(__GLcontext *gc);
|
|
static GLboolean glWinLoseCurrent(__GLcontext *gc);
|
|
static GLboolean glWinMakeCurrent(__GLcontext *gc);
|
|
static GLboolean glWinShareContext(__GLcontext *gc, __GLcontext *gcShare);
|
|
static GLboolean glWinCopyContext(__GLcontext *dst, const __GLcontext *src,
|
|
GLuint mask);
|
|
static GLboolean glWinForceCurrent(__GLcontext *gc);
|
|
|
|
/* Drawing surface notification callbacks */
|
|
static GLboolean glWinNotifyResize(__GLcontext *gc);
|
|
static void glWinNotifyDestroy(__GLcontext *gc);
|
|
static void glWinNotifySwapBuffers(__GLcontext *gc);
|
|
|
|
/* Dispatch table override control for external agents like libGLS */
|
|
static struct __GLdispatchStateRec* glWinDispatchExec(__GLcontext *gc);
|
|
static void glWinBeginDispatchOverride(__GLcontext *gc);
|
|
static void glWinEndDispatchOverride(__GLcontext *gc);
|
|
|
|
/* Debug output */
|
|
static void pfdOut(const PIXELFORMATDESCRIPTOR *pfd);
|
|
|
|
static __GLexports glWinExports = {
|
|
glWinDestroyContext,
|
|
glWinLoseCurrent,
|
|
glWinMakeCurrent,
|
|
glWinShareContext,
|
|
glWinCopyContext,
|
|
glWinForceCurrent,
|
|
|
|
glWinNotifyResize,
|
|
glWinNotifyDestroy,
|
|
glWinNotifySwapBuffers,
|
|
|
|
glWinDispatchExec,
|
|
glWinBeginDispatchOverride,
|
|
glWinEndDispatchOverride
|
|
};
|
|
|
|
glWinScreenRec glWinScreens[MAXSCREENS];
|
|
|
|
/* __GLdrawablePrivate->private */
|
|
typedef struct {
|
|
DrawablePtr pDraw;
|
|
/* xp_surface_id sid; */
|
|
} GLWinDrawableRec;
|
|
|
|
struct __GLcontextRec {
|
|
struct __GLinterfaceRec interface; /* required to be first */
|
|
|
|
HGLRC ctx; /* Windows GL Context */
|
|
|
|
HDC dc; /* Windows Device Context */
|
|
winWindowInfoRec winInfo; /* Window info from XWin */
|
|
|
|
PIXELFORMATDESCRIPTOR pfd; /* Pixelformat flags */
|
|
int pixelFormat; /* Pixelformat index */
|
|
|
|
unsigned isAttached :1; /* Flag to track if context is attached */
|
|
};
|
|
|
|
static HDC glWinMakeDC(__GLcontext *gc)
|
|
{
|
|
HDC dc;
|
|
/*if (gc->winInfo.hrgn == NULL)
|
|
{
|
|
GLWIN_DEBUG_MSG("Creating region from RECT(%ld,%ld,%ld,%ld):",
|
|
gc->winInfo.rect.left,
|
|
gc->winInfo.rect.top,
|
|
gc->winInfo.rect.right,
|
|
gc->winInfo.rect.bottom);
|
|
gc->winInfo.hrgn = CreateRectRgnIndirect(&gc->winInfo.rect);
|
|
GLWIN_DEBUG_MSG2("%p\n", gc->winInfo.hrgn);
|
|
}*/
|
|
|
|
dc = GetDC(gc->winInfo.hwnd);
|
|
/*dc = GetDCEx(gc->winInfo.hwnd, gc->winInfo.hrgn,
|
|
DCX_WINDOW | DCX_NORESETATTRS ); */
|
|
|
|
if (dc == NULL)
|
|
ErrorF("GetDC error: %s\n", glWinErrorMessage());
|
|
return dc;
|
|
}
|
|
|
|
static void unattach(__GLcontext *gc)
|
|
{
|
|
BOOL ret;
|
|
GLWIN_DEBUG_MSG("unattach (ctx %p)\n", gc->ctx);
|
|
if (!gc->isAttached)
|
|
{
|
|
ErrorF("called unattach on an unattached context\n");
|
|
return;
|
|
}
|
|
|
|
if (gc->ctx)
|
|
{
|
|
ret = wglDeleteContext(gc->ctx);
|
|
if (!ret)
|
|
ErrorF("wglDeleteContext error: %s\n", glWinErrorMessage());
|
|
gc->ctx = NULL;
|
|
}
|
|
|
|
if (gc->winInfo.hrgn)
|
|
{
|
|
ret = DeleteObject(gc->winInfo.hrgn);
|
|
if (!ret)
|
|
ErrorF("DeleteObject error: %s\n", glWinErrorMessage());
|
|
gc->winInfo.hrgn = NULL;
|
|
}
|
|
|
|
gc->isAttached = 0;
|
|
}
|
|
|
|
static BOOL glWinCreateContextReal(__GLcontext *gc, WindowPtr pWin)
|
|
{
|
|
HDC dc;
|
|
BOOL ret;
|
|
|
|
if (pWin == NULL)
|
|
{
|
|
GLWIN_DEBUG_MSG("Deferring until window is created\n");
|
|
return FALSE;
|
|
}
|
|
|
|
winGetWindowInfo(pWin, &gc->winInfo);
|
|
|
|
GLWIN_DEBUG_HWND(gc->winInfo.hwnd);
|
|
if (gc->winInfo.hwnd == NULL)
|
|
{
|
|
GLWIN_DEBUG_MSG("Deferring until window is created\n");
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
dc = glWinMakeDC(gc);
|
|
|
|
if (glWinDebugSettings.dumpDC)
|
|
GLWIN_DEBUG_MSG("Got HDC %p\n", dc);
|
|
|
|
gc->pixelFormat = ChoosePixelFormat(dc, &gc->pfd);
|
|
if (gc->pixelFormat == 0)
|
|
{
|
|
ErrorF("ChoosePixelFormat error: %s\n", glWinErrorMessage());
|
|
ReleaseDC(gc->winInfo.hwnd, dc);
|
|
return FALSE;
|
|
}
|
|
|
|
ret = SetPixelFormat(dc, gc->pixelFormat, &gc->pfd);
|
|
if (!ret) {
|
|
ErrorF("SetPixelFormat error: %s\n", glWinErrorMessage());
|
|
ReleaseDC(gc->winInfo.hwnd, dc);
|
|
return FALSE;
|
|
}
|
|
|
|
gc->ctx = wglCreateContext(dc);
|
|
if (gc->ctx == NULL) {
|
|
ErrorF("wglCreateContext error: %s\n", glWinErrorMessage());
|
|
ReleaseDC(gc->winInfo.hwnd, dc);
|
|
return FALSE;
|
|
}
|
|
ReleaseDC(gc->winInfo.hwnd, dc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void attach(__GLcontext *gc, __GLdrawablePrivate *glPriv)
|
|
{
|
|
__GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other;
|
|
|
|
GLWIN_DEBUG_MSG("attach (ctx %p)\n", gc->ctx);
|
|
|
|
if (gc->isAttached)
|
|
{
|
|
ErrorF("called attach on an attached context\n");
|
|
return;
|
|
}
|
|
|
|
if (glxPriv->type == DRAWABLE_WINDOW)
|
|
{
|
|
WindowPtr pWin = (WindowPtr) glxPriv->pDraw;
|
|
if (pWin == NULL)
|
|
{
|
|
GLWIN_DEBUG_MSG("Deferring ChoosePixelFormat until window is created\n");
|
|
} else
|
|
{
|
|
if (glWinCreateContextReal(gc, pWin))
|
|
{
|
|
gc->isAttached = TRUE;
|
|
GLWIN_DEBUG_MSG("attached\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static GLboolean glWinLoseCurrent(__GLcontext *gc)
|
|
{
|
|
/*GLWIN_DEBUG_MSG("glWinLoseCurrent (ctx %p)\n", gc->ctx);*/
|
|
|
|
__glXLastContext = NULL; /* Mesa does this; why? */
|
|
|
|
return GL_TRUE;
|
|
}
|
|
|
|
/* Context manipulation; return GL_FALSE on failure */
|
|
static GLboolean glWinDestroyContext(__GLcontext *gc)
|
|
{
|
|
GLWIN_DEBUG_MSG("glWinDestroyContext (ctx %p)\n", gc->ctx);
|
|
|
|
if (gc != NULL)
|
|
{
|
|
if (gc->isAttached)
|
|
unattach(gc);
|
|
if (gc->dc != NULL)
|
|
DeleteDC(gc->dc);
|
|
free(gc);
|
|
}
|
|
|
|
return GL_TRUE;
|
|
}
|
|
|
|
static GLboolean glWinMakeCurrent(__GLcontext *gc)
|
|
{
|
|
__GLdrawablePrivate *glPriv = gc->interface.imports.getDrawablePrivate(gc);
|
|
BOOL ret;
|
|
HDC dc;
|
|
|
|
if (!gc->isAttached)
|
|
attach(gc, glPriv);
|
|
|
|
if (gc->ctx == NULL) {
|
|
ErrorF("Context is NULL\n");
|
|
return GL_FALSE;
|
|
}
|
|
|
|
dc = glWinMakeDC(gc);
|
|
ret = wglMakeCurrent(dc, gc->ctx);
|
|
if (!ret)
|
|
ErrorF("glMakeCurrent error: %s\n", glWinErrorMessage());
|
|
ReleaseDC(gc->winInfo.hwnd, dc);
|
|
|
|
return ret?GL_TRUE:GL_FALSE;
|
|
}
|
|
|
|
static GLboolean glWinShareContext(__GLcontext *gc, __GLcontext *gcShare)
|
|
{
|
|
GLWIN_DEBUG_MSG("glWinShareContext unimplemented\n");
|
|
|
|
return GL_TRUE;
|
|
}
|
|
|
|
static GLboolean glWinCopyContext(__GLcontext *dst, const __GLcontext *src,
|
|
GLuint mask)
|
|
{
|
|
BOOL ret;
|
|
|
|
GLWIN_DEBUG_MSG("glWinCopyContext\n");
|
|
|
|
|
|
|
|
ret = wglCopyContext(src->ctx, dst->ctx, mask);
|
|
if (!ret)
|
|
{
|
|
ErrorF("wglCopyContext error: %s\n", glWinErrorMessage());
|
|
return GL_FALSE;
|
|
}
|
|
|
|
return GL_TRUE;
|
|
}
|
|
|
|
static GLboolean glWinForceCurrent(__GLcontext *gc)
|
|
{
|
|
BOOL ret;
|
|
HDC dc;
|
|
|
|
dc = glWinMakeDC(gc);
|
|
ret = wglMakeCurrent(dc, gc->ctx);
|
|
if (!ret)
|
|
ErrorF("wglSetCurrent error: %s\n", glWinErrorMessage());
|
|
ReleaseDC(gc->winInfo.hwnd, dc);
|
|
|
|
return ret?GL_TRUE:GL_FALSE;
|
|
}
|
|
|
|
/* Drawing surface notification callbacks */
|
|
|
|
static GLboolean glWinNotifyResize(__GLcontext *gc)
|
|
{
|
|
GLWIN_DEBUG_MSG("unimplemented glWinNotifyResize");
|
|
return GL_TRUE;
|
|
}
|
|
|
|
static void glWinNotifyDestroy(__GLcontext *gc)
|
|
{
|
|
GLWIN_DEBUG_MSG("unimplemented glWinNotifyDestroy");
|
|
}
|
|
|
|
static void glWinNotifySwapBuffers(__GLcontext *gc)
|
|
{
|
|
GLWIN_DEBUG_MSG("unimplemented glWinNotifySwapBuffers");
|
|
}
|
|
|
|
/* Dispatch table override control for external agents like libGLS */
|
|
static struct __GLdispatchStateRec* glWinDispatchExec(__GLcontext *gc)
|
|
{
|
|
GLWIN_DEBUG_MSG("unimplemented glWinDispatchExec");
|
|
return NULL;
|
|
}
|
|
|
|
static void glWinBeginDispatchOverride(__GLcontext *gc)
|
|
{
|
|
GLWIN_DEBUG_MSG("unimplemented glWinBeginDispatchOverride");
|
|
}
|
|
|
|
static void glWinEndDispatchOverride(__GLcontext *gc)
|
|
{
|
|
GLWIN_DEBUG_MSG("unimplemented glWinEndDispatchOverride");
|
|
}
|
|
|
|
#define DUMP_PFD_FLAG(flag) \
|
|
if (pfd->dwFlags & flag) { \
|
|
ErrorF("%s%s", pipesym, #flag); \
|
|
pipesym = " | "; \
|
|
}
|
|
|
|
static void pfdOut(const PIXELFORMATDESCRIPTOR *pfd)
|
|
{
|
|
const char *pipesym = ""; /* will be set after first flag dump */
|
|
ErrorF("PIXELFORMATDESCRIPTOR:\n");
|
|
ErrorF("nSize = %u\n", pfd->nSize);
|
|
ErrorF("nVersion = %u\n", pfd->nVersion);
|
|
ErrorF("dwFlags = %lu = {", pfd->dwFlags);
|
|
DUMP_PFD_FLAG(PFD_MAIN_PLANE);
|
|
DUMP_PFD_FLAG(PFD_OVERLAY_PLANE);
|
|
DUMP_PFD_FLAG(PFD_UNDERLAY_PLANE);
|
|
DUMP_PFD_FLAG(PFD_DOUBLEBUFFER);
|
|
DUMP_PFD_FLAG(PFD_STEREO);
|
|
DUMP_PFD_FLAG(PFD_DRAW_TO_WINDOW);
|
|
DUMP_PFD_FLAG(PFD_DRAW_TO_BITMAP);
|
|
DUMP_PFD_FLAG(PFD_SUPPORT_GDI);
|
|
DUMP_PFD_FLAG(PFD_SUPPORT_OPENGL);
|
|
DUMP_PFD_FLAG(PFD_GENERIC_FORMAT);
|
|
DUMP_PFD_FLAG(PFD_NEED_PALETTE);
|
|
DUMP_PFD_FLAG(PFD_NEED_SYSTEM_PALETTE);
|
|
DUMP_PFD_FLAG(PFD_SWAP_EXCHANGE);
|
|
DUMP_PFD_FLAG(PFD_SWAP_COPY);
|
|
DUMP_PFD_FLAG(PFD_SWAP_LAYER_BUFFERS);
|
|
DUMP_PFD_FLAG(PFD_GENERIC_ACCELERATED);
|
|
DUMP_PFD_FLAG(PFD_DEPTH_DONTCARE);
|
|
DUMP_PFD_FLAG(PFD_DOUBLEBUFFER_DONTCARE);
|
|
DUMP_PFD_FLAG(PFD_STEREO_DONTCARE);
|
|
ErrorF("}\n");
|
|
|
|
ErrorF("iPixelType = %hhu = %s\n", pfd->iPixelType,
|
|
(pfd->iPixelType == PFD_TYPE_RGBA ? "PFD_TYPE_RGBA" : "PFD_TYPE_COLORINDEX"));
|
|
ErrorF("cColorBits = %hhu\n", pfd->cColorBits);
|
|
ErrorF("cRedBits = %hhu\n", pfd->cRedBits);
|
|
ErrorF("cRedShift = %hhu\n", pfd->cRedShift);
|
|
ErrorF("cGreenBits = %hhu\n", pfd->cGreenBits);
|
|
ErrorF("cGreenShift = %hhu\n", pfd->cGreenShift);
|
|
ErrorF("cBlueBits = %hhu\n", pfd->cBlueBits);
|
|
ErrorF("cBlueShift = %hhu\n", pfd->cBlueShift);
|
|
ErrorF("cAlphaBits = %hhu\n", pfd->cAlphaBits);
|
|
ErrorF("cAlphaShift = %hhu\n", pfd->cAlphaShift);
|
|
ErrorF("cAccumBits = %hhu\n", pfd->cAccumBits);
|
|
ErrorF("cAccumRedBits = %hhu\n", pfd->cAccumRedBits);
|
|
ErrorF("cAccumGreenBits = %hhu\n", pfd->cAccumGreenBits);
|
|
ErrorF("cAccumBlueBits = %hhu\n", pfd->cAccumBlueBits);
|
|
ErrorF("cAccumAlphaBits = %hhu\n", pfd->cAccumAlphaBits);
|
|
ErrorF("cDepthBits = %hhu\n", pfd->cDepthBits);
|
|
ErrorF("cStencilBits = %hhu\n", pfd->cStencilBits);
|
|
ErrorF("cAuxBuffers = %hhu\n", pfd->cAuxBuffers);
|
|
ErrorF("iLayerType = %hhu\n", pfd->iLayerType);
|
|
ErrorF("bReserved = %hhu\n", pfd->bReserved);
|
|
ErrorF("dwLayerMask = %lu\n", pfd->dwLayerMask);
|
|
ErrorF("dwVisibleMask = %lu\n", pfd->dwVisibleMask);
|
|
ErrorF("dwDamageMask = %lu\n", pfd->dwDamageMask);
|
|
ErrorF("\n");
|
|
}
|
|
|
|
static int makeFormat(__GLcontextModes *mode, PIXELFORMATDESCRIPTOR *pfdret)
|
|
{
|
|
PIXELFORMATDESCRIPTOR pfd = {
|
|
sizeof(PIXELFORMATDESCRIPTOR), /* size of this pfd */
|
|
1, /* version number */
|
|
PFD_DRAW_TO_WINDOW | /* support window */
|
|
PFD_SUPPORT_OPENGL, /* support OpenGL */
|
|
PFD_TYPE_RGBA, /* RGBA type */
|
|
24, /* 24-bit color depth */
|
|
0, 0, 0, 0, 0, 0, /* color bits ignored */
|
|
0, /* no alpha buffer */
|
|
0, /* shift bit ignored */
|
|
0, /* no accumulation buffer */
|
|
0, 0, 0, 0, /* accum bits ignored */
|
|
0, /* 32-bit z-buffer */
|
|
0, /* no stencil buffer */
|
|
0, /* no auxiliary buffer */
|
|
PFD_MAIN_PLANE, /* main layer */
|
|
0, /* reserved */
|
|
0, 0, 0 /* layer masks ignored */
|
|
}, *result = &pfd;
|
|
|
|
/* disable anything but rgba. must get rgba to work first */
|
|
if (!mode->rgbMode)
|
|
return -1;
|
|
|
|
if (mode->stereoMode) {
|
|
result->dwFlags |= PFD_STEREO;
|
|
}
|
|
if (mode->doubleBufferMode) {
|
|
result->dwFlags |= PFD_DOUBLEBUFFER;
|
|
}
|
|
|
|
if (mode->colorIndexMode) {
|
|
/* ignored, see above */
|
|
result->iPixelType = PFD_TYPE_COLORINDEX;
|
|
result->cColorBits = mode->redBits + mode->greenBits + mode->blueBits;
|
|
result->cRedBits = mode->redBits;
|
|
result->cRedShift = 0; /* FIXME */
|
|
result->cGreenBits = mode->greenBits;
|
|
result->cGreenShift = 0; /* FIXME */
|
|
result->cBlueBits = mode->blueBits;
|
|
result->cBlueShift = 0; /* FIXME */
|
|
result->cAlphaBits = mode->alphaBits;
|
|
result->cAlphaShift = 0; /* FIXME */
|
|
}
|
|
|
|
if (mode->rgbMode) {
|
|
result->iPixelType = PFD_TYPE_RGBA;
|
|
result->cColorBits = mode->redBits + mode->greenBits + mode->blueBits;
|
|
result->cRedBits = mode->redBits;
|
|
result->cRedShift = 0; /* FIXME */
|
|
result->cGreenBits = mode->greenBits;
|
|
result->cGreenShift = 0; /* FIXME */
|
|
result->cBlueBits = mode->blueBits;
|
|
result->cBlueShift = 0; /* FIXME */
|
|
result->cAlphaBits = mode->alphaBits;
|
|
result->cAlphaShift = 0; /* FIXME */
|
|
}
|
|
|
|
if (mode->haveAccumBuffer) {
|
|
result->cAccumBits = mode->accumRedBits + mode->accumGreenBits
|
|
+ mode->accumBlueBits + mode->accumAlphaBits;
|
|
result->cAccumRedBits = mode->accumRedBits;
|
|
result->cAccumGreenBits = mode->accumGreenBits;
|
|
result->cAccumBlueBits = mode->accumBlueBits;
|
|
result->cAccumAlphaBits = mode->accumAlphaBits;
|
|
}
|
|
|
|
if (mode->haveDepthBuffer) {
|
|
result->cDepthBits = mode->depthBits;
|
|
}
|
|
if (mode->haveStencilBuffer) {
|
|
result->cStencilBits = mode->stencilBits;
|
|
}
|
|
|
|
/* result->cAuxBuffers = mode->numAuxBuffers; */
|
|
|
|
/* mode->level ignored */
|
|
|
|
/* mode->pixmapMode ? */
|
|
|
|
*pfdret = pfd;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static __GLinterface *glWinCreateContext(__GLimports *imports,
|
|
__GLcontextModes *mode,
|
|
__GLinterface *shareGC)
|
|
{
|
|
__GLcontext *result;
|
|
|
|
GLWIN_DEBUG_MSG("glWinCreateContext\n");
|
|
|
|
result = (__GLcontext *)calloc(1, sizeof(__GLcontext));
|
|
if (!result)
|
|
return NULL;
|
|
|
|
result->interface.imports = *imports;
|
|
result->interface.exports = glWinExports;
|
|
|
|
if (makeFormat(mode, &result->pfd))
|
|
{
|
|
ErrorF("makeFormat failed\n");
|
|
free(result);
|
|
return NULL;
|
|
}
|
|
|
|
if (glWinDebugSettings.dumpPFD)
|
|
pfdOut(&result->pfd);
|
|
|
|
GLWIN_DEBUG_MSG("glWinCreateContext done\n");
|
|
return (__GLinterface *)result;
|
|
}
|
|
|
|
Bool
|
|
glWinRealizeWindow(WindowPtr pWin)
|
|
{
|
|
/* If this window has GL contexts, tell them to reattach */
|
|
Bool result;
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
glWinScreenRec *screenPriv = &glWinScreens[pScreen->myNum];
|
|
__GLXdrawablePrivate *glxPriv;
|
|
|
|
GLWIN_DEBUG_MSG("glWinRealizeWindow\n");
|
|
|
|
/* Allow the window to be created (RootlessRealizeWindow is inside our wrap) */
|
|
pScreen->RealizeWindow = screenPriv->RealizeWindow;
|
|
result = pScreen->RealizeWindow(pWin);
|
|
pScreen->RealizeWindow = glWinRealizeWindow;
|
|
|
|
/* Re-attach this window's GL contexts, if any. */
|
|
glxPriv = __glXFindDrawablePrivate(pWin->drawable.id);
|
|
if (glxPriv) {
|
|
__GLXcontext *gx;
|
|
__GLcontext *gc;
|
|
__GLdrawablePrivate *glPriv = &glxPriv->glPriv;
|
|
GLWIN_DEBUG_MSG("glWinRealizeWindow is GL drawable!\n");
|
|
|
|
/* GL contexts bound to this window for drawing */
|
|
for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) {
|
|
gc = (__GLcontext *)gx->gc;
|
|
if (gc->isAttached)
|
|
unattach(gc);
|
|
attach(gc, glPriv);
|
|
}
|
|
|
|
/* GL contexts bound to this window for reading */
|
|
for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) {
|
|
gc = (__GLcontext *)gx->gc;
|
|
if (gc->isAttached)
|
|
unattach(gc);
|
|
attach(gc, glPriv);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
void
|
|
glWinCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
|
|
{
|
|
ScreenPtr pScreen = pWindow->drawable.pScreen;
|
|
glWinScreenRec *screenPriv = &glWinScreens[pScreen->myNum];
|
|
__GLXdrawablePrivate *glxPriv;
|
|
|
|
/* Check if the window is attached and discard any drawing request */
|
|
glxPriv = __glXFindDrawablePrivate(pWindow->drawable.id);
|
|
if (glxPriv) {
|
|
__GLXcontext *gx;
|
|
|
|
/* GL contexts bound to this window for drawing */
|
|
for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) {
|
|
/*
|
|
GLWIN_DEBUG_MSG("glWinCopyWindow - calling glDrawBuffer\n");
|
|
glDrawBuffer(GL_FRONT);
|
|
*/
|
|
return;
|
|
}
|
|
|
|
/* GL contexts bound to this window for reading */
|
|
for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
GLWIN_DEBUG_MSG("glWinCopyWindow - passing to hw layer\n");
|
|
|
|
pScreen->CopyWindow = screenPriv->CopyWindow;
|
|
pScreen->CopyWindow(pWindow, ptOldOrg, prgnSrc);
|
|
pScreen->CopyWindow = glWinCopyWindow;
|
|
}
|
|
|
|
Bool
|
|
glWinUnrealizeWindow(WindowPtr pWin)
|
|
{
|
|
/* If this window has GL contexts, tell them to unattach */
|
|
Bool result;
|
|
ScreenPtr pScreen = pWin->drawable.pScreen;
|
|
glWinScreenRec *screenPriv = &glWinScreens[pScreen->myNum];
|
|
__GLXdrawablePrivate *glxPriv;
|
|
|
|
GLWIN_DEBUG_MSG("glWinUnrealizeWindow\n");
|
|
|
|
/* The Aqua window may have already been destroyed (windows
|
|
* are unrealized from top down)
|
|
*/
|
|
|
|
/* Unattach this window's GL contexts, if any. */
|
|
glxPriv = __glXFindDrawablePrivate(pWin->drawable.id);
|
|
if (glxPriv) {
|
|
__GLXcontext *gx;
|
|
__GLcontext *gc;
|
|
GLWIN_DEBUG_MSG("glWinUnealizeWindow is GL drawable!\n");
|
|
|
|
/* GL contexts bound to this window for drawing */
|
|
for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) {
|
|
gc = (__GLcontext *)gx->gc;
|
|
unattach(gc);
|
|
}
|
|
|
|
/* GL contexts bound to this window for reading */
|
|
for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) {
|
|
gc = (__GLcontext *)gx->gc;
|
|
unattach(gc);
|
|
}
|
|
}
|
|
|
|
pScreen->UnrealizeWindow = screenPriv->UnrealizeWindow;
|
|
result = pScreen->UnrealizeWindow(pWin);
|
|
pScreen->UnrealizeWindow = glWinUnrealizeWindow;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*
|
|
* In the case the driver has no GLX visuals we'll use these.
|
|
* [0] = RGB, double buffered
|
|
* [1] = RGB, double buffered, stencil, accum
|
|
*/
|
|
/* Originally copied from Mesa */
|
|
|
|
static int numConfigs = 0;
|
|
static __GLXvisualConfig *visualConfigs = NULL;
|
|
static void **visualPrivates = NULL;
|
|
|
|
#define NUM_FALLBACK_CONFIGS 2
|
|
static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
|
|
{
|
|
-1, /* vid */
|
|
-1, /* class */
|
|
True, /* rgba */
|
|
-1, -1, -1, 0, /* rgba sizes */
|
|
-1, -1, -1, 0, /* rgba masks */
|
|
0, 0, 0, 0, /* rgba accum sizes */
|
|
True, /* doubleBuffer */
|
|
False, /* stereo */
|
|
-1, /* bufferSize */
|
|
16, /* depthSize */
|
|
0, /* stencilSize */
|
|
0, /* auxBuffers */
|
|
0, /* level */
|
|
GLX_NONE_EXT, /* visualRating */
|
|
0, /* transparentPixel */
|
|
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
|
0 /* transparentIndex */
|
|
},
|
|
{
|
|
-1, /* vid */
|
|
-1, /* class */
|
|
True, /* rgba */
|
|
-1, -1, -1, 0, /* rgba sizes */
|
|
-1, -1, -1, 0, /* rgba masks */
|
|
16, 16, 16, 0, /* rgba accum sizes */
|
|
True, /* doubleBuffer */
|
|
False, /* stereo */
|
|
-1, /* bufferSize */
|
|
16, /* depthSize */
|
|
8, /* stencilSize */
|
|
0, /* auxBuffers */
|
|
0, /* level */
|
|
GLX_NONE_EXT, /* visualRating */
|
|
0, /* transparentPixel */
|
|
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
|
0 /* transparentIndex */
|
|
}
|
|
};
|
|
|
|
static inline int count_bits(uint32_t x)
|
|
{
|
|
x = x - ((x >> 1) & 0x55555555);
|
|
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
|
|
x = (x + (x >> 4)) & 0x0f0f0f0f;
|
|
x = x + (x >> 8);
|
|
x = x + (x >> 16);
|
|
return x & 63;
|
|
}
|
|
|
|
/* Mostly copied from Mesa's xf86glx.c */
|
|
static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
|
|
VisualID *defaultVisp,
|
|
int ndepth, DepthPtr pdepth,
|
|
int rootDepth)
|
|
{
|
|
int numRGBconfigs;
|
|
int numCIconfigs;
|
|
int numVisuals = *nvisualp;
|
|
int numNewVisuals;
|
|
int numNewConfigs;
|
|
VisualPtr pVisual = *visualp;
|
|
VisualPtr pVisualNew = NULL;
|
|
VisualID *orig_vid = NULL;
|
|
__GLcontextModes *modes = NULL;
|
|
__GLXvisualConfig *pNewVisualConfigs = NULL;
|
|
void **glXVisualPriv;
|
|
void **pNewVisualPriv;
|
|
int found_default;
|
|
int i, j, k;
|
|
|
|
GLWIN_DEBUG_MSG("init_visuals\n");
|
|
|
|
if (numConfigs > 0)
|
|
numNewConfigs = numConfigs;
|
|
else
|
|
numNewConfigs = NUM_FALLBACK_CONFIGS;
|
|
|
|
/* Alloc space for the list of new GLX visuals */
|
|
pNewVisualConfigs = (__GLXvisualConfig *)
|
|
__glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig));
|
|
if (!pNewVisualConfigs) {
|
|
return FALSE;
|
|
}
|
|
|
|
/* Alloc space for the list of new GLX visual privates */
|
|
pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *));
|
|
if (!pNewVisualPriv) {
|
|
__glXFree(pNewVisualConfigs);
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
** If SetVisualConfigs was not called, then use default GLX
|
|
** visual configs.
|
|
*/
|
|
if (numConfigs == 0) {
|
|
memcpy(pNewVisualConfigs, FallbackConfigs,
|
|
NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig));
|
|
memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
|
|
}
|
|
else {
|
|
/* copy driver's visual config info */
|
|
for (i = 0; i < numConfigs; i++) {
|
|
pNewVisualConfigs[i] = visualConfigs[i];
|
|
pNewVisualPriv[i] = visualPrivates[i];
|
|
}
|
|
}
|
|
|
|
/* Count the number of RGB and CI visual configs */
|
|
numRGBconfigs = 0;
|
|
numCIconfigs = 0;
|
|
for (i = 0; i < numNewConfigs; i++) {
|
|
if (pNewVisualConfigs[i].rgba)
|
|
numRGBconfigs++;
|
|
else
|
|
numCIconfigs++;
|
|
}
|
|
|
|
/* Count the total number of visuals to compute */
|
|
numNewVisuals = 0;
|
|
for (i = 0; i < numVisuals; i++) {
|
|
int count;
|
|
|
|
count = ((pVisual[i].class == TrueColor
|
|
|| pVisual[i].class == DirectColor)
|
|
? numRGBconfigs : numCIconfigs);
|
|
if (count == 0)
|
|
count = 1; /* preserve the existing visual */
|
|
|
|
numNewVisuals += count;
|
|
}
|
|
|
|
/* Reset variables for use with the next screen/driver's visual configs */
|
|
visualConfigs = NULL;
|
|
numConfigs = 0;
|
|
|
|
/* Alloc temp space for the list of orig VisualIDs for each new visual */
|
|
orig_vid = (VisualID *)__glXMalloc(numNewVisuals * sizeof(VisualID));
|
|
if (!orig_vid) {
|
|
__glXFree(pNewVisualPriv);
|
|
__glXFree(pNewVisualConfigs);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Alloc space for the list of glXVisuals */
|
|
modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
|
|
if (modes == NULL) {
|
|
__glXFree(orig_vid);
|
|
__glXFree(pNewVisualPriv);
|
|
__glXFree(pNewVisualConfigs);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Alloc space for the list of glXVisualPrivates */
|
|
glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *));
|
|
if (!glXVisualPriv) {
|
|
_gl_context_modes_destroy( modes );
|
|
__glXFree(orig_vid);
|
|
__glXFree(pNewVisualPriv);
|
|
__glXFree(pNewVisualConfigs);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Alloc space for the new list of the X server's visuals */
|
|
pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec));
|
|
if (!pVisualNew) {
|
|
__glXFree(glXVisualPriv);
|
|
_gl_context_modes_destroy( modes );
|
|
__glXFree(orig_vid);
|
|
__glXFree(pNewVisualPriv);
|
|
__glXFree(pNewVisualConfigs);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Initialize the new visuals */
|
|
found_default = FALSE;
|
|
glWinScreens[screenInfo.numScreens-1].modes = modes;
|
|
for (i = j = 0; i < numVisuals; i++) {
|
|
int is_rgb = (pVisual[i].class == TrueColor ||
|
|
pVisual[i].class == DirectColor);
|
|
|
|
#if 0
|
|
if (!is_rgb)
|
|
{
|
|
/* We don't support non-rgb visuals for GL. But we don't
|
|
want to remove them either, so just pass them through
|
|
with null glX configs */
|
|
|
|
pVisualNew[j] = pVisual[i];
|
|
pVisualNew[j].vid = FakeClientID(0);
|
|
|
|
/* Check for the default visual */
|
|
if (!found_default && pVisual[i].vid == *defaultVisp) {
|
|
*defaultVisp = pVisualNew[j].vid;
|
|
found_default = TRUE;
|
|
}
|
|
|
|
/* Save the old VisualID */
|
|
orig_vid[j] = pVisual[i].vid;
|
|
|
|
/* Initialize the glXVisual */
|
|
glXVisualPtr[j] = NullConfig;
|
|
glXVisualPriv[j] = NULL;
|
|
|
|
j++;
|
|
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
for (k = 0; k < numNewConfigs; k++) {
|
|
if (pNewVisualConfigs[k].rgba != is_rgb)
|
|
continue;
|
|
|
|
assert( modes != NULL );
|
|
|
|
/* Initialize the new visual */
|
|
pVisualNew[j] = pVisual[i];
|
|
pVisualNew[j].vid = FakeClientID(0);
|
|
|
|
/* Check for the default visual */
|
|
if (!found_default && pVisual[i].vid == *defaultVisp) {
|
|
*defaultVisp = pVisualNew[j].vid;
|
|
found_default = TRUE;
|
|
}
|
|
|
|
/* Save the old VisualID */
|
|
orig_vid[j] = pVisual[i].vid;
|
|
|
|
/* Initialize the glXVisual */
|
|
_gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] );
|
|
modes->visualID = pVisualNew[j].vid;
|
|
|
|
/*
|
|
* If the class is -1, then assume the X visual information
|
|
* is identical to what GLX needs, and take them from the X
|
|
* visual. NOTE: if class != -1, then all other fields MUST
|
|
* be initialized.
|
|
*/
|
|
if (modes->visualType == GLX_NONE) {
|
|
modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class );
|
|
modes->redBits = count_bits(pVisual[i].redMask);
|
|
modes->greenBits = count_bits(pVisual[i].greenMask);
|
|
modes->blueBits = count_bits(pVisual[i].blueMask);
|
|
modes->alphaBits = modes->alphaBits;
|
|
modes->redMask = pVisual[i].redMask;
|
|
modes->greenMask = pVisual[i].greenMask;
|
|
modes->blueMask = pVisual[i].blueMask;
|
|
modes->alphaMask = modes->alphaMask;
|
|
modes->rgbBits = (is_rgb)
|
|
? (modes->redBits + modes->greenBits +
|
|
modes->blueBits + modes->alphaBits)
|
|
: rootDepth;
|
|
}
|
|
|
|
/* Save the device-dependent private for this visual */
|
|
glXVisualPriv[j] = pNewVisualPriv[k];
|
|
|
|
j++;
|
|
modes = modes->next;
|
|
}
|
|
}
|
|
|
|
assert(j <= numNewVisuals);
|
|
|
|
/* Save the GLX visuals in the screen structure */
|
|
glWinScreens[screenInfo.numScreens-1].num_vis = numNewVisuals;
|
|
glWinScreens[screenInfo.numScreens-1].priv = glXVisualPriv;
|
|
|
|
/* Set up depth's VisualIDs */
|
|
for (i = 0; i < ndepth; i++) {
|
|
int numVids = 0;
|
|
VisualID *pVids = NULL;
|
|
int k, n = 0;
|
|
|
|
/* Count the new number of VisualIDs at this depth */
|
|
for (j = 0; j < pdepth[i].numVids; j++)
|
|
for (k = 0; k < numNewVisuals; k++)
|
|
if (pdepth[i].vids[j] == orig_vid[k])
|
|
numVids++;
|
|
|
|
/* Allocate a new list of VisualIDs for this depth */
|
|
pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID));
|
|
|
|
/* Initialize the new list of VisualIDs for this depth */
|
|
for (j = 0; j < pdepth[i].numVids; j++)
|
|
for (k = 0; k < numNewVisuals; k++)
|
|
if (pdepth[i].vids[j] == orig_vid[k])
|
|
pVids[n++] = pVisualNew[k].vid;
|
|
|
|
/* Update this depth's list of VisualIDs */
|
|
__glXFree(pdepth[i].vids);
|
|
pdepth[i].vids = pVids;
|
|
pdepth[i].numVids = numVids;
|
|
}
|
|
|
|
/* Update the X server's visuals */
|
|
*nvisualp = numNewVisuals;
|
|
*visualp = pVisualNew;
|
|
|
|
/* Free the old list of the X server's visuals */
|
|
__glXFree(pVisual);
|
|
|
|
/* Clean up temporary allocations */
|
|
__glXFree(orig_vid);
|
|
__glXFree(pNewVisualPriv);
|
|
__glXFree(pNewVisualConfigs);
|
|
|
|
/* Free the private list created by DDX HW driver */
|
|
if (visualPrivates)
|
|
xfree(visualPrivates);
|
|
visualPrivates = NULL;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void fixup_visuals(int screen)
|
|
{
|
|
ScreenPtr pScreen = screenInfo.screens[screen];
|
|
glWinScreenRec *pScr = &glWinScreens[screen];
|
|
__GLcontextModes *modes;
|
|
int j;
|
|
|
|
GLWIN_DEBUG_MSG("fixup_visuals\n");
|
|
|
|
for (modes = pScr->modes; modes != NULL; modes = modes->next ) {
|
|
const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
|
|
const int nplanes = (modes->rgbBits - modes->alphaBits);
|
|
VisualPtr pVis = pScreen->visuals;
|
|
|
|
/* Find a visual that matches the GLX visual's class and size */
|
|
for (j = 0; j < pScreen->numVisuals; j++) {
|
|
if (pVis[j].class == vis_class &&
|
|
pVis[j].nplanes == nplanes) {
|
|
|
|
/* Fixup the masks */
|
|
modes->redMask = pVis[j].redMask;
|
|
modes->greenMask = pVis[j].greenMask;
|
|
modes->blueMask = pVis[j].blueMask;
|
|
|
|
/* Recalc the sizes */
|
|
modes->redBits = count_bits(modes->redMask);
|
|
modes->greenBits = count_bits(modes->greenMask);
|
|
modes->blueBits = count_bits(modes->blueMask);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void init_screen_visuals(int screen)
|
|
{
|
|
ScreenPtr pScreen = screenInfo.screens[screen];
|
|
__GLcontextModes *modes;
|
|
int *used;
|
|
int i, j;
|
|
|
|
GLWIN_DEBUG_MSG("init_screen_visuals\n");
|
|
|
|
used = (int *)__glXMalloc(pScreen->numVisuals * sizeof(int));
|
|
__glXMemset(used, 0, pScreen->numVisuals * sizeof(int));
|
|
|
|
i = 0;
|
|
for ( modes = glWinScreens[screen].modes
|
|
; modes != NULL
|
|
; modes = modes->next) {
|
|
const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
|
|
const int nplanes = (modes->rgbBits - modes->alphaBits);
|
|
const VisualPtr pVis = pScreen->visuals;
|
|
|
|
for (j = 0; j < pScreen->numVisuals; j++) {
|
|
|
|
if (pVis[j].class == vis_class &&
|
|
pVis[j].nplanes == nplanes &&
|
|
pVis[j].redMask == modes->redMask &&
|
|
pVis[j].greenMask == modes->greenMask &&
|
|
pVis[j].blueMask == modes->blueMask &&
|
|
!used[j]) {
|
|
|
|
#if 0
|
|
/* Create the XMesa visual */
|
|
pXMesaVisual[i] =
|
|
XMesaCreateVisual(pScreen,
|
|
pVis,
|
|
modes->rgbMode,
|
|
(modes->alphaBits > 0),
|
|
modes->doubleBufferMode,
|
|
modes->stereoMode,
|
|
GL_TRUE, /* ximage_flag */
|
|
modes->depthBits,
|
|
modes->stencilBits,
|
|
modes->accumRedBits,
|
|
modes->accumGreenBits,
|
|
modes->accumBlueBits,
|
|
modes->accumAlphaBits,
|
|
modes->samples,
|
|
modes->level,
|
|
modes->visualRating);
|
|
#endif
|
|
|
|
/* Set the VisualID */
|
|
modes->visualID = pVis[j].vid;
|
|
|
|
/* Mark this visual used */
|
|
used[j] = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( j == pScreen->numVisuals ) {
|
|
ErrorF("No matching visual for __GLcontextMode with "
|
|
"visual class = %d (%d), nplanes = %u\n",
|
|
vis_class,
|
|
modes->visualType,
|
|
(modes->rgbBits - modes->alphaBits) );
|
|
}
|
|
else if ( modes->visualID == -1 ) {
|
|
FatalError( "Matching visual found, but visualID still -1!\n" );
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
__glXFree(used);
|
|
|
|
/* glWinScreens[screen].xm_vis = pXMesaVisual; */
|
|
}
|
|
|
|
static Bool glWinScreenProbe(int screen)
|
|
{
|
|
ScreenPtr pScreen;
|
|
glWinScreenRec *screenPriv;
|
|
|
|
GLWIN_DEBUG_MSG("glWinScreenProbe\n");
|
|
|
|
/*
|
|
* Set up the current screen's visuals.
|
|
*/
|
|
__glDDXScreenInfo.modes = glWinScreens[screen].modes;
|
|
__glDDXScreenInfo.pVisualPriv = glWinScreens[screen].priv;
|
|
__glDDXScreenInfo.numVisuals =
|
|
__glDDXScreenInfo.numUsableVisuals = glWinScreens[screen].num_vis;
|
|
|
|
/*
|
|
* Set the current screen's createContext routine. This could be
|
|
* wrapped by a DDX GLX context creation routine.
|
|
*/
|
|
__glDDXScreenInfo.createContext = glWinCreateContext;
|
|
|
|
/*
|
|
* The ordering of the rgb compenents might have been changed by the
|
|
* driver after mi initialized them.
|
|
*/
|
|
fixup_visuals(screen);
|
|
|
|
/*
|
|
* Find the GLX visuals that are supported by this screen and create
|
|
* XMesa's visuals.
|
|
*/
|
|
init_screen_visuals(screen);
|
|
|
|
/* Wrap RealizeWindow and UnrealizeWindow on this screen */
|
|
pScreen = screenInfo.screens[screen];
|
|
screenPriv = &glWinScreens[screen];
|
|
screenPriv->RealizeWindow = pScreen->RealizeWindow;
|
|
pScreen->RealizeWindow = glWinRealizeWindow;
|
|
screenPriv->UnrealizeWindow = pScreen->UnrealizeWindow;
|
|
pScreen->UnrealizeWindow = glWinUnrealizeWindow;
|
|
screenPriv->CopyWindow = pScreen->CopyWindow;
|
|
pScreen->CopyWindow = glWinCopyWindow;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static GLboolean glWinSwapBuffers(__GLXdrawablePrivate *glxPriv)
|
|
{
|
|
/* swap buffers on only *one* of the contexts
|
|
* (e.g. the last one for drawing)
|
|
*/
|
|
__GLcontext *gc = (__GLcontext *)glxPriv->drawGlxc->gc;
|
|
HDC dc;
|
|
BOOL ret;
|
|
|
|
if (gc != NULL && gc->ctx != NULL)
|
|
{
|
|
dc = glWinMakeDC(gc);
|
|
|
|
ret = SwapBuffers(dc);
|
|
if (!ret)
|
|
ErrorF("SwapBuffers failed: %s\n", glWinErrorMessage());
|
|
|
|
ReleaseDC(gc->winInfo.hwnd, dc);
|
|
if (!ret)
|
|
return GL_FALSE;
|
|
}
|
|
|
|
return GL_TRUE;
|
|
}
|
|
|
|
static void glWinDestroyDrawablePrivate(__GLdrawablePrivate *glPriv)
|
|
{
|
|
GLWIN_DEBUG_MSG("glWinDestroyDrawablePrivate\n");
|
|
|
|
/* It doesn't work to call DRIDestroySurface here, the drawable's
|
|
already gone.. But dri.c notices the window destruction and
|
|
frees the surface itself. */
|
|
|
|
free(glPriv->private);
|
|
glPriv->private = NULL;
|
|
}
|
|
|
|
|
|
static void glWinCreateBuffer(__GLXdrawablePrivate *glxPriv)
|
|
{
|
|
GLWinDrawableRec *winPriv = malloc(sizeof(GLWinDrawableRec));
|
|
__GLdrawablePrivate *glPriv = &glxPriv->glPriv;
|
|
|
|
/*winPriv->sid = 0; */
|
|
winPriv->pDraw = NULL;
|
|
|
|
GLWIN_DEBUG_MSG("glWinCreateBuffer\n");
|
|
|
|
/* replace swapBuffers (original is never called) */
|
|
glxPriv->swapBuffers = glWinSwapBuffers;
|
|
|
|
/* stash private data */
|
|
glPriv->private = winPriv;
|
|
glPriv->freePrivate = glWinDestroyDrawablePrivate;
|
|
}
|
|
|
|
static void glWinResetExtension(void)
|
|
{
|
|
GLWIN_DEBUG_MSG("glWinResetExtension\n");
|
|
}
|
|
|
|
/* based on code in apples/indirect.c which is based on i830_dri.c */
|
|
static void
|
|
glWinInitVisualConfigs(void)
|
|
{
|
|
int lclNumConfigs = 0;
|
|
__GLXvisualConfig *lclVisualConfigs = NULL;
|
|
void **lclVisualPrivates = NULL;
|
|
|
|
int depth, aux, buffers, stencil, accum;
|
|
int i = 0;
|
|
|
|
GLWIN_DEBUG_MSG("glWinInitVisualConfigs ");
|
|
|
|
/* count num configs:
|
|
2 Z buffer (0, 24 bit)
|
|
2 AUX buffer (0, 2)
|
|
2 buffers (single, double)
|
|
2 stencil (0, 8 bit)
|
|
2 accum (0, 64 bit)
|
|
= 32 configs */
|
|
|
|
lclNumConfigs = 2 * 2 * 2 * 2 * 2; /* 32 */
|
|
|
|
/* alloc */
|
|
lclVisualConfigs = xcalloc(sizeof(__GLXvisualConfig), lclNumConfigs);
|
|
lclVisualPrivates = xcalloc(sizeof(void *), lclNumConfigs);
|
|
|
|
/* fill in configs */
|
|
if (NULL != lclVisualConfigs) {
|
|
i = 0; /* current buffer */
|
|
for (depth = 0; depth < 2; depth++) {
|
|
for (aux = 0; aux < 2; aux++) {
|
|
for (buffers = 0; buffers < 2; buffers++) {
|
|
for (stencil = 0; stencil < 2; stencil++) {
|
|
for (accum = 0; accum < 2; accum++) {
|
|
lclVisualConfigs[i].vid = -1;
|
|
lclVisualConfigs[i].class = -1;
|
|
lclVisualConfigs[i].rgba = TRUE;
|
|
lclVisualConfigs[i].redSize = -1;
|
|
lclVisualConfigs[i].greenSize = -1;
|
|
lclVisualConfigs[i].blueSize = -1;
|
|
lclVisualConfigs[i].redMask = -1;
|
|
lclVisualConfigs[i].greenMask = -1;
|
|
lclVisualConfigs[i].blueMask = -1;
|
|
lclVisualConfigs[i].alphaMask = 0;
|
|
if (accum) {
|
|
lclVisualConfigs[i].accumRedSize = 16;
|
|
lclVisualConfigs[i].accumGreenSize = 16;
|
|
lclVisualConfigs[i].accumBlueSize = 16;
|
|
lclVisualConfigs[i].accumAlphaSize = 16;
|
|
}
|
|
else {
|
|
lclVisualConfigs[i].accumRedSize = 0;
|
|
lclVisualConfigs[i].accumGreenSize = 0;
|
|
lclVisualConfigs[i].accumBlueSize = 0;
|
|
lclVisualConfigs[i].accumAlphaSize = 0;
|
|
}
|
|
lclVisualConfigs[i].doubleBuffer = buffers ? TRUE : FALSE;
|
|
lclVisualConfigs[i].stereo = FALSE;
|
|
lclVisualConfigs[i].bufferSize = -1;
|
|
|
|
lclVisualConfigs[i].depthSize = depth? 24 : 0;
|
|
lclVisualConfigs[i].stencilSize = stencil ? 8 : 0;
|
|
lclVisualConfigs[i].auxBuffers = aux ? 2 : 0;
|
|
lclVisualConfigs[i].level = 0;
|
|
lclVisualConfigs[i].visualRating = GLX_NONE_EXT;
|
|
lclVisualConfigs[i].transparentPixel = 0;
|
|
lclVisualConfigs[i].transparentRed = 0;
|
|
lclVisualConfigs[i].transparentGreen = 0;
|
|
lclVisualConfigs[i].transparentBlue = 0;
|
|
lclVisualConfigs[i].transparentAlpha = 0;
|
|
lclVisualConfigs[i].transparentIndex = 0;
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (i != lclNumConfigs)
|
|
GLWIN_DEBUG_MSG("glWinInitVisualConfigs failed to alloc visual configs");
|
|
|
|
GlxSetVisualConfigs(lclNumConfigs, lclVisualConfigs, lclVisualPrivates);
|
|
}
|
|
|
|
/* Copied from Mesa */
|
|
static void glWinSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
|
|
void **privates)
|
|
{
|
|
GLWIN_DEBUG_MSG("glWinSetVisualConfigs\n");
|
|
|
|
numConfigs = nconfigs;
|
|
visualConfigs = configs;
|
|
visualPrivates = privates;
|
|
}
|
|
|
|
/* Copied from Mesa */
|
|
static Bool glWinInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
|
|
int *nvisualp, int *ndepthp,
|
|
int *rootDepthp, VisualID *defaultVisp,
|
|
unsigned long sizes, int bitsPerRGB)
|
|
{
|
|
glWinInitDebugSettings();
|
|
|
|
GLWIN_DEBUG_MSG("glWinInitVisuals\n");
|
|
|
|
if (0 == numConfigs) /* if no configs */
|
|
glWinInitVisualConfigs(); /* ensure the visula configs are setup */
|
|
|
|
/*
|
|
* Setup the visuals supported by this particular screen.
|
|
*/
|
|
return init_visuals(nvisualp, visualp, defaultVisp,
|
|
*ndepthp, *depthp, *rootDepthp);
|
|
}
|