////////////////////////////////////////////////////////////////////////////////
//
// DX8SDDIFW
//
// Template library framework for creating a DX8 SDDI pluggable software
// rasterizer.
//
// Two #defines supported:
// DX8SDDIFW_NONAMESPACE: Don't use the DX8SDDIFW namespace. This can cause
//     symbols to bloat up if not needed.
// DX8SDDIFW_NOCATCHALL: Don't use catch( ... ) in certain places to create
//     a more stable driver. There are catch( ... ) clauses in certain areas
//     like DP2 command processing, so that each command succeeds or fails.
//     However, this can cause problems debugging, as Access Violations can
//     be masked and caught without causing the app to freeze or even see an
//     error.
//
////////////////////////////////////////////////////////////////////////////////
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#if !defined( DX8SDDIFW_NONAMESPACE)
namespace DX8SDDIFW
{
#endif // !defined( DX8SDDIFW_NONAMESPACE)

// Since MSVC doesn't have a block type currently, include one. This
// dependency can be removed if a similar type is provided in CRT STL.
#include "block.h"

// Utility functions for clamping a value:
template< class T> inline
void clamp_max( T& Var, const T& ClampMax)
{
    if( Var> ClampMax)
        Var= ClampMax;
}

template< class T> inline
void clamp_min( T& Var, const T& ClampMin)
{
    if( Var< ClampMin)
        Var= ClampMin;
}

template< class T> inline
void clamp( T& Var, const T& ClampMin, const T& ClampMax)
{
    assert( ClampMax>= ClampMin);
    if( Var> ClampMax)
        Var= ClampMax;
    else if( Var< ClampMin)
        Var= ClampMin;
}

////////////////////////////////////////////////////////////////////////////////
//
// CPushValue
//
// This class creates a safe run-time stack which pushes a value upon
// construction and pops the value upon destruction.
//
////////////////////////////////////////////////////////////////////////////////
template< class T>
struct CPushValue
{
protected: // Variables
    T& m_Val;
    T m_OldVal;

public: // Functions
    CPushValue( T& Val, const T& NewVal) : m_Val( Val)
    {
        m_OldVal= Val;
        Val= NewVal;
    }
    ~CPushValue() 
    {
        m_Val= m_OldVal;
    }
};

////////////////////////////////////////////////////////////////////////////////
//
// COSDetector
//
// This class can detect whether the host OS is the Win9X code base or the WinNT
// code base. The difference is important, because driver structures differ
// depending on which OS the rasterizer runs on. We don't want to build 2 lib
// versions, thus requiring the app to link with both.
//
////////////////////////////////////////////////////////////////////////////////
class COSDetector
{
public: // Types
    enum EOS
    {
        Unknown,
        Win9X,
        WinNT
    };

protected: // Variables
    const EOS m_eOS;

protected: // Functions
    static EOS DetermineOS()
    {
        OSVERSIONINFO osvi;
        ZeroMemory( &osvi, sizeof( osvi));
        osvi.dwOSVersionInfoSize= sizeof( osvi);
        if( !GetVersionEx( &osvi))
        {
            const bool Unsupported_OS_probably_Win31( false);
            assert( Unsupported_OS_probably_Win31);
            return EOS::Unknown;
        }
        else if( VER_PLATFORM_WIN32_WINDOWS== osvi.dwPlatformId)
            return EOS::Win9X;
        else if( VER_PLATFORM_WIN32_NT== osvi.dwPlatformId)
            return EOS::WinNT;
        else
        {
            const bool Unsupported_OS( false);
            assert( Unsupported_OS);
            return EOS::Unknown;
        }
    }

public: // Functions
    COSDetector():
        m_eOS( DetermineOS())
    { }
    ~COSDetector()
    { }
    EOS GetOS() const
    { return m_eOS; }
};
extern COSDetector g_OSDetector;

////////////////////////////////////////////////////////////////////////////////
//
// DDRAWI_XXX redefinitions
//
// Some DDRAWI_XXX structures differ depending on whether the binary is being
// compiled for Win9X or WinNT. We'll eliminate this difference, but to do so
// both OS structures need to be seperately defined. The structure which causes
// this is DDRAWI_DDRAWSURFACE_MORE. But for safety, more redefinition is done,
// to try to make developers aware of what's going on. 
//
////////////////////////////////////////////////////////////////////////////////

class PORTABLE_DDRAWSURFACE_LCL;
struct PORTABLE_ATTACHLIST
{
    DWORD                      dwFlags;
    PORTABLE_ATTACHLIST*       lpLink;
    PORTABLE_DDRAWSURFACE_LCL* lpAttached;  // attached surface local obj
    DDRAWI_DDRAWSURFACE_INT*   lpIAttached; // attached surface interface
};

class PORTABLE_DDRAWSURFACE_MORE;
class PORTABLE_DDRAWSURFACE_LCL
{
private:
    PORTABLE_DDRAWSURFACE_MORE*   m_lpSurfMore;
    LPDDRAWI_DDRAWSURFACE_GBL     m_lpGbl;
    ULONG_PTR                     m_hDDSurface;
    PORTABLE_ATTACHLIST*          m_lpAttachList;
    PORTABLE_ATTACHLIST*          m_lpAttachListFrom;
    DWORD                         m_dwLocalRefCnt;
    DWORD                         m_dwProcessId;
    DWORD                         m_dwFlags;
    DDSCAPS                       m_ddsCaps;
    union {
        LPDDRAWI_DDRAWPALETTE_INT m_lpDDPalette;
        LPDDRAWI_DDRAWPALETTE_INT m_lp16DDPalette;
    };
    union {
        LPDDRAWI_DDRAWCLIPPER_LCL m_lpDDClipper;
        LPDDRAWI_DDRAWCLIPPER_INT m_lp16DDClipper;
    };
    DWORD                         m_dwModeCreatedIn;
    DWORD                         m_dwBackBufferCount;
    DDCOLORKEY                    m_ddckCKDestBlt;
    DDCOLORKEY                    m_ddckCKSrcBlt;
    ULONG_PTR                     m_hDC;
    ULONG_PTR                     m_dwReserved1;
    DDCOLORKEY                    m_ddckCKSrcOverlay;
    DDCOLORKEY                    m_ddckCKDestOverlay;
    LPDDRAWI_DDRAWSURFACE_INT     m_lpSurfaceOverlaying;
    DBLNODE                       m_dbnOverlayNode;
    RECT                          m_rcOverlaySrc;
    RECT                          m_rcOverlayDest;
    DWORD                         m_dwClrXparent;
    DWORD                         m_dwAlpha;
    LONG                          m_lOverlayX;
    LONG                          m_lOverlayY;

public:
    PORTABLE_DDRAWSURFACE_MORE*& lpSurfMore()
    { return m_lpSurfMore; }
    LPDDRAWI_DDRAWSURFACE_GBL&   lpGbl()
    { return m_lpGbl; }
    ULONG_PTR&                   hDDSurface()
    { return m_hDDSurface; }
    PORTABLE_ATTACHLIST*&        lpAttachList()
    { return m_lpAttachList; }
    PORTABLE_ATTACHLIST*&        lpAttachListFrom()
    { return m_lpAttachListFrom; }
    DWORD&                       dwLocalRefCnt()
    { return m_dwLocalRefCnt; }
    DWORD&                       dwProcessId()
    { return m_dwProcessId; }
    DWORD&                       dwFlags()
    { return m_dwFlags; }
    DDSCAPS&                     ddsCaps()
    { return m_ddsCaps; }
    LPDDRAWI_DDRAWPALETTE_INT&   lpDDPalette()
    { return m_lpDDPalette; }
    LPDDRAWI_DDRAWPALETTE_INT&   lp16DDPalette()
    { return m_lp16DDPalette; }
    LPDDRAWI_DDRAWCLIPPER_LCL&   lpDDClipper()
    { return m_lpDDClipper; }
    LPDDRAWI_DDRAWCLIPPER_INT&   lp16DDClipper()
    { return m_lp16DDClipper; }
    DWORD&                       dwModeCreatedIn()
    { return m_dwModeCreatedIn; }
    DWORD&                       dwBackBufferCount()
    { return m_dwBackBufferCount; }
    DDCOLORKEY&                  ddckCKDestBlt()
    { return m_ddckCKDestBlt; }
    DDCOLORKEY&                  ddckCKSrcBlt()
    { return m_ddckCKSrcBlt; }
    ULONG_PTR&                   hDC()
    { return m_hDC; }
    ULONG_PTR&                   dwReserved1()
    { return m_dwReserved1; }
    DDCOLORKEY&                  ddckCKSrcOverlay()
    { return m_ddckCKSrcOverlay; }
    DDCOLORKEY&                  ddckCKDestOverlay()
    { return m_ddckCKDestOverlay; }
    LPDDRAWI_DDRAWSURFACE_INT&   lpSurfaceOverlaying()
    { return m_lpSurfaceOverlaying; }
    DBLNODE&                     dbnOverlayNode()
    { return m_dbnOverlayNode; }
    RECT&                        rcOverlaySrc()
    { return m_rcOverlaySrc; }
    RECT&                        rcOverlayDest()
    { return m_rcOverlayDest; }
    DWORD&                       dwClrXparent()
    { return m_dwClrXparent; }
    DWORD&                       dwAlpha()
    { return m_dwAlpha; }
    LONG&                        lOverlayX()
    { return m_lOverlayX; }
    LONG&                        lOverlayY()
    { return m_lOverlayY; }
};

class PORTABLE_DDRAWSURFACE_MORE
{
public:
    struct DDRAWI_DDRAWSURFACE_MORE_WIN9X
    {
        DWORD                       dwSize;
        IUNKNOWN_LIST FAR *         lpIUnknowns;
        LPDDRAWI_DIRECTDRAW_LCL     lpDD_lcl;
        DWORD                       dwPageLockCount;
        DWORD                       dwBytesAllocated;
        LPDDRAWI_DIRECTDRAW_INT     lpDD_int;
        DWORD                       dwMipMapCount;
        LPDDRAWI_DDRAWCLIPPER_INT   lpDDIClipper;
        LPHEAPALIASINFO             lpHeapAliasInfo;
        DWORD                       dwOverlayFlags;
        LPVOID                      rgjunc;
        LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;
        LPDDOVERLAYFX               lpddOverlayFX;
        DDSCAPSEX                   ddsCapsEx;
        DWORD                       dwTextureStage;
        LPVOID                      lpDDRAWReserved;
        LPVOID                      lpDDRAWReserved2;
        LPVOID                      lpDDrawReserved3;
        DWORD                       dwDDrawReserved4;
        LPVOID                      lpDDrawReserved5;
        LPDWORD                     lpGammaRamp;
        LPDWORD                     lpOriginalGammaRamp;
        LPVOID                      lpDDrawReserved6;
        DWORD                       dwSurfaceHandle;
        DWORD                       qwDDrawReserved8[2];
        LPVOID                      lpDDrawReserved9;
        DWORD                       cSurfaces;
        LPDDSURFACEDESC2            pCreatedDDSurfaceDesc2;
        PORTABLE_DDRAWSURFACE_LCL** slist;
        DWORD                       dwFVF;
        LPVOID                      lpVB;
    };
    struct DDRAWI_DDRAWSURFACE_MORE_WINNT
    {
        DWORD                       dwSize;
        IUNKNOWN_LIST FAR *         lpIUnknowns;
        LPDDRAWI_DIRECTDRAW_LCL     lpDD_lcl;
        DWORD                       dwPageLockCount;
        DWORD                       dwBytesAllocated;
        LPDDRAWI_DIRECTDRAW_INT     lpDD_int;
        DWORD                       dwMipMapCount;
        LPDDRAWI_DDRAWCLIPPER_INT   lpDDIClipper;
        LPHEAPALIASINFO             lpHeapAliasInfo;
        DWORD                       dwOverlayFlags;
        LPVOID                      rgjunc;
        LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;
        LPDDOVERLAYFX               lpddOverlayFX;
        DDSCAPSEX                   ddsCapsEx;
        DWORD                       dwTextureStage;
        LPVOID                      lpDDRAWReserved;
        LPVOID                      lpDDRAWReserved2;
        LPVOID                      lpDDrawReserved3;
        DWORD                       dwDDrawReserved4;
        LPVOID                      lpDDrawReserved5;
        LPDWORD                     lpGammaRamp;
        LPDWORD                     lpOriginalGammaRamp;
        LPVOID                      lpDDrawReserved6;
        DISPLAYMODEINFO             dmiDDrawReserved7;
        DWORD                       dwSurfaceHandle;
        DWORD                       qwDDrawReserved8[2];
        LPVOID                      lpDDrawReserved9;
        DWORD                       cSurfaces;
        LPDDSURFACEDESC2            pCreatedDDSurfaceDesc2;
        PORTABLE_DDRAWSURFACE_LCL** slist;
        DWORD                       dwFVF;
        LPVOID                      lpVB;
    };

private:
    union {
        DDRAWI_DDRAWSURFACE_MORE_WIN9X m_Win9X;
        DDRAWI_DDRAWSURFACE_MORE_WINNT m_WinNT;
    };

public:
    DWORD&                       dwSize()
    { return m_Win9X.dwSize; }
    IUNKNOWN_LIST FAR *&         lpIUnknowns()
    { return m_Win9X.lpIUnknowns; }
    LPDDRAWI_DIRECTDRAW_LCL&     lpDD_lcl()
    { return m_Win9X.lpDD_lcl; }
    DWORD&                       dwPageLockCount()
    { return m_Win9X.dwPageLockCount; }
    DWORD&                       dwBytesAllocated()
    { return m_Win9X.dwBytesAllocated; }
    LPDDRAWI_DIRECTDRAW_INT&     lpDD_int()
    { return m_Win9X.lpDD_int; }
    DWORD&                       dwMipMapCount()
    { return m_Win9X.dwMipMapCount; }
    LPDDRAWI_DDRAWCLIPPER_INT&   lpDDIClipper()
    { return m_Win9X.lpDDIClipper; }
    LPHEAPALIASINFO&             lpHeapAliasInfo()
    { return m_Win9X.lpHeapAliasInfo; }
    DWORD&                       dwOverlayFlags()
    { return m_Win9X.dwOverlayFlags; }
    LPVOID&                      rgjunc()
    { return m_Win9X.rgjunc; }
    LPDDRAWI_DDVIDEOPORT_LCL&    lpVideoPort()
    { return m_Win9X.lpVideoPort; }
    LPDDOVERLAYFX&               lpddOverlayFX()
    { return m_Win9X.lpddOverlayFX; }
    DDSCAPSEX&                   ddsCapsEx()
    { return m_Win9X.ddsCapsEx; }
    DWORD&                       dwTextureStage()
    { return m_Win9X.dwTextureStage; }
    LPVOID&                      lpDDRAWReserved()
    { return m_Win9X.lpDDRAWReserved; }
    LPVOID&                      lpDDRAWReserved2()
    { return m_Win9X.lpDDRAWReserved2; }
    LPVOID&                      lpDDrawReserved3()
    { return m_Win9X.lpDDrawReserved3; }
    DWORD&                       dwDDrawReserved4()
    { return m_Win9X.dwDDrawReserved4; }
    LPVOID&                      lpDDrawReserved5()
    { return m_Win9X.lpDDrawReserved5; }
    LPDWORD&                     lpGammaRamp()
    { return m_Win9X.lpGammaRamp; }
    LPDWORD&                     lpOriginalGammaRamp()
    { return m_Win9X.lpOriginalGammaRamp; }
    LPVOID&                      lpDDrawReserved6()
    { return m_Win9X.lpDDrawReserved6; }
    DWORD&                       dwSurfaceHandle()
    { switch( g_OSDetector.GetOS()) {
        case( COSDetector::Win9X): return m_Win9X.dwSurfaceHandle;
        case( COSDetector::WinNT): return m_WinNT.dwSurfaceHandle;
        default: assert( 2!= 2); return m_WinNT.dwSurfaceHandle;
    } }
    DWORD&                       qwDDrawReserved8_0_()
    { switch( g_OSDetector.GetOS()) {
        case( COSDetector::Win9X): return m_Win9X.qwDDrawReserved8[0];
        case( COSDetector::WinNT): return m_WinNT.qwDDrawReserved8[0];
        default: assert( 2!= 2); return m_WinNT.qwDDrawReserved8[0];
    } }
    DWORD&                       qwDDrawReserved8_1_()
    { switch( g_OSDetector.GetOS()) {
        case( COSDetector::Win9X): return m_Win9X.qwDDrawReserved8[1];
        case( COSDetector::WinNT): return m_WinNT.qwDDrawReserved8[1];
        default: assert( 2!= 2); return m_WinNT.qwDDrawReserved8[1];
    } }
    LPVOID&                      lpDDrawReserved9()
    { switch( g_OSDetector.GetOS()) {
        case( COSDetector::Win9X): return m_Win9X.lpDDrawReserved9;
        case( COSDetector::WinNT): return m_WinNT.lpDDrawReserved9;
        default: assert( 2!= 2); return m_WinNT.lpDDrawReserved9;
    } }
    DWORD&                       cSurfaces()
    { switch( g_OSDetector.GetOS()) {
        case( COSDetector::Win9X): return m_Win9X.cSurfaces;
        case( COSDetector::WinNT): return m_WinNT.cSurfaces;
        default: assert( 2!= 2); return m_WinNT.cSurfaces;
    } }
    LPDDSURFACEDESC2&            pCreatedDDSurfaceDesc2()
    { switch( g_OSDetector.GetOS()) {
        case( COSDetector::Win9X): return m_Win9X.pCreatedDDSurfaceDesc2;
        case( COSDetector::WinNT): return m_WinNT.pCreatedDDSurfaceDesc2;
        default: assert( 2!= 2); return m_WinNT.pCreatedDDSurfaceDesc2;
    } }
    PORTABLE_DDRAWSURFACE_LCL**& slist()
    { switch( g_OSDetector.GetOS()) {
        case( COSDetector::Win9X): return m_Win9X.slist;
        case( COSDetector::WinNT): return m_WinNT.slist;
        default: assert( 2!= 2); return m_WinNT.slist;
    } }
    DWORD&                       dwFVF()
    { switch( g_OSDetector.GetOS()) {
        case( COSDetector::Win9X): return m_Win9X.dwFVF;
        case( COSDetector::WinNT): return m_WinNT.dwFVF;
        default: assert( 2!= 2); return m_WinNT.dwFVF;
    } }
    LPVOID&                      lpVB()
    { switch( g_OSDetector.GetOS()) {
        case( COSDetector::Win9X): return m_Win9X.lpVB;
        case( COSDetector::WinNT): return m_WinNT.lpVB;
        default: assert( 2!= 2); return m_WinNT.lpVB;
    } }
};

class PORTABLE_CONTEXTCREATEDATA
{
private:
    union {
        LPDDRAWI_DIRECTDRAW_GBL    m_lpDDGbl;
        LPDDRAWI_DIRECTDRAW_LCL    m_lpDDLcl;
    };
    union {
        LPDIRECTDRAWSURFACE        m_lpDDS;
        PORTABLE_DDRAWSURFACE_LCL* m_lpDDSLcl;
    };
    union {
        LPDIRECTDRAWSURFACE        m_lpDDSZ;
        PORTABLE_DDRAWSURFACE_LCL* m_lpDDSZLcl;
    };
    union {
        DWORD                      m_dwPID;
        ULONG_PTR                  m_dwrstates;
    };
    ULONG_PTR                      m_dwhContext;
    HRESULT                        m_ddrval;

public:
    LPDDRAWI_DIRECTDRAW_GBL&        lpDDGbl()
    { return m_lpDDGbl; }
    LPDDRAWI_DIRECTDRAW_LCL&        lpDDLcl()
    { return m_lpDDLcl; }
    LPDIRECTDRAWSURFACE&            lpDDS()
    { return m_lpDDS; }
    PORTABLE_DDRAWSURFACE_LCL*&     lpDDSLcl()
    { return m_lpDDSLcl; }
    LPDIRECTDRAWSURFACE&            lpDDSZ()
    { return m_lpDDSZ; }
    PORTABLE_DDRAWSURFACE_LCL*&     lpDDSZLcl()
    { return m_lpDDSZLcl; }
    DWORD&                          dwPID()
    { return m_dwPID; }
    ULONG_PTR&                      dwrstates()
    { return m_dwrstates; }
    ULONG_PTR&                      dwhContext()
    { return m_dwhContext; }
    HRESULT&                        ddrval()
    { return m_ddrval; }
};

class PORTABLE_SETRENDERTARGETDATA
{
private:
    ULONG_PTR                      m_dwhContext;
    union {
        LPDIRECTDRAWSURFACE        m_lpDDS;
        PORTABLE_DDRAWSURFACE_LCL* m_lpDDSLcl;
    };
    union {
        LPDIRECTDRAWSURFACE        m_lpDDSZ;
        PORTABLE_DDRAWSURFACE_LCL* m_lpDDSZLcl;
    };
    HRESULT                        m_ddrval;

public:
    ULONG_PTR&                      dwhContext()
    { return m_dwhContext; }
    LPDIRECTDRAWSURFACE&            lpDDS()
    { return m_lpDDS; }
    PORTABLE_DDRAWSURFACE_LCL*&     lpDDSLcl()
    { return m_lpDDSLcl; }
    LPDIRECTDRAWSURFACE&            lpDDSZ()
    { return m_lpDDSZ; }
    PORTABLE_DDRAWSURFACE_LCL*&     lpDDSZLcl()
    { return m_lpDDSZLcl; }
    HRESULT&                        ddrval()
    { return m_ddrval; }
};

class PORTABLE_DRAWPRIMITIVES2DATA
{
private:
    ULONG_PTR                      m_dwhContext;
    DWORD                          m_dwFlags;
    DWORD                          m_dwVertexType;
    PORTABLE_DDRAWSURFACE_LCL*     m_lpDDCommands;
    DWORD                          m_dwCommandOffset;
    DWORD                          m_dwCommandLength;
    union {
        PORTABLE_DDRAWSURFACE_LCL* m_lpDDVertex;
        LPVOID                     m_lpVertices;
    };
    DWORD                          m_dwVertexOffset;
    DWORD                          m_dwVertexLength;
    DWORD                          m_dwReqVertexBufSize;
    DWORD                          m_dwReqCommandBufSize;
    LPDWORD                        m_lpdwRStates;
    union {
        DWORD                      m_dwVertexSize;
        HRESULT                    m_ddrval;
    };
    DWORD                          m_dwErrorOffset;

public:
    ULONG_PTR&                      dwhContext()
    { return m_dwhContext; }
    DWORD&                          dwFlags()
    { return m_dwFlags; }
    DWORD&                          dwVertexType()
    { return m_dwVertexType; }
    PORTABLE_DDRAWSURFACE_LCL*&     lpDDCommands()
    { return m_lpDDCommands; }
    DWORD&                          dwCommandOffset()
    { return m_dwCommandOffset; }
    DWORD&                          dwCommandLength()
    { return m_dwCommandLength; }
    PORTABLE_DDRAWSURFACE_LCL*&     lpDDVertex()
    { return m_lpDDVertex; }
    LPVOID&                         lpVertices()
    { return m_lpVertices; }
    DWORD&                          dwVertexOffset()
    { return m_dwVertexOffset; }
    DWORD&                          dwVertexLength()
    { return m_dwVertexLength; }
    DWORD&                          dwReqVertexBufSize()
    { return m_dwReqVertexBufSize; }
    DWORD&                          dwReqCommandBufSize()
    { return m_dwReqCommandBufSize; }    
    LPDWORD&                        lpdwRStates()
    { return m_lpdwRStates; }
    DWORD&                          dwVertexSize()
    { return m_dwVertexSize; }
    HRESULT&                        ddrval()
    { return m_ddrval; }
    DWORD&                          dwErrorOffset()
    { return m_dwErrorOffset; }
};

class PORTABLE_CREATESURFACEEXDATA
{
private:
    DWORD                       m_dwFlags;
    LPDDRAWI_DIRECTDRAW_LCL     m_lpDDLcl;
    PORTABLE_DDRAWSURFACE_LCL*  m_lpDDSLcl;
    HRESULT                     m_ddRVal;

public:
    DWORD&                       dwFlags()
    { return m_dwFlags; }
    LPDDRAWI_DIRECTDRAW_LCL&     lpDDLcl()
    { return m_lpDDLcl; }
    PORTABLE_DDRAWSURFACE_LCL*&  lpDDSLcl()
    { return m_lpDDSLcl; }
    HRESULT&                     ddRVal()
    { return m_ddRVal; }
};

class PORTABLE_CREATESURFACEDATA
{
private:
    LPDDRAWI_DIRECTDRAW_GBL     m_lpDD;
    LPDDSURFACEDESC             m_lpDDSurfaceDesc;
    PORTABLE_DDRAWSURFACE_LCL** m_lplpSList;
    DWORD                       m_dwSCnt;
    HRESULT                     m_ddRVal;
    LPDDHAL_CREATESURFACE       m_CreateSurface;

public:
    LPDDRAWI_DIRECTDRAW_GBL&     lpDD()
    { return m_lpDD; }
    LPDDSURFACEDESC&             lpDDSurfaceDesc()
    { return m_lpDDSurfaceDesc; }
    PORTABLE_DDRAWSURFACE_LCL**& lplpSList()
    { return m_lplpSList; }
    DWORD&                       dwSCnt()
    { return m_dwSCnt; }
    HRESULT&                     ddRVal()
    { return m_ddRVal; }
    LPDDHAL_CREATESURFACE&       CreateSurface()
    { return m_CreateSurface; }
};

class PORTABLE_DESTROYSURFACEDATA
{
private:
    LPDDRAWI_DIRECTDRAW_GBL      m_lpDD;
    PORTABLE_DDRAWSURFACE_LCL*   m_lpDDSurface;
    HRESULT                      m_ddRVal;
    LPDDHALSURFCB_DESTROYSURFACE m_DestroySurface;

public:
    LPDDRAWI_DIRECTDRAW_GBL&      lpDD()
    { return m_lpDD; }
    PORTABLE_DDRAWSURFACE_LCL*&   lpDDSurface()
    { return m_lpDDSurface; }
    HRESULT&                      ddRVal()
    { return m_ddRVal; }
    LPDDHALSURFCB_DESTROYSURFACE& DestroySurface()
    { return m_DestroySurface; }
};

class PORTABLE_LOCKDATA
{
private:
    LPDDRAWI_DIRECTDRAW_GBL    m_lpDD;
    PORTABLE_DDRAWSURFACE_LCL* m_lpDDSurface;
    DWORD                      m_bHasRect;
    RECTL                      m_rArea;
    LPVOID                     m_lpSurfData;
    HRESULT                    m_ddRVal;
    LPDDHALSURFCB_LOCK         m_Lock;
    DWORD                      m_dwFlags;

public:
    LPDDRAWI_DIRECTDRAW_GBL&    lpDD()
    { return m_lpDD; }
    PORTABLE_DDRAWSURFACE_LCL*& lpDDSurface()
    { return m_lpDDSurface; }
    DWORD&                      bHasRect()
    { return m_bHasRect; }
    RECTL&                      rArea()
    { return m_rArea; }
    LPVOID&                     lpSurfData()
    { return m_lpSurfData; }
    HRESULT&                    ddRVal()
    { return m_ddRVal; }
    LPDDHALSURFCB_LOCK&         Lock()
    { return m_Lock; }
    DWORD&                      dwFlags()
    { return m_dwFlags; }
};

class PORTABLE_UNLOCKDATA
{
private:
    LPDDRAWI_DIRECTDRAW_GBL    m_lpDD;
    PORTABLE_DDRAWSURFACE_LCL* m_lpDDSurface;
    HRESULT                    m_ddRVal;
    LPDDHALSURFCB_UNLOCK       m_Unlock;

public:
    LPDDRAWI_DIRECTDRAW_GBL&    lpDD()
    { return m_lpDD; }
    PORTABLE_DDRAWSURFACE_LCL*& lpDDSurface()
    { return m_lpDDSurface; }
    HRESULT&                    ddRVal()
    { return m_ddRVal; }
    LPDDHALSURFCB_UNLOCK&       Unlock()
    { return m_Unlock; }
};

////////////////////////////////////////////////////////////////////////////////
//
// CSurfaceLocker
//
// This class safely locks a surface upon construction and unlocks the surface
// upon destruction. 
//
////////////////////////////////////////////////////////////////////////////////
template< class TSurfacePtr>
class CSurfaceLocker
{
protected: // Variables
    TSurfacePtr m_pSurface;
    void* m_pSData;

public: // Functions
    explicit CSurfaceLocker( const TSurfacePtr& S, DWORD dwLockFlags,
        const RECTL* pRect) : m_pSurface( S)
    { m_pSData= m_pSurface->Lock( dwLockFlags, pRect); }
    ~CSurfaceLocker() 
    { m_pSurface->Unlock(); }
    void* const& GetData() const 
    { return m_pSData; }
};

////////////////////////////////////////////////////////////////////////////////
//
// CEnsureFPUModeForC
//
// This class converts the FPU mode for x86 chips back into the mode compatable
// for C operations. The mode that D3D sets up for rasterizers is single
// precision, for more speed. But, sometimes, the rasterizer needs to do
// double operations and get double precision accuracy. This class sets up the
// mode for as long as the class is in scope.
//
////////////////////////////////////////////////////////////////////////////////
class CEnsureFPUModeForC
{
protected: // Variables
    WORD m_wSaveFP;

public:
    CEnsureFPUModeForC() 
    {
#if defined(_X86_)
        // save floating point mode and set to double precision mode
        // which is compatable with C/ C++
        WORD wTemp, wSave;
        __asm
        {
            fstcw   wSave
            mov ax, wSave
            or ax, 0200h
            mov wTemp, ax
            fldcw   wTemp
        }
        m_wSaveFP= wSave;
#endif
    }
    ~CEnsureFPUModeForC() 
    {
#if defined(_X86_)
        WORD wSave( m_wSaveFP);
        __asm fldcw wSave
#endif
    }
};

////////////////////////////////////////////////////////////////////////////////
//
// SDP2NextCmd
//
// A unary_function which can return the pointer to the next
// DrawPrimitive2 command in a contiguous buffer given a pointer to a valid
// DrawPrimitive2 command in the same buffer, as is a common situation for
// processing DrawPrimitive2 commands within the DrawPrimitive2 function call.
// This class is naturally useful for DrawPrimitive2 command iterators.
// It contains all the possible commands that could be encountered for a DX8SDDI
// driver.
//
////////////////////////////////////////////////////////////////////////////////
struct SDP2NextCmd:
    public unary_function< const D3DHAL_DP2COMMAND*, D3DHAL_DP2COMMAND*>
{
    // This function allows iteration from one D3DHAL_DP2COMMAND* to the next.
    // This operation can be optimized quite a bit if many of the more advanced
    // features aren't supported (as tough to process D3DDP2_OPs might not be
    // encountered).
    D3DHAL_DP2COMMAND* operator()( const D3DHAL_DP2COMMAND* pCur) const 
    {
        const UINT8* pBRet= reinterpret_cast< const UINT8*>(pCur)+
            sizeof( D3DHAL_DP2COMMAND);
        switch( pCur->bCommand)
        {
        //case( D3DDP2OP_POINTS): // <DX8
        //case( D3DDP2OP_INDEXEDLINELIST): // <DX8
        //case( D3DDP2OP_INDEXEDTRIANGLELIST): // <DX8
        //case( D3DDP2OP_RESERVED0): 
        case( D3DDP2OP_RENDERSTATE): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2RENDERSTATE)* pCur->wStateCount;
            break;
        //case( D3DDP2OP_LINELIST): // <DX8
        //case( D3DDP2OP_LINESTRIP): // <DX8
        //case( D3DDP2OP_INDEXEDLINESTRIP): // <DX8
        //case( D3DDP2OP_TRIANGLELIST): // <DX8
        //case( D3DDP2OP_TRIANGLESTRIP): // <DX8
        //case( D3DDP2OP_INDEXEDTRIANGLESTRIP): // <DX8
        //case( D3DDP2OP_TRIANGLEFAN): // <DX8
        //case( D3DDP2OP_INDEXEDTRIANGLEFAN): // <DX8
        //case( D3DDP2OP_TRIANGLEFAN_IMM): // <DX8
        //case( D3DDP2OP_LINELIST_IMM): // <DX8
        case( D3DDP2OP_TEXTURESTAGESTATE): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2TEXTURESTAGESTATE)* pCur->wStateCount;
            break;
        //case( D3DDP2OP_INDEXEDTRIANGLELIST2): // <DX8
        //case( D3DDP2OP_INDEXEDLINELIST2): // <DX8
        case( D3DDP2OP_VIEWPORTINFO): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2VIEWPORTINFO)* pCur->wStateCount;
            break;
        case( D3DDP2OP_WINFO): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2WINFO)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETPALETTE): // DX8 (if support palettized surf/tex)
            pBRet+= sizeof( D3DHAL_DP2SETPALETTE)* pCur->wStateCount;
            break;
        case( D3DDP2OP_UPDATEPALETTE): // DX8 (if support palettized surf/tex)
            assert( pCur->wStateCount== 1);
            pBRet= pBRet+ sizeof( D3DHAL_DP2UPDATEPALETTE)+
                reinterpret_cast< const D3DHAL_DP2UPDATEPALETTE*>(
                pBRet)->wNumEntries* sizeof( DWORD);
            break;
        case( D3DDP2OP_ZRANGE): // DX8 (if support TnL)
            pBRet+= sizeof( D3DHAL_DP2ZRANGE)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETMATERIAL): // DX8 (if support TnL)
            pBRet+= sizeof( D3DHAL_DP2SETMATERIAL)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETLIGHT): // DX8 (if support TnL)
            { WORD wStateCount( pCur->wStateCount);
            if( wStateCount!= 0) do
            {
                const D3DHAL_DP2SETLIGHT* pSL=
                    reinterpret_cast< const D3DHAL_DP2SETLIGHT*>( pBRet);

                if( D3DHAL_SETLIGHT_DATA== pSL->dwDataType)
                    pBRet+= sizeof( D3DLIGHT8);
                pBRet+= sizeof( D3DHAL_DP2SETLIGHT);
            } while( --wStateCount); }
            break;
        case( D3DDP2OP_CREATELIGHT): // DX8 (if support TnL)
            pBRet+= sizeof( D3DHAL_DP2CREATELIGHT)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETTRANSFORM): // DX8 (if support TnL)
            pBRet+= sizeof( D3DHAL_DP2SETTRANSFORM)* pCur->wStateCount;
            break;
        case( D3DDP2OP_EXT): // DX8 (if work seemlessly with TnL extensions)
            { WORD wStateCount( pCur->wStateCount);
            if( wStateCount!= 0) do
            {
                pBRet+= reinterpret_cast< const D3DHAL_DP2EXT*>(pBRet)->dwSize;
            } while( --wStateCount); }
            break;
        case( D3DDP2OP_TEXBLT): // DX8 (if support vidmem texture)
            pBRet+= sizeof( D3DHAL_DP2TEXBLT)* pCur->wStateCount;
            break;
        case( D3DDP2OP_STATESET): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2STATESET)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETPRIORITY): // DX8 (if manage textures)
            pBRet+= sizeof( D3DHAL_DP2SETPRIORITY)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETRENDERTARGET): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2SETRENDERTARGET)* pCur->wStateCount;
            break;
        case( D3DDP2OP_CLEAR): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2CLEAR)- sizeof( RECT)+ sizeof( RECT)*
                pCur->wStateCount;
            break;
        case( D3DDP2OP_SETTEXLOD): // DX8 (if manage textures)
            pBRet+= sizeof( D3DHAL_DP2SETTEXLOD)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETCLIPPLANE): // DX8 (if support user clip planes)
            pBRet+= sizeof( D3DHAL_DP2SETCLIPPLANE)* pCur->wStateCount;
            break;
        case( D3DDP2OP_CREATEVERTEXSHADER): // DX8 (if support vshaders)
            { WORD wStateCount( pCur->wStateCount);
            if( wStateCount!= 0) do
            {
                const D3DHAL_DP2CREATEVERTEXSHADER* pCVS=
                    reinterpret_cast< const D3DHAL_DP2CREATEVERTEXSHADER*>(
                    pBRet);
                pBRet+= sizeof( D3DHAL_DP2CREATEVERTEXSHADER)+
                    pCVS->dwDeclSize+ pCVS->dwCodeSize;
            } while( --wStateCount); }
            break;
        case( D3DDP2OP_DELETEVERTEXSHADER): // DX8 (if support vshaders)
            pBRet+= sizeof( D3DHAL_DP2VERTEXSHADER)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETVERTEXSHADER): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2VERTEXSHADER)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETVERTEXSHADERCONST): // DX8 (if support vshaders)
            { WORD wStateCount( pCur->wStateCount);
            if( wStateCount!= 0) do
            {
                const D3DHAL_DP2SETVERTEXSHADERCONST* pSVSC=
                    reinterpret_cast< const D3DHAL_DP2SETVERTEXSHADERCONST*>(
                    pBRet);
                pBRet+= sizeof( D3DHAL_DP2SETVERTEXSHADERCONST)+
                    4* sizeof( D3DVALUE)* pSVSC->dwCount;
            } while( --wStateCount); }
            break;
        case( D3DDP2OP_SETSTREAMSOURCE): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2SETSTREAMSOURCE)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETSTREAMSOURCEUM): // DX8 All (unless no DrawPrimUP calls)
            pBRet+= sizeof( D3DHAL_DP2SETSTREAMSOURCEUM)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETINDICES): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2SETINDICES)* pCur->wStateCount;
            break;
        case( D3DDP2OP_DRAWPRIMITIVE): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2DRAWPRIMITIVE)* pCur->wPrimitiveCount;
            break;
        case( D3DDP2OP_DRAWINDEXEDPRIMITIVE): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2DRAWINDEXEDPRIMITIVE)*
                pCur->wPrimitiveCount;
            break;
        case( D3DDP2OP_CREATEPIXELSHADER): // DX8 (if support pshaders)
            { WORD wStateCount( pCur->wStateCount);
            if( wStateCount!= 0) do
            {
                const D3DHAL_DP2CREATEPIXELSHADER* pCPS=
                    reinterpret_cast< const D3DHAL_DP2CREATEPIXELSHADER*>(
                    pBRet);
                pBRet+= sizeof( D3DHAL_DP2CREATEPIXELSHADER)+
                    pCPS->dwCodeSize;
            } while( --wStateCount); }
            break;
        case( D3DDP2OP_DELETEPIXELSHADER): // DX8 (if support pshaders)
            pBRet+= sizeof( D3DHAL_DP2PIXELSHADER)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETPIXELSHADER): // DX8 (if support pshaders)
            pBRet+= sizeof( D3DHAL_DP2PIXELSHADER)* pCur->wStateCount;
            break;
        case( D3DDP2OP_SETPIXELSHADERCONST): // DX8 (if support pshaders)
            { WORD wStateCount( pCur->wStateCount);
            if( wStateCount!= 0) do
            {
                const D3DHAL_DP2SETPIXELSHADERCONST* pSPSC=
                    reinterpret_cast< const D3DHAL_DP2SETPIXELSHADERCONST*>(
                    pBRet);
                pBRet+= sizeof( D3DHAL_DP2SETPIXELSHADERCONST)+
                    4* sizeof( D3DVALUE)* pSPSC->dwCount;
            } while( --wStateCount); }
            break;
        case( D3DDP2OP_CLIPPEDTRIANGLEFAN): // DX8 All
            pBRet+= sizeof( D3DHAL_CLIPPEDTRIANGLEFAN)* pCur->wPrimitiveCount;
            break;
        case( D3DDP2OP_DRAWPRIMITIVE2): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2DRAWPRIMITIVE2)* pCur->wPrimitiveCount;
            break;
        case( D3DDP2OP_DRAWINDEXEDPRIMITIVE2): // DX8 All
            pBRet+= sizeof( D3DHAL_DP2DRAWINDEXEDPRIMITIVE2)*
                pCur->wPrimitiveCount;
            break;
        case( D3DDP2OP_DRAWRECTPATCH): // DX8 (if support higher order prims)
            { WORD wPrimitiveCount( pCur->wPrimitiveCount);
            if( wPrimitiveCount!= 0) do
            {
                const D3DHAL_DP2DRAWRECTPATCH* pDRP= 
                    reinterpret_cast< const D3DHAL_DP2DRAWRECTPATCH*>(pBRet);

                pBRet+= sizeof( D3DHAL_DP2DRAWRECTPATCH);

                if((pDRP->Flags& RTPATCHFLAG_HASSEGS)!= 0)
                    pBRet+= 4* sizeof( D3DVALUE);

                if((pDRP->Flags& RTPATCHFLAG_HASINFO)!= 0)
                    pBRet+= sizeof( D3DRECTPATCH_INFO);
            } while( --wPrimitiveCount); }
            break;
        case( D3DDP2OP_DRAWTRIPATCH): // DX8 (if support higher order prims)
            { WORD wPrimitiveCount( pCur->wPrimitiveCount);
            if( wPrimitiveCount!= 0) do
            {
                const D3DHAL_DP2DRAWTRIPATCH* pDTP= 
                    reinterpret_cast< const D3DHAL_DP2DRAWTRIPATCH*>(pBRet);

                pBRet+= sizeof( D3DHAL_DP2DRAWTRIPATCH);

                if((pDTP->Flags& RTPATCHFLAG_HASSEGS)!= 0)
                    pBRet+= 3* sizeof( D3DVALUE);

                if((pDTP->Flags& RTPATCHFLAG_HASINFO)!= 0)
                    pBRet+= sizeof( D3DTRIPATCH_INFO);
            } while( --wPrimitiveCount); }
            break;
        case( D3DDP2OP_VOLUMEBLT): // DX8 (if support vidmem volume texture)
            pBRet+= sizeof( D3DHAL_DP2VOLUMEBLT)* pCur->wStateCount;
            break;
        case( D3DDP2OP_BUFFERBLT): // DX8 (if support vidmem vrtx/indx buffer)
            pBRet+= sizeof( D3DHAL_DP2BUFFERBLT)* pCur->wStateCount;
            break;
        case( D3DDP2OP_MULTIPLYTRANSFORM): // DX8 (if support TnL)
            pBRet+= sizeof( D3DHAL_DP2MULTIPLYTRANSFORM)* pCur->wStateCount;
            break;
        default: {
            const bool Unable_To_Parse_Unrecognized_D3DDP2OP( false);
            assert( Unable_To_Parse_Unrecognized_D3DDP2OP);
            } break;
        }
        return const_cast<D3DHAL_DP2COMMAND*>
            (reinterpret_cast<const D3DHAL_DP2COMMAND*>(pBRet));
    }
};

