windows-server-2003/multimedia/directx/dxg/ref8/drv/refif.cpp

//----------------------------------------------------------------------------
//
// refrastfn.cpp
//
// Reference rasterizer callback functions for D3DIM.
//
// Copyright (C) Microsoft Corporation, 1997.
//
//----------------------------------------------------------------------------
#include "pch.cpp"
#pragma hdrstop

// The DDI refrast is emulating
RDDDITYPE g_RefDDI;

// All the supported texture formats
DDSURFACEDESC g_ddsdTex[RD_MAX_NUM_TEXTURE_FORMATS];

// The current caps8 for newly created devices
static D3DCAPS8 g_RefCaps8;

// Maps D3DMULTISAMPLE_TYPE into the bit to use for the flags.
// Maps each of the multisampling values (2 to 16) to the bits[1] to bits[15]
// of wBltMSTypes and wFlipMSTypes
#define DDI_MULTISAMPLE_TYPE(x) (1 << ((x)-1))

//----------------------------------------------------------------------------
//
// RefRastUpdatePalettes
//
//----------------------------------------------------------------------------
HRESULT
RefRastUpdatePalettes(RefDev *pRefDev)
{
    INT i, j, k;
    RDSurface2D* pRDTex[D3DHAL_TSS_MAXSTAGES];
    D3DTEXTUREHANDLE phTex[D3DHAL_TSS_MAXSTAGES];
    HRESULT hr;
    int cActTex;

    if ((cActTex = pRefDev->GetCurrentTextureMaps(phTex, pRDTex)) == 0)
    {
        return D3D_OK;
    }

    for (j = 0; j < cActTex; j++)
    {
        // stages may not have texture bound
        if ( NULL == pRDTex[j] ) continue;
        pRDTex[j]->UpdatePalette();
    }

    return D3D_OK;

}

//----------------------------------------------------------------------------
//
// RDRenderTarget::Initialize
//
// Converts color and Z surface information into refrast form.
//
//----------------------------------------------------------------------------

HRESULT
RDRenderTarget::Initialize( LPDDRAWI_DDRAWSURFACE_LCL pLclColor,
                            LPDDRAWI_DDRAWSURFACE_LCL pLclZ )
{
    HRESULT hr;
    RDSurfaceFormat ColorFmt;
    RDSurfaceFormat ZFmt;
    RDSurface2D* pOldColor = m_pColor;
    RDSurface2D* pOldDepth = m_pDepth;

    if( m_pColor )
    {
        m_pColor = NULL;
    }
    if( m_pDepth )
    {
        m_pDepth = NULL;
    }

    // Find the surfaces from the global surface manager
    // We are assuming that CreateSurfaceEx has been called on these
    // surfaces before this.
    RDSurface2D* pColor = m_pColor = new RDSurface2D;
    if( pColor == NULL )
    {
        DPFERR( "Color surface could not be allocated" );
        m_pColor = pOldColor;
        m_pDepth = pOldDepth;
        return DDERR_OUTOFMEMORY;
    }
    if( FAILED( hr = pColor->Initialize( pLclColor ) ) )
    {
        DPFERR( "Unable to initialize the color buffer" );
        delete pColor;
        m_pColor = pOldColor;
        m_pDepth = pOldDepth;
        return hr;
    }

    if (NULL != pLclZ)
    {
        RDSurface2D* pDepth = m_pDepth = new RDSurface2D;
        if( pDepth == NULL )
        {
            DPFERR( "Depth surface could not be allocated" );
            delete pColor;
            m_pColor = pOldColor;
            m_pDepth = pOldDepth;
            return DDERR_OUTOFMEMORY;
        }
        if( FAILED( hr = pDepth->Initialize( pLclZ ) ) )
        {
            DPFERR("Unable to initialize the Depth buffer");
            delete pColor;
            delete pDepth;
            m_pColor = pOldColor;
            m_pDepth = pOldDepth;
            return hr;
        }
    }

    m_Clip.left = 0;
    m_Clip.top = 0;
    m_Clip.bottom = pColor->GetHeight() - 1;
    m_Clip.right = pColor->GetWidth() - 1;

    m_bPreDX7DDI = TRUE;
    delete pOldColor;
    delete pOldDepth;
    return D3D_OK;
}

//----------------------------------------------------------------------------
//
// RDRenderTarget::Initialize
//
// Converts color and Z surface information into refrast form.
//
//----------------------------------------------------------------------------

HRESULT
RDRenderTarget::Initialize( LPDDRAWI_DIRECTDRAW_LCL pDDLcl,
                            LPDDRAWI_DDRAWSURFACE_LCL pLclColor,
                            LPDDRAWI_DDRAWSURFACE_LCL pLclZ )
{
    HRESULT hr;
    RDSurfaceFormat ColorFmt;
    RDSurfaceFormat ZFmt;
    RDSurface2D* pOldColor = m_pColor;
    RDSurface2D* pOldDepth = m_pDepth;

    if( m_pColor )
    {
        m_pColor = NULL;
    }
    if( m_pDepth )
    {
        m_pDepth = NULL;
    }

    // Find the surfaces from the global surface manager
    // We are assuming that CreateSurfaceEx has been called on these
    // surfaces before this.
    DWORD dwColorHandle = pLclColor->lpSurfMore->dwSurfaceHandle;
    RDSurface2D* pColor = m_pColor =
        (RDSurface2D *)g_SurfMgr.GetSurfFromList( pDDLcl,
                                                       dwColorHandle);
    if( pColor == NULL )
    {
        DPFERR("Color surface not found");
        m_pColor = pOldColor;
        m_pDepth = pOldDepth;
        return DDERR_INVALIDPARAMS;
    }

    if (NULL != pLclZ)
    {
        DWORD dwDepthHandle = pLclZ->lpSurfMore->dwSurfaceHandle;
        RDSurface2D* pDepth = m_pDepth =
            (RDSurface2D *)g_SurfMgr.GetSurfFromList( pDDLcl,
                                                           dwDepthHandle);
        if( pDepth == NULL )
        {
            DPFERR("Depth surface not found");
            m_pColor = pOldColor;
            m_pDepth = pOldDepth;
            return DDERR_INVALIDPARAMS;
        }
    }

    m_Clip.left = 0;
    m_Clip.top = 0;
    m_Clip.bottom = pColor->GetHeight() - 1;
    m_Clip.right = pColor->GetWidth() - 1;

    return D3D_OK;
}

//----------------------------------------------------------------------------
//
// RDRenderTarget::Initialize
//
// Converts color and Z surface information into refrast form.
//
//----------------------------------------------------------------------------

HRESULT
RDRenderTarget::Initialize( LPDDRAWI_DIRECTDRAW_LCL pDDLcl,
                            DWORD dwColorHandle,
                            DWORD dwDepthHandle )
{
    HRESULT hr;
    RDSurfaceFormat ColorFmt;
    RDSurfaceFormat ZFmt;
    RDSurface2D* pOldColor = m_pColor;
    RDSurface2D* pOldDepth = m_pDepth;

    // Release objects we hold pointers to
    if( m_pColor )
    {
        m_pColor = NULL;
    }
    if( m_pDepth )
    {
        m_pDepth = NULL;
    }

    // Find the surfaces from the global surface manager
    // We are assuming that CreateSurfaceEx has been called on these
    // surfaces before this.
    RDSurface2D* pColor = m_pColor =
        (RDSurface2D *)g_SurfMgr.GetSurfFromList( pDDLcl,
                                                       dwColorHandle);
    if( pColor == NULL )
    {
        DPFERR("Color surface not found");
        m_pColor = pOldColor;
        m_pDepth = pOldDepth;
        return DDERR_INVALIDPARAMS;
    }

    if (0 != dwDepthHandle)
    {
        RDSurface2D* pDepth = m_pDepth =
            (RDSurface2D *)g_SurfMgr.GetSurfFromList( pDDLcl,
                                                           dwDepthHandle);
        if( pDepth == NULL )
        {
            DPFERR("Depth surface not found");
            m_pColor = pOldColor;
            m_pDepth = pOldDepth;
            return DDERR_INVALIDPARAMS;
        }
    }

    m_Clip.left = 0;
    m_Clip.top = 0;
    m_Clip.bottom = pColor->GetHeight() - 1;
    m_Clip.right = pColor->GetWidth() - 1;

    return D3D_OK;
}

