dll_main.c

Go to the documentation of this file.

/****************************************************************************
*
*                        Mesa 3-D graphics library
*                        Direct3D Driver Interface
*
*  ========================================================================
*
*   Copyright (C) 1991-2004 SciTech Software, Inc. All rights reserved.
*
*   Permission is hereby granted, free of charge, to any person obtaining a
*   copy of this software and associated documentation files (the "Software"),
*   to deal in the Software without restriction, including without limitation
*   the rights to use, copy, modify, merge, publish, distribute, sublicense,
*   and/or sell copies of the Software, and to permit persons to whom the
*   Software is furnished to do so, subject to the following conditions:
*
*   The above copyright notice and this permission notice shall be included
*   in all copies or substantial portions of the Software.
*
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
*   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
*   SCITECH SOFTWARE INC BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
*   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
*   OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*   SOFTWARE.
*
*  ======================================================================
*
* Language:     ANSI C
* Environment:  Windows 9x (Win32)
*
* Description:  Win32 DllMain functions.
*
****************************************************************************/

// INITGUID must only be defined once.
// Don't put it in a shared header file!
// GLD3 uses dxguid.lib, so INITGUID must *not* be used!
#ifndef _USE_GLD3_WGL
#define INITGUID
#endif // _USE_GLD3_WGL

#include "dllmain.h"

//#include "snap/graphics.h"
//#include "drvlib/os/os.h"

#ifdef _USE_GLD3_WGL
typedef void (APIENTRY *LPDGLSPLASHSCREEN)(int, int, char*);
#include "gld_driver.h"
#endif

// ***********************************************************************

BOOL bInitialized = FALSE;              // callback driver initialized?
BOOL bExited = FALSE;                   // callback driver exited this instance?
HINSTANCE hInstanceDll = NULL;          // DLL instance handle

static BOOL bDriverValidated = FALSE;   // prior validation status
static BOOL bSplashScreen = TRUE;       // Splash Screen ?
static BOOL bValidINIFound = FALSE;     // Have we found a valid INI file?

HHOOK   hKeyHook = NULL;                // global keyboard handler hook

// Multi-threaded support needs to be reflected in Mesa code. (DaveM)
int _gld_bMultiThreaded = FALSE;

// ***********************************************************************

DWORD dwLogging = 0;                    // Logging flag
DWORD dwDebugLevel = 0;                 // Log debug level

char szLogPath[_MAX_PATH] = {"\0"};     // Log file path
char szSNAPPath[_MAX_PATH] = {"\0"};    // SNAP driver path

#ifndef _USE_GLD3_WGL
DGL_wglFuncs wglFuncs = {
    sizeof(DGL_wglFuncs),
    DGL_ChoosePixelFormat,
    DGL_CopyContext,
    DGL_CreateContext,
    DGL_CreateLayerContext,
    DGL_DeleteContext,
    DGL_DescribeLayerPlane,
    DGL_DescribePixelFormat,
    DGL_GetCurrentContext,
    DGL_GetCurrentDC,
    DGL_GetDefaultProcAddress,
    DGL_GetLayerPaletteEntries,
    DGL_GetPixelFormat,
    DGL_GetProcAddress,
    DGL_MakeCurrent,
    DGL_RealizeLayerPalette,
    DGL_SetLayerPaletteEntries,
    DGL_SetPixelFormat,
    DGL_ShareLists,
    DGL_SwapBuffers,
    DGL_SwapLayerBuffers,
    DGL_UseFontBitmapsA,
    DGL_UseFontBitmapsW,
    DGL_UseFontOutlinesA,
    DGL_UseFontOutlinesW,
};

DGL_mesaFuncs mesaFuncs = {
    sizeof(DGL_mesaFuncs),
};
#endif // _USE_GLD3_WGL

// ***********************************************************************