////////////////////////////////////////////////////////////////////////////////
//
// CDP2CmdIterator & CDP2ConstCmdIterator
//
// These iterators are provided as a convenience to iterate DrawPrimitive2
// commands which are packed in a contiguous chunk of memory, as is typical
// of execute/ command buffers which need to be processed within the
// DrawPrimitive2 function call. The actual iteration logic is encapsulated in
// the template parameter, so that it can be easily extended, if certain
// commands aren't exepected and a better iteration scheme could be used.
//
// Be careful, these iterators are only useful for iterating. They do not
// directly know the size of the data they point to. For completeness, which
// would allow seperate storage of commands, another class would need to be
// created and assigned as the value_type. Dereferencing the iterator only
// returns a D3DHAL_DP2COMMAND without any extra data. Something like:
//
// CDP2Cmd DP2Cmd= *itDP2Cmd; 
//
// is possible; but requires more work and definition of CDP2Cmd.
//
////////////////////////////////////////////////////////////////////////////////
template< class TNextCmd= SDP2NextCmd>
class CDP2CmdIterator
{
public: // Types
    typedef forward_iterator_tag iterator_category;
    typedef D3DHAL_DP2COMMAND    value_type;
    typedef ptrdiff_t            difference_type;
    typedef D3DHAL_DP2COMMAND*   pointer;
    typedef D3DHAL_DP2COMMAND&   reference;

protected: // Variables
    pointer m_pRawCmd;
    TNextCmd m_NextCmd;

public: // Functions
    CDP2CmdIterator( pointer pRaw= NULL) 
        :m_pRawCmd( pRaw) { }
    CDP2CmdIterator( pointer pRaw, const TNextCmd& NextCmd) 
        :m_NextCmd( NextCmd), m_pRawCmd( pRaw) { }
    CDP2CmdIterator( const CDP2CmdIterator< TNextCmd>& Other) 
        :m_NextCmd( Other.m_NextCmd), m_pRawCmd( Other.m_pRawCmd) { }

    reference operator*() const 
    { return *m_pRawCmd; }
    pointer operator->() const 
    { return m_pRawCmd; }
    operator pointer() const 
    { return m_pRawCmd; }

    CDP2CmdIterator< TNextCmd>& operator++() 
    { m_pRawCmd= m_NextCmd( m_pRawCmd); return *this; }
    CDP2CmdIterator< TNextCmd> operator++(int) 
    {
        CDP2CmdIterator< TNextCmd> tmp= *this;
        m_pRawCmd= m_NextCmd( m_pRawCmd);
        return tmp;
    }
    bool operator==( CDP2CmdIterator< TNextCmd>& x) const 
    { return m_pRawCmd== x.m_pRawCmd; }
    bool operator!=( CDP2CmdIterator< TNextCmd>& x) const 
    { return m_pRawCmd!= x.m_pRawCmd; }
};

template< class TNextCmd= SDP2NextCmd>
class CConstDP2CmdIterator
{
public: // Types
    typedef forward_iterator_tag     iterator_category;
    typedef const D3DHAL_DP2COMMAND  value_type;
    typedef ptrdiff_t                difference_type;
    typedef const D3DHAL_DP2COMMAND* pointer;
    typedef const D3DHAL_DP2COMMAND& reference;

protected: // Variables
    pointer m_pRawCmd;
    TNextCmd m_NextCmd;

public: // Functions
    CConstDP2CmdIterator( pointer pRaw= NULL) 
        :m_pRawCmd( pRaw) { }
    CConstDP2CmdIterator( pointer pRaw, const TNextCmd& NextCmd) 
        :m_NextCmd( NextCmd), m_pRawCmd( pRaw) { }
    CConstDP2CmdIterator( const CDP2CmdIterator< TNextCmd>& Other) 
        :m_NextCmd( Other.m_NextCmd), m_pRawCmd( Other.m_pRawCmd) { }
    CConstDP2CmdIterator( const CConstDP2CmdIterator< TNextCmd>& Other) 
        :m_NextCmd( Other.m_NextCmd), m_pRawCmd( Other.m_pRawCmd) { }

    reference operator*() const 
    { return *m_pRawCmd; }
    pointer operator->() const 
    { return m_pRawCmd; }
    operator pointer() const 
    { return m_pRawCmd; }

    CConstDP2CmdIterator< TNextCmd>& operator++() 
    { m_pRawCmd= m_NextCmd( m_pRawCmd); return *this; }
    CConstDP2CmdIterator< TNextCmd> operator++(int) 
    {
        CConstDP2CmdIterator< TNextCmd> tmp= *this;
        m_pRawCmd= m_NextCmd( m_pRawCmd);
        return tmp;
    }
    bool operator==( CConstDP2CmdIterator< TNextCmd>& x) const 
    { return m_pRawCmd== x.m_pRawCmd; }
    bool operator!=( CConstDP2CmdIterator< TNextCmd>& x) const 
    { return m_pRawCmd!= x.m_pRawCmd; }
};

////////////////////////////////////////////////////////////////////////////////
//
// CDP2DataWrap
//
// This class is provided as a convenience to expose the
// PORTABLE_DRAWPRIMITIVES2DATA as a more friendly class. Mostly, it wraps the
// execute/ command buffer with an STL Sequence Container, so that the commands
// can be iterated over without copying and pre-parsing the command data.
//
// <Template Parameters>
// TNextCmd: a unary_function which takes a const D3DHAL_DP2COMMAND* in and
//     returns a D3DHAL_DP2COMMAND* which points to the next command. In
//     essence, a unary_function which enables a forward iterator on a
//     contiguous command buffer.
//
// <Exposed Types>
// TCmds: The Sequence Container type which exposed the commands.
//
// <Exposed Functions>
// CDP2DataWrap( PORTABLE_DRAWPRIMITIVES2DATA& DP2Data): Constructor to wrap the
//     PORTABLE_DRAWPRIMITIVES2DATA.
// const TCmds& GetCommands() const: Accessor function to get at the Sequence
//     Container.
//     
////////////////////////////////////////////////////////////////////////////////
template< class TNextCmd= SDP2NextCmd>
class CDP2DataWrap:
    public PORTABLE_DRAWPRIMITIVES2DATA
{
public: // Types
    class CDP2Cmds
    {
    public: // Types
        typedef CConstDP2CmdIterator< TNextCmd>          const_iterator;
        typedef typename const_iterator::value_type      value_type;
        typedef typename const_iterator::reference       const_reference;
        typedef typename const_iterator::pointer         const_pointer;
        typedef typename const_iterator::difference_type difference_type;
        typedef size_t                                   size_type;

    protected: // Variables
        CDP2DataWrap< TNextCmd>* m_pDP2Data;

    protected: // Functions
        // Allow to call constructor and set member variable.
        friend class CDP2DataWrap< TNextCmd>;

        CDP2Cmds( ) 
            :m_pDP2Data( NULL) { }

    public: // Functions
        const_iterator begin( void) const 
        {
            return const_iterator( reinterpret_cast<D3DHAL_DP2COMMAND*>(
                reinterpret_cast<UINT8*>(m_pDP2Data->lpDDCommands()->lpGbl()->fpVidMem)
                + m_pDP2Data->dwCommandOffset()));
        }
        const_iterator end( void) const 
        {
            return const_iterator( reinterpret_cast<D3DHAL_DP2COMMAND*>(
                reinterpret_cast<UINT8*>(m_pDP2Data->lpDDCommands()->lpGbl()->fpVidMem)
                + m_pDP2Data->dwCommandOffset()+ m_pDP2Data->dwCommandLength()));
        }
        size_type size( void) const 
        {
            size_type N( 0);
            const_iterator itS( begin());
            const_iterator itE( end());
            while( itS!= itE)
            { ++itS; ++N; }
            return N;
        }
        size_type max_size( void) const 
        { return size(); }
        bool empty( void) const 
        { return begin()== end(); }
    };
    typedef CDP2Cmds TCmds;

protected: // Variables
    TCmds m_Cmds;

public: // Functions
    explicit CDP2DataWrap( PORTABLE_DRAWPRIMITIVES2DATA& DP2Data) 
        : PORTABLE_DRAWPRIMITIVES2DATA( DP2Data)
    { m_Cmds.m_pDP2Data= this; }
    const TCmds& GetCommands( void) const 
    { return m_Cmds; }
};

////////////////////////////////////////////////////////////////////////////////
//
// SDP2MFnParser
//
// This class is a functional class, with many too many paramters to squeeze
// into the standard functional classes. It automates the parsing, member fn
// lookup, and dispatching for DrawPrimitive2 commands. This parser uses the
// command number to lookup a member function from a container to call.
//
////////////////////////////////////////////////////////////////////////////////
struct SDP2MFnParser
{
    // <Parameters>
    // MFnCaller: A binary_function type with TDP2CmdFnCtr::value_type,
    //     typically a member function pointer, as the first argument;
    //     TIter, typically a smart DP2 command iterator, as the second
    //     argument; and returns an HRESULT. This function type should call
    //     the member function to process the DP2 command, with the iterator
    //     used to determine the DP2 Cmd data.
    // DP2CmdFnCtr: This can be any Unique, Pair Associative Container,
    //     typically a map, which associates a D3DHAL_DP2OPERATION with a
    //     member function.
    // [itStart, itEnd): These iterators define a standard range of
    //     D3DHAL_DP2COMMAND. The iterators need only be forward iterators,
    //     and be convertable to raw D3DHAL_DP2COMMAND*. Note: itStart is
    //     a reference, so that the caller can determine the current iterator
    //     position upon return of function (when HRESULT!= DD_OK).
    template< class TMFnCaller, class TDP2CmdFnCtr, class TIter>
    HRESULT ParseDP2( TMFnCaller& MFnCaller, TDP2CmdFnCtr& DP2CmdFnCtr,
        TIter& itStart, TIter itEnd) const 
    {
        HRESULT hr( DD_OK);
        while( itStart!= itEnd)
        {
            try
            {
                hr= MFnCaller( DP2CmdFnCtr[ itStart->bCommand], itStart);
            } catch( HRESULT hrEx) {
                hr= hrEx;
#if !defined( DX8SDDIFW_NOCATCHALL)
            } catch ( ... ) {
                const bool Unrecognized_Exception_In_A_DP2_Op_Function( false);
                assert( Unrecognized_Exception_In_A_DP2_Op_Function);
                hr= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
            }

            // Only move on to next command if DD_OK. Otherwise return out
            // to caller. They can always call us back if caller determines
            // error code is a SUCCESS.
            if( DD_OK== hr)
                ++itStart;
            else
                break;
        }
        return hr;
    }
};

////////////////////////////////////////////////////////////////////////////////
//
// CSubStateSet & CMinimalStateSet
//
// This class contains a default implementation of a stateset. It copies/ packs
// a contiguous DP2 command buffer into a memory buffer. To capture, it asks
// the context to record the command buffer with the Context's current state.
// To execute, it fixes up a Fake DrawPrimitives2 point parameter
// and calls the context's DrawPrimitives2 entry point. The context
// needs to be able to handle recursive DrawPrimitives2 calls in order to use
// this default stateset. CStdDrawPrimitives2's DrawPrimitives2 handler
// does this by storing whether it is executing a stateset.
//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyStateSet type.
// TC: The Context type, typically, CMyContext.
//
// <Exposed Types>
// TContext: The Context type passed in as a template parameter.
//
// <Exposed Functions>
// CSubStateSet( TContext&, const D3DHAL_DP2COMMAND*, const D3DHAL_DP2COMMAND*):
//     The constructor which builds a stateset for a Context, from a range of
//     a command buffer. The default implementation will just copy this range.
// CSubStateSet( const CSubStateSet& Other): Standard copy constructor.
// void Capture( TContext&): The state set is instructed to capture the
//     necessary data from the Context, in order to perform an Execute later,
//     which will restore the data fields or state that the state set was
//     constructed with.
// void Execute( TContext&): Restore or rebuild the Context with the data/
//     state that was saved during the Capture operation.
//
////////////////////////////////////////////////////////////////////////////////
template< class TSuper, class TC>
class CSubStateSet
{
public: // Types
    typedef TC TContext;

protected: // Variables
    TContext& m_Context;
    D3DHAL_DP2COMMAND* m_pBeginSS;
    size_t m_uiSSBufferSize;

protected: // Functions
    CSubStateSet( const CSubStateSet< TSuper, TC>& Other)
        :m_Context( Other.m_Context), m_pBeginSS( NULL),
        m_uiSSBufferSize( Other.m_uiSSBufferSize)
    {
        try {
            m_pBeginSS= reinterpret_cast< D3DHAL_DP2COMMAND*>(
                operator new( m_uiSSBufferSize));
        } catch( ... ) {
        }
        if( NULL== m_pBeginSS)
            throw bad_alloc( "Not enough room to copy state set command "
                "buffer.");
        memcpy( m_pBeginSS, Other.m_pBeginSS, m_uiSSBufferSize);
    }
    CSubStateSet( TContext& C, const D3DHAL_DP2COMMAND* pBeginSS, const
        D3DHAL_DP2COMMAND* pEndSS) : m_Context( C), m_pBeginSS( NULL),
        m_uiSSBufferSize( 0)
    {
        // Convert the contiguous command pointers to byte pointers, to
        // calculate the size of buffer needed to copy the data.
        const UINT8* pSBytePtr= reinterpret_cast< const UINT8*>( pBeginSS);
        const UINT8* pEBytePtr= reinterpret_cast< const UINT8*>( pEndSS);
        m_uiSSBufferSize= static_cast< size_t>( pEBytePtr- pSBytePtr);
        try {
            m_pBeginSS= reinterpret_cast< D3DHAL_DP2COMMAND*>(
                operator new( m_uiSSBufferSize));
        } catch( ... ) {
        }
        if( NULL== m_pBeginSS)
            throw bad_alloc( "Not enough room to allocate state set command "
                "buffer.");
        memcpy( m_pBeginSS, pBeginSS, m_uiSSBufferSize);
    }
    ~CSubStateSet()
    {
        operator delete( static_cast< void*>( m_pBeginSS));
    }

public: // Functions
    CSubStateSet< TSuper, TC>& operator=( const CSubStateSet< TSuper, TC>& Oth)
    {
        assert( &m_Context== &Oth.m_Context);
        if( m_uiSSBufferSize<= Oth.m_uiSSBufferSize)
        {
            m_uiSSBufferSize= Oth.m_uiSSBufferSize;
            memcpy( m_pBeginSS, Oth.m_pBeginSS, m_uiSSBufferSize);
        }
        else
        {
            void* pNewBuffer= NULL;
            try {
                pNewBuffer= operator new( Oth.m_uiSSBufferSize);
            } catch( ... ) {
            }
            if( NULL== pNewBuffer)
                throw bad_alloc( "Not enough room to copy state set command "
                    "buffer.");

            operator delete( static_cast< void*>( m_pBeginSS));
            m_pBeginSS= reinterpret_cast< D3DHAL_DP2COMMAND*>( pNewBuffer);
            m_uiSSBufferSize= Oth.m_uiSSBufferSize;
            memcpy( m_pBeginSS, Other.m_pBeginSS, m_uiSSBufferSize);
        }
        return *this;
    }
    void Capture( TContext& Ctx) 
    {
        assert( &m_Context== &Ctx);

        UINT8* pBytePtr= reinterpret_cast< UINT8*>( m_pBeginSS);
        D3DHAL_DP2COMMAND* pEndSS= reinterpret_cast< D3DHAL_DP2COMMAND*>(
            pBytePtr+ m_uiSSBufferSize);

        // Ask Context to record it's current state into the stored command
        // buffer. CStdDrawPrimitives2 can provide an implementation of
        // RecordCommandBuffer for the Context.
        Ctx.RecordCommandBuffer( m_pBeginSS, pEndSS);
    }
    void Execute( TContext& Ctx) 
    {
        assert( &m_Context== &Ctx);

        // Build up a fake PORTABLE_DRAWPRIMITIVES2DATA environment.
        PORTABLE_DDRAWSURFACE_LCL DDSLcl;
        PORTABLE_DDRAWSURFACE_MORE DDSMore;
        DDRAWI_DDRAWSURFACE_GBL DDSGbl;
        memset( &DDSLcl, 0, sizeof( DDSLcl));
        memset( &DDSMore, 0, sizeof( DDSMore));
        memset( &DDSGbl, 0, sizeof( DDSGbl));

        PORTABLE_DRAWPRIMITIVES2DATA FakeDPD;

        FakeDPD.dwhContext()= reinterpret_cast< ULONG_PTR>( &Ctx);
        FakeDPD.dwFlags()= D3DHALDP2_USERMEMVERTICES;
        FakeDPD.dwVertexType()= 0;
        FakeDPD.lpDDCommands()= &DDSLcl;
        FakeDPD.dwCommandOffset()= 0;
        FakeDPD.dwCommandLength()= m_uiSSBufferSize;
        FakeDPD.lpVertices()= NULL;
        FakeDPD.dwVertexOffset()= 0;
        FakeDPD.dwVertexLength()= 0;
        FakeDPD.dwReqVertexBufSize()= 0;
        FakeDPD.dwReqCommandBufSize()= 0;
        FakeDPD.lpdwRStates()= NULL;
        FakeDPD.dwVertexSize()= 0;

        // If the data is not 0, then a union can't be used, as we're
        // writing over valid data.
        DDSLcl.lpGbl()= &DDSGbl;
        DDSLcl.ddsCaps().dwCaps= DDSCAPS2_COMMANDBUFFER| DDSCAPS_SYSTEMMEMORY;
        DDSLcl.lpSurfMore()= &DDSMore;
        DDSGbl.fpVidMem= reinterpret_cast<FLATPTR>( m_pBeginSS);

        // Now call Context's DrawPrimitives2 entry point. CStdDrawPrimitives2
        // can provide an implementation of DrawPrimitives2 for the Context.
        HRESULT hr( Ctx.DrawPrimitives2( FakeDPD));
        assert( SUCCEEDED( hr));
    }
};

//
// <Template Parameters>
// TC: The Context type, typically, CMyContext.
//
template< class TC>
class CMinimalStateSet: public CSubStateSet< CMinimalStateSet, TC>
{
public: // Types
    typedef TC TContext;

public: // Functions
    CMinimalStateSet( const CMinimalStateSet< TC>& Other)
        :CSubStateSet< CMinimalStateSet, TC>( Other)
    { }
    CMinimalStateSet( TContext& C, const D3DHAL_DP2COMMAND* pBeginSS, const
        D3DHAL_DP2COMMAND* pEndSS) :
        CSubStateSet< CMinimalStateSet, TC>( C, pBeginSS, pEndSS) { }
    ~CMinimalStateSet()  { }
};

////////////////////////////////////////////////////////////////////////////////
//
// CStdDrawPrimitives2
//
// This class contains a default implementation of responding to the
// DrawPrimitives2 function call, as well as a function to record state back
// into a command buffer. Upon constuction, it will use the provided ranges
// to bind DP2 operations to both processing and recording member functions.
// In order to process the DrawPrimitives2 function call, it must wrap the
// PORTABLE_DRAWPRIMITIVES2DATA with a convience type which allows commands to
// be walked through with iterators. It will then use the DP2MFnParser to
// parse the DP2 commands and call the member functions.
//
// This class also provides a member function for processing the DP2 StateSet
// operation, and uses it to build up, manage, and execute state sets. In
// order to handle pure device state sets, it creates the appropriate command
// buffer for the Device (based off of caps), constructs a new state set
// on this command buffer, and asks the state set to Capture the current state.
//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TSS: The StateSet type, typically, CMyStateSet or CMinimalStateSet. The
//     StateSet class should be able to be constructed from a command buffer,
//     and then be able to Capture and Execute.
// TSSDB: This can be any Unique, Pair Associative Container, typically a map,
//     which associates a DWORD state set handle to a StateSet type. 
// TDP2D: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA.
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, along with exposing an STL conforming
//     container which provides iterators which ease iterating over the command
//     buffer. This is typically CDP2DataWrap<>.
// TDP2MFC: A map container, which associates a D3DHAL_DP2OPERATION with a
//     member function. A standard array is acceptable, as the number of
//     entries is not variable at runtime. The member function is used to
//     process the command.
// TDP2RMFC: A map container, which associates a D3DHAL_DP2OPERATION with a
//     member function. A standard array is acceptable, as the number of
//     entries is not variable at runtime. The member function is used to
//     record or fill in the command with the current state.
//
// <Exposed Types>
// TDP2Data: The wrapper class type for PORTABLE_DRAWPRIMITIVES2DATA, which is
//     the passed in TDP2D template parameter.
// TDP2DataCmds: The Sequence Container of DP2 commands provided by the
//     TDP2Data wrapper class, which is relied upon to provide iteration over
//     the command buffer. (TDP2Data::TCmds)
// TStateSet: The StateSet type, which was passed in as the TSS template
//     parameter.
// TMFn: The member function type, which all DP2 command processing member
//     functions should conform to. This is mostly exposed as a convience to
//     Context implementors.
// TMFnCaller: An Adaptable Binary Function class which is used to call
//     a TMFn, only being passed the TMFn and DP2 command pointer.
// TDP2CmdBind: A simple type, exposed as a convience to Context implementors,
//     to provide a type that can be passed into the constructor, associating
//     D3DHAL_DP2OPERATIONs with member functions/ TMFn.
// TRMFn: The member function type, which all DP2 command recording member
//     functions should conform to. This is mostly exposed as a convience to
//     Context implementors.
// TRMFnCaller: An Adaptable Binary Function class which is used to call
//     a TRMFn, only being passed the TRMFn and DP2 command pointer.
// TRecDP2CmdBind: A simple type, exposed as a convience to Context implementors,
//     to provide a type that can be passed into the constructor, associating
//     D3DHAL_DP2OPERATIONs with member functions/ TRMFn.
//
// <Exposed Functions>
// CStdDrawPrimitives2(): Default constructor.
// template< class TIter1, class TIter2>
// CStdDrawPrimitives2( TIter1, const TIter1, TIter2, const TIter2): Standard
//     constructor which receives two ranges of D3DHAL_DP2OPERATION bindings.
//     The first range is a range of DP2 command processing bindings. The
//     second range is a range of DP2 command recording bindings.
// void OnBeginDrawPrimitives2( TDP2Data&): A notification function called
//     at the beginning of processing a DrawPrimitives2 entry point.
// void OnEndDrawPrimitives2( TDP2Data&): A notification function called at
//     the end of processing a DrawPrimitives2 entry point.
// void CreateAndCaptureAllState( DWORD): The request to capture all state,
//     which should only be received by pure devices.
// void CreateAndCapturePixelState( DWORD): The request to capture pixel state,
//     which should only be received by pure devices.
// void CreateAndCaptureVertexState( DWORD): The request to capture vertex
//     state, which should only be received by pure devices.
// HRESULT DP2StateSet( TDP2Data&, const D3DHAL_DP2COMMAND*, const void*): The
//     default DP2 command processing member function for D3DDP2OP_STATESET.
// void RecordCommandBuffer( D3DHAL_DP2COMMAND*, D3DHAL_DP2COMMAND*): The
//     request to save or fill in the blanks of the passed in range of command
//     buffer, by using the DP2 command recording functions.
// HRESULT DrawPrimitives2( PORTABLE_DRAWPRIMITIVES2DATA&): The function,
//     typically called by the Driver class to process the DrawPrimitives2
//     entry point.
//
////////////////////////////////////////////////////////////////////////////////
template< class TSuper, 
    class TSS= CMinimalStateSet< TSuper>, class TSSDB= map< DWORD, TSS>,
    class TDP2D= CDP2DataWrap<>,
    class TDP2MFC= block<
        HRESULT(TSuper::*)( TDP2D&, const D3DHAL_DP2COMMAND*, const void*), 66>,
    class TDP2RMFC= block<
        HRESULT(TSuper::*)( const D3DHAL_DP2COMMAND*, void*), 66> >
class CStdDrawPrimitives2
{
public: // Types
    typedef TDP2D TDP2Data;
    typedef typename TDP2Data::TCmds TDP2DataCmds;
    typedef TSS TStateSet;
    typedef HRESULT (TSuper::* TMFn)(TDP2Data&,const D3DHAL_DP2COMMAND*,
        const void*);
    struct TMFnCaller: // Used in conjunction 
        public binary_function< TMFn, const D3DHAL_DP2COMMAND*, HRESULT>
    {
        TSuper& m_Context;
        TDP2Data& m_DP2Data;

        TMFnCaller( TSuper& Context, TDP2Data& DP2Data)
            : m_Context( Context), m_DP2Data( DP2Data)
        { }

        result_type operator()( first_argument_type MFn,
            second_argument_type pDP2Cmd) const
        {
#if defined(DBG) || defined(_DEBUG)
            const D3DHAL_DP2OPERATION Op(
                static_cast< D3DHAL_DP2OPERATION>( pDP2Cmd->bCommand));
#endif
            return (m_Context.*MFn)( m_DP2Data, pDP2Cmd, pDP2Cmd+ 1);
        }
    };
    struct TDP2CmdBind
    {
        D3DHAL_DP2OPERATION m_DP2Op;
        TMFn m_MFn;

        operator D3DHAL_DP2OPERATION() const 
        { return m_DP2Op; }
        operator TMFn() const 
        { return m_MFn; }
    };
    typedef HRESULT (TSuper::* TRMFn)( const D3DHAL_DP2COMMAND*, void*);
    struct TRMFnCaller:
        public binary_function< TRMFn, D3DHAL_DP2COMMAND*, HRESULT>
    {
        TSuper& m_Context;

        TRMFnCaller( TSuper& Context)
            : m_Context( Context)
        { }

        result_type operator()( first_argument_type RMFn,
            second_argument_type pDP2Cmd) const
        {
#if defined(DBG) || defined(_DEBUG)
            const D3DHAL_DP2OPERATION Op(
                static_cast< D3DHAL_DP2OPERATION>( pDP2Cmd->bCommand));
#endif
            return (m_Context.*RMFn)( pDP2Cmd, pDP2Cmd+ 1);
        }
    };
    struct TRecDP2CmdBind
    {
        D3DHAL_DP2OPERATION m_DP2Op;
        TRMFn m_RMFn;

        operator D3DHAL_DP2OPERATION() const 
        { return m_DP2Op; }
        operator TRMFn() const 
        { return m_RMFn; }
    };


protected: // Types
    typedef TSSDB TSSDB;
    typedef TDP2MFC TDP2MFnCtr;
    typedef TDP2RMFC TDP2RecMFnCtr;

protected: // Variables
    static const HRESULT c_hrStateSetBegin;
    static const HRESULT c_hrStateSetEnd;
    TSSDB m_StateSetDB;
    TDP2MFnCtr m_DefFnCtr;
    TDP2RecMFnCtr m_RecFnCtr;
    const D3DHAL_DP2COMMAND* m_pEndStateSet;
    DWORD m_dwStateSetId;
    bool m_bRecordingStateSet;
    bool m_bExecutingStateSet;

protected: // Functions
    // This function is used as a filler. If the assert is hit, step one
    // level up/down in the call stack and check which DP2 Operation has
    // no support, but the app indirectly needs it.
    HRESULT DP2Empty( TDP2Data&, const D3DHAL_DP2COMMAND*, const void*) 
    {
        const bool A_DP2_Op_Requires_A_Supporting_Function( false);
        assert( A_DP2_Op_Requires_A_Supporting_Function);
        return D3DERR_COMMAND_UNPARSED;
    }

    // This function is used as a fake, to prevent actual processing of
    // DP2 Operations while recording a StateSet.
    HRESULT DP2Fake( TDP2Data&, const D3DHAL_DP2COMMAND*, const void*) 
    { return DD_OK; }

    // Notification functions. Overriding is optional.
    void OnBeginDrawPrimitives2( TDP2Data& DP2Data) const 
    { }
    void OnEndDrawPrimitives2( TDP2Data& DP2Data) const 
    { }

    CStdDrawPrimitives2() 
        :m_bRecordingStateSet( false), m_bExecutingStateSet( false),
        m_pEndStateSet( NULL)
    {
        typename TDP2MFnCtr::iterator itCur( m_DefFnCtr.begin());
        while( itCur!= m_DefFnCtr.end())
        {
            *itCur= DP2Empty;
            ++itCur;
        }
        itCur= m_RecFnCtr.begin();
        while( itCur!= m_RecFnCtr.end())
        {
            *itCur= NULL;
            ++itCur;
        }
        m_DefFnCtr[ D3DDP2OP_STATESET]= DP2StateSet;
    }

