windows-xp/Source/XPSP1/NT/multimedia/directx/dxg/ref8/inc/refdev.hpp

///////////////////////////////////////////////////////////////////////////////
// Copyright (C) Microsoft Corporation, 2000.
//
// refdev.hpp
//
// Direct3D Reference Device - Main Header File
//
///////////////////////////////////////////////////////////////////////////////
#ifndef  _REFDEV_HPP
#define  _REFDEV_HPP

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <windows.h>

#pragma warning( disable: 4056) // fp constant
#pragma warning( disable: 4244) // fp DOUBLE->FLOAT

#include <ddraw.h>
#include <ddrawi.h>
#include <d3dhal.h>
#include "d3d8ddi.h"
//@@BEGIN_MSINTERNAL
#include "d3d8p.h"
//@@END_MSINTERNAL

#include <rdcomm.hpp>

// forward declarations
class D3DDebugMonitor;
class RDDebugMonitor;
class RDSurfaceManager;
class RDSurface2D;
class RDSurface;
class RDRenderTarget;
class RDTextureStageState;
class RDBSpline;
class RDNPatch;
class RefDev;

#include <rddmon.hpp>
#include <templarr.hpp>
#include <vshader.h>
#include <vstream.h>
#include <reftnl.hpp>
#include <refrast.hpp>
#include <pshader.h>

//-----------------------------------------------------------------------------
//
// A special legacy (pre-DX6) texture op we can't easily map into the new
// texture ops.
//
//-----------------------------------------------------------------------------

#define D3DTOP_LEGACY_ALPHAOVR  (0x7fffffff)

//-----------------------------------------------------------------------------
//
// Constants
//
//-----------------------------------------------------------------------------
const DWORD RD_MAX_NUM_TEXTURE_FORMATS = 50;

const DWORD RD_MAX_CLOD = 13*6; // base texture up to 4kx4k for 6 Cubemaps

//-----------------------------------------------------------------------------
//
// RefRastSetMemif - Routine to set memory allocation interface for reference
// rasterizer - takes pointers to functions to use for malloc, free, and realloc.
//
// These must be set prior to new'ing any RefDev objects.
//
//-----------------------------------------------------------------------------
void
RefRastSetMemif(
    LPVOID( _cdecl* pfnMemAlloc )( size_t ),
    void( _cdecl* pfnMemFree )( PVOID ),
    LPVOID( _cdecl* pfnMemReAlloc )( PVOID, size_t ) );

//-----------------------------------------------------------------------------
//
// RDRenderTarget - Class which encompasses all information about rendering
// target, including size, type/pointer/stride for color and depth/stencil
// buffers, guard band clip info, W range info.
//
// Usage is to instantiate, fill out public members, and install into a
// RefDev object via RefDev::SetRenderTarget.
//
//-----------------------------------------------------------------------------
class RDRenderTarget : public RDAlloc
{
public:
    ///////////////////////////////////////////////////////////////////////////
    //
    // public interface
    //
    ///////////////////////////////////////////////////////////////////////////

    RDRenderTarget( void );
    ~RDRenderTarget( void );
//
// these need to be filled in by the user before installing in a
// RefDev object
//
    RECT    m_Clip;         // clipping bounds
    FLOAT   m_fWRange[2];   // range of device W (W at near and far clip planes)

    RDSurface2D* m_pColor;
    RDSurface2D* m_pDepth;

    // This boolean indicates that the DDI used to set render target
    // is a pre-DX7. This is used by the destructor to free up the
    // color and depth buffers.
    BOOL    m_bPreDX7DDI;

    ///////////////////////////////////////////////////////////////////////////
    //
    // internal state and methods
    //
    ///////////////////////////////////////////////////////////////////////////
    friend class RefDev;
    HRESULT Initialize( LPDDRAWI_DIRECTDRAW_LCL pDDLcl, DWORD dwColorHandle,
                        DWORD dwDepthHandle );
    HRESULT Initialize( LPDDRAWI_DIRECTDRAW_LCL pDDLcl,
                        LPDDRAWI_DDRAWSURFACE_LCL pLclColor,
                        LPDDRAWI_DDRAWSURFACE_LCL pLclZ );
    HRESULT Initialize( LPDDRAWI_DDRAWSURFACE_LCL pLclColor,
                        LPDDRAWI_DDRAWSURFACE_LCL pLclZ );

    // read/write specific sample
    void ReadPixelColor   ( INT32 iX, INT32 iY, UINT Sample, RDColor& Color );
    void WritePixelColor  ( INT32 iX, INT32 iY, UINT Sample, const RDColor& Color, BOOL bDither );
    void WritePixelDepth  ( INT32 iX, INT32 iY, UINT Sample, const RDDepth& Depth );
    void ReadPixelDepth   ( INT32 iX, INT32 iY, UINT Sample, RDDepth& Depth );
    void WritePixelStencil( INT32 iX, INT32 iY, UINT Sample, UINT8 uStencil );
    void ReadPixelStencil ( INT32 iX, INT32 iY, UINT Sample, UINT8& uStencil );

    // write all samples
    void WritePixelColor  ( INT32 iX, INT32 iY, const RDColor& Color, BOOL bDither );
    void WritePixelDepth  ( INT32 iX, INT32 iY, const RDDepth& Depth );
    void WritePixelStencil( INT32 iX, INT32 iY, UINT8 uStencil );

    void Clear            ( RDColor fillColor, LPD3DHAL_DP2COMMAND pCmd );
    void ClearDepth       ( RDDepth fillDepth, LPD3DHAL_DP2COMMAND pCmd );
    void ClearStencil     ( UINT8 uStencil, LPD3DHAL_DP2COMMAND pCmd );
    void ClearDepthStencil( RDDepth fillDepth, UINT8 uStencil, LPD3DHAL_DP2COMMAND pCmd );
};

