1 module directx.d3d9; 2 /*==========================================================================; 3 * 4 * Copyright (C) Microsoft Corporation. All Rights Reserved. 5 * 6 * File: d3d9.h 7 * Content: Direct3D include file 8 * 9 ****************************************************************************/ 10 11 import directx.win32; 12 import directx.d3dcommon; 13 14 struct D3DVIEWPORT9 { 15 DWORD X; 16 DWORD Y; /* Viewport Top left */ 17 DWORD Width; 18 DWORD Height; /* Viewport Dimensions */ 19 float MinZ; /* Min/max of clip Volume */ 20 float MaxZ; 21 } 22 23 struct D3DCLIPSTATUS9 { 24 DWORD ClipUnion; 25 DWORD ClipIntersection; 26 } 27 28 struct D3DMATERIAL9 { 29 D3DCOLORVALUE Diffuse; /* Diffuse color RGBA */ 30 D3DCOLORVALUE Ambient; /* Ambient color RGB */ 31 D3DCOLORVALUE Specular; /* Specular 'shininess' */ 32 D3DCOLORVALUE Emissive; /* Emissive color RGB */ 33 float Power; /* Sharpness if specular highlight */ 34 } 35 36 struct D3DLIGHT9 { 37 D3DLIGHTTYPE Type; /* Type of light source */ 38 D3DCOLORVALUE Diffuse; /* Diffuse color of light */ 39 D3DCOLORVALUE Specular; /* Specular color of light */ 40 D3DCOLORVALUE Ambient; /* Ambient color of light */ 41 D3DVECTOR Position; /* Position in world space */ 42 D3DVECTOR Direction; /* Direction in world space */ 43 float Range; /* Cutoff range */ 44 float Falloff; /* Falloff */ 45 float Attenuation0; /* Constant attenuation */ 46 float Attenuation1; /* Linear attenuation */ 47 float Attenuation2; /* Quadratic attenuation */ 48 float Theta; /* Inner angle of spotlight cone */ 49 float Phi; /* Outer angle of spotlight cone */ 50 } 51 52 struct D3DPRESENTSTATS { 53 UINT PresentCount; 54 UINT PresentRefreshCount; 55 UINT SyncRefreshCount; 56 LARGE_INTEGER SyncQPCTime; 57 LARGE_INTEGER SyncGPUTime; 58 } 59 60 alias DWORD D3DSCANLINEORDERING; 61 enum : D3DSCANLINEORDERING { 62 D3DSCANLINEORDERING_UNKNOWN = 0, 63 D3DSCANLINEORDERING_PROGRESSIVE = 1, 64 D3DSCANLINEORDERING_INTERLACED = 2, 65 } 66 67 struct D3DDISPLAYMODEEX { 68 UINT Size; 69 UINT Width; 70 UINT Height; 71 UINT RefreshRate; 72 D3DFORMAT Format; 73 D3DSCANLINEORDERING ScanLineOrdering; 74 } 75 76 struct D3DDISPLAYMODEFILTER { 77 UINT Size; 78 D3DFORMAT Format; 79 D3DSCANLINEORDERING ScanLineOrdering; 80 } 81 82 alias DWORD D3DDISPLAYROTATION; 83 enum : D3DDISPLAYROTATION { 84 D3DDISPLAYROTATION_IDENTITY = 1, // No rotation. 85 D3DDISPLAYROTATION_90 = 2, // Rotated 90 degrees. 86 D3DDISPLAYROTATION_180 = 3, // Rotated 180 degrees. 87 D3DDISPLAYROTATION_270 = 4 // Rotated 270 degrees. 88 } 89 90 alias D3DTEXTUREFILTERTYPE = DWORD; 91 enum : D3DTEXTUREFILTERTYPE { 92 D3DTEXF_NONE = 0, // filtering disabled (valid for mip filter only) 93 D3DTEXF_POINT = 1, // nearest 94 D3DTEXF_LINEAR = 2, // linear interpolation 95 D3DTEXF_ANISOTROPIC = 3, // anisotropic 96 D3DTEXF_PYRAMIDALQUAD = 6, // 4-sample tent 97 D3DTEXF_GAUSSIANQUAD = 7, // 4-sample gaussian 98 /* D3D9Ex only -- */ 99 D3DTEXF_CONVOLUTIONMONO = 8, // Convolution filter for monochrome textures 100 /* -- D3D9Ex only */ 101 } 102 103 /* 104 * State enumerants for per-sampler texture processing. 105 */ 106 alias D3DSAMPLERSTATETYPE = DWORD; 107 enum : D3DSAMPLERSTATETYPE { 108 D3DSAMP_ADDRESSU = 1, /* D3DTEXTUREADDRESS for U coordinate */ 109 D3DSAMP_ADDRESSV = 2, /* D3DTEXTUREADDRESS for V coordinate */ 110 D3DSAMP_ADDRESSW = 3, /* D3DTEXTUREADDRESS for W coordinate */ 111 D3DSAMP_BORDERCOLOR = 4, /* D3DCOLOR */ 112 D3DSAMP_MAGFILTER = 5, /* D3DTEXTUREFILTER filter to use for magnification */ 113 D3DSAMP_MINFILTER = 6, /* D3DTEXTUREFILTER filter to use for minification */ 114 D3DSAMP_MIPFILTER = 7, /* D3DTEXTUREFILTER filter to use between mipmaps during minification */ 115 D3DSAMP_MIPMAPLODBIAS = 8, /* float Mipmap LOD bias */ 116 D3DSAMP_MAXMIPLEVEL = 9, /* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) */ 117 D3DSAMP_MAXANISOTROPY = 10, /* DWORD maximum anisotropy */ 118 D3DSAMP_SRGBTEXTURE = 11, /* Default = 0 (which means Gamma 1.0, 119 no correction required.) else correct for 120 Gamma = 2.2 */ 121 D3DSAMP_ELEMENTINDEX = 12, /* When multi-element texture is assigned to sampler, this 122 indicates which element index to use. Default = 0. */ 123 D3DSAMP_DMAPOFFSET = 13, /* Offset in vertices in the pre-sampled displacement map. 124 Only valid for D3DDMAPSAMPLER sampler */ 125 } 126 127 alias DWORD D3DQUERYTYPE; 128 enum : D3DQUERYTYPE { 129 D3DQUERYTYPE_VCACHE = 4, /* D3DISSUE_END */ 130 D3DQUERYTYPE_RESOURCEMANAGER = 5, /* D3DISSUE_END */ 131 D3DQUERYTYPE_VERTEXSTATS = 6, /* D3DISSUE_END */ 132 D3DQUERYTYPE_EVENT = 8, /* D3DISSUE_END */ 133 D3DQUERYTYPE_OCCLUSION = 9, /* D3DISSUE_BEGIN, D3DISSUE_END */ 134 D3DQUERYTYPE_TIMESTAMP = 10, /* D3DISSUE_END */ 135 D3DQUERYTYPE_TIMESTAMPDISJOINT = 11, /* D3DISSUE_BEGIN, D3DISSUE_END */ 136 D3DQUERYTYPE_TIMESTAMPFREQ = 12, /* D3DISSUE_END */ 137 D3DQUERYTYPE_PIPELINETIMINGS = 13, /* D3DISSUE_BEGIN, D3DISSUE_END */ 138 D3DQUERYTYPE_INTERFACETIMINGS = 14, /* D3DISSUE_BEGIN, D3DISSUE_END */ 139 D3DQUERYTYPE_VERTEXTIMINGS = 15, /* D3DISSUE_BEGIN, D3DISSUE_END */ 140 D3DQUERYTYPE_PIXELTIMINGS = 16, /* D3DISSUE_BEGIN, D3DISSUE_END */ 141 D3DQUERYTYPE_BANDWIDTHTIMINGS = 17, /* D3DISSUE_BEGIN, D3DISSUE_END */ 142 D3DQUERYTYPE_CACHEUTILIZATION = 18, /* D3DISSUE_BEGIN, D3DISSUE_END */ 143 /* D3D9Ex only -- */ 144 D3DQUERYTYPE_MEMORYPRESSURE = 19, /* D3DISSUE_BEGIN, D3DISSUE_END */ 145 } 146 147 alias D3DCOMPOSERECTSOP = DWORD; 148 enum : D3DCOMPOSERECTSOP { 149 D3DCOMPOSERECTS_COPY = 1, 150 D3DCOMPOSERECTS_OR = 2, 151 D3DCOMPOSERECTS_AND = 3, 152 D3DCOMPOSERECTS_NEG = 4 153 } 154 155 struct D3DVERTEXELEMENT9 { 156 WORD Stream; // Stream index 157 WORD Offset; // Offset in the stream in bytes 158 BYTE Type; // Data type 159 BYTE Method; // Processing method 160 BYTE Usage; // Semantics 161 BYTE UsageIndex; // Semantic index 162 } 163 164 extern (C++) interface IDirect3D9 : IUnknown { 165 HRESULT RegisterSoftwareDevice(void* pInitializeFunction); 166 UINT GetAdapterCount(); 167 HRESULT GetAdapterIdentifier(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier); 168 UINT GetAdapterModeCount(UINT Adapter,D3DFORMAT Format); 169 HRESULT EnumAdapterModes(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode); 170 HRESULT GetAdapterDisplayMode(UINT Adapter,D3DDISPLAYMODE* pMode); 171 HRESULT CheckDeviceType(UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed); 172 HRESULT CheckDeviceFormat(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat); 173 HRESULT CheckDeviceMultiSampleType(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels); 174 HRESULT CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat); 175 HRESULT CheckDeviceFormatConversion(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SourceFormat,D3DFORMAT TargetFormat); 176 HRESULT GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps); 177 HMONITOR GetAdapterMonitor(UINT Adapter); 178 HRESULT CreateDevice(UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9* ppReturnedDeviceInterface); 179 } 180 181 extern (C++) interface IDirect3DDevice9 : IUnknown { 182 HRESULT TestCooperativeLevel(); 183 UINT GetAvailableTextureMem(); 184 HRESULT EvictManagedResources(); 185 HRESULT GetDirect3D(IDirect3D9* ppD3D9); 186 HRESULT GetDeviceCaps(D3DCAPS9* pCaps); 187 HRESULT GetDisplayMode(UINT iSwapChain,D3DDISPLAYMODE* pMode); 188 HRESULT GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters); 189 HRESULT SetCursorProperties(UINT XHotSpot,UINT YHotSpot,IDirect3DSurface9 pCursorBitmap); 190 void SetCursorPosition(int X,int Y,DWORD Flags); 191 BOOL ShowCursor(BOOL bShow); 192 HRESULT CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain9* pSwapChain); 193 HRESULT GetSwapChain(UINT iSwapChain,IDirect3DSwapChain9* pSwapChain); 194 UINT GetNumberOfSwapChains(); 195 HRESULT Reset(D3DPRESENT_PARAMETERS* pPresentationParameters); 196 HRESULT Present(const(RECT)* pSourceRect,const(RECT)* pDestRect,HWND hDestWindowOverride,const(RGNDATA)* pDirtyRegion); 197 HRESULT GetBackBuffer(UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9* ppBackBuffer); 198 HRESULT GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus); 199 HRESULT SetDialogBoxMode(BOOL bEnableDialogs); 200 void SetGammaRamp(UINT iSwapChain,DWORD Flags,const(D3DGAMMARAMP)* pRamp); 201 void GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp); 202 HRESULT CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9* ppTexture,HANDLE* pSharedHandle); 203 HRESULT CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9* ppVolumeTexture,HANDLE* pSharedHandle); 204 HRESULT CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9* ppCubeTexture,HANDLE* pSharedHandle); 205 HRESULT CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9* ppVertexBuffer,HANDLE* pSharedHandle); 206 HRESULT CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9* ppIndexBuffer,HANDLE* pSharedHandle); 207 HRESULT CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle); 208 HRESULT CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle); 209 HRESULT UpdateSurface(IDirect3DSurface9 pSourceSurface,const(RECT)* pSourceRect,IDirect3DSurface9 pDestinationSurface,const(POINT)* pDestPoint); 210 HRESULT UpdateTexture(IDirect3DBaseTexture9 pSourceTexture,IDirect3DBaseTexture9 pDestinationTexture); 211 HRESULT GetRenderTargetData(IDirect3DSurface9 pRenderTarget,IDirect3DSurface9 pDestSurface); 212 HRESULT GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9 pDestSurface); 213 HRESULT StretchRect(IDirect3DSurface9 pSourceSurface,const(RECT)* pSourceRect,IDirect3DSurface9 pDestSurface,const(RECT)* pDestRect,D3DTEXTUREFILTERTYPE Filter); 214 HRESULT ColorFill(IDirect3DSurface9 pSurface,const(RECT)* pRect,D3DCOLOR color); 215 HRESULT CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle); 216 HRESULT SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9 pRenderTarget); 217 HRESULT GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* ppRenderTarget); 218 HRESULT SetDepthStencilSurface(IDirect3DSurface9 pNewZStencil); 219 HRESULT GetDepthStencilSurface(IDirect3DSurface9* ppZStencilSurface); 220 HRESULT BeginScene(); 221 HRESULT EndScene(); 222 HRESULT Clear(DWORD Count,const(D3DRECT)* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil); 223 HRESULT SetTransform(D3DTRANSFORMSTATETYPE State,const(D3DMATRIX)* pMatrix); 224 HRESULT GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix); 225 HRESULT MultiplyTransform(D3DTRANSFORMSTATETYPE,const(D3DMATRIX)*); 226 HRESULT SetViewport(const(D3DVIEWPORT9)* pViewport); 227 HRESULT GetViewport(D3DVIEWPORT9* pViewport); 228 HRESULT SetMaterial(const(D3DMATERIAL9)* pMaterial); 229 HRESULT GetMaterial(D3DMATERIAL9* pMaterial); 230 HRESULT SetLight(DWORD Index,const(D3DLIGHT9)*); 231 HRESULT GetLight(DWORD Index,D3DLIGHT9*); 232 HRESULT LightEnable(DWORD Index,BOOL Enable); 233 HRESULT GetLightEnable(DWORD Index,BOOL* pEnable); 234 HRESULT SetClipPlane(DWORD Index,const(float)* pPlane); 235 HRESULT GetClipPlane(DWORD Index,float* pPlane); 236 HRESULT SetRenderState(D3DRENDERSTATETYPE State,DWORD Value); 237 HRESULT GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue); 238 HRESULT CreateStateBlock(D3DSTATEBLOCKTYPE Type,IDirect3DStateBlock9* ppSB); 239 HRESULT BeginStateBlock(); 240 HRESULT EndStateBlock(IDirect3DStateBlock9* ppSB); 241 HRESULT SetClipStatus(const(D3DCLIPSTATUS9)* pClipStatus); 242 HRESULT GetClipStatus(D3DCLIPSTATUS9* pClipStatus); 243 HRESULT GetTexture(DWORD Stage,IDirect3DBaseTexture9* ppTexture); 244 HRESULT SetTexture(DWORD Stage,IDirect3DBaseTexture9 pTexture); 245 HRESULT GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue); 246 HRESULT SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value); 247 HRESULT GetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue); 248 HRESULT SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value); 249 HRESULT ValidateDevice(DWORD* pNumPasses); 250 HRESULT SetPaletteEntries(UINT PaletteNumber,const(PALETTEENTRY)* pEntries); 251 HRESULT GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries); 252 HRESULT SetCurrentTexturePalette(UINT PaletteNumber); 253 HRESULT GetCurrentTexturePalette(UINT *PaletteNumber); 254 HRESULT SetScissorRect(const(RECT)* pRect); 255 HRESULT GetScissorRect(RECT* pRect); 256 HRESULT SetSoftwareVertexProcessing(BOOL bSoftware); 257 BOOL GetSoftwareVertexProcessing(); 258 HRESULT SetNPatchMode(float nSegments); 259 float GetNPatchMode(); 260 HRESULT DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount); 261 HRESULT DrawIndexedPrimitive(D3DPRIMITIVETYPE,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount); 262 HRESULT DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,const(void)* pVertexStreamZeroData,UINT VertexStreamZeroStride); 263 HRESULT DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,const(void)* pIndexData,D3DFORMAT IndexDataFormat,const(void)* pVertexStreamZeroData,UINT VertexStreamZeroStride); 264 HRESULT ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer9 pDestBuffer,IDirect3DVertexDeclaration9 pVertexDecl,DWORD Flags); 265 HRESULT CreateVertexDeclaration(const(D3DVERTEXELEMENT9)* pVertexElements,IDirect3DVertexDeclaration9* ppDecl); 266 HRESULT SetVertexDeclaration(IDirect3DVertexDeclaration9 pDecl); 267 HRESULT GetVertexDeclaration(IDirect3DVertexDeclaration9* ppDecl); 268 HRESULT SetFVF(DWORD FVF); 269 HRESULT GetFVF(DWORD* pFVF); 270 HRESULT CreateVertexShader(const(DWORD)* pFunction,IDirect3DVertexShader9* ppShader); 271 HRESULT SetVertexShader(IDirect3DVertexShader9 pShader); 272 HRESULT GetVertexShader(IDirect3DVertexShader9* ppShader); 273 HRESULT SetVertexShaderConstantF(UINT StartRegister,const(float)* pConstantData,UINT Vector4fCount); 274 HRESULT GetVertexShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount); 275 HRESULT SetVertexShaderConstantI(UINT StartRegister,const(int)* pConstantData,UINT Vector4iCount); 276 HRESULT GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount); 277 HRESULT SetVertexShaderConstantB(UINT StartRegister,const(BOOL)* pConstantData,UINT BoolCount); 278 HRESULT GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount); 279 HRESULT SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9 pStreamData,UINT OffsetInBytes,UINT Stride); 280 HRESULT GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* ppStreamData,UINT* pOffsetInBytes,UINT* pStride); 281 HRESULT SetStreamSourceFreq(UINT StreamNumber,UINT Setting); 282 HRESULT GetStreamSourceFreq(UINT StreamNumber,UINT* pSetting); 283 HRESULT SetIndices(IDirect3DIndexBuffer9 pIndexData); 284 HRESULT GetIndices(IDirect3DIndexBuffer9* ppIndexData); 285 HRESULT CreatePixelShader(const(DWORD)* pFunction,IDirect3DPixelShader9* ppShader); 286 HRESULT SetPixelShader(IDirect3DPixelShader9 pShader); 287 HRESULT GetPixelShader(IDirect3DPixelShader9* ppShader); 288 HRESULT SetPixelShaderConstantF(UINT StartRegister,const(float)* pConstantData,UINT Vector4fCount); 289 HRESULT GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount); 290 HRESULT SetPixelShaderConstantI(UINT StartRegister,const(int)* pConstantData,UINT Vector4iCount); 291 HRESULT GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount); 292 HRESULT SetPixelShaderConstantB(UINT StartRegister,const(BOOL)* pConstantData,UINT BoolCount); 293 HRESULT GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount); 294 HRESULT DrawRectPatch(UINT Handle,const(float)* pNumSegs,const(D3DRECTPATCH_INFO)* pRectPatchInfo); 295 HRESULT DrawTriPatch(UINT Handle,const(float)* pNumSegs,const(D3DTRIPATCH_INFO)* pTriPatchInfo); 296 HRESULT DeletePatch(UINT Handle); 297 HRESULT CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9* ppQuery); 298 HRESULT SetConvolutionMonoKernel(UINT width,UINT height,float* rows,float* columns); 299 HRESULT ComposeRects(IDirect3DSurface9 pSrc,IDirect3DSurface9 pDst,IDirect3DVertexBuffer9 pSrcRectDescs,UINT NumRects,IDirect3DVertexBuffer9 pDstRectDescs,D3DCOMPOSERECTSOP Operation,int Xoffset,int Yoffset); 300 HRESULT PresentEx(const(RECT)* pSourceRect,const(RECT)* pDestRect,HWND hDestWindowOverride,const(RGNDATA)* pDirtyRegion,DWORD dwFlags); 301 HRESULT GetGPUThreadPriority(INT* pPriority); 302 HRESULT SetGPUThreadPriority(INT Priority); 303 HRESULT WaitForVBlank(UINT iSwapChain); 304 HRESULT CheckResourceResidency(IDirect3DResource9* pResourceArray,UINT32 NumResources); 305 HRESULT SetMaximumFrameLatency(UINT MaxLatency); 306 HRESULT GetMaximumFrameLatency(UINT* pMaxLatency); 307 HRESULT CheckDeviceState(HWND hDestinationWindow); 308 } 309 310 extern (C++) interface IDirect3DStateBlock9 : IUnknown { 311 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 312 HRESULT Capture(); 313 HRESULT Apply(); 314 } 315 316 mixin(uuid!(IDirect3DSwapChain9, "794950f2-adfc-458a-905e-10a10b0b503b")); 317 extern (C++) interface IDirect3DSwapChain9 : IUnknown { 318 HRESULT Present(const(RECT)* pSourceRect,const(RECT)* pDestRect,HWND hDestWindowOverride,const(RGNDATA)* pDirtyRegion,DWORD dwFlags); 319 HRESULT GetFrontBufferData(IDirect3DSurface9 pDestSurface); 320 HRESULT GetBackBuffer(UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9* ppBackBuffer); 321 HRESULT GetRasterStatus(D3DRASTER_STATUS* pRasterStatus); 322 HRESULT GetDisplayMode(D3DDISPLAYMODE* pMode); 323 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 324 HRESULT GetPresentParameters(D3DPRESENT_PARAMETERS* pPresentationParameters); 325 } 326 327 extern (C++) interface IDirect3DResource9 : IUnknown { 328 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 329 HRESULT SetPrivateData(REFGUID refguid,const(void)* pData,DWORD SizeOfData,DWORD Flags); 330 HRESULT GetPrivateData(REFGUID refguid,void* pData,DWORD* pSizeOfData); 331 HRESULT FreePrivateData(REFGUID refguid); 332 DWORD SetPriority(DWORD PriorityNew); 333 DWORD GetPriority(); 334 void PreLoad(); 335 D3DRESOURCETYPE GetType(); 336 } 337 338 extern (C++) interface IDirect3DVertexDeclaration9 : IUnknown { 339 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 340 HRESULT GetDeclaration(D3DVERTEXELEMENT9* pElement,UINT* pNumElements); 341 } 342 343 extern (C++) interface IDirect3DVertexShader9 : IUnknown { 344 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 345 HRESULT GetFunction(void*,UINT* pSizeOfData); 346 } 347 348 extern (C++) interface IDirect3DPixelShader9 : IUnknown { 349 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 350 HRESULT GetFunction(void*,UINT* pSizeOfData); 351 } 352 353 extern (C++) interface IDirect3DBaseTexture9 : IDirect3DResource9 { 354 DWORD SetLOD(DWORD LODNew); 355 DWORD GetLOD(); 356 DWORD GetLevelCount(); 357 HRESULT SetAutoGenFilterType(D3DTEXTUREFILTERTYPE FilterType); 358 D3DTEXTUREFILTERTYPE GetAutoGenFilterType(); 359 void GenerateMipSubLevels(); 360 } 361 362 extern (C++) interface IDirect3DTexture9 : IDirect3DBaseTexture9 { 363 HRESULT GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc); 364 HRESULT GetSurfaceLevel(UINT Level,IDirect3DSurface9* ppSurfaceLevel); 365 HRESULT LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,const(RECT)* pRect,DWORD Flags); 366 HRESULT UnlockRect(UINT Level); 367 HRESULT AddDirtyRect(const(RECT)* pDirtyRect); 368 } 369 370 extern (C++) interface IDirect3DVolumeTexture9 : IDirect3DBaseTexture9 { 371 HRESULT GetLevelDesc(UINT Level,D3DVOLUME_DESC *pDesc); 372 HRESULT GetVolumeLevel(UINT Level,IDirect3DVolume9* ppVolumeLevel); 373 HRESULT LockBox(UINT Level,D3DLOCKED_BOX* pLockedVolume,const(D3DBOX)* pBox,DWORD Flags); 374 HRESULT UnlockBox(UINT Level); 375 HRESULT AddDirtyBox(const(D3DBOX)* pDirtyBox); 376 } 377 378 extern (C++) interface IDirect3DCubeTexture9 : IDirect3DBaseTexture9 { 379 HRESULT GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc); 380 HRESULT GetCubeMapSurface(D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9* ppCubeMapSurface); 381 HRESULT LockRect(D3DCUBEMAP_FACES FaceType,UINT Level,D3DLOCKED_RECT* pLockedRect,const(RECT)* pRect,DWORD Flags); 382 HRESULT UnlockRect(D3DCUBEMAP_FACES FaceType,UINT Level); 383 HRESULT AddDirtyRect(D3DCUBEMAP_FACES FaceType,const(RECT)* pDirtyRect); 384 } 385 386 struct D3DVERTEXBUFFER_DESC { 387 D3DFORMAT Format; 388 D3DRESOURCETYPE Type; 389 DWORD Usage; 390 D3DPOOL Pool; 391 UINT Size; 392 DWORD FVF; 393 } 394 395 struct D3DINDEXBUFFER_DESC { 396 D3DFORMAT Format; 397 D3DRESOURCETYPE Type; 398 DWORD Usage; 399 D3DPOOL Pool; 400 UINT Size; 401 } 402 403 extern (C++) interface IDirect3DVertexBuffer9 : IDirect3DResource9 { 404 HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags); 405 HRESULT Unlock(); 406 HRESULT GetDesc(D3DVERTEXBUFFER_DESC *pDesc); 407 } 408 409 extern (C++) interface IDirect3DIndexBuffer9 : IDirect3DResource9 { 410 HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags); 411 HRESULT Unlock(); 412 HRESULT GetDesc(D3DINDEXBUFFER_DESC *pDesc); 413 } 414 415 extern (C++) interface IDirect3DSurface9 : IDirect3DResource9 { 416 HRESULT GetContainer(REFIID riid,void** ppContainer); 417 HRESULT GetDesc(D3DSURFACE_DESC *pDesc); 418 HRESULT LockRect(D3DLOCKED_RECT* pLockedRect,const(RECT)* pRect,DWORD Flags); 419 HRESULT UnlockRect(); 420 HRESULT GetDC(HDC *phdc); 421 HRESULT ReleaseDC(HDC hdc); 422 } 423 424 extern (C++) interface IDirect3DVolume9 : IUnknown { 425 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 426 HRESULT SetPrivateData(REFGUID refguid,const(void)* pData,DWORD SizeOfData,DWORD Flags); 427 HRESULT GetPrivateData(REFGUID refguid,void* pData,DWORD* pSizeOfData); 428 HRESULT FreePrivateData(REFGUID refguid); 429 HRESULT GetContainer(REFIID riid,void** ppContainer); 430 HRESULT GetDesc(D3DVOLUME_DESC *pDesc); 431 HRESULT LockBox(D3DLOCKED_BOX * pLockedVolume,const(D3DBOX)* pBox,DWORD Flags); 432 HRESULT UnlockBox(); 433 } 434 435 extern (C++) interface IDirect3DQuery9 : IUnknown { 436 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 437 D3DQUERYTYPE GetType(); 438 DWORD GetDataSize(); 439 HRESULT Issue(DWORD dwIssueFlags); 440 HRESULT GetData(void* pData,DWORD dwSize,DWORD dwGetDataFlags); 441 } 442 443 extern (C++) interface IDirect3D9Ex : IDirect3D9 { 444 UINT GetAdapterModeCountEx(UINT Adapter,const(D3DDISPLAYMODEFILTER)* pFilter ); 445 HRESULT EnumAdapterModesEx(UINT Adapter,const(D3DDISPLAYMODEFILTER)* pFilter,UINT Mode,D3DDISPLAYMODEEX* pMode); 446 HRESULT GetAdapterDisplayModeEx(UINT Adapter,D3DDISPLAYMODEEX* pMode,D3DDISPLAYROTATION* pRotation); 447 HRESULT CreateDeviceEx(UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,D3DDISPLAYMODEEX* pFullscreenDisplayMode,IDirect3DDevice9Ex* ppReturnedDeviceInterface); 448 HRESULT GetAdapterLUID(UINT Adapter,LUID * pLUID); 449 } 450 451 extern (C++) interface IDirect3DDevice9Ex : IDirect3DDevice9 { 452 HRESULT CreateRenderTargetEx(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle,DWORD Usage); 453 HRESULT CreateOffscreenPlainSurfaceEx(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle,DWORD Usage); 454 HRESULT CreateDepthStencilSurfaceEx(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle,DWORD Usage); 455 HRESULT ResetEx(D3DPRESENT_PARAMETERS* pPresentationParameters,D3DDISPLAYMODEEX *pFullscreenDisplayMode); 456 HRESULT GetDisplayModeEx(UINT iSwapChain,D3DDISPLAYMODEEX* pMode,D3DDISPLAYROTATION* pRotation); 457 } 458 459 extern (C++) interface IDirect3DSwapChain9Ex : IDirect3DSwapChain9 { 460 HRESULT GetLastPresentCount(UINT* pLastPresentCount); 461 HRESULT GetPresentStats(D3DPRESENTSTATS* pPresentationStatistics); 462 HRESULT GetDisplayModeEx(D3DDISPLAYMODEEX* pMode,D3DDISPLAYROTATION* pRotation); 463 } 464 465 extern (C++) interface IDirect3D9ExOverlayExtension : IUnknown { 466 HRESULT CheckDeviceOverlayType(UINT Adapter,D3DDEVTYPE DevType,UINT OverlayWidth,UINT OverlayHeight,D3DFORMAT OverlayFormat,D3DDISPLAYMODEEX* pDisplayMode,D3DDISPLAYROTATION DisplayRotation,D3DOVERLAYCAPS* pOverlayCaps); 467 } 468 469 extern (C++) interface IDirect3DDevice9Video : IUnknown { 470 HRESULT GetContentProtectionCaps(const(GUID)* pCryptoType,const(GUID)* pDecodeProfile,D3DCONTENTPROTECTIONCAPS* pCaps); 471 HRESULT CreateAuthenticatedChannel(D3DAUTHENTICATEDCHANNELTYPE ChannelType,IDirect3DAuthenticatedChannel9* ppAuthenticatedChannel,HANDLE* pChannelHandle); 472 HRESULT CreateCryptoSession(const(GUID)* pCryptoType,const(GUID)* pDecodeProfile,IDirect3DCryptoSession9* ppCryptoSession,HANDLE* pCryptoHandle); 473 } 474 475 extern (C++) interface IDirect3DAuthenticatedChannel9 : IUnknown { 476 HRESULT GetCertificateSize(UINT* pCertificateSize); 477 HRESULT GetCertificate(UINT CertifacteSize,BYTE* ppCertificate); 478 HRESULT NegotiateKeyExchange(UINT DataSize,VOID* pData); 479 HRESULT Query(UINT InputSize,const(VOID)* pInput,UINT OutputSize,VOID* pOutput); 480 HRESULT Configure(UINT InputSize,const(VOID)* pInput,D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT* pOutput); 481 } 482 483 extern (C++) interface IDirect3DCryptoSession9 : IUnknown { 484 HRESULT GetCertificateSize(UINT* pCertificateSize); 485 HRESULT GetCertificate(UINT CertifacteSize,BYTE* ppCertificate); 486 HRESULT NegotiateKeyExchange(UINT DataSize,VOID* pData); 487 HRESULT EncryptionBlt(IDirect3DSurface9 pSrcSurface,IDirect3DSurface9 pDstSurface,UINT DstSurfaceSize,VOID* pIV); 488 HRESULT DecryptionBlt(IDirect3DSurface9 pSrcSurface,IDirect3DSurface9 pDstSurface,UINT SrcSurfaceSize,D3DENCRYPTED_BLOCK_INFO* pEncryptedBlockInfo,VOID* pContentKey,VOID* pIV); 489 HRESULT GetSurfacePitch(IDirect3DSurface9 pSrcSurface,UINT* pSurfacePitch); 490 HRESULT StartSessionKeyRefresh(VOID* pRandomNumber,UINT RandomNumberSize); 491 HRESULT FinishSessionKeyRefresh(); 492 HRESULT GetEncryptionBltKey(VOID* pReadbackKey,UINT KeySize); 493 } 494 495 struct D3DOVERLAYCAPS { 496 UINT Caps; 497 UINT MaxOverlayDisplayWidth; 498 UINT MaxOverlayDisplayHeight; 499 } 500 501 struct D3DCONTENTPROTECTIONCAPS { 502 DWORD Caps; 503 GUID KeyExchangeType; 504 UINT BufferAlignmentStart; 505 UINT BlockAlignmentSize; 506 ULONGLONG ProtectedMemorySize; 507 } 508 509 enum D3D_OMAC_SIZE = 16; 510 511 struct D3D_OMAC { 512 BYTE[D3D_OMAC_SIZE] Omac; 513 } 514 515 alias D3DAUTHENTICATEDCHANNELTYPE = DWORD; 516 enum : D3DAUTHENTICATEDCHANNELTYPE { 517 D3DAUTHENTICATEDCHANNEL_D3D9 = 1, 518 D3DAUTHENTICATEDCHANNEL_DRIVER_SOFTWARE = 2, 519 D3DAUTHENTICATEDCHANNEL_DRIVER_HARDWARE = 3, 520 } 521 522 struct D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT { 523 D3D_OMAC omac; 524 GUID ConfigureType; 525 HANDLE hChannel; 526 UINT SequenceNumber; 527 HRESULT ReturnCode; 528 } 529 530 struct D3DENCRYPTED_BLOCK_INFO { 531 UINT NumEncryptedBytesAtBeginning; 532 UINT NumBytesInSkipPattern; 533 UINT NumBytesInEncryptPattern; 534 } 535 536 __gshared LPDIRECT3DCREATE9 Direct3DCreate9; 537 __gshared LPDIRECT3DCREATE9EX Direct3DCreate9Ex; 538 539 extern (Windows) { 540 alias LPDIRECT3DCREATE9 = IDirect3D9 function(UINT SDKVersion); 541 542 alias LPDIRECT3DCREATE9EX = HRESULT function(UINT SDKVersion, 543 IDirect3D9Ex* ppD3D); 544 } 545 546 enum D3D_SDK_VERSION = 32;