static bool GLimp_SetPixelFormat()
{
static const PIXELFORMATDESCRIPTOR pfdBase =
{
sizeof(PIXELFORMATDESCRIPTOR),
1, // version number
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
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
32, // 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
};
int pixelformat;
if ((pixelformat = wglChoosePixelFormat(gl_hDC, &pfdBase)) == 0)
{
ErrFail("(wgl)ChoosePixelFormat()");
return false;
}
if (wglSetPixelFormat(gl_hDC, pixelformat, &pfdBase) == FALSE)
{
ErrFail("(wgl)SetPixelFormat()");
return false;
}
PIXELFORMATDESCRIPTOR pfd;
wglDescribePixelFormat(gl_hDC, pixelformat, sizeof(pfd), &pfd);
// startup the OpenGL subsystem by creating a context and making it current
if (!CreateGLcontext()) return false;
if (!ActivateGLcontext()) return false;
if (!(pfd.dwFlags & PFD_GENERIC_ACCELERATED) && (pfd.dwFlags & PFD_GENERIC_FORMAT))
{
appWPrintf("...no hardware acceleration detected\n");
return false;
}
// print PFD info
appPrintf("Pixelformat %d: color:%d depth:%d\n", pixelformat, pfd.cColorBits, pfd.cDepthBits);
return true;
}
WINGDIAPI BOOL WINAPI DrvSetPixelFormat(HDC hdc, int pixelFormat)
{
return wglSetPixelFormat(hdc, pixelFormat, NULL);
}
/* ARGSUSED5 */ /* Only Win32 uses gameMode parameter. */
GLUTwindow *
__glutCreateWindow(GLUTwindow * parent,
int x, int y, int width, int height, int gameMode)
{
GLUTwindow *window;
XSetWindowAttributes wa;
unsigned long attribMask;
int winnum;
int i;
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
GLXFBConfigSGIX fbc;
#else
void *fbc;
#endif
#if defined(__OS2PM__)
{
extern HAB hab; /* PM anchor block handle */
CLASSINFO classinfo;
if(!WinQueryClassInfo(hab,"GLUT", &classinfo) )
__glutOpenOS2Connection(NULL);
}
#elif defined(_WIN32)
WNDCLASS wc;
int style;
if (!GetClassInfo(GetModuleHandle(NULL), "GLUT", &wc)) {
__glutOpenWin32Connection(NULL);
}
#else
if (!__glutDisplay) {
__glutOpenXConnection(NULL);
}
#endif
#ifndef __OS2PM__
if (__glutGameModeWindow) {
__glutFatalError("cannot create windows in game mode.");
}
#endif
winnum = getUnusedWindowSlot();
window = (GLUTwindow *) malloc(sizeof(GLUTwindow));
if (!window) {
__glutFatalError("out of memory.");
}
window->num = winnum;
#if defined(__OS2PM__)
/* Add this new window to the window list. */
__glutWindowList[winnum] = window;
window->shownState = -1;
#endif
#if !defined(_WIN32) && !defined(__OS2PM__)
window->vis = __glutDetermineWindowVisual(&window->treatAsSingle,
&window->visAlloced, (void**) &fbc);
if (!window->vis) {
__glutFatalError(
"visual with necessary capabilities not found.");
}
__glutSetupColormap(window->vis, &window->colormap, &window->cmap);
#endif
window->eventMask = StructureNotifyMask | ExposureMask;
attribMask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;
wa.background_pixmap = None;
wa.border_pixel = 0;
wa.colormap = window->cmap;
wa.event_mask = window->eventMask;
if (parent) {
if (parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK)
wa.event_mask |= GLUT_HACK_STOP_PROPAGATE_MASK;
attribMask |= CWDontPropagate;
wa.do_not_propagate_mask = parent->eventMask & GLUT_DONT_PROPAGATE_FILTER_MASK;
} else {
wa.do_not_propagate_mask = 0;
}
/* Stash width and height before Win32's __glutAdjustCoords
possibly overwrites the values. */
window->width = width;
window->height = height;
window->forceReshape = True;
window->ignoreKeyRepeat = False;
#if defined(__OS2PM__)
{ ULONG flStyle=0;
int ii;
ERRORID erridErrorCode;/* last error id code */
extern HAB hab; /* PM anchor block handle */
if (parent) {
flStyle = WS_CLIPCHILDREN|WS_VISIBLE;
} else {
if (gameMode) {
/* Game mode window should be a WS_POPUP window to
ensure that the taskbar is hidden by it. A standard
WS_OVERLAPPEDWINDOW does not hide the task bar. */
flStyle = FCF_STANDARD | WS_MAXIMIZED;
} else {
/* A standard toplevel window with borders and such. */
flStyle = FCF_STANDARD | WS_CLIPCHILDREN;
// flStyle = WS_OVERLAPPEDWINDOW;
}
}
{
HWND hwnd; /* Window */
ULONG ListBoxId; /* Window id */
/* (supplied by application) */
HWND hwndClient; /* handle to the client */
HWND hwndFrame; /* handle to the frame */
PFNWP GenericWndProc;
FRAMECDATA fcd;
RECTL rect; /* Boundary rectangle */
/************************************************/
// flCreate = (FCF_STANDARD) & ~FCF_TASKLIST;
/**********************************/
if (parent)
{ window->frame = NULL;
hwnd = WinCreateWindow(parent->win, /* Parent window */
"GLUTCHILD", /* Class name */
"", /* Window text */
flStyle, /* Window style */
x, y, /* Position (x,y) */
width, height, /* Size (width,height) */
parent->win, /* Owner window */
HWND_TOP, /* Sibling window */
0, /* Window id */
NULL, /* Control data */
NULL); /* Pres parameters */
erridErrorCode = WinGetLastError(hab);
window->win = hwnd;
window->hdc = WinOpenWindowDC(window->win);
window->hpsBuffer = hpsCurrent;
rect.xLeft = x;
rect.xRight = x+width;
rect.yBottom = y;
rect.yTop = y + height;
/***** else parent *****************************/
} else {
hwnd = WinCreateStdWindow(HWND_DESKTOP,
0, /* WS_VISIBLE frame-window style */
&flStyle, /* window style */
"GLUT", /* class name */
"GLUT",/* window title */
0L, /* default client style */
NULLHANDLE, /* resource in executable file */
ID_WINDOW, /* resource id */
&hwndClient); /* receives client window handle */
erridErrorCode = WinGetLastError(hab);
window->win = hwndClient;
window->frame = hwnd;
window->hdc = WinOpenWindowDC(window->win);
window->hpsBuffer = hpsCurrent;
/* converts a client window's boundaries into an equivalent frame rectangle */
rect.xLeft = x;
rect.xRight = x+width;
rect.yBottom = y;
rect.yTop = y + height;
/* calculate equivalent frame boundary from boundary data */
WinCalcFrameRect(window->frame, &rect, FALSE);
}
/***** endof if(parent) *****************************/
/* Must set the XHDC for fake glXChooseVisual & fake
glXCreateContext & fake XAllocColorCells. */
XHDC = window->hdc;
XHWND = window->win;
window->vis = __glutDetermineWindowVisual(&window->treatAsSingle,
&window->visAlloced, &fbc);
if (!window->vis)
{ __glutFatalError(
"pixel format with necessary capabilities not found.");
}
{ int rc;
rc = wglChoosePixelFormat(window->hdc, window->vis),
// evglSetPixelFormat(2); /* int iPixelFormat 1 - doublebuffer/2 - single buffer ??*/
wglSetPixelFormat(window->hdc,rc,window->vis);
}
__glutSetupColormap(window->vis, &window->colormap, &window->cmap);
window->ctx = glXCreateContext(window->hpsBuffer, window->vis,
None, __glutTryDirect);
WinSetWindowPos(hwnd,
HWND_TOP,rect.xLeft,rect.yBottom,
rect.xRight-rect.xLeft, rect.yTop-rect.yBottom,
SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW|SWP_ZORDER); /* flags*/
/* Make sure subwindows get a windowStatus callback. */
if (parent)
WinPostMsg(parent->win, WM_ACTIVATE, 0, 0);
}
}
#elif defined(_WIN32)
__glutAdjustCoords(parent ? parent->win : NULL,
&x, &y, &width, &height);
if (parent) {
style = WS_CHILD;
} else {
if (gameMode) {
/* Game mode window should be a WS_POPUP window to
ensure that the taskbar is hidden by it. A standard
WS_OVERLAPPEDWINDOW does not hide the task bar. */
style = WS_POPUP | WS_MAXIMIZE;
} else {
/* A standard toplevel window with borders and such. */
style = WS_OVERLAPPEDWINDOW;
}
}
window->win = CreateWindow("GLUT", "GLUT",
WS_CLIPSIBLINGS | WS_CLIPCHILDREN | style,
x, y, width, height, parent ? parent->win : __glutRoot,
NULL, GetModuleHandle(NULL), 0);
window->hdc = GetDC(window->win);
/* Must set the XHDC for fake glXChooseVisual & fake
glXCreateContext & fake XAllocColorCells. */
XHDC = window->hdc;
window->vis = __glutDetermineWindowVisual(&window->treatAsSingle,
&window->visAlloced, &fbc);
if (!window->vis) {
__glutFatalError(
"pixel format with necessary capabilities not found.");
}
if (!SetPixelFormat(window->hdc,
ChoosePixelFormat(window->hdc, window->vis),
window->vis)) {
__glutFatalError("SetPixelFormat failed during window create.");
}
__glutSetupColormap(window->vis, &window->colormap, &window->cmap);
/* Make sure subwindows get a windowStatus callback. */
if (parent) {
PostMessage(parent->win, WM_ACTIVATE, 0, 0);
}
window->renderDc = window->hdc;
#else
window->win = XCreateWindow(__glutDisplay,
parent == NULL ? __glutRoot : parent->win,
x, y, width, height, 0,
window->vis->depth, InputOutput, window->vis->visual,
attribMask, &wa);
#endif
window->renderWin = window->win;
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
if (fbc) {
window->ctx = __glut_glXCreateContextWithConfigSGIX(__glutDisplay, fbc,
GLX_RGBA_TYPE_SGIX, None, __glutTryDirect);
} else
#endif
#if defined(__OS2PM__)
// window->ctx = glXCreateContext(window->hpsBuffer, window->vis,
// None, __glutTryDirect);
#else
window->ctx = glXCreateContext(__glutDisplay, window->vis,
None, __glutTryDirect);
#endif
if (!window->ctx) {
__glutFatalError(
"failed to create OpenGL rendering context.");
}
window->renderCtx = window->ctx;
#if !defined(_WIN32) && !defined(__OS2PM__)
window->isDirect = glXIsDirect(__glutDisplay, window->ctx);
if (__glutForceDirect) {
if (!window->isDirect)
__glutFatalError("direct rendering not possible.");
}
#endif
window->parent = parent;
if (parent) {
window->siblings = parent->children;
parent->children = window;
} else {
window->siblings = NULL;
}
window->overlay = NULL;
window->children = NULL;
window->display = __glutDefaultDisplay;
window->reshape = __glutDefaultReshape;
window->mouse = NULL;
window->motion = NULL;
window->passive = NULL;
window->entry = NULL;
window->keyboard = NULL;
window->keyboardUp = NULL;
window->windowStatus = NULL;
window->visibility = NULL;
window->special = NULL;
window->specialUp = NULL;
window->buttonBox = NULL;
window->dials = NULL;
window->spaceMotion = NULL;
window->spaceRotate = NULL;
window->spaceButton = NULL;
window->tabletMotion = NULL;
window->tabletButton = NULL;
#ifdef _WIN32
window->joystick = NULL;
window->joyPollInterval = 0;
#endif
#if defined(__OS2PM__)
window->wm_command = NULL;
#endif
window->tabletPos[0] = -1;
window->tabletPos[1] = -1;
#if defined(__OS2PM__)
if(window->shownState == -1)
window->shownState = 0;
window->visState = window->shownState;
#else
window->shownState = 0;
window->visState = -1; /* not VisibilityUnobscured,
VisibilityPartiallyObscured, or
VisibilityFullyObscured */
#endif
window->entryState = -1; /* not EnterNotify or LeaveNotify */
window->desiredConfMask = 0;
window->buttonUses = 0;
window->cursor = GLUT_CURSOR_INHERIT;
/* Setup window to be mapped when glutMainLoop starts. */
window->workMask = GLUT_MAP_WORK;
#ifdef _WIN32
if (gameMode) {
/* When mapping a game mode window, just show
the window. We have already created the game
mode window with a maximize flag at creation
time. Doing a ShowWindow(window->win, SW_SHOWNORMAL)
would be wrong for a game mode window since it
would unmaximize the window. */
window->desiredMapState = GameModeState;
} else {
window->desiredMapState = NormalState;
}
#else
window->desiredMapState = NormalState;
#endif
window->prevWorkWin = __glutWindowWorkList;
__glutWindowWorkList = window;
/* Initially, no menus attached. */
for (i = 0; i < GLUT_MAX_MENUS; i++) {
window->menu[i] = 0;
}
/* Add this new window to the window list. */
__glutWindowList[winnum] = window;
/* Make the new window the current window. */
__glutSetWindow(window);
__glutDetermineMesaSwapHackSupport();
if (window->treatAsSingle) {
/* We do this because either the window really is single
buffered (in which case this is redundant, but harmless,
because this is the initial single-buffered context
state); or we are treating a double buffered window as a
single-buffered window because the system does not appear
to export any suitable single- buffered visuals (in which
the following are necessary). */
glDrawBuffer(GL_FRONT);
glReadBuffer(GL_FRONT);
}
return window;
}