www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - directX9 SDK in d but with out any use

reply "aelmetwaly" <aelmetwaly gawab.com> writes:
Hi there,
I translated d3d9.h and d3d9caps.h and d3d9types.h into d but when i compile
my program I can't simply link with d3d9.lib and dxguid.lib. the linker give
invalid lib error :-(
It's a major drawback for d language that it doesn't support microsoft libs.
But these are the files for those interseted. I posted here because I don't
know how to add it to dsource. they have no automatic registeration of
projects.
////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
d3d9.d
////////////////////////////////////////

// Author : Ahmed El-Metwaly
// contact : aelmetwaly gawa.com
// Lic     : GPL


/*==========================================================================
;
 *
 *  Copyright (C) Microsoft Corporation.  All Rights Reserved.
 *
 *  File:   d3d9.h
 *  Content:    Direct3D include file
 *

****************************************************************************
/


const int DIRECT3D_VERSION =  0x0900;

// include this file content only if compiling for DX9 interfaces
//#if(DIRECT3D_VERSION >= 0x0900)
//version( DIRECT3D_VERSION)
//{

 /* This identifier is passed to Direct3DCreate9 in order to ensure that an
  * application was built against the correct header files. This number is
  * incremented whenever a header (or other) change would require
applications
  * to be rebuilt. If the version doesn't match, Direct3DCreate9 will fail.
  * (The number itself has no meaning.)*/

 const int D3D_SDK_VERSION = 31;


 import std.c.stdio;
 import std.c.stdlib;
 import std.string;
 import std.c.windows.windows;
 import std.c.windows.com;
 //import win32.wingdi; //too many conflicts with phobos std.c.windows

 // from win32.wingdi
 struct _RGNDATAHEADER {
   DWORD dwSize;
   DWORD iType;
   DWORD nCount;
   DWORD nRgnSize;
   RECT rcBound;
 }
 alias _RGNDATAHEADER RGNDATAHEADER;
 alias _RGNDATAHEADER* PRGNDATAHEADER;

 struct _RGNDATA {
   RGNDATAHEADER rdh;
   char Buffer[1];
 }
 alias _RGNDATA RGNDATA;
 alias _RGNDATA* PRGNDATA;
 alias _RGNDATA* NPRGNDATA;
 alias _RGNDATA* LPRGNDATA;

 alias GUID* REFIID;


 alias HANDLE HMONITOR;
 //alias WINAPI D3DAPI;



 /*
  * Interface IID's
  */


 /* IID_IDirect3D9 */
 /* {81BDCBCA-64D4-426d-AE8D-AD0147F4275C} */
 GUID IID_IDirect3D9 = { 0x81BDCBCA, 0x64D4, 0x426D, [ 0xAE, 0x8D, 0xAD,
0x1, 0x47, 0xF4, 0x27, 0x5C] };

 /* IID_IDirect3DDevice9 */
 // {D0223B96-BF7A-43fd-92BD-A43B0D82B9EB} */
 GUID IID_IDirect3DDevice9 = { 0xd0223b96, 0xbf7a, 0x43fd, [ 0x92, 0xbd,
0xa4, 0x3b, 0xd, 0x82, 0xb9, 0xeb] };

 /* IID_IDirect3DResource9 */
 // {05EEC05D-8F7D-4362-B999-D1BAF357C704}
 GUID IID_IDirect3DResource9 = { 0x5eec05d, 0x8f7d, 0x4362, [ 0xb9,  0x99,
0xd1, 0xba, 0xf3, 0x57, 0xc7, 0x4]};

 /* IID_IDirect3DBaseTexture9 */
 /* {580CA87E-1D3C-4d54-991D-B7D3E3C298CE} */
 GUID IID_IDirect3DBaseTexture9 ={ 0x580ca87e, 0x1d3c, 0x4d54, [ 0x99, 0x1d,
0xb7, 0xd3, 0xe3, 0xc2, 0x98, 0xce]};

 /* IID_IDirect3DTexture9 */
 /* {85C31227-3DE5-4f00-9B3A-F11AC38C18B5} */
 GUID IID_IDirect3DTexture9 = { 0x85c31227, 0x3de5, 0x4f00,[ 0x9b, 0x3a,
0xf1, 0x1a, 0xc3, 0x8c, 0x18, 0xb5]};

 /* IID_IDirect3DCubeTexture9 */
 /* {FFF32F81-D953-473a-9223-93D652ABA93F} */
 GUID IID_IDirect3DCubeTexture9 = { 0xfff32f81, 0xd953, 0x473a, [0x92, 0x23,
0x93, 0xd6, 0x52, 0xab, 0xa9, 0x3f]};

 /* IID_IDirect3DVolumeTexture9 */
 /* {2518526C-E789-4111-A7B9-47EF328D13E6} */
 GUID IID_IDirect3DVolumeTexture9 = { 0x2518526c, 0xe789, 0x4111, [0xa7,
0xb9, 0x47, 0xef, 0x32, 0x8d, 0x13, 0xe6]};

 /* IID_IDirect3DVertexBuffer9 */
 /* {B64BB1B5-FD70-4df6-BF91-19D0A12455E3} */
 GUID IID_IDirect3DVertexBuffer9 = { 0xb64bb1b5, 0xfd70, 0x4df6, [0xbf,
0x91, 0x19, 0xd0, 0xa1, 0x24, 0x55, 0xe3]};

 /* IID_IDirect3DIndexBuffer9 */
 /* {7C9DD65E-D3F7-4529-ACEE-785830ACDE35} */
 GUID IID_IDirect3DIndexBuffer9 = { 0x7c9dd65e, 0xd3f7, 0x4529, [0xac,
0xee, 0x78, 0x58, 0x30, 0xac, 0xde, 0x35]};

 /* IID_IDirect3DSurface9 */
 /* {0CFBAF3A-9FF6-429a-99B3-A2796AF8B89B} */
 GUID IID_IDirect3DSurface9 = { 0xcfbaf3a, 0x9ff6, 0x429a, [0x99,  0xb3,
0xa2, 0x79, 0x6a, 0xf8, 0xb8, 0x9b]};

 /* IID_IDirect3DVolume9 */
 /* {24F416E6-1F67-4aa7-B88E-D33F6F3128A1} */
 GUID IID_IDirect3DVolume9 = { 0x24f416e6, 0x1f67, 0x4aa7, [0xb8,  0x8e,
0xd3, 0x3f, 0x6f, 0x31, 0x28, 0xa1]};

 /* IID_IDirect3DSwapChain9 */
 /* {794950F2-ADFC-458a-905E-10A10B0B503B} */
 GUID IID_IDirect3DSwapChain9 = { 0x794950f2, 0xadfc, 0x458a, [0x90, 0x5e,
0x10, 0xa1, 0xb, 0xb, 0x50, 0x3b]};

 /* IID_IDirect3DVertexDeclaration9 */
 /* {DD13C59C-36FA-4098-A8FB-C7ED39DC8546} */
 GUID IID_IDirect3DVertexDeclaration9 = { 0xdd13c59c, 0x36fa, 0x4098, [0xa8,
0xfb, 0xc7, 0xed, 0x39, 0xdc, 0x85, 0x46]};

 /* IID_IDirect3DVertexShader9 */
 /* {EFC5557E-6265-4613-8A94-43857889EB36} */
 GUID IID_IDirect3DVertexShader9 = { 0xefc5557e, 0x6265, 0x4613, [0x8a,
0x94, 0x43, 0x85, 0x78, 0x89, 0xeb, 0x36]};

 /* IID_IDirect3DPixelShader9 */
 /* {6D3BDBDC-5B02-4415-B852-CE5E8BCCB289} */
 GUID IID_IDirect3DPixelShader9 = { 0x6d3bdbdc, 0x5b02, 0x4415, [0xb8,
0x52, 0xce, 0x5e, 0x8b, 0xcc, 0xb2, 0x89]};

 /* IID_IDirect3DStateBlock9 */
 /* {B07C4FE5-310D-4ba8-A23C-4F0F206F218B} */
 GUID IID_IDirect3DStateBlock9 = { 0xb07c4fe5, 0x310d, 0x4ba8, [ 0xa2, 0x3c,
0x4f, 0xf, 0x20, 0x6f, 0x21, 0x8b]};

 /* IID_IDirect3DQuery9 */
 /* {d9771460-a695-4f26-bbd3-27b840b541cc} */
 GUID IID_IDirect3DQuery9 = { 0xd9771460, 0xa695, 0x4f26, [0xbb,  0xd3,
0x27, 0xb8, 0x40, 0xb5, 0x41, 0xcc]};




 //interface /*DECLSPEC_UUID("81BDCBCA-64D4-426d-AE8D-AD0147F4275C")*/
IDirect3D9;
 //interface /*DECLSPEC_UUID("D0223B96-BF7A-43fd-92BD-A43B0D82B9EB")*/
IDirect3DDevice9;

 //interface /*DECLSPEC_UUID("B07C4FE5-310D-4ba8-A23C-4F0F206F218B")*/
IDirect3DStateBlock9;
 //interface /*DECLSPEC_UUID("05EEC05D-8F7D-4362-B999-D1BAF357C704")*/
IDirect3DResource9;
 //interface /*DECLSPEC_UUID("DD13C59C-36FA-4098-A8FB-C7ED39DC8546")*/
IDirect3DVertexDeclaration9;
 //interface /*DECLSPEC_UUID("EFC5557E-6265-4613-8A94-43857889EB36")*/
IDirect3DVertexShader9;
 //interface /*DECLSPEC_UUID("6D3BDBDC-5B02-4415-B852-CE5E8BCCB289")*/
IDirect3DPixelShader9;
 //interface /*DECLSPEC_UUID("580CA87E-1D3C-4d54-991D-B7D3E3C298CE")*/
IDirect3DBaseTexture9;
 //interface /*DECLSPEC_UUID("85C31227-3DE5-4f00-9B3A-F11AC38C18B5")*/
IDirect3DTexture9;
 //interface /*DECLSPEC_UUID("2518526C-E789-4111-A7B9-47EF328D13E6")*/
IDirect3DVolumeTexture9;
 //interface /*DECLSPEC_UUID("FFF32F81-D953-473a-9223-93D652ABA93F")*/
IDirect3DCubeTexture9;

 //interface /*DECLSPEC_UUID("B64BB1B5-FD70-4df6-BF91-19D0A12455E3")*/
IDirect3DVertexBuffer9;
 //interface /*DECLSPEC_UUID("7C9DD65E-D3F7-4529-ACEE-785830ACDE35")*/
IDirect3DIndexBuffer9;

 //interface /*DECLSPEC_UUID("0CFBAF3A-9FF6-429a-99B3-A2796AF8B89B")*/
IDirect3DSurface9;
 //interface /*DECLSPEC_UUID("24F416E6-1F67-4aa7-B88E-D33F6F3128A1")*/
IDirect3DVolume9;

 //interface /*DECLSPEC_UUID("794950F2-ADFC-458a-905E-10A10B0B503B")*/
IDirect3DSwapChain9;
 //interface /*DECLSPEC_UUID("d9771460-a695-4f26-bbd3-27b840b541cc")*/
IDirect3DQuery9;




 import d3d9types;
 import d3d9caps;


 extern (C) {


 /*
  * DLL Function for creating a Direct3D9 object. This object supports
  * enumeration and allows the creation of Direct3DDevice9 objects.
  * Pass the value of the constant D3D_SDK_VERSION to this function, so
  * that the run-time can validate that your application was compiled
  * against the right headers.
  */

 IDirect3D9 * Direct3DCreate9(UINT SDKVersion);


 /*
  * Direct3D interfaces
  */



 interface IDirect3D9 : IUnknown
 {
     /*** IUnknown methods ***/
     HRESULT QueryInterface (REFIID riid, void** ppvObj);
     ULONG AddRef () ;
     ULONG Release () ;

     /*** IDirect3D9 methods ***/
     HRESULT RegisterSoftwareDevice ( void* pInitializeFunction) ;
     UINT  GetAdapterCount () ;
     HRESULT GetAdapterIdentifier ( UINT Adapter,DWORD
Flags,D3DADAPTER_IDENTIFIER9* pIdentifier) ;
     UINT  GetAdapterModeCount ( UINT Adapter,D3DFORMAT Format) ;
     HRESULT EnumAdapterModes ( UINT Adapter,D3DFORMAT Format,UINT
Mode,D3DDISPLAYMODE* pMode) ;
     HRESULT GetAdapterDisplayMode ( UINT Adapter,D3DDISPLAYMODE* pMode) ;
     HRESULT CheckDeviceType ( UINT iAdapter,D3DDEVTYPE DevType,D3DFORMAT
DisplayFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed) ;
     HRESULT CheckDeviceFormat ( UINT Adapter,D3DDEVTYPE
DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE
RType,D3DFORMAT CheckFormat) ;
     HRESULT CheckDeviceMultiSampleType ( UINT Adapter,D3DDEVTYPE
DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE
MultiSampleType,DWORD* pQualityLevels) ;
     HRESULT CheckDepthStencilMatch ( UINT Adapter,D3DDEVTYPE
DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT
DepthStencilFormat) ;
     HRESULT CheckDeviceFormatConversion ( UINT Adapter,D3DDEVTYPE
DeviceType,D3DFORMAT SourceFormat,D3DFORMAT TargetFormat) ;
     HRESULT GetDeviceCaps ( UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9*
pCaps) ;
     HMONITOR  GetAdapterMonitor ( UINT Adapter) ;
     HRESULT CreateDevice ( UINT Adapter,D3DDEVTYPE DeviceType,HWND
hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS*
pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface) ;
 }

 alias IDirect3D9 * LPDIRECT3D9 /*, PDIRECT3D9 */;





 /* SwapChain */



 interface IDirect3DDevice9 : IUnknown
 {
     /*** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

     /*** IDirect3DDevice9 methods ***/
     HRESULT TestCooperativeLevel () ;
     UINT  GetAvailableTextureMem () ;
     HRESULT EvictManagedResources () ;
     HRESULT GetDirect3D ( IDirect3D9** ppD3D9) ;
     HRESULT GetDeviceCaps ( D3DCAPS9* pCaps) ;
     HRESULT GetDisplayMode ( UINT iSwapChain,D3DDISPLAYMODE* pMode) ;
     HRESULT GetCreationParameters ( D3DDEVICE_CREATION_PARAMETERS
*pParameters) ;
     HRESULT SetCursorProperties ( UINT XHotSpot,UINT
YHotSpot,IDirect3DSurface9* pCursorBitmap) ;
     void  SetCursorPosition ( int X,int Y,DWORD Flags) ;
     BOOL  ShowCursor ( BOOL bShow) ;
     HRESULT CreateAdditionalSwapChain ( D3DPRESENT_PARAMETERS*
pPresentationParameters,IDirect3DSwapChain9** pSwapChain) ;
     HRESULT GetSwapChain ( UINT iSwapChain,IDirect3DSwapChain9**
pSwapChain) ;
     UINT  GetNumberOfSwapChains () ;
     HRESULT Reset ( D3DPRESENT_PARAMETERS* pPresentationParameters) ;
     HRESULT Present (  RECT* pSourceRect, RECT* pDestRect,HWND
hDestWindowOverride, RGNDATA* pDirtyRegion) ;
     HRESULT GetBackBuffer ( UINT iSwapChain,UINT
iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer) ;
     HRESULT GetRasterStatus ( UINT iSwapChain,D3DRASTER_STATUS*
pRasterStatus) ;
     HRESULT SetDialogBoxMode ( BOOL bEnableDialogs) ;
     void  SetGammaRamp ( UINT iSwapChain,DWORD Flags, D3DGAMMARAMP* pRamp)
;
     void  GetGammaRamp ( UINT iSwapChain,D3DGAMMARAMP* pRamp) ;
     HRESULT CreateTexture ( UINT Width,UINT Height,UINT Levels,DWORD
Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,HANDLE*
pSharedHandle) ;
     HRESULT CreateVolumeTexture ( UINT Width,UINT Height,UINT Depth,UINT
Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9**
ppVolumeTexture,HANDLE* pSharedHandle) ;
     HRESULT CreateCubeTexture ( UINT EdgeLength,UINT Levels,DWORD
Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9**
ppCubeTexture,HANDLE* pSharedHandle) ;
     HRESULT CreateVertexBuffer ( UINT Length,DWORD Usage,DWORD FVF,D3DPOOL
Pool,IDirect3DVertexBuffer9** ppVertexBuffer,HANDLE* pSharedHandle) ;
     HRESULT CreateIndexBuffer ( UINT Length,DWORD Usage,D3DFORMAT
Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE*
pSharedHandle) ;
     HRESULT CreateRenderTarget ( UINT Width,UINT Height,D3DFORMAT
Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL
Lockable,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) ;
     HRESULT CreateDepthStencilSurface ( UINT Width,UINT Height,D3DFORMAT
Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL
Discard,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) ;
     HRESULT UpdateSurface ( IDirect3DSurface9* pSourceSurface, RECT*
pSourceRect,IDirect3DSurface9* pDestinationSurface, POINT* pDestPoint) ;
     HRESULT UpdateTexture ( IDirect3DBaseTexture9*
pSourceTexture,IDirect3DBaseTexture9* pDestinationTexture) ;
     HRESULT GetRenderTargetData ( IDirect3DSurface9*
pRenderTarget,IDirect3DSurface9* pDestSurface) ;
     HRESULT GetFrontBufferData ( UINT iSwapChain,IDirect3DSurface9*
pDestSurface) ;
     HRESULT StretchRect ( IDirect3DSurface9* pSourceSurface, RECT*
pSourceRect,IDirect3DSurface9* pDestSurface, RECT*
pDestRect,D3DTEXTUREFILTERTYPE Filter) ;
     HRESULT ColorFill ( IDirect3DSurface9* pSurface, RECT* pRect,D3DCOLOR
color) ;
     HRESULT CreateOffscreenPlainSurface ( UINT Width,UINT Height,D3DFORMAT
Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) ;
     HRESULT SetRenderTarget ( DWORD RenderTargetIndex,IDirect3DSurface9*
pRenderTarget) ;
     HRESULT GetRenderTarget ( DWORD RenderTargetIndex,IDirect3DSurface9**
ppRenderTarget) ;
     HRESULT SetDepthStencilSurface ( IDirect3DSurface9* pNewZStencil) ;
     HRESULT GetDepthStencilSurface ( IDirect3DSurface9** ppZStencilSurface)
;
     HRESULT BeginScene () ;
     HRESULT EndScene () ;
     HRESULT Clear ( DWORD Count, D3DRECT* pRects,DWORD Flags,D3DCOLOR
Color,float Z,DWORD Stencil) ;
     HRESULT SetTransform ( D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix)
;
     HRESULT GetTransform ( D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix)
;
     HRESULT MultiplyTransform ( D3DTRANSFORMSTATETYPE, D3DMATRIX*) ;
     HRESULT SetViewport (  D3DVIEWPORT9* pViewport) ;
     HRESULT GetViewport ( D3DVIEWPORT9* pViewport) ;
     HRESULT SetMaterial (  D3DMATERIAL9* pMaterial) ;
     HRESULT GetMaterial ( D3DMATERIAL9* pMaterial) ;
     HRESULT SetLight ( DWORD Index, D3DLIGHT9*) ;
     HRESULT GetLight ( DWORD Index,D3DLIGHT9*) ;
     HRESULT LightEnable ( DWORD Index,BOOL Enable) ;
     HRESULT GetLightEnable ( DWORD Index,BOOL* pEnable) ;
     HRESULT SetClipPlane ( DWORD Index, float* pPlane) ;
     HRESULT GetClipPlane ( DWORD Index,float* pPlane) ;
     HRESULT SetRenderState ( D3DRENDERSTATETYPE State,DWORD Value) ;
     HRESULT GetRenderState ( D3DRENDERSTATETYPE State,DWORD* pValue) ;
     HRESULT CreateStateBlock ( D3DSTATEBLOCKTYPE
Type,IDirect3DStateBlock9** ppSB) ;
     HRESULT BeginStateBlock () ;
     HRESULT EndStateBlock ( IDirect3DStateBlock9** ppSB) ;
     HRESULT SetClipStatus (  D3DCLIPSTATUS9* pClipStatus) ;
     HRESULT GetClipStatus ( D3DCLIPSTATUS9* pClipStatus) ;
     HRESULT GetTexture ( DWORD Stage,IDirect3DBaseTexture9** ppTexture) ;
     HRESULT SetTexture ( DWORD Stage,IDirect3DBaseTexture9* pTexture) ;
     HRESULT GetTextureStageState ( DWORD Stage,D3DTEXTURESTAGESTATETYPE
Type,DWORD* pValue) ;
     HRESULT SetTextureStageState ( DWORD Stage,D3DTEXTURESTAGESTATETYPE
Type,DWORD Value) ;
     HRESULT GetSamplerState ( DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD*
pValue) ;
     HRESULT SetSamplerState ( DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD
Value) ;
     HRESULT ValidateDevice ( DWORD* pNumPasses) ;
     HRESULT SetPaletteEntries ( UINT PaletteNumber, PALETTEENTRY* pEntries)
;
     HRESULT GetPaletteEntries ( UINT PaletteNumber,PALETTEENTRY* pEntries)
;
     HRESULT SetCurrentTexturePalette ( UINT PaletteNumber) ;
     HRESULT GetCurrentTexturePalette ( UINT *PaletteNumber) ;
     HRESULT SetScissorRect (  RECT* pRect) ;
     HRESULT GetScissorRect ( RECT* pRect) ;
     HRESULT SetSoftwareVertexProcessing ( BOOL bSoftware) ;
     BOOL  GetSoftwareVertexProcessing () ;
     HRESULT SetNPatchMode ( float nSegments) ;
     float  GetNPatchMode () ;
     HRESULT DrawPrimitive ( D3DPRIMITIVETYPE PrimitiveType,UINT
StartVertex,UINT PrimitiveCount) ;
     HRESULT DrawIndexedPrimitive ( D3DPRIMITIVETYPE,INT
BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT
primCount) ;
     HRESULT DrawPrimitiveUP ( D3DPRIMITIVETYPE PrimitiveType,UINT
PrimitiveCount, void* pVertexStreamZeroData,UINT VertexStreamZeroStride) ;
     HRESULT DrawIndexedPrimitiveUP ( D3DPRIMITIVETYPE PrimitiveType,UINT
MinVertexIndex,UINT NumVertices,UINT PrimitiveCount, void*
pIndexData,D3DFORMAT IndexDataFormat, void* pVertexStreamZeroData,UINT
VertexStreamZeroStride) ;
     HRESULT ProcessVertices ( UINT SrcStartIndex,UINT DestIndex,UINT
VertexCount,IDirect3DVertexBuffer9* pDestBuffer,IDirect3DVertexDeclaration9*
pVertexDecl,DWORD Flags) ;
     HRESULT CreateVertexDeclaration (  D3DVERTEXELEMENT9*
pVertexElements,IDirect3DVertexDeclaration9** ppDecl) ;
     HRESULT SetVertexDeclaration ( IDirect3DVertexDeclaration9* pDecl) ;
     HRESULT GetVertexDeclaration ( IDirect3DVertexDeclaration9** ppDecl) ;
     HRESULT SetFVF ( DWORD FVF) ;
     HRESULT GetFVF ( DWORD* pFVF) ;
     HRESULT CreateVertexShader (  DWORD* pFunction,IDirect3DVertexShader9**
ppShader) ;
     HRESULT SetVertexShader ( IDirect3DVertexShader9* pShader) ;
     HRESULT GetVertexShader ( IDirect3DVertexShader9** ppShader) ;
     HRESULT SetVertexShaderConstantF ( UINT StartRegister, float*
pConstantData,UINT Vector4fCount) ;
     HRESULT GetVertexShaderConstantF ( UINT StartRegister,float*
pConstantData,UINT Vector4fCount) ;
     HRESULT SetVertexShaderConstantI ( UINT StartRegister, int*
pConstantData,UINT Vector4iCount) ;
     HRESULT GetVertexShaderConstantI ( UINT StartRegister,int*
pConstantData,UINT Vector4iCount) ;
     HRESULT SetVertexShaderConstantB ( UINT StartRegister, BOOL*
pConstantData,UINT  BoolCount) ;
     HRESULT GetVertexShaderConstantB ( UINT StartRegister,BOOL*
pConstantData,UINT BoolCount) ;
     HRESULT SetStreamSource ( UINT StreamNumber,IDirect3DVertexBuffer9*
pStreamData,UINT OffsetInBytes,UINT Stride) ;
     HRESULT GetStreamSource ( UINT StreamNumber,IDirect3DVertexBuffer9**
ppStreamData,UINT* OffsetInBytes,UINT* pStride) ;
     HRESULT SetStreamSourceFreq ( UINT StreamNumber,UINT Divider) ;
     HRESULT GetStreamSourceFreq ( UINT StreamNumber,UINT* Divider) ;
     HRESULT SetIndices ( IDirect3DIndexBuffer9* pIndexData) ;
     HRESULT GetIndices ( IDirect3DIndexBuffer9** ppIndexData) ;
     HRESULT CreatePixelShader (  DWORD* pFunction,IDirect3DPixelShader9**
ppShader) ;
     HRESULT SetPixelShader ( IDirect3DPixelShader9* pShader) ;
     HRESULT GetPixelShader ( IDirect3DPixelShader9** ppShader) ;
     HRESULT SetPixelShaderConstantF ( UINT StartRegister, float*
pConstantData,UINT Vector4fCount) ;
     HRESULT GetPixelShaderConstantF ( UINT StartRegister,float*
pConstantData,UINT Vector4fCount) ;
     HRESULT SetPixelShaderConstantI ( UINT StartRegister, int*
pConstantData,UINT Vector4iCount) ;
     HRESULT GetPixelShaderConstantI ( UINT StartRegister,int*
pConstantData,UINT Vector4iCount) ;
     HRESULT SetPixelShaderConstantB ( UINT StartRegister, BOOL*
pConstantData,UINT  BoolCount) ;
     HRESULT GetPixelShaderConstantB ( UINT StartRegister,BOOL*
pConstantData,UINT BoolCount) ;
     HRESULT DrawRectPatch ( UINT Handle, float* pNumSegs,
D3DRECTPATCH_INFO* pRectPatchInfo) ;
     HRESULT DrawTriPatch ( UINT Handle, float* pNumSegs, D3DTRIPATCH_INFO*
pTriPatchInfo) ;
     HRESULT DeletePatch ( UINT Handle) ;
     HRESULT CreateQuery ( D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery) ;
 }

 alias IDirect3DDevice9* LPDIRECT3DDEVICE9, PDIRECT3DDEVICE9;



 interface IDirect3DStateBlock9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DStateBlock9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT Capture () ;
     HRESULT Apply () ;
 }

 alias IDirect3DStateBlock9* LPDIRECT3DSTATEBLOCK9, PDIRECT3DSTATEBLOCK9;




 interface IDirect3DSwapChain9 : IUnknown
 {
     /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DSwapChain9 methods ***/
     HRESULT Present (  RECT* pSourceRect, RECT* pDestRect,HWND
hDestWindowOverride, RGNDATA* pDirtyRegion,DWORD dwFlags) ;
     HRESULT GetFrontBufferData ( IDirect3DSurface9* pDestSurface) ;
     HRESULT GetBackBuffer ( UINT iBackBuffer,D3DBACKBUFFER_TYPE
Type,IDirect3DSurface9** ppBackBuffer) ;
     HRESULT GetRasterStatus ( D3DRASTER_STATUS* pRasterStatus) ;
     HRESULT GetDisplayMode ( D3DDISPLAYMODE* pMode) ;
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT GetPresentParameters ( D3DPRESENT_PARAMETERS*
pPresentationParameters) ;
 }

 alias IDirect3DSwapChain9* LPDIRECT3DSWAPCHAIN9, PDIRECT3DSWAPCHAIN9;



 interface IDirect3DResource9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
 }

 alias IDirect3DResource9* LPDIRECT3DRESOURCE9, PDIRECT3DRESOURCE9;




 interface IDirect3DVertexDeclaration9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DVertexDeclaration9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT GetDeclaration ( D3DVERTEXELEMENT9*,UINT* pNumElements) ;
 }

 alias IDirect3DVertexDeclaration9* LPDIRECT3DVERTEXDECLARATION9,
PDIRECT3DVERTEXDECLARATION9;




 interface IDirect3DVertexShader9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DVertexShader9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT GetFunction ( void*,UINT* pSizeOfData) ;
 }

 alias IDirect3DVertexShader9* LPDIRECT3DVERTEXSHADER9,
PDIRECT3DVERTEXSHADER9;




 interface IDirect3DPixelShader9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DPixelShader9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT GetFunction ( void*,UINT* pSizeOfData) ;
 }

 alias IDirect3DPixelShader9* LPDIRECT3DPIXELSHADER9, PDIRECT3DPIXELSHADER9;




 interface IDirect3DBaseTexture9 : IDirect3DResource9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     DWORD  SetLOD ( DWORD LODNew) ;
     DWORD  GetLOD () ;
     DWORD  GetLevelCount () ;
     HRESULT SetAutoGenFilterType ( D3DTEXTUREFILTERTYPE FilterType) ;
     D3DTEXTUREFILTERTYPE  GetAutoGenFilterType () ;
     void  GenerateMipSubLevels () ;
 }

 alias IDirect3DBaseTexture9* LPDIRECT3DBASETEXTURE9, PDIRECT3DBASETEXTURE9;




 interface IDirect3DTexture9 : IDirect3DBaseTexture9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DBaseTexture9 methods ***/
     HRESULT  GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT  SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT  GetPrivateData ( REFIID refguid,void* pData,DWORD*
pSizeOfData) ;
     HRESULT  FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     DWORD  SetLOD ( DWORD LODNew) ;
     DWORD  GetLOD () ;
     DWORD  GetLevelCount () ;
     HRESULT SetAutoGenFilterType ( D3DTEXTUREFILTERTYPE FilterType) ;
     D3DTEXTUREFILTERTYPE  GetAutoGenFilterType () ;
     void  GenerateMipSubLevels () ;
     HRESULT  GetLevelDesc ( UINT Level,D3DSURFACE_DESC *pDesc) ;
     HRESULT  GetSurfaceLevel ( UINT Level,IDirect3DSurface9**
ppSurfaceLevel) ;
     HRESULT  LockRect ( UINT Level,D3DLOCKED_RECT* pLockedRect, RECT*
pRect,DWORD Flags) ;
     HRESULT  UnlockRect ( UINT Level) ;
     HRESULT  AddDirtyRect (  RECT* pDirtyRect) ;
 }

 alias IDirect3DTexture9* LPDIRECT3DTEXTURE9, PDIRECT3DTEXTURE9;





 interface IDirect3DVolumeTexture9 : IDirect3DBaseTexture9
 {
      /* ** IUnknown methods ***/
     HRESULT  QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DBaseTexture9 methods ***/
     HRESULT  GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT  SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT  GetPrivateData ( REFIID refguid,void* pData,DWORD*
pSizeOfData) ;
     HRESULT  FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     DWORD  SetLOD ( DWORD LODNew) ;
     DWORD  GetLOD () ;
     DWORD  GetLevelCount () ;
     HRESULT  SetAutoGenFilterType ( D3DTEXTUREFILTERTYPE FilterType) ;
     D3DTEXTUREFILTERTYPE  GetAutoGenFilterType () ;
     void  GenerateMipSubLevels () ;
     HRESULT  GetLevelDesc ( UINT Level,D3DVOLUME_DESC *pDesc) ;
     HRESULT  GetVolumeLevel ( UINT Level,IDirect3DVolume9** ppVolumeLevel)
;
     HRESULT  LockBox ( UINT Level,D3DLOCKED_BOX* pLockedVolume, D3DBOX*
pBox,DWORD Flags) ;
     HRESULT  UnlockBox ( UINT Level) ;
     HRESULT  AddDirtyBox (  D3DBOX* pDirtyBox) ;
 }

 alias IDirect3DVolumeTexture9* LPDIRECT3DVOLUMETEXTURE9,
PDIRECT3DVOLUMETEXTURE9;





 interface IDirect3DCubeTexture9 : IDirect3DBaseTexture9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DBaseTexture9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     DWORD  SetLOD ( DWORD LODNew) ;
     DWORD  GetLOD () ;
     DWORD  GetLevelCount () ;
     HRESULT SetAutoGenFilterType ( D3DTEXTUREFILTERTYPE FilterType) ;
     D3DTEXTUREFILTERTYPE  GetAutoGenFilterType () ;
     void  GenerateMipSubLevels () ;
     HRESULT GetLevelDesc ( UINT Level,D3DSURFACE_DESC *pDesc) ;
     HRESULT GetCubeMapSurface ( D3DCUBEMAP_FACES FaceType,UINT
Level,IDirect3DSurface9** ppCubeMapSurface) ;
     HRESULT LockRect ( D3DCUBEMAP_FACES FaceType,UINT Level,D3DLOCKED_RECT*
pLockedRect, RECT* pRect,DWORD Flags) ;
     HRESULT UnlockRect ( D3DCUBEMAP_FACES FaceType,UINT Level) ;
     HRESULT AddDirtyRect ( D3DCUBEMAP_FACES FaceType, RECT* pDirtyRect) ;
 }

 alias IDirect3DCubeTexture9* LPDIRECT3DCUBETEXTURE9, PDIRECT3DCUBETEXTURE9;




 interface IDirect3DVertexBuffer9  : IDirect3DResource9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     HRESULT Lock ( UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD
Flags) ;
     HRESULT Unlock () ;
     HRESULT GetDesc ( D3DVERTEXBUFFER_DESC *pDesc) ;
 }

 alias IDirect3DVertexBuffer9* LPDIRECT3DVERTEXBUFFER9,
PDIRECT3DVERTEXBUFFER9;




 interface IDirect3DIndexBuffer9 : IDirect3DResource9
 {
     /*** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

     /*** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     HRESULT Lock ( UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD
Flags) ;
     HRESULT Unlock () ;
     HRESULT GetDesc ( D3DINDEXBUFFER_DESC *pDesc) ;
 }

 alias IDirect3DIndexBuffer9* LPDIRECT3DINDEXBUFFER9, PDIRECT3DINDEXBUFFER9;




 interface IDirect3DSurface9 : IDirect3DResource9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     HRESULT GetContainer ( REFIID riid,void** ppContainer) ;
     HRESULT GetDesc ( D3DSURFACE_DESC *pDesc) ;
     HRESULT LockRect ( D3DLOCKED_RECT* pLockedRect, RECT* pRect,DWORD
Flags) ;
     HRESULT UnlockRect () ;
     HRESULT GetDC ( HDC *phdc) ;
     HRESULT ReleaseDC ( HDC hdc) ;
 }

 alias IDirect3DSurface9* LPDIRECT3DSURFACE9, PDIRECT3DSURFACE9;




 interface IDirect3DVolume9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DVolume9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     HRESULT GetContainer ( REFIID riid,void** ppContainer) ;
     HRESULT GetDesc ( D3DVOLUME_DESC *pDesc) ;
     HRESULT LockBox ( D3DLOCKED_BOX * pLockedVolume, D3DBOX* pBox,DWORD
Flags) ;
     HRESULT UnlockBox () ;
 }

 alias IDirect3DVolume9* LPDIRECT3DVOLUME9, PDIRECT3DVOLUME9;





 interface IDirect3DQuery9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DQuery9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     D3DQUERYTYPE  GetType () ;
     DWORD  GetDataSize () ;
     HRESULT Issue ( DWORD dwIssueFlags) ;
     HRESULT GetData ( void* pData,DWORD dwSize,DWORD dwGetDataFlags) ;
 }

 alias IDirect3DQuery9* LPDIRECT3DQUERY9, PDIRECT3DQUERY9;





/***************************************************************************
*
  * Flags for SetPrivateData method on all D3D9 interfaces
  *
  * The passed pointer is an IUnknown ptr. The SizeOfData argument to
SetPrivateData
  * must be set to sizeof(IUnknown*). Direct3D will call AddRef through this
  * pointer and Release when the private data is destroyed. The data will be
  * destroyed when another SetPrivateData with the same GUID is set, when
  * FreePrivateData is called, or when the D3D9 object is freed.

****************************************************************************
/
 const int D3DSPD_IUNKNOWN                  =    0x00000001L;


/***************************************************************************
*
  *
  *  Flags for IDirect3D9::CreateDevice's BehaviorFlags
  *

****************************************************************************
/

 const int D3DCREATE_FPU_PRESERVE               =   0x00000002L;
 const int D3DCREATE_MULTITHREADED              =   0x00000004L;

 const int D3DCREATE_PUREDEVICE                 =   0x00000010L;
 const int D3DCREATE_SOFTWARE_VERTEXPROCESSING  =   0x00000020L;
 const int D3DCREATE_HARDWARE_VERTEXPROCESSING  =   0x00000040L;
 const int D3DCREATE_MIXED_VERTEXPROCESSING     =   0x00000080L;

 const int D3DCREATE_DISABLE_DRIVER_MANAGEMENT  =   0x00000100L;
 const int D3DCREATE_ADAPTERGROUP_DEVICE        =   0x00000200L;



/***************************************************************************
*
  *
  *  Parameter for IDirect3D9::CreateDevice's iAdapter
  *

****************************************************************************
/

 const int D3DADAPTER_DEFAULT                   =  0;


/***************************************************************************
*
  *
  *  Flags for IDirect3D9::EnumAdapters
  *

****************************************************************************
/

 const int D3DENUM_WHQL_LEVEL                   =   0x00000002L;


/***************************************************************************
*
  *
  *  Maximum number of back-buffers supported in DX8
  *

****************************************************************************
/

 const int D3DPRESENT_BACK_BUFFERS_MAX          =   3L;


/***************************************************************************
*
  *
  *  Flags for IDirect3DDevice9::SetGammaRamp
  *

****************************************************************************
/

 const int D3DSGR_NO_CALIBRATION                =  0x00000000L;
 const int D3DSGR_CALIBRATE                     =  0x00000001L;


/***************************************************************************
*
  *
  *  Flags for IDirect3DDevice9::SetCursorPosition
  *

****************************************************************************
/

 const int D3DCURSOR_IMMEDIATE_UPDATE           =  0x00000001L;


/***************************************************************************
*
  *
  *  Flags for IDirect3DSwapChain9::Present
  *

****************************************************************************
/

 const int D3DPRESENT_DONOTWAIT                 =  0x00000001L;
 const int D3DPRESENT_LINEAR_CONTENT            =  0x00000002L;


/***************************************************************************
*
  *
  *  Flags for DrawPrimitive/DrawIndexedPrimitive
  *   Also valid for Begin/BeginIndexed
  *   Also valid for VertexBuffer::CreateVertexBuffer

****************************************************************************
/


 /*
  *  DirectDraw error codes
  */
 const int _FACD3D   = 0x876;
 /*
 #define MAKE_D3DHRESULT( code )  MAKE_HRESULT( 1, _FACD3D, code )
 #define MAKE_D3DSTATUS( code )  MAKE_HRESULT( 0, _FACD3D, code )

 /*
  * Direct3D Errors
  */
 /*
 #define D3D_OK                              S_OK

 #define D3DERR_WRONGTEXTUREFORMAT               MAKE_D3DHRESULT(2072)
 #define D3DERR_UNSUPPORTEDCOLOROPERATION        MAKE_D3DHRESULT(2073)
 #define D3DERR_UNSUPPORTEDCOLORARG              MAKE_D3DHRESULT(2074)
 #define D3DERR_UNSUPPORTEDALPHAOPERATION        MAKE_D3DHRESULT(2075)
 #define D3DERR_UNSUPPORTEDALPHAARG              MAKE_D3DHRESULT(2076)
 #define D3DERR_TOOMANYOPERATIONS                MAKE_D3DHRESULT(2077)
 #define D3DERR_CONFLICTINGTEXTUREFILTER         MAKE_D3DHRESULT(2078)
 #define D3DERR_UNSUPPORTEDFACTORVALUE           MAKE_D3DHRESULT(2079)
 #define D3DERR_CONFLICTINGRENDERSTATE           MAKE_D3DHRESULT(2081)
 #define D3DERR_UNSUPPORTEDTEXTUREFILTER         MAKE_D3DHRESULT(2082)
 #define D3DERR_CONFLICTINGTEXTUREPALETTE        MAKE_D3DHRESULT(2086)
 #define D3DERR_DRIVERINTERNALERROR              MAKE_D3DHRESULT(2087)

 #define D3DERR_NOTFOUND                         MAKE_D3DHRESULT(2150)
 #define D3DERR_MOREDATA                         MAKE_D3DHRESULT(2151)
 #define D3DERR_DEVICELOST                       MAKE_D3DHRESULT(2152)
 #define D3DERR_DEVICENOTRESET                   MAKE_D3DHRESULT(2153)
 #define D3DERR_NOTAVAILABLE                     MAKE_D3DHRESULT(2154)
 #define D3DERR_OUTOFVIDEOMEMORY                 MAKE_D3DHRESULT(380)
 #define D3DERR_INVALIDDEVICE                    MAKE_D3DHRESULT(2155)
 #define D3DERR_INVALIDCALL                      MAKE_D3DHRESULT(2156)
 #define D3DERR_DRIVERINVALIDCALL                MAKE_D3DHRESULT(2157)
 #define D3DERR_WASSTILLDRAWING                  MAKE_D3DHRESULT(540)
 #define D3DOK_NOAUTOGEN                         MAKE_D3DSTATUS(2159)

 */


 }  //  extern (C)

//} // version DIRECTX9
////////////////////////////////////////////////////////////////////////////
//////


////
d3d9caps.d
/////////////////////////////////////////////////

// Author : Ahmed El-Metwaly
// contact : aelmetwaly gawa.com
// Lic     : GPL

/*==========================================================================
;
 *
 *  Copyright (C) Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       d3d9caps.h
 *  Content:    Direct3D capabilities include file
 *

***************************************************************************/

import std.c.stdio;
import std.c.stdlib;
import std.string;
import std.c.windows.windows;
import std.c.windows.com;
import d3d9types;

const int DIRECT3D_VERSION     =    0x0900;


// include this file content only if compiling for DX9 interfaces
//version(DIRECT3D_VERSION )
//{
 align (4){


 struct _D3DVSHADERCAPS2_0
 {
         DWORD Caps;
         INT DynamicFlowControlDepth;
         INT NumTemps;
         INT StaticFlowControlDepth;
 }

 alias _D3DVSHADERCAPS2_0 D3DVSHADERCAPS2_0;

 const int D3DVS20CAPS_PREDICATION     =        (1<<0);

 const int D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH = 24;
 const int D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0;
 const int D3DVS20_MAX_NUMTEMPS  =  32;
 const int D3DVS20_MIN_NUMTEMPS  =  12;
 const int D3DVS20_MAX_STATICFLOWCONTROLDEPTH  =  4;
 const int D3DVS20_MIN_STATICFLOWCONTROLDEPTH  =  1;

 struct _D3DPSHADERCAPS2_0
 {
     DWORD Caps;
     INT DynamicFlowControlDepth;
     INT NumTemps;
     INT StaticFlowControlDepth;
     INT NumInstructionSlots;
 }

 alias _D3DPSHADERCAPS2_0 D3DPSHADERCAPS2_0;

 const int D3DPS20CAPS_ARBITRARYSWIZZLE       = (1<<0);
 const int D3DPS20CAPS_GRADIENTINSTRUCTIONS   = (1<<1);
 const int D3DPS20CAPS_PREDICATION            = (1<<2);
 const int D3DPS20CAPS_NODEPENDENTREADLIMIT   = (1<<3);
 const int D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT  = (1<<4);

 const int D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH   = 24;
 const int D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH   = 0;
 const int D3DPS20_MAX_NUMTEMPS   = 32;
 const int D3DPS20_MIN_NUMTEMPS   = 12;
 const int D3DPS20_MAX_STATICFLOWCONTROLDEPTH  =  4;
 const int D3DPS20_MIN_STATICFLOWCONTROLDEPTH  =  0;
 const int D3DPS20_MAX_NUMINSTRUCTIONSLOTS   = 512;
 const int D3DPS20_MIN_NUMINSTRUCTIONSLOTS   = 96;

 const int D3DMIN30SHADERINSTRUCTIONS = 512;
 const int D3DMAX30SHADERINSTRUCTIONS = 32768;

 struct _D3DCAPS9
 {
     /* Device Info */
     D3DDEVTYPE  DeviceType;
     UINT        AdapterOrdinal;

     /* Caps from DX7 Draw */
     DWORD   Caps;
     DWORD   Caps2;
     DWORD   Caps3;
     DWORD   PresentationIntervals;

     /* Cursor Caps */
     DWORD   CursorCaps;

     /* 3D Device Caps */
     DWORD   DevCaps;

     DWORD   PrimitiveMiscCaps;
     DWORD   RasterCaps;
     DWORD   ZCmpCaps;
     DWORD   SrcBlendCaps;
     DWORD   DestBlendCaps;
     DWORD   AlphaCmpCaps;
     DWORD   ShadeCaps;
     DWORD   TextureCaps;
     DWORD   TextureFilterCaps;          // D3DPTFILTERCAPS for
IDirect3DTexture9's
     DWORD   CubeTextureFilterCaps;      // D3DPTFILTERCAPS for
IDirect3DCubeTexture9's
     DWORD   VolumeTextureFilterCaps;    // D3DPTFILTERCAPS for
IDirect3DVolumeTexture9's
     DWORD   TextureAddressCaps;         // D3DPTADDRESSCAPS for
IDirect3DTexture9's
     DWORD   VolumeTextureAddressCaps;   // D3DPTADDRESSCAPS for
IDirect3DVolumeTexture9's

     DWORD   LineCaps;                   // D3DLINECAPS

     DWORD   MaxTextureWidth, MaxTextureHeight;
     DWORD   MaxVolumeExtent;

     DWORD   MaxTextureRepeat;
     DWORD   MaxTextureAspectRatio;
     DWORD   MaxAnisotropy;
     float   MaxVertexW;

     float   GuardBandLeft;
     float   GuardBandTop;
     float   GuardBandRight;
     float   GuardBandBottom;

     float   ExtentsAdjust;
     DWORD   StencilCaps;

     DWORD   FVFCaps;
     DWORD   TextureOpCaps;
     DWORD   MaxTextureBlendStages;
     DWORD   MaxSimultaneousTextures;

     DWORD   VertexProcessingCaps;
     DWORD   MaxActiveLights;
     DWORD   MaxUserClipPlanes;
     DWORD   MaxVertexBlendMatrices;
     DWORD   MaxVertexBlendMatrixIndex;

     float   MaxPointSize;

     DWORD   MaxPrimitiveCount;          // max number of primitives per
DrawPrimitive call
     DWORD   MaxVertexIndex;
     DWORD   MaxStreams;
     DWORD   MaxStreamStride;            // max stride for SetStreamSource

     DWORD   VertexShaderVersion;
     DWORD   MaxVertexShaderConst;       // number of vertex shader constant
registers

     DWORD   PixelShaderVersion;
     float   PixelShader1xMaxValue;      // max value storable in registers
of ps.1.x shaders

     // Here are the DX9 specific ones
     DWORD   DevCaps2;

     float   MaxNpatchTessellationLevel;
     DWORD   Reserved5;

     UINT    MasterAdapterOrdinal;       // ordinal of master adaptor for
adapter group
     UINT    AdapterOrdinalInGroup;      // ordinal inside the adapter group
     UINT    NumberOfAdaptersInGroup;    // number of adapters in this
adapter group (only if master)
     DWORD   DeclTypes;                  // Data types, supported in vertex
declarations
     DWORD   NumSimultaneousRTs;         // Will be at least 1
     DWORD   StretchRectFilterCaps;      // Filter caps supported by
StretchRect
     D3DVSHADERCAPS2_0 VS20Caps;
     D3DPSHADERCAPS2_0 PS20Caps;
     DWORD   VertexTextureFilterCaps;    // D3DPTFILTERCAPS for
IDirect3DTexture9's for texture, used in vertex shaders
     DWORD   MaxVShaderInstructionsExecuted; // maximum number of vertex
shader instructions that can be executed
     DWORD   MaxPShaderInstructionsExecuted; // maximum number of pixel
shader instructions that can be executed
     DWORD   MaxVertexShader30InstructionSlots;
     DWORD   MaxPixelShader30InstructionSlots;
 }

 alias _D3DCAPS9 D3DCAPS9;

 //
 // BIT DEFINES FOR D3DCAPS9 DWORD MEMBERS
 //

 //
 // Caps
 //
 const int D3DCAPS_READ_SCANLINE        =   0x00020000L;

 //
 // Caps2
 //
 const int D3DCAPS2_FULLSCREENGAMMA     =   0x00020000L;
 const int D3DCAPS2_CANCALIBRATEGAMMA   =   0x00100000L;
 const int D3DCAPS2_RESERVED            =   0x02000000L;
 const int D3DCAPS2_CANMANAGERESOURCE   =   0x10000000L;
 const int D3DCAPS2_DYNAMICTEXTURES     =   0x20000000L;
 const int D3DCAPS2_CANAUTOGENMIPMAP    =   0x40000000L;

 //
 // Caps3
 //
 const long D3DCAPS3_RESERVED            =   0x8000001fL;

 // Indicates that the device can respect the ALPHABLENDENABLE render state
 // when fullscreen while using the FLIP or DISCARD swap effect.
 // COPY and COPYVSYNC swap effects work whether or not this flag is set.
 const int D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD  = 0x00000020L;

 // Indicates that the device can perform a gamma correction from
 // a windowed back buffer containing linear content to the sRGB desktop.
 const int D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION = 0x00000080L;

 const int D3DCAPS3_COPY_TO_VIDMEM       =  0x00000100L; /* Device can
acclerate copies from sysmem to local vidmem */
 const int D3DCAPS3_COPY_TO_SYSTEMMEM    =  0x00000200L; /* Device can
acclerate copies from local vidmem to sysmem */


 //
 // PresentationIntervals
 //
 const int D3DPRESENT_INTERVAL_DEFAULT   =  0x00000000L;
 const int D3DPRESENT_INTERVAL_ONE       =  0x00000001L;
 const int D3DPRESENT_INTERVAL_TWO       =  0x00000002L;
 const int D3DPRESENT_INTERVAL_THREE     =  0x00000004L;
 const int D3DPRESENT_INTERVAL_FOUR      =  0x00000008L;
 const long D3DPRESENT_INTERVAL_IMMEDIATE =  0x80000000L;

 //
 // CursorCaps
 //
 // Driver supports HW color cursor in at least hi-res modes(height >=400)
 const int D3DCURSORCAPS_COLOR          =   0x00000001L;
 // Driver supports HW cursor also in low-res modes(height < 400)
 const int D3DCURSORCAPS_LOWRES         =   0x00000002L;

 //
 // DevCaps
 //
 const int D3DDEVCAPS_EXECUTESYSTEMMEMORY = 0x00000010L; /* Device can use
execute buffers from system memory */
 const int D3DDEVCAPS_EXECUTEVIDEOMEMORY  = 0x00000020L; /* Device can use
execute buffers from video memory */
 const int D3DDEVCAPS_TLVERTEXSYSTEMMEMORY = 0x00000040L; /* Device can use
TL buffers from system memory */
 const int D3DDEVCAPS_TLVERTEXVIDEOMEMORY = 0x00000080L; /* Device can use
TL buffers from video memory */
 const int D3DDEVCAPS_TEXTURESYSTEMMEMORY = 0x00000100L; /* Device can
texture from system memory */
 const int D3DDEVCAPS_TEXTUREVIDEOMEMORY  = 0x00000200L; /* Device can
texture from device memory */
 const int D3DDEVCAPS_DRAWPRIMTLVERTEX    = 0x00000400L; /* Device can draw
TLVERTEX primitives */
 const int D3DDEVCAPS_CANRENDERAFTERFLIP  = 0x00000800L; /* Device can
render without waiting for flip to complete */
 const int D3DDEVCAPS_TEXTURENONLOCALVIDMEM = 0x00001000L; /* Device can
texture from nonlocal video memory */
 const int D3DDEVCAPS_DRAWPRIMITIVES2    =  0x00002000L; /* Device can
support DrawPrimitives2 */
 const int D3DDEVCAPS_SEPARATETEXTUREMEMORIES = 0x00004000L; /* Device is
texturing from separate memory pools */
 const int D3DDEVCAPS_DRAWPRIMITIVES2EX  =  0x00008000L; /* Device can
support Extended DrawPrimitives2 i.e. DX7 compliant driver*/
 const int D3DDEVCAPS_HWTRANSFORMANDLIGHT = 0x00010000L; /* Device can
support transformation and lighting in hardware and DRAWPRIMITIVES2EX must
be also */
 const int D3DDEVCAPS_CANBLTSYSTONONLOCAL = 0x00020000L; /* Device supports
a Tex Blt from system memory to non-local vidmem */
 const int D3DDEVCAPS_HWRASTERIZATION     = 0x00080000L; /* Device has HW
acceleration for rasterization */
 const int D3DDEVCAPS_PUREDEVICE          = 0x00100000L; /* Device supports
D3DCREATE_PUREDEVICE */
 const int D3DDEVCAPS_QUINTICRTPATCHES    = 0x00200000L; /* Device supports
quintic Beziers and BSplines */
 const int D3DDEVCAPS_RTPATCHES           = 0x00400000L; /* Device supports
Rect and Tri patches */
 const int D3DDEVCAPS_RTPATCHHANDLEZERO   = 0x00800000L; /* Indicates that
RT Patches may be drawn efficiently using handle 0 */
 const int D3DDEVCAPS_NPATCHES            = 0x01000000L; /* Device supports
N-Patches */

 //
 // PrimitiveMiscCaps
 //
 const int D3DPMISCCAPS_MASKZ           =   0x00000002L;
 const int D3DPMISCCAPS_CULLNONE        =   0x00000010L;
 const int D3DPMISCCAPS_CULLCW          =   0x00000020L;
 const int D3DPMISCCAPS_CULLCCW         =   0x00000040L;
 const int D3DPMISCCAPS_COLORWRITEENABLE =  0x00000080L;
 const int D3DPMISCCAPS_CLIPPLANESCALEDPOINTS = 0x00000100L; /* Device
correctly clips scaled points to clip planes */
 const int D3DPMISCCAPS_CLIPTLVERTS     =   0x00000200L; /* device will clip
post-transformed vertex primitives */
 const int D3DPMISCCAPS_TSSARGTEMP      =   0x00000400L; /* device supports
D3DTA_TEMP for temporary register */
 const int D3DPMISCCAPS_BLENDOP         =   0x00000800L; /* device supports
D3DRS_BLENDOP */
 const int D3DPMISCCAPS_NULLREFERENCE   =   0x00001000L; /* Reference Device
that doesnt render */
 const int D3DPMISCCAPS_INDEPENDENTWRITEMASKS =    0x00004000L; /* Device
supports independent write masks for MET or MRT */
 const int D3DPMISCCAPS_PERSTAGECONSTANT =  0x00008000L; /* Device supports
per-stage constants */
 const int D3DPMISCCAPS_FOGANDSPECULARALPHA =  0x00010000L; /* Device
supports separate fog and specular alpha (many devices
                                                           use the specular
alpha channel to store fog factor) */
 const int D3DPMISCCAPS_SEPARATEALPHABLEND    =     0x00020000L; /* Device
supports separate blend settings for the alpha channel */
 const int D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS  =  0x00040000L; /* Device
supports different bit depths for MRT */
 const int D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING = 0x00080000L; /* Device
supports post-pixel shader operations for MRT */
 const int D3DPMISCCAPS_FOGVERTEXCLAMPED        =   0x00100000L; /* Device
clamps fog blend factor per vertex */

 //
 // LineCaps
 //
 const int D3DLINECAPS_TEXTURE        =     0x00000001L;
 const int D3DLINECAPS_ZTEST          =     0x00000002L;
 const int D3DLINECAPS_BLEND          =     0x00000004L;
 const int D3DLINECAPS_ALPHACMP       =     0x00000008L;
 const int D3DLINECAPS_FOG            =     0x00000010L;
 const int D3DLINECAPS_ANTIALIAS      =     0x00000020L;

 //
 // RasterCaps
 //
 const int D3DPRASTERCAPS_DITHER          =       0x00000001L;
 const int D3DPRASTERCAPS_ZTEST           =       0x00000010L;
 const int D3DPRASTERCAPS_FOGVERTEX       =       0x00000080L;
 const int D3DPRASTERCAPS_FOGTABLE        =       0x00000100L;
 const int D3DPRASTERCAPS_MIPMAPLODBIAS   =       0x00002000L;
 const int D3DPRASTERCAPS_ZBUFFERLESSHSR  =       0x00008000L;
 const int D3DPRASTERCAPS_FOGRANGE        =       0x00010000L;
 const int D3DPRASTERCAPS_ANISOTROPY      =       0x00020000L;
 const int D3DPRASTERCAPS_WBUFFER         =       0x00040000L;
 const int D3DPRASTERCAPS_WFOG            =       0x00100000L;
 const int D3DPRASTERCAPS_ZFOG            =       0x00200000L;
 const int D3DPRASTERCAPS_COLORPERSPECTIVE    =   0x00400000L; /* Device
iterates colors perspective correct */
 const int D3DPRASTERCAPS_SCISSORTEST         =   0x01000000L;
 const int D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS =   0x02000000L;
 const int D3DPRASTERCAPS_DEPTHBIAS           =   0x04000000L;
 const int D3DPRASTERCAPS_MULTISAMPLE_TOGGLE  =   0x08000000L;

 //
 // ZCmpCaps, AlphaCmpCaps
 //
 const int D3DPCMPCAPS_NEVER         =      0x00000001L;
 const int D3DPCMPCAPS_LESS          =      0x00000002L;
 const int D3DPCMPCAPS_EQUAL         =      0x00000004L;
 const int D3DPCMPCAPS_LESSEQUAL     =      0x00000008L;
 const int D3DPCMPCAPS_GREATER       =      0x00000010L;
 const int D3DPCMPCAPS_NOTEQUAL      =      0x00000020L;
 const int D3DPCMPCAPS_GREATEREQUAL  =      0x00000040L;
 const int D3DPCMPCAPS_ALWAYS        =      0x00000080L;

 //
 // SourceBlendCaps, DestBlendCaps
 //
 const int D3DPBLENDCAPS_ZERO           =   0x00000001L;
 const int D3DPBLENDCAPS_ONE            =   0x00000002L;
 const int D3DPBLENDCAPS_SRCCOLOR       =   0x00000004L;
 const int D3DPBLENDCAPS_INVSRCCOLOR    =   0x00000008L;
 const int D3DPBLENDCAPS_SRCALPHA       =   0x00000010L;
 const int D3DPBLENDCAPS_INVSRCALPHA    =   0x00000020L;
 const int D3DPBLENDCAPS_DESTALPHA      =   0x00000040L;
 const int D3DPBLENDCAPS_INVDESTALPHA   =   0x00000080L;
 const int D3DPBLENDCAPS_DESTCOLOR      =   0x00000100L;
 const int D3DPBLENDCAPS_INVDESTCOLOR   =   0x00000200L;
 const int D3DPBLENDCAPS_SRCALPHASAT    =   0x00000400L;
 const int D3DPBLENDCAPS_BOTHSRCALPHA   =   0x00000800L;
 const int D3DPBLENDCAPS_BOTHINVSRCALPHA =  0x00001000L;
 const int D3DPBLENDCAPS_BLENDFACTOR     =  0x00002000L; /* Supports both
D3DBLEND_BLENDFACTOR and D3DBLEND_INVBLENDFACTOR */

 //
 // ShadeCaps
 //
 const int D3DPSHADECAPS_COLORGOURAUDRGB     =  0x00000008L;
 const int D3DPSHADECAPS_SPECULARGOURAUDRGB  =  0x00000200L;
 const int D3DPSHADECAPS_ALPHAGOURAUDBLEND   =  0x00004000L;
 const int D3DPSHADECAPS_FOGGOURAUD          =  0x00080000L;

 //
 // TextureCaps
 //
 const int D3DPTEXTURECAPS_PERSPECTIVE       =  0x00000001L; /*
Perspective-correct texturing is supported */
 const int D3DPTEXTURECAPS_POW2              =  0x00000002L; /* Power-of-2
texture dimensions are required - applies to non-Cube/Volume textures only.
*/
 const int D3DPTEXTURECAPS_ALPHA             =  0x00000004L; /* Alpha in
texture pixels is supported */
 const int D3DPTEXTURECAPS_SQUAREONLY        =  0x00000020L; /* Only square
textures are supported */
 const int D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE = 0x00000040L; /*
Texture indices are not scaled by the texture size prior to interpolation */
 const int D3DPTEXTURECAPS_ALPHAPALETTE      =  0x00000080L; /* Device can
draw alpha from texture palettes */
 // Device can use non-POW2 textures if:
 //  1) D3DTEXTURE_ADDRESS is set to CLAMP for this texture's stage
 //  2) D3DRS_WRAP(N) is zero for this texture's coordinates
 //  3) mip mapping is not enabled (use magnification filter only)
 const int D3DPTEXTURECAPS_NONPOW2CONDITIONAL = 0x00000100L;
 const int D3DPTEXTURECAPS_PROJECTED          = 0x00000400L; /* Device can
do D3DTTFF_PROJECTED */
 const int D3DPTEXTURECAPS_CUBEMAP            = 0x00000800L; /* Device can
do cubemap textures */
 const int D3DPTEXTURECAPS_VOLUMEMAP         =  0x00002000L; /* Device can
do volume textures */
 const int D3DPTEXTURECAPS_MIPMAP             = 0x00004000L; /* Device can
do mipmapped textures */
 const int D3DPTEXTURECAPS_MIPVOLUMEMAP       = 0x00008000L; /* Device can
do mipmapped volume textures */
 const int D3DPTEXTURECAPS_MIPCUBEMAP         = 0x00010000L; /* Device can
do mipmapped cube maps */
 const int D3DPTEXTURECAPS_CUBEMAP_POW2       = 0x00020000L; /* Device
requires that cubemaps be power-of-2 dimension */
 const int D3DPTEXTURECAPS_VOLUMEMAP_POW2     = 0x00040000L; /* Device
requires that volume maps be power-of-2 dimension */
 const int D3DPTEXTURECAPS_NOPROJECTEDBUMPENV = 0x00200000L; /* Device does
not support projected bump env lookup operation
                                                           in programmable
and fixed function pixel shaders */

 //
 // TextureFilterCaps, StretchRectFilterCaps
 //
 const int D3DPTFILTERCAPS_MINFPOINT         =  0x00000100L; /* Min Filter
*/
 const int D3DPTFILTERCAPS_MINFLINEAR        =  0x00000200L;
 const int D3DPTFILTERCAPS_MINFANISOTROPIC   =  0x00000400L;
 const int D3DPTFILTERCAPS_MINFPYRAMIDALQUAD =  0x00000800L;
 const int D3DPTFILTERCAPS_MINFGAUSSIANQUAD  =  0x00001000L;
 const int D3DPTFILTERCAPS_MIPFPOINT         =  0x00010000L; /* Mip Filter
*/
 const int D3DPTFILTERCAPS_MIPFLINEAR        =  0x00020000L;
 const int D3DPTFILTERCAPS_MAGFPOINT         =  0x01000000L; /* Mag Filter
*/
 const int D3DPTFILTERCAPS_MAGFLINEAR        =  0x02000000L;
 const int D3DPTFILTERCAPS_MAGFANISOTROPIC   =  0x04000000L;
 const int D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD =  0x08000000L;
 const int D3DPTFILTERCAPS_MAGFGAUSSIANQUAD  =  0x10000000L;

 //
 // TextureAddressCaps
 //
 const int D3DPTADDRESSCAPS_WRAP         =  0x00000001L;
 const int D3DPTADDRESSCAPS_MIRROR       =  0x00000002L;
 const int D3DPTADDRESSCAPS_CLAMP        =  0x00000004L;
 const int D3DPTADDRESSCAPS_BORDER        = 0x00000008L;
 const int D3DPTADDRESSCAPS_INDEPENDENTUV = 0x00000010L;
 const int D3DPTADDRESSCAPS_MIRRORONCE    = 0x00000020L;

 //
 // StencilCaps
 //
 const int D3DSTENCILCAPS_KEEP          =   0x00000001L;
 const int D3DSTENCILCAPS_ZERO          =   0x00000002L;
 const int D3DSTENCILCAPS_REPLACE       =   0x00000004L;
 const int D3DSTENCILCAPS_INCRSAT       =   0x00000008L;
 const int D3DSTENCILCAPS_DECRSAT       =   0x00000010L;
 const int D3DSTENCILCAPS_INVERT        =   0x00000020L;
 const int D3DSTENCILCAPS_INCR          =   0x00000040L;
 const int D3DSTENCILCAPS_DECR          =   0x00000080L;
 const int D3DSTENCILCAPS_TWOSIDED      =   0x00000100L;

 //
 // TextureOpCaps
 //
 const int D3DTEXOPCAPS_DISABLE                  =  0x00000001L;
 const int D3DTEXOPCAPS_SELECTARG1               =  0x00000002L;
 const int D3DTEXOPCAPS_SELECTARG2               =  0x00000004L;
 const int D3DTEXOPCAPS_MODULATE                 =  0x00000008L;
 const int D3DTEXOPCAPS_MODULATE2X               =  0x00000010L;
 const int D3DTEXOPCAPS_MODULATE4X               =  0x00000020L;
 const int D3DTEXOPCAPS_ADD                      =  0x00000040L;
 const int D3DTEXOPCAPS_ADDSIGNED                =  0x00000080L;
 const int D3DTEXOPCAPS_ADDSIGNED2X              =  0x00000100L;
 const int D3DTEXOPCAPS_SUBTRACT                 =  0x00000200L;
 const int D3DTEXOPCAPS_ADDSMOOTH                =  0x00000400L;
 const int D3DTEXOPCAPS_BLENDDIFFUSEALPHA        =  0x00000800L;
 const int D3DTEXOPCAPS_BLENDTEXTUREALPHA        =  0x00001000L;
 const int D3DTEXOPCAPS_BLENDFACTORALPHA         =  0x00002000L;
 const int D3DTEXOPCAPS_BLENDTEXTUREALPHAPM      =  0x00004000L;
 const int D3DTEXOPCAPS_BLENDCURRENTALPHA        =  0x00008000L;
 const int D3DTEXOPCAPS_PREMODULATE              =  0x00010000L;
 const int D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR   =  0x00020000L;
 const int D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA   =  0x00040000L;
 const int D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR =  0x00080000L;
 const int D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA = 0x00100000L;
 const int D3DTEXOPCAPS_BUMPENVMAP               =  0x00200000L;
 const int D3DTEXOPCAPS_BUMPENVMAPLUMINANCE      =  0x00400000L;
 const int D3DTEXOPCAPS_DOTPRODUCT3              =  0x00800000L;
 const int D3DTEXOPCAPS_MULTIPLYADD              =  0x01000000L;
 const int D3DTEXOPCAPS_LERP                     =  0x02000000L;

 //
 // FVFCaps
 //
 const int D3DFVFCAPS_TEXCOORDCOUNTMASK   = 0x0000ffffL; /* mask for texture
coordinate count field */
 const int D3DFVFCAPS_DONOTSTRIPELEMENTS  = 0x00080000L; /* Device prefers
that vertex elements not be stripped */
 const int D3DFVFCAPS_PSIZE               = 0x00100000L; /* Device can
receive point size */

 //
 // VertexProcessingCaps
 //
 const int D3DVTXPCAPS_TEXGEN             = 0x00000001L; /* device can do
texgen */
 const int D3DVTXPCAPS_MATERIALSOURCE7    = 0x00000002L; /* device can do
DX7-level colormaterialsource ops */
 const int D3DVTXPCAPS_DIRECTIONALLIGHTS  = 0x00000008L; /* device can do
directional lights */
 const int D3DVTXPCAPS_POSITIONALLIGHTS   = 0x00000010L; /* device can do
positional lights (includes point and spot) */
 const int D3DVTXPCAPS_LOCALVIEWER        = 0x00000020L; /* device can do
local viewer */
 const int D3DVTXPCAPS_TWEENING           = 0x00000040L; /* device can do
vertex tweening */
 const int D3DVTXPCAPS_TEXGEN_SPHEREMAP   = 0x00000100L; /* device supports
D3DTSS_TCI_SPHEREMAP */
 const int D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER  = 0x00000200L; /* device
does not support TexGen in non-local
                                                             viewer mode */

 //
 // DevCaps2
 //
 const int D3DDEVCAPS2_STREAMOFFSET                      =  0x00000001L; /*
Device supports offsets in streams. Must be set by DX9 drivers */
 const int D3DDEVCAPS2_DMAPNPATCH                        =  0x00000002L; /*
Device supports displacement maps for N-Patches*/
 const int D3DDEVCAPS2_ADAPTIVETESSRTPATCH               =  0x00000004L; /*
Device supports adaptive tesselation of RT-patches*/
 const int D3DDEVCAPS2_ADAPTIVETESSNPATCH                =  0x00000008L; /*
Device supports adaptive tesselation of N-patches*/
 const int D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES     =  0x00000010L; /*
Device supports StretchRect calls with a texture as the source*/
 const int D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH               = 0x00000020L; /*
Device supports presampled displacement maps for N-Patches */
 const int D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET = 0x00000040L; /*
Vertex elements in a vertex declaration can share the same stream offset */

 //
 // DeclTypes
 //
 const int D3DDTCAPS_UBYTE4    = 0x00000001L;
 const int D3DDTCAPS_UBYTE4N   = 0x00000002L;
 const int D3DDTCAPS_SHORT2N   = 0x00000004L;
 const int D3DDTCAPS_SHORT4N   = 0x00000008L;
 const int D3DDTCAPS_USHORT2N  = 0x00000010L;
 const int D3DDTCAPS_USHORT4N  = 0x00000020L;
 const int D3DDTCAPS_UDEC3     = 0x00000040L;
 const int D3DDTCAPS_DEC3N     = 0x00000080L;
 const int D3DDTCAPS_FLOAT16_2 = 0x00000100L;
 const int D3DDTCAPS_FLOAT16_4 = 0x00000200L;


 } //align (4)




//} /* (DIRECT3D_VERSION >= 0x0900) */


////////////////////////////////////////////////
d3d9types.d
///////////////////////////

// Author : Ahmed El-Metwaly
// contact : aelmetwaly gawa.com
// Lic     : GPL

/*==========================================================================
;
 *
 *  Copyright (C) Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       d3d9types.h
 *  Content:    Direct3D capabilities include file
 *

***************************************************************************/


import std.c.stdio;
import std.c.stdlib;
import std.string;
import std.c.windows.windows;
import std.c.windows.com;


const int DIRECT3D_VERSION    =     0x0900;


// include this file content only if compiling for DX9 interfaces
//version(DIRECT3D_VERSION )
//{
 //#include <float.h>

 align(4){


 // D3DCOLOR is equivalent to D3DFMT_A8R8G8B8

 alias DWORD D3DCOLOR;



 // maps unsigned 8 bits/channel to D3DCOLOR
 //#define D3DCOLOR_ARGB(a,r,g,b) \
 //
((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
 D3DCOLOR D3DCOLOR_ARGB(ubyte a, ubyte r, ubyte g, ubyte b)
 {
  return (cast(D3DCOLOR)(((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g &
0xff) << 8) | (b & 0xff)));
 }


 //#define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b)
 D3DCOLOR D3DCOLOR_RGBA (ubyte r, ubyte g, ubyte b, ubyte  a)
 {
  return D3DCOLOR_ARGB(a, r, g, b);
 }

 //#define D3DCOLOR_XRGB(r,g,b)   D3DCOLOR_ARGB(0xff,r,g,b)
 D3DCOLOR D3DCOLOR_XRGB (ubyte r, ubyte g, ubyte b)
 {
  return D3DCOLOR_ARGB( 0xff, r, g, b);
 }

 //#define D3DCOLOR_XYUV(y,u,v)   D3DCOLOR_ARGB(0xff,y,u,v)
 D3DCOLOR D3DCOLOR_XYUV (ubyte y, ubyte u, ubyte v)
 {
  return D3DCOLOR_ARGB (0xff, y, u, v);
 }

 //#define D3DCOLOR_AYUV(a,y,u,v) D3DCOLOR_ARGB(a,y,u,v)
 D3DCOLOR D3DCOLOR_AYUV (ubyte a, ubyte y, ubyte u, ubyte v)
 {
  return D3DCOLOR_ARGB (a, y, u, v);
 }

 // maps floating point channels (0.f to 1.f range) to D3DCOLOR
 //#define D3DCOLOR_COLORVALUE(r,g,b,a) \
 //
D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWOR
D)((a)*255.f))
 D3DCOLOR D3DCOLOR_COLORVALUE ( float r , float g, float b, float a)
 {
  return D3DCOLOR_RGBA( cast(DWORD) ( r * 255.f), cast(DWORD)( g * 255.f ),
cast(DWORD)( b *255.f), cast(DWORD)(a *255.f));
 }



 struct _D3DVECTOR {
     float x;
     float y;
     float z;
 }
 alias _D3DVECTOR D3DVECTOR;




 struct _D3DCOLORVALUE {
     float r;
     float g;
     float b;
     float a;
 }
 alias _D3DCOLORVALUE D3DCOLORVALUE;




 struct _D3DRECT {
     LONG x1;
     LONG y1;
     LONG x2;
     LONG y2;
 }
 alias _D3DRECT D3DRECT;




 struct _D3DMATRIX {
     union {
         struct {
             float        _11, _12, _13, _14;
             float        _21, _22, _23, _24;
             float        _31, _32, _33, _34;
             float        _41, _42, _43, _44;

         };
         float m[4][4];
     };
 }
 alias _D3DMATRIX D3DMATRIX;



 struct _D3DVIEWPORT9 {
     DWORD       X;
     DWORD       Y;            /* Viewport Top left */
     DWORD       Width;
     DWORD       Height;       /* Viewport Dimensions */
     float       MinZ;         /* Min/max of clip Volume */
     float       MaxZ;
 }
 alias _D3DVIEWPORT9 D3DVIEWPORT9;

 /*
  * Values for clip fields.
  */

 // Max number of user clipping planes, supported in D3D.
 const int D3DMAXUSERCLIPPLANES  = 32;

 // These bits could be ORed together to use with D3DRS_CLIPPLANEENABLE
 //
 const int D3DCLIPPLANE0  = (1 << 0);
 const int D3DCLIPPLANE1  = (1 << 1);
 const int D3DCLIPPLANE2  = (1 << 2);
 const int D3DCLIPPLANE3  = (1 << 3);
 const int D3DCLIPPLANE4  = (1 << 4);
 const int D3DCLIPPLANE5  = (1 << 5);

 // The following bits are used in the ClipUnion and ClipIntersection
 // members of the D3DCLIPSTATUS9
 //

 const int D3DCS_LEFT      =  0x00000001L;
 const int D3DCS_RIGHT     =  0x00000002L;
 const int D3DCS_TOP       =  0x00000004L;
 const int D3DCS_BOTTOM    =  0x00000008L;
 const int D3DCS_FRONT     =  0x00000010L;
 const int D3DCS_BACK      =  0x00000020L;
 const int D3DCS_PLANE0    =  0x00000040L;
 const int D3DCS_PLANE1    =  0x00000080L;
 const int D3DCS_PLANE2    =  0x00000100L;
 const int D3DCS_PLANE3    =  0x00000200L;
 const int D3DCS_PLANE4    =  0x00000400L;
 const int D3DCS_PLANE5    =  0x00000800L;

 const int D3DCS_ALL = (D3DCS_LEFT   |
                     D3DCS_RIGHT  |
                     D3DCS_TOP    |
                     D3DCS_BOTTOM |
                     D3DCS_FRONT  |
                     D3DCS_BACK   |
                     D3DCS_PLANE0 |
                     D3DCS_PLANE1 |
                     D3DCS_PLANE2 |
                     D3DCS_PLANE3 |
                     D3DCS_PLANE4 |
                     D3DCS_PLANE5);

 struct _D3DCLIPSTATUS9 {
     DWORD ClipUnion;
     DWORD ClipIntersection;
 }
 alias _D3DCLIPSTATUS9 D3DCLIPSTATUS9;

 struct _D3DMATERIAL9 {
     D3DCOLORVALUE   Diffuse;        /* Diffuse color RGBA */
     D3DCOLORVALUE   Ambient;        /* Ambient color RGB */
     D3DCOLORVALUE   Specular;       /* Specular 'shininess' */
     D3DCOLORVALUE   Emissive;       /* Emissive color RGB */
     float           Power;          /* Sharpness if specular highlight */
 }
 alias _D3DMATERIAL9 D3DMATERIAL9;

 enum _D3DLIGHTTYPE {
     D3DLIGHT_POINT          = 1,
     D3DLIGHT_SPOT           = 2,
     D3DLIGHT_DIRECTIONAL    = 3,
     D3DLIGHT_FORCE_DWORD    = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DLIGHTTYPE D3DLIGHTTYPE;

 struct _D3DLIGHT9 {
     D3DLIGHTTYPE    Type;            /* Type of light source */
     D3DCOLORVALUE   Diffuse;         /* Diffuse color of light */
     D3DCOLORVALUE   Specular;        /* Specular color of light */
     D3DCOLORVALUE   Ambient;         /* Ambient color of light */
     D3DVECTOR       Position;         /* Position in world space */
     D3DVECTOR       Direction;        /* Direction in world space */
     float           Range;            /* Cutoff range */
     float           Falloff;          /* Falloff */
     float           Attenuation0;     /* Constant attenuation */
     float           Attenuation1;     /* Linear attenuation */
     float           Attenuation2;     /* Quadratic attenuation */
     float           Theta;            /* Inner angle of spotlight cone */
     float           Phi;              /* Outer angle of spotlight cone */
 }
 alias _D3DLIGHT9 D3DLIGHT9;

 /*
  * Options for clearing
  */
 const int D3DCLEAR_TARGET        =    0x00000001;  /* Clear target surface
*/
 const int D3DCLEAR_ZBUFFER       =    0x00000002;  /* Clear target z buffer
*/
 const int D3DCLEAR_STENCIL       =    0x00000004;  /* Clear stencil planes
*/

 /*
  * The following defines the rendering states
  */

 enum _D3DSHADEMODE {
     D3DSHADE_FLAT               = 1,
     D3DSHADE_GOURAUD            = 2,
     D3DSHADE_PHONG              = 3,
     D3DSHADE_FORCE_DWORD        = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DSHADEMODE D3DSHADEMODE;

 enum _D3DFILLMODE {
     D3DFILL_POINT               = 1,
     D3DFILL_WIREFRAME           = 2,
     D3DFILL_SOLID               = 3,
     D3DFILL_FORCE_DWORD         = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DFILLMODE D3DFILLMODE;

 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,
     D3DBLEND_BLENDFACTOR        = 14, /* Only supported if
D3DPBLENDCAPS_BLENDFACTOR is on */
     D3DBLEND_INVBLENDFACTOR     = 15, /* Only supported if
D3DPBLENDCAPS_BLENDFACTOR is on */
     D3DBLEND_FORCE_DWORD        = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DBLEND D3DBLEND;





 enum _D3DBLENDOP {
     D3DBLENDOP_ADD              = 1,
     D3DBLENDOP_SUBTRACT         = 2,
     D3DBLENDOP_REVSUBTRACT      = 3,
     D3DBLENDOP_MIN              = 4,
     D3DBLENDOP_MAX              = 5,
     D3DBLENDOP_FORCE_DWORD      = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DBLENDOP D3DBLENDOP;




enum _D3DTEXTUREADDRESS {
     D3DTADDRESS_WRAP            = 1,
     D3DTADDRESS_MIRROR          = 2,
     D3DTADDRESS_CLAMP           = 3,
     D3DTADDRESS_BORDER          = 4,
     D3DTADDRESS_MIRRORONCE      = 5,
     D3DTADDRESS_FORCE_DWORD     = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DTEXTUREADDRESS D3DTEXTUREADDRESS;

 enum _D3DCULL {
     D3DCULL_NONE                = 1,
     D3DCULL_CW                  = 2,
     D3DCULL_CCW                 = 3,
     D3DCULL_FORCE_DWORD         = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DCULL D3DCULL;



 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,
     D3DCMP_FORCE_DWORD          = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DCMPFUNC D3DCMPFUNC;




 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, /* force 32-bit size enum */
 }
 alias _D3DSTENCILOP D3DSTENCILOP;




 enum _D3DFOGMODE {
     D3DFOG_NONE                 = 0,
     D3DFOG_EXP                  = 1,
     D3DFOG_EXP2                 = 2,
     D3DFOG_LINEAR               = 3,
     D3DFOG_FORCE_DWORD          = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DFOGMODE D3DFOGMODE;





 enum _D3DZBUFFERTYPE {
     D3DZB_FALSE                 = 0,
     D3DZB_TRUE                  = 1, // Z buffering
     D3DZB_USEW                  = 2, // W buffering
     D3DZB_FORCE_DWORD           = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DZBUFFERTYPE D3DZBUFFERTYPE;

 // Primitives supported by draw-primitive API
 enum _D3DPRIMITIVETYPE {
     D3DPT_POINTLIST             = 1,
     D3DPT_LINELIST              = 2,
     D3DPT_LINESTRIP             = 3,
     D3DPT_TRIANGLELIST          = 4,
     D3DPT_TRIANGLESTRIP         = 5,
     D3DPT_TRIANGLEFAN           = 6,
     D3DPT_FORCE_DWORD           = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DPRIMITIVETYPE D3DPRIMITIVETYPE;

 enum _D3DTRANSFORMSTATETYPE {
     D3DTS_VIEW          = 2,
     D3DTS_PROJECTION    = 3,
     D3DTS_TEXTURE0      = 16,
     D3DTS_TEXTURE1      = 17,
     D3DTS_TEXTURE2      = 18,
     D3DTS_TEXTURE3      = 19,
     D3DTS_TEXTURE4      = 20,
     D3DTS_TEXTURE5      = 21,
     D3DTS_TEXTURE6      = 22,
     D3DTS_TEXTURE7      = 23,
     D3DTS_FORCE_DWORD     = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DTRANSFORMSTATETYPE D3DTRANSFORMSTATETYPE;




 /** FIXME : convert these !! */
 //#define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
 //#define D3DTS_WORLD  D3DTS_WORLDMATRIX(0)
 //#define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1)
 //#define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2)
 //#define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3)

 enum _D3DRENDERSTATETYPE {
     D3DRS_ZENABLE                   = 7,    /* D3DZBUFFERTYPE (or
TRUE/FALSE for legacy) */
     D3DRS_FILLMODE                  = 8,    /* D3DFILLMODE */
     D3DRS_SHADEMODE                 = 9,    /* D3DSHADEMODE */
     D3DRS_ZWRITEENABLE              = 14,   /* TRUE to enable z writes */
     D3DRS_ALPHATESTENABLE           = 15,   /* TRUE to enable alpha tests
*/
     D3DRS_LASTPIXEL                 = 16,   /* TRUE for last-pixel on lines
*/
     D3DRS_SRCBLEND                  = 19,   /* D3DBLEND */
     D3DRS_DESTBLEND                 = 20,   /* D3DBLEND */
     D3DRS_CULLMODE                  = 22,   /* D3DCULL */
     D3DRS_ZFUNC                     = 23,   /* D3DCMPFUNC */
     D3DRS_ALPHAREF                  = 24,   /* D3DFIXED */
     D3DRS_ALPHAFUNC                 = 25,   /* D3DCMPFUNC */
     D3DRS_DITHERENABLE              = 26,   /* TRUE to enable dithering */
     D3DRS_ALPHABLENDENABLE          = 27,   /* TRUE to enable alpha
blending */
     D3DRS_FOGENABLE                 = 28,   /* TRUE to enable fog blending
*/
     D3DRS_SPECULARENABLE            = 29,   /* TRUE to enable specular */
     D3DRS_FOGCOLOR                  = 34,   /* D3DCOLOR */
     D3DRS_FOGTABLEMODE              = 35,   /* D3DFOGMODE */
     D3DRS_FOGSTART                  = 36,   /* Fog start (for both vertex
and pixel fog) */
     D3DRS_FOGEND                    = 37,   /* Fog end      */
     D3DRS_FOGDENSITY                = 38,   /* Fog density  */
     D3DRS_RANGEFOGENABLE            = 48,   /* Enables range-based fog */
     D3DRS_STENCILENABLE             = 52,   /* BOOL enable/disable
stenciling */
     D3DRS_STENCILFAIL               = 53,   /* D3DSTENCILOP to do if
stencil test fails */
     D3DRS_STENCILZFAIL              = 54,   /* D3DSTENCILOP to do if
stencil test passes and Z test fails */
     D3DRS_STENCILPASS               = 55,   /* D3DSTENCILOP to do if both
stencil and Z tests pass */
     D3DRS_STENCILFUNC               = 56,   /* D3DCMPFUNC fn.  Stencil Test
passes if ((ref & mask) stencilfn (stencil & mask)) is true */
     D3DRS_STENCILREF                = 57,   /* Reference value used in
stencil test */
     D3DRS_STENCILMASK               = 58,   /* Mask value used in stencil
test */
     D3DRS_STENCILWRITEMASK          = 59,   /* Write mask applied to values
written to stencil buffer */
     D3DRS_TEXTUREFACTOR             = 60,   /* D3DCOLOR used for
multi-texture blend */
     D3DRS_WRAP0                     = 128,  /* wrap for 1st texture coord.
set */
     D3DRS_WRAP1                     = 129,  /* wrap for 2nd texture coord.
set */
     D3DRS_WRAP2                     = 130,  /* wrap for 3rd texture coord.
set */
     D3DRS_WRAP3                     = 131,  /* wrap for 4th texture coord.
set */
     D3DRS_WRAP4                     = 132,  /* wrap for 5th texture coord.
set */
     D3DRS_WRAP5                     = 133,  /* wrap for 6th texture coord.
set */
     D3DRS_WRAP6                     = 134,  /* wrap for 7th texture coord.
set */
     D3DRS_WRAP7                     = 135,  /* wrap for 8th texture coord.
set */
     D3DRS_CLIPPING                  = 136,
     D3DRS_LIGHTING                  = 137,
     D3DRS_AMBIENT                   = 139,
     D3DRS_FOGVERTEXMODE             = 140,
     D3DRS_COLORVERTEX               = 141,
     D3DRS_LOCALVIEWER               = 142,
     D3DRS_NORMALIZENORMALS          = 143,
     D3DRS_DIFFUSEMATERIALSOURCE     = 145,
     D3DRS_SPECULARMATERIALSOURCE    = 146,
     D3DRS_AMBIENTMATERIALSOURCE     = 147,
     D3DRS_EMISSIVEMATERIALSOURCE    = 148,
     D3DRS_VERTEXBLEND               = 151,
     D3DRS_CLIPPLANEENABLE           = 152,
     D3DRS_POINTSIZE                 = 154,   /* float point size */
     D3DRS_POINTSIZE_MIN             = 155,   /* float point size min
threshold */
     D3DRS_POINTSPRITEENABLE         = 156,   /* BOOL point texture coord
control */
     D3DRS_POINTSCALEENABLE          = 157,   /* BOOL point size scale
enable */
     D3DRS_POINTSCALE_A              = 158,   /* float point attenuation A
value */
     D3DRS_POINTSCALE_B              = 159,   /* float point attenuation B
value */
     D3DRS_POINTSCALE_C              = 160,   /* float point attenuation C
value */
     D3DRS_MULTISAMPLEANTIALIAS      = 161,  // BOOL - set to do FSAA with
multisample buffer
     D3DRS_MULTISAMPLEMASK           = 162,  // DWORD - per-sample
enable/disable
     D3DRS_PATCHEDGESTYLE            = 163,  // Sets whether patch edges
will use float style tessellation
     D3DRS_DEBUGMONITORTOKEN         = 165,  // DEBUG ONLY - token to debug
monitor
     D3DRS_POINTSIZE_MAX             = 166,   /* float point size max
threshold */
     D3DRS_INDEXEDVERTEXBLENDENABLE  = 167,
     D3DRS_COLORWRITEENABLE          = 168,  // per-channel write enable
     D3DRS_TWEENFACTOR               = 170,   // float tween factor
     D3DRS_BLENDOP                   = 171,   // D3DBLENDOP setting
     D3DRS_POSITIONDEGREE            = 172,   // NPatch position
interpolation degree. D3DDEGREE_LINEAR or D3DDEGREE_CUBIC (default)
     D3DRS_NORMALDEGREE              = 173,   // NPatch normal interpolation
degree. D3DDEGREE_LINEAR (default) or D3DDEGREE_QUADRATIC
     D3DRS_SCISSORTESTENABLE         = 174,
     D3DRS_SLOPESCALEDEPTHBIAS       = 175,
     D3DRS_ANTIALIASEDLINEENABLE     = 176,
     D3DRS_MINTESSELLATIONLEVEL      = 178,
     D3DRS_MAXTESSELLATIONLEVEL      = 179,
     D3DRS_ADAPTIVETESS_X            = 180,
     D3DRS_ADAPTIVETESS_Y            = 181,
     D3DRS_ADAPTIVETESS_Z            = 182,
     D3DRS_ADAPTIVETESS_W            = 183,
     D3DRS_ENABLEADAPTIVETESSELLATION = 184,
     D3DRS_TWOSIDEDSTENCILMODE       = 185,   /* BOOL enable/disable 2 sided
stenciling */
     D3DRS_CCW_STENCILFAIL           = 186,   /* D3DSTENCILOP to do if ccw
stencil test fails */
     D3DRS_CCW_STENCILZFAIL          = 187,   /* D3DSTENCILOP to do if ccw
stencil test passes and Z test fails */
     D3DRS_CCW_STENCILPASS           = 188,   /* D3DSTENCILOP to do if both
ccw stencil and Z tests pass */
     D3DRS_CCW_STENCILFUNC           = 189,   /* D3DCMPFUNC fn.  ccw Stencil
Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */
     D3DRS_COLORWRITEENABLE1         = 190,   /* Additional
ColorWriteEnables for the devices that support
D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
     D3DRS_COLORWRITEENABLE2         = 191,   /* Additional
ColorWriteEnables for the devices that support
D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
     D3DRS_COLORWRITEENABLE3         = 192,   /* Additional
ColorWriteEnables for the devices that support
D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
     D3DRS_BLENDFACTOR               = 193,   /* D3DCOLOR used for a
constant blend factor during alpha blending for devices that support
D3DPBLENDCAPS_BLENDFACTOR */
     D3DRS_SRGBWRITEENABLE           = 194,   /* Enable rendertarget writes
to be DE-linearized to SRGB (for formats that expose
D3DUSAGE_QUERY_SRGBWRITE) */
     D3DRS_DEPTHBIAS                 = 195,
     D3DRS_WRAP8                     = 198,   /* Additional wrap states for
vs_3_0+ attributes with D3DDECLUSAGE_TEXCOORD */
     D3DRS_WRAP9                     = 199,
     D3DRS_WRAP10                    = 200,
     D3DRS_WRAP11                    = 201,
     D3DRS_WRAP12                    = 202,
     D3DRS_WRAP13                    = 203,
     D3DRS_WRAP14                    = 204,
     D3DRS_WRAP15                    = 205,
     D3DRS_SEPARATEALPHABLENDENABLE  = 206,  /* TRUE to enable a separate
blending function for the alpha channel */
     D3DRS_SRCBLENDALPHA             = 207,  /* SRC blend factor for the
alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
     D3DRS_DESTBLENDALPHA            = 208,  /* DST blend factor for the
alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
     D3DRS_BLENDOPALPHA              = 209,  /* Blending operation for the
alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */


     D3DRS_FORCE_DWORD               = 0x7fffffff, /* force 32-bit size enum
*/
 }
 alias _D3DRENDERSTATETYPE D3DRENDERSTATETYPE;





 // Maximum number of simultaneous render targets D3D supports
 const int D3D_MAX_SIMULTANEOUS_RENDERTARGETS  = 4;

 // Values for material source
 enum _D3DMATERIALCOLORSOURCE
 {
     D3DMCS_MATERIAL         = 0,            // Color from material is used
     D3DMCS_COLOR1           = 1,            // Diffuse vertex color is used
     D3DMCS_COLOR2           = 2,            // Specular vertex color is
used
     D3DMCS_FORCE_DWORD      = 0x7fffffff,   // force 32-bit size enum
 }
 alias _D3DMATERIALCOLORSOURCE D3DMATERIALCOLORSOURCE;

 // Bias to apply to the texture coordinate set to apply a wrap to.
 const int D3DRENDERSTATE_WRAPBIAS            =     128;

 /* Flags to construct the WRAP render states */
 const int D3DWRAP_U  = 0x00000001;
 const int D3DWRAP_V  = 0x00000002;
 const int D3DWRAP_W  = 0x00000004;

 /* Flags to construct the WRAP render states for 1D thru 4D texture
coordinates */
 const int D3DWRAPCOORD_0  = 0x00000001;    // same as D3DWRAP_U
 const int D3DWRAPCOORD_1  = 0x00000002;    // same as D3DWRAP_V
 const int D3DWRAPCOORD_2  = 0x00000004;    // same as D3DWRAP_W
 const int D3DWRAPCOORD_3  = 0x00000008;

 /* Flags to construct D3DRS_COLORWRITEENABLE */
 const int D3DCOLORWRITEENABLE_RED    = (1<<0);
 const int D3DCOLORWRITEENABLE_GREEN  = (1<<1);
 const int D3DCOLORWRITEENABLE_BLUE   = (1<<2);
 const int D3DCOLORWRITEENABLE_ALPHA  = (1<<3);

 /*
  * State enumerants for per-stage processing of fixed function pixel
processing
  * Two of these affect fixed function vertex processing as well:
TEXTURETRANSFORMFLAGS and TEXCOORDINDEX.
  */
 enum _D3DTEXTURESTAGESTATETYPE
 {
     D3DTSS_COLOROP        =  1, /* D3DTEXTUREOP - per-stage blending
controls for color channels */
     D3DTSS_COLORARG1      =  2, /* D3DTA_* (texture arg) */
     D3DTSS_COLORARG2      =  3, /* D3DTA_* (texture arg) */
     D3DTSS_ALPHAOP        =  4, /* D3DTEXTUREOP - per-stage blending
controls for alpha channel */
     D3DTSS_ALPHAARG1      =  5, /* D3DTA_* (texture arg) */
     D3DTSS_ALPHAARG2      =  6, /* D3DTA_* (texture arg) */
     D3DTSS_BUMPENVMAT00   =  7, /* float (bump mapping matrix) */
     D3DTSS_BUMPENVMAT01   =  8, /* float (bump mapping matrix) */
     D3DTSS_BUMPENVMAT10   =  9, /* float (bump mapping matrix) */
     D3DTSS_BUMPENVMAT11   = 10, /* float (bump mapping matrix) */
     D3DTSS_TEXCOORDINDEX  = 11, /* identifies which set of texture
coordinates index this texture */
     D3DTSS_BUMPENVLSCALE  = 22, /* float scale for bump map luminance */
     D3DTSS_BUMPENVLOFFSET = 23, /* float offset for bump map luminance */
     D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls
texture transform */
     D3DTSS_COLORARG0      = 26, /* D3DTA_* third arg for triadic ops */
     D3DTSS_ALPHAARG0      = 27, /* D3DTA_* third arg for triadic ops */
     D3DTSS_RESULTARG      = 28, /* D3DTA_* arg for result (CURRENT or TEMP)
*/
     D3DTSS_CONSTANT       = 32, /* Per-stage constant D3DTA_CONSTANT */


     D3DTSS_FORCE_DWORD   = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DTEXTURESTAGESTATETYPE D3DTEXTURESTAGESTATETYPE;

 /*
  * State enumerants for per-sampler texture processing.
  */
 enum _D3DSAMPLERSTATETYPE
 {
     D3DSAMP_ADDRESSU       = 1,  /* D3DTEXTUREADDRESS for U coordinate */
     D3DSAMP_ADDRESSV       = 2,  /* D3DTEXTUREADDRESS for V coordinate */
     D3DSAMP_ADDRESSW       = 3,  /* D3DTEXTUREADDRESS for W coordinate */
     D3DSAMP_BORDERCOLOR    = 4,  /* D3DCOLOR */
     D3DSAMP_MAGFILTER      = 5,  /* D3DTEXTUREFILTER filter to use for
magnification */
     D3DSAMP_MINFILTER      = 6,  /* D3DTEXTUREFILTER filter to use for
minification */
     D3DSAMP_MIPFILTER      = 7,  /* D3DTEXTUREFILTER filter to use between
mipmaps during minification */
     D3DSAMP_MIPMAPLODBIAS  = 8,  /* float Mipmap LOD bias */
     D3DSAMP_MAXMIPLEVEL    = 9,  /* DWORD 0..(n-1) LOD index of largest map
to use (0 == largest) */
     D3DSAMP_MAXANISOTROPY  = 10, /* DWORD maximum anisotropy */
     D3DSAMP_SRGBTEXTURE    = 11, /* Default = 0 (which means Gamma 1.0,
                                    no correction required.) else correct
for
                                    Gamma = 2.2 */
     D3DSAMP_ELEMENTINDEX   = 12, /* When multi-element texture is assigned
to sampler, this
                                     indicates which element index to use.
Default = 0.  */
     D3DSAMP_DMAPOFFSET     = 13, /* Offset in vertices in the pre-sampled
displacement map.
                                     Only valid for D3DDMAPSAMPLER sampler
*/
     D3DSAMP_FORCE_DWORD   = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DSAMPLERSTATETYPE D3DSAMPLERSTATETYPE;

 /* Special sampler which is used in the tesselator */
 const int D3DDMAPSAMPLER  = 256;

 // Samplers used in vertex shaders
 const int D3DVERTEXTEXTURESAMPLER0  = (D3DDMAPSAMPLER+1);
 const int D3DVERTEXTEXTURESAMPLER1  = (D3DDMAPSAMPLER+2);
 const int D3DVERTEXTEXTURESAMPLER2  = (D3DDMAPSAMPLER+3);
 const int D3DVERTEXTEXTURESAMPLER3  = (D3DDMAPSAMPLER+4);

 // Values, used with D3DTSS_TEXCOORDINDEX, to specify that the vertex
data(position
 // and normal in the camera space) should be taken as texture coordinates
 // Low 16 bits are used to specify texture coordinate index, to take the
WRAP mode from
 //
 const int D3DTSS_TCI_PASSTHRU                        =     0x00000000;
 const int D3DTSS_TCI_CAMERASPACENORMAL               =     0x00010000;
 const int D3DTSS_TCI_CAMERASPACEPOSITION             =     0x00020000;
 const int D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR     =     0x00030000;
 const int D3DTSS_TCI_SPHEREMAP                       =     0x00040000;

 /*
  * Enumerations for COLOROP and ALPHAOP texture blending operations set in
  * texture processing stage controls in D3DTSS.
  */
 enum _D3DTEXTUREOP
 {
     // Control
     D3DTOP_DISABLE              = 1,      // disables stage
     D3DTOP_SELECTARG1           = 2,      // the default
     D3DTOP_SELECTARG2           = 3,

     // Modulate
     D3DTOP_MODULATE             = 4,      // multiply args together
     D3DTOP_MODULATE2X           = 5,      // multiply and  1 bit
     D3DTOP_MODULATE4X           = 6,      // multiply and  2 bits

     // Add
     D3DTOP_ADD                  =  7,   // add arguments together
     D3DTOP_ADDSIGNED            =  8,   // add with -0.5 bias
     D3DTOP_ADDSIGNED2X          =  9,   // as above but left  1 bit
     D3DTOP_SUBTRACT             = 10,   // Arg1 - Arg2, with no saturation
     D3DTOP_ADDSMOOTH            = 11,   // add 2 args, subtract product
                                         // Arg1 + Arg2 - Arg1*Arg2
                                         // = Arg1 + (1-Arg1)*Arg2

     // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
     D3DTOP_BLENDDIFFUSEALPHA    = 12, // iterated alpha
     D3DTOP_BLENDTEXTUREALPHA    = 13, // texture alpha
     D3DTOP_BLENDFACTORALPHA     = 14, // alpha from D3DRS_TEXTUREFACTOR

     // Linear alpha blend with pre-multiplied arg1 input: Arg1 +
Arg2*(1-Alpha)
     D3DTOP_BLENDTEXTUREALPHAPM  = 15, // texture alpha
     D3DTOP_BLENDCURRENTALPHA    = 16, // by alpha of current color

     // Specular mapping
     D3DTOP_PREMODULATE            = 17,     // modulate with next texture
before use
     D3DTOP_MODULATEALPHA_ADDCOLOR = 18,     // Arg1.RGB + Arg1.A*Arg2.RGB
                                             // COLOROP only
     D3DTOP_MODULATECOLOR_ADDALPHA = 19,     // Arg1.RGB*Arg2.RGB + Arg1.A
                                             // COLOROP only
     D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20,  // (1-Arg1.A)*Arg2.RGB +
Arg1.RGB
                                             // COLOROP only
     D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21,  // (1-Arg1.RGB)*Arg2.RGB +
Arg1.A
                                             // COLOROP only

     // Bump mapping
     D3DTOP_BUMPENVMAP           = 22, // per pixel env map perturbation
     D3DTOP_BUMPENVMAPLUMINANCE  = 23, // with luminance channel

     // This can do either diffuse or specular bump mapping with correct
input.
     // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G +
Arg1.B*Arg2.B)
     // where each component has been scaled and offset to make it signed.
     // The result is replicated into all four (including alpha) channels.
     // This is a valid COLOROP only.
     D3DTOP_DOTPRODUCT3          = 24,

     // Triadic ops
     D3DTOP_MULTIPLYADD          = 25, // Arg0 + Arg1*Arg2
     D3DTOP_LERP                 = 26, // (Arg0)*Arg1 + (1-Arg0)*Arg2

     D3DTOP_FORCE_DWORD = 0x7fffffff,
 }
 alias _D3DTEXTUREOP D3DTEXTUREOP;

 /*
  * Values for COLORARG0,1,2, ALPHAARG0,1,2, and RESULTARG texture blending
  * operations set in texture processing stage controls in D3DRENDERSTATE.
  */
 const int D3DTA_SELECTMASK     =   0x0000000f;  // mask for arg selector
 const int D3DTA_DIFFUSE        =   0x00000000;  // select diffuse color
(read only)
 const int D3DTA_CURRENT        =   0x00000001;  // select stage destination
register (read/write)
 const int D3DTA_TEXTURE        =   0x00000002;  // select texture color
(read only)
 const int D3DTA_TFACTOR        =   0x00000003;  // select
D3DRS_TEXTUREFACTOR (read only)
 const int D3DTA_SPECULAR       =   0x00000004;  // select specular color
(read only)
 const int D3DTA_TEMP           =   0x00000005;  // select temporary
register color (read/write)
 const int D3DTA_CONSTANT       =   0x00000006;  // select texture stage
constant
 const int D3DTA_COMPLEMENT     =   0x00000010;  // take 1.0 - x (read
modifier)
 const int D3DTA_ALPHAREPLICATE =   0x00000020;  // replicate alpha to color
components (read modifier)

 //
 // Values for D3DSAMP_***FILTER texture stage states
 //
 enum _D3DTEXTUREFILTERTYPE
 {
     D3DTEXF_NONE            = 0,    // filtering disabled (valid for mip
filter only)
     D3DTEXF_POINT           = 1,    // nearest
     D3DTEXF_LINEAR          = 2,    // linear interpolation
     D3DTEXF_ANISOTROPIC     = 3,    // anisotropic
     D3DTEXF_PYRAMIDALQUAD   = 6,    // 4-sample tent
     D3DTEXF_GAUSSIANQUAD    = 7,    // 4-sample gaussian
     D3DTEXF_FORCE_DWORD     = 0x7fffffff,   // force 32-bit size enum
 }
 alias _D3DTEXTUREFILTERTYPE D3DTEXTUREFILTERTYPE;

 /* Bits for Flags in ProcessVertices call */

 const int D3DPV_DONOTCOPYDATA    = (1 << 0);

 //-------------------------------------------------------------------

 // Flexible vertex format bits
 //
 const int D3DFVF_RESERVED0       = 0x001;
 const int D3DFVF_POSITION_MASK   = 0x400E;
 const int D3DFVF_XYZ             = 0x002;
 const int D3DFVF_XYZRHW          = 0x004;
 const int D3DFVF_XYZB1           = 0x006;
 const int D3DFVF_XYZB2           = 0x008;
 const int D3DFVF_XYZB3           = 0x00a;
 const int D3DFVF_XYZB4           = 0x00c;
 const int D3DFVF_XYZB5           = 0x00e;
 const int D3DFVF_XYZW            = 0x4002;

 const int D3DFVF_NORMAL          = 0x010;
 const int D3DFVF_PSIZE           = 0x020;
 const int D3DFVF_DIFFUSE         = 0x040;
 const int D3DFVF_SPECULAR        = 0x080;

 const int D3DFVF_TEXCOUNT_MASK   = 0xf00;
 const int D3DFVF_TEXCOUNT_SHIFT  = 8;
 const int D3DFVF_TEX0            = 0x000;
 const int D3DFVF_TEX1            = 0x100;
 const int D3DFVF_TEX2            = 0x200;
 const int D3DFVF_TEX3            = 0x300;
 const int D3DFVF_TEX4            = 0x400;
 const int D3DFVF_TEX5            = 0x500;
 const int D3DFVF_TEX6            = 0x600;
 const int D3DFVF_TEX7            = 0x700;
 const int D3DFVF_TEX8            = 0x800;

 const int D3DFVF_LASTBETA_UBYTE4  = 0x1000;
 const int D3DFVF_LASTBETA_D3DCOLOR = 0x8000;

 const int D3DFVF_RESERVED2       =  0x6000;  // 2 reserved bits

 //---------------------------------------------------------------------
 // Vertex Shaders
 //

 // Vertex shader declaration

 // Vertex element semantics
 //
 enum _D3DDECLUSAGE
 {
     D3DDECLUSAGE_POSITION = 0,
     D3DDECLUSAGE_BLENDWEIGHT,   // 1
     D3DDECLUSAGE_BLENDINDICES,  // 2
     D3DDECLUSAGE_NORMAL,        // 3
     D3DDECLUSAGE_PSIZE,         // 4
     D3DDECLUSAGE_TEXCOORD,      // 5
     D3DDECLUSAGE_TANGENT,       // 6
     D3DDECLUSAGE_BINORMAL,      // 7
     D3DDECLUSAGE_TESSFACTOR,    // 8
     D3DDECLUSAGE_POSITIONT,     // 9
     D3DDECLUSAGE_COLOR,         // 10
     D3DDECLUSAGE_FOG,           // 11
     D3DDECLUSAGE_DEPTH,         // 12
     D3DDECLUSAGE_SAMPLE,        // 13
 }
 alias _D3DDECLUSAGE D3DDECLUSAGE;

 const int MAXD3DDECLUSAGE      =   D3DDECLUSAGE.D3DDECLUSAGE_SAMPLE;
 const int MAXD3DDECLUSAGEINDEX =   15;
 const int MAXD3DDECLLENGTH     =   64; // does not include "end" marker
vertex element

 enum _D3DDECLMETHOD
 {
     D3DDECLMETHOD_DEFAULT = 0,
     D3DDECLMETHOD_PARTIALU,
     D3DDECLMETHOD_PARTIALV,
     D3DDECLMETHOD_CROSSUV,    // Normal
     D3DDECLMETHOD_UV,
     D3DDECLMETHOD_LOOKUP,               // Lookup a displacement map
     D3DDECLMETHOD_LOOKUPPRESAMPLED,     // Lookup a pre-sampled
displacement map
 }
 alias _D3DDECLMETHOD D3DDECLMETHOD;
 const int MAXD3DDECLMETHOD = D3DDECLMETHOD.D3DDECLMETHOD_LOOKUPPRESAMPLED;



 // Declarations for _Type fields
 //
 enum _D3DDECLTYPE
 {
     D3DDECLTYPE_FLOAT1    =  0,  // 1D float expanded to (value, 0., 0.,
1.)
     D3DDECLTYPE_FLOAT2    =  1,  // 2D float expanded to (value, value, 0.,
1.)
     D3DDECLTYPE_FLOAT3    =  2,  // 3D float expanded to (value, value,
value, 1.)
     D3DDECLTYPE_FLOAT4    =  3,  // 4D float
     D3DDECLTYPE_D3DCOLOR  =  4,  // 4D packed unsigned bytes mapped to 0.
to 1. range
                                  // Input is in D3DCOLOR format (ARGB)
expanded to (R, G, B, A)
     D3DDECLTYPE_UBYTE4    =  5,  // 4D unsigned byte
     D3DDECLTYPE_SHORT2    =  6,  // 2D signed short expanded to (value,
value, 0., 1.)
     D3DDECLTYPE_SHORT4    =  7,  // 4D signed short

 // The following types are valid only with vertex shaders >= 2.0


     D3DDECLTYPE_UBYTE4N   =  8,  // Each of 4 bytes is normalized by
dividing to 255.0
     D3DDECLTYPE_SHORT2N   =  9,  // 2D signed short normalized
(v[0]/32767.0,v[1]/32767.0,0,1)
     D3DDECLTYPE_SHORT4N   = 10,  // 4D signed short normalized
(v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
     D3DDECLTYPE_USHORT2N  = 11,  // 2D unsigned short normalized
(v[0]/65535.0,v[1]/65535.0,0,1)
     D3DDECLTYPE_USHORT4N  = 12,  // 4D unsigned short normalized
(v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
     D3DDECLTYPE_UDEC3     = 13,  // 3D unsigned 10 10 10 format expanded to
(value, value, value, 1)
     D3DDECLTYPE_DEC3N     = 14,  // 3D signed 10 10 10 format normalized
and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
     D3DDECLTYPE_FLOAT16_2 = 15,  // Two 16-bit floating point values,
expanded to (value, value, 0, 1)
     D3DDECLTYPE_FLOAT16_4 = 16,  // Four 16-bit floating point values
     D3DDECLTYPE_UNUSED    = 17,  // When the type field in a decl is
unused.
 }
 alias _D3DDECLTYPE D3DDECLTYPE;

 const int MAXD3DDECLTYPE = D3DDECLTYPE.D3DDECLTYPE_UNUSED;

 struct _D3DVERTEXELEMENT9
 {
     WORD    Stream;     // Stream index
     WORD    Offset;     // Offset in the stream in bytes
     BYTE    Type;       // Data type
     BYTE    Method;     // Processing method
     BYTE    Usage;      // Semantics
     BYTE    UsageIndex; // Semantic index
 }
 alias _D3DVERTEXELEMENT9 D3DVERTEXELEMENT9;
 alias D3DVERTEXELEMENT9* LPD3DVERTEXELEMENT9;


 // This is used to initialize the last vertex element in a vertex
declaration
 // array
 //
 //#define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0}
 D3DVERTEXELEMENT9 D3DDECL_END ()
 {
  static D3DVERTEXELEMENT9 d3dVerElement =
   { Stream : 0xFF, Offset : 0, Type : D3DDECLTYPE.D3DDECLTYPE_UNUSED,
Method : 0, Usage : 0, UsageIndex : 0};
  return d3dVerElement;
 }

 // Maximum supported number of texture coordinate sets
 const int D3DDP_MAXTEXCOORD =  8;


 //---------------------------------------------------------------------
 //
 // The internal format of Pixel Shader (PS) & Vertex Shader (VS)
 // Instruction Tokens is defined in the Direct3D Device Driver Kit
 //
 //---------------------------------------------------------------------

 //
 // Instruction Token Bit Definitions
 //
 const int D3DSI_OPCODE_MASK      = 0x0000FFFF;

 const int D3DSI_INSTLENGTH_MASK  = 0x0F000000;
 const int D3DSI_INSTLENGTH_SHIFT = 24;

 enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE
 {
     D3DSIO_NOP          = 0,
     D3DSIO_MOV          ,
     D3DSIO_ADD          ,
     D3DSIO_SUB          ,
     D3DSIO_MAD          ,
     D3DSIO_MUL          ,
     D3DSIO_RCP          ,
     D3DSIO_RSQ          ,
     D3DSIO_DP3          ,
     D3DSIO_DP4          ,
     D3DSIO_MIN          ,
     D3DSIO_MAX          ,
     D3DSIO_SLT          ,
     D3DSIO_SGE          ,
     D3DSIO_EXP          ,
     D3DSIO_LOG          ,
     D3DSIO_LIT          ,
     D3DSIO_DST          ,
     D3DSIO_LRP          ,
     D3DSIO_FRC          ,
     D3DSIO_M4x4         ,
     D3DSIO_M4x3         ,
     D3DSIO_M3x4         ,
     D3DSIO_M3x3         ,
     D3DSIO_M3x2         ,
     D3DSIO_CALL         ,
     D3DSIO_CALLNZ       ,
     D3DSIO_LOOP         ,
     D3DSIO_RET          ,
     D3DSIO_ENDLOOP      ,
     D3DSIO_LABEL        ,
     D3DSIO_DCL          ,
     D3DSIO_POW          ,
     D3DSIO_CRS          ,
     D3DSIO_SGN          ,
     D3DSIO_ABS          ,
     D3DSIO_NRM          ,
     D3DSIO_SINCOS       ,
     D3DSIO_REP          ,
     D3DSIO_ENDREP       ,
     D3DSIO_IF           ,
     D3DSIO_IFC          ,
     D3DSIO_ELSE         ,
     D3DSIO_ENDIF        ,
     D3DSIO_BREAK        ,
     D3DSIO_BREAKC       ,
     D3DSIO_MOVA         ,
     D3DSIO_DEFB         ,
     D3DSIO_DEFI         ,

     D3DSIO_TEXCOORD     = 64,
     D3DSIO_TEXKILL      ,
     D3DSIO_TEX          ,
     D3DSIO_TEXBEM       ,
     D3DSIO_TEXBEML      ,
     D3DSIO_TEXREG2AR    ,
     D3DSIO_TEXREG2GB    ,
     D3DSIO_TEXM3x2PAD   ,
     D3DSIO_TEXM3x2TEX   ,
     D3DSIO_TEXM3x3PAD   ,
     D3DSIO_TEXM3x3TEX   ,
     D3DSIO_RESERVED0    ,
     D3DSIO_TEXM3x3SPEC  ,
     D3DSIO_TEXM3x3VSPEC ,
     D3DSIO_EXPP         ,
     D3DSIO_LOGP         ,
     D3DSIO_CND          ,
     D3DSIO_DEF          ,
     D3DSIO_TEXREG2RGB   ,
     D3DSIO_TEXDP3TEX    ,
     D3DSIO_TEXM3x2DEPTH ,
     D3DSIO_TEXDP3       ,
     D3DSIO_TEXM3x3      ,
     D3DSIO_TEXDEPTH     ,
     D3DSIO_CMP          ,
     D3DSIO_BEM          ,
     D3DSIO_DP2ADD       ,
     D3DSIO_DSX          ,
     D3DSIO_DSY          ,
     D3DSIO_TEXLDD       ,
     D3DSIO_SETP         ,
     D3DSIO_TEXLDL       ,
     D3DSIO_BREAKP       ,

     D3DSIO_PHASE        = 0xFFFD,
     D3DSIO_COMMENT      = 0xFFFE,
     D3DSIO_END          = 0xFFFF,

     D3DSIO_FORCE_DWORD  = 0x7fffffff,   // force 32-bit size enum
 }
 alias _D3DSHADER_INSTRUCTION_OPCODE_TYPE D3DSHADER_INSTRUCTION_OPCODE_TYPE;

 //---------------------------------------------------------------------
 // Use these constants with D3DSIO_SINCOS macro as SRC2, SRC3
 //
 /** ATTENTION !! : I don't know how to convert these 2 lines. */
 //#define D3DSINCOSCONST1 -1.5500992e-006f, -2.1701389e-005f,
0.0026041667f, 0.00026041668f
 //const char[] D3DSINCOSCONST1 = "-1.5500992e-006f, -2.1701389e-005f,
0.0026041667f, 0.00026041668f";
 const float[4] D3DSINCOSCONST1 = [ -1.5500992e-006f, -2.1701389e-005f,
0.0026041667f, 0.00026041668f ];
 //#define D3DSINCOSCONST2 -0.020833334f, -0.12500000f, 1.0f, 0.50000000f
 //const char[] D3DSINCOSCONST2 = "-0.020833334f, -0.12500000f, 1.0f,
0.50000000f";
 const float[4] D3DSINCOSCONST2 = [ -0.020833334f, -0.12500000f, 1.0f,
0.50000000f ];


 //---------------------------------------------------------------------
 // Co-Issue Instruction Modifier - if set then this instruction is to be
 // issued in parallel with the previous instruction(s) for which this bit
 // is not set.
 //
 const int D3DSI_COISSUE        =   0x40000000;

 //---------------------------------------------------------------------
 // Opcode specific controls

 const int D3DSP_OPCODESPECIFICCONTROL_MASK = 0x00ff0000;
 const int D3DSP_OPCODESPECIFICCONTROL_SHIFT = 16;

 // ps_2_0 texld controls
 const int D3DSI_TEXLD_PROJECT = (0x01 <<
D3DSP_OPCODESPECIFICCONTROL_SHIFT);
 const int D3DSI_TEXLD_BIAS    = (0x02 <<
D3DSP_OPCODESPECIFICCONTROL_SHIFT);

 // Comparison for dynamic conditional instruction opcodes (i.e. if, breakc)
 enum _D3DSHADER_COMPARISON
 {
                          // < = >
     D3DSPC_RESERVED0= 0, // 0 0 0
     D3DSPC_GT       = 1, // 0 0 1
     D3DSPC_EQ       = 2, // 0 1 0
     D3DSPC_GE       = 3, // 0 1 1
     D3DSPC_LT       = 4, // 1 0 0
     D3DSPC_NE       = 5, // 1 0 1
     D3DSPC_LE       = 6, // 1 1 0
     D3DSPC_RESERVED1= 7  // 1 1 1
 }
 alias _D3DSHADER_COMPARISON D3DSHADER_COMPARISON;

 // Comparison is part of instruction opcode token:
 const int D3DSHADER_COMPARISON_SHIFT = D3DSP_OPCODESPECIFICCONTROL_SHIFT;
 const int D3DSHADER_COMPARISON_MASK = (0x7<<D3DSHADER_COMPARISON_SHIFT);

 //---------------------------------------------------------------------
 // Predication flags on instruction token
 const int D3DSHADER_INSTRUCTION_PREDICATED   = (0x1 << 28);

 //---------------------------------------------------------------------
 // DCL Info Token Controls

 // For dcl info tokens requiring a semantic (usage + index)
 const int D3DSP_DCL_USAGE_SHIFT = 0;
 const int D3DSP_DCL_USAGE_MASK  = 0x0000000f;

 const int D3DSP_DCL_USAGEINDEX_SHIFT = 16;
 const int D3DSP_DCL_USAGEINDEX_MASK  = 0x000f0000;

 // DCL pixel shader sampler info token.
 const int D3DSP_TEXTURETYPE_SHIFT = 27;
 const int D3DSP_TEXTURETYPE_MASK  = 0x78000000;

 enum _D3DSAMPLER_TEXTURE_TYPE
 {
     D3DSTT_UNKNOWN = 0<<D3DSP_TEXTURETYPE_SHIFT, // uninitialized value
     D3DSTT_2D      = 2<<D3DSP_TEXTURETYPE_SHIFT, // dcl_2d s# (for
declaring a 2-D texture)
     D3DSTT_CUBE    = 3<<D3DSP_TEXTURETYPE_SHIFT, // dcl_cube s# (for
declaring a cube texture)
     D3DSTT_VOLUME  = 4<<D3DSP_TEXTURETYPE_SHIFT, // dcl_volume s# (for
declaring a volume texture)
     D3DSTT_FORCE_DWORD  = 0x7fffffff,      // force 32-bit size enum
 }
 alias _D3DSAMPLER_TEXTURE_TYPE D3DSAMPLER_TEXTURE_TYPE;

 //---------------------------------------------------------------------
 // Parameter Token Bit Definitions
 //
 const int D3DSP_REGNUM_MASK   =    0x000007FF;

 // destination parameter write mask
 const int D3DSP_WRITEMASK_0    =   0x00010000;  // Component 0 (X;Red)
 const int D3DSP_WRITEMASK_1    =   0x00020000;  // Component 1 (Y;Green)
 const int D3DSP_WRITEMASK_2    =   0x00040000;  // Component 2 (Z;Blue)
 const int D3DSP_WRITEMASK_3    =   0x00080000;  // Component 3 (W;Alpha)
 const int D3DSP_WRITEMASK_ALL  =   0x000F0000;  // All Components

 // destination parameter modifiers
 const int D3DSP_DSTMOD_SHIFT   =   20;
 const int D3DSP_DSTMOD_MASK    =   0x00F00000;

 // Bit masks for destination parameter modifiers
 const int    D3DSPDM_NONE              =   (0<<D3DSP_DSTMOD_SHIFT); // nop
 const int    D3DSPDM_SATURATE          =   (1<<D3DSP_DSTMOD_SHIFT); //
clamp to 0. to 1. range
 const int    D3DSPDM_PARTIALPRECISION  =   (2<<D3DSP_DSTMOD_SHIFT); //
Partial precision hint
 const int    D3DSPDM_MSAMPCENTROID     =   (4<<D3DSP_DSTMOD_SHIFT); //
Relevant to multisampling only:
                                                                  //
When the pixel center is not covered, sample
                                                                  //
attribute or compute gradients/LOD
                                                                  //
using multisample "centroid" location.
                                                                  //
"Centroid" is some location within the covered
                                                                  //
region of the pixel.

 // destination parameter
 const int D3DSP_DSTSHIFT_SHIFT  =  24;
 const int D3DSP_DSTSHIFT_MASK   =  0x0F000000;

 // destination/source parameter register type
 const int D3DSP_REGTYPE_SHIFT   =  28;
 const int D3DSP_REGTYPE_SHIFT2  =  8;
 const int D3DSP_REGTYPE_MASK    =  0x70000000;
 const int D3DSP_REGTYPE_MASK2   =  0x00001800;

 enum _D3DSHADER_PARAM_REGISTER_TYPE
 {
     D3DSPR_TEMP           =  0, // Temporary Register File
     D3DSPR_INPUT          =  1, // Input Register File
     D3DSPR_CONST          =  2, // Constant Register File
     D3DSPR_ADDR           =  3, // Address Register (VS)
     D3DSPR_TEXTURE        =  3, // Texture Register File (PS)
     D3DSPR_RASTOUT        =  4, // Rasterizer Register File
     D3DSPR_ATTROUT        =  5, // Attribute Output Register File
     D3DSPR_TEXCRDOUT      =  6, // Texture Coordinate Output Register File
     D3DSPR_OUTPUT         =  6, // Output register file for VS3.0+
     D3DSPR_CONSTINT       =  7, // Constant Integer Vector Register File
     D3DSPR_COLOROUT       =  8, // Color Output Register File
     D3DSPR_DEPTHOUT       =  9, // Depth Output Register File
     D3DSPR_SAMPLER        = 10, // Sampler State Register File
     D3DSPR_CONST2         = 11, // Constant Register File  2048 - 4095
     D3DSPR_CONST3         = 12, // Constant Register File  4096 - 6143
     D3DSPR_CONST4         = 13, // Constant Register File  6144 - 8191
     D3DSPR_CONSTBOOL      = 14, // Constant Boolean register file
     D3DSPR_LOOP           = 15, // Loop counter register file
     D3DSPR_TEMPFLOAT16    = 16, // 16-bit float temp register file
     D3DSPR_MISCTYPE       = 17, // Miscellaneous (single) registers.
     D3DSPR_LABEL          = 18, // Label
     D3DSPR_PREDICATE      = 19, // Predicate register
     D3DSPR_FORCE_DWORD  = 0x7fffffff,         // force 32-bit size enum
 }
 alias _D3DSHADER_PARAM_REGISTER_TYPE D3DSHADER_PARAM_REGISTER_TYPE;

 // The miscellaneous register file (D3DSPR_MISCTYPES)
 // contains register types for which there is only ever one
 // register (i.e. the register # is not needed).
 // Rather than use up additional register types for such
 // registers, they are defined
 // as particular offsets into the misc. register file:
 enum _D3DSHADER_MISCTYPE_OFFSETS
 {
     D3DSMO_POSITION   = 0, // Input position x,y,z,rhw (PS)
     D3DSMO_FACE   = 1, // Floating point primitive area (PS)
 }
 alias _D3DSHADER_MISCTYPE_OFFSETS D3DSHADER_MISCTYPE_OFFSETS;

 // Register offsets in the Rasterizer Register File
 //
 enum _D3DVS_RASTOUT_OFFSETS
 {
     D3DSRO_POSITION = 0,
     D3DSRO_FOG,
     D3DSRO_POINT_SIZE,
     D3DSRO_FORCE_DWORD  = 0x7fffffff,         // force 32-bit size enum
 }
 alias _D3DVS_RASTOUT_OFFSETS D3DVS_RASTOUT_OFFSETS;

 // Source operand addressing modes

 const int D3DVS_ADDRESSMODE_SHIFT = 13;
 const int D3DVS_ADDRESSMODE_MASK  = (1 << D3DVS_ADDRESSMODE_SHIFT);

 enum _D3DVS_ADDRESSMODE_TYPE
 {
     D3DVS_ADDRMODE_ABSOLUTE  = (0 << D3DVS_ADDRESSMODE_SHIFT),
     D3DVS_ADDRMODE_RELATIVE  = (1 << D3DVS_ADDRESSMODE_SHIFT),
     D3DVS_ADDRMODE_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
 }
 alias _D3DVS_ADDRESSMODE_TYPE D3DVS_ADDRESSMODE_TYPE;

 const int D3DSHADER_ADDRESSMODE_SHIFT = 13;
 const int D3DSHADER_ADDRESSMODE_MASK  = (1 << D3DSHADER_ADDRESSMODE_SHIFT);

 enum _D3DSHADER_ADDRESSMODE_TYPE
 {
     D3DSHADER_ADDRMODE_ABSOLUTE  = (0 << D3DSHADER_ADDRESSMODE_SHIFT),
     D3DSHADER_ADDRMODE_RELATIVE  = (1 << D3DSHADER_ADDRESSMODE_SHIFT),
     D3DSHADER_ADDRMODE_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
 }
 alias _D3DSHADER_ADDRESSMODE_TYPE D3DSHADER_ADDRESSMODE_TYPE;

 // Source operand swizzle definitions
 //
 const int D3DVS_SWIZZLE_SHIFT   =  16;
 const int D3DVS_SWIZZLE_MASK    =  0x00FF0000;

 // The following bits define where to take component X from:

 const int D3DVS_X_X     =  (0 << D3DVS_SWIZZLE_SHIFT);
 const int D3DVS_X_Y     =  (1 << D3DVS_SWIZZLE_SHIFT);
 const int D3DVS_X_Z     =  (2 << D3DVS_SWIZZLE_SHIFT);
 const int D3DVS_X_W     =  (3 << D3DVS_SWIZZLE_SHIFT);

 // The following bits define where to take component Y from:

 const int D3DVS_Y_X     =  (0 << (D3DVS_SWIZZLE_SHIFT + 2));
 const int D3DVS_Y_Y     =  (1 << (D3DVS_SWIZZLE_SHIFT + 2));
 const int D3DVS_Y_Z     =  (2 << (D3DVS_SWIZZLE_SHIFT + 2));
 const int D3DVS_Y_W     =  (3 << (D3DVS_SWIZZLE_SHIFT + 2));

 // The following bits define where to take component Z from:

 const int D3DVS_Z_X     =  (0 << (D3DVS_SWIZZLE_SHIFT + 4));
 const int D3DVS_Z_Y     =  (1 << (D3DVS_SWIZZLE_SHIFT + 4));
 const int D3DVS_Z_Z     =  (2 << (D3DVS_SWIZZLE_SHIFT + 4));
 const int D3DVS_Z_W     =  (3 << (D3DVS_SWIZZLE_SHIFT + 4));

 // The following bits define where to take component W from:

 const int D3DVS_W_X     =  (0 << (D3DVS_SWIZZLE_SHIFT + 6));
 const int D3DVS_W_Y     =  (1 << (D3DVS_SWIZZLE_SHIFT + 6));
 const int D3DVS_W_Z     =  (2 << (D3DVS_SWIZZLE_SHIFT + 6));
 const int D3DVS_W_W     =  (3 << (D3DVS_SWIZZLE_SHIFT + 6));

 // Value when there is no swizzle (X is taken from X, Y is taken from Y,
 // Z is taken from Z, W is taken from W
 //
 const int D3DVS_NOSWIZZLE = (D3DVS_X_X | D3DVS_Y_Y | D3DVS_Z_Z |
D3DVS_W_W);

 // source parameter swizzle
 const int D3DSP_SWIZZLE_SHIFT   =  16;
 const int D3DSP_SWIZZLE_MASK    =  0x00FF0000;

 //#define D3DSP_NOSWIZZLE \
 //    ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (3 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_NOSWIZZLE =
     ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) |
       (1 << (D3DSP_SWIZZLE_SHIFT + 2)) |
       (2 << (D3DSP_SWIZZLE_SHIFT + 4)) |
       (3 << (D3DSP_SWIZZLE_SHIFT + 6)) );

 // pixel-shader swizzle ops
 //#define D3DSP_REPLICATERED \
 //    ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (0 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (0 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (0 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_REPLICATERED =
     ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) |
       (0 << (D3DSP_SWIZZLE_SHIFT + 2)) |
       (0 << (D3DSP_SWIZZLE_SHIFT + 4)) |
       (0 << (D3DSP_SWIZZLE_SHIFT + 6)) );



 //#define D3DSP_REPLICATEGREEN \
 //    ( (1 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (1 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (1 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_REPLICATEGREEN =
  ( (1 << (D3DSP_SWIZZLE_SHIFT + 0)) |
       (1 << (D3DSP_SWIZZLE_SHIFT + 2)) |
       (1 << (D3DSP_SWIZZLE_SHIFT + 4)) |
       (1 << (D3DSP_SWIZZLE_SHIFT + 6)) );



 //#define D3DSP_REPLICATEBLUE \
 //    ( (2 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (2 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (2 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_REPLICATEBLUE = ( (2 << (D3DSP_SWIZZLE_SHIFT + 0)) |
                (2 << (D3DSP_SWIZZLE_SHIFT + 2)) |
                (2 << (D3DSP_SWIZZLE_SHIFT + 4)) |
                (2 << (D3DSP_SWIZZLE_SHIFT + 6)) );


 //#define D3DSP_REPLICATEALPHA \
 //    ( (3 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (3 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (3 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (3 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_REPLICATEALPHA = ( (3 << (D3DSP_SWIZZLE_SHIFT + 0)) |
               (3 << (D3DSP_SWIZZLE_SHIFT + 2)) |
               (3 << (D3DSP_SWIZZLE_SHIFT + 4)) |
               (3 << (D3DSP_SWIZZLE_SHIFT + 6)) );


 // source parameter modifiers
 const int D3DSP_SRCMOD_SHIFT   =   24;
 const int D3DSP_SRCMOD_MASK    =   0x0F000000;

 enum _D3DSHADER_PARAM_SRCMOD_TYPE
 {
     D3DSPSM_NONE    = 0<<D3DSP_SRCMOD_SHIFT, // nop
     D3DSPSM_NEG     = 1<<D3DSP_SRCMOD_SHIFT, // negate
     D3DSPSM_BIAS    = 2<<D3DSP_SRCMOD_SHIFT, // bias
     D3DSPSM_BIASNEG = 3<<D3DSP_SRCMOD_SHIFT, // bias and negate
     D3DSPSM_SIGN    = 4<<D3DSP_SRCMOD_SHIFT, // sign
     D3DSPSM_SIGNNEG = 5<<D3DSP_SRCMOD_SHIFT, // sign and negate
     D3DSPSM_COMP    = 6<<D3DSP_SRCMOD_SHIFT, // complement
     D3DSPSM_X2      = 7<<D3DSP_SRCMOD_SHIFT, // *2
     D3DSPSM_X2NEG   = 8<<D3DSP_SRCMOD_SHIFT, // *2 and negate
     D3DSPSM_DZ      = 9<<D3DSP_SRCMOD_SHIFT, // divide through by z
component
     D3DSPSM_DW      = 10<<D3DSP_SRCMOD_SHIFT, // divide through by w
component
     D3DSPSM_ABS     = 11<<D3DSP_SRCMOD_SHIFT, // abs()
     D3DSPSM_ABSNEG  = 12<<D3DSP_SRCMOD_SHIFT, // -abs()
     D3DSPSM_NOT     = 13<<D3DSP_SRCMOD_SHIFT, // for predicate register:
"!p0"
     D3DSPSM_FORCE_DWORD = 0x7fffffff,        // force 32-bit size enum
 }
 alias _D3DSHADER_PARAM_SRCMOD_TYPE D3DSHADER_PARAM_SRCMOD_TYPE;

 // pixel shader version token
 //#define D3DPS_VERSION(_Major,_Minor) (0xFFFF0000|((_Major)<<8)|(_Minor))
 int D3DPS_VERSION (int _Major, int _Minor)
 {
  return (0xFFFF0000|((_Major)<<8)|(_Minor));
 }

 // vertex shader version token
 //#define D3DVS_VERSION(_Major,_Minor) (0xFFFE0000|((_Major)<<8)|(_Minor))
 int D3DVS_VERSION (int _Major , int _Minor)
 {
  return (0xFFFE0000|((_Major)<<8)|(_Minor));
 }

 // extract major/minor from version cap
 //#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
 int D3DSHADER_VERSION_MAJOR (int _Version)
 {
  return  (((_Version)>>8) & 0xFF);
 }

 //#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
 int D3DSHADER_VERSION_MINOR (int _Version)
 {
  return (((_Version)>>0)&0xFF);
 }

 // destination/source parameter register type
 const int D3DSI_COMMENTSIZE_SHIFT   =  16;
 const int D3DSI_COMMENTSIZE_MASK    =  0x7FFF0000;

 //#define D3DSHADER_COMMENT(_DWordSize) \
 //
((((_DWordSize)<<D3DSI_COMMENTSIZE_SHIFT)&D3DSI_COMMENTSIZE_MASK)|D3DSIO_COM
MENT)
 int D3DSHADER_COMMENT (DWORD _DWordSize)
 {
  return ((((_DWordSize) << D3DSI_COMMENTSIZE_SHIFT) &
D3DSI_COMMENTSIZE_MASK) | D3DSHADER_INSTRUCTION_OPCODE_TYPE.D3DSIO_COMMENT);
 }

 // pixel/vertex shader end token
 //#define D3DPS_END()  0x0000FFFF
 int D3DPS_END ()
 {
  return 0x0000FFFF;
 }

 //#define D3DVS_END()  0x0000FFFF
 int D3DVS_END ()
 {
  return 0x0000FFFF;
 }


 //---------------------------------------------------------------------

 // High order surfaces
 //
 enum _D3DBASISTYPE
 {
    D3DBASIS_BEZIER      = 0,
    D3DBASIS_BSPLINE     = 1,
    D3DBASIS_CATMULL_ROM = 2, /* In D3D8 this used to be
D3DBASIS_INTERPOLATE */
    D3DBASIS_FORCE_DWORD = 0x7fffffff,
 }
 alias _D3DBASISTYPE D3DBASISTYPE;

 enum _D3DDEGREETYPE
 {
    D3DDEGREE_LINEAR      = 1,
    D3DDEGREE_QUADRATIC   = 2,
    D3DDEGREE_CUBIC       = 3,
    D3DDEGREE_QUINTIC     = 5,
    D3DDEGREE_FORCE_DWORD = 0x7fffffff,
 }
 alias _D3DDEGREETYPE D3DDEGREETYPE;

 enum _D3DPATCHEDGESTYLE
 {
    D3DPATCHEDGE_DISCRETE    = 0,
    D3DPATCHEDGE_CONTINUOUS  = 1,
    D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff,
 }
 alias _D3DPATCHEDGESTYLE D3DPATCHEDGESTYLE;

 enum _D3DSTATEBLOCKTYPE
 {
     D3DSBT_ALL           = 1, // capture all state
     D3DSBT_PIXELSTATE    = 2, // capture pixel state
     D3DSBT_VERTEXSTATE   = 3, // capture vertex state
     D3DSBT_FORCE_DWORD   = 0x7fffffff,
 }
 alias _D3DSTATEBLOCKTYPE D3DSTATEBLOCKTYPE;

 // The D3DVERTEXBLENDFLAGS type is used with D3DRS_VERTEXBLEND state.
 //
 enum _D3DVERTEXBLENDFLAGS
 {
     D3DVBF_DISABLE  = 0,     // Disable vertex blending
     D3DVBF_1WEIGHTS = 1,     // 2 matrix blending
     D3DVBF_2WEIGHTS = 2,     // 3 matrix blending
     D3DVBF_3WEIGHTS = 3,     // 4 matrix blending
     D3DVBF_TWEENING = 255,   // blending using D3DRS_TWEENFACTOR
     D3DVBF_0WEIGHTS = 256,   // one matrix is used with weight 1.0
     D3DVBF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
 }
 alias _D3DVERTEXBLENDFLAGS D3DVERTEXBLENDFLAGS;

 enum _D3DTEXTURETRANSFORMFLAGS
 {
     D3DTTFF_DISABLE         = 0,    // texture coordinates are passed
directly
     D3DTTFF_COUNT1          = 1,    // rasterizer should expect 1-D texture
coords
     D3DTTFF_COUNT2          = 2,    // rasterizer should expect 2-D texture
coords
     D3DTTFF_COUNT3          = 3,    // rasterizer should expect 3-D texture
coords
     D3DTTFF_COUNT4          = 4,    // rasterizer should expect 4-D texture
coords
     D3DTTFF_PROJECTED       = 256,  // texcoords to be divided by COUNTth
element
     D3DTTFF_FORCE_DWORD     = 0x7fffffff,
 }
 alias _D3DTEXTURETRANSFORMFLAGS D3DTEXTURETRANSFORMFLAGS;

 // Macros to set texture coordinate format bits in the FVF id

 const int D3DFVF_TEXTUREFORMAT2 = 0;         // Two floating point values
 const int D3DFVF_TEXTUREFORMAT1 = 3;         // One floating point value
 const int D3DFVF_TEXTUREFORMAT3 = 1;         // Three floating point values
 const int D3DFVF_TEXTUREFORMAT4 = 2;         // Four floating point values

 //#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 <<
(CoordIndex*2 + 16))
 int D3DFVF_TEXCOORDSIZE3 (int CoordIndex)
 {
  return (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16));
 }

 //#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2)
 int D3DFVF_TEXCOORDSIZE2 (int CoordIndex)
 {
  return (D3DFVF_TEXTUREFORMAT2);
 }

 //#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 <<
(CoordIndex*2 + 16))
 int D3DFVF_TEXCOORDSIZE4 (int CoordIndex)
 {
  return  (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16));
 }

 //#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 <<
(CoordIndex*2 + 16))
 int D3DFVF_TEXCOORDSIZE1 (int CoordIndex)
 {
  return (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16));
 }


 //---------------------------------------------------------------------

 /* Direct3D9 Device types */
 enum _D3DDEVTYPE
 {
     D3DDEVTYPE_HAL         = 1,
     D3DDEVTYPE_REF         = 2,
     D3DDEVTYPE_SW          = 3,

     D3DDEVTYPE_FORCE_DWORD  = 0x7fffffff
 }
 alias _D3DDEVTYPE D3DDEVTYPE;

 /* Multi-Sample buffer types */
 enum _D3DMULTISAMPLE_TYPE
 {
     D3DMULTISAMPLE_NONE            =  0,
     D3DMULTISAMPLE_NONMASKABLE     =  1,
     D3DMULTISAMPLE_2_SAMPLES       =  2,
     D3DMULTISAMPLE_3_SAMPLES       =  3,
     D3DMULTISAMPLE_4_SAMPLES       =  4,
     D3DMULTISAMPLE_5_SAMPLES       =  5,
     D3DMULTISAMPLE_6_SAMPLES       =  6,
     D3DMULTISAMPLE_7_SAMPLES       =  7,
     D3DMULTISAMPLE_8_SAMPLES       =  8,
     D3DMULTISAMPLE_9_SAMPLES       =  9,
     D3DMULTISAMPLE_10_SAMPLES      = 10,
     D3DMULTISAMPLE_11_SAMPLES      = 11,
     D3DMULTISAMPLE_12_SAMPLES      = 12,
     D3DMULTISAMPLE_13_SAMPLES      = 13,
     D3DMULTISAMPLE_14_SAMPLES      = 14,
     D3DMULTISAMPLE_15_SAMPLES      = 15,
     D3DMULTISAMPLE_16_SAMPLES      = 16,

     D3DMULTISAMPLE_FORCE_DWORD     = 0x7fffffff
 }
 alias _D3DMULTISAMPLE_TYPE D3DMULTISAMPLE_TYPE;

 /* Formats
  * Most of these names have the following convention:
  *      A = Alpha
  *      R = Red
  *      G = Green
  *      B = Blue
  *      X = Unused Bits
  *      P = Palette
  *      L = Luminance
  *      U = dU coordinate for BumpMap
  *      V = dV coordinate for BumpMap
  *      S = Stencil
  *      D = Depth (e.g. Z or W buffer)
  *      C = Computed from other channels (typically on certain read
operations)
  *
  *      Further, the order of the pieces are from MSB first; hence
  *      D3DFMT_A8L8 indicates that the high byte of this two byte
  *      format is alpha.
  *
  *      D16 indicates:
  *           - An integer 16-bit value.
  *           - An app-lockable surface.
  *
  *      All Depth/Stencil formats except D3DFMT_D16_LOCKABLE indicate:
  *          - no particular bit ordering per pixel, and
  *          - are not app lockable, and
  *          - the driver is allowed to consume more than the indicated
  *            number of bits per Depth channel (but not Stencil channel).
  */

  //   #define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
  //               ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |       \
  //               ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
  int MAKEFOURCC ( char ch0, char ch1, char ch2, char ch3)
  {
   return ( cast(DWORD)( cast(BYTE)((ch0)) | ( cast(DWORD) (cast(BYTE)((ch1
<< 8))) ) |
       ( cast(DWORD)( cast(BYTE)(( ch2 << 16))) ) | ( cast(DWORD)(
cast(BYTE)((ch3 << 24)))) ));
  }



 enum _D3DFORMAT
 {
     D3DFMT_UNKNOWN              =  0,

     D3DFMT_R8G8B8               = 20,
     D3DFMT_A8R8G8B8             = 21,
     D3DFMT_X8R8G8B8             = 22,
     D3DFMT_R5G6B5               = 23,
     D3DFMT_X1R5G5B5             = 24,
     D3DFMT_A1R5G5B5             = 25,
     D3DFMT_A4R4G4B4             = 26,
     D3DFMT_R3G3B2               = 27,
     D3DFMT_A8                   = 28,
     D3DFMT_A8R3G3B2             = 29,
     D3DFMT_X4R4G4B4             = 30,
     D3DFMT_A2B10G10R10          = 31,
     D3DFMT_A8B8G8R8             = 32,
     D3DFMT_X8B8G8R8             = 33,
     D3DFMT_G16R16               = 34,
     D3DFMT_A2R10G10B10          = 35,
     D3DFMT_A16B16G16R16         = 36,

     D3DFMT_A8P8                 = 40,
     D3DFMT_P8                   = 41,

     D3DFMT_L8                   = 50,
     D3DFMT_A8L8                 = 51,
     D3DFMT_A4L4                 = 52,

     D3DFMT_V8U8                 = 60,
     D3DFMT_L6V5U5               = 61,
     D3DFMT_X8L8V8U8             = 62,
     D3DFMT_Q8W8V8U8             = 63,
     D3DFMT_V16U16               = 64,
     D3DFMT_A2W10V10U10          = 67,

     D3DFMT_UYVY                 = 85, //MAKEFOURCC('U', 'Y', 'V', 'Y'),
     D3DFMT_R8G8_B8G8            = 82, //MAKEFOURCC('R', 'G', 'B', 'G'),
     D3DFMT_YUY2                 = 89, //MAKEFOURCC('Y', 'U', 'Y', '2'),
     D3DFMT_G8R8_G8B8            = 71, //MAKEFOURCC('G', 'R', 'G', 'B'),
     D3DFMT_DXT1                 = 68, //MAKEFOURCC('D', 'X', 'T', '1'),
     D3DFMT_DXT2                 = 68, //MAKEFOURCC('D', 'X', 'T', '2'),
     D3DFMT_DXT3                 = 68, //MAKEFOURCC('D', 'X', 'T', '3'),
     D3DFMT_DXT4                 = 68, //MAKEFOURCC('D', 'X', 'T', '4'),
     D3DFMT_DXT5                 = 68, //MAKEFOURCC('D', 'X', 'T', '5'),

     D3DFMT_D16_LOCKABLE         = 70,
     D3DFMT_D32                  = 71,
     D3DFMT_D15S1                = 73,
     D3DFMT_D24S8                = 75,
     D3DFMT_D24X8                = 77,
     D3DFMT_D24X4S4              = 79,
     D3DFMT_D16                  = 80,

     D3DFMT_D32F_LOCKABLE        = 82,
     D3DFMT_D24FS8               = 83,


     D3DFMT_L16                  = 81,

     D3DFMT_VERTEXDATA           =100,
     D3DFMT_INDEX16              =101,
     D3DFMT_INDEX32              =102,

     D3DFMT_Q16W16V16U16         =110,

     D3DFMT_MULTI2_ARGB8         = 68, //MAKEFOURCC('M','E','T','1'),

     // Floating point surface formats

     // s10e5 formats (16-bits per channel)
     D3DFMT_R16F                 = 111,
     D3DFMT_G16R16F              = 112,
     D3DFMT_A16B16G16R16F        = 113,

     // IEEE s23e8 formats (32-bits per channel)
     D3DFMT_R32F                 = 114,
     D3DFMT_G32R32F              = 115,
     D3DFMT_A32B32G32R32F        = 116,

     D3DFMT_CxV8U8               = 117,


     D3DFMT_FORCE_DWORD          =0x7fffffff
 }
 alias _D3DFORMAT D3DFORMAT;

 /* Display Modes */
 struct _D3DDISPLAYMODE
 {
     UINT            Width;
     UINT            Height;
     UINT            RefreshRate;
     D3DFORMAT       Format;
 }
 alias _D3DDISPLAYMODE D3DDISPLAYMODE;

 /* Creation Parameters */
 struct _D3DDEVICE_CREATION_PARAMETERS
 {
     UINT            AdapterOrdinal;
     D3DDEVTYPE      DeviceType;
     HWND            hFocusWindow;
     DWORD           BehaviorFlags;
 }
 alias _D3DDEVICE_CREATION_PARAMETERS D3DDEVICE_CREATION_PARAMETERS;


 /* SwapEffects */
 enum _D3DSWAPEFFECT
 {
     D3DSWAPEFFECT_DISCARD           = 1,
     D3DSWAPEFFECT_FLIP              = 2,
     D3DSWAPEFFECT_COPY              = 3,

     D3DSWAPEFFECT_FORCE_DWORD       = 0x7fffffff
 }
 alias _D3DSWAPEFFECT D3DSWAPEFFECT;

 /* Pool types */
 enum _D3DPOOL
 {
     D3DPOOL_DEFAULT                 = 0,
     D3DPOOL_MANAGED                 = 1,
     D3DPOOL_SYSTEMMEM               = 2,
     D3DPOOL_SCRATCH                 = 3,

     D3DPOOL_FORCE_DWORD             = 0x7fffffff
 }
 alias _D3DPOOL D3DPOOL;


 /* RefreshRate pre-defines */
 const int D3DPRESENT_RATE_DEFAULT      =   0x00000000;


 /* Resize Optional Parameters */
 struct _D3DPRESENT_PARAMETERS_
 {
     UINT                BackBufferWidth;
     UINT                BackBufferHeight;
     D3DFORMAT           BackBufferFormat;
     UINT                BackBufferCount;

     D3DMULTISAMPLE_TYPE MultiSampleType;
     DWORD               MultiSampleQuality;

     D3DSWAPEFFECT       SwapEffect;
     HWND                hDeviceWindow;
     BOOL                Windowed;
     BOOL                EnableAutoDepthStencil;
     D3DFORMAT           AutoDepthStencilFormat;
     DWORD               Flags;

     /* FullScreen_RefreshRateInHz must be zero for Windowed mode */
     UINT                FullScreen_RefreshRateInHz;
     UINT                PresentationInterval;
 }
 alias _D3DPRESENT_PARAMETERS_ D3DPRESENT_PARAMETERS;

 // Values for D3DPRESENT_PARAMETERS.Flags

 const int D3DPRESENTFLAG_LOCKABLE_BACKBUFFER    =  0x00000001;
 const int D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL   =  0x00000002;
 const int D3DPRESENTFLAG_DEVICECLIP             =  0x00000004;
 const int D3DPRESENTFLAG_VIDEO                  =  0x00000010;

 /* Gamma Ramp: Same as DX7 */

 struct _D3DGAMMARAMP
 {
     WORD                red  [256];
     WORD                green[256];
     WORD                blue [256];
 }
 alias _D3DGAMMARAMP D3DGAMMARAMP;

 /* Back buffer types */
 enum _D3DBACKBUFFER_TYPE
 {
     D3DBACKBUFFER_TYPE_MONO         = 0,
     D3DBACKBUFFER_TYPE_LEFT         = 1,
     D3DBACKBUFFER_TYPE_RIGHT        = 2,

     D3DBACKBUFFER_TYPE_FORCE_DWORD  = 0x7fffffff
 }
 alias _D3DBACKBUFFER_TYPE D3DBACKBUFFER_TYPE;


 /* Types */
 enum _D3DRESOURCETYPE
 {
     D3DRTYPE_SURFACE                =  1,
     D3DRTYPE_VOLUME                 =  2,
     D3DRTYPE_TEXTURE                =  3,
     D3DRTYPE_VOLUMETEXTURE          =  4,
     D3DRTYPE_CUBETEXTURE            =  5,
     D3DRTYPE_VERTEXBUFFER           =  6,
     D3DRTYPE_INDEXBUFFER            =  7,


     D3DRTYPE_FORCE_DWORD            = 0x7fffffff
 }
 alias _D3DRESOURCETYPE D3DRESOURCETYPE;

 /* Usages */
 const int D3DUSAGE_RENDERTARGET     =  0x00000001;
 const int D3DUSAGE_DEPTHSTENCIL     =  0x00000002;
 const int D3DUSAGE_DYNAMIC          =  0x00000200;

 // When passed to CheckDeviceFormat, D3DUSAGE_AUTOGENMIPMAP may return
 // D3DOK_NOAUTOGEN if the device doesn't support autogeneration for that
format.
 // D3DOK_NOAUTOGEN is a success code, not a failure code... the SUCCEEDED
and FAILED macros
 // will return true and false respectively for this code.
 const int D3DUSAGE_AUTOGENMIPMAP     = 0x00000400;
 const int D3DUSAGE_DMAP              = 0x00004000;

 // The following usages are valid only for querying CheckDeviceFormat
 const int D3DUSAGE_QUERY_LEGACYBUMPMAP          =  0x00008000;
 const int D3DUSAGE_QUERY_SRGBREAD               =  0x00010000;
 const int D3DUSAGE_QUERY_FILTER                 =  0x00020000;
 const int D3DUSAGE_QUERY_SRGBWRITE              =  0x00040000;
 const int D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING = 0x00080000;
 const int D3DUSAGE_QUERY_VERTEXTEXTURE          =  0x00100000;

 /* Usages for Vertex/Index buffers */
 const int D3DUSAGE_WRITEONLY         = 0x00000008;
 const int D3DUSAGE_SOFTWAREPROCESSING = 0x00000010;
 const int D3DUSAGE_DONOTCLIP         = 0x00000020;
 const int D3DUSAGE_POINTS            = 0x00000040;
 const int D3DUSAGE_RTPATCHES         = 0x00000080;
 const int D3DUSAGE_NPATCHES          = 0x00000100;










 /* CubeMap Face identifiers */
 enum _D3DCUBEMAP_FACES
 {
     D3DCUBEMAP_FACE_POSITIVE_X     = 0,
     D3DCUBEMAP_FACE_NEGATIVE_X     = 1,
     D3DCUBEMAP_FACE_POSITIVE_Y     = 2,
     D3DCUBEMAP_FACE_NEGATIVE_Y     = 3,
     D3DCUBEMAP_FACE_POSITIVE_Z     = 4,
     D3DCUBEMAP_FACE_NEGATIVE_Z     = 5,

     D3DCUBEMAP_FACE_FORCE_DWORD    = 0x7fffffff
 }
 alias _D3DCUBEMAP_FACES D3DCUBEMAP_FACES;


 /* Lock flags */

 const int D3DLOCK_READONLY         =  0x00000010;
 const int D3DLOCK_DISCARD          =  0x00002000;
 const int D3DLOCK_NOOVERWRITE      =  0x00001000;
 const int D3DLOCK_NOSYSLOCK        =  0x00000800;
 const int D3DLOCK_DONOTWAIT        =  0x00004000;

 const int D3DLOCK_NO_DIRTY_UPDATE  =   0x00008000;







 /* Vertex Buffer Description */
 struct _D3DVERTEXBUFFER_DESC
 {
     D3DFORMAT           Format;
     D3DRESOURCETYPE     Type;
     DWORD               Usage;
     D3DPOOL             Pool;
     UINT                Size;

     DWORD               FVF;

 }
 alias _D3DVERTEXBUFFER_DESC D3DVERTEXBUFFER_DESC;

 /* Index Buffer Description */
 struct _D3DINDEXBUFFER_DESC
 {
     D3DFORMAT           Format;
     D3DRESOURCETYPE     Type;
     DWORD               Usage;
     D3DPOOL             Pool;
     UINT                Size;
 }
 alias _D3DINDEXBUFFER_DESC D3DINDEXBUFFER_DESC;


 /* Surface Description */
 struct _D3DSURFACE_DESC
 {
     D3DFORMAT           Format;
     D3DRESOURCETYPE     Type;
     DWORD               Usage;
     D3DPOOL             Pool;

     D3DMULTISAMPLE_TYPE MultiSampleType;
     DWORD               MultiSampleQuality;
     UINT                Width;
     UINT                Height;
 }
 alias _D3DSURFACE_DESC D3DSURFACE_DESC;

 struct _D3DVOLUME_DESC
 {
     D3DFORMAT           Format;
     D3DRESOURCETYPE     Type;
     DWORD               Usage;
     D3DPOOL             Pool;

     UINT                Width;
     UINT                Height;
     UINT                Depth;
 }
 alias _D3DVOLUME_DESC D3DVOLUME_DESC;

 /* Structure for LockRect */
 struct _D3DLOCKED_RECT
 {
     INT                 Pitch;
     void*               pBits;
 }
 alias _D3DLOCKED_RECT D3DLOCKED_RECT;

 /* Structures for LockBox */
 struct _D3DBOX
 {
     UINT                Left;
     UINT                Top;
     UINT                Right;
     UINT                Bottom;
     UINT                Front;
     UINT                Back;
 }
 alias _D3DBOX D3DBOX;

 struct _D3DLOCKED_BOX
 {
     INT                 RowPitch;
     INT                 SlicePitch;
     void*               pBits;
 }
 alias _D3DLOCKED_BOX D3DLOCKED_BOX;

 /* Structures for LockRange */
 struct _D3DRANGE
 {
     UINT                Offset;
     UINT                Size;
 }
 alias _D3DRANGE D3DRANGE;

 /* Structures for high order primitives */
 struct _D3DRECTPATCH_INFO
 {
     UINT                StartVertexOffsetWidth;
     UINT                StartVertexOffsetHeight;
     UINT                Width;
     UINT                Height;
     UINT                Stride;
     D3DBASISTYPE        Basis;
     D3DDEGREETYPE       Degree;
 }
 alias _D3DRECTPATCH_INFO D3DRECTPATCH_INFO;

 struct _D3DTRIPATCH_INFO
 {
     UINT                StartVertexOffset;
     UINT                NumVertices;
     D3DBASISTYPE        Basis;
     D3DDEGREETYPE       Degree;
 }
 alias _D3DTRIPATCH_INFO D3DTRIPATCH_INFO;

 /* Adapter Identifier */

 const int MAX_DEVICE_IDENTIFIER_STRING    =    512;
 struct _D3DADAPTER_IDENTIFIER9
 {
     char            Driver[MAX_DEVICE_IDENTIFIER_STRING];
     char            Description[MAX_DEVICE_IDENTIFIER_STRING];
     char            DeviceName[32];         /* Device name for GDI (ex.
\\.\DISPLAY1) */

 //#ifdef _WIN32
     int   DriverVersion;          /* Defined for 32 bit components */
 //#else
 //    DWORD           DriverVersionLowPart;   ///* Defined for 16 bit
driver components*/
 //    DWORD           DriverVersionHighPart;
 //#endif

     DWORD           VendorId;
     DWORD           DeviceId;
     DWORD           SubSysId;
     DWORD           Revision;

     GUID            DeviceIdentifier;

     DWORD           WHQLLevel;

 }
 alias _D3DADAPTER_IDENTIFIER9 D3DADAPTER_IDENTIFIER9;


 /* Raster Status structure returned by GetRasterStatus */
 struct _D3DRASTER_STATUS
 {
     BOOL            InVBlank;
     UINT            ScanLine;
 }
 alias _D3DRASTER_STATUS D3DRASTER_STATUS;



 /* Debug monitor tokens (DEBUG only)

    Note that if D3DRS_DEBUGMONITORTOKEN is set, the call is treated as
    passing a token to the debug monitor.  For example, if, after passing
    D3DDMT_ENABLE/DISABLE to D3DRS_DEBUGMONITORTOKEN other token values
    are passed in, the enabled/disabled state of the debug
    monitor will still persist.

    The debug monitor defaults to enabled.

    Calling GetRenderState on D3DRS_DEBUGMONITORTOKEN is not of any use.
 */
 enum _D3DDEBUGMONITORTOKENS
 {
     D3DDMT_ENABLE            = 0,    // enable debug monitor
     D3DDMT_DISABLE           = 1,    // disable debug monitor
     D3DDMT_FORCE_DWORD     = 0x7fffffff,
 }
 alias _D3DDEBUGMONITORTOKENS D3DDEBUGMONITORTOKENS;

 // Async feedback

 enum _D3DQUERYTYPE {
     D3DQUERYTYPE_VCACHE                 = 4, /* D3DISSUE_END */
     D3DQUERYTYPE_RESOURCEMANAGER        = 5, /* D3DISSUE_END */
     D3DQUERYTYPE_VERTEXSTATS            = 6, /* D3DISSUE_END */
     D3DQUERYTYPE_EVENT                  = 8, /* D3DISSUE_END */
     D3DQUERYTYPE_OCCLUSION              = 9, /* D3DISSUE_BEGIN,
D3DISSUE_END */
 }
 alias _D3DQUERYTYPE D3DQUERYTYPE;

 // Flags field for Issue
 const int D3DISSUE_END   = (1 << 0); // Tells the runtime to issue the end
of a query, changing it's state to "non-signaled".
 const int D3DISSUE_BEGIN  = (1 << 1); // Tells the runtime to issue the
beginng of a query.


 // Flags field for GetData
 const int D3DGETDATA_FLUSH  = (1 << 0); // Tells the runtime to flush if
the query is outstanding.


 struct _D3DRESOURCESTATS
 {
 // Data collected since last Present()
     BOOL    bThrashing;             /* indicates if thrashing */
     DWORD   ApproxBytesDownloaded;  /* Approximate number of bytes
downloaded by resource manager */
     DWORD   NumEvicts;              /* number of objects evicted */
     DWORD   NumVidCreates;          /* number of objects created in video
memory */
     DWORD   LastPri;                /* priority of last object evicted */
     DWORD   NumUsed;                /* number of objects set to the device
*/
     DWORD   NumUsedInVidMem;        /* number of objects set to the device,
which are already in video memory */
 // Persistent data
     DWORD   WorkingSet;             /* number of objects in video memory */
     DWORD   WorkingSetBytes;        /* number of bytes in video memory */
     DWORD   TotalManaged;           /* total number of managed objects */
     DWORD   TotalBytes;             /* total number of bytes of managed
objects */
 }
 alias _D3DRESOURCESTATS D3DRESOURCESTATS;

 const int D3DRTYPECOUNT = D3DRESOURCETYPE.D3DRTYPE_INDEXBUFFER + 1;

 struct _D3DDEVINFO_RESOURCEMANAGER
 {
     D3DRESOURCESTATS    stats[D3DRTYPECOUNT];
 }
 alias _D3DDEVINFO_RESOURCEMANAGER D3DDEVINFO_RESOURCEMANAGER;
 alias D3DDEVINFO_RESOURCEMANAGER* LPD3DDEVINFO_RESOURCEMANAGER;

 struct _D3DDEVINFO_D3DVERTEXSTATS
 {
     DWORD   NumRenderedTriangles;       /* total number of triangles that
are not clipped in this frame */
     DWORD   NumExtraClippingTriangles;  /* Number of new triangles
generated by clipping */
 }
 alias _D3DDEVINFO_D3DVERTEXSTATS D3DDEVINFO_D3DVERTEXSTATS;
 alias D3DDEVINFO_D3DVERTEXSTATS* LPD3DDEVINFO_D3DVERTEXSTATS;


 struct _D3DDEVINFO_VCACHE {
     DWORD   Pattern;                    /* bit pattern, return value must
be FOUR_CC(?C?, ?A?, ?C?, ?H?) */
     DWORD   OptMethod;                  /* optimization method 0 means
longest strips, 1 means vertex cache based */
     DWORD   CacheSize;                  /* cache size to optimize for
(only required if type is 1) */
     DWORD   MagicNumber;                /* used to determine when to
restart strips (only required if type is 1)*/
 }
 alias _D3DDEVINFO_VCACHE D3DDEVINFO_VCACHE;
 alias D3DDEVINFO_VCACHE* LPD3DDEVINFO_VCACHE;

 } // align (4)


//} /* (DIRECT3D_VERSION) */
Aug 31 2004
next sibling parent Q <Q_member pathlink.com> writes:
You can't use the libs in there original form but you have 2 options, run implib
that comes with DM on the DLL for aresulting lib, or runn coff2omf on the static
lib of MS's.

Q

In article <ch2nro$16p4$1 digitaldaemon.com>, aelmetwaly says...
Hi there,
I translated d3d9.h and d3d9caps.h and d3d9types.h into d but when i compile
my program I can't simply link with d3d9.lib and dxguid.lib. the linker give
invalid lib error :-(
It's a major drawback for d language that it doesn't support microsoft libs.
But these are the files for those interseted. I posted here because I don't
know how to add it to dsource. they have no automatic registeration of
projects.
////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
d3d9.d
////////////////////////////////////////

// Author : Ahmed El-Metwaly
// contact : aelmetwaly gawa.com
// Lic     : GPL


/*==========================================================================
;
 *
 *  Copyright (C) Microsoft Corporation.  All Rights Reserved.
 *
 *  File:   d3d9.h
 *  Content:    Direct3D include file
 *

****************************************************************************
/


const int DIRECT3D_VERSION =  0x0900;

// include this file content only if compiling for DX9 interfaces
//#if(DIRECT3D_VERSION >= 0x0900)
//version( DIRECT3D_VERSION)
//{

 /* This identifier is passed to Direct3DCreate9 in order to ensure that an
  * application was built against the correct header files. This number is
  * incremented whenever a header (or other) change would require
applications
  * to be rebuilt. If the version doesn't match, Direct3DCreate9 will fail.
  * (The number itself has no meaning.)*/

 const int D3D_SDK_VERSION = 31;


 import std.c.stdio;
 import std.c.stdlib;
 import std.string;
 import std.c.windows.windows;
 import std.c.windows.com;
 //import win32.wingdi; //too many conflicts with phobos std.c.windows

 // from win32.wingdi
 struct _RGNDATAHEADER {
   DWORD dwSize;
   DWORD iType;
   DWORD nCount;
   DWORD nRgnSize;
   RECT rcBound;
 }
 alias _RGNDATAHEADER RGNDATAHEADER;
 alias _RGNDATAHEADER* PRGNDATAHEADER;

 struct _RGNDATA {
   RGNDATAHEADER rdh;
   char Buffer[1];
 }
 alias _RGNDATA RGNDATA;
 alias _RGNDATA* PRGNDATA;
 alias _RGNDATA* NPRGNDATA;
 alias _RGNDATA* LPRGNDATA;

 alias GUID* REFIID;


 alias HANDLE HMONITOR;
 //alias WINAPI D3DAPI;



 /*
  * Interface IID's
  */


 /* IID_IDirect3D9 */
 /* {81BDCBCA-64D4-426d-AE8D-AD0147F4275C} */
 GUID IID_IDirect3D9 = { 0x81BDCBCA, 0x64D4, 0x426D, [ 0xAE, 0x8D, 0xAD,
0x1, 0x47, 0xF4, 0x27, 0x5C] };

 /* IID_IDirect3DDevice9 */
 // {D0223B96-BF7A-43fd-92BD-A43B0D82B9EB} */
 GUID IID_IDirect3DDevice9 = { 0xd0223b96, 0xbf7a, 0x43fd, [ 0x92, 0xbd,
0xa4, 0x3b, 0xd, 0x82, 0xb9, 0xeb] };

 /* IID_IDirect3DResource9 */
 // {05EEC05D-8F7D-4362-B999-D1BAF357C704}
 GUID IID_IDirect3DResource9 = { 0x5eec05d, 0x8f7d, 0x4362, [ 0xb9,  0x99,
0xd1, 0xba, 0xf3, 0x57, 0xc7, 0x4]};

 /* IID_IDirect3DBaseTexture9 */
 /* {580CA87E-1D3C-4d54-991D-B7D3E3C298CE} */
 GUID IID_IDirect3DBaseTexture9 ={ 0x580ca87e, 0x1d3c, 0x4d54, [ 0x99, 0x1d,
0xb7, 0xd3, 0xe3, 0xc2, 0x98, 0xce]};

 /* IID_IDirect3DTexture9 */
 /* {85C31227-3DE5-4f00-9B3A-F11AC38C18B5} */
 GUID IID_IDirect3DTexture9 = { 0x85c31227, 0x3de5, 0x4f00,[ 0x9b, 0x3a,
0xf1, 0x1a, 0xc3, 0x8c, 0x18, 0xb5]};

 /* IID_IDirect3DCubeTexture9 */
 /* {FFF32F81-D953-473a-9223-93D652ABA93F} */
 GUID IID_IDirect3DCubeTexture9 = { 0xfff32f81, 0xd953, 0x473a, [0x92, 0x23,
0x93, 0xd6, 0x52, 0xab, 0xa9, 0x3f]};

 /* IID_IDirect3DVolumeTexture9 */
 /* {2518526C-E789-4111-A7B9-47EF328D13E6} */
 GUID IID_IDirect3DVolumeTexture9 = { 0x2518526c, 0xe789, 0x4111, [0xa7,
0xb9, 0x47, 0xef, 0x32, 0x8d, 0x13, 0xe6]};

 /* IID_IDirect3DVertexBuffer9 */
 /* {B64BB1B5-FD70-4df6-BF91-19D0A12455E3} */
 GUID IID_IDirect3DVertexBuffer9 = { 0xb64bb1b5, 0xfd70, 0x4df6, [0xbf,
0x91, 0x19, 0xd0, 0xa1, 0x24, 0x55, 0xe3]};

 /* IID_IDirect3DIndexBuffer9 */
 /* {7C9DD65E-D3F7-4529-ACEE-785830ACDE35} */
 GUID IID_IDirect3DIndexBuffer9 = { 0x7c9dd65e, 0xd3f7, 0x4529, [0xac,
0xee, 0x78, 0x58, 0x30, 0xac, 0xde, 0x35]};

 /* IID_IDirect3DSurface9 */
 /* {0CFBAF3A-9FF6-429a-99B3-A2796AF8B89B} */
 GUID IID_IDirect3DSurface9 = { 0xcfbaf3a, 0x9ff6, 0x429a, [0x99,  0xb3,
0xa2, 0x79, 0x6a, 0xf8, 0xb8, 0x9b]};

 /* IID_IDirect3DVolume9 */
 /* {24F416E6-1F67-4aa7-B88E-D33F6F3128A1} */
 GUID IID_IDirect3DVolume9 = { 0x24f416e6, 0x1f67, 0x4aa7, [0xb8,  0x8e,
0xd3, 0x3f, 0x6f, 0x31, 0x28, 0xa1]};

 /* IID_IDirect3DSwapChain9 */
 /* {794950F2-ADFC-458a-905E-10A10B0B503B} */
 GUID IID_IDirect3DSwapChain9 = { 0x794950f2, 0xadfc, 0x458a, [0x90, 0x5e,
0x10, 0xa1, 0xb, 0xb, 0x50, 0x3b]};

 /* IID_IDirect3DVertexDeclaration9 */
 /* {DD13C59C-36FA-4098-A8FB-C7ED39DC8546} */
 GUID IID_IDirect3DVertexDeclaration9 = { 0xdd13c59c, 0x36fa, 0x4098, [0xa8,
0xfb, 0xc7, 0xed, 0x39, 0xdc, 0x85, 0x46]};

 /* IID_IDirect3DVertexShader9 */
 /* {EFC5557E-6265-4613-8A94-43857889EB36} */
 GUID IID_IDirect3DVertexShader9 = { 0xefc5557e, 0x6265, 0x4613, [0x8a,
0x94, 0x43, 0x85, 0x78, 0x89, 0xeb, 0x36]};

 /* IID_IDirect3DPixelShader9 */
 /* {6D3BDBDC-5B02-4415-B852-CE5E8BCCB289} */
 GUID IID_IDirect3DPixelShader9 = { 0x6d3bdbdc, 0x5b02, 0x4415, [0xb8,
0x52, 0xce, 0x5e, 0x8b, 0xcc, 0xb2, 0x89]};

 /* IID_IDirect3DStateBlock9 */
 /* {B07C4FE5-310D-4ba8-A23C-4F0F206F218B} */
 GUID IID_IDirect3DStateBlock9 = { 0xb07c4fe5, 0x310d, 0x4ba8, [ 0xa2, 0x3c,
0x4f, 0xf, 0x20, 0x6f, 0x21, 0x8b]};

 /* IID_IDirect3DQuery9 */
 /* {d9771460-a695-4f26-bbd3-27b840b541cc} */
 GUID IID_IDirect3DQuery9 = { 0xd9771460, 0xa695, 0x4f26, [0xbb,  0xd3,
0x27, 0xb8, 0x40, 0xb5, 0x41, 0xcc]};




 //interface /*DECLSPEC_UUID("81BDCBCA-64D4-426d-AE8D-AD0147F4275C")*/
IDirect3D9;
 //interface /*DECLSPEC_UUID("D0223B96-BF7A-43fd-92BD-A43B0D82B9EB")*/
IDirect3DDevice9;

 //interface /*DECLSPEC_UUID("B07C4FE5-310D-4ba8-A23C-4F0F206F218B")*/
IDirect3DStateBlock9;
 //interface /*DECLSPEC_UUID("05EEC05D-8F7D-4362-B999-D1BAF357C704")*/
IDirect3DResource9;
 //interface /*DECLSPEC_UUID("DD13C59C-36FA-4098-A8FB-C7ED39DC8546")*/
IDirect3DVertexDeclaration9;
 //interface /*DECLSPEC_UUID("EFC5557E-6265-4613-8A94-43857889EB36")*/
IDirect3DVertexShader9;
 //interface /*DECLSPEC_UUID("6D3BDBDC-5B02-4415-B852-CE5E8BCCB289")*/
IDirect3DPixelShader9;
 //interface /*DECLSPEC_UUID("580CA87E-1D3C-4d54-991D-B7D3E3C298CE")*/
IDirect3DBaseTexture9;
 //interface /*DECLSPEC_UUID("85C31227-3DE5-4f00-9B3A-F11AC38C18B5")*/
IDirect3DTexture9;
 //interface /*DECLSPEC_UUID("2518526C-E789-4111-A7B9-47EF328D13E6")*/
IDirect3DVolumeTexture9;
 //interface /*DECLSPEC_UUID("FFF32F81-D953-473a-9223-93D652ABA93F")*/
IDirect3DCubeTexture9;

 //interface /*DECLSPEC_UUID("B64BB1B5-FD70-4df6-BF91-19D0A12455E3")*/
IDirect3DVertexBuffer9;
 //interface /*DECLSPEC_UUID("7C9DD65E-D3F7-4529-ACEE-785830ACDE35")*/
IDirect3DIndexBuffer9;

 //interface /*DECLSPEC_UUID("0CFBAF3A-9FF6-429a-99B3-A2796AF8B89B")*/
IDirect3DSurface9;
 //interface /*DECLSPEC_UUID("24F416E6-1F67-4aa7-B88E-D33F6F3128A1")*/
IDirect3DVolume9;

 //interface /*DECLSPEC_UUID("794950F2-ADFC-458a-905E-10A10B0B503B")*/
IDirect3DSwapChain9;
 //interface /*DECLSPEC_UUID("d9771460-a695-4f26-bbd3-27b840b541cc")*/
IDirect3DQuery9;




 import d3d9types;
 import d3d9caps;


 extern (C) {


 /*
  * DLL Function for creating a Direct3D9 object. This object supports
  * enumeration and allows the creation of Direct3DDevice9 objects.
  * Pass the value of the constant D3D_SDK_VERSION to this function, so
  * that the run-time can validate that your application was compiled
  * against the right headers.
  */

 IDirect3D9 * Direct3DCreate9(UINT SDKVersion);


 /*
  * Direct3D interfaces
  */



 interface IDirect3D9 : IUnknown
 {
     /*** IUnknown methods ***/
     HRESULT QueryInterface (REFIID riid, void** ppvObj);
     ULONG AddRef () ;
     ULONG Release () ;

     /*** IDirect3D9 methods ***/
     HRESULT RegisterSoftwareDevice ( void* pInitializeFunction) ;
     UINT  GetAdapterCount () ;
     HRESULT GetAdapterIdentifier ( UINT Adapter,DWORD
Flags,D3DADAPTER_IDENTIFIER9* pIdentifier) ;
     UINT  GetAdapterModeCount ( UINT Adapter,D3DFORMAT Format) ;
     HRESULT EnumAdapterModes ( UINT Adapter,D3DFORMAT Format,UINT
Mode,D3DDISPLAYMODE* pMode) ;
     HRESULT GetAdapterDisplayMode ( UINT Adapter,D3DDISPLAYMODE* pMode) ;
     HRESULT CheckDeviceType ( UINT iAdapter,D3DDEVTYPE DevType,D3DFORMAT
DisplayFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed) ;
     HRESULT CheckDeviceFormat ( UINT Adapter,D3DDEVTYPE
DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE
RType,D3DFORMAT CheckFormat) ;
     HRESULT CheckDeviceMultiSampleType ( UINT Adapter,D3DDEVTYPE
DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE
MultiSampleType,DWORD* pQualityLevels) ;
     HRESULT CheckDepthStencilMatch ( UINT Adapter,D3DDEVTYPE
DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT
DepthStencilFormat) ;
     HRESULT CheckDeviceFormatConversion ( UINT Adapter,D3DDEVTYPE
DeviceType,D3DFORMAT SourceFormat,D3DFORMAT TargetFormat) ;
     HRESULT GetDeviceCaps ( UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9*
pCaps) ;
     HMONITOR  GetAdapterMonitor ( UINT Adapter) ;
     HRESULT CreateDevice ( UINT Adapter,D3DDEVTYPE DeviceType,HWND
hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS*
pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface) ;
 }

 alias IDirect3D9 * LPDIRECT3D9 /*, PDIRECT3D9 */;





 /* SwapChain */



 interface IDirect3DDevice9 : IUnknown
 {
     /*** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

     /*** IDirect3DDevice9 methods ***/
     HRESULT TestCooperativeLevel () ;
     UINT  GetAvailableTextureMem () ;
     HRESULT EvictManagedResources () ;
     HRESULT GetDirect3D ( IDirect3D9** ppD3D9) ;
     HRESULT GetDeviceCaps ( D3DCAPS9* pCaps) ;
     HRESULT GetDisplayMode ( UINT iSwapChain,D3DDISPLAYMODE* pMode) ;
     HRESULT GetCreationParameters ( D3DDEVICE_CREATION_PARAMETERS
*pParameters) ;
     HRESULT SetCursorProperties ( UINT XHotSpot,UINT
YHotSpot,IDirect3DSurface9* pCursorBitmap) ;
     void  SetCursorPosition ( int X,int Y,DWORD Flags) ;
     BOOL  ShowCursor ( BOOL bShow) ;
     HRESULT CreateAdditionalSwapChain ( D3DPRESENT_PARAMETERS*
pPresentationParameters,IDirect3DSwapChain9** pSwapChain) ;
     HRESULT GetSwapChain ( UINT iSwapChain,IDirect3DSwapChain9**
pSwapChain) ;
     UINT  GetNumberOfSwapChains () ;
     HRESULT Reset ( D3DPRESENT_PARAMETERS* pPresentationParameters) ;
     HRESULT Present (  RECT* pSourceRect, RECT* pDestRect,HWND
hDestWindowOverride, RGNDATA* pDirtyRegion) ;
     HRESULT GetBackBuffer ( UINT iSwapChain,UINT
iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer) ;
     HRESULT GetRasterStatus ( UINT iSwapChain,D3DRASTER_STATUS*
pRasterStatus) ;
     HRESULT SetDialogBoxMode ( BOOL bEnableDialogs) ;
     void  SetGammaRamp ( UINT iSwapChain,DWORD Flags, D3DGAMMARAMP* pRamp)
;
     void  GetGammaRamp ( UINT iSwapChain,D3DGAMMARAMP* pRamp) ;
     HRESULT CreateTexture ( UINT Width,UINT Height,UINT Levels,DWORD
Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,HANDLE*
pSharedHandle) ;
     HRESULT CreateVolumeTexture ( UINT Width,UINT Height,UINT Depth,UINT
Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9**
ppVolumeTexture,HANDLE* pSharedHandle) ;
     HRESULT CreateCubeTexture ( UINT EdgeLength,UINT Levels,DWORD
Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9**
ppCubeTexture,HANDLE* pSharedHandle) ;
     HRESULT CreateVertexBuffer ( UINT Length,DWORD Usage,DWORD FVF,D3DPOOL
Pool,IDirect3DVertexBuffer9** ppVertexBuffer,HANDLE* pSharedHandle) ;
     HRESULT CreateIndexBuffer ( UINT Length,DWORD Usage,D3DFORMAT
Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE*
pSharedHandle) ;
     HRESULT CreateRenderTarget ( UINT Width,UINT Height,D3DFORMAT
Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL
Lockable,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) ;
     HRESULT CreateDepthStencilSurface ( UINT Width,UINT Height,D3DFORMAT
Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL
Discard,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) ;
     HRESULT UpdateSurface ( IDirect3DSurface9* pSourceSurface, RECT*
pSourceRect,IDirect3DSurface9* pDestinationSurface, POINT* pDestPoint) ;
     HRESULT UpdateTexture ( IDirect3DBaseTexture9*
pSourceTexture,IDirect3DBaseTexture9* pDestinationTexture) ;
     HRESULT GetRenderTargetData ( IDirect3DSurface9*
pRenderTarget,IDirect3DSurface9* pDestSurface) ;
     HRESULT GetFrontBufferData ( UINT iSwapChain,IDirect3DSurface9*
pDestSurface) ;
     HRESULT StretchRect ( IDirect3DSurface9* pSourceSurface, RECT*
pSourceRect,IDirect3DSurface9* pDestSurface, RECT*
pDestRect,D3DTEXTUREFILTERTYPE Filter) ;
     HRESULT ColorFill ( IDirect3DSurface9* pSurface, RECT* pRect,D3DCOLOR
color) ;
     HRESULT CreateOffscreenPlainSurface ( UINT Width,UINT Height,D3DFORMAT
Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) ;
     HRESULT SetRenderTarget ( DWORD RenderTargetIndex,IDirect3DSurface9*
pRenderTarget) ;
     HRESULT GetRenderTarget ( DWORD RenderTargetIndex,IDirect3DSurface9**
ppRenderTarget) ;
     HRESULT SetDepthStencilSurface ( IDirect3DSurface9* pNewZStencil) ;
     HRESULT GetDepthStencilSurface ( IDirect3DSurface9** ppZStencilSurface)
;
     HRESULT BeginScene () ;
     HRESULT EndScene () ;
     HRESULT Clear ( DWORD Count, D3DRECT* pRects,DWORD Flags,D3DCOLOR
Color,float Z,DWORD Stencil) ;
     HRESULT SetTransform ( D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix)
;
     HRESULT GetTransform ( D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix)
;
     HRESULT MultiplyTransform ( D3DTRANSFORMSTATETYPE, D3DMATRIX*) ;
     HRESULT SetViewport (  D3DVIEWPORT9* pViewport) ;
     HRESULT GetViewport ( D3DVIEWPORT9* pViewport) ;
     HRESULT SetMaterial (  D3DMATERIAL9* pMaterial) ;
     HRESULT GetMaterial ( D3DMATERIAL9* pMaterial) ;
     HRESULT SetLight ( DWORD Index, D3DLIGHT9*) ;
     HRESULT GetLight ( DWORD Index,D3DLIGHT9*) ;
     HRESULT LightEnable ( DWORD Index,BOOL Enable) ;
     HRESULT GetLightEnable ( DWORD Index,BOOL* pEnable) ;
     HRESULT SetClipPlane ( DWORD Index, float* pPlane) ;
     HRESULT GetClipPlane ( DWORD Index,float* pPlane) ;
     HRESULT SetRenderState ( D3DRENDERSTATETYPE State,DWORD Value) ;
     HRESULT GetRenderState ( D3DRENDERSTATETYPE State,DWORD* pValue) ;
     HRESULT CreateStateBlock ( D3DSTATEBLOCKTYPE
Type,IDirect3DStateBlock9** ppSB) ;
     HRESULT BeginStateBlock () ;
     HRESULT EndStateBlock ( IDirect3DStateBlock9** ppSB) ;
     HRESULT SetClipStatus (  D3DCLIPSTATUS9* pClipStatus) ;
     HRESULT GetClipStatus ( D3DCLIPSTATUS9* pClipStatus) ;
     HRESULT GetTexture ( DWORD Stage,IDirect3DBaseTexture9** ppTexture) ;
     HRESULT SetTexture ( DWORD Stage,IDirect3DBaseTexture9* pTexture) ;
     HRESULT GetTextureStageState ( DWORD Stage,D3DTEXTURESTAGESTATETYPE
Type,DWORD* pValue) ;
     HRESULT SetTextureStageState ( DWORD Stage,D3DTEXTURESTAGESTATETYPE
Type,DWORD Value) ;
     HRESULT GetSamplerState ( DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD*
pValue) ;
     HRESULT SetSamplerState ( DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD
Value) ;
     HRESULT ValidateDevice ( DWORD* pNumPasses) ;
     HRESULT SetPaletteEntries ( UINT PaletteNumber, PALETTEENTRY* pEntries)
;
     HRESULT GetPaletteEntries ( UINT PaletteNumber,PALETTEENTRY* pEntries)
;
     HRESULT SetCurrentTexturePalette ( UINT PaletteNumber) ;
     HRESULT GetCurrentTexturePalette ( UINT *PaletteNumber) ;
     HRESULT SetScissorRect (  RECT* pRect) ;
     HRESULT GetScissorRect ( RECT* pRect) ;
     HRESULT SetSoftwareVertexProcessing ( BOOL bSoftware) ;
     BOOL  GetSoftwareVertexProcessing () ;
     HRESULT SetNPatchMode ( float nSegments) ;
     float  GetNPatchMode () ;
     HRESULT DrawPrimitive ( D3DPRIMITIVETYPE PrimitiveType,UINT
StartVertex,UINT PrimitiveCount) ;
     HRESULT DrawIndexedPrimitive ( D3DPRIMITIVETYPE,INT
BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT
primCount) ;
     HRESULT DrawPrimitiveUP ( D3DPRIMITIVETYPE PrimitiveType,UINT
PrimitiveCount, void* pVertexStreamZeroData,UINT VertexStreamZeroStride) ;
     HRESULT DrawIndexedPrimitiveUP ( D3DPRIMITIVETYPE PrimitiveType,UINT
MinVertexIndex,UINT NumVertices,UINT PrimitiveCount, void*
pIndexData,D3DFORMAT IndexDataFormat, void* pVertexStreamZeroData,UINT
VertexStreamZeroStride) ;
     HRESULT ProcessVertices ( UINT SrcStartIndex,UINT DestIndex,UINT
VertexCount,IDirect3DVertexBuffer9* pDestBuffer,IDirect3DVertexDeclaration9*
pVertexDecl,DWORD Flags) ;
     HRESULT CreateVertexDeclaration (  D3DVERTEXELEMENT9*
pVertexElements,IDirect3DVertexDeclaration9** ppDecl) ;
     HRESULT SetVertexDeclaration ( IDirect3DVertexDeclaration9* pDecl) ;
     HRESULT GetVertexDeclaration ( IDirect3DVertexDeclaration9** ppDecl) ;
     HRESULT SetFVF ( DWORD FVF) ;
     HRESULT GetFVF ( DWORD* pFVF) ;
     HRESULT CreateVertexShader (  DWORD* pFunction,IDirect3DVertexShader9**
ppShader) ;
     HRESULT SetVertexShader ( IDirect3DVertexShader9* pShader) ;
     HRESULT GetVertexShader ( IDirect3DVertexShader9** ppShader) ;
     HRESULT SetVertexShaderConstantF ( UINT StartRegister, float*
pConstantData,UINT Vector4fCount) ;
     HRESULT GetVertexShaderConstantF ( UINT StartRegister,float*
pConstantData,UINT Vector4fCount) ;
     HRESULT SetVertexShaderConstantI ( UINT StartRegister, int*
pConstantData,UINT Vector4iCount) ;
     HRESULT GetVertexShaderConstantI ( UINT StartRegister,int*
pConstantData,UINT Vector4iCount) ;
     HRESULT SetVertexShaderConstantB ( UINT StartRegister, BOOL*
pConstantData,UINT  BoolCount) ;
     HRESULT GetVertexShaderConstantB ( UINT StartRegister,BOOL*
pConstantData,UINT BoolCount) ;
     HRESULT SetStreamSource ( UINT StreamNumber,IDirect3DVertexBuffer9*
pStreamData,UINT OffsetInBytes,UINT Stride) ;
     HRESULT GetStreamSource ( UINT StreamNumber,IDirect3DVertexBuffer9**
ppStreamData,UINT* OffsetInBytes,UINT* pStride) ;
     HRESULT SetStreamSourceFreq ( UINT StreamNumber,UINT Divider) ;
     HRESULT GetStreamSourceFreq ( UINT StreamNumber,UINT* Divider) ;
     HRESULT SetIndices ( IDirect3DIndexBuffer9* pIndexData) ;
     HRESULT GetIndices ( IDirect3DIndexBuffer9** ppIndexData) ;
     HRESULT CreatePixelShader (  DWORD* pFunction,IDirect3DPixelShader9**
ppShader) ;
     HRESULT SetPixelShader ( IDirect3DPixelShader9* pShader) ;
     HRESULT GetPixelShader ( IDirect3DPixelShader9** ppShader) ;
     HRESULT SetPixelShaderConstantF ( UINT StartRegister, float*
pConstantData,UINT Vector4fCount) ;
     HRESULT GetPixelShaderConstantF ( UINT StartRegister,float*
pConstantData,UINT Vector4fCount) ;
     HRESULT SetPixelShaderConstantI ( UINT StartRegister, int*
pConstantData,UINT Vector4iCount) ;
     HRESULT GetPixelShaderConstantI ( UINT StartRegister,int*
pConstantData,UINT Vector4iCount) ;
     HRESULT SetPixelShaderConstantB ( UINT StartRegister, BOOL*
pConstantData,UINT  BoolCount) ;
     HRESULT GetPixelShaderConstantB ( UINT StartRegister,BOOL*
pConstantData,UINT BoolCount) ;
     HRESULT DrawRectPatch ( UINT Handle, float* pNumSegs,
D3DRECTPATCH_INFO* pRectPatchInfo) ;
     HRESULT DrawTriPatch ( UINT Handle, float* pNumSegs, D3DTRIPATCH_INFO*
pTriPatchInfo) ;
     HRESULT DeletePatch ( UINT Handle) ;
     HRESULT CreateQuery ( D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery) ;
 }

 alias IDirect3DDevice9* LPDIRECT3DDEVICE9, PDIRECT3DDEVICE9;



 interface IDirect3DStateBlock9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DStateBlock9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT Capture () ;
     HRESULT Apply () ;
 }

 alias IDirect3DStateBlock9* LPDIRECT3DSTATEBLOCK9, PDIRECT3DSTATEBLOCK9;




 interface IDirect3DSwapChain9 : IUnknown
 {
     /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DSwapChain9 methods ***/
     HRESULT Present (  RECT* pSourceRect, RECT* pDestRect,HWND
hDestWindowOverride, RGNDATA* pDirtyRegion,DWORD dwFlags) ;
     HRESULT GetFrontBufferData ( IDirect3DSurface9* pDestSurface) ;
     HRESULT GetBackBuffer ( UINT iBackBuffer,D3DBACKBUFFER_TYPE
Type,IDirect3DSurface9** ppBackBuffer) ;
     HRESULT GetRasterStatus ( D3DRASTER_STATUS* pRasterStatus) ;
     HRESULT GetDisplayMode ( D3DDISPLAYMODE* pMode) ;
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT GetPresentParameters ( D3DPRESENT_PARAMETERS*
pPresentationParameters) ;
 }

 alias IDirect3DSwapChain9* LPDIRECT3DSWAPCHAIN9, PDIRECT3DSWAPCHAIN9;



 interface IDirect3DResource9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
 }

 alias IDirect3DResource9* LPDIRECT3DRESOURCE9, PDIRECT3DRESOURCE9;




 interface IDirect3DVertexDeclaration9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DVertexDeclaration9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT GetDeclaration ( D3DVERTEXELEMENT9*,UINT* pNumElements) ;
 }

 alias IDirect3DVertexDeclaration9* LPDIRECT3DVERTEXDECLARATION9,
PDIRECT3DVERTEXDECLARATION9;




 interface IDirect3DVertexShader9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DVertexShader9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT GetFunction ( void*,UINT* pSizeOfData) ;
 }

 alias IDirect3DVertexShader9* LPDIRECT3DVERTEXSHADER9,
PDIRECT3DVERTEXSHADER9;




 interface IDirect3DPixelShader9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DPixelShader9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT GetFunction ( void*,UINT* pSizeOfData) ;
 }

 alias IDirect3DPixelShader9* LPDIRECT3DPIXELSHADER9, PDIRECT3DPIXELSHADER9;




 interface IDirect3DBaseTexture9 : IDirect3DResource9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     DWORD  SetLOD ( DWORD LODNew) ;
     DWORD  GetLOD () ;
     DWORD  GetLevelCount () ;
     HRESULT SetAutoGenFilterType ( D3DTEXTUREFILTERTYPE FilterType) ;
     D3DTEXTUREFILTERTYPE  GetAutoGenFilterType () ;
     void  GenerateMipSubLevels () ;
 }

 alias IDirect3DBaseTexture9* LPDIRECT3DBASETEXTURE9, PDIRECT3DBASETEXTURE9;




 interface IDirect3DTexture9 : IDirect3DBaseTexture9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DBaseTexture9 methods ***/
     HRESULT  GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT  SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT  GetPrivateData ( REFIID refguid,void* pData,DWORD*
pSizeOfData) ;
     HRESULT  FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     DWORD  SetLOD ( DWORD LODNew) ;
     DWORD  GetLOD () ;
     DWORD  GetLevelCount () ;
     HRESULT SetAutoGenFilterType ( D3DTEXTUREFILTERTYPE FilterType) ;
     D3DTEXTUREFILTERTYPE  GetAutoGenFilterType () ;
     void  GenerateMipSubLevels () ;
     HRESULT  GetLevelDesc ( UINT Level,D3DSURFACE_DESC *pDesc) ;
     HRESULT  GetSurfaceLevel ( UINT Level,IDirect3DSurface9**
ppSurfaceLevel) ;
     HRESULT  LockRect ( UINT Level,D3DLOCKED_RECT* pLockedRect, RECT*
pRect,DWORD Flags) ;
     HRESULT  UnlockRect ( UINT Level) ;
     HRESULT  AddDirtyRect (  RECT* pDirtyRect) ;
 }

 alias IDirect3DTexture9* LPDIRECT3DTEXTURE9, PDIRECT3DTEXTURE9;





 interface IDirect3DVolumeTexture9 : IDirect3DBaseTexture9
 {
      /* ** IUnknown methods ***/
     HRESULT  QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DBaseTexture9 methods ***/
     HRESULT  GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT  SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT  GetPrivateData ( REFIID refguid,void* pData,DWORD*
pSizeOfData) ;
     HRESULT  FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     DWORD  SetLOD ( DWORD LODNew) ;
     DWORD  GetLOD () ;
     DWORD  GetLevelCount () ;
     HRESULT  SetAutoGenFilterType ( D3DTEXTUREFILTERTYPE FilterType) ;
     D3DTEXTUREFILTERTYPE  GetAutoGenFilterType () ;
     void  GenerateMipSubLevels () ;
     HRESULT  GetLevelDesc ( UINT Level,D3DVOLUME_DESC *pDesc) ;
     HRESULT  GetVolumeLevel ( UINT Level,IDirect3DVolume9** ppVolumeLevel)
;
     HRESULT  LockBox ( UINT Level,D3DLOCKED_BOX* pLockedVolume, D3DBOX*
pBox,DWORD Flags) ;
     HRESULT  UnlockBox ( UINT Level) ;
     HRESULT  AddDirtyBox (  D3DBOX* pDirtyBox) ;
 }

 alias IDirect3DVolumeTexture9* LPDIRECT3DVOLUMETEXTURE9,
PDIRECT3DVOLUMETEXTURE9;





 interface IDirect3DCubeTexture9 : IDirect3DBaseTexture9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DBaseTexture9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     DWORD  SetLOD ( DWORD LODNew) ;
     DWORD  GetLOD () ;
     DWORD  GetLevelCount () ;
     HRESULT SetAutoGenFilterType ( D3DTEXTUREFILTERTYPE FilterType) ;
     D3DTEXTUREFILTERTYPE  GetAutoGenFilterType () ;
     void  GenerateMipSubLevels () ;
     HRESULT GetLevelDesc ( UINT Level,D3DSURFACE_DESC *pDesc) ;
     HRESULT GetCubeMapSurface ( D3DCUBEMAP_FACES FaceType,UINT
Level,IDirect3DSurface9** ppCubeMapSurface) ;
     HRESULT LockRect ( D3DCUBEMAP_FACES FaceType,UINT Level,D3DLOCKED_RECT*
pLockedRect, RECT* pRect,DWORD Flags) ;
     HRESULT UnlockRect ( D3DCUBEMAP_FACES FaceType,UINT Level) ;
     HRESULT AddDirtyRect ( D3DCUBEMAP_FACES FaceType, RECT* pDirtyRect) ;
 }

 alias IDirect3DCubeTexture9* LPDIRECT3DCUBETEXTURE9, PDIRECT3DCUBETEXTURE9;




 interface IDirect3DVertexBuffer9  : IDirect3DResource9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     HRESULT Lock ( UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD
Flags) ;
     HRESULT Unlock () ;
     HRESULT GetDesc ( D3DVERTEXBUFFER_DESC *pDesc) ;
 }

 alias IDirect3DVertexBuffer9* LPDIRECT3DVERTEXBUFFER9,
PDIRECT3DVERTEXBUFFER9;




 interface IDirect3DIndexBuffer9 : IDirect3DResource9
 {
     /*** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

     /*** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     HRESULT Lock ( UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD
Flags) ;
     HRESULT Unlock () ;
     HRESULT GetDesc ( D3DINDEXBUFFER_DESC *pDesc) ;
 }

 alias IDirect3DIndexBuffer9* LPDIRECT3DINDEXBUFFER9, PDIRECT3DINDEXBUFFER9;




 interface IDirect3DSurface9 : IDirect3DResource9
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DResource9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     DWORD  SetPriority ( DWORD PriorityNew) ;
     DWORD  GetPriority () ;
     void  PreLoad () ;
     D3DRESOURCETYPE  GetType () ;
     HRESULT GetContainer ( REFIID riid,void** ppContainer) ;
     HRESULT GetDesc ( D3DSURFACE_DESC *pDesc) ;
     HRESULT LockRect ( D3DLOCKED_RECT* pLockedRect, RECT* pRect,DWORD
Flags) ;
     HRESULT UnlockRect () ;
     HRESULT GetDC ( HDC *phdc) ;
     HRESULT ReleaseDC ( HDC hdc) ;
 }

 alias IDirect3DSurface9* LPDIRECT3DSURFACE9, PDIRECT3DSURFACE9;




 interface IDirect3DVolume9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DVolume9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     HRESULT SetPrivateData ( REFIID refguid, void* pData,DWORD
SizeOfData,DWORD Flags) ;
     HRESULT GetPrivateData ( REFIID refguid,void* pData,DWORD* pSizeOfData)
;
     HRESULT FreePrivateData ( REFIID refguid) ;
     HRESULT GetContainer ( REFIID riid,void** ppContainer) ;
     HRESULT GetDesc ( D3DVOLUME_DESC *pDesc) ;
     HRESULT LockBox ( D3DLOCKED_BOX * pLockedVolume, D3DBOX* pBox,DWORD
Flags) ;
     HRESULT UnlockBox () ;
 }

 alias IDirect3DVolume9* LPDIRECT3DVOLUME9, PDIRECT3DVOLUME9;





 interface IDirect3DQuery9 : IUnknown
 {
      /* ** IUnknown methods ***/
     HRESULT QueryInterface ( REFIID riid, void** ppvObj) ;
     ULONG AddRef () ;
     ULONG Release () ;

      /* ** IDirect3DQuery9 methods ***/
     HRESULT GetDevice ( IDirect3DDevice9** ppDevice) ;
     D3DQUERYTYPE  GetType () ;
     DWORD  GetDataSize () ;
     HRESULT Issue ( DWORD dwIssueFlags) ;
     HRESULT GetData ( void* pData,DWORD dwSize,DWORD dwGetDataFlags) ;
 }

 alias IDirect3DQuery9* LPDIRECT3DQUERY9, PDIRECT3DQUERY9;





/***************************************************************************
*
  * Flags for SetPrivateData method on all D3D9 interfaces
  *
  * The passed pointer is an IUnknown ptr. The SizeOfData argument to
SetPrivateData
  * must be set to sizeof(IUnknown*). Direct3D will call AddRef through this
  * pointer and Release when the private data is destroyed. The data will be
  * destroyed when another SetPrivateData with the same GUID is set, when
  * FreePrivateData is called, or when the D3D9 object is freed.

****************************************************************************
/
 const int D3DSPD_IUNKNOWN                  =    0x00000001L;


/***************************************************************************
*
  *
  *  Flags for IDirect3D9::CreateDevice's BehaviorFlags
  *

****************************************************************************
/

 const int D3DCREATE_FPU_PRESERVE               =   0x00000002L;
 const int D3DCREATE_MULTITHREADED              =   0x00000004L;

 const int D3DCREATE_PUREDEVICE                 =   0x00000010L;
 const int D3DCREATE_SOFTWARE_VERTEXPROCESSING  =   0x00000020L;
 const int D3DCREATE_HARDWARE_VERTEXPROCESSING  =   0x00000040L;
 const int D3DCREATE_MIXED_VERTEXPROCESSING     =   0x00000080L;

 const int D3DCREATE_DISABLE_DRIVER_MANAGEMENT  =   0x00000100L;
 const int D3DCREATE_ADAPTERGROUP_DEVICE        =   0x00000200L;



/***************************************************************************
*
  *
  *  Parameter for IDirect3D9::CreateDevice's iAdapter
  *

****************************************************************************
/

 const int D3DADAPTER_DEFAULT                   =  0;


/***************************************************************************
*
  *
  *  Flags for IDirect3D9::EnumAdapters
  *

****************************************************************************
/

 const int D3DENUM_WHQL_LEVEL                   =   0x00000002L;


/***************************************************************************
*
  *
  *  Maximum number of back-buffers supported in DX8
  *

****************************************************************************
/

 const int D3DPRESENT_BACK_BUFFERS_MAX          =   3L;


/***************************************************************************
*
  *
  *  Flags for IDirect3DDevice9::SetGammaRamp
  *

****************************************************************************
/

 const int D3DSGR_NO_CALIBRATION                =  0x00000000L;
 const int D3DSGR_CALIBRATE                     =  0x00000001L;


/***************************************************************************
*
  *
  *  Flags for IDirect3DDevice9::SetCursorPosition
  *

****************************************************************************
/

 const int D3DCURSOR_IMMEDIATE_UPDATE           =  0x00000001L;


/***************************************************************************
*
  *
  *  Flags for IDirect3DSwapChain9::Present
  *

****************************************************************************
/

 const int D3DPRESENT_DONOTWAIT                 =  0x00000001L;
 const int D3DPRESENT_LINEAR_CONTENT            =  0x00000002L;


/***************************************************************************
*
  *
  *  Flags for DrawPrimitive/DrawIndexedPrimitive
  *   Also valid for Begin/BeginIndexed
  *   Also valid for VertexBuffer::CreateVertexBuffer

****************************************************************************
/


 /*
  *  DirectDraw error codes
  */
 const int _FACD3D   = 0x876;
 /*
 #define MAKE_D3DHRESULT( code )  MAKE_HRESULT( 1, _FACD3D, code )
 #define MAKE_D3DSTATUS( code )  MAKE_HRESULT( 0, _FACD3D, code )

 /*
  * Direct3D Errors
  */
 /*
 #define D3D_OK                              S_OK

 #define D3DERR_WRONGTEXTUREFORMAT               MAKE_D3DHRESULT(2072)
 #define D3DERR_UNSUPPORTEDCOLOROPERATION        MAKE_D3DHRESULT(2073)
 #define D3DERR_UNSUPPORTEDCOLORARG              MAKE_D3DHRESULT(2074)
 #define D3DERR_UNSUPPORTEDALPHAOPERATION        MAKE_D3DHRESULT(2075)
 #define D3DERR_UNSUPPORTEDALPHAARG              MAKE_D3DHRESULT(2076)
 #define D3DERR_TOOMANYOPERATIONS                MAKE_D3DHRESULT(2077)
 #define D3DERR_CONFLICTINGTEXTUREFILTER         MAKE_D3DHRESULT(2078)
 #define D3DERR_UNSUPPORTEDFACTORVALUE           MAKE_D3DHRESULT(2079)
 #define D3DERR_CONFLICTINGRENDERSTATE           MAKE_D3DHRESULT(2081)
 #define D3DERR_UNSUPPORTEDTEXTUREFILTER         MAKE_D3DHRESULT(2082)
 #define D3DERR_CONFLICTINGTEXTUREPALETTE        MAKE_D3DHRESULT(2086)
 #define D3DERR_DRIVERINTERNALERROR              MAKE_D3DHRESULT(2087)

 #define D3DERR_NOTFOUND                         MAKE_D3DHRESULT(2150)
 #define D3DERR_MOREDATA                         MAKE_D3DHRESULT(2151)
 #define D3DERR_DEVICELOST                       MAKE_D3DHRESULT(2152)
 #define D3DERR_DEVICENOTRESET                   MAKE_D3DHRESULT(2153)
 #define D3DERR_NOTAVAILABLE                     MAKE_D3DHRESULT(2154)
 #define D3DERR_OUTOFVIDEOMEMORY                 MAKE_D3DHRESULT(380)
 #define D3DERR_INVALIDDEVICE                    MAKE_D3DHRESULT(2155)
 #define D3DERR_INVALIDCALL                      MAKE_D3DHRESULT(2156)
 #define D3DERR_DRIVERINVALIDCALL                MAKE_D3DHRESULT(2157)
 #define D3DERR_WASSTILLDRAWING                  MAKE_D3DHRESULT(540)
 #define D3DOK_NOAUTOGEN                         MAKE_D3DSTATUS(2159)

 */


 }  //  extern (C)

//} // version DIRECTX9
////////////////////////////////////////////////////////////////////////////
//////


////
d3d9caps.d
/////////////////////////////////////////////////

// Author : Ahmed El-Metwaly
// contact : aelmetwaly gawa.com
// Lic     : GPL

/*==========================================================================
;
 *
 *  Copyright (C) Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       d3d9caps.h
 *  Content:    Direct3D capabilities include file
 *

***************************************************************************/

import std.c.stdio;
import std.c.stdlib;
import std.string;
import std.c.windows.windows;
import std.c.windows.com;
import d3d9types;

const int DIRECT3D_VERSION     =    0x0900;


// include this file content only if compiling for DX9 interfaces
//version(DIRECT3D_VERSION )
//{
 align (4){


 struct _D3DVSHADERCAPS2_0
 {
         DWORD Caps;
         INT DynamicFlowControlDepth;
         INT NumTemps;
         INT StaticFlowControlDepth;
 }

 alias _D3DVSHADERCAPS2_0 D3DVSHADERCAPS2_0;

 const int D3DVS20CAPS_PREDICATION     =        (1<<0);

 const int D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH = 24;
 const int D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0;
 const int D3DVS20_MAX_NUMTEMPS  =  32;
 const int D3DVS20_MIN_NUMTEMPS  =  12;
 const int D3DVS20_MAX_STATICFLOWCONTROLDEPTH  =  4;
 const int D3DVS20_MIN_STATICFLOWCONTROLDEPTH  =  1;

 struct _D3DPSHADERCAPS2_0
 {
     DWORD Caps;
     INT DynamicFlowControlDepth;
     INT NumTemps;
     INT StaticFlowControlDepth;
     INT NumInstructionSlots;
 }

 alias _D3DPSHADERCAPS2_0 D3DPSHADERCAPS2_0;

 const int D3DPS20CAPS_ARBITRARYSWIZZLE       = (1<<0);
 const int D3DPS20CAPS_GRADIENTINSTRUCTIONS   = (1<<1);
 const int D3DPS20CAPS_PREDICATION            = (1<<2);
 const int D3DPS20CAPS_NODEPENDENTREADLIMIT   = (1<<3);
 const int D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT  = (1<<4);

 const int D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH   = 24;
 const int D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH   = 0;
 const int D3DPS20_MAX_NUMTEMPS   = 32;
 const int D3DPS20_MIN_NUMTEMPS   = 12;
 const int D3DPS20_MAX_STATICFLOWCONTROLDEPTH  =  4;
 const int D3DPS20_MIN_STATICFLOWCONTROLDEPTH  =  0;
 const int D3DPS20_MAX_NUMINSTRUCTIONSLOTS   = 512;
 const int D3DPS20_MIN_NUMINSTRUCTIONSLOTS   = 96;

 const int D3DMIN30SHADERINSTRUCTIONS = 512;
 const int D3DMAX30SHADERINSTRUCTIONS = 32768;

 struct _D3DCAPS9
 {
     /* Device Info */
     D3DDEVTYPE  DeviceType;
     UINT        AdapterOrdinal;

     /* Caps from DX7 Draw */
     DWORD   Caps;
     DWORD   Caps2;
     DWORD   Caps3;
     DWORD   PresentationIntervals;

     /* Cursor Caps */
     DWORD   CursorCaps;

     /* 3D Device Caps */
     DWORD   DevCaps;

     DWORD   PrimitiveMiscCaps;
     DWORD   RasterCaps;
     DWORD   ZCmpCaps;
     DWORD   SrcBlendCaps;
     DWORD   DestBlendCaps;
     DWORD   AlphaCmpCaps;
     DWORD   ShadeCaps;
     DWORD   TextureCaps;
     DWORD   TextureFilterCaps;          // D3DPTFILTERCAPS for
IDirect3DTexture9's
     DWORD   CubeTextureFilterCaps;      // D3DPTFILTERCAPS for
IDirect3DCubeTexture9's
     DWORD   VolumeTextureFilterCaps;    // D3DPTFILTERCAPS for
IDirect3DVolumeTexture9's
     DWORD   TextureAddressCaps;         // D3DPTADDRESSCAPS for
IDirect3DTexture9's
     DWORD   VolumeTextureAddressCaps;   // D3DPTADDRESSCAPS for
IDirect3DVolumeTexture9's

     DWORD   LineCaps;                   // D3DLINECAPS

     DWORD   MaxTextureWidth, MaxTextureHeight;
     DWORD   MaxVolumeExtent;

     DWORD   MaxTextureRepeat;
     DWORD   MaxTextureAspectRatio;
     DWORD   MaxAnisotropy;
     float   MaxVertexW;

     float   GuardBandLeft;
     float   GuardBandTop;
     float   GuardBandRight;
     float   GuardBandBottom;

     float   ExtentsAdjust;
     DWORD   StencilCaps;

     DWORD   FVFCaps;
     DWORD   TextureOpCaps;
     DWORD   MaxTextureBlendStages;
     DWORD   MaxSimultaneousTextures;

     DWORD   VertexProcessingCaps;
     DWORD   MaxActiveLights;
     DWORD   MaxUserClipPlanes;
     DWORD   MaxVertexBlendMatrices;
     DWORD   MaxVertexBlendMatrixIndex;

     float   MaxPointSize;

     DWORD   MaxPrimitiveCount;          // max number of primitives per
DrawPrimitive call
     DWORD   MaxVertexIndex;
     DWORD   MaxStreams;
     DWORD   MaxStreamStride;            // max stride for SetStreamSource

     DWORD   VertexShaderVersion;
     DWORD   MaxVertexShaderConst;       // number of vertex shader constant
registers

     DWORD   PixelShaderVersion;
     float   PixelShader1xMaxValue;      // max value storable in registers
of ps.1.x shaders

     // Here are the DX9 specific ones
     DWORD   DevCaps2;

     float   MaxNpatchTessellationLevel;
     DWORD   Reserved5;

     UINT    MasterAdapterOrdinal;       // ordinal of master adaptor for
adapter group
     UINT    AdapterOrdinalInGroup;      // ordinal inside the adapter group
     UINT    NumberOfAdaptersInGroup;    // number of adapters in this
adapter group (only if master)
     DWORD   DeclTypes;                  // Data types, supported in vertex
declarations
     DWORD   NumSimultaneousRTs;         // Will be at least 1
     DWORD   StretchRectFilterCaps;      // Filter caps supported by
StretchRect
     D3DVSHADERCAPS2_0 VS20Caps;
     D3DPSHADERCAPS2_0 PS20Caps;
     DWORD   VertexTextureFilterCaps;    // D3DPTFILTERCAPS for
IDirect3DTexture9's for texture, used in vertex shaders
     DWORD   MaxVShaderInstructionsExecuted; // maximum number of vertex
shader instructions that can be executed
     DWORD   MaxPShaderInstructionsExecuted; // maximum number of pixel
shader instructions that can be executed
     DWORD   MaxVertexShader30InstructionSlots;
     DWORD   MaxPixelShader30InstructionSlots;
 }

 alias _D3DCAPS9 D3DCAPS9;

 //
 // BIT DEFINES FOR D3DCAPS9 DWORD MEMBERS
 //

 //
 // Caps
 //
 const int D3DCAPS_READ_SCANLINE        =   0x00020000L;

 //
 // Caps2
 //
 const int D3DCAPS2_FULLSCREENGAMMA     =   0x00020000L;
 const int D3DCAPS2_CANCALIBRATEGAMMA   =   0x00100000L;
 const int D3DCAPS2_RESERVED            =   0x02000000L;
 const int D3DCAPS2_CANMANAGERESOURCE   =   0x10000000L;
 const int D3DCAPS2_DYNAMICTEXTURES     =   0x20000000L;
 const int D3DCAPS2_CANAUTOGENMIPMAP    =   0x40000000L;

 //
 // Caps3
 //
 const long D3DCAPS3_RESERVED            =   0x8000001fL;

 // Indicates that the device can respect the ALPHABLENDENABLE render state
 // when fullscreen while using the FLIP or DISCARD swap effect.
 // COPY and COPYVSYNC swap effects work whether or not this flag is set.
 const int D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD  = 0x00000020L;

 // Indicates that the device can perform a gamma correction from
 // a windowed back buffer containing linear content to the sRGB desktop.
 const int D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION = 0x00000080L;

 const int D3DCAPS3_COPY_TO_VIDMEM       =  0x00000100L; /* Device can
acclerate copies from sysmem to local vidmem */
 const int D3DCAPS3_COPY_TO_SYSTEMMEM    =  0x00000200L; /* Device can
acclerate copies from local vidmem to sysmem */


 //
 // PresentationIntervals
 //
 const int D3DPRESENT_INTERVAL_DEFAULT   =  0x00000000L;
 const int D3DPRESENT_INTERVAL_ONE       =  0x00000001L;
 const int D3DPRESENT_INTERVAL_TWO       =  0x00000002L;
 const int D3DPRESENT_INTERVAL_THREE     =  0x00000004L;
 const int D3DPRESENT_INTERVAL_FOUR      =  0x00000008L;
 const long D3DPRESENT_INTERVAL_IMMEDIATE =  0x80000000L;

 //
 // CursorCaps
 //
 // Driver supports HW color cursor in at least hi-res modes(height >=400)
 const int D3DCURSORCAPS_COLOR          =   0x00000001L;
 // Driver supports HW cursor also in low-res modes(height < 400)
 const int D3DCURSORCAPS_LOWRES         =   0x00000002L;

 //
 // DevCaps
 //
 const int D3DDEVCAPS_EXECUTESYSTEMMEMORY = 0x00000010L; /* Device can use
execute buffers from system memory */
 const int D3DDEVCAPS_EXECUTEVIDEOMEMORY  = 0x00000020L; /* Device can use
execute buffers from video memory */
 const int D3DDEVCAPS_TLVERTEXSYSTEMMEMORY = 0x00000040L; /* Device can use
TL buffers from system memory */
 const int D3DDEVCAPS_TLVERTEXVIDEOMEMORY = 0x00000080L; /* Device can use
TL buffers from video memory */
 const int D3DDEVCAPS_TEXTURESYSTEMMEMORY = 0x00000100L; /* Device can
texture from system memory */
 const int D3DDEVCAPS_TEXTUREVIDEOMEMORY  = 0x00000200L; /* Device can
texture from device memory */
 const int D3DDEVCAPS_DRAWPRIMTLVERTEX    = 0x00000400L; /* Device can draw
TLVERTEX primitives */
 const int D3DDEVCAPS_CANRENDERAFTERFLIP  = 0x00000800L; /* Device can
render without waiting for flip to complete */
 const int D3DDEVCAPS_TEXTURENONLOCALVIDMEM = 0x00001000L; /* Device can
texture from nonlocal video memory */
 const int D3DDEVCAPS_DRAWPRIMITIVES2    =  0x00002000L; /* Device can
support DrawPrimitives2 */
 const int D3DDEVCAPS_SEPARATETEXTUREMEMORIES = 0x00004000L; /* Device is
texturing from separate memory pools */
 const int D3DDEVCAPS_DRAWPRIMITIVES2EX  =  0x00008000L; /* Device can
support Extended DrawPrimitives2 i.e. DX7 compliant driver*/
 const int D3DDEVCAPS_HWTRANSFORMANDLIGHT = 0x00010000L; /* Device can
support transformation and lighting in hardware and DRAWPRIMITIVES2EX must
be also */
 const int D3DDEVCAPS_CANBLTSYSTONONLOCAL = 0x00020000L; /* Device supports
a Tex Blt from system memory to non-local vidmem */
 const int D3DDEVCAPS_HWRASTERIZATION     = 0x00080000L; /* Device has HW
acceleration for rasterization */
 const int D3DDEVCAPS_PUREDEVICE          = 0x00100000L; /* Device supports
D3DCREATE_PUREDEVICE */
 const int D3DDEVCAPS_QUINTICRTPATCHES    = 0x00200000L; /* Device supports
quintic Beziers and BSplines */
 const int D3DDEVCAPS_RTPATCHES           = 0x00400000L; /* Device supports
Rect and Tri patches */
 const int D3DDEVCAPS_RTPATCHHANDLEZERO   = 0x00800000L; /* Indicates that
RT Patches may be drawn efficiently using handle 0 */
 const int D3DDEVCAPS_NPATCHES            = 0x01000000L; /* Device supports
N-Patches */

 //
 // PrimitiveMiscCaps
 //
 const int D3DPMISCCAPS_MASKZ           =   0x00000002L;
 const int D3DPMISCCAPS_CULLNONE        =   0x00000010L;
 const int D3DPMISCCAPS_CULLCW          =   0x00000020L;
 const int D3DPMISCCAPS_CULLCCW         =   0x00000040L;
 const int D3DPMISCCAPS_COLORWRITEENABLE =  0x00000080L;
 const int D3DPMISCCAPS_CLIPPLANESCALEDPOINTS = 0x00000100L; /* Device
correctly clips scaled points to clip planes */
 const int D3DPMISCCAPS_CLIPTLVERTS     =   0x00000200L; /* device will clip
post-transformed vertex primitives */
 const int D3DPMISCCAPS_TSSARGTEMP      =   0x00000400L; /* device supports
D3DTA_TEMP for temporary register */
 const int D3DPMISCCAPS_BLENDOP         =   0x00000800L; /* device supports
D3DRS_BLENDOP */
 const int D3DPMISCCAPS_NULLREFERENCE   =   0x00001000L; /* Reference Device
that doesnt render */
 const int D3DPMISCCAPS_INDEPENDENTWRITEMASKS =    0x00004000L; /* Device
supports independent write masks for MET or MRT */
 const int D3DPMISCCAPS_PERSTAGECONSTANT =  0x00008000L; /* Device supports
per-stage constants */
 const int D3DPMISCCAPS_FOGANDSPECULARALPHA =  0x00010000L; /* Device
supports separate fog and specular alpha (many devices
                                                           use the specular
alpha channel to store fog factor) */
 const int D3DPMISCCAPS_SEPARATEALPHABLEND    =     0x00020000L; /* Device
supports separate blend settings for the alpha channel */
 const int D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS  =  0x00040000L; /* Device
supports different bit depths for MRT */
 const int D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING = 0x00080000L; /* Device
supports post-pixel shader operations for MRT */
 const int D3DPMISCCAPS_FOGVERTEXCLAMPED        =   0x00100000L; /* Device
clamps fog blend factor per vertex */

 //
 // LineCaps
 //
 const int D3DLINECAPS_TEXTURE        =     0x00000001L;
 const int D3DLINECAPS_ZTEST          =     0x00000002L;
 const int D3DLINECAPS_BLEND          =     0x00000004L;
 const int D3DLINECAPS_ALPHACMP       =     0x00000008L;
 const int D3DLINECAPS_FOG            =     0x00000010L;
 const int D3DLINECAPS_ANTIALIAS      =     0x00000020L;

 //
 // RasterCaps
 //
 const int D3DPRASTERCAPS_DITHER          =       0x00000001L;
 const int D3DPRASTERCAPS_ZTEST           =       0x00000010L;
 const int D3DPRASTERCAPS_FOGVERTEX       =       0x00000080L;
 const int D3DPRASTERCAPS_FOGTABLE        =       0x00000100L;
 const int D3DPRASTERCAPS_MIPMAPLODBIAS   =       0x00002000L;
 const int D3DPRASTERCAPS_ZBUFFERLESSHSR  =       0x00008000L;
 const int D3DPRASTERCAPS_FOGRANGE        =       0x00010000L;
 const int D3DPRASTERCAPS_ANISOTROPY      =       0x00020000L;
 const int D3DPRASTERCAPS_WBUFFER         =       0x00040000L;
 const int D3DPRASTERCAPS_WFOG            =       0x00100000L;
 const int D3DPRASTERCAPS_ZFOG            =       0x00200000L;
 const int D3DPRASTERCAPS_COLORPERSPECTIVE    =   0x00400000L; /* Device
iterates colors perspective correct */
 const int D3DPRASTERCAPS_SCISSORTEST         =   0x01000000L;
 const int D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS =   0x02000000L;
 const int D3DPRASTERCAPS_DEPTHBIAS           =   0x04000000L;
 const int D3DPRASTERCAPS_MULTISAMPLE_TOGGLE  =   0x08000000L;

 //
 // ZCmpCaps, AlphaCmpCaps
 //
 const int D3DPCMPCAPS_NEVER         =      0x00000001L;
 const int D3DPCMPCAPS_LESS          =      0x00000002L;
 const int D3DPCMPCAPS_EQUAL         =      0x00000004L;
 const int D3DPCMPCAPS_LESSEQUAL     =      0x00000008L;
 const int D3DPCMPCAPS_GREATER       =      0x00000010L;
 const int D3DPCMPCAPS_NOTEQUAL      =      0x00000020L;
 const int D3DPCMPCAPS_GREATEREQUAL  =      0x00000040L;
 const int D3DPCMPCAPS_ALWAYS        =      0x00000080L;

 //
 // SourceBlendCaps, DestBlendCaps
 //
 const int D3DPBLENDCAPS_ZERO           =   0x00000001L;
 const int D3DPBLENDCAPS_ONE            =   0x00000002L;
 const int D3DPBLENDCAPS_SRCCOLOR       =   0x00000004L;
 const int D3DPBLENDCAPS_INVSRCCOLOR    =   0x00000008L;
 const int D3DPBLENDCAPS_SRCALPHA       =   0x00000010L;
 const int D3DPBLENDCAPS_INVSRCALPHA    =   0x00000020L;
 const int D3DPBLENDCAPS_DESTALPHA      =   0x00000040L;
 const int D3DPBLENDCAPS_INVDESTALPHA   =   0x00000080L;
 const int D3DPBLENDCAPS_DESTCOLOR      =   0x00000100L;
 const int D3DPBLENDCAPS_INVDESTCOLOR   =   0x00000200L;
 const int D3DPBLENDCAPS_SRCALPHASAT    =   0x00000400L;
 const int D3DPBLENDCAPS_BOTHSRCALPHA   =   0x00000800L;
 const int D3DPBLENDCAPS_BOTHINVSRCALPHA =  0x00001000L;
 const int D3DPBLENDCAPS_BLENDFACTOR     =  0x00002000L; /* Supports both
D3DBLEND_BLENDFACTOR and D3DBLEND_INVBLENDFACTOR */

 //
 // ShadeCaps
 //
 const int D3DPSHADECAPS_COLORGOURAUDRGB     =  0x00000008L;
 const int D3DPSHADECAPS_SPECULARGOURAUDRGB  =  0x00000200L;
 const int D3DPSHADECAPS_ALPHAGOURAUDBLEND   =  0x00004000L;
 const int D3DPSHADECAPS_FOGGOURAUD          =  0x00080000L;

 //
 // TextureCaps
 //
 const int D3DPTEXTURECAPS_PERSPECTIVE       =  0x00000001L; /*
Perspective-correct texturing is supported */
 const int D3DPTEXTURECAPS_POW2              =  0x00000002L; /* Power-of-2
texture dimensions are required - applies to non-Cube/Volume textures only.
*/
 const int D3DPTEXTURECAPS_ALPHA             =  0x00000004L; /* Alpha in
texture pixels is supported */
 const int D3DPTEXTURECAPS_SQUAREONLY        =  0x00000020L; /* Only square
textures are supported */
 const int D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE = 0x00000040L; /*
Texture indices are not scaled by the texture size prior to interpolation */
 const int D3DPTEXTURECAPS_ALPHAPALETTE      =  0x00000080L; /* Device can
draw alpha from texture palettes */
 // Device can use non-POW2 textures if:
 //  1) D3DTEXTURE_ADDRESS is set to CLAMP for this texture's stage
 //  2) D3DRS_WRAP(N) is zero for this texture's coordinates
 //  3) mip mapping is not enabled (use magnification filter only)
 const int D3DPTEXTURECAPS_NONPOW2CONDITIONAL = 0x00000100L;
 const int D3DPTEXTURECAPS_PROJECTED          = 0x00000400L; /* Device can
do D3DTTFF_PROJECTED */
 const int D3DPTEXTURECAPS_CUBEMAP            = 0x00000800L; /* Device can
do cubemap textures */
 const int D3DPTEXTURECAPS_VOLUMEMAP         =  0x00002000L; /* Device can
do volume textures */
 const int D3DPTEXTURECAPS_MIPMAP             = 0x00004000L; /* Device can
do mipmapped textures */
 const int D3DPTEXTURECAPS_MIPVOLUMEMAP       = 0x00008000L; /* Device can
do mipmapped volume textures */
 const int D3DPTEXTURECAPS_MIPCUBEMAP         = 0x00010000L; /* Device can
do mipmapped cube maps */
 const int D3DPTEXTURECAPS_CUBEMAP_POW2       = 0x00020000L; /* Device
requires that cubemaps be power-of-2 dimension */
 const int D3DPTEXTURECAPS_VOLUMEMAP_POW2     = 0x00040000L; /* Device
requires that volume maps be power-of-2 dimension */
 const int D3DPTEXTURECAPS_NOPROJECTEDBUMPENV = 0x00200000L; /* Device does
not support projected bump env lookup operation
                                                           in programmable
and fixed function pixel shaders */

 //
 // TextureFilterCaps, StretchRectFilterCaps
 //
 const int D3DPTFILTERCAPS_MINFPOINT         =  0x00000100L; /* Min Filter
*/
 const int D3DPTFILTERCAPS_MINFLINEAR        =  0x00000200L;
 const int D3DPTFILTERCAPS_MINFANISOTROPIC   =  0x00000400L;
 const int D3DPTFILTERCAPS_MINFPYRAMIDALQUAD =  0x00000800L;
 const int D3DPTFILTERCAPS_MINFGAUSSIANQUAD  =  0x00001000L;
 const int D3DPTFILTERCAPS_MIPFPOINT         =  0x00010000L; /* Mip Filter
*/
 const int D3DPTFILTERCAPS_MIPFLINEAR        =  0x00020000L;
 const int D3DPTFILTERCAPS_MAGFPOINT         =  0x01000000L; /* Mag Filter
*/
 const int D3DPTFILTERCAPS_MAGFLINEAR        =  0x02000000L;
 const int D3DPTFILTERCAPS_MAGFANISOTROPIC   =  0x04000000L;
 const int D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD =  0x08000000L;
 const int D3DPTFILTERCAPS_MAGFGAUSSIANQUAD  =  0x10000000L;

 //
 // TextureAddressCaps
 //
 const int D3DPTADDRESSCAPS_WRAP         =  0x00000001L;
 const int D3DPTADDRESSCAPS_MIRROR       =  0x00000002L;
 const int D3DPTADDRESSCAPS_CLAMP        =  0x00000004L;
 const int D3DPTADDRESSCAPS_BORDER        = 0x00000008L;
 const int D3DPTADDRESSCAPS_INDEPENDENTUV = 0x00000010L;
 const int D3DPTADDRESSCAPS_MIRRORONCE    = 0x00000020L;

 //
 // StencilCaps
 //
 const int D3DSTENCILCAPS_KEEP          =   0x00000001L;
 const int D3DSTENCILCAPS_ZERO          =   0x00000002L;
 const int D3DSTENCILCAPS_REPLACE       =   0x00000004L;
 const int D3DSTENCILCAPS_INCRSAT       =   0x00000008L;
 const int D3DSTENCILCAPS_DECRSAT       =   0x00000010L;
 const int D3DSTENCILCAPS_INVERT        =   0x00000020L;
 const int D3DSTENCILCAPS_INCR          =   0x00000040L;
 const int D3DSTENCILCAPS_DECR          =   0x00000080L;
 const int D3DSTENCILCAPS_TWOSIDED      =   0x00000100L;

 //
 // TextureOpCaps
 //
 const int D3DTEXOPCAPS_DISABLE                  =  0x00000001L;
 const int D3DTEXOPCAPS_SELECTARG1               =  0x00000002L;
 const int D3DTEXOPCAPS_SELECTARG2               =  0x00000004L;
 const int D3DTEXOPCAPS_MODULATE                 =  0x00000008L;
 const int D3DTEXOPCAPS_MODULATE2X               =  0x00000010L;
 const int D3DTEXOPCAPS_MODULATE4X               =  0x00000020L;
 const int D3DTEXOPCAPS_ADD                      =  0x00000040L;
 const int D3DTEXOPCAPS_ADDSIGNED                =  0x00000080L;
 const int D3DTEXOPCAPS_ADDSIGNED2X              =  0x00000100L;
 const int D3DTEXOPCAPS_SUBTRACT                 =  0x00000200L;
 const int D3DTEXOPCAPS_ADDSMOOTH                =  0x00000400L;
 const int D3DTEXOPCAPS_BLENDDIFFUSEALPHA        =  0x00000800L;
 const int D3DTEXOPCAPS_BLENDTEXTUREALPHA        =  0x00001000L;
 const int D3DTEXOPCAPS_BLENDFACTORALPHA         =  0x00002000L;
 const int D3DTEXOPCAPS_BLENDTEXTUREALPHAPM      =  0x00004000L;
 const int D3DTEXOPCAPS_BLENDCURRENTALPHA        =  0x00008000L;
 const int D3DTEXOPCAPS_PREMODULATE              =  0x00010000L;
 const int D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR   =  0x00020000L;
 const int D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA   =  0x00040000L;
 const int D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR =  0x00080000L;
 const int D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA = 0x00100000L;
 const int D3DTEXOPCAPS_BUMPENVMAP               =  0x00200000L;
 const int D3DTEXOPCAPS_BUMPENVMAPLUMINANCE      =  0x00400000L;
 const int D3DTEXOPCAPS_DOTPRODUCT3              =  0x00800000L;
 const int D3DTEXOPCAPS_MULTIPLYADD              =  0x01000000L;
 const int D3DTEXOPCAPS_LERP                     =  0x02000000L;

 //
 // FVFCaps
 //
 const int D3DFVFCAPS_TEXCOORDCOUNTMASK   = 0x0000ffffL; /* mask for texture
coordinate count field */
 const int D3DFVFCAPS_DONOTSTRIPELEMENTS  = 0x00080000L; /* Device prefers
that vertex elements not be stripped */
 const int D3DFVFCAPS_PSIZE               = 0x00100000L; /* Device can
receive point size */

 //
 // VertexProcessingCaps
 //
 const int D3DVTXPCAPS_TEXGEN             = 0x00000001L; /* device can do
texgen */
 const int D3DVTXPCAPS_MATERIALSOURCE7    = 0x00000002L; /* device can do
DX7-level colormaterialsource ops */
 const int D3DVTXPCAPS_DIRECTIONALLIGHTS  = 0x00000008L; /* device can do
directional lights */
 const int D3DVTXPCAPS_POSITIONALLIGHTS   = 0x00000010L; /* device can do
positional lights (includes point and spot) */
 const int D3DVTXPCAPS_LOCALVIEWER        = 0x00000020L; /* device can do
local viewer */
 const int D3DVTXPCAPS_TWEENING           = 0x00000040L; /* device can do
vertex tweening */
 const int D3DVTXPCAPS_TEXGEN_SPHEREMAP   = 0x00000100L; /* device supports
D3DTSS_TCI_SPHEREMAP */
 const int D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER  = 0x00000200L; /* device
does not support TexGen in non-local
                                                             viewer mode */

 //
 // DevCaps2
 //
 const int D3DDEVCAPS2_STREAMOFFSET                      =  0x00000001L; /*
Device supports offsets in streams. Must be set by DX9 drivers */
 const int D3DDEVCAPS2_DMAPNPATCH                        =  0x00000002L; /*
Device supports displacement maps for N-Patches*/
 const int D3DDEVCAPS2_ADAPTIVETESSRTPATCH               =  0x00000004L; /*
Device supports adaptive tesselation of RT-patches*/
 const int D3DDEVCAPS2_ADAPTIVETESSNPATCH                =  0x00000008L; /*
Device supports adaptive tesselation of N-patches*/
 const int D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES     =  0x00000010L; /*
Device supports StretchRect calls with a texture as the source*/
 const int D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH               = 0x00000020L; /*
Device supports presampled displacement maps for N-Patches */
 const int D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET = 0x00000040L; /*
Vertex elements in a vertex declaration can share the same stream offset */

 //
 // DeclTypes
 //
 const int D3DDTCAPS_UBYTE4    = 0x00000001L;
 const int D3DDTCAPS_UBYTE4N   = 0x00000002L;
 const int D3DDTCAPS_SHORT2N   = 0x00000004L;
 const int D3DDTCAPS_SHORT4N   = 0x00000008L;
 const int D3DDTCAPS_USHORT2N  = 0x00000010L;
 const int D3DDTCAPS_USHORT4N  = 0x00000020L;
 const int D3DDTCAPS_UDEC3     = 0x00000040L;
 const int D3DDTCAPS_DEC3N     = 0x00000080L;
 const int D3DDTCAPS_FLOAT16_2 = 0x00000100L;
 const int D3DDTCAPS_FLOAT16_4 = 0x00000200L;


 } //align (4)




//} /* (DIRECT3D_VERSION >= 0x0900) */


////////////////////////////////////////////////
d3d9types.d
///////////////////////////

// Author : Ahmed El-Metwaly
// contact : aelmetwaly gawa.com
// Lic     : GPL

/*==========================================================================
;
 *
 *  Copyright (C) Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       d3d9types.h
 *  Content:    Direct3D capabilities include file
 *

***************************************************************************/


import std.c.stdio;
import std.c.stdlib;
import std.string;
import std.c.windows.windows;
import std.c.windows.com;


const int DIRECT3D_VERSION    =     0x0900;


// include this file content only if compiling for DX9 interfaces
//version(DIRECT3D_VERSION )
//{
 //#include <float.h>

 align(4){


 // D3DCOLOR is equivalent to D3DFMT_A8R8G8B8

 alias DWORD D3DCOLOR;



 // maps unsigned 8 bits/channel to D3DCOLOR
 //#define D3DCOLOR_ARGB(a,r,g,b) \
 //
((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
 D3DCOLOR D3DCOLOR_ARGB(ubyte a, ubyte r, ubyte g, ubyte b)
 {
  return (cast(D3DCOLOR)(((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g &
0xff) << 8) | (b & 0xff)));
 }


 //#define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b)
 D3DCOLOR D3DCOLOR_RGBA (ubyte r, ubyte g, ubyte b, ubyte  a)
 {
  return D3DCOLOR_ARGB(a, r, g, b);
 }

 //#define D3DCOLOR_XRGB(r,g,b)   D3DCOLOR_ARGB(0xff,r,g,b)
 D3DCOLOR D3DCOLOR_XRGB (ubyte r, ubyte g, ubyte b)
 {
  return D3DCOLOR_ARGB( 0xff, r, g, b);
 }

 //#define D3DCOLOR_XYUV(y,u,v)   D3DCOLOR_ARGB(0xff,y,u,v)
 D3DCOLOR D3DCOLOR_XYUV (ubyte y, ubyte u, ubyte v)
 {
  return D3DCOLOR_ARGB (0xff, y, u, v);
 }

 //#define D3DCOLOR_AYUV(a,y,u,v) D3DCOLOR_ARGB(a,y,u,v)
 D3DCOLOR D3DCOLOR_AYUV (ubyte a, ubyte y, ubyte u, ubyte v)
 {
  return D3DCOLOR_ARGB (a, y, u, v);
 }

 // maps floating point channels (0.f to 1.f range) to D3DCOLOR
 //#define D3DCOLOR_COLORVALUE(r,g,b,a) \
 //
D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWOR
D)((a)*255.f))
 D3DCOLOR D3DCOLOR_COLORVALUE ( float r , float g, float b, float a)
 {
  return D3DCOLOR_RGBA( cast(DWORD) ( r * 255.f), cast(DWORD)( g * 255.f ),
cast(DWORD)( b *255.f), cast(DWORD)(a *255.f));
 }



 struct _D3DVECTOR {
     float x;
     float y;
     float z;
 }
 alias _D3DVECTOR D3DVECTOR;




 struct _D3DCOLORVALUE {
     float r;
     float g;
     float b;
     float a;
 }
 alias _D3DCOLORVALUE D3DCOLORVALUE;




 struct _D3DRECT {
     LONG x1;
     LONG y1;
     LONG x2;
     LONG y2;
 }
 alias _D3DRECT D3DRECT;




 struct _D3DMATRIX {
     union {
         struct {
             float        _11, _12, _13, _14;
             float        _21, _22, _23, _24;
             float        _31, _32, _33, _34;
             float        _41, _42, _43, _44;

         };
         float m[4][4];
     };
 }
 alias _D3DMATRIX D3DMATRIX;



 struct _D3DVIEWPORT9 {
     DWORD       X;
     DWORD       Y;            /* Viewport Top left */
     DWORD       Width;
     DWORD       Height;       /* Viewport Dimensions */
     float       MinZ;         /* Min/max of clip Volume */
     float       MaxZ;
 }
 alias _D3DVIEWPORT9 D3DVIEWPORT9;

 /*
  * Values for clip fields.
  */

 // Max number of user clipping planes, supported in D3D.
 const int D3DMAXUSERCLIPPLANES  = 32;

 // These bits could be ORed together to use with D3DRS_CLIPPLANEENABLE
 //
 const int D3DCLIPPLANE0  = (1 << 0);
 const int D3DCLIPPLANE1  = (1 << 1);
 const int D3DCLIPPLANE2  = (1 << 2);
 const int D3DCLIPPLANE3  = (1 << 3);
 const int D3DCLIPPLANE4  = (1 << 4);
 const int D3DCLIPPLANE5  = (1 << 5);

 // The following bits are used in the ClipUnion and ClipIntersection
 // members of the D3DCLIPSTATUS9
 //

 const int D3DCS_LEFT      =  0x00000001L;
 const int D3DCS_RIGHT     =  0x00000002L;
 const int D3DCS_TOP       =  0x00000004L;
 const int D3DCS_BOTTOM    =  0x00000008L;
 const int D3DCS_FRONT     =  0x00000010L;
 const int D3DCS_BACK      =  0x00000020L;
 const int D3DCS_PLANE0    =  0x00000040L;
 const int D3DCS_PLANE1    =  0x00000080L;
 const int D3DCS_PLANE2    =  0x00000100L;
 const int D3DCS_PLANE3    =  0x00000200L;
 const int D3DCS_PLANE4    =  0x00000400L;
 const int D3DCS_PLANE5    =  0x00000800L;

 const int D3DCS_ALL = (D3DCS_LEFT   |
                     D3DCS_RIGHT  |
                     D3DCS_TOP    |
                     D3DCS_BOTTOM |
                     D3DCS_FRONT  |
                     D3DCS_BACK   |
                     D3DCS_PLANE0 |
                     D3DCS_PLANE1 |
                     D3DCS_PLANE2 |
                     D3DCS_PLANE3 |
                     D3DCS_PLANE4 |
                     D3DCS_PLANE5);

 struct _D3DCLIPSTATUS9 {
     DWORD ClipUnion;
     DWORD ClipIntersection;
 }
 alias _D3DCLIPSTATUS9 D3DCLIPSTATUS9;

 struct _D3DMATERIAL9 {
     D3DCOLORVALUE   Diffuse;        /* Diffuse color RGBA */
     D3DCOLORVALUE   Ambient;        /* Ambient color RGB */
     D3DCOLORVALUE   Specular;       /* Specular 'shininess' */
     D3DCOLORVALUE   Emissive;       /* Emissive color RGB */
     float           Power;          /* Sharpness if specular highlight */
 }
 alias _D3DMATERIAL9 D3DMATERIAL9;

 enum _D3DLIGHTTYPE {
     D3DLIGHT_POINT          = 1,
     D3DLIGHT_SPOT           = 2,
     D3DLIGHT_DIRECTIONAL    = 3,
     D3DLIGHT_FORCE_DWORD    = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DLIGHTTYPE D3DLIGHTTYPE;

 struct _D3DLIGHT9 {
     D3DLIGHTTYPE    Type;            /* Type of light source */
     D3DCOLORVALUE   Diffuse;         /* Diffuse color of light */
     D3DCOLORVALUE   Specular;        /* Specular color of light */
     D3DCOLORVALUE   Ambient;         /* Ambient color of light */
     D3DVECTOR       Position;         /* Position in world space */
     D3DVECTOR       Direction;        /* Direction in world space */
     float           Range;            /* Cutoff range */
     float           Falloff;          /* Falloff */
     float           Attenuation0;     /* Constant attenuation */
     float           Attenuation1;     /* Linear attenuation */
     float           Attenuation2;     /* Quadratic attenuation */
     float           Theta;            /* Inner angle of spotlight cone */
     float           Phi;              /* Outer angle of spotlight cone */
 }
 alias _D3DLIGHT9 D3DLIGHT9;

 /*
  * Options for clearing
  */
 const int D3DCLEAR_TARGET        =    0x00000001;  /* Clear target surface
*/
 const int D3DCLEAR_ZBUFFER       =    0x00000002;  /* Clear target z buffer
*/
 const int D3DCLEAR_STENCIL       =    0x00000004;  /* Clear stencil planes
*/

 /*
  * The following defines the rendering states
  */

 enum _D3DSHADEMODE {
     D3DSHADE_FLAT               = 1,
     D3DSHADE_GOURAUD            = 2,
     D3DSHADE_PHONG              = 3,
     D3DSHADE_FORCE_DWORD        = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DSHADEMODE D3DSHADEMODE;

 enum _D3DFILLMODE {
     D3DFILL_POINT               = 1,
     D3DFILL_WIREFRAME           = 2,
     D3DFILL_SOLID               = 3,
     D3DFILL_FORCE_DWORD         = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DFILLMODE D3DFILLMODE;

 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,
     D3DBLEND_BLENDFACTOR        = 14, /* Only supported if
D3DPBLENDCAPS_BLENDFACTOR is on */
     D3DBLEND_INVBLENDFACTOR     = 15, /* Only supported if
D3DPBLENDCAPS_BLENDFACTOR is on */
     D3DBLEND_FORCE_DWORD        = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DBLEND D3DBLEND;





 enum _D3DBLENDOP {
     D3DBLENDOP_ADD              = 1,
     D3DBLENDOP_SUBTRACT         = 2,
     D3DBLENDOP_REVSUBTRACT      = 3,
     D3DBLENDOP_MIN              = 4,
     D3DBLENDOP_MAX              = 5,
     D3DBLENDOP_FORCE_DWORD      = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DBLENDOP D3DBLENDOP;




enum _D3DTEXTUREADDRESS {
     D3DTADDRESS_WRAP            = 1,
     D3DTADDRESS_MIRROR          = 2,
     D3DTADDRESS_CLAMP           = 3,
     D3DTADDRESS_BORDER          = 4,
     D3DTADDRESS_MIRRORONCE      = 5,
     D3DTADDRESS_FORCE_DWORD     = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DTEXTUREADDRESS D3DTEXTUREADDRESS;

 enum _D3DCULL {
     D3DCULL_NONE                = 1,
     D3DCULL_CW                  = 2,
     D3DCULL_CCW                 = 3,
     D3DCULL_FORCE_DWORD         = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DCULL D3DCULL;



 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,
     D3DCMP_FORCE_DWORD          = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DCMPFUNC D3DCMPFUNC;




 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, /* force 32-bit size enum */
 }
 alias _D3DSTENCILOP D3DSTENCILOP;




 enum _D3DFOGMODE {
     D3DFOG_NONE                 = 0,
     D3DFOG_EXP                  = 1,
     D3DFOG_EXP2                 = 2,
     D3DFOG_LINEAR               = 3,
     D3DFOG_FORCE_DWORD          = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DFOGMODE D3DFOGMODE;





 enum _D3DZBUFFERTYPE {
     D3DZB_FALSE                 = 0,
     D3DZB_TRUE                  = 1, // Z buffering
     D3DZB_USEW                  = 2, // W buffering
     D3DZB_FORCE_DWORD           = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DZBUFFERTYPE D3DZBUFFERTYPE;

 // Primitives supported by draw-primitive API
 enum _D3DPRIMITIVETYPE {
     D3DPT_POINTLIST             = 1,
     D3DPT_LINELIST              = 2,
     D3DPT_LINESTRIP             = 3,
     D3DPT_TRIANGLELIST          = 4,
     D3DPT_TRIANGLESTRIP         = 5,
     D3DPT_TRIANGLEFAN           = 6,
     D3DPT_FORCE_DWORD           = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DPRIMITIVETYPE D3DPRIMITIVETYPE;

 enum _D3DTRANSFORMSTATETYPE {
     D3DTS_VIEW          = 2,
     D3DTS_PROJECTION    = 3,
     D3DTS_TEXTURE0      = 16,
     D3DTS_TEXTURE1      = 17,
     D3DTS_TEXTURE2      = 18,
     D3DTS_TEXTURE3      = 19,
     D3DTS_TEXTURE4      = 20,
     D3DTS_TEXTURE5      = 21,
     D3DTS_TEXTURE6      = 22,
     D3DTS_TEXTURE7      = 23,
     D3DTS_FORCE_DWORD     = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DTRANSFORMSTATETYPE D3DTRANSFORMSTATETYPE;




 /** FIXME : convert these !! */
 //#define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
 //#define D3DTS_WORLD  D3DTS_WORLDMATRIX(0)
 //#define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1)
 //#define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2)
 //#define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3)

 enum _D3DRENDERSTATETYPE {
     D3DRS_ZENABLE                   = 7,    /* D3DZBUFFERTYPE (or
TRUE/FALSE for legacy) */
     D3DRS_FILLMODE                  = 8,    /* D3DFILLMODE */
     D3DRS_SHADEMODE                 = 9,    /* D3DSHADEMODE */
     D3DRS_ZWRITEENABLE              = 14,   /* TRUE to enable z writes */
     D3DRS_ALPHATESTENABLE           = 15,   /* TRUE to enable alpha tests
*/
     D3DRS_LASTPIXEL                 = 16,   /* TRUE for last-pixel on lines
*/
     D3DRS_SRCBLEND                  = 19,   /* D3DBLEND */
     D3DRS_DESTBLEND                 = 20,   /* D3DBLEND */
     D3DRS_CULLMODE                  = 22,   /* D3DCULL */
     D3DRS_ZFUNC                     = 23,   /* D3DCMPFUNC */
     D3DRS_ALPHAREF                  = 24,   /* D3DFIXED */
     D3DRS_ALPHAFUNC                 = 25,   /* D3DCMPFUNC */
     D3DRS_DITHERENABLE              = 26,   /* TRUE to enable dithering */
     D3DRS_ALPHABLENDENABLE          = 27,   /* TRUE to enable alpha
blending */
     D3DRS_FOGENABLE                 = 28,   /* TRUE to enable fog blending
*/
     D3DRS_SPECULARENABLE            = 29,   /* TRUE to enable specular */
     D3DRS_FOGCOLOR                  = 34,   /* D3DCOLOR */
     D3DRS_FOGTABLEMODE              = 35,   /* D3DFOGMODE */
     D3DRS_FOGSTART                  = 36,   /* Fog start (for both vertex
and pixel fog) */
     D3DRS_FOGEND                    = 37,   /* Fog end      */
     D3DRS_FOGDENSITY                = 38,   /* Fog density  */
     D3DRS_RANGEFOGENABLE            = 48,   /* Enables range-based fog */
     D3DRS_STENCILENABLE             = 52,   /* BOOL enable/disable
stenciling */
     D3DRS_STENCILFAIL               = 53,   /* D3DSTENCILOP to do if
stencil test fails */
     D3DRS_STENCILZFAIL              = 54,   /* D3DSTENCILOP to do if
stencil test passes and Z test fails */
     D3DRS_STENCILPASS               = 55,   /* D3DSTENCILOP to do if both
stencil and Z tests pass */
     D3DRS_STENCILFUNC               = 56,   /* D3DCMPFUNC fn.  Stencil Test
passes if ((ref & mask) stencilfn (stencil & mask)) is true */
     D3DRS_STENCILREF                = 57,   /* Reference value used in
stencil test */
     D3DRS_STENCILMASK               = 58,   /* Mask value used in stencil
test */
     D3DRS_STENCILWRITEMASK          = 59,   /* Write mask applied to values
written to stencil buffer */
     D3DRS_TEXTUREFACTOR             = 60,   /* D3DCOLOR used for
multi-texture blend */
     D3DRS_WRAP0                     = 128,  /* wrap for 1st texture coord.
set */
     D3DRS_WRAP1                     = 129,  /* wrap for 2nd texture coord.
set */
     D3DRS_WRAP2                     = 130,  /* wrap for 3rd texture coord.
set */
     D3DRS_WRAP3                     = 131,  /* wrap for 4th texture coord.
set */
     D3DRS_WRAP4                     = 132,  /* wrap for 5th texture coord.
set */
     D3DRS_WRAP5                     = 133,  /* wrap for 6th texture coord.
set */
     D3DRS_WRAP6                     = 134,  /* wrap for 7th texture coord.
set */
     D3DRS_WRAP7                     = 135,  /* wrap for 8th texture coord.
set */
     D3DRS_CLIPPING                  = 136,
     D3DRS_LIGHTING                  = 137,
     D3DRS_AMBIENT                   = 139,
     D3DRS_FOGVERTEXMODE             = 140,
     D3DRS_COLORVERTEX               = 141,
     D3DRS_LOCALVIEWER               = 142,
     D3DRS_NORMALIZENORMALS          = 143,
     D3DRS_DIFFUSEMATERIALSOURCE     = 145,
     D3DRS_SPECULARMATERIALSOURCE    = 146,
     D3DRS_AMBIENTMATERIALSOURCE     = 147,
     D3DRS_EMISSIVEMATERIALSOURCE    = 148,
     D3DRS_VERTEXBLEND               = 151,
     D3DRS_CLIPPLANEENABLE           = 152,
     D3DRS_POINTSIZE                 = 154,   /* float point size */
     D3DRS_POINTSIZE_MIN             = 155,   /* float point size min
threshold */
     D3DRS_POINTSPRITEENABLE         = 156,   /* BOOL point texture coord
control */
     D3DRS_POINTSCALEENABLE          = 157,   /* BOOL point size scale
enable */
     D3DRS_POINTSCALE_A              = 158,   /* float point attenuation A
value */
     D3DRS_POINTSCALE_B              = 159,   /* float point attenuation B
value */
     D3DRS_POINTSCALE_C              = 160,   /* float point attenuation C
value */
     D3DRS_MULTISAMPLEANTIALIAS      = 161,  // BOOL - set to do FSAA with
multisample buffer
     D3DRS_MULTISAMPLEMASK           = 162,  // DWORD - per-sample
enable/disable
     D3DRS_PATCHEDGESTYLE            = 163,  // Sets whether patch edges
will use float style tessellation
     D3DRS_DEBUGMONITORTOKEN         = 165,  // DEBUG ONLY - token to debug
monitor
     D3DRS_POINTSIZE_MAX             = 166,   /* float point size max
threshold */
     D3DRS_INDEXEDVERTEXBLENDENABLE  = 167,
     D3DRS_COLORWRITEENABLE          = 168,  // per-channel write enable
     D3DRS_TWEENFACTOR               = 170,   // float tween factor
     D3DRS_BLENDOP                   = 171,   // D3DBLENDOP setting
     D3DRS_POSITIONDEGREE            = 172,   // NPatch position
interpolation degree. D3DDEGREE_LINEAR or D3DDEGREE_CUBIC (default)
     D3DRS_NORMALDEGREE              = 173,   // NPatch normal interpolation
degree. D3DDEGREE_LINEAR (default) or D3DDEGREE_QUADRATIC
     D3DRS_SCISSORTESTENABLE         = 174,
     D3DRS_SLOPESCALEDEPTHBIAS       = 175,
     D3DRS_ANTIALIASEDLINEENABLE     = 176,
     D3DRS_MINTESSELLATIONLEVEL      = 178,
     D3DRS_MAXTESSELLATIONLEVEL      = 179,
     D3DRS_ADAPTIVETESS_X            = 180,
     D3DRS_ADAPTIVETESS_Y            = 181,
     D3DRS_ADAPTIVETESS_Z            = 182,
     D3DRS_ADAPTIVETESS_W            = 183,
     D3DRS_ENABLEADAPTIVETESSELLATION = 184,
     D3DRS_TWOSIDEDSTENCILMODE       = 185,   /* BOOL enable/disable 2 sided
stenciling */
     D3DRS_CCW_STENCILFAIL           = 186,   /* D3DSTENCILOP to do if ccw
stencil test fails */
     D3DRS_CCW_STENCILZFAIL          = 187,   /* D3DSTENCILOP to do if ccw
stencil test passes and Z test fails */
     D3DRS_CCW_STENCILPASS           = 188,   /* D3DSTENCILOP to do if both
ccw stencil and Z tests pass */
     D3DRS_CCW_STENCILFUNC           = 189,   /* D3DCMPFUNC fn.  ccw Stencil
Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */
     D3DRS_COLORWRITEENABLE1         = 190,   /* Additional
ColorWriteEnables for the devices that support
D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
     D3DRS_COLORWRITEENABLE2         = 191,   /* Additional
ColorWriteEnables for the devices that support
D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
     D3DRS_COLORWRITEENABLE3         = 192,   /* Additional
ColorWriteEnables for the devices that support
D3DPMISCCAPS_INDEPENDENTWRITEMASKS */
     D3DRS_BLENDFACTOR               = 193,   /* D3DCOLOR used for a
constant blend factor during alpha blending for devices that support
D3DPBLENDCAPS_BLENDFACTOR */
     D3DRS_SRGBWRITEENABLE           = 194,   /* Enable rendertarget writes
to be DE-linearized to SRGB (for formats that expose
D3DUSAGE_QUERY_SRGBWRITE) */
     D3DRS_DEPTHBIAS                 = 195,
     D3DRS_WRAP8                     = 198,   /* Additional wrap states for
vs_3_0+ attributes with D3DDECLUSAGE_TEXCOORD */
     D3DRS_WRAP9                     = 199,
     D3DRS_WRAP10                    = 200,
     D3DRS_WRAP11                    = 201,
     D3DRS_WRAP12                    = 202,
     D3DRS_WRAP13                    = 203,
     D3DRS_WRAP14                    = 204,
     D3DRS_WRAP15                    = 205,
     D3DRS_SEPARATEALPHABLENDENABLE  = 206,  /* TRUE to enable a separate
blending function for the alpha channel */
     D3DRS_SRCBLENDALPHA             = 207,  /* SRC blend factor for the
alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
     D3DRS_DESTBLENDALPHA            = 208,  /* DST blend factor for the
alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */
     D3DRS_BLENDOPALPHA              = 209,  /* Blending operation for the
alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE */


     D3DRS_FORCE_DWORD               = 0x7fffffff, /* force 32-bit size enum
*/
 }
 alias _D3DRENDERSTATETYPE D3DRENDERSTATETYPE;





 // Maximum number of simultaneous render targets D3D supports
 const int D3D_MAX_SIMULTANEOUS_RENDERTARGETS  = 4;

 // Values for material source
 enum _D3DMATERIALCOLORSOURCE
 {
     D3DMCS_MATERIAL         = 0,            // Color from material is used
     D3DMCS_COLOR1           = 1,            // Diffuse vertex color is used
     D3DMCS_COLOR2           = 2,            // Specular vertex color is
used
     D3DMCS_FORCE_DWORD      = 0x7fffffff,   // force 32-bit size enum
 }
 alias _D3DMATERIALCOLORSOURCE D3DMATERIALCOLORSOURCE;

 // Bias to apply to the texture coordinate set to apply a wrap to.
 const int D3DRENDERSTATE_WRAPBIAS            =     128;

 /* Flags to construct the WRAP render states */
 const int D3DWRAP_U  = 0x00000001;
 const int D3DWRAP_V  = 0x00000002;
 const int D3DWRAP_W  = 0x00000004;

 /* Flags to construct the WRAP render states for 1D thru 4D texture
coordinates */
 const int D3DWRAPCOORD_0  = 0x00000001;    // same as D3DWRAP_U
 const int D3DWRAPCOORD_1  = 0x00000002;    // same as D3DWRAP_V
 const int D3DWRAPCOORD_2  = 0x00000004;    // same as D3DWRAP_W
 const int D3DWRAPCOORD_3  = 0x00000008;

 /* Flags to construct D3DRS_COLORWRITEENABLE */
 const int D3DCOLORWRITEENABLE_RED    = (1<<0);
 const int D3DCOLORWRITEENABLE_GREEN  = (1<<1);
 const int D3DCOLORWRITEENABLE_BLUE   = (1<<2);
 const int D3DCOLORWRITEENABLE_ALPHA  = (1<<3);

 /*
  * State enumerants for per-stage processing of fixed function pixel
processing
  * Two of these affect fixed function vertex processing as well:
TEXTURETRANSFORMFLAGS and TEXCOORDINDEX.
  */
 enum _D3DTEXTURESTAGESTATETYPE
 {
     D3DTSS_COLOROP        =  1, /* D3DTEXTUREOP - per-stage blending
controls for color channels */
     D3DTSS_COLORARG1      =  2, /* D3DTA_* (texture arg) */
     D3DTSS_COLORARG2      =  3, /* D3DTA_* (texture arg) */
     D3DTSS_ALPHAOP        =  4, /* D3DTEXTUREOP - per-stage blending
controls for alpha channel */
     D3DTSS_ALPHAARG1      =  5, /* D3DTA_* (texture arg) */
     D3DTSS_ALPHAARG2      =  6, /* D3DTA_* (texture arg) */
     D3DTSS_BUMPENVMAT00   =  7, /* float (bump mapping matrix) */
     D3DTSS_BUMPENVMAT01   =  8, /* float (bump mapping matrix) */
     D3DTSS_BUMPENVMAT10   =  9, /* float (bump mapping matrix) */
     D3DTSS_BUMPENVMAT11   = 10, /* float (bump mapping matrix) */
     D3DTSS_TEXCOORDINDEX  = 11, /* identifies which set of texture
coordinates index this texture */
     D3DTSS_BUMPENVLSCALE  = 22, /* float scale for bump map luminance */
     D3DTSS_BUMPENVLOFFSET = 23, /* float offset for bump map luminance */
     D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls
texture transform */
     D3DTSS_COLORARG0      = 26, /* D3DTA_* third arg for triadic ops */
     D3DTSS_ALPHAARG0      = 27, /* D3DTA_* third arg for triadic ops */
     D3DTSS_RESULTARG      = 28, /* D3DTA_* arg for result (CURRENT or TEMP)
*/
     D3DTSS_CONSTANT       = 32, /* Per-stage constant D3DTA_CONSTANT */


     D3DTSS_FORCE_DWORD   = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DTEXTURESTAGESTATETYPE D3DTEXTURESTAGESTATETYPE;

 /*
  * State enumerants for per-sampler texture processing.
  */
 enum _D3DSAMPLERSTATETYPE
 {
     D3DSAMP_ADDRESSU       = 1,  /* D3DTEXTUREADDRESS for U coordinate */
     D3DSAMP_ADDRESSV       = 2,  /* D3DTEXTUREADDRESS for V coordinate */
     D3DSAMP_ADDRESSW       = 3,  /* D3DTEXTUREADDRESS for W coordinate */
     D3DSAMP_BORDERCOLOR    = 4,  /* D3DCOLOR */
     D3DSAMP_MAGFILTER      = 5,  /* D3DTEXTUREFILTER filter to use for
magnification */
     D3DSAMP_MINFILTER      = 6,  /* D3DTEXTUREFILTER filter to use for
minification */
     D3DSAMP_MIPFILTER      = 7,  /* D3DTEXTUREFILTER filter to use between
mipmaps during minification */
     D3DSAMP_MIPMAPLODBIAS  = 8,  /* float Mipmap LOD bias */
     D3DSAMP_MAXMIPLEVEL    = 9,  /* DWORD 0..(n-1) LOD index of largest map
to use (0 == largest) */
     D3DSAMP_MAXANISOTROPY  = 10, /* DWORD maximum anisotropy */
     D3DSAMP_SRGBTEXTURE    = 11, /* Default = 0 (which means Gamma 1.0,
                                    no correction required.) else correct
for
                                    Gamma = 2.2 */
     D3DSAMP_ELEMENTINDEX   = 12, /* When multi-element texture is assigned
to sampler, this
                                     indicates which element index to use.
Default = 0.  */
     D3DSAMP_DMAPOFFSET     = 13, /* Offset in vertices in the pre-sampled
displacement map.
                                     Only valid for D3DDMAPSAMPLER sampler
*/
     D3DSAMP_FORCE_DWORD   = 0x7fffffff, /* force 32-bit size enum */
 }
 alias _D3DSAMPLERSTATETYPE D3DSAMPLERSTATETYPE;

 /* Special sampler which is used in the tesselator */
 const int D3DDMAPSAMPLER  = 256;

 // Samplers used in vertex shaders
 const int D3DVERTEXTEXTURESAMPLER0  = (D3DDMAPSAMPLER+1);
 const int D3DVERTEXTEXTURESAMPLER1  = (D3DDMAPSAMPLER+2);
 const int D3DVERTEXTEXTURESAMPLER2  = (D3DDMAPSAMPLER+3);
 const int D3DVERTEXTEXTURESAMPLER3  = (D3DDMAPSAMPLER+4);

 // Values, used with D3DTSS_TEXCOORDINDEX, to specify that the vertex
data(position
 // and normal in the camera space) should be taken as texture coordinates
 // Low 16 bits are used to specify texture coordinate index, to take the
WRAP mode from
 //
 const int D3DTSS_TCI_PASSTHRU                        =     0x00000000;
 const int D3DTSS_TCI_CAMERASPACENORMAL               =     0x00010000;
 const int D3DTSS_TCI_CAMERASPACEPOSITION             =     0x00020000;
 const int D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR     =     0x00030000;
 const int D3DTSS_TCI_SPHEREMAP                       =     0x00040000;

 /*
  * Enumerations for COLOROP and ALPHAOP texture blending operations set in
  * texture processing stage controls in D3DTSS.
  */
 enum _D3DTEXTUREOP
 {
     // Control
     D3DTOP_DISABLE              = 1,      // disables stage
     D3DTOP_SELECTARG1           = 2,      // the default
     D3DTOP_SELECTARG2           = 3,

     // Modulate
     D3DTOP_MODULATE             = 4,      // multiply args together
     D3DTOP_MODULATE2X           = 5,      // multiply and  1 bit
     D3DTOP_MODULATE4X           = 6,      // multiply and  2 bits

     // Add
     D3DTOP_ADD                  =  7,   // add arguments together
     D3DTOP_ADDSIGNED            =  8,   // add with -0.5 bias
     D3DTOP_ADDSIGNED2X          =  9,   // as above but left  1 bit
     D3DTOP_SUBTRACT             = 10,   // Arg1 - Arg2, with no saturation
     D3DTOP_ADDSMOOTH            = 11,   // add 2 args, subtract product
                                         // Arg1 + Arg2 - Arg1*Arg2
                                         // = Arg1 + (1-Arg1)*Arg2

     // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
     D3DTOP_BLENDDIFFUSEALPHA    = 12, // iterated alpha
     D3DTOP_BLENDTEXTUREALPHA    = 13, // texture alpha
     D3DTOP_BLENDFACTORALPHA     = 14, // alpha from D3DRS_TEXTUREFACTOR

     // Linear alpha blend with pre-multiplied arg1 input: Arg1 +
Arg2*(1-Alpha)
     D3DTOP_BLENDTEXTUREALPHAPM  = 15, // texture alpha
     D3DTOP_BLENDCURRENTALPHA    = 16, // by alpha of current color

     // Specular mapping
     D3DTOP_PREMODULATE            = 17,     // modulate with next texture
before use
     D3DTOP_MODULATEALPHA_ADDCOLOR = 18,     // Arg1.RGB + Arg1.A*Arg2.RGB
                                             // COLOROP only
     D3DTOP_MODULATECOLOR_ADDALPHA = 19,     // Arg1.RGB*Arg2.RGB + Arg1.A
                                             // COLOROP only
     D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20,  // (1-Arg1.A)*Arg2.RGB +
Arg1.RGB
                                             // COLOROP only
     D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21,  // (1-Arg1.RGB)*Arg2.RGB +
Arg1.A
                                             // COLOROP only

     // Bump mapping
     D3DTOP_BUMPENVMAP           = 22, // per pixel env map perturbation
     D3DTOP_BUMPENVMAPLUMINANCE  = 23, // with luminance channel

     // This can do either diffuse or specular bump mapping with correct
input.
     // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G +
Arg1.B*Arg2.B)
     // where each component has been scaled and offset to make it signed.
     // The result is replicated into all four (including alpha) channels.
     // This is a valid COLOROP only.
     D3DTOP_DOTPRODUCT3          = 24,

     // Triadic ops
     D3DTOP_MULTIPLYADD          = 25, // Arg0 + Arg1*Arg2
     D3DTOP_LERP                 = 26, // (Arg0)*Arg1 + (1-Arg0)*Arg2

     D3DTOP_FORCE_DWORD = 0x7fffffff,
 }
 alias _D3DTEXTUREOP D3DTEXTUREOP;

 /*
  * Values for COLORARG0,1,2, ALPHAARG0,1,2, and RESULTARG texture blending
  * operations set in texture processing stage controls in D3DRENDERSTATE.
  */
 const int D3DTA_SELECTMASK     =   0x0000000f;  // mask for arg selector
 const int D3DTA_DIFFUSE        =   0x00000000;  // select diffuse color
(read only)
 const int D3DTA_CURRENT        =   0x00000001;  // select stage destination
register (read/write)
 const int D3DTA_TEXTURE        =   0x00000002;  // select texture color
(read only)
 const int D3DTA_TFACTOR        =   0x00000003;  // select
D3DRS_TEXTUREFACTOR (read only)
 const int D3DTA_SPECULAR       =   0x00000004;  // select specular color
(read only)
 const int D3DTA_TEMP           =   0x00000005;  // select temporary
register color (read/write)
 const int D3DTA_CONSTANT       =   0x00000006;  // select texture stage
constant
 const int D3DTA_COMPLEMENT     =   0x00000010;  // take 1.0 - x (read
modifier)
 const int D3DTA_ALPHAREPLICATE =   0x00000020;  // replicate alpha to color
components (read modifier)

 //
 // Values for D3DSAMP_***FILTER texture stage states
 //
 enum _D3DTEXTUREFILTERTYPE
 {
     D3DTEXF_NONE            = 0,    // filtering disabled (valid for mip
filter only)
     D3DTEXF_POINT           = 1,    // nearest
     D3DTEXF_LINEAR          = 2,    // linear interpolation
     D3DTEXF_ANISOTROPIC     = 3,    // anisotropic
     D3DTEXF_PYRAMIDALQUAD   = 6,    // 4-sample tent
     D3DTEXF_GAUSSIANQUAD    = 7,    // 4-sample gaussian
     D3DTEXF_FORCE_DWORD     = 0x7fffffff,   // force 32-bit size enum
 }
 alias _D3DTEXTUREFILTERTYPE D3DTEXTUREFILTERTYPE;

 /* Bits for Flags in ProcessVertices call */

 const int D3DPV_DONOTCOPYDATA    = (1 << 0);

 //-------------------------------------------------------------------

 // Flexible vertex format bits
 //
 const int D3DFVF_RESERVED0       = 0x001;
 const int D3DFVF_POSITION_MASK   = 0x400E;
 const int D3DFVF_XYZ             = 0x002;
 const int D3DFVF_XYZRHW          = 0x004;
 const int D3DFVF_XYZB1           = 0x006;
 const int D3DFVF_XYZB2           = 0x008;
 const int D3DFVF_XYZB3           = 0x00a;
 const int D3DFVF_XYZB4           = 0x00c;
 const int D3DFVF_XYZB5           = 0x00e;
 const int D3DFVF_XYZW            = 0x4002;

 const int D3DFVF_NORMAL          = 0x010;
 const int D3DFVF_PSIZE           = 0x020;
 const int D3DFVF_DIFFUSE         = 0x040;
 const int D3DFVF_SPECULAR        = 0x080;

 const int D3DFVF_TEXCOUNT_MASK   = 0xf00;
 const int D3DFVF_TEXCOUNT_SHIFT  = 8;
 const int D3DFVF_TEX0            = 0x000;
 const int D3DFVF_TEX1            = 0x100;
 const int D3DFVF_TEX2            = 0x200;
 const int D3DFVF_TEX3            = 0x300;
 const int D3DFVF_TEX4            = 0x400;
 const int D3DFVF_TEX5            = 0x500;
 const int D3DFVF_TEX6            = 0x600;
 const int D3DFVF_TEX7            = 0x700;
 const int D3DFVF_TEX8            = 0x800;

 const int D3DFVF_LASTBETA_UBYTE4  = 0x1000;
 const int D3DFVF_LASTBETA_D3DCOLOR = 0x8000;

 const int D3DFVF_RESERVED2       =  0x6000;  // 2 reserved bits

 //---------------------------------------------------------------------
 // Vertex Shaders
 //

 // Vertex shader declaration

 // Vertex element semantics
 //
 enum _D3DDECLUSAGE
 {
     D3DDECLUSAGE_POSITION = 0,
     D3DDECLUSAGE_BLENDWEIGHT,   // 1
     D3DDECLUSAGE_BLENDINDICES,  // 2
     D3DDECLUSAGE_NORMAL,        // 3
     D3DDECLUSAGE_PSIZE,         // 4
     D3DDECLUSAGE_TEXCOORD,      // 5
     D3DDECLUSAGE_TANGENT,       // 6
     D3DDECLUSAGE_BINORMAL,      // 7
     D3DDECLUSAGE_TESSFACTOR,    // 8
     D3DDECLUSAGE_POSITIONT,     // 9
     D3DDECLUSAGE_COLOR,         // 10
     D3DDECLUSAGE_FOG,           // 11
     D3DDECLUSAGE_DEPTH,         // 12
     D3DDECLUSAGE_SAMPLE,        // 13
 }
 alias _D3DDECLUSAGE D3DDECLUSAGE;

 const int MAXD3DDECLUSAGE      =   D3DDECLUSAGE.D3DDECLUSAGE_SAMPLE;
 const int MAXD3DDECLUSAGEINDEX =   15;
 const int MAXD3DDECLLENGTH     =   64; // does not include "end" marker
vertex element

 enum _D3DDECLMETHOD
 {
     D3DDECLMETHOD_DEFAULT = 0,
     D3DDECLMETHOD_PARTIALU,
     D3DDECLMETHOD_PARTIALV,
     D3DDECLMETHOD_CROSSUV,    // Normal
     D3DDECLMETHOD_UV,
     D3DDECLMETHOD_LOOKUP,               // Lookup a displacement map
     D3DDECLMETHOD_LOOKUPPRESAMPLED,     // Lookup a pre-sampled
displacement map
 }
 alias _D3DDECLMETHOD D3DDECLMETHOD;
 const int MAXD3DDECLMETHOD = D3DDECLMETHOD.D3DDECLMETHOD_LOOKUPPRESAMPLED;



 // Declarations for _Type fields
 //
 enum _D3DDECLTYPE
 {
     D3DDECLTYPE_FLOAT1    =  0,  // 1D float expanded to (value, 0., 0.,
1.)
     D3DDECLTYPE_FLOAT2    =  1,  // 2D float expanded to (value, value, 0.,
1.)
     D3DDECLTYPE_FLOAT3    =  2,  // 3D float expanded to (value, value,
value, 1.)
     D3DDECLTYPE_FLOAT4    =  3,  // 4D float
     D3DDECLTYPE_D3DCOLOR  =  4,  // 4D packed unsigned bytes mapped to 0.
to 1. range
                                  // Input is in D3DCOLOR format (ARGB)
expanded to (R, G, B, A)
     D3DDECLTYPE_UBYTE4    =  5,  // 4D unsigned byte
     D3DDECLTYPE_SHORT2    =  6,  // 2D signed short expanded to (value,
value, 0., 1.)
     D3DDECLTYPE_SHORT4    =  7,  // 4D signed short

 // The following types are valid only with vertex shaders >= 2.0


     D3DDECLTYPE_UBYTE4N   =  8,  // Each of 4 bytes is normalized by
dividing to 255.0
     D3DDECLTYPE_SHORT2N   =  9,  // 2D signed short normalized
(v[0]/32767.0,v[1]/32767.0,0,1)
     D3DDECLTYPE_SHORT4N   = 10,  // 4D signed short normalized
(v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
     D3DDECLTYPE_USHORT2N  = 11,  // 2D unsigned short normalized
(v[0]/65535.0,v[1]/65535.0,0,1)
     D3DDECLTYPE_USHORT4N  = 12,  // 4D unsigned short normalized
(v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
     D3DDECLTYPE_UDEC3     = 13,  // 3D unsigned 10 10 10 format expanded to
(value, value, value, 1)
     D3DDECLTYPE_DEC3N     = 14,  // 3D signed 10 10 10 format normalized
and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
     D3DDECLTYPE_FLOAT16_2 = 15,  // Two 16-bit floating point values,
expanded to (value, value, 0, 1)
     D3DDECLTYPE_FLOAT16_4 = 16,  // Four 16-bit floating point values
     D3DDECLTYPE_UNUSED    = 17,  // When the type field in a decl is
unused.
 }
 alias _D3DDECLTYPE D3DDECLTYPE;

 const int MAXD3DDECLTYPE = D3DDECLTYPE.D3DDECLTYPE_UNUSED;

 struct _D3DVERTEXELEMENT9
 {
     WORD    Stream;     // Stream index
     WORD    Offset;     // Offset in the stream in bytes
     BYTE    Type;       // Data type
     BYTE    Method;     // Processing method
     BYTE    Usage;      // Semantics
     BYTE    UsageIndex; // Semantic index
 }
 alias _D3DVERTEXELEMENT9 D3DVERTEXELEMENT9;
 alias D3DVERTEXELEMENT9* LPD3DVERTEXELEMENT9;


 // This is used to initialize the last vertex element in a vertex
declaration
 // array
 //
 //#define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0}
 D3DVERTEXELEMENT9 D3DDECL_END ()
 {
  static D3DVERTEXELEMENT9 d3dVerElement =
   { Stream : 0xFF, Offset : 0, Type : D3DDECLTYPE.D3DDECLTYPE_UNUSED,
Method : 0, Usage : 0, UsageIndex : 0};
  return d3dVerElement;
 }

 // Maximum supported number of texture coordinate sets
 const int D3DDP_MAXTEXCOORD =  8;


 //---------------------------------------------------------------------
 //
 // The internal format of Pixel Shader (PS) & Vertex Shader (VS)
 // Instruction Tokens is defined in the Direct3D Device Driver Kit
 //
 //---------------------------------------------------------------------

 //
 // Instruction Token Bit Definitions
 //
 const int D3DSI_OPCODE_MASK      = 0x0000FFFF;

 const int D3DSI_INSTLENGTH_MASK  = 0x0F000000;
 const int D3DSI_INSTLENGTH_SHIFT = 24;

 enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE
 {
     D3DSIO_NOP          = 0,
     D3DSIO_MOV          ,
     D3DSIO_ADD          ,
     D3DSIO_SUB          ,
     D3DSIO_MAD          ,
     D3DSIO_MUL          ,
     D3DSIO_RCP          ,
     D3DSIO_RSQ          ,
     D3DSIO_DP3          ,
     D3DSIO_DP4          ,
     D3DSIO_MIN          ,
     D3DSIO_MAX          ,
     D3DSIO_SLT          ,
     D3DSIO_SGE          ,
     D3DSIO_EXP          ,
     D3DSIO_LOG          ,
     D3DSIO_LIT          ,
     D3DSIO_DST          ,
     D3DSIO_LRP          ,
     D3DSIO_FRC          ,
     D3DSIO_M4x4         ,
     D3DSIO_M4x3         ,
     D3DSIO_M3x4         ,
     D3DSIO_M3x3         ,
     D3DSIO_M3x2         ,
     D3DSIO_CALL         ,
     D3DSIO_CALLNZ       ,
     D3DSIO_LOOP         ,
     D3DSIO_RET          ,
     D3DSIO_ENDLOOP      ,
     D3DSIO_LABEL        ,
     D3DSIO_DCL          ,
     D3DSIO_POW          ,
     D3DSIO_CRS          ,
     D3DSIO_SGN          ,
     D3DSIO_ABS          ,
     D3DSIO_NRM          ,
     D3DSIO_SINCOS       ,
     D3DSIO_REP          ,
     D3DSIO_ENDREP       ,
     D3DSIO_IF           ,
     D3DSIO_IFC          ,
     D3DSIO_ELSE         ,
     D3DSIO_ENDIF        ,
     D3DSIO_BREAK        ,
     D3DSIO_BREAKC       ,
     D3DSIO_MOVA         ,
     D3DSIO_DEFB         ,
     D3DSIO_DEFI         ,

     D3DSIO_TEXCOORD     = 64,
     D3DSIO_TEXKILL      ,
     D3DSIO_TEX          ,
     D3DSIO_TEXBEM       ,
     D3DSIO_TEXBEML      ,
     D3DSIO_TEXREG2AR    ,
     D3DSIO_TEXREG2GB    ,
     D3DSIO_TEXM3x2PAD   ,
     D3DSIO_TEXM3x2TEX   ,
     D3DSIO_TEXM3x3PAD   ,
     D3DSIO_TEXM3x3TEX   ,
     D3DSIO_RESERVED0    ,
     D3DSIO_TEXM3x3SPEC  ,
     D3DSIO_TEXM3x3VSPEC ,
     D3DSIO_EXPP         ,
     D3DSIO_LOGP         ,
     D3DSIO_CND          ,
     D3DSIO_DEF          ,
     D3DSIO_TEXREG2RGB   ,
     D3DSIO_TEXDP3TEX    ,
     D3DSIO_TEXM3x2DEPTH ,
     D3DSIO_TEXDP3       ,
     D3DSIO_TEXM3x3      ,
     D3DSIO_TEXDEPTH     ,
     D3DSIO_CMP          ,
     D3DSIO_BEM          ,
     D3DSIO_DP2ADD       ,
     D3DSIO_DSX          ,
     D3DSIO_DSY          ,
     D3DSIO_TEXLDD       ,
     D3DSIO_SETP         ,
     D3DSIO_TEXLDL       ,
     D3DSIO_BREAKP       ,

     D3DSIO_PHASE        = 0xFFFD,
     D3DSIO_COMMENT      = 0xFFFE,
     D3DSIO_END          = 0xFFFF,

     D3DSIO_FORCE_DWORD  = 0x7fffffff,   // force 32-bit size enum
 }
 alias _D3DSHADER_INSTRUCTION_OPCODE_TYPE D3DSHADER_INSTRUCTION_OPCODE_TYPE;

 //---------------------------------------------------------------------
 // Use these constants with D3DSIO_SINCOS macro as SRC2, SRC3
 //
 /** ATTENTION !! : I don't know how to convert these 2 lines. */
 //#define D3DSINCOSCONST1 -1.5500992e-006f, -2.1701389e-005f,
0.0026041667f, 0.00026041668f
 //const char[] D3DSINCOSCONST1 = "-1.5500992e-006f, -2.1701389e-005f,
0.0026041667f, 0.00026041668f";
 const float[4] D3DSINCOSCONST1 = [ -1.5500992e-006f, -2.1701389e-005f,
0.0026041667f, 0.00026041668f ];
 //#define D3DSINCOSCONST2 -0.020833334f, -0.12500000f, 1.0f, 0.50000000f
 //const char[] D3DSINCOSCONST2 = "-0.020833334f, -0.12500000f, 1.0f,
0.50000000f";
 const float[4] D3DSINCOSCONST2 = [ -0.020833334f, -0.12500000f, 1.0f,
0.50000000f ];


 //---------------------------------------------------------------------
 // Co-Issue Instruction Modifier - if set then this instruction is to be
 // issued in parallel with the previous instruction(s) for which this bit
 // is not set.
 //
 const int D3DSI_COISSUE        =   0x40000000;

 //---------------------------------------------------------------------
 // Opcode specific controls

 const int D3DSP_OPCODESPECIFICCONTROL_MASK = 0x00ff0000;
 const int D3DSP_OPCODESPECIFICCONTROL_SHIFT = 16;

 // ps_2_0 texld controls
 const int D3DSI_TEXLD_PROJECT = (0x01 <<
D3DSP_OPCODESPECIFICCONTROL_SHIFT);
 const int D3DSI_TEXLD_BIAS    = (0x02 <<
D3DSP_OPCODESPECIFICCONTROL_SHIFT);

 // Comparison for dynamic conditional instruction opcodes (i.e. if, breakc)
 enum _D3DSHADER_COMPARISON
 {
                          // < = >
     D3DSPC_RESERVED0= 0, // 0 0 0
     D3DSPC_GT       = 1, // 0 0 1
     D3DSPC_EQ       = 2, // 0 1 0
     D3DSPC_GE       = 3, // 0 1 1
     D3DSPC_LT       = 4, // 1 0 0
     D3DSPC_NE       = 5, // 1 0 1
     D3DSPC_LE       = 6, // 1 1 0
     D3DSPC_RESERVED1= 7  // 1 1 1
 }
 alias _D3DSHADER_COMPARISON D3DSHADER_COMPARISON;

 // Comparison is part of instruction opcode token:
 const int D3DSHADER_COMPARISON_SHIFT = D3DSP_OPCODESPECIFICCONTROL_SHIFT;
 const int D3DSHADER_COMPARISON_MASK = (0x7<<D3DSHADER_COMPARISON_SHIFT);

 //---------------------------------------------------------------------
 // Predication flags on instruction token
 const int D3DSHADER_INSTRUCTION_PREDICATED   = (0x1 << 28);

 //---------------------------------------------------------------------
 // DCL Info Token Controls

 // For dcl info tokens requiring a semantic (usage + index)
 const int D3DSP_DCL_USAGE_SHIFT = 0;
 const int D3DSP_DCL_USAGE_MASK  = 0x0000000f;

 const int D3DSP_DCL_USAGEINDEX_SHIFT = 16;
 const int D3DSP_DCL_USAGEINDEX_MASK  = 0x000f0000;

 // DCL pixel shader sampler info token.
 const int D3DSP_TEXTURETYPE_SHIFT = 27;
 const int D3DSP_TEXTURETYPE_MASK  = 0x78000000;

 enum _D3DSAMPLER_TEXTURE_TYPE
 {
     D3DSTT_UNKNOWN = 0<<D3DSP_TEXTURETYPE_SHIFT, // uninitialized value
     D3DSTT_2D      = 2<<D3DSP_TEXTURETYPE_SHIFT, // dcl_2d s# (for
declaring a 2-D texture)
     D3DSTT_CUBE    = 3<<D3DSP_TEXTURETYPE_SHIFT, // dcl_cube s# (for
declaring a cube texture)
     D3DSTT_VOLUME  = 4<<D3DSP_TEXTURETYPE_SHIFT, // dcl_volume s# (for
declaring a volume texture)
     D3DSTT_FORCE_DWORD  = 0x7fffffff,      // force 32-bit size enum
 }
 alias _D3DSAMPLER_TEXTURE_TYPE D3DSAMPLER_TEXTURE_TYPE;

 //---------------------------------------------------------------------
 // Parameter Token Bit Definitions
 //
 const int D3DSP_REGNUM_MASK   =    0x000007FF;

 // destination parameter write mask
 const int D3DSP_WRITEMASK_0    =   0x00010000;  // Component 0 (X;Red)
 const int D3DSP_WRITEMASK_1    =   0x00020000;  // Component 1 (Y;Green)
 const int D3DSP_WRITEMASK_2    =   0x00040000;  // Component 2 (Z;Blue)
 const int D3DSP_WRITEMASK_3    =   0x00080000;  // Component 3 (W;Alpha)
 const int D3DSP_WRITEMASK_ALL  =   0x000F0000;  // All Components

 // destination parameter modifiers
 const int D3DSP_DSTMOD_SHIFT   =   20;
 const int D3DSP_DSTMOD_MASK    =   0x00F00000;

 // Bit masks for destination parameter modifiers
 const int    D3DSPDM_NONE              =   (0<<D3DSP_DSTMOD_SHIFT); // nop
 const int    D3DSPDM_SATURATE          =   (1<<D3DSP_DSTMOD_SHIFT); //
clamp to 0. to 1. range
 const int    D3DSPDM_PARTIALPRECISION  =   (2<<D3DSP_DSTMOD_SHIFT); //
Partial precision hint
 const int    D3DSPDM_MSAMPCENTROID     =   (4<<D3DSP_DSTMOD_SHIFT); //
Relevant to multisampling only:
                                                                  //
When the pixel center is not covered, sample
                                                                  //
attribute or compute gradients/LOD
                                                                  //
using multisample "centroid" location.
                                                                  //
"Centroid" is some location within the covered
                                                                  //
region of the pixel.

 // destination parameter
 const int D3DSP_DSTSHIFT_SHIFT  =  24;
 const int D3DSP_DSTSHIFT_MASK   =  0x0F000000;

 // destination/source parameter register type
 const int D3DSP_REGTYPE_SHIFT   =  28;
 const int D3DSP_REGTYPE_SHIFT2  =  8;
 const int D3DSP_REGTYPE_MASK    =  0x70000000;
 const int D3DSP_REGTYPE_MASK2   =  0x00001800;

 enum _D3DSHADER_PARAM_REGISTER_TYPE
 {
     D3DSPR_TEMP           =  0, // Temporary Register File
     D3DSPR_INPUT          =  1, // Input Register File
     D3DSPR_CONST          =  2, // Constant Register File
     D3DSPR_ADDR           =  3, // Address Register (VS)
     D3DSPR_TEXTURE        =  3, // Texture Register File (PS)
     D3DSPR_RASTOUT        =  4, // Rasterizer Register File
     D3DSPR_ATTROUT        =  5, // Attribute Output Register File
     D3DSPR_TEXCRDOUT      =  6, // Texture Coordinate Output Register File
     D3DSPR_OUTPUT         =  6, // Output register file for VS3.0+
     D3DSPR_CONSTINT       =  7, // Constant Integer Vector Register File
     D3DSPR_COLOROUT       =  8, // Color Output Register File
     D3DSPR_DEPTHOUT       =  9, // Depth Output Register File
     D3DSPR_SAMPLER        = 10, // Sampler State Register File
     D3DSPR_CONST2         = 11, // Constant Register File  2048 - 4095
     D3DSPR_CONST3         = 12, // Constant Register File  4096 - 6143
     D3DSPR_CONST4         = 13, // Constant Register File  6144 - 8191
     D3DSPR_CONSTBOOL      = 14, // Constant Boolean register file
     D3DSPR_LOOP           = 15, // Loop counter register file
     D3DSPR_TEMPFLOAT16    = 16, // 16-bit float temp register file
     D3DSPR_MISCTYPE       = 17, // Miscellaneous (single) registers.
     D3DSPR_LABEL          = 18, // Label
     D3DSPR_PREDICATE      = 19, // Predicate register
     D3DSPR_FORCE_DWORD  = 0x7fffffff,         // force 32-bit size enum
 }
 alias _D3DSHADER_PARAM_REGISTER_TYPE D3DSHADER_PARAM_REGISTER_TYPE;

 // The miscellaneous register file (D3DSPR_MISCTYPES)
 // contains register types for which there is only ever one
 // register (i.e. the register # is not needed).
 // Rather than use up additional register types for such
 // registers, they are defined
 // as particular offsets into the misc. register file:
 enum _D3DSHADER_MISCTYPE_OFFSETS
 {
     D3DSMO_POSITION   = 0, // Input position x,y,z,rhw (PS)
     D3DSMO_FACE   = 1, // Floating point primitive area (PS)
 }
 alias _D3DSHADER_MISCTYPE_OFFSETS D3DSHADER_MISCTYPE_OFFSETS;

 // Register offsets in the Rasterizer Register File
 //
 enum _D3DVS_RASTOUT_OFFSETS
 {
     D3DSRO_POSITION = 0,
     D3DSRO_FOG,
     D3DSRO_POINT_SIZE,
     D3DSRO_FORCE_DWORD  = 0x7fffffff,         // force 32-bit size enum
 }
 alias _D3DVS_RASTOUT_OFFSETS D3DVS_RASTOUT_OFFSETS;

 // Source operand addressing modes

 const int D3DVS_ADDRESSMODE_SHIFT = 13;
 const int D3DVS_ADDRESSMODE_MASK  = (1 << D3DVS_ADDRESSMODE_SHIFT);

 enum _D3DVS_ADDRESSMODE_TYPE
 {
     D3DVS_ADDRMODE_ABSOLUTE  = (0 << D3DVS_ADDRESSMODE_SHIFT),
     D3DVS_ADDRMODE_RELATIVE  = (1 << D3DVS_ADDRESSMODE_SHIFT),
     D3DVS_ADDRMODE_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
 }
 alias _D3DVS_ADDRESSMODE_TYPE D3DVS_ADDRESSMODE_TYPE;

 const int D3DSHADER_ADDRESSMODE_SHIFT = 13;
 const int D3DSHADER_ADDRESSMODE_MASK  = (1 << D3DSHADER_ADDRESSMODE_SHIFT);

 enum _D3DSHADER_ADDRESSMODE_TYPE
 {
     D3DSHADER_ADDRMODE_ABSOLUTE  = (0 << D3DSHADER_ADDRESSMODE_SHIFT),
     D3DSHADER_ADDRMODE_RELATIVE  = (1 << D3DSHADER_ADDRESSMODE_SHIFT),
     D3DSHADER_ADDRMODE_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
 }
 alias _D3DSHADER_ADDRESSMODE_TYPE D3DSHADER_ADDRESSMODE_TYPE;

 // Source operand swizzle definitions
 //
 const int D3DVS_SWIZZLE_SHIFT   =  16;
 const int D3DVS_SWIZZLE_MASK    =  0x00FF0000;

 // The following bits define where to take component X from:

 const int D3DVS_X_X     =  (0 << D3DVS_SWIZZLE_SHIFT);
 const int D3DVS_X_Y     =  (1 << D3DVS_SWIZZLE_SHIFT);
 const int D3DVS_X_Z     =  (2 << D3DVS_SWIZZLE_SHIFT);
 const int D3DVS_X_W     =  (3 << D3DVS_SWIZZLE_SHIFT);

 // The following bits define where to take component Y from:

 const int D3DVS_Y_X     =  (0 << (D3DVS_SWIZZLE_SHIFT + 2));
 const int D3DVS_Y_Y     =  (1 << (D3DVS_SWIZZLE_SHIFT + 2));
 const int D3DVS_Y_Z     =  (2 << (D3DVS_SWIZZLE_SHIFT + 2));
 const int D3DVS_Y_W     =  (3 << (D3DVS_SWIZZLE_SHIFT + 2));

 // The following bits define where to take component Z from:

 const int D3DVS_Z_X     =  (0 << (D3DVS_SWIZZLE_SHIFT + 4));
 const int D3DVS_Z_Y     =  (1 << (D3DVS_SWIZZLE_SHIFT + 4));
 const int D3DVS_Z_Z     =  (2 << (D3DVS_SWIZZLE_SHIFT + 4));
 const int D3DVS_Z_W     =  (3 << (D3DVS_SWIZZLE_SHIFT + 4));

 // The following bits define where to take component W from:

 const int D3DVS_W_X     =  (0 << (D3DVS_SWIZZLE_SHIFT + 6));
 const int D3DVS_W_Y     =  (1 << (D3DVS_SWIZZLE_SHIFT + 6));
 const int D3DVS_W_Z     =  (2 << (D3DVS_SWIZZLE_SHIFT + 6));
 const int D3DVS_W_W     =  (3 << (D3DVS_SWIZZLE_SHIFT + 6));

 // Value when there is no swizzle (X is taken from X, Y is taken from Y,
 // Z is taken from Z, W is taken from W
 //
 const int D3DVS_NOSWIZZLE = (D3DVS_X_X | D3DVS_Y_Y | D3DVS_Z_Z |
D3DVS_W_W);

 // source parameter swizzle
 const int D3DSP_SWIZZLE_SHIFT   =  16;
 const int D3DSP_SWIZZLE_MASK    =  0x00FF0000;

 //#define D3DSP_NOSWIZZLE \
 //    ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (3 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_NOSWIZZLE =
     ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) |
       (1 << (D3DSP_SWIZZLE_SHIFT + 2)) |
       (2 << (D3DSP_SWIZZLE_SHIFT + 4)) |
       (3 << (D3DSP_SWIZZLE_SHIFT + 6)) );

 // pixel-shader swizzle ops
 //#define D3DSP_REPLICATERED \
 //    ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (0 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (0 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (0 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_REPLICATERED =
     ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) |
       (0 << (D3DSP_SWIZZLE_SHIFT + 2)) |
       (0 << (D3DSP_SWIZZLE_SHIFT + 4)) |
       (0 << (D3DSP_SWIZZLE_SHIFT + 6)) );



 //#define D3DSP_REPLICATEGREEN \
 //    ( (1 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (1 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (1 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_REPLICATEGREEN =
  ( (1 << (D3DSP_SWIZZLE_SHIFT + 0)) |
       (1 << (D3DSP_SWIZZLE_SHIFT + 2)) |
       (1 << (D3DSP_SWIZZLE_SHIFT + 4)) |
       (1 << (D3DSP_SWIZZLE_SHIFT + 6)) );



 //#define D3DSP_REPLICATEBLUE \
 //    ( (2 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (2 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (2 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_REPLICATEBLUE = ( (2 << (D3DSP_SWIZZLE_SHIFT + 0)) |
                (2 << (D3DSP_SWIZZLE_SHIFT + 2)) |
                (2 << (D3DSP_SWIZZLE_SHIFT + 4)) |
                (2 << (D3DSP_SWIZZLE_SHIFT + 6)) );


 //#define D3DSP_REPLICATEALPHA \
 //    ( (3 << (D3DSP_SWIZZLE_SHIFT + 0)) | \
 //      (3 << (D3DSP_SWIZZLE_SHIFT + 2)) | \
 //      (3 << (D3DSP_SWIZZLE_SHIFT + 4)) | \
 //      (3 << (D3DSP_SWIZZLE_SHIFT + 6)) )
 const int D3DSP_REPLICATEALPHA = ( (3 << (D3DSP_SWIZZLE_SHIFT + 0)) |
               (3 << (D3DSP_SWIZZLE_SHIFT + 2)) |
               (3 << (D3DSP_SWIZZLE_SHIFT + 4)) |
               (3 << (D3DSP_SWIZZLE_SHIFT + 6)) );


 // source parameter modifiers
 const int D3DSP_SRCMOD_SHIFT   =   24;
 const int D3DSP_SRCMOD_MASK    =   0x0F000000;

 enum _D3DSHADER_PARAM_SRCMOD_TYPE
 {
     D3DSPSM_NONE    = 0<<D3DSP_SRCMOD_SHIFT, // nop
     D3DSPSM_NEG     = 1<<D3DSP_SRCMOD_SHIFT, // negate
     D3DSPSM_BIAS    = 2<<D3DSP_SRCMOD_SHIFT, // bias
     D3DSPSM_BIASNEG = 3<<D3DSP_SRCMOD_SHIFT, // bias and negate
     D3DSPSM_SIGN    = 4<<D3DSP_SRCMOD_SHIFT, // sign
     D3DSPSM_SIGNNEG = 5<<D3DSP_SRCMOD_SHIFT, // sign and negate
     D3DSPSM_COMP    = 6<<D3DSP_SRCMOD_SHIFT, // complement
     D3DSPSM_X2      = 7<<D3DSP_SRCMOD_SHIFT, // *2
     D3DSPSM_X2NEG   = 8<<D3DSP_SRCMOD_SHIFT, // *2 and negate
     D3DSPSM_DZ      = 9<<D3DSP_SRCMOD_SHIFT, // divide through by z
component
     D3DSPSM_DW      = 10<<D3DSP_SRCMOD_SHIFT, // divide through by w
component
     D3DSPSM_ABS     = 11<<D3DSP_SRCMOD_SHIFT, // abs()
     D3DSPSM_ABSNEG  = 12<<D3DSP_SRCMOD_SHIFT, // -abs()
     D3DSPSM_NOT     = 13<<D3DSP_SRCMOD_SHIFT, // for predicate register:
"!p0"
     D3DSPSM_FORCE_DWORD = 0x7fffffff,        // force 32-bit size enum
 }
 alias _D3DSHADER_PARAM_SRCMOD_TYPE D3DSHADER_PARAM_SRCMOD_TYPE;

 // pixel shader version token
 //#define D3DPS_VERSION(_Major,_Minor) (0xFFFF0000|((_Major)<<8)|(_Minor))
 int D3DPS_VERSION (int _Major, int _Minor)
 {
  return (0xFFFF0000|((_Major)<<8)|(_Minor));
 }

 // vertex shader version token
 //#define D3DVS_VERSION(_Major,_Minor) (0xFFFE0000|((_Major)<<8)|(_Minor))
 int D3DVS_VERSION (int _Major , int _Minor)
 {
  return (0xFFFE0000|((_Major)<<8)|(_Minor));
 }

 // extract major/minor from version cap
 //#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
 int D3DSHADER_VERSION_MAJOR (int _Version)
 {
  return  (((_Version)>>8) & 0xFF);
 }

 //#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
 int D3DSHADER_VERSION_MINOR (int _Version)
 {
  return (((_Version)>>0)&0xFF);
 }

 // destination/source parameter register type
 const int D3DSI_COMMENTSIZE_SHIFT   =  16;
 const int D3DSI_COMMENTSIZE_MASK    =  0x7FFF0000;

 //#define D3DSHADER_COMMENT(_DWordSize) \
 //
((((_DWordSize)<<D3DSI_COMMENTSIZE_SHIFT)&D3DSI_COMMENTSIZE_MASK)|D3DSIO_COM
MENT)
 int D3DSHADER_COMMENT (DWORD _DWordSize)
 {
  return ((((_DWordSize) << D3DSI_COMMENTSIZE_SHIFT) &
D3DSI_COMMENTSIZE_MASK) | D3DSHADER_INSTRUCTION_OPCODE_TYPE.D3DSIO_COMMENT);
 }

 // pixel/vertex shader end token
 //#define D3DPS_END()  0x0000FFFF
 int D3DPS_END ()
 {
  return 0x0000FFFF;
 }

 //#define D3DVS_END()  0x0000FFFF
 int D3DVS_END ()
 {
  return 0x0000FFFF;
 }


 //---------------------------------------------------------------------

 // High order surfaces
 //
 enum _D3DBASISTYPE
 {
    D3DBASIS_BEZIER      = 0,
    D3DBASIS_BSPLINE     = 1,
    D3DBASIS_CATMULL_ROM = 2, /* In D3D8 this used to be
D3DBASIS_INTERPOLATE */
    D3DBASIS_FORCE_DWORD = 0x7fffffff,
 }
 alias _D3DBASISTYPE D3DBASISTYPE;

 enum _D3DDEGREETYPE
 {
    D3DDEGREE_LINEAR      = 1,
    D3DDEGREE_QUADRATIC   = 2,
    D3DDEGREE_CUBIC       = 3,
    D3DDEGREE_QUINTIC     = 5,
    D3DDEGREE_FORCE_DWORD = 0x7fffffff,
 }
 alias _D3DDEGREETYPE D3DDEGREETYPE;

 enum _D3DPATCHEDGESTYLE
 {
    D3DPATCHEDGE_DISCRETE    = 0,
    D3DPATCHEDGE_CONTINUOUS  = 1,
    D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff,
 }
 alias _D3DPATCHEDGESTYLE D3DPATCHEDGESTYLE;

 enum _D3DSTATEBLOCKTYPE
 {
     D3DSBT_ALL           = 1, // capture all state
     D3DSBT_PIXELSTATE    = 2, // capture pixel state
     D3DSBT_VERTEXSTATE   = 3, // capture vertex state
     D3DSBT_FORCE_DWORD   = 0x7fffffff,
 }
 alias _D3DSTATEBLOCKTYPE D3DSTATEBLOCKTYPE;

 // The D3DVERTEXBLENDFLAGS type is used with D3DRS_VERTEXBLEND state.
 //
 enum _D3DVERTEXBLENDFLAGS
 {
     D3DVBF_DISABLE  = 0,     // Disable vertex blending
     D3DVBF_1WEIGHTS = 1,     // 2 matrix blending
     D3DVBF_2WEIGHTS = 2,     // 3 matrix blending
     D3DVBF_3WEIGHTS = 3,     // 4 matrix blending
     D3DVBF_TWEENING = 255,   // blending using D3DRS_TWEENFACTOR
     D3DVBF_0WEIGHTS = 256,   // one matrix is used with weight 1.0
     D3DVBF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
 }
 alias _D3DVERTEXBLENDFLAGS D3DVERTEXBLENDFLAGS;

 enum _D3DTEXTURETRANSFORMFLAGS
 {
     D3DTTFF_DISABLE         = 0,    // texture coordinates are passed
directly
     D3DTTFF_COUNT1          = 1,    // rasterizer should expect 1-D texture
coords
     D3DTTFF_COUNT2          = 2,    // rasterizer should expect 2-D texture
coords
     D3DTTFF_COUNT3          = 3,    // rasterizer should expect 3-D texture
coords
     D3DTTFF_COUNT4          = 4,    // rasterizer should expect 4-D texture
coords
     D3DTTFF_PROJECTED       = 256,  // texcoords to be divided by COUNTth
element
     D3DTTFF_FORCE_DWORD     = 0x7fffffff,
 }
 alias _D3DTEXTURETRANSFORMFLAGS D3DTEXTURETRANSFORMFLAGS;

 // Macros to set texture coordinate format bits in the FVF id

 const int D3DFVF_TEXTUREFORMAT2 = 0;         // Two floating point values
 const int D3DFVF_TEXTUREFORMAT1 = 3;         // One floating point value
 const int D3DFVF_TEXTUREFORMAT3 = 1;         // Three floating point values
 const int D3DFVF_TEXTUREFORMAT4 = 2;         // Four floating point values

 //#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 <<
(CoordIndex*2 + 16))
 int D3DFVF_TEXCOORDSIZE3 (int CoordIndex)
 {
  return (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16));
 }

 //#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2)
 int D3DFVF_TEXCOORDSIZE2 (int CoordIndex)
 {
  return (D3DFVF_TEXTUREFORMAT2);
 }

 //#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 <<
(CoordIndex*2 + 16))
 int D3DFVF_TEXCOORDSIZE4 (int CoordIndex)
 {
  return  (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16));
 }

 //#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 <<
(CoordIndex*2 + 16))
 int D3DFVF_TEXCOORDSIZE1 (int CoordIndex)
 {
  return (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16));
 }


 //---------------------------------------------------------------------

 /* Direct3D9 Device types */
 enum _D3DDEVTYPE
 {
     D3DDEVTYPE_HAL         = 1,
     D3DDEVTYPE_REF         = 2,
     D3DDEVTYPE_SW          = 3,

     D3DDEVTYPE_FORCE_DWORD  = 0x7fffffff
 }
 alias _D3DDEVTYPE D3DDEVTYPE;

 /* Multi-Sample buffer types */
 enum _D3DMULTISAMPLE_TYPE
 {
     D3DMULTISAMPLE_NONE            =  0,
     D3DMULTISAMPLE_NONMASKABLE     =  1,
     D3DMULTISAMPLE_2_SAMPLES       =  2,
     D3DMULTISAMPLE_3_SAMPLES       =  3,
     D3DMULTISAMPLE_4_SAMPLES       =  4,
     D3DMULTISAMPLE_5_SAMPLES       =  5,
     D3DMULTISAMPLE_6_SAMPLES       =  6,
     D3DMULTISAMPLE_7_SAMPLES       =  7,
     D3DMULTISAMPLE_8_SAMPLES       =  8,
     D3DMULTISAMPLE_9_SAMPLES       =  9,
     D3DMULTISAMPLE_10_SAMPLES      = 10,
     D3DMULTISAMPLE_11_SAMPLES      = 11,
     D3DMULTISAMPLE_12_SAMPLES      = 12,
     D3DMULTISAMPLE_13_SAMPLES      = 13,
     D3DMULTISAMPLE_14_SAMPLES      = 14,
     D3DMULTISAMPLE_15_SAMPLES      = 15,
     D3DMULTISAMPLE_16_SAMPLES      = 16,

     D3DMULTISAMPLE_FORCE_DWORD     = 0x7fffffff
 }
 alias _D3DMULTISAMPLE_TYPE D3DMULTISAMPLE_TYPE;

 /* Formats
  * Most of these names have the following convention:
  *      A = Alpha
  *      R = Red
  *      G = Green
  *      B = Blue
  *      X = Unused Bits
  *      P = Palette
  *      L = Luminance
  *      U = dU coordinate for BumpMap
  *      V = dV coordinate for BumpMap
  *      S = Stencil
  *      D = Depth (e.g. Z or W buffer)
  *      C = Computed from other channels (typically on certain read
operations)
  *
  *      Further, the order of the pieces are from MSB first; hence
  *      D3DFMT_A8L8 indicates that the high byte of this two byte
  *      format is alpha.
  *
  *      D16 indicates:
  *           - An integer 16-bit value.
  *           - An app-lockable surface.
  *
  *      All Depth/Stencil formats except D3DFMT_D16_LOCKABLE indicate:
  *          - no particular bit ordering per pixel, and
  *          - are not app lockable, and
  *          - the driver is allowed to consume more than the indicated
  *            number of bits per Depth channel (but not Stencil channel).
  */

  //   #define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
  //               ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |       \
  //               ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
  int MAKEFOURCC ( char ch0, char ch1, char ch2, char ch3)
  {
   return ( cast(DWORD)( cast(BYTE)((ch0)) | ( cast(DWORD) (cast(BYTE)((ch1
<< 8))) ) |
       ( cast(DWORD)( cast(BYTE)(( ch2 << 16))) ) | ( cast(DWORD)(
cast(BYTE)((ch3 << 24)))) ));
  }



 enum _D3DFORMAT
 {
     D3DFMT_UNKNOWN              =  0,

     D3DFMT_R8G8B8               = 20,
     D3DFMT_A8R8G8B8             = 21,
     D3DFMT_X8R8G8B8             = 22,
     D3DFMT_R5G6B5               = 23,
     D3DFMT_X1R5G5B5             = 24,
     D3DFMT_A1R5G5B5             = 25,
     D3DFMT_A4R4G4B4             = 26,
     D3DFMT_R3G3B2               = 27,
     D3DFMT_A8                   = 28,
     D3DFMT_A8R3G3B2             = 29,
     D3DFMT_X4R4G4B4             = 30,
     D3DFMT_A2B10G10R10          = 31,
     D3DFMT_A8B8G8R8             = 32,
     D3DFMT_X8B8G8R8             = 33,
     D3DFMT_G16R16               = 34,
     D3DFMT_A2R10G10B10          = 35,
     D3DFMT_A16B16G16R16         = 36,

     D3DFMT_A8P8                 = 40,
     D3DFMT_P8                   = 41,

     D3DFMT_L8                   = 50,
     D3DFMT_A8L8                 = 51,
     D3DFMT_A4L4                 = 52,

     D3DFMT_V8U8                 = 60,
     D3DFMT_L6V5U5               = 61,
     D3DFMT_X8L8V8U8             = 62,
     D3DFMT_Q8W8V8U8             = 63,
     D3DFMT_V16U16               = 64,
     D3DFMT_A2W10V10U10          = 67,

     D3DFMT_UYVY                 = 85, //MAKEFOURCC('U', 'Y', 'V', 'Y'),
     D3DFMT_R8G8_B8G8            = 82, //MAKEFOURCC('R', 'G', 'B', 'G'),
     D3DFMT_YUY2                 = 89, //MAKEFOURCC('Y', 'U', 'Y', '2'),
     D3DFMT_G8R8_G8B8            = 71, //MAKEFOURCC('G', 'R', 'G', 'B'),
     D3DFMT_DXT1                 = 68, //MAKEFOURCC('D', 'X', 'T', '1'),
     D3DFMT_DXT2                 = 68, //MAKEFOURCC('D', 'X', 'T', '2'),
     D3DFMT_DXT3                 = 68, //MAKEFOURCC('D', 'X', 'T', '3'),
     D3DFMT_DXT4                 = 68, //MAKEFOURCC('D', 'X', 'T', '4'),
     D3DFMT_DXT5                 = 68, //MAKEFOURCC('D', 'X', 'T', '5'),

     D3DFMT_D16_LOCKABLE         = 70,
     D3DFMT_D32                  = 71,
     D3DFMT_D15S1                = 73,
     D3DFMT_D24S8                = 75,
     D3DFMT_D24X8                = 77,
     D3DFMT_D24X4S4              = 79,
     D3DFMT_D16                  = 80,

     D3DFMT_D32F_LOCKABLE        = 82,
     D3DFMT_D24FS8               = 83,


     D3DFMT_L16                  = 81,

     D3DFMT_VERTEXDATA           =100,
     D3DFMT_INDEX16              =101,
     D3DFMT_INDEX32              =102,

     D3DFMT_Q16W16V16U16         =110,

     D3DFMT_MULTI2_ARGB8         = 68, //MAKEFOURCC('M','E','T','1'),

     // Floating point surface formats

     // s10e5 formats (16-bits per channel)
     D3DFMT_R16F                 = 111,
     D3DFMT_G16R16F              = 112,
     D3DFMT_A16B16G16R16F        = 113,

     // IEEE s23e8 formats (32-bits per channel)
     D3DFMT_R32F                 = 114,
     D3DFMT_G32R32F              = 115,
     D3DFMT_A32B32G32R32F        = 116,

     D3DFMT_CxV8U8               = 117,


     D3DFMT_FORCE_DWORD          =0x7fffffff
 }
 alias _D3DFORMAT D3DFORMAT;

 /* Display Modes */
 struct _D3DDISPLAYMODE
 {
     UINT            Width;
     UINT            Height;
     UINT            RefreshRate;
     D3DFORMAT       Format;
 }
 alias _D3DDISPLAYMODE D3DDISPLAYMODE;

 /* Creation Parameters */
 struct _D3DDEVICE_CREATION_PARAMETERS
 {
     UINT            AdapterOrdinal;
     D3DDEVTYPE      DeviceType;
     HWND            hFocusWindow;
     DWORD           BehaviorFlags;
 }
 alias _D3DDEVICE_CREATION_PARAMETERS D3DDEVICE_CREATION_PARAMETERS;


 /* SwapEffects */
 enum _D3DSWAPEFFECT
 {
     D3DSWAPEFFECT_DISCARD           = 1,
     D3DSWAPEFFECT_FLIP              = 2,
     D3DSWAPEFFECT_COPY              = 3,

     D3DSWAPEFFECT_FORCE_DWORD       = 0x7fffffff
 }
 alias _D3DSWAPEFFECT D3DSWAPEFFECT;

 /* Pool types */
 enum _D3DPOOL
 {
     D3DPOOL_DEFAULT                 = 0,
     D3DPOOL_MANAGED                 = 1,
     D3DPOOL_SYSTEMMEM               = 2,
     D3DPOOL_SCRATCH                 = 3,

     D3DPOOL_FORCE_DWORD             = 0x7fffffff
 }
 alias _D3DPOOL D3DPOOL;


 /* RefreshRate pre-defines */
 const int D3DPRESENT_RATE_DEFAULT      =   0x00000000;


 /* Resize Optional Parameters */
 struct _D3DPRESENT_PARAMETERS_
 {
     UINT                BackBufferWidth;
     UINT                BackBufferHeight;
     D3DFORMAT           BackBufferFormat;
     UINT                BackBufferCount;

     D3DMULTISAMPLE_TYPE MultiSampleType;
     DWORD               MultiSampleQuality;

     D3DSWAPEFFECT       SwapEffect;
     HWND                hDeviceWindow;
     BOOL                Windowed;
     BOOL                EnableAutoDepthStencil;
     D3DFORMAT           AutoDepthStencilFormat;
     DWORD               Flags;

     /* FullScreen_RefreshRateInHz must be zero for Windowed mode */
     UINT                FullScreen_RefreshRateInHz;
     UINT                PresentationInterval;
 }
 alias _D3DPRESENT_PARAMETERS_ D3DPRESENT_PARAMETERS;

 // Values for D3DPRESENT_PARAMETERS.Flags

 const int D3DPRESENTFLAG_LOCKABLE_BACKBUFFER    =  0x00000001;
 const int D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL   =  0x00000002;
 const int D3DPRESENTFLAG_DEVICECLIP             =  0x00000004;
 const int D3DPRESENTFLAG_VIDEO                  =  0x00000010;

 /* Gamma Ramp: Same as DX7 */

 struct _D3DGAMMARAMP
 {
     WORD                red  [256];
     WORD                green[256];
     WORD                blue [256];
 }
 alias _D3DGAMMARAMP D3DGAMMARAMP;

 /* Back buffer types */
 enum _D3DBACKBUFFER_TYPE
 {
     D3DBACKBUFFER_TYPE_MONO         = 0,
     D3DBACKBUFFER_TYPE_LEFT         = 1,
     D3DBACKBUFFER_TYPE_RIGHT        = 2,

     D3DBACKBUFFER_TYPE_FORCE_DWORD  = 0x7fffffff
 }
 alias _D3DBACKBUFFER_TYPE D3DBACKBUFFER_TYPE;


 /* Types */
 enum _D3DRESOURCETYPE
 {
     D3DRTYPE_SURFACE                =  1,
     D3DRTYPE_VOLUME                 =  2,
     D3DRTYPE_TEXTURE                =  3,
     D3DRTYPE_VOLUMETEXTURE          =  4,
     D3DRTYPE_CUBETEXTURE            =  5,
     D3DRTYPE_VERTEXBUFFER           =  6,
     D3DRTYPE_INDEXBUFFER            =  7,


     D3DRTYPE_FORCE_DWORD            = 0x7fffffff
 }
 alias _D3DRESOURCETYPE D3DRESOURCETYPE;

 /* Usages */
 const int D3DUSAGE_RENDERTARGET     =  0x00000001;
 const int D3DUSAGE_DEPTHSTENCIL     =  0x00000002;
 const int D3DUSAGE_DYNAMIC          =  0x00000200;

 // When passed to CheckDeviceFormat, D3DUSAGE_AUTOGENMIPMAP may return
 // D3DOK_NOAUTOGEN if the device doesn't support autogeneration for that
format.
 // D3DOK_NOAUTOGEN is a success code, not a failure code... the SUCCEEDED
and FAILED macros
 // will return true and false respectively for this code.
 const int D3DUSAGE_AUTOGENMIPMAP     = 0x00000400;
 const int D3DUSAGE_DMAP              = 0x00004000;

 // The following usages are valid only for querying CheckDeviceFormat
 const int D3DUSAGE_QUERY_LEGACYBUMPMAP          =  0x00008000;
 const int D3DUSAGE_QUERY_SRGBREAD               =  0x00010000;
 const int D3DUSAGE_QUERY_FILTER                 =  0x00020000;
 const int D3DUSAGE_QUERY_SRGBWRITE              =  0x00040000;
 const int D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING = 0x00080000;
 const int D3DUSAGE_QUERY_VERTEXTEXTURE          =  0x00100000;

 /* Usages for Vertex/Index buffers */
 const int D3DUSAGE_WRITEONLY         = 0x00000008;
 const int D3DUSAGE_SOFTWAREPROCESSING = 0x00000010;
 const int D3DUSAGE_DONOTCLIP         = 0x00000020;
 const int D3DUSAGE_POINTS            = 0x00000040;
 const int D3DUSAGE_RTPATCHES         = 0x00000080;
 const int D3DUSAGE_NPATCHES          = 0x00000100;










 /* CubeMap Face identifiers */
 enum _D3DCUBEMAP_FACES
 {
     D3DCUBEMAP_FACE_POSITIVE_X     = 0,
     D3DCUBEMAP_FACE_NEGATIVE_X     = 1,
     D3DCUBEMAP_FACE_POSITIVE_Y     = 2,
     D3DCUBEMAP_FACE_NEGATIVE_Y     = 3,
     D3DCUBEMAP_FACE_POSITIVE_Z     = 4,
     D3DCUBEMAP_FACE_NEGATIVE_Z     = 5,

     D3DCUBEMAP_FACE_FORCE_DWORD    = 0x7fffffff
 }
 alias _D3DCUBEMAP_FACES D3DCUBEMAP_FACES;


 /* Lock flags */

 const int D3DLOCK_READONLY         =  0x00000010;
 const int D3DLOCK_DISCARD          =  0x00002000;
 const int D3DLOCK_NOOVERWRITE      =  0x00001000;
 const int D3DLOCK_NOSYSLOCK        =  0x00000800;
 const int D3DLOCK_DONOTWAIT        =  0x00004000;

 const int D3DLOCK_NO_DIRTY_UPDATE  =   0x00008000;







 /* Vertex Buffer Description */
 struct _D3DVERTEXBUFFER_DESC
 {
     D3DFORMAT           Format;
     D3DRESOURCETYPE     Type;
     DWORD               Usage;
     D3DPOOL             Pool;
     UINT                Size;

     DWORD               FVF;

 }
 alias _D3DVERTEXBUFFER_DESC D3DVERTEXBUFFER_DESC;

 /* Index Buffer Description */
 struct _D3DINDEXBUFFER_DESC
 {
     D3DFORMAT           Format;
     D3DRESOURCETYPE     Type;
     DWORD               Usage;
     D3DPOOL             Pool;
     UINT                Size;
 }
 alias _D3DINDEXBUFFER_DESC D3DINDEXBUFFER_DESC;


 /* Surface Description */
 struct _D3DSURFACE_DESC
 {
     D3DFORMAT           Format;
     D3DRESOURCETYPE     Type;
     DWORD               Usage;
     D3DPOOL             Pool;

     D3DMULTISAMPLE_TYPE MultiSampleType;
     DWORD               MultiSampleQuality;
     UINT                Width;
     UINT                Height;
 }
 alias _D3DSURFACE_DESC D3DSURFACE_DESC;

 struct _D3DVOLUME_DESC
 {
     D3DFORMAT           Format;
     D3DRESOURCETYPE     Type;
     DWORD               Usage;
     D3DPOOL             Pool;

     UINT                Width;
     UINT                Height;
     UINT                Depth;
 }
 alias _D3DVOLUME_DESC D3DVOLUME_DESC;

 /* Structure for LockRect */
 struct _D3DLOCKED_RECT
 {
     INT                 Pitch;
     void*               pBits;
 }
 alias _D3DLOCKED_RECT D3DLOCKED_RECT;

 /* Structures for LockBox */
 struct _D3DBOX
 {
     UINT                Left;
     UINT                Top;
     UINT                Right;
     UINT                Bottom;
     UINT                Front;
     UINT                Back;
 }
 alias _D3DBOX D3DBOX;

 struct _D3DLOCKED_BOX
 {
     INT                 RowPitch;
     INT                 SlicePitch;
     void*               pBits;
 }
 alias _D3DLOCKED_BOX D3DLOCKED_BOX;

 /* Structures for LockRange */
 struct _D3DRANGE
 {
     UINT                Offset;
     UINT                Size;
 }
 alias _D3DRANGE D3DRANGE;

 /* Structures for high order primitives */
 struct _D3DRECTPATCH_INFO
 {
     UINT                StartVertexOffsetWidth;
     UINT                StartVertexOffsetHeight;
     UINT                Width;
     UINT                Height;
     UINT                Stride;
     D3DBASISTYPE        Basis;
     D3DDEGREETYPE       Degree;
 }
 alias _D3DRECTPATCH_INFO D3DRECTPATCH_INFO;

 struct _D3DTRIPATCH_INFO
 {
     UINT                StartVertexOffset;
     UINT                NumVertices;
     D3DBASISTYPE        Basis;
     D3DDEGREETYPE       Degree;
 }
 alias _D3DTRIPATCH_INFO D3DTRIPATCH_INFO;

 /* Adapter Identifier */

 const int MAX_DEVICE_IDENTIFIER_STRING    =    512;
 struct _D3DADAPTER_IDENTIFIER9
 {
     char            Driver[MAX_DEVICE_IDENTIFIER_STRING];
     char            Description[MAX_DEVICE_IDENTIFIER_STRING];
     char            DeviceName[32];         /* Device name for GDI (ex.
\\.\DISPLAY1) */

 //#ifdef _WIN32
     int   DriverVersion;          /* Defined for 32 bit components */
 //#else
 //    DWORD           DriverVersionLowPart;   ///* Defined for 16 bit
driver components*/
 //    DWORD           DriverVersionHighPart;
 //#endif

     DWORD           VendorId;
     DWORD           DeviceId;
     DWORD           SubSysId;
     DWORD           Revision;

     GUID            DeviceIdentifier;

     DWORD           WHQLLevel;

 }
 alias _D3DADAPTER_IDENTIFIER9 D3DADAPTER_IDENTIFIER9;


 /* Raster Status structure returned by GetRasterStatus */
 struct _D3DRASTER_STATUS
 {
     BOOL            InVBlank;
     UINT            ScanLine;
 }
 alias _D3DRASTER_STATUS D3DRASTER_STATUS;



 /* Debug monitor tokens (DEBUG only)

    Note that if D3DRS_DEBUGMONITORTOKEN is set, the call is treated as
    passing a token to the debug monitor.  For example, if, after passing
    D3DDMT_ENABLE/DISABLE to D3DRS_DEBUGMONITORTOKEN other token values
    are passed in, the enabled/disabled state of the debug
    monitor will still persist.

    The debug monitor defaults to enabled.

    Calling GetRenderState on D3DRS_DEBUGMONITORTOKEN is not of any use.
 */
 enum _D3DDEBUGMONITORTOKENS
 {
     D3DDMT_ENABLE            = 0,    // enable debug monitor
     D3DDMT_DISABLE           = 1,    // disable debug monitor
     D3DDMT_FORCE_DWORD     = 0x7fffffff,
 }
 alias _D3DDEBUGMONITORTOKENS D3DDEBUGMONITORTOKENS;

 // Async feedback

 enum _D3DQUERYTYPE {
     D3DQUERYTYPE_VCACHE                 = 4, /* D3DISSUE_END */
     D3DQUERYTYPE_RESOURCEMANAGER        = 5, /* D3DISSUE_END */
     D3DQUERYTYPE_VERTEXSTATS            = 6, /* D3DISSUE_END */
     D3DQUERYTYPE_EVENT                  = 8, /* D3DISSUE_END */
     D3DQUERYTYPE_OCCLUSION              = 9, /* D3DISSUE_BEGIN,
D3DISSUE_END */
 }
 alias _D3DQUERYTYPE D3DQUERYTYPE;

 // Flags field for Issue
 const int D3DISSUE_END   = (1 << 0); // Tells the runtime to issue the end
of a query, changing it's state to "non-signaled".
 const int D3DISSUE_BEGIN  = (1 << 1); // Tells the runtime to issue the
beginng of a query.


 // Flags field for GetData
 const int D3DGETDATA_FLUSH  = (1 << 0); // Tells the runtime to flush if
the query is outstanding.


 struct _D3DRESOURCESTATS
 {
 // Data collected since last Present()
     BOOL    bThrashing;             /* indicates if thrashing */
     DWORD   ApproxBytesDownloaded;  /* Approximate number of bytes
downloaded by resource manager */
     DWORD   NumEvicts;              /* number of objects evicted */
     DWORD   NumVidCreates;          /* number of objects created in video
memory */
     DWORD   LastPri;                /* priority of last object evicted */
     DWORD   NumUsed;                /* number of objects set to the device
*/
     DWORD   NumUsedInVidMem;        /* number of objects set to the device,
which are already in video memory */
 // Persistent data
     DWORD   WorkingSet;             /* number of objects in video memory */
     DWORD   WorkingSetBytes;        /* number of bytes in video memory */
     DWORD   TotalManaged;           /* total number of managed objects */
     DWORD   TotalBytes;             /* total number of bytes of managed
objects */
 }
 alias _D3DRESOURCESTATS D3DRESOURCESTATS;

 const int D3DRTYPECOUNT = D3DRESOURCETYPE.D3DRTYPE_INDEXBUFFER + 1;

 struct _D3DDEVINFO_RESOURCEMANAGER
 {
     D3DRESOURCESTATS    stats[D3DRTYPECOUNT];
 }
 alias _D3DDEVINFO_RESOURCEMANAGER D3DDEVINFO_RESOURCEMANAGER;
 alias D3DDEVINFO_RESOURCEMANAGER* LPD3DDEVINFO_RESOURCEMANAGER;

 struct _D3DDEVINFO_D3DVERTEXSTATS
 {
     DWORD   NumRenderedTriangles;       /* total number of triangles that
are not clipped in this frame */
     DWORD   NumExtraClippingTriangles;  /* Number of new triangles
generated by clipping */
 }
 alias _D3DDEVINFO_D3DVERTEXSTATS D3DDEVINFO_D3DVERTEXSTATS;
 alias D3DDEVINFO_D3DVERTEXSTATS* LPD3DDEVINFO_D3DVERTEXSTATS;


 struct _D3DDEVINFO_VCACHE {
     DWORD   Pattern;                    /* bit pattern, return value must
be FOUR_CC(?C?, ?A?, ?C?, ?H?) */
     DWORD   OptMethod;                  /* optimization method 0 means
longest strips, 1 means vertex cache based */
     DWORD   CacheSize;                  /* cache size to optimize for
(only required if type is 1) */
     DWORD   MagicNumber;                /* used to determine when to
restart strips (only required if type is 1)*/
 }
 alias _D3DDEVINFO_VCACHE D3DDEVINFO_VCACHE;
 alias D3DDEVINFO_VCACHE* LPD3DDEVINFO_VCACHE;

 } // align (4)


//} /* (DIRECT3D_VERSION) */

Aug 31 2004
prev sibling parent reply J C Calvarese <jcc7 cox.net> writes:
aelmetwaly wrote:
 Hi there,
 I translated d3d9.h and d3d9caps.h and d3d9types.h into d but when i compile
 my program I can't simply link with d3d9.lib and dxguid.lib. the linker give
 invalid lib error :-(

Non-Digital Mars .libs will do that.
 It's a major drawback for d language that it doesn't support microsoft libs.

Yes. Some of us have already discussed this at dsource: http://www.dsource.org/forums/viewtopic.php?t=288 There are a couple theories for a way around this, but I don't think anyone's tested them yet.
 But these are the files for those interseted. I posted here because I don't

Thanks for posting.
 know how to add it to dsource. they have no automatic registeration of
 projects.

If you PM Brad at dsource, he'll likely either give you access to an existing project or create a new one for you. By the way, I think someone's already ported D3D9 bindings to D: http://svn.dsource.org/svn/projects/bindings/trunk/ -- Justin (a/k/a jcc7) http://jcc_7.tripod.com/d/
Aug 31 2004
parent reply Brad Anderson <brad dsource.dot.org> writes:
J C Calvarese wrote:
 aelmetwaly wrote:
 
 Hi there,
 I translated d3d9.h and d3d9caps.h and d3d9types.h into d but when i 
 compile
 my program I can't simply link with d3d9.lib and dxguid.lib. the 
 linker give
 invalid lib error :-(

Non-Digital Mars .libs will do that.
 It's a major drawback for d language that it doesn't support microsoft 
 libs.

Yes. Some of us have already discussed this at dsource: http://www.dsource.org/forums/viewtopic.php?t=288 There are a couple theories for a way around this, but I don't think anyone's tested them yet.
 But these are the files for those interseted. I posted here because I 
 don't

Thanks for posting.
 know how to add it to dsource. they have no automatic registeration of
 projects.

If you PM Brad at dsource, he'll likely either give you access to an existing project or create a new one for you. By the way, I think someone's already ported D3D9 bindings to D: http://svn.dsource.org/svn/projects/bindings/trunk/

SVN (Subversion) client.
Aug 31 2004
parent J C Calvarese <jcc7 cox.net> writes:
Brad Anderson wrote:
 J C Calvarese wrote:
 
 If you PM Brad at dsource, he'll likely either give you access to an 
 existing project or create a new one for you.

 By the way, I think someone's already ported D3D9 bindings to D:

 http://svn.dsource.org/svn/projects/bindings/trunk/

SVN (Subversion) client.

Cool. That's good to know. -- Justin (a/k/a jcc7) http://jcc_7.tripod.com/d/
Aug 31 2004