windows-server-2003/multimedia/directx/dxg/ref8/hop/drawgrid.cpp

/*============================================================================
 *
 *  Copyright (C) 1999-2000 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       drawgrid.cpp
 *  Content:    Implementation for high order surfaces
 *
 ****************************************************************************/

#include "pch.cpp"
#pragma hdrstop

//-----------------------------------------------------------------------------
// RDHOCoeffs::operator=
//-----------------------------------------------------------------------------
RDHOCoeffs& RDHOCoeffs::operator=(const RDHOCoeffs &coeffs)
{
    m_Width  = coeffs.m_Width;
    m_Height = coeffs.m_Height;
    m_Stride = coeffs.m_Stride;
    m_Basis  = coeffs.m_Basis;
    m_Order  = coeffs.m_Order;
    if(coeffs.m_pNumSegs != 0)
    {
        m_pNumSegs = new FLOAT[4];
        if(m_pNumSegs != 0)
        {
            memcpy(m_pNumSegs, coeffs.m_pNumSegs, sizeof(FLOAT) * 4);
        }
    }
    else
    {
        m_pNumSegs = 0;
    }
    for(unsigned i = 0; i < RD_MAX_NUMSTREAMS; ++i)
    {
        if(coeffs.m_pData[i] != 0)
        {
            m_DataSize[i] = coeffs.m_DataSize[i];
            m_pData[i] = new BYTE[m_DataSize[i]];
            if(m_pData[i] != 0)
            {
                memcpy(m_pData[i], coeffs.m_pData[i], m_DataSize[i]);
            }
        }
        else
        {
            m_pData[i] = 0;
        }
    }
    return *this;
}

//-----------------------------------------------------------------------------
// RefDev::DrawRectPatch
//-----------------------------------------------------------------------------
HRESULT 
RefDev::DrawRectPatch( LPD3DHAL_DP2DRAWRECTPATCH pDP )
{
    HRESULT hr = S_OK;
    
    if( RDVSD_ISLEGACY( m_CurrentVShaderHandle ) )
    {
        //
        // The legacy FVF style: The Zero'th Stream is implied
        //
        DWORD dwFVF    = m_CurrentVShaderHandle;
        RDVStream& Stream = m_VStream[0];
        DWORD dwStride = Stream.m_dwStride;
        DWORD dwFVFSize = GetFVFVertexSize( dwFVF );

        if( Stream.m_pData == NULL || dwStride == 0 )
        {
            DPFERR("Zero'th stream doesnt have valid VB set");
            return DDERR_INVALIDPARAMS;
        }
        if( dwStride < dwFVFSize )
        {
            DPFERR("The stride set for the vertex stream is less than the FVF vertex size");
            return E_FAIL;
        }        
    }

    FLOAT *pSegs;
    D3DRECTPATCH_INFO Info, *pInfo;
    BYTE *TempData[RD_MAX_NUMSTREAMS + 1];

    if(pDP->Handle != 0)
    {
        if((pDP->Flags & RTPATCHFLAG_HASINFO) != 0) // Is either a first time or a recompute
        {
            HR_RET( m_HOSCoeffs.Grow(pDP->Handle) );

            if((pDP->Flags & RTPATCHFLAG_HASSEGS) != 0)
            {
                pInfo = (D3DRECTPATCH_INFO*)(((BYTE*)(pDP + 1) + sizeof(FLOAT) * 4));
                pSegs = (FLOAT*)(pDP + 1);
            }
            else
            {
                pInfo = (D3DRECTPATCH_INFO*)(pDP + 1);
                pSegs = 0;
            }

            RDHOCoeffs &coeffs = m_HOSCoeffs[pDP->Handle];
            coeffs.m_Width  = pInfo->Width;
            coeffs.m_Height = pInfo->Height;
            coeffs.m_Stride = pInfo->Width;
            coeffs.m_Basis  = pInfo->Basis;
            coeffs.m_Order  = pInfo->Order;

            delete[] coeffs.m_pNumSegs;
            if(pSegs != 0)
            {
                coeffs.m_pNumSegs = new FLOAT[4];
                if(coeffs.m_pNumSegs == 0)
                {
                    return E_OUTOFMEMORY;
                }
                memcpy(coeffs.m_pNumSegs, pSegs, sizeof(FLOAT) * 4);
            }
            else
            {
                coeffs.m_pNumSegs = 0;
            }

            RDVDeclaration &Decl = m_pCurrentVShader->m_Declaration;
            for(unsigned i = 0; i < Decl.m_dwNumActiveStreams; ++i) 
            {
                RDVStreamDecl &StreamDecl = Decl.m_StreamArray[i];
                if(StreamDecl.m_dwStreamIndex < RD_MAX_NUMSTREAMS) // ignore the implicit stream
                {
                    RDVStream &Stream = m_VStream[StreamDecl.m_dwStreamIndex];
                    delete[] coeffs.m_pData[StreamDecl.m_dwStreamIndex];
                    coeffs.m_DataSize[StreamDecl.m_dwStreamIndex] = pInfo->Width * pInfo->Height * Stream.m_dwStride;
                    coeffs.m_pData[StreamDecl.m_dwStreamIndex] = new BYTE[coeffs.m_DataSize[StreamDecl.m_dwStreamIndex]];
                    if(coeffs.m_pData[StreamDecl.m_dwStreamIndex] == 0)
                    {
                        return E_OUTOFMEMORY;
                    }
                    for(unsigned k = 0; k < pInfo->Height; ++k)
                    {
                        memcpy(&coeffs.m_pData[StreamDecl.m_dwStreamIndex][k * pInfo->Width * Stream.m_dwStride],
                               &Stream.m_pData[((pInfo->StartVertexOffsetHeight + k) * pInfo->Stride + pInfo->StartVertexOffsetWidth) * Stream.m_dwStride],
                               pInfo->Width * Stream.m_dwStride);
                    }
                }
            }
        }

        // Guard against bad handles
        if(pDP->Handle >= m_HOSCoeffs.GetSize())
        {
            DPFERR("Invalid patch handle specified in Draw*Patch call");
            return E_FAIL;
        }

        RDHOCoeffs &coeffs = m_HOSCoeffs[pDP->Handle];
        Info.StartVertexOffsetWidth  = 0;
        Info.StartVertexOffsetHeight = 0;
        Info.Width                   = coeffs.m_Width;
        Info.Height                  = coeffs.m_Height;
        Info.Stride                  = coeffs.m_Stride;
        Info.Basis                   = coeffs.m_Basis;
        Info.Order                   = coeffs.m_Order;
        pInfo = &Info;

        if((pDP->Flags & RTPATCHFLAG_HASSEGS) != 0)
        {
            pSegs = (FLOAT*)(pDP + 1);
        }
        else
        {
            pSegs = coeffs.m_pNumSegs;
        }
        
        // Save current data stream pointers and replace with 
        // pointer to tessellation output
        hr = LinkCachedTessellatorOutput(pDP->Handle, TempData);
    }
    else
    {
        if((pDP->Flags & RTPATCHFLAG_HASINFO) == 0)
        {
            DPFERR("Need patch info if handle is zero");
            return DDERR_INVALIDPARAMS;
        }
        
        if((pDP->Flags & RTPATCHFLAG_HASSEGS) != 0)
        {
            pInfo = (D3DRECTPATCH_INFO*)(((BYTE*)(pDP + 1) + sizeof(FLOAT) * 4));
            pSegs = (FLOAT*)(pDP + 1);
        }
        else
        {
            pInfo = (D3DRECTPATCH_INFO*)(pDP + 1);
            pSegs = 0;
        }

        // Save current data stream pointers and replace with 
        // pointer to tessellation output
        hr = LinkTessellatorOutput();
    }

    if( SUCCEEDED(hr) )
    {
        switch(pInfo->Basis)
        {
        case D3DBASIS_BSPLINE:
            hr = ProcessBSpline(pInfo->StartVertexOffsetWidth, pInfo->StartVertexOffsetHeight,
                                pInfo->Width, pInfo->Height,
                                pInfo->Stride, pInfo->Order,
                                pSegs);
            break;
        case D3DBASIS_BEZIER:
            hr = ProcessBezier(pInfo->StartVertexOffsetWidth, pInfo->StartVertexOffsetHeight,
                               pInfo->Width, pInfo->Height,
                               pInfo->Stride, pInfo->Order,
                               pSegs,
                               false);
            break;
        case D3DBASIS_INTERPOLATE:
            hr = ProcessCatRomSpline(pInfo->StartVertexOffsetWidth, pInfo->StartVertexOffsetHeight,
                                     pInfo->Width, pInfo->Height,
                                     pInfo->Stride,
                                     pSegs);
            break;
        default:
            hr = E_NOTIMPL;
        }
    }

    if(pDP->Handle != 0)
    {
        // Restore back saved pointer
        UnlinkCachedTessellatorOutput(TempData);
    }
    else
    {
        // Restore back saved pointer
        UnlinkTessellatorOutput();
    }
    
    return hr;
}