typedef struct {
    DWORD   dwDriver;           // 0=SciTech SW, 1=Direct3D SW, 2=Direct3D HW
    BOOL    bMipmapping;        // 0=off, 1=on
    BOOL    bMultitexture;      // 0=off, 1=on
    BOOL    bWaitForRetrace;    // 0=off, 1=on
    BOOL    bFullscreenBlit;    // 0=off, 1=on
    BOOL    bFastFPU;           // 0=off, 1=on
    BOOL    bDirectDrawPersistant;// 0=off, 1=on
    BOOL    bPersistantBuffers; // 0=off, 1=on
    DWORD   dwLogging;          // 0=off, 1=normal, 2=crash-proof
    DWORD   dwLoggingSeverity;  // 0=all, 1=warnings+errors, 2=errors only
    BOOL    bMessageBoxWarnings;// 0=off, 1=on
    BOOL    bMultiThreaded;     // 0=off, 1=on
    BOOL    bAppCustomizations; // 0=off, 1=on
    BOOL    bHotKeySupport;     // 0=off, 1=on
    BOOL    bSplashScreen;      // 0=off, 1=on

#ifdef _USE_GLD3_WGL
    //
    // New for GLDirect 3.0
    //
    DWORD   dwAdapter;          // DX8 adpater ordinal
    DWORD   dwTnL;              // Transform & Lighting type
    DWORD   dwMultisample;      // DX8 multisample type
#endif // _USE_GLD3_WGL
} INI_settings;

static INI_settings ini;

// ***********************************************************************

BOOL APIENTRY DGL_initDriver(
#ifdef _USE_GLD3_WGL
    void)
{
#else
    DGL_wglFuncs *lpWglFuncs,
    DGL_mesaFuncs *lpMesaFuncs)
{
    // Check for valid pointers
    if ((lpWglFuncs == NULL) || (lpMesaFuncs == NULL))
        return FALSE;

    // Check for valid structs
    if (lpWglFuncs->dwSize != sizeof(DGL_wglFuncs)) {
        return FALSE;
    }

    // Check for valid structs
    if (lpMesaFuncs->dwSize != sizeof(DGL_mesaFuncs)) {
        return FALSE;
    }

    // Copy the Mesa functions
    memcpy(&mesaFuncs, lpMesaFuncs, sizeof(DGL_mesaFuncs));

    // Pass back the wgl functions
    memcpy(lpWglFuncs, &wglFuncs, sizeof(DGL_wglFuncs));
#endif // _USE_GLD3_WGL

    // Finally initialize the callback driver
    if (!dglInitDriver())
        return FALSE;

    return TRUE;
};

// ***********************************************************************

