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.
798 lines
23 KiB
798 lines
23 KiB
/******************************Module*Header*******************************\
|
|
* Module Name: dllinit.c
|
|
*
|
|
* (Brief description)
|
|
*
|
|
* Created: 18-Oct-1993 14:13:21
|
|
* Author: Gilman Wong [gilmanw]
|
|
*
|
|
* Copyright (c) 1993 Microsoft Corporation
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include "batchinf.h"
|
|
#include "glteb.h"
|
|
#include "glapi.h"
|
|
#include "glsbcltu.h"
|
|
#ifdef _CLIENTSIDE_
|
|
#include "glscreen.h"
|
|
#include "glgenwin.h"
|
|
#endif //_CLIENTSIDE_
|
|
#include "context.h"
|
|
#include "global.h"
|
|
#include "parray.h"
|
|
#include "gencx.h"
|
|
#include "cpu.h"
|
|
#include "fixed.h"
|
|
|
|
#ifdef _CLIENTSIDE_
|
|
// Global screen access info. This is NULL if screen access is not available.
|
|
|
|
SCREENINFO *gpScreenInfo = NULL;
|
|
|
|
extern GLubyte *dBufFill;
|
|
extern GLubyte *dBufTopLeft;
|
|
|
|
//
|
|
// This global multiply-lookup table helps with pixel-related functions.
|
|
//
|
|
|
|
BYTE gbMulTable[256*256+4];
|
|
BYTE gbSatTable[256+256];
|
|
|
|
//
|
|
// This global inverse-lookup table helps with rasterization setup
|
|
//
|
|
|
|
#define INV_TABLE_SIZE (1 << __GL_VERTEX_FRAC_BITS) * (__GL_MAX_INV_TABLE + 1)
|
|
|
|
__GLfloat invTable[INV_TABLE_SIZE];
|
|
|
|
// Global thread local storage index. Allocated at process attach.
|
|
// This is the slot reserved in thread local storage for per-thread
|
|
// GLTLSINFO structures.
|
|
|
|
static DWORD dwTlsIndex = 0xFFFFFFFF;
|
|
|
|
static BOOL bProcessInitialized = FALSE;
|
|
|
|
// Offset into the TEB where dwTlsIndex is
|
|
// This enables us to directly access our TLS data in the TEB
|
|
|
|
#if defined(_WIN64)
|
|
#define NT_TLS_OFFSET 5248
|
|
#else
|
|
#define NT_TLS_OFFSET 3600
|
|
#endif
|
|
|
|
#define WIN95_TLS_OFFSET 136
|
|
|
|
DWORD dwTlsOffset;
|
|
|
|
// Platform indicator for conditional code
|
|
DWORD dwPlatformId;
|
|
|
|
// Thread count
|
|
LONG lThreadsAttached = 0;
|
|
|
|
// Global header node for the linked list of GLGENwindow structures.
|
|
// The semaphore in the header node is used as the list access semaphore.
|
|
|
|
GLGENwindow gwndHeader;
|
|
|
|
// Synchronization object for pixel formats
|
|
CRITICAL_SECTION gcsPixelFormat;
|
|
|
|
// Protection for palette watcher
|
|
CRITICAL_SECTION gcsPaletteWatcher;
|
|
|
|
#ifdef GL_METAFILE
|
|
BOOL (APIENTRY *pfnGdiAddGlsRecord)(HDC hdc, DWORD cb, BYTE *pb,
|
|
LPRECTL prclBounds);
|
|
BOOL (APIENTRY *pfnGdiAddGlsBounds)(HDC hdc, LPRECTL prclBounds);
|
|
BOOL (APIENTRY *pfnGdiIsMetaPrintDC)(HDC hdc);
|
|
#endif
|
|
|
|
#endif //_CLIENTSIDE_
|
|
|
|
// OpenGL client debug flag
|
|
#if DBG
|
|
long glDebugLevel;
|
|
ULONG glDebugFlags;
|
|
#endif
|
|
|
|
BOOL bDirectScreen = FALSE;
|
|
|
|
PFN_GETSURFACEFROMDC pfnGetSurfaceFromDC = NULL;
|
|
|
|
/******************************Public*Routine******************************\
|
|
*
|
|
* DdbdToCount
|
|
*
|
|
* Converts a DDBD constant to its equivalent number
|
|
*
|
|
* History:
|
|
* Mon Aug 26 14:11:34 1996 -by- Drew Bliss [drewb]
|
|
* Created
|
|
*
|
|
\**************************************************************************/
|
|
|
|
DWORD APIENTRY DdbdToCount(DWORD ddbd)
|
|
{
|
|
switch(ddbd)
|
|
{
|
|
case DDBD_1:
|
|
return 1;
|
|
case DDBD_2:
|
|
return 2;
|
|
case DDBD_4:
|
|
return 4;
|
|
case DDBD_8:
|
|
return 8;
|
|
case DDBD_16:
|
|
return 16;
|
|
case DDBD_24:
|
|
return 24;
|
|
case DDBD_32:
|
|
return 32;
|
|
}
|
|
ASSERTOPENGL(FALSE, "DdbdToCount: Invalid ddbd\n");
|
|
return 0;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* GLInitializeProcess
|
|
*
|
|
* Called from OPENGL32.DLL entry point for PROCESS_ATTACH.
|
|
*
|
|
* History:
|
|
* 01-Nov-1994 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
BOOL GLInitializeProcess()
|
|
{
|
|
PVOID pv;
|
|
#ifdef _CLIENTSIDE_
|
|
OSVERSIONINFO osvi;
|
|
#endif
|
|
|
|
// Attempt to locate GDI exports for metafiling support
|
|
{
|
|
HMODULE hdll;
|
|
|
|
hdll = GetModuleHandleA("gdi32");
|
|
ASSERTOPENGL(hdll != NULL, "Unable to get gdi32 handle\n");
|
|
*(PROC *)&pfnGdiAddGlsRecord = GetProcAddress(hdll, "GdiAddGlsRecord");
|
|
*(PROC *)&pfnGdiAddGlsBounds = GetProcAddress(hdll, "GdiAddGlsBounds");
|
|
*(PROC *)&pfnGdiIsMetaPrintDC = GetProcAddress(hdll,
|
|
"GdiIsMetaPrintDC");
|
|
|
|
#ifdef ALLOW_DDRAW_SURFACES
|
|
hdll = GetModuleHandleA("ddraw");
|
|
ASSERTOPENGL(hdll != NULL, "Unable to get ddraw handle\n");
|
|
pfnGetSurfaceFromDC = (PFN_GETSURFACEFROMDC)
|
|
GetProcAddress(hdll, "GetSurfaceFromDC");
|
|
#endif
|
|
}
|
|
|
|
#if DBG
|
|
#define STR_OPENGL_DEBUG (PCSTR)"Software\\Microsoft\\Windows\\CurrentVersion\\DebugOpenGL"
|
|
{
|
|
HKEY hkDebug;
|
|
|
|
// Initialize debugging level and flags.
|
|
|
|
glDebugLevel = LEVEL_ERROR;
|
|
glDebugFlags = 0;
|
|
if ( RegOpenKeyExA(HKEY_LOCAL_MACHINE,
|
|
STR_OPENGL_DEBUG,
|
|
0,
|
|
KEY_QUERY_VALUE,
|
|
&hkDebug) == ERROR_SUCCESS )
|
|
{
|
|
DWORD dwDataType;
|
|
DWORD cjSize;
|
|
long lTmp;
|
|
|
|
cjSize = sizeof(long);
|
|
if ( (RegQueryValueExA(hkDebug,
|
|
(LPSTR) "glDebugLevel",
|
|
(LPDWORD) NULL,
|
|
&dwDataType,
|
|
(LPBYTE) &lTmp,
|
|
&cjSize) == ERROR_SUCCESS) )
|
|
{
|
|
glDebugLevel = lTmp;
|
|
}
|
|
|
|
cjSize = sizeof(long);
|
|
if ( (RegQueryValueExA(hkDebug,
|
|
(LPSTR) "glDebugFlags",
|
|
(LPDWORD) NULL,
|
|
&dwDataType,
|
|
(LPBYTE) &lTmp,
|
|
&cjSize) == ERROR_SUCCESS) )
|
|
{
|
|
glDebugFlags = (ULONG) lTmp;
|
|
}
|
|
|
|
RegCloseKey(hkDebug);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef _CLIENTSIDE_
|
|
// Determine which platform we're running on and remember it
|
|
|
|
osvi.dwOSVersionInfoSize = sizeof(osvi);
|
|
if (!GetVersionEx(&osvi))
|
|
{
|
|
WARNING1("GetVersionEx failed with %d\n", GetLastError());
|
|
goto EH_Fail;
|
|
}
|
|
|
|
dwPlatformId = osvi.dwPlatformId;
|
|
|
|
if (!(
|
|
(dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) ||
|
|
(dwPlatformId == VER_PLATFORM_WIN32_NT
|
|
&& !(osvi.dwMajorVersion == 3 && osvi.dwMinorVersion <= 51)
|
|
)
|
|
)
|
|
)
|
|
{
|
|
WARNING("DLL must be run on NT 4.0 or Win95");
|
|
goto EH_Fail;
|
|
}
|
|
|
|
// Allocate a thread local storage slot.
|
|
|
|
if ( (dwTlsIndex = TlsAlloc()) == 0xFFFFFFFF )
|
|
{
|
|
WARNING("DllInitialize: TlsAlloc failed\n");
|
|
goto EH_Fail;
|
|
}
|
|
|
|
// Set up the offset to the TLS slot, OS-specific
|
|
|
|
if (dwPlatformId == VER_PLATFORM_WIN32_NT)
|
|
{
|
|
ASSERTOPENGL(FIELD_OFFSET(TEB, TlsSlots) == NT_TLS_OFFSET,
|
|
"NT TLS offset not at expected location");
|
|
|
|
dwTlsOffset = dwTlsIndex*sizeof(DWORD_PTR)+NT_TLS_OFFSET;
|
|
}
|
|
|
|
#if !defined(_WIN64)
|
|
|
|
else
|
|
{
|
|
// We don't have Win95's TIB type available so the assert is
|
|
// slightly different
|
|
ASSERTOPENGL(((ULONG_PTR)(NtCurrentTeb()->ThreadLocalStoragePointer)-
|
|
(ULONG_PTR)NtCurrentTeb()) == WIN95_TLS_OFFSET,
|
|
"Win95 TLS offset not at expected location");
|
|
|
|
dwTlsOffset = dwTlsIndex*sizeof(DWORD)+WIN95_TLS_OFFSET;
|
|
}
|
|
|
|
#endif
|
|
#endif
|
|
|
|
// Reserve memory for the local handle table.
|
|
|
|
if ( (pLocalTable = (PLHE) VirtualAlloc (
|
|
(LPVOID) NULL, // let base locate it
|
|
MAX_HANDLES*sizeof(LHE),
|
|
MEM_RESERVE | MEM_TOP_DOWN,
|
|
PAGE_READWRITE
|
|
)) == (PLHE) NULL )
|
|
{
|
|
WARNING("DllInitialize: VirtualAlloc failed\n");
|
|
goto EH_TlsIndex;
|
|
}
|
|
|
|
// Initialize the local handle manager semaphore.
|
|
__try
|
|
{
|
|
INITIALIZECRITICALSECTION(&semLocal);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
goto EH_LocalTable;
|
|
}
|
|
|
|
#ifdef _CLIENTSIDE_
|
|
// Initialize the GLGENwindow list semaphore.
|
|
__try
|
|
{
|
|
INITIALIZECRITICALSECTION(&gwndHeader.sem);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
goto EH_semLocal;
|
|
}
|
|
gwndHeader.pNext = &gwndHeader;
|
|
|
|
// Initialize the pixel format critical section
|
|
__try
|
|
{
|
|
INITIALIZECRITICALSECTION(&gcsPixelFormat);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
goto EH_gwndHeader;
|
|
}
|
|
|
|
// Initialize the palette watcher critical section.
|
|
__try
|
|
{
|
|
INITIALIZECRITICALSECTION(&gcsPaletteWatcher);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
goto EH_PixelFormat;
|
|
}
|
|
|
|
// Initialize direct screen access.
|
|
|
|
if (GetSystemMetrics(SM_CMONITORS) > 1)
|
|
{
|
|
gpScreenInfo = NULL;
|
|
}
|
|
else
|
|
{
|
|
#if _WIN32_WINNT >= 0x0501
|
|
BOOL wow64Process;
|
|
|
|
if (IsWow64Process(GetCurrentProcess(), &wow64Process) && wow64Process)
|
|
gpScreenInfo = NULL;
|
|
else
|
|
#endif
|
|
gpScreenInfo = (SCREENINFO *)ALLOCZ(sizeof(SCREENINFO));
|
|
}
|
|
|
|
if ( gpScreenInfo )
|
|
{
|
|
UINT uiOldErrorMode;
|
|
HRESULT hr;
|
|
|
|
// We want to ensure that DDraw doesn't pop up any message
|
|
// boxes on failure when we call DirectDrawCreate. DDraw
|
|
// does errors on a different thread which it creates just
|
|
// for the error. It waits for the error to complete before
|
|
// returning. This function is running inside the loader
|
|
// DllInitialize critical section, though, so other threads
|
|
// do not get to run, causing a deadlock.
|
|
// Force the error mode to get around this.
|
|
uiOldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
|
|
hr = DirectDrawCreate(NULL, &gpScreenInfo->pdd, NULL);
|
|
|
|
SetErrorMode(uiOldErrorMode);
|
|
|
|
if (hr == DD_OK)
|
|
{
|
|
hr = gpScreenInfo->pdd->lpVtbl->
|
|
SetCooperativeLevel(gpScreenInfo->pdd, NULL, DDSCL_NORMAL);
|
|
|
|
if (hr == DD_OK)
|
|
{
|
|
gpScreenInfo->gdds.ddsd.dwSize = sizeof(DDSURFACEDESC);
|
|
gpScreenInfo->gdds.ddsd.dwFlags = DDSD_CAPS;
|
|
gpScreenInfo->gdds.ddsd.ddsCaps.dwCaps =
|
|
DDSCAPS_PRIMARYSURFACE;
|
|
hr = gpScreenInfo->pdd->lpVtbl->
|
|
CreateSurface(gpScreenInfo->pdd, &gpScreenInfo->gdds.ddsd,
|
|
&gpScreenInfo->gdds.pdds, NULL);
|
|
}
|
|
|
|
if (hr == DD_OK)
|
|
{
|
|
#if DBG
|
|
|
|
#define LEVEL_SCREEN LEVEL_INFO
|
|
|
|
gpScreenInfo->gdds.pdds->lpVtbl->
|
|
GetSurfaceDesc(gpScreenInfo->gdds.pdds,
|
|
&gpScreenInfo->gdds.ddsd);
|
|
DBGLEVEL (LEVEL_SCREEN, "=============================\n");
|
|
DBGLEVEL (LEVEL_SCREEN, "Direct screen access enabled for OpenGL\n\n");
|
|
DBGLEVEL (LEVEL_SCREEN, "Surface info:\n");
|
|
DBGLEVEL1(LEVEL_SCREEN, "\tdwSize = 0x%lx\n",
|
|
gpScreenInfo->gdds.ddsd.dwSize);
|
|
DBGLEVEL1(LEVEL_SCREEN, "\tdwWidth = %ld\n",
|
|
gpScreenInfo->gdds.ddsd.dwWidth);
|
|
DBGLEVEL1(LEVEL_SCREEN, "\tdwHeight = %ld\n",
|
|
gpScreenInfo->gdds.ddsd.dwHeight);
|
|
DBGLEVEL1(LEVEL_SCREEN, "\tlStride = 0x%lx\n",
|
|
gpScreenInfo->gdds.ddsd.lPitch);
|
|
DBGLEVEL1(LEVEL_SCREEN, "\tdwBitCount = %ld\n",
|
|
gpScreenInfo->gdds.ddsd.ddpfPixelFormat.dwRGBBitCount);
|
|
|
|
gpScreenInfo->gdds.pdds->lpVtbl->
|
|
Lock(gpScreenInfo->gdds.pdds,
|
|
NULL, &gpScreenInfo->gdds.ddsd,
|
|
DDLOCK_SURFACEMEMORYPTR, NULL);
|
|
DBGLEVEL1(LEVEL_SCREEN, "\tdwOffSurface = 0x%lx\n",
|
|
gpScreenInfo->gdds.ddsd.lpSurface);
|
|
gpScreenInfo->gdds.pdds->lpVtbl->
|
|
Unlock(gpScreenInfo->gdds.pdds, gpScreenInfo->gdds.ddsd.lpSurface);
|
|
DBGLEVEL (LEVEL_SCREEN, "=============================\n");
|
|
#endif
|
|
|
|
// Verify screen access
|
|
|
|
if (gpScreenInfo->gdds.pdds->lpVtbl->
|
|
GetSurfaceDesc(gpScreenInfo->gdds.pdds,
|
|
&gpScreenInfo->gdds.ddsd) != DD_OK ||
|
|
gpScreenInfo->gdds.pdds->lpVtbl->
|
|
Lock(gpScreenInfo->gdds.pdds,
|
|
NULL, &gpScreenInfo->gdds.ddsd,
|
|
DDLOCK_SURFACEMEMORYPTR, NULL) != DD_OK)
|
|
{
|
|
DBGLEVEL(LEVEL_SCREEN,
|
|
"Direct screen access failure : disabling\n");
|
|
}
|
|
else
|
|
{
|
|
gpScreenInfo->gdds.dwBitDepth =
|
|
DdPixDepthToCount(gpScreenInfo->gdds.ddsd.
|
|
ddpfPixelFormat.dwRGBBitCount);
|
|
gpScreenInfo->gdds.pdds->lpVtbl->
|
|
Unlock(gpScreenInfo->gdds.pdds,
|
|
gpScreenInfo->gdds.ddsd.lpSurface);
|
|
|
|
bDirectScreen = TRUE;
|
|
}
|
|
}
|
|
#if DBG
|
|
else
|
|
{
|
|
DBGLEVEL (LEVEL_SCREEN, "=============================\n");
|
|
DBGLEVEL2(LEVEL_SCREEN,
|
|
"Screen access failed code 0x%08lX (%s)\n",
|
|
hr, (hr == DDERR_NOTFOUND) ? "DDERR_NOTFOUND" :
|
|
"unknown");
|
|
DBGLEVEL (LEVEL_SCREEN, "=============================\n");
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
DBGLEVEL(LEVEL_SCREEN, "DirectDrawCreate failed\n");
|
|
}
|
|
}
|
|
|
|
if (!bDirectScreen)
|
|
{
|
|
if (gpScreenInfo)
|
|
{
|
|
if (gpScreenInfo->gdds.pdds)
|
|
{
|
|
gpScreenInfo->gdds.pdds->lpVtbl->
|
|
Release(gpScreenInfo->gdds.pdds);
|
|
}
|
|
if (gpScreenInfo->pdd)
|
|
{
|
|
gpScreenInfo->pdd->lpVtbl->Release(gpScreenInfo->pdd);
|
|
}
|
|
FREE(gpScreenInfo);
|
|
gpScreenInfo = NULL;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
// Set up our multiplication table:
|
|
|
|
{
|
|
BYTE *pMulTable = gbMulTable;
|
|
ULONG i, j;
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
ULONG tmp = 0;
|
|
|
|
for (j = 0; j < 256; j++, tmp += i) {
|
|
*pMulTable++ = (BYTE)(tmp >> 8);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set up our saturation table:
|
|
|
|
{
|
|
ULONG i;
|
|
|
|
for (i = 0; i < 256; i++)
|
|
gbSatTable[i] = (BYTE)i;
|
|
|
|
for (; i < (256+256); i++)
|
|
gbSatTable[i] = 255;
|
|
}
|
|
|
|
// Set up inverse-lookup table:
|
|
|
|
{
|
|
__GLfloat accum = (__GLfloat)(1.0 / (__GLfloat)__GL_VERTEX_FRAC_ONE);
|
|
GLint i;
|
|
|
|
invTable[0] = (__GLfloat)0.0;
|
|
|
|
for (i = 1; i < INV_TABLE_SIZE; i++) {
|
|
|
|
invTable[i] = __glOne / accum;
|
|
accum += (__GLfloat)(1.0 / (__GLfloat)__GL_VERTEX_FRAC_ONE);
|
|
}
|
|
}
|
|
|
|
bProcessInitialized = TRUE;
|
|
|
|
return TRUE;
|
|
|
|
EH_PixelFormat:
|
|
DELETECRITICALSECTION(&gcsPixelFormat);
|
|
EH_gwndHeader:
|
|
DELETECRITICALSECTION(&gwndHeader.sem);
|
|
EH_semLocal:
|
|
DELETECRITICALSECTION(&semLocal);
|
|
EH_LocalTable:
|
|
VirtualFree(pLocalTable, 0, MEM_RELEASE);
|
|
EH_TlsIndex:
|
|
TlsFree(dwTlsIndex);
|
|
dwTlsIndex = 0xFFFFFFFF;
|
|
EH_Fail:
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* GLUnInitializeProcess
|
|
*
|
|
* Called from OPENGL32.DLL entry point for PROCESS_DETACH.
|
|
*
|
|
* History:
|
|
* 01-Nov-1994 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
void GLUnInitializeProcess()
|
|
{
|
|
// If we never finished process initialization, quit now.
|
|
|
|
if (!bProcessInitialized)
|
|
return;
|
|
|
|
// Cleanup stray HGLRCs that the app may have forgotten to delete.
|
|
{
|
|
static GLTEBINFO gltebInfoTmp;
|
|
|
|
// Need a temporary GLTEBINFO for this thread in order to do the
|
|
// cleanup processing.
|
|
|
|
ASSERTOPENGL(!CURRENT_GLTEBINFO(),
|
|
"GLUnInitializeProcess: GLTEBINFO not NULL!\n");
|
|
// made static and no longer need memset
|
|
// memset(&gltebInfoTmp, 0, sizeof(gltebInfoTmp));
|
|
SET_CURRENT_GLTEBINFO(&gltebInfoTmp);
|
|
|
|
vCleanupAllLRC();
|
|
|
|
SET_CURRENT_GLTEBINFO((PGLTEBINFO) NULL);
|
|
}
|
|
|
|
// Cleanup window tracking structures (GLGENwindow structs).
|
|
|
|
vCleanupWnd();
|
|
|
|
// Cleanup evaluator arrays
|
|
|
|
if (dBufFill)
|
|
FREE(dBufFill);
|
|
if (dBufTopLeft)
|
|
FREE(dBufTopLeft);
|
|
|
|
// Screen access shutdown.
|
|
|
|
if (gpScreenInfo)
|
|
{
|
|
if (gpScreenInfo->gdds.pdds)
|
|
{
|
|
gpScreenInfo->gdds.pdds->lpVtbl->Release(gpScreenInfo->gdds.pdds);
|
|
}
|
|
if (gpScreenInfo->pdd)
|
|
{
|
|
gpScreenInfo->pdd->lpVtbl->Release(gpScreenInfo->pdd);
|
|
}
|
|
FREE(gpScreenInfo);
|
|
}
|
|
|
|
// Free the TLS slot.
|
|
|
|
if (dwTlsIndex != 0xFFFFFFFF)
|
|
if (!TlsFree(dwTlsIndex))
|
|
RIP("DllInitialize: TlsFree failed\n");
|
|
|
|
// Free the global semaphores.
|
|
|
|
DELETECRITICALSECTION(&gcsPaletteWatcher);
|
|
DELETECRITICALSECTION(&gcsPixelFormat);
|
|
DELETECRITICALSECTION(&gwndHeader.sem);
|
|
DELETECRITICALSECTION(&semLocal);
|
|
|
|
// Free the local handle table.
|
|
|
|
if ( pLocalTable )
|
|
VirtualFree(pLocalTable, 0, MEM_RELEASE);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* GLInitializeThread
|
|
*
|
|
* Called from OPENGL32.DLL entry point for THREAD_ATTACH. May assume that
|
|
* GLInitializeProcess has succeeded.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID GLInitializeThread(ULONG ulReason)
|
|
{
|
|
GLTEBINFO *pglti;
|
|
GLMSGBATCHINFO *pMsgBatchInfo;
|
|
POLYARRAY *pa;
|
|
|
|
#if !defined(_WIN95_) && defined(_X86_)
|
|
{
|
|
TEB *pteb;
|
|
|
|
pteb = NtCurrentTeb();
|
|
|
|
// Set up linear pointers to TEB regions in the TEB
|
|
// this saves an addition when referencing these values
|
|
// This must occur early so that these pointers are available
|
|
// for the rest of thread initialization
|
|
((POLYARRAY *)pteb->glReserved1)->paTeb =
|
|
(POLYARRAY *)pteb->glReserved1;
|
|
pteb->glTable = pteb->glDispatchTable;
|
|
}
|
|
#endif
|
|
|
|
pglti = (GLTEBINFO *)ALLOCZ(sizeof(GLTEBINFO));
|
|
SET_CURRENT_GLTEBINFO(pglti);
|
|
|
|
if (pglti)
|
|
{
|
|
pa = GLTEB_CLTPOLYARRAY();
|
|
pa->flags = 0; // not in begin mode
|
|
|
|
// Save shared section pointer in POLYARRAY for fast pointer access
|
|
pa->pMsgBatchInfo = (PVOID) pglti->glMsgBatchInfo;
|
|
|
|
pMsgBatchInfo = (GLMSGBATCHINFO *) pa->pMsgBatchInfo;
|
|
pMsgBatchInfo->MaximumOffset
|
|
= SHARED_SECTION_SIZE - GLMSG_ALIGN(sizeof(ULONG));
|
|
pMsgBatchInfo->FirstOffset
|
|
= GLMSG_ALIGN(sizeof(GLMSGBATCHINFO));
|
|
pMsgBatchInfo->NextOffset
|
|
= GLMSG_ALIGN(sizeof(GLMSGBATCHINFO));
|
|
SetCltProcTable(&glNullCltProcTable, &glNullExtProcTable, TRUE);
|
|
GLTEB_SET_CLTCURRENTRC(NULL);
|
|
GLTEB_SET_CLTPOLYMATERIAL(NULL);
|
|
GLTEB_SET_CLTDRIVERSLOT(NULL);
|
|
|
|
#if !defined(_WIN95_)
|
|
ASSERTOPENGL((ULONG_PTR) pMsgBatchInfo == GLMSG_ALIGNPTR(pMsgBatchInfo),
|
|
"bad shared memory alignment!\n");
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
// This can be made into a WARNING (debug builds only) later on.
|
|
DbgPrint ("Memory alloc failed for TebInfo structure, thread may AV if GL calls are made without MakeCurrent\n");
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* GLUnInitializeThread
|
|
*
|
|
* Called from OPENGL32.DLL entry point for THREAD_DETACH.
|
|
*
|
|
* The server generic driver should cleanup on its own. Same for the
|
|
* installable driver.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID GLUnInitializeThread(VOID)
|
|
{
|
|
// If we never finished process initialization, quit now.
|
|
|
|
if (!bProcessInitialized)
|
|
return;
|
|
|
|
if (!CURRENT_GLTEBINFO())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (GLTEB_CLTCURRENTRC() != NULL)
|
|
{
|
|
PLRC plrc = GLTEB_CLTCURRENTRC();
|
|
|
|
// May be an application error
|
|
|
|
DBGERROR("GLUnInitializeThread: RC is current when thread exits\n");
|
|
|
|
// Release the RC
|
|
|
|
plrc->tidCurrent = INVALID_THREAD_ID;
|
|
plrc->gwidCurrent.iType = GLWID_ERROR;
|
|
GLTEB_SET_CLTCURRENTRC(NULL);
|
|
vUnlockHandle((ULONG_PTR)(plrc->hrc));
|
|
}
|
|
// GLTEB_SET_CLTPROCTABLE(&glNullCltProcTable,&glNullExtProcTable);
|
|
|
|
if (GLTEB_CLTPOLYMATERIAL())
|
|
FreePolyMaterial();
|
|
|
|
FREE(CURRENT_GLTEBINFO());
|
|
SET_CURRENT_GLTEBINFO(NULL);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* DllInitialize
|
|
*
|
|
* This is the entry point for OPENGL32.DLL, which is called each time
|
|
* a process or thread that is linked to it is created or terminated.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL DllInitialize(HMODULE hModule, ULONG Reason, PVOID Reserved)
|
|
{
|
|
// Do the appropriate task for process and thread attach/detach.
|
|
|
|
DBGLEVEL3(LEVEL_INFO, "DllInitialize: %s Pid %d, Tid %d\n",
|
|
Reason == DLL_PROCESS_ATTACH ? "PROCESS_ATTACH" :
|
|
Reason == DLL_PROCESS_DETACH ? "PROCESS_DETACH" :
|
|
Reason == DLL_THREAD_ATTACH ? "THREAD_ATTACH" :
|
|
Reason == DLL_THREAD_DETACH ? "THREAD_DETACH" :
|
|
"Reason UNKNOWN!",
|
|
GetCurrentProcessId(), GetCurrentThreadId());
|
|
|
|
switch (Reason)
|
|
{
|
|
case DLL_THREAD_ATTACH:
|
|
case DLL_PROCESS_ATTACH:
|
|
|
|
if (Reason == DLL_PROCESS_ATTACH)
|
|
{
|
|
if (!GLInitializeProcess())
|
|
return FALSE;
|
|
}
|
|
|
|
InterlockedIncrement(&lThreadsAttached);
|
|
GLInitializeThread(Reason);
|
|
|
|
break;
|
|
|
|
case DLL_THREAD_DETACH:
|
|
case DLL_PROCESS_DETACH:
|
|
|
|
GLUnInitializeThread();
|
|
InterlockedDecrement(&lThreadsAttached);
|
|
|
|
if ( Reason == DLL_PROCESS_DETACH )
|
|
{
|
|
GLUnInitializeProcess();
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
RIP("DllInitialize: unknown reason!\n");
|
|
break;
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|