//-----------------------------------------------------------------------------
// RefDev::ConvertLinearTriBezierToRectBezier
//-----------------------------------------------------------------------------
HRESULT
RefDev::ConvertLinearTriBezierToRectBezier(DWORD dwDataType, const BYTE *B, DWORD dwStride, BYTE *Q)
{
    DWORD dwElements = 0;
    switch(dwDataType)
    {
    case D3DVSDT_FLOAT4:
        ++dwElements;
    case D3DVSDT_FLOAT3:
        ++dwElements;
    case D3DVSDT_FLOAT2:
        ++dwElements;
    case D3DVSDT_FLOAT1:
        ++dwElements;
        {
            // Replicate first point twice to get a singular edge
            for(unsigned i = 0; i < 2; ++i)
            {
                memcpy(Q, B, sizeof(FLOAT) * dwElements);
                Q += dwStride;
            }
            B += dwStride;

            // Finally we just copy the last row
            for(i = 0; i < 2; ++i)
            {
                memcpy(Q, B, sizeof(FLOAT) * dwElements);
                Q += dwStride;
                B += dwStride;
            }
        }
        break;
    case D3DVSDT_D3DCOLOR:
    case D3DVSDT_UBYTE4:
        dwElements = 4;
        {
            // Replicate first point twice to get a singular edge
            for(unsigned i = 0; i < 2; ++i)
            {
                memcpy(Q, B, sizeof(BYTE) * dwElements);
                Q += dwStride;
            }
            B += dwStride;

            // Finally we just copy the last row
            for(i = 0; i < 2; ++i)
            {
                memcpy(Q, B, sizeof(BYTE) * dwElements);
                Q += dwStride;
                B += dwStride;
            }
        }
        break;
    case D3DVSDT_SHORT4:
        dwElements += 2;
    case D3DVSDT_SHORT2:
        dwElements += 2;
        {
            // Replicate first point twice to get a singular edge
            for(unsigned i = 0; i < 2; ++i)
            {
                memcpy(Q, B, sizeof(SHORT) * dwElements);
                Q += dwStride;
            }
            B += dwStride;

            // Finally we just copy the last row
            for(i = 0; i < 2; ++i)
            {
                memcpy(Q, B, sizeof(SHORT) * dwElements);
                Q += dwStride;
                B += dwStride;
            }
        }
        break;
    default:
        _ASSERT(FALSE, "Ununderstood vertex element data type");
        return DDERR_INVALIDPARAMS;
    }
    return S_OK;
}