BOOL ReadINIFile(
    HINSTANCE hInstance)
{
    char        szModuleFilename[MAX_PATH];
    char        szSystemDirectory[MAX_PATH];
    const char  szSectionName[] = "Config";
    char        szINIFile[MAX_PATH];
    int         pos;

    // Now using the DLL module handle. KeithH, 24/May/2000.
    // Addendum: GetModuleFileName(NULL, ...    returns process filename,
    //           GetModuleFileName(hModule, ... returns DLL filename,

    // Get the dll path and filename.
    GetModuleFileName(hInstance, &szModuleFilename[0], MAX_PATH); // NULL for current process
    // Get the System directory.
    GetSystemDirectory(&szSystemDirectory[0], MAX_PATH);

    // Test to see if DLL is in system directory.
    if (strnicmp(szModuleFilename, szSystemDirectory, strlen(szSystemDirectory))==0) {
        // DLL *is* in system directory.
        // Return FALSE to indicate that registry keys should be read.
        return FALSE;
    }

    // Compose filename of INI file
    strcpy(szINIFile, szModuleFilename);
    pos = strlen(szINIFile);
    while (szINIFile[pos] != '\\') {
        pos--;
    }
    szINIFile[pos+1] = '\0';
    // Use run-time DLL path for log file too
    strcpy(szLogPath, szINIFile);
    szLogPath[pos] = '\0';
    // Complete full INI file path
    strcat(szINIFile, "gldirect.ini");

    // Read settings from private INI file.
    // Note that defaults are contained in the calls.
    ini.dwDriver = GetPrivateProfileInt(szSectionName, "dwDriver", 2, szINIFile);
    ini.bMipmapping = GetPrivateProfileInt(szSectionName, "bMipmapping", 1, szINIFile);
    ini.bMultitexture = GetPrivateProfileInt(szSectionName, "bMultitexture", 1, szINIFile);
    ini.bWaitForRetrace = GetPrivateProfileInt(szSectionName, "bWaitForRetrace", 0, szINIFile);
    ini.bFullscreenBlit = GetPrivateProfileInt(szSectionName, "bFullscreenBlit", 0, szINIFile);
    ini.bFastFPU = GetPrivateProfileInt(szSectionName, "bFastFPU", 1, szINIFile);
    ini.bDirectDrawPersistant = GetPrivateProfileInt(szSectionName, "bPersistantDisplay", 0, szINIFile);
    ini.bPersistantBuffers = GetPrivateProfileInt(szSectionName, "bPersistantResources", 0, szINIFile);
    ini.dwLogging = GetPrivateProfileInt(szSectionName, "dwLogging", 0, szINIFile);
    ini.dwLoggingSeverity = GetPrivateProfileInt(szSectionName, "dwLoggingSeverity", 0, szINIFile);
    ini.bMessageBoxWarnings = GetPrivateProfileInt(szSectionName, "bMessageBoxWarnings", 0, szINIFile);
    ini.bMultiThreaded = GetPrivateProfileInt(szSectionName, "bMultiThreaded", 0, szINIFile);
    ini.bAppCustomizations = GetPrivateProfileInt(szSectionName, "bAppCustomizations", 1, szINIFile);
    ini.bHotKeySupport = GetPrivateProfileInt(szSectionName, "bHotKeySupport", 0, szINIFile);
    ini.bSplashScreen = GetPrivateProfileInt(szSectionName, "bSplashScreen", 1, szINIFile);

#ifdef _USE_GLD3_WGL
    // New for GLDirect 3.x
    ini.dwAdapter       = GetPrivateProfileInt(szSectionName, "dwAdapter", 0, szINIFile);
    // dwTnL now defaults to zero (chooses TnL at runtime). KeithH
    ini.dwTnL           = GetPrivateProfileInt(szSectionName, "dwTnL", 0, szINIFile);
    ini.dwMultisample   = GetPrivateProfileInt(szSectionName, "dwMultisample", 0, szINIFile);
#endif

    return TRUE;
}

// ***********************************************************************