//----------------------------------------------------------------------------
//
// RefRastContextCreate
//
// Creates a RefDev and initializes it with the info passed in.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastContextCreate(LPD3DHAL_CONTEXTCREATEDATA pCtxData)
{
    RefDev *pRefDev;
    RDRenderTarget *pRendTgt;
    INT i;

    // Surface7 pointers for QI
    LPDDRAWI_DDRAWSURFACE_LCL pZLcl = NULL;
    LPDDRAWI_DDRAWSURFACE_LCL pColorLcl = NULL;
    HRESULT ret;

    DPFM(0, DRV, ("In the new RefRast Dll\n"));

    // this only needs to be called once, but once per context won't hurt
    RefRastSetMemif(&malloc, &free, &realloc);

    if ((pRendTgt = new RDRenderTarget()) == NULL)
    {
        pCtxData->ddrval = DDERR_OUTOFMEMORY;
        return DDHAL_DRIVER_HANDLED;
    }

    // If it is expected to be a DX7+ driver
    if (g_RefDDI < RDDDI_DX7HAL)
    {
        if (pCtxData->lpDDS)
            pColorLcl = ((LPDDRAWI_DDRAWSURFACE_INT)(pCtxData->lpDDS))->lpLcl;
        if (pCtxData->lpDDSZ)
            pZLcl = ((LPDDRAWI_DDRAWSURFACE_INT)(pCtxData->lpDDSZ))->lpLcl;

        // Collect surface information where the failures are easy to handle.
        pCtxData->ddrval = pRendTgt->Initialize( pColorLcl, pZLcl );
    }
    else
    {
        pColorLcl = pCtxData->lpDDSLcl;
        pZLcl     = pCtxData->lpDDSZLcl;

        // Collect surface information where the failures are easy to handle.
        pCtxData->ddrval = pRendTgt->Initialize( pCtxData->lpDDLcl, pColorLcl,
                                                 pZLcl );
    }

    if (pCtxData->ddrval != D3D_OK)
    {
        delete pRendTgt;
        return DDHAL_DRIVER_HANDLED;
    }


    // Note:
    // dwhContext is used by the runtime to inform the driver, which
    // d3d interface is calling the driver.
    if ( ( pRefDev = new RefDev( pCtxData->lpDDLcl,
                                               (DWORD)(pCtxData->dwhContext),
                                               g_RefDDI, &g_RefCaps8 ) ) == NULL )
    {
        pCtxData->ddrval = DDERR_OUTOFMEMORY;
        return DDHAL_DRIVER_HANDLED;
    }

    pRefDev->SetRenderTarget( pRendTgt );

    //  return RR object pointer as context handle
    pCtxData->dwhContext = (ULONG_PTR)pRefDev;

    pCtxData->ddrval = D3D_OK;
    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// RefRastContextDestroy
//
// Destroy a RefDev.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastContextDestroy(LPD3DHAL_CONTEXTDESTROYDATA pCtxDestroyData)
{
    RefDev *pRefDev;

    // Check RefDev
    VALIDATE_REFRAST_CONTEXT("RefRastContextDestroy", pCtxDestroyData);

    // Clean up override bits

    RDRenderTarget *pRendTgt = pRefDev->GetRenderTarget();
    if ( NULL != pRendTgt ) { delete pRendTgt; }

    delete pRefDev;

    pCtxDestroyData->ddrval = D3D_OK;
    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// RefRastSceneCapture
//
// Pass scene capture callback to ref rast.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastSceneCapture(LPD3DHAL_SCENECAPTUREDATA pData)
{
    RefDev *pRefDev;

    // Check RefDev
    VALIDATE_REFRAST_CONTEXT("RefRastSceneCapture", pData);

    pRefDev->SceneCapture( pData->dwFlag );

    pData->ddrval = D3D_OK;        // Should this be changed to a QI ?

    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// RefRastSetRenderTarget
//
// Update a RefRast context with the info from a new render target.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastSetRenderTarget(LPD3DHAL_SETRENDERTARGETDATA pTgtData)
{
    RefDev *pRefDev;
    LPDDRAWI_DDRAWSURFACE_LCL pZLcl = NULL;
    LPDDRAWI_DDRAWSURFACE_LCL pColorLcl = NULL;
    HRESULT ret;

    // Check RefDev
    VALIDATE_REFRAST_CONTEXT("RefRastSetRenderTarget", pTgtData);

    _ASSERT( pRefDev->IsDriverDX6AndBefore(), "This callback should"
        "never be called on DDIs DX7 and beyond" )

    _ASSERT( pRefDev->IsInterfaceDX6AndBefore(), "An older interface should"
             "never call this DLL" )

    RDRenderTarget *pRendTgt = pRefDev->GetRenderTarget();
    if ( NULL == pRendTgt ) { return DDHAL_DRIVER_HANDLED; }

    if( pTgtData->lpDDS )
        pColorLcl = ((LPDDRAWI_DDRAWSURFACE_INT)(pTgtData->lpDDS))->lpLcl;
    if( pTgtData->lpDDSZ )
        pZLcl = ((LPDDRAWI_DDRAWSURFACE_INT)(pTgtData->lpDDSZ))->lpLcl;

    // Collect surface information.
    pTgtData->ddrval = pRendTgt->Initialize( pColorLcl, pZLcl);
    if (pTgtData->ddrval != D3D_OK)
    {
        return DDHAL_DRIVER_HANDLED;
    }

    pRefDev->SetRenderTarget(pRendTgt);

    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// RefRastValidateTextureStageState
//
// Validate current blend operations.  RefRast does everything.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastValidateTextureStageState(LPD3DHAL_VALIDATETEXTURESTAGESTATEDATA pData)
{
    RefDev *pRefDev;

    // Check RefDev
    VALIDATE_REFRAST_CONTEXT("RefRastValidateTextureStageState", pData);

    pData->dwNumPasses = 1;
    pData->ddrval = D3D_OK;

    return DDHAL_DRIVER_HANDLED;
}


//----------------------------------------------------------------------------
//
// RefRastTextureCreate
//
// Creates a RefRast texture and initializes it with the info passed in.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastTextureCreate(LPD3DHAL_TEXTURECREATEDATA pTexData)
{
    RefDev *pRefDev;
    RDSurface2D* pRDTex;
    HRESULT hr;
    LPDDRAWI_DDRAWSURFACE_LCL pLcl;

    if (pTexData->lpDDS)
    {
        pLcl = ((LPDDRAWI_DDRAWSURFACE_INT)pTexData->lpDDS)->lpLcl;
    }

    // Check RefDev
    VALIDATE_REFRAST_CONTEXT("RefRastTextureCreate", pTexData);

    // Runtime shouldnt be calling TextureCreate for DX7 and newer
    // driver models
    _ASSERT( pRefDev->IsDriverDX6AndBefore(), "This DDI should not"
             "be called from DDIs previous to DX7" );

    // assume OKness
    pTexData->ddrval = D3D_OK;

    // Allocate RDSurface2D
    if ( !(pRefDev->TextureCreate(
        (LPD3DTEXTUREHANDLE)&(pTexData->dwHandle), &pRDTex ) ) )
    {
        pTexData->ddrval = DDERR_GENERIC;
        return DDHAL_DRIVER_HANDLED;
    }

    // Init texturemap.
    hr = pRDTex->Initialize( pLcl );
    if (hr != D3D_OK)
    {
        pTexData->ddrval = hr;
        return DDHAL_DRIVER_HANDLED;
    }

    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// RefRastTextureDestroy
//
// Destroy a RefRast texture.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastTextureDestroy(LPD3DHAL_TEXTUREDESTROYDATA pTexDestroyData)
{
    RefDev *pRefDev;

    // Check RefDev
    VALIDATE_REFRAST_CONTEXT("RefRastTextureDestroy", pTexDestroyData);

    // Runtime shouldnt be Calling TextureCreate for DX7 and newer
    // driver models
    _ASSERT( pRefDev->IsDriverDX6AndBefore(), "This DDI should not"
             "be called from DDIs previous to DX7" );

    if (!(pRefDev->TextureDestroy(pTexDestroyData->dwHandle)))
    {
        pTexDestroyData->ddrval = DDERR_GENERIC;
    }
    else
    {
        pTexDestroyData->ddrval = D3D_OK;
    }

    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// RefRastTextureGetSurf
//
// Returns the surface pointer associate with a texture handle.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastTextureGetSurf(LPD3DHAL_TEXTUREGETSURFDATA pTexGetSurf)
{
    RefDev *pRefDev;

    // Check RefDev
    VALIDATE_REFRAST_CONTEXT("RefRastTextureGetSurf", pTexGetSurf);

    pTexGetSurf->lpDDS = pRefDev->TextureGetSurf(pTexGetSurf->dwHandle);
    pTexGetSurf->ddrval = D3D_OK;

    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// RefRastGetDriverState
//
// Called by the runtime to get any kind of driver information
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastGetDriverState(LPDDHAL_GETDRIVERSTATEDATA pGDSData)
{
    RefDev *pRefDev;

    // Check RefDev
#if DBG
    if ((pGDSData) == NULL)
    {
        DPFERR("in %s, data pointer = NULL", "RefRastGetDriverState");
        return DDHAL_DRIVER_HANDLED;
    }
    pRefDev = (RefDev *)ULongToPtr((pGDSData)->dwhContext);
    if (!pRefDev)
    {
        DPFERR("in %s, dwhContext = NULL", "RefRastGetDriverState");
        pGDSData->ddRVal = D3DHAL_CONTEXT_BAD;
        return DDHAL_DRIVER_HANDLED;
    }
#else // !DBG
    pRefDev = (RefDev *)ULongToPtr((pGDSData)->dwhContext);
#endif // !DBG

    //
    // No implementation yet, so nothing is understood yet
    //
    pGDSData->ddRVal = S_FALSE;

    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// FindAttachedSurfaceCaps2
//
// Walks the attachment list for the surface, looking for an attachment
// that has any of the dwCaps2 bits (or ignores if zero) and none of the
// FindAttachedSurfaceCaps2NotPresent bits.
//
//----------------------------------------------------------------------------
LPDDRAWI_DDRAWSURFACE_LCL
FindAttachedSurfaceCaps2(
    LPDDRAWI_DDRAWSURFACE_LCL pLcl,
    DWORD dwCaps2)
{
    LPATTACHLIST lpAttachStruct = pLcl->lpAttachList;
    while(lpAttachStruct)
    {
        if ((dwCaps2 == 0) || (lpAttachStruct->lpAttached->lpSurfMore->ddsCapsEx.dwCaps2 & dwCaps2))
            return lpAttachStruct->lpAttached;
        lpAttachStruct = lpAttachStruct->lpLink;
    }

    return 0;
}


//----------------------------------------------------------------------------
//
// ProcessPossibleMipMap
//
// Record private data structure for this surface and all attached mip
// sublevels.
//
//----------------------------------------------------------------------------
void
ProcessPossibleMipMap(
    LPDDHAL_CREATESURFACEEXDATA p,
    LPDDRAWI_DDRAWSURFACE_LCL lpDDSMipLcl
    )
{
    do
    {
        // This function should not deal with deletions. Assert this.
        _ASSERT( SURFACE_MEMORY(lpDDSMipLcl),
                 "Delete should have already taken place" );

        p->ddRVal = g_SurfMgr.AddSurfToList( p->lpDDLcl, lpDDSMipLcl, NULL );
        if (FAILED(p->ddRVal))
            return;

        // Now search down the 2nd+ order attachment: the chain
        // of mip sublevels.
        lpDDSMipLcl = FindAttachedSurfaceCaps2(lpDDSMipLcl,
                                               DDSCAPS2_MIPMAPSUBLEVEL);
    }
    while (lpDDSMipLcl);
}

//----------------------------------------------------------------------------
//
// RefRastCreateSurfaceEx
//
// Refrast implementation of CreateSurfaceEx. g_SurfMgr is the object
// that does the real job.
//
// CreateSurfaceEx is also used to inform the driver to create and destroy
// surface representations for a given handle. The way the driver can tell
// the difference between create and destroy is by looking at the fpVidmem
// pointer of the passed local. If it is null, it is a destroy.
//
// Create: This call is atomic. i.e. the attachments are all done by the
//         runtime. The driver is expected to walk through the attachment and
//         form its internal picture as described below.
// For complex surfaces (mipped textures, cubemaps), we need to record an
// internal representation for the top-level surface that includes all
// sub-surfaces. This is because the handle associated with the top-level
// surface is what's passed to SetTextureStage.
// However, we also need entries in our list that allow us to set any
// of the sublevels as render targets. Thus this top-level routine iterates
// across the entire attachment graph (to accomodate SRT on any subsurface)
// and the lower-level routine (RDSurface2D::Initialize) also iterates across
// the whole graph (to accomodate SetTexture on the top-level).
// A flipping chain is another structure that needs SRT to work on all
// contained surfaces.
//
// Destroy: The destruction unfortunately is not atomic. The driver gets
//          the call to destroy per sub-level. The attachment has no meaning
//          at this time, so the driver should only delete the level being
//          referred to.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastCreateSurfaceEx(LPDDHAL_CREATESURFACEEXDATA p)
{
#if DBG
    if( p == NULL )
    {
        DPFERR("CreateSurfaceExData ptr is NULL");
        return DDHAL_DRIVER_HANDLED;
    }
    if( p->lpDDLcl == NULL || p->lpDDSLcl == NULL )
    {
        DPFERR("DDLcl or the DDSLcl ptr is NULL");
        return DDHAL_DRIVER_HANDLED;
    }
#endif
    LPDDRAWI_DDRAWSURFACE_LCL lpDDSLcl = p->lpDDSLcl;
    p->ddRVal = DD_OK;

    //
    // Is it a Delete call ? If so simply delete the surface-rep associated
    // with this local and dont walk the local chain.
    //

    if( 0 == SURFACE_MEMORY(lpDDSLcl) )
    {
        g_SurfMgr.RemoveSurfFromList( p->lpDDLcl, lpDDSLcl );
        return DDHAL_DRIVER_HANDLED;
    }

    ProcessPossibleMipMap(p, lpDDSLcl);

    //Now we have two possibilities: cubemap or flipping chain.
    // Check cube map first:

    //+ve X is always the first face
    // (Note a DX7 driver would have to handle cubes w/o the +X face (since DX7
    // cubes may have any set of faces missing).)
    if (lpDDSLcl->lpSurfMore->ddsCapsEx.dwCaps2 & DDSCAPS2_CUBEMAP_POSITIVEX)
    {
        //Go find each attached cubemap face and process it as a mipmap
        for (int i=1;i<6;i++)
        {
            DWORD dwCaps2=0;
            switch(i)
            {
            case 1: dwCaps2 = DDSCAPS2_CUBEMAP_NEGATIVEX; break;
            case 2: dwCaps2 = DDSCAPS2_CUBEMAP_POSITIVEY; break;
            case 3: dwCaps2 = DDSCAPS2_CUBEMAP_NEGATIVEY; break;
            case 4: dwCaps2 = DDSCAPS2_CUBEMAP_POSITIVEZ; break;
            case 5: dwCaps2 = DDSCAPS2_CUBEMAP_NEGATIVEZ; break;
            }

            //Find the top-level faces attached to the root
            //(there will be no mip sublevel of any of these five types
            //attached to the root).
            lpDDSLcl = FindAttachedSurfaceCaps2(p->lpDDSLcl, dwCaps2);
            if (lpDDSLcl) ProcessPossibleMipMap(p, lpDDSLcl);
        }
    }
    else if (
        0==(lpDDSLcl->ddsCaps.dwCaps & DDSCAPS_MIPMAP) &&
        0 != lpDDSLcl->lpAttachList)
    {
        //just assert that we're not handling some of the other types
        //we know are passed to CSEx.
        _ASSERT(0==(lpDDSLcl->ddsCaps.dwCaps & DDSCAPS_TEXTURE), "CSEx for an attached texture?");
        _ASSERT(0==(lpDDSLcl->ddsCaps.dwCaps & DDSCAPS_EXECUTEBUFFER), "CSEx for an attached execute buffer?");

        // We processed mipmaps above, so either there will be no
        // more attachments (aside from the mipsublevels), or it's
        // a flipping chain.

        // The first member of the chain was processed above.
        // Npw we look around the ring, terminating when we hit the first surface
        // again.
        //
        // NOTE: DX8 software drivers will only ever see a chain, not a ring.
        // This code terminates at the end of the chain.
        //
        // A real driver may have to check for attached Z surfaces
        // here, as well as stereo left surfaces.

        lpDDSLcl = lpDDSLcl->lpAttachList->lpAttached;
        _ASSERT(lpDDSLcl, "Bad attachment List");

        while (lpDDSLcl && lpDDSLcl != p->lpDDSLcl) //i.e. not the first surface again
        {
            //We just reuse the "ProcessPossibleMipmap" function, and
            //assert that it will not have to traverse a mipmap here.
            _ASSERT(0==(lpDDSLcl->ddsCaps.dwCaps & DDSCAPS_MIPMAP),
                "Flipping chains should not be mipmaps");

            ProcessPossibleMipMap(p, lpDDSLcl);

            //This is the termination condition we expect for DX8 software
            //drivers.
            if (0 == lpDDSLcl->lpAttachList)
            {
                lpDDSLcl = 0;
                break;
            }

            lpDDSLcl = lpDDSLcl->lpAttachList->lpAttached;

            _ASSERT(lpDDSLcl, "Bad attachment List");
        }
    }
    // else we drop through and do no further attachment list processing
    // (typically on mipmaps or execute buffers).

    return DDHAL_DRIVER_HANDLED;
}


extern HRESULT FASTCALL
FindOutSurfFormat(LPDDPIXELFORMAT  pDdPixFmt, RDSurfaceFormat* pFmt,
                  BOOL*   pbIsDepth);

//----------------------------------------------------------------------------
//
// RefRastCreateSurface
//
// Create a requested surface. Fake VIDMEM allocation.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastCreateSurface(LPDDHAL_CREATESURFACEDATA pData)
{
    LPDDRAWI_DDRAWSURFACE_LCL  pSLcl  = NULL;
    LPDDRAWI_DDRAWSURFACE_GBL  pSGbl  = NULL;
    LPDDRAWI_DDRAWSURFACE_MORE pSMore = NULL;
    DWORD dwBytesPerPixel = 0;
    DWORD dwBytesInVB = 0;
    DWORD dwNumBytes = 0;
    DWORD dwPitch = 0;
    DWORD dwSlicePitch = 0;
    DWORD i = 0, j = 0;
    BYTE* pBits = NULL;
    BOOL  isDXT = FALSE;
    UINT  MultiSampleCount;
    DWORD dwMultiSamplePitch = 0;
    BYTE* pMultiSampleBits = NULL;
    DWORD dwNumMultiSampleBytes = 0;
    HRESULT hr = S_OK;

    pData->ddRVal = DD_OK;

    //
    // Validation
    //

    // The surface count
    if( pData->dwSCnt < 1 )
    {
        DPFERR("At least one surface should be created");
        pData->ddRVal = E_FAIL;
        return DDHAL_DRIVER_HANDLED;
    }

    // Primary surface cannot be handled here
    if( pData->lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE )
    {
        DPFERR("Refrast cannot allocate Primary surface");
        pData->ddRVal = DDERR_UNSUPPORTED;
        return DDHAL_DRIVER_HANDLED;
    }

    // Only Vidmem or Driver Managed allocations are handled here
    if(((pData->lpDDSurfaceDesc->ddsCaps.dwCaps &
          (DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM)) == 0)
        &&
        ((pData->lplpSList[0]->lpSurfMore->ddsCapsEx.dwCaps2 &
          DDSCAPS2_TEXTUREMANAGE) == 0))
    {
        DPFERR("Refrast can only allocate Vidmem or DriverManaged surfaces");
        pData->ddRVal = DDERR_UNSUPPORTED;
        return DDHAL_DRIVER_HANDLED;
    }

    // Dont allocate if the width or the height is not provided
    if( (pData->lpDDSurfaceDesc->dwFlags & (DDSD_WIDTH | DDSD_HEIGHT )) !=
        (DDSD_WIDTH | DDSD_HEIGHT ) )
    {
        DPFERR("No size provided for the surface");
        pData->ddRVal = DDERR_UNSUPPORTED;
        return DDHAL_DRIVER_HANDLED;
    }

    // Currently, allocation takes place only if a pixel format is provided
    if( pData->lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT )
    {
        dwBytesPerPixel =
            (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount >> 3);

        // For FourCCs, we need to explicitly indicate the bytes per pixel

        if ((dwBytesPerPixel == 0) &&
            (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_FOURCC))
        {
            if( IsYUV( pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC ) )
            {
                dwBytesPerPixel = 2;
            }
            else if( IsDXTn( pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC ) )
            {
                dwBytesPerPixel = 1;
                isDXT = TRUE;
            }
            // All the new surface formats (introduced after DX7) are marked as
            // 4CC. Technically they are not 4CC, that field is overloaded to
            // mean the new DX8 style format ID.
            else if( (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC ==
                      0xFF000004)    ||
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC ==
                      (DWORD) D3DFMT_Q8W8V8U8) ||
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC ==
                      (DWORD) D3DFMT_V16U16) ||
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC ==
                      (DWORD) D3DFMT_W11V11U10) ||
                     // Formats introduced in DX8.1
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC == 
                      (DWORD)D3DFMT_A2B10G10R10) ||
#if 0
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC == 
                      (DWORD)D3DFMT_A8B8G8R8) ||
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC == 
                      (DWORD)D3DFMT_X8B8G8R8) ||
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC == 
                      (DWORD)D3DFMT_W10V11U11) ||
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC == 
                      (DWORD)D3DFMT_A8X8V8U8) ||
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC == 
                      (DWORD)D3DFMT_L8X8V8U8) ||
#endif
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC == 
                      (DWORD)D3DFMT_G16R16) ||
                     (pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC == 
                      (DWORD)D3DFMT_A2W10V10U10)
                    )
            {
                // Private new format
                dwBytesPerPixel = 4;
            }
        }
    }
    else if( pData->lpDDSurfaceDesc->ddsCaps.dwCaps  & DDSCAPS_EXECUTEBUFFER )
    {
        dwBytesInVB = ((LPDDSURFACEDESC2)(pData->lpDDSurfaceDesc))->dwWidth;
    }
    else
    {
        // Note: for DX8 drivers, this case should never be encountered.
        // In the future, if RefDev is revamped to work with legacy interfaces
        // then this case needs to something real instead of failing:
        // If the pixel-formats are not provided, then the current primary
        // format should be assumed.
        DPFERR( "Refrast can only allocate if PixelFormat is provided" );
        pData->ddRVal = DDERR_UNSUPPORTED;
        return DDHAL_DRIVER_HANDLED;
    }

    //
    // Allocate the memory and compute the Pitch for every surface on the
    // list.
    //

    // We should be guaranteed that this is the same for all surfaces in the
    // list
    MultiSampleCount = 0xf & (pData->lplpSList[0]->lpSurfMore->ddsCapsEx.dwCaps3);

    //This will be the case on older than DX8 runtimes
    if (MultiSampleCount == 0)
    {
        MultiSampleCount = 1;
    }


    for( i = 0; i < pData->dwSCnt; i++ )
    {
        RDCREATESURFPRIVATE* pPriv = NULL;

        pSLcl  = pData->lplpSList[i];
        pSGbl  = pSLcl->lpGbl;
        pSMore = pSLcl->lpSurfMore;
        DWORD dwHeight = pSGbl->wHeight;

        // If already allocated, just return
        if( pSGbl->fpVidMem || pSGbl->dwReserved1 )
        {
            DPFERR("Surface has already been allocated");
            pData->ddRVal = E_FAIL;
            break;
        }

        // Figure out if it is a vertex buffer
        if( dwBytesInVB )
        {
            dwNumBytes = dwBytesInVB;
            dwPitch = dwBytesInVB;
        }
        else
        {
            // Figure out the pitch and allocate
            switch( pData->lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC )
            {
            case MAKEFOURCC('D', 'X', 'T', '1'):
                dwMultiSamplePitch = (MultiSampleCount *
                                      ((pSGbl->wWidth+3)>>2) *
                                      g_DXTBlkSize[0] + 7) & ~7;
                dwPitch = (((pSGbl->wWidth+3)>>2) * g_DXTBlkSize[0] + 7) & ~7;
                dwHeight = ((pSGbl->wHeight+3)>>2);
                break;
            case MAKEFOURCC('D', 'X', 'T', '2'):
                dwMultiSamplePitch = (MultiSampleCount *
                                      ((pSGbl->wWidth+3)>>2) *
                                      g_DXTBlkSize[1] + 7) & ~7;
                dwPitch = (((pSGbl->wWidth+3)>>2) * g_DXTBlkSize[1] + 7) & ~7;
                dwHeight = ((pSGbl->wHeight+3)>>2);
                break;
            case MAKEFOURCC('D', 'X', 'T', '3'):
                dwMultiSamplePitch = (MultiSampleCount *
                                      ((pSGbl->wWidth+3)>>2) *
                                      g_DXTBlkSize[2] + 7) & ~7;
                dwPitch = (((pSGbl->wWidth+3)>>2) *
                           g_DXTBlkSize[2] + 7) & ~7;
                dwHeight = ((pSGbl->wHeight+3)>>2);
                break;
            case MAKEFOURCC('D', 'X', 'T', '4'):
                dwMultiSamplePitch = (MultiSampleCount *
                                      ((pSGbl->wWidth+3)>>2) *
                                      g_DXTBlkSize[3] + 7) & ~7;
                dwPitch = (((pSGbl->wWidth+3)>>2) *
                           g_DXTBlkSize[3] + 7) & ~7;
                dwHeight = ((pSGbl->wHeight+3)>>2);
                break;
            case MAKEFOURCC('D', 'X', 'T', '5'):
                dwMultiSamplePitch = (MultiSampleCount *
                                      ((pSGbl->wWidth+3)>>2) *
                                      g_DXTBlkSize[4] + 7) & ~7;
                dwPitch = (((pSGbl->wWidth+3)>>2) *
                           g_DXTBlkSize[4] + 7) & ~7;
                dwHeight = ((pSGbl->wHeight+3)>>2);
                break;
            default:
                dwMultiSamplePitch = (MultiSampleCount
                                      * dwBytesPerPixel *
                                      pSGbl->wWidth + 7) & ~7;
                dwPitch = (dwBytesPerPixel *
                           pSGbl->wWidth + 7) & ~7;
                break;
            }

            if (!(pSMore->ddsCapsEx.dwCaps2 & DDSCAPS2_VOLUME))
            {
                dwNumBytes = dwPitch * dwHeight;
                if( MultiSampleCount > 1 )
                    dwNumMultiSampleBytes = dwMultiSamplePitch *
                        pSGbl->wHeight;
            }
            else
            {
                _ASSERT( dwMultiSamplePitch == dwPitch,
                         "Cant have multisample for volume textures\n" );
                dwSlicePitch = dwPitch * dwHeight;

                // low word of ddsCaps.ddsCapsEx.dwCaps4 has depth
                // (volume texture only).
                dwNumBytes  = dwSlicePitch *
                    LOWORD(pSMore->ddsCapsEx.dwCaps4);
            }
        }

        pPriv = new RDCREATESURFPRIVATE;
        if( pPriv == NULL )
        {
            DPFERR("Allocation failed");
            pData->ddRVal = DDERR_OUTOFMEMORY;
            break;
        }

        pPriv->pBits = new BYTE[dwNumBytes];
        if( pPriv->pBits == NULL)
        {
            DPFERR("Allocation failed");
            delete pPriv;
            pData->ddRVal = DDERR_OUTOFMEMORY;
            break;
        }
        pPriv->dwPitch                 = dwPitch;

        // Allocate the private MultiSample buffer
        if( dwNumMultiSampleBytes )
        {
            pPriv->pMultiSampleBits = new BYTE[dwNumMultiSampleBytes];
            if( pPriv->pMultiSampleBits == NULL)
            {
                DPFERR("Multisample allocation failed");
                delete pPriv;
                pData->ddRVal = DDERR_OUTOFMEMORY;
                break;
            }
            pPriv->dwMultiSamplePitch = dwMultiSamplePitch;
            pPriv->wSamples = (WORD)MultiSampleCount;
            HR_RET(FindOutSurfFormat(&(DDSurf_PixFmt(pSLcl)),
                                     &pPriv->SurfaceFormat, NULL));
        }

        // Save the stuff on the surface
        pSGbl->fpVidMem = (FLATPTR)pPriv->pBits;
        if ( isDXT )
        {
            pSGbl->lPitch = dwNumBytes;
            if (pSMore->ddsCapsEx.dwCaps2 & DDSCAPS2_VOLUME)
            {
                // set slice pitch (volume texture only).
                pSGbl->lSlicePitch = dwSlicePitch;
            }
        }
        else
        {
            pSGbl->lPitch = pPriv->dwPitch;
            if (pSMore->ddsCapsEx.dwCaps2 & DDSCAPS2_VOLUME)
            {
                // set slice pitch (volume texture only).
                pSGbl->lSlicePitch = dwSlicePitch;
            }
        }
        pSGbl->dwReserved1 = (ULONG_PTR)pPriv;
    }

    // The loop completed successfully
    if( i == pData->dwSCnt )
        return DDHAL_DRIVER_HANDLED;

    // Else the loop terminated abnormally,
    // Free up allocated memory and quit with the error
    for( j = 0; j < i; j++ )
    {
        pData->lplpSList[j]->lpGbl->lPitch = 0;
        if (pSMore->ddsCapsEx.dwCaps2 & DDSCAPS2_VOLUME)
        {
            pData->lplpSList[j]->lpGbl->lSlicePitch = 0;
        }
        delete (RDCREATESURFPRIVATE *)pData->lplpSList[j]->lpGbl->dwReserved1;
        pData->lplpSList[j]->lpGbl->dwReserved1 = 0;
    }
    return DDHAL_DRIVER_HANDLED;
}