//-----------------------------------------------------------------------------
//
// RDTextureStageState - This holds the per-stage state for texture mapping.
// An array of these are instanced in the RefDev object.
//
// Store texture matrix at the end of the texture stage state.
//
//-----------------------------------------------------------------------------
class RDTextureStageState
{
public:
    union
    {
        DWORD   m_dwVal[D3DTSS_MAX]; // state array (unsigned)
        FLOAT   m_fVal[D3DTSS_MAX];  // state array (float)
    };
};

//-----------------------------------------------------------------------------
//
// RDSurface - Class instanced once per surface which encompasses information
// about a chain of surfaces used either as a mipmap, cubemap, render-target,
// depth-buffer, vertex buffer or an index buffer.  Includes size and type
// (assumed same for each level of detail) and pointer/stride for each LOD.
//
// Created by CreateSurfaceEx DDI call.
//
//-----------------------------------------------------------------------------

// Surface type flags. Some combination of them are legal
const DWORD RR_ST_UNKNOWN                = 0;
const DWORD RR_ST_TEXTURE                = (1<<0);
const DWORD RR_ST_RENDERTARGETCOLOR      = (1<<2);
const DWORD RR_ST_RENDERTARGETDEPTH      = (1<<3);
const DWORD RR_ST_VERTEXBUFFER           = (1<<4);
const DWORD RR_ST_INDEXBUFFER            = (1<<5);

// The following flags track the surface status
const DWORD RRSURFACE_STATUS_INITCALLED =  (1<<0);
const DWORD RRSURFACE_STATUS_REFCREATED =  (1<<1);
const DWORD RRSURFACE_STATUS_ISLOCKED   =  (1<<2);


class RDSurface
{
public:
    RDSurface()
    {
        m_dwStatus          = 0;
        m_MemPool           = D3DPOOL_FORCE_DWORD;
        m_SurfType          = RR_ST_UNKNOWN;
        m_iLockCount        = 0;
    }

    virtual HRESULT Initialize( LPDDRAWI_DDRAWSURFACE_LCL   pDDSLcl ) = 0;

    virtual ~RDSurface()
    {
        return;
    }
    BOOL IsInitialized(){ return (m_dwStatus & RRSURFACE_STATUS_INITCALLED); }
    void SetInitialized(){ m_dwStatus |= RRSURFACE_STATUS_INITCALLED; }

    BOOL IsRefCreated() { return (m_dwStatus & RRSURFACE_STATUS_REFCREATED); }
    void SetRefCreated(){ m_dwStatus |= RRSURFACE_STATUS_REFCREATED; }

    BOOL IsLocked()     { return (m_dwStatus & RRSURFACE_STATUS_ISLOCKED); }
    void Lock()         { m_iLockCount++;   }
    void Unlock()       { if( m_iLockCount > 0 ) m_iLockCount--; }

    DWORD GetSurfaceType() { return m_SurfType; }
    D3DPOOL GetMemPool() { return m_MemPool; }

protected:
    D3DPOOL         m_MemPool;                      // Where is this allocated
    DWORD           m_SurfType;                     // the type of surface
    DWORD           m_dwStatus;
    int             m_iLockCount;
};

//-----------------------------------------------------------------------------
//
// RDCREATESURFPRIVATE
// PrivateData stored in SurfaceGbl->dwReserved1 at CreateSurface call
//
//-----------------------------------------------------------------------------
class RDCREATESURFPRIVATE
{
public:
    RDCREATESURFPRIVATE()
    {
        dwPitch = 0;
        dwLockCount = 0;
        pBits = NULL;

        wSamples = 1;
        dwMultiSamplePitch = 0;
        pMultiSampleBits = NULL;
        SurfaceFormat = RD_SF_NULL;
    }

    ~RDCREATESURFPRIVATE()
    {
        _ASSERT( dwLockCount == 0, "Surface being deleted has some"
                 "outstanding locks" );
        delete [] pBits;
        delete [] pMultiSampleBits;
    }

    void Lock()
    {
        dwLockCount++;
    }

    void Unlock()
    {
        if( dwLockCount > 0)
            dwLockCount--;
    }

    DWORD dwLockCount;

    union
    {
        DWORD dwPitch;
        DWORD dwVBSize;
    };
    BYTE* pBits;

    WORD  wSamples;
    DWORD dwMultiSamplePitch;
    BYTE* pMultiSampleBits;
    RDSurfaceFormat SurfaceFormat;
};

//---------------------------------------------------------------------------
// RDDSurfaceArrayNode
//
// This is a node in the linked list of the growable array of RefSurfaces
// maintained per ddraw lcl.
//---------------------------------------------------------------------------
struct RDSurfaceHandle
{
    RDSurfaceHandle()
    {
        m_pSurf = NULL;
#if DBG
        m_tag = 0;
#endif
    }
    RDSurface* m_pSurf;
#if DBG
    // Non zero means that it has been allocated
    DWORD      m_tag;
#endif
};

class RDSurfaceArrayNode : public RDListEntry
{
public:
    RDSurfaceArrayNode(LPDDRAWI_DIRECTDRAW_LCL pDDLcl);
    ~RDSurfaceArrayNode();
    HRESULT AddSurface( LPDDRAWI_DDRAWSURFACE_LCL   pDDSLcl,
                        RDSurface**                 ppSurf );
    RDSurface* GetSurface( DWORD dwHandle );
    HRESULT RemoveSurface( DWORD dwHandle );

private:
    LPDDRAWI_DIRECTDRAW_LCL  m_pDDLcl;
    GArrayT<RDSurfaceHandle> m_SurfHandleArray;
    RDSurfaceArrayNode* m_pNext;

    friend class RDSurfaceManager;
};