//-----------------------------------------------------------------------------
// RefDev::ConvertCubicTriBezierToRectBezier
//-----------------------------------------------------------------------------
HRESULT
RefDev::ConvertCubicTriBezierToRectBezier(DWORD dwDataType, const BYTE *B, DWORD dwStride, BYTE *Q)
{
    DWORD dwElements = 0;
    switch(dwDataType)
    {
    case D3DVSDT_FLOAT4:
        ++dwElements;
    case D3DVSDT_FLOAT3:
        ++dwElements;
    case D3DVSDT_FLOAT2:
        ++dwElements;
    case D3DVSDT_FLOAT1:
        ++dwElements;
        {
            // Replicate first point four times to get a singular edge
            for(unsigned i = 0; i < 4; ++i)
            {
                memcpy(Q, B, sizeof(FLOAT) * dwElements);
                Q += dwStride;
            }
            B += dwStride;

            // For the next row, we simply copy the second point
            // followed by two interpolated control points
            // followed by the third point
            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            
            FLOAT *B021 = (FLOAT*)B, *B120 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B021[i] * 2.0 + B120[i]) / 3.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B021[i] + B120[i] * 2.0) / 3.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            
            FLOAT *B012 = (FLOAT*)B, *B111 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B012[i] + B111[i] * 2.0) / 3.0);
            }
            Q += dwStride;
            B += dwStride;

            FLOAT *B210 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B111[i] * 2.0 + B210[i]) / 3.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Finally we just copy the last row
            for(i = 0; i < 4; ++i)
            {
                memcpy(Q, B, sizeof(FLOAT) * dwElements);
                Q += dwStride;
                B += dwStride;
            }
        }
        break;
    case D3DVSDT_D3DCOLOR:
    case D3DVSDT_UBYTE4:
        dwElements = 4;
        {
            // Replicate first point four times to get a singular edge
            for(unsigned i = 0; i < 4; ++i)
            {
                memcpy(Q, B, sizeof(BYTE) * dwElements);
                Q += dwStride;
            }
            B += dwStride;

            // For the next row, we simply copy the second point
            // followed by two interpolated control points
            // followed by the third point
            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            
            BYTE *B021 = (BYTE*)B, *B120 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B021[i] * 2.0 + B120[i]) / 3.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B021[i] + B120[i] * 2.0) / 3.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            
            BYTE *B012 = (BYTE*)B, *B111 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B012[i] + B111[i] * 2.0) / 3.0);
            }
            Q += dwStride;
            B += dwStride;

            BYTE *B210 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B111[i] * 2.0 + B210[i]) / 3.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Finally we just copy the last row
            for(i = 0; i < 4; ++i)
            {
                memcpy(Q, B, sizeof(BYTE) * dwElements);
                Q += dwStride;
                B += dwStride;
            }
        }
        break;
    case D3DVSDT_SHORT4:
        dwElements += 2;
    case D3DVSDT_SHORT2:
        dwElements += 2;
        {
            // Replicate first point four times to get a singular edge
            for(unsigned i = 0; i < 4; ++i)
            {
                memcpy(Q, B, sizeof(SHORT) * dwElements);
                Q += dwStride;
            }
            B += dwStride;

            // For the next row, we simply copy the second point
            // followed by two interpolated control points
            // followed by the third point
            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            
            SHORT *B021 = (SHORT*)B, *B120 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B021[i] * 2.0 + B120[i]) / 3.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B021[i] + B120[i] * 2.0) / 3.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            
            SHORT *B012 = (SHORT*)B, *B111 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B012[i] + B111[i] * 2.0) / 3.0);
            }
            Q += dwStride;
            B += dwStride;

            SHORT *B210 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B111[i] * 2.0 + B210[i]) / 3.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Finally we just copy the last row
            for(i = 0; i < 4; ++i)
            {
                memcpy(Q, B, sizeof(SHORT) * dwElements);
                Q += dwStride;
                B += dwStride;
            }
        }
        break;
    default:
        _ASSERT(FALSE, "Ununderstood vertex element data type");
        return DDERR_INVALIDPARAMS;
    }
    return S_OK;
}