//----------------------------------------------------------------------------
//
// RefRastDestroySurface
//
// Destroy a requested surface.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastDestroySurface(LPDDHAL_DESTROYSURFACEDATA pData)
{
    pData->ddRVal = DD_OK;

    //
    // Validation
    //
    if( pData->lpDDSurface->lpGbl->dwReserved1 == NULL )
    {
        DPFERR("This surface was not created by refrast");
        pData->ddRVal = E_FAIL;
        return DDHAL_DRIVER_HANDLED;
    }

    delete (RDCREATESURFPRIVATE *)pData->lpDDSurface->lpGbl->dwReserved1;
    pData->lpDDSurface->lpGbl->dwReserved1 = 0;

    // For vid-mem surfaces, runtime calls this DDI once per entire mip-chain
    // so this needs to be removed.
    // Now free the handle if it has been allocated for this surface
    pData->ddRVal = g_SurfMgr.RemoveSurfFromList(
        pData->lpDDSurface->lpSurfMore->lpDD_lcl,
        pData->lpDDSurface );

    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// RefRastLock
//
// Locks the given surface.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastLock(LPDDHAL_LOCKDATA pData)
{
    DWORD dwBytesPerPixel = 0;
    LPDDRAWI_DDRAWSURFACE_LCL pSLcl = pData->lpDDSurface;
    LPDDRAWI_DDRAWSURFACE_GBL  pSGbl = pSLcl->lpGbl;
    pData->ddRVal = DD_OK;

    //
    // Validation
    //
    if( pSGbl->dwReserved1 == NULL )
    {
        DPFERR("This surface was not created by refrast");
        pData->ddRVal = E_FAIL;
        return DDHAL_DRIVER_HANDLED;
    }

    //
    // Obtain the private data
    //
    RDCREATESURFPRIVATE* pPriv =
        (RDCREATESURFPRIVATE *)pSGbl->dwReserved1;

    if (g_RefDDI > RDDDI_DX7HAL)
    {
        // Figure out the device it is being used with.

        // If this is a Multisampled Rendertarget, need to filter down for
        // the runtime.
        if( pPriv->pMultiSampleBits )
        {
            BYTE* pBits   = pPriv->pBits;
            DWORD dwPitch = pPriv->dwPitch;

            BYTE* pMSBits   = pPriv->pMultiSampleBits;
            DWORD dwMSPitch = pPriv->dwMultiSamplePitch;

            RDSurfaceFormat sf = pPriv->SurfaceFormat;
            FLOAT fSampleScale = 1.F/((FLOAT)pPriv->wSamples);

            int width  = (int)DDSurf_Width(pSLcl);
            int height = (int)DDSurf_Height(pSLcl);
            for (int iY = 0; iY < height; iY++)
            {
                for (int iX = 0; iX < width; iX++)
                {
                    RDColor Color((UINT32)0);
                    for (UINT iS=0; iS<pPriv->wSamples; iS++)
                    {
                        RDColor SampleColor;
                        SampleColor.ConvertFrom(
                            sf, PixelAddress( iX, iY, 0, iS,
                                              pMSBits,
                                              dwMSPitch,
                                              0,
                                              pPriv->wSamples,
                                              sf ) );
                        Color.R += (SampleColor.R * fSampleScale);
                        Color.G += (SampleColor.G * fSampleScale);
                        Color.B += (SampleColor.B * fSampleScale);
                        Color.A += (SampleColor.A * fSampleScale);
                    }
                    Color.ConvertTo( sf, 0., PixelAddress( iX, iY, 0, pBits,
                                                           dwPitch, 0, sf ) );
                }
            }
        }
    }

    if( pData->bHasRect )
    {
        // If it is either a 1) VB, 2) IB or 3) CB then the
        // rect has a special meaning. rect.top - rect.bottom
        // gives the range of memory desired.
        // Note: it rect.bottom is the higher address and it is exclusive.
        if( pSLcl->ddsCaps.dwCaps  & DDSCAPS_EXECUTEBUFFER )
        {
            pData->lpSurfData = (LPVOID)(pPriv->pBits + pData->rArea.top);
        }
        else if( pSLcl->lpSurfMore->ddsCapsEx.dwCaps2 & DDSCAPS2_VOLUME )
        {
            // If it is a volume texture, then the front and back are
            // or'd into the high word of rect->left and rect->right
            // respectively.
            DWORD front  = (pData->rArea.left >> 16);
            DWORD left   = pData->rArea.left & 0x0000ffff;
            DWORD top    = pData->rArea.top;
            DWORD slicePitch = pSGbl->lSlicePitch;
            if( IsDXTn( pSGbl->ddpfSurface.dwFourCC ) )
            {
                _ASSERT( FALSE, "Should not be reached without driver "
                         "managed support" );

            }
            else
            {
                dwBytesPerPixel = pSGbl->ddpfSurface.dwRGBBitCount >> 3;
                pData->lpSurfData = (LPVOID)(pPriv->pBits +
                                             front  * slicePitch +
                                             top    * pPriv->dwPitch +
                                             left   * dwBytesPerPixel);
            }
        }
        else
        {
            if( IsDXTn( pSGbl->ddpfSurface.dwFourCC ) )
            {
                _ASSERT( FALSE, "Should not be reached without driver "
                         "managed support" );

            }
            else
            {
                dwBytesPerPixel = pSGbl->ddpfSurface.dwRGBBitCount >> 3;
                pData->lpSurfData = (LPVOID)(pPriv->pBits +
                                             pData->rArea.top*pPriv->dwPitch +
                                             pData->rArea.left*dwBytesPerPixel);
            }
        }
    }
    else
    {
        pData->lpSurfData = (LPVOID)pPriv->pBits;
    }

    pPriv->Lock();
    return DDHAL_DRIVER_HANDLED;
}

//----------------------------------------------------------------------------
//
// RefRastUnlock
//
// Unlocks the given surface.
//
//----------------------------------------------------------------------------
DWORD __stdcall
RefRastUnlock(LPDDHAL_UNLOCKDATA pData)
{
    pData->ddRVal = DD_OK;

    //
    // Validation
    //
    if( pData->lpDDSurface->lpGbl->dwReserved1 == NULL )
    {
        DPFERR("This surface was not created by refrast");
        pData->ddRVal = E_FAIL;
        return DDHAL_DRIVER_HANDLED;
    }

    //
    // Obtain the private data
    //
    RDCREATESURFPRIVATE* pPriv =
        (RDCREATESURFPRIVATE *)pData->lpDDSurface->lpGbl->dwReserved1;

    pPriv->Unlock();
    return DDHAL_DRIVER_HANDLED;
}


//////////////////////////////////////////////////////////////////////////////
//
// Software DDI interface implementation
//
//////////////////////////////////////////////////////////////////////////////

//
// DX8 DDI caps
//

#define RESPATH_D3DREF  RESPATH_D3D "\\ReferenceDevice"
static void
ModifyDeviceCaps8( void )
{
    HKEY hKey = (HKEY) NULL;
    if( ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, RESPATH_D3DREF, &hKey) )
    {
        DWORD dwType;
        DWORD dwValue;
        char  dwString[128];
        DWORD dwSize;

        dwSize = sizeof(dwValue);
        if ( (ERROR_SUCCESS == RegQueryValueEx( hKey, "PixelShaderVersion", NULL,
                &dwType, (LPBYTE)&dwValue, &dwSize )) &&
             (dwType == REG_DWORD) )
        {
            g_RefCaps8.PixelShaderVersion = dwValue;
        }
        dwSize = sizeof(dwString);
        if ( (ERROR_SUCCESS == RegQueryValueEx( hKey, "MaxPixelShaderValue", NULL,
                &dwType, (LPBYTE)dwString, &dwSize )) &&
             (dwType == REG_SZ) )
        {
            sscanf( dwString, "%f", &g_RefCaps8.MaxPixelShaderValue );
        }

        RegCloseKey(hKey);
    }


}

