windows-xp/Source/XPSP1/NT/multimedia/directx/dxg/d3d8/fe/ddidx8.cpp

#include "pch.cpp"
#pragma hdrstop
/*==========================================================================;
 *
 *  Copyright (C) 2000 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       ddidx8.cpp
 *  Content:    Direct3D Dx8 DDI encapsulation implementations
 *
 ***************************************************************************/
#include "d3d8p.h"
#include "ddi.h"
#include "fe.h"
#include "ddi.inl"

extern DWORD g_DebugFlags;
extern HRESULT ProcessClippedPointSprites(D3DFE_PROCESSVERTICES *pv);
extern DWORD D3DFE_GenClipFlags(D3DFE_PROCESSVERTICES *pv);
//-----------------------------------------------------------------------------
// TL stream which is read-only
//
class CTLStreamRO: public CTLStream
{
public:
    CTLStreamRO(): CTLStream(TRUE) {m_dwIndex = 0; m_bUserMemStream = FALSE;}
    void Init(CVertexBuffer* pVB, UINT primitiveBase);
    BYTE* Lock(UINT NeededSize, CD3DDDIDX6* pDDI);
    void Unlock() {}
    BOOL IsUserMemStream() {return m_bUserMemStream;}
    void AddVertices(UINT NumVertices) {}
    void SubVertices(UINT NumVertices) {}
    void MovePrimitiveBase(int NumVertices)
        {
            m_dwPrimitiveBase += NumVertices * m_dwStride;
        }
    void SkipVertices(DWORD NumVertices)
        {
            m_dwPrimitiveBase += NumVertices * m_dwStride;
        }
protected:
    BOOL m_bUserMemStream;
};
//-----------------------------------------------------------------------------
void CTLStreamRO::Init(CVertexBuffer* pVB, UINT primitiveBase)
{
    if (m_pVB)
    {
        m_pVB->DecrementUseCount();
        m_pVB = NULL;
    }
    m_pVB = pVB;
    if (pVB)
    {
        m_bUserMemStream = FALSE;
        m_pVB->IncrementUseCount();
    }
    else
    {
        m_bUserMemStream = TRUE;
    }
    m_dwPrimitiveBase = primitiveBase;
}
//-----------------------------------------------------------------------------
// Index stream which is read-only
//
class CTLIndexStreamRO: public CTLIndexStream
{
public:
    CTLIndexStreamRO() {m_dwIndex = __NUMSTREAMS;}
    void Init(CIndexBuffer* pVB, UINT primitiveBase);
    BYTE* Lock(UINT NeededSize, CD3DDDIDX6* pDDI);
    void Unlock() {}
    void AddVertices(UINT NumVertices) {}
    void SubVertices(UINT NumVertices) {}
    void MovePrimitiveBase(int NumVertices)
        {
            m_dwPrimitiveBase += NumVertices * m_dwStride;
        }
    void SkipVertices(DWORD NumVertices)
        {
            m_dwPrimitiveBase += NumVertices * m_dwStride;
        }
};
//-----------------------------------------------------------------------------
void CTLIndexStreamRO::Init(CIndexBuffer* pVB, UINT primitiveBase)
{
    if (m_pVBI)
    {
        m_pVBI->DecrementUseCount();
        m_pVBI = NULL;
    }
    m_pVBI = pVB;
    if (m_pVBI)
        m_pVBI->IncrementUseCount();
    m_dwPrimitiveBase = primitiveBase;
}
//-----------------------------------------------------------------------------
CTLStream::CTLStream(BOOL bWriteOnly)
{
    m_bWriteOnly = bWriteOnly;
    m_dwSize = 0;
    m_dwPrimitiveBase = 0;
    m_dwUsedSize = 0;
    m_dwIndex = 0;
    m_Usage = 0;
}
//-----------------------------------------------------------------------------
CTLStream::CTLStream(BOOL bWriteOnly, UINT Usage)
{
    m_bWriteOnly = bWriteOnly;
    m_dwSize = 0;
    m_dwPrimitiveBase = 0;
    m_dwUsedSize = 0;
    m_dwIndex = 0;
    m_Usage = Usage;
}
//-----------------------------------------------------------------------------
void CTLStream::Grow(UINT RequiredSize, CD3DDDIDX6* pDDI)
{
    if (RequiredSize > m_dwSize)
    {
        // We create the new vertex buffer before releasing the old one to
        // prevent creating the buffer on the same place in memory
        DWORD dwUsage = D3DUSAGE_INTERNALBUFFER | D3DUSAGE_DYNAMIC | m_Usage;
        if (m_bWriteOnly)
            dwUsage |= D3DUSAGE_WRITEONLY;
        IDirect3DVertexBuffer8 * pVB;
        HRESULT ret = CVertexBuffer::Create(pDDI->GetDevice(),
                                            RequiredSize,
                                            dwUsage,
                                            0,
                                            D3DPOOL_DEFAULT,
                                            REF_INTERNAL,
                                            &pVB);
        if (ret != DD_OK)
        {
            D3D_THROW(ret, "Could not allocate internal vertex buffer");
        }
        if (m_pVB)
            m_pVB->DecrementUseCount();
        m_pVB = static_cast<CVertexBuffer*>(pVB);
        m_dwSize = RequiredSize;
    }
}
//-----------------------------------------------------------------------------
BYTE* CTLStream::Lock(UINT NeededSize, CD3DDDIDX6* pDDI)
{
    HRESULT ret;
    DXGASSERT(m_dwSize >= m_dwUsedSize);
    if (NeededSize > m_dwSize - m_dwUsedSize || m_dwUsedSize == 0)
    {
        Grow(NeededSize, pDDI);
        ret = m_pVB->Lock(0, m_dwSize, &m_pData, D3DLOCK_DISCARD |
                                                 D3DLOCK_NOSYSLOCK);
        this->Reset();
    }
    else
    {
        ret = m_pVB->Lock(0, m_dwSize, &m_pData, D3DLOCK_NOOVERWRITE |
                                                 D3DLOCK_NOSYSLOCK);
    }
    if (ret != DD_OK)
    {
        D3D_THROW(ret, "Could not lock internal vertex buffer");
    }
    // m_dwPrimitiveBase could be out of sync with m_dwUsedSize, because
    // sometimes we re-use vertices (like when clipping line strips). Make
    // sure that they are in sync.
    m_dwPrimitiveBase = m_dwUsedSize;
    return m_pData + m_dwUsedSize;
}
//-----------------------------------------------------------------------------
void CTLStream::Unlock()
{
    m_pVB->Unlock();
}
//-----------------------------------------------------------------------------
CTLIndexStream::CTLIndexStream()
{
    m_dwSize = 0;
    m_dwPrimitiveBase = 0;
    m_dwUsedSize = 0;
    m_dwIndex = 0;
}
//-----------------------------------------------------------------------------
void CTLIndexStream::Grow(UINT RequiredSize, CD3DDDIDX6* pDDI)
{
    if (RequiredSize > m_dwSize)
    {
        // We create the new vertex buffer before releasing the old one to
        // prevent creating the buffer on the same place in memory
        DWORD dwUsage = D3DUSAGE_INTERNALBUFFER | D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC;
        IDirect3DIndexBuffer8 * pVB;
        HRESULT ret = CIndexBuffer::Create(pDDI->GetDevice(),
                                           RequiredSize,
                                           dwUsage,
                                           D3DFMT_INDEX16,
                                           D3DPOOL_DEFAULT,
                                           REF_INTERNAL,
                                           &pVB);
        if (ret != DD_OK)
        {
            D3D_THROW(ret, "Could not allocate internal index buffer");
        }
        if (m_pVBI)
            m_pVBI->DecrementUseCount();
        m_pVBI = static_cast<CIndexBuffer*>(pVB);
        m_dwSize = RequiredSize;
    }
}
//-----------------------------------------------------------------------------
BYTE* CTLIndexStream::Lock(UINT NeededSize, CD3DDDIDX6* pDDI)
{
    HRESULT ret;
    DXGASSERT(m_dwSize >= m_dwUsedSize);
    if (NeededSize > m_dwSize - m_dwUsedSize || m_dwUsedSize == 0)
    {
        Grow(NeededSize, pDDI);
        ret = m_pVBI->Lock(0, m_dwSize, &m_pData, D3DLOCK_DISCARD |
                                                  D3DLOCK_NOSYSLOCK);
        this->Reset();
    }
    else
    {
        ret = m_pVBI->Lock(0, m_dwSize, &m_pData, D3DLOCK_NOOVERWRITE |
                                                  D3DLOCK_NOSYSLOCK);
    }
    if (ret != DD_OK)
    {
        D3D_THROW(ret, "Could not lock internal index buffer");
    }
    // m_dwPrimitiveBase could be out of sync with m_dwUsedSize, because
    // sometimes we re-use vertices (like when clipping line strips). Make
    // sure that they are in sync.
    m_dwPrimitiveBase = m_dwUsedSize;
    return m_pData + m_dwUsedSize;
}
//-----------------------------------------------------------------------------
BYTE* CTLIndexStream::LockDiscard(UINT NeededSize, CD3DDDIDX6* pDDI)
{
    HRESULT ret;
    DXGASSERT(m_dwSize >= m_dwUsedSize);
    Grow(NeededSize, pDDI);
    ret = m_pVBI->Lock(0, m_dwSize, &m_pData, D3DLOCK_DISCARD |
                                              D3DLOCK_NOSYSLOCK);
    this->Reset();
    if (ret != DD_OK)
    {
        D3D_THROW(ret, "Could not lock internal index buffer");
    }
    // We have called Reset() so no need to set PrimitiveBase
    return m_pData;
}
//-----------------------------------------------------------------------------
void CTLIndexStream::Unlock()
{
    m_pVBI->Unlock();
}
//-----------------------------------------------------------------------------
BYTE* CTLStreamRO::Lock(UINT NeededSize, CD3DDDIDX6* pDDI)
{
    return m_pVB->Data();
}
//-----------------------------------------------------------------------------
BYTE* CTLIndexStreamRO::Lock(UINT NeededSize, CD3DDDIDX6* pDDI)
{
    return m_pVBI->Data();
}

/////////////////////////////////////////////////////////////////////////////
//                                                                         //
// CD3DDDIDX8                                                              //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////

const DWORD CD3DDDIDX8::m_dwDummyVertexLength = 10;
const DWORD CD3DDDIDX8::m_dwDummyVertexSize   = sizeof(D3DVERTEX);

CD3DDDIDX8::CD3DDDIDX8()
{
    m_ddiType = D3DDDITYPE_DX8;
    m_pTLStream = NULL;
    m_pTLStreamRO = NULL;
    m_pTLStreamW = NULL;
    m_pCurrentTLStream = NULL;
    m_pIndexStream = NULL;
    m_pTLStreamClip = NULL;
    m_pCurrentIndexStream = NULL;
    m_pTLIndexStreamRO = NULL;
    m_dwInterfaceNumber = 4;
    m_pvDummyArray = NULL;
}

//-----------------------------------------------------------------------------
CD3DDDIDX8::~CD3DDDIDX8()
{
    // During deletion of the objects below, the Flush could happen.
    // We have to assing pointers to NULL to prevent accessing objects
    // during the Flush.
    m_pCurrentTLStream = NULL;

    delete m_pTLStreamW;
    m_pTLStreamW = NULL;
    delete m_pTLStream;
    m_pTLStream = NULL;
    delete m_pTLStreamRO;
    m_pTLStreamRO = NULL;
    delete m_pTLIndexStreamRO;
    m_pTLIndexStreamRO = NULL;
    delete m_pIndexStream;
    m_pIndexStream = NULL;
    delete m_pTLStreamClip;
    m_pTLStreamClip = NULL;
    if (m_pvDummyArray)
    {
        delete [] m_pvDummyArray;
        m_pvDummyArray = NULL;
    }
    delete m_pPointStream;
    m_pPointStream = NULL;
    return;
}
//---------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::Init"

void
CD3DDDIDX8::Init(CD3DBase* pDevice)
{
    // CD3DDDIDX6::Init( pDevice );
    m_pDevice = pDevice;
    CreateContext();
    GrowCommandBuffer(dwD3DDefaultCommandBatchSize);

    m_pvDummyArray =
        (VOID *)new BYTE[m_dwDummyVertexSize*m_dwDummyVertexLength];
    if( m_pvDummyArray == NULL )
    {
        D3D_THROW(E_OUTOFMEMORY, "Cannot allocate dummy array");
    }

    // Fill the dp2data structure with initial values
    dp2data.dwFlags = D3DHALDP2_SWAPCOMMANDBUFFER;
    dp2data.dwVertexType = 0; // Initial assumption
    // We always pass this flag to prevent NT kernel from validation of vertex
    // buffer pointer
    dp2data.dwFlags |= D3DHALDP2_USERMEMVERTICES;
    SetDummyData();
    ClearBatch(FALSE);

    m_pTLStream = new CTLStream(FALSE);
    if (m_pTLStream == NULL)
        D3D_THROW(E_OUTOFMEMORY, "Cannot allocate internal stream m_pTLStream");
    m_pTLStreamW = new CTLStream(TRUE);
    if (m_pTLStreamW == NULL)
        D3D_THROW(E_OUTOFMEMORY, "Cannot allocate internal stream m_pTLStreamW");
    m_pTLStreamClip = new CTLStream(TRUE);
    if (m_pTLStreamClip == NULL)
        D3D_THROW(E_OUTOFMEMORY, "Cannot allocate internal stream m_pTLStreamClip");
    m_pIndexStream = new CTLIndexStream();
    if (m_pIndexStream == NULL)
        D3D_THROW(E_OUTOFMEMORY, "Cannot allocate internal stream m_pIndexStream");
    m_pTLStreamRO = new CTLStreamRO();
    if (m_pTLStreamRO == NULL)
        D3D_THROW(E_OUTOFMEMORY, "Cannot allocate internal stream m_pTLStreamRO");
    m_pTLIndexStreamRO = new CTLIndexStreamRO();
    if (m_pTLIndexStreamRO == NULL)
        D3D_THROW(E_OUTOFMEMORY, "Cannot allocate internal stream m_pTLIndexStreamRO");

    m_pTLStream->Grow(__INIT_VERTEX_NUMBER*2*sizeof(D3DTLVERTEX), this);
    m_pTLStreamW->Grow(__INIT_VERTEX_NUMBER*2*sizeof(D3DTLVERTEX), this);
    m_pTLStreamClip->Grow(__INIT_VERTEX_NUMBER*2*sizeof(D3DTLVERTEX), this);
    m_pIndexStream->Grow(__INIT_VERTEX_NUMBER*4, this);

    m_CurrentVertexShader = 0;

    m_pPointStream  = new CTLStream(FALSE);
    if (m_pPointStream == NULL)
        D3D_THROW(E_OUTOFMEMORY, "Cannot allocate internal data structure CTLStream");

#if DBG
    m_bValidateCommands = FALSE;
#endif
}