//-----------------------------------------------------------------------------
// RefDev::ConvertQuinticTriBezierToRectBezier
//-----------------------------------------------------------------------------
HRESULT
RefDev::ConvertQuinticTriBezierToRectBezier(DWORD dwDataType, const BYTE *B, DWORD dwStride, BYTE *Q)
{
    DWORD dwElements = 0;
    switch(dwDataType)
    {
    case D3DVSDT_FLOAT4:
        ++dwElements;
    case D3DVSDT_FLOAT3:
        ++dwElements;
    case D3DVSDT_FLOAT2:
        ++dwElements;
    case D3DVSDT_FLOAT1:
        ++dwElements;
        {
            // Replicate first point six times to get a singular edge
            for(unsigned i = 0; i < 6; ++i)
            {
                memcpy(Q, B, sizeof(FLOAT) * dwElements);
                Q += dwStride;
            }
            B += dwStride;

            // For the next row, we simply copy the second point
            // followed by four interpolated control points
            // followed by the fifth point
            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            
            FLOAT *B041 = (FLOAT*)B, *B140 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B041[i] * 4.0 + B140[i]) / 5.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B041[i] * 3.0 + B140[i] * 2.0) / 5.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B041[i] * 2.0 + B140[i] * 3.0) / 5.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B041[i] + B140[i] * 4.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            
            FLOAT *B032 = (FLOAT*)B, *B131 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B032[i] * 3.0 + B131[i] * 2.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            FLOAT *B230 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B032[i] * 3.0 + B131[i] * 6.0 + B230[i]) / 10.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B032[i] + B131[i] * 6.0 + B230[i] * 3.0) / 10.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B131[i] * 2.0 + B230[i] * 3.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            
            FLOAT *B023 = (FLOAT*)B, *B122 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B023[i] * 2.0 + B122[i] * 3.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            FLOAT *B221 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B023[i] + B122[i] * 6.0 + B221[i] * 3.0) / 10.0);
            }
            Q += dwStride;
            B += dwStride;

            FLOAT *B320 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B122[i] * 3.0 + B221[i] * 6.0 + B320[i]) / 10.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B221[i] * 3.0 + B320[i] * 2.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            
            FLOAT *B014 = (FLOAT*)B, *B113 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B014[i] + B113[i] * 4.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            FLOAT *B212 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B113[i] * 2.0 + B212[i] * 3.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            FLOAT *B311 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B212[i] * 3.0 + B311[i] * 2.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            FLOAT *B410 = (FLOAT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((FLOAT*)Q)[i] = FLOAT((B311[i] * 4.0 + B410[i]) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(FLOAT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Finally we just copy the last row
            for(i = 0; i < 6; ++i)
            {
                memcpy(Q, B, sizeof(FLOAT) * dwElements);
                Q += dwStride;
                B += dwStride;
            }
        }
        break;
    case D3DVSDT_UBYTE4:
    case D3DVSDT_D3DCOLOR:
        dwElements = 4;
        {
            // Replicate first point six times to get a singular edge
            for(unsigned i = 0; i < 6; ++i)
            {
                memcpy(Q, B, sizeof(BYTE) * dwElements);
                Q += dwStride;
            }
            B += dwStride;

            // For the next row, we simply copy the second point
            // followed by four interpolated control points
            // followed by the fifth point
            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            
            BYTE *B041 = (BYTE*)B, *B140 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B041[i] * 4.0 + B140[i]) / 5.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B041[i] * 3.0 + B140[i] * 2.0) / 5.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B041[i] * 2.0 + B140[i] * 3.0) / 5.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B041[i] + B140[i] * 4.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            
            BYTE *B032 = (BYTE*)B, *B131 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B032[i] * 3.0 + B131[i] * 2.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            BYTE *B230 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B032[i] * 3.0 + B131[i] * 6.0 + B230[i]) / 10.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B032[i] + B131[i] * 6.0 + B230[i] * 3.0) / 10.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B131[i] * 2.0 + B230[i] * 3.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            
            BYTE *B023 = (BYTE*)B, *B122 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B023[i] * 2.0 + B122[i] * 3.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            BYTE *B221 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B023[i] + B122[i] * 6.0 + B221[i] * 3.0) / 10.0);
            }
            Q += dwStride;
            B += dwStride;

            BYTE *B320 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B122[i] * 3.0 + B221[i] * 6.0 + B320[i]) / 10.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B221[i] * 3.0 + B320[i] * 2.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            
            BYTE *B014 = (BYTE*)B, *B113 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B014[i] + B113[i] * 4.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            BYTE *B212 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B113[i] * 2.0 + B212[i] * 3.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            BYTE *B311 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B212[i] * 3.0 + B311[i] * 2.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            BYTE *B410 = (BYTE*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((BYTE*)Q)[i] = BYTE((B311[i] * 4.0 + B410[i]) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(BYTE) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Finally we just copy the last row
            for(i = 0; i < 6; ++i)
            {
                memcpy(Q, B, sizeof(BYTE) * dwElements);
                Q += dwStride;
                B += dwStride;
            }
        }
        break;
    case D3DVSDT_SHORT4:
        dwElements += 2;
    case D3DVSDT_SHORT2:
        dwElements += 2;
        {
            // Replicate first point six times to get a singular edge
            for(unsigned i = 0; i < 6; ++i)
            {
                memcpy(Q, B, sizeof(SHORT) * dwElements);
                Q += dwStride;
            }
            B += dwStride;

            // For the next row, we simply copy the second point
            // followed by four interpolated control points
            // followed by the fifth point
            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            
            SHORT *B041 = (SHORT*)B, *B140 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B041[i] * 4.0 + B140[i]) / 5.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B041[i] * 3.0 + B140[i] * 2.0) / 5.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B041[i] * 2.0 + B140[i] * 3.0) / 5.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B041[i] + B140[i] * 4.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            
            SHORT *B032 = (SHORT*)B, *B131 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B032[i] * 3.0 + B131[i] * 2.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            SHORT *B230 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B032[i] * 3.0 + B131[i] * 6.0 + B230[i]) / 10.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B032[i] + B131[i] * 6.0 + B230[i] * 3.0) / 10.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B131[i] * 2.0 + B230[i] * 3.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            
            SHORT *B023 = (SHORT*)B, *B122 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B023[i] * 2.0 + B122[i] * 3.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            SHORT *B221 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B023[i] + B122[i] * 6.0 + B221[i] * 3.0) / 10.0);
            }
            Q += dwStride;
            B += dwStride;

            SHORT *B320 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B122[i] * 3.0 + B221[i] * 6.0 + B320[i]) / 10.0);
            }
            Q += dwStride;

            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B221[i] * 3.0 + B320[i] * 2.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Again, we copy the edge points and interpolate
            // the central ones
            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            
            SHORT *B014 = (SHORT*)B, *B113 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B014[i] + B113[i] * 4.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            SHORT *B212 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B113[i] * 2.0 + B212[i] * 3.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            SHORT *B311 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B212[i] * 3.0 + B311[i] * 2.0) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            SHORT *B410 = (SHORT*)(B + dwStride);
            for(i = 0; i < dwElements; ++i)
            {
                ((SHORT*)Q)[i] = SHORT((B311[i] * 4.0 + B410[i]) / 5.0);
            }
            Q += dwStride;
            B += dwStride;

            memcpy(Q, B, sizeof(SHORT) * dwElements);
            Q += dwStride;
            B += dwStride;

            // Finally we just copy the last row
            for(i = 0; i < 6; ++i)
            {
                memcpy(Q, B, sizeof(SHORT) * dwElements);
                Q += dwStride;
                B += dwStride;
            }
        }
        break;
    default:
        _ASSERT(FALSE, "Ununderstood vertex element data type");
        return DDERR_INVALIDPARAMS;
    }
    return S_OK;
}