static void
FillOutDeviceCaps8( RDDDITYPE ddi )
{
    g_RefCaps8.DevCaps=
        D3DDEVCAPS_EXECUTESYSTEMMEMORY  |
        D3DDEVCAPS_TLVERTEXSYSTEMMEMORY |
        D3DDEVCAPS_TEXTURESYSTEMMEMORY  |
        D3DDEVCAPS_DRAWPRIMTLVERTEX     |
        D3DDEVCAPS_PUREDEVICE           |
        D3DDEVCAPS_DRAWPRIMITIVES2EX    |
        D3DDEVCAPS_HWVERTEXBUFFER       |
        D3DDEVCAPS_HWINDEXBUFFER        |
        0;

    g_RefCaps8.PrimitiveMiscCaps =
        D3DPMISCCAPS_MASKZ                 |
        D3DPMISCCAPS_LINEPATTERNREP        |
        D3DPMISCCAPS_CULLNONE              |
        D3DPMISCCAPS_CULLCW                |
        D3DPMISCCAPS_CULLCCW               |
        D3DPMISCCAPS_COLORWRITEENABLE      |
        D3DPMISCCAPS_CLIPTLVERTS           |
        D3DPMISCCAPS_TSSARGTEMP            |
        D3DPMISCCAPS_FOGINFVF              |
        D3DPMISCCAPS_BLENDOP               ;

#ifdef __D3D_NULL_REF
    g_RefCaps8.PrimitiveMiscCaps |= D3DPMISCCAPS_NULLREFERENCE;
#endif //__D3D_NULL_REF

    g_RefCaps8.RasterCaps =
        D3DPRASTERCAPS_DITHER              |
        D3DPRASTERCAPS_ZTEST               |
        D3DPRASTERCAPS_FOGVERTEX           |
        D3DPRASTERCAPS_FOGTABLE            |
        D3DPRASTERCAPS_MIPMAPLODBIAS       |
        D3DPRASTERCAPS_PAT                 |
//        D3DPRASTERCAPS_ZBIAS               |
        D3DPRASTERCAPS_FOGRANGE            |
        D3DPRASTERCAPS_ANISOTROPY          |
        D3DPRASTERCAPS_WBUFFER             |
        D3DPRASTERCAPS_WFOG                |
        D3DPRASTERCAPS_ZFOG                |
        D3DPRASTERCAPS_COLORPERSPECTIVE    ;

    g_RefCaps8.ZCmpCaps =
        D3DPCMPCAPS_NEVER        |
        D3DPCMPCAPS_LESS         |
        D3DPCMPCAPS_EQUAL        |
        D3DPCMPCAPS_LESSEQUAL    |
        D3DPCMPCAPS_GREATER      |
        D3DPCMPCAPS_NOTEQUAL     |
        D3DPCMPCAPS_GREATEREQUAL |
        D3DPCMPCAPS_ALWAYS       ;

    g_RefCaps8.SrcBlendCaps =
        D3DPBLENDCAPS_ZERO             |
        D3DPBLENDCAPS_ONE              |
        D3DPBLENDCAPS_SRCCOLOR         |
        D3DPBLENDCAPS_INVSRCCOLOR      |
        D3DPBLENDCAPS_SRCALPHA         |
        D3DPBLENDCAPS_INVSRCALPHA      |
        D3DPBLENDCAPS_DESTALPHA        |
        D3DPBLENDCAPS_INVDESTALPHA     |
        D3DPBLENDCAPS_DESTCOLOR        |
        D3DPBLENDCAPS_INVDESTCOLOR     |
        D3DPBLENDCAPS_SRCALPHASAT      |
        D3DPBLENDCAPS_BOTHSRCALPHA     |
        D3DPBLENDCAPS_BOTHINVSRCALPHA  ;

    g_RefCaps8.DestBlendCaps =
        D3DPBLENDCAPS_ZERO             |
        D3DPBLENDCAPS_ONE              |
        D3DPBLENDCAPS_SRCCOLOR         |
        D3DPBLENDCAPS_INVSRCCOLOR      |
        D3DPBLENDCAPS_SRCALPHA         |
        D3DPBLENDCAPS_INVSRCALPHA      |
        D3DPBLENDCAPS_DESTALPHA        |
        D3DPBLENDCAPS_INVDESTALPHA     |
        D3DPBLENDCAPS_DESTCOLOR        |
        D3DPBLENDCAPS_INVDESTCOLOR     |
        D3DPBLENDCAPS_SRCALPHASAT      ;

    g_RefCaps8.AlphaCmpCaps =
        D3DPCMPCAPS_NEVER        |
        D3DPCMPCAPS_LESS         |
        D3DPCMPCAPS_EQUAL        |
        D3DPCMPCAPS_LESSEQUAL    |
        D3DPCMPCAPS_GREATER      |
        D3DPCMPCAPS_NOTEQUAL     |
        D3DPCMPCAPS_GREATEREQUAL |
        D3DPCMPCAPS_ALWAYS       ;

    g_RefCaps8.ShadeCaps =
        D3DPSHADECAPS_COLORGOURAUDRGB       |
        D3DPSHADECAPS_SPECULARGOURAUDRGB    |
        D3DPSHADECAPS_ALPHAGOURAUDBLEND     |
        D3DPSHADECAPS_FOGGOURAUD            ;

    g_RefCaps8.TextureCaps =
        D3DPTEXTURECAPS_PERSPECTIVE              |
//        D3DPTEXTURECAPS_POW2                     |
        D3DPTEXTURECAPS_ALPHA                    |
        D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE |
        D3DPTEXTURECAPS_ALPHAPALETTE             |
        D3DPTEXTURECAPS_PROJECTED                |
        D3DPTEXTURECAPS_CUBEMAP                  |
        D3DPTEXTURECAPS_VOLUMEMAP                |
        D3DPTEXTURECAPS_MIPMAP                   |
        D3DPTEXTURECAPS_MIPVOLUMEMAP             |
        D3DPTEXTURECAPS_MIPCUBEMAP               |
        D3DPTEXTURECAPS_CUBEMAP_POW2             |
        D3DPTEXTURECAPS_VOLUMEMAP_POW2           ;

    g_RefCaps8.TextureFilterCaps =
        D3DPTFILTERCAPS_MINFPOINT           |
        D3DPTFILTERCAPS_MINFLINEAR          |
        D3DPTFILTERCAPS_MINFANISOTROPIC     |
        D3DPTFILTERCAPS_MIPFPOINT           |
        D3DPTFILTERCAPS_MIPFLINEAR          |
        D3DPTFILTERCAPS_MAGFPOINT           |
        D3DPTFILTERCAPS_MAGFLINEAR          |
        D3DPTFILTERCAPS_MAGFANISOTROPIC     ;

    g_RefCaps8.CubeTextureFilterCaps =
        D3DPTFILTERCAPS_MINFPOINT           |
        D3DPTFILTERCAPS_MINFLINEAR          |
        D3DPTFILTERCAPS_MIPFPOINT           |
        D3DPTFILTERCAPS_MIPFLINEAR          |
        D3DPTFILTERCAPS_MAGFPOINT           |
        D3DPTFILTERCAPS_MAGFLINEAR          ;

    g_RefCaps8.VolumeTextureFilterCaps =
        D3DPTFILTERCAPS_MINFPOINT           |
        D3DPTFILTERCAPS_MINFLINEAR          |
        D3DPTFILTERCAPS_MIPFPOINT           |
        D3DPTFILTERCAPS_MIPFLINEAR          |
        D3DPTFILTERCAPS_MAGFPOINT           |
        D3DPTFILTERCAPS_MAGFLINEAR          ;

    g_RefCaps8.TextureAddressCaps =
        D3DPTADDRESSCAPS_WRAP          |
        D3DPTADDRESSCAPS_MIRROR        |
        D3DPTADDRESSCAPS_CLAMP         |
        D3DPTADDRESSCAPS_BORDER        |
        D3DPTADDRESSCAPS_INDEPENDENTUV |
        D3DPTADDRESSCAPS_MIRRORONCE    ;

    g_RefCaps8.VolumeTextureAddressCaps =
        D3DPTADDRESSCAPS_WRAP          |
        D3DPTADDRESSCAPS_MIRROR        |
        D3DPTADDRESSCAPS_CLAMP         |
        D3DPTADDRESSCAPS_BORDER        |
        D3DPTADDRESSCAPS_INDEPENDENTUV |
        D3DPTADDRESSCAPS_MIRRORONCE    ;

    g_RefCaps8.LineCaps =
        D3DLINECAPS_TEXTURE     |
        D3DLINECAPS_ZTEST       |
        D3DLINECAPS_BLEND       |
        D3DLINECAPS_ALPHACMP    |
        D3DLINECAPS_FOG         ;

    g_RefCaps8.MaxTextureWidth  = 4096;
    g_RefCaps8.MaxTextureHeight = 4096;
    g_RefCaps8.MaxVolumeExtent  = 4096;

    g_RefCaps8.MaxTextureRepeat = 32768;
    g_RefCaps8.MaxTextureAspectRatio = 0;
    g_RefCaps8.MaxAnisotropy = 16;
    g_RefCaps8.MaxVertexW = 1.0e10;

    g_RefCaps8.GuardBandLeft   = -32768.f;
    g_RefCaps8.GuardBandTop    = -32768.f;
    g_RefCaps8.GuardBandRight  =  32767.f;
    g_RefCaps8.GuardBandBottom =  32767.f;

    g_RefCaps8.ExtentsAdjust = 0.;
    g_RefCaps8.StencilCaps =
        D3DSTENCILCAPS_KEEP   |
        D3DSTENCILCAPS_ZERO   |
        D3DSTENCILCAPS_REPLACE|
        D3DSTENCILCAPS_INCRSAT|
        D3DSTENCILCAPS_DECRSAT|
        D3DSTENCILCAPS_INVERT |
        D3DSTENCILCAPS_INCR   |
        D3DSTENCILCAPS_DECR;

    g_RefCaps8.FVFCaps = 8 | D3DFVFCAPS_PSIZE;

    g_RefCaps8.TextureOpCaps =
        D3DTEXOPCAPS_DISABLE                   |
        D3DTEXOPCAPS_SELECTARG1                |
        D3DTEXOPCAPS_SELECTARG2                |
        D3DTEXOPCAPS_MODULATE                  |
        D3DTEXOPCAPS_MODULATE2X                |
        D3DTEXOPCAPS_MODULATE4X                |
        D3DTEXOPCAPS_ADD                       |
        D3DTEXOPCAPS_ADDSIGNED                 |
        D3DTEXOPCAPS_ADDSIGNED2X               |
        D3DTEXOPCAPS_SUBTRACT                  |
        D3DTEXOPCAPS_ADDSMOOTH                 |
        D3DTEXOPCAPS_BLENDDIFFUSEALPHA         |
        D3DTEXOPCAPS_BLENDTEXTUREALPHA         |
        D3DTEXOPCAPS_BLENDFACTORALPHA          |
        D3DTEXOPCAPS_BLENDTEXTUREALPHAPM       |
        D3DTEXOPCAPS_BLENDCURRENTALPHA         |
        D3DTEXOPCAPS_PREMODULATE               |
        D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR    |
        D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA    |
        D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
        D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA |
        D3DTEXOPCAPS_BUMPENVMAP                |
        D3DTEXOPCAPS_BUMPENVMAPLUMINANCE       |
        D3DTEXOPCAPS_DOTPRODUCT3               |
        D3DTEXOPCAPS_MULTIPLYADD               |
        D3DTEXOPCAPS_LERP                      ;

    g_RefCaps8.MaxTextureBlendStages = 8;
    g_RefCaps8.MaxSimultaneousTextures = 8;

    g_RefCaps8.VertexProcessingCaps      = 0;
    g_RefCaps8.MaxActiveLights           = 0;
    g_RefCaps8.MaxUserClipPlanes         = 0;
    g_RefCaps8.MaxVertexBlendMatrices    = 0;
    g_RefCaps8.MaxVertexBlendMatrixIndex = 0;

    g_RefCaps8.MaxPointSize = RD_MAX_POINT_SIZE;

    g_RefCaps8.MaxPrimitiveCount = 0x001fffff;
    g_RefCaps8.MaxVertexIndex = 0x00ffffff;
    g_RefCaps8.MaxStreams = 1;
    g_RefCaps8.MaxStreamStride = 256;

    g_RefCaps8.VertexShaderVersion  = D3DVS_VERSION(0,0);
    g_RefCaps8.MaxVertexShaderConst = 0;

    g_RefCaps8.PixelShaderVersion   = D3DPS_VERSION(1,4);
    g_RefCaps8.MaxPixelShaderValue  = FLT_MAX;

    // Non 3D Caps
    g_RefCaps8.Caps  = 0;
    g_RefCaps8.Caps2 = DDCAPS2_CANMANAGERESOURCE | DDCAPS2_CANRENDERWINDOWED | DDCAPS2_DYNAMICTEXTURES;

    switch( ddi )
    {
    case RDDDI_DX8TLHAL:
    g_RefCaps8.DevCaps |=
        D3DDEVCAPS_HWTRANSFORMANDLIGHT  |
        D3DDEVCAPS_RTPATCHES            |
        D3DDEVCAPS_RTPATCHHANDLEZERO    |
        D3DDEVCAPS_NPATCHES             |
        D3DDEVCAPS_QUINTICRTPATCHES     |
        0;
        g_RefCaps8.VertexProcessingCaps =
            D3DVTXPCAPS_TEXGEN            |
            D3DVTXPCAPS_MATERIALSOURCE7   |
            D3DVTXPCAPS_DIRECTIONALLIGHTS |
            D3DVTXPCAPS_POSITIONALLIGHTS  |
            D3DVTXPCAPS_TWEENING          |
            D3DVTXPCAPS_LOCALVIEWER       ;
        g_RefCaps8.MaxActiveLights = 0xffffffff;
        g_RefCaps8.MaxUserClipPlanes = RD_MAX_USER_CLIPPLANES;
        g_RefCaps8.MaxVertexBlendMatrices = RD_MAX_BLEND_WEIGHTS;
        g_RefCaps8.MaxVertexBlendMatrixIndex = RD_MAX_WORLD_MATRICES - 1;
        g_RefCaps8.MaxStreams = RD_MAX_NUMSTREAMS;
        g_RefCaps8.VertexShaderVersion  = D3DVS_VERSION(1,1);
        g_RefCaps8.MaxVertexShaderConst = RD_MAX_NUMCONSTREG;
        break;
    }
}