BOOL dllReadRegistry(
    HINSTANCE hInstance)
{
    // Read settings from INI file, if available
    bValidINIFound = FALSE;
    if (ReadINIFile(hInstance)) {
        const char *szRendering[3] = {
            "SciTech Software Renderer",
            "Direct3D MMX Software Renderer",
            "Direct3D Hardware Renderer"
        };
        // Set globals
        glb.bPrimary = 1;
        glb.bHardware = (ini.dwDriver == 2) ? 1 : 0;
#ifndef _USE_GLD3_WGL
        memset(&glb.ddGuid, 0, sizeof(glb.ddGuid));
        glb.d3dGuid = (ini.dwDriver == 2) ? IID_IDirect3DHALDevice : IID_IDirect3DRGBDevice;
#endif // _USE_GLD3_WGL
        strcpy(glb.szDDName, "Primary");
        strcpy(glb.szD3DName, szRendering[ini.dwDriver]);
        glb.dwRendering = ini.dwDriver;
        glb.bUseMipmaps = ini.bMipmapping;
        glb.bMultitexture = ini.bMultitexture;
        glb.bWaitForRetrace = ini.bWaitForRetrace;
        glb.bFullscreenBlit = ini.bFullscreenBlit;
        glb.bFastFPU = ini.bFastFPU;
        glb.bDirectDrawPersistant = ini.bDirectDrawPersistant;
        glb.bPersistantBuffers = ini.bPersistantBuffers;
        dwLogging = ini.dwLogging;
        dwDebugLevel = ini.dwLoggingSeverity;
        glb.bMessageBoxWarnings = ini.bMessageBoxWarnings;
        glb.bMultiThreaded = ini.bMultiThreaded;
        glb.bAppCustomizations = ini.bAppCustomizations;
        glb.bHotKeySupport = ini.bHotKeySupport;
        bSplashScreen = ini.bSplashScreen;
#ifdef _USE_GLD3_WGL
        // New for GLDirect 3.x
        glb.dwAdapter       = ini.dwAdapter;
        glb.dwDriver        = ini.dwDriver;
        glb.dwTnL           = ini.dwTnL;
        glb.dwMultisample   = ini.dwMultisample;
#endif
        bValidINIFound = TRUE;
        return TRUE;
    }
    // Read settings from registry
    else {
    HKEY    hReg;
    DWORD   cbValSize;
    DWORD   dwType = REG_SZ; // Registry data type for strings
    BOOL    bRegistryError;
    BOOL    bSuccess;

#define REG_READ_DWORD(a, b)                            \
    cbValSize = sizeof(b);                              \
    if (ERROR_SUCCESS != RegQueryValueEx( hReg, (a),    \
        NULL, NULL, (LPBYTE)&(b), &cbValSize ))         \
        bRegistryError = TRUE;

#define REG_READ_DEVICEID(a, b)                                 \
    cbValSize = MAX_DDDEVICEID_STRING;                          \
    if(ERROR_SUCCESS != RegQueryValueEx(hReg, (a), 0, &dwType,  \
                    (LPBYTE)&(b), &cbValSize))                  \
        bRegistryError = TRUE;

#define REG_READ_STRING(a, b)                                   \
    cbValSize = sizeof((b));                                    \
    if(ERROR_SUCCESS != RegQueryValueEx(hReg, (a), 0, &dwType,  \
                    (LPBYTE)&(b), &cbValSize))                  \
        bRegistryError = TRUE;

    // Read settings from the registry.

    // Open the registry key for the current user if it exists.
    bSuccess = (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER,
                                      DIRECTGL_REG_SETTINGS_KEY,
                                      0,
                                      KEY_READ,
                                      &hReg));
    // Otherwise open the registry key for the local machine.
    if (!bSuccess)
        bSuccess = (ERROR_SUCCESS == RegOpenKeyEx(DIRECTGL_REG_KEY_ROOT,
                                      DIRECTGL_REG_SETTINGS_KEY,
                                      0,
                                      KEY_READ,
                                      &hReg));
    if (!bSuccess)
        return FALSE;

    bRegistryError = FALSE;

    REG_READ_DWORD(DIRECTGL_REG_SETTING_PRIMARY, glb.bPrimary);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_D3D_HW, glb.bHardware);
#ifndef _USE_GLD3_WGL
    REG_READ_DWORD(DIRECTGL_REG_SETTING_DD_GUID, glb.ddGuid);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_D3D_GUID, glb.d3dGuid);
#endif // _USE_GLD3_WGL
    REG_READ_DWORD(DIRECTGL_REG_SETTING_LOGGING, dwLogging);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_DEBUGLEVEL, dwDebugLevel);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_RENDERING, glb.dwRendering);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_MULTITEXTURE, glb.bMultitexture);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_WAITFORRETRACE, glb.bWaitForRetrace);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_FULLSCREENBLIT, glb.bFullscreenBlit);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_USEMIPMAPS, glb.bUseMipmaps);

    REG_READ_DEVICEID(DIRECTGL_REG_SETTING_DD_NAME, glb.szDDName);
    REG_READ_DEVICEID(DIRECTGL_REG_SETTING_D3D_NAME, glb.szD3DName);

    REG_READ_DWORD(DIRECTGL_REG_SETTING_MSGBOXWARNINGS, glb.bMessageBoxWarnings);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_PERSISTDISPLAY, glb.bDirectDrawPersistant);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_PERSISTBUFFERS, glb.bPersistantBuffers);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_FASTFPU, glb.bFastFPU);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_HOTKEYS, glb.bHotKeySupport);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_MULTITHREAD, glb.bMultiThreaded);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_APPCUSTOM, glb.bAppCustomizations);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_SPLASHSCREEN, bSplashScreen);