//-----------------------------------------------------------------------------
// RefDev::DrawTriPatch
//-----------------------------------------------------------------------------
HRESULT 
RefDev::DrawTriPatch( LPD3DHAL_DP2DRAWTRIPATCH pDP )
{
    HRESULT hr = S_OK;
    
    if( RDVSD_ISLEGACY( m_CurrentVShaderHandle ) )
    {
        //
        // The legacy FVF style: The Zero'th Stream is implied
        //
        DWORD dwFVF    = m_CurrentVShaderHandle;
        RDVStream& Stream = m_VStream[0];
        DWORD dwStride = Stream.m_dwStride;
        DWORD dwFVFSize = GetFVFVertexSize( dwFVF );

        if( Stream.m_pData == NULL || dwStride == 0 )
        {
            DPFERR("Zero'th stream doesnt have valid VB set");
            return DDERR_INVALIDPARAMS;
        }
        if( dwStride < dwFVFSize )
        {
            DPFERR("The stride set for the vertex stream is less than the FVF vertex size");
            return E_FAIL;
        }        
    }

    FLOAT *pSegs;
    D3DRECTPATCH_INFO Info;
    BYTE *TempData[RD_MAX_NUMSTREAMS + 1];

    if(pDP->Handle == 0 && (pDP->Flags & RTPATCHFLAG_HASINFO) == 0)
    {
        DPFERR("Need patch info if handle is zero");
        return DDERR_INVALIDPARAMS;
    }

    if((pDP->Flags & RTPATCHFLAG_HASINFO) != 0) // Is either a first time or a recompute
    {
        HR_RET( m_HOSCoeffs.Grow(pDP->Handle) );

        D3DTRIPATCH_INFO *pInfo;
        if((pDP->Flags & RTPATCHFLAG_HASSEGS) != 0)
        {
            pInfo = (D3DTRIPATCH_INFO*)(((BYTE*)(pDP + 1) + sizeof(FLOAT) * 3));
            pSegs = (FLOAT*)(pDP + 1);
        }
        else
        {
            pInfo = (D3DTRIPATCH_INFO*)(pDP + 1);
            pSegs = 0;
        }

        RDHOCoeffs &coeffs = m_HOSCoeffs[pDP->Handle];
        coeffs.m_Width  = (DWORD)pInfo->Order + 1;
        coeffs.m_Height = (DWORD)pInfo->Order + 1;
        coeffs.m_Stride = (DWORD)pInfo->Order + 1;
        coeffs.m_Basis  = pInfo->Basis;
        coeffs.m_Order  = pInfo->Order;

        delete[] coeffs.m_pNumSegs;
        if(pSegs != 0)
        {
            coeffs.m_pNumSegs = new FLOAT[4];
            if(coeffs.m_pNumSegs == 0)
            {
                return E_OUTOFMEMORY;
            }
            coeffs.m_pNumSegs[0] = pSegs[2];
            memcpy(&coeffs.m_pNumSegs[1], pSegs, sizeof(FLOAT) * 3);
        }
        else
        {
            coeffs.m_pNumSegs = 0;
        }

        RDVDeclaration &Decl = m_pCurrentVShader->m_Declaration;

        // Allocate memory to hold rect patches rather than tri patches
        for(unsigned i = 0; i < Decl.m_dwNumActiveStreams; ++i) 
        {
            RDVStreamDecl &StreamDecl = Decl.m_StreamArray[i];
            if(StreamDecl.m_dwStreamIndex < RD_MAX_NUMSTREAMS) // ignore the implicit stream
            {
                RDVStream &Stream = m_VStream[StreamDecl.m_dwStreamIndex];
                delete[] coeffs.m_pData[StreamDecl.m_dwStreamIndex];
                coeffs.m_DataSize[StreamDecl.m_dwStreamIndex] = coeffs.m_Width * coeffs.m_Height * Stream.m_dwStride;
                coeffs.m_pData[StreamDecl.m_dwStreamIndex] = new BYTE[coeffs.m_DataSize[StreamDecl.m_dwStreamIndex]];
                if(coeffs.m_pData[StreamDecl.m_dwStreamIndex] == 0)
                {
                    return E_OUTOFMEMORY;
                }
            }
        }

        // Now go through tri patch data, convert it to rect patch and store it in
        // in the space that we allocated above
        for(unsigned e = 0; e < Decl.m_dwNumElements; ++e)
        {
            RDVElement &velem = Decl.m_VertexElements[e];
            if(!velem.m_bIsTessGen)
            {
                RDVStream &vstream = m_VStream[velem.m_dwStreamIndex];
                LPBYTE Q = coeffs.m_pData[velem.m_dwStreamIndex] + velem.m_dwOffset;
                LPBYTE B = vstream.m_pData + pInfo->StartVertexOffset * vstream.m_dwStride + velem.m_dwOffset;
                if(pInfo->Order == D3DORDER_LINEAR)
                {
                    hr = ConvertLinearTriBezierToRectBezier(velem.m_dwDataType, B, vstream.m_dwStride, Q);
                    if(FAILED(hr))
                    {
                        DPFERR("Conversion from Linear Tri Patch to Rect Patch failed");
                        return E_FAIL;
                    }
                }
                else if(pInfo->Order == D3DORDER_CUBIC)
                {
                    hr = ConvertCubicTriBezierToRectBezier(velem.m_dwDataType, B, vstream.m_dwStride, Q);
                    if(FAILED(hr))
                    {
                        DPFERR("Conversion from Cubic Tri Patch to Rect Patch failed");
                        return E_FAIL;
                    }
                }
                else if(pInfo->Order == D3DORDER_QUINTIC)
                {
                    hr = ConvertQuinticTriBezierToRectBezier(velem.m_dwDataType, B, vstream.m_dwStride, Q);
                    if(FAILED(hr))
                    {
                        DPFERR("Conversion from Quintic Tri Patch to Rect Patch failed");
                        return E_FAIL;
                    }
                }
                else
                {
                    DPFERR("Only cubic Bezier patches currently supported");
                    return E_FAIL;
                }
            }
        }
    }

    // Guard against bad handles
    if(pDP->Handle >= m_HOSCoeffs.GetSize())
    {
        DPFERR("Invalid patch handle specified in Draw*Patch call");
        return E_FAIL;
    }

    RDHOCoeffs &coeffs = m_HOSCoeffs[pDP->Handle];
    Info.StartVertexOffsetWidth  = 0;
    Info.StartVertexOffsetHeight = 0;
    Info.Width                   = coeffs.m_Width;
    Info.Height                  = coeffs.m_Height;
    Info.Stride                  = coeffs.m_Stride;
    Info.Basis                   = coeffs.m_Basis;
    Info.Order                   = coeffs.m_Order;
    D3DRECTPATCH_INFO *pInfo = &Info;

    FLOAT Segs[4];
    if((pDP->Flags & RTPATCHFLAG_HASSEGS) != 0)
    {
        Segs[0] = ((FLOAT*)(pDP + 1))[2];
        memcpy(&Segs[1], pDP + 1, sizeof(FLOAT) * 3);
        pSegs = &Segs[0];
    }
    else
    {
        pSegs = coeffs.m_pNumSegs;
    }
    
    // Save current data stream pointers and replace with 
    // pointer to tessellation output
    hr = LinkCachedTessellatorOutput(pDP->Handle, TempData);
    if( SUCCEEDED(hr) )
    {
        switch(pInfo->Basis)
        {
        case D3DBASIS_BEZIER:
            hr = ProcessBezier(pInfo->StartVertexOffsetWidth, pInfo->StartVertexOffsetHeight,
                               pInfo->Width, pInfo->Height,
                               pInfo->Stride, pInfo->Order,
                               pSegs,
                               true);
            break;
        default:
            hr = E_NOTIMPL;
        }
    }

    // Restore back saved pointer
    UnlinkCachedTessellatorOutput(TempData);

    return hr;
}