    // [itSetStart, itSetEnd): A valid range of bindings, which associate
    //     a D3DHAL_DP2OPERATION with a processing member function.
    // [itRecStart, itRecEnd): A valid range of bindings, which associate
    //     a D3DHAL_DP2OPERATION with a recording member function.
    template< class TIter1, class TIter2> // TDP2CmdBind*, TRecDP2CmdBind*
    CStdDrawPrimitives2( TIter1 itSetStart, const TIter1 itSetEnd,
        TIter2 itRecStart, const TIter2 itRecEnd) 
        :m_bRecordingStateSet( false), m_bExecutingStateSet( false),
        m_pEndStateSet( NULL)
    {
        typename TDP2MFnCtr::iterator itCur( m_DefFnCtr.begin());
        while( itCur!= m_DefFnCtr.end())
        {
            *itCur= DP2Empty;
            ++itCur;
        }
        typename TDP2RecMFnCtr::iterator itRCur= m_RecFnCtr.begin();
        while( itRCur!= m_RecFnCtr.end())
        {
            *itRCur= NULL;
            ++itRCur;
        }
        while( itSetStart!= itSetEnd)
        {
            const D3DHAL_DP2OPERATION DP2Op(
                static_cast<D3DHAL_DP2OPERATION>(*itSetStart));

            // This assert will fire if there are duplicate entries for the
            // same DP2OPERATION.
            assert( DP2Empty== m_DefFnCtr[ DP2Op]);
            m_DefFnCtr[ DP2Op]= static_cast<TMFn>(*itSetStart);
            ++itSetStart;
        }
        while( itRecStart!= itRecEnd)
        {
            const D3DHAL_DP2OPERATION DP2Op(
                static_cast<D3DHAL_DP2OPERATION>(*itRecStart));

            // This assert will fire if there are duplicate entries for the
            // same DP2OPERATION.
            assert( NULL== m_RecFnCtr[ DP2Op]);
            m_RecFnCtr[ DP2Op]= static_cast<TRMFn>(*itRecStart);
            ++itRecStart;
        }
        if( DP2Empty== m_DefFnCtr[ D3DDP2OP_STATESET])
            m_DefFnCtr[ D3DDP2OP_STATESET]= DP2StateSet;

        // Supporting these operations is considered the "safe minimal"
        // support necessary to function. It is strongly recommended that
        // these functions are supported, unless you know you can live without.
        assert( m_DefFnCtr[ D3DDP2OP_VIEWPORTINFO]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_WINFO]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_RENDERSTATE]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_CLEAR]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_SETRENDERTARGET]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_SETVERTEXSHADER]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_SETSTREAMSOURCE]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_SETSTREAMSOURCEUM]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_SETINDICES]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_DRAWPRIMITIVE]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_DRAWPRIMITIVE2]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_DRAWINDEXEDPRIMITIVE]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_DRAWINDEXEDPRIMITIVE2]!= DP2Empty);
        assert( m_DefFnCtr[ D3DDP2OP_CLIPPEDTRIANGLEFAN]!= DP2Empty);
        assert( m_RecFnCtr[ D3DDP2OP_VIEWPORTINFO]!= NULL);
        assert( m_RecFnCtr[ D3DDP2OP_WINFO]!= NULL);
        assert( m_RecFnCtr[ D3DDP2OP_RENDERSTATE]!= NULL);
        assert( m_RecFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= NULL);
        assert( m_RecFnCtr[ D3DDP2OP_SETVERTEXSHADER]!= NULL);
        assert( m_RecFnCtr[ D3DDP2OP_SETSTREAMSOURCE]!= NULL);
        assert( m_RecFnCtr[ D3DDP2OP_SETINDICES]!= NULL);
        // To remove this asserting, bind these functions to a different stub,
        // most likely a member function of TSuper, which does nothing; so that
        // they will not be equal to DP2Empty. Or use the default constructor.
    }
    ~CStdDrawPrimitives2() 
    { }

    // To determine number of const registers available to pixel shader.
    static DWORD GetNumPixelShaderConstReg( const DWORD dwPixelShaderVer)
    {
        switch(dwPixelShaderVer)
        {
        case( 0): return 0;
        case( D3DPS_VERSION(1,0)): return 8;
        case( D3DPS_VERSION(1,1)): return 8;
        case( D3DPS_VERSION(254,254)): return 2;
        case( D3DPS_VERSION(255,255)): return 16;
        default: {
                const bool Unrecognizable_Pixel_Shader_Version( false);
                assert( Unrecognizable_Pixel_Shader_Version);
            } break;
        }
        return 0;
    }

public: // Functions
    // Default implementataions for Capturing amounts of state, DX8 
    // pure device style.
    void CreateAndCaptureAllState( DWORD dwStateSetId)
    {
#if defined( D3D_ENABLE_SHADOW_BUFFER)
#if defined( D3D_ENABLE_SHADOW_JITTER)
        typedef block< D3DRENDERSTATETYPE, 78> TAllRSToCapture;
#else // !defined( D3D_ENABLE_SHADOW_JITTER)
        typedef block< D3DRENDERSTATETYPE, 75> TAllRSToCapture;
#endif // !defined( D3D_ENABLE_SHADOW_JITTER)
#else // !defined( D3D_ENABLE_SHADOW_BUFFER)
        typedef block< D3DRENDERSTATETYPE, 73> TAllRSToCapture;
#endif// !defined( D3D_ENABLE_SHADOW_BUFFER)
        const TAllRSToCapture AllRSToCapture=
        {
            D3DRENDERSTATE_SPECULARENABLE,
            D3DRENDERSTATE_ZENABLE,
            D3DRENDERSTATE_FILLMODE,
            D3DRENDERSTATE_SHADEMODE,
            D3DRENDERSTATE_LINEPATTERN,
            D3DRENDERSTATE_ZWRITEENABLE,
            D3DRENDERSTATE_ALPHATESTENABLE,
            D3DRENDERSTATE_LASTPIXEL,
            D3DRENDERSTATE_SRCBLEND,
            D3DRENDERSTATE_DESTBLEND,
            D3DRENDERSTATE_CULLMODE,
            D3DRENDERSTATE_ZFUNC,
            D3DRENDERSTATE_ALPHAREF,
            D3DRENDERSTATE_ALPHAFUNC,
            D3DRENDERSTATE_DITHERENABLE,
            D3DRENDERSTATE_FOGENABLE,
            D3DRENDERSTATE_STIPPLEDALPHA,
            D3DRENDERSTATE_FOGCOLOR,
            D3DRENDERSTATE_FOGTABLEMODE,
            D3DRENDERSTATE_FOGSTART,
            D3DRENDERSTATE_FOGEND,
            D3DRENDERSTATE_FOGDENSITY,
            D3DRENDERSTATE_EDGEANTIALIAS,
            D3DRENDERSTATE_ALPHABLENDENABLE,
            D3DRENDERSTATE_ZBIAS,
            D3DRENDERSTATE_RANGEFOGENABLE,
            D3DRENDERSTATE_STENCILENABLE,
            D3DRENDERSTATE_STENCILFAIL,
            D3DRENDERSTATE_STENCILZFAIL,
            D3DRENDERSTATE_STENCILPASS,
            D3DRENDERSTATE_STENCILFUNC,
            D3DRENDERSTATE_STENCILREF,
            D3DRENDERSTATE_STENCILMASK,
            D3DRENDERSTATE_STENCILWRITEMASK,
            D3DRENDERSTATE_TEXTUREFACTOR,
            D3DRENDERSTATE_WRAP0,
            D3DRENDERSTATE_WRAP1,
            D3DRENDERSTATE_WRAP2,
            D3DRENDERSTATE_WRAP3,
            D3DRENDERSTATE_WRAP4,
            D3DRENDERSTATE_WRAP5,
            D3DRENDERSTATE_WRAP6,
            D3DRENDERSTATE_WRAP7,
            D3DRENDERSTATE_AMBIENT,
            D3DRENDERSTATE_COLORVERTEX,
            D3DRENDERSTATE_FOGVERTEXMODE,
            D3DRENDERSTATE_CLIPPING,
            D3DRENDERSTATE_LIGHTING,
            D3DRENDERSTATE_NORMALIZENORMALS,
            D3DRENDERSTATE_LOCALVIEWER,
            D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,
            D3DRENDERSTATE_AMBIENTMATERIALSOURCE,
            D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,
            D3DRENDERSTATE_SPECULARMATERIALSOURCE,
            D3DRENDERSTATE_VERTEXBLEND,
            D3DRENDERSTATE_CLIPPLANEENABLE,
            D3DRS_SOFTWAREVERTEXPROCESSING,
            D3DRS_POINTSIZE,
            D3DRS_POINTSIZE_MIN,
            D3DRS_POINTSPRITEENABLE,
            D3DRS_POINTSCALEENABLE,
            D3DRS_POINTSCALE_A,
            D3DRS_POINTSCALE_B,
            D3DRS_POINTSCALE_C,
            D3DRS_MULTISAMPLEANTIALIAS,
            D3DRS_MULTISAMPLEMASK,
            D3DRS_PATCHEDGESTYLE,
            D3DRS_PATCHSEGMENTS,
            D3DRS_POINTSIZE_MAX,
            D3DRS_INDEXEDVERTEXBLENDENABLE,
            D3DRS_COLORWRITEENABLE,
            D3DRS_TWEENFACTOR,
            D3DRS_BLENDOP,
#if defined( D3D_ENABLE_SHADOW_BUFFER)
            D3DRS_ZSLOPESCALE,
            D3DRS_ZCLAMP,
#if defined( D3D_ENABLE_SHADOW_JITTER)
            D3DRS_JITZBIASMIN,
            D3DRS_JITZBIASMAX,
            D3DRS_JITSHADOWSIZE,
#endif // defined( D3D_ENABLE_SHADOW_JITTER)
#endif // defined( D3D_ENABLE_SHADOW_BUFFER)
        };
#if defined( D3D_ENABLE_SHADOW_BUFFER)
#if defined( D3D_ENABLE_SHADOW_JITTER)
        assert( D3DRS_JITSHADOWSIZE== *AllRSToCapture.rbegin());
#else // !defined( D3D_ENABLE_SHADOW_JITTER)
        assert( D3DRS_ZCLAMP== *AllRSToCapture.rbegin());
#endif // !defined( D3D_ENABLE_SHADOW_JITTER)
#else // !defined( D3D_ENABLE_SHADOW_BUFFER)
        assert( D3DRS_BLENDOP== *AllRSToCapture.rbegin());
#endif // !defined( D3D_ENABLE_SHADOW_BUFFER)

#if defined( D3D_ENABLE_SHADOW_BUFFER)
        typedef block< D3DTEXTURESTAGESTATETYPE, 30> TAllTSSToCapture;
#else // !defined( D3D_ENABLE_SHADOW_BUFFER)
        typedef block< D3DTEXTURESTAGESTATETYPE, 27> TAllTSSToCapture;
#endif // !defined( D3D_ENABLE_SHADOW_BUFFER)
        const TAllTSSToCapture AllTSSToCapture=
        {
            D3DTSS_COLOROP,
            D3DTSS_COLORARG1,
            D3DTSS_COLORARG2,
            D3DTSS_ALPHAOP,
            D3DTSS_ALPHAARG1,
            D3DTSS_ALPHAARG2,
            D3DTSS_BUMPENVMAT00,
            D3DTSS_BUMPENVMAT01,
            D3DTSS_BUMPENVMAT10,
            D3DTSS_BUMPENVMAT11,
            D3DTSS_TEXCOORDINDEX,
            D3DTSS_ADDRESSU,
            D3DTSS_ADDRESSV,
            D3DTSS_BORDERCOLOR,
            D3DTSS_MAGFILTER,
            D3DTSS_MINFILTER,
            D3DTSS_MIPFILTER,
            D3DTSS_MIPMAPLODBIAS,
            D3DTSS_MAXMIPLEVEL,
            D3DTSS_MAXANISOTROPY,
            D3DTSS_BUMPENVLSCALE,
            D3DTSS_BUMPENVLOFFSET,
            D3DTSS_TEXTURETRANSFORMFLAGS,
            D3DTSS_ADDRESSW,
            D3DTSS_COLORARG0,
            D3DTSS_ALPHAARG0,
            D3DTSS_RESULTARG,
#if defined( D3D_ENABLE_SHADOW_BUFFER)
            D3DTSS_SHADOWNEARW,
            D3DTSS_SHADOWFARW,
            D3DTSS_SHADOWBUFFERENABLE,
#endif // defined( D3D_ENABLE_SHADOW_BUFFER)
        };
#if defined( D3D_ENABLE_SHADOW_BUFFER)
        assert( D3DTSS_SHADOWBUFFERENABLE== *AllTSSToCapture.rbegin());
#else // !defined( D3D_ENABLE_SHADOW_BUFFER)
        assert( D3DTSS_RESULTARG== *AllTSSToCapture.rbegin());
#endif // !defined( D3D_ENABLE_SHADOW_BUFFER)

        TSuper* pSThis= static_cast< TSuper*>( this);
        typedef TSuper::TPerDDrawData TPerDDrawData;
        typedef TPerDDrawData::TDriver TDriver;
        const DWORD dwTextureStages( D3DHAL_TSS_MAXSTAGES);
        const DWORD dwTextureMatrices( D3DHAL_TSS_MAXSTAGES);
        const DWORD dwClipPlanes( TDriver::GetCaps().MaxUserClipPlanes);
        const DWORD dwVertexShaderConsts( TDriver::GetCaps().MaxVertexShaderConst);
        const DWORD dwPixelShaderConsts( GetNumPixelShaderConstReg(
            TDriver::GetCaps().PixelShaderVersion));

        // Algorithm to determine maximum SetTransform Index to support.
        DWORD dwWorldMatrices( TDriver::GetCaps().MaxVertexBlendMatrixIndex+ 1);
        if( TDriver::GetCaps().MaxVertexBlendMatrices> dwWorldMatrices)
            dwWorldMatrices= TDriver::GetCaps().MaxVertexBlendMatrices;

        DWORD dwActiveLights( 0);
        size_t uiRecDP2BufferSize( 0);

        // Pass 1: Calculate size of DP2 buffer required.

        // Render States
        if( m_RecFnCtr[ D3DDP2OP_RENDERSTATE]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_RENDERSTATE]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                AllRSToCapture.size()* sizeof( D3DHAL_DP2RENDERSTATE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_RENDERSTATE]== DP2Empty); }

        // Texture States
        if( m_RecFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= NULL&&
            dwTextureStages!= 0)
        {   assert( m_DefFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+ dwTextureStages*
                AllTSSToCapture.size()* sizeof( D3DHAL_DP2TEXTURESTAGESTATE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]== DP2Empty); }

        // Viewport
        if( m_RecFnCtr[ D3DDP2OP_VIEWPORTINFO]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_VIEWPORTINFO]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2VIEWPORTINFO);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_VIEWPORTINFO]== DP2Empty); }

        // Transforms
        if( m_RecFnCtr[ D3DDP2OP_SETTRANSFORM]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETTRANSFORM]!= DP2Empty);

            // World, Texture, View, & Projection
            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2SETTRANSFORM)* (dwWorldMatrices+
                dwTextureMatrices+ 2);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETTRANSFORM]== DP2Empty); }

        // Clipplanes
        if( m_RecFnCtr[ D3DDP2OP_SETCLIPPLANE]!= NULL&& dwClipPlanes!= 0)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETCLIPPLANE]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2SETCLIPPLANE)* dwClipPlanes;
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETCLIPPLANE]== DP2Empty); }

        // Material
        if( m_RecFnCtr[ D3DDP2OP_SETMATERIAL]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETMATERIAL]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2SETMATERIAL);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETMATERIAL]== DP2Empty); }

        // Lights
        if( m_RecFnCtr[ D3DDP2OP_CREATELIGHT]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETLIGHT]!= DP2Empty);
            assert( m_DefFnCtr[ D3DDP2OP_CREATELIGHT]!= DP2Empty);

            // Special exception here. First, ask how many active lights there
            // are. We'll then prepare a buffer that the RecFnCtr function
            // will have to know what to do with (as this is the only case
            // that is not obvious how to handle). RecFnCtr will key off
            // bCommand== 0.

            const D3DHAL_DP2COMMAND DP2Cmd= {
                static_cast< D3DHAL_DP2OPERATION>( 0), 0 };
            
            // Ask for how many active lights in DP2ActiveLights.dwIndex;
            D3DHAL_DP2CREATELIGHT DP2ActiveLights= { 0 };
            (pSThis->*m_RecFnCtr[ D3DDP2OP_CREATELIGHT])(
                &DP2Cmd, &DP2ActiveLights);
            dwActiveLights= DP2ActiveLights.dwIndex;
            
            if( dwActiveLights!= 0)
            {
                // Create structures.
                uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+ dwActiveLights*
                    sizeof( D3DHAL_DP2CREATELIGHT);
                // Set structures.
                uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+ dwActiveLights*
                    (2* sizeof( D3DHAL_DP2SETLIGHT)+ sizeof( D3DLIGHT8));
            }
        }
        else {
            assert( m_DefFnCtr[ D3DDP2OP_SETLIGHT]== DP2Empty);
            assert( m_DefFnCtr[ D3DDP2OP_CREATELIGHT]== DP2Empty);
        }

        // Vertex Shader
        if( m_RecFnCtr[ D3DDP2OP_SETVERTEXSHADER]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETVERTEXSHADER]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2VERTEXSHADER);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETVERTEXSHADER]== DP2Empty); }
        
        // Pixel Shader
        if( m_RecFnCtr[ D3DDP2OP_SETPIXELSHADER]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETPIXELSHADER]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2PIXELSHADER);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETPIXELSHADER]== DP2Empty); }

        // Vertex Shader Constants
        if( m_RecFnCtr[ D3DDP2OP_SETVERTEXSHADERCONST]!= NULL&&
            dwVertexShaderConsts!= 0)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETVERTEXSHADERCONST]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2SETVERTEXSHADERCONST)+
                dwVertexShaderConsts* 4* sizeof(D3DVALUE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETVERTEXSHADERCONST]== DP2Empty); }

        // Pixel Shader Constants
        if( m_RecFnCtr[ D3DDP2OP_SETPIXELSHADERCONST]!= NULL&&
            dwPixelShaderConsts!= 0)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETPIXELSHADERCONST]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2SETPIXELSHADERCONST)+
                dwPixelShaderConsts* 4* sizeof(D3DVALUE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETPIXELSHADERCONST]== DP2Empty); }

        // Pass 2: Build command buffer for states.
        UINT8* pTempBuffer= NULL;
        try {
            pTempBuffer= reinterpret_cast< UINT8*>( 
                operator new ( uiRecDP2BufferSize));
        } catch ( ... ) {
        }
        if( NULL== pTempBuffer)
            throw bad_alloc( "Not enough room for StateSet");

        D3DHAL_DP2COMMAND* pStartSSet= reinterpret_cast< D3DHAL_DP2COMMAND*>(
            pTempBuffer);
        D3DHAL_DP2COMMAND* pCur= pStartSSet;
        D3DHAL_DP2COMMAND* pEndSSet= reinterpret_cast< D3DHAL_DP2COMMAND*>(
            pTempBuffer+ uiRecDP2BufferSize);

        // Render States
        if( m_RecFnCtr[ D3DDP2OP_RENDERSTATE]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_RENDERSTATE;
            pCur->wStateCount= static_cast< WORD>( AllRSToCapture.size());

            D3DHAL_DP2RENDERSTATE* pParam=
                reinterpret_cast< D3DHAL_DP2RENDERSTATE*>( pCur+ 1);

            TAllRSToCapture::const_iterator itRS( AllRSToCapture.begin());
            while( itRS!= AllRSToCapture.end())
            {
                pParam->RenderState= *itRS;
                ++itRS;
                ++pParam;
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam);
        }

        // Texture States
        if( m_RecFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= NULL&&
            dwTextureStages!= 0)
        {
            pCur->bCommand= D3DDP2OP_TEXTURESTAGESTATE;
            pCur->wStateCount= static_cast< WORD>( dwTextureStages*
                AllTSSToCapture.size());

            D3DHAL_DP2TEXTURESTAGESTATE* pParam=
                reinterpret_cast< D3DHAL_DP2TEXTURESTAGESTATE*>( pCur+ 1);

            for( WORD wStage( 0); wStage< dwTextureStages; ++wStage)
            {
                TAllTSSToCapture::const_iterator itTSS( AllTSSToCapture.begin());
                while( itTSS!= AllTSSToCapture.end())
                {
                    pParam->wStage= wStage;
                    pParam->TSState= *itTSS;
                    ++itTSS;
                    ++pParam;
                }
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam);
        }

        // Viewport
        if( m_RecFnCtr[ D3DDP2OP_VIEWPORTINFO]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_VIEWPORTINFO;
            pCur->wStateCount= 1;

            D3DHAL_DP2VIEWPORTINFO* pParam=
                reinterpret_cast< D3DHAL_DP2VIEWPORTINFO*>( pCur+ 1);

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam+ 1);
        }

        // Transforms
        if( m_RecFnCtr[ D3DDP2OP_SETTRANSFORM]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_SETTRANSFORM;
            pCur->wStateCount= static_cast< WORD>( dwWorldMatrices+
                dwTextureMatrices+ 2);

            D3DHAL_DP2SETTRANSFORM* pParam=
                reinterpret_cast< D3DHAL_DP2SETTRANSFORM*>( pCur+ 1);

            pParam->xfrmType= D3DTRANSFORMSTATE_PROJECTION;
            ++pParam;

            pParam->xfrmType= D3DTRANSFORMSTATE_VIEW;
            ++pParam;

            for( DWORD dwTM( 0); dwTM< dwTextureMatrices; ++dwTM)
            {
                pParam->xfrmType= static_cast< D3DTRANSFORMSTATETYPE>(
                    D3DTRANSFORMSTATE_TEXTURE0+ dwTM);
                ++pParam;
            }

            for( DWORD dwWM( 0); dwWM< dwWorldMatrices; ++dwWM)
            {
                pParam->xfrmType= D3DTS_WORLDMATRIX( dwWM);
                ++pParam;
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam);
        }

        // Clipplanes
        if( m_RecFnCtr[ D3DDP2OP_SETCLIPPLANE]!= NULL&& dwClipPlanes!= 0)
        {
            pCur->bCommand= D3DDP2OP_SETCLIPPLANE;
            pCur->wStateCount= static_cast< WORD>( dwClipPlanes);

            D3DHAL_DP2SETCLIPPLANE* pParam=
                reinterpret_cast< D3DHAL_DP2SETCLIPPLANE*>( pCur+ 1);

            for( DWORD dwCP( 0); dwCP< dwClipPlanes; ++dwCP)
            {
                pParam->dwIndex= dwCP;
                ++pParam;
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam);
        }

        // Material
        if( m_RecFnCtr[ D3DDP2OP_SETMATERIAL]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_SETMATERIAL;
            pCur->wStateCount= 1;

            D3DHAL_DP2SETMATERIAL* pParam=
                reinterpret_cast< D3DHAL_DP2SETMATERIAL*>( pCur+ 1);

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam+ 1);
        }

        // Lights
        if( m_RecFnCtr[ D3DDP2OP_CREATELIGHT]!= NULL&& dwActiveLights!= 0)
        {
            // Special exception here. First, we asked how many active lights
            // there were. The RecFnCtr function will have to know what to do
            // with this buffer. We now give it a chance to fill in the
            // light ids. RecFnCtr will key off bCommand== 0.
            pCur->bCommand= static_cast< D3DHAL_DP2OPERATION>( 0);
            pCur->wStateCount= static_cast< WORD>( dwActiveLights);

            D3DHAL_DP2CREATELIGHT* pParam=
                reinterpret_cast< D3DHAL_DP2CREATELIGHT*>( pCur+ 1);
            (pSThis->*m_RecFnCtr[ D3DDP2OP_CREATELIGHT])(
                pCur, pParam);

            // Change back the bCommand for proper usage later.
            pCur->bCommand= D3DDP2OP_CREATELIGHT;
            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam+ dwActiveLights);

            // Now, with the light ids in the CREATELIGHT structures, we can
            // fill out SETLIGHT structures with ids correctly.
            pCur->bCommand= D3DDP2OP_SETLIGHT;
            pCur->wStateCount= static_cast< WORD>( 2* dwActiveLights);

            D3DHAL_DP2SETLIGHT* pSParam=
                reinterpret_cast< D3DHAL_DP2SETLIGHT*>( pCur+ 1);

            for( DWORD dwL( 0); dwL< dwActiveLights; ++dwL)
            {
                pSParam->dwIndex= pParam->dwIndex;
                pSParam->dwDataType= D3DHAL_SETLIGHT_DATA;
                D3DLIGHT8* pLight= reinterpret_cast< D3DLIGHT8*>( pSParam+ 1);

                pSParam= reinterpret_cast< D3DHAL_DP2SETLIGHT*>( pLight+ 1);
                pSParam->dwIndex= pParam->dwIndex;
                pSParam->dwDataType= D3DHAL_SETLIGHT_DISABLE;
                ++pParam;
                ++pSParam;
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pSParam);
        }

        // Vertex Shader
        if( m_RecFnCtr[ D3DDP2OP_SETVERTEXSHADER]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_SETVERTEXSHADER;
            pCur->wStateCount= 1;

            D3DHAL_DP2VERTEXSHADER* pParam=
                reinterpret_cast< D3DHAL_DP2VERTEXSHADER*>( pCur+ 1);

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam+ 1);
        }
        
        // Pixel Shader
        if( m_RecFnCtr[ D3DDP2OP_SETPIXELSHADER]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_SETPIXELSHADER;
            pCur->wStateCount= 1;

            D3DHAL_DP2PIXELSHADER* pParam=
                reinterpret_cast< D3DHAL_DP2PIXELSHADER*>( pCur+ 1);

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam+ 1);
        }

        // Vertex Shader Constants
        if( m_RecFnCtr[ D3DDP2OP_SETVERTEXSHADERCONST]!= NULL&&
            dwVertexShaderConsts!= 0)
        {
            pCur->bCommand= D3DDP2OP_SETVERTEXSHADERCONST;
            pCur->wStateCount= 1;

            D3DHAL_DP2SETVERTEXSHADERCONST* pParam=
                reinterpret_cast< D3DHAL_DP2SETVERTEXSHADERCONST*>( pCur+ 1);
            pParam->dwRegister= 0;
            pParam->dwCount= dwVertexShaderConsts;

            D3DVALUE* pFloat= reinterpret_cast< D3DVALUE*>( pParam+ 1);
            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>(
                pFloat+ 4* dwVertexShaderConsts);
        }

        // Pixel Shader Constants
        if( m_RecFnCtr[ D3DDP2OP_SETPIXELSHADERCONST]!= NULL&&
            dwPixelShaderConsts!= 0)
        {
            pCur->bCommand= D3DDP2OP_SETPIXELSHADERCONST;
            pCur->wStateCount= 1;

            D3DHAL_DP2SETPIXELSHADERCONST* pParam=
                reinterpret_cast< D3DHAL_DP2SETPIXELSHADERCONST*>( pCur+ 1);
            pParam->dwRegister= 0;
            pParam->dwCount= dwPixelShaderConsts;

            D3DVALUE* pFloat= reinterpret_cast< D3DVALUE*>( pParam+ 1);
            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>(
                pFloat+ 4* dwPixelShaderConsts);
        }

        assert( reinterpret_cast< D3DHAL_DP2COMMAND*>( pCur)== pEndSSet);

        // Finally, build stateset.
        pair< TSSDB::iterator, bool> Ret;
        try {
            Ret= m_StateSetDB.insert( TSSDB::value_type(
                dwStateSetId, TStateSet( *pSThis, pStartSSet, pEndSSet)));
            assert( Ret.second);
        } catch ( ... ) {
            operator delete ( static_cast< void*>( pTempBuffer));
            throw;
        }

        // Now, capture it.
        Ret.first->second.Capture( *pSThis);
    }

    void CreateAndCapturePixelState( DWORD dwStateSetId)
    {
#if defined( D3D_ENABLE_SHADOW_BUFFER)
#if defined( D3D_ENABLE_SHADOW_JITTER)
        typedef block< D3DRENDERSTATETYPE, 44> TPixRSToCapture;
#else // !defined( D3D_ENABLE_SHADOW_JITTER)
        typedef block< D3DRENDERSTATETYPE, 41> TPixRSToCapture;
#endif // !defined( D3D_ENABLE_SHADOW_JITTER)
#else // !defined( D3D_ENABLE_SHADOW_BUFFER)
        typedef block< D3DRENDERSTATETYPE, 39> TPixRSToCapture;
#endif // !defined( D3D_ENABLE_SHADOW_BUFFER)
        const TPixRSToCapture PixRSToCapture=
        {
            D3DRENDERSTATE_ZENABLE,
            D3DRENDERSTATE_FILLMODE,
            D3DRENDERSTATE_SHADEMODE,
            D3DRENDERSTATE_LINEPATTERN,
            D3DRENDERSTATE_ZWRITEENABLE,
            D3DRENDERSTATE_ALPHATESTENABLE,
            D3DRENDERSTATE_LASTPIXEL,
            D3DRENDERSTATE_SRCBLEND,
            D3DRENDERSTATE_DESTBLEND,
            D3DRENDERSTATE_ZFUNC,
            D3DRENDERSTATE_ALPHAREF,
            D3DRENDERSTATE_ALPHAFUNC,
            D3DRENDERSTATE_DITHERENABLE,
            D3DRENDERSTATE_STIPPLEDALPHA,
            D3DRENDERSTATE_FOGSTART,
            D3DRENDERSTATE_FOGEND,
            D3DRENDERSTATE_FOGDENSITY,
            D3DRENDERSTATE_EDGEANTIALIAS,
            D3DRENDERSTATE_ALPHABLENDENABLE,
            D3DRENDERSTATE_ZBIAS,
            D3DRENDERSTATE_STENCILENABLE,
            D3DRENDERSTATE_STENCILFAIL,
            D3DRENDERSTATE_STENCILZFAIL,
            D3DRENDERSTATE_STENCILPASS,
            D3DRENDERSTATE_STENCILFUNC,
            D3DRENDERSTATE_STENCILREF,
            D3DRENDERSTATE_STENCILMASK,
            D3DRENDERSTATE_STENCILWRITEMASK,
            D3DRENDERSTATE_TEXTUREFACTOR,
            D3DRENDERSTATE_WRAP0,
            D3DRENDERSTATE_WRAP1,
            D3DRENDERSTATE_WRAP2,
            D3DRENDERSTATE_WRAP3,
            D3DRENDERSTATE_WRAP4,
            D3DRENDERSTATE_WRAP5,
            D3DRENDERSTATE_WRAP6,
            D3DRENDERSTATE_WRAP7,
            D3DRS_COLORWRITEENABLE,
            D3DRS_BLENDOP,
#if defined( D3D_ENABLE_SHADOW_BUFFER)
            D3DRS_ZSLOPESCALE,
            D3DRS_ZCLAMP,
#if defined( D3D_ENABLE_SHADOW_JITTER)
            D3DRS_JITZBIASMIN,
            D3DRS_JITZBIASMAX,
            D3DRS_JITSHADOWSIZE,
#endif // defined( D3D_ENABLE_SHADOW_JITTER)
#endif // defined( D3D_ENABLE_SHADOW_BUFFER)
        };
#if defined( D3D_ENABLE_SHADOW_BUFFER)
#if defined( D3D_ENABLE_SHADOW_JITTER)
        assert( D3DRS_JITSHADOWSIZE== *PixRSToCapture.rbegin());
#else // !defined( D3D_ENABLE_SHADOW_JITTER)
        assert( D3DRS_ZCLAMP== *PixRSToCapture.rbegin());
#endif // !defined( D3D_ENABLE_SHADOW_JITTER)
#else // !defined( D3D_ENABLE_SHADOW_BUFFER)
        assert( D3DRS_BLENDOP== *PixRSToCapture.rbegin());
#endif // !defined( D3D_ENABLE_SHADOW_BUFFER)

#if defined( D3D_ENABLE_SHADOW_BUFFER)
        typedef block< D3DTEXTURESTAGESTATETYPE, 30> TPixTSSToCapture;
#else // !defined( D3D_ENABLE_SHADOW_BUFFER)
        typedef block< D3DTEXTURESTAGESTATETYPE, 27> TPixTSSToCapture;
#endif // !defined( D3D_ENABLE_SHADOW_BUFFER)
        const TPixTSSToCapture PixTSSToCapture=
        {
            D3DTSS_COLOROP,
            D3DTSS_COLORARG1,
            D3DTSS_COLORARG2,
            D3DTSS_ALPHAOP,
            D3DTSS_ALPHAARG1,
            D3DTSS_ALPHAARG2,
            D3DTSS_BUMPENVMAT00,
            D3DTSS_BUMPENVMAT01,
            D3DTSS_BUMPENVMAT10,
            D3DTSS_BUMPENVMAT11,
            D3DTSS_TEXCOORDINDEX,
            D3DTSS_ADDRESSU,
            D3DTSS_ADDRESSV,
            D3DTSS_BORDERCOLOR,
            D3DTSS_MAGFILTER,
            D3DTSS_MINFILTER,
            D3DTSS_MIPFILTER,
            D3DTSS_MIPMAPLODBIAS,
            D3DTSS_MAXMIPLEVEL,
            D3DTSS_MAXANISOTROPY,
            D3DTSS_BUMPENVLSCALE,
            D3DTSS_BUMPENVLOFFSET,
            D3DTSS_TEXTURETRANSFORMFLAGS,
            D3DTSS_ADDRESSW,
            D3DTSS_COLORARG0,
            D3DTSS_ALPHAARG0,
            D3DTSS_RESULTARG,
#if defined( D3D_ENABLE_SHADOW_BUFFER)
            D3DTSS_SHADOWNEARW,
            D3DTSS_SHADOWFARW,
            D3DTSS_SHADOWBUFFERENABLE,
#endif // defined( D3D_ENABLE_SHADOW_BUFFER)
        };
#if defined( D3D_ENABLE_SHADOW_BUFFER)
        assert( D3DTSS_SHADOWBUFFERENABLE== *PixTSSToCapture.rbegin());
#else // !defined( D3D_ENABLE_SHADOW_BUFFER)
        assert( D3DTSS_RESULTARG== *PixTSSToCapture.rbegin());
#endif // !defined( D3D_ENABLE_SHADOW_BUFFER)

        TSuper* pSThis= static_cast< TSuper*>( this);
        typedef TSuper::TPerDDrawData TPerDDrawData;
        typedef TPerDDrawData::TDriver TDriver;
        const DWORD dwTextureStages( D3DHAL_TSS_MAXSTAGES);
        const DWORD dwPixelShaderConsts( GetNumPixelShaderConstReg(
            TDriver::GetCaps().PixelShaderVersion));

        size_t uiRecDP2BufferSize( 0);

        // Pass 1: Calculate size of DP2 buffer required.

        // Render States
        if( m_RecFnCtr[ D3DDP2OP_RENDERSTATE]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_RENDERSTATE]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                PixRSToCapture.size()* sizeof( D3DHAL_DP2RENDERSTATE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_RENDERSTATE]== DP2Empty); }

        // Texture States
        if( m_RecFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= NULL&&
            dwTextureStages!= 0)
        {   assert( m_DefFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+ dwTextureStages*
                PixTSSToCapture.size()* sizeof( D3DHAL_DP2TEXTURESTAGESTATE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]== DP2Empty); }

        // Pixel Shader
        if( m_RecFnCtr[ D3DDP2OP_SETPIXELSHADER]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETPIXELSHADER]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2PIXELSHADER);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETPIXELSHADER]== DP2Empty); }

        // Pixel Shader Constants
        if( m_RecFnCtr[ D3DDP2OP_SETPIXELSHADERCONST]!= NULL&&
            dwPixelShaderConsts!= 0)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETPIXELSHADERCONST]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2SETPIXELSHADERCONST)+
                dwPixelShaderConsts* 4* sizeof(D3DVALUE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETPIXELSHADERCONST]== DP2Empty); }

        // Pass 2: Build command buffer for states.
        UINT8* pTempBuffer= NULL;
        try {
            pTempBuffer= reinterpret_cast< UINT8*>( 
                operator new ( uiRecDP2BufferSize));
        } catch ( ... ) {
        }
        if( NULL== pTempBuffer)
            throw bad_alloc( "Not enough room for StateSet");

        D3DHAL_DP2COMMAND* pStartSSet= reinterpret_cast< D3DHAL_DP2COMMAND*>(
            pTempBuffer);
        D3DHAL_DP2COMMAND* pCur= pStartSSet;
        D3DHAL_DP2COMMAND* pEndSSet= reinterpret_cast< D3DHAL_DP2COMMAND*>(
            pTempBuffer+ uiRecDP2BufferSize);

        // Render States
        if( m_RecFnCtr[ D3DDP2OP_RENDERSTATE]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_RENDERSTATE;
            pCur->wStateCount= static_cast< WORD>( PixRSToCapture.size());

            D3DHAL_DP2RENDERSTATE* pParam=
                reinterpret_cast< D3DHAL_DP2RENDERSTATE*>( pCur+ 1);

            TPixRSToCapture::const_iterator itRS( PixRSToCapture.begin());
            while( itRS!= PixRSToCapture.end())
            {
                pParam->RenderState= *itRS;
                ++itRS;
                ++pParam;
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam);
        }

        // Texture States
        if( m_RecFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= NULL&&
            dwTextureStages!= 0)
        {
            pCur->bCommand= D3DDP2OP_TEXTURESTAGESTATE;
            pCur->wStateCount= static_cast< WORD>( dwTextureStages*
                PixTSSToCapture.size());

            D3DHAL_DP2TEXTURESTAGESTATE* pParam=
                reinterpret_cast< D3DHAL_DP2TEXTURESTAGESTATE*>( pCur+ 1);

            for( WORD wStage( 0); wStage< dwTextureStages; ++wStage)
            {
                TPixTSSToCapture::const_iterator itTSS( PixTSSToCapture.begin());
                while( itTSS!= PixTSSToCapture.end())
                {
                    pParam->wStage= wStage;
                    pParam->TSState= *itTSS;
                    ++itTSS;
                    ++pParam;
                }
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam);
        }

        // Pixel Shader
        if( m_RecFnCtr[ D3DDP2OP_SETPIXELSHADER]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_SETPIXELSHADER;
            pCur->wStateCount= 1;

            D3DHAL_DP2PIXELSHADER* pParam=
                reinterpret_cast< D3DHAL_DP2PIXELSHADER*>( pCur+ 1);

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam+ 1);
        }

        // Pixel Shader Constants
        if( m_RecFnCtr[ D3DDP2OP_SETPIXELSHADERCONST]!= NULL&&
            dwPixelShaderConsts!= 0)
        {
            pCur->bCommand= D3DDP2OP_SETPIXELSHADERCONST;
            pCur->wStateCount= 1;

            D3DHAL_DP2SETPIXELSHADERCONST* pParam=
                reinterpret_cast< D3DHAL_DP2SETPIXELSHADERCONST*>( pCur+ 1);
            pParam->dwRegister= 0;
            pParam->dwCount= dwPixelShaderConsts;

            D3DVALUE* pFloat= reinterpret_cast< D3DVALUE*>( pParam+ 1);
            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>(
                pFloat+ 4* dwPixelShaderConsts);
        }

        assert( reinterpret_cast< D3DHAL_DP2COMMAND*>( pCur)== pEndSSet);

        // Finally, build stateset.
        pair< TSSDB::iterator, bool> Ret;
        try {
            Ret= m_StateSetDB.insert( TSSDB::value_type(
                dwStateSetId, TStateSet( *pSThis, pStartSSet, pEndSSet)));
            assert( Ret.second);
        } catch ( ... ) {
            operator delete ( static_cast< void*>( pTempBuffer));
            throw;
        }

        // Now, capture it.
        Ret.first->second.Capture( *pSThis);
    }

    void CreateAndCaptureVertexState( DWORD dwStateSetId)
    {
        typedef block< D3DRENDERSTATETYPE, 38> TVtxRSToCapture;
        const TVtxRSToCapture VtxRSToCapture=
        {
            D3DRENDERSTATE_SPECULARENABLE,
            D3DRENDERSTATE_SHADEMODE,
            D3DRENDERSTATE_CULLMODE,
            D3DRENDERSTATE_FOGENABLE,
            D3DRENDERSTATE_FOGCOLOR,
            D3DRENDERSTATE_FOGTABLEMODE,
            D3DRENDERSTATE_FOGSTART,
            D3DRENDERSTATE_FOGEND,
            D3DRENDERSTATE_FOGDENSITY,
            D3DRENDERSTATE_RANGEFOGENABLE,
            D3DRENDERSTATE_AMBIENT,
            D3DRENDERSTATE_COLORVERTEX,
            D3DRENDERSTATE_FOGVERTEXMODE,
            D3DRENDERSTATE_CLIPPING,
            D3DRENDERSTATE_LIGHTING,
            D3DRENDERSTATE_NORMALIZENORMALS,
            D3DRENDERSTATE_LOCALVIEWER,
            D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,
            D3DRENDERSTATE_AMBIENTMATERIALSOURCE,
            D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,
            D3DRENDERSTATE_SPECULARMATERIALSOURCE,
            D3DRENDERSTATE_VERTEXBLEND,
            D3DRENDERSTATE_CLIPPLANEENABLE,
            D3DRS_SOFTWAREVERTEXPROCESSING,
            D3DRS_POINTSIZE,
            D3DRS_POINTSIZE_MIN,
            D3DRS_POINTSPRITEENABLE,
            D3DRS_POINTSCALEENABLE,
            D3DRS_POINTSCALE_A,
            D3DRS_POINTSCALE_B,
            D3DRS_POINTSCALE_C,
            D3DRS_MULTISAMPLEANTIALIAS,
            D3DRS_MULTISAMPLEMASK,
            D3DRS_PATCHEDGESTYLE,
            D3DRS_PATCHSEGMENTS,
            D3DRS_POINTSIZE_MAX,
            D3DRS_INDEXEDVERTEXBLENDENABLE,
            D3DRS_TWEENFACTOR
        };
        assert( D3DRS_TWEENFACTOR== *VtxRSToCapture.rbegin());
        typedef block< D3DTEXTURESTAGESTATETYPE, 2> TVtxTSSToCapture;
        const TVtxTSSToCapture VtxTSSToCapture=
        {
            D3DTSS_TEXCOORDINDEX,
            D3DTSS_TEXTURETRANSFORMFLAGS
        };
        assert( D3DTSS_TEXTURETRANSFORMFLAGS== *VtxTSSToCapture.rbegin());

        TSuper* pSThis= static_cast< TSuper*>( this);
        typedef TSuper::TPerDDrawData TPerDDrawData;
        typedef TPerDDrawData::TDriver TDriver;
        const DWORD dwTextureStages( D3DHAL_TSS_MAXSTAGES);
        const DWORD dwVertexShaderConsts( TDriver::GetCaps().MaxVertexShaderConst);
        DWORD dwActiveLights( 0);

        size_t uiRecDP2BufferSize( 0);

        // Pass 1: Calculate size of DP2 buffer required.

        // Render States
        if( m_RecFnCtr[ D3DDP2OP_RENDERSTATE]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_RENDERSTATE]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                VtxRSToCapture.size()* sizeof( D3DHAL_DP2RENDERSTATE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_RENDERSTATE]== DP2Empty); }

        // Texture States
        if( m_RecFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= NULL&&
            dwTextureStages!= 0)
        {   assert( m_DefFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+ dwTextureStages*
                VtxTSSToCapture.size()* sizeof( D3DHAL_DP2TEXTURESTAGESTATE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]== DP2Empty); }

        // Lights
        if( m_RecFnCtr[ D3DDP2OP_CREATELIGHT]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETLIGHT]!= DP2Empty);
            assert( m_DefFnCtr[ D3DDP2OP_CREATELIGHT]!= DP2Empty);

            // Special exception here. First, ask how many active lights there
            // are. We'll then prepare a buffer that the RecFnCtr function
            // will have to know what to do with (as this is the only case
            // that is not obvious how to handle). RecFnCtr will key off
            // bCommand== 0.

            const D3DHAL_DP2COMMAND DP2Cmd= {
                static_cast< D3DHAL_DP2OPERATION>( 0), 0 };
            
            // Ask for how many active lights in DP2ActiveLights.dwIndex;
            D3DHAL_DP2CREATELIGHT DP2ActiveLights= { 0 };
            (pSThis->*m_RecFnCtr[ D3DDP2OP_CREATELIGHT])(
                &DP2Cmd, &DP2ActiveLights);
            dwActiveLights= DP2ActiveLights.dwIndex;
            
            if( dwActiveLights!= 0)
            {
                // Create structures.
                uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+ dwActiveLights*
                    sizeof( D3DHAL_DP2CREATELIGHT);
                // Set structures.
                uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+ dwActiveLights*
                    (2* sizeof( D3DHAL_DP2SETLIGHT)+ sizeof( D3DLIGHT8));
            }
        }
        else {
            assert( m_DefFnCtr[ D3DDP2OP_SETLIGHT]== DP2Empty);
            assert( m_DefFnCtr[ D3DDP2OP_CREATELIGHT]== DP2Empty);
        }

        // Vertex Shader
        if( m_RecFnCtr[ D3DDP2OP_SETVERTEXSHADER]!= NULL)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETVERTEXSHADER]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2VERTEXSHADER);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETVERTEXSHADER]== DP2Empty); }
        
        // Vertex Shader Constants
        if( m_RecFnCtr[ D3DDP2OP_SETVERTEXSHADERCONST]!= NULL&&
            dwVertexShaderConsts!= 0)
        {   assert( m_DefFnCtr[ D3DDP2OP_SETVERTEXSHADERCONST]!= DP2Empty);

            uiRecDP2BufferSize+= sizeof( D3DHAL_DP2COMMAND)+
                sizeof( D3DHAL_DP2SETVERTEXSHADERCONST)+
                dwVertexShaderConsts* 4* sizeof(D3DVALUE);
        }
        else { assert( m_DefFnCtr[ D3DDP2OP_SETVERTEXSHADERCONST]== DP2Empty); }

        // Pass 2: Build command buffer for states.
        UINT8* pTempBuffer= NULL;
        try {
            pTempBuffer= reinterpret_cast< UINT8*>( 
                operator new ( uiRecDP2BufferSize));
        } catch ( ... ) {
        }
        if( NULL== pTempBuffer)
            throw bad_alloc( "Not enough room for StateSet");

        D3DHAL_DP2COMMAND* pStartSSet= reinterpret_cast< D3DHAL_DP2COMMAND*>(
            pTempBuffer);
        D3DHAL_DP2COMMAND* pCur= pStartSSet;
        D3DHAL_DP2COMMAND* pEndSSet= reinterpret_cast< D3DHAL_DP2COMMAND*>(
            pTempBuffer+ uiRecDP2BufferSize);

        // Render States
        if( m_RecFnCtr[ D3DDP2OP_RENDERSTATE]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_RENDERSTATE;
            pCur->wStateCount= static_cast< WORD>( VtxRSToCapture.size());

            D3DHAL_DP2RENDERSTATE* pParam=
                reinterpret_cast< D3DHAL_DP2RENDERSTATE*>( pCur+ 1);

            TVtxRSToCapture::const_iterator itRS( VtxRSToCapture.begin());
            while( itRS!= VtxRSToCapture.end())
            {
                pParam->RenderState= *itRS;
                ++itRS;
                ++pParam;
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam);
        }

        // Texture States
        if( m_RecFnCtr[ D3DDP2OP_TEXTURESTAGESTATE]!= NULL&&
            dwTextureStages!= 0)
        {
            pCur->bCommand= D3DDP2OP_TEXTURESTAGESTATE;
            pCur->wStateCount= static_cast< WORD>( dwTextureStages*
                VtxTSSToCapture.size());

            D3DHAL_DP2TEXTURESTAGESTATE* pParam=
                reinterpret_cast< D3DHAL_DP2TEXTURESTAGESTATE*>( pCur+ 1);

            for( WORD wStage( 0); wStage< dwTextureStages; ++wStage)
            {
                TVtxTSSToCapture::const_iterator itTSS( VtxTSSToCapture.begin());
                while( itTSS!= VtxTSSToCapture.end())
                {
                    pParam->wStage= wStage;
                    pParam->TSState= *itTSS;
                    ++itTSS;
                    ++pParam;
                }
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam);
        }

        // Lights
        if( m_RecFnCtr[ D3DDP2OP_CREATELIGHT]!= NULL&& dwActiveLights!= 0)
        {
            // Special exception here. First, we asked how many active lights
            // there were. The RecFnCtr function will have to know what to do
            // with this buffer. We now give it a chance to fill in the
            // light ids. RecFnCtr will key off bCommand== 0.
            pCur->bCommand= static_cast< D3DHAL_DP2OPERATION>( 0);
            pCur->wStateCount= static_cast< WORD>( dwActiveLights);

            D3DHAL_DP2CREATELIGHT* pParam=
                reinterpret_cast< D3DHAL_DP2CREATELIGHT*>( pCur+ 1);
            (pSThis->*m_RecFnCtr[ D3DDP2OP_CREATELIGHT])(
                pCur, pParam);

            // Change back the bCommand for proper usage later.
            pCur->bCommand= D3DDP2OP_CREATELIGHT;
            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam+ dwActiveLights);

            // Now, with the light ids in the CREATELIGHT structures, we can
            // fill out SETLIGHT structures with ids correctly.
            pCur->bCommand= D3DDP2OP_SETLIGHT;
            pCur->wStateCount= static_cast< WORD>( 2* dwActiveLights);

            D3DHAL_DP2SETLIGHT* pSParam=
                reinterpret_cast< D3DHAL_DP2SETLIGHT*>( pCur+ 1);

            for( DWORD dwL( 0); dwL< dwActiveLights; ++dwL)
            {
                pSParam->dwIndex= pParam->dwIndex;
                pSParam->dwDataType= D3DHAL_SETLIGHT_DATA;
                D3DLIGHT8* pLight= reinterpret_cast< D3DLIGHT8*>( pSParam+ 1);

                pSParam= reinterpret_cast< D3DHAL_DP2SETLIGHT*>( pLight+ 1);
                pSParam->dwIndex= pParam->dwIndex;
                pSParam->dwDataType= D3DHAL_SETLIGHT_DISABLE;
                ++pParam;
                ++pSParam;
            }

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pSParam);
        }

        // Vertex Shader
        if( m_RecFnCtr[ D3DDP2OP_SETVERTEXSHADER]!= NULL)
        {
            pCur->bCommand= D3DDP2OP_SETVERTEXSHADER;
            pCur->wStateCount= 1;

            D3DHAL_DP2VERTEXSHADER* pParam=
                reinterpret_cast< D3DHAL_DP2VERTEXSHADER*>( pCur+ 1);

            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>( pParam+ 1);
        }
        
        // Vertex Shader Constants
        if( m_RecFnCtr[ D3DDP2OP_SETVERTEXSHADERCONST]!= NULL&&
            dwVertexShaderConsts!= 0)
        {
            pCur->bCommand= D3DDP2OP_SETVERTEXSHADERCONST;
            pCur->wStateCount= 1;

            D3DHAL_DP2SETVERTEXSHADERCONST* pParam=
                reinterpret_cast< D3DHAL_DP2SETVERTEXSHADERCONST*>( pCur+ 1);
            pParam->dwRegister= 0;
            pParam->dwCount= dwVertexShaderConsts;

            D3DVALUE* pFloat= reinterpret_cast< D3DVALUE*>( pParam+ 1);
            pCur= reinterpret_cast< D3DHAL_DP2COMMAND*>(
                pFloat+ 4* dwVertexShaderConsts);
        }

        assert( reinterpret_cast< D3DHAL_DP2COMMAND*>( pCur)== pEndSSet);

        // Finally, build stateset.
        pair< TSSDB::iterator, bool> Ret;
        try {
            Ret= m_StateSetDB.insert( TSSDB::value_type(
                dwStateSetId, TStateSet( *pSThis, pStartSSet, pEndSSet)));
            assert( Ret.second);
        } catch ( ... ) {
            operator delete ( static_cast< void*>( pTempBuffer));
            throw;
        }

        // Now, capture it.
        Ret.first->second.Capture( *pSThis);
    }

    // This member function handles the DP2OP_STATESET, which communicates back
    // to the DrawPrimitives2 entry point handler to implement state sets.
    HRESULT DP2StateSet( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP) 
    {
        const D3DHAL_DP2STATESET* pParam=
            reinterpret_cast<const D3DHAL_DP2STATESET*>(pP);
        HRESULT hr( DD_OK);
        WORD wStateCount( pCmd->wStateCount);

        TSuper* pSThis= static_cast<TSuper*>(this);
        if( wStateCount!= 0) do
        {
            switch( pParam->dwOperation)
            {
            case( D3DHAL_STATESETCREATE):
                assert( !m_bRecordingStateSet);
                typedef TSuper::TPerDDrawData TPerDDrawData;
                typedef TPerDDrawData::TDriver TDriver;
                assert((TDriver::GetCaps().DevCaps& D3DDEVCAPS_PUREDEVICE)!= 0);

                try {
                    switch( pParam->sbType)
                    {
                    case( D3DSBT_ALL):
                        pSThis->CreateAndCaptureAllState( pParam->dwParam);
                        break;

                    case( D3DSBT_PIXELSTATE):
                        pSThis->CreateAndCapturePixelState( pParam->dwParam);
                        break;

                    case( D3DSBT_VERTEXSTATE):
                        pSThis->CreateAndCaptureVertexState( pParam->dwParam);
                        break;

                    default: {
                        const bool Unrecognized_StateSetCreate_Operation( false);
                        assert( Unrecognized_StateSetCreate_Operation);
                        } break;
                    }
                } catch( bad_alloc ba) {
                    return DDERR_OUTOFMEMORY;
                }
                break;

            case( D3DHAL_STATESETBEGIN):
                assert( 1== wStateCount);
                assert( !m_bRecordingStateSet);

                m_bRecordingStateSet= true;
                hr= c_hrStateSetBegin;
                // Returning this constant will break out of the parsing and
                // notify DrawPrimitive2 entry point handler to create a state
                // set.
                break;

            case( D3DHAL_STATESETCAPTURE):
                if( !m_bRecordingStateSet)
                {
                    // First, find the StateSet to capture.
                    typename TSSDB::iterator itSS(
                        m_StateSetDB.find( pParam->dwParam));
                    assert( itSS!= m_StateSetDB.end());

                    // Capture it.
                    itSS->second.Capture( *pSThis);
                }
                break;

            case( D3DHAL_STATESETDELETE):
                if( !m_bRecordingStateSet)
                {
                    m_StateSetDB.erase( pParam->dwParam);
                }
                break;

            case( D3DHAL_STATESETEND):
                assert( 1== wStateCount);
                assert( m_bRecordingStateSet);
                m_bRecordingStateSet= false;
                m_dwStateSetId= pParam->dwParam;
                m_pEndStateSet= pCmd;
                hr= c_hrStateSetEnd;
                break;

            case( D3DHAL_STATESETEXECUTE):
                if( !m_bRecordingStateSet)
                {
                    // First, find the StateSet to execute.
                    typename TSSDB::iterator itSS(
                        m_StateSetDB.find( pParam->dwParam));
                    assert( itSS!= m_StateSetDB.end());

                    // "Push" value of m_bExecutingStateSet, then set to true.
                    // "Pop" will occur at destruction.
                    CPushValue< bool> m_PushExecutingBit(
                        m_bExecutingStateSet, true);

                    // Execute it.
                    itSS->second.Execute( *pSThis);
                }
                break;

            default: {
                const bool Unrecognized_StateSet_Operation( false);
                assert( Unrecognized_StateSet_Operation);
                } break;
            }

            ++pParam;
        } while( SUCCEEDED( hr) && --wStateCount);

        return hr;
    }

    // This function is used to record the current state of the context/ device
    // into the command buffer.
    void RecordCommandBuffer( D3DHAL_DP2COMMAND* pBeginSS,
        D3DHAL_DP2COMMAND* pEndSS)
    {
        TSuper* pSThis= static_cast<TSuper*>(this);

        CDP2CmdIterator<> itCur( pBeginSS);
        const CDP2CmdIterator<> itEnd( pEndSS);
        SDP2MFnParser DP2Parser;
        TRMFnCaller RMFnCaller( *pSThis);

        HRESULT hr( DD_OK);
        while( itCur!= itEnd)
        {
            hr= DP2Parser.ParseDP2( RMFnCaller, m_RecFnCtr, itCur, itEnd);
            assert( SUCCEEDED( hr));

            // Ignore recording errors, except for debugging. Hopefully
            // the processing of this DP2 command (when appling the state set)
            // won't fault later.
            if( FAILED( hr))
                ++itCur;
        }
    }

    // Primary reason for class, handling of this function for the context.
    HRESULT DrawPrimitives2( PORTABLE_DRAWPRIMITIVES2DATA& dpd) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        TDP2Data DP2Data( dpd);

        // If not currently executing a stateset (which might recursively call
        // this function) notify start of DP2 entry point.
        if( !m_bExecutingStateSet)
            pSThis->OnBeginDrawPrimitives2( DP2Data);

        typename TDP2DataCmds::const_iterator itCur(
            DP2Data.GetCommands().begin() );
        const typename TDP2DataCmds::const_iterator itEnd(
            DP2Data.GetCommands().end() );
        SDP2MFnParser DP2Parser;
        TMFnCaller MFnCaller( *pSThis, DP2Data);

        HRESULT hr( DD_OK);
        do
        {
            hr= DP2Parser.ParseDP2( MFnCaller, m_DefFnCtr,
                itCur, itEnd);

            if( c_hrStateSetBegin== hr)
            {
                typename TDP2DataCmds::const_iterator itStartSSet( ++itCur);

                {
                    TDP2MFnCtr FakeFnCtr;
                    typename TDP2MFnCtr::iterator itCurFake( FakeFnCtr.begin());
                    while( itCurFake!= FakeFnCtr.end())
                        *itCurFake++ = DP2Fake;
                    FakeFnCtr[ D3DDP2OP_STATESET]= DP2StateSet;

                    hr= DP2Parser.ParseDP2( MFnCaller, FakeFnCtr,
                        itCur, itEnd);

                    assert( c_hrStateSetEnd== hr);
                    itCur++;
                }

                try
                {
                    pair< TSSDB::iterator, bool> Ret;
                    Ret= m_StateSetDB.insert( TSSDB::value_type( m_dwStateSetId,
                        TStateSet( *pSThis, itStartSSet, m_pEndStateSet)));

                    // There shouldn't be two statesets with the same Id.
                    assert( Ret.second);
                    hr= S_OK;
                } catch( bad_alloc e) {
                    hr= DDERR_OUTOFMEMORY;
                }
            }
            assert( c_hrStateSetEnd!= hr);
        } while( SUCCEEDED(hr)&& itCur!= itEnd);

        if( FAILED( hr))
        {
            const D3DHAL_DP2COMMAND* pS= itCur;
            const D3DHAL_DP2COMMAND* pE= itEnd;
            dpd.dwErrorOffset()= reinterpret_cast<const UINT8*>(pE)-
                reinterpret_cast<const UINT8*>(pS);
        }

        // If not currently executing a stateset (which might recursively call
        // this function) notify end of DP2 entry point.
        if( !m_bExecutingStateSet)
            pSThis->OnEndDrawPrimitives2( DP2Data);
        return hr;
    }
};