#ifdef _USE_GLD3_WGL
    // New for GLDirect 3.x
    glb.dwDriver = glb.dwRendering;
    REG_READ_DWORD(DIRECTGL_REG_SETTING_ADAPTER, glb.dwAdapter);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_TNL, glb.dwTnL);
    REG_READ_DWORD(DIRECTGL_REG_SETTING_MULTISAMPLE, glb.dwMultisample);
#endif

    RegCloseKey(hReg);

    // Open the global registry key for GLDirect
    bSuccess = (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                                      DIRECTGL_REG_SETTINGS_KEY,
                                      0,
                                      KEY_READ,
                                      &hReg));
    if (bSuccess) {
        // Read the installation path for GLDirect
        REG_READ_STRING("InstallLocation",szLogPath);
        RegCloseKey(hReg);
        }

    if (bRegistryError || !bSuccess)
        return FALSE;
    else
        
        return TRUE;

#undef REG_READ_DWORD
#undef REG_READ_DEVICEID
#undef REG_READ_STRING
    }
}

// ***********************************************************************

BOOL dllWriteRegistry(
    void )
{
    HKEY    hReg;
    DWORD   dwCreateDisposition, cbValSize;
    BOOL    bRegistryError = FALSE;

#define REG_WRITE_DWORD(a, b)                           \
    cbValSize = sizeof(b);                              \
    if (ERROR_SUCCESS != RegSetValueEx( hReg, (a),      \
        0, REG_DWORD, (LPBYTE)&(b), cbValSize ))        \
        bRegistryError = TRUE;

    if (ERROR_SUCCESS == RegCreateKeyEx( DIRECTGL_REG_KEY_ROOT, DIRECTGL_REG_SETTINGS_KEY,
                                        0, NULL, 0, KEY_WRITE, NULL, &hReg,
                                        &dwCreateDisposition )) {
        RegFlushKey(hReg); // Make sure keys are written to disk
        RegCloseKey(hReg);
        hReg = NULL;
        }

    if (bRegistryError)
        return FALSE;
    else
        return TRUE;

#undef REG_WRITE_DWORD
}

// ***********************************************************************

void dglInitHotKeys(HINSTANCE hInstance)
{
    // Hot-Key support at all?
    if (!glb.bHotKeySupport)
        return;

    // Install global keyboard interceptor
    hKeyHook = SetWindowsHookEx(WH_KEYBOARD, dglKeyProc, hInstance, 0);
}

// ***********************************************************************

void dglExitHotKeys(void)
{
    // Hot-Key support at all?
    if (!glb.bHotKeySupport)
        return;

    // Remove global keyboard interceptor
    if (hKeyHook)
        UnhookWindowsHookEx(hKeyHook);
    hKeyHook = NULL;
}

// ***********************************************************************

