git.cworth.org Git - apitrace/blob - wrappers/d3d10stubs.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2012 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  *
  24  **************************************************************************/
  25
  26
  27 /*
  28  *Stubs for internal D3D10 functions.
  29  */
  30
  31
  32 #include "os.hpp"
  33
  34 #include "d3d10imports.hpp"
  35
  36
  37 static HMODULE g_hD3D10Module = NULL;
  38
  39
  40 static PROC
  41 _getD3D10ProcAddress(LPCSTR lpProcName) {
  42     if (!g_hD3D10Module) {
  43         char szDll[MAX_PATH] = {0};
  44         if (!GetSystemDirectoryA(szDll, MAX_PATH)) {
  45             return NULL;
  46         }
  47         strcat(szDll, "\\\\d3d10.dll");
  48         g_hD3D10Module = LoadLibraryA(szDll);
  49         if (!g_hD3D10Module) {
  50            return NULL;
  51         }
  52     }
  53     return GetProcAddress(g_hD3D10Module, lpProcName);
  54 }
  55
  56
  57 #ifndef NDEBUG
  58 #define LOG() os::log("%s\n", __FUNCTION__)
  59 #else
  60 #define LOG()
  61 #endif
  62
  63
  64 typedef HRESULT (WINAPI *PFN_D3D10COMPILESHADER)(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, const char *pFunctionName, const char *pProfile, UINT Flags, ID3D10Blob **ppShader, ID3D10Blob **ppErrorMsgs);
  65 static PFN_D3D10COMPILESHADER _D3D10CompileShader_ptr = NULL;
  66
  67 EXTERN_C HRESULT WINAPI
  68 D3D10CompileShader(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, const char *pFunctionName, const char *pProfile, UINT Flags, ID3D10Blob **ppShader, ID3D10Blob **ppErrorMsgs) {
  69     const char *_name = "D3D10CompileShader";
  70     LOG();
  71     if (!_D3D10CompileShader_ptr) {
  72         _D3D10CompileShader_ptr = (PFN_D3D10COMPILESHADER)_getD3D10ProcAddress(_name);
  73         if (!_D3D10CompileShader_ptr) {
  74             os::log("error: unavailable function %s\n", _name);
  75             os::abort();
  76         }
  77     }
  78     return _D3D10CompileShader_ptr(pSrcData, SrcDataSize, pFileName, pDefines, pInclude, pFunctionName, pProfile, Flags, ppShader, ppErrorMsgs);
  79 }
  80
  81 typedef HRESULT (WINAPI *PFN_D3D10DISASSEMBLESHADER)(const void *pShader, SIZE_T BytecodeLength, BOOL EnableColorCode, const char *pComments, ID3D10Blob **ppDisassembly);
  82 static PFN_D3D10DISASSEMBLESHADER _D3D10DisassembleShader_ptr = NULL;
  83
  84 EXTERN_C HRESULT WINAPI
  85 D3D10DisassembleShader(const void *pShader, SIZE_T BytecodeLength, BOOL EnableColorCode, const char *pComments, ID3D10Blob **ppDisassembly) {
  86     const char *_name = "D3D10DisassembleShader";
  87     LOG();
  88     if (!_D3D10DisassembleShader_ptr) {
  89         _D3D10DisassembleShader_ptr = (PFN_D3D10DISASSEMBLESHADER)_getD3D10ProcAddress(_name);
  90         if (!_D3D10DisassembleShader_ptr) {
  91             os::log("error: unavailable function %s\n", _name);
  92             os::abort();
  93         }
  94     }
  95     return _D3D10DisassembleShader_ptr(pShader, BytecodeLength, EnableColorCode, pComments, ppDisassembly);
  96 }
  97
  98 typedef const char *(WINAPI *PFN_D3D10GETPIXELSHADERPROFILE)(ID3D10Device *pDevice);
  99 static PFN_D3D10GETPIXELSHADERPROFILE _D3D10GetPixelShaderProfile_ptr = NULL;
 100
 101 EXTERN_C const char *WINAPI
 102 D3D10GetPixelShaderProfile(ID3D10Device *pDevice) {
 103     const char *_name = "D3D10GetPixelShaderProfile";
 104     LOG();
 105     if (!_D3D10GetPixelShaderProfile_ptr) {
 106         _D3D10GetPixelShaderProfile_ptr = (PFN_D3D10GETPIXELSHADERPROFILE)_getD3D10ProcAddress(_name);
 107         if (!_D3D10GetPixelShaderProfile_ptr) {
 108             os::log("error: unavailable function %s\n", _name);
 109             os::abort();
 110         }
 111     }
 112     return _D3D10GetPixelShaderProfile_ptr(pDevice);
 113 }
 114
 115 typedef const char *(WINAPI *PFN_D3D10GETVERTEXSHADERPROFILE)(ID3D10Device *pDevice);
 116 static PFN_D3D10GETVERTEXSHADERPROFILE _D3D10GetVertexShaderProfile_ptr = NULL;
 117
 118 EXTERN_C const char *WINAPI
 119 D3D10GetVertexShaderProfile(ID3D10Device *pDevice) {
 120     const char *_name = "D3D10GetVertexShaderProfile";
 121     LOG();
 122     if (!_D3D10GetVertexShaderProfile_ptr) {
 123         _D3D10GetVertexShaderProfile_ptr = (PFN_D3D10GETVERTEXSHADERPROFILE)_getD3D10ProcAddress(_name);
 124         if (!_D3D10GetVertexShaderProfile_ptr) {
 125             os::log("error: unavailable function %s\n", _name);
 126             os::abort();
 127         }
 128     }
 129     return _D3D10GetVertexShaderProfile_ptr(pDevice);
 130 }
 131
 132 typedef const char *(WINAPI *PFN_D3D10GETGEOMETRYSHADERPROFILE)(ID3D10Device *pDevice);
 133 static PFN_D3D10GETGEOMETRYSHADERPROFILE _D3D10GetGeometryShaderProfile_ptr = NULL;
 134
 135 EXTERN_C const char *WINAPI
 136 D3D10GetGeometryShaderProfile(ID3D10Device *pDevice) {
 137     const char *_name = "D3D10GetGeometryShaderProfile";
 138     LOG();
 139     if (!_D3D10GetGeometryShaderProfile_ptr) {
 140         _D3D10GetGeometryShaderProfile_ptr = (PFN_D3D10GETGEOMETRYSHADERPROFILE)_getD3D10ProcAddress(_name);
 141         if (!_D3D10GetGeometryShaderProfile_ptr) {
 142             os::log("error: unavailable function %s\n", _name);
 143             os::abort();
 144         }
 145     }
 146     return _D3D10GetGeometryShaderProfile_ptr(pDevice);
 147 }
 148
 149 typedef HRESULT (WINAPI *PFN_D3D10REFLECTSHADER)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10ShaderReflection **ppReflector);
 150 static PFN_D3D10REFLECTSHADER _D3D10ReflectShader_ptr = NULL;
 151
 152 EXTERN_C HRESULT WINAPI
 153 D3D10ReflectShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10ShaderReflection **ppReflector) {
 154     const char *_name = "D3D10ReflectShader";
 155     LOG();
 156     if (!_D3D10ReflectShader_ptr) {
 157         _D3D10ReflectShader_ptr = (PFN_D3D10REFLECTSHADER)_getD3D10ProcAddress(_name);
 158         if (!_D3D10ReflectShader_ptr) {
 159             os::log("error: unavailable function %s\n", _name);
 160             os::abort();
 161         }
 162     }
 163     return _D3D10ReflectShader_ptr(pShaderBytecode, BytecodeLength, ppReflector);
 164 }
 165
 166 typedef HRESULT (WINAPI *PFN_D3D10PREPROCESSSHADER)(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, ID3D10Blob **ppShaderText, ID3D10Blob **ppErrorMsgs);
 167 static PFN_D3D10PREPROCESSSHADER _D3D10PreprocessShader_ptr = NULL;
 168
 169 EXTERN_C HRESULT WINAPI
 170 D3D10PreprocessShader(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, ID3D10Blob **ppShaderText, ID3D10Blob **ppErrorMsgs) {
 171     const char *_name = "D3D10PreprocessShader";
 172     LOG();
 173     if (!_D3D10PreprocessShader_ptr) {
 174         _D3D10PreprocessShader_ptr = (PFN_D3D10PREPROCESSSHADER)_getD3D10ProcAddress(_name);
 175         if (!_D3D10PreprocessShader_ptr) {
 176             os::log("error: unavailable function %s\n", _name);
 177             os::abort();
 178         }
 179     }
 180     return _D3D10PreprocessShader_ptr(pSrcData, SrcDataSize, pFileName, pDefines, pInclude, ppShaderText, ppErrorMsgs);
 181 }
 182
 183 typedef HRESULT (WINAPI *PFN_D3D10GETINPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob);
 184 static PFN_D3D10GETINPUTSIGNATUREBLOB _D3D10GetInputSignatureBlob_ptr = NULL;
 185
 186 EXTERN_C HRESULT WINAPI
 187 D3D10GetInputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) {
 188     const char *_name = "D3D10GetInputSignatureBlob";
 189     LOG();
 190     if (!_D3D10GetInputSignatureBlob_ptr) {
 191         _D3D10GetInputSignatureBlob_ptr = (PFN_D3D10GETINPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name);
 192         if (!_D3D10GetInputSignatureBlob_ptr) {
 193             os::log("error: unavailable function %s\n", _name);
 194             os::abort();
 195         }
 196     }
 197     return _D3D10GetInputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob);
 198 }
 199
 200 typedef HRESULT (WINAPI *PFN_D3D10GETOUTPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob);
 201 static PFN_D3D10GETOUTPUTSIGNATUREBLOB _D3D10GetOutputSignatureBlob_ptr = NULL;
 202
 203 EXTERN_C HRESULT WINAPI
 204 D3D10GetOutputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) {
 205     const char *_name = "D3D10GetOutputSignatureBlob";
 206     LOG();
 207     if (!_D3D10GetOutputSignatureBlob_ptr) {
 208         _D3D10GetOutputSignatureBlob_ptr = (PFN_D3D10GETOUTPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name);
 209         if (!_D3D10GetOutputSignatureBlob_ptr) {
 210             os::log("error: unavailable function %s\n", _name);
 211             os::abort();
 212         }
 213     }
 214     return _D3D10GetOutputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob);
 215 }
 216
 217 typedef HRESULT (WINAPI *PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob);
 218 static PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB _D3D10GetInputAndOutputSignatureBlob_ptr = NULL;
 219
 220 EXTERN_C HRESULT WINAPI
 221 D3D10GetInputAndOutputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) {
 222     const char *_name = "D3D10GetInputAndOutputSignatureBlob";
 223     LOG();
 224     if (!_D3D10GetInputAndOutputSignatureBlob_ptr) {
 225         _D3D10GetInputAndOutputSignatureBlob_ptr = (PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name);
 226         if (!_D3D10GetInputAndOutputSignatureBlob_ptr) {
 227             os::log("error: unavailable function %s\n", _name);
 228             os::abort();
 229         }
 230     }
 231     return _D3D10GetInputAndOutputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob);
 232 }
 233
 234 typedef HRESULT (WINAPI *PFN_D3D10GETSHADERDEBUGINFO)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppDebugInfo);
 235 static PFN_D3D10GETSHADERDEBUGINFO _D3D10GetShaderDebugInfo_ptr = NULL;
 236
 237 EXTERN_C HRESULT WINAPI
 238 D3D10GetShaderDebugInfo(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppDebugInfo) {
 239     const char *_name = "D3D10GetShaderDebugInfo";
 240     LOG();
 241     if (!_D3D10GetShaderDebugInfo_ptr) {
 242         _D3D10GetShaderDebugInfo_ptr = (PFN_D3D10GETSHADERDEBUGINFO)_getD3D10ProcAddress(_name);
 243         if (!_D3D10GetShaderDebugInfo_ptr) {
 244             os::log("error: unavailable function %s\n", _name);
 245             os::abort();
 246         }
 247     }
 248     return _D3D10GetShaderDebugInfo_ptr(pShaderBytecode, BytecodeLength, ppDebugInfo);
 249 }
 250
 251 typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKUNION)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult);
 252 static PFN_D3D10STATEBLOCKMASKUNION _D3D10StateBlockMaskUnion_ptr = NULL;
 253
 254 EXTERN_C HRESULT WINAPI
 255 D3D10StateBlockMaskUnion(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult) {
 256     const char *_name = "D3D10StateBlockMaskUnion";
 257     LOG();
 258     if (!_D3D10StateBlockMaskUnion_ptr) {
 259         _D3D10StateBlockMaskUnion_ptr = (PFN_D3D10STATEBLOCKMASKUNION)_getD3D10ProcAddress(_name);
 260         if (!_D3D10StateBlockMaskUnion_ptr) {
 261             os::log("error: unavailable function %s\n", _name);
 262             os::abort();
 263         }
 264     }
 265     return _D3D10StateBlockMaskUnion_ptr(pA, pB, pResult);
 266 }
 267
 268 typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKINTERSECT)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult);
 269 static PFN_D3D10STATEBLOCKMASKINTERSECT _D3D10StateBlockMaskIntersect_ptr = NULL;
 270
 271 EXTERN_C HRESULT WINAPI
 272 D3D10StateBlockMaskIntersect(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult) {
 273     const char *_name = "D3D10StateBlockMaskIntersect";
 274     LOG();
 275     if (!_D3D10StateBlockMaskIntersect_ptr) {
 276         _D3D10StateBlockMaskIntersect_ptr = (PFN_D3D10STATEBLOCKMASKINTERSECT)_getD3D10ProcAddress(_name);
 277         if (!_D3D10StateBlockMaskIntersect_ptr) {
 278             os::log("error: unavailable function %s\n", _name);
 279             os::abort();
 280         }
 281     }
 282     return _D3D10StateBlockMaskIntersect_ptr(pA, pB, pResult);
 283 }
 284
 285 typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDIFFERENCE)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult);
 286 static PFN_D3D10STATEBLOCKMASKDIFFERENCE _D3D10StateBlockMaskDifference_ptr = NULL;
 287
 288 EXTERN_C HRESULT WINAPI
 289 D3D10StateBlockMaskDifference(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult) {
 290     const char *_name = "D3D10StateBlockMaskDifference";
 291     LOG();
 292     if (!_D3D10StateBlockMaskDifference_ptr) {
 293         _D3D10StateBlockMaskDifference_ptr = (PFN_D3D10STATEBLOCKMASKDIFFERENCE)_getD3D10ProcAddress(_name);
 294         if (!_D3D10StateBlockMaskDifference_ptr) {
 295             os::log("error: unavailable function %s\n", _name);
 296             os::abort();
 297         }
 298     }
 299     return _D3D10StateBlockMaskDifference_ptr(pA, pB, pResult);
 300 }
 301
 302 typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKENABLECAPTURE)(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength);
 303 static PFN_D3D10STATEBLOCKMASKENABLECAPTURE _D3D10StateBlockMaskEnableCapture_ptr = NULL;
 304
 305 EXTERN_C HRESULT WINAPI
 306 D3D10StateBlockMaskEnableCapture(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength) {
 307     const char *_name = "D3D10StateBlockMaskEnableCapture";
 308     LOG();
 309     if (!_D3D10StateBlockMaskEnableCapture_ptr) {
 310         _D3D10StateBlockMaskEnableCapture_ptr = (PFN_D3D10STATEBLOCKMASKENABLECAPTURE)_getD3D10ProcAddress(_name);
 311         if (!_D3D10StateBlockMaskEnableCapture_ptr) {
 312             os::log("error: unavailable function %s\n", _name);
 313             os::abort();
 314         }
 315     }
 316     return _D3D10StateBlockMaskEnableCapture_ptr(pMask, StateType, RangeStart, RangeLength);
 317 }
 318
 319 typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDISABLECAPTURE)(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength);
 320 static PFN_D3D10STATEBLOCKMASKDISABLECAPTURE _D3D10StateBlockMaskDisableCapture_ptr = NULL;
 321
 322 EXTERN_C HRESULT WINAPI
 323 D3D10StateBlockMaskDisableCapture(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength) {
 324     const char *_name = "D3D10StateBlockMaskDisableCapture";
 325     LOG();
 326     if (!_D3D10StateBlockMaskDisableCapture_ptr) {
 327         _D3D10StateBlockMaskDisableCapture_ptr = (PFN_D3D10STATEBLOCKMASKDISABLECAPTURE)_getD3D10ProcAddress(_name);
 328         if (!_D3D10StateBlockMaskDisableCapture_ptr) {
 329             os::log("error: unavailable function %s\n", _name);
 330             os::abort();
 331         }
 332     }
 333     return _D3D10StateBlockMaskDisableCapture_ptr(pMask, StateType, RangeStart, RangeLength);
 334 }
 335
 336 typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKENABLEALL)(D3D10_STATE_BLOCK_MASK *pMask);
 337 static PFN_D3D10STATEBLOCKMASKENABLEALL _D3D10StateBlockMaskEnableAll_ptr = NULL;
 338
 339 EXTERN_C HRESULT WINAPI
 340 D3D10StateBlockMaskEnableAll(D3D10_STATE_BLOCK_MASK *pMask) {
 341     const char *_name = "D3D10StateBlockMaskEnableAll";
 342     LOG();
 343     if (!_D3D10StateBlockMaskEnableAll_ptr) {
 344         _D3D10StateBlockMaskEnableAll_ptr = (PFN_D3D10STATEBLOCKMASKENABLEALL)_getD3D10ProcAddress(_name);
 345         if (!_D3D10StateBlockMaskEnableAll_ptr) {
 346             os::log("error: unavailable function %s\n", _name);
 347             os::abort();
 348         }
 349     }
 350     return _D3D10StateBlockMaskEnableAll_ptr(pMask);
 351 }
 352
 353 typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDISABLEALL)(D3D10_STATE_BLOCK_MASK *pMask);
 354 static PFN_D3D10STATEBLOCKMASKDISABLEALL _D3D10StateBlockMaskDisableAll_ptr = NULL;
 355
 356 EXTERN_C HRESULT WINAPI
 357 D3D10StateBlockMaskDisableAll(D3D10_STATE_BLOCK_MASK *pMask) {
 358     const char *_name = "D3D10StateBlockMaskDisableAll";
 359     LOG();
 360     if (!_D3D10StateBlockMaskDisableAll_ptr) {
 361         _D3D10StateBlockMaskDisableAll_ptr = (PFN_D3D10STATEBLOCKMASKDISABLEALL)_getD3D10ProcAddress(_name);
 362         if (!_D3D10StateBlockMaskDisableAll_ptr) {
 363             os::log("error: unavailable function %s\n", _name);
 364             os::abort();
 365         }
 366     }
 367     return _D3D10StateBlockMaskDisableAll_ptr(pMask);
 368 }
 369
 370 typedef BOOL (WINAPI *PFN_D3D10STATEBLOCKMASKGETSETTING)(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT Entry);
 371 static PFN_D3D10STATEBLOCKMASKGETSETTING _D3D10StateBlockMaskGetSetting_ptr = NULL;
 372
 373 EXTERN_C BOOL WINAPI
 374 D3D10StateBlockMaskGetSetting(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT Entry) {
 375     const char *_name = "D3D10StateBlockMaskGetSetting";
 376     LOG();
 377     if (!_D3D10StateBlockMaskGetSetting_ptr) {
 378         _D3D10StateBlockMaskGetSetting_ptr = (PFN_D3D10STATEBLOCKMASKGETSETTING)_getD3D10ProcAddress(_name);
 379         if (!_D3D10StateBlockMaskGetSetting_ptr) {
 380             os::log("error: unavailable function %s\n", _name);
 381             os::abort();
 382         }
 383     }
 384     return _D3D10StateBlockMaskGetSetting_ptr(pMask, StateType, Entry);
 385 }
 386
 387 typedef HRESULT (WINAPI *PFN_D3D10CREATESTATEBLOCK)(ID3D10Device *pDevice, D3D10_STATE_BLOCK_MASK *pStateBlockMask, ID3D10StateBlock **ppStateBlock);
 388 static PFN_D3D10CREATESTATEBLOCK _D3D10CreateStateBlock_ptr = NULL;
 389
 390 EXTERN_C HRESULT WINAPI
 391 D3D10CreateStateBlock(ID3D10Device *pDevice, D3D10_STATE_BLOCK_MASK *pStateBlockMask, ID3D10StateBlock **ppStateBlock) {
 392     const char *_name = "D3D10CreateStateBlock";
 393     LOG();
 394     if (!_D3D10CreateStateBlock_ptr) {
 395         _D3D10CreateStateBlock_ptr = (PFN_D3D10CREATESTATEBLOCK)_getD3D10ProcAddress(_name);
 396         if (!_D3D10CreateStateBlock_ptr) {
 397             os::log("error: unavailable function %s\n", _name);
 398             os::abort();
 399         }
 400     }
 401     return _D3D10CreateStateBlock_ptr(pDevice, pStateBlockMask, ppStateBlock);
 402 }
 403
 404 typedef HRESULT (WINAPI *PFN_D3D10COMPILEEFFECTFROMMEMORY)(void *pData, SIZE_T DataLength, const char *pSrcFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, UINT HLSLFlags, UINT FXFlags, ID3D10Blob **ppCompiledEffect, ID3D10Blob **ppErrors);
 405 static PFN_D3D10COMPILEEFFECTFROMMEMORY _D3D10CompileEffectFromMemory_ptr = NULL;
 406
 407 EXTERN_C HRESULT WINAPI
 408 D3D10CompileEffectFromMemory(void *pData, SIZE_T DataLength, const char *pSrcFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, UINT HLSLFlags, UINT FXFlags, ID3D10Blob **ppCompiledEffect, ID3D10Blob **ppErrors) {
 409     const char *_name = "D3D10CompileEffectFromMemory";
 410     LOG();
 411     if (!_D3D10CompileEffectFromMemory_ptr) {
 412         _D3D10CompileEffectFromMemory_ptr = (PFN_D3D10COMPILEEFFECTFROMMEMORY)_getD3D10ProcAddress(_name);
 413         if (!_D3D10CompileEffectFromMemory_ptr) {
 414             os::log("error: unavailable function %s\n", _name);
 415             os::abort();
 416         }
 417     }
 418     return _D3D10CompileEffectFromMemory_ptr(pData, DataLength, pSrcFileName, pDefines, pInclude, HLSLFlags, FXFlags, ppCompiledEffect, ppErrors);
 419 }
 420
 421 typedef HRESULT (WINAPI *PFN_D3D10CREATEEFFECTFROMMEMORY)(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool *pEffectPool, ID3D10Effect **ppEffect);
 422 static PFN_D3D10CREATEEFFECTFROMMEMORY _D3D10CreateEffectFromMemory_ptr = NULL;
 423
 424 EXTERN_C HRESULT WINAPI
 425 D3D10CreateEffectFromMemory(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool *pEffectPool, ID3D10Effect **ppEffect) {
 426     const char *_name = "D3D10CreateEffectFromMemory";
 427     LOG();
 428     if (!_D3D10CreateEffectFromMemory_ptr) {
 429         _D3D10CreateEffectFromMemory_ptr = (PFN_D3D10CREATEEFFECTFROMMEMORY)_getD3D10ProcAddress(_name);
 430         if (!_D3D10CreateEffectFromMemory_ptr) {
 431             os::log("error: unavailable function %s\n", _name);
 432             os::abort();
 433         }
 434     }
 435     return _D3D10CreateEffectFromMemory_ptr(pData, DataLength, FXFlags, pDevice, pEffectPool, ppEffect);
 436 }
 437
 438 typedef HRESULT (WINAPI *PFN_D3D10CREATEEFFECTPOOLFROMMEMORY)(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool **ppEffectPool);
 439 static PFN_D3D10CREATEEFFECTPOOLFROMMEMORY _D3D10CreateEffectPoolFromMemory_ptr = NULL;
 440
 441 EXTERN_C HRESULT WINAPI
 442 D3D10CreateEffectPoolFromMemory(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool **ppEffectPool) {
 443     const char *_name = "D3D10CreateEffectPoolFromMemory";
 444     LOG();
 445     if (!_D3D10CreateEffectPoolFromMemory_ptr) {
 446         _D3D10CreateEffectPoolFromMemory_ptr = (PFN_D3D10CREATEEFFECTPOOLFROMMEMORY)_getD3D10ProcAddress(_name);
 447         if (!_D3D10CreateEffectPoolFromMemory_ptr) {
 448             os::log("error: unavailable function %s\n", _name);
 449             os::abort();
 450         }
 451     }
 452     return _D3D10CreateEffectPoolFromMemory_ptr(pData, DataLength, FXFlags, pDevice, ppEffectPool);
 453 }
 454
 455 typedef HRESULT (WINAPI *PFN_D3D10DISASSEMBLEEFFECT)(ID3D10Effect *pEffect, BOOL EnableColorCode, ID3D10Blob **ppDisassembly);
 456 static PFN_D3D10DISASSEMBLEEFFECT _D3D10DisassembleEffect_ptr = NULL;
 457
 458 EXTERN_C HRESULT WINAPI
 459 D3D10DisassembleEffect(ID3D10Effect *pEffect, BOOL EnableColorCode, ID3D10Blob **ppDisassembly) {
 460     const char *_name = "D3D10DisassembleEffect";
 461     LOG();
 462     if (!_D3D10DisassembleEffect_ptr) {
 463         _D3D10DisassembleEffect_ptr = (PFN_D3D10DISASSEMBLEEFFECT)_getD3D10ProcAddress(_name);
 464         if (!_D3D10DisassembleEffect_ptr) {
 465             os::log("error: unavailable function %s\n", _name);
 466             os::abort();
 467         }
 468     }
 469     return _D3D10DisassembleEffect_ptr(pEffect, EnableColorCode, ppDisassembly);
 470 }
 471
 472 typedef HRESULT (WINAPI *PFN_D3D10CREATEBLOB)(SIZE_T NumBytes, ID3D10Blob **ppBuffer);
 473 static PFN_D3D10CREATEBLOB _D3D10CreateBlob_ptr = NULL;
 474
 475 EXTERN_C HRESULT WINAPI
 476 D3D10CreateBlob(SIZE_T NumBytes, ID3D10Blob **ppBuffer) {
 477     const char *_name = "D3D10CreateBlob";
 478     LOG();
 479     if (!_D3D10CreateBlob_ptr) {
 480         _D3D10CreateBlob_ptr = (PFN_D3D10CREATEBLOB)_getD3D10ProcAddress(_name);
 481         if (!_D3D10CreateBlob_ptr) {
 482             os::log("error: unavailable function %s\n", _name);
 483             os::abort();
 484         }
 485     }
 486     return _D3D10CreateBlob_ptr(NumBytes, ppBuffer);
 487 }
 488
 489 typedef DWORD (WINAPI *PFN_D3D10GETVERSION)(void);
 490 static PFN_D3D10GETVERSION _D3D10GetVersion_ptr = NULL;
 491
 492 EXTERN_C DWORD WINAPI
 493 D3D10GetVersion(void) {
 494     const char *_name = "D3D10GetVersion";
 495     LOG();
 496     if (!_D3D10GetVersion_ptr) {
 497         _D3D10GetVersion_ptr = (PFN_D3D10GETVERSION)_getD3D10ProcAddress(_name);
 498         if (!_D3D10GetVersion_ptr) {
 499             os::log("error: unavailable function %s\n", _name);
 500             os::abort();
 501         }
 502     }
 503     return _D3D10GetVersion_ptr();
 504 }
 505
 506 typedef DWORD (WINAPI *PFN_D3D10REGISTERLAYERS)(void);
 507 static PFN_D3D10REGISTERLAYERS _D3D10RegisterLayers_ptr = NULL;
 508
 509 EXTERN_C DWORD WINAPI
 510 D3D10RegisterLayers(void) {
 511     const char *_name = "D3D10RegisterLayers";
 512     LOG();
 513     if (!_D3D10RegisterLayers_ptr) {
 514         _D3D10RegisterLayers_ptr = (PFN_D3D10REGISTERLAYERS)_getD3D10ProcAddress(_name);
 515         if (!_D3D10RegisterLayers_ptr) {
 516             os::log("error: unavailable function %s\n", _name);
 517             os::abort();
 518         }
 519     }
 520     return _D3D10RegisterLayers_ptr();
 521 }
 522