//---------------------------------------------------------------------------
// RDSurfaceManager
//
// This class maintains a linked list of all the
// surface handle tables for each DD_LCL
//---------------------------------------------------------------------------
class RDSurfaceManager
{
public:
    RDSurfaceManager() {m_pFirstNode = NULL;}
    ~RDSurfaceManager()
    {
        RDSurfaceArrayNode *pNode = m_pFirstNode;
        while( pNode )
        {
            RDSurfaceArrayNode *pTmp = pNode;
            pNode = pNode->m_pNext;
            delete pTmp;
        }
    }

    RDSurfaceArrayNode* AddLclNode( LPDDRAWI_DIRECTDRAW_LCL pDDLcl );
    RDSurfaceArrayNode* GetLclNode( LPDDRAWI_DIRECTDRAW_LCL pDDLcl );

    HRESULT AddSurfToList( LPDDRAWI_DIRECTDRAW_LCL     pDDLcl,
                           LPDDRAWI_DDRAWSURFACE_LCL   pDDSLcl,
                           RDSurface**                 ppSurf );
    RDSurface* GetSurfFromList( LPDDRAWI_DIRECTDRAW_LCL   pDDLcl,
                                DWORD                     dwHandle );

    HRESULT RemoveSurfFromList( LPDDRAWI_DIRECTDRAW_LCL     pDDLcl,
                                LPDDRAWI_DDRAWSURFACE_LCL   pDDSLcl);
    HRESULT RemoveSurfFromList( LPDDRAWI_DIRECTDRAW_LCL     pDDLcl,
                                DWORD dwHandle );

private:
    RDSurfaceArrayNode *m_pFirstNode;
};

extern RDSurfaceManager g_SurfMgr;


//-----------------------------------------------------------------------------
//
// RDVertexBuffer - The RefDev's representation of the VertexBuffer. It gets
// created on a CreateSurfaceEx call.
//
//-----------------------------------------------------------------------------
class RDVertexBuffer : public RDSurface
{
public:
    RDVertexBuffer()
    {
        m_pBits = NULL;
        m_cbSize = 0;
        m_FVF = 0;
    }

    virtual ~RDVertexBuffer() { return; }
    HRESULT Initialize( LPDDRAWI_DDRAWSURFACE_LCL pLcl );
    LPBYTE GetBits() { return m_pBits; }
    int GetFVF()  { return m_FVF; }
    int GetSize()  { return m_cbSize; }

protected:
    DWORD   m_FVF;
    BYTE*   m_pBits;
    DWORD   m_cbSize;
};

//-----------------------------------------------------------------------------
//
// RDPalette - Class for representing and managing palettes in RefDev
//
//-----------------------------------------------------------------------------
class RDPalette
{
public:
    RDPalette()
    {
        m_dwFlags = 0;
        memset( m_Entries, 0, sizeof( m_Entries ) );
    }

    D3DCOLOR* GetEntries()
    {
        return m_Entries;
    }

    static const DWORD RDPAL_ALPHAINPALETTE;
    static const DWORD m_dwNumEntries;

    HRESULT Update( WORD StartIndex, WORD wNumEntries,
                    PALETTEENTRY* pEntries );
    BOOL HasAlpha()
    {
        return (m_dwFlags & RDPAL_ALPHAINPALETTE);
    }

    DWORD     m_dwFlags;
    D3DCOLOR  m_Entries[256];
};


struct RDPaletteHandle
{
    RDPaletteHandle()
    {
        m_pPal = NULL;
#if DBG
        m_tag = 0;
#endif
    }
    RDPalette* m_pPal;
#if DBG
    // Non zero means that it has been allocated
    DWORD      m_tag;
#endif
};

//-----------------------------------------------------------------------------
//
// RDSurface2D - Class instanced once per 2D surface which could be either
// texture, color render target or  depth buffer information
// about a chain of surfaces.  Includes size and type
// (assumed same for each level of detail) and pointer/stride for each LOD.
//
// Also includes pointer to palette, and colorkey value (legacy support only).
//
//-----------------------------------------------------------------------------
class RDSurface2D : public RDSurface
{
public:
    ///////////////////////////////////////////////////////////////////////////
    //
    // public interface
    //
    ///////////////////////////////////////////////////////////////////////////

    RDSurface2D( void );
    ~RDSurface2D( void );

    friend class RefDev;
    class RefDev *  m_pRefDev;  // refdev which created this - used only when this is bound as a texture
    void SetRefDev( RefDev* pRefDev) { m_pRefDev = pRefDev; }

    DWORD           m_uFlags;       // RR_TEXTURE_* bitdefs
// bit definitions for RDSurface2D::uFlags
#define RR_TEXTURE_HAS_CK           (1L<< 0)    // set if texture has colorkey
#define RR_TEXTURE_ALPHAINPALETTE   (1L<< 1)    // set if alpha channel in palette
#define RR_TEXTURE_CUBEMAP          (1L<< 2)    // set if texture is Cubemap with 6 times the number of surfaces
#define RR_TEXTURE_VOLUME           (1L<< 4)    // set if texture is volume

    // basic info
    UINT            m_iSamples;
    int             m_iWidth;                       // size of top-level map
    int             m_iHeight;
    int             m_iDepth;                       // depth of volume texture
    BYTE*           m_pBits[RD_MAX_CLOD];         // pointer to surface bits
    int             m_iPitch[RD_MAX_CLOD];        // pitch in bytes
    int             m_iSlicePitch[RD_MAX_CLOD];   // slice pitch in bytes
                                                    // for volume texture
    int             m_cLOD;     // 0..(n-1) count of LODs currently available

    RDSurfaceFormat m_SurfFormat;                   // format of pixel

    DWORD           m_dwColorKey;   // D3DCOLOR colorkey value

    DWORD           m_dwEmptyFaceColor;     // D3DCOLOR empty cubemap empty face value

    DWORD*          m_pPalette;     // pointer to D3DCOLOR palette (may be NULL)
    RDPalette*      m_pPalObj;