//
// pre-DX8 DDI caps
//

static D3DHAL_GLOBALDRIVERDATA RefGDD = { 0 };
static D3DHAL_D3DEXTENDEDCAPS RefExtCaps = { 0 };

static void
FillOutDeviceCaps( BOOL bIsNullDevice, RDDDITYPE ddi )
{
    //
    //  set device description
    //
    RefGDD.dwSize = sizeof(RefGDD);
    RefGDD.hwCaps.dwDevCaps =
        D3DDEVCAPS_FLOATTLVERTEX        |
        D3DDEVCAPS_EXECUTESYSTEMMEMORY  |
        D3DDEVCAPS_TLVERTEXSYSTEMMEMORY |
        D3DDEVCAPS_TEXTURESYSTEMMEMORY  |
        D3DDEVCAPS_DRAWPRIMTLVERTEX;

    RefGDD.dwNumVertices = (RD_MAX_VERTEX_COUNT - RD_MAX_CLIP_VERTICES);
    RefGDD.dwNumClipVertices = RD_MAX_CLIP_VERTICES;

    RefGDD.hwCaps.dpcTriCaps.dwSize = sizeof(D3DPRIMCAPS);
    RefGDD.hwCaps.dpcTriCaps.dwMiscCaps =
    D3DPMISCCAPS_MASKZ    |
    D3DPMISCCAPS_CULLNONE |
    D3DPMISCCAPS_CULLCW   |
    D3DPMISCCAPS_CULLCCW  ;
    RefGDD.hwCaps.dpcTriCaps.dwRasterCaps =
        D3DPRASTERCAPS_DITHER                   |
//        D3DPRASTERCAPS_ROP2                     |
//        D3DPRASTERCAPS_XOR                      |
//        D3DPRASTERCAPS_PAT                      |
        D3DPRASTERCAPS_ZTEST                    |
        D3DPRASTERCAPS_SUBPIXEL                 |
        D3DPRASTERCAPS_SUBPIXELX                |
        D3DPRASTERCAPS_FOGVERTEX                |
        D3DPRASTERCAPS_FOGTABLE                 |
//        D3DPRASTERCAPS_STIPPLE                  |
//        D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT   |
        D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT |
//        D3DPRASTERCAPS_ANTIALIASEDGES           |
        D3DPRASTERCAPS_MIPMAPLODBIAS            |
//        D3DPRASTERCAPS_ZBIAS                    |
//        D3DPRASTERCAPS_ZBUFFERLESSHSR           |
        D3DPRASTERCAPS_FOGRANGE                 |
        D3DPRASTERCAPS_ANISOTROPY               |
        D3DPRASTERCAPS_WBUFFER                  |
        D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT |
        D3DPRASTERCAPS_WFOG |
        D3DPRASTERCAPS_ZFOG;
    RefGDD.hwCaps.dpcTriCaps.dwZCmpCaps =
        D3DPCMPCAPS_NEVER        |
        D3DPCMPCAPS_LESS         |
        D3DPCMPCAPS_EQUAL        |
        D3DPCMPCAPS_LESSEQUAL    |
        D3DPCMPCAPS_GREATER      |
        D3DPCMPCAPS_NOTEQUAL     |
        D3DPCMPCAPS_GREATEREQUAL |
        D3DPCMPCAPS_ALWAYS       ;
    RefGDD.hwCaps.dpcTriCaps.dwSrcBlendCaps =
        D3DPBLENDCAPS_ZERO             |
        D3DPBLENDCAPS_ONE              |
        D3DPBLENDCAPS_SRCCOLOR         |
        D3DPBLENDCAPS_INVSRCCOLOR      |
        D3DPBLENDCAPS_SRCALPHA         |
        D3DPBLENDCAPS_INVSRCALPHA      |
        D3DPBLENDCAPS_DESTALPHA        |
        D3DPBLENDCAPS_INVDESTALPHA     |
        D3DPBLENDCAPS_DESTCOLOR        |
        D3DPBLENDCAPS_INVDESTCOLOR     |
        D3DPBLENDCAPS_SRCALPHASAT      |
        D3DPBLENDCAPS_BOTHSRCALPHA     |
        D3DPBLENDCAPS_BOTHINVSRCALPHA  ;
    RefGDD.hwCaps.dpcTriCaps.dwDestBlendCaps =
        D3DPBLENDCAPS_ZERO             |
        D3DPBLENDCAPS_ONE              |
        D3DPBLENDCAPS_SRCCOLOR         |
        D3DPBLENDCAPS_INVSRCCOLOR      |
        D3DPBLENDCAPS_SRCALPHA         |
        D3DPBLENDCAPS_INVSRCALPHA      |
        D3DPBLENDCAPS_DESTALPHA        |
        D3DPBLENDCAPS_INVDESTALPHA     |
        D3DPBLENDCAPS_DESTCOLOR        |
        D3DPBLENDCAPS_INVDESTCOLOR     |
        D3DPBLENDCAPS_SRCALPHASAT      ;
    RefGDD.hwCaps.dpcTriCaps.dwAlphaCmpCaps =
    RefGDD.hwCaps.dpcTriCaps.dwZCmpCaps;
    RefGDD.hwCaps.dpcTriCaps.dwShadeCaps =
        D3DPSHADECAPS_COLORFLATRGB       |
        D3DPSHADECAPS_COLORGOURAUDRGB    |
        D3DPSHADECAPS_SPECULARFLATRGB    |
        D3DPSHADECAPS_SPECULARGOURAUDRGB |
        D3DPSHADECAPS_ALPHAFLATBLEND     |
        D3DPSHADECAPS_ALPHAGOURAUDBLEND  |
        D3DPSHADECAPS_FOGFLAT            |
        D3DPSHADECAPS_FOGGOURAUD         ;
    RefGDD.hwCaps.dpcTriCaps.dwTextureCaps =
        D3DPTEXTURECAPS_PERSPECTIVE              |
        D3DPTEXTURECAPS_POW2                     |
        D3DPTEXTURECAPS_ALPHA                    |
        D3DPTEXTURECAPS_TRANSPARENCY             |
        D3DPTEXTURECAPS_ALPHAPALETTE             |
        D3DPTEXTURECAPS_BORDER                   |
        D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE |
        D3DPTEXTURECAPS_ALPHAPALETTE             |
        D3DPTEXTURECAPS_PROJECTED                |
        D3DPTEXTURECAPS_CUBEMAP                  |
        D3DPTEXTURECAPS_COLORKEYBLEND;
    RefGDD.hwCaps.dpcTriCaps.dwTextureFilterCaps =
        D3DPTFILTERCAPS_NEAREST          |
        D3DPTFILTERCAPS_LINEAR           |
        D3DPTFILTERCAPS_MIPNEAREST       |
        D3DPTFILTERCAPS_MIPLINEAR        |
        D3DPTFILTERCAPS_LINEARMIPNEAREST |
        D3DPTFILTERCAPS_LINEARMIPLINEAR  |
        D3DPTFILTERCAPS_MINFPOINT        |
        D3DPTFILTERCAPS_MINFLINEAR       |
        D3DPTFILTERCAPS_MINFANISOTROPIC  |
        D3DPTFILTERCAPS_MIPFPOINT        |
        D3DPTFILTERCAPS_MIPFLINEAR       |
        D3DPTFILTERCAPS_MAGFPOINT        |
        D3DPTFILTERCAPS_MAGFLINEAR       |
        D3DPTFILTERCAPS_MAGFANISOTROPIC  ;
    RefGDD.hwCaps.dpcTriCaps.dwTextureBlendCaps =
        D3DPTBLENDCAPS_DECAL         |
        D3DPTBLENDCAPS_MODULATE      |
        D3DPTBLENDCAPS_DECALALPHA    |
        D3DPTBLENDCAPS_MODULATEALPHA |
        // D3DPTBLENDCAPS_DECALMASK     |
        // D3DPTBLENDCAPS_MODULATEMASK  |
        D3DPTBLENDCAPS_COPY          |
        D3DPTBLENDCAPS_ADD           ;
    RefGDD.hwCaps.dpcTriCaps.dwTextureAddressCaps =
        D3DPTADDRESSCAPS_WRAP          |
        D3DPTADDRESSCAPS_MIRROR        |
        D3DPTADDRESSCAPS_CLAMP         |
        D3DPTADDRESSCAPS_BORDER        |
        D3DPTADDRESSCAPS_INDEPENDENTUV ;
    RefGDD.hwCaps.dpcTriCaps.dwStippleWidth = 0;
    RefGDD.hwCaps.dpcTriCaps.dwStippleHeight = 0;

    //  line caps - copy tricaps and modify
    memcpy( &RefGDD.hwCaps.dpcLineCaps, &RefGDD.hwCaps.dpcTriCaps,
            sizeof(D3DPRIMCAPS) );

    //  disable antialias cap
    RefGDD.hwCaps.dpcLineCaps.dwRasterCaps =
        D3DPRASTERCAPS_DITHER                   |
//        D3DPRASTERCAPS_ROP2                     |
//        D3DPRASTERCAPS_XOR                      |
//        D3DPRASTERCAPS_PAT                      |
        D3DPRASTERCAPS_ZTEST                    |
        D3DPRASTERCAPS_SUBPIXEL                 |
        D3DPRASTERCAPS_SUBPIXELX                |
        D3DPRASTERCAPS_FOGVERTEX                |
        D3DPRASTERCAPS_FOGTABLE                 |
//        D3DPRASTERCAPS_STIPPLE                  |
//        D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT   |
//        D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT |
//        D3DPRASTERCAPS_ANTIALIASEDGES           |
        D3DPRASTERCAPS_MIPMAPLODBIAS            |
//        D3DPRASTERCAPS_ZBIAS                    |
//        D3DPRASTERCAPS_ZBUFFERLESSHSR           |
        D3DPRASTERCAPS_FOGRANGE                 |
        D3DPRASTERCAPS_ANISOTROPY               |
        D3DPRASTERCAPS_WBUFFER                  |
//        D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT |
        D3DPRASTERCAPS_WFOG;

    RefGDD.hwCaps.dwDeviceRenderBitDepth = DDBD_16 | DDBD_24 | DDBD_32;
    RefGDD.hwCaps.dwDeviceZBufferBitDepth = DDBD_16 | DDBD_32;

    //
    //  set extended caps
    //
    RefExtCaps.dwSize = sizeof(RefExtCaps);

    RefExtCaps.dwMinTextureWidth = 1;
    RefExtCaps.dwMaxTextureWidth = 4096;
    RefExtCaps.dwMinTextureHeight = 1;
    RefExtCaps.dwMaxTextureHeight = 4096;
    RefExtCaps.dwMinStippleWidth = 0;   //  stipple unsupported
    RefExtCaps.dwMaxStippleWidth = 0;
    RefExtCaps.dwMinStippleHeight = 0;
    RefExtCaps.dwMaxStippleHeight = 0;

    RefExtCaps.dwMaxTextureRepeat = 32768;
    RefExtCaps.dwMaxTextureAspectRatio = 0; // no limit
    RefExtCaps.dwMaxAnisotropy = 16;

    RefExtCaps.dvGuardBandLeft   = (bIsNullDevice) ? (-2048.f) : (-32768.f);
    RefExtCaps.dvGuardBandTop    = (bIsNullDevice) ? (-2048.f) : (-32768.f);
    RefExtCaps.dvGuardBandRight  = (bIsNullDevice) ? ( 2047.f) : ( 32767.f);
    RefExtCaps.dvGuardBandBottom = (bIsNullDevice) ? ( 2047.f) : ( 32767.f);
    RefExtCaps.dvExtentsAdjust = 0.;    //  AA kernel is 1.0 x 1.0
    RefExtCaps.dwStencilCaps =
        D3DSTENCILCAPS_KEEP   |
        D3DSTENCILCAPS_ZERO   |
        D3DSTENCILCAPS_REPLACE|
        D3DSTENCILCAPS_INCRSAT|
        D3DSTENCILCAPS_DECRSAT|
        D3DSTENCILCAPS_INVERT |
        D3DSTENCILCAPS_INCR   |
        D3DSTENCILCAPS_DECR;
    RefExtCaps.dwFVFCaps = 8;   // max number of tex coord sets
    RefExtCaps.dwTextureOpCaps =
        D3DTEXOPCAPS_DISABLE                   |
        D3DTEXOPCAPS_SELECTARG1                |
        D3DTEXOPCAPS_SELECTARG2                |
        D3DTEXOPCAPS_MODULATE                  |
        D3DTEXOPCAPS_MODULATE2X                |
        D3DTEXOPCAPS_MODULATE4X                |
        D3DTEXOPCAPS_ADD                       |
        D3DTEXOPCAPS_ADDSIGNED                 |
        D3DTEXOPCAPS_ADDSIGNED2X               |
        D3DTEXOPCAPS_SUBTRACT                  |
        D3DTEXOPCAPS_ADDSMOOTH                 |
        D3DTEXOPCAPS_BLENDDIFFUSEALPHA         |
        D3DTEXOPCAPS_BLENDTEXTUREALPHA         |
        D3DTEXOPCAPS_BLENDFACTORALPHA          |
        D3DTEXOPCAPS_BLENDTEXTUREALPHAPM       |
        D3DTEXOPCAPS_BLENDCURRENTALPHA         |
        D3DTEXOPCAPS_PREMODULATE               |
        D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR    |
        D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA    |
        D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
        D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA |
        D3DTEXOPCAPS_BUMPENVMAP                |
        D3DTEXOPCAPS_BUMPENVMAPLUMINANCE       |
        D3DTEXOPCAPS_DOTPRODUCT3               ;
    RefExtCaps.wMaxTextureBlendStages = 8;
    RefExtCaps.wMaxSimultaneousTextures = 8;
    RefExtCaps.dwMaxActiveLights = 0xffffffff;
    RefExtCaps.dvMaxVertexW = 1.0e10;

    switch( ddi )
    {
    case RDDDI_DX7TLHAL:
        RefGDD.hwCaps.dwDevCaps |= D3DDEVCAPS_HWTRANSFORMANDLIGHT;
        RefExtCaps.dwVertexProcessingCaps = (D3DVTXPCAPS_TEXGEN            |
                                             D3DVTXPCAPS_MATERIALSOURCE7   |
                                             D3DVTXPCAPS_VERTEXFOG         |
                                             D3DVTXPCAPS_DIRECTIONALLIGHTS |
                                             D3DVTXPCAPS_POSITIONALLIGHTS  |
                                             D3DVTXPCAPS_LOCALVIEWER);
        RefExtCaps.wMaxUserClipPlanes = RD_MAX_USER_CLIPPLANES;
        RefExtCaps.wMaxVertexBlendMatrices = RD_MAX_BLEND_WEIGHTS;
        // Fall throug
    case RDDDI_DX7HAL:
        RefGDD.hwCaps.dwDevCaps |= D3DDEVCAPS_DRAWPRIMITIVES2EX;
    }
}

