#ifndef _D3DTYPES_H
#define _D3DTYPES_H

/* Direct3D type definitions */

#include <windows.h>

#include <float.h>
#include "ddraw.h"

#ifndef DIRECT3D_VERSION
#define DIRECT3D_VERSION  0x0700
#endif

#if (DIRECT3D_VERSION >= 0x0800)
#pragma message("should not include d3dtypes.h when compiling for DX8 or newer interfaces")
#endif

#include <pshpack4.h>

#if __POCC__ >= 290
#pragma warn(push)
#pragma warn(disable:2198)  /* Nameless field is not standard */
#endif

#ifndef DX_SHARED_DEFINES
typedef float D3DVALUE, *LPD3DVALUE;
#endif

typedef LONG D3DFIXED;

#define D3DVALP(val,prec)  ((float)(val))
#define D3DVAL(val)  ((float)(val))
#define D3DDivide(a,b)  (float)((double)(a)/(double)(b))
#define D3DMultiply(a,b)  ((a)*(b))

#ifndef RGB_MAKE
#define CI_GETALPHA(ci)  ((ci)>>24)
#define CI_GETINDEX(ci)  (((ci)>>8)&0xFFFF)
#define CI_GETFRACTION(ci) ((ci) & 0xFF)
#define CI_ROUNDINDEX(ci)  CI_GETINDEX((ci)+0x80)
#define CI_MASKALPHA(ci)  ((ci)&0xFFFFFF)
#define CI_MAKE(a,i,f)  (((a)<<24)|((i)<<8)|(f))

#define RGBA_GETALPHA(rgb)  ((rgb)>>24)
#define RGBA_GETRED(rgb)  (((rgb)>>16)&0xFF)
#define RGBA_GETGREEN(rgb)  (((rgb)>>8)&0xFF)
#define RGBA_GETBLUE(rgb)  ((rgb)&0xFF)
#define RGBA_MAKE(r,g,b,a)  ((D3DCOLOR)(((a)<<24)|((r)<<16)|((g)<<8)|(b)))

#define D3DRGB(r,g,b)  (0xFF000000L|(((long)((r)*255))<<16)|(((long)((g)*255))<<8)|(long)((b)*255))
#define D3DRGBA(r,g,b,a)  ((((long)((a)*255))<<24)|(((long)((r)*255))<<16)|(((long)((g)*255))<<8)|(long)((b)*255))

#define RGB_GETRED(rgb)  (((rgb)>>16)&0xFF)
#define RGB_GETGREEN(rgb)  (((rgb)>>8)&0xFF)
#define RGB_GETBLUE(rgb)  ((rgb)&0xFF)
#define RGBA_SETALPHA(rgba,x)  (((x)<<24)|((rgba)&0x00FFFFFF))
#define RGB_MAKE(r,g,b)  ((D3DCOLOR)(((r)<<16)|((g)<<8)|(b)))
#define RGBA_TORGB(rgba)  ((D3DCOLOR)((rgba)&0xFFFFFF))
#define RGB_TORGBA(rgb)  ((D3DCOLOR)((rgb)|0xFF000000))
#endif /* RGB_MAKE */

#define D3DENUMRET_CANCEL  DDENUMRET_CANCEL
#define D3DENUMRET_OK  DDENUMRET_OK

typedef HRESULT (CALLBACK* LPD3DVALIDATECALLBACK)(LPVOID,DWORD);
typedef HRESULT (CALLBACK* LPD3DENUMTEXTUREFORMATSCALLBACK)(LPDDSURFACEDESC,LPVOID);
typedef HRESULT (CALLBACK* LPD3DENUMPIXELFORMATSCALLBACK)(LPDDPIXELFORMAT,LPVOID);

#ifndef DX_SHARED_DEFINES
#ifndef D3DCOLOR_DEFINED
typedef DWORD D3DCOLOR;
#define D3DCOLOR_DEFINED
#endif
#endif

#ifndef LPD3DCOLOR_DEFINED
typedef DWORD *LPD3DCOLOR;
#define LPD3DCOLOR_DEFINED
#endif

typedef DWORD D3DMATERIALHANDLE, *LPD3DMATERIALHANDLE;
typedef DWORD D3DTEXTUREHANDLE, *LPD3DTEXTUREHANDLE;
typedef DWORD D3DMATRIXHANDLE, *LPD3DMATRIXHANDLE;

typedef struct _D3DCOLORVALUE {
    union {
        D3DVALUE r;
        D3DVALUE dvR;
    };
    union {
        D3DVALUE g;
        D3DVALUE dvG;
    };
    union {
        D3DVALUE b;
        D3DVALUE dvB;
    };
    union {
        D3DVALUE a;
        D3DVALUE dvA;
    };
} D3DCOLORVALUE, *LPD3DCOLORVALUE;

typedef struct _D3DRECT {
    union {
        LONG x1;
        LONG lX1;
    };
    union {
        LONG y1;
        LONG lY1;
    };
    union {
        LONG x2;
        LONG lX2;
    };
    union {
        LONG y2;
        LONG lY2;
    };
} D3DRECT, *LPD3DRECT;

#ifndef DX_SHARED_DEFINES