//---------------------------------------------------------------------
// RefDev::LinkTessellatorOutput
//---------------------------------------------------------------------
HRESULT RefDev::LinkTessellatorOutput()
{
    HRESULT hr = S_OK;
    RDVDeclaration &Decl = m_pCurrentVShader->m_Declaration;
    for(unsigned i = 0; i < Decl.m_dwNumActiveStreams; ++i) 
    {
        RDVStreamDecl &StreamDecl = Decl.m_StreamArray[i];
        RDVStream &Stream = m_VStream[StreamDecl.m_dwStreamIndex];
        // Make space for four vertices
        hr |= Stream.m_TessOut.Grow(StreamDecl.m_dwStride * 4);
        Stream.m_pSavedData = Stream.m_pData;
        Stream.m_pData = &Stream.m_TessOut[0];
    }
    return hr;
}

//---------------------------------------------------------------------
// RefDev::LinkCachedTessellatorOutput
//---------------------------------------------------------------------
HRESULT RefDev::LinkCachedTessellatorOutput(DWORD Handle, BYTE **pTempData)
{
    HRESULT hr = S_OK;
    RDVDeclaration &Decl = m_pCurrentVShader->m_Declaration;
    for(unsigned i = 0; i < Decl.m_dwNumActiveStreams; ++i) 
    {
        RDVStreamDecl &StreamDecl = Decl.m_StreamArray[i];
        RDVStream &Stream = m_VStream[StreamDecl.m_dwStreamIndex];
        // Make space for four vertices
        hr |= Stream.m_TessOut.Grow(StreamDecl.m_dwStride * 4);
        if(StreamDecl.m_dwStreamIndex < RD_MAX_NUMSTREAMS) // ignore the implicit stream
        {
            Stream.m_pSavedData = m_HOSCoeffs[Handle].m_pData[StreamDecl.m_dwStreamIndex];
            if(Stream.m_pSavedData == 0)
            {
                DPFERR("Deleted or unspecified patch was requested to be drawn");
                hr |= E_FAIL;
            }
        }
        else
        {
            Stream.m_pSavedData = 0;
        }
        pTempData[StreamDecl.m_dwStreamIndex] = Stream.m_pData;
        Stream.m_pData = &Stream.m_TessOut[0];
    }
    return hr;
}

//---------------------------------------------------------------------
// RefDev::UnlinkTessellatorOuput
//---------------------------------------------------------------------
void RefDev::UnlinkTessellatorOutput()
{
    RDVDeclaration &Decl = m_pCurrentVShader->m_Declaration;
    for(unsigned i = 0; i < Decl.m_dwNumActiveStreams; ++i) 
    {
        RDVStreamDecl &StreamDecl = Decl.m_StreamArray[i];
        RDVStream &Stream = m_VStream[StreamDecl.m_dwStreamIndex];
        Stream.m_pData = Stream.m_pSavedData;
        Stream.m_pSavedData = NULL;
    }
}

//---------------------------------------------------------------------
// RefDev::UnlinkTessellatorOuput
//---------------------------------------------------------------------
void RefDev::UnlinkCachedTessellatorOutput(BYTE **pTempData)
{
    RDVDeclaration &Decl = m_pCurrentVShader->m_Declaration;
    for(unsigned i = 0; i < Decl.m_dwNumActiveStreams; ++i) 
    {
        RDVStreamDecl &StreamDecl = Decl.m_StreamArray[i];
        RDVStream &Stream = m_VStream[StreamDecl.m_dwStreamIndex];
        Stream.m_pData = pTempData[StreamDecl.m_dwStreamIndex];
        Stream.m_pSavedData = NULL;
    }
}