//----------------------------------------------------------------------------
//
// Pixel formats
//
// Returns all the pixel formats supported by our rasterizer, and what we
// can do with them.
// Called at device creation time.
//
//----------------------------------------------------------------------------

DWORD
GetRefFormatOperations( LPDDSURFACEDESC* lplpddsd )
{
    int i = 0;

    DDSURFACEDESC* ddsd = g_ddsdTex;

    // Here we list our DX8 texture formats.
    // A driver wishing to run against DX7 or earlier runtimes would duplicate
    // entries, placing a list of DDSURFACEDESCs before this list that contain
    // old-style DDPIXELFORMAT structures. Example of old style:
    //    /* 888 */
    //    ddsd[i].dwSize = sizeof(ddsd[0]);
    //    ddsd[i].dwFlags = DDSD_PIXELFORMAT | DDSD_CAPS;
    //    ddsd[i].ddsCaps.dwCaps = DDSCAPS_TEXTURE;
    //    ddsd[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
    //    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_RGB;
    //    ddsd[i].ddpfPixelFormat.dwRGBBitCount = 32;
    //    ddsd[i].ddpfPixelFormat.dwRBitMask = 0xff0000;
    //    ddsd[i].ddpfPixelFormat.dwGBitMask = 0x00ff00;
    //    ddsd[i].ddpfPixelFormat.dwBBitMask = 0x0000ff;


    //-------------------------- (A)RGB Formats -----------------------------------------

    /* 888 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_R8G8B8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_3DACCELERATION |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    /* x888 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_X8R8G8B8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_3DACCELERATION |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    /* 8888 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A8R8G8B8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    /* 565 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_R5G6B5;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_3DACCELERATION |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    /* x555 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_X1R5G5B5;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_3DACCELERATION |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    /* 1555 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A1R5G5B5;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    // A formats for PC98 consistency
    // 4444 ARGB (it is already supported by S3 Virge)
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A4R4G4B4;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    // 4444 XRGB
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_X4R4G4B4;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    // 332 8-bit RGB
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_R3G3B2;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    // 8332 16-bit ARGB
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A8R3G3B2;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    //---------------------------- Palettized formats ------------------------------------
#if 0
    /* pal4 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD)
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES);
    i++;
#endif

    /* A8P8 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A8P8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    /* pal8 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_P8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    //-------------------------- alpha/luminance formats -----------------------------------

    /* 8 bit luminance-only */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_L8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    /* 16 bit alpha-luminance */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A8L8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    /* 8 bit alpha-luminance */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A4L4;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    /* A8 */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    //-------------------------- YUV formats -----------------------------------

    // UYVY
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_UYVY;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // YUY2
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_YUY2;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    //-------------------------- DXT formats -----------------------------------

    // DXT compressed texture format 1
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_DXT1;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // DXT compressed texture format 2
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_DXT2;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;


    // DXT compressed texture format 3
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_DXT3;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;


    // DXT compressed texture format 4
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_DXT4;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;


    // DXT compressed texture format 5
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_DXT5;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    //-------------------------- Bump/luminance formats / Signed formats -----------------

    // V8U8
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_V8U8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // L6V5U5
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_L6V5U5;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // X8L8V8U8
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_X8L8V8U8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // V16U16
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_V16U16;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // Q8W8V8U8
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_Q8W8V8U8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // W11V11U10
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_W11V11U10;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    //-------------- Formats introduced in DX8.1 -------------------------
#if 0
    // A8B8G8R8
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A8B8G8R8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // W10V11U11
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_W10V11U11;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // A8X8V8U8
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A8X8V8U8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // L8X8V8U8
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_L8X8V8U8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // X8B8G8R8
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_X8B8G8R8;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;
#endif

    // A2W10V10U10
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A2W10V10U10;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // A2B10G10R10
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_A2B10G10R10;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE |
        D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET |
        D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    // G16R16
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_G16R16;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_TEXTURE |
        D3DFORMAT_OP_VOLUMETEXTURE |
        D3DFORMAT_OP_CUBETEXTURE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    //-------------------------- Z/Stencil buffer formats -----------------------------------

    /* 8 bit stencil; 24 bit Z  */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_S8D24;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH |
        D3DFORMAT_OP_ZSTENCIL;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    /* 1 bit stencil; 15 bit Z */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_S1D15;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH |
        D3DFORMAT_OP_ZSTENCIL;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    /* 4 bit stencil; 24 bit Z  */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_D24X4S4;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH |
        D3DFORMAT_OP_ZSTENCIL;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    //-------------------------- Z/Stencil/texture + shadow buffer formats -----------------------------------

    // Z16S0
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_D16_LOCKABLE;
    ddsd[i].ddpfPixelFormat.dwOperations =
#if 0
// for Shadow Buffer prototype API
        D3DFORMAT_OP_TEXTURE |
#endif
        D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH |
        D3DFORMAT_OP_ZSTENCIL;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;


    // Z32S0
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_D32;
    ddsd[i].ddpfPixelFormat.dwOperations =
#if 0
// for Shadow Buffer prototype API
        D3DFORMAT_OP_TEXTURE |
#endif
        D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH |
        D3DFORMAT_OP_ZSTENCIL;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    /* 24 bit Z  */
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) D3DFMT_X8D24;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH |
        D3DFORMAT_OP_ZSTENCIL;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 0;    //not required for known formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes =
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_4_SAMPLES) |
        DDI_MULTISAMPLE_TYPE(D3DMULTISAMPLE_9_SAMPLES);
    i++;

    //
    // This is an example of a IHV-specific format
    // The HIWORD must be the PCI-ID of the IHV
    // and the third byte must be zero.
    // In this case, we're using a sample PCI-ID of
    // FF00, and we're denoting the 4th format
    // by that PCI-ID.
    //
    // In this case, we're exposing a non-standard Z-buffer format
    // that can be used as a texture and depth-stencil at
    // in the same format.(We are also choosing to
    // disallow it as valid for cubemaps and volumes.)
    //
    ddsd[i].ddpfPixelFormat.dwFlags = DDPF_D3DFORMAT;
    ddsd[i].ddpfPixelFormat.dwFourCC = (DWORD) 0xFF000004;
    ddsd[i].ddpfPixelFormat.dwOperations =
        D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH |
        D3DFORMAT_OP_ZSTENCIL |
        D3DFORMAT_OP_TEXTURE | 
        D3DFORMAT_OP_PIXELSIZE;
    ddsd[i].ddpfPixelFormat.dwPrivateFormatBitCount = 32;    // required for IHV formats
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes = 0;
    ddsd[i].ddpfPixelFormat.MultiSampleCaps.wBltMSTypes = 0;
    i++;

    *lplpddsd = ddsd;

    _ASSERT(i<=RD_MAX_NUM_TEXTURE_FORMATS, "Not enough space in static texture list");

    return i;
}