// Note: This app-customization step must be performed in both the main
// OpenGL32 driver and the callback driver DLLs for multithreading option.
void dglSetAppCustomizations(void)
{
    char        szModuleFileName[MAX_PATH];
    int         iSize = MAX_PATH;

    // Get the currently loaded EXE filename.
    GetModuleFileName(NULL, &szModuleFileName[0], MAX_PATH); // NULL for current process
    strupr(szModuleFileName);
    iSize = strlen(szModuleFileName);

    // Check for specific EXEs and adjust global settings accordingly

    // NOTE: In GLD3.x "bDirectDrawPersistant" corresponds to IDirect3D8 and
    //       "bPersistantBuffers" corresponds to IDirect3DDevice8. KeithH

    // Case 1: 3DStudio must be multi-threaded
    // Added: Discreet GMAX (3DStudio MAX 4 for gamers. KeithH)
    if (strstr(szModuleFileName, "3DSMAX.EXE")
        || strstr(szModuleFileName, "3DSVIZ.EXE")
        || strstr(szModuleFileName, "GMAX.EXE")) {
        glb.bMultiThreaded = TRUE;
        glb.bDirectDrawPersistant = FALSE;
        glb.bPersistantBuffers = FALSE;
        return;
    }

    // Case 2: Solid Edge must use pre-allocated resources for all GLRCs
    if (strstr(szModuleFileName, "PART.EXE")
        || strstr(szModuleFileName, "ASSEMBL.EXE")
        || strstr(szModuleFileName, "DRAFT.EXE")
        || strstr(szModuleFileName, "SMARTVW.EXE")
        || strstr(szModuleFileName, "SMETAL.EXE")) {
        glb.bMultiThreaded = FALSE;
        glb.bDirectDrawPersistant = TRUE;
        glb.bPersistantBuffers = FALSE;
        return;
    }

    // Case 3: Sudden Depth creates and destroys GLRCs on paint commands
    if (strstr(szModuleFileName, "SUDDEPTH.EXE")
        || strstr(szModuleFileName, "SUDDEMO.EXE")) {
        glb.bMultiThreaded = FALSE;
        glb.bDirectDrawPersistant = TRUE;
        glb.bPersistantBuffers = TRUE;
        glb.bFullscreenBlit = TRUE;
        return;
    }

    // Case 4: StereoGraphics test apps create and destroy GLRCs on paint commands
    if (strstr(szModuleFileName, "REDBLUE.EXE")
        || strstr(szModuleFileName, "DIAGNOSE.EXE")) {
        glb.bMultiThreaded = FALSE;
        glb.bDirectDrawPersistant = TRUE;
        glb.bPersistantBuffers = TRUE;
        return;
    }

    // Case 5: Pipes screen savers share multiple GLRCs for same window
    if (strstr(szModuleFileName, "PIPES.SCR")
        || (strstr(szModuleFileName, "PIPES") && strstr(szModuleFileName, ".SCR"))) {
        glb.bMultiThreaded = FALSE;
        glb.bDirectDrawPersistant = TRUE;
        glb.bPersistantBuffers = TRUE;
        return;
    }

    // Case 6: AutoVue uses sub-viewport ops which are temporarily broken in stereo window
    if (strstr(szModuleFileName, "AVWIN.EXE")) {
        glb.bMultiThreaded = FALSE;
        glb.bDirectDrawPersistant = TRUE;
        glb.bPersistantBuffers = TRUE;
        return;
    }
    // Case 7: Quake3 is waiting for DDraw objects to be released at exit
    if (strstr(szModuleFileName, "QUAKE")) {
        glb.bMultiThreaded = FALSE;
        glb.bDirectDrawPersistant = FALSE;
        glb.bPersistantBuffers = FALSE;
        glb.bFullscreenBlit = FALSE;
        return;
    }
    // Case 8: Reflection GLX server is unable to switch contexts at run-time
    if (strstr(szModuleFileName, "RX.EXE")) {
        glb.bMultiThreaded = FALSE;
        glb.bMessageBoxWarnings = FALSE;
        return;
    }
    // Case 9: Original AutoCAD 2000 must share DDraw objects across GLRCs
    if (strstr(szModuleFileName, "ACAD.EXE")) {
        glb.bFastFPU = FALSE;
        if (GetModuleHandle("wopengl6.hdi") != NULL) {
        glb.bMultiThreaded = FALSE;
        glb.bDirectDrawPersistant = TRUE;
        glb.bPersistantBuffers = FALSE;
        }
        return;
    }
}

// ***********************************************************************