template< class TSuper, class TSS, class TSSDB, class TDP2D, class TDP2MFC,
    class TDP2RMFC>
const HRESULT CStdDrawPrimitives2< TSuper, TSS, TSSDB, TDP2D, TDP2MFC,
    TDP2RMFC>::c_hrStateSetBegin= S_FALSE+ 556;

template< class TSuper, class TSS, class TSSDB, class TDP2D, class TDP2MFC,
    class TDP2RMFC>
const HRESULT CStdDrawPrimitives2< TSuper, TSS, TSSDB, TDP2D, TDP2MFC,
    TDP2RMFC>::c_hrStateSetEnd= S_FALSE+ 557;

////////////////////////////////////////////////////////////////////////////////
//
// CStdDP2ViewportInfoStore,
// CStdDP2WInfoStore,
// CStdDP2SetTransformStore,
// etc: CStdDP2xxxxxStore...
//
// These classes provide default DP2 operation support, typically just storing
// state. They have support for a notification mechanism, which delegates to
// the parent Context.
//
////////////////////////////////////////////////////////////////////////////////

// MSVC doesn't support partial specialization or we could've had something
// elegant like:
//
// template< class TSuper, class TParam>
// class CStdDP2ParamStore {};
//
// for typical support like:
// CStdDP2ParamStore< ..., D3DHAL_DP2VIEWPORTINFO>
// CStdDP2ParamStore< ..., D3DHAL_DP2WINFO>
//
// with partial specializations for exceptions like:
//
// template< class TSuper>
// class CStdDP2ParamStore< TSuper, D3DHAL_DP2RENDERSTATE> {};
// template< class TSuper>
// class CStdDP2ParamStore< TSuper, D3DHAL_DP2TEXTURESTAGESTATE> {};
//
// So, without this support, it'll be easier for each class to have a unique
// name; as MSVC is currently buggy about inheriting from the same named class
// multiple times, even WITH a different template parameter.

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TDP2Data= CDP2DataWrap<> >
class CStdDP2ViewportInfoStore
{
protected: // Variables
    D3DHAL_DP2VIEWPORTINFO m_Param;

protected: // Functions
    CStdDP2ViewportInfoStore() 
    { }
    explicit CStdDP2ViewportInfoStore( const D3DHAL_DP2VIEWPORTINFO& P) 
        :m_Param( P)
    { }
    ~CStdDP2ViewportInfoStore() 
    { }