#include <d3d8sddi.h>

HRESULT WINAPI
D3D8GetSWInfo( D3DCAPS8* pCaps, PD3D8_SWCALLBACKS pCallbacks,
               DWORD* pNumTextures, DDSURFACEDESC** ppTexList )
{
#define RESPATH_D3D "Software\\Microsoft\\Direct3D"

    // First query the registry to check if we were asked to
    // emulate any particular DDI.
    g_RefDDI = RDDDI_DX8TLHAL;
    HKEY hKey = (HKEY) NULL;
    if( ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, RESPATH_D3D, &hKey) )
    {
        DWORD dwType;
        DWORD dwValue;
        DWORD dwSize = sizeof(dwValue);
        if ( ERROR_SUCCESS == RegQueryValueEx( hKey, "DriverStyle", NULL,
                                               &dwType, (LPBYTE) &dwValue,
                                               &dwSize ) &&
             dwType == REG_DWORD &&
             dwValue > 0
            )
        {
            g_RefDDI = (RDDDITYPE)dwValue;

            // NOTE: RefDev's DDI emulation is currently restricted to
            // DX8 TL and Non-TL HALs only.
            if(  g_RefDDI > RDDDI_DX8TLHAL )
            {
                DPFERR( "Bad Driver style set. Assuming DX8TLHAL" );
                g_RefDDI = RDDDI_DX8TLHAL;
            }
            if(  g_RefDDI < RDDDI_DX8HAL )
            {
                DPFERR( "Bad Driver style set. Assuming DX8HAL" );
                g_RefDDI = RDDDI_DX8HAL;
            }
        }
        RegCloseKey(hKey);
    }

    // NULL out all the callbacks first
    memset( pCallbacks, 0, sizeof(PD3D8_SWCALLBACKS) );

    // These callbacks are needed by everyone
    pCallbacks->CreateContext               = RefRastContextCreate;
    pCallbacks->ContextDestroy              = RefRastContextDestroy;
    pCallbacks->ContextDestroyAll           = NULL;
    pCallbacks->SceneCapture                = RefRastSceneCapture;
    pCallbacks->CreateSurface               = RefRastCreateSurface;
    pCallbacks->Lock                        = RefRastLock;
    pCallbacks->DestroySurface              = RefRastDestroySurface;
    pCallbacks->Unlock                      = RefRastUnlock;

    switch( g_RefDDI )
    {
    case RDDDI_DX8TLHAL:
    case RDDDI_DX8HAL:
    case RDDDI_DX7TLHAL:
    case RDDDI_DX7HAL:
        pCallbacks->GetDriverState              = RefRastGetDriverState;
        pCallbacks->CreateSurfaceEx             = RefRastCreateSurfaceEx;
        // Fall through
    case RDDDI_DP2HAL:
        pCallbacks->ValidateTextureStageState =
            RefRastValidateTextureStageState;
        pCallbacks->DrawPrimitives2           = RefRastDrawPrimitives2;
        pCallbacks->Clear2                    = NULL;
        // Fall through
    case RDDDI_DPHAL:
        pCallbacks->DrawOnePrimitive        = NULL;
        pCallbacks->DrawOneIndexedPrimitive = NULL;
        pCallbacks->DrawPrimitives          = NULL;
        pCallbacks->Clear                   = NULL;
        pCallbacks->SetRenderTarget         = RefRastSetRenderTarget;
        // Fall through
    case RDDDI_OLDHAL:
        pCallbacks->RenderState     = NULL;
        pCallbacks->RenderPrimitive = NULL;
        pCallbacks->TextureCreate   = RefRastTextureCreate;
        pCallbacks->TextureDestroy  = RefRastTextureDestroy;
        pCallbacks->TextureSwap     = NULL;
        pCallbacks->TextureGetSurf  = RefRastTextureGetSurf;
        break;
    default:
        DPFERR( "Unknown DDI style set" );
        return E_FAIL;
    }


    // Now deal with the caps
    FillOutDeviceCaps(FALSE, g_RefDDI);

    // Fill in the supported pixel format operations
    // In DX8 these operations are expressed through the texture
    // format list.
    *pNumTextures = GetRefFormatOperations( ppTexList );

    FillOutDeviceCaps8( g_RefDDI );
    ModifyDeviceCaps8();
    *pCaps = g_RefCaps8;

    return DD_OK;
}