    // DD surface pointers for locking/unlocking and GetSurf callback
    LPDDRAWI_DDRAWSURFACE_LCL m_pDDSLcl[RD_MAX_CLOD];
    int             m_cLODDDS;  // 0..(n-1) count of LODs actually in the pDDS array

    D3DTEXTUREHANDLE    m_hTex; // texture handle

    ///////////////////////////////////////////////////////////////////////////
    //
    // internal state and methods
    //
    ///////////////////////////////////////////////////////////////////////////
    BOOL            m_bHasAlpha;        // TRUE if texture has an alpha channel

    int             m_cDimension;       // 1,2,3 for 1D,2D,3D textures
    int             m_cTexels[RD_MAX_CLOD][3]; // integer number of texels in each dimension
    float           m_fTexels[RD_MAX_CLOD][3]; // float number of texels in each dimension


    HRESULT Initialize( LPDDRAWI_DDRAWSURFACE_LCL pLcl );
    DWORD ComputePitch( LPDDRAWI_DDRAWSURFACE_LCL pLcl ) const;
    DWORD ComputePitch( LPDDRAWI_DDRAWSURFACE_LCL pLcl,
                        RDSurfaceFormat SurfFormat,
                        DWORD width, DWORD height ) const;

    void SetPalette( RDPalette* pPal )
    {
        m_pPalObj = pPal;
    }

    void UpdatePalette();
    BOOL Validate( void );
    void ReadColor( INT32 iX, INT32 iY, INT32 iZ, INT32 iLOD, RDColor& Texel, BOOL &bColorKeyKill );

    inline int GetPitch( DWORD level = 0 )  { return m_iPitch[level]; }
    inline LPBYTE GetBits( DWORD level = 0) { return m_pBits[level]; }
    inline int GetWidth()  { return m_iWidth; }
    inline int GetHeight() { return m_iHeight; }
    inline int GetSamples() { return m_iSamples; }
    HRESULT SetLod( DWORD dwLOD )
    {
        return S_OK;
    }
    inline RDSurfaceFormat GetSurfaceFormat() { return m_SurfFormat; }

    friend class RDRenderTarget;
};

#define RD_STATESET_GROWDELTA      1

#define RRSTATEOVERRIDE_DWORD_BITS      32
#define RRSTATEOVERRIDE_DWORD_SHIFT     5

typedef TemplArray<UINT8> StateSetData;
typedef StateSetData *LPStateSetData;

typedef HRESULT (*PFN_DP2REFOPERATION)(RefDev *pRefDev, LPD3DHAL_DP2COMMAND pCmd);
typedef HRESULT (*PFN_DP2REFOPERATIONUPDATE)(RefDev *pRefDev, LPD3DHAL_DP2COMMAND* ppCmd);
typedef HRESULT (*PFN_DP2REFSETRENDERSTATES)(RefDev *pRefDev,
                                        DWORD dwFvf,
                                        LPD3DHAL_DP2COMMAND pCmd,
                                        LPDWORD lpdwRuntimeRStates);
typedef HRESULT (*PFN_DP2REFTEXTURESTAGESTATE)(RefDev *pRefDev,
                                            DWORD dwFvf,
                                            LPD3DHAL_DP2COMMAND pCmd);
typedef HRESULT (*PFN_DP2REFSETLIGHT)(RefDev *pRefDev,
                                      LPD3DHAL_DP2COMMAND pCmd,
                                      LPDWORD pdwStride);
typedef HRESULT (*PFN_DP2REFSETVERTEXSHADEDCONSTS)
    (RefDev *pRefDev, DWORD StartReg, DWORD dwCount,
                                     LPDWORD pData );
typedef HRESULT (*PFN_DP2REFSETPIXELSHADEDCONSTS)
    (RefDev *pRefDev, DWORD StartReg, DWORD dwCount,
                                     LPDWORD pData );

typedef struct _RD_STATESETFUNCTIONTBL
{
    DWORD                       dwSize;                 // size of struct
    PFN_DP2REFSETRENDERSTATES pfnDp2SetRenderStates;
    PFN_DP2REFTEXTURESTAGESTATE pfnDp2TextureStageState;
    PFN_DP2REFOPERATION pfnDp2SetViewport;
    PFN_DP2REFOPERATION pfnDp2SetWRange;
    PFN_DP2REFOPERATION pfnDp2SetMaterial;
    PFN_DP2REFOPERATION pfnDp2SetZRange;
    PFN_DP2REFSETLIGHT  pfnDp2SetLight;
    PFN_DP2REFOPERATION pfnDp2CreateLight;
    PFN_DP2REFOPERATION pfnDp2SetTransform;
    PFN_DP2REFOPERATION pfnDp2SetExtention;
    PFN_DP2REFOPERATION pfnDp2SetClipPlane;
    PFN_DP2REFOPERATION pfnDp2SetVertexShader;
    PFN_DP2REFSETVERTEXSHADEDCONSTS pfnDp2SetVertexShaderConsts;
    PFN_DP2REFOPERATION pfnDp2SetPixelShader;
    PFN_DP2REFSETPIXELSHADEDCONSTS  pfnDp2SetPixelShaderConsts;
    PFN_DP2REFOPERATION pfnDp2SetStreamSource;
    PFN_DP2REFOPERATION pfnDp2SetIndices;
    PFN_DP2REFOPERATION pfnDp2MultiplyTransform;
} RD_STATESETFUNCTIONTBL, *LPRD_STATESETFUNCTIONTBL;

//
// The device type that the RefDev should emulate
//
typedef enum {
    RDDDI_UNKNOWN = 0,
    RDDDI_OLDHAL  = 1,
    RDDDI_DPHAL,
    RDDDI_DP2HAL,          // DX6 HAL
    RDDDI_DX7HAL,          // DX7 HAL w/out T&L, with state sets
    RDDDI_DX7TLHAL,
    RDDDI_DX8HAL,
    RDDDI_DX8TLHAL,
    RDDDI_FORCE_DWORD = 0xffffffff
} RDDDITYPE;