    D3DHAL_DP2VIEWPORTINFO NewDP2ViewportInfo( const D3DHAL_DP2VIEWPORTINFO&
        CurParam, const D3DHAL_DP2VIEWPORTINFO& NewParam) const 
    {   // Tell notifier to store the new param.
        return NewParam;
    }

public: // Fuctions
    void GetDP2ViewportInfo( D3DHAL_DP2VIEWPORTINFO& GetParam) const 
    { GetParam= m_Param; }
    operator D3DHAL_DP2VIEWPORTINFO() const 
    { return m_Param; }
    HRESULT DP2ViewportInfo( TDP2Data&, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2VIEWPORTINFO* pParam=
            reinterpret_cast< const D3DHAL_DP2VIEWPORTINFO*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            m_Param= pSThis->NewDP2ViewportInfo( m_Param, *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT RecDP2ViewportInfo( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2VIEWPORTINFO* pParam=
            reinterpret_cast< D3DHAL_DP2VIEWPORTINFO*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            GetDP2ViewportInfo( *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TDP2Data= CDP2DataWrap<> >
class CStdDP2WInfoStore
{
protected: // Variables
    D3DHAL_DP2WINFO m_Param;

protected: // Functions
    CStdDP2WInfoStore() 
    { }
    explicit CStdDP2WInfoStore( const D3DHAL_DP2WINFO& P) 
        :m_Param( P)
    { }
    ~CStdDP2WInfoStore() 
    { }

    D3DHAL_DP2WINFO NewDP2WInfo( const D3DHAL_DP2WINFO& CurParam,
        const D3DHAL_DP2WINFO& NewParam) const 
    {   // Tell notifier to store the new param.
        return NewParam;
    }

public: // Fuctions
    void GetDP2WInfo( D3DHAL_DP2WINFO& GetParam) const 
    { GetParam= m_Param; }
    operator D3DHAL_DP2WINFO() const 
    { return m_Param; }
    HRESULT DP2WInfo( TDP2Data&, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2WINFO* pParam=
            reinterpret_cast< const D3DHAL_DP2WINFO*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            m_Param= pSThis->NewDP2WInfo( m_Param, *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT RecDP2WInfo( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2WINFO* pParam=
            reinterpret_cast< D3DHAL_DP2WINFO*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            GetDP2WInfo( *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TDP2Data= CDP2DataWrap<> >
class CStdDP2ZRangeStore
{
protected: // Variables
    D3DHAL_DP2ZRANGE m_Param;

protected: // Functions
    CStdDP2ZRangeStore() 
    { }
    explicit CStdDP2ZRangeStore( const D3DHAL_DP2ZRANGE& P) 
        :m_Param( P)
    { }
    ~CStdDP2ZRangeStore() 
    { }

    D3DHAL_DP2ZRANGE NewDP2ZRange( const D3DHAL_DP2ZRANGE& CurParam,
        const D3DHAL_DP2ZRANGE& NewParam) const 
    {   // Tell notifier to store the new param.
        return NewParam;
    }

public: // Fuctions
    void GetDP2ZRange( D3DHAL_DP2ZRANGE& GetParam) const 
    { GetParam= m_Param; }
    operator D3DHAL_DP2ZRANGE() const 
    { return m_Param; }
    HRESULT DP2ZRange( TDP2Data&, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2ZRANGE* pParam=
            reinterpret_cast< const D3DHAL_DP2ZRANGE*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            m_Param= pSThis->NewDP2ZRange( m_Param, *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT RecDP2ZRange( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2ZRANGE* pParam=
            reinterpret_cast< D3DHAL_DP2ZRANGE*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            GetDP2ZRange( *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TDP2Data= CDP2DataWrap<> >
class CStdDP2SetMaterialStore
{
protected: // Variables
    D3DHAL_DP2SETMATERIAL m_Param;

protected: // Functions
    CStdDP2SetMaterialStore() 
    { }
    explicit CStdDP2SetMaterialStore( const D3DHAL_DP2SETMATERIAL& P) 
        :m_Param( P)
    { }
    ~CStdDP2SetMaterialStore() 
    { }

    D3DHAL_DP2SETMATERIAL NewDP2SetMaterial( const D3DHAL_DP2SETMATERIAL& CurParam,
        const D3DHAL_DP2SETMATERIAL& NewParam) const 
    {   // Tell notifier to store the new param.
        return NewParam;
    }

public: // Fuctions
    void GetDP2SetMaterial( D3DHAL_DP2SETMATERIAL& GetParam) const 
    { GetParam= m_Param; }
    operator D3DHAL_DP2SETMATERIAL() const 
    { return m_Param; }
    HRESULT DP2SetMaterial( TDP2Data&, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2SETMATERIAL* pParam=
            reinterpret_cast< const D3DHAL_DP2SETMATERIAL*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            m_Param= pSThis->NewDP2SetMaterial( m_Param, *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT RecDP2SetMaterial( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2SETMATERIAL* pParam=
            reinterpret_cast< D3DHAL_DP2SETMATERIAL*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            GetDP2SetMaterial( *pParam);
            ++pParam;
        } while( --wStateCount);
        return DD_OK;
    }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TDP2Data= CDP2DataWrap<> >
class CStdDP2SetVertexShaderStore
{
protected: // Variables
    D3DHAL_DP2VERTEXSHADER m_Param;

protected: // Functions
    CStdDP2SetVertexShaderStore() 
    { }
    explicit CStdDP2SetVertexShaderStore( const D3DHAL_DP2VERTEXSHADER& P)
        : m_Param( P)
    { }
    ~CStdDP2SetVertexShaderStore() 
    { }

    D3DHAL_DP2VERTEXSHADER NewDP2SetVertexShader( const D3DHAL_DP2VERTEXSHADER&
        CurParam, const D3DHAL_DP2VERTEXSHADER& NewParam) const 
    {   // Tell notifier to store the new param.
        return NewParam;
    }

public: // Fuctions
    void GetDP2SetVertexShader( D3DHAL_DP2VERTEXSHADER& GetParam) const 
    { GetParam= m_Param; }
    operator D3DHAL_DP2VERTEXSHADER() const 
    { return m_Param; }
    HRESULT DP2SetVertexShader( TDP2Data&, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2VERTEXSHADER* pParam=
            reinterpret_cast< const D3DHAL_DP2VERTEXSHADER*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            m_Param= pSThis->NewDP2SetVertexShader( m_Param, *pParam);

            // If the handle is 0, the Device/ Context needs to invalidate all
            // streams.
            if( 0== m_Param.dwHandle)
            {
                // The CStdDP2VStreamManager provides a default implementation
                // for InvalidateAllVStreams()
                pSThis->InvalidateAllVStreams();
                // The CStdDP2IStreamManager provides a default implementation
                // for InvalidateAllIStreams()
                pSThis->InvalidateAllIStreams();
            }
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT RecDP2SetVertexShader( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2VERTEXSHADER* pParam=
            reinterpret_cast< D3DHAL_DP2VERTEXSHADER*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            GetDP2SetVertexShader( *pParam);
            ++pParam;
        } while( wStateCount!= 0);
        return DD_OK;
    }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TDP2Data= CDP2DataWrap<> >
class CStdDP2SetPixelShaderStore
{
protected: // Variables
    D3DHAL_DP2PIXELSHADER m_Param;

protected: // Functions
    CStdDP2SetPixelShaderStore() 
    { }
    explicit CStdDP2SetPixelShaderStore( const D3DHAL_DP2PIXELSHADER& P)
        : m_Param( P)
    { }
    ~CStdDP2SetPixelShaderStore() 
    { }

    D3DHAL_DP2PIXELSHADER NewDP2SetPixelShader( const D3DHAL_DP2PIXELSHADER&
        CurParam, const D3DHAL_DP2PIXELSHADER& NewParam) const 
    {   // Tell notifier to store the new param.
        return NewParam;
    }

public: // Fuctions
    void GetDP2SetPixelShader( D3DHAL_DP2PIXELSHADER& GetParam) const 
    { GetParam= m_Param; }
    operator D3DHAL_DP2PIXELSHADER() const 
    { return m_Param; }
    HRESULT DP2SetPixelShader( TDP2Data&, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2PIXELSHADER* pParam=
            reinterpret_cast< const D3DHAL_DP2PIXELSHADER*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            m_Param= pSThis->NewDP2SetPixelShader( m_Param, *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT RecDP2SetPixelShader( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2PIXELSHADER* pParam=
            reinterpret_cast< D3DHAL_DP2PIXELSHADER*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            GetDP2SetPixelShader( *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// c_uiWorldMatrices: The number of world transform matrices that should be
//     stored.
// c_uiTextureMatrices: The number of texture transform matrices that should
//     be stored.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, const size_t c_uiWorldMatrices= 256,
    const size_t c_uiTextureMatrices= D3DHAL_TSS_MAXSTAGES,
    class TDP2Data= CDP2DataWrap<> >
class CStdDP2SetTransformStore
{
protected: // Types
    typedef block< D3DMATRIX, 2+ c_uiTextureMatrices+ c_uiWorldMatrices>
        TMatrices;

protected: // Variables
    TMatrices m_Matrices;

private: // Functions
    static bool IsValidTransformType( D3DTRANSFORMSTATETYPE Type)
    {
        // We might not be storing this transform matrix, so we shouldn't
        // record it in a state set and ignore any SET requests.
        if( (Type>= D3DTS_VIEW&& Type<= D3DTS_PROJECTION)||
            (Type>= D3DTS_TEXTURE0&& Type< static_cast< D3DTRANSFORMSTATETYPE>( 
            D3DTS_TEXTURE0+ c_uiTextureMatrices))||
            (Type>= D3DTS_WORLD&& Type< static_cast< D3DTRANSFORMSTATETYPE>(
            D3DTS_WORLDMATRIX( c_uiWorldMatrices))))
            return true;
        return false;
    }
    static size_t TransformTypeToIndex( D3DTRANSFORMSTATETYPE Type)
    {
        assert( Type>= D3DTS_VIEW);
        if( Type< D3DTS_TEXTURE0)
        {
            assert( Type<= D3DTS_PROJECTION);
            return static_cast< size_t>( Type- D3DTS_VIEW);
        }
        else if( Type< D3DTS_WORLD)
        {
            assert( Type< static_cast< D3DTRANSFORMSTATETYPE>( \
                D3DTS_TEXTURE0+ c_uiTextureMatrices));
            return static_cast< size_t>( Type- D3DTS_TEXTURE0+ 2);
        }
        else
        {
            assert( Type< static_cast< D3DTRANSFORMSTATETYPE>( \
                D3DTS_WORLDMATRIX( c_uiWorldMatrices)));
            return static_cast< size_t>( Type- D3DTS_WORLD+
                c_uiTextureMatrices+ 2);
        }
    }

protected: // Functions
    CStdDP2SetTransformStore()
    { }
    template< class TIter> // D3DHAL_DP2SETTRANSFORM*
    CStdDP2SetTransformStore( TIter itStart, const TIter itEnd)
    {
        while( itStart!= itEnd)
        {
            m_Matrices[ TransformTypeToIndex( itStart->xfrmType)]=
                itStart->matrix;
            ++itStart;
        }
    }
    ~CStdDP2SetTransformStore()
    { }

    D3DHAL_DP2SETTRANSFORM NewDP2SetTransform( const D3DHAL_DP2SETTRANSFORM&
        CurParam, const D3DHAL_DP2SETTRANSFORM& NewParam) const 
    {   // Tell notifier to store the new param.
        return NewParam;
    }

public: // Fuctions
    D3DMATRIX GetTransform( D3DTRANSFORMSTATETYPE Type) const
    { return m_Matrices[ TransformTypeToIndex( Type)]; }
    void GetDP2SetTransform( D3DHAL_DP2SETTRANSFORM& GetParam) const 
    { GetParam.matrix= GetTransform( GetParam.xfrmType); }
    HRESULT DP2SetTransform( TDP2Data&, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2SETTRANSFORM* pParam=
            reinterpret_cast<const D3DHAL_DP2SETTRANSFORM*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            if( IsValidTransformType( pParam->xfrmType))
            {
                D3DHAL_DP2SETTRANSFORM CurWrap;
                CurWrap.xfrmType= pParam->xfrmType;
                GetDP2SetTransform( CurWrap);

                D3DHAL_DP2SETTRANSFORM NewState(
                    pSThis->NewDP2SetTransform( CurWrap, *pParam));

                m_Matrices[ TransformTypeToIndex( NewState.xfrmType)]=
                    NewState.matrix;
            }
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT RecDP2SetTransform( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2SETTRANSFORM* pParam=
            reinterpret_cast< D3DHAL_DP2SETTRANSFORM*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            if( IsValidTransformType( pParam->xfrmType))
                GetDP2SetTransform( *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// c_uiClipPlanes: The number of user clip planes that should be stored. This
//     should be consistent with the driver cap.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, const size_t c_uiClipPlanes,
    class TDP2Data= CDP2DataWrap<> >
class CStdDP2SetClipPlaneStore
{
protected: // Types
    typedef block< block< D3DVALUE, 4>, c_uiClipPlanes> TClipPlanes;

protected: // Variables
    TClipPlanes m_ClipPlanes;

protected: // Functions
    CStdDP2SetClipPlaneStore()
    { }
    template< class TIter> // D3DHAL_DP2SETCLIPPLANE*
    CStdDP2SetClipPlaneStore( TIter itStart, const TIter itEnd)
    {
        while( itStart!= itEnd)
        {
            m_ClipPlanes[ itStart->dwIndex]= itStart->plane;
            ++itStart;
        }
    }
    ~CStdDP2SetClipPlaneStore()
    { }

    D3DHAL_DP2SETCLIPPLANE NewDP2SetClipPlane( const D3DHAL_DP2SETCLIPPLANE&
        CurParam, const D3DHAL_DP2SETCLIPPLANE& NewParam) const
    {   // Tell notifier to store the new param.
        return NewParam;
    }

public: // Functions
    block< D3DVALUE, 4> GetClipPlane( DWORD dwIndex) const
    { return m_ClipPlanes[ dwIndex]; }
    void GetDP2SetClipPlane( D3DHAL_DP2SETCLIPPLANE& GetParam) const
    { 
        block< D3DVALUE, 4> CP( GetClipPlane( GetParam.dwIndex));
        copy( CP.begin(), CP.end(), &GetParam.plane[ 0]);
    }
    HRESULT DP2SetClipPlane( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2SETCLIPPLANE* pParam=
            reinterpret_cast<const D3DHAL_DP2SETCLIPPLANE*>(pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            if( pParam->dwIndex< m_ClipPlanes.size())
            {
                D3DHAL_DP2SETCLIPPLANE CurWrap;
                CurWrap.dwIndex= pParam->dwIndex;
                GetDP2SetClipPlane( CurWrap);

                D3DHAL_DP2SETCLIPPLANE NewState( 
                    pSThis->NewDP2SetClipPlane( CurWrap, *pParam));

                copy( &NewState.plane[ 0], &NewState.plane[ 4],
                    m_ClipPlanes[ NewState.dwIndex].begin());
            }
            ++pParam;
        } while( --wStateCount);
        return DD_OK;
    }
    HRESULT RecDP2SetClipPlane( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2SETCLIPPLANE* pParam=
            reinterpret_cast< D3DHAL_DP2SETCLIPPLANE*>(pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            if( pParam->dwIndex< m_ClipPlanes.size())
                GetDP2SetClipPlane( *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TDP2Data= CDP2DataWrap<> >
class CStdDP2RenderStateStore
{
protected: // Variables
    block< DWORD, D3DHAL_MAX_RSTATES> m_Param;

protected: // Functions
    CStdDP2RenderStateStore() 
    { m_Param[ D3DRENDERSTATE_SCENECAPTURE]= FALSE; }
    template< class TIter> // D3DHAL_DP2RENDERSTATE*
    CStdDP2RenderStateStore( TIter itStart, const TIter itEnd)
    {
        m_Param[ D3DRENDERSTATE_SCENECAPTURE]= FALSE; 
        while( itStart!= itEnd)
        {
            m_Param[ itStart->RenderState]= itStart->dwState;
            itStart++;
        }
    }
    ~CStdDP2RenderStateStore() 
    { }

    D3DHAL_DP2RENDERSTATE NewDP2RenderState( const D3DHAL_DP2RENDERSTATE&
        CurParam, const D3DHAL_DP2RENDERSTATE& NewParam) const 
    {   // Tell notifier to store the new param.
        return NewParam;
    }

    void OnSceneCaptureStart( void) 
    { }
    void OnSceneCaptureEnd( void) 
    { }

public: // Functions
    DWORD GetRenderStateDW( D3DRENDERSTATETYPE RS) const 
    { return m_Param[ RS]; }
    D3DVALUE GetRenderStateDV( D3DRENDERSTATETYPE RS) const 
    { return *(reinterpret_cast< const D3DVALUE*>( &m_Param[ RS])); }
    void GetDP2RenderState( D3DHAL_DP2RENDERSTATE& GetParam) const 
    { GetParam.dwState= GetRenderStateDW( GetParam.RenderState); }
    HRESULT DP2RenderState( TDP2Data& DP2Data, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2RENDERSTATE* pParam=
            reinterpret_cast<const D3DHAL_DP2RENDERSTATE*>(pP);
        WORD wStateCount( pCmd->wStateCount);

        D3DHAL_DP2RENDERSTATE SCap;
        SCap.RenderState= static_cast< D3DRENDERSTATETYPE>(
            D3DRENDERSTATE_SCENECAPTURE);
        GetDP2RenderState( SCap);
        const DWORD dwOldSC( SCap.dwState);

        if((DP2Data.dwFlags()& D3DHALDP2_EXECUTEBUFFER)!= 0)
        {
            // DP2Data.lpdwRStates should be valid.

            if( wStateCount!= 0) do
            {
                if( pParam->RenderState< D3DHAL_MAX_RSTATES)
                {
                    D3DHAL_DP2RENDERSTATE CurWrap;
                    CurWrap.RenderState= pParam->RenderState;
                    GetDP2RenderState( CurWrap);

                    D3DHAL_DP2RENDERSTATE NewState(
                        pSThis->NewDP2RenderState( CurWrap, *pParam));
                    
                    m_Param[ NewState.RenderState]= NewState.dwState;
                    DP2Data.lpdwRStates()[ NewState.RenderState]= NewState.dwState;
                }
                ++pParam;
            } while( --wStateCount!= 0);
            
        }
        else
        {
            if( wStateCount!= 0) do
            {
                if( pParam->RenderState< D3DHAL_MAX_RSTATES)
                {
                    D3DHAL_DP2RENDERSTATE CurWrap;
                    CurWrap.RenderState= pParam->RenderState;
                    GetDP2RenderState( CurWrap);

                    D3DHAL_DP2RENDERSTATE NewState(
                        pSThis->NewDP2RenderState( CurWrap, *pParam));

                    m_Param[ NewState.RenderState]= NewState.dwState;
                }
                ++pParam;
            } while( --wStateCount!= 0);
        }

        GetDP2RenderState( SCap);
        if( FALSE== dwOldSC && TRUE== SCap.dwState)
            OnSceneCaptureStart();
        else if( TRUE== dwOldSC && FALSE== SCap.dwState)
            OnSceneCaptureEnd();

        return DD_OK;
    }
    HRESULT RecDP2RenderState( const D3DHAL_DP2COMMAND* pCmd, void* pP) 
    {
        D3DHAL_DP2RENDERSTATE* pParam=
            reinterpret_cast< D3DHAL_DP2RENDERSTATE*>(pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount) do
        {
            if( pParam->RenderState< D3DHAL_MAX_RSTATES)
                GetDP2RenderState( *pParam);
            ++pParam;
        } while( --wStateCount!= 0);

        return DD_OK;
    }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TDP2Data= CDP2DataWrap<> >
class CStdDP2TextureStageStateStore
{
protected: // Variables
    block< block< DWORD, D3DTSS_MAX>, D3DHAL_TSS_MAXSTAGES> m_Param;

protected: // Functions
    CStdDP2TextureStageStateStore() 
    { }
    template< class TIter> // D3DHAL_DP2TEXTURESTAGESTATE*
    CStdDP2TextureStageStateStore( TIter itStart, const TIter itEnd)
    {   
        while( itStart!= itEnd)
        {
            m_Param[ itStart->wStage][ itStart->TSState]= itStart->dwValue();
            ++itStart;
        }
    }
    ~CStdDP2TextureStageStateStore() 
    { }

    D3DHAL_DP2TEXTURESTAGESTATE NewDP2TextureStageState( const 
        D3DHAL_DP2TEXTURESTAGESTATE& CurParam, const
        D3DHAL_DP2TEXTURESTAGESTATE& NewParam) const 
    {   // Tell notifier to store the new param.
        return NewParam;
    }

public: // Functions
    DWORD GetTextureStageStateDW( WORD wStage, WORD wTSState) const 
    { return m_Param[ wStage][ wTSState]; }
    D3DVALUE GetTextureStageStateDV( WORD wStage, WORD wTSState) const 
    { return *(reinterpret_cast< const D3DVALUE*>( &m_Param[ wStage][ wTSState])); }
    void GetDP2TextureStageState( D3DHAL_DP2TEXTURESTAGESTATE& GetParam) const
    { GetParam.dwValue= GetTextureStageStateDW( GetParam.wStage, GetParam.TSState); }
    HRESULT DP2TextureStageState( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2TEXTURESTAGESTATE* pParam=
            reinterpret_cast<const D3DHAL_DP2TEXTURESTAGESTATE*>(pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            if( pParam->wStage< D3DHAL_TSS_MAXSTAGES&& pParam->TSState< D3DTSS_MAX)
            {
                D3DHAL_DP2TEXTURESTAGESTATE CurWrap;
                CurWrap.wStage= pParam->wStage;
                CurWrap.TSState= pParam->TSState;
                GetDP2TextureStageState( CurWrap);

                D3DHAL_DP2TEXTURESTAGESTATE NewState( 
                    pSThis->NewDP2TextureStageState( CurWrap, *pParam));

                m_Param[ NewState.wStage][ NewState.TSState]= NewState.dwValue;
            }
            ++pParam;
        } while( --wStateCount);

        return DD_OK;
    }
    HRESULT RecDP2TextureStageState( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2TEXTURESTAGESTATE* pParam=
            reinterpret_cast< D3DHAL_DP2TEXTURESTAGESTATE*>(pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            if( pParam->wStage< D3DHAL_TSS_MAXSTAGES&& pParam->TSState< D3DTSS_MAX)
                GetDP2TextureStageState( *pParam);
            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
};

//
// The more complex manager classes:
//

////////////////////////////////////////////////////////////////////////////////
//
// CVStream
//
// This class stores everything associated with a vertex stream. This
// implementation allows 4 representations (video, system, user, and none).
// This class is used by a VStream manager class.
//
// <Template Parameters>
// TS: Video memory surface object, typically either CMySurface or
//     IVidMemSurface, etc. A valid pointer to this object is stored, when the
//     stream source is from a video memory surface.
// TSDBE: The SurfDBEntry type, typically, CMySurfDBEntry or CSurfDBEntry. A
//     valid pointer to this object is stored, when the stream source is from
//     a video memory or system memory surface.
//
////////////////////////////////////////////////////////////////////////////////
template< class TS, class TSDBE>
class CVStream
{
public: // Types
    typedef TS TSurface;
    typedef TSDBE TSurfDBEntry;
    enum EMemLocation
    {
        None,
        User,
        System,
        Video
    };

protected: // Variables
    DWORD m_dwHandle;
    TSurface m_Surface;
    TSurfDBEntry m_SurfDBEntry;
    void* m_pUserMemData;
    DWORD m_dwStride;
    DWORD m_dwFVF;
    EMemLocation m_eMemLocation;

public: // Functions
    CVStream()
        : m_dwHandle( 0), m_pUserMemData( NULL), m_dwStride( 0), m_dwFVF( 0),
        m_eMemLocation( None)
    { }
    // Video Memory representation constructor.
    CVStream( DWORD dwHandle, const TSurface& Surface,
        const TSurfDBEntry& SurfDBEntry, DWORD dwStride): m_dwHandle( dwHandle),
        m_Surface( Surface), m_SurfDBEntry( SurfDBEntry), m_pUserMemData( NULL),
        m_dwStride( dwStride), m_dwFVF( 0), m_eMemLocation( Video)
    { }
    // System Memory representation constructor.
    CVStream( DWORD dwHandle, const TSurfDBEntry& SurfDBEntry, DWORD dwStride):
        m_dwHandle( dwHandle), m_SurfDBEntry( SurfDBEntry),
        m_pUserMemData( NULL), m_dwStride( dwStride), m_dwFVF( 0),
        m_eMemLocation( System)
    { }
    // User Memory representation constructor.
    CVStream( void* pUserMem, DWORD dwStride):
        m_dwHandle( 0), m_pUserMemData( pUserMem), m_dwStride( dwStride),
        m_dwFVF( 0), m_eMemLocation( User)
    { }

    EMemLocation GetMemLocation() const
    { return m_eMemLocation; }
    void SetFVF( DWORD dwFVF)
    { m_dwFVF= dwFVF; }
    DWORD GetFVF() const
    { return m_dwFVF; }
    DWORD GetHandle() const
    {
        assert( GetMemLocation()== System|| GetMemLocation()== Video);
        return m_dwHandle;
    }
    DWORD GetStride() const
    {
        assert( GetMemLocation()!= None);
        return m_dwStride;
    }
    TSurface& GetVidMemRepresentation()
    {
        assert( GetMemLocation()== Video);
        return m_Surface;
    }
    const TSurface& GetVidMemRepresentation() const
    {
        assert( GetMemLocation()== Video);
        return m_Surface;
    }
    TSurfDBEntry& GetSurfDBRepresentation()
    {
        assert( GetMemLocation()== Video|| GetMemLocation()== System);
        return m_SurfDBEntry;
    }
    const TSurfDBEntry& GetSurfDBRepresentation() const
    {
        assert( GetMemLocation()== Video|| GetMemLocation()== System);
        return m_SurfDBEntry;
    }
    void* GetUserMemPtr() const
    {
        assert( GetMemLocation()== User);
        return m_pUserMemData;
    }
};

////////////////////////////////////////////////////////////////////////////////
//
// CStdDP2VStreamManager
//
// This class contains DP2 member functions to correctly process 
// D3DDP2OP_SETSTREAMSOURCE & D3DDP2OP_SETSTREAMSOURCEUM. It can also correctly
// record a command buffer operation for D3DDP2OP_SETSTREAMSOURCE. To do this,
// however, it must maintain information for vertex stream, or "manage"
// VStream objects.
//
// This class also contains a function, InvalidateAllStreams, which is needed
// to be called when a D3DDP2OP_SETVERTEXSHADER operation is processed with a
// zero value VERTEXSHADER.
//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TVS: The vertex stream type which represents data associated with a vertex
//     stream. This is typically, CVStream<> or something derived from it.
// c_uiStreams: The number of vertex streams to support. Typically, non-TnL
//     drivers only support 1. This should be consistent with the cap in the
//     driver.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
////////////////////////////////////////////////////////////////////////////////
template< class TSuper,
    class TVS= CVStream< TSuper::TPerDDrawData::TDriver::TSurface*, TSuper::TPerDDrawData::TSurfDBEntry*>,
    const size_t c_uiStreams= 1, class TDP2Data= CDP2DataWrap<> >
class CStdDP2VStreamManager
{
public: // Types
    typedef TVS TVStream;
    typedef block< TVStream, c_uiStreams> TVStreamDB;

protected: // Variables
    TVStreamDB m_VStreamDB;

protected: // Functions
    CStdDP2VStreamManager() 
    { }
    ~CStdDP2VStreamManager() 
    { }

public: // Fuctions
    TVStream& GetVStream( TVStreamDB::size_type uiStream)
    { return m_VStreamDB[ uiStream]; }
    const TVStream& GetVStream( TVStreamDB::size_type uiStream) const
    { return m_VStreamDB[ uiStream]; }
    HRESULT DP2SetStreamSource( TDP2Data&, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        const D3DHAL_DP2SETSTREAMSOURCE* pParam=
            reinterpret_cast< const D3DHAL_DP2SETSTREAMSOURCE*>( pP);
        TSuper* pSThis= static_cast<TSuper*>(this);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            if( pParam->dwStream< m_VStreamDB.size())
            {
                if( 0== pParam->dwVBHandle)
                    m_VStreamDB[ pParam->dwStream]= TVStream();
                else
                {
                    typename TSuper::TPerDDrawData::TSurfDBEntry* pDBEntry=
                        pSThis->GetPerDDrawData().GetSurfDBEntry(
                        pParam->dwVBHandle);
                    if( pDBEntry!= NULL)
                    {
                        if((pDBEntry->GetLCLddsCaps().dwCaps&
                            DDSCAPS_VIDEOMEMORY)!= 0)
                        {
                            // Assign in a video memory representation.
                            m_VStreamDB[ pParam->dwStream]=
                                TVStream( pParam->dwVBHandle, pSThis->
                                GetPerDDrawData().GetDriver().GetSurface(
                                *pDBEntry), pDBEntry, pParam->dwStride);
                        }
                        else
                        {
                            // Assign in a system memory representation.
                            m_VStreamDB[ pParam->dwStream]=
                                TVStream( pParam->dwVBHandle,
                                pDBEntry, pParam->dwStride);
                        }
                    }
                    else
                    {
                        // Handle invalid, reset stream.
                        m_VStreamDB[ pParam->dwStream]= TVStream();
                    }
                }
            }

            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT DP2SetStreamSourceUM( TDP2Data& DP2Data, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        const D3DHAL_DP2SETSTREAMSOURCEUM* pParam=
            reinterpret_cast< const D3DHAL_DP2SETSTREAMSOURCEUM*>( pP);
        TSuper* pSThis= static_cast<TSuper*>(this);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            if( pParam->dwStream< m_VStreamDB.size())
            {
                if( DP2Data.lpVertices()!= NULL)
                {
                    // Assign in a user memory representation.
                    m_VStreamDB[ pParam->dwStream]=
                        TVStream( DP2Data.lpVertices(), pParam->dwStride);
                }
                else
                {
                    // Reset stream.
                    m_VStreamDB[ pParam->dwStream]= TVStream();
                }
            }

            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT RecDP2SetStreamSource( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2SETSTREAMSOURCE* pParam=
            reinterpret_cast< D3DHAL_DP2SETSTREAMSOURCE*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            const DWORD dwStream( pParam->dwStream);
            if( dwStream< m_VStreamDB.size())
            {
                const TVStream& VStream( m_VStreamDB[ dwStream]);
                switch( VStream.GetMemLocation())
                {
                case( TVStream::EMemLocation::None): ;
                case( TVStream::EMemLocation::User): ;
                    pParam->dwVBHandle= 0;
                    pParam->dwStride= 0;
                    break;

                case( TVStream::EMemLocation::System): ;
                case( TVStream::EMemLocation::Video): ;
                    pParam->dwVBHandle= VStream.GetHandle();
                    pParam->dwStride= VStream.GetStride();
                    break;

                default: {
                    const bool Unrecognized_VStream_enum( false);
                    assert( Unrecognized_VStream_enum);
                    }
                }
            }

            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    void InvalidateAllVStreams()
    {
        fill( m_VStreamDB.begin(), m_VStreamDB.end(), TVStream());
    }
};

////////////////////////////////////////////////////////////////////////////////
//
// CIStream
//
// This class stores everything associated with a index stream. This
// implementation allows 3 representations (video, system, and none).
// This class is used by a IStream manager class.
//
// <Template Parameters>
// TS: Video memory surface object, typically either CMySurface or
//     IVidMemSurface, etc. A valid pointer to this object is stored, when the
//     stream source is from a video memory surface.
// TSDBE: The SurfDBEntry type, typically, CMySurfDBEntry or CSurfDBEntry. A
//     valid pointer to this object is stored, when the stream source is from
//     a video memory or system memory surface.
//
////////////////////////////////////////////////////////////////////////////////
template< class TS, class TSDBE>
class CIStream
{
public: // Types
    typedef TS TSurface;
    typedef TSDBE TSurfDBEntry;
    enum EMemLocation
    {
        None,
        System,
        Video
    };

protected: // Variables
    DWORD m_dwHandle;
    TSurface m_Surface;
    TSurfDBEntry m_SurfDBEntry;
    DWORD m_dwStride;
    EMemLocation m_eMemLocation;

public: // Functions
    CIStream():
        m_dwHandle( 0), m_dwStride( 0), m_eMemLocation( None)
    { }
    // Video Memory representation constructor.
    CIStream( DWORD dwHandle, const TSurface& Surface,
        const TSurfDBEntry& SurfDBEntry, DWORD dwStride): m_dwHandle( dwHandle),
        m_Surface( Surface), m_SurfDBEntry( SurfDBEntry), m_dwStride( dwStride),
        m_eMemLocation( Video)
    { }
    // System Memory representation constructor.
    CIStream( DWORD dwHandle, const TSurfDBEntry& SurfDBEntry, DWORD dwStride):
        m_dwHandle( dwHandle), m_SurfDBEntry( SurfDBEntry),
        m_dwStride( dwStride), m_eMemLocation( System)
    { }

    EMemLocation GetMemLocation() const
    { return m_eMemLocation; }
    DWORD GetHandle() const
    {
        assert( GetMemLocation()== System|| GetMemLocation()== Video);
        return m_dwHandle;
    }
    DWORD GetStride() const
    {
        assert( GetMemLocation()!= None);
        return m_dwStride;
    }
    const TSurface& GetVidMemRepresentation() const
    {
        assert( GetMemLocation()== Video);
        return m_Surface;
    }
    TSurface& GetVidMemRepresentation()
    {
        assert( GetMemLocation()== Video);
        return m_Surface;
    }
    const TSurfDBEntry& GetSurfDBRepresentation() const
    {
        assert( GetMemLocation()== Video|| GetMemLocation()== System);
        return m_SurfDBEntry;
    }
    TSurfDBEntry& GetSurfDBRepresentation()
    {
        assert( GetMemLocation()== Video|| GetMemLocation()== System);
        return m_SurfDBEntry;
    }
};

////////////////////////////////////////////////////////////////////////////////
//
// CStdDP2IStreamManager
//
// This class contains DP2 member functions to correctly process 
// D3DDP2OP_SETINDICES. It can also correctly record a command buffer operation
// for D3DDP2OP_SETINDICES. To do this, however, it must maintain information
// for index streams, or "manage" IStream objects.
//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TIS: The index stream type which represents data associated with a index
//     stream. This is typically, CIStream<> or something derived from it.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
////////////////////////////////////////////////////////////////////////////////
template< class TSuper,
    class TIS= CIStream< TSuper::TPerDDrawData::TDriver::TSurface*, TSuper::TPerDDrawData::TSurfDBEntry*>,
    class TDP2Data= CDP2DataWrap<> >
class CStdDP2IStreamManager
{
public: // Types
    typedef TIS TIStream;
    typedef block< TIStream, 1> TIStreamDB;

protected: // Variables
    TIStreamDB m_IStreamDB;

protected: // Functions
    CStdDP2IStreamManager() 
    { }
    ~CStdDP2IStreamManager() 
    { }

public: // Fuctions
    TIStream& GetIStream( TIStreamDB::size_type uiStream)
    { return m_IStreamDB[ uiStream]; }
    const TIStream& GetIStream( TIStreamDB::size_type uiStream) const
    { return m_IStreamDB[ uiStream]; }
    HRESULT DP2SetIndices( TDP2Data&, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        const D3DHAL_DP2SETINDICES* pParam=
            reinterpret_cast< const D3DHAL_DP2SETINDICES*>( pP);
        TSuper* pSThis= static_cast<TSuper*>(this);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            // For ease of extension in case multiple IStreams are supported
            // later.
            const DWORD dwStream( 0);

            if( dwStream< m_IStreamDB.size())
            {
                if( 0== pParam->dwVBHandle)
                    m_IStreamDB[ dwStream]= TIStream();
                else
                {
                    typename TSuper::TPerDDrawData::TSurfDBEntry* pDBEntry=
                        pSThis->GetPerDDrawData().GetSurfDBEntry(
                        pParam->dwVBHandle);
                    if( pDBEntry!= NULL)
                    {
                        if((pDBEntry->GetLCLddsCaps().dwCaps&
                            DDSCAPS_VIDEOMEMORY)!= 0)
                        {
                            // Assign in a video memory representation.
                            m_IStreamDB[ dwStream]=
                                TIStream( pParam->dwVBHandle, pSThis->
                                GetPerDDrawData().GetDriver().GetSurface(
                                *pDBEntry), pDBEntry, pParam->dwStride);
                        }
                        else
                        {
                            // Assign in a system memory representation.
                            m_IStreamDB[ dwStream]=
                                TIStream( pParam->dwVBHandle,
                                pDBEntry, pParam->dwStride);
                        }
                    }
                    else
                    {
                        // Handle invalid, reset stream.
                        m_IStreamDB[ dwStream]= TIStream();
                    }
                }
            }

            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    HRESULT RecDP2SetIndices( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2SETINDICES* pParam=
            reinterpret_cast< D3DHAL_DP2SETINDICES*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0) do
        {
            const DWORD dwStream( 0);
            if( dwStream< m_IStreamDB.size())
            {
                const TIStream& IStream( m_IStreamDB[ dwStream]);
                switch( IStream.GetMemLocation())
                {
                case( TIStream::EMemLocation::None): ;
                    pParam->dwVBHandle= 0;
                    pParam->dwStride= 0;
                    break;

                case( TIStream::EMemLocation::System): ;
                case( TIStream::EMemLocation::Video): ;
                    pParam->dwVBHandle= IStream.GetHandle();
                    pParam->dwStride= IStream.GetStride();
                    break;

                default: {
                    const bool Unrecognized_IStream_enum( false);
                    assert( Unrecognized_IStream_enum);
                    }
                }
            }

            ++pParam;
        } while( --wStateCount!= 0);
        return DD_OK;
    }
    void InvalidateAllIStreams()
    {
        fill( m_IStreamDB.begin(), m_IStreamDB.end(), TIStream());
    }
};

class CPalDBEntry
{
protected: // Types
    typedef block< DWORD, 256> TPalEntries;

protected: // Variables
    DWORD m_dwFlags;
    TPalEntries m_PalEntries;

public: // Functions
    CPalDBEntry() : m_dwFlags( 0)
    { fill( m_PalEntries.begin(), m_PalEntries.end(), 0); }
    ~CPalDBEntry() 
    { }
    void SetFlags( DWORD dwFlags) 
    { m_dwFlags= dwFlags; }
    DWORD GetFlags() 
    { return m_dwFlags; }
    DWORD* GetEntries() 
    { return m_PalEntries.begin(); }
    template< class ForwardIterator>
    void Update( TPalEntries::size_type uiStart, ForwardIterator f,
        ForwardIterator l) 
    { copy( f, l, m_PalEntries.begin()+ uiStart); }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TPDBE: This is the palette database entry type, or whatever is associated
//     with a palette. This type is typically, CPalDBEntry or something
//     derived from it.
// TPDB: This can be any Unique, Pair Associative Container, typically a map,
//     which associates a DWORD palette handle to a palette type.
// TSPDB: This can be any Unique, Pair Associative Container, typically a map,
//     which associates a DWORD surface handle to a DWORD palette handle.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TPDBE= CPalDBEntry, class TPDB= map< DWORD, TPDBE>,
    class TDP2Data= CDP2DataWrap<> >
class CStdDP2PaletteManager
{
public: // Types
    typedef TPDBE TPalDBEntry;
    typedef TPDB TPalDB;

protected: // Variables
    TPalDB m_PalDB;

protected: // Functions
    CStdDP2PaletteManager() 
    { }
    ~CStdDP2PaletteManager() 
    { }

public: // Functions
    void UpdatePalette( const D3DHAL_DP2UPDATEPALETTE* pParam)
    {
        typename TPalDB::iterator itPal( 
            m_PalDB.find( pParam->dwPaletteHandle));

        if( m_PalDB.end()== itPal)
            itPal= m_PalDB.insert( TPalDB::value_type( pParam->dwPaletteHandle,
                TPalDBEntry())).first;

        const DWORD* pEStart= reinterpret_cast< const DWORD*>( pParam+ 1);
        itPal->second.Update( pParam->wStartIndex, pEStart,
            pEStart+ pParam->wNumEntries);
    }
    void SetPalette( const D3DHAL_DP2SETPALETTE* pParam)
    {
        TSuper* pSThis= static_cast< TSuper*>( this);
        typedef typename TSuper::TPerDDrawData TPerDDrawData;
        typename TPerDDrawData::TSurfDBEntry* pSurfDBEntry=
            pSThis->GetPerDDrawData().GetSurfDBEntry( pParam->dwSurfaceHandle);
        assert( NULL!= pSurfDBEntry);

        if( 0== pParam->dwPaletteHandle)
        {
            // Disassociate the surface with any palette.
            pSurfDBEntry->SetPalette( NULL);
        }
        else
        {
            typename TPalDB::iterator itPal( 
                m_PalDB.find( pParam->dwPaletteHandle));

            if( m_PalDB.end()== itPal)
                itPal= m_PalDB.insert( TPalDB::value_type( pParam->dwPaletteHandle,
                    TPalDBEntry())).first;

            itPal->second.SetFlags( pParam->dwPaletteFlags);
            pSurfDBEntry->SetPalette( &itPal->second);
        }
    }
    HRESULT DP2SetPalette( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2SETPALETTE* pParam=
            reinterpret_cast<const D3DHAL_DP2SETPALETTE*>(pP);
        WORD wStateCount( pCmd->wStateCount);

        try
        {
            if( wStateCount!= 0) do
            {
                pSThis->SetPalette( pParam);
                ++pParam;
            } while( --wStateCount);
        } catch ( bad_alloc ba)
        { return E_OUTOFMEMORY; }

        return DD_OK;
    }
    HRESULT DP2UpdatePalette( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP) 
    {
        TSuper* pSThis= static_cast<TSuper*>(this);
        const D3DHAL_DP2UPDATEPALETTE* pParam=
            reinterpret_cast<const D3DHAL_DP2UPDATEPALETTE*>(pP);
        WORD wStateCount( pCmd->wStateCount);

        try
        {
            if( wStateCount!= 0)
                pSThis->UpdatePalette( pParam);
        } catch ( bad_alloc ba)
        { return E_OUTOFMEMORY; }

        return DD_OK;
    }
};

class CLightDBEntry:
    public D3DLIGHT8
{
protected: // Variables
    bool m_bEnabled;

public: // Functions
    CLightDBEntry()
        : m_bEnabled( false)
    {
        // Default light settings:
        Type= D3DLIGHT_DIRECTIONAL;
        Diffuse.r= 1.0f; Diffuse.g= 1.0f; Diffuse.b= 1.0f; Diffuse.a= 0.0f;
        Specular.r= 0.0f; Specular.g= 0.0f; Specular.b= 0.0f; Specular.a= 0.0f;
        Ambient.r= 0.0f; Ambient.g= 0.0f; Ambient.b= 0.0f; Ambient.a= 0.0f;
        Position.x= 0.0f; Position.y= 0.0f; Position.z= 0.0f;
        Direction.x= 0.0f; Direction.y= 0.0f; Direction.z= 1.0f;
        Range= 0.0f;
        Falloff= 0.0f;
        Attenuation0= 0.0f;
        Attenuation1= 0.0f;
        Attenuation2= 0.0f;
        Theta= 0.0f;
        Phi= 0.0f;
    }
    operator const D3DLIGHT8&() const
    { return *static_cast< const D3DLIGHT8*>( this); }
    CLightDBEntry& operator=( const D3DLIGHT8& Other)
    {
        *static_cast< D3DLIGHT8*>( this)= Other;
        return *this;
    }
    void SetEnabled( bool bEn)
    { m_bEnabled= bEn; }
    bool GetEnabled() const
    { return m_bEnabled; }
};

//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TLDBE: This is the light database entry type, or whatever is associated
//     with a light. This type is typically, CLightDBEntry or something
//     derived from it or convertable to D3DLIGHT8, at least.
// TLDB: This can be any Unique, Pair Associative Container, typically a map,
//     which associates a DWORD light id to a light type.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
template< class TSuper, class TLDBE= CLightDBEntry,
    class TLDB= map< DWORD, TLDBE>, class TDP2Data= CDP2DataWrap<> >
class CStdDP2LightManager
{
public: // Types
    typedef TLDBE TLightDBEntry;
    typedef TLDB TLightDB;

protected: // Variables
    TLightDB m_LightDB;

protected: // Functions
    CStdDP2LightManager() 
    { }
    ~CStdDP2LightManager() 
    { }

public: // Functions
    void CreateLight( DWORD dwId)
    {
        pair< typename TLightDB::iterator, bool> Ret= m_LightDB.insert( 
            typename TLightDB::value_type( dwId, TLightDBEntry()));
    }
    void EnableLight( DWORD dwId, bool bEnable)
    {
        typename TLightDB::iterator itLight( m_LightDB.find( dwId));
        assert( itLight!= m_LightDB.end());

        itLight->second.SetEnabled( bEnable);
    }
    void UpdateLight( DWORD dwId, const D3DLIGHT8& LightValue)
    {
        typename TLightDB::iterator itLight( m_LightDB.find( dwId));
        assert( itLight!= m_LightDB.end());

        itLight->second= LightValue;
    }
    HRESULT DP2CreateLight( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP) 
    {
        TSuper* pSThis= static_cast< TSuper*>( this);
        const D3DHAL_DP2CREATELIGHT* pParam=
            reinterpret_cast< const D3DHAL_DP2CREATELIGHT*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        try
        {
            if( wStateCount!= 0) do
            {
                pSThis->CreateLight( pParam->dwIndex);
                ++pParam;
            } while( --wStateCount);
        } catch ( bad_alloc ba)
        { return E_OUTOFMEMORY; }

        return D3D_OK;
    }
    HRESULT DP2SetLight( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP) 
    {
        TSuper* pSThis= static_cast< TSuper*>( this);
        const D3DHAL_DP2SETLIGHT* pParam=
            reinterpret_cast< const D3DHAL_DP2SETLIGHT*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        try
        {
            if( wStateCount!= 0) do
            {
                if( m_LightDB.end()== m_LightDB.find( pParam->dwIndex))
                {
                    const bool SetLight_without_succeeded_CreateLight( false);
                    assert( SetLight_without_succeeded_CreateLight);
                    return DDERR_INVALIDPARAMS;
                }

                bool bEnable( false);
                switch( pParam->dwDataType)
                {
                case( D3DHAL_SETLIGHT_DATA):
                    const D3DLIGHT8* pL= reinterpret_cast< const D3DLIGHT8*>(
                        pParam+ 1);
                    pSThis->UpdateLight( pParam->dwIndex, *pL);
                    pParam= reinterpret_cast< const D3DHAL_DP2SETLIGHT*>(
                        pL+ 1);
                    break;

                case( D3DHAL_SETLIGHT_ENABLE):
                    bEnable= true; // Fall-through.
                case( D3DHAL_SETLIGHT_DISABLE):
                    pSThis->EnableLight( pParam->dwIndex, bEnable);
                    ++pParam;
                    break;

                default: {
                        const bool Unrecognized_D3DHAL_SETLIGHT_data_type( false);
                        assert( Unrecognized_D3DHAL_SETLIGHT_data_type);
                        return DDERR_INVALIDPARAMS;
                    }
                }
            } while( --wStateCount);
        } catch ( bad_alloc ba)
        { return E_OUTOFMEMORY; }

        return D3D_OK;
    }
    HRESULT RecDP2CreateLight( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2CREATELIGHT* pParam=
            reinterpret_cast< D3DHAL_DP2CREATELIGHT*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        // Special case here, the default state set capturing, will ask how
        // many active lights are needed to be recorded, and their id's. In
        // order to support the default state set, we must process this
        // specially.
        if( 0== pCmd->bCommand)
        {
            // Now, we're either being asked how many lights or what their
            // id's are.
            if( 0== wStateCount)
                pParam->dwIndex= m_LightDB.size();
            else
            {
                assert( m_LightDB.size()== wStateCount);
                typename TLightDB::const_iterator itCur( m_LightDB.begin());
                do
                {
                    pParam->dwIndex= itCur.first;
                    ++pParam;
                    ++itCur;
                } while( --wStateCount!= 0);
            }
            return D3D_OK;
        }

        // Otherwise, recording creation is easy,
        // leave the command buffer as is.
        return D3D_OK;
    }
    HRESULT RecDP2SetLight( const D3DHAL_DP2COMMAND* pCmd, void* pP)
    {
        D3DHAL_DP2SETLIGHT* pParam=
            reinterpret_cast< D3DHAL_DP2SETLIGHT*>( pP);
        WORD wStateCount( pCmd->wStateCount);

        const typename TLightDB::const_iterator itEnd( m_LightDB.end());
        typename TLightDB::const_iterator itLight( itEnd);
        if( wStateCount!= 0) do
        {
            if( itLight!= itEnd&& itLight->first!= pParam->dwIndex)
                itLight= m_LightDB.find( pParam->dwIndex);
            assert( itLight!= itEnd);

            switch( pParam->dwDataType)
            {
            case( D3DHAL_SETLIGHT_DATA):
                D3DLIGHT8* pL= reinterpret_cast< D3DLIGHT8*>( pParam+ 1);
                *pL= itLight->second;
                pParam= reinterpret_cast< D3DHAL_DP2SETLIGHT*>( pL+ 1);
                break;

            case( D3DHAL_SETLIGHT_ENABLE):
            case( D3DHAL_SETLIGHT_DISABLE):
                pParam->dwDataType= ( itLight->second.GetEnabled()? 
                    D3DHAL_SETLIGHT_ENABLE: D3DHAL_SETLIGHT_DISABLE);
                ++pParam;
                break;

            default: {
                    const bool Unrecognized_D3DHAL_SETLIGHT_data_type( false);
                    assert( Unrecognized_D3DHAL_SETLIGHT_data_type);
                    return DDERR_INVALIDPARAMS;
                }
            }
        } while( --wStateCount!= 0);

        return D3D_OK;
    }
};

template< class TS, class TSDBE>
class CRTarget
{
public: // Types
    typedef TS TSurface;
    typedef TSDBE TSurfDBEntry;
    enum EMemLocation
    {
        None,
        Video
    };

protected: // Variables
    DWORD m_dwHandle;
    TSurface m_Surface;
    TSurfDBEntry m_SurfDBEntry;
    EMemLocation m_eMemLocation;

public: // Functions
    CRTarget(): m_eMemLocation( None)
    { }
    // Video Memory representation constructor.
    CRTarget( DWORD dwHandle, const TSurface& Surface,
        const TSurfDBEntry& SurfDBEntry): m_dwHandle( dwHandle),
        m_Surface( Surface), m_SurfDBEntry( SurfDBEntry), m_eMemLocation( Video)
    { }
    ~CRTarget()
    { }

    bool operator==( const CRTarget& Other) const
    {
        const EMemLocation MemLocation( GetMemLocation());
        return MemLocation== Other.GetMemLocation()&&
            (None== MemLocation|| GetHandle()== Other.GetHandle());
    }
    bool operator!=( const CRTarget& Other) const
    { return !(*this== Other); }

    DWORD GetHandle() const
    {
        assert( GetMemLocation()!= None);
        return m_dwHandle;
    }
    TSurface& GetVidMemRepresentation()
    {
        assert( GetMemLocation()== Video);
        return m_Surface;
    }
    const TSurface& GetVidMemRepresentation() const
    {
        assert( GetMemLocation()== Video);
        return m_Surface;
    }
    TSurfDBEntry& GetSurfDBRepresentation()
    {
        assert( GetMemLocation()== Video);
        return m_SurfDBEntry;
    }
    const TSurfDBEntry& GetSurfDBRepresentation() const
    {
        assert( GetMemLocation()== Video);
        return m_SurfDBEntry;
    }
    EMemLocation GetMemLocation() const
    { return m_eMemLocation; }
    void Clear( const D3DHAL_DP2CLEAR& DP2Clear, const RECT& Rect)
    {
        if( GetMemLocation()!= None)
            GetVidMemRepresentation()->Clear( DP2Clear, Rect);
    }
};

////////////////////////////////////////////////////////////////////////////////
//
// CSubContext
//
// This provides a base implementation for a context. It provides
// implementations for dealing with the SetRenderTarget and Clear
// DrawPrimitive2 commands; and also a minimal implementation for
// GetDriverState.
//
// <Template Parameters>
// TSuper: Standard parent type which is inheriting from this child class.
//     In this case, it should typically be the CMyContext type.
// TPDDD: The PerDDrawData type, typically CMyPerDDrawData or
//     CMinimalPerDDrawData<>.
// TDP2Data: This is some kind of wrapper class for PORTABLE_DRAWPRIMITIVES2DATA
//     The type is expected to inherit or emulate PORTABLE_DRAWPRIMITIVES2DATA's
//     fields/ member variables, and should typically be consistent with
//     CStdDrawPrimitives2< xxx >::TDP2Data.
//
// <Exposed Types>
// TPerDDrawData: The PerDDrawData type, passed in as the template parameter,
//     TPDDD.
// TDriver: This is equal to TPerDDrawData::TDriver. This type is exposed
//     only as a convience to the implementation to get at TDriver::TSurface.
// TSurface: This is equal to TDriver::TSurface. This type is exposed only
//     as a convience to the implementation.
//
// <Exposed Functions>
// CSubContext( TPerDDrawData&, TSurface*, TSurface*, DWORD): Constructor,
//     a typical SDDI Context isnt' expected to be created without this data.
// ~CSubContext(): Standard destructor.
// TPerDDrawData& GetPerDDrawData() const: Trivial accessor function to get at
//     the PerDDrawData.
// TSurface* GetRTarget() const: Trivial accessor function to get at the
//     current render target.
// TSurface* GetZBuffer() const: Trivial accessor function to get at the
//     current z/ stencil buffer.
// HRESULT DP2SetRenderTarget( TDP2Data&, const D3DHAL_DP2COMMAND*, const void*):
//     The default DP2 command processing member function for
//     D3DDP2OP_SETRENDERTARGET.
// void NewRenderTarget( TSurface*, TSurface*) const: Notification mechanism
//     called just before new render targets are saved into the member
//     variables. This notification mechanism is called by DP2SetRenderTarget.
// HRESULT DP2Clear( TDP2Data&, const D3DHAL_DP2COMMAND*, const void*):
//     The default DP2 command processing member function for D3DDP2OP_CLEAR.
//     This function relies on TSurface having a member function Clear.
// HRESULT GetDriverState( DDHAL_GETDRIVERSTATEDATA&): A minimal implementation
//     of GetDriverState, which should return S_FALSE if the id isn't
//     understood. This function should be overriden to add understanding for
//     custom ids.
//
////////////////////////////////////////////////////////////////////////////////
template< class TSuper, class TPDDD,
    class TRT= CRTarget< TPDDD::TDriver::TSurface*, TPDDD::TSurfDBEntry*>,
    class TDP2Data= CDP2DataWrap<> >
class CSubContext
{
public: // Types
    typedef TPDDD TPerDDrawData;
    typedef TRT TRTarget;

protected: // Variables
    TPerDDrawData& m_PerDDrawData;
    TRTarget m_ColorBuffer;
    TRTarget m_DepthBuffer;

protected: // Functions
    void NewColorBuffer() const 
    {
        // Override this notification mechanism to provide color buffer
        // state managing.
    }
    void NewDepthBuffer() const
    {
        // Override this notification mechanism to provide depth buffer
        // state managing.
    }

    CSubContext( TPerDDrawData& PerDDrawData, PORTABLE_CONTEXTCREATEDATA& ccd):
        m_PerDDrawData( PerDDrawData)
    {
        // To set the render targets, we must convert the structures to our
        // SurfDBEntry representation.
        typename TPerDDrawData::TDriver& Driver= PerDDrawData.GetDriver();

        if( ccd.lpDDSLcl()!= NULL)
        {
            typename TPerDDrawData::TDriver::TSurface* pSurface=
                Driver.GetSurface( *ccd.lpDDSLcl());
            if( pSurface!= NULL)
            {
                const DWORD dwHandle(
                    ccd.lpDDSLcl()->lpSurfMore()->dwSurfaceHandle());

                m_ColorBuffer= TRTarget( dwHandle, pSurface,
                    PerDDrawData.GetSurfDBEntry( dwHandle));
            }
        }
        if( ccd.lpDDSZLcl()!= NULL)
        {
            typename TPerDDrawData::TDriver::TSurface* pSurface=
                Driver.GetSurface( *ccd.lpDDSZLcl());
            if( pSurface!= NULL)
            {
                const DWORD dwHandle(
                    ccd.lpDDSZLcl()->lpSurfMore()->dwSurfaceHandle());

                m_DepthBuffer= TRTarget( dwHandle, pSurface,
                    PerDDrawData.GetSurfDBEntry( dwHandle));
            }
        }
    }
    ~CSubContext() 
    { }

public: // Functions
    TPerDDrawData& GetPerDDrawData() const  { return m_PerDDrawData; }
    const TRTarget& GetColorBuffer() const { return m_ColorBuffer; }
    TRTarget& GetColorBuffer() { return m_ColorBuffer; }
    const TRTarget& GetDepthBuffer() const { return m_DepthBuffer; }
    TRTarget& GetDepthBuffer() { return m_DepthBuffer; }

    HRESULT DP2SetRenderTarget( TDP2Data& DP2Data, const D3DHAL_DP2COMMAND*
        pCmd, const void* pP) 
    {
        const D3DHAL_DP2SETRENDERTARGET* pParam=
            reinterpret_cast< const D3DHAL_DP2SETRENDERTARGET*>( pP);
        TSuper* pSThis= static_cast< TSuper*>( this);
        WORD wStateCount( pCmd->wStateCount);

        if( wStateCount!= 0)
        {
            TPerDDrawData& PerDDrawData= GetPerDDrawData();
            typename TPerDDrawData::TDriver& Driver= PerDDrawData.GetDriver();

            do
            {
                // To set the render targets, we must convert the handles to our
                // SurfDBEntry representation.
                typename TPerDDrawData::TSurfDBEntry* pSurfDBEntry=
                    PerDDrawData.GetSurfDBEntry( pParam->hRenderTarget);
                if( pSurfDBEntry!= NULL)
                {
                    // We can immediately convert the SurfDBEntry representation to our
                    // Video Memory object, because Render Targets MUST be VM.
                    typename TPerDDrawData::TDriver::TSurface* pSurface=
                        Driver.GetSurface( *pSurfDBEntry);
                    if( pSurface!= NULL)
                    {
                        m_ColorBuffer= TRTarget( pParam->hRenderTarget,
                            pSurface, pSurfDBEntry);
                        pSThis->NewColorBuffer();
                    }
                }

                pSurfDBEntry= PerDDrawData.GetSurfDBEntry( pParam->hZBuffer);
                if( pSurfDBEntry!= NULL)
                {
                    // We can immediately convert the SurfDBEntry representation to our
                    // Video Memory object, because Render Targets MUST be VM.
                    typename TPerDDrawData::TDriver::TSurface* pSurface=
                        Driver.GetSurface( *pSurfDBEntry);
                    if( pSurface!= NULL)
                    {
                        m_DepthBuffer= TRTarget( pParam->hZBuffer,
                            pSurface, pSurfDBEntry);
                        pSThis->NewDepthBuffer();
                    }
                }
            } while( --wStateCount!= 0);
        }
        return DD_OK;
    }
    HRESULT DP2Clear( TDP2Data& DP2Data, const D3DHAL_DP2COMMAND* pCmd,
        const void* pP) 
    {
        const D3DHAL_DP2CLEAR* pParam= reinterpret_cast< const D3DHAL_DP2CLEAR*>
            ( pP);

        TSuper* pSThis= static_cast< TSuper*>( this);
        const D3DHAL_DP2VIEWPORTINFO CurViewport( *pSThis);
        RECT ViewportRect;
        ViewportRect.left= CurViewport.dwX;
        ViewportRect.top= CurViewport.dwY;
        ViewportRect.right= CurViewport.dwX+ CurViewport.dwWidth;
        ViewportRect.bottom= CurViewport.dwY+ CurViewport.dwHeight;

        TRTarget& ColorBuffer= GetColorBuffer();
        TRTarget& DepthBuffer= GetDepthBuffer();
        const bool bClearBoth(!(ColorBuffer== DepthBuffer));

        if( 0== pCmd->wStateCount)
        {
            if( TRTarget::EMemLocation::None!= ColorBuffer.GetMemLocation())
                ColorBuffer.Clear( *pParam, ViewportRect);
            if( TRTarget::EMemLocation::None!= DepthBuffer.GetMemLocation()&&
                bClearBoth)
                DepthBuffer.Clear( *pParam, ViewportRect);
        }
        else
        {
            WORD wStateCount( pCmd->wStateCount);
            const RECT* pRect= pParam->Rects;

            if((pParam->dwFlags& D3DCLEAR_COMPUTERECTS)!= 0)
            {
                // Clip rect to viewport.
                RECT rcClipped( *pRect);
                do
                {
                    clamp_min( rcClipped.left, ViewportRect.left);
                    clamp_min( rcClipped.top, ViewportRect.top);
                    clamp( rcClipped.right, rcClipped.left, ViewportRect.right);
                    clamp( rcClipped.bottom, rcClipped.top, ViewportRect.bottom);

                    if( TRTarget::EMemLocation::None!=
                        ColorBuffer.GetMemLocation())
                        ColorBuffer.Clear( *pParam, rcClipped);
                    if( TRTarget::EMemLocation::None!=
                        DepthBuffer.GetMemLocation()&& bClearBoth)
                        DepthBuffer.Clear( *pParam, rcClipped);
                    pRect++;
                } while( --wStateCount);
            }
            else
            {
                do
                {
                    if( TRTarget::EMemLocation::None!=
                        ColorBuffer.GetMemLocation())
                        ColorBuffer.Clear( *pParam, *pRect);
                    if( TRTarget::EMemLocation::None!=
                        DepthBuffer.GetMemLocation()&& bClearBoth)
                        DepthBuffer.Clear( *pParam, *pRect);
                    pRect++;
                }  while( --wStateCount);
            }
        }
        return DD_OK;
    }

    // A minimal implementation of GetDriverState, which should return S_FALSE
    // if the id isn't understood. Override this function to add understanding.
    HRESULT GetDriverState( DDHAL_GETDRIVERSTATEDATA& gdsd)
    { return S_FALSE; }
};

////////////////////////////////////////////////////////////////////////////////
//
// CMinimalContext
//
// This class contains a minimal implementation of a Context for a driver,
// which supports only one stream, no TnL, and legacy pixel shading. This
// Context still needs an implementation of the primitive drawing functions,
// which it uses a Rasterizer class for. CMinimalContext takes care of most
// of the responsibilities of a SDDI driver, except rasterization. 
//
// <Template Parameters>
// TPDDD: The PerDDrawData type, typically CMyPerDDrawData or
//     CMinimalPerDDrawData<>.
// TR: The Rasterizer type, typically CMyRasterizer.
//
////////////////////////////////////////////////////////////////////////////////
template< class TPDDD, class TR>
class CMinimalContext:
    public CSubContext< CMinimalContext< TPDDD, TR>, TPDDD>,
    public CStdDrawPrimitives2< CMinimalContext< TPDDD, TR> >,
    public CStdDP2ViewportInfoStore< CMinimalContext< TPDDD, TR> >,
    public CStdDP2WInfoStore< CMinimalContext< TPDDD, TR> >,
    public CStdDP2RenderStateStore< CMinimalContext< TPDDD, TR> >,
    public CStdDP2TextureStageStateStore< CMinimalContext< TPDDD, TR> >,
    public CStdDP2SetVertexShaderStore< CMinimalContext< TPDDD, TR> >,
    public CStdDP2VStreamManager< CMinimalContext< TPDDD, TR> >,
    public CStdDP2IStreamManager< CMinimalContext< TPDDD, TR> >
{
public: // Types
    typedef TPDDD TPerDDrawData;
    typedef TR TRasterizer;
    typedef block< TDP2CmdBind, 15> TDP2Bindings;
    typedef block< TRecDP2CmdBind, 7> TRecDP2Bindings;

protected: // Variables
    TRasterizer m_Rasterizer;
    static const TDP2Bindings c_DP2Bindings;
    static const TRecDP2Bindings c_RecDP2Bindings;

public: // Functions
    CMinimalContext( TPerDDrawData& PDDD, PORTABLE_CONTEXTCREATEDATA& ccd)
        : CSubContext< CMinimalContext< TPDDD, TR>, TPDDD>( PDDD, ccd),
        CStdDrawPrimitives2< CMinimalContext< TPDDD, TR>>(
            c_DP2Bindings.begin(), c_DP2Bindings.end(),
            c_RecDP2Bindings.begin(), c_RecDP2Bindings.end())
    {
        // These keep the arrays in sync with their typedef.
        assert( D3DDP2OP_CLIPPEDTRIANGLEFAN== *c_DP2Bindings.rbegin());
        assert( D3DDP2OP_SETINDICES== *c_RecDP2Bindings.rbegin());
    }
    ~CMinimalContext()  { }

    // Provide this function to ease minimal implementations.
    HRESULT ValidateTextureStageState( const D3DHAL_VALIDATETEXTURESTAGESTATEDATA&
        vsssd) const
    { return DD_OK; }

    HRESULT DP2DrawPrimitive( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP)
    {
        const D3DHAL_DP2DRAWPRIMITIVE* pParam= reinterpret_cast<
            const D3DHAL_DP2DRAWPRIMITIVE*>(pP);
        return m_Rasterizer.DrawPrimitive( *this, *pCmd, pParam);
    }
    HRESULT DP2DrawPrimitive2( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP)
    {
        const D3DHAL_DP2DRAWPRIMITIVE2* pParam= reinterpret_cast<
            const D3DHAL_DP2DRAWPRIMITIVE2*>(pP);
        return m_Rasterizer.DrawPrimitive2( *this, *pCmd, pParam);
    }
    HRESULT DP2DrawIndexedPrimitive( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP)
    {
        const D3DHAL_DP2DRAWINDEXEDPRIMITIVE* pParam= reinterpret_cast<
            const D3DHAL_DP2DRAWINDEXEDPRIMITIVE*>(pP);
        return m_Rasterizer.DrawIndexedPrimitive( *this, *pCmd, pParam);
    }
    HRESULT DP2DrawIndexedPrimitive2( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP)
    {
        const D3DHAL_DP2DRAWINDEXEDPRIMITIVE2* pParam= reinterpret_cast<
            const D3DHAL_DP2DRAWINDEXEDPRIMITIVE2*>(pP);
        return m_Rasterizer.DrawIndexedPrimitive2( *this, *pCmd, pParam);
    }
    HRESULT DP2ClippedTriangleFan( TDP2Data& DP2Data,
        const D3DHAL_DP2COMMAND* pCmd, const void* pP)
    {
        const D3DHAL_CLIPPEDTRIANGLEFAN* pParam= reinterpret_cast<
            const D3DHAL_CLIPPEDTRIANGLEFAN*>(pP);
        return m_Rasterizer.ClippedTriangleFan( *this, *pCmd, pParam);
    }
};

// These tables require TConstDP2Bindings to be changed also, with the number
// of bindings.
template< class TPDDD, class TR>
const CMinimalContext< TPDDD, TR>::TDP2Bindings
    CMinimalContext< TPDDD, TR>::c_DP2Bindings=
{
    D3DDP2OP_VIEWPORTINFO,          DP2ViewportInfo,
    D3DDP2OP_WINFO,                 DP2WInfo,
    D3DDP2OP_RENDERSTATE,           DP2RenderState,
    D3DDP2OP_TEXTURESTAGESTATE,     DP2TextureStageState,
    D3DDP2OP_CLEAR,                 DP2Clear,
    D3DDP2OP_SETRENDERTARGET,       DP2SetRenderTarget,
    D3DDP2OP_SETVERTEXSHADER,       DP2SetVertexShader,
    D3DDP2OP_SETSTREAMSOURCE,       DP2SetStreamSource,
    D3DDP2OP_SETSTREAMSOURCEUM,     DP2SetStreamSourceUM,
    D3DDP2OP_SETINDICES,            DP2SetIndices,
    D3DDP2OP_DRAWPRIMITIVE,         DP2DrawPrimitive,
    D3DDP2OP_DRAWPRIMITIVE2,        DP2DrawPrimitive2,
    D3DDP2OP_DRAWINDEXEDPRIMITIVE,  DP2DrawIndexedPrimitive,
    D3DDP2OP_DRAWINDEXEDPRIMITIVE2, DP2DrawIndexedPrimitive2,
    D3DDP2OP_CLIPPEDTRIANGLEFAN,    DP2ClippedTriangleFan
};

// These tables require TConstRecDP2Bindings to be changed also, with the number
// of bindings.
template< class TPDDD, class TR>
const CMinimalContext< TPDDD, TR>::TRecDP2Bindings
    CMinimalContext< TPDDD, TR>::c_RecDP2Bindings=
{
    D3DDP2OP_VIEWPORTINFO,          RecDP2ViewportInfo,
    D3DDP2OP_WINFO,                 RecDP2WInfo,
    D3DDP2OP_RENDERSTATE,           RecDP2RenderState,
    D3DDP2OP_TEXTURESTAGESTATE,     RecDP2TextureStageState,
    D3DDP2OP_SETVERTEXSHADER,       RecDP2SetVertexShader,
    D3DDP2OP_SETSTREAMSOURCE,       RecDP2SetStreamSource,
    D3DDP2OP_SETINDICES,            RecDP2SetIndices
};

class IVidMemSurface
{
protected: // Variables
    DWORD m_dwHandle;

protected: // Functions
    IVidMemSurface( DWORD dwHandle) : m_dwHandle( dwHandle) { }

public: // Functions
    DWORD GetHandle() const 
    { return m_dwHandle; }
    virtual ~IVidMemSurface() 
    { }
    virtual void* Lock( DWORD dwFlags, const RECTL* pRect)= 0;
    virtual void Unlock( void)= 0;
    virtual void Clear( const D3DHAL_DP2CLEAR& DP2Clear, const RECT& RC)= 0;
};

struct SD3DDataConv
{
    // A( 0), R( 1), G( 2), B( 3), Z( 4), S( 5)
    typedef block< DWORD, 6> TMasks;
    // A( 0), R( 1), G( 2), B( 3), Z( 4), ZBits( 5), S( 6), SBits( 7)
    typedef block< signed char, 8> TD3DBitShftRgt;
    TMasks m_ToSurfMasks;
    TD3DBitShftRgt m_D3DBitShftRgt;

    SD3DDataConv()
    {
        fill( m_ToSurfMasks.begin(), m_ToSurfMasks.end(),
            static_cast< TMasks::value_type>( 0));
        fill( m_D3DBitShftRgt.begin(), m_D3DBitShftRgt.end(),
            static_cast< TD3DBitShftRgt::value_type>( 0));
    }
    SD3DDataConv( const DDPIXELFORMAT& PF) 
    { (*this)= PF; }
    SD3DDataConv& operator=( const DDPIXELFORMAT& PF) 
    {
        const block< signed char, 4> D3DHighBitPos= {31,23,15,7};

        fill( m_ToSurfMasks.begin(), m_ToSurfMasks.end(),
            static_cast< TMasks::value_type>( 0));
        fill( m_D3DBitShftRgt.begin(), m_D3DBitShftRgt.end(),
            static_cast< TD3DBitShftRgt::value_type>( 0));

        // Alpha
        if((PF.dwFlags& DDPF_ALPHA)!= 0)
        {
            assert( PF.dwAlphaBitDepth< 32);
            m_ToSurfMasks[ 0]= (0x1<< PF.dwAlphaBitDepth)- 1;
        }
        else if((PF.dwFlags& DDPF_ALPHAPIXELS)!= 0)
            m_ToSurfMasks[ 0]= PF.dwRGBAlphaBitMask;

        // RGB Color
        if((PF.dwFlags& DDPF_RGB)!= 0)
        {
            m_ToSurfMasks[ 1]= PF.dwRBitMask;
            m_ToSurfMasks[ 2]= PF.dwGBitMask;
            m_ToSurfMasks[ 3]= PF.dwBBitMask;
        }

        // Z
        if((PF.dwFlags& DDPF_ZBUFFER)!= 0)
        {
            m_D3DBitShftRgt[ 5]= PF.dwZBufferBitDepth;
            if( 32== PF.dwZBufferBitDepth)
                m_ToSurfMasks[ 4]= 0xFFFFFFFF;
            else
                m_ToSurfMasks[ 4]= (0x1<< PF.dwZBufferBitDepth)- 1;
        }
        else if((PF.dwFlags& DDPF_ZPIXELS)!= 0)
        {
            DWORD dwZBitMask( PF.dwRGBZBitMask);
            m_ToSurfMasks[ 5]= PF.dwRGBZBitMask;

            while((dwZBitMask& 1)== 0)
            {
                m_D3DBitShftRgt[ 4]--;
                dwZBitMask>>= 1;
            }

            while((dwZBitMask& 1)!= 0)
            {
                dwZBitMask>>= 1;
                m_D3DBitShftRgt[ 5]++;
            }
        }

        // Stensil
        if((PF.dwFlags& DDPF_STENCILBUFFER)!= 0)
        {
            DWORD dwSBitMask( PF.dwStencilBitMask);
            m_ToSurfMasks[ 6]= PF.dwStencilBitMask;

            while((dwSBitMask& 1)== 0)
            {
                m_D3DBitShftRgt[ 6]--;
                dwSBitMask>>= 1;
            }

            while((dwSBitMask& 1)!= 0)
            {
                dwSBitMask>>= 1;
                m_D3DBitShftRgt[ 7]++;
            }
        }

        block< signed char, 4>::const_iterator itD3DBitPos( D3DHighBitPos.begin());
        TD3DBitShftRgt::iterator itBitShftRgt( m_D3DBitShftRgt.begin());
        TMasks::const_iterator itToSurfMask( m_ToSurfMasks.begin());

        while( itD3DBitPos!= D3DHighBitPos.end())
        {
            signed char iBitPos( 31);
            TMasks::value_type dwMask( 0x80000000);

            while((dwMask& *itToSurfMask)== 0 && iBitPos>= 0)
            {
                dwMask>>= 1;
                iBitPos--;
            }

            *itBitShftRgt= ( iBitPos>= 0? *itD3DBitPos- iBitPos: 0);

            ++itD3DBitPos;
            ++itToSurfMask;
            ++itBitShftRgt;
        }
        return *this;
    }
    // SurfData, ValidMask
    pair< UINT32, UINT32> ConvColor( D3DCOLOR D3DColor) const 
    {
        pair< UINT32, UINT32> RetVal( 0, 0);

        const block< DWORD, 4> FromD3DMasks= {0xFF000000,0xFF0000,0xFF00,0xFF};

        TD3DBitShftRgt::const_iterator itBitShftRgt( m_D3DBitShftRgt.begin());
        block< DWORD, 4>::const_iterator itFromMask( FromD3DMasks.begin());
        TMasks::const_iterator itToMask( m_ToSurfMasks.begin());
        while( itFromMask!= FromD3DMasks.end())
        {
            const UINT32 uiTmp( D3DColor& *itFromMask);
            
            RetVal.first|= *itToMask& (*itBitShftRgt>= 0?
                uiTmp>> *itBitShftRgt: uiTmp<< *itBitShftRgt);
            RetVal.second|= *itToMask;

            ++itBitShftRgt;
            ++itToMask;
            ++itFromMask;
        }
        return RetVal;
    }
    // SurfData, ValidMask
    pair< UINT32, UINT32> ConvZ( D3DVALUE D3DZ) const 
    {
        CEnsureFPUModeForC FPUMode;

        if( D3DZ> 1.0f)
            D3DZ= 1.0f;
        else if( D3DZ< 0.0f)
            D3DZ= 0.0f;

        pair< UINT32, UINT32> RetVal( 0, 0);

        const UINT32 uiMaxZ( m_D3DBitShftRgt[ 5]== 32? 0xFFFFFFFF:
            (0x1<< m_D3DBitShftRgt[ 5])- 1);

        const UINT32 uiZVal( static_cast<UINT32>( 
            static_cast< DOUBLE>(D3DZ)* static_cast< DOUBLE>(uiMaxZ)+ 0.5));

        RetVal.first|= m_ToSurfMasks[ 4]& (m_D3DBitShftRgt[ 4]>= 0?
            uiZVal>> m_D3DBitShftRgt[ 4]: uiZVal<< m_D3DBitShftRgt[ 4]);
        RetVal.second|= m_ToSurfMasks[ 4];
        return RetVal;
    }
    // SurfData, ValidMask
    pair< UINT32, UINT32> ConvS( DWORD D3DStensil) const 
    {
        pair< UINT32, UINT32> RetVal( 0, 0);

        RetVal.first|= m_ToSurfMasks[ 5]& (m_D3DBitShftRgt[ 6]>= 0?
            D3DStensil>> m_D3DBitShftRgt[ 6]: D3DStensil<< m_D3DBitShftRgt[ 6]);
        RetVal.second|= m_ToSurfMasks[ 5];
        return RetVal;
    }
};

class CGenSurface:
    public IVidMemSurface
{
public: // Types
    typedef unsigned int TLocks;

protected: // Variables
    SD3DDataConv m_D3DDataConv;
    DWORD m_dwCaps;
    TLocks m_uiLocks;

    // Regular data
    void* m_pData;
    LONG m_lPitch;
    size_t m_uiBytes;
    WORD m_wWidth;
    WORD m_wHeight;

    unsigned char m_ucBPP;

public: // Functions
    CGenSurface( const DDSURFACEDESC& SDesc, PORTABLE_DDRAWSURFACE_LCL& DDSurf)
        :IVidMemSurface( DDSurf.lpSurfMore()->dwSurfaceHandle()),
        m_dwCaps( SDesc.ddsCaps.dwCaps), m_uiLocks( 0), m_pData( NULL),
        m_lPitch( 0), m_uiBytes( 0), m_wWidth( DDSurf.lpGbl()->wWidth),
        m_wHeight( DDSurf.lpGbl()->wHeight), m_ucBPP( 0)
    {
        size_t uiBytesPerPixel( 0);

        // Certain data needs to be written into the DDSurf description,
        // so that the DXG runtime and the app will know characteristics
        // about the surface. (fpVidMem, lPitch, etc.)

        // DO NOT STORE &DDSurf! This is considered illegal. The typical
        // implementation contains a surfaceDB which contains copies of the
        // DDRAWI_ structures.

        if((SDesc.dwFlags& DDSD_PIXELFORMAT)!= 0)
        {
            // CGenSurface can only be used for byte-aligned pixels.
            assert( 8== SDesc.ddpfPixelFormat.dwRGBBitCount ||
                16== SDesc.ddpfPixelFormat.dwRGBBitCount ||
                24== SDesc.ddpfPixelFormat.dwRGBBitCount ||
                32== SDesc.ddpfPixelFormat.dwRGBBitCount);

            m_D3DDataConv= SDesc.ddpfPixelFormat;
            m_ucBPP= static_cast<unsigned char>(
                SDesc.ddpfPixelFormat.dwRGBBitCount>> 3);

            // Align the Pitch/ Width.
            DDSurf.lpGbl()->lPitch= m_lPitch= ((m_ucBPP* m_wWidth+ 7)& ~7);
            m_uiBytes= m_lPitch* m_wHeight;
        }
        else if((m_dwCaps& DDSCAPS_EXECUTEBUFFER)!= 0)
        {
            // Execute buffers are considered linear and byte-sized.
            m_lPitch= DDSurf.lpGbl()->lPitch;
            m_uiBytes= m_lPitch* m_wHeight;
        }
        else
        {
            const bool Unsupported_Surface_In_Allocation_Routine2( false);
            assert( Unsupported_Surface_In_Allocation_Routine2);
        }

        // It would've been nice to have the initial proctection NOACCESS, but
        // it seems the HAL needs to read to the region, initially.
        m_pData= VirtualAlloc( NULL, m_uiBytes, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
        if( m_pData== NULL)
            throw bad_alloc( "Not enough memory to allocate Surface data");
        DDSurf.lpGbl()->fpVidMem= reinterpret_cast<FLATPTR>(m_pData);
    }
    virtual ~CGenSurface() 
    {
        // Warning: m_uiLocks doesn't have to be 0. The run-time will destroy
        // a surface without un-locking it.
        assert( m_pData!= NULL);
        VirtualFree( m_pData, 0, MEM_DECOMMIT| MEM_RELEASE);
    }
    virtual void* Lock( DWORD dwFlags, const RECTL* pRect) 
    {
        // Typically, m_uiLocks!= 0 equals bad design or bug. But, it is valid.
        // Second Dummy removes vc6 unrefd variable warning.
        numeric_limits< TLocks> Dummy; Dummy;
        assert( Dummy.max()!= m_uiLocks);
        ++m_uiLocks;

        if( pRect!= NULL)
        {
            // If it is either a 1) VB, 2) IB or 3) CB then the rect has a
            // special meaning. rect.top - rect.bottom gives the range of
            // memory desired, because of being linear.
            if((m_dwCaps& DDSCAPS_EXECUTEBUFFER)!= 0)
            {
                return static_cast<void*>( reinterpret_cast<UINT8*>(
                    m_pData)+ pRect->top);
            }
            else
            {
                return static_cast<void*>( reinterpret_cast<UINT8*>(
                    m_pData)+ pRect->top* m_lPitch+ pRect->left* m_ucBPP);
            }
        }
        else
            return m_pData;
    }
    virtual void Unlock( void) 
    {
        assert( 0!= m_uiLocks);
        --m_uiLocks;
    }
    virtual void Clear( const D3DHAL_DP2CLEAR& DP2Clear, const RECT& RC) 
    {
        // A VB, IB, or CB should never be asked to 'Clear'. Only
        // RenderTargets and ZBuffers, etc.
        assert((m_dwCaps& DDSCAPS_EXECUTEBUFFER)== 0);

        // Check for empty RECT.
        if((RC.left>= RC.right) || (RC.top>= RC.bottom))
            return;

        assert( 1<= m_ucBPP && 4>= m_ucBPP);
        UINT32 ui32BitFill( 0), ui32BitValidMask( 0);
        UINT32 ui32BitSMask( 4== m_ucBPP? 0xFFFFFFFF: (1<< (m_ucBPP* 8))- 1);

        pair< UINT32, UINT32> RetVal;
        if((DP2Clear.dwFlags& D3DCLEAR_TARGET)!= 0)
        {
            RetVal= m_D3DDataConv.ConvColor( DP2Clear.dwFillColor);
            ui32BitFill|= RetVal.first;
            ui32BitValidMask|= RetVal.second;
        }
        if((DP2Clear.dwFlags& D3DCLEAR_ZBUFFER)!= 0)
        {
            RetVal= m_D3DDataConv.ConvZ( DP2Clear.dvFillDepth);
            ui32BitFill|= RetVal.first;
            ui32BitValidMask|= RetVal.second;
        }
        if((DP2Clear.dwFlags& D3DCLEAR_STENCIL)!= 0)
        {
            RetVal= m_D3DDataConv.ConvS( DP2Clear.dwFillStencil);
            ui32BitFill|= RetVal.first;
            ui32BitValidMask|= RetVal.second;
        }

        RECTL RectL;
        RectL.top= RC.top;
        RectL.left= RC.left;
        RectL.bottom= RC.bottom;
        RectL.right= RC.right;
        unsigned int iRow( RC.bottom- RC.top);
        const unsigned int iCols( RC.right- RC.left);

        // New scope for SurfaceLocker.
        { 
            CSurfaceLocker< CGenSurface*> MySLocker( this, 0, &RectL);
            UINT8* pSData= reinterpret_cast<UINT8*>( MySLocker.GetData());

            if( 3== m_ucBPP)
            {
                UINT32 ui32FillData[3];
                ui32FillData[0]= ((ui32BitFill& 0xFFFFFF)<< 8)|
                    ((ui32BitFill& 0xFF0000)>> 16);
                ui32FillData[1]= ((ui32BitFill& 0x00FFFF)<< 16)|
                    ((ui32BitFill& 0xFFFF00)>> 8);
                ui32FillData[2]= ((ui32BitFill& 0x0000FF)<< 24)|
                    ((ui32BitFill& 0xFFFFFF)>> 0);

                // Little-endian implementation.
                UINT8 ui8FillData[3];
                ui8FillData[0]= (0xFF& ui32BitFill);
                ui8FillData[1]= (0xFF00& ui32BitFill)>> 8;
                ui8FillData[2]= (0xFF0000& ui32BitFill)>> 16;

                if( ui32BitSMask== ui32BitValidMask)
                {
                    // Only fill, no need to read, modify, write.
                    do
                    {
                        UINT32* p32Data= reinterpret_cast<UINT32*>(pSData);

                        // We've packed 4 pixels of data in 3 UINT32.
                        unsigned int iCol( iCols>> 2); // (>> 2) == (/ 4)

                        // Unroll.
                        if( iCol!= 0) do
                        {
                            p32Data[ 0]= ui32FillData[0];
                            p32Data[ 1]= ui32FillData[1];
                            p32Data[ 2]= ui32FillData[2];
                            p32Data[ 3]= ui32FillData[0];
                            p32Data[ 4]= ui32FillData[1];
                            p32Data[ 5]= ui32FillData[2];
                            p32Data[ 6]= ui32FillData[0];
                            p32Data[ 7]= ui32FillData[1];
                            p32Data[ 8]= ui32FillData[2];
                            p32Data[ 9]= ui32FillData[0];
                            p32Data[10]= ui32FillData[1];
                            p32Data[11]= ui32FillData[2];
                            p32Data+= 12;
                        } while( --iCol);

                        iCol= iCols& 0x3; // (% 4) == (& 0x3)
                        if( iCol!= 0) {
                            UINT8* p8Data= reinterpret_cast<UINT8*>(p32Data);
                            do
                            {
                                p8Data[0]= ui8FillData[0];
                                p8Data[1]= ui8FillData[1];
                                p8Data[2]= ui8FillData[2];
                                p8Data+= 3;
                            } while( --iCol);
                        }

                        pSData+= m_lPitch;
                    } while( --iRow);
                }
                else
                {
                    const UINT32 ui32BitMask= ~ui32BitValidMask;
                    UINT32 ui32MaskData[3];
                    ui32MaskData[0]= ((ui32BitMask& 0xFFFFFF)<< 8)|
                        ((ui32BitMask& 0xFF0000)>> 16);
                    ui32MaskData[1]= ((ui32BitMask& 0x00FFFF)<< 16)|
                        ((ui32BitMask& 0xFFFF00)>> 8);
                    ui32MaskData[2]= ((ui32BitMask& 0x0000FF)<< 24)|
                        ((ui32BitMask& 0xFFFFFF)>> 0);

                    UINT8 ui8MaskData[3];
                    ui8MaskData[0]= (0xFF& ui32BitMask);
                    ui8MaskData[1]= (0xFF00& ui32BitMask)>> 8;
                    ui8MaskData[2]= (0xFF0000& ui32BitMask)>> 16;

                    // Need to mask in the data.
                    do
                    {
                        UINT32* p32Data= reinterpret_cast<UINT32*>(pSData);

                        // We've packed 4 pixels of data in 3 UINT32.
                        int iCol( iCols>> 2); // (>> 2) == (/ 4)

                        // Unroll.
                        if( iCol!= 0) do
                        {
                            p32Data[ 0]= (p32Data[ 0]& ui32MaskData[0])| ui32FillData[0];
                            p32Data[ 1]= (p32Data[ 1]& ui32MaskData[1])| ui32FillData[1];
                            p32Data[ 2]= (p32Data[ 2]& ui32MaskData[2])| ui32FillData[2];
                            p32Data[ 3]= (p32Data[ 3]& ui32MaskData[0])| ui32FillData[0];
                            p32Data[ 4]= (p32Data[ 4]& ui32MaskData[1])| ui32FillData[1];
                            p32Data[ 5]= (p32Data[ 5]& ui32MaskData[2])| ui32FillData[2];
                            p32Data[ 6]= (p32Data[ 6]& ui32MaskData[0])| ui32FillData[0];
                            p32Data[ 7]= (p32Data[ 7]& ui32MaskData[1])| ui32FillData[1];
                            p32Data[ 8]= (p32Data[ 8]& ui32MaskData[2])| ui32FillData[2];
                            p32Data[ 9]= (p32Data[ 9]& ui32MaskData[0])| ui32FillData[0];
                            p32Data[10]= (p32Data[10]& ui32MaskData[1])| ui32FillData[1];
                            p32Data[11]= (p32Data[11]& ui32MaskData[2])| ui32FillData[2];
                            p32Data+= 12;
                        } while( --iCol);

                        iCol= iCols& 0x3; // (% 4) == (& 0x3)
                        if( iCol!= 0) {
                            UINT8* p8Data= reinterpret_cast<UINT8*>(p32Data);
                            do
                            {
                                p8Data[0]= (p8Data[0]& ui8MaskData[0])| ui8FillData[0];
                                p8Data[1]= (p8Data[1]& ui8MaskData[1])| ui8FillData[1];
                                p8Data[2]= (p8Data[2]& ui8MaskData[2])| ui8FillData[2];
                                p8Data+= 3;
                            } while( --iCol);
                        }

                        pSData+= m_lPitch;
                    } while( --iRow);
                }
            }
            else
            {
                unsigned int uiPakedPixels;
                unsigned int uiPixelsLeft;
                UINT32 ui32FillData;
                UINT32 ui32MaskData;
                if( 1== m_ucBPP)
                {
                    uiPakedPixels= iCols>> 6;
                    uiPixelsLeft= iCols& 0x3F;
                    ui32FillData= (ui32BitFill& 0xFF)|
                        ((ui32BitFill& 0xFF)<< 8)|
                        ((ui32BitFill& 0xFF)<< 16)|
                        ((ui32BitFill& 0xFF)<< 24);
                    ui32MaskData= (~ui32BitValidMask& 0xFF)|
                        ((~ui32BitValidMask& 0xFF)<< 8)|
                        ((~ui32BitValidMask& 0xFF)<< 16)|
                        ((~ui32BitValidMask& 0xFF)<< 24);
                }
                else if( 2== m_ucBPP)
                {
                    uiPakedPixels= iCols>> 5;
                    uiPixelsLeft= iCols& 0x1F;
                    ui32FillData= (ui32BitFill& 0xFFFF)|
                        ((ui32BitFill& 0xFFFF)<< 16);
                    ui32MaskData= (~ui32BitValidMask& 0xFFFF)|
                        ((~ui32BitValidMask& 0xFFFF)<< 16);
                }
                else if( 4== m_ucBPP)
                {
                    uiPakedPixels= iCols>> 4;
                    uiPixelsLeft= iCols& 0xF;
                    ui32FillData= ui32BitFill;
                    ui32MaskData= ~ui32BitValidMask;
                }

                if( ui32BitSMask== ui32BitValidMask)
                {
                    // Only fill, no need to read, modify, write.
                    do
                    {
                        UINT32* p32Data= reinterpret_cast<UINT32*>(pSData);

                        // We've packed pixels of data in a UINT32.
                        unsigned int iCol( uiPakedPixels);

                        // Unroll.
                        if( iCol!= 0) do
                        {
                            p32Data[ 0]= ui32FillData;
                            p32Data[ 1]= ui32FillData;
                            p32Data[ 2]= ui32FillData;
                            p32Data[ 3]= ui32FillData;
                            p32Data[ 4]= ui32FillData;
                            p32Data[ 5]= ui32FillData;
                            p32Data[ 6]= ui32FillData;
                            p32Data[ 7]= ui32FillData;
                            p32Data[ 8]= ui32FillData;
                            p32Data[ 9]= ui32FillData;
                            p32Data[10]= ui32FillData;
                            p32Data[11]= ui32FillData;
                            p32Data[12]= ui32FillData;
                            p32Data[13]= ui32FillData;
                            p32Data[14]= ui32FillData;
                            p32Data[15]= ui32FillData;
                            p32Data+= 16;
                        } while( --iCol);

                        iCol= uiPixelsLeft;
                        if( iCol!= 0) {
                            if( 1== m_ucBPP)
                            {
                                UINT8 ui8FillData= ui32FillData& 0xFF;
                                UINT8* p8Data= reinterpret_cast<UINT8*>(p32Data);
                                do
                                {
                                    p8Data[0]= ui8FillData;
                                    p8Data++;
                                } while( --iCol);
                            }
                            else if( 2== m_ucBPP)
                            {
                                UINT16 ui16FillData= ui32FillData& 0xFFFF;
                                UINT16* p16Data= reinterpret_cast<UINT16*>(p32Data);
                                do
                                {
                                    p16Data[0]= ui16FillData;
                                    p16Data++;
                                } while( --iCol);
                            }
                            else if( 4== m_ucBPP)
                            {
                                do
                                {
                                    p32Data[0]= ui32FillData;
                                    p32Data++;
                                } while( --iCol);
                            }
                        }

                        pSData+= m_lPitch;
                    } while( --iRow);
                }
                else
                {
                    // Need to mask in the data.
                    do
                    {
                        UINT32* p32Data= reinterpret_cast<UINT32*>(pSData);

                        // We've packed pixels of data in a UINT32.
                        unsigned int iCol( uiPakedPixels);

                        // Unroll.
                        if( iCol!= 0) do
                        {
                            p32Data[ 0]= (p32Data[ 0]& ui32MaskData)| ui32FillData;
                            p32Data[ 1]= (p32Data[ 1]& ui32MaskData)| ui32FillData;
                            p32Data[ 2]= (p32Data[ 2]& ui32MaskData)| ui32FillData;
                            p32Data[ 3]= (p32Data[ 3]& ui32MaskData)| ui32FillData;
                            p32Data[ 4]= (p32Data[ 4]& ui32MaskData)| ui32FillData;
                            p32Data[ 5]= (p32Data[ 5]& ui32MaskData)| ui32FillData;
                            p32Data[ 6]= (p32Data[ 6]& ui32MaskData)| ui32FillData;
                            p32Data[ 7]= (p32Data[ 7]& ui32MaskData)| ui32FillData;
                            p32Data[ 8]= (p32Data[ 8]& ui32MaskData)| ui32FillData;
                            p32Data[ 9]= (p32Data[ 9]& ui32MaskData)| ui32FillData;
                            p32Data[10]= (p32Data[10]& ui32MaskData)| ui32FillData;
                            p32Data[11]= (p32Data[11]& ui32MaskData)| ui32FillData;
                            p32Data[12]= (p32Data[12]& ui32MaskData)| ui32FillData;
                            p32Data[13]= (p32Data[13]& ui32MaskData)| ui32FillData;
                            p32Data[14]= (p32Data[14]& ui32MaskData)| ui32FillData;
                            p32Data[15]= (p32Data[15]& ui32MaskData)| ui32FillData;
                            p32Data+= 16;
                        } while( --iCol);

                        iCol= uiPixelsLeft;
                        if( iCol!= 0) {
                            if( 1== m_ucBPP)
                            {
                                UINT8 ui8FillData= ui32FillData& 0xFF;
                                UINT8 ui8MaskData= ui32MaskData& 0xFF;
                                UINT8* p8Data= reinterpret_cast<UINT8*>(p32Data);
                                do
                                {
                                    p8Data[0]= (p8Data[0]& ui8MaskData)| ui8FillData;
                                    p8Data++;
                                } while( --iCol);
                            }
                            else if( 2== m_ucBPP)
                            {
                                UINT16 ui16FillData= ui32FillData& 0xFFFF;
                                UINT16 ui16MaskData= ui32MaskData& 0xFFFF;
                                UINT16* p16Data= reinterpret_cast<UINT16*>(p32Data);
                                do
                                {
                                    p16Data[0]= (p16Data[0]& ui16MaskData)| ui16FillData;
                                    p16Data++;
                                } while( --iCol);
                            }
                            else if( 4== m_ucBPP)
                            {
                                do
                                {
                                    p32Data[0]= (p32Data[0]& ui32MaskData)| ui32FillData;
                                    p32Data++;
                                } while( --iCol);
                            }
                        }

                        pSData+= m_lPitch;
                    } while( --iRow);
                }
            }
        }
    }

    static IVidMemSurface* CreateSurf( const DDSURFACEDESC& SDesc,
        PORTABLE_DDRAWSURFACE_LCL& DDSurf)
    {
        return new CGenSurface( SDesc, DDSurf);
    }
};

struct SPixelFormat: public DDPIXELFORMAT
{
    SPixelFormat( D3DFORMAT D3DFmt) 
    {
        ZeroMemory( static_cast< DDPIXELFORMAT*>(this),
            sizeof(DDPIXELFORMAT));
        dwSize= sizeof(DDPIXELFORMAT);

        // Convert away
        if( HIWORD( static_cast< DWORD>(D3DFmt))!= 0)
        {
            dwFlags= DDPF_FOURCC;
            dwFourCC= static_cast< DWORD>(D3DFmt);
        }
        else switch( D3DFmt)
        {
        case( D3DFMT_R8G8B8):
            dwFlags           = DDPF_RGB;
            dwRBitMask        = 0x00ff0000;
            dwGBitMask        = 0x0000ff00;
            dwBBitMask        = 0x000000ff;
            dwRGBBitCount     = 24;
            break;

        case( D3DFMT_A8R8G8B8):
            dwFlags           = DDPF_RGB| DDPF_ALPHAPIXELS;
            dwRGBAlphaBitMask = 0xFF000000;
            dwRBitMask        = 0x00ff0000;
            dwGBitMask        = 0x0000ff00;
            dwBBitMask        = 0x000000ff;
            dwRGBBitCount     = 32;
            break;

        case( D3DFMT_X8R8G8B8):
            dwFlags           = DDPF_RGB;
            dwRBitMask        = 0x00ff0000;
            dwGBitMask        = 0x0000ff00;
            dwBBitMask        = 0x000000ff;
            dwRGBBitCount     = 32;
            break;

        case( D3DFMT_R5G6B5):
            dwFlags           = DDPF_RGB;
            dwRBitMask        = 0x0000f800;
            dwGBitMask        = 0x000007e0;
            dwBBitMask        = 0x0000001f;
            dwRGBBitCount     = 16;
            break;

        case( D3DFMT_X1R5G5B5):
            dwFlags           = DDPF_RGB;
            dwRBitMask        = 0x00007c00;
            dwGBitMask        = 0x000003e0;
            dwBBitMask        = 0x0000001f;
            dwRGBBitCount     = 16;
            break;

        case( D3DFMT_A1R5G5B5):
            dwFlags           = DDPF_RGB| DDPF_ALPHAPIXELS;
            dwRGBAlphaBitMask = 0x00008000;
            dwRBitMask        = 0x00007c00;
            dwGBitMask        = 0x000003e0;
            dwBBitMask        = 0x0000001f;
            dwRGBBitCount     = 16;
            break;

        case( D3DFMT_A4R4G4B4):
            dwFlags           = DDPF_RGB| DDPF_ALPHAPIXELS;
            dwRGBAlphaBitMask = 0x0000f000;
            dwRBitMask        = 0x00000f00;
            dwGBitMask        = 0x000000f0;
            dwBBitMask        = 0x0000000f;
            dwRGBBitCount     = 16;
            break;

        case( D3DFMT_X4R4G4B4):
            dwFlags           = DDPF_RGB;
            dwRBitMask        = 0x00000f00;
            dwGBitMask        = 0x000000f0;
            dwBBitMask        = 0x0000000f;
            dwRGBBitCount     = 16;
            break;

        case( D3DFMT_R3G3B2):
            dwFlags           = DDPF_RGB;
            dwRBitMask        = 0x000000e0;
            dwGBitMask        = 0x0000001c;
            dwBBitMask        = 0x00000003;
            dwRGBBitCount     = 8;
            break;

        case( D3DFMT_A8R3G3B2):
            dwFlags           = DDPF_RGB| DDPF_ALPHAPIXELS;
            dwRGBAlphaBitMask = 0x0000FF00;
            dwRBitMask        = 0x000000e0;
            dwGBitMask        = 0x0000001c;
            dwBBitMask        = 0x00000003;
            dwRGBBitCount     = 16;
            break;

        case( D3DFMT_A8P8):
            dwFlags            = DDPF_RGB| DDPF_ALPHAPIXELS| DDPF_PALETTEINDEXED8;
            dwRGBAlphaBitMask  = 0x0000FF00;
            dwRGBBitCount      = 16;
            break;

        case( D3DFMT_P8):
            dwFlags            = DDPF_RGB| DDPF_PALETTEINDEXED8;
            dwRGBBitCount      = 8;
            break;

        case( D3DFMT_L8):
            dwFlags             = DDPF_LUMINANCE;
            dwLuminanceBitMask  = 0x000000FF;
            dwLuminanceBitCount = 8;
            break;

        case( D3DFMT_A8L8):
            dwFlags                 = DDPF_LUMINANCE| DDPF_ALPHAPIXELS;
            dwLuminanceAlphaBitMask = 0x0000FF00;
            dwLuminanceBitMask      = 0x000000FF;
            dwLuminanceBitCount     = 16;
            break;

        case( D3DFMT_A4L4):
            dwFlags                 = DDPF_LUMINANCE| DDPF_ALPHAPIXELS;
            dwLuminanceAlphaBitMask = 0x000000F0;
            dwLuminanceBitMask      = 0x0000000F;
            dwLuminanceBitCount     = 8;
            break;

        case( D3DFMT_V8U8):
            dwFlags                = DDPF_BUMPDUDV;
            dwBumpDvBitMask        = 0x0000FF00;
            dwBumpDuBitMask        = 0x000000FF;
            dwBumpBitCount         = 16;
            break;

        case( D3DFMT_L6V5U5):
            dwFlags                = DDPF_BUMPDUDV| DDPF_BUMPLUMINANCE;
            dwBumpLuminanceBitMask = 0x0000FC00;
            dwBumpDvBitMask        = 0x000003E0;
            dwBumpDuBitMask        = 0x0000001F;
            dwBumpBitCount         = 16;
            break;

        case( D3DFMT_X8L8V8U8):
            dwFlags                = DDPF_BUMPDUDV| DDPF_BUMPLUMINANCE;
            dwBumpLuminanceBitMask = 0x00FF0000;
            dwBumpDvBitMask        = 0x0000FF00;
            dwBumpDuBitMask        = 0x000000FF;
            dwBumpBitCount         = 32;
            break;

        case( D3DFMT_A8):
            dwFlags                = DDPF_ALPHA;
            dwAlphaBitDepth        = 8;
            break;

        case( D3DFMT_D16):
        case( D3DFMT_D16_LOCKABLE):
            dwFlags                = DDPF_ZBUFFER;
            dwZBufferBitDepth      = 16;
            dwZBitMask             = 0xFFFF;
            break;

        case( D3DFMT_D32):
            dwFlags                = DDPF_ZBUFFER;
            dwZBufferBitDepth      = 32;
            dwZBitMask             = 0xFFFFFFFF;
            break;

        case( D3DFMT_D15S1):
            dwFlags                = DDPF_ZBUFFER| DDPF_STENCILBUFFER;
            dwZBufferBitDepth      = 16;
            dwZBitMask             = 0xFFFE;
            dwStencilBitDepth      = 1;
            dwStencilBitMask       = 0x0001;
            break;

        case( D3DFMT_D24S8):
            dwFlags                = DDPF_ZBUFFER| DDPF_STENCILBUFFER;
            dwZBufferBitDepth      = 32;
            dwZBitMask             = 0xFFFFFF00;
            dwStencilBitDepth      = 8;
            dwStencilBitMask       = 0xFF;
            break;

        case( D3DFMT_S1D15):
            dwFlags                = DDPF_ZBUFFER| DDPF_STENCILBUFFER;
            dwZBufferBitDepth      = 16;
            dwZBitMask             = 0x7FFF;
            dwStencilBitDepth      = 1;
            dwStencilBitMask       = 0x8000;
            break;

        case( D3DFMT_S8D24):
            dwFlags                = DDPF_ZBUFFER| DDPF_STENCILBUFFER;
            dwZBufferBitDepth      = 32;
            dwZBitMask             = 0x00FFFFFF;
            dwStencilBitDepth      = 8;
            dwStencilBitMask       = 0xFF000000;
            break;

        case( D3DFMT_X8D24):
            dwFlags                = DDPF_ZBUFFER;
            dwZBufferBitDepth      = 32;
            dwZBitMask             = 0x00FFFFFF;
            break;

        case( D3DFMT_D24X8):
            dwFlags                = DDPF_ZBUFFER;
            dwZBufferBitDepth      = 32;
            dwZBitMask             = 0xFFFFFF00;
            break;

        case( D3DFMT_D24X4S4):
            dwFlags                = DDPF_ZBUFFER| DDPF_STENCILBUFFER;
            dwZBufferBitDepth      = 32;
            dwZBitMask             = 0xFFFFFF00;
            dwStencilBitDepth      = 4;
            dwStencilBitMask       = 0x0000000F;
            break;

        case( D3DFMT_X4S4D24):
            dwFlags                = DDPF_ZBUFFER| DDPF_STENCILBUFFER;
            dwZBufferBitDepth      = 32;
            dwZBitMask             = 0x00FFFFFF;
            dwStencilBitDepth      = 4;
            dwStencilBitMask       = 0x0F000000;
            break;

        default:
            const bool Unrecognized_D3DFmt( false);
            assert( Unrecognized_D3DFmt);
            dwFlags= DDPF_FOURCC;
            dwFourCC= static_cast< DWORD>(D3DFmt);
            break;
        }
    }
};

struct SMatchSDesc:
    public unary_function< const DDSURFACEDESC&, bool>
{
    const DDSURFACEDESC& m_SDesc;

    SMatchSDesc( const DDSURFACEDESC& SDesc) : m_SDesc( SDesc) { }

    result_type operator()( argument_type Arg) const 
    {
        if((Arg.dwFlags& DDSD_CAPS)!= 0&& ((m_SDesc.dwFlags& DDSD_CAPS)== 0 ||
            (m_SDesc.ddsCaps.dwCaps& Arg.ddsCaps.dwCaps)!= Arg.ddsCaps.dwCaps))
                return false;
        if((Arg.dwFlags& DDSD_PIXELFORMAT)!= 0&&
            ((m_SDesc.dwFlags& DDSD_PIXELFORMAT)== 0 ||
            m_SDesc.ddpfPixelFormat.dwFlags!= Arg.ddpfPixelFormat.dwFlags ||
            m_SDesc.ddpfPixelFormat.dwFourCC!= Arg.ddpfPixelFormat.dwFourCC ||
            m_SDesc.ddpfPixelFormat.dwRGBBitCount!= Arg.ddpfPixelFormat.dwRGBBitCount ||
            m_SDesc.ddpfPixelFormat.dwRBitMask!= Arg.ddpfPixelFormat.dwRBitMask ||
            m_SDesc.ddpfPixelFormat.dwGBitMask!= Arg.ddpfPixelFormat.dwGBitMask ||
            m_SDesc.ddpfPixelFormat.dwBBitMask!= Arg.ddpfPixelFormat.dwBBitMask ||
            m_SDesc.ddpfPixelFormat.dwRGBZBitMask!= Arg.ddpfPixelFormat.dwRGBZBitMask))
                return false;

        return true;
    }
};

////////////////////////////////////////////////////////////////////////////////
//
// CSurfaceAllocator
//
////////////////////////////////////////////////////////////////////////////////
template< class TMatchFn= SMatchSDesc>
class CIVidMemAllocator
{
public: // Types
    typedef IVidMemSurface TSurface;
    typedef TSurface* (*TCreateSurfFn)( const DDSURFACEDESC&,
        PORTABLE_DDRAWSURFACE_LCL&);
    typedef vector< pair< DDSURFACEDESC, TCreateSurfFn> > TCreateSurfFns;

protected: // Types
    TCreateSurfFns m_CreateSurfFns;
    struct SAdaptedMatchFn: public TMatchFn
    {
        typedef typename TCreateSurfFns::value_type argument_type;
        using typename TMatchFn::result_type;

        SAdaptedMatchFn( const DDSURFACEDESC& SDesc) : TMatchFn( SDesc) {}

        result_type operator()( argument_type Arg) const 
        { return (*static_cast< const TMatchFn*>(this))( Arg.first); }
    };

public: // Functions
    CIVidMemAllocator()  { }
    template< class TIter>
    CIVidMemAllocator( TIter itStart, const TIter itEnd)
    {
        while( itStart!= itEnd)
        {
            m_CreateSurfFns.push_back(
                typename TCreateSurfFns::value_type( *itStart, *itStart));
            itStart++;
        }
    }
    ~CIVidMemAllocator()  { }

    TSurface* CreateSurf( const DDSURFACEDESC& SDesc,
        PORTABLE_DDRAWSURFACE_LCL& Surf) const
    {
        if( m_CreateSurfFns.empty())
            return new CGenSurface( SDesc, Surf);

        typename TCreateSurfFns::const_iterator itFound( 
            find_if( m_CreateSurfFns.begin(), m_CreateSurfFns.end(),
            SAdaptedMatchFn( SDesc) ) );

        if( itFound!= m_CreateSurfFns.end())
            return (itFound->second)( SDesc, Surf);

        // Warning, no specifications matched. If creation functions were
        // provided, there should also be a "default" specification or
        // DDSURFACEDESC with empty flags?, in order to "match rest".
        const bool No_Default_CreateSurface_Function_Found( false);
        assert( No_Default_CreateSurface_Function_Found);
        return new CGenSurface( SDesc, Surf);
    }

};

////////////////////////////////////////////////////////////////////////////////
//
// CPerDDrawData
//
////////////////////////////////////////////////////////////////////////////////
template< class THV= vector< DWORD> >
class CSurfDBEntry
{
public: // Types
    typedef THV THandleVector;

protected: // Variables
    DWORD m_LCLdwFlags;
    DDSCAPS m_LCLddsCaps;
    DWORD m_LCLdwBackBufferCount;
    DWORD m_MOREdwMipMapCount;
    DDSCAPSEX m_MOREddsCapsEx;
    DWORD m_MOREdwSurfaceHandle;
    DWORD m_MOREdwFVF;
    DWORD m_GBLdwGlobalFlags;
    ULONG_PTR m_GBLfpVidMem;
    LONG m_GBLlPitch;
    WORD m_GBLwHeight;
    WORD m_GBLwWidth;
    ULONG_PTR m_GBLdwReserved1;
    DDPIXELFORMAT m_GBLddpfSurface;
    THandleVector m_AttachedTo;
    THandleVector m_AttachedFrom;

public: // Functions
    CSurfDBEntry()  { }
    explicit CSurfDBEntry( PORTABLE_DDRAWSURFACE_LCL& DDSurf)
    { 
        try{
            (*this)= DDSurf;
        } catch( ... ) {
            m_AttachedTo.clear();
            m_AttachedFrom.clear();
            throw;
        }
    }
    ~CSurfDBEntry()  { }
    CSurfDBEntry< THV>& operator=( PORTABLE_DDRAWSURFACE_LCL& DDSurf)
    {
        // DO NOT STORE &DDSurf. This is considered illegal.
        m_LCLdwFlags= DDSurf.dwFlags();
        m_LCLddsCaps= DDSurf.ddsCaps();
        m_LCLdwBackBufferCount= DDSurf.dwBackBufferCount();
        m_MOREdwMipMapCount= DDSurf.lpSurfMore()->dwMipMapCount();
        m_MOREddsCapsEx= DDSurf.lpSurfMore()->ddsCapsEx();
        m_MOREdwSurfaceHandle= DDSurf.lpSurfMore()->dwSurfaceHandle();
        m_MOREdwFVF= DDSurf.lpSurfMore()->dwFVF();
        m_GBLdwGlobalFlags= DDSurf.lpGbl()->dwGlobalFlags;
        m_GBLfpVidMem= DDSurf.lpGbl()->fpVidMem;
        m_GBLlPitch= DDSurf.lpGbl()->lPitch;
        m_GBLwHeight= DDSurf.lpGbl()->wHeight;
        m_GBLwWidth= DDSurf.lpGbl()->wWidth;
        m_GBLdwReserved1= DDSurf.lpGbl()->dwReserved1;
        m_GBLddpfSurface= DDSurf.lpGbl()->ddpfSurface;
 
        const DWORD dwMyHandle( DDSurf.lpSurfMore()->dwSurfaceHandle());
        m_AttachedTo.clear();
        m_AttachedFrom.clear();

        PORTABLE_ATTACHLIST* pAl, *pNextAl;
        if((pAl= DDSurf.lpAttachList())!= NULL)
        {
            pNextAl= pAl;
            do
            {
                if( pNextAl->lpAttached!= NULL&& dwMyHandle!=
                    pNextAl->lpAttached->lpSurfMore()->dwSurfaceHandle())
                {
                    m_AttachedTo.push_back(
                        pNextAl->lpAttached->lpSurfMore()->dwSurfaceHandle());
                }
                pNextAl= pNextAl->lpLink;
            } while( pNextAl!= pAl && pNextAl!= NULL);
        }
        if((pAl= DDSurf.lpAttachListFrom())!= NULL)
        {
            pNextAl= pAl;
            do
            {
                if( pNextAl->lpAttached!= NULL&& dwMyHandle!=
                    pNextAl->lpAttached->lpSurfMore()->dwSurfaceHandle())
                {
                    m_AttachedFrom.push_back(
                        pNextAl->lpAttached->lpSurfMore()->dwSurfaceHandle());
                }
                pNextAl= pNextAl->lpLink;
            } while( pNextAl!= pAl && pNextAl!= NULL);
        }
        return *this;
    }
    DWORD GetLCLdwFlags( void) const 
    { return m_LCLdwFlags; }
    const DDSCAPS& GetLCLddsCaps( void) const 
    { return m_LCLddsCaps; }
    DWORD GetLCLdwBackBufferCount( void) const 
    { return m_LCLdwBackBufferCount; }
    DWORD GetMOREdwMipMapCount( void) const 
    { return m_MOREdwMipMapCount; }
    const DDSCAPSEX& GetMOREddsCapsEx( void) const 
    { return m_MOREddsCapsEx; }
    DWORD GetMOREdwSurfaceHandle( void) const 
    { return m_MOREdwSurfaceHandle; }
    DWORD GetMOREdwFVF( void) const 
    { return m_MOREdwFVF; }
    DWORD GetGBLdwGlobalFlags( void) const 
    { return m_GBLdwGlobalFlags; }
    ULONG_PTR GetGBLfpVidMem( void) const 
    { return m_GBLfpVidMem; }
    LONG GetGBLlPitch( void) const 
    { return m_GBLlPitch; }
    WORD GetGBLwHeight( void) const 
    { return m_GBLwHeight; }
    WORD GetGBLwWidth( void) const 
    { return m_GBLwWidth; }
    ULONG_PTR GetGBLdwReserved1( void) const 
    { return m_GBLdwReserved1; }
    const DDPIXELFORMAT& GetGBLddpfSurface( void) const 
    { return m_GBLddpfSurface; }
    const THandleVector& GetAttachedTo( void) const 
    { return m_AttachedTo; }
    const THandleVector& GetAttachedFrom( void) const 
    { return m_AttachedFrom; }
};

template< class TPDBE= CPalDBEntry, class THV= vector< DWORD> >
class CSurfDBEntryWPal:
    public CSurfDBEntry< THV>
{
public: // Types
    typedef TPDBE TPalDBEntry;

protected: // Variables
    TPalDBEntry* m_pPalDBEntry;

public: // Functions
    CSurfDBEntryWPal():
        m_pPalDBEntry( NULL)
    { }
    explicit CSurfDBEntryWPal( PORTABLE_DDRAWSURFACE_LCL& DDSurf):
        CSurfDBEntry< THV>( DDSurf), m_pPalDBEntry( NULL)
    { }
    ~CSurfDBEntryWPal()
    { }
    CSurfDBEntryWPal< TPDBE, THV>& operator=( PORTABLE_DDRAWSURFACE_LCL& DDSurf)
    {
        CSurfDBEntry< THV>* pSub= static_cast< CSurfDBEntry< THV>*>( this);
        // DO NOT STORE &DDSurf. This is considered illegal.
        *pSub= DDSurf;
        return *this;
    }
    void SetPalette( TPalDBEntry* pPalDBEntry)
    { m_pPalDBEntry= pPalDBEntry; }
    TPalDBEntry* GetPalette() const
    { return m_pPalDBEntry; }
};

template< class TSuper, class TD, class TSDBE= CSurfDBEntry<>,
    class TSDB= map< DWORD, TSDBE>,
    class TFS= set< PORTABLE_DDRAWSURFACE_LCL*> >
class CSubPerDDrawData
{
public: // Types
    typedef TD TDriver;
    typedef TSDBE TSurfDBEntry;
    typedef TSDB TSurfDB;

protected: // Variables
    TDriver& m_Driver;
    TSurfDB m_SurfDB;

protected: // Functions
    CSubPerDDrawData( TDriver& Driver, const DDRAWI_DIRECTDRAW_LCL& DDLcl) 
        :m_Driver( Driver)
    { }
    ~CSubPerDDrawData()  { }

public: // Functions
    TDriver& GetDriver( void) const  { return m_Driver; }
    TSurfDBEntry* GetSurfDBEntry( DWORD dwH) 
    {
        typename TSurfDB::iterator itSurf( m_SurfDB.find( dwH));
        if( itSurf!= m_SurfDB.end())
            return &itSurf->second;
        else
            return NULL;
    }
    const TSurfDBEntry* GetSurfDBEntry( DWORD dwH) const 
    {
        typename TSurfDB::const_iterator itSurf( m_SurfDB.find( dwH));
        if( itSurf!= m_SurfDB.end())
            return &itSurf->second;
        else
            return NULL;
    }

    bool PreProcessFullSurface( PORTABLE_DDRAWSURFACE_LCL& DDSLcl) const 
    {
        // DO NOT STORE &DDSLcl. This is considered illegal.
        // It is only valid for the duration of the call.
        return false;
    }
    bool PreProcessIndividualSurface( PORTABLE_DDRAWSURFACE_LCL& DDSLcl) const
        
    {
        // DO NOT STORE &DDSLcl. This is considered illegal.
        // It is only valid for the duration of the call.
        return false;
    }
    void ProcessIndividualSurface( PORTABLE_DDRAWSURFACE_LCL& DDSLcl)
    {
        // DO NOT STORE &DDSLcl. This is considered illegal.
        // It is only valid for the duration of the call.
        pair< TSurfDB::iterator, bool> Ret= m_SurfDB.insert( 
            TSurfDB::value_type( DDSLcl.lpSurfMore()->dwSurfaceHandle(),
            TSurfDBEntry( DDSLcl)));

        // If not added, update data.
        if( !Ret.second) Ret.first->second= DDSLcl;
    }
    void ProcessFullSurface( PORTABLE_DDRAWSURFACE_LCL& DDSLcl)
    {
        // DO NOT STORE &DDSLcl. This is considered illegal.
        // It is only valid for the duration of the call.
        TSuper* pSThis= static_cast<TSuper*>(this);
        typedef TFS TFoundSet;
        TFoundSet FoundSet;
        typename TFoundSet::size_type OldSetSize( FoundSet.size());

        // First traverse all over the attach lists looking for new surfaces.
        PORTABLE_ATTACHLIST* pAl, *pNextAl;
        FoundSet.insert( &DDSLcl);
        typename TFoundSet::size_type NewSetSize( FoundSet.size());
        while( OldSetSize!= NewSetSize)
        {
            OldSetSize= NewSetSize;

            typename TFoundSet::iterator itSurf( FoundSet.begin());
            while( itSurf!= FoundSet.end())
            {
                if((pAl= (*itSurf)->lpAttachList())!= NULL)
                {
                    pNextAl= pAl;
                    do
                    {
                        if( pNextAl->lpAttached!= NULL)
                            FoundSet.insert( pNextAl->lpAttached);

                        pNextAl= pNextAl->lpLink;
                    } while( pNextAl!= pAl && pNextAl!= NULL);
                }
                if((pAl= (*itSurf)->lpAttachListFrom())!= NULL)
                {
                    pNextAl= pAl;
                    do
                    {
                        if( pNextAl->lpAttached!= NULL)
                            FoundSet.insert( pNextAl->lpAttached);

                        pNextAl= pNextAl->lpLink;
                    } while( pNextAl!= pAl && pNextAl!= NULL);
                }
                itSurf++;                
            }
            NewSetSize= FoundSet.size();
        }

        // After all surfaces have been found, add them to the DB.
        typename TFoundSet::iterator itSurf( FoundSet.begin());
        while( itSurf!= FoundSet.end())
        {
            if( !pSThis->PreProcessIndividualSurface( *(*itSurf)))
                ProcessIndividualSurface( *(*itSurf));

            itSurf++;
        }
    }

    // Notification that a system or video memory surface was created. At the
    // least, we have to keep track of the surface handles.
    void SurfaceCreated( PORTABLE_DDRAWSURFACE_LCL& DDSLcl)
    {
        // DO NOT STORE &DDSLcl. This is considered illegal.
        // It is only valid for the duration of the call.
        TSuper* pSThis= static_cast<TSuper*>(this);

        // If true is returned, then a super structure was recognized and
        // processed. Otherwise, false indicates no recognition, and all
        // surfaces will be scoured.
        if( !pSThis->PreProcessFullSurface( DDSLcl))
            pSThis->ProcessFullSurface( DDSLcl);
    }
    bool SurfaceDestroyed( PORTABLE_DDRAWSURFACE_LCL& DDSLcl) 
    {
        // DO NOT STORE &DDSLcl. This is considered illegal.
        // It is only valid for the duration of the call.

        // No need to assert removal, as we might not be tracking this type
        // of surface. Someone could override and filter out surfaces.
        m_SurfDB.erase( DDSLcl.lpSurfMore()->dwSurfaceHandle());

        // Return true to tell driver to delete this object. So,
        // if DB is empty, odds are good to delete this.
        return m_SurfDB.empty();
    }
};

template< class TD>
class CMinimalPerDDrawData:
    public CSubPerDDrawData< CMinimalPerDDrawData< TD>, TD>
{
public:
    CMinimalPerDDrawData( TDriver& Driver, DDRAWI_DIRECTDRAW_LCL& DDLcl) 
        :CSubPerDDrawData< CMinimalPerDDrawData< TD>, TD>( Driver, DDLcl)
    { }
    ~CMinimalPerDDrawData()  { }
};

////////////////////////////////////////////////////////////////////////////////
//
// CSubDriver
//
////////////////////////////////////////////////////////////////////////////////
template< class T>
struct SFakeEntryPointHook
{
    SFakeEntryPointHook( T& t, const char* szEntryPoint)  { }
    ~SFakeEntryPointHook()  { }
};

template< class TD, class TC, class TSA= CIVidMemAllocator<>,
    class TPDDD= CMinimalPerDDrawData< TD>,
    class TCs= set< TC*>,
    class TPDDDs= map< LPDDRAWI_DIRECTDRAW_LCL, TPDDD>,
    class TSs= set< TSA::TSurface*>,
    class TEntryPointHook= SFakeEntryPointHook< TD> >
class CSubDriver
{
public: // Types
    typedef TD TDriver;
    typedef TC TContext;
    typedef TCs TContexts;
    typedef TPDDD TPerDDrawData;
    typedef TPDDDs TPerDDrawDatas;
    typedef TSA TSurfAlloc;
    typedef typename TSurfAlloc::TSurface TSurface;
    typedef TSs TSurfaces;

    class CSurfaceCapWrap
    {
    protected:
        DDSURFACEDESC m_SDesc;
    public:
        CSurfaceCapWrap()  { }
        CSurfaceCapWrap( const D3DFORMAT D3DFmt, const DWORD dwSupportedOps,
            const DWORD dwPrivateFmtBitCount= 0,
            const WORD wFlipMSTypes= 0, const WORD wBltMSTypes= 0) 
        {
            ZeroMemory( &m_SDesc, sizeof( m_SDesc));
            m_SDesc.dwSize= sizeof( m_SDesc);

            m_SDesc.ddpfPixelFormat.dwFlags= DDPF_D3DFORMAT;
            m_SDesc.ddpfPixelFormat.dwFourCC= static_cast<DWORD>(D3DFmt);
            m_SDesc.ddpfPixelFormat.dwOperations= dwSupportedOps;
            m_SDesc.ddpfPixelFormat.dwPrivateFormatBitCount= dwPrivateFmtBitCount;
            m_SDesc.ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes= wFlipMSTypes;
            m_SDesc.ddpfPixelFormat.MultiSampleCaps.wBltMSTypes= wBltMSTypes;
        }
        CSurfaceCapWrap( const D3DFORMAT D3DFmt, const bool bTexture,
            const bool bVolTexture, const bool bCubeTexture,
            const bool bOffScreenTarget, const bool bSameFmtTarget,
            const bool bZStencil, const bool bZStencilWithColor,
            const bool bSameFmtUpToAlpha, const bool b3DAccel,
            const DWORD dwPrivateFmtBitCount= 0,
            const WORD wFlipMSTypes= 0, const WORD wBltMSTypes= 0) 
        {
            ZeroMemory( &m_SDesc, sizeof( m_SDesc));
            m_SDesc.dwSize= sizeof( m_SDesc);

            DWORD dwOps( 0);
            if( bTexture) dwOps|= D3DFORMAT_OP_TEXTURE;
            if( bVolTexture) dwOps|= D3DFORMAT_OP_VOLUMETEXTURE;
            if( bCubeTexture) dwOps|= D3DFORMAT_OP_CUBETEXTURE;
            if( bOffScreenTarget) dwOps|= D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
            if( bSameFmtTarget) dwOps|= D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET;
            if( bZStencil) dwOps|= D3DFORMAT_OP_ZSTENCIL;
            if( bZStencilWithColor) dwOps|= D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH;
            if( bSameFmtUpToAlpha) dwOps|= D3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET;
            if( b3DAccel) dwOps|= D3DFORMAT_OP_3DACCELERATION;

            m_SDesc.ddpfPixelFormat.dwFlags= DDPF_D3DFORMAT;
            m_SDesc.ddpfPixelFormat.dwFourCC= static_cast<DWORD>(D3DFmt);
            m_SDesc.ddpfPixelFormat.dwOperations= dwOps;
            m_SDesc.ddpfPixelFormat.dwPrivateFormatBitCount= dwPrivateFmtBitCount;
            m_SDesc.ddpfPixelFormat.MultiSampleCaps.wFlipMSTypes= wFlipMSTypes;
            m_SDesc.ddpfPixelFormat.MultiSampleCaps.wBltMSTypes= wBltMSTypes;
        }
        ~CSurfaceCapWrap()  { }
        operator DDSURFACEDESC() const 
        { return m_SDesc; }
    };

private:
    // Stubs for secondary entry points.
    DWORD static APIENTRY ContextCreateStub( LPD3DHAL_CONTEXTCREATEDATA pccd) 
    {
        return sm_pGlobalDriver->ContextCreate(
            *reinterpret_cast< PORTABLE_CONTEXTCREATEDATA*>( pccd));
    }
    DWORD static APIENTRY ContextDestroyStub( LPD3DHAL_CONTEXTDESTROYDATA pcdd) 
    { return sm_pGlobalDriver->ContextDestroy( *pcdd); }
    DWORD static APIENTRY ContextDestroyAllStub( LPD3DHAL_CONTEXTDESTROYALLDATA pcdad) 
    { return sm_pGlobalDriver->ContextDestroyAll( *pcdad); }
    DWORD static APIENTRY SceneCaptureStub( LPD3DHAL_SCENECAPTUREDATA pscd) 
    { return sm_pGlobalDriver->SceneCapture( *pscd); }
    DWORD static APIENTRY RenderStateStub( LPD3DHAL_RENDERSTATEDATA prsd) 
    { return sm_pGlobalDriver->RenderState( *prsd); }
    DWORD static APIENTRY RenderPrimitiveStub( LPD3DHAL_RENDERPRIMITIVEDATA prpd) 
    { return sm_pGlobalDriver->RenderPrimitive( *prpd); }
    DWORD static APIENTRY TextureCreateStub( LPD3DHAL_TEXTURECREATEDATA ptcd) 
    { return sm_pGlobalDriver->TextureCreate( *ptcd); }
    DWORD static APIENTRY TextureDestroyStub( LPD3DHAL_TEXTUREDESTROYDATA ptdd) 
    { return sm_pGlobalDriver->TextureDestroy( *ptdd); }
    DWORD static APIENTRY TextureSwapStub( LPD3DHAL_TEXTURESWAPDATA ptsd) 
    { return sm_pGlobalDriver->TextureSwap( *ptsd); }
    DWORD static APIENTRY TextureGetSurfStub( LPD3DHAL_TEXTUREGETSURFDATA ptgsd) 
    { return sm_pGlobalDriver->TextureGetSurf( *ptgsd); }
    DWORD static APIENTRY GetStateStub( LPD3DHAL_GETSTATEDATA pgsd) 
    { return sm_pGlobalDriver->GetState( *pgsd); }
    DWORD static APIENTRY SetRenderTargetStub( LPD3DHAL_SETRENDERTARGETDATA psrtd) 
    {
        return sm_pGlobalDriver->SetRenderTarget(
            *reinterpret_cast< PORTABLE_SETRENDERTARGETDATA*>( psrtd));
    }
    DWORD static APIENTRY ClearStub( LPD3DHAL_CLEARDATA pcd) 
    { return sm_pGlobalDriver->Clear( *pcd); }
    DWORD static APIENTRY DrawOnePrimitiveStub( LPD3DHAL_DRAWONEPRIMITIVEDATA pdopd) 
    { return sm_pGlobalDriver->DrawOnePrimitive( *pdopd); }
    DWORD static APIENTRY DrawOneIndexedPrimitiveStub( LPD3DHAL_DRAWONEINDEXEDPRIMITIVEDATA pdoipd) 
    { return sm_pGlobalDriver->DrawOneIndexedPrimitive( *pdoipd); }
    DWORD static APIENTRY DrawPrimitivesStub( LPD3DHAL_DRAWPRIMITIVESDATA pdpd) 
    { return sm_pGlobalDriver->DrawPrimitives( *pdpd); }
    DWORD static APIENTRY Clear2Stub( LPD3DHAL_CLEAR2DATA pc2d) 
    { return sm_pGlobalDriver->Clear2( *pc2d); }
    DWORD static APIENTRY ValidateTextureStageStateStub( LPD3DHAL_VALIDATETEXTURESTAGESTATEDATA pvtssd) 
    { return sm_pGlobalDriver->ValidateTextureStageState( *pvtssd); }
    DWORD static APIENTRY DrawPrimitives2Stub( LPD3DHAL_DRAWPRIMITIVES2DATA pdpd) 
    {
        return sm_pGlobalDriver->DrawPrimitives2(
            *reinterpret_cast< PORTABLE_DRAWPRIMITIVES2DATA*>( pdpd));
    }
    DWORD static APIENTRY GetDriverStateStub( LPDDHAL_GETDRIVERSTATEDATA pgdsd) 
    { return sm_pGlobalDriver->GetDriverState( *pgdsd); }
    DWORD static APIENTRY CreateSurfaceExStub( LPDDHAL_CREATESURFACEEXDATA pcsxd) 
    {
        return sm_pGlobalDriver->CreateSurfaceEx(
            *reinterpret_cast< PORTABLE_CREATESURFACEEXDATA*>( pcsxd));
    }
    DWORD static APIENTRY CreateSurfaceStub( LPDDHAL_CREATESURFACEDATA pcsd) 
    {
        return sm_pGlobalDriver->CreateSurface(
            *reinterpret_cast< PORTABLE_CREATESURFACEDATA*>( pcsd));
    }
    DWORD static APIENTRY DestroySurfaceStub( LPDDHAL_DESTROYSURFACEDATA pdsd) 
    {
        return sm_pGlobalDriver->DestroySurface(
            *reinterpret_cast< PORTABLE_DESTROYSURFACEDATA*>( pdsd));
    }
    DWORD static APIENTRY LockStub( LPDDHAL_LOCKDATA pld) 
    {
        return sm_pGlobalDriver->Lock(
            *reinterpret_cast< PORTABLE_LOCKDATA*>( pld));
    }
    DWORD static APIENTRY UnlockStub( LPDDHAL_UNLOCKDATA pud) 
    {
        return sm_pGlobalDriver->Unlock(
            *reinterpret_cast< PORTABLE_UNLOCKDATA*>( pud));
    }

protected:
    TSurfAlloc m_SurfAlloc;
    TContexts m_Contexts;
    TPerDDrawDatas m_PerDDrawDatas;
    TSurfaces m_Surfaces;
    typedef vector< DDSURFACEDESC> TSupportedSurfaces;
    TSupportedSurfaces m_SupportedSurfaces;

    template< class TIter> // DDSURFACEDESC*
    CSubDriver( TIter itStart, const TIter itEnd, TSurfAlloc SA= TSurfAlloc()):
        m_SurfAlloc( SA)
    {
        // Copy supported surfaces formats into a guarenteed contiguous storage
        // for passing to D3D.
        while( itStart!= itEnd)
            m_SupportedSurfaces.push_back( *itStart++);
    }
    ~CSubDriver()  { }
    // Binds a VidMem DDRAWI object together with an internal driver surface object.
    void static AssociateSurface( PORTABLE_DDRAWSURFACE_LCL& DDSurf,
        TSurface* pSurf) 
    {
        assert((DDSurf.ddsCaps().dwCaps& DDSCAPS_VIDEOMEMORY)!= 0);
        DDSurf.lpGbl()->dwReserved1= reinterpret_cast< ULONG_PTR>(pSurf);
    }

public:
    // The global driver static member pointer. Only one Driver object, and
    // this points to it.
    static TDriver* sm_pGlobalDriver;

    TSurface* GetSurface( PORTABLE_DDRAWSURFACE_LCL& DDSurf,
        bool bCheck= true) const 
    {
        TSurface* pSurface= reinterpret_cast< TSurface*>(
            DDSurf.lpGbl()->dwReserved1);
        assert( bCheck&& m_Surfaces.find( pSurface)!= m_Surfaces.end());
        return pSurface;
    }
    TSurface* GetSurface( const typename TPerDDrawData::TSurfDBEntry& DBEntry,
        bool bCheck= true) const 
    {
        TSurface* pSurface= reinterpret_cast< TSurface*>(
            DBEntry.GetGBLdwReserved1());
        assert( bCheck&& m_Surfaces.find( pSurface)!= m_Surfaces.end());
        return pSurface;
    }

    // Secondary entry points with C++ friendly parameters.
    DWORD ContextCreate( PORTABLE_CONTEXTCREATEDATA& ccd) throw()
    {
        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "ContextCreate");

            ccd.ddrval()= DD_OK;
            TDriver* pSThis= static_cast<TDriver*>(this);

            // We should already have a PerDDrawData at this point, as the
            // surfaces to initialize the context had to be created already,
            // and the PerDDrawData should've been created there.
            typename TPerDDrawDatas::iterator itPerDDrawData(
                m_PerDDrawDatas.find( ccd.lpDDLcl()));
            assert( itPerDDrawData!= m_PerDDrawDatas.end());

            // Create the new context, passing in a ref to the PerDDrawData object.
            auto_ptr< TContext> pNewContext( new TContext(
                itPerDDrawData->second, ccd));

            // Keep track of our new context.
            pair< TContexts::iterator, bool> RetVal( m_Contexts.insert(
                pNewContext.get()));
            assert( RetVal.second); // Assure that there wasn't a duplicate.

            // Ownership now has been transfered to m_Contexts & D3D.
            ccd.dwhContext()= reinterpret_cast<ULONG_PTR>( pNewContext.release());
        } catch( bad_alloc e) {
            ccd.ddrval()= D3DHAL_OUTOFCONTEXTS;
        } catch( HRESULT hr) {
            ccd.ddrval()= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool ContextCreate_Unrecognized_Exception( false);
            assert( ContextCreate_Unrecognized_Exception);
            ccd.ddrval()= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }
    DWORD ContextDestroy( D3DHAL_CONTEXTDESTROYDATA& cdd) throw()
    {
        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "ContextDestroy");

            cdd.ddrval= DD_OK;

            // Ownership now has been transfered to local auto_ptr.
            auto_ptr< TContext> pContext(
                reinterpret_cast<TContext*>(cdd.dwhContext));

            // Remove tracking of this context.
            typename TContexts::size_type Ret( m_Contexts.erase( pContext.get()));
            assert( Ret!= 0);
        } catch( HRESULT hr) {
            cdd.ddrval= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool ContextDestroy_Unrecognized_Exception( false);
            assert( ContextDestroy_Unrecognized_Exception);
            cdd.ddrval= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }
    DWORD ContextDestroyAll( D3DHAL_CONTEXTDESTROYALLDATA& cdad) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "ContextDestroyAll");
        const bool ContextDestroyAll_thought_to_be_depreciated_entry_point( false);
        assert( ContextDestroyAll_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD SceneCapture( D3DHAL_SCENECAPTUREDATA& scd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "SceneCapture");
        const bool SceneCapture_thought_to_be_depreciated_entry_point( false);
        assert( SceneCapture_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD RenderState( D3DHAL_RENDERSTATEDATA& rsd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "RenderState");
        const bool RenderState_thought_to_be_depreciated_entry_point( false);
        assert( RenderState_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD RenderPrimitive( D3DHAL_RENDERPRIMITIVEDATA& rpd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "RenderPrimitive");
        const bool RenderPrimitive_thought_to_be_depreciated_entry_point( false);
        assert( RenderPrimitive_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD TextureCreate( D3DHAL_TEXTURECREATEDATA& tcd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "TextureCreate");
        const bool TextureCreate_thought_to_be_depreciated_entry_point( false);
        assert( TextureCreate_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD TextureDestroy( D3DHAL_TEXTUREDESTROYDATA& tdd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "TextureDestroy");
        const bool TextureDestroy_thought_to_be_depreciated_entry_point( false);
        assert( TextureDestroy_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD TextureSwap( D3DHAL_TEXTURESWAPDATA& tsd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "TextureSwap");
        const bool TextureSwap_thought_to_be_depreciated_entry_point( false);
        assert( TextureSwap_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD TextureGetSurf( D3DHAL_TEXTUREGETSURFDATA& tgsd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "TextureGetSurf");
        const bool TextureGetSurf_thought_to_be_depreciated_entry_point( false);
        assert( TextureGetSurf_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD GetState( D3DHAL_GETSTATEDATA& gsd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "GetState");
        const bool GetState_thought_to_be_depreciated_entry_point( false);
        assert( GetState_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD SetRenderTarget( PORTABLE_SETRENDERTARGETDATA& srtd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "SetRenderTarget");
        const bool SetRenderTarget_thought_to_be_depreciated_entry_point( false);
        assert( SetRenderTarget_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD Clear( D3DHAL_CLEARDATA& cd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "Clear");
        const bool Clear_thought_to_be_depreciated_entry_point( false);
        assert( Clear_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD DrawOnePrimitive( D3DHAL_DRAWONEPRIMITIVEDATA& dopd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "DrawOnePrimitive");
        const bool DrawOnePrimitive_thought_to_be_depreciated_entry_point( false);
        assert( DrawOnePrimitive_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD DrawOneIndexedPrimitive( D3DHAL_DRAWONEINDEXEDPRIMITIVEDATA& doipd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "DrawOneIndexedPrimitive");
        const bool DrawOneIndexedPrimitive_thought_to_be_depreciated_entry_point( false);
        assert( DrawOneIndexedPrimitive_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD DrawPrimitives( D3DHAL_DRAWPRIMITIVESDATA& dpd) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "DrawPrimitives");
        const bool DrawPrimitives_thought_to_be_depreciated_entry_point( false);
        assert( DrawPrimitives_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD Clear2( D3DHAL_CLEAR2DATA& c2d) const throw()
    {
        TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "Clear2");
        const bool Clear2_thought_to_be_depreciated_entry_point( false);
        assert( Clear2_thought_to_be_depreciated_entry_point);
        return DDHAL_DRIVER_NOTHANDLED;
    }
    DWORD ValidateTextureStageState( D3DHAL_VALIDATETEXTURESTAGESTATEDATA& vtssd) const throw()
    { 
        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "ValidateTextureStageState");

            vtssd.ddrval= DD_OK;
            TContext* pContext= reinterpret_cast<TContext*>(vtssd.dwhContext);

            // Make sure we've created this context.
            assert( m_Contexts.find( pContext)!= m_Contexts.end());

            // Pass entry point to context.
            vtssd.ddrval= pContext->ValidateTextureStageState( vtssd);
        } catch( HRESULT hr) {
            vtssd.ddrval= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool ValidateTextureStageState_Unrecognized_Exception( false);
            assert( ValidateTextureStageState_Unrecognized_Exception);
            vtssd.ddrval= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }
    DWORD DrawPrimitives2( PORTABLE_DRAWPRIMITIVES2DATA& dpd) const throw()
    {
        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "DrawPrimitives2");

            dpd.ddrval()= DD_OK;
            TContext* pContext= reinterpret_cast<TContext*>(dpd.dwhContext());

            // Make sure we've created this context.
            assert( m_Contexts.find( pContext)!= m_Contexts.end());

            // Pass entry point to context.
            dpd.ddrval()= pContext->DrawPrimitives2( dpd);
        } catch( HRESULT hr) {
            dpd.ddrval()= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool DrawPrimitives2_Unrecognized_Exception( false);
            assert( DrawPrimitives2_Unrecognized_Exception);
            dpd.ddrval()= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }
    DWORD GetDriverState( DDHAL_GETDRIVERSTATEDATA& gdsd) const throw()
    {
        // This entry point is hooked up to IDirect3DDevice8::GetInfo(
        //   DWORD DevInfoId, VOID* pDevInfoStruct, DWORD DevInfoStructSize).
        // gdsd.dwFlags= DevInfoId
        // gdsd.lpdwStates= pDevInfoStruct
        // gdsd.dwLength= DevInfoStructSize
        //
        // This entry point can be used for driver defined/ extended state
        // passing. Currently no DevInfoIds are pre-defined. S_FALSE should
        // be returned if nothing is done or the Id is not understood.
        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "GetDriverState");

            gdsd.ddRVal= DD_OK;
            TContext* pContext= reinterpret_cast< TContext*>( gdsd.dwhContext);

            // Make sure we've created this context.
            assert( m_Contexts.find( pContext)!= m_Contexts.end());

            // Pass entry point to context.
            gdsd.ddRVal= pContext->GetDriverState( gdsd);
        } catch( HRESULT hr) {
            gdsd.ddRVal= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool GetDriverState_Unrecognized_Exception( false);
            assert( GetDriverState_Unrecognized_Exception);
            gdsd.ddRVal= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }
    DWORD CreateSurfaceEx( PORTABLE_CREATESURFACEEXDATA& csxd) throw()
    {
        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "CreateSurfaceEx");

            TDriver* pSThis= static_cast<TDriver*>(this);
            csxd.ddRVal()= DD_OK;
            
            // Upon CreateSurfaceEx, we must detect whether this is a creation
            // or destruction notification and pass it to the associated
            // PerDDrawData.

            // Get PerDDrawData for this DDraw object.
            typename TPerDDrawDatas::iterator itPerDDrawData( m_PerDDrawDatas.find(
                csxd.lpDDLcl()));

            if( 0== csxd.lpDDSLcl()->lpGbl()->fpVidMem)
            {   // System Memory Surface Destruction,
                // Pass notification to PerDDrawData, if exists. PerDDraw data
                // will return bool indicating whether to delete it or not.
                if( itPerDDrawData!= m_PerDDrawDatas.end() &&
                    itPerDDrawData->second.SurfaceDestroyed( *csxd.lpDDSLcl()))
                    m_PerDDrawDatas.erase( itPerDDrawData);
            }
            else
            {   // Video or System Memory Surface Creation
                // If we don't have PerDDrawData for this DDraw object yet,
                // we must create it.
                if( itPerDDrawData== m_PerDDrawDatas.end())
                {
                    // Typically, storing pointers to DDRAWI objects is illegal,
                    // but this case has been deemed okay. Otherwise, we
                    // couldn't have the concept of "per DDraw" data, as
                    // "per DDraw" would be hard to figure out; as nothing
                    // guarentees uniqueness between the DDRAWI objects, besides
                    // the pointers.
                    itPerDDrawData= m_PerDDrawDatas.insert( 
                        TPerDDrawDatas::value_type( csxd.lpDDLcl(),
                        TPerDDrawData( *pSThis, *csxd.lpDDLcl())) ).first;
                }

                // Now pass notification to PerDDrawData.
                // DO NOT STORE csxd.lpDDSLcl. This is considered illegal.
                // It is only valid for the duration of the call.
                itPerDDrawData->second.SurfaceCreated( *csxd.lpDDSLcl());
            }
        } catch( bad_alloc e) {
            csxd.ddRVal()= DDERR_OUTOFMEMORY;
        } catch( HRESULT hr) {
            csxd.ddRVal()= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool CreateSurfaceEx_Unrecognized_Exception( false);
            assert( CreateSurfaceEx_Unrecognized_Exception);
            csxd.ddRVal()= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }
    DWORD CreateSurface( PORTABLE_CREATESURFACEDATA& csd) throw()
    {
        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "CreateSurface");

            TDriver* pSThis= static_cast<TDriver*>(this);
            csd.ddRVal()= DD_OK;

            // Upon CreateSurface, we must allocate memory for the "video"
            // memory surface and also associate our internal representation
            // with the surface.

            DWORD dwS( 0);
            try
            {
                // For each surface we're asked to create...
                while( dwS< csd.dwSCnt())
                {
                    // Get PerDDrawData for this DDraw object.
                    const LPDDRAWI_DIRECTDRAW_LCL pDDLcl(
                        csd.lplpSList()[ dwS]->lpSurfMore()->lpDD_lcl());
                    typename TPerDDrawDatas::iterator itPerDDrawData(
                        m_PerDDrawDatas.find( pDDLcl));

                    // If we don't have PerDDrawData for this DDraw object yet,
                    // we must create it.
                    if( itPerDDrawData== m_PerDDrawDatas.end())
                    {
                        // Typically, storing pointers to DDRAWI objects is
                        // illegal, but this case has been deemed okay.
                        // Otherwise, we couldn't have the concept of
                        // "per DDraw" data, as "per DDraw" would be hard to
                        // figure out; as nothing guarentees uniqueness
                        // between the DDRAWI objects, besides the pointers.
                        itPerDDrawData= m_PerDDrawDatas.insert( 
                            TPerDDrawDatas::value_type( pDDLcl,
                            TPerDDrawData( *pSThis, *pDDLcl)) ).first;
                    }

                    // Create the new surface, by using the surface allocator.
                    // DO NOT STORE csd.lplpSList[ dwS]. This is considered
                    // illegal. It is only valid for the duration of the call.
                    auto_ptr< TSurface> pNewSurf(
                        m_SurfAlloc.CreateSurf( *csd.lpDDSurfaceDesc(),
                        *csd.lplpSList()[ dwS]));

                    // Add the pointer to our set of VM surfaces for tracking.
                    m_Surfaces.insert( pNewSurf.get());

                    // Bind the internal representation to the DDRAWI object.
                    AssociateSurface( *csd.lplpSList()[ dwS], pNewSurf.get());

                    pNewSurf.release();
                    dwS++;
                }
            } catch( ... ) {
                // dwS will point to failed alloc, then deallocate the
                // succeeded allocations.

                // Bind NULL to the DDRAWI object and blank out fpVidMem, just
                // in case.
                AssociateSurface( *csd.lplpSList()[ dwS], NULL);
                csd.lplpSList()[ dwS]->lpGbl()->fpVidMem= NULL;
                if( dwS!= 0) do
                {
                    --dwS;

                    TSurface* pSurface= GetSurface( *csd.lplpSList()[ dwS]);
                    m_Surfaces.erase( pSurface);
                    delete pSurface;

                    // Bind NULL to the DDRAWI object and blank out fpVidMem,
                    // to avoid DDraw in thinking the surface was allocated.
                    AssociateSurface( *csd.lplpSList()[ dwS], NULL);
                    csd.lplpSList()[ dwS]->lpGbl()->fpVidMem= NULL;
                } while( dwS!= 0);

                throw; // Re-throw the exception.
            }

            // We wait till CreateSurfaceEx to make the handle association.
        } catch( bad_alloc e) {
            csd.ddRVal()= DDERR_OUTOFMEMORY;
        } catch( HRESULT hr) {
            csd.ddRVal()= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool CreateSurface_Unrecognized_Exception( false);
            assert( CreateSurface_Unrecognized_Exception);
            csd.ddRVal()= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }
    DWORD DestroySurface( PORTABLE_DESTROYSURFACEDATA& dsd) throw()
    { 
        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "DestroySurface");

            dsd.ddRVal()= DD_OK;

            // Retrieve 
            TSurface* pSurface= GetSurface( *dsd.lpDDSurface());

            // Surface object must be destroyed before the DB entry. This is
            // a requirement so that a link (pointer) can safely be
            // established between the DB entry and the object.
            m_Surfaces.erase( pSurface);
            delete pSurface;

            // Pass destruction notice to PerDDrawData. If it returns true,
            // then PerDDrawData indicates that it should be destroyed.
            typename TPerDDrawDatas::iterator itPerDDrawData( m_PerDDrawDatas.find(
                dsd.lpDDSurface()->lpSurfMore()->lpDD_lcl()));
            if( itPerDDrawData!= m_PerDDrawDatas.end() &&
                itPerDDrawData->second.SurfaceDestroyed( *dsd.lpDDSurface()))
                m_PerDDrawDatas.erase( itPerDDrawData);
        } catch( HRESULT hr) {
            dsd.ddRVal()= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool DestroySurface_Unrecognized_Exception( false);
            assert( DestroySurface_Unrecognized_Exception);
            dsd.ddRVal()= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }
    DWORD Lock( PORTABLE_LOCKDATA& ld) const throw()
    { 
        // Typically, an application requesting a "Lock" of a multisampled
        // surface is not allowed. It would require a MSLock or a new version
        // of Lock to get access to the multisampled bits. However, these
        // surfaces still need to be able to "Present" the bits or "Blt" the
        // bits to the Primary, typically. This requires a workaround:
        // The runtime WILL lock the surface (not for the app), expecting the
        // rasterizer to subsample the multisampled bits into an equivalent
        // non-multisampled area and return this smaller area out of Lock,
        // so that the runtime can "Present" the bits, or whatever.

        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "Lock");

            ld.ddRVal()= DD_OK;

            // First, retrieve surface object bound to this structure.
            TSurface* pSurface= GetSurface( *ld.lpDDSurface());

            // Pass control to object's Lock function.
            ld.lpSurfData()= pSurface->Lock( ld.dwFlags(), (ld.bHasRect()?
                &ld.rArea(): NULL));
        } catch( HRESULT hr) {
            ld.ddRVal()= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool Lock_Unrecognized_Exception( false);
            assert( Lock_Unrecognized_Exception);
            ld.ddRVal()= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }
    DWORD Unlock( PORTABLE_UNLOCKDATA& ud) const throw()
    { 
        try
        {
            TEntryPointHook EntryPointHook( *sm_pGlobalDriver, "Unlock");

            ud.ddRVal()= DD_OK;

            // First, retrieve surface object bound to this structure.
            TSurface* pSurface= GetSurface( *ud.lpDDSurface());

            // Pass control to object's Unlock function.
            pSurface->Unlock();
        } catch( HRESULT hr) {
            ud.ddRVal()= hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            const bool Unlock_Unrecognized_Exception( false);
            assert( Unlock_Unrecognized_Exception);
            ud.ddRVal()= E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return DDHAL_DRIVER_HANDLED;
    }

    // Main entry point of driver.
    // Should be called by a bridge function, only.
    HRESULT GetSWInfo( D3DCAPS8& Caps8, D3D8_SWCALLBACKS& Callbacks,
        DWORD& dwNumTextures, DDSURFACEDESC*& pTexList) throw()
    {
        // This static member variable should be initialized to be NULL or
        // point it to the global class.
        assert( NULL== sm_pGlobalDriver|| \
            static_cast< TDriver*>( this)== sm_pGlobalDriver);
        sm_pGlobalDriver= static_cast< TDriver*>( this);

        Callbacks.CreateContext            = ContextCreateStub; // Needed.
        Callbacks.ContextDestroy           = ContextDestroyStub; // Needed.
        Callbacks.ContextDestroyAll        = ContextDestroyAllStub; // Unused in DX8DDI?
        Callbacks.SceneCapture             = SceneCaptureStub; // Unused in DX8DDI, now a render state.
        Callbacks.RenderState              = RenderStateStub; // Unused in DX8DDI?
        Callbacks.RenderPrimitive          = RenderPrimitiveStub; // Unused in DX8DDI?
        Callbacks.TextureCreate            = TextureCreateStub; // Unused in DX8DDI?
        Callbacks.TextureDestroy           = TextureDestroyStub; // Unused in DX8DDI?
        Callbacks.TextureSwap              = TextureSwapStub; // Unused in DX8DDI?
        Callbacks.TextureGetSurf           = TextureGetSurfStub; // Unused in DX8DDI?
        Callbacks.GetState                 = GetStateStub; // Unused in DX8DDI?
        Callbacks.SetRenderTarget          = SetRenderTargetStub; // Unused in DX8DDI?
        Callbacks.Clear                    = ClearStub; // Unused in DX8DDI?
        Callbacks.DrawOnePrimitive         = DrawOnePrimitiveStub; // Unused in DX8DDI?
        Callbacks.DrawOneIndexedPrimitive  = DrawOneIndexedPrimitiveStub; // Unused in DX8DDI?
        Callbacks.DrawPrimitives           = DrawPrimitivesStub; // Unused in DX8DDI?
        Callbacks.Clear2                   = Clear2Stub; // Unused in DX8DDI?
        Callbacks.ValidateTextureStageState= ValidateTextureStageStateStub; // Optional?
        Callbacks.DrawPrimitives2          = DrawPrimitives2Stub; // Needed.
        Callbacks.GetDriverState           = GetDriverStateStub; // Optional?
        Callbacks.CreateSurfaceEx          = CreateSurfaceExStub; // Needed.
        Callbacks.CreateSurface            = CreateSurfaceStub; // Needed.
        Callbacks.DestroySurface           = DestroySurfaceStub; // Needed.
        Callbacks.Lock                     = LockStub; // Needed.
        Callbacks.Unlock                   = UnlockStub; // Needed.

        try {
            Caps8= sm_pGlobalDriver->GetCaps();

            // There needs to be support for some surfaces, at least.
            assert( !m_SupportedSurfaces.empty());

            dwNumTextures= m_SupportedSurfaces.size();
            pTexList= &(*m_SupportedSurfaces.begin());
        } catch( bad_alloc ba) {
            return E_OUTOFMEMORY;
        } catch( HRESULT hr) {
            return hr;
#if !defined( DX8SDDIFW_NOCATCHALL)
        } catch( ... ) {
            return E_UNEXPECTED;
#endif // !defined( DX8SDDIFW_NOCATCHALL)
        }
        return S_OK;
    }
};

template< class TD, class TR>
class CMinimalDriver:
    public CSubDriver< TD, CMinimalContext< CMinimalPerDDrawData< TD>, TR> >
{
public: // Types
    typedef TR TRasterizer;

protected:
    template< class TIter> // DDSURFACEDESC*
    CMinimalDriver( TIter itStart, const TIter itEnd) :
        CSubDriver< TD, TContext>( itStart, itEnd)
    { /* TODO: Check caps? */ }
    ~CMinimalDriver() 
    { }
};

#if !defined( DX8SDDIFW_NONAMESPACE)
}
#endif // !defined( DX8SDDIFW_NONAMESPACE)