Q 
Posted in reply to aelmetwaly
| 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) */
>
>
>
>
>
>
|
Permalink
Reply