BOOL dglInitDriver(void)
{
    UCHAR szExeName[MAX_PATH];
    const char *szRendering[] = {
        "Mesa Software",
        "Direct3D RGB SW",
        "Direct3D HW",
    };
    static BOOL bWarnOnce = FALSE;

    // Already initialized?
    if (bInitialized)
        return TRUE;

    // Moved from DllMain DLL_PROCESS_ATTACH:

        // (Re-)Init defaults
        dglInitGlobals();

        // Read registry or INI file settings
        if (!dllReadRegistry(hInstanceDll)) {
            if (!bWarnOnce)
                MessageBox( NULL, "GLDirect has not been configured.\n\n"
                              "Please run the configuration program\n"
                              "before using GLDirect with applications.\n",
                              "GLDirect", MB_OK | MB_ICONWARNING);
            bWarnOnce = TRUE;
            return FALSE;
        }

#ifdef _USE_GLD3_WGL
        // Must do this as early as possible.
        // Need to read regkeys/ini-file first though.
        gldInitDriverPointers(glb.dwDriver);

        // Create private driver globals
        _gldDriver.CreatePrivateGlobals();
#endif
        // Overide settings with application customizations
        if (glb.bAppCustomizations)
            dglSetAppCustomizations();

//#ifndef _USE_GLD3_WGL
        // Set the global memory type to either sysmem or vidmem
        glb.dwMemoryType = glb.bHardware ? DDSCAPS_VIDEOMEMORY : DDSCAPS_SYSTEMMEMORY;
//#endif

        // Multi-threaded support overides persistant display support
        if (glb.bMultiThreaded)
            glb.bDirectDrawPersistant = glb.bPersistantBuffers = FALSE;

        // Multi-threaded support needs to be reflected in Mesa code. (DaveM)
        _gld_bMultiThreaded = glb.bMultiThreaded;

        // Start logging
        ddlogPathOption(szLogPath);
        ddlogWarnOption(glb.bMessageBoxWarnings);
        ddlogOpen((DDLOG_loggingMethodType)dwLogging,
                  (DDLOG_severityType)dwDebugLevel);

        // Obtain the name of the calling app
        ddlogMessage(DDLOG_SYSTEM, "Driver           : SciTech GLDirect 4.0\n");
        GetModuleFileName(NULL, szExeName, sizeof(szExeName));
        ddlogPrintf(DDLOG_SYSTEM, "Executable       : %s", szExeName);

        ddlogPrintf(DDLOG_SYSTEM, "DirectDraw device: %s", glb.szDDName);
        ddlogPrintf(DDLOG_SYSTEM, "Direct3D driver  : %s", glb.szD3DName);

        ddlogPrintf(DDLOG_SYSTEM, "Rendering type   : %s", szRendering[glb.dwRendering]);

        ddlogPrintf(DDLOG_SYSTEM, "Multithreaded    : %s", glb.bMultiThreaded ? "Enabled" : "Disabled");
        ddlogPrintf(DDLOG_SYSTEM, "Display resources: %s", glb.bDirectDrawPersistant ? "Persistant" : "Instanced");
        ddlogPrintf(DDLOG_SYSTEM, "Buffer resources : %s", glb.bPersistantBuffers ? "Persistant" : "Instanced");

        dglInitContextState();
        dglBuildPixelFormatList();
        //dglBuildTextureFormatList();

    // D3D callback driver is now successfully initialized
    bInitialized = TRUE;
    // D3D callback driver is now ready to be exited
    bExited = FALSE;

    return TRUE;
}

// ***********************************************************************

void dglExitDriver(void)
{

    // Only need to clean up once per instance:
    // May be called implicitly from DLL_PROCESS_DETACH,
    // or explicitly from DGL_exitDriver().
    if (bExited)
        return;
    bExited = TRUE;

    // DDraw objects may be invalid when DLL unloads.
__try {

    // Clean-up sequence (moved from DLL_PROCESS_DETACH)
#ifndef _USE_GLD3_WGL
    dglReleaseTextureFormatList();
#endif
    dglReleasePixelFormatList();
    dglDeleteContextState();

#ifdef _USE_GLD3_WGL
    _gldDriver.DestroyPrivateGlobals();
#endif

}
__except(EXCEPTION_EXECUTE_HANDLER) {
        ddlogPrintf(DDLOG_WARN, "Exception raised in dglExitDriver.");
}

    // Close the log file
    ddlogClose();
}