//---------------------------------------------------------------------
// RefDev::DrawTessQuad
//---------------------------------------------------------------------
HRESULT RefDev::DrawTessQuad( const RDBSpline &Surf, DWORD dwOffW, DWORD dwOffH, DWORD dwStride, 
                              const unsigned *m, const unsigned *n, 
                              double u0, double v0, double u1, double v1,
                              double tu0, double tv0, double tu1, double tv1,
                              bool bDegenerate )
{
    RDVDeclaration &Decl = m_pCurrentVShader->m_Declaration;
    for(unsigned e = 0; e < Decl.m_dwNumElements; ++e)
    {
        RDVElement &velem = Decl.m_VertexElements[e];
        if(velem.m_bIsTessGen)
        {
            if((velem.m_dwToken & 0x10000000) == 0) // Check if token is D3DVSD_TESSNORMAL
            {
                RDVStream &vstrmin = m_VStream[velem.m_dwStreamIndexIn];
                RDVStream &vstream = m_VStream[velem.m_dwStreamIndex];
                LPBYTE Q = &vstream.m_pData[velem.m_dwOffset];
                LPBYTE B = vstrmin.m_pSavedData + ((dwOffH + n[0]) * dwStride + (dwOffW + m[0])) * vstrmin.m_dwStride + velem.m_dwOffsetIn;
                Surf.SampleNormal(velem.m_dwDataType, u0, v0, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
                Q += vstream.m_dwStride;
                B = vstrmin.m_pSavedData + ((dwOffH + n[1]) * dwStride + (dwOffW + m[1])) * vstrmin.m_dwStride + velem.m_dwOffsetIn;
                Surf.SampleNormal(velem.m_dwDataType, u1, v0, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
                Q += vstream.m_dwStride;
                B = vstrmin.m_pSavedData + ((dwOffH + n[2]) * dwStride + (dwOffW + m[2])) * vstrmin.m_dwStride + velem.m_dwOffsetIn;
                Surf.SampleNormal(velem.m_dwDataType, u1, v1, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
                Q += vstream.m_dwStride;
                B = vstrmin.m_pSavedData + ((dwOffH + n[3]) * dwStride + (dwOffW + m[3])) * vstrmin.m_dwStride + velem.m_dwOffsetIn;
                Surf.SampleNormal(velem.m_dwDataType, u0, v1, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
            }
            else // it is D3DVSD_TESSUV
            {
                RDVStream &vstream = m_VStream[velem.m_dwStreamIndex];
                LPBYTE Q = &vstream.m_pData[velem.m_dwOffset];
                if(bDegenerate)
                {
                    ((FLOAT*)Q)[0] = (FLOAT)(tu0 * tv0);
                    ((FLOAT*)Q)[1] = (FLOAT)tv0;
                }
                else
                {
                    ((FLOAT*)Q)[0] = (FLOAT)tu0;
                    ((FLOAT*)Q)[1] = (FLOAT)tv0;
                }
                Q += vstream.m_dwStride;
                if(bDegenerate)
                {
                    ((FLOAT*)Q)[0] = (FLOAT)(tu1 * tv0);
                    ((FLOAT*)Q)[1] = (FLOAT)tv0;
                }
                else
                {
                    ((FLOAT*)Q)[0] = (FLOAT)tu1;
                    ((FLOAT*)Q)[1] = (FLOAT)tv0;
                }
                Q += vstream.m_dwStride;
                if(bDegenerate)
                {
                    ((FLOAT*)Q)[0] = (FLOAT)(tu1 * tv1);
                    ((FLOAT*)Q)[1] = (FLOAT)tv1;
                }
                else
                {
                    ((FLOAT*)Q)[0] = (FLOAT)tu1;
                    ((FLOAT*)Q)[1] = (FLOAT)tv1;
                }
                Q += vstream.m_dwStride;
                if(bDegenerate)
                {
                    ((FLOAT*)Q)[0] = (FLOAT)(tu0 * tv1);
                    ((FLOAT*)Q)[1] = (FLOAT)tv1;
                }
                else
                {
                    ((FLOAT*)Q)[0] = (FLOAT)tu0;
                    ((FLOAT*)Q)[1] = (FLOAT)tv1;
                }
            }
        }
        else
        {
            RDVStream &vstream = m_VStream[velem.m_dwStreamIndex];
            LPBYTE B = vstream.m_pSavedData + ((dwOffH + n[0]) * dwStride + (dwOffW + m[0])) * vstream.m_dwStride + velem.m_dwOffset;
            LPBYTE Q = &vstream.m_pData[velem.m_dwOffset];
            Surf.Sample(velem.m_dwDataType, u0, v0, B, vstream.m_dwStride, dwStride * vstream.m_dwStride, Q);
            Q += vstream.m_dwStride;
            B = vstream.m_pSavedData + ((dwOffH + n[1]) * dwStride + (dwOffW + m[1])) * vstream.m_dwStride + velem.m_dwOffset;
            Surf.Sample(velem.m_dwDataType, u1, v0, B, vstream.m_dwStride, dwStride * vstream.m_dwStride, Q);
            Q += vstream.m_dwStride;
            B = vstream.m_pSavedData + ((dwOffH + n[2]) * dwStride + (dwOffW + m[2])) * vstream.m_dwStride + velem.m_dwOffset;
            Surf.Sample(velem.m_dwDataType, u1, v1, B, vstream.m_dwStride, dwStride * vstream.m_dwStride, Q);
            Q += vstream.m_dwStride;
            B = vstream.m_pSavedData + ((dwOffH + n[3]) * dwStride + (dwOffW + m[3])) * vstream.m_dwStride + velem.m_dwOffset;
            Surf.Sample(velem.m_dwDataType, u0, v1, B, vstream.m_dwStride, dwStride * vstream.m_dwStride, Q);
        }
    }

    HRESULT hr;
    if( m_pCurrentVShader->IsFixedFunction() )
    {
        //
        // With declaration for Fixed Function pipeline, DX8 style
        //
        hr = ProcessPrimitive( D3DPT_TRIANGLEFAN, 0, 4, 0, 0 );
    }
    else
    {
        //
        // Pure Vertex Shader
        //
        hr = ProcessPrimitiveVVM( D3DPT_TRIANGLEFAN, 0, 4, 0, 0 );
    }
    return hr;
}

//---------------------------------------------------------------------
// RefDev::DrawTessTri
//---------------------------------------------------------------------
HRESULT RefDev::DrawTessTri( const RDBSpline &Surf, DWORD dwOffW, DWORD dwOffH, DWORD dwStride, 
                             const unsigned *m, const unsigned *n, 
                             double u0, double v0, double u1, double v1, double u2, double v2,
                             double tu0, double tv0, double tu1, double tv1, double tu2, double tv2,
                             bool bDegenerate0, bool bDegenerate1, bool bDegenerate2 )
{
    RDVDeclaration &Decl = m_pCurrentVShader->m_Declaration;
    for(unsigned e = 0; e < Decl.m_dwNumElements; ++e)
    {
        RDVElement &velem = Decl.m_VertexElements[e];
        if(velem.m_bIsTessGen)
        {
            if((velem.m_dwToken & 0x10000000) == 0) // Check if token is D3DVSD_TESSNORMAL
            {
                RDVStream &vstrmin = m_VStream[velem.m_dwStreamIndexIn];
                RDVStream &vstream = m_VStream[velem.m_dwStreamIndex];
                LPBYTE Q = &vstream.m_pData[velem.m_dwOffset];
                LPBYTE B = vstrmin.m_pSavedData + ((dwOffH + n[0]) * dwStride + (dwOffW + m[0])) * vstrmin.m_dwStride + velem.m_dwOffsetIn;
                if(bDegenerate0)
                {
                    Surf.SampleDegenerateNormal(velem.m_dwDataType, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
                }
                else
                {
                    Surf.SampleNormal(velem.m_dwDataType, u0, v0, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
                }
                Q += vstream.m_dwStride;
                B = vstrmin.m_pSavedData + ((dwOffH + n[1]) * dwStride + (dwOffW + m[1])) * vstrmin.m_dwStride + velem.m_dwOffsetIn;
                if(bDegenerate1)
                {
                    Surf.SampleDegenerateNormal(velem.m_dwDataType, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
                }
                else
                {
                    Surf.SampleNormal(velem.m_dwDataType, u1, v1, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
                }
                Q += vstream.m_dwStride;
                B = vstrmin.m_pSavedData + ((dwOffH + n[2]) * dwStride + (dwOffW + m[2])) * vstrmin.m_dwStride + velem.m_dwOffsetIn;
                if(bDegenerate2)
                {
                    Surf.SampleDegenerateNormal(velem.m_dwDataType, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
                }
                else
                {
                    Surf.SampleNormal(velem.m_dwDataType, u2, v2, B, vstrmin.m_dwStride, dwStride * vstrmin.m_dwStride, Q);
                }
            }
            else // it is D3DVSD_TESSUV
            {
                RDVStream &vstream = m_VStream[velem.m_dwStreamIndex];
                LPBYTE Q = &vstream.m_pData[velem.m_dwOffset];
                ((FLOAT*)Q)[0] = (FLOAT)tu0;
                ((FLOAT*)Q)[1] = (FLOAT)tv0;
                Q += vstream.m_dwStride;
                ((FLOAT*)Q)[0] = (FLOAT)tu1;
                ((FLOAT*)Q)[1] = (FLOAT)tv1;
                Q += vstream.m_dwStride;
                ((FLOAT*)Q)[0] = (FLOAT)tu2;
                ((FLOAT*)Q)[1] = (FLOAT)tv2;
            }
        }
        else
        {
            RDVStream &vstream = m_VStream[velem.m_dwStreamIndex];
            LPBYTE B = vstream.m_pSavedData + ((dwOffH + n[0]) * dwStride + (dwOffW + m[0])) * vstream.m_dwStride + velem.m_dwOffset;
            LPBYTE Q = &vstream.m_pData[velem.m_dwOffset];
            Surf.Sample(velem.m_dwDataType, u0, v0, B, vstream.m_dwStride, dwStride * vstream.m_dwStride, Q);
            Q += vstream.m_dwStride;
            B = vstream.m_pSavedData + ((dwOffH + n[1]) * dwStride + (dwOffW + m[1])) * vstream.m_dwStride + velem.m_dwOffset;
            Surf.Sample(velem.m_dwDataType, u1, v1, B, vstream.m_dwStride, dwStride * vstream.m_dwStride, Q);
            Q += vstream.m_dwStride;
            B = vstream.m_pSavedData + ((dwOffH + n[2]) * dwStride + (dwOffW + m[2])) * vstream.m_dwStride + velem.m_dwOffset;
            Surf.Sample(velem.m_dwDataType, u2, v2, B, vstream.m_dwStride, dwStride * vstream.m_dwStride, Q);
        }
    }

    HRESULT hr;
    if( m_pCurrentVShader->IsFixedFunction() )
    {
        //
        // With declaration for Fixed Function pipeline, DX8 style
        //
        hr = ProcessPrimitive( D3DPT_TRIANGLELIST, 0, 3, 0, 0 );
    }
    else
    {
        //
        // Pure Vertex Shader
        //
        hr = ProcessPrimitiveVVM( D3DPT_TRIANGLELIST, 0, 3, 0, 0 );
    }
    return hr;
}

//---------------------------------------------------------------------
// RefDev::DrawNPatch
//---------------------------------------------------------------------
HRESULT RefDev::DrawNPatch(const RDNPatch &Patch, DWORD dwStride, 
                                        const unsigned *m, const unsigned *n, unsigned segs)
{
    for(unsigned i = 0; i < segs; ++i)
    {
        double v0 = double(i) / double(segs);
        double v1 = v0;
        double v2 = double(i + 1) / double(segs);
        double v3 = v2;
        for(unsigned j = 0; j < segs - i; ++j)
        {
            double u0 = double(j + 1) / double(segs);
            double u1 = double(j) / double(segs);
            double u2 = u1;
            double u3 = u0;
            RDVDeclaration &Decl = m_pCurrentVShader->m_Declaration;
            for(unsigned e = 0; e < Decl.m_dwNumElements; ++e)
            {
                RDVElement &velem = Decl.m_VertexElements[e];
                RDVStream &vstream = m_VStream[velem.m_dwStreamIndex];
                LPBYTE Q = &vstream.m_pData[velem.m_dwOffset];
                if(velem.m_dwRegister == D3DVSDE_POSITION)
                {
                    Patch.SamplePosition(u0, v0, (FLOAT*)Q);
                    Q += vstream.m_dwStride;
                    Patch.SamplePosition(u1, v1, (FLOAT*)Q);
                    Q += vstream.m_dwStride;
                    Patch.SamplePosition(u2, v2, (FLOAT*)Q);
                    if(j != segs - i - 1)
                    {
                        Q += vstream.m_dwStride;
                        Patch.SamplePosition(u3, v3, (FLOAT*)Q);
                    }
                }
                else
                if(velem.m_dwRegister == D3DVSDE_NORMAL)
                {
                    BYTE* B[3];
                    B[0] = vstream.m_pSavedData + (n[0] * dwStride + m[0]) * vstream.m_dwStride + velem.m_dwOffset;
                    B[1] = vstream.m_pSavedData + (n[1] * dwStride + m[1]) * vstream.m_dwStride + velem.m_dwOffset;
                    B[2] = vstream.m_pSavedData + (n[2] * dwStride + m[2]) * vstream.m_dwStride + velem.m_dwOffset;

                    Patch.SampleNormal(u0, v0, B, (FLOAT*)Q);
                    Q += vstream.m_dwStride;
                    Patch.SampleNormal(u1, v1, B, (FLOAT*)Q);
                    Q += vstream.m_dwStride;
                    Patch.SampleNormal(u2, v2, B, (FLOAT*)Q);
                    if(j != segs - i - 1)
                    {
                        Q += vstream.m_dwStride;
                        Patch.SampleNormal(u3, v3, B, (FLOAT*)Q);
                    }
                }
                else
                {
                    BYTE *B[3];
                    B[0] = vstream.m_pSavedData + (n[0] * dwStride + m[0]) * vstream.m_dwStride + velem.m_dwOffset;
                    B[1] = vstream.m_pSavedData + (n[1] * dwStride + m[1]) * vstream.m_dwStride + velem.m_dwOffset;
                    B[2] = vstream.m_pSavedData + (n[2] * dwStride + m[2]) * vstream.m_dwStride + velem.m_dwOffset;
                    Patch.Sample(velem.m_dwDataType, u0, v0, B, Q);
                    Q += vstream.m_dwStride;
                    Patch.Sample(velem.m_dwDataType, u1, v1, B, Q);
                    Q += vstream.m_dwStride;
                    Patch.Sample(velem.m_dwDataType, u2, v2, B, Q);
                    if(j != segs - i - 1)
                    {
                        Q += vstream.m_dwStride;
                        Patch.Sample(velem.m_dwDataType, u3, v3, B, Q);
                    }
                }
            }
            DWORD cVerts = (j != segs - i - 1) ? 4 : 3;
            HRESULT hr;
            if( m_pCurrentVShader->IsFixedFunction() )
            {
                //
                // With declaration for Fixed Function pipeline, DX8 style
                //
                hr = ProcessPrimitive( D3DPT_TRIANGLEFAN, 0, cVerts, 0, 0 );
            }
            else
            {
                //
                // Pure Vertex Shader
                //
                hr = ProcessPrimitiveVVM( D3DPT_TRIANGLEFAN, 0, cVerts, 0, 0 );
            }
            if(FAILED(hr))
            {
                return hr;
            }
        }
    }
    return S_OK;
}