/*==========================================================================;
 *
 *  Copyright (C) 1998 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:   d3ddev.cpp
 *  Content:    Direct3D device implementation
 *@@BEGIN_MSINTERNAL
 *
 *  $Id: device.c,v 1.26 1995/12/04 11:29:47 sjl Exp $
 *
 *  History:
 *   Date   By  Reason
 *   ====   ==  ======
 *   05/11/95   stevela Initial rev with this header.
 *   11/11/95   stevela Light code changed.
 *   23/11/95   colinmc Modifications to support aggregatable interfaces
 *   07/12/95   stevela Merged Colin's changes.
 *   10/12/95   stevela Removed AGGREGATE_D3D.
 *   18/12/95   stevela Added GetMatrix, GetState.
 *   15/07/96   andyhird Initialise Render state on devices
 *   13/08/96   andyhird Check surface and device are compatible
 *   18/08/96   colinmc Fixed z-buffer leak
 *@@END_MSINTERNAL
 *
 ***************************************************************************/

#include "pch.cpp"
#pragma hdrstop

/*
 * Create an api for the Direct3DDevice object
 */
extern "C" {
#define this _this
#include "ddrawpr.h"
#undef this
}
#include "commdrv.hpp"
#include "drawprim.hpp"

//#ifdef DEBUG_PIPELINE
#include "testprov.h"
//#endif //DEBUG_PIPELINE

// Remove DDraw's type unsafe definition and replace with our C++ friendly def
#ifdef VALIDEX_CODE_PTR
#undef VALIDEX_CODE_PTR
#endif
#define VALIDEX_CODE_PTR( ptr ) \
(!IsBadCodePtr( (FARPROC) ptr ) )

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice"

extern BOOL isMMXprocessor(void);
extern HRESULT GenGetPickRecords(LPDIRECT3DDEVICEI, D3DI_PICKDATA *);
extern BOOL IsValidD3DDeviceGuid(REFCLSID riid);

BOOL D3DI_isHALValid(LPD3DHAL_CALLBACKS halTable)
{
    if(halTable==NULL) {
        D3D_WARN(0, "HAL callbacks is NULL. HAL will not be enumerated.");
        return FALSE;
    }

    if (halTable->dwSize != D3DHAL_SIZE_V1) {
        D3D_WARN(0, "HAL callbacks invalid - size = %d, wanted %d. HAL will not be enumerated.",
            halTable->dwSize, D3DHAL_SIZE_V1);
        return FALSE;
    }
    if (halTable->dwReserved  ||
        halTable->dwReserved0 ||
        halTable->dwReserved1 ||
        halTable->dwReserved2 ||
        halTable->dwReserved3 ||
        halTable->dwReserved4 ||
        halTable->dwReserved5 ||
        halTable->dwReserved6 ||
        halTable->dwReserved7 ||
        halTable->dwReserved8 ||
        halTable->dwReserved9 ||
        halTable->lpReserved10 ||
        halTable->lpReserved11 ||
        halTable->lpReserved12 ||
        halTable->lpReserved13 ||
        halTable->lpReserved14 ||
        halTable->lpReserved15 ||
        halTable->lpReserved16 ||
        halTable->lpReserved17 ||
        halTable->lpReserved18 ||
        halTable->lpReserved19 ||
        halTable->lpReserved20 ||
        halTable->lpReserved21) {
        D3D_WARN(0, "HAL callbacks invalid - has non-zero reserved fields, HAL will not be enumerated.");
        return FALSE;
    }

    return TRUE;
}

