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