typedef struct _RRSTATEOVERRIDES
{
    DWORD    bits[D3DSTATE_OVERRIDE_BIAS >> RRSTATEOVERRIDE_DWORD_SHIFT];
} RRSTATEOVERRIDES;

struct RDHOCoeffs
{
    RDHOCoeffs()
    {
        m_pNumSegs = 0;
        for(unsigned i = 0; i < RD_MAX_NUMSTREAMS; m_pData[i++] = 0);
    }
    ~RDHOCoeffs()
    {
        delete[] m_pNumSegs;
        for(unsigned i = 0; i < RD_MAX_NUMSTREAMS; delete[] m_pData[i++]);
    }

    RDHOCoeffs& operator=(const RDHOCoeffs &coeffs);

    UINT           m_Width;
    UINT           m_Height;
    UINT           m_Stride;
    D3DBASISTYPE   m_Basis;
    D3DORDERTYPE   m_Order;
    FLOAT         *m_pNumSegs;
    BYTE          *m_pData[RD_MAX_NUMSTREAMS];
    UINT           m_DataSize[RD_MAX_NUMSTREAMS];
};

//-----------------------------------------------------------------------------
//
// RefDev - Primary object for reference rasterizer.  Each instance
// of this corresponds to a D3D device.
//
// Usage is to instantiate, install RDRenderTarget (and optional RDSurface2D's),
// and set state and draw primitives.
//
//-----------------------------------------------------------------------------
class RefDev : public RDAlloc
{
public:
    friend class RDDebugMonitor;
    friend class RefRast;
    friend class RDPShader;
    ///////////////////////////////////////////////////////////////////////////
    //
    // public interface
    //
    ///////////////////////////////////////////////////////////////////////////
    RDDebugMonitor* m_pDbgMon;

    RefDev( LPDDRAWI_DIRECTDRAW_LCL pDDLcl, DWORD dwInterfaceType,
            RDDDITYPE dwDDIType, D3DCAPS8* pCaps8 );
    ~RefDev( void );
    LPDDRAWI_DIRECTDRAW_LCL GetDDLcl() { return m_pDDLcl; }

    // Methods to get embedded objects
    RefVP&      GetVP()      {  return m_RefVP;  }
    RefVM&      GetVM()      {  return m_RefVM;  }
    RefClipper& GetClipper() { return m_Clipper; }

    RefRast&    GetRast()    { return m_Rast; }

    // DDI methods
    HRESULT DrawPrimitives2( PUINT8 pUMVtx, UINT16 dwStride, DWORD dwFvf,
                             DWORD dwNumVertices, LPD3DHAL_DP2COMMAND *ppCmd,
                             LPDWORD lpdwRStates );