//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ValidateDevice"

void
CD3DDDIDX8::ValidateDevice(LPDWORD lpdwNumPasses)
{
    HRESULT ret;
    D3D8_VALIDATETEXTURESTAGESTATEDATA vd;
    memset( &vd, 0, sizeof( vd ) );
    vd.dwhContext = m_dwhContext;

    // First, Update textures since drivers pass /fail this call based
    // on the current texture handles
    m_pDevice->UpdateTextures();

    UpdateDirtyStreams();

    // Flush states, so we can validate the current state
    FlushStates();

    // Now ask the driver!
    ret = m_pDevice->GetHalCallbacks()->ValidateTextureStageState(&vd);
    *lpdwNumPasses = vd.dwNumPasses;

    if (ret != DDHAL_DRIVER_HANDLED)
        throw E_NOTIMPL;
    else if (FAILED(vd.ddrval))
        throw vd.ddrval;
}


//-----------------------------------------------------------------------------
// Sends "dirty" streams to the command buffer
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::UpdateDirtyStreams"

void CD3DDDIDX8::UpdateDirtyStreams()
{
    DWORD dwNumStreams = m_pDevice->m_dwNumStreams;
    if (m_pDevice->m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING)
    {
        // For software vertex processing we should update only stream 0 
        // and index stream
        dwNumStreams = 1;
    }
    for(unsigned dwStream = 0, StreamMask = 1; dwStream <= dwNumStreams; dwStream++, StreamMask <<= 1)
    {
        // When max number of vertex stream is reached, process index stream
        if (dwStream == dwNumStreams)
        {
            dwStream = __NUMSTREAMS;
            StreamMask = (1 << __NUMSTREAMS);
        }

        BOOL bDirty = (m_pDevice->m_dwStreamDirty & StreamMask) != 0;
        m_pDevice->m_dwStreamDirty &= ~StreamMask; // reset stage dirty
        CBuffer *pBuf;
        if(dwStream < dwNumStreams)
        {
            pBuf = m_pDevice->m_pStream[dwStream].m_pVB;
        }
        else
        {
            pBuf = m_pDevice->m_pIndexStream->m_pVBI;
        }
        if(pBuf != 0)
        {
            if(pBuf->IsD3DManaged())
            {
                HRESULT result;
                result = m_pDevice->ResourceManager()->UpdateVideo(pBuf->RMHandle(), &bDirty);
                if(result != D3D_OK)
                {
                    D3D_THROW(result, "Resource manager failed to create or update video memory VB/IB");
                }
            }
        }
        if (!bDirty)
        {
            continue;
        }
        if(dwStream < dwNumStreams)
        {
            InsertStreamSource(&m_pDevice->m_pStream[dwStream]);
            CDDIStream &Stream = m_pDDIStream[dwStream];
            Stream.m_pStream = &m_pDevice->m_pStream[dwStream];
            Stream.m_pBuf = pBuf;
            Stream.m_dwStride = m_pDevice->m_pStream[dwStream].m_dwStride;
        }
        else
        {
            DXGASSERT(dwStream == __NUMSTREAMS);
            InsertIndices(m_pDevice->m_pIndexStream);
            CDDIStream &Stream = m_pDDIStream[dwStream];
            Stream.m_pStream = m_pDevice->m_pIndexStream;
            Stream.m_pBuf = pBuf;
            Stream.m_dwStride = m_pDevice->m_pIndexStream->m_dwStride;
        }
    }
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::LockVB"

HRESULT __declspec(nothrow) CD3DDDIDX8::LockVB(CDriverVertexBuffer *pVB, DWORD dwFlags)
{
    HRESULT hr;
    if (pVB->GetCachedDataPointer() != 0) // if lock was cached
    {
        DXGASSERT((dwFlags & (D3DLOCK_READONLY | D3DLOCK_NOOVERWRITE)) == 0);
        DXGASSERT((pVB->GetBufferDesc()->Usage & D3DUSAGE_DYNAMIC) != 0);
        hr = pVB->UnlockI();
        if(FAILED(hr))
        {
            DPF_ERR("Driver failed to unlock a vertex buffer"
                    " when attempting to re-cache the lock.");
            pVB->SetCachedDataPointer(0);
            return hr;
        }
    }
    hr = pVB->LockI(dwFlags | D3DLOCK_NOSYSLOCK);
    if (FAILED(hr))
    {
        DPF_ERR("Driver failed to lock a vertex buffer" 
                " when attempting to cache the lock.");
        pVB->SetCachedDataPointer(0);
        return hr;
    }
    return D3D_OK;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::UnlockVB"

HRESULT __declspec(nothrow) CD3DDDIDX8::UnlockVB(CDriverVertexBuffer *pVB)
{
    return pVB->UnlockI();
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::SetTSS"

void
CD3DDDIDX8::SetTSS(DWORD dwStage,
                   D3DTEXTURESTAGESTATETYPE dwState,
                   DWORD dwValue)
{
    // Filter unsupported states
    if (dwState >= m_pDevice->m_tssMax)
        return;

    if (bDP2CurrCmdOP == D3DDP2OP_TEXTURESTAGESTATE)
    { // Last instruction is a texture stage state, append this one to it
        if (dwDP2CommandLength + sizeof(D3DHAL_DP2TEXTURESTAGESTATE) <=
            dwDP2CommandBufSize)
        {
            LPD3DHAL_DP2TEXTURESTAGESTATE lpRState =
                (LPD3DHAL_DP2TEXTURESTAGESTATE)((LPBYTE)lpvDP2Commands +
                dwDP2CommandLength + dp2data.dwCommandOffset);
            lpDP2CurrCommand->wStateCount = ++wDP2CurrCmdCnt;
            lpRState->wStage = (WORD)dwStage;
            lpRState->TSState = (WORD)dwState;
            lpRState->dwValue = dwValue;
            dwDP2CommandLength += sizeof(D3DHAL_DP2TEXTURESTAGESTATE);
            D3D_INFO(6, "Modify Ins:%08lx", *(LPDWORD)lpDP2CurrCommand);
            return;
        }
    }
    // Check for space
    if (dwDP2CommandLength + sizeof(D3DHAL_DP2COMMAND) +
        sizeof(D3DHAL_DP2TEXTURESTAGESTATE) > dwDP2CommandBufSize)
    {
            FlushStates();
    }
    // Add new renderstate instruction
    lpDP2CurrCommand = (LPD3DHAL_DP2COMMAND)((LPBYTE)lpvDP2Commands +
        dwDP2CommandLength + dp2data.dwCommandOffset);
    lpDP2CurrCommand->bCommand = D3DDP2OP_TEXTURESTAGESTATE;
    bDP2CurrCmdOP = D3DDP2OP_TEXTURESTAGESTATE;
    lpDP2CurrCommand->bReserved = 0;
    lpDP2CurrCommand->wStateCount = 1;
    wDP2CurrCmdCnt = 1;
    D3D_INFO(6, "Write Ins:%08lx", *(LPDWORD)lpDP2CurrCommand);
    // Add renderstate data
    LPD3DHAL_DP2TEXTURESTAGESTATE lpRState =
        (LPD3DHAL_DP2TEXTURESTAGESTATE)(lpDP2CurrCommand + 1);
    lpRState->wStage = (WORD)dwStage;
    lpRState->TSState = (WORD)dwState;
    lpRState->dwValue = dwValue;
    dwDP2CommandLength += sizeof(D3DHAL_DP2COMMAND) +
                          sizeof(D3DHAL_DP2TEXTURESTAGESTATE);
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::CreatePixelShader"

void
CD3DDDIDX8::CreatePixelShader(CONST DWORD* pdwFunction,
                              DWORD dwCodeSize,
                              DWORD dwHandle)
{
    FlushStates();
    LPD3DHAL_DP2CREATEPIXELSHADER pData;
    pData = (LPD3DHAL_DP2CREATEPIXELSHADER)
            GetHalBufferPointer(D3DDP2OP_CREATEPIXELSHADER,
                                sizeof(*pData) + dwCodeSize);
    pData->dwHandle = dwHandle;
    pData->dwCodeSize = dwCodeSize;
    LPBYTE p = (LPBYTE)&pData[1];
    memcpy(p, pdwFunction, dwCodeSize);
    FlushStates(TRUE,FALSE);
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::SetPixelShader"

void
CD3DDDIDX8::SetPixelShader( DWORD dwHandle )
{
    LPD3DHAL_DP2PIXELSHADER pData;
    pData = (LPD3DHAL_DP2PIXELSHADER)
            GetHalBufferPointer(D3DDP2OP_SETPIXELSHADER, sizeof(*pData));
    pData->dwHandle = dwHandle;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::DeletePixelShader"

void
CD3DDDIDX8::DeletePixelShader(DWORD dwHandle)
{
    LPD3DHAL_DP2PIXELSHADER pData;
    pData = (LPD3DHAL_DP2PIXELSHADER)
            GetHalBufferPointer(D3DDP2OP_DELETEPIXELSHADER, sizeof(*pData));
    pData->dwHandle = dwHandle;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::SetPixelShaderConstant"

void
CD3DDDIDX8::SetPixelShaderConstant(DWORD dwRegister, CONST VOID* data, 
                                   DWORD count)
{
    const DWORD size = count << 4;
    LPD3DHAL_DP2SETPIXELSHADERCONST pData;
    pData = (LPD3DHAL_DP2SETPIXELSHADERCONST)
            GetHalBufferPointer(D3DDP2OP_SETPIXELSHADERCONST,
                                sizeof(*pData) + size);
    pData->dwRegister = dwRegister;
    pData->dwCount = count;
    memcpy(pData+1, data, size);
}
//-----------------------------------------------------------------------------
// Inserts SetStreamSource command into the command buffer
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::InsertStreamSource"

void
CD3DDDIDX8::InsertStreamSource(CVStream* pStream)
{
    if (pStream->IsUserMemStream())
    {
        InsertStreamSourceUP(pStream->m_dwStride);
        return;
    }
    LPD3DHAL_DP2SETSTREAMSOURCE pData;
    pData = (LPD3DHAL_DP2SETSTREAMSOURCE)
        GetHalBufferPointer(D3DDP2OP_SETSTREAMSOURCE, sizeof(*pData));
    pData->dwStream   = pStream->m_dwIndex;
    pData->dwVBHandle = pStream->m_pVB != 0 ? pStream->m_pVB->DriverAccessibleDrawPrimHandle() : 0;
    pData->dwStride   = pStream->m_dwStride;
    CDDIStream* pDDIStream = &m_pDDIStream[pStream->m_dwIndex];
    pDDIStream->m_dwStride = pStream->m_dwStride;
    pDDIStream->m_pStream = pStream;
    pDDIStream->m_pBuf = pStream->m_pVB;
    if (pStream->m_pVB != 0)
    {
        pStream->m_pVB->Batch();
    }
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::InsertStreamSourceUP"

void
CD3DDDIDX8::InsertStreamSourceUP(DWORD dwStride)
{
    // User memory source
    LPD3DHAL_DP2SETSTREAMSOURCEUM pData;
    pData = (LPD3DHAL_DP2SETSTREAMSOURCEUM)
        GetHalBufferPointer(D3DDP2OP_SETSTREAMSOURCEUM, sizeof(*pData));
    pData->dwStream   = 0;
    pData->dwStride   = dwStride;
    CDDIStream* pDDIStream = &m_pDDIStream[0];
    pDDIStream->m_dwStride = dwStride;
    pDDIStream->m_pStream = NULL;
    pDDIStream->m_pBuf = NULL;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::InsertIndices"

void
CD3DDDIDX8::InsertIndices(CVIndexStream* pStream)
{
    LPD3DHAL_DP2SETINDICES pData;
    pData = (LPD3DHAL_DP2SETINDICES)
            GetHalBufferPointer(D3DDP2OP_SETINDICES, sizeof(*pData));
    pData->dwVBHandle = pStream->m_pVBI != 0 ? pStream->m_pVBI->DriverAccessibleDrawPrimHandle() : 0;
    pData->dwStride = pStream->m_dwStride;
    m_pDDIStream[__NUMSTREAMS].m_dwStride = pStream->m_dwStride;
    m_pDDIStream[__NUMSTREAMS].m_pStream = pStream;
    m_pDDIStream[__NUMSTREAMS].m_pBuf = pStream->m_pVBI;
    if(pStream->m_pVBI != 0)
    {
        pStream->m_pVBI->Batch();
    }
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8_DrawPrimitive"

void
CD3DDDIDX8_DrawPrimitive(CD3DBase* pDevice, D3DPRIMITIVETYPE PrimitiveType,
                         UINT StartVertex, UINT PrimitiveCount)
{
#if DBG
    if (!(pDevice->BehaviorFlags() & D3DCREATE_PUREDEVICE))
    {
        CD3DHal* pDev = static_cast<CD3DHal*>(pDevice);
        UINT nVer = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
        pDev->ValidateDraw2(PrimitiveType, StartVertex, PrimitiveCount, 
                            nVer, FALSE);
    }
#endif // DBG
    CD3DDDIDX8* pDDI = static_cast<CD3DDDIDX8*>(pDevice->m_pDDI);
    if(pDevice->m_dwRuntimeFlags & D3DRT_NEED_TEXTURE_UPDATE)
    {
        pDevice->UpdateTextures();
        pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_TEXTURE_UPDATE;
    }
    if (pDevice->m_dwRuntimeFlags & D3DRT_NEED_VB_UPDATE)
    {
        pDDI->UpdateDirtyStreams();
        pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_VB_UPDATE;
    }
    if (pDDI->bDP2CurrCmdOP == D3DDP2OP_DRAWPRIMITIVE)
    { // Last instruction is a DrawPrimitive, append this one to it
        //
        // First check if the new instruction is a TRIANGLELIST. If it is,
        // AND if the new StartVertex = prev StartVertex + prev PrimitiveCount * 3
        // then we can simply bump up the prev primitive count. This makes
        // drivers go a LOT faster. (snene - 12/00)
        //
        
        //!!!!!!!!!!!!!!!!!!!!!!!!!!ALERT!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        // The following code READS BACK from the batched command. This is
        // NOT a problem for sysmem command buffers in DX8. However, going
        // forward, if we ever implement vidmem command buffers, we need
        // to FIX this code to not read back. (snene - 12/00)
        LPD3DHAL_DP2DRAWPRIMITIVE pData = (LPD3DHAL_DP2DRAWPRIMITIVE)
            ((LPBYTE)pDDI->lpvDP2Commands + pDDI->dwDP2CommandLength - sizeof(D3DHAL_DP2DRAWPRIMITIVE) +
            pDDI->dp2data.dwCommandOffset);
        if(pData->primType == D3DPT_TRIANGLELIST && 
           pData->primType == PrimitiveType && 
           pData->VStart + pData->PrimitiveCount * 3 == StartVertex &&
           pData->PrimitiveCount + PrimitiveCount >= pData->PrimitiveCount) // overflow
        {
            pData->PrimitiveCount += PrimitiveCount;
            return;
        }                
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

        if (pDDI->dwDP2CommandLength + sizeof(D3DHAL_DP2DRAWPRIMITIVE) <=
            pDDI->dwDP2CommandBufSize)
        {
            ++pData;
            pDDI->lpDP2CurrCommand->wStateCount = ++pDDI->wDP2CurrCmdCnt;
            pData->primType = PrimitiveType;
            pData->VStart = StartVertex;
            pData->PrimitiveCount = PrimitiveCount;
            pDDI->dwDP2CommandLength += sizeof(D3DHAL_DP2DRAWPRIMITIVE);
            D3D_INFO(6, "Modify Ins:%08lx", *(LPDWORD)pDDI->lpDP2CurrCommand);
            return;
        }
    }
    // Check for space
    if (pDDI->dwDP2CommandLength + sizeof(D3DHAL_DP2COMMAND) +
        sizeof(D3DHAL_DP2DRAWPRIMITIVE) > pDDI->dwDP2CommandBufSize)
    {
        pDDI->FlushStates();
    }
    // Add new DrawPrimitive instruction
    pDDI->lpDP2CurrCommand = (LPD3DHAL_DP2COMMAND)((LPBYTE)pDDI->lpvDP2Commands +
        pDDI->dwDP2CommandLength + pDDI->dp2data.dwCommandOffset);
    pDDI->lpDP2CurrCommand->bCommand = D3DDP2OP_DRAWPRIMITIVE;
    pDDI->bDP2CurrCmdOP = D3DDP2OP_DRAWPRIMITIVE;
    pDDI->lpDP2CurrCommand->bReserved = 0;
    pDDI->lpDP2CurrCommand->wStateCount = 1;
    pDDI->wDP2CurrCmdCnt = 1;
    D3D_INFO(6, "Write Ins:%08lx", *(LPDWORD)pDDI->lpDP2CurrCommand);
    // Add DrawPrimitive data
    LPD3DHAL_DP2DRAWPRIMITIVE pData;
    pData = (LPD3DHAL_DP2DRAWPRIMITIVE)(pDDI->lpDP2CurrCommand + 1);
    pData->primType = PrimitiveType;
    pData->VStart = StartVertex;
    pData->PrimitiveCount = PrimitiveCount;
    pDDI->dwDP2CommandLength += sizeof(D3DHAL_DP2COMMAND) +
                                sizeof(D3DHAL_DP2DRAWPRIMITIVE);
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::SetDummyData"

void
CD3DDDIDX8::SetDummyData()
{
    dp2data.dwVertexSize   = m_dwDummyVertexSize;
    dp2data.lpVertices     = m_pvDummyArray;
    dp2data.dwVertexLength = m_dwDummyVertexLength;
}

//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8_DrawIndexedPrimitive"

void
CD3DDDIDX8_DrawIndexedPrimitive(CD3DBase* pDevice,
                                D3DPRIMITIVETYPE PrimitiveType,
                                UINT BaseVertexIndex,
                                UINT MinIndex, UINT NumVertices,
                                UINT StartIndex, UINT PrimitiveCount)
{
#if DBG
    if (!(pDevice->BehaviorFlags() & D3DCREATE_PUREDEVICE))
    {
        CD3DHal* pDev = static_cast<CD3DHal*>(pDevice);
        pDev->ValidateDraw2(PrimitiveType, MinIndex + BaseVertexIndex,
                            PrimitiveCount, NumVertices, TRUE, StartIndex);
    }
#endif // DBG
    CD3DDDIDX8* pDDI = static_cast<CD3DDDIDX8*>(pDevice->m_pDDI);
    if(pDevice->m_dwRuntimeFlags & D3DRT_NEED_TEXTURE_UPDATE)
    {
        pDevice->UpdateTextures();
        pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_TEXTURE_UPDATE;
    }
    if (pDevice->m_dwRuntimeFlags & D3DRT_NEED_VB_UPDATE)
    {
        pDDI->UpdateDirtyStreams();
        pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_VB_UPDATE;
    }
    if (pDDI->bDP2CurrCmdOP == D3DDP2OP_DRAWINDEXEDPRIMITIVE)
    { // Last instruction is a DrawIndexedPrimitive, append this one to it
        //
        // First check if the new instruction is a TRIANGLELIST. If it is,
        // AND if the new StartIndex = prev StartIndex + prev PrimitiveCount * 3
        // AND if the new BaseVertexIndex = prev BaseVertexIndex
        // then we can simply bump up the prev primitive count. This makes
        // drivers go a LOT faster. (snene - 12/00)
        //
        
        //!!!!!!!!!!!!!!!!!!!!!!!!!!ALERT!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        // The following code READS BACK from the batched command. This is
        // NOT a problem for sysmem command buffers in DX8. However, going
        // forward, if we ever implement vidmem command buffers, we need
        // to FIX this code to not read back. (snene - 12/00)
        LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE pData = (LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE)
            ((LPBYTE)pDDI->lpvDP2Commands + pDDI->dwDP2CommandLength - sizeof(D3DHAL_DP2DRAWINDEXEDPRIMITIVE) +
            pDDI->dp2data.dwCommandOffset);
        if(pData->primType == D3DPT_TRIANGLELIST && 
           pData->primType == PrimitiveType && 
           pData->BaseVertexIndex == BaseVertexIndex &&
           pData->StartIndex + pData->PrimitiveCount * 3 == StartIndex &&
           pData->PrimitiveCount + PrimitiveCount >= pData->PrimitiveCount) // overflow
        {
            UINT mnidx = min(pData->MinIndex, MinIndex);
            UINT mxidx = max(pData->MinIndex + pData->NumVertices, MinIndex + NumVertices);
            if(mxidx - mnidx <= pData->NumVertices + NumVertices)
            {
                pData->NumVertices = mxidx - mnidx;
                pData->MinIndex = mnidx;
                pData->PrimitiveCount += PrimitiveCount;
                return;
            }
        }                
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

        if (pDDI->dwDP2CommandLength + sizeof(D3DHAL_DP2DRAWINDEXEDPRIMITIVE) <=
            pDDI->dwDP2CommandBufSize)
        {
            ++pData;
            pDDI->lpDP2CurrCommand->wStateCount = ++pDDI->wDP2CurrCmdCnt;
            pData->BaseVertexIndex = BaseVertexIndex;
            pData->primType = PrimitiveType;
            pData->PrimitiveCount = PrimitiveCount;
            pData->MinIndex = MinIndex;
            pData->NumVertices = NumVertices;
            pData->StartIndex = StartIndex;
            pDDI->dwDP2CommandLength += sizeof(D3DHAL_DP2DRAWINDEXEDPRIMITIVE);
            D3D_INFO(6, "Modify Ins:%08lx", *(LPDWORD)pDDI->lpDP2CurrCommand);
            return;
        }
    }
    // Check for space
    if (pDDI->dwDP2CommandLength + sizeof(D3DHAL_DP2COMMAND) +
        sizeof(D3DHAL_DP2DRAWINDEXEDPRIMITIVE) > pDDI->dwDP2CommandBufSize)
    {
        pDDI->FlushStates();
    }
    // Add new DrawIndexedPrimitive instruction
    pDDI->lpDP2CurrCommand = (LPD3DHAL_DP2COMMAND)((LPBYTE)pDDI->lpvDP2Commands +
        pDDI->dwDP2CommandLength + pDDI->dp2data.dwCommandOffset);
    pDDI->lpDP2CurrCommand->bCommand = D3DDP2OP_DRAWINDEXEDPRIMITIVE;
    pDDI->bDP2CurrCmdOP = D3DDP2OP_DRAWINDEXEDPRIMITIVE;
    pDDI->lpDP2CurrCommand->bReserved = 0;
    pDDI->lpDP2CurrCommand->wStateCount = 1;
    pDDI->wDP2CurrCmdCnt = 1;
    D3D_INFO(6, "Write Ins:%08lx", *(LPDWORD)pDDI->lpDP2CurrCommand);
    // Add DrawIndexedPrimitive data
    LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE pData;
    pData = (LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE)(pDDI->lpDP2CurrCommand + 1);
    pData->BaseVertexIndex = BaseVertexIndex;
    pData->primType = PrimitiveType;
    pData->PrimitiveCount = PrimitiveCount;
    pData->MinIndex = MinIndex;
    pData->NumVertices = NumVertices;
    pData->StartIndex = StartIndex;
    pDDI->dwDP2CommandLength += sizeof(D3DHAL_DP2COMMAND) +
                                sizeof(D3DHAL_DP2DRAWINDEXEDPRIMITIVE);

#if DBG
//    if (m_bValidateCommands)
//        ValidateCommand(lpDP2CurrCommand);
#endif
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::DrawPrimitiveUP"

void
CD3DDDIDX8::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount)
{
    UINT NumVertices = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
    if (NumVertices > LOWVERTICESNUMBER)
    {
        if (m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_VB_UPDATE)
        {
            UpdateDirtyStreams();
            m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_VB_UPDATE;
        }
        this->FlushStates();
        dp2data.dwVertexType = 0;
        dp2data.dwVertexSize = m_pDevice->m_pStream[0].m_dwStride;
        dp2data.lpVertices = m_pDevice->m_pStream[0].m_pData;
        dp2data.dwVertexLength = NumVertices;
        try
        {
            InsertStreamSourceUP(m_pDevice->m_pStream[0].m_dwStride);
            CD3DDDIDX8_DrawPrimitive(m_pDevice, PrimitiveType, 0, PrimitiveCount);
            this->FlushStates();
        }
        catch( HRESULT hr )
        {
            SetDummyData();
            throw hr;
        }
        SetDummyData();
    }
    else
    {
        // Copy vertices to the internal TL buffer

        UINT VertexSize = m_pDevice->m_pStream[0].m_dwStride;
        // When vertex size has been changed we need to start from the 
        // beginning of the vertex buffer to correctly handle vertex offsets
        if (m_pTLStreamW->GetPrimitiveBase() % VertexSize)
        {
            this->FlushStates();
            m_pTLStreamW->Reset();
        }

        // Copy vertices into the internal write only buffer
        m_pTLStreamW->SetVertexSize(VertexSize);
        UINT VertexPoolSize = VertexSize * NumVertices;
        LPVOID lpvOut = m_pTLStreamW->Lock(VertexPoolSize, this);
        UINT StartVertex = m_pTLStreamW->GetPrimitiveBase() / VertexSize;
        memcpy(lpvOut, m_pDevice->m_pStream[0].m_pData, VertexPoolSize);
        m_pTLStreamW->Unlock();
        m_pTLStreamW->SkipVertices(NumVertices);

        // To prevent overriding of stream 0 we clear D3DRT_NEED_VB_UPDATE and
        // stream dirty bit. We need to clear the stream dirty bit, because during
        // UpdateTextures D3DRT_NEED_VB_UPDATE could be set again
        DWORD dwRuntimeFlags = m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_VB_UPDATE;
        m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_VB_UPDATE;
        m_pDevice->m_dwStreamDirty &= ~1;

        if (m_pDDIStream[0].m_pBuf != m_pTLStreamW->m_pVB || 
            m_pDDIStream[0].m_dwStride != m_pTLStreamW->m_dwStride)
        {
            InsertStreamSource(m_pTLStreamW);
        }

#if DBG
        // Need this to pass validation
        m_pDevice->m_pStream[0].m_dwNumVertices = StartVertex + NumVertices;
#endif
        // Insert drawing command
        CD3DDDIDX8_DrawPrimitive(m_pDevice, PrimitiveType, StartVertex, PrimitiveCount);

        m_pDevice->m_dwRuntimeFlags |= dwRuntimeFlags;
    }
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::DrawIndexedPrimitiveUP"

void
CD3DDDIDX8::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,
                                  UINT MinVertexIndex,
                                  UINT NumVertices,
                                  UINT PrimitiveCount)
{
    if (NumVertices > LOWVERTICESNUMBER)
    {
        if (m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_VB_UPDATE)
        {
            UpdateDirtyStreams();
            m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_VB_UPDATE;
        }
        this->FlushStates();
        dp2data.dwVertexType = 0;
        dp2data.dwVertexSize = m_pDevice->m_pStream[0].m_dwStride;
        dp2data.lpVertices = m_pDevice->m_pStream[0].m_pData;
        dp2data.dwVertexLength = NumVertices;
        try
        {
            InsertStreamSourceUP(m_pDevice->m_pStream[0].m_dwStride);

            UINT NumIndices = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
            m_pIndexStream->SetVertexSize(m_pDevice->m_pIndexStream->m_dwStride);
            // Always start from the beginning of the index stream
            // Copy indices into the internal stream
            DWORD dwIndicesByteCount = NumIndices * m_pIndexStream->m_dwStride;
            BYTE* pIndexData = m_pIndexStream->LockDiscard(dwIndicesByteCount, this);
            memcpy(pIndexData, m_pDevice->m_pIndexStream->m_pData, dwIndicesByteCount);
            m_pIndexStream->Unlock();

            InsertIndices(m_pIndexStream);

            CD3DDDIDX8_DrawIndexedPrimitive(m_pDevice, PrimitiveType, 0,
                                            MinVertexIndex, NumVertices, 0,
                                            PrimitiveCount);
            this->FlushStates();
        }
        catch( HRESULT hr )
        {
            SetDummyData();
            throw hr;
        }
        SetDummyData();
    }
    else
    {
        // Copy user data into internal buffers
        
        UINT VertexSize = m_pDevice->m_pStream[0].m_dwStride;
        UINT IndexSize = m_pDevice->m_pIndexStream->m_dwStride;
        if ((m_pTLStreamW->GetPrimitiveBase() % VertexSize) ||
            (m_pIndexStream->GetPrimitiveBase() % IndexSize))
        {
            this->FlushStates();
            m_pTLStreamW->Reset();
            m_pIndexStream->Reset();
        }

        // Copy vertices into the internal write only buffer
        m_pTLStreamW->SetVertexSize(VertexSize);
        UINT VertexPoolSize = VertexSize * NumVertices;
        LPVOID lpvOut = m_pTLStreamW->Lock(VertexPoolSize, this);
        UINT StartVertex = m_pTLStreamW->GetPrimitiveBase() / VertexSize;
        UINT FirstVertexOffset = MinVertexIndex * VertexSize;
        memcpy(lpvOut, m_pDevice->m_pStream[0].m_pData + FirstVertexOffset, 
               VertexPoolSize);
        m_pTLStreamW->Unlock();
        m_pTLStreamW->SkipVertices(NumVertices);

        // To prevent overriding of stream 0 we clear D3DRT_NEED_VB_UPDATE and
        // stream dirty bit. We need to clear the stream dirty bit, because during
        // UpdateTextures D3DRT_NEED_VB_UPDATE could be set again
        DWORD dwRuntimeFlags = m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_VB_UPDATE;
        m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_VB_UPDATE;
        m_pDevice->m_dwStreamDirty &= ~(1 | (1 << __NUMSTREAMS));

        if (m_pDDIStream[0].m_pBuf != m_pTLStreamW->m_pVB || 
            m_pDDIStream[0].m_dwStride != m_pTLStreamW->m_dwStride)
        {
            InsertStreamSource(m_pTLStreamW);
        }

        // Copy indices into the internal buffer. Re-base indices if necessery.
        m_pIndexStream->SetVertexSize(IndexSize);
        UINT NumIndices = GETVERTEXCOUNT(PrimitiveType, PrimitiveCount);
        UINT IndexPoolSize = IndexSize * NumIndices;
        lpvOut = m_pIndexStream->Lock(IndexPoolSize, this);
        UINT StartIndex = m_pIndexStream->GetPrimitiveBase() / IndexSize;
        memcpy(lpvOut, m_pDevice->m_pIndexStream->m_pData, IndexPoolSize);
        m_pIndexStream->Unlock();
        m_pIndexStream->SkipVertices(NumIndices);

        if (m_pDDIStream[__NUMSTREAMS].m_pBuf != m_pIndexStream->m_pVBI || 
            m_pDDIStream[__NUMSTREAMS].m_dwStride != m_pIndexStream->m_dwStride)
        {
            InsertIndices(m_pIndexStream);
        }

#if DBG
        // Need this to pass validation
        m_pDevice->m_pStream[0].m_dwNumVertices = StartVertex + NumVertices;
        m_pDevice->m_pIndexStream->m_dwNumVertices = StartIndex + NumIndices;
#endif
        // Draw primitive
        CD3DDDIDX8_DrawIndexedPrimitive(m_pDevice, PrimitiveType, 
                                        StartVertex - MinVertexIndex,
                                        MinVertexIndex, NumVertices, StartIndex, 
                                        PrimitiveCount);

        m_pDevice->m_dwRuntimeFlags |= dwRuntimeFlags;
    }
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::DrawRectPatch"

void
CD3DDDIDX8::DrawRectPatch(UINT Handle, CONST D3DRECTPATCH_INFO *pSurf, 
                          CONST FLOAT *pNumSegs)
{
    if(m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_TEXTURE_UPDATE)
    {
        m_pDevice->UpdateTextures();
        m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_TEXTURE_UPDATE;
    }
    if (m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_VB_UPDATE)
    {
        UpdateDirtyStreams();
        m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_VB_UPDATE;
    }
    LPD3DHAL_DP2DRAWRECTPATCH pData;
    pData = (LPD3DHAL_DP2DRAWRECTPATCH)
            GetHalBufferPointer(D3DDP2OP_DRAWRECTPATCH,
                                sizeof(*pData) + (pSurf != 0 ? sizeof(D3DRECTPATCH_INFO) : 0) + (pNumSegs != 0 ? sizeof(FLOAT) * 4 : 0));
    pData->Handle = Handle;
    DWORD offset;
    if(pNumSegs != 0)
    {
        offset = sizeof(FLOAT) * 4;
        memcpy(pData + 1, pNumSegs, offset);
        pData->Flags = RTPATCHFLAG_HASSEGS;
    }
    else
    {
        pData->Flags = 0;
        offset = 0;
    }
    if(pSurf != 0)
    {
        memcpy((BYTE*)(pData + 1) + offset, pSurf, sizeof(D3DRECTPATCH_INFO));
        pData->Flags |= RTPATCHFLAG_HASINFO;
    }
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::DrawTriSurface"

void
CD3DDDIDX8::DrawTriPatch(UINT Handle, CONST D3DTRIPATCH_INFO *pSurf, 
                         CONST FLOAT *pNumSegs)
{
    if(m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_TEXTURE_UPDATE)
    {
        m_pDevice->UpdateTextures();
        m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_TEXTURE_UPDATE;
    }
    if (m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_VB_UPDATE)
    {
        UpdateDirtyStreams();
        m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_VB_UPDATE;
    }
    LPD3DHAL_DP2DRAWTRIPATCH pData;
    pData = (LPD3DHAL_DP2DRAWTRIPATCH)
            GetHalBufferPointer(D3DDP2OP_DRAWTRIPATCH,
                                sizeof(*pData) + (pSurf != 0 ? sizeof(D3DTRIPATCH_INFO) : 0) + (pNumSegs != 0 ? sizeof(FLOAT) * 3 : 0));
    pData->Handle = Handle;
    DWORD offset;
    if(pNumSegs != 0)
    {
        offset = sizeof(FLOAT) * 3;
        memcpy(pData + 1, pNumSegs, offset);
        pData->Flags = RTPATCHFLAG_HASSEGS;
    }
    else
    {
        pData->Flags = 0;
        offset = 0;
    }
    if(pSurf != 0)
    {
        memcpy((BYTE*)(pData + 1) + offset, pSurf, sizeof(D3DTRIPATCH_INFO));
        pData->Flags |= RTPATCHFLAG_HASINFO;
    }
}
//-----------------------------------------------------------------------------
// This function prepares the batch for new primitive.
// Called only if vertices from user memory are NOT used for rendering
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::StartPrimVB"

void
CD3DDDIDX8::StartPrimVB(D3DFE_PROCESSVERTICES * pv, CVStream* pStream,
                        DWORD dwStartVertex)
{
    SetWithinPrimitive(TRUE);
    UINT size = dwStartVertex * pv->dwOutputSize;
    if (pStream)
        m_pTLStreamRO->Init(pStream->m_pVB, size);
    else
        m_pTLStreamRO->Init(NULL, size);
    m_pTLStreamRO->SetVertexSize(pv->dwOutputSize);
    m_pCurrentTLStream = m_pTLStreamRO;
}
//-----------------------------------------------------------------------------
// This function prepares the batch for new primitive.
// Called only if vertices from user memory are NOT used for rendering
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::StartIndexPrimVB"

void
CD3DDDIDX8::StartIndexPrimVB(CVIndexStream* pStream, UINT StartIndex,
                             UINT IndexSize)
{
    m_pTLIndexStreamRO->Init(pStream->m_pVBI, StartIndex * IndexSize);
    m_pTLIndexStreamRO->SetVertexSize(IndexSize);
    m_pCurrentIndexStream = m_pTLIndexStreamRO;
}
//-----------------------------------------------------------------------------
// This function prepares the batch for new primitive.
// Called when the runtime needs to output vertices to a TL buffer
// TL buffer grows if necessary
//
// Uses the following global variables:
//      pv->dwOutputSize
//     Sets "within primitive" to TRUE
// Returns:
//      TL buffer address
//
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::StartPrimTL"

LPVOID
CD3DDDIDX8::StartPrimTL(D3DFE_PROCESSVERTICES * pv, DWORD dwVertexPoolSize,
                        BOOL bWriteOnly)
{
    CTLStream* pStream = bWriteOnly? m_pTLStreamW : m_pTLStream;
    LPVOID p = pStream->Lock(dwVertexPoolSize, this);
    pStream->SetVertexSize(pv->dwOutputSize);
    m_pCurrentTLStream = pStream;
    SetWithinPrimitive(TRUE);
    return p;
}
//---------------------------------------------------------------------
// Uses the following members of D3DFE_PROCESSVERTICES:
//      primType
//      dwNumVertices
//      dwNumPrimitives
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::DrawPrim"

void
CD3DDDIDX8::DrawPrim(D3DFE_PROCESSVERTICES* pv)
{
#ifdef DEBUG_PIPELINE
    if (g_DebugFlags & __DEBUG_NORENDERING)
        return;
#endif

    if(m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_TEXTURE_UPDATE)
    {
        m_pDevice->UpdateTextures();
        m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_TEXTURE_UPDATE;
    }
    if (m_pDDIStream[0].m_pBuf != static_cast<CBuffer*>(m_pCurrentTLStream->m_pVB) ||
        pv->dwOutputSize != m_pDDIStream[0].m_dwStride)
    {
        InsertStreamSource(m_pCurrentTLStream);
        // API stream should be set dirty, in case it is later passed to DDI directly
        m_pDevice->m_dwStreamDirty |= 1;
        m_pDevice->m_dwRuntimeFlags |= D3DRT_NEED_VB_UPDATE;
    }
    if (pv->primType == D3DPT_POINTLIST &&
        pv->dwDeviceFlags & D3DDEV_DOPOINTSPRITEEMULATION)
    {
        DrawPrimPS(pv);
        return;
    }
    LPD3DHAL_DP2DRAWPRIMITIVE2 pData;
    pData = (LPD3DHAL_DP2DRAWPRIMITIVE2)
            GetHalBufferPointer(D3DDP2OP_DRAWPRIMITIVE2, sizeof(*pData));
    pData->primType = pv->primType;
    pData->FirstVertexOffset = m_pCurrentTLStream->GetPrimitiveBase();
    pData->PrimitiveCount = pv->dwNumPrimitives;

    m_pCurrentTLStream->SkipVertices(pv->dwNumVertices);

#if DBG
    if (m_bValidateCommands)
        ValidateCommand(lpDP2CurrCommand);
#endif
}
//---------------------------------------------------------------------
//
// The vertices are already in the vertex buffer.
//
// Uses the following members of D3DFE_PROCESSVERTICES:
//      primType
//      dwNumVertices
//      dwNumPrimitives
//      dwNumIndices
//      dwIndexSize
//      lpwIndices
//

#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::DrawIndexPrim"

void
CD3DDDIDX8::DrawIndexPrim(D3DFE_PROCESSVERTICES* pv)
{
#ifdef DEBUG_PIPELINE
    if (g_DebugFlags & __DEBUG_NORENDERING)
        return;
#endif
    this->dwDP2Flags |= D3DDDI_INDEXEDPRIMDRAWN;
    if (m_pCurrentIndexStream == m_pIndexStream)
    {
        // We always copy user provided indices to the internal index stream.
        // Therefore we have to check the available stream size and do Lock/Unlock
        DWORD dwIndicesByteCount = pv->dwNumIndices * pv->dwIndexSize;
        // We cannot mix DWORD and WORD indices because of alignment issues 
        // on ia64
        if (m_pIndexStream->GetVertexSize() != pv->dwIndexSize)
        {
            this->FlushStates();
            m_pIndexStream->Reset();
            m_pIndexStream->SetVertexSize(pv->dwIndexSize);
        }
        BYTE* pIndexData = m_pIndexStream->Lock(dwIndicesByteCount, this);
        memcpy(pIndexData, pv->lpwIndices, dwIndicesByteCount);
        m_pIndexStream->Unlock();
    }
    if (m_pCurrentIndexStream->m_pVBI->IsD3DManaged())
    {
        if (m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_VB_UPDATE)
        {
            BOOL bDirty = FALSE;
            HRESULT result = m_pDevice->ResourceManager()->UpdateVideo(m_pCurrentIndexStream->m_pVBI->RMHandle(), &bDirty);
            if(result != D3D_OK)
            {
                D3D_THROW(result, "Resource manager failed to create or update video memory IB");
            }
            if((m_pDevice->m_dwStreamDirty & (1 << __NUMSTREAMS)) != 0 || bDirty)
            {
                InsertIndices(m_pCurrentIndexStream);
                CDDIStream &Stream = m_pDDIStream[__NUMSTREAMS];
                Stream.m_pStream = m_pCurrentIndexStream;
                Stream.m_pBuf = m_pCurrentIndexStream->m_pVBI;
                Stream.m_dwStride = m_pCurrentIndexStream->m_dwStride;
                m_pDevice->m_dwStreamDirty &= ~(1 << __NUMSTREAMS); // reset stage dirty
            }
            m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_VB_UPDATE;
        }
    }
    else
    {
        if (m_pDDIStream[__NUMSTREAMS].m_pBuf != static_cast<CBuffer*>(m_pCurrentIndexStream->m_pVBI) ||
            pv->dwIndexSize != m_pDDIStream[__NUMSTREAMS].m_dwStride)
        {
            m_pCurrentIndexStream->SetVertexSize(pv->dwIndexSize);
            InsertIndices(m_pCurrentIndexStream);
            // API stream should be set dirty, in case it is later passed to DDI directly
            m_pDevice->m_dwStreamDirty |= (1 << __NUMSTREAMS);
            m_pDevice->m_dwRuntimeFlags |= D3DRT_NEED_VB_UPDATE;  // Need to call UpdateDirtyStreams()
        }
    }
    if(m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_TEXTURE_UPDATE)
    {
        m_pDevice->UpdateTextures();
        m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_TEXTURE_UPDATE;
    }

    if (m_pDDIStream[0].m_pBuf != static_cast<CBuffer*>(m_pCurrentTLStream->m_pVB) ||
        pv->dwOutputSize != m_pDDIStream[0].m_dwStride)
    {
        m_pDDIStream[0].m_dwStride = pv->dwOutputSize;
        InsertStreamSource(m_pCurrentTLStream);
        // API stream should be set dirty, in case it is later passed to DDI directly
        m_pDevice->m_dwStreamDirty |= 1;
        m_pDevice->m_dwRuntimeFlags |= D3DRT_NEED_VB_UPDATE;  // Need to call UpdateDirtyStreams()
    }

    LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE2 pData;
    pData = (LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE2)
            GetHalBufferPointer(D3DDP2OP_DRAWINDEXEDPRIMITIVE2, sizeof(*pData));
    pData->primType = pv->primType;
    pData->BaseVertexOffset = m_BaseVertexIndex;
    pData->MinIndex = m_MinVertexIndex;
    pData->NumVertices = m_NumVertices;
    pData->StartIndexOffset = m_pCurrentIndexStream->GetPrimitiveBase();
    pData->PrimitiveCount = pv->dwNumPrimitives;

    m_pCurrentIndexStream->SkipVertices(pv->dwNumIndices);

}
//-----------------------------------------------------------------------------
// This primitive is generated by the clipper.
// The vertices of this primitive are pointed to by the
// lpvOut member, which need to be copied into the
// command stream immediately after the command itself.
//
// Uses the following members of D3DFE_PROCESSVERTICES:
//      primType
//      dwNumVertices
//      dwNumPrimitives
//      dwOutputSize
//      dwFlags (D3DPV_NONCLIPPED)
//      lpdwRStates (FILLMODE)
//      lpvOut
//      ClipperState.current_vbuf
//

#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::DrawClippedPrim"

void
CD3DDDIDX8::DrawClippedPrim(D3DFE_PROCESSVERTICES* pv)
{
#ifdef DEBUG_PIPELINE
    if (g_DebugFlags & __DEBUG_NORENDERING)
        return;
#endif
    if (m_pDDIStream[0].m_pBuf != static_cast<CBuffer*>(m_pTLStreamClip->m_pVB) ||
        pv->dwOutputSize != m_pDDIStream[0].m_dwStride)
    {
        m_pTLStreamClip->SetVertexSize(pv->dwOutputSize);
        InsertStreamSource(m_pTLStreamClip);
        // API stream should be set dirty, in case it is later passed to DDI directly
        m_pDevice->m_dwStreamDirty |= 1;
        m_pDevice->m_dwRuntimeFlags |= D3DRT_NEED_VB_UPDATE;  // Need to call UpdateDirtyStreams()
    }
    if(m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_TEXTURE_UPDATE)
    {
        m_pDevice->UpdateTextures();
        m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_TEXTURE_UPDATE;
    }
    DWORD dwVertexPoolSize = pv->dwNumVertices * pv->dwOutputSize;
    LPVOID pVertices;
    if (pv->primType == D3DPT_TRIANGLEFAN)
    {
        if (pv->lpdwRStates[D3DRENDERSTATE_FILLMODE] == D3DFILL_WIREFRAME &&
            pv->dwFlags & D3DPV_NONCLIPPED)
        {
            // For unclipped (but pretended to be clipped) tri fans in
            // wireframe mode we generate 3-vertex tri fans to enable drawing
            // of interior edges
            BYTE vertices[__MAX_VERTEX_SIZE*3];
            BYTE *pV1 = vertices + pv->dwOutputSize;
            BYTE *pV2 = pV1 + pv->dwOutputSize;
            BYTE *pInput = (BYTE*)pv->lpvOut;
            memcpy(vertices, pInput, pv->dwOutputSize);
            pInput += pv->dwOutputSize;
            const DWORD nTriangles = pv->dwNumVertices - 2;
            pv->dwNumVertices = 3;
            pv->dwNumPrimitives = 1;
            pv->lpvOut = vertices;
            // Remove this flag for recursive call
            pv->dwFlags &= ~D3DPV_NONCLIPPED;
            for (DWORD i = nTriangles; i; i--)
            {
                memcpy(pV1, pInput, pv->dwOutputSize);
                memcpy(pV2, pInput + pv->dwOutputSize, pv->dwOutputSize);
                pInput += pv->dwOutputSize;
                // To enable all edge flag we set the fill mode to SOLID.
                // This will prevent checking the clip flags in the clipper
                // state
                pv->lpdwRStates[D3DRENDERSTATE_FILLMODE] = D3DFILL_SOLID;
                DrawClippedPrim(pv);
                pv->lpdwRStates[D3DRENDERSTATE_FILLMODE] = D3DFILL_WIREFRAME;
            }
            return;
        }
        // Lock should be before GetPrimitiveBase(), because the primitive
        // base could be changed during Lock()
        pVertices = m_pTLStreamClip->Lock(dwVertexPoolSize, this);
        LPD3DHAL_CLIPPEDTRIANGLEFAN pData;
        pData = (LPD3DHAL_CLIPPEDTRIANGLEFAN)
                GetHalBufferPointer(D3DDP2OP_CLIPPEDTRIANGLEFAN, sizeof(*pData));
        pData->FirstVertexOffset = m_pTLStreamClip->GetPrimitiveBase();
        pData->PrimitiveCount = pv->dwNumPrimitives;
        if (pv->lpdwRStates[D3DRENDERSTATE_FILLMODE] != D3DFILL_WIREFRAME)
        {
            // Mark all exterior edges visible
            pData->dwEdgeFlags = 0xFFFFFFFF;
        }
        else
        {
            pData->dwEdgeFlags = 0;
            ClipVertex **clip = pv->ClipperState.current_vbuf;
            // Look at the exterior edges and mark the visible ones
            for(DWORD i = 0; i < pv->dwNumVertices; ++i)
            {
                if (clip[i]->clip & CLIPPED_ENABLE)
                    pData->dwEdgeFlags |= (1 << i);
            }
        }
    }
    else
    {
        // Lock should be before GetPrimitiveBase(), because the primitive
        // base could be changed during Lock()
        pVertices = m_pTLStreamClip->Lock(dwVertexPoolSize, this);
#if DBG
        if (pv->primType != D3DPT_LINELIST)
        {
            D3D_THROW_FAIL("Internal error - invalid primitive type");
        }
#endif
        LPD3DHAL_DP2DRAWPRIMITIVE2 pData;
        pData = (LPD3DHAL_DP2DRAWPRIMITIVE2)
                GetHalBufferPointer(D3DDP2OP_DRAWPRIMITIVE2, sizeof(*pData));
        pData->primType = D3DPT_LINELIST;
        pData->FirstVertexOffset = m_pTLStreamClip->GetPrimitiveBase();
        pData->PrimitiveCount = pv->dwNumPrimitives;
    }

    // Copy vertices to the clipped stream
    memcpy(pVertices, pv->lpvOut, dwVertexPoolSize);
    m_pTLStreamClip->Unlock();
    m_pTLStreamClip->SkipVertices(pv->dwNumVertices);

#if DBG
    if (m_bValidateCommands)
        ValidateCommand(lpDP2CurrCommand);
#endif
}
//-----------------------------------------------------------------------------
// This function is called whe software vertex processing is used
// Handle should be always legacy
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::SetVertexShader"

void
CD3DDDIDX8::SetVertexShader( DWORD dwHandle )
{
    DXGASSERT(D3DVSD_ISLEGACY(dwHandle));

    if (dwHandle != m_CurrentVertexShader)
    {
        m_CurrentVertexShader = dwHandle;
        LPD3DHAL_DP2VERTEXSHADER pData;
        pData = (LPD3DHAL_DP2VERTEXSHADER)
                GetHalBufferPointer(D3DDP2OP_SETVERTEXSHADER, sizeof(*pData));
        {
            // Drivers do not need to know about D3DFVF_LASTBETA_UBYTE4 bit
            dwHandle &= ~D3DFVF_LASTBETA_UBYTE4;
        }
        pData->dwHandle = dwHandle;
    }
}
//-----------------------------------------------------------------------------
// This function is called whe hardware vertex processing is used
// Redundant shader check has been done at the API level
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::SetVertexShaderHW"

void
CD3DDDIDX8::SetVertexShaderHW( DWORD dwHandle )
{
    m_CurrentVertexShader = dwHandle;
    LPD3DHAL_DP2VERTEXSHADER pData;
    pData = (LPD3DHAL_DP2VERTEXSHADER)
            GetHalBufferPointer(D3DDP2OP_SETVERTEXSHADER, sizeof(*pData));
    if( D3DVSD_ISLEGACY(dwHandle) )
    {
        // Drivers do not need to know about D3DFVF_LASTBETA_UBYTE4 bit
        dwHandle &= ~D3DFVF_LASTBETA_UBYTE4;
    }
    pData->dwHandle = dwHandle;
}
//-----------------------------------------------------------------------------
// Point sprites are drawn as indexed triangle list
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::StartPointSprites"

void CD3DDDIDX8::StartPointSprites()
{
    D3DFE_PROCESSVERTICES* pv = static_cast<CD3DHal*>(m_pDevice)->m_pv;
    
    // For StartPrimTL we should use vertex size, which will go to the driver
    DWORD tmpVertexSize = pv->dwOutputSize;
    pv->dwOutputSize = m_dwOutputSizePS;

    // Set new output vertex shader for the DDI
    SetVertexShader(m_dwVIDOutPS);
    
    // Reserve place for the output vertices
    const UINT size = NUM_SPRITES_IN_BATCH * 4 * pv->dwOutputSize;
    m_pCurSpriteVertex = (BYTE*)StartPrimTL(pv, size, TRUE);

    // Restore vertex size, which is size before point sprite emulation
    pv->dwOutputSize = tmpVertexSize;

    // Index stream used to hold indices
    m_pCurrentIndexStream = m_pIndexStream;
    pv->dwIndexSize = 2;
    // Reserve place for indices
    UINT count = NUM_SPRITES_IN_BATCH * 2 * 6;
    m_pCurPointSpriteIndex = (WORD*)m_pIndexStream->Lock(count, this);

    m_CurNumberOfSprites = 0;
    SetWithinPrimitive(TRUE);
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::EndPointSprites"

void CD3DDDIDX8::EndPointSprites()
{
    D3DFE_PROCESSVERTICES* pv = static_cast<CD3DHal*>(m_pDevice)->m_pv;
    m_pCurrentIndexStream->Unlock();
    m_pCurrentTLStream->Unlock();
    if (m_CurNumberOfSprites)
    {
        if (m_pDDIStream[__NUMSTREAMS].m_pBuf != static_cast<CBuffer*>(m_pCurrentIndexStream->m_pVBI) ||
            pv->dwIndexSize != m_pDDIStream[__NUMSTREAMS].m_dwStride)
        {
            m_pCurrentIndexStream->SetVertexSize(pv->dwIndexSize);
            InsertIndices(m_pCurrentIndexStream);
        }
        if (m_pDDIStream[0].m_pBuf != static_cast<CBuffer*>(m_pCurrentTLStream->m_pVB) ||
            m_dwOutputSizePS != m_pDDIStream[0].m_dwStride)
        {
            InsertStreamSource(m_pCurrentTLStream);
        }
        if(m_pDevice->m_dwRuntimeFlags & D3DRT_NEED_TEXTURE_UPDATE)
        {
            m_pDevice->UpdateTextures();
            m_pDevice->m_dwRuntimeFlags &= ~D3DRT_NEED_TEXTURE_UPDATE;
        }
        UINT NumVertices = m_CurNumberOfSprites * 4;
        LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE2 pData;
        pData = (LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE2)
                GetHalBufferPointer(D3DDP2OP_DRAWINDEXEDPRIMITIVE2, sizeof(*pData));
        pData->primType = D3DPT_TRIANGLELIST;
        pData->BaseVertexOffset = m_pCurrentTLStream->GetPrimitiveBase();
        pData->MinIndex = 0;
        pData->NumVertices = NumVertices;
        pData->StartIndexOffset = m_pCurrentIndexStream->GetPrimitiveBase();
        pData->PrimitiveCount = m_CurNumberOfSprites * 2;

        m_pCurrentIndexStream->SkipVertices(m_CurNumberOfSprites * 6);
        m_pCurrentTLStream->SkipVertices(NumVertices);

        m_CurNumberOfSprites = 0;
    }
    SetWithinPrimitive(FALSE);
}

/////////////////////////////////////////////////////////////////////////////
//                                                                         //
// CD3DDDIDX8TL                                                            //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////

CD3DDDIDX8TL::CD3DDDIDX8TL()
{
    m_ddiType = D3DDDITYPE_DX8TL;
    m_dwInterfaceNumber = 4;
}

//-----------------------------------------------------------------------------
CD3DDDIDX8TL::~CD3DDDIDX8TL()
{
    return;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::CreateVertexShader"

void
CD3DDDIDX8TL::CreateVertexShader(CONST DWORD* pdwDeclaration,
                                 DWORD dwDeclSize,
                                 CONST DWORD* pdwFunction,
                                 DWORD dwCodeSize,
                                 DWORD dwHandle,
                                 BOOL bLegacyFVF)
{
    FlushStates();
    LPD3DHAL_DP2CREATEVERTEXSHADER pData;
    pData = (LPD3DHAL_DP2CREATEVERTEXSHADER)
            GetHalBufferPointer(D3DDP2OP_CREATEVERTEXSHADER,
                                sizeof(*pData) + dwDeclSize + dwCodeSize);
    pData->dwHandle = dwHandle;
    pData->dwDeclSize = dwDeclSize;
    pData->dwCodeSize = dwCodeSize;
    LPBYTE p = (LPBYTE)&pData[1];
    memcpy(p, pdwDeclaration, dwDeclSize);
    if (pdwFunction)
    {
        p += dwDeclSize;
        memcpy(p, pdwFunction, dwCodeSize);
    }
    FlushStates();
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::DeleteVertexShader"

void
CD3DDDIDX8TL::DeleteVertexShader(DWORD dwHandle)
{
    if (dwHandle == m_CurrentVertexShader)
        m_CurrentVertexShader = 0;
    LPD3DHAL_DP2VERTEXSHADER pData;
    pData = (LPD3DHAL_DP2VERTEXSHADER)
            GetHalBufferPointer(D3DDP2OP_DELETEVERTEXSHADER, sizeof(*pData));
    pData->dwHandle = dwHandle;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::SetVertexShaderConstant"

void
CD3DDDIDX8TL::SetVertexShaderConstant(DWORD dwRegister, CONST VOID* data, DWORD count)
{
    const DWORD size = count << 4;
    LPD3DHAL_DP2SETVERTEXSHADERCONST pData;
    pData = (LPD3DHAL_DP2SETVERTEXSHADERCONST)
            GetHalBufferPointer(D3DDP2OP_SETVERTEXSHADERCONST,
                                sizeof(*pData) + size);
    pData->dwRegister = dwRegister;
    pData->dwCount = count;
    memcpy(pData+1, data, size);
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::MultiplyTransform"

void
CD3DDDIDX8TL::MultiplyTransform(D3DTRANSFORMSTATETYPE state, CONST D3DMATRIX* lpMat)
{
    // Send down the state and the matrix
    LPD3DHAL_DP2MULTIPLYTRANSFORM pData;
    pData = (LPD3DHAL_DP2MULTIPLYTRANSFORM)
            GetHalBufferPointer(D3DDP2OP_MULTIPLYTRANSFORM, sizeof(*pData));
    pData->xfrmType = state;
    pData->matrix = *lpMat;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::SetTransform"

void
CD3DDDIDX8TL::SetTransform(D3DTRANSFORMSTATETYPE state, CONST D3DMATRIX* lpMat)
{
    // Send down the state and the matrix
    LPD3DHAL_DP2SETTRANSFORM pData;
    pData = (LPD3DHAL_DP2SETTRANSFORM)
            GetHalBufferPointer(D3DDP2OP_SETTRANSFORM, sizeof(*pData));
    pData->xfrmType = state;
    pData->matrix = *lpMat;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::SetViewport"

void
CD3DDDIDX8TL::SetViewport(CONST D3DVIEWPORT8* lpVwpData)
{
    // Update viewport size
    CD3DDDIDX6::SetViewport(lpVwpData);

    // Update Z range
    LPD3DHAL_DP2ZRANGE pData;
    pData = (LPD3DHAL_DP2ZRANGE)GetHalBufferPointer(D3DDP2OP_ZRANGE, sizeof(*pData));
    pData->dvMinZ = lpVwpData->MinZ;
    pData->dvMaxZ = lpVwpData->MaxZ;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::SetMaterial"

void
CD3DDDIDX8TL::SetMaterial(CONST D3DMATERIAL8* pMat)
{
    LPD3DHAL_DP2SETMATERIAL pData;
    pData = (LPD3DHAL_DP2SETMATERIAL)GetHalBufferPointer(D3DDP2OP_SETMATERIAL, sizeof(*pData));
    *pData = *((LPD3DHAL_DP2SETMATERIAL)pMat);
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::SetLight"

void
CD3DDDIDX8TL::SetLight(DWORD dwLightIndex, CONST D3DLIGHT8* pLight)
{
    LPD3DHAL_DP2SETLIGHT pData;
    pData = (LPD3DHAL_DP2SETLIGHT)
            GetHalBufferPointer(D3DDP2OP_SETLIGHT,
                                sizeof(*pData) + sizeof(D3DLIGHT8));
    pData->dwIndex = dwLightIndex;
    pData->dwDataType = D3DHAL_SETLIGHT_DATA;
    D3DLIGHT8 UNALIGNED64 * p = (D3DLIGHT8 UNALIGNED64 *)((LPBYTE)pData + sizeof(D3DHAL_DP2SETLIGHT));
    *p = *pLight;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::CreateLight"

void
CD3DDDIDX8TL::CreateLight(DWORD dwLightIndex)
{
    LPD3DHAL_DP2CREATELIGHT pData;
    pData = (LPD3DHAL_DP2CREATELIGHT)GetHalBufferPointer(D3DDP2OP_CREATELIGHT, sizeof(*pData));
    pData->dwIndex = dwLightIndex;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::LightEnable"

void
CD3DDDIDX8TL::LightEnable(DWORD dwLightIndex, BOOL bEnable)
{
    LPD3DHAL_DP2SETLIGHT pData;
    pData = (LPD3DHAL_DP2SETLIGHT)GetHalBufferPointer(D3DDP2OP_SETLIGHT, sizeof(*pData));
    pData->dwIndex = dwLightIndex;
    if (bEnable)
        pData->dwDataType = D3DHAL_SETLIGHT_ENABLE;
    else
        pData->dwDataType = D3DHAL_SETLIGHT_DISABLE;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8TL::SetClipPlane"

void
CD3DDDIDX8TL::SetClipPlane(DWORD dwPlaneIndex, CONST D3DVALUE* pPlaneEquation)
{
    LPD3DHAL_DP2SETCLIPPLANE pData;
    pData = (LPD3DHAL_DP2SETCLIPPLANE)
            GetHalBufferPointer(D3DDP2OP_SETCLIPPLANE, sizeof(*pData));
    pData->dwIndex = dwPlaneIndex;
    pData->plane[0] = pPlaneEquation[0];
    pData->plane[1] = pPlaneEquation[1];
    pData->plane[2] = pPlaneEquation[2];
    pData->plane[3] = pPlaneEquation[3];
}
//---------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ClearBatch"

void
CD3DDDIDX8::ClearBatch(BOOL bWithinPrimitive)
{
    // Reset command buffer
    lpDP2CurrCommand = (LPD3DHAL_DP2COMMAND)lpvDP2Commands;
    dwDP2CommandLength = 0;
    dp2data.dwCommandOffset = 0;
    dp2data.dwCommandLength = 0;
    bDP2CurrCmdOP = 0;
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::FlushStates"

void
CD3DDDIDX8::FlushStates(BOOL bReturnDriverError, BOOL bWithinPrimitive)
{
    HRESULT dwRet=D3D_OK;
    if (m_bWithinPrimitive)
        bWithinPrimitive = TRUE;
    if (dwDP2CommandLength) // Do we have some instructions to flush ?
    {
        m_pDevice->IncrementBatchCount();

        // Batch currently set VB streams
        CDDIStream* pStream = m_pDDIStream;
        for (UINT i=0; i < __NUMSTREAMS; i++)
        {
            if (pStream->m_pStream)
            {
                CVStream* p = static_cast<CVStream*>(pStream->m_pStream);
                CVertexBuffer* pVB = p->m_pVB;
                if (pVB)
                    pVB->Batch();
            }
            pStream++;
        }
        // Now pStream points to the index stream
        if (pStream->m_pStream)
        {
            CVIndexStream* p = static_cast<CVIndexStream*>(pStream->m_pStream);
            CIndexBuffer* pVB = p->m_pVBI;
            if (pVB)
                pVB->Batch();
        }
        // Save since it will get overwritten by ddrval after DDI call
        DWORD dwVertexSize = dp2data.dwVertexSize;

        dp2data.dwCommandLength = dwDP2CommandLength;
        //we clear this to break re-entering as SW rasterizer needs to lock DDRAWSURFACE
        dwDP2CommandLength = 0;
        // Try and set these 2 values only once during initialization
        dp2data.dwhContext = m_dwhContext;
        dp2data.lpdwRStates = (LPDWORD)lpwDPBuffer;

        // Spin waiting on the driver if wait requested
        do {
            // Need to set this since the driver may have overwrote it by
            // setting ddrval = DDERR_WASSTILLDRAWING
            dp2data.dwVertexSize = dwVertexSize;
            dwRet = m_pDevice->GetHalCallbacks()->DrawPrimitives2(&dp2data);
            if (dwRet != DDHAL_DRIVER_HANDLED)
            {
                D3D_ERR ( "Driver not handled in DrawPrimitives2" );
                // Need sensible return value in this case,
                // currently we return whatever the driver stuck in here.
            }
        } while (dp2data.ddrval == DDERR_WASSTILLDRAWING);

        dwRet= dp2data.ddrval;
        // update command buffer pointer
        if ((dwRet == D3D_OK) &&
            (dp2data.dwFlags & D3DHALDP2_SWAPCOMMANDBUFFER))
        {
            // Implement VidMem command buffer and
            // command buffer swapping.
        }

        // Restore to value before the DDI call
        dp2data.dwVertexSize = dwVertexSize;
        ClearBatch(bWithinPrimitive);
    }
    // There are situations when the command stream has no data,
    // but there is data in the vertex pool. This could happen, for instance
    // if every triangle got rejected while clipping. In this case we still
    // need to "Flush out" the vertex data.
    else if (dp2data.dwCommandLength == 0)
    {
        ClearBatch(bWithinPrimitive);
    }

    if( FAILED( dwRet ) )
    {
        ClearBatch(FALSE);
        if( !bReturnDriverError )
        {
            switch( dwRet )
            {
            case D3DERR_OUTOFVIDEOMEMORY:
                D3D_ERR("Driver out of video memory!");
                break;
            case D3DERR_COMMAND_UNPARSED:
                D3D_ERR("Driver could not parse this batch!");
                break;
            default:
                D3D_ERR("Driver returned error: %s", HrToStr(dwRet));
                break;
            }
            DPF_ERR("Driver failed command batch. Attempting to reset device"
                    " state. The device may now be in an unstable state and"
                    " the application may experience an access violation.");
        }
        else
        {
            throw dwRet;
        }
    }
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ProcessPointSprites"

void CD3DDDIDX8::PickProcessPrimitive()
{
    D3DFE_PROCESSVERTICES* pv = static_cast<CD3DHal*>(m_pDevice)->m_pv;
    if (pv->dwDeviceFlags & D3DDEV_DOPOINTSPRITEEMULATION)
    {
        m_pfnProcessPrimitive = ProcessPointSprites;
    }
    else
    if (pv->dwDeviceFlags & D3DDEV_TRANSFORMEDFVF)
    {
        m_pfnProcessPrimitive =
            static_cast<PFN_PROCESSPRIM>(ProcessPrimitiveT);
        m_pfnProcessIndexedPrimitive =
            static_cast<PFN_PROCESSPRIM>(ProcessIndexedPrimitiveT);
    }
    else
    if (pv->dwDeviceFlags & D3DDEV_DONOTCLIP)
    {
        m_pfnProcessPrimitive =
            static_cast<PFN_PROCESSPRIM>(ProcessPrimitive);
        m_pfnProcessIndexedPrimitive =
            static_cast<PFN_PROCESSPRIM>(ProcessIndexedPrimitive);
    }
    else
    {
        m_pfnProcessPrimitive =
            static_cast<PFN_PROCESSPRIM>(ProcessPrimitiveC);
        m_pfnProcessIndexedPrimitive =
            static_cast<PFN_PROCESSPRIM>(ProcessIndexedPrimitiveC);
    }
}
//-----------------------------------------------------------------------------
// Processes non-indexed primitives with untransformed vertices and without
// clipping
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ProcessPrimitive"

void
CD3DDDIDX8::ProcessPrimitive(D3DFE_PROCESSVERTICES* pv, UINT StartVertex)
{
    DXGASSERT((pv->dwVIDIn & D3DFVF_POSITION_MASK) != D3DFVF_XYZRHW);

    CD3DHal* pDevice = static_cast<CD3DHal*>(m_pDevice);

    if (pDevice->dwFEFlags & D3DFE_FRONTEND_DIRTY)
        DoUpdateState(pDevice);

    pv->lpvOut = StartPrimTL(pv, pv->dwNumVertices * pv->dwOutputSize, TRUE);
    HRESULT ret = pv->pGeometryFuncs->ProcessVertices(pv);
    if (ret != D3D_OK)
    {
        SetWithinPrimitive(FALSE);
        m_pCurrentTLStream->Unlock();
        D3D_THROW(ret, "Error in PSGP");
    }
    DrawPrim(pv);
    SetWithinPrimitive(FALSE);
    m_pCurrentTLStream->Unlock();
}
//-----------------------------------------------------------------------------
// Processes non-indexed primitives with untransformed vertices and with
// clipping
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ProcessPrimitiveC"

void
CD3DDDIDX8::ProcessPrimitiveC(D3DFE_PROCESSVERTICES* pv, UINT StartVertex)
{
    DXGASSERT((pv->dwVIDIn & D3DFVF_POSITION_MASK) != D3DFVF_XYZRHW);

    CD3DHal* pDevice = static_cast<CD3DHal*>(m_pDevice);

    // Update lighting and related flags
    if (pDevice->dwFEFlags & D3DFE_FRONTEND_DIRTY)
        DoUpdateState(pDevice);

    PrepareForClipping(pv, 0);
    pv->lpvOut = StartPrimTL(pv, pv->dwNumVertices * pv->dwOutputSize, 
                             NeverReadFromTLBuffer(pv));
    // When a triangle strip is clipped, we draw indexed primitives
    // sometimes. This is why we need to initialize the index stream
    m_BaseVertexIndex = m_pCurrentTLStream->GetPrimitiveBase();
    m_pCurrentIndexStream = m_pIndexStream;

    HRESULT ret;
    if (pv->primType == D3DPT_POINTLIST)
    {
        // When all points are clipped by X or Y planes we do not throw
        // them away, because they could have point size and be visible
        ret = D3D_OK;
        DWORD clipIntersection = pv->pGeometryFuncs->ProcessVertices(pv);
        clipIntersection &= ~(D3DCS_LEFT | D3DCS_RIGHT | 
                              D3DCS_TOP | D3DCS_BOTTOM |
                              __D3DCLIPGB_ALL);
        if (!clipIntersection)
        {
            // There are some vertices inside the screen
            if (pv->dwClipUnion == 0)
                DrawPrim(pv);
            else
                ret = ProcessClippedPointSprites(pv);
        }
    }
    else
    {
        ret = pv->pGeometryFuncs->ProcessPrimitive(pv);
    }
    if (ret != D3D_OK)
    {
        SetWithinPrimitive(FALSE);
        m_pCurrentTLStream->Unlock();
        D3D_THROW(ret, "Error in PSGP");
    }
    SetWithinPrimitive(FALSE);
    m_pCurrentTLStream->Unlock();
    UpdateClipStatus(pDevice);
}
//-----------------------------------------------------------------------------
// Processes non-indexed primitives with transformed vertices with clipping
//
// Only transformed vertices generated by ProcessVertices call are allowed here
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ProcessPrimitiveT"

void
CD3DDDIDX8::ProcessPrimitiveT(D3DFE_PROCESSVERTICES* pv, UINT StartVertex)
{
    DXGASSERT((pv->dwVIDIn & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW);
    // Clipping must be enabled when we are here
    DXGASSERT((pv->dwDeviceFlags & D3DDEV_DONOTCLIP) == 0);

    BOOL bNoClipping = FALSE;

    pv->dwOutputSize = m_pDevice->m_pStream[0].m_dwStride;

    // We need to do special processing for point sprites - they should not be
    // clipped as points without size.
    if (m_pDevice->m_dwRuntimeFlags & D3DRT_POINTSIZEPRESENT &&
        pv->primType == D3DPT_POINTLIST)
    {
        // This function is called only if a device supports point sprites.
        // Otherwise DrawPoints() function should be called.
        DXGASSERT((pv->dwDeviceFlags & D3DDEV_DOPOINTSPRITEEMULATION) == 0);

        PrepareForClipping(pv, StartVertex);

        if (!(pv->dwDeviceFlags & D3DDEV_VBPROCVER))
        {
            // Set emulation flag, because we want to compute clipping code as
            // for point sprites
            pv->dwDeviceFlags |= D3DDEV_DOPOINTSPRITEEMULATION;
            // Compute clip codes, because there was no ProcessVertices
            DWORD clip_intersect = D3DFE_GenClipFlags(pv);
            UpdateClipStatus(static_cast<CD3DHal*>(m_pDevice));
            pv->dwDeviceFlags &= ~D3DDEV_DOPOINTSPRITEEMULATION;
            if (clip_intersect)
            {
                return;
            }
        }
        // There are some vertices inside the screen. We need to do clipping if
        // a result of ProcessVertices is used as input (clip union is unknown)
        // or clipping is needed based on clip union and guard band flags.
        if (pv->dwDeviceFlags & D3DDEV_VBPROCVER || CheckIfNeedClipping(pv))
        {
            // Set emulation flag, because clipped points should be expanded,
            // not regected. We will clip point sprites by viewport during
            // the expansion.
            pv->dwDeviceFlags |= D3DDEV_DOPOINTSPRITEEMULATION;

            // This will prevent computing clip codes second time.
            pv->dwDeviceFlags |= D3DDEV_VBPROCVER | D3DDEV_DONOTCOMPUTECLIPCODES;

            // Now we can call a function which will take care of point sprite
            // expansion, clipping, culling mode etc.
            ProcessPointSprites(pv, StartVertex);

            pv->dwDeviceFlags &= ~(D3DDEV_DOPOINTSPRITEEMULATION |
                                   D3DDEV_VBPROCVER |
                                   D3DDEV_DONOTCOMPUTECLIPCODES);
            return;
        }
        // We are here when all point centres are inside guard band. We can 
        // draw them as points without clipping, because device supports point
        // sprites.
        bNoClipping = TRUE;
    }

    if (m_pDevice->m_dwRuntimeFlags & D3DRT_USERMEMPRIMITIVE)
    {
        DXGASSERT(StartVertex == 0);
        // Copy vertices to the TL buffer
        UINT VertexPoolSize = pv->dwOutputSize * pv->dwNumVertices;
        pv->lpvOut = (BYTE*)StartPrimTL(pv, VertexPoolSize, FALSE);
        pv->position.lpvData = pv->lpvOut;
        memcpy(pv->lpvOut, m_pDevice->m_pStream[0].m_pData, VertexPoolSize);
    }
    else
        StartPrimVB(pv, &m_pDevice->m_pStream[0], StartVertex);

    if (bNoClipping)
    {
        DrawPrim(pv);
        goto l_exit;
    }

    PrepareForClipping(pv, StartVertex);

    CD3DHal* pDevice = static_cast<CD3DHal*>(m_pDevice);
    pv->dwVIDOut = pv->dwVIDIn;
    pv->dwIndexOffset = 0;
    pv->lpvOut = pv->position.lpvData;

    if (!(pv->dwDeviceFlags & D3DDEV_VBPROCVER))
    {
        pv->dwFlags |= D3DPV_TLVCLIP;
        // Compute clip codes, because there was no ProcessVertices
        DWORD clip_intersect = D3DFE_GenClipFlags(pv);
        UpdateClipStatus(pDevice);
        if (clip_intersect)
            goto l_exit;
    }
    // When a triangle strip is clipped, we draw indexed primitives
    // sometimes.
    m_BaseVertexIndex = 0;
    HRESULT ret = pDevice->GeometryFuncsGuaranteed->DoDrawPrimitive(pv);
    if (ret != D3D_OK)
        throw ret;
l_exit:
    pv->dwFlags &= ~D3DPV_TLVCLIP;
    SetWithinPrimitive(FALSE);
    if (m_pDevice->m_dwRuntimeFlags & D3DRT_USERMEMPRIMITIVE)
    {
        m_pCurrentTLStream->Unlock();
    }
    else
    {
        // If DDI vertex stream has been set to the internal stream during 
        // clipping, we need to restore the original stream
        if (m_pDDIStream[0].m_pBuf != m_pDevice->m_pStream[0].m_pVB)
        {
            m_pDevice->m_dwStreamDirty |= 1;
            m_pDevice->m_dwRuntimeFlags |= D3DRT_NEED_VB_UPDATE;  // Need to call UpdateDirtyStreams()
        }
    }
    pv->dwFlags &= ~D3DPV_TLVCLIP;
}
//-----------------------------------------------------------------------------
// Processes indexed primitives with untransformed vertices and without
// clipping
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ProcessIndexedPrimitive"

void
CD3DDDIDX8::ProcessIndexedPrimitive(D3DFE_PROCESSVERTICES* pv, UINT StartVertex)
{
    DXGASSERT((pv->dwVIDIn & D3DFVF_POSITION_MASK) != D3DFVF_XYZRHW);

    CD3DHal* pDevice = static_cast<CD3DHal*>(m_pDevice);

    // Update lighting and related flags
    if (pDevice->dwFEFlags & D3DFE_FRONTEND_DIRTY)
        DoUpdateState(pDevice);

    pv->lpvOut = StartPrimTL(pv, pv->dwNumVertices * pv->dwOutputSize, TRUE);

    HRESULT ret = pv->pGeometryFuncs->ProcessVertices(pv);
    if (ret != D3D_OK)
    {
        SetWithinPrimitive(FALSE);
        m_pCurrentTLStream->Unlock();
        D3D_THROW(ret, "Error in PSGP");
    }

    if (pDevice->m_pIndexStream->m_pVBI)
        StartIndexPrimVB(pDevice->m_pIndexStream, m_StartIndex,
                         pv->dwIndexSize);
    else
        m_pCurrentIndexStream = m_pIndexStream;
    // Let the driver map indices to be relative to the start of
    // the processed vertices
    m_BaseVertexIndex = m_pCurrentTLStream->GetPrimitiveBase() -
                          m_MinVertexIndex * pv->dwOutputSize;
    DrawIndexPrim(pv);
    m_pCurrentTLStream->SkipVertices(pv->dwNumVertices);
    SetWithinPrimitive(FALSE);
    m_pCurrentTLStream->Unlock();
}


//-----------------------------------------------------------------------------
// Processes indexed primitives with untransformed vertices and with
// clipping
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ProcessIndexedPrimitiveC"

void
CD3DDDIDX8::ProcessIndexedPrimitiveC(D3DFE_PROCESSVERTICES* pv, UINT StartVertex)
{
    DXGASSERT((pv->dwVIDIn & D3DFVF_POSITION_MASK) != D3DFVF_XYZRHW);

    CD3DHal* pDevice = static_cast<CD3DHal*>(m_pDevice);

    // Update lighting and related flags
    if (pDevice->dwFEFlags & D3DFE_FRONTEND_DIRTY)
        DoUpdateState(pDevice);

    pv->lpwIndices = (WORD*)(pDevice->m_pIndexStream->Data() +
                     m_StartIndex * pDevice->m_pIndexStream->m_dwStride);

    PrepareForClipping(pv, 0);

    pv->lpvOut = StartPrimTL(pv, pv->dwNumVertices * pv->dwOutputSize, FALSE);
    m_BaseVertexIndex = m_pCurrentTLStream->GetPrimitiveBase() -
                          m_MinVertexIndex * pv->dwOutputSize;

    pv->dwIndexOffset = m_MinVertexIndex;   // Needed for clipping
    m_pCurrentIndexStream = m_pIndexStream;

    this->dwDP2Flags &= ~D3DDDI_INDEXEDPRIMDRAWN;
    m_pCurrentTLStream->AddVertices(pv->dwNumVertices);
    DWORD NumVertices = pv->dwNumVertices;

    HRESULT ret = pv->pGeometryFuncs->ProcessIndexedPrimitive(pv);

    if (this->dwDP2Flags & D3DDDI_INDEXEDPRIMDRAWN)
        m_pCurrentTLStream->MovePrimitiveBase(NumVertices);
    else
        m_pCurrentTLStream->SubVertices(NumVertices);

    SetWithinPrimitive(FALSE);
    m_pCurrentTLStream->Unlock();
    UpdateClipStatus(pDevice);

    if (ret != D3D_OK)
    {
        D3D_THROW(ret, "Error in PSGP");
    }
}
//-----------------------------------------------------------------------------
// Processes indexed primitives with transformed vertices and with clipping
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ProcessIndexedPrimitiveT"

void
CD3DDDIDX8::ProcessIndexedPrimitiveT(D3DFE_PROCESSVERTICES* pv, UINT StartVertex)
{
    DXGASSERT((pv->dwVIDIn & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW);
    // Clipping must be enabled when we are here
    DXGASSERT((pv->dwDeviceFlags & D3DDEV_DONOTCLIP) == 0);

    CD3DHal* pDevice = static_cast<CD3DHal*>(m_pDevice);

    pv->dwOutputSize = m_pDevice->m_pStream[0].m_dwStride;

    if (m_pDevice->m_dwRuntimeFlags & D3DRT_USERMEMPRIMITIVE)
    {
        // We copy user vertices, starting from MinVertexIndex, to the internal
        // TL buffer and do the clipping. Vertex base changes in the process.

        // m_NumVertices has been computed as MinVertexIndex + NumVertices, so 
        // it needs to be adjusted, because vertex base has benn changed
        m_NumVertices -= m_MinVertexIndex;
        pv->dwNumVertices = m_NumVertices;
        // Copy vertices to the TL buffer
        UINT VertexPoolSize = pv->dwOutputSize * pv->dwNumVertices;
        pv->lpvOut = (BYTE*)StartPrimTL(pv, VertexPoolSize, FALSE);
        pv->position.lpvData = pv->lpvOut;
        memcpy(pv->lpvOut, 
               m_pDevice->m_pStream[0].m_pData + m_MinVertexIndex * pv->dwOutputSize, 
               VertexPoolSize);
        // We need to adjust m_BaseVertexIndex, bacause we do not want to 
        // re-compute indices for the new vertex base
        m_BaseVertexIndex = m_pCurrentTLStream->GetPrimitiveBase() - 
                            m_MinVertexIndex * pv->dwOutputSize;
        m_pCurrentTLStream->AddVertices(pv->dwNumVertices);        

        // During clipping we need to adjust indices by m_MinVertexIndex
        pv->dwIndexOffset = m_MinVertexIndex;

        pv->lpwIndices = (WORD*)(pDevice->m_pIndexStream->Data());
    }
    else
    {
        StartPrimVB(pv, &m_pDevice->m_pStream[0], StartVertex);
        m_BaseVertexIndex = pDevice->m_pIndexStream->m_dwBaseIndex *
                            pv->dwOutputSize;
        pv->dwIndexOffset = m_MinVertexIndex;   // For clipping
        pv->lpwIndices = (WORD*)(pDevice->m_pIndexStream->Data() +
                         m_StartIndex * pDevice->m_pIndexStream->m_dwStride);
    }

    PrepareForClipping(pv, StartVertex);
    if (!(pv->dwDeviceFlags & D3DDEV_VBPROCVER))
    {
        pv->dwFlags |= D3DPV_TLVCLIP;
        // Compute clip codes, because there was no ProcessVertices
        DWORD clip_intersect = D3DFE_GenClipFlags(pv);
        UpdateClipStatus(pDevice);
        if (clip_intersect)
            goto l_exit;
    }
    pv->dwVIDOut = pv->dwVIDIn;
    pv->lpvOut = pv->position.lpvData;
    m_pCurrentIndexStream = m_pIndexStream;

    HRESULT ret;
    ret = pDevice->GeometryFuncsGuaranteed->DoDrawIndexedPrimitive(pv);
    if (ret != D3D_OK)
        throw ret;
l_exit:
    SetWithinPrimitive(FALSE);
    if (m_pDevice->m_dwRuntimeFlags & D3DRT_USERMEMPRIMITIVE)
    {
        m_pCurrentTLStream->Unlock();
        m_pCurrentTLStream->MovePrimitiveBase(pv->dwNumVertices);        
    }
    else
    {
        // If DDI vertex stream has been set to the internal stream during 
        // clipping, we need to restore the original stream
        if (m_pDDIStream[0].m_pBuf != m_pDevice->m_pStream[0].m_pVB)
        {
            m_pDevice->m_dwStreamDirty |= 1;
            m_pDevice->m_dwRuntimeFlags |= D3DRT_NEED_VB_UPDATE;  // Need to call UpdateDirtyStreams()
        }
        // If DDI index stream has been set to the internal stream during 
        // clipping, we need to restore the original stream
        if (m_pDDIStream[__NUMSTREAMS].m_pBuf != m_pDevice->m_pIndexStream->m_pVBI)
        {
            m_pDevice->m_dwStreamDirty |= (1 << __NUMSTREAMS);
            m_pDevice->m_dwRuntimeFlags |= D3DRT_NEED_VB_UPDATE;  // Need to call UpdateDirtyStreams()
        }
    }
    pv->dwFlags &= ~D3DPV_TLVCLIP;
}
//-----------------------------------------------------------------------------
#if DBG

#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::ValidateCommand"

void CD3DDDIDX8::ValidateCommand(LPD3DHAL_DP2COMMAND lpCmd)
{
    CD3DHal* pDevice = static_cast<CD3DHal*>(m_pDevice);
    D3DFE_PROCESSVERTICES* pv = static_cast<CD3DHal*>(m_pDevice)->m_pv;

    if (!(pDevice->m_dwRuntimeFlags & D3DRT_RSSOFTWAREPROCESSING))
        return;

    DWORD dwVertexSize = pv->dwOutputSize;
    BOOL bNeedUnlock = FALSE;
    UINT  count;
    BYTE* pVertices;
    CTLStream* pStream = (CTLStream*)m_pDDIStream[0].m_pStream;
    if (pStream->m_pVB)
        if (pStream->m_pVB->IsLocked())
            pVertices = pStream->m_pData;
        else
        {
            pVertices = pStream->Lock(pStream->m_pVB->GetBufferDesc()->Size, this);
            bNeedUnlock = TRUE;
        }
    else
        // User memory vertices
        pVertices = (LPBYTE)(dp2data.lpVertices);

    switch (lpCmd->bCommand)
    {
    case D3DDP2OP_DRAWPRIMITIVE:
        {
            LPD3DHAL_DP2DRAWPRIMITIVE pData = (LPD3DHAL_DP2DRAWPRIMITIVE)(lpCmd+1);
            count = GETVERTEXCOUNT(pData->primType, pData->PrimitiveCount);
            pVertices += pData->VStart * dwVertexSize;
            for (WORD i = 0; i < count; i++)
            {
                ValidateVertex((LPDWORD)(pVertices + i * dwVertexSize));
            }
        }
        break;
    case D3DDP2OP_DRAWPRIMITIVE2:
        {
            LPD3DHAL_DP2DRAWPRIMITIVE2 pData = (LPD3DHAL_DP2DRAWPRIMITIVE2)(lpCmd+1);
            count = GETVERTEXCOUNT(pData->primType, pData->PrimitiveCount);
            pVertices += pData->FirstVertexOffset;
            for (WORD i = 0; i < count; i++)
            {
                ValidateVertex((LPDWORD)(pVertices + i * dwVertexSize));
            }
        }
        break;
    case D3DDP2OP_DRAWINDEXEDPRIMITIVE:
    case D3DDP2OP_DRAWINDEXEDPRIMITIVE2:
        {
            BYTE* pIndices;
            BOOL bNeedUnlock = FALSE;
            CTLIndexStream* pStream = (CTLIndexStream*)m_pDDIStream[__NUMSTREAMS].m_pStream;
            if (pStream->m_pVBI->IsLocked())
                pIndices = pStream->m_pData;
            else
            {
                pIndices = pStream->Lock(pStream->m_pVBI->GetBufferDesc()->Size, this);
                bNeedUnlock = TRUE;
            }

            UINT MaxIndex;
            UINT MinIndex;
            if (lpCmd->bCommand == D3DDP2OP_DRAWINDEXEDPRIMITIVE)
            {
                LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE pData =
                    (LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE)(lpCmd+1);
                pIndices += pData->StartIndex * pv->dwIndexSize;
                pVertices += pData->BaseVertexIndex * dwVertexSize;
                MaxIndex = pData->MinIndex + pData->NumVertices - 1;
                count = GETVERTEXCOUNT(pData->primType, pData->PrimitiveCount);
                MinIndex = pData->MinIndex;
            }
            else
            {
                LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE2 pData =
                    (LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE2)(lpCmd+1);
                pIndices += pData->StartIndexOffset;
                pVertices += pData->BaseVertexOffset;
                MaxIndex = pData->MinIndex + pData->NumVertices - 1;
                count = GETVERTEXCOUNT(pData->primType, pData->PrimitiveCount);
                MinIndex = pData->MinIndex;
            }
            for (WORD i = 0; i < count; i++)
            {
                DWORD index;
                if (pv->dwIndexSize == 4)
                    index = *(DWORD*)(pIndices + i * 4);
                else
                    index = *(WORD*)(pIndices + i * 2);
                if (index  < MinIndex || index  > MaxIndex)
                {
                    D3D_THROW_FAIL("Invalid index in the index stream");
                }
                BYTE* pVertex = &pVertices[index];
                if (pVertex < pVertices ||
                    pVertex > pVertices + dwVertexSize * MaxIndex)
                {
                    D3D_THROW_FAIL("Bad vertex address");
                }
                ValidateVertex((LPDWORD)(pVertices + index * dwVertexSize));
            }
            if (bNeedUnlock)
                pStream->Unlock();
        }
        break;
    case D3DDP2OP_CLIPPEDTRIANGLEFAN:
        if (bNeedUnlock)
            pStream->Unlock();
        CD3DDDIDX6::ValidateCommand(lpCmd);
        return;
    case D3DDP2OP_DRAWRECTPATCH:
    case D3DDP2OP_DRAWTRIPATCH:
        return;

    default:
        D3D_THROW_FAIL("Invalid DX8 drawing command in DP2 stream");
    }
    if (bNeedUnlock)
        pStream->Unlock();
}
#endif

//-----------------------------------------------------------------------------
// Volume Blt
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::VolBlt"

void
CD3DDDIDX8::VolBlt(CBaseTexture *lpDst, CBaseTexture* lpSrc, DWORD dwDestX,
                   DWORD dwDestY, DWORD dwDestZ, D3DBOX *pBox)
{
    if (bDP2CurrCmdOP == D3DDP2OP_VOLUMEBLT)
    { // Last instruction is a tex blt, append this one to it
        if (dwDP2CommandLength + sizeof(D3DHAL_DP2VOLUMEBLT) <=
            dwDP2CommandBufSize)
        {
            LPD3DHAL_DP2VOLUMEBLT lpVolBlt =
                (LPD3DHAL_DP2VOLUMEBLT)((LPBYTE)lpvDP2Commands +
                                        dwDP2CommandLength +
                                        dp2data.dwCommandOffset);
            lpDP2CurrCommand->wStateCount = ++wDP2CurrCmdCnt;
            lpVolBlt->dwDDDestSurface   = lpDst == NULL ? 0 :
                lpDst->DriverAccessibleDrawPrimHandle();
            lpVolBlt->dwDDSrcSurface    = lpSrc->BaseDrawPrimHandle();
            lpVolBlt->dwDestX            = dwDestX;
            lpVolBlt->dwDestY            = dwDestY;
            lpVolBlt->dwDestZ            = dwDestZ;
            lpVolBlt->srcBox             = *pBox;
            lpVolBlt->dwFlags            = 0;
            dwDP2CommandLength += sizeof(D3DHAL_DP2VOLUMEBLT);
            D3D_INFO(6, "Modify Ins:%08lx", *(LPDWORD)lpDP2CurrCommand);

            // For the source, we want to call BatchBase since
            // we want to batch the backing (or sysmem) texture
            // rather than the promoted one.
            lpSrc->BatchBase();
            if(lpDst != 0)
            {
                lpDst->Batch();
            }
            return;
        }
    }
    // Check for space
    if (dwDP2CommandLength + sizeof(D3DHAL_DP2COMMAND) +
        sizeof(D3DHAL_DP2VOLUMEBLT) > dwDP2CommandBufSize)
    {
        FlushStates();
    }
    // Add new instruction
    lpDP2CurrCommand = (LPD3DHAL_DP2COMMAND)((LPBYTE)lpvDP2Commands +
        dwDP2CommandLength + dp2data.dwCommandOffset);
    lpDP2CurrCommand->bCommand = D3DDP2OP_VOLUMEBLT;
    bDP2CurrCmdOP = D3DDP2OP_VOLUMEBLT;
    lpDP2CurrCommand->bReserved = 0;
    lpDP2CurrCommand->wStateCount = 1;
    wDP2CurrCmdCnt = 1;
    D3D_INFO(6, "Write Ins:%08lx", *(LPDWORD)lpDP2CurrCommand);
    // Add texture blt data
    LPD3DHAL_DP2VOLUMEBLT lpVolBlt =
        (LPD3DHAL_DP2VOLUMEBLT)(lpDP2CurrCommand + 1);
    lpVolBlt->dwDDDestSurface   = lpDst == NULL ? 0 :
        lpDst->DriverAccessibleDrawPrimHandle();
    lpVolBlt->dwDDSrcSurface    = lpSrc->BaseDrawPrimHandle();
    lpVolBlt->dwDestX           = dwDestX;
    lpVolBlt->dwDestY           = dwDestY;
    lpVolBlt->dwDestZ           = dwDestZ;
    lpVolBlt->srcBox            = *pBox;
    lpVolBlt->dwFlags           = 0;
    dwDP2CommandLength += sizeof(D3DHAL_DP2COMMAND) +
        sizeof(D3DHAL_DP2VOLUMEBLT);
    // For the source, we want to call BatchBase since
    // we want to batch the backing (or sysmem) texture
    // rather than the promoted one.
    lpSrc->BatchBase();
    if(lpDst != 0)
    {
        lpDst->Batch();
    }
}

//-----------------------------------------------------------------------------
// Buffer Blt
//
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::BufBlt"

void
CD3DDDIDX8::BufBlt(CBuffer *lpDst, CBuffer* lpSrc, DWORD dwOffset,
                   D3DRANGE* pRange)
{
    if (bDP2CurrCmdOP == D3DDP2OP_BUFFERBLT)
    { // Last instruction is a tex blt, append this one to it
        if (dwDP2CommandLength + sizeof(D3DHAL_DP2BUFFERBLT) <=
            dwDP2CommandBufSize)
        {
            LPD3DHAL_DP2BUFFERBLT lpBufBlt =
                (LPD3DHAL_DP2BUFFERBLT)((LPBYTE)lpvDP2Commands +
                                        dwDP2CommandLength +
                                        dp2data.dwCommandOffset);
            lpDP2CurrCommand->wStateCount = ++wDP2CurrCmdCnt;
            lpBufBlt->dwDDDestSurface   = lpDst == NULL ? 0 :
                lpDst->DriverAccessibleDrawPrimHandle();
            lpBufBlt->dwDDSrcSurface    = lpSrc->BaseDrawPrimHandle();
            lpBufBlt->dwOffset          = dwOffset;
            lpBufBlt->rSrc              = *pRange;
            lpBufBlt->dwFlags           = 0;
            dwDP2CommandLength += sizeof(D3DHAL_DP2BUFFERBLT);
            D3D_INFO(6, "Modify Ins:%08lx", *(LPDWORD)lpDP2CurrCommand);

            // For the source, we want to call BatchBase since
            // we want to batch the backing (or sysmem) texture
            // rather than the promoted one.
            lpSrc->BatchBase();
            if(lpDst != 0)
            {
                lpDst->Batch();
            }
            return;
        }
    }
    // Check for space
    if (dwDP2CommandLength + sizeof(D3DHAL_DP2COMMAND) +
        sizeof(D3DHAL_DP2BUFFERBLT) > dwDP2CommandBufSize)
    {
        FlushStates();
    }
    // Add new instruction
    lpDP2CurrCommand = (LPD3DHAL_DP2COMMAND)((LPBYTE)lpvDP2Commands +
        dwDP2CommandLength + dp2data.dwCommandOffset);
    lpDP2CurrCommand->bCommand = D3DDP2OP_BUFFERBLT;
    bDP2CurrCmdOP = D3DDP2OP_BUFFERBLT;
    lpDP2CurrCommand->bReserved = 0;
    lpDP2CurrCommand->wStateCount = 1;
    wDP2CurrCmdCnt = 1;
    D3D_INFO(6, "Write Ins:%08lx", *(LPDWORD)lpDP2CurrCommand);
    // Add texture blt data
    LPD3DHAL_DP2BUFFERBLT lpBufBlt =
        (LPD3DHAL_DP2BUFFERBLT)(lpDP2CurrCommand + 1);
    lpBufBlt->dwDDDestSurface   = lpDst == NULL ? 0 :
        lpDst->DriverAccessibleDrawPrimHandle();
    lpBufBlt->dwDDSrcSurface    = lpSrc->BaseDrawPrimHandle();
    lpBufBlt->dwOffset          = dwOffset;
    lpBufBlt->rSrc              = *pRange;
    lpBufBlt->dwFlags           = 0;
    dwDP2CommandLength += sizeof(D3DHAL_DP2COMMAND) +
        sizeof(D3DHAL_DP2BUFFERBLT);
    // For the source, we want to call BatchBase since
    // we want to batch the backing (or sysmem) texture
    // rather than the promoted one.
    lpSrc->BatchBase();
    if(lpDst != 0)
    {
        lpDst->Batch();
    }
}
//-----------------------------------------------------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "CD3DDDIDX8::GetMaxRenderState"

// Note: This is a hack for DX8.1 release. The only renderstates that we added 
// in DX8.1 pertain to the NPATCHES features. At the time of DX8.1 release 
// there were no real drivers besides Reference that could support this feature. 
// We also know that the only can driver that does support the NPATCH feature 
// will support these renderstates (i.e. will be a DX8.1 driver. Hence it is 
// safe to assume that if any driver supports the D3DDEVCAPS_NPATCHES cap, then 
// it is a DX8.1 driver and understands the extra renderstates that were added 
// in DX8.1.
D3DRENDERSTATETYPE CD3DDDIDX8::GetMaxRenderState() 
{   
    const D3DCAPS8* pCaps = m_pDevice->GetD3DCaps();
    if (pCaps->DevCaps & D3DDEVCAPS_NPATCHES)
    {
        return D3D_MAXRENDERSTATES;
    }
    else
    {
        return D3DRS_POSITIONORDER;
    }
}