archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/multimedia/opengl/server/generic/pixelfmt.c

3303 lines
98 KiB
Raw Permalink Blame History

/******************************Module*Header*******************************\
* Module Name: pixelfmt.c
*
* This contains the pixel format functions.
*
* Created: 15-Dec-1994 00:28:39
* Author: Gilman Wong [gilmanw] -- ported from gdi\gre\pixelfmt.cxx
*
* Copyright (c) 1994 Microsoft Corporation
\**************************************************************************/
#include "precomp.h"
#pragma hdrstop
//#define DBG_WINDOW
//#define DBG_REFCOUNTS
#ifdef _CLIENTSIDE_
// Need for glsbAttention declaration
#include "glsbcltu.h"
#include "glscreen.h"
#endif
#ifdef _MCD_
#include "mcd.h"
#endif
#define SAVE_ERROR_CODE(x) SetLastError((x))
// Number of generic pixel formats. There are 5 pixel depths (4,8,16,24,32).
// This is to convert BMF constants into # bits per pel
#define BMF_COUNT (BMF_32BPP+1)
ULONG gaulConvert[BMF_COUNT] =
{
0,
1,
4,
8,
16,
24,
32
};
#define MIN_GENERIC_PFD 1
#define MAX_GENERIC_PFD 36
LRESULT CALLBACK
wglWndProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam);
#define PALETTE_WATCHER_CLASS __TEXT("Palette Watcher")
static ATOM aPaletteWatcherClass = 0;
DWORD tidPaletteWatcherThread = 0;
ULONG ulPaletteWatcherCount = 0;
HANDLE hPaletteWatcherThread = 0;
HWND hwndPaletteWatcher = 0;
LONG lPaletteWatcherUsers = 0;
/******************************Public*Routine******************************\
* pwndNew
*
* Allocate a new GLGENwindow, initialize it (from input structure), and
* insert it into the global linked list.
*
* Returns:
* Pointer to structure if successful, NULL otherwise.
*
* History:
* 01-Nov-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
GLGENwindow * APIENTRY pwndNew(GLGENwindow *pwndInit)
{
GLGENwindow *pwndRet = (GLGENwindow *) NULL;
BOOL bDirectScreen = GLDIRECTSCREEN && pwndInit->gwid.hwnd;
LPDIRECTDRAWCLIPPER pddClip = (LPDIRECTDRAWCLIPPER) NULL;
// If using direct access, retrieve or create a clipper object to track
// vis rgn changes.
if (pwndInit->gwid.iType == GLWID_DDRAW)
{
HRESULT hr;
hr = pwndInit->gwid.pdds->lpVtbl->
GetClipper(pwndInit->gwid.pdds, &pddClip);
if (hr != DD_OK && hr != DDERR_NOCLIPPERATTACHED)
{
return NULL;
}
}
if ( !bDirectScreen ||
pwndInit->gwid.iType == GLWID_DDRAW ||
(GLSCREENINFO->pdd->lpVtbl->
CreateClipper(GLSCREENINFO->pdd, 0, &pddClip, NULL) == DD_OK &&
pddClip->lpVtbl->SetHWnd(pddClip, 0, pwndInit->gwid.hwnd) == DD_OK) )
{
pwndInit->pddClip = pddClip;
// Allocate a new GLGENwindow.
pwndRet = (GLGENwindow *)ALLOC(sizeof(GLGENwindow));
if (pwndRet)
{
// Initialize from input structure.
*pwndRet = *pwndInit;
// Initialize per-window semaphore.
__try
{
InitializeCriticalSection(&pwndRet->sem);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
FREE(pwndRet);
pwndRet = NULL;
}
if (pwndRet)
{
// Set initial usage count to one
pwndRet->lUsers = 1;
// Insert into linked list.
EnterCriticalSection(&gwndHeader.sem);
{
pwndRet->pNext = gwndHeader.pNext;
gwndHeader.pNext = pwndRet;
}
LeaveCriticalSection(&gwndHeader.sem);
}
}
}
else
{
WARNING("pwndNew: Clipper setup failed\n");
if (pddClip != NULL)
{
pddClip->lpVtbl->Release(pddClip);
}
}
#ifdef DBG_WINDOW
if (pwndRet != NULL)
{
DbgPrint("Alloc window %p, type %d, hdc %p, hwnd %p, pdds %p\n",
pwndRet, pwndRet->gwid.iType, pwndRet->gwid.hdc,
pwndRet->gwid.hwnd, pwndRet->gwid.pdds);
}
#endif
return pwndRet;
}
/******************************Public*Routine******************************\
*
* pwndUnsubclass
*
* Removes OpenGL's subclassing set when windows are created
*
* History:
* Mon May 20 14:05:23 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
void pwndUnsubclass(GLGENwindow *pwnd, BOOL bProcessExit)
{
WNDPROC wpCur;
// We only restore the original WNDPROC if the current WNDPROC
// is one of ours. This prevents us from stomping on the WNDPROC
// pointer if somebody else has changed it.
if ((pwnd->ulFlags & GLGENWIN_OTHERPROCESS) == 0)
{
wpCur = (WNDPROC)GetWindowLongPtr(pwnd->gwid.hwnd, GWLP_WNDPROC);
if (wpCur == wglWndProc)
{
SetWindowLongPtr(pwnd->gwid.hwnd, GWLP_WNDPROC,
(LONG_PTR) pwnd->pfnOldWndProc);
}
}
else
{
// Clean up the palette watcher window if this is the last user.
EnterCriticalSection(&gcsPaletteWatcher);
ASSERTOPENGL(lPaletteWatcherUsers > 0,
"lPaletteWatcherUsers too low\n");
if (--lPaletteWatcherUsers == 0)
{
if( PostMessage(hwndPaletteWatcher, WM_CLOSE, 0, 0) == FALSE)
{
DbgPrint( "PostMessage to hwnd: %08x failed with error: %08x\n",
hwndPaletteWatcher, GetLastError() );
// Check if the thread is still alive
if( WaitForSingleObject( hPaletteWatcherThread, 100 ) !=
WAIT_OBJECT_0 )
{
// This means that the thread is still alive and
// somehow the window is invalid.
// Kill this thread or else GL will keep waiting.
TerminateThread( hPaletteWatcherThread, 0 );
}
// Should be safe to do. If the thread is alive, it
// was killed above else, someone else killed it
tidPaletteWatcherThread = 0;
}
CloseHandle( hPaletteWatcherThread );
// We don't want to zero the palette watcher's thread ID
// at process exit because we use it to wait for the
// thread to die.
if (!bProcessExit)
{
tidPaletteWatcherThread = 0;
}
}
LeaveCriticalSection(&gcsPaletteWatcher);
}
}
/******************************Public*Routine******************************\
* pwndFree
*
* Frees the specified GLGENwindow.
*
* Returns:
* NULL if successful, pointer to structure otherwise
*
* History:
* 07-Nov-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
GLGENwindow * APIENTRY pwndFree(GLGENwindow *pwndVictim, BOOL bProcessExit)
{
BOOL bDirectScreen = GLDIRECTSCREEN && pwndVictim->gwid.hwnd;
#ifdef DBG_WINDOW
DbgPrint("Free window %p\n", pwndVictim);
#endif
// Check for a stray screen lock and release if necessary.
if (pwndVictim->ulFlags & GLGENWIN_DIRECTSCREEN)
EndDirectScreenAccess(pwndVictim);
// Free clipper object.
if (bDirectScreen)
{
pwndVictim->pddClip->lpVtbl->Release(pwndVictim->pddClip);
}
// Cleanup visible region caches if they exist.
if ( pwndVictim->prgndat )
FREE(pwndVictim->prgndat);
if ( pwndVictim->pscandat )
FREE(pwndVictim->pscandat);
// Restore original WNDPROC in window.
if (pwndVictim->gwid.hwnd != NULL)
pwndUnsubclass(pwndVictim, bProcessExit);
// Cleanup GLGENlayers.
if (pwndVictim->plyr)
{
int i;
for (i = 0; i < 15; i++)
{
if (pwndVictim->plyr->overlayInfo[i])
FREE(pwndVictim->plyr->overlayInfo[i]);
if (pwndVictim->plyr->underlayInfo[i])
FREE(pwndVictim->plyr->underlayInfo[i]);
}
FREE(pwndVictim->plyr);
}
// Notify MCD that this window has gone away
if (pwndVictim->dwMcdWindow != 0)
{
GenMcdDestroyWindow(pwndVictim);
}
// Delete victim.
DeleteCriticalSection(&pwndVictim->sem);
FREE(pwndVictim);
return NULL;
}
/******************************Public*Routine******************************\
*
* pwndCleanup
*
* Does all cleanup necessary for window destruction
*
* History:
* Mon Mar 18 17:30:49 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
void APIENTRY pwndCleanup(GLGENwindow *pwndVictim)
{
GLGENwindow *pwnd, *pwndPrev;
#if DBG
ULONG ulLoops;
#endif
#ifdef DBG_WINDOW
DbgPrint("Clean window %p\n", pwndVictim);
#endif
EnterCriticalSection(&gwndHeader.sem);
// Search for victim. Maintain a prev pointer so we can do
// removal from linked list.
for (
pwndPrev = &gwndHeader, pwnd = pwndPrev->pNext;
pwnd != &gwndHeader;
pwndPrev = pwnd, pwnd = pwndPrev->pNext
)
{
if (pwnd == pwndVictim)
break;
}
// If victim was found, take it out.
if (pwnd == pwndVictim)
{
// Excise victim from linked list.
pwndPrev->pNext = pwnd->pNext;
}
LeaveCriticalSection(&gwndHeader.sem);
if (pwnd == NULL)
{
WARNING("pwndFree: pwndVictim not found in list\n");
return;
}
// If victim was found, it's out of the list so nobody
// new can get access to it.
// Wait for all current accessors to go away before cleaning up
// the window
#if DBG
ulLoops = 0;
#endif
for (;;)
{
if (pwndVictim->lUsers == 1)
{
break;
}
#if DBG
if (++ulLoops == 1000)
{
DbgPrint("Spinning on window %p\n", pwndVictim);
#ifdef DBG_WINDOW
DebugBreak();
#endif
}
#endif
// Wait on the critical section as a delay
// Acquiring it doesn't guarantee that we're the last
// accessor, but it does kill time in the case where
// another accessor is already holding it
EnterCriticalSection(&pwndVictim->sem);
LeaveCriticalSection(&pwndVictim->sem);
// Allow other threads time to run so we don't starve
// anybody while we're waiting
Sleep(0);
}
if (pwndVictim->buffers != NULL)
{
__glGenFreeBuffers(pwndVictim->buffers);
wglCleanupWindow(pwndVictim);
}
if (pwndFree(pwndVictim, FALSE))
WARNING("window deletion failed\n");
}
/******************************Public*Routine******************************\
* vCleanupWnd
*
* Removes and deletes all GLGENwindow structures from the linked list.
* Must *ONLY* be called from process detach (GLUnInitializeProcess).
*
* History:
* 25-Jul-1995 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
VOID APIENTRY vCleanupWnd()
{
GLGENwindow *pwndNext;
EnterCriticalSection(&gwndHeader.sem);
while ( gwndHeader.pNext != &gwndHeader )
{
pwndNext = gwndHeader.pNext->pNext;
pwndFree(gwndHeader.pNext, TRUE);
gwndHeader.pNext = pwndNext;
}
LeaveCriticalSection(&gwndHeader.sem);
// Wait for the palette watcher thread to die. This ensures
// that the palette watcher critical section can be deleted
// safely in process detach.
// We don't use a critical section at this point because of
// the special critsec rules during DLL detach processing.
while (tidPaletteWatcherThread != 0)
{
Sleep(50);
}
// Give the palette watcher thread some time to exit after
// clearing the thread ID.
Sleep(50);
}
/******************************Public*Routine******************************\
* pwndGetFromHWND
*
* Finds the corresponding GLGENwindow for the given window handle.
*
* Returns:
* Pointer to GLGENwindow if sucessful; NULL otherwise.
*
* History:
* 19-Oct-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
GLGENwindow * APIENTRY pwndGetFromHWND(HWND hwnd)
{
GLGENwindow *pwndRet = (GLGENwindow *) NULL;
GLGENwindow *pwnd = (GLGENwindow *) NULL;
EnterCriticalSection(&gwndHeader.sem);
{
for (pwnd = gwndHeader.pNext; pwnd != &gwndHeader; pwnd = pwnd->pNext)
if (pwnd->gwid.hwnd == hwnd)
{
pwndRet = pwnd;
InterlockedIncrement(&pwnd->lUsers);
break;
}
}
LeaveCriticalSection(&gwndHeader.sem);
#ifdef DBG_REFCOUNTS
if (pwndRet != 0)
{
DbgPrint("GetHWND %p to %d\n", pwndRet, pwndRet->lUsers);
}
#endif
return pwndRet;
}
/******************************Public*Routine******************************\
* pwndGetFromMemDC
*
* Finds the corresponding GLGENwindow for the given mem DC handle.
*
* Returns:
* Pointer to GLGENwindow if sucessful; NULL otherwise.
*
* History:
* 21-Jan-1995 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
GLGENwindow * APIENTRY pwndGetFromMemDC(HDC hdcMem)
{
GLGENwindow *pwndRet = (GLGENwindow *) NULL;
GLGENwindow *pwnd = (GLGENwindow *) NULL;
EnterCriticalSection(&gwndHeader.sem);
{
for (pwnd = gwndHeader.pNext; pwnd != &gwndHeader; pwnd = pwnd->pNext)
{
// If the pwnd has an HWND then the DC used at its
// creation was associated with a window. If we're
// in this routine, though, that means hdcMem is
// not associated with a window, so there's been
// a reuse of the HDC handle and even though
// we match DCs we can't return the pwnd.
if (pwnd->gwid.hdc == hdcMem && pwnd->gwid.hwnd == NULL)
{
pwndRet = pwnd;
InterlockedIncrement(&pwndRet->lUsers);
break;
}
}
}
LeaveCriticalSection(&gwndHeader.sem);
#ifdef DBG_REFCOUNTS
if (pwndRet != 0)
{
DbgPrint("GetDC %p to %d\n", pwndRet, pwndRet->lUsers);
}
#endif
return pwndRet;
}
/******************************Public*Routine******************************\
*
* pwndGetFromDdraw
*
* Looks up a window by its DirectDraw surface
*
* History:
* Wed Aug 28 18:15:40 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
GLGENwindow *pwndGetFromDdraw(LPDIRECTDRAWSURFACE pdds)
{
GLGENwindow *pwndRet = (GLGENwindow *) NULL;
GLGENwindow *pwnd = (GLGENwindow *) NULL;
EnterCriticalSection(&gwndHeader.sem);
{
for (pwnd = gwndHeader.pNext; pwnd != &gwndHeader; pwnd = pwnd->pNext)
if (pwnd->gwid.pdds == pdds)
{
pwndRet = pwnd;
InterlockedIncrement(&pwndRet->lUsers);
break;
}
}
LeaveCriticalSection(&gwndHeader.sem);
#ifdef DBG_REFCOUNTS
if (pwndRet != 0)
{
DbgPrint("GetDD %p to %d\n", pwndRet, pwndRet->lUsers);
}
#endif
return pwndRet;
}
/******************************Public*Routine******************************\
* pwndGetFromID
*
* Finds the corresponding GLGENwindow for the given window ID.
*
* Returns:
* Pointer to GLGENwindow if sucessful; NULL otherwise.
*
* History:
* 19-Oct-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
GLGENwindow * APIENTRY pwndGetFromID(GLWINDOWID *pgwid)
{
GLGENwindow *pwndRet = (GLGENwindow *) NULL;
switch (pgwid->iType)
{
case GLWID_HWND:
pwndRet = pwndGetFromHWND(pgwid->hwnd);
break;
case GLWID_HDC:
pwndRet = pwndGetFromMemDC(pgwid->hdc);
break;
case GLWID_DDRAW:
pwndRet = pwndGetFromDdraw(pgwid->pdds);
break;
}
return pwndRet;
}
/******************************Public*Routine******************************\
*
* pwndRelease
*
* Decrements the user count of a window
*
* History:
* Mon Mar 18 19:35:28 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
#if DBG
void APIENTRY pwndRelease(GLGENwindow *pwnd)
{
ASSERTOPENGL(pwnd->lUsers > 0, "Decrement lUsers below zero\n");
InterlockedDecrement(&pwnd->lUsers);
#ifdef DBG_REFCOUNTS
DbgPrint("Release %p to %d\n", pwnd, pwnd->lUsers);
#endif
}
#endif
/******************************Public*Routine******************************\
*
* pwndUnlock
*
* Releases an owner of a window
*
* History:
* Mon Mar 18 17:25:56 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
void APIENTRY pwndUnlock(GLGENwindow *pwnd, __GLGENcontext *gengc)
{
ASSERTOPENGL(pwnd != NULL, "Unlocking NULL window\n");
LEAVE_WINCRIT_GC(pwnd, gengc);
pwndRelease(pwnd);
}
/******************************Public*Routine******************************\
*
* ENTER_WINCRIT_GC
* LEAVE_WINCRIT_GC
*
* Window lock tracking routines. The pwnd and gengc are validated
* and updated to reflect current locks.
*
* If the gengc is non-NULL then recursion is not allowed. This is
* to prevent difficulties with maintaining gengc->pwndLocked correctly
* during recursion. Recursing with gengc == NULL is not a problem.
*
* No ASSERTOPENGL usage so these can be enabled on free builds.
*
* History:
* Wed Jul 02 12:57:26 1997 -by- Drew Bliss [drewb]
*
\**************************************************************************/
void ENTER_WINCRIT_GC(GLGENwindow *pwnd, __GLGENcontext *gengc)
{
EnterCriticalSection(&pwnd->sem);
if (pwnd->owningThread == 0)
{
#if DBG || defined(TRACK_WINCRIT)
if (pwnd->lockRecursion != 0)
{
DbgPrint("Unowned window 0x%08lX has recursion count %d\n",
pwnd, pwnd->lockRecursion);
DebugBreak();
}
if (pwnd->gengc != NULL)
{
DbgPrint("Unowned window 0x%08lX has gengc 0x%08lX\n",
pwnd, pwnd->gengc);
DebugBreak();
}
if (gengc != NULL && gengc->pwndLocked != NULL)
{
DbgPrint("gengc 0x%08lX has pwnd 0x%08lX while locking 0x%08lX\n",
gengc, gengc->pwndLocked, pwnd);
DebugBreak();
}
#endif
pwnd->owningThread = GetCurrentThreadId();
if (gengc != NULL)
{
gengc->pwndLocked = pwnd;
pwnd->gengc = gengc;
}
}
else
{
// Make sure this thread is really the one holding the lock.
ASSERT_WINCRIT(pwnd);
#if DBG || defined(TRACK_WINCRIT)
// Recursion is only allowed with gengc == NULL.
if (gengc != NULL)
{
DbgPrint("Window 0x%08lX recursing with gengc 0x%08lX\n",
pwnd, gengc);
DebugBreak();
}
#endif
}
pwnd->lockRecursion++;
}
void LEAVE_WINCRIT_GC(GLGENwindow *pwnd, __GLGENcontext *gengc)
{
ASSERT_WINCRIT(pwnd);
#if 0
// Currently turned off because of difference in RTL_CRITICAL_SECTION
// RecursionCount between x86 and Alpha
#if !defined(_WIN95_) && (DBG || defined(TRACK_WINCRIT))
// Check and make sure that our tracking information is following
// what the system thinks.
if (pwnd->sem.OwningThread != (HANDLE)pwnd->owningThread ||
(DWORD)pwnd->sem.RecursionCount != pwnd->lockRecursion)
{
DbgPrint("pwnd 0x%08lX critsec information mismatch\n", pwnd);
DebugBreak();
}
#endif
#endif
#if DBG || defined(TRACK_WINCRIT)
if (gengc != NULL)
{
if (pwnd->gengc != gengc || gengc->pwndLocked != pwnd)
{
DbgPrint("pwnd 0x%08lX:%08lX mismatch with gengc 0x%08lX:%08lX\n",
pwnd, pwnd->gengc, gengc, gengc->pwndLocked);
DebugBreak();
}
if (pwnd->lockRecursion != 1)
{
DbgPrint("gengc 0x%08lX leaving window 0x%08lX with "
"recursion count of %d\n",
gengc, pwnd, pwnd->lockRecursion);
DebugBreak();
}
}
#endif
if (--pwnd->lockRecursion == 0)
{
if (gengc != NULL)
{
gengc->pwndLocked = NULL;
}
pwnd->gengc = NULL;
pwnd->owningThread = 0;
}
LeaveCriticalSection(&pwnd->sem);
}
/******************************Public*Routine******************************\
*
* wglValidateWindows
*
* Walks the window list and prunes away any DC-based windows with
* invalid DCs. This is necessary because, unlike window-based
* windows, we usually aren't notified when a memory DC goes away
* so if it has a window it just hangs around
*
* History:
* Thu May 02 17:44:23 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
void APIENTRY wglValidateWindows(void)
{
GLGENwindow *pwnd, *pwndNext;
BOOL bValid;
EnterCriticalSection(&gwndHeader.sem);
for (pwnd = gwndHeader.pNext; pwnd != &gwndHeader; pwnd = pwndNext)
{
pwndNext = pwnd->pNext;
switch(pwnd->gwid.iType)
{
case GLWID_HDC:
bValid = GetObjectType(pwnd->gwid.hdc) != 0;
break;
case GLWID_DDRAW:
// Better validation? Not really necessary since properly
// behaved apps will have the genwin cleaned up on
// context destruction.
bValid = !IsBadReadPtr(pwnd->gwid.pdds, sizeof(void *)) &&
*(void **)pwnd->gwid.pdds == pwnd->pvSurfaceVtbl;
break;
default:
// No validation for HWNDs necessary
bValid = TRUE;
break;
}
if (!bValid)
{
// Increment so users count is one
InterlockedIncrement(&pwnd->lUsers);
pwndCleanup(pwnd);
}
}
LeaveCriticalSection(&gwndHeader.sem);
}
/******************************Public*Routine******************************\
* plyriGet
*
* Returns the GLGENlayerInfo for the specified layer plane from the pwnd.
* If it doesn't yet exist, the GLGENlayer and/or GLGENlayerInfo structure(s)
* are allocated.
*
* Returns:
* A non-NULL pointer if successful; NULL otherwise.
*
* History:
* 16-May-1996 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
GLGENlayerInfo * APIENTRY plyriGet(GLGENwindow *pwnd, HDC hdc, int iLayer)
{
GLGENlayerInfo *plyriRet = (GLGENlayerInfo * ) NULL;
GLGENlayerInfo **pplyri;
ASSERTOPENGL(pwnd, "plyriGet: bad pwnd\n");
// Allocate plyr if needed.
if (!pwnd->plyr)
{
pwnd->plyr = (GLGENlayers *) ALLOCZ(sizeof(GLGENlayers));
if (!pwnd->plyr)
{
WARNING("plyriGet: alloc failed (GLGENlayers)\n");
goto plyriGet_exit;
}
}
// Get info for the specified layer (positive values are overlay planes,
// negative values are underlay planes).
if (iLayer > 0)
pplyri = &pwnd->plyr->overlayInfo[iLayer - 1];
else if (iLayer < 1)
pplyri = &pwnd->plyr->underlayInfo[(-iLayer) - 1];
else
{
WARNING("plyriGet: no layer plane info for main plane!\n");
goto plyriGet_exit;
}
// Allocate plyri if needed.
if (!(*pplyri))
{
LAYERPLANEDESCRIPTOR lpd;
if (!wglDescribeLayerPlane(hdc, pwnd->ipfd, iLayer, sizeof(lpd), &lpd))
{
WARNING("plyriGet: wglDescribeLayerPlane failed\n");
goto plyriGet_exit;
}
*pplyri = (GLGENlayerInfo *)
ALLOC((sizeof(COLORREF) * (1 << lpd.cColorBits))
+ sizeof(GLGENlayerInfo));
if (*pplyri)
{
int i;
// Initialize the new GLGENlayerInfo.
// Note that the palette is initialized with all white colors.
(*pplyri)->cPalEntries = 1 << lpd.cColorBits;
for (i = 0; i < (*pplyri)->cPalEntries; i++)
(*pplyri)->pPalEntries[i] = RGB(255, 255, 255);
}
else
{
WARNING("plyriGet: alloc failed (GLGENlayerInfo)\n");
goto plyriGet_exit;
}
}
// Success.
plyriRet = *pplyri;
plyriGet_exit:
return plyriRet;
}
/******************************Public*Routine******************************\
* GetScreenRect
*
* Get the screen rectangle by accessing the virtual screen metrics.
*
* If the system does not understand multimon, such as old Win95 or NT,
* just use the device caps. This code technically isn't necessary but
* it's useful.
*
\**************************************************************************/
static void GetScreenRect( HDC hdc, LPRECTL pRect )
{
// If SM_CMONITORS is not understood the system returns zero,
// so this if test works for both old and new systems.
if (GetSystemMetrics(SM_CMONITORS) > 1)
{
pRect->left = GetSystemMetrics( SM_XVIRTUALSCREEN );
pRect->top = GetSystemMetrics( SM_YVIRTUALSCREEN );
pRect->right = pRect->left + GetSystemMetrics( SM_CXVIRTUALSCREEN );
pRect->bottom = pRect->top + GetSystemMetrics( SM_CYVIRTUALSCREEN );
}
else
{
pRect->left = 0;
pRect->top = 0;
pRect->right = GetDeviceCaps(hdc, HORZRES);
pRect->bottom = GetDeviceCaps(hdc, VERTRES);
}
}
/******************************Public*Routine******************************\
* bClipToScreen(prclDst, prclSrc)
*
* Clip source rectangle to screen bounds and store in destination rectangle.
*
* Returns:
* TRUE if resultant prclDst == prclSrc; FALSE otherwise.
*
\**************************************************************************/
BOOL bClipToScreen(RECTL *prclDst, RECTL *prclSrc)
{
BOOL bRet;
HDC hdc;
if (hdc = GetDC(NULL))
{
RECTL rclScreen;
GetScreenRect( hdc, &rclScreen );
prclDst->left = max(prclSrc->left , rclScreen.left );
prclDst->top = max(prclSrc->top , rclScreen.top );
prclDst->right = min(prclSrc->right , rclScreen.right );
prclDst->bottom = min(prclSrc->bottom, rclScreen.bottom);
if ((prclDst->left >= prclDst->right) ||
(prclDst->top >= prclDst->bottom))
{
prclDst->left = 0;
prclDst->top = 0;
prclDst->right = 0;
prclDst->bottom = 0;
}
ReleaseDC(NULL, hdc);
}
else
{
prclDst->left = 0;
prclDst->top = 0;
prclDst->right = 0;
prclDst->bottom = 0;
}
if ((prclDst->left == prclSrc->left ) &&
(prclDst->top == prclSrc->top ) &&
(prclDst->right == prclSrc->right ) &&
(prclDst->bottom == prclSrc->bottom))
bRet = TRUE;
else
bRet = FALSE;
return bRet;
}
/******************************Public*Routine******************************\
*
* PaletteWatcherProc
*
* Window proc for the palette watcher
*
* History:
* Mon Oct 14 15:29:10 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
LRESULT WINAPI PaletteWatcherProc(HWND hwnd, UINT uiMsg,
WPARAM wpm, LPARAM lpm)
{
switch(uiMsg)
{
case WM_PALETTECHANGED:
InterlockedIncrement((LONG *)&ulPaletteWatcherCount);
return 0;
default:
return DefWindowProc(hwnd, uiMsg, wpm, lpm);
}
}
/******************************Public*Routine******************************\
*
* PaletteWatcher
*
* Thread routine for the palette change monitor. Creates a hidden
* top level window and looks for WM_PALETTECHANGED.
*
* History:
* Mon Oct 14 15:16:02 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
DWORD WINAPI PaletteWatcher(LPVOID pvArg)
{
HWND hwnd;
hwnd = CreateWindow(PALETTE_WATCHER_CLASS,
PALETTE_WATCHER_CLASS,
WS_OVERLAPPED,
0, 0, 1, 1,
NULL,
NULL,
(HINSTANCE)GetModuleHandle(NULL),
NULL);
if (hwnd != NULL)
{
HDC hdc;
HPALETTE hpal;
// Select a palette into the window DC. This is necessary
// to get around an optimization introduced into NT5 where
// WM_PALETTECHANGED is only sent to windows that have selected
// a palette.
hpal = NULL;
hdc = GetDC(hwnd);
if (hdc != NULL)
{
hpal = SelectPalette(hdc, GetStockObject(DEFAULT_PALETTE), FALSE);
ReleaseDC(hwnd, hdc);
}
if (hpal == NULL)
{
goto EH_Exit;
}
hwndPaletteWatcher = hwnd;
for (;;)
{
MSG msg;
if (GetMessage(&msg, hwnd, 0, 0) > 0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
break;
}
}
EH_Exit:
DestroyWindow(hwnd);
hwndPaletteWatcher = 0;
}
EnterCriticalSection(&gcsPaletteWatcher);
// Some kind of problem occurred or this thread is dying.
// Indicate that this thread is going away and that a
// new watcher needs to be created.
if (tidPaletteWatcherThread == GetCurrentThreadId())
{
tidPaletteWatcherThread = 0;
}
LeaveCriticalSection(&gcsPaletteWatcher);
return 0;
}
/******************************Public*Routine******************************\
*
* StartPaletteWatcher
*
* Spins up a thread to watch for palette change events
*
* History:
* Mon Oct 14 15:11:35 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
BOOL StartPaletteWatcher(void)
{
BOOL bRet;
EnterCriticalSection(&gcsPaletteWatcher);
bRet = FALSE;
if (tidPaletteWatcherThread == 0)
{
HANDLE h;
if (aPaletteWatcherClass == 0)
{
WNDCLASS wc;
wc.style = 0;
wc.lpfnWndProc = PaletteWatcherProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = (HINSTANCE)GetModuleHandle(NULL);
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = PALETTE_WATCHER_CLASS;
aPaletteWatcherClass = RegisterClass(&wc);
}
if (aPaletteWatcherClass != 0)
{
h = CreateThread(NULL, 4096, PaletteWatcher,
NULL, 0, &tidPaletteWatcherThread);
if (h != NULL)
{
hPaletteWatcherThread = h;
bRet = TRUE;
}
}
}
else
{
bRet = TRUE;
}
if (bRet)
{
lPaletteWatcherUsers++;
}
LeaveCriticalSection(&gcsPaletteWatcher);
// Make sure that the Palette watcher window is created.
// Dont need to be in the CritSec for this.
while( (hwndPaletteWatcher == 0) &&
(tidPaletteWatcherThread != 0) ) Sleep( 100 );
return bRet;
}
/******************************Public*Routine******************************\
* wglWndProc
*
* Handle window events for keeping GLGENwindows current
*
* History:
* 19-Oct-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
LRESULT CALLBACK
wglWndProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
GLGENwindow *pwnd;
LRESULT lRet = 0;
WORD width, height;
__GLGENcontext *gengc;
pwnd = pwndGetFromHWND(hwnd);
if (pwnd)
{
__GLGENbuffers *buffers = (__GLGENbuffers *) NULL;
// Cache old WNDPROC because we may delete pwnd
WNDPROC pfnWndProc = pwnd->pfnOldWndProc;
// If WM_NCDESTROY, do OpenGL housekeeping after
// calling original WndProc.
// NOTE - We shouldn't really need this special case.
// It's present in order to allow apps to do things like
// wglDeleteContext in NCDESTROY which wouldn't work if
// we cleaned up the window before we passed on the message
// This used to be done in WM_DESTROY where apps do work,
// but now that it's on NCDESTROY it's much less likely that
// an app is doing anything. We preserved the old behavior
// for safety, though.
if (uiMsg == WM_NCDESTROY)
{
// Subclassing is supposed to be removed during NCDESTROY
// processing and order is important. Remove our
// subclassing before passing on the message.
pwndUnsubclass(pwnd, FALSE);
if (pfnWndProc)
{
lRet = CallWindowProc(pfnWndProc, hwnd,
uiMsg, wParam, lParam);
}
}
// OpenGL housekeeping in response to windowing system messages.
switch (uiMsg)
{
case WM_SIZE:
width = LOWORD(lParam);
height = HIWORD(lParam);
gengc = (__GLGENcontext *)GLTEB_SRVCONTEXT();
// Use the non-gc enter to allow recursion.
ENTER_WINCRIT(pwnd);
{
POINT pt;
// Convert client coordinates to screen coordinates
// as genwin information is always in screen coordinates.
// The given lParam information may be parent-relative
// for child windows so it can't be used directly.
pt.x = 0;
pt.y = 0;
ClientToScreen(hwnd, &pt);
pwnd->rclClient.left = pt.x;
pwnd->rclClient.right = pt.x + width;
pwnd->rclClient.top = pt.y;
pwnd->rclClient.bottom = pt.y + height;
#if 0
DbgPrint("size %d,%d - %d,%d\n",
pwnd->rclClient.left,
pwnd->rclClient.top,
pwnd->rclClient.right,
pwnd->rclClient.bottom);
#endif
// At least clip to screen.
if (bClipToScreen(&pwnd->rclBounds,
&pwnd->rclClient))
pwnd->clipComplexity = CLC_TRIVIAL;
else
pwnd->clipComplexity = CLC_RECT;
buffers = pwnd->buffers;
if (buffers)
{
buffers->WndUniq++;
buffers->WndSizeUniq++;
// Don't let it hit -1. -1 is special and is used by
// MakeCurrent to signal that an update is required
if (buffers->WndUniq == -1)
buffers->WndUniq = 0;
if (buffers->WndSizeUniq == -1)
buffers->WndSizeUniq = 0;
if ((gengc != NULL) && (pwnd == gengc->pwndLocked))
UpdateWindowInfo(gengc);
}
}
LEAVE_WINCRIT(pwnd);
break;
case WM_MOVE:
gengc = (__GLGENcontext *)GLTEB_SRVCONTEXT();
// Use the non-gc enter to allow recursion.
ENTER_WINCRIT(pwnd);
{
POINT pt;
// Convert client coordinates to screen coordinates
// as genwin information is always in screen coordinates.
// The given lParam information may be parent-relative
// for child windows so it can't be used directly.
pt.x = 0;
pt.y = 0;
ClientToScreen(hwnd, &pt);
width = (WORD) (pwnd->rclClient.right -
pwnd->rclClient.left);
height = (WORD) (pwnd->rclClient.bottom -
pwnd->rclClient.top);
ASSERTOPENGL(
(pwnd->rclClient.right -
pwnd->rclClient.left) <= 0x0FFFF &&
(pwnd->rclClient.bottom -
pwnd->rclClient.top) <= 0x0FFFF,
"wglWndProc(): WM_MOVE - width/height overflow\n"
);
pwnd->rclClient.left = pt.x;
pwnd->rclClient.right = pt.x + width;
pwnd->rclClient.top = pt.y;
pwnd->rclClient.bottom = pt.y + height;
#if 0
DbgPrint("move %d,%d - %d,%d\n",
pwnd->rclClient.left,
pwnd->rclClient.top,
pwnd->rclClient.right,
pwnd->rclClient.bottom);
#endif
// At least clip to screen.
if (bClipToScreen(&pwnd->rclBounds,
&pwnd->rclClient))
pwnd->clipComplexity = CLC_TRIVIAL;
else
pwnd->clipComplexity = CLC_RECT;
buffers = pwnd->buffers;
if (buffers)
{
buffers->WndUniq++;
// Don't let it hit -1. -1 is special and is used by
// MakeCurrent to signal that an update is required
if (buffers->WndUniq == -1)
buffers->WndUniq = 0;
if ((gengc != NULL) && (pwnd == gengc->pwndLocked))
UpdateWindowInfo(gengc);
}
}
LEAVE_WINCRIT(pwnd);
break;
case WM_PALETTECHANGED:
gengc = (__GLGENcontext *)GLTEB_SRVCONTEXT();
// Use the non-gc enter to allow recursion.
ENTER_WINCRIT(pwnd);
{
pwnd->ulPaletteUniq++;
if ((gengc != NULL) && (pwnd == gengc->pwndLocked))
HandlePaletteChanges(gengc, pwnd);
}
LEAVE_WINCRIT(pwnd);
break;
case WM_NCDESTROY:
pwndCleanup(pwnd);
// WM_NCDESTROY (and WM_DESTROY) are sent after the window has
// been removed from the screen. The window area is invalid
// but there is no API that allows us to dertermine that. This
// allows multithreaded drawing to draw on the screen area
// formerly occupied by the window. On Win95, DirectDraw does
// not force a repaint of the system when a window is destroyed.
// Therefore, if we are running multiple threads on Win95,
// we force a repaint of the desktop. Note that multithreaded
// does not mean that we are doing multithreaded drawing, but
// its a reasonable approximation.
if (WIN95_PLATFORM && (lThreadsAttached > 1))
{
InvalidateRect(NULL, NULL, FALSE);
}
return lRet;
default:
break;
}
// If !WM_NCDESTROY, do OpenGL housekeeping before calling original
// WndProc.
ASSERTOPENGL(uiMsg != WM_NCDESTROY,
"WM_NCDESTROY processing didn't terminate\n");
pwndRelease(pwnd);
if (pfnWndProc)
lRet = CallWindowProc(pfnWndProc, hwnd,
uiMsg, wParam, lParam);
}
return lRet;
}
/******************************Public*Routine******************************\
*
* CreatePwnd
*
* Creates a window for the given surface
*
* History:
* Thu Aug 29 10:33:59 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
GLGENwindow * APIENTRY CreatePwnd(GLWINDOWID *pgwid, int ipfd, int ipfdDevMax,
DWORD dwObjectType, RECTL *prcl, BOOL *pbNew)
{
GLGENwindow *pwnd;
GLGENwindow wndInit;
pwnd = pwndGetFromID(pgwid);
if ( !pwnd )
{
memset(&wndInit, 0, sizeof(wndInit));
wndInit.gwid = *pgwid;
wndInit.ipfd = ipfd;
wndInit.ipfdDevMax = ipfdDevMax;
//!!!client driver
//!!!dbug -- Move SetWindowLong call to pwndNew?!? Maybe move
//!!!dbug everything from this if.. clause to pwndNew?!?
if ( wndInit.gwid.hwnd )
{
DWORD dwPid;
if (GetWindowThreadProcessId(wndInit.gwid.hwnd,
&dwPid) == 0xffffffff)
{
return NULL;
}
if (dwPid == GetCurrentProcessId())
{
wndInit.pfnOldWndProc =
(WNDPROC) SetWindowLongPtr(wndInit.gwid.hwnd,
GWLP_WNDPROC, (LONG_PTR) wglWndProc);
}
else
{
wndInit.ulFlags |= GLGENWIN_OTHERPROCESS;
// Start a thread to watch for palette changes
if (!StartPaletteWatcher())
{
return NULL;
}
}
// Get *SCREEN* coordinates of client rectangle.
GetClientRect(wndInit.gwid.hwnd, (LPRECT) &wndInit.rclClient);
ClientToScreen(wndInit.gwid.hwnd, (LPPOINT) &wndInit.rclClient);
wndInit.rclClient.right += wndInit.rclClient.left;
wndInit.rclClient.bottom += wndInit.rclClient.top;
}
else if (dwObjectType == OBJ_DC)
{
// A direct DC without a window is treated like a DFB
GetScreenRect( pgwid->hdc, &wndInit.rclClient );
}
else if (dwObjectType == OBJ_MEMDC)
{
DIBSECTION bmi;
// Get bitmap dimensions.
if ( !GetObject(GetCurrentObject(pgwid->hdc, OBJ_BITMAP),
sizeof(DIBSECTION), (LPVOID) &bmi) )
{
WARNING("wglSetPixelFormat(): GetObject failed\n");
return NULL;
}
wndInit.rclClient.left = 0;
wndInit.rclClient.top = 0;
wndInit.rclClient.right = bmi.dsBm.bmWidth;
wndInit.rclClient.bottom = abs(bmi.dsBm.bmHeight);
}
else if (dwObjectType == OBJ_DDRAW)
{
// DirectDraw surface, use passed in rectangle
ASSERTOPENGL(prcl != NULL, "NULL rect for DDraw surface\n");
wndInit.rclClient = *prcl;
// Record the surface vtbl pointer for later validation
wndInit.pvSurfaceVtbl = *(void **)pgwid->pdds;
}
else
{
ASSERTOPENGL(dwObjectType == OBJ_ENHMETADC,
"Bad dwType in SetPixelFormat\n");
// Initialize metafile DC's to have no size so all output
// is clipped. This is good because there's no surface
// to draw on
wndInit.rclClient.left = 0;
wndInit.rclClient.top = 0;
wndInit.rclClient.right = 0;
wndInit.rclClient.bottom = 0;
}
if (wndInit.gwid.hwnd)
{
// To be safe, at least clip bounds to screen.
if (bClipToScreen(&wndInit.rclBounds,
&wndInit.rclClient))
wndInit.clipComplexity = CLC_TRIVIAL;
else
wndInit.clipComplexity = CLC_RECT;
}
else
{
// Make bounds the same as client.
wndInit.rclBounds = wndInit.rclClient;
wndInit.clipComplexity = CLC_TRIVIAL;
}
pwnd = pwndNew(&wndInit);
if (pwnd == NULL)
{
WARNING("wglSetPixelFormat: Unable to allocate new window\n");
if ( wndInit.gwid.hwnd )
{
pwndUnsubclass(&wndInit, FALSE);
}
}
*pbNew = TRUE;
}
else
{
// If the given pixel format is the same as the previous one, return
// success. Otherwise, as the pixel format can be set only once,
// return error.
if ( pwnd->ipfd != ipfd )
{
WARNING("wglSetPixelFormat: Attempt to set pixel format twice\n");
SAVE_ERROR_CODE(ERROR_INVALID_PIXEL_FORMAT);
pwndRelease(pwnd);
pwnd = NULL;
}
*pbNew = FALSE;
}
return pwnd;
}
/******************************Public*Routine******************************\
* wglGetPixelFormat
*
* Get the pixel format for the window or surface associated with the given
* DC.
*
* Returns:
* 0 if error or no pixel format was previously set in the window or
* surface; current pixel format index otherwise
*
* History:
* 19-Oct-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
int WINAPI wglGetPixelFormat(HDC hdc)
{
GLGENwindow *pwnd;
int iRet = 0;
GLWINDOWID gwid;
WindowIdFromHdc(hdc, &gwid);
pwnd = pwndGetFromID(&gwid);
if (pwnd)
{
iRet = pwnd->ipfd;
pwndRelease(pwnd);
}
else
{
#if 0
// Too noisy for normal operation
WARNING("wglGetPixelFormat: No window for DC\n");
#endif
SAVE_ERROR_CODE(ERROR_INVALID_PIXEL_FORMAT);
}
return iRet;
}
/*****************************Private*Routine******************************\
*
* EnterPixelFormatSection
*
* Enters pixel format exclusive code
*
* NOTE - Pixel format information is maintained in the client process
* so it is not synchronized between processes. This means that two
* processes could successfully set the pixel format for a window.
* If the list becomes global, this synchronization code should also become
* cross-process aware.
*
* History:
* Mon Jun 26 17:49:04 1995 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
#define EnterPixelFormatSection() \
(EnterCriticalSection(&gcsPixelFormat), TRUE)
/*****************************Private*Routine******************************\
*
* LeavePixelFormatSection
*
* Leaves pixel format exclusive code
*
* History:
* Mon Jun 26 17:55:20 1995 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
#define LeavePixelFormatSection() \
LeaveCriticalSection(&gcsPixelFormat)
/******************************Public*Routine******************************\
* wglNumHardwareFormats
*
* Returns the number of hardware formats (ICD and MCD), supported on the
* specified hdc.
*
* History:
* 17-Apr-1996 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
VOID APIENTRY wglNumHardwareFormats(HDC hdc, DWORD dwType,
int *piMcd, int *piIcd)
{
// It is assumed that the caller has already validated the DC.
ASSERTOPENGL((dwType == OBJ_DC) ||
(dwType == OBJ_MEMDC) ||
(dwType == OBJ_ENHMETADC) ||
(dwType == OBJ_DDRAW),
"wglNumHardwareFormats: bad hdc\n");
// Do not call MCD or ICD for enhanced metafile DCs. In such a
// case, the code in ntgdi\client\output.c will return a non-zero value
// even if there are no ICD or MCD pixelformats.
#if _WIN32_WINNT >= 0x0501
{
BOOL wow64Process;
if (IsWow64Process(GetCurrentProcess(), &wow64Process) && wow64Process)
dwType = OBJ_ENHMETADC;
}
#endif
if ( dwType == OBJ_ENHMETADC )
{
// It's a metafile DC. Therefore it cannot support MCD or ICD
// (current OpenGL metafiling support would have to be modified
// to allow this).
*piIcd = 0;
*piMcd = 0;
}
else
{
// Get ICD pixelformat count.
*piIcd = __DrvDescribePixelFormat(hdc, 1, 0, NULL);
// Get MCD pixelformat count.
#ifdef _MCD_
if ( gpMcdTable || bInitMcd(hdc) )
*piMcd = (gpMcdTable->pMCDDescribePixelFormat)(hdc, 1, NULL);
else
*piMcd = 0;
#else
*piMcd = 0;
#endif
}
}
/******************************Public*Routine******************************\
*
* GetCompatibleDevice
*
* Returns an HDC appropriate for making escape calls on.
* In the memdc case it returns a DC for the screen.
*
* History:
* Wed Nov 20 17:48:57 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
HDC GetCompatibleDevice(HDC hdc, DWORD dwObjectType)
{
HDC hdcDriver;
int iTech;
hdcDriver = hdc;
iTech = GetDeviceCaps(hdc, TECHNOLOGY);
if ((dwObjectType == OBJ_MEMDC) && (iTech != DT_PLOTTER) &&
(iTech != DT_RASPRINTER))
{
hdcDriver = GetDC(NULL);
}
return hdcDriver;
}
/******************************Public*Routine******************************\
* wglSetPixelFormat
*
* Set the pixel format for the window or surface associated with the given
* DC.
*
* Note:
* Since the pixel format is per-window data (per-DC for non-display DCs), a
* side effect of this call is to create a GLGENwindow structure.
*
* Note:
* For an installable client driver, a GLGENwindow structure is still created
* to track the pixel format and the driver structure (GLDRIVER).
*
* History:
* 19-Oct-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
BOOL WINAPI wglSetPixelFormat(HDC hdc, int ipfd,
CONST PIXELFORMATDESCRIPTOR *ppfd)
{
GLGENwindow *pwnd = NULL;
int ipfdDevMax, ipfdMcdMax;
DWORD dwObjectType;
BOOL bRet = FALSE;
GLWINDOWID gwid;
BOOL bNew;
HDC hdcDriver;
LPDIRECTDRAWSURFACE pdds;
RECTL rcl, *prcl;
DDSURFACEDESC ddsd;
//DBGPRINT1("wglSetPixelFormat: ipfd = %ld\n", ipfd);
// Validate DC.
switch (dwObjectType = wglObjectType(hdc))
{
case OBJ_DC:
case OBJ_MEMDC:
case OBJ_ENHMETADC:
break;
default:
WARNING1("wglSetPixelFormat: Attempt to set format of %d type DC\n",
dwObjectType);
SAVE_ERROR_CODE(ERROR_INVALID_HANDLE);
return(FALSE);
}
// Take the pixel format mutex
if (!EnterPixelFormatSection())
{
WARNING("wglSetPixelFormat: Unable to take pixel format mutex\n");
return FALSE;
}
// Get the number of hardware supported formats.
if (pfnGetSurfaceFromDC != NULL &&
pfnGetSurfaceFromDC(hdc, &pdds, &hdcDriver) == DD_OK)
{
// Get the surface dimensions
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
if (pdds->lpVtbl->GetSurfaceDesc(pdds, &ddsd) != DD_OK)
{
goto LeaveSection;
}
rcl.left = 0;
rcl.top = 0;
rcl.right = ddsd.dwWidth;
rcl.bottom = ddsd.dwHeight;
prcl = &rcl;
// Switch object type to identify this as a DirectDraw surface
dwObjectType = OBJ_DDRAW;
}
else
{
pdds = NULL;
prcl = NULL;
hdcDriver = GetCompatibleDevice(hdc, dwObjectType);
if (hdcDriver == NULL)
{
goto LeaveSection;
}
}
wglNumHardwareFormats(hdcDriver, dwObjectType,
&ipfdMcdMax, &ipfdDevMax);
// Filter out invalid (out of range) pixel format indices.
if ( (ipfd < 1) || (ipfd > (ipfdDevMax + ipfdMcdMax + MAX_GENERIC_PFD)) )
{
WARNING1("wglSetPixelFormat: ipfd %d out of range\n", ipfd);
SAVE_ERROR_CODE(ERROR_INVALID_PARAMETER);
goto LeaveSection;
}
// If it exists, grab pwnd. Otherwise, create one.
WindowIdFromHdc(hdc, &gwid);
pwnd = CreatePwnd(&gwid, ipfd, ipfdDevMax, dwObjectType, prcl, &bNew);
if (pwnd == NULL)
{
goto LeaveSection;
}
if (bNew)
{
// Dispatch driver formats.
// Driver is responsible for doing its own validation of the pixelformat.
// For generic formats, we call wglValidPixelFormat to validate.
// We do not send DirectDraw pixel format calls to the driver
// so that we avoid having new pixel format calls.
if (dwObjectType != OBJ_DDRAW && ipfd <= ipfdDevMax)
{
bRet = __DrvSetPixelFormat(hdc, ipfd, (PVOID) pwnd);
#if DBG
if (!bRet)
{
WARNING("__DrvSetPixelFormat failed\n");
}
#endif
}
else
{
bRet = wglValidPixelFormat(hdc, ipfd, dwObjectType,
pdds, &ddsd);
#if DBG
if (!bRet)
{
WARNING("wglValidPixelFormat failed\n");
}
#endif
}
// If the pixel format is not valid or could not be set in the driver,
// cleanup and return error.
if (!bRet)
{
goto FreeWnd;
}
}
else
{
bRet = TRUE;
}
pwndRelease(pwnd);
LeaveSection:
LeavePixelFormatSection();
if (pdds != NULL)
{
pdds->lpVtbl->Release(pdds);
}
else if (hdcDriver != hdc)
{
ReleaseDC((HWND) NULL, hdcDriver);
}
return bRet;
FreeWnd:
pwndCleanup(pwnd);
goto LeaveSection;
}
/******************************Public*Routine******************************\
* wglChoosePixelFormat
*
* Choose the pixel format.
*
* Returns: 0 if error; best matching pixel format index otherwise
*
* History:
*
* Sat Feb 10 11:55:22 1996 -by- Hock San Lee [hockl]
* Chose generic 16-bit depth buffer over 32-bit depth buffer.
* Added PFD_DEPTH_DONTCARE flag.
*
* 19-Oct-1994 Gilman Wong [gilmanw]
* Taken from GreChoosePixelFormat (gdi\gre\pixelfmt.cxx).
*
* History for gdi\gre\pixelfmt.cxx:
* Tue Sep 21 14:25:04 1993 -by- Hock San Lee [hockl]
* Wrote it.
\**************************************************************************/
// Reserve some PFD_SUPPORT flags for other potential graphics systems
// such as PEX, HOOPS, Renderman etc.
#define PFD_SUPPORT_OTHER1 0x01000000
#define PFD_SUPPORT_OTHER2 0x02000000
#define PFD_SUPPORT_OTHER3 0x04000000
#define PFD_SUPPORT_OTHER4 0x08000000
// Scores for matching pixel formats
#define PFD_DRAW_TO_WINDOW_SCORE 0x10000 /* must match */
#define PFD_DRAW_TO_BITMAP_SCORE 0x01000
#define PFD_PIXEL_TYPE_SCORE 0x01000
#define PFD_SUPPORT_SCORE 0x01000
#define PFD_DOUBLEBUFFER_SCORE1 0x01000
#define PFD_DOUBLEBUFFER_SCORE2 0x00001
#define PFD_STEREO_SCORE1 0x01000
#define PFD_STEREO_SCORE2 0x00001
#define PFD_BUFFER_SCORE1 0x01010
#define PFD_BUFFER_SCORE2 0x01001
#define PFD_BUFFER_SCORE3 0x01000
// #define PFD_LAYER_TYPE_SCORE 0x01000
#define PFD_DEVICE_FORMAT_SCORE 0x00100
#define PFD_ACCEL_FORMAT_SCORE 0x00010
#define PFD_SUPPORT_DDRAW_SCORE 0x10000 /* must match */
//!!! Add code to choose overlays?
int WINAPI wglChoosePixelFormat(HDC hdc, CONST PIXELFORMATDESCRIPTOR *ppfd)
{
PIXELFORMATDESCRIPTOR pfdIn = *ppfd;
PIXELFORMATDESCRIPTOR pfdCurrent;
// Enumerate and find the best match.
int ipfdBest = 1; // assume the default is the best
int iScoreBest = -1;
int ipfdMax;
int ipfd = 1;
do
{
int iScore = 0;
ipfdMax = wglDescribePixelFormat(hdc,ipfd,sizeof(PIXELFORMATDESCRIPTOR),&pfdCurrent);
if (ipfdMax == 0)
return(0); // something went wrong
if (pfdIn.iPixelType == pfdCurrent.iPixelType)
iScore += PFD_PIXEL_TYPE_SCORE;
if ((pfdIn.cColorBits == 0)
|| (pfdIn.cColorBits == pfdCurrent.cColorBits))
iScore += PFD_BUFFER_SCORE1;
else if (pfdIn.cColorBits < pfdCurrent.cColorBits)
iScore += PFD_BUFFER_SCORE2;
else if (pfdCurrent.cColorBits != 0)
iScore += PFD_BUFFER_SCORE3;
if (!(pfdIn.dwFlags & PFD_DRAW_TO_WINDOW)
|| (pfdCurrent.dwFlags & PFD_DRAW_TO_WINDOW))
iScore += PFD_DRAW_TO_WINDOW_SCORE;
if (!(pfdIn.dwFlags & PFD_DRAW_TO_BITMAP)
|| (pfdCurrent.dwFlags & PFD_DRAW_TO_BITMAP))
iScore += PFD_DRAW_TO_BITMAP_SCORE;
if (!(pfdIn.dwFlags & PFD_SUPPORT_GDI)
|| (pfdCurrent.dwFlags & PFD_SUPPORT_GDI))
iScore += PFD_SUPPORT_SCORE;
if (!(pfdIn.dwFlags & PFD_SUPPORT_OPENGL)
|| (pfdCurrent.dwFlags & PFD_SUPPORT_OPENGL))
iScore += PFD_SUPPORT_SCORE;
if ((pfdIn.dwFlags & PFD_SUPPORT_DIRECTDRAW) == 0 ||
(pfdCurrent.dwFlags & PFD_SUPPORT_DIRECTDRAW))
{
iScore += PFD_SUPPORT_DDRAW_SCORE;
}
if (!(pfdIn.dwFlags & PFD_SUPPORT_OTHER1)
|| (pfdCurrent.dwFlags & PFD_SUPPORT_OTHER1))
iScore += PFD_SUPPORT_SCORE;
if (!(pfdIn.dwFlags & PFD_SUPPORT_OTHER2)
|| (pfdCurrent.dwFlags & PFD_SUPPORT_OTHER2))
iScore += PFD_SUPPORT_SCORE;
if (!(pfdIn.dwFlags & PFD_SUPPORT_OTHER3)
|| (pfdCurrent.dwFlags & PFD_SUPPORT_OTHER3))
iScore += PFD_SUPPORT_SCORE;
if (!(pfdIn.dwFlags & PFD_SUPPORT_OTHER4)
|| (pfdCurrent.dwFlags & PFD_SUPPORT_OTHER4))
iScore += PFD_SUPPORT_SCORE;
if (pfdCurrent.dwFlags & PFD_GENERIC_ACCELERATED)
iScore += PFD_ACCEL_FORMAT_SCORE;
else if (!(pfdCurrent.dwFlags & PFD_GENERIC_FORMAT))
iScore += PFD_DEVICE_FORMAT_SCORE;
if ((pfdIn.dwFlags & PFD_DOUBLEBUFFER_DONTCARE)
|| ((pfdIn.dwFlags & PFD_DOUBLEBUFFER)
== (pfdCurrent.dwFlags & PFD_DOUBLEBUFFER)))
iScore += PFD_DOUBLEBUFFER_SCORE1;
else if (pfdCurrent.dwFlags & PFD_DOUBLEBUFFER)
iScore += PFD_DOUBLEBUFFER_SCORE2;
if ((pfdIn.dwFlags & PFD_STEREO_DONTCARE)
|| ((pfdIn.dwFlags & PFD_STEREO)
== (pfdCurrent.dwFlags & PFD_STEREO)))
iScore += PFD_STEREO_SCORE1;
else if (pfdCurrent.dwFlags & PFD_STEREO)
iScore += PFD_STEREO_SCORE2;
if ((pfdIn.cAlphaBits == 0)
|| (pfdIn.cAlphaBits == pfdCurrent.cAlphaBits))
iScore += PFD_BUFFER_SCORE1;
else if (pfdIn.cAlphaBits < pfdCurrent.cAlphaBits)
iScore += PFD_BUFFER_SCORE2;
else if (pfdCurrent.cAlphaBits != 0)
iScore += PFD_BUFFER_SCORE3;
if ((pfdIn.cAccumBits == 0)
|| (pfdIn.cAccumBits == pfdCurrent.cAccumBits))
iScore += PFD_BUFFER_SCORE1;
else if (pfdIn.cAccumBits < pfdCurrent.cAccumBits)
iScore += PFD_BUFFER_SCORE2;
else if (pfdCurrent.cAccumBits != 0)
iScore += PFD_BUFFER_SCORE3;
// Some applications (e.g. GLview browser) specifies a 0-bit depth buffer
// but expect this function to return a pixel format with a depth buffer.
// This works in NT 3.51 since all pixel formats have a depth buffer.
// When pixel formats with no depth buffer were added in NT 4.0, these
// applications stopped working. The flag PFD_DEPTH_DONTCARE is added to
// indicate that no depth buffer is required. If this flags is not given,
// this function will attempt to select a pixel format with a depth buffer.
if (pfdIn.dwFlags & PFD_DEPTH_DONTCARE)
{
if (pfdCurrent.cDepthBits == 0)
iScore += PFD_BUFFER_SCORE1;
else
iScore += PFD_BUFFER_SCORE2;
}
else if (pfdCurrent.cDepthBits != 0)
{
if ((pfdIn.cDepthBits == 0)
|| (pfdIn.cDepthBits == pfdCurrent.cDepthBits))
iScore += PFD_BUFFER_SCORE1;
else if (pfdIn.cDepthBits < pfdCurrent.cDepthBits)
iScore += PFD_BUFFER_SCORE2;
else if (pfdCurrent.cDepthBits != 0)
iScore += PFD_BUFFER_SCORE3;
}
if ((pfdIn.cStencilBits == 0)
|| (pfdIn.cStencilBits == pfdCurrent.cStencilBits))
iScore += PFD_BUFFER_SCORE1;
else if (pfdIn.cStencilBits < pfdCurrent.cStencilBits)
iScore += PFD_BUFFER_SCORE2;
else if (pfdCurrent.cStencilBits != 0)
iScore += PFD_BUFFER_SCORE3;
if ((pfdIn.cAuxBuffers == 0)
|| (pfdIn.cAuxBuffers == pfdCurrent.cAuxBuffers))
iScore += PFD_BUFFER_SCORE1;
else if (pfdIn.cAuxBuffers < pfdCurrent.cAuxBuffers)
iScore += PFD_BUFFER_SCORE2;
else if (pfdCurrent.cAuxBuffers != 0)
iScore += PFD_BUFFER_SCORE3;
#if 0
DbgPrint("%2d: score is %8X, best %8X (%2d)\n",
ipfd, iScore, iScoreBest, ipfdBest);
#endif
if (iScore > iScoreBest)
{
iScoreBest = iScore;
ipfdBest = ipfd;
}
else if (iScore == iScoreBest)
{
// When everything is equal, we should choose the pixel format with a
// smaller depth size for better performance, provided that the smaller
// depth buffer satisfies the request. The best way to do this is to
// order pixel formats such that one with smaller depth buffer comes
// first. In NT 3.51, however, the generic pixel format was not ordered
// this way. As a result, pixel formats with 32-bit depth buffer are
// choosen by default. To maintain compatibility, we modify the selection
// here without reordering generic pixel formats.
if ((pfdCurrent.dwFlags & PFD_GENERIC_FORMAT) &&
#ifdef _MCD_
!(pfdCurrent.dwFlags & PFD_GENERIC_ACCELERATED) &&
#endif
(pfdIn.cDepthBits < 16 || pfdIn.dwFlags & PFD_DEPTH_DONTCARE) &&
(pfdCurrent.cDepthBits == 16) &&
(ipfd == ipfdBest + 1))
{
ipfdBest = ipfd;
}
}
ipfd++;
} while (ipfd <= ipfdMax);
return(ipfdBest);
}
/******************************Public*Routine******************************\
*
* MaskToBitsAndShift
*
* Counts bits in a mask and determines shift
* Set bits must be contiguous
*
* History:
* Mon Aug 26 14:16:28 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
void APIENTRY MaskToBitsAndShift(DWORD dwMask, BYTE *pbBits, BYTE *pbShift)
{
DWORD dwBit;
*pbBits = 0;
*pbShift = 0;
/* Determine first set bit and accumulate shift count */
dwBit = 0x1;
while ((dwMask & dwBit) == 0)
{
dwBit <<= 1;
(*pbShift)++;
}
/* Count set bits */
while ((dwMask & dwBit) != 0)
{
dwBit <<= 1;
(*pbBits)++;
}
/* No other bits in the mask can be set */
ASSERTOPENGL(((*pbBits+*pbShift) == (sizeof(dwMask)*8)) ||
((dwMask >> (*pbBits+*pbShift)) == 0),
"Invalid mask\n");
}
/*****************************Private*Routine******************************\
*
* ComputeBitsFromMasks
*
* Determines the values for c*Bits and c*Shift from BI_BITFIELD
* channel masks
*
* History:
* Tue Feb 14 10:50:10 1995 -by- Drew Bliss [drewb]
* Created by pulling out duplicated code
*
\**************************************************************************/
static void ComputeBitsFromMasks(PIXELFORMATDESCRIPTOR *ppfd,
DWORD dwRedMask, DWORD dwGreenMask,
DWORD dwBlueMask)
{
/* Masks can't be zero and they can't overlap */
ASSERTOPENGL(dwRedMask != 0 &&
dwGreenMask != 0 &&
dwBlueMask != 0,
"Bitfield mask is zero");
ASSERTOPENGL((dwRedMask & dwGreenMask) == 0 &&
(dwRedMask & dwBlueMask) == 0 &&
(dwGreenMask & dwBlueMask) == 0,
"Bitfield masks overlap");
MaskToBitsAndShift(dwRedMask, &ppfd->cRedBits, &ppfd->cRedShift);
MaskToBitsAndShift(dwGreenMask, &ppfd->cGreenBits, &ppfd->cGreenShift);
MaskToBitsAndShift(dwBlueMask, &ppfd->cBlueBits, &ppfd->cBlueShift);
}
/******************************Public*Routine******************************\
* __wglGetDdFormat
*
* Special case of __wglGetBitfieldColorFormat to support DirectDraw
* surfaces. Fills in the cRedBits, cRedShift, cGreenBits, etc. fields
* of the PIXELFORMATDESCRIPTOR for 16, 24, and 32bpp direct surfaces.
*
* This is done by interpreting the given surface information
*
* History:
* 07-Jun-1995 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
void __wglGetDdFormat(DDSURFACEDESC *pddsd,
PIXELFORMATDESCRIPTOR *ppfd)
{
// This routine should only be called for bitfield formats, but
// random mode changes in the middle of certain calls could cause
// it to be called with non-bitfield formats.
//
// When such a mode change occurs OpenGL should not crash but
// does not necessarily have to produce correct output
if ((pddsd->ddpfPixelFormat.dwFlags & DDPF_RGB) == 0 ||
(pddsd->ddpfPixelFormat.dwFlags & (DDPF_PALETTEINDEXED1 |
DDPF_PALETTEINDEXED2 |
DDPF_PALETTEINDEXED4 |
DDPF_PALETTEINDEXED8)))
{
WARNING1("__wglGetDdFormat called with 0x%08lX ddpf flags\n",
pddsd->ddpfPixelFormat.dwFlags);
ppfd->cRedBits = 8;
ppfd->cRedShift = 0;
ppfd->cGreenBits = 8;
ppfd->cGreenShift = 0;
ppfd->cBlueBits = 8;
ppfd->cBlueShift = 0;
}
else
{
ComputeBitsFromMasks(ppfd,
pddsd->ddpfPixelFormat.dwRBitMask,
pddsd->ddpfPixelFormat.dwGBitMask,
pddsd->ddpfPixelFormat.dwBBitMask);
}
}
/******************************Public*Routine******************************\
* __wglGetBitfieldColorFormat
*
* Fills in the cRedBits, cRedShift, cGreenBits, etc. fields of the
* PIXELFORMATDESCRIPTOR for 16, 24, and 32bpp surfaces (either device
* or bitmap surfaces).
*
* This is done by creating a compatible bitmap and calling GetDIBits
* to return the color masks. This is done with two calls. The first
* call passes in biBitCount = 0 to GetDIBits which will fill in the
* base BITMAPINFOHEADER data. The second call to GetDIBits (passing
* in the BITMAPINFO filled in by the first call) will return the color
* table or bitmasks, as appropriate.
*
* This function is used to describe the color format for both the underlying
* surface and for the device. This is the same thing if the DC is a
* display DC. However, for a memory DC, the surface and the device may have
* different formats. The bDescribeSurf flag indicates whether the caller
* wants the decription of the device (FALSE) or the surface (TRUE).
*
* Returns:
* TRUE if successful, FALSE otherwise.
*
* History:
* 07-Jun-1995 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
BOOL APIENTRY
__wglGetBitfieldColorFormat(HDC hdc, UINT cColorBits, PIXELFORMATDESCRIPTOR *ppfd,
BOOL bDescribeSurf)
{
HBITMAP hbm = (HBITMAP) NULL;
BOOL bRet = FALSE;
HDC hdcDriver;
#if DBG
// Dynamic color depth changes can cause this. It will not cause us to crash,
// but drawing (color) may be incorrect.
if ((GetObjectType(hdc) == OBJ_DC) &&
(GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE))
{
WARNING("Palette managed device that is greater than 8 bits\n");
}
if (cColorBits < 16)
{
WARNING("__wglGetBitfieldColorFormat with cColorBits < 16\n");
}
#endif
// Handle direct case.
if ( GLDIRECTSCREEN && wglIsDirectDevice(hdc) )
{
__wglGetDdFormat(&GLSCREENINFO->gdds.ddsd, ppfd);
return TRUE;
}
// Create a dummy bitmap from which we can query color format info.
//
// If we want a device format AND its a MEM_DC AND NOT a printer or plotter,
// then we need to create a compatible bitmap from a display DC (not the mem
// DC passed into this function).
//
// Otherwise, the format of the surface (whether bitmap or device) associated
// with the DC passed in will suffice.
//
// WinNT does not care, but the Win95 GetDIBits call might
// fail if we use a memory DC. Specifically, if the memory
// DC contains a surface that does not match the display
// (remember, the new bitmap is compatible with the display)
// the Win95 GetDIBits call will fail.
//
// So use the display DC. It works on both platforms.
if (!bDescribeSurf)
{
hdcDriver = GetCompatibleDevice(hdc, GetObjectType(hdc));
if (hdcDriver == NULL)
{
return FALSE;
}
}
else
{
hdcDriver = hdc;
}
hbm = CreateCompatibleBitmap(hdcDriver, 1, 1);
if ( !hbm )
{
WARNING("__wglGetBitfieldColorFormat: "
"CreateCompatibleBitmap failed\n");
}
// Get the color format by calling GetDIBits.
else
{
BYTE ajBitmapInfo[sizeof(BITMAPINFO) + 3*sizeof(DWORD)];
BITMAPINFO *pbmi = (BITMAPINFO *) ajBitmapInfo;
int iRet;
//!!!dbug -- Init masks to zero so we can
// tell if they are set by GetDIBits.
memset(pbmi, 0, sizeof(ajBitmapInfo));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
// Call first time to fill in BITMAPINFO header.
iRet = GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
#if DBG
if (pbmi->bmiHeader.biBitCount != cColorBits)
WARNING2("__wglGetBitfieldColorFormat: bit count != BITSPIXEL "
" (%ld, %ld)\n", pbmi->bmiHeader.biBitCount, cColorBits);
#endif
switch ( pbmi->bmiHeader.biCompression )
{
case BI_RGB:
#if DBG
// Dynamic color depth changes can cause this. It will not cause
// us to crash, but drawing (color) may be incorrect.
if (pbmi->bmiHeader.biBitCount != cColorBits)
{
WARNING("__wglGetBitfieldColorFormat(): bit count mismatch\n");
}
#endif
// Default DIB format. Color masks are implicit for each bit depth.
switch ( pbmi->bmiHeader.biBitCount )
{
case 16:
// 16bpp default is 555 BGR-ordering
ppfd->cRedBits = 5; ppfd->cRedShift = 10;
ppfd->cGreenBits = 5; ppfd->cGreenShift = 5;
ppfd->cBlueBits = 5; ppfd->cBlueShift = 0;
bRet = TRUE;
break;
case 24:
case 32:
// 24 and 32bpp default is 888 BGR-ordering
ppfd->cRedBits = 8; ppfd->cRedShift = 16;
ppfd->cGreenBits = 8; ppfd->cGreenShift = 8;
ppfd->cBlueBits = 8; ppfd->cBlueShift = 0;
bRet = TRUE;
break;
default:
break;
}
break;
case BI_BITFIELDS:
// Some drivers seem to return bitfields for everything that's
// not paletted. They return correct BGR bitfields so we
// operate correctly, so remove this assert
#ifdef STRICT_BITFIELD_CHECK
ASSERTOPENGL(
cColorBits == 16 || cColorBits == 32,
"__wglGetBitfieldColorFormat(): "
"BI_BITFIELDS surface not 16 or 32bpp\n"
);
#endif
// Call a second time to get the color masks.
// It's a GetDIBits Win32 "feature".
iRet = GetDIBits(hdc, hbm, 0, pbmi->bmiHeader.biHeight, NULL,
pbmi, DIB_RGB_COLORS);
ComputeBitsFromMasks(ppfd,
*(DWORD *)&pbmi->bmiColors[0],
*(DWORD *)&pbmi->bmiColors[1],
*(DWORD *)&pbmi->bmiColors[2]);
bRet = TRUE;
break;
default:
RIP("__wglGetBitfieldColorFormat(): bad biCompression\n");
break;
}
DeleteObject(hbm);
}
if ( hdcDriver != hdc )
{
ReleaseDC((HWND) NULL, hdcDriver);
}
return bRet;
}
/******************************Public*Routine******************************\
*
* wglGetDeviceDepth
*
* Returns the depth of the given HDC
* Primarily used to workaround potential problems with printers
* that lie about their depth in GetDeviceCaps
*
* History:
* Tue Apr 09 16:52:47 1996 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
int wglGetDeviceDepth(HDC hdc)
{
int iTech;
// If this is an enhanced metafile it should return the technology
// of the reference device
iTech = GetDeviceCaps(hdc, TECHNOLOGY);
if (iTech == DT_PLOTTER || iTech == DT_RASPRINTER)
{
HBITMAP hbm;
BYTE ajBitmapInfo[sizeof(BITMAPINFO) + 3*sizeof(DWORD)];
BITMAPINFO *pbmi = (BITMAPINFO *) ajBitmapInfo;
int iRet;
// We're dealing with a printer or a metafile that has a printer
// as a reference device
// Find out the true depth by creating a compatible
// bitmap and querying its format
if ( (hbm = CreateCompatibleBitmap(hdc, 1, 1)) != NULL )
{
memset(pbmi, 0, sizeof(ajBitmapInfo));
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
iRet = GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
DeleteObject(hbm);
return iRet != 0 ? pbmi->bmiHeader.biBitCount : -1;
}
// Failure
return -1;
}
else
{
// We're dealing with a well-behaved DC so just return
// the normal depth
return GetDeviceCaps(hdc, BITSPIXEL)*GetDeviceCaps(hdc, PLANES);
}
}
/******************************Public*Routine******************************\
* wglDescribePixelFormat
*
* Describe the pixel format.
* If cjpfd is 0, just return the maximum pixel format index.
*
* Returns: 0 if error; maximum pixel format index otherwise
*
* History:
* 19-Oct-1994 Gilman Wong [gilmanw]
* Adapted from GreDescribePixelFormat (gdi\gre\pixelfmt.cxx).
*
* History for gdi\gre\pixelfmt.cxx:
* Mon Apr 25 15:34:32 1994 -by- Hock San Lee [hockl]
* Added 16-bit Z buffer formats and removed double buffered formats for bitmaps.
* Tue Sep 21 14:25:04 1993 -by- Hock San Lee [hockl]
* Wrote it.
\**************************************************************************/
// Here are the generic formats that we enumerate. ChoosePixelFormat code
// assumes that generic pixel formats with z32 comes before z16 as given below:
//
// I. Native formats:
//
// 1. rgb.sb.z32.a0
// 2. rgb.sb.z16.a0
// 3. rgb.db.z32.a0
// 4. rgb.db.z16.a0
// 5. rgb.sb.z32.a8
// 6. rgb.sb.z16.a8
// 7. rgb.db.z32.a8
// 8. rgb.db.z16.a8
// 9. ci.sb.z32
// 10. ci.sb.z16
// 11. ci.db.z32
// 12. ci.db.z16
//
// II. Other formats:
//
// 1. rgb.sb.z32.a0
// 2. rgb.sb.z16.a0
// 3. rgb.sb.z32.a8
// 4. rgb.sb.z16.a8
// 5. ci.sb.z32
// 6. ci.sb.z16
//
// We always enumerate the native formats first followed by other formats
// in the BPP order {24, 32, 16, 8, 4} for a total of 1 * 12 + 4 * 6 = 36
// pixel formats.
// Highest native format generic pixel format index.
#define MAX_NATIVE_GENERIC_PFD 12
// Number of non-native formats in a non-native group.
#define NON_NATIVE_PFD_GROUP 6
static BYTE aabPixelBits[BMF_COUNT][4] =
{
{24, 32, 16, 8}, // error
{24, 32, 16, 8}, // 1 bpp
{24, 32, 16, 8}, // 4 bpp
{24, 32, 16, 4}, // 8 bpp
{24, 32, 8, 4}, // 16 bpp
{32, 16, 8, 4}, // 24 bpp
{24, 16, 8, 4} // 32 bpp
};
static BYTE abPixelType[MAX_GENERIC_PFD] =
{
PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA,
PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA,
PFD_TYPE_COLORINDEX,PFD_TYPE_COLORINDEX, PFD_TYPE_COLORINDEX,PFD_TYPE_COLORINDEX,
PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA,
PFD_TYPE_COLORINDEX, PFD_TYPE_COLORINDEX,
PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA,
PFD_TYPE_COLORINDEX, PFD_TYPE_COLORINDEX,
PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA,
PFD_TYPE_COLORINDEX, PFD_TYPE_COLORINDEX,
PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA, PFD_TYPE_RGBA,
PFD_TYPE_COLORINDEX, PFD_TYPE_COLORINDEX
};
int WINAPI InternalDescribePixelFormat(HDC hdc, HDC hdcDriver,
int ipfd, UINT cjpfd,
LPPIXELFORMATDESCRIPTOR ppfd,
int ipfdDevMax, int ipfdMcdMax,
LPDIRECTDRAWSURFACE pdds,
DDSURFACEDESC *pddsd)
{
int iRet = 0;
int ipfdGen;
UINT iDitherFormat;
BYTE cColorBitsNative;
// If cjpfd is 0, just return the maximum pixel format index.
if (cjpfd == 0 || ppfd == NULL)
{
iRet = MAX_GENERIC_PFD + ipfdDevMax + ipfdMcdMax;
goto wglDescribePixelFormat_cleanup;
}
// Validate the size of the pixel format descriptor.
if (cjpfd < sizeof(PIXELFORMATDESCRIPTOR))
{
SAVE_ERROR_CODE(ERROR_INVALID_PARAMETER);
goto wglDescribePixelFormat_cleanup;
}
// Validate pixel format index.
// If a driver support device pixel formats 1..ipfdDevMax, the generic
// pixel formats will be (ipfdDevMax+1)..(ipfdDevMax+MAX_GENERIC_PFD).
// Otherwise, ipfdDevMax is 0 and the generic pixel formats are
// 1..MAX_GENERIC_PFD.
if ((ipfd < 1) || (ipfd > ipfdDevMax + ipfdMcdMax + MAX_GENERIC_PFD))
{
SAVE_ERROR_CODE(ERROR_INVALID_PARAMETER);
goto wglDescribePixelFormat_cleanup;
}
// Dispatch ICD driver formats.
if (ipfd <= ipfdDevMax)
{
int iDrvRet = __DrvDescribePixelFormat(hdcDriver,ipfd,cjpfd,ppfd);
if (iDrvRet)
{
ASSERTOPENGL(iDrvRet == ipfdDevMax,
"wglDescribePixelFornat: Bad ipfdDevMax");
iRet = MAX_GENERIC_PFD + ipfdDevMax + ipfdMcdMax;
}
goto wglDescribePixelFormat_cleanup;
}
#ifdef _MCD_
// Dispatch MCD driver formats.
ipfdGen = ipfd - ipfdDevMax;
if (ipfdGen <= ipfdMcdMax)
{
int iMcdRet;
// Note: don't need to check if gpMcdTable is valid because we can't get
// here unless ipfdDevMax is non-zero and that can't happen unless the
// the table is valid.
ASSERTOPENGL(gpMcdTable, "wglDescribePixelFormat: bad MCD table\n");
iMcdRet = (gpMcdTable->pMCDDescribePixelFormat)(hdcDriver, ipfdGen,
ppfd);
if (iMcdRet)
{
ASSERTOPENGL(iMcdRet == ipfdMcdMax,
"wglDescribePixelFornat: Bad ipfdMcdMax");
iRet = MAX_GENERIC_PFD + ipfdDevMax + ipfdMcdMax;
}
goto wglDescribePixelFormat_cleanup;
}
// Generic implementation.
// Normalize the generic pixel format index to 0..(MAX_GENERIC_PFD-1).
ipfdGen = ipfdGen - ipfdMcdMax - 1;
#else
// Generic implementation.
// Normalize the generic pixel format index to 0..(MAX_GENERIC_PFD-1).
ipfdGen = ipfd - ipfdDevMax - 1;
#endif
// Get the native BPP format.
if (pdds != NULL)
{
cColorBitsNative = DdPixelDepth(pddsd);
}
else
{
cColorBitsNative = (BYTE)wglGetDeviceDepth(hdc);
}
if (cColorBitsNative < 1)
{
SAVE_ERROR_CODE(ERROR_INVALID_PARAMETER);
goto wglDescribePixelFormat_cleanup;
}
if (cColorBitsNative <= 1)
{
cColorBitsNative = 1;
iDitherFormat = BMF_1BPP;
}
else if (cColorBitsNative <= 4)
{
cColorBitsNative = 4;
iDitherFormat = BMF_4BPP;
}
else if (cColorBitsNative <= 8)
{
cColorBitsNative = 8;
iDitherFormat = BMF_8BPP;
}
else if (cColorBitsNative <= 16)
{
cColorBitsNative = 16;
iDitherFormat = BMF_16BPP;
}
else if (cColorBitsNative <= 24)
{
cColorBitsNative = 24;
iDitherFormat = BMF_24BPP;
}
else
{
cColorBitsNative = 32;
iDitherFormat = BMF_32BPP;
}
// Fill in the pixel format descriptor.
ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
ppfd->nVersion = 1;
ppfd->iPixelType = abPixelType[ipfdGen];
if (ipfdGen < MAX_NATIVE_GENERIC_PFD)
{
ppfd->cColorBits = max(cColorBitsNative, 4); // 1 bpp not supported
}
else
{
ppfd->cColorBits = aabPixelBits[iDitherFormat]
[(ipfdGen - MAX_NATIVE_GENERIC_PFD) / NON_NATIVE_PFD_GROUP];
}
// If the color format is compatible to that of the device and the
// color bits is 16 or greater, use the device description.
// Otherwise, use the generic format.
if (ipfdGen < MAX_NATIVE_GENERIC_PFD && cColorBitsNative >= 16)
{
// Handle compatible formats that are greater than 16-bits.
if (pdds != NULL)
{
__wglGetDdFormat(pddsd, ppfd);
}
else if ( !__wglGetBitfieldColorFormat(hdc, cColorBitsNative,
ppfd, FALSE) )
{
// Don't know how to deal with this device!
WARNING("Unknown device format");
SAVE_ERROR_CODE(ERROR_NOT_SUPPORTED);
goto wglDescribePixelFormat_cleanup;
}
}
else
{
// Handle generic formats.
switch (ppfd->cColorBits)
{
case 4:
ppfd->cRedBits = 1; ppfd->cRedShift = 0;
ppfd->cGreenBits = 1; ppfd->cGreenShift = 1;
ppfd->cBlueBits = 1; ppfd->cBlueShift = 2;
break;
case 8:
ppfd->cRedBits = 3; ppfd->cRedShift = 0;
ppfd->cGreenBits = 3; ppfd->cGreenShift = 3;
ppfd->cBlueBits = 2; ppfd->cBlueShift = 6;
break;
case 16:
/*
** Even though Win95 allows arbitrary bitfield definitions
** for 16bpp DIBs, only 555BGR is usable by Win95's GDI.
*/
ppfd->cRedBits = 5; ppfd->cRedShift = 10; // 555BGR
ppfd->cGreenBits = 5; ppfd->cGreenShift = 5;
ppfd->cBlueBits = 5; ppfd->cBlueShift = 0;
break;
case 24:
case 32:
/*
** Even though Win95 allows arbitrary bitfield definitions
** for 32bpp, only 888BGR is usable by Win95's GDI. Similarly,
** NT has the concept of a RGB 24bpp DIB, but Win95 does not.
*/
ppfd->cRedBits = 8; ppfd->cRedShift = 16; // 888BGR
ppfd->cGreenBits = 8; ppfd->cGreenShift = 8;
ppfd->cBlueBits = 8; ppfd->cBlueShift = 0;
break;
default:
ASSERTOPENGL(FALSE, "wglDescribePixelFornat: Unknown format");
break;
}
}
ppfd->cAlphaBits = 0;
ppfd->cAlphaShift = 0;
if ( ipfdGen < MAX_NATIVE_GENERIC_PFD)
{
// Only report alpha bits if the DirectDraw surface has them.
if (pdds != NULL)
{
if (pddsd->ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS)
{
ASSERTOPENGL(pddsd->dwFlags & DDSD_ALPHABITDEPTH,
"Surface with alpha but no bit depth set\n");
ppfd->cAlphaBits = (BYTE)pddsd->dwAlphaBitDepth;
}
}
else if ( (ipfdGen > 3) && (ipfdGen < 8) )
{
ppfd->cAlphaBits = 8;
}
}
else
{
int ipfd = (ipfdGen - MAX_NATIVE_GENERIC_PFD) % NON_NATIVE_PFD_GROUP;
if ( (ipfd == 2) || (ipfd == 3) )
{
ppfd->cAlphaBits = 8;
}
}
if (ppfd->iPixelType == PFD_TYPE_RGBA)
{
if (ppfd->cColorBits <= 16)
{
if (ppfd->cColorBits < 8)
{
// !!! Internally now, we will actually be using a 32-bit accum
// buffer, but the user will think it's 16 (This is for
// backwards compatibility).
ppfd->cAccumBits = 16;
if( ppfd->cAlphaBits )
{
ppfd->cAccumRedBits = 4;
ppfd->cAccumGreenBits = 4;
ppfd->cAccumBlueBits = 4;
ppfd->cAccumAlphaBits = 4;
}
else
{
ppfd->cAccumRedBits = 5;
ppfd->cAccumGreenBits = 6;
ppfd->cAccumBlueBits = 5;
ppfd->cAccumAlphaBits = 0;
}
}
else
{
ppfd->cAccumBits = 32;
if( ppfd->cAlphaBits )
{
ppfd->cAccumRedBits = 8;
ppfd->cAccumGreenBits = 8;
ppfd->cAccumBlueBits = 8;
ppfd->cAccumAlphaBits = 8;
}
else
{
ppfd->cAccumRedBits = 11;
ppfd->cAccumGreenBits = 11;
ppfd->cAccumBlueBits = 10;
ppfd->cAccumAlphaBits = 0;
}
}
}
else
{
ppfd->cAccumBits = 64;
if( ppfd->cAlphaBits )
{
ppfd->cAccumRedBits = 16;
ppfd->cAccumGreenBits = 16;
ppfd->cAccumBlueBits = 16;
ppfd->cAccumAlphaBits = 16;
}
else
{
ppfd->cAccumRedBits = 16;
ppfd->cAccumGreenBits = 16;
ppfd->cAccumBlueBits = 16;
ppfd->cAccumAlphaBits = 0;
}
}
}
else
{
ppfd->cAccumBits = 0;
ppfd->cAccumRedBits = 0;
ppfd->cAccumGreenBits = 0;
ppfd->cAccumBlueBits = 0;
ppfd->cAccumAlphaBits = 0;
}
// Generic formats alternate between 16- and 32-bit depth buffer. Evens
// are 32-bit, odds are 16-bit.
// DirectDraw surfaces always report the depth of the attached Z buffer
// for the native format indices.
if (pdds != NULL && ipfdGen < MAX_NATIVE_GENERIC_PFD)
{
DDSCAPS ddscaps;
LPDIRECTDRAWSURFACE pddsZ;
// DDraw surfaces may not have attached Z buffers, in which case
// we should not report depth bits. If one is attached, its
// depth should be reported.
// We only do this processing for native pixel formats.
memset(&ddscaps, 0, sizeof(ddscaps));
ddscaps.dwCaps = DDSCAPS_ZBUFFER;
if (pdds->lpVtbl->
GetAttachedSurface(pdds, &ddscaps, &pddsZ) == DD_OK)
{
HRESULT hr;
DDSURFACEDESC ddsdZ;
memset(&ddsdZ, 0, sizeof(ddsdZ));
ddsdZ.dwSize = sizeof(ddsdZ);
hr = pddsZ->lpVtbl->GetSurfaceDesc(pddsZ, &ddsdZ);
pddsZ->lpVtbl->Release(pddsZ);
if (hr != DD_OK)
{
goto wglDescribePixelFormat_cleanup;
}
ppfd->cDepthBits =
(BYTE)DdPixDepthToCount(ddsdZ.ddpfPixelFormat.
dwZBufferBitDepth);
}
else
{
ppfd->cDepthBits = 0;
}
}
else if (ipfdGen & 0x1)
{
ppfd->cDepthBits = 16;
}
else
{
ppfd->cDepthBits = 32;
}
ppfd->cStencilBits = 8;
ppfd->cAuxBuffers = 0;
ppfd->iLayerType = PFD_MAIN_PLANE;
ppfd->bReserved = 0;
ppfd->dwLayerMask = 0;
ppfd->dwVisibleMask = 0;
ppfd->dwDamageMask = 0;
// Compute the buffer flags.
// Support OpenGL in all generic formats.
ppfd->dwFlags = PFD_SUPPORT_OPENGL | PFD_GENERIC_FORMAT;
// Indicate DirectDraw support on native pixel formats for DD surfaces.
if (pdds != NULL && ipfdGen < MAX_NATIVE_GENERIC_PFD)
{
ppfd->dwFlags |= PFD_SUPPORT_DIRECTDRAW;
}
// Bitmaps and GDI drawing are available in single buffered mode only.
if (pdds == NULL &&
(ipfdGen == 2 || ipfdGen == 3 || ipfdGen == 6 || ipfdGen == 7 ||
ipfdGen == 10 || ipfdGen == 11))
{
ppfd->dwFlags |= PFD_DOUBLEBUFFER | PFD_SWAP_COPY;
}
else
{
ppfd->dwFlags |= PFD_DRAW_TO_BITMAP | PFD_SUPPORT_GDI;
}
// Draw to window or device surface only if the format is compatible.
if (ipfdGen < MAX_NATIVE_GENERIC_PFD)
{
ppfd->dwFlags |= PFD_DRAW_TO_WINDOW;
// Need a palette if it is a RGBA pixel type on a palette managed device.
if (ppfd->cColorBits == 8 && ppfd->iPixelType == PFD_TYPE_RGBA)
{
ppfd->dwFlags |= PFD_NEED_PALETTE;
}
}
// If this is a 1 bpp surface, we don't support drawing to window and
// double buffered mode. Re-set the buffer flags.
if (cColorBitsNative < 4)
{
#ifndef GL_METAFILE
ASSERTOPENGL(ppfd->cColorBits == 4,
"wglDescribePixelFormat: bad cColorBits for 1 bpp surface\n");
#endif
ppfd->dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_GDI |
PFD_SUPPORT_OPENGL | PFD_GENERIC_FORMAT;
}
// To support other potential graphics systems, we reserve the following
// flags in the pixel format descriptor. For example, PEX may use
// PFD_SUPPORT_OTHER1 on the system that supports PEX. Since we don't
// support these other systems in the generic implementation, they belong
// to the device pixel format descriptor.
ASSERTOPENGL(!(ppfd->dwFlags & (PFD_SUPPORT_OTHER1 | PFD_SUPPORT_OTHER2 |
PFD_SUPPORT_OTHER3 | PFD_SUPPORT_OTHER4)),
"dwFlags reserved for device formats\n");
iRet = MAX_GENERIC_PFD + ipfdDevMax + ipfdMcdMax;
wglDescribePixelFormat_cleanup:
return iRet;
}
int WINAPI wglDescribePixelFormat(HDC hdc, int ipfd, UINT cjpfd,
LPPIXELFORMATDESCRIPTOR ppfd)
{
int iRet = 0;
int ipfdDevMax, ipfdMcdMax;
DWORD dwObjectType;
HDC hdcDriver = NULL;
LPDIRECTDRAWSURFACE pdds;
DDSURFACEDESC ddsd;
// Validate DC.
switch (dwObjectType = wglObjectType(hdc))
{
case OBJ_DC:
case OBJ_MEMDC:
case OBJ_ENHMETADC:
break;
default:
SAVE_ERROR_CODE(ERROR_INVALID_HANDLE);
return(0);
}
// Check to see if this is a DirectDraw DC. If it is, use the
// device DC returned from DirectDraw.
if (pfnGetSurfaceFromDC != NULL &&
pfnGetSurfaceFromDC(hdc, &pdds, &hdcDriver) == DD_OK)
{
// pdds reference must be released before exiting this function.
// Retrieve surface description for later use.
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
if (pdds->lpVtbl->GetSurfaceDesc(pdds, &ddsd) != DD_OK)
{
goto wglDescribePixelFormat_cleanup;
}
}
else
{
pdds = NULL;
hdcDriver = GetCompatibleDevice(hdc, dwObjectType);
if (hdcDriver == NULL)
{
goto wglDescribePixelFormat_cleanup;
}
// NOTE: From this point on, all exit cases must cleanup hdcDriver
}
// Get the number of hardware supported formats.
wglNumHardwareFormats(hdcDriver, dwObjectType, &ipfdMcdMax, &ipfdDevMax);
iRet = InternalDescribePixelFormat(hdc, hdcDriver, ipfd, cjpfd, ppfd,
ipfdDevMax, ipfdMcdMax,
pdds, &ddsd);
wglDescribePixelFormat_cleanup:
if (pdds != NULL)
{
pdds->lpVtbl->Release(pdds);
}
else if (hdcDriver != hdc)
{
ReleaseDC((HWND) NULL, hdcDriver);
}
return iRet;
}
#ifdef _MCD_
/******************************Public*Routine******************************\
* GenMcdGenericCompatibleFormat
*
* Determines if pixelformat in gengc can be supported by generic code.
*
* Note:
* The implication of not being compatible is that generic cannot be
* used for driver kickbacks and MCD contexts cannot be converted.
*
* Returns:
* TRUE if compatible, FALSE otherwise.
*
* History:
* 04-Jun-1996 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
BOOL FASTCALL GenMcdGenericCompatibleFormat(__GLGENcontext *gengc)
{
PIXELFORMATDESCRIPTOR *ppfd;
// Software-only formats are definitely supported.
ppfd = &gengc->gsurf.pfd;
if ((ppfd->dwFlags & (PFD_GENERIC_FORMAT|PFD_GENERIC_ACCELERATED))
== PFD_GENERIC_FORMAT)
return TRUE;
// Layer planes are not supported.
if (gengc->iLayerPlane)
return FALSE;
// Generic is PFD_SWAP_COPY only. There can't be many apps that rely
// on PFD_SWAP_EXCHANGE behavior (usually they look for PFD_SWAP_COPY
// so the back buffer can be used as backing store), but for now I think
// we should be conservative.
//
// Note: most MGA cards will set PFD_SWAP_COPY or neither (i.e., either
// style might be used depending on window size).
if (ppfd->dwFlags & PFD_SWAP_EXCHANGE)
return FALSE;
// Can only support 8bpp stencils.
if ((ppfd->cStencilBits != 0) && (ppfd->cStencilBits != 8))
return FALSE;
// Passed all the checks, we're compatible.
return TRUE;
}
#endif
/******************************Public*Routine******************************\
* wglSwapBuffers
*
\**************************************************************************/
BOOL WINAPI wglSwapBuffers(HDC hdc)
{
int ipfd;
BOOL bRet = FALSE;
GLGENwindow *pwnd;
GLWINDOWID gwid;
// Validate the DC.
if (IsDirectDrawDevice(hdc))
{
SetLastError(ERROR_INVALID_FUNCTION);
return FALSE;
}
switch ( wglObjectType(hdc) )
{
case OBJ_DC:
break;
case OBJ_MEMDC:
return(TRUE); // early out -- nothing to do if memory DC
default:
WARNING("wglSwapBuffers(): invalid hdc\n");
SAVE_ERROR_CODE(ERROR_INVALID_HANDLE);
return(FALSE);
}
// Validate pixel format.
WindowIdFromHdc(hdc, &gwid);
pwnd = pwndGetFromID(&gwid);
if ( pwnd )
{
if (pwnd->ipfd > 0)
{
// Dispatch to driver or generic. Which one can be determined by
// the pixel format.
if ( pwnd->ipfd <= pwnd->ipfdDevMax )
{
// Some ICDs do not need glFinish synchronization so
// we don't do it here. __DrvSwapBuffers will call
// it if necessary.
bRet = __DrvSwapBuffers(hdc, TRUE);
}
else
{
// Finish OpenGL calls in this thread before doing the swap.
// We use glFinish instead of glFlush to ensure that all
// OpenGL operations are completed.
glFinish();
ENTER_WINCRIT(pwnd);
// Can't rely on the pwnd's HDC because it may have
// been released since SetPixelFormat. Always use
// the DC passed in as the target.
bRet = glsrvSwapBuffers(hdc, pwnd);
LEAVE_WINCRIT(pwnd);
}
}
pwndRelease(pwnd);
}
else
{
SAVE_ERROR_CODE(ERROR_INVALID_HANDLE);
}
return bRet;
}