#ifndef D3DVECTOR_DEFINED
typedef struct _D3DVECTOR {
    union {
        D3DVALUE x;
        D3DVALUE dvX;
    };
    union {
        D3DVALUE y;
        D3DVALUE dvY;
    };
    union {
        D3DVALUE z;
        D3DVALUE dvZ;
    };
#if (DIRECT3D_VERSION >= 0x0500)
#if (defined __cplusplus) && (defined D3D_OVERLOADS)

public:
    _D3DVECTOR() {}
    _D3DVECTOR(D3DVALUE f);
    _D3DVECTOR(D3DVALUE _x, D3DVALUE _y, D3DVALUE _z);
    _D3DVECTOR(const D3DVALUE f[3]);

    const D3DVALUE&operator[](int i) const;
    D3DVALUE&operator[](int i);

    _D3DVECTOR& operator += (const _D3DVECTOR& v);
    _D3DVECTOR& operator -= (const _D3DVECTOR& v);
    _D3DVECTOR& operator *= (const _D3DVECTOR& v);
    _D3DVECTOR& operator /= (const _D3DVECTOR& v);
    _D3DVECTOR& operator *= (D3DVALUE s);
    _D3DVECTOR& operator /= (D3DVALUE s);

    friend _D3DVECTOR operator + (const _D3DVECTOR& v);
    friend _D3DVECTOR operator - (const _D3DVECTOR& v);

    friend _D3DVECTOR operator + (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend _D3DVECTOR operator - (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend _D3DVECTOR operator * (const _D3DVECTOR& v, D3DVALUE s);
    friend _D3DVECTOR operator * (D3DVALUE s, const _D3DVECTOR& v);
    friend _D3DVECTOR operator / (const _D3DVECTOR& v, D3DVALUE s);
    friend _D3DVECTOR operator * (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend _D3DVECTOR operator / (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend int operator < (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend int operator <= (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend int operator == (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend D3DVALUE SquareMagnitude (const _D3DVECTOR& v);
    friend D3DVALUE Magnitude (const _D3DVECTOR& v);
    friend _D3DVECTOR Normalize (const _D3DVECTOR& v);
    friend D3DVALUE Min (const _D3DVECTOR& v);
    friend D3DVALUE Max (const _D3DVECTOR& v);
    friend _D3DVECTOR Minimize (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend _D3DVECTOR Maximize (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend D3DVALUE DotProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
    friend _D3DVECTOR CrossProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
#endif
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DVECTOR, *LPD3DVECTOR;
#define D3DVECTOR_DEFINED
#endif /* D3DVECTOR_DEFINED */

#define DX_SHARED_DEFINES
#endif /* DX_SHARED_DEFINES */

typedef struct _D3DHVERTEX {
    DWORD dwFlags;
    union {
        D3DVALUE hx;
        D3DVALUE dvHX;
    };
    union {
        D3DVALUE hy;
        D3DVALUE dvHY;
    };
    union {
        D3DVALUE hz;
        D3DVALUE dvHZ;
    };
} D3DHVERTEX, *LPD3DHVERTEX;

typedef struct _D3DTLVERTEX {
    union {
        D3DVALUE sx;
        D3DVALUE dvSX;
    };
    union {
        D3DVALUE sy;
        D3DVALUE dvSY;
    };
    union {
        D3DVALUE sz;
        D3DVALUE dvSZ;
    };
    union {
        D3DVALUE rhw;
        D3DVALUE dvRHW;
    };
    union {
        D3DCOLOR color;
        D3DCOLOR dcColor;
    };
    union {
        D3DCOLOR specular;
        D3DCOLOR dcSpecular;
    };
    union {
        D3DVALUE tu;
        D3DVALUE dvTU;
    };
    union {
        D3DVALUE tv;
        D3DVALUE dvTV;
    };
#if (DIRECT3D_VERSION >= 0x0500)
#if (defined __cplusplus) && (defined D3D_OVERLOADS)
    _D3DTLVERTEX() {}
    _D3DTLVERTEX(const D3DVECTOR& v, float _rhw, D3DCOLOR _color, D3DCOLOR _specular, float _tu, float _tv)
    { sx = v.x; sy = v.y; sz = v.z; rhw = _rhw; color = _color; specular = _specular; tu = _tu; tv = _tv; }
#endif
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DTLVERTEX, *LPD3DTLVERTEX;

typedef struct _D3DLVERTEX {
    union {
        D3DVALUE x;
        D3DVALUE dvX;
    };
    union {
        D3DVALUE y;
        D3DVALUE dvY;
    };
    union {
        D3DVALUE z;
        D3DVALUE dvZ;
    };
    DWORD dwReserved;
    union {
        D3DCOLOR color;
        D3DCOLOR dcColor;
    };
    union {
        D3DCOLOR specular;
        D3DCOLOR dcSpecular;
    };
    union {
        D3DVALUE tu;
        D3DVALUE dvTU;
    };
    union {
        D3DVALUE tv;
        D3DVALUE dvTV;
    };
#if (DIRECT3D_VERSION >= 0x0500)
#if (defined __cplusplus) && (defined D3D_OVERLOADS)
    _D3DLVERTEX() {}
    _D3DLVERTEX(const D3DVECTOR& v, D3DCOLOR _color, D3DCOLOR _specular, float _tu, float _tv)
        { x = v.x; y = v.y; z = v.z; dwReserved = 0; color = _color; specular = _specular; tu = _tu; tv = _tv; }
#endif
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DLVERTEX, *LPD3DLVERTEX;

typedef struct _D3DVERTEX {
    union {
        D3DVALUE x;
        D3DVALUE dvX;
    };
    union {
        D3DVALUE y;
        D3DVALUE dvY;
    };
    union {
        D3DVALUE z;
        D3DVALUE dvZ;
    };
    union {
        D3DVALUE nx;
        D3DVALUE dvNX;
    };
    union {
        D3DVALUE ny;
        D3DVALUE dvNY;
    };
    union {
        D3DVALUE nz;
        D3DVALUE dvNZ;
    };
    union {
        D3DVALUE tu;
        D3DVALUE dvTU;
    };
    union {
        D3DVALUE tv;
        D3DVALUE dvTV;
    };
#if (DIRECT3D_VERSION >= 0x0500)
#if (defined __cplusplus) && (defined D3D_OVERLOADS)
    _D3DVERTEX() {}
    _D3DVERTEX(const D3DVECTOR& v, const D3DVECTOR& n, float _tu, float _tv)
        { x = v.x; y = v.y; z = v.z; nx = n.x; ny = n.y; nz = n.z; tu = _tu; tv = _tv; }
#endif
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DVERTEX, *LPD3DVERTEX;

typedef struct _D3DMATRIX {
#if (DIRECT3D_VERSION >= 0x0500)
#if (defined __cplusplus) && (defined D3D_OVERLOADS)
    union {
        struct {
#endif
#endif /* DIRECT3D_VERSION >= 0x0500 */
            D3DVALUE _11, _12, _13, _14;
            D3DVALUE _21, _22, _23, _24;
            D3DVALUE _31, _32, _33, _34;
            D3DVALUE _41, _42, _43, _44;
#if (DIRECT3D_VERSION >= 0x0500)
#if (defined __cplusplus) && (defined D3D_OVERLOADS)
        };
        D3DVALUE m[4][4];
    };
    _D3DMATRIX() {}
    _D3DMATRIX(D3DVALUE _m00, D3DVALUE _m01, D3DVALUE _m02, D3DVALUE _m03, D3DVALUE _m10, D3DVALUE _m11, D3DVALUE _m12, D3DVALUE _m13,
               D3DVALUE _m20, D3DVALUE _m21, D3DVALUE _m22, D3DVALUE _m23, D3DVALUE _m30, D3DVALUE _m31, D3DVALUE _m32, D3DVALUE _m33)
    {
        m[0][0] = _m00; m[0][1] = _m01; m[0][2] = _m02; m[0][3] = _m03;
        m[1][0] = _m10; m[1][1] = _m11; m[1][2] = _m12; m[1][3] = _m13;
        m[2][0] = _m20; m[2][1] = _m21; m[2][2] = _m22; m[2][3] = _m23;
        m[3][0] = _m30; m[3][1] = _m31; m[3][2] = _m32; m[3][3] = _m33;
    }

    D3DVALUE& operator()(int iRow, int iColumn) { return m[iRow][iColumn]; }
    const D3DVALUE& operator()(int iRow, int iColumn) const { return m[iRow][iColumn]; }
#if(DIRECT3D_VERSION >= 0x0600)
    friend _D3DMATRIX operator* (const _D3DMATRIX&, const _D3DMATRIX&);
#endif /* DIRECT3D_VERSION >= 0x0600 */
#endif
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DMATRIX, *LPD3DMATRIX;

#if (defined __cplusplus) && (defined D3D_OVERLOADS)
#error D3DVEC.INL missing...
/* #include "d3dvec.inl" */
#endif

typedef struct _D3DVIEWPORT {
    DWORD dwSize;
    DWORD dwX;
    DWORD dwY;
    DWORD dwWidth;
    DWORD dwHeight;
    D3DVALUE dvScaleX;
    D3DVALUE dvScaleY;
    D3DVALUE dvMaxX;
    D3DVALUE dvMaxY;
    D3DVALUE dvMinZ;
    D3DVALUE dvMaxZ;
} D3DVIEWPORT, *LPD3DVIEWPORT;

#if (DIRECT3D_VERSION >= 0x0500)
typedef struct _D3DVIEWPORT2 {
    DWORD dwSize;
    DWORD dwX;
    DWORD dwY;
    DWORD dwWidth;
    DWORD dwHeight;
    D3DVALUE dvClipX;
    D3DVALUE dvClipY;
    D3DVALUE dvClipWidth;
    D3DVALUE dvClipHeight;
    D3DVALUE dvMinZ;
    D3DVALUE dvMaxZ;
} D3DVIEWPORT2, *LPD3DVIEWPORT2;
#endif /* DIRECT3D_VERSION >= 0x0500 */

#if (DIRECT3D_VERSION >= 0x0700)
typedef struct _D3DVIEWPORT7 {
    DWORD dwX;
    DWORD dwY;
    DWORD dwWidth;
    DWORD dwHeight;
    D3DVALUE dvMinZ;
    D3DVALUE dvMaxZ;
} D3DVIEWPORT7, *LPD3DVIEWPORT7;
#endif /* DIRECT3D_VERSION >= 0x0700 */

#if (DIRECT3D_VERSION >= 0x0700)
#define D3DMAXUSERCLIPPLANES  32

#define D3DCLIPPLANE0  (1<<0)
#define D3DCLIPPLANE1  (1<<1)
#define D3DCLIPPLANE2  (1<<2)
#define D3DCLIPPLANE3  (1<<3)
#define D3DCLIPPLANE4  (1<<4)
#define D3DCLIPPLANE5  (1<<5)
#endif /* DIRECT3D_VERSION >= 0x0700 */

#define D3DCLIP_LEFT  0x00000001L
#define D3DCLIP_RIGHT  0x00000002L
#define D3DCLIP_TOP  0x00000004L
#define D3DCLIP_BOTTOM  0x00000008L
#define D3DCLIP_FRONT  0x00000010L
#define D3DCLIP_BACK  0x00000020L
#define D3DCLIP_GEN0  0x00000040L
#define D3DCLIP_GEN1  0x00000080L
#define D3DCLIP_GEN2  0x00000100L
#define D3DCLIP_GEN3  0x00000200L
#define D3DCLIP_GEN4  0x00000400L
#define D3DCLIP_GEN5  0x00000800L

#define D3DSTATUS_CLIPUNIONLEFT  D3DCLIP_LEFT
#define D3DSTATUS_CLIPUNIONRIGHT  D3DCLIP_RIGHT
#define D3DSTATUS_CLIPUNIONTOP  D3DCLIP_TOP
#define D3DSTATUS_CLIPUNIONBOTTOM  D3DCLIP_BOTTOM
#define D3DSTATUS_CLIPUNIONFRONT  D3DCLIP_FRONT
#define D3DSTATUS_CLIPUNIONBACK  D3DCLIP_BACK
#define D3DSTATUS_CLIPUNIONGEN0  D3DCLIP_GEN0
#define D3DSTATUS_CLIPUNIONGEN1  D3DCLIP_GEN1
#define D3DSTATUS_CLIPUNIONGEN2  D3DCLIP_GEN2
#define D3DSTATUS_CLIPUNIONGEN3  D3DCLIP_GEN3
#define D3DSTATUS_CLIPUNIONGEN4  D3DCLIP_GEN4
#define D3DSTATUS_CLIPUNIONGEN5  D3DCLIP_GEN5

#define D3DSTATUS_CLIPINTERSECTIONLEFT  0x00001000L
#define D3DSTATUS_CLIPINTERSECTIONRIGHT  0x00002000L
#define D3DSTATUS_CLIPINTERSECTIONTOP  0x00004000L
#define D3DSTATUS_CLIPINTERSECTIONBOTTOM  0x00008000L
#define D3DSTATUS_CLIPINTERSECTIONFRONT  0x00010000L
#define D3DSTATUS_CLIPINTERSECTIONBACK  0x00020000L
#define D3DSTATUS_CLIPINTERSECTIONGEN0  0x00040000L
#define D3DSTATUS_CLIPINTERSECTIONGEN1  0x00080000L
#define D3DSTATUS_CLIPINTERSECTIONGEN2  0x00100000L
#define D3DSTATUS_CLIPINTERSECTIONGEN3  0x00200000L
#define D3DSTATUS_CLIPINTERSECTIONGEN4  0x00400000L
#define D3DSTATUS_CLIPINTERSECTIONGEN5  0x00800000L
#define D3DSTATUS_ZNOTVISIBLE  0x01000000L

#define D3DSTATUS_CLIPUNIONALL  (D3DSTATUS_CLIPUNIONLEFT|D3DSTATUS_CLIPUNIONRIGHT|D3DSTATUS_CLIPUNIONTOP|D3DSTATUS_CLIPUNIONBOTTOM|D3DSTATUS_CLIPUNIONFRONT|D3DSTATUS_CLIPUNIONBACK|D3DSTATUS_CLIPUNIONGEN0|D3DSTATUS_CLIPUNIONGEN1|D3DSTATUS_CLIPUNIONGEN2|D3DSTATUS_CLIPUNIONGEN3|D3DSTATUS_CLIPUNIONGEN4|D3DSTATUS_CLIPUNIONGEN5)
#define D3DSTATUS_CLIPINTERSECTIONALL  (D3DSTATUS_CLIPINTERSECTIONLEFT|D3DSTATUS_CLIPINTERSECTIONRIGHT|D3DSTATUS_CLIPINTERSECTIONTOP|D3DSTATUS_CLIPINTERSECTIONBOTTOM|D3DSTATUS_CLIPINTERSECTIONFRONT|D3DSTATUS_CLIPINTERSECTIONBACK|D3DSTATUS_CLIPINTERSECTIONGEN0|D3DSTATUS_CLIPINTERSECTIONGEN1|D3DSTATUS_CLIPINTERSECTIONGEN2|D3DSTATUS_CLIPINTERSECTIONGEN3|D3DSTATUS_CLIPINTERSECTIONGEN4|D3DSTATUS_CLIPINTERSECTIONGEN5)
#define D3DSTATUS_DEFAULT  (D3DSTATUS_CLIPINTERSECTIONALL|D3DSTATUS_ZNOTVISIBLE)

#define D3DTRANSFORM_CLIPPED  0x00000001L
#define D3DTRANSFORM_UNCLIPPED  0x00000002L

typedef struct _D3DTRANSFORMDATA {
    DWORD dwSize;
    LPVOID lpIn;
    DWORD dwInSize;
    LPVOID lpOut;
    DWORD dwOutSize;
    LPD3DHVERTEX lpHOut;
    DWORD dwClip;
    DWORD dwClipIntersection;
    DWORD dwClipUnion;
    D3DRECT drExtent;
} D3DTRANSFORMDATA, *LPD3DTRANSFORMDATA;

typedef struct _D3DLIGHTINGELEMENT {
    D3DVECTOR dvPosition;
    D3DVECTOR dvNormal;
} D3DLIGHTINGELEMENT, *LPD3DLIGHTINGELEMENT;

typedef struct _D3DMATERIAL {
    DWORD dwSize;
    union {
        D3DCOLORVALUE diffuse;
        D3DCOLORVALUE dcvDiffuse;
    };
    union {
        D3DCOLORVALUE ambient;
        D3DCOLORVALUE dcvAmbient;
    };
    union {
        D3DCOLORVALUE specular;
        D3DCOLORVALUE dcvSpecular;
    };
    union {
        D3DCOLORVALUE emissive;
        D3DCOLORVALUE dcvEmissive;
    };
    union {
        D3DVALUE power;
        D3DVALUE dvPower;
    };
    D3DTEXTUREHANDLE hTexture;
    DWORD dwRampSize;
} D3DMATERIAL, *LPD3DMATERIAL;

#if (DIRECT3D_VERSION >= 0x0700)
typedef struct _D3DMATERIAL7 {
    union {
        D3DCOLORVALUE diffuse;
        D3DCOLORVALUE dcvDiffuse;
    };
    union {
        D3DCOLORVALUE ambient;
        D3DCOLORVALUE dcvAmbient;
    };
    union {
        D3DCOLORVALUE specular;
        D3DCOLORVALUE dcvSpecular;
    };
    union {
        D3DCOLORVALUE emissive;
        D3DCOLORVALUE dcvEmissive;
    };
    union {
        D3DVALUE power;
        D3DVALUE dvPower;
    };
} D3DMATERIAL7, *LPD3DMATERIAL7;
#endif /* DIRECT3D_VERSION >= 0x0700 */

typedef enum _D3DLIGHTTYPE {
    D3DLIGHT_POINT = 1,
    D3DLIGHT_SPOT = 2,
    D3DLIGHT_DIRECTIONAL = 3,
    D3DLIGHT_PARALLELPOINT = 4,
#if (DIRECT3D_VERSION < 0x0500)
    D3DLIGHT_GLSPOT = 5,
#endif
    D3DLIGHT_FORCE_DWORD = 0x7FFFFFFF,
} D3DLIGHTTYPE;

typedef struct _D3DLIGHT {
    DWORD dwSize;
    D3DLIGHTTYPE dltType;
    D3DCOLORVALUE dcvColor;
    D3DVECTOR dvPosition;
    D3DVECTOR dvDirection;
    D3DVALUE dvRange;
    D3DVALUE dvFalloff;
    D3DVALUE dvAttenuation0;
    D3DVALUE dvAttenuation1;
    D3DVALUE dvAttenuation2;
    D3DVALUE dvTheta;
    D3DVALUE dvPhi;
} D3DLIGHT, *LPD3DLIGHT;

#if (DIRECT3D_VERSION >= 0x0700)
typedef struct _D3DLIGHT7 {
    D3DLIGHTTYPE dltType;
    D3DCOLORVALUE dcvDiffuse;
    D3DCOLORVALUE dcvSpecular;
    D3DCOLORVALUE dcvAmbient;
    D3DVECTOR dvPosition;
    D3DVECTOR dvDirection;
    D3DVALUE dvRange;
    D3DVALUE dvFalloff;
    D3DVALUE dvAttenuation0;
    D3DVALUE dvAttenuation1;
    D3DVALUE dvAttenuation2;
    D3DVALUE dvTheta;
    D3DVALUE dvPhi;
} D3DLIGHT7, *LPD3DLIGHT7;
#endif /* DIRECT3D_VERSION >= 0x0700 */

#if (DIRECT3D_VERSION >= 0x0500)
#define D3DLIGHT_ACTIVE  0x00000001
#define D3DLIGHT_NO_SPECULAR  0x00000002
#define D3DLIGHT_ALL  (D3DLIGHT_ACTIVE|D3DLIGHT_NO_SPECULAR)
#define D3DLIGHT_RANGE_MAX  ((float)sqrt(FLT_MAX))

typedef struct _D3DLIGHT2 {
    DWORD dwSize;
    D3DLIGHTTYPE dltType;
    D3DCOLORVALUE dcvColor;
    D3DVECTOR dvPosition;
    D3DVECTOR dvDirection;
    D3DVALUE dvRange;
    D3DVALUE dvFalloff;
    D3DVALUE dvAttenuation0;
    D3DVALUE dvAttenuation1;
    D3DVALUE dvAttenuation2;
    D3DVALUE dvTheta;
    D3DVALUE dvPhi;
    DWORD dwFlags;
} D3DLIGHT2, *LPD3DLIGHT2;
#endif /* DIRECT3D_VERSION >= 0x0500 */

typedef struct _D3DLIGHTDATA {
    DWORD dwSize;
    LPD3DLIGHTINGELEMENT lpIn;
    DWORD dwInSize;
    LPD3DTLVERTEX lpOut;
    DWORD dwOutSize;
} D3DLIGHTDATA, *LPD3DLIGHTDATA;

#if (DIRECT3D_VERSION >= 0x0500)
#define D3DCOLOR_MONO  1
#define D3DCOLOR_RGB  2
typedef DWORD D3DCOLORMODEL;
#endif /* DIRECT3D_VERSION >= 0x0500 */

#define D3DCLEAR_TARGET  0x00000001L
#define D3DCLEAR_ZBUFFER  0x00000002L
#if(DIRECT3D_VERSION >= 0x0600)
#define D3DCLEAR_STENCIL  0x00000004L
#endif /* DIRECT3D_VERSION >= 0x0600 */

typedef enum _D3DOPCODE {
    D3DOP_POINT = 1,
    D3DOP_LINE = 2,
    D3DOP_TRIANGLE = 3,
    D3DOP_MATRIXLOAD = 4,
    D3DOP_MATRIXMULTIPLY = 5,
    D3DOP_STATETRANSFORM = 6,
    D3DOP_STATELIGHT = 7,
    D3DOP_STATERENDER = 8,
    D3DOP_PROCESSVERTICES = 9,
    D3DOP_TEXTURELOAD = 10,
    D3DOP_EXIT = 11,
    D3DOP_BRANCHFORWARD = 12,
    D3DOP_SPAN = 13,
    D3DOP_SETSTATUS = 14,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DOP_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DOPCODE;

typedef struct _D3DINSTRUCTION {
    BYTE bOpcode;
    BYTE bSize;
    WORD wCount;
} D3DINSTRUCTION, *LPD3DINSTRUCTION;

typedef struct _D3DTEXTURELOAD {
    D3DTEXTUREHANDLE hDestTexture;
    D3DTEXTUREHANDLE hSrcTexture;
} D3DTEXTURELOAD, *LPD3DTEXTURELOAD;

typedef struct _D3DPICKRECORD {
    BYTE bOpcode;
    BYTE bPad;
    DWORD dwOffset;
    D3DVALUE dvZ;
} D3DPICKRECORD, *LPD3DPICKRECORD;

typedef enum _D3DSHADEMODE {
    D3DSHADE_FLAT = 1,
    D3DSHADE_GOURAUD = 2,
    D3DSHADE_PHONG = 3,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DSHADE_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DSHADEMODE;

typedef enum _D3DFILLMODE {
    D3DFILL_POINT = 1,
    D3DFILL_WIREFRAME = 2,
    D3DFILL_SOLID = 3,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DFILL_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DFILLMODE;

typedef struct _D3DLINEPATTERN {
    WORD wRepeatFactor;
    WORD wLinePattern;
} D3DLINEPATTERN;

typedef enum _D3DTEXTUREFILTER {
    D3DFILTER_NEAREST = 1,
    D3DFILTER_LINEAR = 2,
    D3DFILTER_MIPNEAREST = 3,
    D3DFILTER_MIPLINEAR = 4,
    D3DFILTER_LINEARMIPNEAREST = 5,
    D3DFILTER_LINEARMIPLINEAR = 6,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DFILTER_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DTEXTUREFILTER;

typedef enum _D3DBLEND {
    D3DBLEND_ZERO = 1,
    D3DBLEND_ONE = 2,
    D3DBLEND_SRCCOLOR = 3,
    D3DBLEND_INVSRCCOLOR = 4,
    D3DBLEND_SRCALPHA = 5,
    D3DBLEND_INVSRCALPHA = 6,
    D3DBLEND_DESTALPHA = 7,
    D3DBLEND_INVDESTALPHA = 8,
    D3DBLEND_DESTCOLOR = 9,
    D3DBLEND_INVDESTCOLOR = 10,
    D3DBLEND_SRCALPHASAT = 11,
    D3DBLEND_BOTHSRCALPHA = 12,
    D3DBLEND_BOTHINVSRCALPHA = 13,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DBLEND_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DBLEND;

typedef enum _D3DTEXTUREBLEND {
    D3DTBLEND_DECAL = 1,
    D3DTBLEND_MODULATE = 2,
    D3DTBLEND_DECALALPHA = 3,
    D3DTBLEND_MODULATEALPHA = 4,
    D3DTBLEND_DECALMASK = 5,
    D3DTBLEND_MODULATEMASK = 6,
    D3DTBLEND_COPY = 7,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DTBLEND_ADD = 8,
    D3DTBLEND_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DTEXTUREBLEND;

typedef enum _D3DTEXTUREADDRESS {
    D3DTADDRESS_WRAP = 1,
    D3DTADDRESS_MIRROR = 2,
    D3DTADDRESS_CLAMP = 3,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DTADDRESS_BORDER = 4,
    D3DTADDRESS_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DTEXTUREADDRESS;

typedef enum _D3DCULL {
    D3DCULL_NONE = 1,
    D3DCULL_CW = 2,
    D3DCULL_CCW = 3,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DCULL_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DCULL;

typedef enum _D3DCMPFUNC {
    D3DCMP_NEVER = 1,
    D3DCMP_LESS = 2,
    D3DCMP_EQUAL = 3,
    D3DCMP_LESSEQUAL = 4,
    D3DCMP_GREATER = 5,
    D3DCMP_NOTEQUAL = 6,
    D3DCMP_GREATEREQUAL = 7,
    D3DCMP_ALWAYS = 8,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DCMP_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DCMPFUNC;

#if (DIRECT3D_VERSION >= 0x0600)
typedef enum _D3DSTENCILOP {
    D3DSTENCILOP_KEEP = 1,
    D3DSTENCILOP_ZERO = 2,
    D3DSTENCILOP_REPLACE = 3,
    D3DSTENCILOP_INCRSAT = 4,
    D3DSTENCILOP_DECRSAT = 5,
    D3DSTENCILOP_INVERT = 6,
    D3DSTENCILOP_INCR = 7,
    D3DSTENCILOP_DECR = 8,
    D3DSTENCILOP_FORCE_DWORD = 0x7FFFFFFF,
} D3DSTENCILOP;
#endif /* DIRECT3D_VERSION >= 0x0600 */

typedef enum _D3DFOGMODE {
    D3DFOG_NONE = 0,
    D3DFOG_EXP = 1,
    D3DFOG_EXP2 = 2,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DFOG_LINEAR = 3,
    D3DFOG_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DFOGMODE;

#if (DIRECT3D_VERSION >= 0x0600)
typedef enum _D3DZBUFFERTYPE {
    D3DZB_FALSE = 0,
    D3DZB_TRUE = 1,
    D3DZB_USEW = 2,
    D3DZB_FORCE_DWORD = 0x7FFFFFFF,
} D3DZBUFFERTYPE;
#endif /* DIRECT3D_VERSION >= 0x0600 */

#if (DIRECT3D_VERSION >= 0x0500)
typedef enum _D3DANTIALIASMODE {
    D3DANTIALIAS_NONE = 0,
    D3DANTIALIAS_SORTDEPENDENT = 1,
    D3DANTIALIAS_SORTINDEPENDENT = 2,
    D3DANTIALIAS_FORCE_DWORD = 0x7FFFFFFF,
} D3DANTIALIASMODE;

typedef enum _D3DVERTEXTYPE {
    D3DVT_VERTEX = 1,
    D3DVT_LVERTEX = 2,
    D3DVT_TLVERTEX = 3,
    D3DVT_FORCE_DWORD = 0x7FFFFFFF,
} D3DVERTEXTYPE;

typedef enum _D3DPRIMITIVETYPE {
    D3DPT_POINTLIST = 1,
    D3DPT_LINELIST = 2,
    D3DPT_LINESTRIP = 3,
    D3DPT_TRIANGLELIST = 4,
    D3DPT_TRIANGLESTRIP = 5,
    D3DPT_TRIANGLEFAN = 6,
    D3DPT_FORCE_DWORD = 0x7FFFFFFF,
} D3DPRIMITIVETYPE;
#endif /* DIRECT3D_VERSION >= 0x0500 */

#define D3DSTATE_OVERRIDE_BIAS  256
#define D3DSTATE_OVERRIDE(type)  (D3DRENDERSTATETYPE)(((DWORD)(type)+D3DSTATE_OVERRIDE_BIAS))

typedef enum _D3DTRANSFORMSTATETYPE {
    D3DTRANSFORMSTATE_WORLD = 1,
    D3DTRANSFORMSTATE_VIEW = 2,
    D3DTRANSFORMSTATE_PROJECTION = 3,
#if (DIRECT3D_VERSION >= 0x0700)
    D3DTRANSFORMSTATE_WORLD1 = 4,
    D3DTRANSFORMSTATE_WORLD2 = 5,
    D3DTRANSFORMSTATE_WORLD3 = 6,
    D3DTRANSFORMSTATE_TEXTURE0 = 16,
    D3DTRANSFORMSTATE_TEXTURE1 = 17,
    D3DTRANSFORMSTATE_TEXTURE2 = 18,
    D3DTRANSFORMSTATE_TEXTURE3 = 19,
    D3DTRANSFORMSTATE_TEXTURE4 = 20,
    D3DTRANSFORMSTATE_TEXTURE5 = 21,
    D3DTRANSFORMSTATE_TEXTURE6 = 22,
    D3DTRANSFORMSTATE_TEXTURE7 = 23,
#endif /* DIRECT3D_VERSION >= 0x0700 */
#if (DIRECT3D_VERSION >= 0x0500)
    D3DTRANSFORMSTATE_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DTRANSFORMSTATETYPE;

typedef enum _D3DLIGHTSTATETYPE {
    D3DLIGHTSTATE_MATERIAL = 1,
    D3DLIGHTSTATE_AMBIENT = 2,
    D3DLIGHTSTATE_COLORMODEL = 3,
    D3DLIGHTSTATE_FOGMODE = 4,
    D3DLIGHTSTATE_FOGSTART = 5,
    D3DLIGHTSTATE_FOGEND = 6,
    D3DLIGHTSTATE_FOGDENSITY = 7,
#if (DIRECT3D_VERSION >= 0x0600)
    D3DLIGHTSTATE_COLORVERTEX = 8,
#endif /* DIRECT3D_VERSION >= 0x0600 */
#if (DIRECT3D_VERSION >= 0x0500)
    D3DLIGHTSTATE_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DLIGHTSTATETYPE;

typedef enum _D3DRENDERSTATETYPE {
    D3DRENDERSTATE_ANTIALIAS = 2,
    D3DRENDERSTATE_TEXTUREPERSPECTIVE = 4,
    D3DRENDERSTATE_ZENABLE = 7,
    D3DRENDERSTATE_FILLMODE = 8,
    D3DRENDERSTATE_SHADEMODE = 9,
    D3DRENDERSTATE_LINEPATTERN = 10,
    D3DRENDERSTATE_ZWRITEENABLE = 14,
    D3DRENDERSTATE_ALPHATESTENABLE = 15,
    D3DRENDERSTATE_LASTPIXEL = 16,
    D3DRENDERSTATE_SRCBLEND = 19,
    D3DRENDERSTATE_DESTBLEND = 20,
    D3DRENDERSTATE_CULLMODE = 22,
    D3DRENDERSTATE_ZFUNC = 23,
    D3DRENDERSTATE_ALPHAREF = 24,
    D3DRENDERSTATE_ALPHAFUNC = 25,
    D3DRENDERSTATE_DITHERENABLE = 26,
#if(DIRECT3D_VERSION >= 0x0500)
    D3DRENDERSTATE_ALPHABLENDENABLE = 27,
#endif /* DIRECT3D_VERSION >= 0x0500 */
    D3DRENDERSTATE_FOGENABLE = 28,
    D3DRENDERSTATE_SPECULARENABLE = 29,
    D3DRENDERSTATE_ZVISIBLE = 30,
    D3DRENDERSTATE_STIPPLEDALPHA = 33,
    D3DRENDERSTATE_FOGCOLOR = 34,
    D3DRENDERSTATE_FOGTABLEMODE = 35,
#if(DIRECT3D_VERSION >= 0x0700)
    D3DRENDERSTATE_FOGSTART = 36,
    D3DRENDERSTATE_FOGEND = 37,
    D3DRENDERSTATE_FOGDENSITY = 38,
#endif /* DIRECT3D_VERSION >= 0x0700 */
#if(DIRECT3D_VERSION >= 0x0500)
    D3DRENDERSTATE_EDGEANTIALIAS = 40,
    D3DRENDERSTATE_COLORKEYENABLE = 41,
    D3DRENDERSTATE_ZBIAS = 47,
    D3DRENDERSTATE_RANGEFOGENABLE = 48,
#endif /* DIRECT3D_VERSION >= 0x0500 */
#if (DIRECT3D_VERSION >= 0x0600)
    D3DRENDERSTATE_STENCILENABLE = 52,
    D3DRENDERSTATE_STENCILFAIL = 53,
    D3DRENDERSTATE_STENCILZFAIL = 54,
    D3DRENDERSTATE_STENCILPASS = 55,
    D3DRENDERSTATE_STENCILFUNC = 56,
    D3DRENDERSTATE_STENCILREF = 57,
    D3DRENDERSTATE_STENCILMASK = 58,
    D3DRENDERSTATE_STENCILWRITEMASK = 59,
    D3DRENDERSTATE_TEXTUREFACTOR = 60,
#endif /* DIRECT3D_VERSION >= 0x0600 */

#if (DIRECT3D_VERSION >= 0x0600)
    D3DRENDERSTATE_WRAP0 = 128,
    D3DRENDERSTATE_WRAP1 = 129,
    D3DRENDERSTATE_WRAP2 = 130,
    D3DRENDERSTATE_WRAP3 = 131,
    D3DRENDERSTATE_WRAP4 = 132,
    D3DRENDERSTATE_WRAP5 = 133,
    D3DRENDERSTATE_WRAP6 = 134,
    D3DRENDERSTATE_WRAP7 = 135,
#endif /* DIRECT3D_VERSION >= 0x0600 */
#if (DIRECT3D_VERSION >= 0x0700)
    D3DRENDERSTATE_CLIPPING = 136,
    D3DRENDERSTATE_LIGHTING = 137,
    D3DRENDERSTATE_EXTENTS = 138,
    D3DRENDERSTATE_AMBIENT = 139,
    D3DRENDERSTATE_FOGVERTEXMODE = 140,
    D3DRENDERSTATE_COLORVERTEX = 141,
    D3DRENDERSTATE_LOCALVIEWER = 142,
    D3DRENDERSTATE_NORMALIZENORMALS = 143,
    D3DRENDERSTATE_COLORKEYBLENDENABLE = 144,
    D3DRENDERSTATE_DIFFUSEMATERIALSOURCE = 145,
    D3DRENDERSTATE_SPECULARMATERIALSOURCE = 146,
    D3DRENDERSTATE_AMBIENTMATERIALSOURCE = 147,
    D3DRENDERSTATE_EMISSIVEMATERIALSOURCE = 148,
    D3DRENDERSTATE_VERTEXBLEND = 151,
    D3DRENDERSTATE_CLIPPLANEENABLE = 152,

#endif /* DIRECT3D_VERSION >= 0x0700 */

    D3DRENDERSTATE_TEXTUREHANDLE = 1,
    D3DRENDERSTATE_TEXTUREADDRESS = 3,
    D3DRENDERSTATE_WRAPU = 5,
    D3DRENDERSTATE_WRAPV = 6,
    D3DRENDERSTATE_MONOENABLE = 11,
    D3DRENDERSTATE_ROP2 = 12,
    D3DRENDERSTATE_PLANEMASK = 13,
    D3DRENDERSTATE_TEXTUREMAG = 17,
    D3DRENDERSTATE_TEXTUREMIN = 18,
    D3DRENDERSTATE_TEXTUREMAPBLEND = 21,
    D3DRENDERSTATE_SUBPIXEL = 31,
    D3DRENDERSTATE_SUBPIXELX = 32,
    D3DRENDERSTATE_STIPPLEENABLE = 39,
#if (DIRECT3D_VERSION >= 0x0500)
    D3DRENDERSTATE_BORDERCOLOR = 43,
    D3DRENDERSTATE_TEXTUREADDRESSU = 44,
    D3DRENDERSTATE_TEXTUREADDRESSV = 45,
    D3DRENDERSTATE_MIPMAPLODBIAS = 46,
    D3DRENDERSTATE_ANISOTROPY = 49,
#endif /* DIRECT3D_VERSION >= 0x0500 */
    D3DRENDERSTATE_FLUSHBATCH = 50,
#if (DIRECT3D_VERSION >= 0x0600)
    D3DRENDERSTATE_TRANSLUCENTSORTINDEPENDENT = 51,
#endif /* DIRECT3D_VERSION >= 0x0600 */
    D3DRENDERSTATE_STIPPLEPATTERN00 = 64,
    D3DRENDERSTATE_STIPPLEPATTERN01 = 65,
    D3DRENDERSTATE_STIPPLEPATTERN02 = 66,
    D3DRENDERSTATE_STIPPLEPATTERN03 = 67,
    D3DRENDERSTATE_STIPPLEPATTERN04 = 68,
    D3DRENDERSTATE_STIPPLEPATTERN05 = 69,
    D3DRENDERSTATE_STIPPLEPATTERN06 = 70,
    D3DRENDERSTATE_STIPPLEPATTERN07 = 71,
    D3DRENDERSTATE_STIPPLEPATTERN08 = 72,
    D3DRENDERSTATE_STIPPLEPATTERN09 = 73,
    D3DRENDERSTATE_STIPPLEPATTERN10 = 74,
    D3DRENDERSTATE_STIPPLEPATTERN11 = 75,
    D3DRENDERSTATE_STIPPLEPATTERN12 = 76,
    D3DRENDERSTATE_STIPPLEPATTERN13 = 77,
    D3DRENDERSTATE_STIPPLEPATTERN14 = 78,
    D3DRENDERSTATE_STIPPLEPATTERN15 = 79,
    D3DRENDERSTATE_STIPPLEPATTERN16 = 80,
    D3DRENDERSTATE_STIPPLEPATTERN17 = 81,
    D3DRENDERSTATE_STIPPLEPATTERN18 = 82,
    D3DRENDERSTATE_STIPPLEPATTERN19 = 83,
    D3DRENDERSTATE_STIPPLEPATTERN20 = 84,
    D3DRENDERSTATE_STIPPLEPATTERN21 = 85,
    D3DRENDERSTATE_STIPPLEPATTERN22 = 86,
    D3DRENDERSTATE_STIPPLEPATTERN23 = 87,
    D3DRENDERSTATE_STIPPLEPATTERN24 = 88,
    D3DRENDERSTATE_STIPPLEPATTERN25 = 89,
    D3DRENDERSTATE_STIPPLEPATTERN26 = 90,
    D3DRENDERSTATE_STIPPLEPATTERN27 = 91,
    D3DRENDERSTATE_STIPPLEPATTERN28 = 92,
    D3DRENDERSTATE_STIPPLEPATTERN29 = 93,
    D3DRENDERSTATE_STIPPLEPATTERN30 = 94,
    D3DRENDERSTATE_STIPPLEPATTERN31 = 95,
    D3DRENDERSTATE_FOGTABLESTART = 36,
    D3DRENDERSTATE_FOGTABLEEND = 37,
    D3DRENDERSTATE_FOGTABLEDENSITY = 38,

#if (DIRECT3D_VERSION >= 0x0500)
    D3DRENDERSTATE_FORCE_DWORD = 0x7FFFFFFF,
#endif /* DIRECT3D_VERSION >= 0x0500 */
} D3DRENDERSTATETYPE;

typedef enum _D3DMATERIALCOLORSOURCE
{
    D3DMCS_MATERIAL = 0,
    D3DMCS_COLOR1 = 1,
    D3DMCS_COLOR2 = 2,
    D3DMCS_FORCE_DWORD = 0x7FFFFFFF,
} D3DMATERIALCOLORSOURCE;

#if (DIRECT3D_VERSION >= 0x0500)
#define D3DRENDERSTATE_BLENDENABLE  D3DRENDERSTATE_ALPHABLENDENABLE
#endif /* DIRECT3D_VERSION >= 0x0500 */

#if (DIRECT3D_VERSION >= 0x0600)
#define D3DRENDERSTATE_WRAPBIAS  128UL
#define D3DWRAP_U  0x00000001L
#define D3DWRAP_V  0x00000002L
#endif /* DIRECT3D_VERSION >= 0x0600 */

#if (DIRECT3D_VERSION >= 0x0700)
#define D3DWRAPCOORD_0  0x00000001L
#define D3DWRAPCOORD_1  0x00000002L
#define D3DWRAPCOORD_2  0x00000004L
#define D3DWRAPCOORD_3  0x00000008L
#endif /* DIRECT3D_VERSION >= 0x0700 */

#define D3DRENDERSTATE_STIPPLEPATTERN(y)  (D3DRENDERSTATE_STIPPLEPATTERN00+(y))

typedef struct _D3DSTATE {
    union {
        D3DTRANSFORMSTATETYPE dtstTransformStateType;
        D3DLIGHTSTATETYPE dlstLightStateType;
        D3DRENDERSTATETYPE drstRenderStateType;
    };
    union {
        DWORD dwArg[1];
        D3DVALUE dvArg[1];
    };
} D3DSTATE, *LPD3DSTATE;

typedef struct _D3DMATRIXLOAD {
    D3DMATRIXHANDLE hDestMatrix;
    D3DMATRIXHANDLE hSrcMatrix;
} D3DMATRIXLOAD, *LPD3DMATRIXLOAD;

typedef struct _D3DMATRIXMULTIPLY {
    D3DMATRIXHANDLE hDestMatrix;
    D3DMATRIXHANDLE hSrcMatrix1;
    D3DMATRIXHANDLE hSrcMatrix2;
} D3DMATRIXMULTIPLY, *LPD3DMATRIXMULTIPLY;

typedef struct _D3DPROCESSVERTICES {
    DWORD dwFlags;
    WORD wStart;
    WORD wDest;
    DWORD dwCount;
    DWORD dwReserved;
} D3DPROCESSVERTICES, *LPD3DPROCESSVERTICES;

#define D3DPROCESSVERTICES_TRANSFORMLIGHT  0x00000000L
#define D3DPROCESSVERTICES_TRANSFORM  0x00000001L
#define D3DPROCESSVERTICES_COPY  0x00000002L
#define D3DPROCESSVERTICES_OPMASK  0x00000007L
#define D3DPROCESSVERTICES_UPDATEEXTENTS  0x00000008L
#define D3DPROCESSVERTICES_NOCOLOR  0x00000010L

#if (DIRECT3D_VERSION >= 0x0600)

typedef enum _D3DTEXTURESTAGESTATETYPE
{
    D3DTSS_COLOROP =  1,
    D3DTSS_COLORARG1 =  2,
    D3DTSS_COLORARG2 =  3,
    D3DTSS_ALPHAOP =  4,
    D3DTSS_ALPHAARG1 =  5,
    D3DTSS_ALPHAARG2 =  6,
    D3DTSS_BUMPENVMAT00 =  7,
    D3DTSS_BUMPENVMAT01 =  8,
    D3DTSS_BUMPENVMAT10 =  9,
    D3DTSS_BUMPENVMAT11 = 10,
    D3DTSS_TEXCOORDINDEX = 11,
    D3DTSS_ADDRESS = 12,
    D3DTSS_ADDRESSU = 13,
    D3DTSS_ADDRESSV = 14,
    D3DTSS_BORDERCOLOR = 15,
    D3DTSS_MAGFILTER = 16,
    D3DTSS_MINFILTER = 17,
    D3DTSS_MIPFILTER = 18,
    D3DTSS_MIPMAPLODBIAS = 19,
    D3DTSS_MAXMIPLEVEL = 20,
    D3DTSS_MAXANISOTROPY = 21,
    D3DTSS_BUMPENVLSCALE = 22,
    D3DTSS_BUMPENVLOFFSET = 23,
#if (DIRECT3D_VERSION >= 0x0700)
    D3DTSS_TEXTURETRANSFORMFLAGS = 24,
#endif /* DIRECT3D_VERSION >= 0x0700 */
    D3DTSS_FORCE_DWORD = 0x7FFFFFFF,
} D3DTEXTURESTAGESTATETYPE;

#if (DIRECT3D_VERSION >= 0x0700)
#define D3DTSS_TCI_PASSTHRU  0x00000000
#define D3DTSS_TCI_CAMERASPACENORMAL  0x00010000
#define D3DTSS_TCI_CAMERASPACEPOSITION  0x00020000
#define D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR  0x00030000
#endif /* DIRECT3D_VERSION >= 0x0700 */

typedef enum _D3DTEXTUREOP {
    D3DTOP_DISABLE = 1,
    D3DTOP_SELECTARG1 = 2,
    D3DTOP_SELECTARG2 = 3,
    D3DTOP_MODULATE = 4,
    D3DTOP_MODULATE2X = 5,
    D3DTOP_MODULATE4X = 6,
    D3DTOP_ADD =  7,
    D3DTOP_ADDSIGNED =  8,
    D3DTOP_ADDSIGNED2X =  9,
    D3DTOP_SUBTRACT = 10,
    D3DTOP_ADDSMOOTH = 11,
    D3DTOP_BLENDDIFFUSEALPHA = 12,
    D3DTOP_BLENDTEXTUREALPHA = 13,
    D3DTOP_BLENDFACTORALPHA = 14,
    D3DTOP_BLENDTEXTUREALPHAPM = 15,
    D3DTOP_BLENDCURRENTALPHA = 16,
    D3DTOP_PREMODULATE = 17,
    D3DTOP_MODULATEALPHA_ADDCOLOR = 18,
    D3DTOP_MODULATECOLOR_ADDALPHA = 19,
    D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20,
    D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21,
    D3DTOP_BUMPENVMAP = 22,
    D3DTOP_BUMPENVMAPLUMINANCE = 23,
    D3DTOP_DOTPRODUCT3 = 24,
    D3DTOP_FORCE_DWORD = 0x7FFFFFFF,
} D3DTEXTUREOP;

#define D3DTA_SELECTMASK  0x0000000F
#define D3DTA_DIFFUSE  0x00000000
#define D3DTA_CURRENT  0x00000001
#define D3DTA_TEXTURE  0x00000002
#define D3DTA_TFACTOR  0x00000003
#if (DIRECT3D_VERSION >= 0x0700)
#define D3DTA_SPECULAR  0x00000004
#endif /* DIRECT3D_VERSION >= 0x0700 */
#define D3DTA_COMPLEMENT  0x00000010
#define D3DTA_ALPHAREPLICATE  0x00000020

typedef enum _D3DTEXTUREMAGFILTER {
    D3DTFG_POINT = 1,
    D3DTFG_LINEAR = 2,
    D3DTFG_FLATCUBIC = 3,
    D3DTFG_GAUSSIANCUBIC = 4,
    D3DTFG_ANISOTROPIC = 5,
    D3DTFG_FORCE_DWORD = 0x7FFFFFFF,
} D3DTEXTUREMAGFILTER;

typedef enum _D3DTEXTUREMINFILTER {
    D3DTFN_POINT = 1,
    D3DTFN_LINEAR = 2,
    D3DTFN_ANISOTROPIC = 3,
    D3DTFN_FORCE_DWORD = 0x7FFFFFFF,
} D3DTEXTUREMINFILTER;

typedef enum _D3DTEXTUREMIPFILTER {
    D3DTFP_NONE = 1,
    D3DTFP_POINT = 2,
    D3DTFP_LINEAR = 3,
    D3DTFP_FORCE_DWORD = 0x7FFFFFFF,
} D3DTEXTUREMIPFILTER;

#endif /* DIRECT3D_VERSION >= 0x0600 */

#define D3DTRIFLAG_START  0x00000000L
#define D3DTRIFLAG_STARTFLAT(len)  (len)
#define D3DTRIFLAG_ODD  0x0000001EL
#define D3DTRIFLAG_EVEN  0x0000001FL

#define D3DTRIFLAG_EDGEENABLE1  0x00000100L
#define D3DTRIFLAG_EDGEENABLE2  0x00000200L
#define D3DTRIFLAG_EDGEENABLE3  0x00000400L
#define D3DTRIFLAG_EDGEENABLETRIANGLE  (D3DTRIFLAG_EDGEENABLE1|D3DTRIFLAG_EDGEENABLE2|D3DTRIFLAG_EDGEENABLE3)

typedef struct _D3DTRIANGLE {
    union {
        WORD v1;
        WORD wV1;
    };
    union {
        WORD v2;
        WORD wV2;
    };
    union {
        WORD v3;
        WORD wV3;
    };
    WORD wFlags;
} D3DTRIANGLE, *LPD3DTRIANGLE;

typedef struct _D3DLINE {
    union {
        WORD v1;
        WORD wV1;
    };
    union {
        WORD v2;
        WORD wV2;
    };
} D3DLINE, *LPD3DLINE;

typedef struct _D3DSPAN {
    WORD wCount;
    WORD wFirst;
} D3DSPAN, *LPD3DSPAN;

typedef struct _D3DPOINT {
    WORD wCount;
    WORD wFirst;
} D3DPOINT, *LPD3DPOINT;

typedef struct _D3DBRANCH {
    DWORD dwMask;
    DWORD dwValue;
    BOOL bNegate;
    DWORD dwOffset;
} D3DBRANCH, *LPD3DBRANCH;

typedef struct _D3DSTATUS {
    DWORD dwFlags;
    DWORD dwStatus;
    D3DRECT drExtent;
} D3DSTATUS, *LPD3DSTATUS;

#define D3DSETSTATUS_STATUS  0x00000001L
#define D3DSETSTATUS_EXTENTS  0x00000002L
#define D3DSETSTATUS_ALL  (D3DSETSTATUS_STATUS|D3DSETSTATUS_EXTENTS)

#if (DIRECT3D_VERSION >= 0x0500)
typedef struct _D3DCLIPSTATUS {
    DWORD dwFlags;
    DWORD dwStatus;
    float minx, maxx;
    float miny, maxy;
    float minz, maxz;
} D3DCLIPSTATUS, *LPD3DCLIPSTATUS;

#define D3DCLIPSTATUS_STATUS  0x00000001L
#define D3DCLIPSTATUS_EXTENTS2  0x00000002L
#define D3DCLIPSTATUS_EXTENTS3  0x00000004L
#endif /* DIRECT3D_VERSION >= 0x0500 */

typedef struct _D3DSTATS {
    DWORD dwSize;
    DWORD dwTrianglesDrawn;
    DWORD dwLinesDrawn;
    DWORD dwPointsDrawn;
    DWORD dwSpansDrawn;
    DWORD dwVerticesProcessed;
} D3DSTATS, *LPD3DSTATS;

#define D3DEXECUTE_CLIPPED  0x00000001L
#define D3DEXECUTE_UNCLIPPED  0x00000002L

typedef struct _D3DEXECUTEDATA {
    DWORD dwSize;
    DWORD dwVertexOffset;
    DWORD dwVertexCount;
    DWORD dwInstructionOffset;
    DWORD dwInstructionLength;
    DWORD dwHVertexOffset;
    D3DSTATUS dsStatus;
} D3DEXECUTEDATA, *LPD3DEXECUTEDATA;

#define D3DPAL_FREE  0x00
#define D3DPAL_READONLY  0x40
#define D3DPAL_RESERVED  0x80

#if (DIRECT3D_VERSION >= 0x0600)

typedef struct _D3DVERTEXBUFFERDESC {
    DWORD dwSize;
    DWORD dwCaps;
    DWORD dwFVF;
    DWORD dwNumVertices;
} D3DVERTEXBUFFERDESC, *LPD3DVERTEXBUFFERDESC;

#define D3DVBCAPS_SYSTEMMEMORY  0x00000800L
#define D3DVBCAPS_WRITEONLY  0x00010000L
#define D3DVBCAPS_OPTIMIZED  0x80000000L
#define D3DVBCAPS_DONOTCLIP  0x00000001L

#define D3DVOP_LIGHT  (1<<10)
#define D3DVOP_TRANSFORM  (1<<0)
#define D3DVOP_CLIP  (1<<2)
#define D3DVOP_EXTENTS  (1<<3)

#define D3DMAXNUMVERTICES  ((1<<16)-1)
#define D3DMAXNUMPRIMITIVES  ((1<<16)-1)

#if (DIRECT3D_VERSION >= 0x0700)
#define D3DPV_DONOTCOPYDATA (1<<0)
#endif /* DIRECT3D_VERSION >= 0x0700 */

#define D3DFVF_RESERVED0  0x001
#define D3DFVF_POSITION_MASK  0x00E
#define D3DFVF_XYZ  0x002
#define D3DFVF_XYZRHW  0x004
#if (DIRECT3D_VERSION >= 0x0700)
#define D3DFVF_XYZB1  0x006
#define D3DFVF_XYZB2  0x008
#define D3DFVF_XYZB3  0x00A
#define D3DFVF_XYZB4  0x00C
#define D3DFVF_XYZB5  0x00E
#endif /* DIRECT3D_VERSION >= 0x0700 */
#define D3DFVF_NORMAL  0x010
#define D3DFVF_RESERVED1  0x020
#define D3DFVF_DIFFUSE  0x040
#define D3DFVF_SPECULAR  0x080
#define D3DFVF_TEXCOUNT_MASK  0xF00
#define D3DFVF_TEXCOUNT_SHIFT  8
#define D3DFVF_TEX0  0x000
#define D3DFVF_TEX1  0x100
#define D3DFVF_TEX2  0x200
#define D3DFVF_TEX3  0x300
#define D3DFVF_TEX4  0x400
#define D3DFVF_TEX5  0x500
#define D3DFVF_TEX6  0x600
#define D3DFVF_TEX7  0x700
#define D3DFVF_TEX8  0x800
#define D3DFVF_RESERVED2  0xF000

#define D3DFVF_VERTEX  (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)
#define D3DFVF_LVERTEX  (D3DFVF_XYZ|D3DFVF_RESERVED1|D3DFVF_DIFFUSE|D3DFVF_SPECULAR|D3DFVF_TEX1)
#define D3DFVF_TLVERTEX  (D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_SPECULAR|D3DFVF_TEX1)

typedef struct _D3DDP_PTRSTRIDE {
    LPVOID lpvData;
    DWORD dwStride;
} D3DDP_PTRSTRIDE;

#define D3DDP_MAXTEXCOORD  8

typedef struct _D3DDRAWPRIMITIVESTRIDEDDATA {
    D3DDP_PTRSTRIDE position;
    D3DDP_PTRSTRIDE normal;
    D3DDP_PTRSTRIDE diffuse;
    D3DDP_PTRSTRIDE specular;
    D3DDP_PTRSTRIDE textureCoords[D3DDP_MAXTEXCOORD];
} D3DDRAWPRIMITIVESTRIDEDDATA, *LPD3DDRAWPRIMITIVESTRIDEDDATA;

#define D3DVIS_INSIDE_FRUSTUM  0
#define D3DVIS_INTERSECT_FRUSTUM  1
#define D3DVIS_OUTSIDE_FRUSTUM  2
#define D3DVIS_INSIDE_LEFT  0
#define D3DVIS_INTERSECT_LEFT  (1<<2)
#define D3DVIS_OUTSIDE_LEFT  (2<<2)
#define D3DVIS_INSIDE_RIGHT  0
#define D3DVIS_INTERSECT_RIGHT  (1<<4)
#define D3DVIS_OUTSIDE_RIGHT  (2<<4)
#define D3DVIS_INSIDE_TOP  0
#define D3DVIS_INTERSECT_TOP  (1<<6)
#define D3DVIS_OUTSIDE_TOP  (2<<6)
#define D3DVIS_INSIDE_BOTTOM  0
#define D3DVIS_INTERSECT_BOTTOM  (1<<8)
#define D3DVIS_OUTSIDE_BOTTOM  (2<<8)
#define D3DVIS_INSIDE_NEAR  0
#define D3DVIS_INTERSECT_NEAR  (1<<10)
#define D3DVIS_OUTSIDE_NEAR  (2<<10)
#define D3DVIS_INSIDE_FAR  0
#define D3DVIS_INTERSECT_FAR  (1<<12)
#define D3DVIS_OUTSIDE_FAR  (2<<12)

#define D3DVIS_MASK_FRUSTUM  (3<<0)
#define D3DVIS_MASK_LEFT  (3<<2)
#define D3DVIS_MASK_RIGHT  (3<<4)
#define D3DVIS_MASK_TOP  (3<<6)
#define D3DVIS_MASK_BOTTOM  (3<<8)
#define D3DVIS_MASK_NEAR  (3<<10)
#define D3DVIS_MASK_FAR  (3<<12)

#endif /* DIRECT3D_VERSION >= 0x0600 */

#if (DIRECT3D_VERSION >= 0x0700)

#define D3DDEVINFOID_TEXTUREMANAGER  1
#define D3DDEVINFOID_D3DTEXTUREMANAGER 2
#define D3DDEVINFOID_TEXTURING  3

typedef enum _D3DSTATEBLOCKTYPE {
    D3DSBT_ALL = 1,
    D3DSBT_PIXELSTATE = 2,
    D3DSBT_VERTEXSTATE = 3,
    D3DSBT_FORCE_DWORD = 0xFFFFFFFF
} D3DSTATEBLOCKTYPE;

typedef enum _D3DVERTEXBLENDFLAGS {
    D3DVBLEND_DISABLE = 0,
    D3DVBLEND_1WEIGHT = 1,
    D3DVBLEND_2WEIGHTS = 2,
    D3DVBLEND_3WEIGHTS = 3,
} D3DVERTEXBLENDFLAGS;

typedef enum _D3DTEXTURETRANSFORMFLAGS {
    D3DTTFF_DISABLE = 0,
    D3DTTFF_COUNT1 = 1,
    D3DTTFF_COUNT2 = 2,
    D3DTTFF_COUNT3 = 3,
    D3DTTFF_COUNT4 = 4,
    D3DTTFF_PROJECTED = 256,
    D3DTTFF_FORCE_DWORD = 0x7FFFFFFF,
} D3DTEXTURETRANSFORMFLAGS;

#define D3DFVF_TEXTUREFORMAT2  0
#define D3DFVF_TEXTUREFORMAT1  3
#define D3DFVF_TEXTUREFORMAT3  1
#define D3DFVF_TEXTUREFORMAT4  2

#define D3DFVF_TEXCOORDSIZE3(CoordIndex)  (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16))
#define D3DFVF_TEXCOORDSIZE2(CoordIndex)  (D3DFVF_TEXTUREFORMAT2)
#define D3DFVF_TEXCOORDSIZE4(CoordIndex)  (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16))
#define D3DFVF_TEXCOORDSIZE1(CoordIndex)  (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16))

#endif /* DIRECT3D_VERSION >= 0x0700 */

#if __POCC__ >= 290
#pragma warn(pop)
#endif

#include <poppack.h>

#endif /* _D3DTYPES_H */

