mirror of https://github.com/tongzx/nt5src
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.
658 lines
18 KiB
658 lines
18 KiB
/******************************Module*Header*******************************\
|
|
* Module Name: makecur.c
|
|
*
|
|
* wglMakeCurrent implementation
|
|
*
|
|
* Created: 02-10-1997
|
|
*
|
|
* Copyright (c) 1993-1997 Microsoft Corporation
|
|
\**************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include <context.h>
|
|
#include <global.h>
|
|
|
|
#include "metasup.h"
|
|
#include "wgldef.h"
|
|
|
|
/******************************Public*Routine******************************\
|
|
*
|
|
* __wglSetProcTable
|
|
*
|
|
* Callback function given to ICDs to set a proc table
|
|
*
|
|
\**************************************************************************/
|
|
|
|
void APIENTRY
|
|
__wglSetProcTable(PGLCLTPROCTABLE pglCltProcTable)
|
|
{
|
|
if (pglCltProcTable == (PGLCLTPROCTABLE) NULL)
|
|
return;
|
|
|
|
// It must have either 306 entries for version 1.0 or 336 entries for 1.1
|
|
|
|
if (pglCltProcTable->cEntries != OPENGL_VERSION_100_ENTRIES &&
|
|
pglCltProcTable->cEntries != OPENGL_VERSION_110_ENTRIES)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// This function is called by client drivers which do not use
|
|
// the EXT procs provided by opengl32. Use the null EXT proc
|
|
// table to disable those stubs since they should never be
|
|
// called anyway
|
|
SetCltProcTable(pglCltProcTable, &glNullExtProcTable, TRUE);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
*
|
|
* CheckDeviceModes
|
|
*
|
|
* Ensures that the HDC doesn't have any disallowed state
|
|
*
|
|
* History:
|
|
* Mon Aug 26 15:03:28 1996 -by- Drew Bliss [drewb]
|
|
* Split from wglMakeCurrent
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL CheckDeviceModes(HDC hdc)
|
|
{
|
|
SIZE szW, szV;
|
|
XFORM xform;
|
|
POINT pt;
|
|
HRGN hrgnTmp;
|
|
int iRgn;
|
|
|
|
// For release 1, GDI transforms must be identity.
|
|
// This is to allow GDI transform binding in future.
|
|
|
|
switch (GetMapMode(hdc))
|
|
{
|
|
case MM_TEXT:
|
|
break;
|
|
case MM_ANISOTROPIC:
|
|
if (!GetWindowExtEx(hdc, &szW)
|
|
|| !GetViewportExtEx(hdc, &szV)
|
|
|| szW.cx != szV.cx
|
|
|| szW.cy != szV.cy)
|
|
goto wglMakeCurrent_xform_error;
|
|
break;
|
|
default:
|
|
goto wglMakeCurrent_xform_error;
|
|
}
|
|
|
|
if (!GetViewportOrgEx(hdc, &pt) || pt.x != 0 || pt.y != 0)
|
|
goto wglMakeCurrent_xform_error;
|
|
|
|
if (!GetWindowOrgEx(hdc, &pt) || pt.x != 0 || pt.y != 0)
|
|
goto wglMakeCurrent_xform_error;
|
|
|
|
if (!GetWorldTransform(hdc, &xform))
|
|
{
|
|
// Win95 does not support GetWorldTransform.
|
|
|
|
if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
|
|
goto wglMakeCurrent_xform_error;
|
|
}
|
|
else if (xform.eDx != 0.0f || xform.eDy != 0.0f
|
|
|| xform.eM12 != 0.0f || xform.eM21 != 0.0f
|
|
|| xform.eM11 < 0.999f || xform.eM11 > 1.001f // allow rounding errors
|
|
|| xform.eM22 < 0.999f || xform.eM22 > 1.001f)
|
|
{
|
|
wglMakeCurrent_xform_error:
|
|
DBGERROR("wglMakeCurrent: GDI transforms not identity\n");
|
|
SetLastError(ERROR_TRANSFORM_NOT_SUPPORTED);
|
|
return FALSE;
|
|
}
|
|
|
|
// For release 1, GDI clip region is not allowed.
|
|
// This is to allow GDI clip region binding in future.
|
|
|
|
if (!(hrgnTmp = CreateRectRgn(0, 0, 0, 0)))
|
|
return FALSE;
|
|
|
|
iRgn = GetClipRgn(hdc, hrgnTmp);
|
|
|
|
if (!DeleteObject(hrgnTmp))
|
|
ASSERTOPENGL(FALSE, "DeleteObject failed");
|
|
|
|
switch (iRgn)
|
|
{
|
|
case -1: // error
|
|
WARNING("wglMakeCurrent: GetClipRgn failed\n");
|
|
return FALSE;
|
|
|
|
case 0: // no initial clip region
|
|
break;
|
|
|
|
case 1: // has initial clip region
|
|
DBGERROR("wglMakeCurrent: GDI clip region not allowed\n");
|
|
SetLastError(ERROR_CLIPPING_NOT_SUPPORTED);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
*
|
|
* MakeAnyCurrent
|
|
*
|
|
* Makes any type of context current
|
|
*
|
|
* History:
|
|
* Mon Aug 26 15:00:44 1996 -by- Drew Bliss [drewb]
|
|
* Created
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL MakeAnyCurrent(HGLRC hrc, int ipfd, DWORD dwObjectType,
|
|
GLWINDOWID *pgwid)
|
|
{
|
|
HGLRC hrcSrv;
|
|
PLRC plrc;
|
|
DWORD tidCurrent;
|
|
ULONG irc;
|
|
PLHE plheRC;
|
|
PGLCLTPROCTABLE pglProcTable;
|
|
PGLEXTPROCTABLE pglExtProcTable;
|
|
POLYARRAY *pa;
|
|
|
|
DBGENTRY("wglMakeCurrent\n");
|
|
|
|
// If this is a new, uninitialized thread, try to initialize it
|
|
if (CURRENT_GLTEBINFO() == NULL)
|
|
{
|
|
GLInitializeThread(DLL_THREAD_ATTACH);
|
|
|
|
// If the teb was not set up at thread initialization, return failure.
|
|
|
|
if (!CURRENT_GLTEBINFO())
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
// There are four cases:
|
|
//
|
|
// 1. hrc is NULL and there is no current RC.
|
|
// 2. hrc is NULL and there is a current RC.
|
|
// 3. hrc is not NULL and there is a current RC.
|
|
// 4. hrc is not NULL and there is no current RC.
|
|
|
|
// Case 1: hrc is NULL and there is no current RC.
|
|
// This is a noop, return success.
|
|
|
|
if (hrc == (HGLRC) 0 && (GLTEB_CLTCURRENTRC() == (PLRC) NULL))
|
|
return(TRUE);
|
|
|
|
// Case 2: hrc is NULL and there is a current RC.
|
|
// Make the current RC inactive.
|
|
|
|
if (hrc == (HGLRC) 0 && (GLTEB_CLTCURRENTRC() != (PLRC) NULL))
|
|
return(bMakeNoCurrent());
|
|
|
|
// Get the current thread id.
|
|
|
|
tidCurrent = GetCurrentThreadId();
|
|
ASSERTOPENGL(tidCurrent != INVALID_THREAD_ID,
|
|
"wglMakeCurrent: GetCurrentThreadId returned a bad value\n");
|
|
|
|
// Validate the handles. hrc is not NULL here.
|
|
|
|
ASSERTOPENGL(hrc != (HGLRC) NULL, "wglMakeCurrent: hrc is NULL\n");
|
|
|
|
// Validate the RC.
|
|
|
|
if (cLockHandle((ULONG_PTR)hrc) <= 0)
|
|
{
|
|
DBGLEVEL1(LEVEL_ERROR, "wglMakeCurrent: can't lock hrc 0x%lx\n", hrc);
|
|
goto wglMakeCurrent_error_nolock;
|
|
}
|
|
irc = MASKINDEX(hrc);
|
|
plheRC = pLocalTable + irc;
|
|
plrc = (PLRC) plheRC->pv;
|
|
hrcSrv = (HGLRC) plheRC->hgre;
|
|
ASSERTOPENGL(plrc->ident == LRC_IDENTIFIER, "wglMakeCurrent: Bad plrc\n");
|
|
|
|
#ifdef GL_METAFILE
|
|
// Ensure that metafile RC's are made current only to
|
|
// metafile DC's
|
|
if (plrc->uiGlsCaptureContext != 0 && dwObjectType != OBJ_ENHMETADC)
|
|
{
|
|
DBGLEVEL(LEVEL_ERROR,
|
|
"wglMakeCurrent: attempt to make meta RC current "
|
|
"to non-meta DC\n");
|
|
SetLastError(ERROR_INVALID_HANDLE);
|
|
vUnlockHandle((ULONG_PTR)hrc);
|
|
return FALSE;
|
|
}
|
|
|
|
// Ensure that non-metafile RC's are made current only to
|
|
// non-metafile DC's
|
|
if (plrc->uiGlsCaptureContext == 0 && dwObjectType == OBJ_ENHMETADC)
|
|
{
|
|
DBGLEVEL(LEVEL_ERROR,
|
|
"wglMakeCurrent: attempt to make non-meta RC current "
|
|
"to meta DC\n");
|
|
SetLastError(ERROR_METAFILE_NOT_SUPPORTED);
|
|
vUnlockHandle((ULONG_PTR)hrc);
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
// If the RC is current, it must be current to this thread because
|
|
// makecurrent locks down the handle.
|
|
// If the given RC is already current to this thread, we will release it first,
|
|
// then make it current again. This is to support DC/RC attribute bindings in
|
|
// this function.
|
|
|
|
ASSERTOPENGL(plrc->tidCurrent == INVALID_THREAD_ID ||
|
|
plrc->tidCurrent == tidCurrent,
|
|
"wglMakeCurrent: hrc is current to another thread\n");
|
|
|
|
// Case 3: hrc is not NULL and there is a current RC.
|
|
// This is case 2 followed by case 4.
|
|
|
|
if (GLTEB_CLTCURRENTRC())
|
|
{
|
|
// First, make the current RC inactive.
|
|
|
|
if (!bMakeNoCurrent())
|
|
{
|
|
DBGERROR("wglMakeCurrent: bMakeNoCurrent failed\n");
|
|
vUnlockHandle((ULONG_PTR)hrc);
|
|
return(FALSE);
|
|
}
|
|
|
|
// Second, make hrc current. Fall through to case 4.
|
|
}
|
|
|
|
// Case 4: hrc is not NULL and there is no current RC.
|
|
|
|
ASSERTOPENGL(GLTEB_CLTCURRENTRC() == (PLRC) NULL,
|
|
"wglMakeCurrent: There is a current RC!\n");
|
|
|
|
// If the pixel format of the window or surface is different from that of
|
|
// the RC, return error.
|
|
|
|
if (ipfd != plrc->iPixelFormat)
|
|
{
|
|
DBGERROR("wglMakeCurrent: different hdc and hrc pixel formats\n");
|
|
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
|
goto wglMakeCurrent_error;
|
|
}
|
|
|
|
// Since the client code manages the function table, we will make
|
|
// either the server or the driver current.
|
|
|
|
if (!plrc->dhrc)
|
|
{
|
|
// If this is a generic format, tell the server to make it current.
|
|
|
|
#ifndef _CLIENTSIDE_
|
|
// If the subbatch data has not been set up for this thread, set it up now.
|
|
|
|
if (GLTEB_CLTSHAREDSECTIONINFO() == NULL)
|
|
{
|
|
if (!glsbCreateAndDuplicateSection(SHARED_SECTION_SIZE))
|
|
{
|
|
WARNING("wglMakeCurrent: unable to create section\n");
|
|
goto wglMakeCurrent_error;
|
|
}
|
|
}
|
|
#endif // !_CLIENTSIDE_
|
|
|
|
if (!__wglMakeCurrent(pgwid, hrcSrv, plrc->uiGlsCaptureContext != 0))
|
|
{
|
|
DBGERROR("wglMakeCurrent: server failed\n");
|
|
goto wglMakeCurrent_error;
|
|
}
|
|
|
|
// Get the generic function table or metafile function table
|
|
|
|
#ifdef GL_METAFILE
|
|
if (plrc->fCapturing)
|
|
{
|
|
MetaGlProcTables(&pglProcTable, &pglExtProcTable);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
// Use RGBA or CI proc table depending on the color mode.
|
|
|
|
// The gc should be available by now.
|
|
__GL_SETUP();
|
|
|
|
if (gc->modes.colorIndexMode)
|
|
pglProcTable = &glCltCIProcTable;
|
|
else
|
|
pglProcTable = &glCltRGBAProcTable;
|
|
pglExtProcTable = &glExtProcTable;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If this is a device format, tell the driver to make it current.
|
|
// Get the driver function table from the driver.
|
|
// pfnDrvSetContext returns the address of the driver OpenGL function
|
|
// table if successful; NULL otherwise.
|
|
|
|
ASSERTOPENGL(plrc->pGLDriver, "wglMakeCurrent: No GLDriver\n");
|
|
|
|
pglProcTable = plrc->pGLDriver->pfnDrvSetContext(pgwid->hdc,
|
|
plrc->dhrc,
|
|
__wglSetProcTable);
|
|
if (pglProcTable == (PGLCLTPROCTABLE) NULL)
|
|
{
|
|
DBGERROR("wglMakeCurrent: pfnDrvSetContext failed\n");
|
|
goto wglMakeCurrent_error;
|
|
}
|
|
|
|
// It must have either 306 entries for version 1.0 or 336 entries for 1.1
|
|
|
|
if (pglProcTable->cEntries != OPENGL_VERSION_100_ENTRIES &&
|
|
pglProcTable->cEntries != OPENGL_VERSION_110_ENTRIES)
|
|
{
|
|
DBGERROR("wglMakeCurrent: pfnDrvSetContext returned bad table\n");
|
|
plrc->pGLDriver->pfnDrvReleaseContext(plrc->dhrc);
|
|
SetLastError(ERROR_BAD_DRIVER);
|
|
goto wglMakeCurrent_error;
|
|
}
|
|
|
|
DBGLEVEL1(LEVEL_INFO, "wglMakeCurrent: driver function table 0x%lx\n",
|
|
pglProcTable);
|
|
|
|
// Always use the null EXT proc table since client drivers don't
|
|
// use opengl32's stubs for EXT procs
|
|
pglExtProcTable = &glNullExtProcTable;
|
|
}
|
|
|
|
// Make hrc current.
|
|
|
|
plrc->tidCurrent = tidCurrent;
|
|
plrc->gwidCurrent = *pgwid;
|
|
GLTEB_SET_CLTCURRENTRC(plrc);
|
|
SetCltProcTable(pglProcTable, pglExtProcTable, TRUE);
|
|
|
|
#ifdef GL_METAFILE
|
|
// Set up metafile context if necessary
|
|
if (plrc->fCapturing)
|
|
{
|
|
__GL_SETUP();
|
|
|
|
ActivateMetaRc(plrc, pgwid->hdc);
|
|
|
|
// Set the metafile's base dispatch table by resetting
|
|
// the proc table. Since we know we're capturing, this
|
|
// will cause the GLS capture exec table to be updated
|
|
// with the RGBA or CI proc table, preparing the
|
|
// GLS context for correct passthrough
|
|
|
|
if (gc->modes.colorIndexMode)
|
|
pglProcTable = &glCltCIProcTable;
|
|
else
|
|
pglProcTable = &glCltRGBAProcTable;
|
|
pglExtProcTable = &glExtProcTable;
|
|
SetCltProcTable(pglProcTable, pglExtProcTable, FALSE);
|
|
}
|
|
#endif
|
|
|
|
// Initialize polyarray structure in the TEB.
|
|
|
|
pa = GLTEB_CLTPOLYARRAY();
|
|
pa->flags = 0; // not in begin mode
|
|
if (!plrc->dhrc)
|
|
{
|
|
POLYMATERIAL *pm;
|
|
__GL_SETUP();
|
|
|
|
pa->pdBufferNext = &gc->vertex.pdBuf[0];
|
|
pa->pdBuffer0 = &gc->vertex.pdBuf[0];
|
|
pa->pdBufferMax = &gc->vertex.pdBuf[gc->vertex.pdBufSize - 1];
|
|
// reset next DPA message offset
|
|
pa->nextMsgOffset = PA_nextMsgOffset_RESET_VALUE;
|
|
|
|
// Vertex buffer size may have changed. For example, a generic gc's
|
|
// vertex buffer may be of a different size than a MCD vertex buffer.
|
|
// If it has changed, free the polymaterial array and realloc it later.
|
|
|
|
pm = GLTEB_CLTPOLYMATERIAL();
|
|
if (pm)
|
|
{
|
|
if (pm->aMatSize !=
|
|
gc->vertex.pdBufSize * 2 / POLYMATERIAL_ARRAY_SIZE + 1)
|
|
FreePolyMaterial();
|
|
}
|
|
}
|
|
|
|
// Keep the handle locked while it is current.
|
|
|
|
return(TRUE);
|
|
|
|
// An error has occured, release the current RC.
|
|
|
|
wglMakeCurrent_error:
|
|
vUnlockHandle((ULONG_PTR)hrc);
|
|
wglMakeCurrent_error_nolock:
|
|
if (GLTEB_CLTCURRENTRC() != (PLRC) NULL)
|
|
(void) bMakeNoCurrent();
|
|
return(FALSE);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
*
|
|
* WindowIdFromHdc
|
|
*
|
|
* Fills out a GLWINDOWID for an HDC
|
|
*
|
|
* History:
|
|
* Wed Aug 28 18:33:19 1996 -by- Drew Bliss [drewb]
|
|
* Created
|
|
*
|
|
\**************************************************************************/
|
|
|
|
void APIENTRY WindowIdFromHdc(HDC hdc, GLWINDOWID *pgwid)
|
|
{
|
|
LPDIRECTDRAWSURFACE pdds;
|
|
HDC hdcDriver;
|
|
|
|
if (pfnGetSurfaceFromDC != NULL &&
|
|
pfnGetSurfaceFromDC(hdc, &pdds, &hdcDriver) == DD_OK)
|
|
{
|
|
// Release reference on the surface since this surface value
|
|
// is only used as an identifier.
|
|
pdds->lpVtbl->Release(pdds);
|
|
|
|
pgwid->iType = GLWID_DDRAW;
|
|
pgwid->hwnd = NULL;
|
|
pgwid->hdc = hdcDriver;
|
|
pgwid->pdds = pdds;
|
|
}
|
|
else
|
|
{
|
|
pgwid->hdc = hdc;
|
|
pgwid->hwnd = WindowFromDC(hdc);
|
|
if (pgwid->hwnd == NULL)
|
|
{
|
|
pgwid->iType = GLWID_HDC;
|
|
}
|
|
else
|
|
{
|
|
pgwid->iType = GLWID_HWND;
|
|
}
|
|
pgwid->pdds = NULL;
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglMakeCurrent(HDC hdc, HGLRC hrc)
|
|
*
|
|
* Make the hrc current.
|
|
* Both hrc and hdc must have the same pixel format.
|
|
*
|
|
* If an error occurs, the current RC, if any, is made not current!
|
|
*
|
|
* Arguments:
|
|
* hdc - Device context.
|
|
* hrc - Rendering context.
|
|
*
|
|
* History:
|
|
* Tue Oct 26 10:25:26 1993 -by- Hock San Lee [hockl]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
BOOL WINAPI wglMakeCurrent(HDC hdc, HGLRC hrc)
|
|
{
|
|
int iPixelFormat;
|
|
DWORD dwObjectType;
|
|
GLWINDOWID gwid;
|
|
|
|
DBGENTRY("wglMakeCurrent\n");
|
|
|
|
if (GLTEB_CLTCURRENTRC() != NULL)
|
|
{
|
|
// Flush OpenGL calls.
|
|
glFlush();
|
|
|
|
// Avoid HDC validation for simple make-non-current cases
|
|
if (hrc == NULL)
|
|
{
|
|
return bMakeNoCurrent();
|
|
}
|
|
}
|
|
|
|
// Validate the DC.
|
|
|
|
dwObjectType = wglObjectType(hdc);
|
|
switch (dwObjectType)
|
|
{
|
|
case OBJ_DC:
|
|
case OBJ_MEMDC:
|
|
break;
|
|
|
|
case OBJ_ENHMETADC:
|
|
#ifdef GL_METAFILE
|
|
if (pfnGdiAddGlsRecord == NULL)
|
|
{
|
|
DBGLEVEL1(LEVEL_ERROR, "wglMakeCurrent: metafile hdc: 0x%lx\n",
|
|
hdc);
|
|
SetLastError(ERROR_INVALID_HANDLE);
|
|
return FALSE;
|
|
}
|
|
break;
|
|
#else
|
|
DBGLEVEL1(LEVEL_ERROR, "wglMakeCurrent: metafile hdc: 0x%lx\n", hdc);
|
|
SetLastError(ERROR_INVALID_HANDLE);
|
|
return FALSE;
|
|
#endif
|
|
|
|
case OBJ_METADC:
|
|
default:
|
|
// 16-bit metafiles are not supported
|
|
DBGLEVEL1(LEVEL_ERROR, "wglMakeCurrent: bad hdc: 0x%lx\n", hdc);
|
|
SetLastError(ERROR_INVALID_HANDLE);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!CheckDeviceModes(hdc))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
#ifdef GL_METAFILE
|
|
// For metafile RC's, use the reference HDC rather than the
|
|
// metafile DC
|
|
// Skip pixel format checks
|
|
if (dwObjectType == OBJ_ENHMETADC)
|
|
{
|
|
iPixelFormat = 0;
|
|
goto NoPixelFormat;
|
|
}
|
|
#endif
|
|
|
|
// Get the current pixel format of the window or surface.
|
|
// If no pixel format has been set, return error.
|
|
|
|
if (!(iPixelFormat = GetPixelFormat(hdc)))
|
|
{
|
|
WARNING("wglMakeCurrent: No pixel format set in hdc\n");
|
|
return FALSE;
|
|
}
|
|
|
|
#ifdef GL_METAFILE
|
|
NoPixelFormat:
|
|
#endif
|
|
|
|
WindowIdFromHdc(hdc, &gwid);
|
|
return MakeAnyCurrent(hrc, iPixelFormat, dwObjectType, &gwid);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* bMakeNoCurrent
|
|
*
|
|
* Make the current RC inactive.
|
|
*
|
|
* History:
|
|
* Tue Oct 26 10:25:26 1993 -by- Hock San Lee [hockl]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
BOOL bMakeNoCurrent(void)
|
|
{
|
|
BOOL bRet = FALSE; // assume error
|
|
PLRC plrc = GLTEB_CLTCURRENTRC();
|
|
|
|
DBGENTRY("bMakeNoCurrent\n");
|
|
|
|
ASSERTOPENGL(plrc != (PLRC) NULL, "bMakeNoCurrent: No current RC!\n");
|
|
ASSERTOPENGL(plrc->tidCurrent == GetCurrentThreadId(),
|
|
"bMakeNoCurrent: Current RC does not belong to this thread!\n");
|
|
ASSERTOPENGL(plrc->gwidCurrent.iType != GLWID_ERROR,
|
|
"bMakeNoCurrent: Current surface is NULL!\n");
|
|
|
|
if (!plrc->dhrc)
|
|
{
|
|
#ifdef GL_METAFILE
|
|
// Reset metafile context if necessary
|
|
if (plrc->uiGlsCaptureContext != 0)
|
|
{
|
|
DeactivateMetaRc(plrc);
|
|
}
|
|
#endif
|
|
|
|
// If this is a generic format, tell the server to make the current RC inactive.
|
|
|
|
bRet = __wglMakeCurrent(NULL, NULL, FALSE);
|
|
if (!bRet)
|
|
{
|
|
DBGERROR("bMakeNoCurrent: server failed\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If this is a device format, tell the driver to make the current RC inactive.
|
|
|
|
ASSERTOPENGL(plrc->pGLDriver, "wglMakeCurrent: No GLDriver\n");
|
|
|
|
bRet = plrc->pGLDriver->pfnDrvReleaseContext(plrc->dhrc);
|
|
if (!bRet)
|
|
{
|
|
DBGERROR("bMakeNoCurrent: pfnDrvReleaseContext failed\n");
|
|
}
|
|
}
|
|
|
|
// Always make the current RC inactive.
|
|
// The handle is also unlocked when the RC becomes inactive.
|
|
|
|
plrc->tidCurrent = INVALID_THREAD_ID;
|
|
plrc->gwidCurrent.iType = GLWID_ERROR;
|
|
GLTEB_SET_CLTCURRENTRC(NULL);
|
|
SetCltProcTable(&glNullCltProcTable, &glNullExtProcTable, TRUE);
|
|
vUnlockHandle((ULONG_PTR)(plrc->hrc));
|
|
return(bRet);
|
|
}
|