    // Dp2 token handling functions
    HRESULT Dp2RecRenderStates(DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd, LPDWORD lpdwRuntimeRStates);
    HRESULT Dp2RecTextureStageState(DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecViewport(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecWRange(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecMaterial(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecZRange(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecSetLight(LPD3DHAL_DP2COMMAND pCmd, LPDWORD pdwStride);
    HRESULT Dp2RecCreateLight(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecTransform(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecExtention(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecClipPlane(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecSetVertexShader(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecSetVertexShaderConsts(DWORD StartReg, DWORD dwCount,
                                        LPDWORD pData);
    HRESULT Dp2RecSetPixelShader(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecSetPixelShaderConsts(DWORD StartReg, DWORD dwCount,
                                       LPDWORD pData);
    HRESULT Dp2RecSetStreamSource(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2RecSetIndices(LPD3DHAL_DP2COMMAND pCmd);

    HRESULT Dp2SetRenderStates(DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd, LPDWORD lpdwRuntimeRStates);
    HRESULT Dp2SetTextureStageState(DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetViewport(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetWRange(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetMaterial(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetZRange(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetLight(LPD3DHAL_DP2COMMAND pCmd, PDWORD pdwStride);
    HRESULT Dp2CreateLight(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetTransform(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2MultiplyTransform(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetExtention(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetRenderTarget(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetClipPlane(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2DrawPrimitive(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2DrawPrimitive2(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2DrawIndexedPrimitive(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2DrawIndexedPrimitive2(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2DrawClippedTriFan(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2CreateVertexShader(DWORD handle,
                                  DWORD dwDeclSize, LPDWORD pDecl,
                                  DWORD dwCodeSize, LPDWORD pCode);
    HRESULT Dp2DeleteVertexShader(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetVertexShader(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetVertexShaderConsts(DWORD StartReg, DWORD dwCount,
                                     LPDWORD pData);
    HRESULT Dp2SetStreamSource(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetStreamSourceUM(LPD3DHAL_DP2COMMAND pCmd, PUINT8 pUMVtx );
    HRESULT Dp2SetIndices(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2CreatePixelShader(DWORD handle,
                                 DWORD dwCodeSize, LPDWORD pCode);
    HRESULT Dp2DeletePixelShader(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetPixelShader(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2SetPixelShaderConsts(DWORD StartReg, DWORD dwCount,
                                    LPDWORD pData);
    HRESULT Dp2SetPalette(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT Dp2UpdatePalette(LPD3DHAL_DP2UPDATEPALETTE pUP,
                             PALETTEENTRY *pEntries);
    HRESULT Dp2SetTexLod(LPD3DHAL_DP2COMMAND pCmd);

    // StateSet related functions
    void SetRecStateFunctions(void);
    void SetSetStateFunctions(void);
    HRESULT BeginStateSet(DWORD dwHandle);
    HRESULT EndStateSet(void);
    HRESULT ExecuteStateSet(DWORD dwHandle);
    HRESULT DeleteStateSet(DWORD dwHandle);
    HRESULT CaptureStateSet(DWORD dwHandle);
    HRESULT CreateStateSet(DWORD dwHandle, D3DSTATEBLOCKTYPE sbType);
    HRESULT RecordAllState( DWORD dwHandle );
    HRESULT RecordVertexState( DWORD dwHandle );
    HRESULT RecordPixelState( DWORD dwHandle );

    HRESULT RecordStates(PUINT8 pData, DWORD dwSize);
    HRESULT RecordLastState(LPD3DHAL_DP2COMMAND pCmd, DWORD dwUnitSize);

    LPRD_STATESETFUNCTIONTBL pStateSetFuncTbl;

    // Interface style
    BOOL IsInterfaceDX6AndBefore() {return (m_dwInterfaceType <= 2);}
    BOOL IsInterfaceDX7AndBefore() {return (m_dwInterfaceType <= 3);}

    // DriverStyle
    BOOL IsDriverDX6AndBefore()
    {
        return ((m_dwDDIType <= RDDDI_DP2HAL) && (m_dwDDIType > 0));
    }
    BOOL IsDriverDX7AndBefore()
    {
        return ((m_dwDDIType <= RDDDI_DX7TLHAL) && (m_dwDDIType > 0));
    }

    RDDDITYPE GetDDIType()
    {
        return m_dwDDIType;
    }

    // Last Pixel State
    void StoreLastPixelState(BOOL bStore);

    // RenderTarget control
    void SetRenderTarget( RDRenderTarget* pRenderTarget );
    RDRenderTarget* GetRenderTarget( void );

    // state management functions
    void SetRenderState( DWORD dwState, DWORD dwValue );
    void SetTextureStageState( DWORD dwStage, DWORD dwStageState, DWORD dwValue );
    void SceneCapture( DWORD dwFlags );

    // texture management functions
    BOOL TextureCreate  ( LPD3DTEXTUREHANDLE phTex, RDSurface2D** ppTexture );
    BOOL TextureDestroy ( D3DTEXTUREHANDLE hTex );
    DWORD TextureGetSurf( D3DTEXTUREHANDLE hTex );

    // rendering functions
    HRESULT Clear(LPD3DHAL_DP2COMMAND pCmd);
    HRESULT BeginRendering( void );
    HRESULT EndRendering( void  );

    HRESULT UpdateRastState( void );
    DWORD   m_dwRastFlags;  // rasterizer-core specific flags
#define RDRF_MULTISAMPLE_CHANGED        (1L<<0)
#define RDRF_PIXELSHADER_CHANGED        (1L<<1)
#define RDRF_LEGACYPIXELSHADER_CHANGED  (1L<<2)
#define RDRF_TEXTURESTAGESTATE_CHANGED  (1L<<3)


    // Method to convert FVF vertices into the internal RDVertex. Used for
    // TLVertex rendering and legacy driver models.
    void FvfToRDVertex( PUINT8 pVtx, GArrayT<RDVertex>& dstArray, DWORD dwFvf,
                        DWORD dwStride, UINT cVertices );

    // Rasterizer functions
    void DrawPoint( RDVertex* pvV0 );
    void DrawLine( RDVertex* pvV0, RDVertex* pvV1, RDVertex* pvVFlat = NULL );
    void DrawTriangle( RDVertex* pvV0, RDVertex* pvV1, RDVertex* pvV2,
                       WORD wFlags = D3DTRIFLAG_EDGEENABLETRIANGLE );

    HRESULT DrawOnePrimitive( GArrayT<RDVertex>& VtxArray,
                              DWORD dwStartVertex,
                              D3DPRIMITIVETYPE PrimType,
                              UINT cVertices );
    HRESULT DrawOneIndexedPrimitive( GArrayT<RDVertex>& VtxArray,
                                     int StartVertexIndex,
                                     LPWORD pIndices,
                                     DWORD StartIndex,
                                     UINT  cIndices,
                                     D3DPRIMITIVETYPE PrimType );
    HRESULT DrawOneIndexedPrimitive( GArrayT<RDVertex>& VtxArray,
                                     int StartVertexIndex,
                                     LPDWORD pIndices,
                                     DWORD StartIndex,
                                     UINT cIndices,
                                     D3DPRIMITIVETYPE PrimType );
    HRESULT DrawOneEdgeFlagTriangleFan( GArrayT<RDVertex>& VtxArray,
                                        UINT cVertices,
                                        UINT32 dwEdgeFlags );

//
// these are used to facilitate the way refdev is used in the D3D runtime
//
    // functions to manipulate current set of texture
    int GetCurrentTextureMaps( D3DTEXTUREHANDLE* phTex, RDSurface2D** pTex );
    BOOL SetTextureMap( D3DTEXTUREHANDLE hTex, RDSurface2D* pTex );

//
// T&L Hal specific functions
//

    HRESULT ProcessPrimitive( D3DPRIMITIVETYPE primType,
                              DWORD dwStartVertex,// Index of the start vertex
                              DWORD cVertices,
                              DWORD dwStartIndex,
                              DWORD cIndices );
    HRESULT ProcessPrimitiveVVM( D3DPRIMITIVETYPE primType,
                                 DWORD dwStartVertex,
                                 DWORD cVertices,
                                 DWORD dwStartIndex,
                                 DWORD cIndices );
    HRESULT ProcessBSpline( DWORD dwOffW, DWORD dwOffH,
                            DWORD dwWidth, DWORD dwHeight,
                            DWORD dwStride, DWORD order,
                            FLOAT *pPrimSegments);
    HRESULT ProcessBezier ( DWORD dwOffW, DWORD dwOffH,
                            DWORD dwWidth, DWORD dwHeight,
                            DWORD dwStride, DWORD order,
                            FLOAT *pPrimSegments,
                            bool bDegenerate );
    HRESULT ProcessCatRomSpline ( DWORD dwOffW, DWORD dwOffH,
                                  DWORD dwWidth, DWORD dwHeight,
                                  DWORD dwStride,
                                  FLOAT *pPrimSegments);
    HRESULT ProcessTessPrimitive( LPD3DHAL_DP2DRAWPRIMITIVE pDP );
    HRESULT ProcessTessIndexedPrimitive( LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE pDP );
    HRESULT DrawTessQuad( const RDBSpline &Surf, DWORD dwOffW, DWORD dwOffH, DWORD dwStride,
                          const unsigned *m, const unsigned *n,
                          double u0, double v0, double u1, double v1,
                          double tu0, double tv0, double tu1, double tv1,
                          bool bDegenerate );
    HRESULT DrawTessTri( const RDBSpline &Surf, DWORD dwOffW, DWORD dwOffH, DWORD dwStride,
                         const unsigned *m, const unsigned *n,
                         double u0, double v0, double u1, double v1, double u2, double v2,
                         double tu0, double tv0, double tu1, double tv1, double tu2, double tv2,
                         bool bDegenerate0, bool bDegenerate1, bool bDegenerate2 );
    HRESULT DrawNPatch( const RDNPatch &Patch, DWORD dwStride,
                        const unsigned *m, const unsigned *n, unsigned segs );

    HRESULT ConvertLinearTriBezierToRectBezier(DWORD dwDataType, const BYTE *B, DWORD dwStride, BYTE *Q);
    HRESULT ConvertCubicTriBezierToRectBezier(DWORD dwDataType, const BYTE *B, DWORD dwStride, BYTE *Q);
    HRESULT ConvertQuinticTriBezierToRectBezier(DWORD dwDataType, const BYTE *B, DWORD dwStride, BYTE *Q);

    HRESULT SetupStrides();
    HRESULT UpdateTLState();
    HRESULT UpdateClipper();

    HRESULT DrawDX8Prim(  LPD3DHAL_DP2DRAWPRIMITIVE pDP );
    HRESULT DrawDX8Prim2(  LPD3DHAL_DP2DRAWPRIMITIVE2 pDP );
    HRESULT DrawRectPatch(  LPD3DHAL_DP2DRAWRECTPATCH pDP );
    HRESULT DrawTriPatch(  LPD3DHAL_DP2DRAWTRIPATCH pDP );
    HRESULT DrawDX8IndexedPrim( LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE pDIP );
    HRESULT DrawDX8IndexedPrim2( LPD3DHAL_DP2DRAWINDEXEDPRIMITIVE2 pDIP );
    HRESULT DrawDX8ClippedTriFan( LPD3DHAL_CLIPPEDTRIANGLEFAN pDIP );

    inline RDVStream& GetVStream( DWORD index )
    {
        return m_VStream[index];
    }

    inline HRESULT GrowTLVArray( DWORD dwNumVerts )
    {
        return m_TLVArray.Grow( dwNumVerts );
    }

    inline GArrayT<RDVertex>& GetTLVArray()
    {
        return m_TLVArray;
    }

private:
    ///////////////////////////////////////////////////////////////////////////
    //
    // internal state and methods
    //
    ///////////////////////////////////////////////////////////////////////////

    //-------------------------------------------------------------------------
    // Embedded Objects
    //-------------------------------------------------------------------------
    RefVP       m_RefVP;          // The fixed function T&L object
    RefVM       m_RefVM;          // The programmable vertex machine object
    RefClipper  m_Clipper;        // Clipper object

    RefRast     m_Rast;           // Rasterizer object

    //-------------------------------------------------------------------------
    // state
    //-------------------------------------------------------------------------

    // Caps struct, potentially modified from static caps settings.  Ref code
    //  will behave according to settings of some of the caps in this struct.
    D3DCAPS8    m_Caps8;

    // DDraw Local, needed for the new texture handles from DX7 onwards
    LPDDRAWI_DIRECTDRAW_LCL m_pDDLcl;

    // This is obtained from CONTEXTCREATE->ddrval, indicates
    // what kind of emulation (DX3, DX5, DX6 or DX7) the driver should do.
    RDDDITYPE       m_dwDDIType;

    // This is obtained from CONTEXTCREATE->dwhContext, indicates
    // which D3D Device interface called the driver.
    DWORD           m_dwInterfaceType;

    // save area for floating point unit control
    WORD            m_wSaveFP;

    // TRUE if in begin/end primitive sequence
    BOOL            m_bInBegin;

    // TRUE if in rendering point sprite triangles
    BOOL            m_bPointSprite;

    // render target (color & Z buffer)
    RDRenderTarget* m_pRenderTarget;
    FLOAT           m_fWBufferNorm[2]; // { Wnear, 1/(Wfar-Wnear) } to normalize W buffer value

    // D3D renderstate
    union
    {
        DWORD       m_dwRenderState[D3DHAL_MAX_RSTATES];
        FLOAT       m_fRenderState[D3DHAL_MAX_RSTATES];
    };

    // State Override flags
    RRSTATEOVERRIDES m_renderstate_override;

    // Palette handles
    GArrayT<RDPaletteHandle> m_PaletteHandleArray;

    // texture state - per-stage state and pointer to associated texture
    int                 m_cActiveTextureStages; // count of active texture stages (range 0..D3DHAL_TSS_MAXSTAGES)
    DWORD               m_ReferencedTexCoordMask; // which texture coordinate sets are referenced
    RDSurface2D*        m_pTexture[D3DHAL_TSS_MAXSTAGES];  //  texture maps associated with texture stages
    union
    {
        DWORD   m_dwTextureStageState[D3DHAL_TSS_MAXSTAGES][D3DTSS_MAX]; // state array (unsigned)
        FLOAT   m_fTextureStageState[D3DHAL_TSS_MAXSTAGES][D3DTSS_MAX];  // state array (float)
        RDTextureStageState m_TextureStageState[D3DHAL_TSS_MAXSTAGES];
    };
    DWORD*  m_pTextureStageState[D3DHAL_TSS_MAXSTAGES]; // to speed GetTSS

    BOOL                m_bOverrideTCI;
    DWORD               m_dwTexArrayLength;

    // Vertex and Index streams
    // The extra VStream is for the Tesselator generated data.
    RDVStream                m_VStream[RD_MAX_NUMSTREAMS + 1];
    RDIStream                m_IndexStream;

    // Buffer to store transformed vertices
    GArrayT<RDVertex>        m_TLVArray;

    // Vertex shader state
    GArrayT<RDVShaderHandle> m_VShaderHandleArray;
    RDVShader                m_FVFShader; // Declaration for the legacy (FVF)
                                          // shader
    DWORD                    m_CurrentVShaderHandle;
    RDVShader*               m_pCurrentVShader;
    UINT64                   m_qwFVFOut;  // Desired FVF for the output
                                          // vertices

    // Coefficient storage for HOS
    GArrayT<RDHOCoeffs>      m_HOSCoeffs;

    // Primitive information
    D3DPRIMITIVETYPE m_primType;      // Current primitive being drawn
    DWORD            m_dwNumVertices; // Number of vertices to process
    DWORD            m_dwStartVertex;
    DWORD            m_dwNumIndices;
    DWORD            m_dwStartIndex;

    // Last state
    DWORD m_LastState;

    // Array of StateSets, which are in turn implemented with TemplArray as
    // TemplArray<UINT8> StateSetData
    TemplArray<LPStateSetData> m_pStateSets;

    // pixel shader state
    DWORD                    m_CurrentPShaderHandle;
    GArrayT<RDPShaderHandle> m_PShaderHandleArray;

    // Buffer used to process clear rects
    GArrayT<BYTE>            m_ClearRectBuffer;

    //-------------------------------------------------------------------------
    // methods
    //-------------------------------------------------------------------------

// refrasti.cpp
    HRESULT GrowTexArray( DWORD dwHandle );
    HRESULT SetTextureHandle( int iStage, DWORD dwHandle );
    void MapTextureHandleToDevice( int iStage );
    void UpdateActiveTexStageCount( void );
    RDSurface2D* MapHandleToTexture( D3DTEXTUREHANDLE hTex );

// MapLegcy.cpp
    void MapLegacyTextureBlend( void );
    void MapLegacyTextureFilter( void );

// primfns.cpp
    HRESULT GrowLightArray(const DWORD dwIndex);

    // pixel shader handle manipulation
    inline RDPShader* GetPShader( DWORD dwHandle )
    {
        if( m_PShaderHandleArray.IsValidIndex( dwHandle ) )
            return m_PShaderHandleArray[dwHandle].m_pShader;
        return NULL;
    }

// drawgrid.cpp
    HRESULT LinkTessellatorOutput();
    HRESULT LinkCachedTessellatorOutput(DWORD Handle, BYTE **pTempData);
    void UnlinkTessellatorOutput();
    void UnlinkCachedTessellatorOutput(BYTE **pTempData);

public:
    ///////////////////////////////////////////////////////////////////////////
    //
    // methods used by refdev objects to get at device state
    //
    ///////////////////////////////////////////////////////////////////////////
    inline DWORD* GetRS( void ) { return m_dwRenderState; }
    inline FLOAT* GetRSf( void ) { return m_fRenderState; }
    inline DWORD* GetTSS( DWORD Stage ) { return m_pTextureStageState[Stage]; }
    inline FLOAT* GetTSSf( DWORD Stage ) { return (FLOAT*)m_pTextureStageState[Stage]; }
    inline BOOL ColorKeyEnabled( void )
    {
        return
            m_dwRenderState[D3DRENDERSTATE_COLORKEYENABLE] ||
            m_dwRenderState[D3DRENDERSTATE_COLORKEYBLENDENABLE];
    }

    inline D3DCAPS8* GetCaps8( void ) { return &m_Caps8; }
};

//-------------------------------------------------------------------------
// DXTn compressed texture formats
//-------------------------------------------------------------------------
// number of DXT compression formats
#define NUM_DXT_FORMATS    5
// number of pixels in block
#define DXT_BLOCK_PIXELS   16

// DXT block size array
extern int g_DXTBlkSize[];

typedef struct  {
    BYTE    rgba[4];
} DXT_COLOR;

typedef WORD        RGB565;     // packed color
typedef DWORD       PIXBM;      // 2 BPP bitmap


typedef struct  {
    RGB565      rgb0;       // color for index 0
    RGB565      rgb1;       // color for index 1
    PIXBM       pixbm;      // pixel bitmap
} DXTBlockRGB;

typedef struct  {
    WORD        alphabm[4]; // alpha bitmap at 4 BPP
    DXTBlockRGB    rgb;        // color block
} DXTBlockAlpha4;

typedef struct  {
    BYTE        alpha0;     // alpha for index 0
    BYTE        alpha1;     // alpha for index 1
    BYTE        alphabm[6]; // alpha bitmap at 3 BPP
    DXTBlockRGB    rgb;        // color block
} DXTBlockAlpha3;

void DecodeBlockRGB (DXTBlockRGB *pblockSrc,
                     DXT_COLOR colorDst[DXT_BLOCK_PIXELS]);
void DecodeBlockAlpha4(DXTBlockAlpha4 *pblockSrc,
                       DXT_COLOR colorDst[DXT_BLOCK_PIXELS]);
void DecodeBlockAlpha3(DXTBlockAlpha3 *pblockSrc,
                       DXT_COLOR colorDst[DXT_BLOCK_PIXELS]);

///////////////////////////////////////////////////////////////////////////////
#endif // _REFDEV_HPP