HRESULT DIRECT3DDEVICEI::stateInitialize(BOOL bZEnable)
{
    D3DDEVICEDESC hwDesc, helDesc;
    D3DLINEPATTERN defLPat;
    HRESULT ret;
    float tmpval;
    BOOL ckeyenable = FALSE;

    /* Get the device caps for MONOENABLE */
    memset(&hwDesc, 0, sizeof(D3DDEVICEDESC));
    hwDesc.dwSize = sizeof(D3DDEVICEDESC);
    memset(&helDesc, 0, sizeof(D3DDEVICEDESC));
    helDesc.dwSize = sizeof(D3DDEVICEDESC);

    ret = GetCapsI(&hwDesc, &helDesc);
    if (FAILED(ret)) {
        D3D_ERR("stateInitialise: GetCaps failed");
        return(ret);
    }

    /* If we run on (HAL OR RefRast) AND this is a DX3 app
       then we need to initialize colorkey to TRUE so that the old HW driver (except s3 virge) behavior
       is exhibited. */
    if ( (this->dwVersion < 2) &&
         ( (IS_HW_DEVICE(this)) || (IsEqualIID(this->guid, IID_IDirect3DRefDevice)) ) )
    {
        ckeyenable = TRUE;
    }

    // Obviate SetRenderState filtering 'redundant' render state settings
    // since this is the init step.
    memset( this->rstates, 0xff, sizeof(DWORD)*D3DHAL_MAX_RSTATES );
    this->rstates[D3DRENDERSTATE_PLANEMASK] = 0;
    this->rstates[D3DRENDERSTATE_STENCILMASK] = 0;
    this->rstates[D3DRENDERSTATE_STENCILWRITEMASK] = 0;
    this->rstates[D3DRENDERSTATE_PLANEMASK] = 0;

    SetRenderState( D3DRENDERSTATE_TEXTUREHANDLE, (DWORD)NULL);
    SetRenderState( D3DRENDERSTATE_ANTIALIAS, FALSE);
    SetRenderState( D3DRENDERSTATE_TEXTUREADDRESS, D3DTADDRESS_WRAP);
    if (this->dwVersion <= 2)
    {
        SetRenderState( D3DRENDERSTATE_TEXTUREPERSPECTIVE, FALSE);
        SetRenderState( D3DRENDERSTATE_SPECULARENABLE, TRUE);
    }
    else
    {
        // perspective enabled by default for Device3 and later
        SetRenderState( D3DRENDERSTATE_TEXTUREPERSPECTIVE, TRUE);
        // specular disabled by default for Device3 and later
        SetRenderState( D3DRENDERSTATE_SPECULARENABLE, FALSE);
    }
    SetRenderState( D3DRENDERSTATE_WRAPU, FALSE);
    SetRenderState( D3DRENDERSTATE_WRAPV, FALSE);
    SetRenderState( D3DRENDERSTATE_ZENABLE, bZEnable);
    SetRenderState( D3DRENDERSTATE_FILLMODE, D3DFILL_SOLID);
    SetRenderState( D3DRENDERSTATE_SHADEMODE, D3DSHADE_GOURAUD);

    defLPat.wRepeatFactor = 0;
    defLPat.wLinePattern = 0;

    SetRenderState( D3DRENDERSTATE_LINEPATTERN, *((LPDWORD)&defLPat)); /* 10 */
    /*
      ((LPD3DSTATE)lpPointer)->drstRenderStateType =
      (D3DRENDERSTATETYPE)D3DRENDERSTATE_LINEPATTERN;
      memcpy(&(((LPD3DSTATE)lpPointer)->dwArg[0]), &defLPat, sizeof(DWORD));
      lpPointer = (void *)(((LPD3DSTATE)lpPointer) + 1);*/

    SetRenderState( D3DRENDERSTATE_ROP2, R2_COPYPEN);
    SetRenderState( D3DRENDERSTATE_PLANEMASK, (DWORD)~0);
    SetRenderState( D3DRENDERSTATE_ZWRITEENABLE, TRUE);
    SetRenderState( D3DRENDERSTATE_ALPHATESTENABLE, FALSE);
    SetRenderState( D3DRENDERSTATE_LASTPIXEL, TRUE);
    SetRenderState( D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
    SetRenderState( D3DRENDERSTATE_DESTBLEND, D3DBLEND_ZERO);
    SetRenderState( D3DRENDERSTATE_CULLMODE, D3DCULL_CCW); /* 21 */
    SetRenderState( D3DRENDERSTATE_ZFUNC, D3DCMP_LESSEQUAL);
    SetRenderState( D3DRENDERSTATE_ALPHAREF, 0);
    SetRenderState( D3DRENDERSTATE_ALPHAFUNC, D3DCMP_ALWAYS);
    SetRenderState( D3DRENDERSTATE_DITHERENABLE, FALSE);
    SetRenderState( D3DRENDERSTATE_BLENDENABLE, FALSE);
    SetRenderState( D3DRENDERSTATE_FOGENABLE, FALSE);
    SetRenderState( D3DRENDERSTATE_ZVISIBLE, FALSE);
    SetRenderState( D3DRENDERSTATE_SUBPIXEL, FALSE); /* 30 */
    SetRenderState( D3DRENDERSTATE_SUBPIXELX, FALSE);
    SetRenderState( D3DRENDERSTATE_STIPPLEDALPHA, FALSE);
    SetRenderState( D3DRENDERSTATE_FOGCOLOR, 0);
    SetRenderState( D3DRENDERSTATE_FOGTABLEMODE, D3DFOG_NONE);

    /* Initialise these - although they may not need doing */
    tmpval = 0.0f;
    SetRenderState( D3DRENDERSTATE_FOGTABLESTART, *((DWORD *)&tmpval));
    tmpval = 1.0f;
    SetRenderState( D3DRENDERSTATE_FOGTABLEEND, *((DWORD *)&tmpval));
    tmpval = 1.0f;
    SetRenderState( D3DRENDERSTATE_FOGTABLEDENSITY, *((DWORD *)&tmpval));
    SetRenderState( D3DRENDERSTATE_STIPPLEENABLE, FALSE);
    SetRenderState( D3DRENDERSTATE_EDGEANTIALIAS, FALSE);
    SetRenderState( D3DRENDERSTATE_COLORKEYENABLE, ckeyenable);
    SetRenderState( D3DRENDERSTATE_ALPHABLENDENABLE, FALSE);
    SetRenderState( D3DRENDERSTATE_BORDERCOLOR, 0);
    SetRenderState( D3DRENDERSTATE_TEXTUREADDRESSU, D3DTADDRESS_WRAP);
    SetRenderState( D3DRENDERSTATE_TEXTUREADDRESSV, D3DTADDRESS_WRAP);
    SetRenderState( D3DRENDERSTATE_MIPMAPLODBIAS, 0);
    SetRenderState( D3DRENDERSTATE_ZBIAS, 0);
    SetRenderState( D3DRENDERSTATE_RANGEFOGENABLE, FALSE);
    SetRenderState( D3DRENDERSTATE_ANISOTROPY, 1);

    /* Again - all these probably don't need doing */
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN00, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN01, 0); /* 40 */
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN02, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN03, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN04, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN05, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN06, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN07, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN08, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN09, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN10, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN11, 0); /* 50 */
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN12, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN13, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN14, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN15, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN16, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN17, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN18, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN19, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN20, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN21, 0); /* 60 */
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN22, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN23, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN24, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN25, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN26, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN27, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN28, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN29, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN30, 0);
    SetRenderState( D3DRENDERSTATE_STIPPLEPATTERN31, 0); /* 70 */

     // init stencil states to something reasonable
     // stencil enable is OFF by default since stenciling rasterizers will be
     // faster with it disabled, even if stencil states are benign
    SetRenderState( D3DRENDERSTATE_STENCILENABLE,   FALSE);
    SetRenderState( D3DRENDERSTATE_STENCILFAIL,     D3DSTENCILOP_KEEP);
    SetRenderState( D3DRENDERSTATE_STENCILZFAIL,    D3DSTENCILOP_KEEP);
    SetRenderState( D3DRENDERSTATE_STENCILPASS,     D3DSTENCILOP_KEEP);
    SetRenderState( D3DRENDERSTATE_STENCILFUNC,     D3DCMP_ALWAYS);
    SetRenderState( D3DRENDERSTATE_STENCILREF,      0);
    SetRenderState( D3DRENDERSTATE_STENCILMASK,     0xFFFFFFFF);
    SetRenderState( D3DRENDERSTATE_STENCILWRITEMASK,0xFFFFFFFF);

    // don't forget about texturefactor (like we did in DX6.0...)
    SetRenderState( D3DRENDERSTATE_TEXTUREFACTOR,   0xFFFFFFFF);

    /* Check to see if the driver can do RGB - if not set MONOENABLE to
       true otherwise false (ie. RGB) by default */
    if (hwDesc.dwFlags & D3DDD_COLORMODEL) {
        if ((hwDesc.dcmColorModel & D3DCOLOR_RGB)) {
            D3D_INFO(3, "hw and RGB. MONOENABLE = FALSE");
            SetRenderState( D3DRENDERSTATE_MONOENABLE, FALSE);
        } else {
            D3D_INFO(3, "hw and !RGB. MONOENABLE = TRUE");
            SetRenderState( D3DRENDERSTATE_MONOENABLE, TRUE);
        }
    } else if (helDesc.dwFlags & D3DDD_COLORMODEL) {
        if ((helDesc.dcmColorModel & D3DCOLOR_RGB)) {
            D3D_INFO(3, "hel and RGB. MONOENABLE = FALSE");
            SetRenderState( D3DRENDERSTATE_MONOENABLE, FALSE);
        } else {
            D3D_INFO(3, "hel and !RGB. MONOENABLE = TRUE");
            SetRenderState( D3DRENDERSTATE_MONOENABLE, TRUE);
        }
    } else {
        /* Hmm, something bad has happened if we get here! */
        D3D_ERR("stateInitialise: neither hw or hel caps set");
        return(DDERR_GENERIC);
    }

    for (unsigned i = 0; i < 8; i++)
    {
        SetRenderState( (D3DRENDERSTATETYPE)
                        (D3DRENDERSTATE_WRAPBIAS + i), FALSE );
    }
    for (i = 0; i < D3DHAL_TSS_MAXSTAGES; i++)
    {
        lpD3DMappedTexI[i] = NULL;
        lpD3DMappedBlock[i] = NULL;
    }
    SetLightState( D3DLIGHTSTATE_COLORVERTEX, TRUE);

    // Obviate SetTextureStageState/Settexture filtering 'redundant' render state
    // settings since this is the init step.
    memset( this->tsstates, 0xff, sizeof(DWORD)*D3DHAL_TSS_MAXSTAGES*D3DHAL_TSS_STATESPERSTAGE );
    for (i = 0; i < D3DHAL_TSS_MAXSTAGES; i++)
    {
        SetTexture(i, NULL);
        if(i == 0)
            SetTextureStageState(i, D3DTSS_COLOROP, D3DTOP_MODULATE);
        else
            SetTextureStageState(i, D3DTSS_COLOROP, D3DTOP_DISABLE);
        SetTextureStageState(i, D3DTSS_COLORARG1, D3DTA_TEXTURE);
        SetTextureStageState(i, D3DTSS_COLORARG2, D3DTA_CURRENT);
        if(i == 0)
            SetTextureStageState(i, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
        else
            SetTextureStageState(i, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
        SetTextureStageState(i, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
        SetTextureStageState(i, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
        SetTextureStageState(i, D3DTSS_BUMPENVMAT00, 0);
        SetTextureStageState(i, D3DTSS_BUMPENVMAT01, 0);
        SetTextureStageState(i, D3DTSS_BUMPENVMAT10, 0);
        SetTextureStageState(i, D3DTSS_BUMPENVMAT11, 0);
        SetTextureStageState(i, D3DTSS_TEXCOORDINDEX, 0);
        SetTextureStageState(i, D3DTSS_ADDRESS, D3DTADDRESS_WRAP);
        SetTextureStageState(i, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
        SetTextureStageState(i, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
        SetTextureStageState(i, D3DTSS_BORDERCOLOR, 0x00000000);
        SetTextureStageState(i, D3DTSS_MAGFILTER, D3DTFG_POINT);
        SetTextureStageState(i, D3DTSS_MINFILTER, D3DTFN_POINT);
        SetTextureStageState(i, D3DTSS_MIPFILTER, D3DTFP_NONE);
        SetTextureStageState(i, D3DTSS_MIPMAPLODBIAS, 0);
        SetTextureStageState(i, D3DTSS_MAXMIPLEVEL, 0);
        SetTextureStageState(i, D3DTSS_MAXANISOTROPY, 1);
        SetTextureStageState(i, D3DTSS_BUMPENVLSCALE, 0);
        SetTextureStageState(i, D3DTSS_BUMPENVLOFFSET, 0);
    }

    // need to set legacy blend and filtering states after per-stage initialization
    //  to properly set defaults in device
    SetRenderState( D3DRENDERSTATE_TEXTUREMAG, D3DFILTER_NEAREST);
    SetRenderState( D3DRENDERSTATE_TEXTUREMIN, D3DFILTER_NEAREST);
    SetRenderState( D3DRENDERSTATE_TEXTUREMAPBLEND, D3DTBLEND_MODULATE);

    // Reset request bit as legacy renderstates have been already initialized
    // and no mapping is needed
    this->dwFEFlags &= ~D3DFE_MAP_TSS_TO_RS;

    return(D3D_OK);
}

DWORD BitDepthToDDBD(int bpp)
{
    switch(bpp)
    {
    case 1:
        return DDBD_1;
    case 2:
        return DDBD_2;
    case 4:
        return DDBD_4;
    case 8:
        return DDBD_8;
    case 16:
        return DDBD_16;
    case 24:
        return DDBD_24;
    case 32:
        return DDBD_32;
    default:
        D3D_ERR("Invalid bit depth");
        return 0;
    }
}

HRESULT DIRECT3DDEVICEI::checkDeviceSurface(LPDIRECTDRAWSURFACE lpDDS, LPDIRECTDRAWSURFACE lpZbuffer, LPGUID pGuid)
{
    D3DDEVICEDESC hwDesc, helDesc;
    DDPIXELFORMAT surfPF;
    DDSCAPS surfCaps;
    HRESULT ret;
    DWORD bpp;

    /* Get caps bits - check whether device and surface are:
       - video/system memory and depth compatible */

    if (FAILED(ret = lpDDS->GetCaps(&surfCaps))) {
        D3D_ERR("Failed to get render-target surface caps");
        return(ret);
    }

    memset(&surfPF, 0, sizeof(DDPIXELFORMAT));
    surfPF.dwSize = sizeof(DDPIXELFORMAT);

    if (FAILED(ret = lpDDS->GetPixelFormat(&surfPF))) {
        D3D_ERR("Failed to get render-target surface pixel format");
        return(ret);
    }

    memset(&hwDesc, 0, sizeof(D3DDEVICEDESC));
    hwDesc.dwSize = sizeof(D3DDEVICEDESC);
    memset(&helDesc, 0, sizeof(D3DDEVICEDESC));
    helDesc.dwSize = sizeof(D3DDEVICEDESC);

    // ATTENTION - Why doesn't this just look at the DEVICEI fields?
    ret = GetCapsI(&hwDesc, &helDesc);
    if (FAILED(ret)) {
        D3D_ERR("GetCaps failed");
        return(ret);
    }

    if (hwDesc.dwFlags) {
        /* I'm taking this as evidence that its running on hardware - therefore
           the surface should be in video memory */
        D3D_INFO(3, "Hardware device being used");

        if (!(surfCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) {
            D3D_ERR("Render-target surface not in video memory for hw device");
            return(D3DERR_SURFACENOTINVIDMEM);
        }
    }

    /* A surface can only have one bit depth - whereas a device can support
       multiple bit depths */
    if (surfPF.dwFlags & DDPF_RGB) {
        D3D_INFO(3, "Render-target surface is RGB");

        bpp = BitDepthToDDBD(surfPF.dwRGBBitCount);
        if (!bpp) {
            D3D_ERR("Bogus render-target surface pixel depth");
            return(DDERR_INVALIDPIXELFORMAT);
       }

       if((surfPF.dwRGBBitCount<16) && (IsEqualIID(*pGuid, IID_IDirect3DRefDevice) || IsEqualIID(*pGuid, IID_IDirect3DNullDevice))) {
           // this is actually subsumed by the following test, but whatever
            D3D_ERR("Reference rasterizer and null device dont support render targets with bitdepth < 16");
            return(DDERR_INVALIDPIXELFORMAT);
       }

        if (!(bpp & helDesc.dwDeviceRenderBitDepth) &&
            !(bpp & hwDesc.dwDeviceRenderBitDepth)) {
            D3D_ERR("Render-target surface bitdepth is not supported by HEL or HW for this device");
            return(DDERR_INVALIDPIXELFORMAT);
        }
    }

    if(lpZbuffer==NULL)
      return D3D_OK;

    memset(&surfPF, 0, sizeof(DDPIXELFORMAT));
    surfPF.dwSize = sizeof(DDPIXELFORMAT);

    if (FAILED(ret = lpZbuffer->GetPixelFormat(&surfPF))) {
        D3D_ERR("Failed to get zbuffer pixel format");
        return(ret);
    }

    if (FAILED(ret = lpZbuffer->GetCaps(&surfCaps))) {
        D3D_ERR("Failed to get Zbuffer caps");
        return(ret);
    }

    if (hwDesc.dwFlags) {
        if (!(surfCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) {
            D3D_ERR("Zbuffer not in video memory for hw device");
            return(D3DERR_ZBUFF_NEEDS_VIDEOMEMORY);
        }
        D3D_INFO(3, "Hw device, zbuffer in video memory");
    } else if (helDesc.dwFlags) {
        if (!(surfCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)) {
            D3D_ERR("Zbuffer not in system memory for HEL device");
            return(D3DERR_ZBUFF_NEEDS_SYSTEMMEMORY);
        }
        D3D_INFO(3, "Hel device, zbuffer in system memory");

         // have to hack in a check to make sure ramp isn't used with stencil zbuffer
         // cant do this validation until device creation time (instead of at zbuffer creation in
         // ddhel.c) because rgb vs. ramp isn't known until now
         if(IsEqualIID(*pGuid, IID_IDirect3DRampDevice)) {
            if(surfPF.dwFlags & DDPF_STENCILBUFFER) {
                D3D_ERR("Z-Buffer with stencil is invalid with RAMP software rasterizer");
                return DDERR_INVALIDPARAMS;
            }
         }
    }

    if (surfPF.dwFlags & DDPF_ZBUFFER) {
        bpp = BitDepthToDDBD(surfPF.dwZBufferBitDepth);
        if (!bpp) {
            D3D_ERR("Bogus Zbuffer surface pixel depth");
            return(DDERR_INVALIDPIXELFORMAT);
        }
    }

    return(D3D_OK);
}


/*
 * Initialisation - class part and device part
 */

/*
 * Generic class part initialisation
 */
HRESULT InitDeviceI(LPDIRECT3DDEVICEI lpDevI, LPDIRECT3DI lpD3DI)
{
    LPDDRAWI_DIRECTDRAW_GBL lpDDI;
    HRESULT error;

    lpDDI = ((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->lpGbl;

    //
    // Retrieve HAL information from provider.
    //

    error = lpDevI->pHalProv->GetCaps(lpDDI,
                                      &lpDevI->d3dHWDevDesc,
                                      &lpDevI->d3dHELDevDesc,
                                      lpDevI->dwVersion);
    if (error != S_OK)
    {
        return (error);
    }
    D3DHALPROVIDER_INTERFACEDATA HalProviderIData;
    memset(&HalProviderIData,0,sizeof(HalProviderIData));
    HalProviderIData.dwSize = sizeof(HalProviderIData);
    if ((error = lpDevI->pHalProv->GetInterface(lpDDI,
                                                &HalProviderIData,
                                                lpDevI->dwVersion)) != S_OK)
    {
        return error;
    }
    //  interface data for <=DX5 HAL
    lpDevI->lpD3DHALGlobalDriverData = HalProviderIData.pGlobalData;
    lpDevI->lpD3DExtendedCaps        = HalProviderIData.pExtCaps;
    lpDevI->lpD3DHALCallbacks        = HalProviderIData.pCallbacks;
    lpDevI->lpD3DHALCallbacks2       = HalProviderIData.pCallbacks2;
    //  interface data for DX6 HAL
    lpDevI->lpD3DHALCallbacks3       = HalProviderIData.pCallbacks3;

    lpDevI->pfnRampService = HalProviderIData.pfnRampService;
    lpDevI->pfnRastService = HalProviderIData.pfnRastService;
    lpDevI->dwHintFlags = 0;

    // Zero out 8 bpp render target caps for real hardware.
    if (lpDevI->d3dHWDevDesc.dwFlags != 0)
    {
        lpDevI->lpD3DHALGlobalDriverData->hwCaps.dwDeviceRenderBitDepth &=
            (~DDBD_8);
    }

    if (!D3DI_isHALValid(lpDevI->lpD3DHALCallbacks))
    {
        return D3DERR_INITFAILED;
    }

    if (lpDevI->lpD3DExtendedCaps && lpDevI->lpD3DExtendedCaps->dwFVFCaps)
    {
        lpDevI->dwMaxTextureIndices =
            lpDevI->lpD3DExtendedCaps->dwFVFCaps & D3DFVFCAPS_TEXCOORDCOUNTMASK;
        lpDevI->dwMaxTextureBlendStages =
            lpDevI->lpD3DExtendedCaps->wMaxTextureBlendStages;
        lpDevI->dwDeviceFlags |= D3DDEV_FVF;
        if (lpDevI->lpD3DExtendedCaps->dwFVFCaps & D3DFVFCAPS_DONOTSTRIPELEMENTS)
            lpDevI->dwDeviceFlags |= D3DDEV_DONOTSTRIPELEMENTS;

        DWORD value;
        if ((lpDevI->dwDebugFlags & D3DDEBUG_DISABLEDP ||
            lpDevI->dwDebugFlags & D3DDEBUG_DISABLEDP2 ||
            (GetD3DRegValue(REG_DWORD, "DisableFVF", &value, 4) &&
            value != 0)) &&
            FVF_DRIVERSUPPORTED(lpDevI))
        {
            lpDevI->dwMaxTextureIndices = 1;
            lpDevI->dwMaxTextureBlendStages = 1;
            lpDevI->dwDeviceFlags &= ~D3DDEV_FVF;
            lpDevI->dwDebugFlags |= D3DDEBUG_DISABLEFVF;
        }
        if ((GetD3DRegValue(REG_DWORD, "DisableStripFVF", &value, 4) &&
            value != 0))
        {
            lpDevI->dwDeviceFlags |= D3DDEV_DONOTSTRIPELEMENTS;
        }
    }
    else
    {
        lpDevI->dwMaxTextureIndices = 1;
        lpDevI->dwMaxTextureBlendStages = 1;
    }

    lpDevI->pfnDrawPrim = &DIRECT3DDEVICEI::DrawPrim;
    lpDevI->pfnDrawIndexedPrim = &DIRECT3DDEVICEI::DrawIndexPrim;
#if DBG
    lpDevI->dwCaller=0;
    memset(lpDevI->dwPrimitiveType,0,sizeof(lpDevI->dwPrimitiveType));
    memset(lpDevI->dwVertexType1,0,sizeof(lpDevI->dwVertexType1));
    memset(lpDevI->dwVertexType2,0,sizeof(lpDevI->dwVertexType2));
#endif
    return D3D_OK;
}

HRESULT D3DMallocBucket(LPDIRECT3DI lpD3DI, LPD3DBUCKET *lplpBucket)
{
    if (lpD3DI->lpFreeList == NULL ){
      lpD3DI->lpTextureManager->cleanup();  //free unused nodes it may have
      if (lpD3DI->lpFreeList == NULL )
      {
        LPD3DBUCKET   lpBufferList;
        LPVOID  lpBuffer;
        int i;
        *lplpBucket=NULL;
        if (D3DMalloc(&lpBuffer, D3DBUCKETBUFFERSIZE*sizeof(D3DBUCKET)) != D3D_OK)
            return  DDERR_OUTOFMEMORY;
        D3D_INFO(9, "D3DMallocBucket %d Bytes allocated for %d free Buckets",
            D3DBUCKETBUFFERSIZE*sizeof(D3DBUCKET),D3DBUCKETBUFFERSIZE-1);
        lpBufferList=(LPD3DBUCKET)lpBuffer;
        for (i=0;i<D3DBUCKETBUFFERSIZE-2;i++)
            lpBufferList[i].next=&lpBufferList[i+1];
        lpBufferList[D3DBUCKETBUFFERSIZE-2].next=NULL;
        lpD3DI->lpFreeList=(LPD3DBUCKET)lpBuffer; //new free list
        lpBufferList[D3DBUCKETBUFFERSIZE-1].next=lpD3DI->lpBufferList;//add to lpBufferList
        lpBufferList[D3DBUCKETBUFFERSIZE-1].lpBuffer=lpBuffer;
        lpD3DI->lpBufferList=&lpBufferList[D3DBUCKETBUFFERSIZE-1];
      }
    }
    *lplpBucket=lpD3DI->lpFreeList;
    lpD3DI->lpFreeList=lpD3DI->lpFreeList->next;
    return  D3D_OK;
}

void    D3DFreeBucket(LPDIRECT3DI lpD3DI, LPD3DBUCKET lpBucket)
{
    lpBucket->next=lpD3DI->lpFreeList;
    lpD3DI->lpFreeList=lpBucket;
}

/*
 * Generic device part destroy
 */
void DIRECT3DDEVICEI::DestroyDevice()
{
    LPDIRECT3DVIEWPORTI lpViewI;
    LPDIRECTDRAWSURFACE lpDDS=NULL, lpDDSZ=NULL;
    LPDIRECTDRAWSURFACE4 lpDDS_DDS4=NULL;
    LPDIRECTDRAWPALETTE lpDDPal=NULL;
    BOOL bIsDX3Device;

    /* Clear flags that could prohibit cleanup */
    this->dwHintFlags &=  ~(D3DDEVBOOL_HINTFLAGS_INBEGIN_ALL | D3DDEVBOOL_HINTFLAGS_INSCENE);

    /*
     * Remove all viewports attached to this device.
     */
    while ((lpViewI = CIRCLE_QUEUE_FIRST(&this->viewports)) &&
           (lpViewI != (LPDIRECT3DVIEWPORTI)&this->viewports)) {
        DeleteViewport((LPDIRECT3DVIEWPORT3)lpViewI);
    }

    /*
     * free up all textures created by this object - this also frees up Textures
     * We need to do this backwards because we cannot have a texture bound to
     * stage i + 1 when there is a texture bound to stage i.
     */
    for (int i = D3DHAL_TSS_MAXSTAGES - 1; i >= 0; --i)
    {
        if (lpD3DMappedTexI[i])
        {
            lpD3DMappedTexI[i]->Release();
            lpD3DMappedTexI[i] = NULL;
            lpD3DMappedBlock[i] = NULL;
        }
    }
    // The following code can result in D3DHAL_TextureDestroy() being called.
    // This BATCHES NEW INSTRUCTIONS in the instruction stream. So we must
    // make sure that at this point, the device is still able to accept
    // instructions.
    while (LIST_FIRST(&this->texBlocks)) {
        LPD3DI_TEXTUREBLOCK tBlock = LIST_FIRST(&this->texBlocks);
        D3DI_RemoveTextureHandle(tBlock);
        // Remove from device
        LIST_DELETE(tBlock, devList);
        // Remove from texture
        LIST_DELETE(tBlock, list);
        D3DFree(tBlock);
    }

    /*
     * free up all execute buffers created by this object
     */
    while (LIST_FIRST(&this->buffers)) {
        LPDIRECT3DEXECUTEBUFFERI lpBufI =
            LIST_FIRST(&this->buffers);
        lpBufI->Release();
    }

    /*
     * All materials associated with this device must be disassocited
     */
    while (LIST_FIRST(&this->matBlocks)) {
        LPD3DI_MATERIALBLOCK mBlock =
            LIST_FIRST(&this->matBlocks);
        D3DI_RemoveMaterialBlock(mBlock);
    }

    // In DX3, d3d device is aggregated and doesnt keep references to
    // rendertarget surfaces, so they shouldnt be "released"

    bIsDX3Device=(this->lpDDSTarget == (LPDIRECTDRAWSURFACE)(this->lpOwningIUnknown));

    if(!bIsDX3Device)
    {
        // Hold pointers into ddraw object for release after driver is destroyed
        lpDDSZ = this->lpDDSZBuffer;
        lpDDPal = this->lpDDPalTarget;
        if (this->dwVersion == 2)
            lpDDS = this->lpDDSTarget;
        else
            lpDDS_DDS4 = this->lpDDSTarget_DDS4;
    }

    //Unhook so that DDRAW surfaces won't try to flush the dead device
    if (this->lpDDSTarget)
        UnHookD3DDeviceFromSurface(this,((LPDDRAWI_DDRAWSURFACE_INT) this->lpDDSTarget)->lpLcl);
    if (this->lpDDSZBuffer)
        UnHookD3DDeviceFromSurface(this,((LPDDRAWI_DDRAWSURFACE_INT) this->lpDDSZBuffer)->lpLcl);

    if (pGeometryFuncs != &GeometryFuncsGuaranteed)
        delete pGeometryFuncs;

    D3DFE_Destroy(this);

    if (this->lpDirect3DI)
        unhookDeviceFromD3D();

    if (this->wTriIndex)
        D3DFree(this->wTriIndex);

    // Free the rstates that was allocated
    if(!(IS_HW_DEVICE(this) && IS_DP2HAL_DEVICE(this)))
    {
        delete rstates;
    }

    if (this->lpwDPBufferAlloced)
        D3DFree(this->lpwDPBufferAlloced);
    if (this->lpvVertexBatch)
        D3DFree(this->lpvVertexBatch);
    if (this->lpIndexBatch)
        D3DFree(this->lpIndexBatch);
    if (this->lpHWCounts)
        D3DFree(this->lpHWCounts);
    if (this->lpHWTris)
        D3DFree(this->lpHWTris);
    DeleteCriticalSection(&this->BeginEndCSect);

    if (this->pHalProv != NULL)
    {
        this->pHalProv->Release();
    }
    if (this->hDllProv != NULL)
    {
        FreeLibrary(this->hDllProv);
    }

    /* Now that the class has been destroyed, we should be able to release
       any DDraw object that might need to be released */

    if(!bIsDX3Device) {
        if (lpDDS)
            lpDDS->Release();
        if (lpDDSZ)
            lpDDSZ->Release();
        if (lpDDPal)
            lpDDPal->Release();
        if (lpDDS_DDS4)
            lpDDS_DDS4->Release();
    }
}

HRESULT DIRECT3DDEVICEI::hookDeviceToD3D(LPDIRECT3DI lpD3DI)
{

    LIST_INSERT_ROOT(&lpD3DI->devices, this, list);
    this->lpDirect3DI = lpD3DI;

    lpD3DI->numDevs++;

    return (D3D_OK);
}

HRESULT DIRECT3DDEVICEI::unhookDeviceFromD3D()
{
    LIST_DELETE(this, list);
    this->lpDirect3DI->numDevs--;
    this->lpDirect3DI = NULL;

    return (D3D_OK);
}

HRESULT D3DAPI DIRECT3DDEVICEI::Initialize(LPDIRECT3D lpD3D, LPGUID lpGuid, LPD3DDEVICEDESC lpD3Ddd)
{
    return DDERR_ALREADYINITIALIZED;
}


HRESULT HookD3DDeviceToSurface( LPDIRECT3DDEVICEI pd3ddev,
                                LPDDRAWI_DDRAWSURFACE_LCL lpLcl)
{
    LPD3DBUCKET lpD3DDevIList;
    LPDDRAWI_DDRAWSURFACE_MORE  this_more;
    // we only batch with DRAWPRIMITIVE aware HAL, so don't bother otherwise
    if (!lpLcl)     return  DDERR_ALREADYINITIALIZED;
    this_more = lpLcl->lpSurfMore;
    for(lpD3DDevIList=(LPD3DBUCKET)this_more->lpD3DDevIList;
        lpD3DDevIList;lpD3DDevIList=lpD3DDevIList->next) {
        if ((LPDIRECT3DDEVICEI)lpD3DDevIList->lpD3DDevI==pd3ddev)
            return DDERR_ALREADYINITIALIZED;  // this device is already hooked to the surface
    }
    if (D3DMallocBucket(pd3ddev->lpDirect3DI,&lpD3DDevIList) != D3D_OK) {
        D3D_ERR("HookD3DDeviceToSurface: Out of memory");
        return DDERR_OUTOFMEMORY;
    }
    D3D_INFO(8,"adding lpd3ddev=%08lx to surface %08lx",pd3ddev,lpLcl);
    //Link a node to the DDRAW surface
    lpD3DDevIList->lpD3DDevI=(LPVOID)pd3ddev;
    lpD3DDevIList->next=(LPD3DBUCKET)this_more->lpD3DDevIList;
    this_more->lpD3DDevIList=lpD3DDevIList;
    if (DDSCAPS_ZBUFFER & lpLcl->ddsCaps.dwCaps)
    {
        if (pd3ddev->dwVersion==1)
        {
            lpD3DDevIList->lplpDDSZBuffer=(LPDIRECTDRAWSURFACE*)&pd3ddev->lpDDSZBuffer_DDS4;
        }
        else
        {
            lpD3DDevIList->lplpDDSZBuffer=NULL;
        }
    }
    return D3D_OK;
}

void UnHookD3DDeviceFromSurface( LPDIRECT3DDEVICEI pd3ddev,
                                    LPDDRAWI_DDRAWSURFACE_LCL lpLcl)
{
    LPD3DBUCKET last,current,temp;
    LPDDRAWI_DDRAWSURFACE_MORE  this_more;
    // we only batch with DRAWPRIMITIVE aware HAL, so don't bother otherwise
    if (!lpLcl) return;
    this_more = lpLcl->lpSurfMore;

    last=NULL;
    current=(LPD3DBUCKET)this_more->lpD3DDevIList;
    while(current){
        if ((LPDIRECT3DDEVICEI)current->lpD3DDevI==pd3ddev){
            temp=current;
            current=current->next;
            if (last)
                last->next=current;
            else
                this_more->lpD3DDevIList=current;
            D3DFreeBucket(pd3ddev->lpDirect3DI,temp);
            D3D_INFO(8,"removed lpd3ddev=%08lx from surface %08lx",pd3ddev,lpLcl);
            return; // end of search as this is only one pd3ddev in the list
        }
        else{
            last=current;
            current=current->next;
        }
    }
    return;
}

HRESULT D3DFlushStates(LPDIRECT3DDEVICEI lpDevI)
{
    return lpDevI->FlushStates();
}

/*
 * Create a device.
 *
 * NOTE: Radical modifications to support the aggregatable device
 * interface (so devices can be queried off DirectDraw surfaces):
 *
 * 1) This call is no longer a member of the Direct3D device interface.
 *    It is now an API function exported from the Direct3D DLL. Its
 *    a hidden API function - only DirectDraw will ever invoke it.
 *
 * 2) This call is, in effect, the class factory for Direct3DDevice
 *    objects. This function will be invoked to create the aggregated
 *    device object hanging off the DirectDraw surface.
 *
 * NOTE: So the Direct3DDevice knows which DirectDraw surface is
 * its rendering target this function is passed an interface pointer
 * for that DirectDraw surface. I suspect this blows a nice big
 * hole in the COM model as the DirectDraw surface is also the
 * owning interface of the device and I don't think aggregated
 * objects should know about thier owning interfaces. However, to
 * make this thing work this is what we have to do.
 *
 * EXTRA BIG NOTE: Because of the above don't take a reference to
 * the DirectDraw surface passed in. If you do you will get a circular
 * reference and the bloody thing will never die. When aggregated
 * the device interface's lifetime is entirely defined by the
 * lifetime of its owning interface (the DirectDraw surface) so the
 * DirectDraw surface can never go away before the texture.
 *
 * EXTRA EXTRA BIG NOTE: No device description is passed in any more.
 * The only things that can get passed in are things that DirectDraw
 * knows about (which does not include stuff like dither and color
 * model). Therefore, any input parameters must come in via a
 * different IID for the device. The data returned by the device
 * description must now be retrieved by another call.
 */

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DCreateDevice"

HRESULT WINAPI Direct3DCreateDevice(REFCLSID            riid,
                                    LPUNKNOWN           lpDirect3D,
                                    LPDIRECTDRAWSURFACE lpDDSTarget,
                                    LPUNKNOWN*          lplpD3DDevice,
                                    IUnknown*           pUnkOuter,
                                    DWORD               dwVersion)
{
    LPDIRECT3DI       lpD3DI;
    LPDIRECT3DDEVICEI     pd3ddev;
    D3DCOLORMODEL     cm = D3DCOLOR_MONO;
    HRESULT ret = D3D_OK;
    HKEY                  hKey = (HKEY) NULL;
    bool                  bDisableDP = false;
    bool                  bDisableST = false;
    bool                  bDisableDP2 = false;
#if _D3D_FORCEDOUBLE
    bool    bForceDouble = true;
#endif  //_D3D_FORCEDOUBLE
    /* No need to validate params as they are passed to us by DirectDraw */

    /* CreateDevice member of IDirect3D2 will cause this function to be called
     * from within Direct3D. The parameters from the application level must be
     * validated. Need a way to validate the surface pointer from outside DDraw.
     */

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    TRY
    {
        if( ! VALID_PTR_PTR( lplpD3DDevice) )
        {
            D3D_ERR( "Invalid ptr to device pointer in Direct3DCreateDevice" );
            return DDERR_INVALIDPARAMS;
        }

        if(!IsValidD3DDeviceGuid(riid)) {
            D3D_ERR( "Unrecognized Device GUID!");
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters in Direct3DCreateDevice" );
        return DDERR_INVALIDPARAMS;
    }

    *lplpD3DDevice = NULL;

    // Might be safer to use dynamic_cast<> if RTTI is enabled
    lpD3DI = reinterpret_cast<CDirect3DUnk*>(lpDirect3D)->pD3DI;

#ifndef _X86_
    if(IsEqualIID(riid, IID_IDirect3DRampDevice)) {
         // quietly fail if trying to create a RampDevice on a non-x86 platform
         return DDERR_INVALIDPARAMS;
    }
#endif

    if((dwVersion>=3) && IsEqualIID(riid, IID_IDirect3DRampDevice)) {
         // Ramp not available in Device3.  No more old-style texture handles.
         D3D_ERR( "RAMP Device is incompatible with IDirect3DDevice3 and so cannot be created from IDirect3D3");
         return DDERR_INVALIDPARAMS;
    }

    if (IsEqualIID(riid, IID_IDirect3DMMXDevice) && !isMMXprocessor()) {
      D3D_ERR("Can't create MMX Device on non-MMX machine");
      return DDERR_INVALIDPARAMS;
    }

    if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, RESPATH_D3D, &hKey) )
    {
        DWORD dwType;
        DWORD dwValue;
        DWORD dwSize = 4;
#ifdef WIN95
        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, "DisableDP", NULL, &dwType, (LPBYTE) &dwValue, &dwSize) &&
             dwType == REG_DWORD &&
             dwValue != 0)
        {
            bDisableDP = true;
            bDisableDP2 = true;
        }
#endif //WIN95
        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, "DisableST", NULL, &dwType, (LPBYTE) &dwValue, &dwSize) &&
             dwType == REG_DWORD &&
             dwValue != 0)
        {
            bDisableST = true;
        }
#ifdef WIN95
        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, "DisableDP2", NULL, &dwType, (LPBYTE) &dwValue, &dwSize) &&
             dwType == REG_DWORD &&
             dwValue != 0)
        {
            bDisableDP2 = true;
        }
#endif //WIN95

        D3D_INFO(2,"EnableDP2: %d",!bDisableDP2);
#if _D3D_FORCEDOUBLE
        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, "ForceDouble", NULL, &dwType, (LPBYTE) &dwValue, &dwSize) &&
             dwType == REG_DWORD &&
             dwValue == 0)
        {
            bForceDouble = false;
        }
        D3D_INFO(2,"ForceDouble: %d",bForceDouble);
#endif  //_D3D_FORCEDOUBLE
        RegCloseKey( hKey );
    }
    LPD3DHAL_GLOBALDRIVERDATA lpD3DHALGlobalDriverData=((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->lpGbl->lpD3DGlobalDriverData;
#ifdef WIN95
    /* Test for presence of CB HAL */
    if (IsEqualIID(riid, IID_IDirect3DHALDevice) )
    {
        /* Test for presence of DP2 DDI */
        if ((lpD3DHALGlobalDriverData)
            && (lpD3DHALGlobalDriverData->hwCaps.dwDevCaps & D3DDEVCAPS_DRAWPRIMITIVES2EX)
           )
        {
            pd3ddev = static_cast<LPDIRECT3DDEVICEI>(new CDirect3DDeviceIDP2());
            if (pd3ddev) pd3ddev->deviceType = D3DDEVTYPE_DX7HAL;
        }
        else if ((!bDisableDP2) &&
            ((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->lpGbl->lpD3DHALCallbacks3 &&
            ((LPD3DHAL_CALLBACKS3)((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->lpGbl->lpD3DHALCallbacks3)->DrawPrimitives2)
        {
            pd3ddev = static_cast<LPDIRECT3DDEVICEI>(new CDirect3DDeviceIDP2());
        }
        /* Test for presence DP HAL */
        else if ((!bDisableDP) &&
                ((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->lpGbl->lpD3DHALCallbacks2 &&
                ((LPD3DHAL_CALLBACKS2)((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->lpGbl->lpD3DHALCallbacks2)->DrawOnePrimitive)
        {
            pd3ddev = static_cast<LPDIRECT3DDEVICEI>(new CDirect3DDeviceIDP());
        }
        else
        {
            pd3ddev = static_cast<LPDIRECT3DDEVICEI>(new CDirect3DDeviceIHW());
        }
    }
    else // all software rasterizers are DP-enabled
#endif // WIN95
    if (!bDisableDP2)
    {
        if ((lpD3DHALGlobalDriverData)
            && (IsEqualIID(riid, IID_IDirect3DHALDevice) )
            && (lpD3DHALGlobalDriverData->hwCaps.dwDevCaps & D3DDEVCAPS_DRAWPRIMITIVES2EX)
           )
        {
            pd3ddev = static_cast<LPDIRECT3DDEVICEI>(new CDirect3DDeviceIDP2());
            if (pd3ddev) pd3ddev->deviceType = D3DDEVTYPE_DX7HAL;
        }
        else
        {
            pd3ddev = static_cast<LPDIRECT3DDEVICEI>(new CDirect3DDeviceIDP2());
        }
    }
    else if (!bDisableDP)
        pd3ddev = static_cast<LPDIRECT3DDEVICEI>(new CDirect3DDeviceIDP());
    else
        pd3ddev = static_cast<LPDIRECT3DDEVICEI>(new CDirect3DDeviceIHW());

    if (!pd3ddev) {
        D3D_ERR("Failed to allocate space for D3DDevice. Quitting.");
        return (DDERR_OUTOFMEMORY);
    }

    // If we have lost managed textures, we need to cleanup
    // since CheckSurfaces() would fail which would cause
    // FlushStates() to fail, which would result in the
    // current batch being abandoned (along with any device initialization)
    if(lpD3DI->lpTextureManager->CheckIfLost())
    {
        D3D_INFO(2, "Found lost managed textures. Evicting...");
        lpD3DI->lpTextureManager->EvictTextures();
    }

    if (bDisableDP)
        pd3ddev->dwDebugFlags |= D3DDEBUG_DISABLEDP;
    if (bDisableDP2)
        pd3ddev->dwDebugFlags |= D3DDEBUG_DISABLEDP2;

    ret = pd3ddev->Init(riid, lpD3DI, lpDDSTarget, pUnkOuter, lplpD3DDevice, dwVersion);
    if (ret!=D3D_OK)
    {
        delete pd3ddev;
        D3D_ERR("Failed to intilialize D3DDevice");
        return ret;
    }

    if (bDisableST)
        pd3ddev->dwHintFlags |= D3DDEVBOOL_HINTFLAGS_MULTITHREADED;

#ifdef _X86_
    if (((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->dwLocalFlags & DDRAWILCL_FPUSETUP &&
        IS_DP2HAL_DEVICE(pd3ddev))
    {
        WORD wSave, wTemp;
        __asm {
            fstcw wSave
            mov ax, wSave
            and ax, not 300h    ;; single mode
            or  ax, 3fh         ;; disable all exceptions
            and ax, not 0C00h   ;; round to nearest mode
            mov wTemp, ax
            fldcw   wTemp
        }
    }
#if _D3D_FORCEDOUBLE
    if (bForceDouble && (pd3ddev->deviceType <= D3DDEVTYPE_DPHAL))
    {
        pd3ddev->dwDebugFlags |= D3DDEBUG_FORCEDOUBLE;
    }
    else
    {
        pd3ddev->dwDebugFlags &= ~D3DDEBUG_FORCEDOUBLE;
    }
#endif  //_D3D_FORCEDOUBLE
#endif

    return (ret);
}

HRESULT DIRECT3DDEVICEI::Init(REFCLSID riid, LPDIRECT3DI lpD3DI, LPDIRECTDRAWSURFACE lpDDS,
                              IUnknown* pUnkOuter, LPUNKNOWN* lplpD3DDevice, DWORD dwVersion)
{
    DDSCAPS               ddscaps;
    DDSURFACEDESC     ddsd;
    HRESULT       ret, ddrval;
    LPDIRECTDRAWSURFACE lpDDSZ=NULL;
    LPDIRECTDRAWPALETTE lpDDPal=NULL;
    LPGUID              pGuid;
    BOOL          bIsDX3Device;
    DDSCAPS surfCaps;

    this->dwFVFLastIn = this->dwFVFLastOut = 0;
    this->mDevUnk.refCnt             = 1;
    this->dwVersion          = dwVersion;
    this->mDevUnk.pDevI = this;
    pD3DMappedTexI = (LPVOID*)(this->lpD3DMappedTexI);
    pfnFlushStates = D3DFlushStates;
    this->dwFEFlags |= D3DFE_TSSINDEX_DIRTY;

    /* Single threaded or Multi threaded app ? */
    if (((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->dwLocalFlags & DDRAWILCL_MULTITHREADED)
        this->dwHintFlags |= D3DDEVBOOL_HINTFLAGS_MULTITHREADED;

    /*
     * Are we really being aggregated?
     */

    bIsDX3Device=(pUnkOuter!=NULL);

    if (bIsDX3Device)
    {
        /*
         * Yup - we are being aggregated. Store the supplied
         * IUnknown so we can punt to that.
         * NOTE: We explicitly DO NOT AddRef here.
         */
        this->lpOwningIUnknown = pUnkOuter;
        DDASSERT(dwVersion==1);
    }
    else
    {
        /*
         * Nope - but we pretend we are anyway by storing our
         * own IUnknown as the parent IUnknown. This makes the
         * code much neater.
         */
        this->lpOwningIUnknown = (LPUNKNOWN)&this->mDevUnk;
    }

    // create the begin/end critical section
    InitializeCriticalSection(&this->BeginEndCSect);

    /*
     * Initialise textures
     */
    LIST_INITIALIZE(&this->texBlocks);

    /*
     * Initialise buffers
     */
    LIST_INITIALIZE(&this->buffers);

    /*
     * Initialise viewports
     */
    CIRCLE_QUEUE_INITIALIZE(&this->viewports, DIRECT3DVIEWPORTI);

    this->lpCurrentViewport = NULL;
    this->v_id = 0;

    /*
     * Initialise materials
     */
    LIST_INITIALIZE(&this->matBlocks);

    this->lpvVertexBatch = this->lpIndexBatch = NULL;
    this->dwHWNumCounts = 0;
    this->dwHWOffset = 0;
    this->dwHWTriIndex = 0;
    this->lpTextureBatched = NULL;
    this->dwVertexBase = 0;
    pGeometryFuncs = &GeometryFuncsGuaranteed;

    /*-----------------------------------------------------------------------------------------
     * Up till now we have done the easy part of the initialization. This is the stuff that
     * cannot fail. It initializes the object so that the destructor can be safely called if
     * any of the further initialization does not succeed.
     *---------------------------------------------------------------------------------------*/

    /*
     * Ensure the riid is one we understand.
     *
     * Query the registry.
     */
    pGuid = (GUID *)&riid;

#if DBG
    if (IsEqualIID(*pGuid, IID_IDirect3DRampDevice))
    {
        D3D_INFO(1, "======================= Ramp device selected");
    }
    if (IsEqualIID(*pGuid, IID_IDirect3DRGBDevice))
    {
        D3D_INFO(1, "======================= RGB device selected");
    }
    if (IsEqualIID(*pGuid, IID_IDirect3DMMXDevice))
    {
        D3D_INFO(1, "======================= RGB(MMX) device selected");
    }
    if (IsEqualIID(*pGuid, IID_IDirect3DHALDevice))
    {
        D3D_INFO(1, "======================= HAL device selected");
    }
    if (IsEqualIID(*pGuid, IID_IDirect3DRefDevice))
    {
        D3D_INFO(1, "======================= Reference Rasterizer device selected");
    }
    if (IsEqualIID(*pGuid, IID_IDirect3DNullDevice))
    {
        D3D_INFO(1, "======================= Null device selected");
    }
    if (IsEqualIID(*pGuid, IID_IDirect3DNewRGBDevice))
    {
        D3D_INFO(1, "======================= New RGB device selected");
    }
    D3D_INFO(1,"with HAL deviceType=%d",deviceType);
#endif

    // set up flag to use MMX when requested RGB
    BOOL bUseMMXAsRGBDevice = FALSE;
    if (IsEqualIID(*pGuid, IID_IDirect3DRGBDevice) && isMMXprocessor())
    {
        bUseMMXAsRGBDevice = TRUE;
        // read reg key to override use of MMX for RGB
        HKEY    hKey = (HKEY) NULL;
        if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, RESPATH, &hKey) )
        {
            DWORD dwType;
            DWORD dwValue;
            DWORD dwSize = 4;

            if ( ERROR_SUCCESS == RegQueryValueEx( hKey, "UseMMXForRGB", NULL, &dwType, (LPBYTE) &dwValue, &dwSize) &&
                 dwType == REG_DWORD &&
                 dwValue == 0)
            {
                bUseMMXAsRGBDevice = FALSE;
            }
            RegCloseKey( hKey );
        }
        if (bUseMMXAsRGBDevice)
        {
            D3D_INFO(1, "  using MMX in RGB device");
        }
    }

    BOOL bIsRamp = FALSE;
    if (IsEqualIID(*pGuid, IID_IDirect3DRampDevice))
    {
        bIsRamp = TRUE;
    }

    if (IsEqualIID(*pGuid, IID_IDirect3DRGBDevice) &&
        isMMXprocessor())
    {
        // Check for whether this app is one of the Intel ones
        // that want the MMX rasterizer
        LPDDRAWI_DIRECTDRAW_LCL lpDDLcl = ((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl;

        // 0x4 corresponds to the "Intel app that wants MMX"
        // flag defined in ddrawpr.h
        if ( lpDDLcl->dwAppHackFlags & 0x4 )
        {
            pGuid = (GUID *)&IID_IDirect3DMMXDevice;
        }
    }

    /*
     * Check if the 3D cap is set on the surface.
     */
    memset(&ddsd, 0, sizeof ddsd);
    ddsd.dwSize = sizeof ddsd;
    ddrval = lpDDS->GetSurfaceDesc(&ddsd);
    if (ddrval != DD_OK) {
        D3D_ERR("Failed to get surface description of device's surface.");
        return (ddrval);
    }

    if (!(ddsd.ddsCaps.dwCaps & DDSCAPS_3DDEVICE)) {
        D3D_ERR("**** The DDSCAPS_3DDEVICE is not set on this surface.");
        D3D_ERR("**** You need to add DDSCAPS_3DDEVICE to ddsCaps.dwCaps");
        D3D_ERR("**** when creating the surface.");
        return (DDERR_INVALIDCAPS);
    }

    if (ddsd.ddsCaps.dwCaps & DDSCAPS_ZBUFFER) {
        D3D_ERR("**** DDSCAPS_ZBUFFER is set on this surface.");
        D3D_ERR("**** Rendering into Z buffer surfaces is not");
        D3D_ERR("**** currently supported by Direct3D.");
        return (DDERR_INVALIDCAPS);
    }

    if (ddsd.dwWidth > 2048 || ddsd.dwHeight > 2048)
    {
        D3D_ERR("**** Surface too large - must be <= 2048 in width & height.");
        return (DDERR_INVALIDOBJECT);
    }

    /* Check for palette... */
    ret = lpDDS->GetPalette(&lpDDPal);
    if ((ret != DD_OK) && (ret != DDERR_NOPALETTEATTACHED))
    {
        /*
         * NOTE: Again, not an error (yet) if there is no palette attached.
         * But if there is palette and we can't get at it for some reason
         * - fail.
         */
        D3D_ERR("Supplied DirectDraw Palette is invalid - can't create device");
        return (DDERR_INVALIDPARAMS);
    }

    /*
     * We're going to check now whether we should have got a palette.
     */
    if (ret == DDERR_NOPALETTEATTACHED) {
        if (ddsd.ddpfPixelFormat.dwRGBBitCount < 16) {
            D3D_ERR("No palette supplied for palettized surface - can't create device");
            return (DDERR_NOPALETTEATTACHED);
        }
    }

    // For DX3, we must not keep references to Palette and ZBuffer to avoid
    // circular references in the aggregation model.  But for DX5+, we want
    // to keep references to both to ensure they dont disappear.

    if(bIsDX3Device && (lpDDPal != NULL))
       lpDDPal->Release();  // release the reference GetPalette created
    this->lpDDPalTarget = lpDDPal;

    // Check for ZBuffer

    memset(&surfCaps, 0, sizeof(DDSCAPS));
    surfCaps.dwCaps = DDSCAPS_ZBUFFER;

    if (FAILED(ret = lpDDS->GetAttachedSurface(&surfCaps, &lpDDSZ))) {
        if (ret != DDERR_NOTFOUND) {
           D3D_ERR("Failed GetAttachedSurface for ZBuffer");
           goto handle_err;
        }
        D3D_INFO(2, "No zbuffer is attached to rendertarget surface (which is OK)");
    }

    if(bIsDX3Device && (lpDDSZ != NULL))
       lpDDSZ->Release();   // release the reference GetAttachedSurface created
    this->lpDDSZBuffer = lpDDSZ;

    this->guid = *pGuid;

    // Try to get a HAL provider for this driver (may need to use MMX guid if
    // using MMX for RGB requested device)
    ret = GetSwHalProvider(
        bUseMMXAsRGBDevice ? IID_IDirect3DMMXAsRGBDevice : riid,
        &this->pHalProv, &this->hDllProv);

    if (ret == S_OK)
    {
        // Got a software provider.
    }
    else if (ret == E_NOINTERFACE &&
             ((ret = GetHwHalProvider(riid, &this->pHalProv,
                                     &this->hDllProv,
                                     ((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->lpGbl)) == S_OK))
    {
        // Got a hardware provider.
    }
    else
    {
        if(IsEqualIID(riid, IID_IDirect3DHALDevice)) {
            D3D_ERR("Requested HAL Device non-existent or invalid");
        } else {
            D3D_ERR("Unable to get D3D Device provider for requested GUID");
        }
        goto handle_err;
    }

    {
        // Initialize test HAL provider to drop HAL calls (sort of a Null device)
        //
        DWORD value = 0;
        if (GetD3DRegValue(REG_DWORD, "DisableRendering", &value, sizeof(DWORD)) &&
            value != 0)
        {
            ret = GetTestHalProvider(
                    riid, ((LPDDRAWI_DIRECTDRAW_INT)lpD3DI->lpDD)->lpLcl->lpGbl,
                    &this->pHalProv, this->pHalProv, 0);
            if (ret != D3D_OK)
            {
                D3D_ERR("Unable to set up 'DisableRendering' mode");
                goto handle_err;
            }
        }
    }

    // Initialise general DEVICEI information.
    if ((ret = InitDeviceI(this, lpD3DI)) != D3D_OK)
    {
        D3D_ERR("Failed to initialise device");
        goto handle_err;
    }

    // Check the surface and device to see if they're compatible
    if (FAILED(ret = checkDeviceSurface(lpDDS,lpDDSZ,pGuid))) {
        D3D_ERR("Device and surface aren't compatible");
        goto handle_err;
    }

    // Create front-end support structures.
    // ATTENTION - We probably want to avoid doing this if the driver
    // does its own front end.  Software fallbacks complicate the issue,
    // though.
    ret = D3DFE_Create(this, lpD3DI->lpDD, lpDDS, lpDDSZ, lpDDPal);
    if (ret != D3D_OK)
    {
        D3D_ERR("Failed to create front-end data-structures.");
        goto handle_err;
    }

    // Figure out place for rstates
    if (IS_HW_DEVICE(this) && IS_DP2HAL_DEVICE(this))
    {
        // In case of HW DP2 HAL we reuse the kernel allocated
        // memory for RStates since we need the driver to update
        // it
        rstates = (LPDWORD)lpwDPBuffer;
    }
    else
    {
        // In all other cases we simply allocate memory for rstates
        rstates = new DWORD[D3DHAL_MAX_RSTATES];
    }
    D3DFE_PROCESSVERTICES::lpdwRStates = this->rstates;

    // Check if we have a processor specific implementation available
    //  only use if DisablePSGP is not in registry or set to zero
    DWORD value;
    if (!GetD3DRegValue(REG_DWORD, "DisablePSGP", &value, sizeof(DWORD)))
    {
        value = 0;
    }

#ifdef _X86_
extern HRESULT D3DAPI pii_FEContextCreate(DWORD dwFlags, LPD3DFE_PVFUNCS *lpLeafFuncs);
    if (pfnFEContextCreate == pii_FEContextCreate)
    {
        // here if this is PentiumII PSGP

        // regkey disable for PII PSGP - default is ENABLED
        DWORD dwValue2;  // disable if this is TRUE
        if (!GetD3DRegValue(REG_DWORD, "DisablePIIPSGP", &dwValue2, sizeof(DWORD)))
        {
            dwValue2 = 0;
        }
        else
        {
            D3D_INFO(2, "DisablePIIPSGP %d",dwValue2);
        }

        // do disable
        if ( dwValue2 )
        {
            pfnFEContextCreate = NULL;
        }
    }
#endif

    if (pfnFEContextCreate && ( value == 0) && (!bIsRamp) )
    {
        D3D_INFO(2, "PSGP enabled for device");
        // Ask the PV implementation to create a device specific "context"
        LPD3DFE_PVFUNCS pOptGeoFuncs = pGeometryFuncs;
        ret = pfnFEContextCreate(dwDeviceFlags, &pOptGeoFuncs);
        if ((ret == D3D_OK) && pOptGeoFuncs)
        {
            D3D_INFO(2, "using PSGP");
            pGeometryFuncs = pOptGeoFuncs;
        }
    }

    /*
     * put this device in the list of those owned by the Direct3D object
     */
    ret = hookDeviceToD3D(lpD3DI);
    if (ret != D3D_OK)
    {
        D3D_ERR("Failed to associate device with Direct3D");
        goto handle_err;
    }
    {
        if(lpD3DHALGlobalDriverData->hwCaps.dwMaxVertexCount == 0)
        {
            lpD3DHALGlobalDriverData->hwCaps.dwMaxVertexCount = __INIT_VERTEX_NUMBER;
        }
        if (TLVbuf.Grow(this, (__INIT_VERTEX_NUMBER*2)*sizeof(D3DTLVERTEX)) != DD_OK)
        {
            D3D_ERR( "Out of memory in DeviceCreate (TLVbuf)" );
            ret = DDERR_OUTOFMEMORY;
            goto handle_err;
        }
        if (HVbuf.Grow((__INIT_VERTEX_NUMBER*2)*sizeof(D3DFE_CLIPCODE)) != DD_OK)
        {
            D3D_ERR( "Out of memory in DeviceCreate (HVBuf)" );
            ret = DDERR_OUTOFMEMORY;
            goto handle_err;
        }
        ret = this->ClipperState.clipBuf.Grow
                (this, MAX_CLIP_VERTICES*__MAX_VERTEX_SIZE);
        if (ret != D3D_OK)
        {
            D3D_ERR( "Out of memory in DeviceCreate (ClipBuf)" );
            ret = DDERR_OUTOFMEMORY;
            goto handle_err;
        }
        ret = this->ClipperState.clipBufPrim.Grow
                (this, MAX_CLIP_TRIANGLES*sizeof(D3DTRIANGLE));
        if (ret != D3D_OK)
        {
            D3D_ERR( "Out of memory in DeviceCreate (ClipBufPrim)" );
            ret = DDERR_OUTOFMEMORY;
            goto handle_err;
        }

    }
    /*
     * IDirect3DDevice2 specific initialization
     */
    if (D3DMalloc((void**)&this->wTriIndex, dwD3DTriBatchSize*4*sizeof(WORD)) != DD_OK) {
        D3D_ERR( "Out of memory in DeviceCreate (wTriIndex)" );
        ret = DDERR_OUTOFMEMORY;
        goto handle_err;
    }

    if (D3DMalloc((void**)&this->lpHWCounts, dwHWBufferSize*sizeof(D3DI_HWCOUNTS)/32 ) != DD_OK)
    {
        D3D_ERR( "Out of memory in DeviceCreate (HWCounts)" );
        ret = DDERR_OUTOFMEMORY;
        goto handle_err;
    }
    memset(this->lpHWCounts, 0, sizeof(D3DI_HWCOUNTS) );
    this->lpHWVertices = (LPD3DTLVERTEX) this->lpwDPBuffer;
    if (D3DMalloc((void**)&this->lpHWTris, dwHWMaxTris*sizeof(D3DTRIANGLE) ) != DD_OK)
    {
        D3D_ERR( "Out of memory in DeviceCreate (HWVertices)" );
        ret = DDERR_OUTOFMEMORY;
        goto handle_err;
    }

    if (DDERR_OUTOFMEMORY == (ret=HookD3DDeviceToSurface(this, ((LPDDRAWI_DDRAWSURFACE_INT) lpDDS)->lpLcl)))
        goto handle_err;
    if (lpDDSZ && (DDERR_OUTOFMEMORY == (ret=HookD3DDeviceToSurface(this, ((LPDDRAWI_DDRAWSURFACE_INT) lpDDSZ)->lpLcl))))
    {
        UnHookD3DDeviceFromSurface(this, ((LPDDRAWI_DDRAWSURFACE_INT) lpDDS)->lpLcl);
        goto handle_err;
    }

    /* Set the initial render state of the device */
    if (FAILED(ret = stateInitialize(lpDDSZ!=NULL))) {
        D3D_ERR("Failed to set initial state for device");
        goto handle_err;
    }

    /*
     * NOTE: We don't return the actual device interface. We
     * return the device's special IUnknown interface which
     * will be used in a QueryInterface to get the actual
     * Direct3D device interface.
     */
    *lplpD3DDevice = static_cast<LPUNKNOWN>(&(this->mDevUnk));


    return (D3D_OK);
handle_err:
    // might be able to simplify if this fn and not D3DFE_Create sets this->lpDDSZBuffer/this->lpDDPalette
    if(lpDDSZ!=NULL) {
       if(!bIsDX3Device) {
           lpDDSZ->Release();    // release the reference GetAttachedSurface created
       }
       this->lpDDSZBuffer=NULL;  // make sure the device destructor doesn't try to re-release this
                                 // I'd let device destructor handle this, but errors can occur before D3DFE_Create is called
    }

    if(lpDDPal!=NULL) {
      if(!bIsDX3Device) {
        lpDDPal->Release();      // release the reference GetPalette created
      }
      this->lpDDPalTarget=NULL;  // make sure the device destructor doesn't try to re-release this
    }

    D3D_ERR("Device creation failed!!");
    return(ret);
}

#undef DPF_MODNAME
#define DPF_MODNAME "DIRECT3DDEVICEI::GetStats"

HRESULT D3DAPI DIRECT3DDEVICEI::GetStats(LPD3DSTATS lpStats)
{
    // not implemented for Device3 (and newer) interfaces
    if (this->dwVersion >= 3)
    {
        D3D_INFO(3, "GetStats not implemented for Device3 interface");
        return E_NOTIMPL;
    }

    D3DSTATS    stats;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_D3DSTATS_PTR(lpStats)) {
            D3D_ERR( "Invalid D3DSTATS pointer" );
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters in GetStats" );
        return DDERR_INVALIDPARAMS;
    }

    stats = this->D3DStats;

    *lpStats = stats;
    lpStats->dwSize = sizeof(D3DSTATS);

    return DD_OK;
}

/**
 ** Viewport Management
 **/
HRESULT DIRECT3DDEVICEI::hookViewportToDevice(LPDIRECT3DVIEWPORTI lpD3DView)
{

    CIRCLE_QUEUE_INSERT_END(&this->viewports, DIRECT3DVIEWPORTI,
                            lpD3DView, vw_list);
    lpD3DView->lpDevI = this;

    this->numViewports++;

    return (D3D_OK);
}

#undef DPF_MODNAME
#define DPF_MODNAME "DIRECT3DDEVICEI::AddViewport"

HRESULT D3DAPI DIRECT3DDEVICEI::AddViewport(LPDIRECT3DVIEWPORT lpD3DView)
{
    return AddViewport((LPDIRECT3DVIEWPORT3)lpD3DView);
}

HRESULT D3DAPI DIRECT3DDEVICEI::AddViewport(LPDIRECT3DVIEWPORT2 lpD3DView)
{
    return AddViewport((LPDIRECT3DVIEWPORT3)lpD3DView);
}

HRESULT D3DAPI DIRECT3DDEVICEI::AddViewport(LPDIRECT3DVIEWPORT3 lpD3DView)
{
    LPDIRECT3DVIEWPORTI lpViewI;
    HRESULT err = D3D_OK;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    lpViewI = (LPDIRECT3DVIEWPORTI)lpD3DView;

    if (lpViewI->lpDevI) {
        D3D_ERR("viewport already associated with a device");
        return (DDERR_INVALIDPARAMS);
    }

    err = hookViewportToDevice(lpViewI);

    /*
     * AddRef the viewport.
     */
    lpD3DView->AddRef();

    return (err);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::DeleteViewport"

HRESULT D3DAPI DIRECT3DDEVICEI::DeleteViewport(LPDIRECT3DVIEWPORT lpD3DView)
{
    return DeleteViewport((LPDIRECT3DVIEWPORT3)lpD3DView);
}

HRESULT D3DAPI DIRECT3DDEVICEI::DeleteViewport(LPDIRECT3DVIEWPORT2 lpD3DView)
{
    return DeleteViewport((LPDIRECT3DVIEWPORT3)lpD3DView);
}

HRESULT D3DAPI DIRECT3DDEVICEI::DeleteViewport(LPDIRECT3DVIEWPORT3 lpD3DView)
{
    LPDIRECT3DVIEWPORTI lpViewI;
    HRESULT err = D3D_OK;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DVIEWPORT3_PTR(lpD3DView)) {
            D3D_ERR( "Invalid Direct3DViewport pointer" );
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters in DeleteViewport" );
        return DDERR_INVALIDPARAMS;
    }
    if (this->dwHintFlags & D3DDEVBOOL_HINTFLAGS_INBEGIN)
    {
        D3D_ERR( "DeleteViewport in Begin" );
        return D3DERR_INBEGIN;
    }
    lpViewI = (LPDIRECT3DVIEWPORTI)lpD3DView;

    if (lpViewI->lpDevI != this) {
        D3D_ERR("This Viewport is not associated with this device");
        return (DDERR_INVALIDPARAMS);
    }

    /*
     * Remove this viewport from the device.
     */
    CIRCLE_QUEUE_DELETE(&this->viewports, lpViewI, vw_list);
    this->numViewports--;

    lpViewI->lpDevI = NULL;
    if (lpViewI == lpCurrentViewport)
    {
        // AnanKan (6/10/98):
        // Apparently this release needs to be done for proper COM
        // implementation, since we do lpCurrentViewport->AddRef() when
        // we make a viewport the current viewport of the device. But this
        // breaks some old apps (pplane.exe)
        if(!(this->dwDeviceFlags & D3DDEV_PREDX6DEVICE))
            lpCurrentViewport->Release();
        lpCurrentViewport = NULL;
        v_id = 0;
    }

    /*
     * Release the viewport.
     */
    lpD3DView->Release();

    return (err);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::NextViewport"

HRESULT D3DAPI DIRECT3DDEVICEI::NextViewport(LPDIRECT3DVIEWPORT lpD3DView,
                                   LPDIRECT3DVIEWPORT* lplpView,
                                   DWORD dwFlags)
{
    return NextViewport((LPDIRECT3DVIEWPORT3)lpD3DView,
                               (LPDIRECT3DVIEWPORT3*)lplpView, dwFlags);
}

HRESULT D3DAPI DIRECT3DDEVICEI::NextViewport(LPDIRECT3DVIEWPORT2 lpD3DView,
                                    LPDIRECT3DVIEWPORT2* lplpView,
                                    DWORD dwFlags)
{
    return NextViewport((LPDIRECT3DVIEWPORT3)lpD3DView,
                               (LPDIRECT3DVIEWPORT3*)lplpView, dwFlags);
}

HRESULT D3DAPI DIRECT3DDEVICEI::NextViewport(LPDIRECT3DVIEWPORT3 lpD3DView,
                                    LPDIRECT3DVIEWPORT3* lplpView,
                                    DWORD dwFlags)
{
    LPDIRECT3DVIEWPORTI lpViewI;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_OUTPTR(lplpView)) {
            D3D_ERR( "Invalid pointer to viewport object pointer" );
            return DDERR_INVALIDPARAMS;
        }

        *lplpView = NULL;

        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (dwFlags == D3DNEXT_NEXT) {
            if (!VALID_DIRECT3DVIEWPORT3_PTR(lpD3DView)) {
                D3D_ERR( "Invalid Direct3DViewport pointer" );
                return DDERR_INVALIDPARAMS;
            }
            lpViewI = (LPDIRECT3DVIEWPORTI)lpD3DView;
            if (lpViewI->lpDevI != this) {
                D3D_ERR("This Viewport is not associated with this device");
                return (DDERR_INVALIDPARAMS);
            }
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR("Exception encountered validating parameters in NextViewport");
        return DDERR_INVALIDPARAMS;
    }

    if (this->numViewports <= 0) {
        D3D_ERR( "No viewport has been added to the device yet." );
        return D3DERR_NOVIEWPORTS;
    }

    if (this->dwHintFlags & D3DDEVBOOL_HINTFLAGS_INBEGIN)
    {
        D3D_ERR( "NextViewport called in Begin" );
        return D3DERR_INBEGIN;
    }
    switch (dwFlags) {
    case D3DNEXT_NEXT:
        *lplpView = (LPDIRECT3DVIEWPORT3)
            CIRCLE_QUEUE_NEXT(&this->viewports,lpViewI,vw_list);
        break;
    case D3DNEXT_HEAD:
        *lplpView = (LPDIRECT3DVIEWPORT3)
            CIRCLE_QUEUE_FIRST(&this->viewports);
        break;
    case D3DNEXT_TAIL:
        *lplpView = (LPDIRECT3DVIEWPORT3)
            CIRCLE_QUEUE_LAST(&this->viewports);
        break;
    default:
        D3D_ERR("invalid dwFlags in NextViewport");
        return (DDERR_INVALIDPARAMS);
    }
    if (*lplpView == (LPDIRECT3DVIEWPORT3)&this->viewports) {
        *lplpView = NULL;
    }

    /*
     * Must AddRef the returned object
     */
    if (*lplpView) {
        (*lplpView)->AddRef();
    }

    return (D3D_OK);
}
//---------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "DIRECT3DDEVICEI::Execute"

HRESULT D3DAPI DIRECT3DDEVICEI::Execute(LPDIRECT3DEXECUTEBUFFER lpBuffer,
                              LPDIRECT3DVIEWPORT lpD3DView,
                              DWORD dwInpFlags)
{
    HRESULT ret;
    LPDIRECT3DVIEWPORTI lpD3DViewI;
    LPDIRECT3DVIEWPORTI lpD3DOldViewI;
    BOOL viewportChanged;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this))
        {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_DIRECT3DEXECUTEBUFFER_PTR(lpBuffer))
        {
            D3D_ERR( "Invalid Direct3DExecuteBuffer pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (lpD3DView && (!VALID_DIRECT3DVIEWPORT_PTR(lpD3DView)) )
        {
            D3D_ERR( "Invalid Direct3DViewport pointer" );
            return DDERR_INVALIDOBJECT;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters in Execute" );
        return DDERR_INVALIDPARAMS;
    }
    lpD3DOldViewI = lpCurrentViewport;
    if (lpD3DView)
        lpD3DViewI = (LPDIRECT3DVIEWPORTI)lpD3DView;
    else
        lpD3DViewI = lpCurrentViewport;

    // The viewport must be associated with lpDev device
    //
    if (lpD3DViewI->lpDevI != this)
    {
        return (DDERR_INVALIDPARAMS);
    }

    lpCurrentViewport = lpD3DViewI;

    ret = CheckDeviceSettings(this);
    if (ret != D3D_OK)
    {
        lpCurrentViewport = lpD3DOldViewI;
        D3D_ERR("Bad Device settings");
        return (ret);
    }

    /*
     * Save existing fp state and then disable divide-by-zero exceptions.
     * XXX need a better way for non-intel platforms.
     */

    LPDIRECT3DEXECUTEBUFFERI lpBufferI;
    D3DI_EXECUTEDATA exData;

    lpBufferI = (LPDIRECT3DEXECUTEBUFFERI)lpBuffer;

    /* Make sure this buffer is associated with the correct device */
    if (lpBufferI->lpDevI != this)
    {
        D3D_ERR("Exe-buffer not associated with this device");
        return (DDERR_INVALIDPARAMS);
    }

    if (lpBufferI->locked)
    {
        D3D_ERR("Exe-buffer is locked");
        return (D3DERR_EXECUTE_LOCKED);
    }

    /* Apply any cached render states */
    if ((ret=this->FlushStates()) != D3D_OK)
    {
        D3D_ERR("Error trying to flush batched commands");
        return ret;
    }
    /*
     * Create an execute data structure
     */
    memset(&exData, 0, sizeof(exData));
    exData.dwSize = sizeof(D3DI_EXECUTEDATA);
    exData.dwHandle = lpBufferI->hBuf;
    exData.dwVertexOffset = lpBufferI->exData.dwVertexOffset;
    exData.dwVertexCount = lpBufferI->exData.dwVertexCount;
    exData.dwInstructionOffset = lpBufferI->exData.dwInstructionOffset;
    exData.dwInstructionLength = lpBufferI->exData.dwInstructionLength;
    exData.dwHVertexOffset = lpBufferI->exData.dwHVertexOffset;

#if DBG
// Validation
    if (exData.dwVertexOffset > exData.dwInstructionOffset ||
        (exData.dwVertexCount * sizeof(D3DVERTEX) + exData.dwVertexOffset) >
        exData.dwInstructionOffset)
    {
        D3D_WARN(1, "Execute: Instruction and vertex areas overlap");
    }

#endif

    this->dwFlags = D3DPV_INSIDEEXECUTE;
    this->dwVIDOut = D3DFVF_TLVERTEX;

    ret = this->ExecuteI(&exData, dwInpFlags);
    if (ret != D3D_OK)
    {
        D3D_ERR("Error trying to Execute");
        return ret;
    }

    this->dwFEFlags &= ~D3DFE_TLVERTEX;    // This flag could be set inside
    // Flush immediately since we cannot batch across EB calls (for DP2)
    if ((ret=this->FlushStates()) != D3D_OK)
    {
        D3D_ERR("Error trying to flush batched commands");
        return ret;
    }
    lpBufferI->exData.dsStatus = exData.dsStatus;

    lpCurrentViewport = lpD3DOldViewI;

    return (ret);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::GetCaps"

HRESULT D3DAPI CDirect3DDevice::GetCaps(LPD3DDEVICEDESC lpD3DHWDevDesc,
                              LPD3DDEVICEDESC lpD3DHELDevDesc)
{
    HRESULT ret;

    ret = GetCapsI(lpD3DHWDevDesc, lpD3DHELDevDesc);
    if ((ret == D3D_OK) && IS_PRE_DX5_DEVICE(this))
    {
        lpD3DHELDevDesc->dpcLineCaps.dwTextureFilterCaps &= ~(D3DPTFILTERCAPS_MIPNEAREST |
                                                              D3DPTFILTERCAPS_MIPLINEAR |
                                                              D3DPTFILTERCAPS_LINEARMIPNEAREST);
        lpD3DHELDevDesc->dpcTriCaps.dwTextureFilterCaps &= ~(D3DPTFILTERCAPS_MIPNEAREST |
                                                             D3DPTFILTERCAPS_MIPLINEAR |
                                                             D3DPTFILTERCAPS_LINEARMIPNEAREST);
    }
    return ret;
}

HRESULT D3DAPI D3DAPI DIRECT3DDEVICEI::GetCaps(LPD3DDEVICEDESC lpD3DHWDevDesc,
                               LPD3DDEVICEDESC lpD3DHELDevDesc)
{
    return GetCapsI(lpD3DHWDevDesc, lpD3DHELDevDesc);
}

HRESULT DIRECT3DDEVICEI::GetCapsI(LPD3DDEVICEDESC lpD3DHWDevDesc,
                               LPD3DDEVICEDESC lpD3DHELDevDesc)
{
    HRESULT ret;

    ret = D3D_OK;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_D3DDEVICEDESC_PTR(lpD3DHWDevDesc)) {
            D3D_ERR( "Invalid D3DDEVICEDESC pointer" );
            return DDERR_INVALIDPARAMS;
        }
        if (!VALID_D3DDEVICEDESC_PTR(lpD3DHELDevDesc)) {
            D3D_ERR( "Invalid D3DDEVICEDESC pointer" );
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters in GetCaps" );
        return DDERR_INVALIDPARAMS;
    }

    memcpy(lpD3DHWDevDesc, &this->d3dHWDevDesc, lpD3DHWDevDesc->dwSize);
    memcpy(lpD3DHELDevDesc, &this->d3dHELDevDesc, lpD3DHELDevDesc->dwSize);
    return (ret);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::Pick"

HRESULT D3DAPI DIRECT3DDEVICEI::Pick(LPDIRECT3DEXECUTEBUFFER lpD3DExBuf,
                           LPDIRECT3DVIEWPORT lpD3DView,
                           DWORD dwFlags,
                           LPD3DRECT lpRect)
{
    HRESULT ret;
    LPDIRECT3DVIEWPORTI lpD3DViewI;
    LPDIRECT3DVIEWPORTI lpD3DOldViewI;
    LPDIRECT3DEXECUTEBUFFERI lpBufferI;
    D3DI_PICKDATA pdata;
    D3DI_EXECUTEDATA exData;

    ret = D3D_OK;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_DIRECT3DEXECUTEBUFFER_PTR(lpD3DExBuf)) {
            D3D_ERR( "Invalid Direct3DExecuteBuffer pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_DIRECT3DVIEWPORT_PTR(lpD3DView)) {
            D3D_ERR( "Invalid Direct3DViewport pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_D3DRECT_PTR(lpRect)) {
            D3D_ERR( "Invalid D3DRECT pointer" );
            return DDERR_INVALIDOBJECT;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }
    lpD3DViewI = (LPDIRECT3DVIEWPORTI)lpD3DView;

    /*
     * The viewport must be associated with this device
     */
    if (lpD3DViewI->lpDevI != this) {
        D3D_ERR("viewport not associated with this device");
        return (DDERR_INVALIDPARAMS);
    }

    lpBufferI = (LPDIRECT3DEXECUTEBUFFERI)lpD3DExBuf;

    /* Make sure this buffer is associated with the correct device */
    if (lpBufferI->lpDevI != this) {
        D3D_ERR("Exe-buffer not associated with this device");
        return (DDERR_INVALIDPARAMS);
    }

    if (lpBufferI->locked) {
        D3D_ERR("Exe-buffer is locked");
        return (D3DERR_EXECUTE_LOCKED);
    }

    lpD3DOldViewI = lpCurrentViewport;
    lpCurrentViewport = lpD3DViewI;

    ret = CheckDeviceSettings(this);
    if (ret != D3D_OK)
    {
        D3D_ERR("Bad Device settings");
        lpCurrentViewport = lpD3DOldViewI;
        return (ret);
    }

    /*
     * Create an execute data structure
     */
    memset(&exData, 0, sizeof(exData));
    exData.dwSize = sizeof(D3DI_EXECUTEDATA);
    exData.dwHandle = lpBufferI->hBuf;
    memcpy((LPBYTE)(&exData.dwVertexOffset), 
           (LPBYTE)(&lpBufferI->exData.dwVertexOffset),
           sizeof(D3DEXECUTEDATA) - sizeof(DWORD));
    pdata.exe = &exData;
    pdata.pick.x1 = lpRect->x1;
    pdata.pick.y1 = lpRect->y1;
    pdata.pick.x2 = lpRect->x2;
    pdata.pick.y2 = lpRect->y2;

    this->dwFlags = D3DPV_INSIDEEXECUTE;
    this->dwVIDOut = D3DFVF_TLVERTEX;

    D3DHAL_ExecutePick(this, &pdata);

    this->dwFEFlags &= ~D3DFE_TLVERTEX;    // This flag could be set inside
    lpCurrentViewport = lpD3DOldViewI;

    return ret;
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::GetPickRecords"

HRESULT D3DAPI DIRECT3DDEVICEI::GetPickRecords(LPDWORD count,
                                     LPD3DPICKRECORD records)
{
    HRESULT     ret;
    D3DI_PICKDATA   pdata;
    D3DPICKRECORD*  tmpBuff;

    ret = D3D_OK;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_DWORD_PTR(count)) {
            D3D_ERR( "Invalid DWORD pointer" );
            return DDERR_INVALIDPARAMS;
        }
#if DBG
        if (*count && records && IsBadWritePtr(records, *count * sizeof(D3DPICKRECORD))) {
            D3D_ERR( "Invalid D3DPICKRECORD pointer" );
            return DDERR_INVALIDPARAMS;
        }
#endif
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    pdata.records = NULL;
    GenGetPickRecords(this, &pdata);

    if (count && records && *count >= (unsigned long)pdata.pick_count)
    {
        int picked_size = pdata.pick_count * sizeof(D3DPICKRECORD);

        if (D3DMalloc((void**)&tmpBuff, picked_size) != DD_OK)
        {
            return (DDERR_OUTOFMEMORY);
        }
        pdata.records = tmpBuff;
        GenGetPickRecords(this, &pdata);
        memcpy((char*)records, (char*)tmpBuff, picked_size);
        D3DFree(tmpBuff);
    }

    *count = pdata.pick_count;

    return (D3D_OK);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::EnumTextureFormats"


#define DEFINEPF(flags, fourcc, bpp, rMask, gMask, bMask, aMask) \
    { sizeof(DDPIXELFORMAT), (flags), (fourcc), (bpp), (rMask), (gMask), (bMask), (aMask) }

static DDPIXELFORMAT g_DX5TexEnumIncListStatic[] = {
DEFINEPF(DDPF_RGB,                      0UL, 16UL, 0x00007c00UL, 0x000003e0UL, 0x0000001fUL, 0x00000000), // 16bit 555
DEFINEPF(DDPF_RGB|DDPF_ALPHAPIXELS,     0UL, 16UL, 0x00007c00UL, 0x000003e0UL, 0x0000001fUL, 0x00008000), // 16bit 1555
DEFINEPF(DDPF_RGB,                      0UL, 16UL, 0x0000f800UL, 0x000007e0UL, 0x0000001fUL, 0x00000000), // 16bit 565
DEFINEPF(DDPF_RGB|DDPF_ALPHAPIXELS,     0UL, 16UL, 0x00000f00UL, 0x000000f0UL, 0x0000000fUL, 0x0000f000), // 16bit 4444
DEFINEPF(DDPF_RGB|DDPF_ALPHAPIXELS,     0UL, 32UL, 0x00ff0000UL, 0x0000ff00UL, 0x000000ffUL, 0xff000000), // 32bit 8888
DEFINEPF(DDPF_RGB,                      0UL, 32UL, 0x00ff0000UL, 0x0000ff00UL, 0x000000ffUL, 0x00000000), // 32bit 888
DEFINEPF(DDPF_RGB,                      0UL,  8UL, 0x000000e0UL, 0x0000001cUL, 0x00000003UL, 0x00000000), // 8bit  332
DEFINEPF(DDPF_RGB|DDPF_PALETTEINDEXED4, 0UL,  4UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000), // 4bit pal
DEFINEPF(DDPF_RGB|DDPF_PALETTEINDEXED8, 0UL,  8UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000), // 8bit pal
};
DWORD g_cDX5TexEnumIncListStatic = sizeof(g_DX5TexEnumIncListStatic)/sizeof(DDPIXELFORMAT);

BOOL
MatchDDPIXELFORMAT( DDPIXELFORMAT* pddpfA, DDPIXELFORMAT* pddpfB )
{
    if ( pddpfA->dwFlags != pddpfB->dwFlags ) return FALSE;
    if ( pddpfA->dwRGBBitCount != pddpfB->dwRGBBitCount ) return FALSE;
    if ( pddpfA->dwRBitMask != pddpfB->dwRBitMask ) return FALSE;
    if ( pddpfA->dwGBitMask != pddpfB->dwGBitMask ) return FALSE;
    if ( pddpfA->dwBBitMask != pddpfB->dwBBitMask ) return FALSE;
    if ( pddpfA->dwRGBAlphaBitMask != pddpfB->dwRGBAlphaBitMask ) return FALSE;
    if ( pddpfA->dwFourCC != pddpfB->dwFourCC ) return FALSE;
    return TRUE;
}

void
LoadTexEnumInclList( char* pResPath, DDPIXELFORMAT*& pddpfInclList, DWORD& cInclList)
{
    HKEY hKey = (HKEY)NULL;
    if (ERROR_SUCCESS == RegOpenKey( HKEY_LOCAL_MACHINE,
        pResPath, &hKey))
    {
        DWORD cSubKeys = 0;
        if ( ERROR_SUCCESS == RegQueryInfoKey ( hKey,
                NULL,NULL,NULL, &cSubKeys, NULL,
                NULL,NULL,NULL,NULL,NULL,NULL ) )
        {
            D3D_INFO(3,"LoadTexEnumInclList: cSubKeys = %d",cSubKeys);

            if (cSubKeys == 0) return;

            // allocate space for ddpf inclusion list
            cInclList = cSubKeys;
            if (D3DMalloc((void**)&pddpfInclList, cInclList*sizeof(DDPIXELFORMAT)) != D3D_OK) {
                D3D_ERR("malloc failed on texture enum inclusion list");
                pddpfInclList = NULL;
                cInclList = 0;
            }
            memset( pddpfInclList, 0, cInclList*sizeof(DDPIXELFORMAT) );

            for (DWORD i=0; i<cSubKeys; i++)
            {
                char pName[128] = "";
                DWORD cbName = 128;
                if (ERROR_SUCCESS == RegEnumKeyEx( hKey, i, pName, &cbName,
                        NULL,NULL,NULL,NULL ) )
                {
                    HKEY hTexKey = (HKEY)NULL;
                    if (ERROR_SUCCESS == RegOpenKey( hKey, pName, &hTexKey))
                    {
                        DWORD dwType; DWORD dwSize;

                        // get string of full ddpf
                        char pDDPFStr[128] = ""; DWORD cbDDPFStr = 128;
                        if (ERROR_SUCCESS == RegQueryValueEx(hTexKey, "ddpf",
                                NULL, &dwType, (LPBYTE)pDDPFStr, &cbDDPFStr) )
                        {
                            sscanf(pDDPFStr, "%x %x %d %x %x %x %x",
                                &pddpfInclList[i].dwFlags,&pddpfInclList[i].dwFourCC,&pddpfInclList[i].dwRGBBitCount,
                                &pddpfInclList[i].dwRBitMask,&pddpfInclList[i].dwGBitMask,&pddpfInclList[i].dwBBitMask,
                                &pddpfInclList[i].dwRGBAlphaBitMask);
                        }

                        D3D_INFO(3,"LoadTexEnumInclList: <%s> %08x %08x %2d %08x %08x %08x %08x",
                            pName,
                            pddpfInclList[i].dwFlags,
                            pddpfInclList[i].dwFourCC,
                            pddpfInclList[i].dwRGBBitCount,
                            pddpfInclList[i].dwRBitMask,
                            pddpfInclList[i].dwGBitMask,
                            pddpfInclList[i].dwBBitMask,
                            pddpfInclList[i].dwRGBAlphaBitMask);
                    }
                    else
                    {
                        D3D_INFO(3,"LoadTexEnumInclList: failed to open subkey %s",pName);
                    }
                }
                else
                {
                    D3D_INFO(3,"LoadTexEnumInclList: failed to enumerate subkey %d",i);
                }
            }
        }
    }
}

HRESULT
DoEnumTextureFormats(
    DIRECT3DDEVICEI* lpDevI,
    LPD3DENUMTEXTUREFORMATSCALLBACK lpEnumCallbackDX5, // DX5 version
    LPD3DENUMPIXELFORMATSCALLBACK lpEnumCallbackDX6,   // DX6 version
    LPVOID lpContext)
{
    HRESULT ret, userRet;
    LPDDSURFACEDESC lpDescs, lpRetDescs;
    DWORD num_descs;
    DWORD i;

    ret = D3D_OK;

    num_descs = lpDevI->lpD3DHALGlobalDriverData->dwNumTextureFormats;
    lpDescs = lpDevI->lpD3DHALGlobalDriverData->lpTextureFormats;
    if (!num_descs)
    {
        D3D_ERR("no texture formats supported");
        return (D3DERR_TEXTURE_NO_SUPPORT);
    }

    if (D3DMalloc((void**)&lpRetDescs, sizeof(DDSURFACEDESC) * num_descs) != D3D_OK)
    {
        D3D_ERR("failed to alloc space for return descriptions");
        return (DDERR_OUTOFMEMORY);
    }
    memcpy(lpRetDescs, lpDescs, sizeof(DDSURFACEDESC) * num_descs);

    // get apphack flags
    LPDDRAWI_DIRECTDRAW_LCL lpDDLcl = ((LPDDRAWI_DIRECTDRAW_INT)(lpDevI->lpDD))->lpLcl;
    DWORD dwEnumInclAppHack =
        ((lpDDLcl->dwAppHackFlags & DDRAW_APPCOMPAT_TEXENUMINCL_0)?1:0) |
        ((lpDDLcl->dwAppHackFlags & DDRAW_APPCOMPAT_TEXENUMINCL_1)?2:0);
    // two bit field:
    //  0 - no apphack (default behavior)
    //  1 - use no inclusion list
    //  2 - use DX5 inclusion list
    //  3 - use DX6 inclusion list
    D3D_INFO(3, "APPCOMPAT_TEXENUMINCL: %d",dwEnumInclAppHack);

    // enumeration limit defaults true for <DX6 interfaces, and can be disabled by apphack
    BOOL bEnumLimit = (lpDevI->dwVersion < 3) ? TRUE : FALSE;
    if (lpDDLcl->dwAppHackFlags & DDRAW_APPCOMPAT_TEXENUMLIMIT) { bEnumLimit = FALSE; }
    D3D_INFO(3, "EnumTextureFormats: bEnumLimit %d",bEnumLimit);

#if DBG
    // debug capability to eliminate enumeration of any subset of first 32 textures
    DWORD dwEnumDisable = 0x0;
    GetD3DRegValue(REG_DWORD, "TextureEnumDisable", &dwEnumDisable, sizeof(DWORD));
    D3D_INFO(3, "TextureEnumDisable: %08x",dwEnumDisable);
#endif

    DDPIXELFORMAT* pDX5TexEnumIncList = NULL;
    DWORD cDX5TexEnumIncList = 0;
    // load DX5 inclusion list from registry
    LoadTexEnumInclList( RESPATH_D3D "\\DX5TextureEnumInclusionList",
        pDX5TexEnumIncList, cDX5TexEnumIncList );

    DDPIXELFORMAT* pDX6TexEnumIncList = NULL;
    DWORD cDX6TexEnumIncList = 0;
    // load DX6 list only for DX6 interface or apphack
    if ((lpDevI->dwVersion == 3) || (dwEnumInclAppHack >= 3))
    {
        LoadTexEnumInclList( RESPATH_D3D "\\DX6TextureEnumInclusionList",
            pDX6TexEnumIncList, cDX6TexEnumIncList );
    }

    userRet = D3DENUMRET_OK;
    int cEnumLimit = 0;
    for (i = 0; i < num_descs && userRet == D3DENUMRET_OK; i++)
    {

        D3D_INFO(3,"EnumTextureFormats: %2d %08x %08x %2d %08x %08x %08x %08x",i,
            lpRetDescs[i].ddpfPixelFormat.dwFlags,
            lpRetDescs[i].ddpfPixelFormat.dwFourCC,
            lpRetDescs[i].ddpfPixelFormat.dwRGBBitCount,
            lpRetDescs[i].ddpfPixelFormat.dwRBitMask,
            lpRetDescs[i].ddpfPixelFormat.dwGBitMask,
            lpRetDescs[i].ddpfPixelFormat.dwBBitMask,
            lpRetDescs[i].ddpfPixelFormat.dwRGBAlphaBitMask);

#if DBG
        if ( (i < 32) && (dwEnumDisable & (1<<i)) )
        {
            D3D_INFO(3, "EnumTextureFormats: filtering texture %d",i);
            continue;
        }
#endif

        // Filtering out texture formats which are not on inclusion list -
        if ( (dwEnumInclAppHack != 1) && // inclusion list not disabled by apphack
             !(lpRetDescs[i].ddpfPixelFormat.dwFlags == DDPF_FOURCC) ) // not FourCC
        {
            BOOL bMatched = FALSE;

            // match against DX5 base (static) inclusion list
            for (DWORD j=0; j<g_cDX5TexEnumIncListStatic; j++)
            {
                if (MatchDDPIXELFORMAT( &(g_DX5TexEnumIncListStatic[j]), &(lpRetDescs[i].ddpfPixelFormat)))
                {
                    bMatched = TRUE; break;
                }
            }
            // match against DX5 extended (regkey) inclusion list
            if (!bMatched && cDX5TexEnumIncList)
            {
                for (DWORD j=0; j<cDX5TexEnumIncList; j++)
                {
                    if (MatchDDPIXELFORMAT( &(pDX5TexEnumIncList[j]), &(lpRetDescs[i].ddpfPixelFormat)))
                    {
                        bMatched = TRUE; break;
                    }
                }
            }

            // match against DX6 regkey list for:
            //   (DX6 interface AND apphack not forcing DX5 inclusion list only) OR
            //   (apphack forcing DX6 inclusion list)
            if ( ((lpDevI->dwVersion == 3) && (dwEnumInclAppHack != 2)) ||
                 (dwEnumInclAppHack == 3) )
            {
                for (DWORD j=0; j<cDX6TexEnumIncList; j++)
                {
                    if (MatchDDPIXELFORMAT( &(pDX6TexEnumIncList[j]), &(lpRetDescs[i].ddpfPixelFormat)))
                    {
                        bMatched = TRUE; break;
                    }
                }
            }

            if (!bMatched) {
                D3D_INFO(3, "EnumTextureFormats: filtering non-included texture %d",i);
                continue;
            }
        }

        // exclude DXT1..5 for <DX6 interfaces
        if ( (lpDevI->dwVersion < 3) && (lpRetDescs[i].ddpfPixelFormat.dwFlags == DDPF_FOURCC) )
        {
            if ( (lpRetDescs[i].ddpfPixelFormat.dwFourCC == MAKEFOURCC('D', 'X', 'T', '1')) ||
                 (lpRetDescs[i].ddpfPixelFormat.dwFourCC == MAKEFOURCC('D', 'X', 'T', '2')) ||
                 (lpRetDescs[i].ddpfPixelFormat.dwFourCC == MAKEFOURCC('D', 'X', 'T', '3')) ||
                 (lpRetDescs[i].ddpfPixelFormat.dwFourCC == MAKEFOURCC('D', 'X', 'T', '4')) ||
                 (lpRetDescs[i].ddpfPixelFormat.dwFourCC == MAKEFOURCC('D', 'X', 'T', '5')) )
            {
                D3D_INFO(3, "EnumTextureFormats: filtering DXT1..5 format for DX3/5 interfaces");
                continue;
            }
        }

        // exclude all FourCC code formats for <DX6 interfaces on DX7 drivers
        if ( (lpDevI->dwVersion < 3) && IS_DX7HAL_DEVICE(lpDevI) &&
             (lpRetDescs[i].ddpfPixelFormat.dwFlags == DDPF_FOURCC) )
        {
            D3D_INFO(3, "EnumTextureFormats: filtering all FOURCC formats for DX3/5 interfaces on DX7 HALs");
            continue;
        }

        // do enumeration if not ('limit enabled' && 'limit exceeded')
        if ( !(bEnumLimit && (++cEnumLimit > 10)) )
        {
            if (lpEnumCallbackDX5)
            {
                userRet = (*lpEnumCallbackDX5)(&lpRetDescs[i], lpContext);
            }
            if (lpEnumCallbackDX6)
            {
                userRet = (*lpEnumCallbackDX6)(&(lpRetDescs[i].ddpfPixelFormat), lpContext);
            }
        }
        else
        {
            D3D_INFO(3, "EnumTextureFormats: enumeration limit exceeded");
        }
    }

    D3DFree(lpRetDescs);
    if (pDX5TexEnumIncList) D3DFree(pDX5TexEnumIncList);
    if (pDX6TexEnumIncList) D3DFree(pDX6TexEnumIncList);

    return (D3D_OK);
}


// Device/Device2 version
HRESULT D3DAPI DIRECT3DDEVICEI::EnumTextureFormats(
    LPD3DENUMTEXTUREFORMATSCALLBACK lpEnumCallback,
    LPVOID lpContext)
{
    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }

        if (!VALIDEX_CODE_PTR(lpEnumCallback)) {
            D3D_ERR( "Invalid callback pointer" );
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    return DoEnumTextureFormats(this, lpEnumCallback, NULL, lpContext);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::EnumTextureFormats"

// Device3 version
HRESULT D3DAPI DIRECT3DDEVICEI::EnumTextureFormats(
    LPD3DENUMPIXELFORMATSCALLBACK lpEnumCallback,
    LPVOID lpContext)
{
    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }

        if (!VALIDEX_CODE_PTR(lpEnumCallback)) {
            D3D_ERR( "Invalid callback pointer" );
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    return DoEnumTextureFormats(this, NULL, lpEnumCallback, lpContext);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::SwapTextureHandles"

HRESULT D3DAPI DIRECT3DDEVICEI::SwapTextureHandles(LPDIRECT3DTEXTURE lpTex1,
                                         LPDIRECT3DTEXTURE lpTex2)
{
    LPDIRECT3DTEXTUREI lpTex1I;
    LPDIRECT3DTEXTUREI lpTex2I;
    HRESULT ret;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_DIRECT3DTEXTURE_PTR(lpTex1)) {
            D3D_ERR( "Invalid Direct3DTexture pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_DIRECT3DTEXTURE_PTR(lpTex2)) {
            D3D_ERR( "Invalid Direct3DTexture pointer" );
            return DDERR_INVALIDOBJECT;
        }
        lpTex1I = static_cast<LPDIRECT3DTEXTUREI>(lpTex1);
        lpTex2I = static_cast<LPDIRECT3DTEXTUREI>(lpTex2);
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }
    ret = SwapTextureHandles((LPDIRECT3DTEXTURE2)lpTex1I,
                                     (LPDIRECT3DTEXTURE2)lpTex2I);
    return ret;
}

HRESULT D3DAPI DIRECT3DDEVICEI::SwapTextureHandles(LPDIRECT3DTEXTURE2 lpTex1,
                                          LPDIRECT3DTEXTURE2 lpTex2)
{
    LPDIRECT3DTEXTUREI lpTex1I;
    LPDIRECT3DTEXTUREI lpTex2I;
    HRESULT servRet;
    D3DTEXTUREHANDLE hTex;
    LPD3DI_TEXTUREBLOCK lptBlock1,lptBlock2;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_DIRECT3DTEXTURE2_PTR(lpTex1)) {
            D3D_ERR( "Invalid Direct3DTexture pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_DIRECT3DTEXTURE2_PTR(lpTex2)) {
            D3D_ERR( "Invalid Direct3DTexture pointer" );
            return DDERR_INVALIDOBJECT;
        }
        lpTex1I = static_cast<LPDIRECT3DTEXTUREI>(lpTex1);
        lpTex2I = static_cast<LPDIRECT3DTEXTUREI>(lpTex2);
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }
    if (lpTex1I->lpDDSSys || lpTex2I->lpDDSSys)
    {
        D3D_ERR("Can't Swap Managed textures. Returning DDERR_INVALIDPARAMS");
        return  DDERR_INVALIDPARAMS;
    }
    if (!(lptBlock1=D3DI_FindTextureBlock(lpTex1I,this)))
    {
        D3D_ERR("lpTex1 is an invalid texture handle.");
        return  DDERR_INVALIDPARAMS;
    }
    if (!(lptBlock2=D3DI_FindTextureBlock(lpTex2I,this)))
    {
        D3D_ERR("lpTex2 is an invalid texture handle.");
        return  DDERR_INVALIDPARAMS;
    }
    if (D3D_OK != (servRet=FlushStates()))
    {
        D3D_ERR("Error trying to flush batched commands during TextureSwap");
        return  servRet;
    }

    if (IS_DX7HAL_DEVICE(this))
    {
        LPDDRAWI_DDRAWSURFACE_LCL surf1 = ((LPDDRAWI_DDRAWSURFACE_INT)lpTex1I->lpDDS)->lpLcl;
        LPDDRAWI_DDRAWSURFACE_LCL surf2 = ((LPDDRAWI_DDRAWSURFACE_INT)lpTex2I->lpDDS)->lpLcl;
        LPDDRAWI_DIRECTDRAW_LCL pDDLcl = ((LPDDRAWI_DIRECTDRAW_INT)lpDirect3DI->lpDD)->lpLcl;
        DDASSERT(pDDLcl != NULL);

        // Update DDraw handle in driver GBL object.
        pDDLcl->lpGbl->hDD = pDDLcl->hDD;
        // Swap the handles stored in the surface locals
        surf1->lpSurfMore->dwSurfaceHandle = lptBlock2->hTex;
        surf2->lpSurfMore->dwSurfaceHandle = lptBlock1->hTex;
        // Swap the surface pointers stored in the handle table stored in
        // ddraw local
        SURFACEHANDLELIST(pDDLcl).dwList[lptBlock1->hTex].lpSurface = surf2;
        SURFACEHANDLELIST(pDDLcl).dwList[lptBlock2->hTex].lpSurface = surf1;

        // call the driver to switch the textures mapped to the handles in
        // the driver
        DDASSERT(NULL != pDDLcl->lpGbl->lpDDCBtmp->HALDDMiscellaneous2.CreateSurfaceEx);
        DDHAL_CREATESURFACEEXDATA   csdex;
        DWORD   rc;
        csdex.ddRVal  = DDERR_GENERIC;
        csdex.dwFlags = 0;
        csdex.lpDDLcl = pDDLcl;
        csdex.lpDDSLcl = surf1;
        rc = pDDLcl->lpGbl->lpDDCBtmp->HALDDMiscellaneous2.CreateSurfaceEx(&csdex);
        if(  DDHAL_DRIVER_HANDLED == rc && DD_OK != csdex.ddRVal)
        {
            // Driver call failed
            D3D_ERR("DdSwapTextureHandles failed!");
            return  D3DERR_TEXTURE_SWAP_FAILED;
        }
        csdex.lpDDSLcl = surf2;
        rc = pDDLcl->lpGbl->lpDDCBtmp->HALDDMiscellaneous2.CreateSurfaceEx(&csdex);
        if(  DDHAL_DRIVER_HANDLED == rc && DD_OK != csdex.ddRVal)
        {
            // Driver call failed
            D3D_ERR("DdSwapTextureHandles failed!");
            return  D3DERR_TEXTURE_SWAP_FAILED;
        }
    }
    else
    {
        servRet=D3DHAL_TextureSwap(this,lptBlock1->hTex,lptBlock2->hTex);
        if (D3D_OK != servRet)
        {
            D3D_ERR("SwapTextureHandles HAL call failed");
            return  D3DERR_TEXTURE_SWAP_FAILED;
        }
    }
    hTex=lptBlock1->hTex;
    lptBlock1->hTex=lptBlock2->hTex;
    lptBlock2->hTex=hTex;

    return (D3D_OK);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::CreateMatrix"

HRESULT D3DAPI DIRECT3DDEVICEI::CreateMatrix(LPD3DMATRIXHANDLE lphMatrix)
{
    HRESULT servRet;
    D3DMATRIXHANDLE hMat;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_D3DMATRIXHANDLE_PTR(lphMatrix)) {
            D3D_ERR( "Invalid D3DMATRIXHANDLE pointer" );
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    *lphMatrix = 0;

    servRet = D3DHAL_MatrixCreate(this, &hMat);
    if (servRet != D3D_OK)
    {
        D3D_ERR("Could not create matrix.");
        return (DDERR_OUTOFMEMORY);
    }

    D3D_INFO(4, "CreateMatrix, Matrix created. handle = %d", hMat);
    *lphMatrix = hMat;

    return (D3D_OK);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::SetMatrix"

HRESULT D3DAPI DIRECT3DDEVICEI::SetMatrix(D3DMATRIXHANDLE hMatrix,
                                const LPD3DMATRIX lpdmMatrix)
{
    HRESULT servRet;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_D3DMATRIX_PTR(lpdmMatrix)) {
            D3D_ERR( "Invalid D3DMATRIX pointer" );
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    if (!hMatrix) {
        D3D_ERR("NULL hMatrix passed");
        return (DDERR_INVALIDPARAMS);
    }

    servRet = D3DHAL_MatrixSetData(this, hMatrix, lpdmMatrix);
    if (servRet != D3D_OK)
    {
        D3D_ERR("Could not set matrix");
        return (DDERR_INVALIDPARAMS);
    }

    return (D3D_OK);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::GetMatrix"

HRESULT D3DAPI DIRECT3DDEVICEI::GetMatrix(D3DMATRIXHANDLE hMatrix,
                                LPD3DMATRIX lpdmMatrix)
{
    HRESULT servRet;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_D3DMATRIX_PTR(lpdmMatrix)) {
            D3D_ERR( "Invalid D3DMATRIX pointer" );
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    if (!hMatrix)
    {
        D3D_ERR("NULL hMatrix passed.");
        return (DDERR_INVALIDPARAMS);
    }

    memset(lpdmMatrix, 0, sizeof(D3DMATRIX));

    servRet = D3DHAL_MatrixGetData(this, hMatrix, lpdmMatrix);
    if (servRet != D3D_OK)
    {
        D3D_ERR("Could not get matrix");
        return (DDERR_INVALIDPARAMS);
    }

    return (D3D_OK);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::DeleteMatrix"

HRESULT D3DAPI DIRECT3DDEVICEI::DeleteMatrix(D3DMATRIXHANDLE hMatrix)
{
    HRESULT servRet;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    if (!hMatrix) {
        D3D_ERR("invalid D3DMATRIXHANDLE");
        return DDERR_INVALIDPARAMS;
    }

    servRet = D3DHAL_MatrixDestroy(this, hMatrix);
    if (servRet != D3D_OK)
    {
        D3D_ERR("Could not delete matrix");
        return (DDERR_INVALIDPARAMS);
    }

    return (D3D_OK);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::BeginScene"

HRESULT D3DAPI DIRECT3DDEVICEI::BeginScene()
{
    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.
    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    if (this->dwHintFlags & D3DDEVBOOL_HINTFLAGS_INSCENE)
    {
        D3D_ERR("BeginScene, already in scene.");
        return (D3DERR_SCENE_IN_SCENE);
    }

    // Check if we lost surfaces or rtarget / zbuffer was locked
    HRESULT servRet = this->CheckSurfaces();
    if (servRet != D3D_OK)
    {
        // If we lost surfaces
        if (servRet == DDERR_SURFACELOST)
        {
            // Even if the app restores the rendertargets and z buffer, it
            // doesn't know anything about vidmem execute buffers or
            // managed texture surfaces in vidmem. So, we need to do
            // this on our own. We first check if it is safe to restore
            // surfaces. If not, we fail in the usual way. Else, we
            // do the restore. Note that we will fail *only* if the
            // app calls BeginScene at the wrong time.
            servRet = this->lpDirect3DI->lpDD4->TestCooperativeLevel();
            if (servRet == DD_OK)
            {
                // Everything must be evicted otherwise Restore might not work
                // as there might be new surface allocated, in fact, we should
                // post a flag in Device so that Texture manage stop calling
                // CreateSurface() if this flag is indicating TestCooperativeLevel()
                // failed, however, even we added those, the EvictTextures below
                // is still needed but not this critical--kanqiu
                this->lpDirect3DI->lpTextureManager->EvictTextures();
                servRet = this->lpDirect3DI->lpDD4->RestoreAllSurfaces();
                if (servRet != DD_OK)
                    return D3DERR_SCENE_BEGIN_FAILED;
            }
            else
                return DDERR_SURFACELOST;
        }
        else
        {
            // Render target and / or the z buffer was locked
            return servRet;
        }
    }
    servRet = D3DHAL_SceneCapture(this, TRUE);

    if (servRet != D3D_OK && servRet != DDERR_NOTFOUND)
    {
        D3D_ERR("Could not BeginScene.");
        return D3DERR_SCENE_BEGIN_FAILED;
    }

    this->dwHintFlags |= D3DDEVBOOL_HINTFLAGS_INSCENE;
    if (lpD3DHALGlobalDriverData->hwCaps.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_ZBUFFERLESSHSR)
    {
        lpDirect3DI->lpTextureManager->TimeStamp();
    }

    return (D3D_OK);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::EndScene"

HRESULT D3DAPI DIRECT3DDEVICEI::EndScene()
{
    HRESULT servRet;

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    if (!(this->dwHintFlags & D3DDEVBOOL_HINTFLAGS_INSCENE)) {
        D3D_ERR("EndScene, not in scene.");
        return (D3DERR_SCENE_NOT_IN_SCENE);
    }

    this->dwHintFlags &= ~D3DDEVBOOL_HINTFLAGS_INSCENE;
    if (IS_DX7HAL_DEVICE(this))
    {
        // must set the token before FlushStates()
        SetRenderStateI((D3DRENDERSTATETYPE)D3DRENDERSTATE_SCENECAPTURE, FALSE);
    }

    servRet = FlushStates();    //time to flush DrawPrimitives
    if (servRet != D3D_OK)
    {
        D3D_ERR("Could not Flush commands in EndScene!");
        return (D3DERR_SCENE_END_FAILED);
    }
    if (!IS_DX7HAL_DEVICE(this))
    {
        servRet = D3DHAL_SceneCapture(this, FALSE);

        if (servRet != D3D_OK && servRet != DDERR_NOTFOUND)
        {
            DPF(0, "(ERROR) Direct3DDevice::EndScene: Could not EndScene. Returning %d", servRet);
            return (D3DERR_SCENE_END_FAILED);
        }
    }

    // Did we lose any surfaces during this scene ?
    if (this->dwFEFlags & D3DFE_LOSTSURFACES)
    {
        D3D_INFO(3, "reporting DDERR_SURFACELOST in EndScene");
        this->dwFEFlags &= ~D3DFE_LOSTSURFACES;
        return DDERR_SURFACELOST;
    }

    return (D3D_OK);
}

#undef DPF_MODNAME
#define DPF_MODNAME "Direct3DDevice::GetDirect3D"

HRESULT D3DAPI DIRECT3DDEVICEI::GetDirect3D(LPDIRECT3D* lplpD3D)
{
    LPDIRECT3D3 lpD3D3;
    HRESULT ret;

    ret = GetDirect3D(&lpD3D3);
    if (ret == D3D_OK)
    {
    //  *lplpD3D = dynamic_cast<LPDIRECT3D>(lpD3D3); // This is possible using RTTI
        *lplpD3D = static_cast<LPDIRECT3D>(static_cast<LPDIRECT3DI>(lpD3D3)); // This is safe even using static_cast
    }
    return ret;
}

HRESULT D3DAPI DIRECT3DDEVICEI::GetDirect3D(LPDIRECT3D2* lplpD3D)
{
    LPDIRECT3D3 lpD3D3;
    HRESULT ret;

    ret = GetDirect3D(&lpD3D3);
    if (ret == D3D_OK)
    {
    //  *lplpD3D = dynamic_cast<LPDIRECT3D>(lpD3D3); // This is possible using RTTI
        *lplpD3D = static_cast<LPDIRECT3D2>(static_cast<LPDIRECT3DI>(lpD3D3)); // This is safe even using static_cast
    }
    return ret;
}

HRESULT D3DAPI DIRECT3DDEVICEI::GetDirect3D(LPDIRECT3D3* lplpD3D)
{

    CLockD3D lockObject(DPF_MODNAME, REMIND(""));   // Takes D3D lock.

    /*
     * validate parms
     */
    TRY
    {
        if (!VALID_DIRECT3DDEVICE3_PTR(this)) {
            D3D_ERR( "Invalid Direct3DDevice pointer" );
            return DDERR_INVALIDOBJECT;
        }
        if (!VALID_OUTPTR(lplpD3D)) {
            D3D_ERR( "Invalid Direct3D pointer pointer" );
            return DDERR_INVALIDPARAMS;
        }
    }
    EXCEPT( EXCEPTION_EXECUTE_HANDLER )
    {
        D3D_ERR( "Exception encountered validating parameters" );
        return DDERR_INVALIDPARAMS;
    }

    *lplpD3D = (LPDIRECT3D3) this->lpDirect3DI;
    (*lplpD3D)->AddRef();

    return (D3D_OK);
}

void
D3DDeviceDescConvert(LPD3DDEVICEDESC lpOut,
                     LPD3DDEVICEDESC_V1 lpV1,
                     LPD3DHAL_D3DEXTENDEDCAPS lpExt)
{
    if(lpV1!=NULL)
       memcpy(lpOut, lpV1, D3DDEVICEDESCSIZE_V1);

    if (lpExt)
    {
        // DX5
        lpOut->dwSize = D3DDEVICEDESCSIZE;
        lpOut->dwMinTextureWidth = lpExt->dwMinTextureWidth;
        lpOut->dwMaxTextureWidth = lpExt->dwMaxTextureWidth;
        lpOut->dwMinTextureHeight = lpExt->dwMinTextureHeight;
        lpOut->dwMaxTextureHeight = lpExt->dwMaxTextureHeight;
        lpOut->dwMinStippleWidth = lpExt->dwMinStippleWidth;
        lpOut->dwMaxStippleWidth = lpExt->dwMaxStippleWidth;
        lpOut->dwMinStippleHeight = lpExt->dwMinStippleHeight;
        lpOut->dwMaxStippleHeight = lpExt->dwMaxStippleHeight;

        // DX6
        lpOut->dwMaxTextureRepeat = lpExt->dwMaxTextureRepeat;
        lpOut->dwMaxTextureAspectRatio = lpExt->dwMaxTextureAspectRatio;
        lpOut->dwMaxAnisotropy = lpExt->dwMaxAnisotropy;
        lpOut->dvGuardBandLeft = lpExt->dvGuardBandLeft;
        lpOut->dvGuardBandTop = lpExt->dvGuardBandTop;
        lpOut->dvGuardBandRight = lpExt->dvGuardBandRight;
        lpOut->dvGuardBandBottom = lpExt->dvGuardBandBottom;
        lpOut->dvExtentsAdjust = lpExt->dvExtentsAdjust;
        lpOut->dwStencilCaps = lpExt->dwStencilCaps;
        lpOut->dwFVFCaps = lpExt->dwFVFCaps;
        lpOut->dwTextureOpCaps = lpExt->dwTextureOpCaps;
        lpOut->wMaxTextureBlendStages = lpExt->wMaxTextureBlendStages;
        lpOut->wMaxSimultaneousTextures = lpExt->wMaxSimultaneousTextures;
    }
}

//---------------------------------------------------------------------
#undef  DPF_MODNAME
#define DPF_MODNAME "DIRECT3DDEVICEI::CheckSurfaces"
HRESULT DIRECT3DDEVICEI::CheckSurfaces()
{
    if(this->lpDirect3DI->lpTextureManager->CheckIfLost())
    {
        D3D_ERR("Managed Textures lost");
        return DDERR_SURFACELOST;
    }
    if ( ((LPDDRAWI_DDRAWSURFACE_INT) this->lpDDSTarget)->lpLcl->lpGbl->dwUsageCount ||
         (this->lpDDSZBuffer && ((LPDDRAWI_DDRAWSURFACE_INT) this->lpDDSZBuffer)->lpLcl->lpGbl->dwUsageCount) )
    {
        D3D_ERR("Render target or Z buffer locked");
        return DDERR_SURFACEBUSY;
    }
    if ( ((LPDDRAWI_DDRAWSURFACE_INT) this->lpDDSTarget)->lpLcl->dwFlags & DDRAWISURF_INVALID )\
        {
            D3D_ERR("Render target buffer lost");
            return DDERR_SURFACELOST;
        }
    if ( this->lpDDSZBuffer && ( ((LPDDRAWI_DDRAWSURFACE_INT) this->lpDDSZBuffer)->lpLcl->dwFlags & DDRAWISURF_INVALID ) )
    {
        D3D_ERR("Z buffer lost");
        return DDERR_SURFACELOST;
    }
    return D3D_OK;
}