// ***********************************************************************

int WINAPI DllMain(
    HINSTANCE hInstance,
    DWORD fdwReason,
    PVOID pvReserved)
{
    switch (fdwReason) {
    case DLL_PROCESS_ATTACH:
        // Cache DLL instance handle
        hInstanceDll = hInstance;

        // Flag that callback driver has yet to be initialized
        bInitialized = bExited = FALSE;

#ifndef _USE_GLD3_WGL
        // Init internal Mesa function pointers
        memset(&mesaFuncs, 0, sizeof(DGL_mesaFuncs));
#endif // _USE_GLD3_WGL

        // Init defaults
        dglInitGlobals();

        // Defer rest of DLL initialization to 1st WGL function call
        break;

    case DLL_PROCESS_DETACH:
        // Call exit clean-up sequence
        dglExitDriver();
        break;
    }

    return TRUE;
}

// ***********************************************************************

void APIENTRY DGL_exitDriver(void)
{
    // Call exit clean-up sequence
    dglExitDriver();
}

// ***********************************************************************

void APIENTRY DGL_reinitDriver(void)
{
    // Force init sequence again
    bInitialized = bExited = FALSE;
    dglInitDriver();
}

// ***********************************************************************

int WINAPI DllInitialize(
    HINSTANCE hInstance,
    DWORD fdwReason,
    PVOID pvReserved)
{
    // Some Watcom compiled executables require this.
    return DllMain(hInstance, fdwReason, pvReserved);
}

// ***********************************************************************

void DGL_LoadSplashScreen(int piReg, char* pszUser)
{
    HINSTANCE           hSplashDll = NULL;
    LPDGLSPLASHSCREEN   dglSplashScreen = NULL;
    static BOOL         bOnce = FALSE;
    static int          iReg = 0;
    static char         szUser[255] = {"\0"};

    // Display splash screen at all?
    if (!bSplashScreen)
        return;

    // Only display splash screen once
    if (bOnce)
        return;
    bOnce = TRUE;

    // Make local copy of string for passing to DLL
    if (pszUser)
        strcpy(szUser, pszUser);
    iReg = piReg;

    // Load Splash Screen DLL
    // (If it fails to load for any reason, we don't care...)
    hSplashDll = LoadLibrary("gldsplash.dll");
    if (hSplashDll) {
        // Execute the Splash Screen function
        dglSplashScreen = (LPDGLSPLASHSCREEN)GetProcAddress(hSplashDll, "GLDSplashScreen");
        if (dglSplashScreen)
            (*dglSplashScreen)(1, iReg, szUser);
        // Don't unload the DLL since splash screen dialog is modeless now
        }
}

// ***********************************************************************

BOOL dglValidate()
{
    char *szCaption = "SciTech GLDirect Driver";
    UINT uType = MB_OK | MB_ICONEXCLAMATION;

#ifdef _USE_GLD3_WGL
    // (Re)build pixelformat list
    if (glb.bPixelformatsDirty)
        _gldDriver.BuildPixelformatList();
#endif

    // Check to see if we have already validated
    if (bDriverValidated && bInitialized)
        return TRUE;

    // Since all (most) the WGL functions must be validated at this point,
    // this also insure that the callback driver is completely initialized.
    if (!bInitialized)
        if (!dglInitDriver()) {
            MessageBox(NULL,
                "The GLDirect driver could not initialize.\n\n"
                "Please run the configuration program to\n"
                "properly configure the driver, or else\n"
                "re-run the installation program.", szCaption, uType);
            _exit(1); // Bail
        }

    return TRUE;
}

// ***********************************************************************