1 /**************************************************************************
3 * Copyright 2012 VMware, Inc.
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
24 **************************************************************************/
28 *Stubs for internal D3D10 functions.
34 #include "d3d10imports.hpp"
37 static HMODULE g_hD3D10Module = NULL;
41 _getD3D10ProcAddress(LPCSTR lpProcName) {
42 if (!g_hD3D10Module) {
43 char szDll[MAX_PATH] = {0};
44 if (!GetSystemDirectoryA(szDll, MAX_PATH)) {
47 strcat(szDll, "\\\\d3d10.dll");
48 g_hD3D10Module = LoadLibraryA(szDll);
49 if (!g_hD3D10Module) {
53 return GetProcAddress(g_hD3D10Module, lpProcName);
58 #define LOG() os::log("%s\n", __FUNCTION__)
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;
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";
71 if (!_D3D10CompileShader_ptr) {
72 _D3D10CompileShader_ptr = (PFN_D3D10COMPILESHADER)_getD3D10ProcAddress(_name);
73 if (!_D3D10CompileShader_ptr) {
74 os::log("error: unavailable function %s\n", _name);
78 return _D3D10CompileShader_ptr(pSrcData, SrcDataSize, pFileName, pDefines, pInclude, pFunctionName, pProfile, Flags, ppShader, ppErrorMsgs);
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;
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";
88 if (!_D3D10DisassembleShader_ptr) {
89 _D3D10DisassembleShader_ptr = (PFN_D3D10DISASSEMBLESHADER)_getD3D10ProcAddress(_name);
90 if (!_D3D10DisassembleShader_ptr) {
91 os::log("error: unavailable function %s\n", _name);
95 return _D3D10DisassembleShader_ptr(pShader, BytecodeLength, EnableColorCode, pComments, ppDisassembly);
98 typedef const char *(WINAPI *PFN_D3D10GETPIXELSHADERPROFILE)(ID3D10Device *pDevice);
99 static PFN_D3D10GETPIXELSHADERPROFILE _D3D10GetPixelShaderProfile_ptr = NULL;
101 EXTERN_C const char *WINAPI
102 D3D10GetPixelShaderProfile(ID3D10Device *pDevice) {
103 const char *_name = "D3D10GetPixelShaderProfile";
105 if (!_D3D10GetPixelShaderProfile_ptr) {
106 _D3D10GetPixelShaderProfile_ptr = (PFN_D3D10GETPIXELSHADERPROFILE)_getD3D10ProcAddress(_name);
107 if (!_D3D10GetPixelShaderProfile_ptr) {
108 os::log("error: unavailable function %s\n", _name);
112 return _D3D10GetPixelShaderProfile_ptr(pDevice);
115 typedef const char *(WINAPI *PFN_D3D10GETVERTEXSHADERPROFILE)(ID3D10Device *pDevice);
116 static PFN_D3D10GETVERTEXSHADERPROFILE _D3D10GetVertexShaderProfile_ptr = NULL;
118 EXTERN_C const char *WINAPI
119 D3D10GetVertexShaderProfile(ID3D10Device *pDevice) {
120 const char *_name = "D3D10GetVertexShaderProfile";
122 if (!_D3D10GetVertexShaderProfile_ptr) {
123 _D3D10GetVertexShaderProfile_ptr = (PFN_D3D10GETVERTEXSHADERPROFILE)_getD3D10ProcAddress(_name);
124 if (!_D3D10GetVertexShaderProfile_ptr) {
125 os::log("error: unavailable function %s\n", _name);
129 return _D3D10GetVertexShaderProfile_ptr(pDevice);
132 typedef const char *(WINAPI *PFN_D3D10GETGEOMETRYSHADERPROFILE)(ID3D10Device *pDevice);
133 static PFN_D3D10GETGEOMETRYSHADERPROFILE _D3D10GetGeometryShaderProfile_ptr = NULL;
135 EXTERN_C const char *WINAPI
136 D3D10GetGeometryShaderProfile(ID3D10Device *pDevice) {
137 const char *_name = "D3D10GetGeometryShaderProfile";
139 if (!_D3D10GetGeometryShaderProfile_ptr) {
140 _D3D10GetGeometryShaderProfile_ptr = (PFN_D3D10GETGEOMETRYSHADERPROFILE)_getD3D10ProcAddress(_name);
141 if (!_D3D10GetGeometryShaderProfile_ptr) {
142 os::log("error: unavailable function %s\n", _name);
146 return _D3D10GetGeometryShaderProfile_ptr(pDevice);
149 typedef HRESULT (WINAPI *PFN_D3D10REFLECTSHADER)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10ShaderReflection **ppReflector);
150 static PFN_D3D10REFLECTSHADER _D3D10ReflectShader_ptr = NULL;
152 EXTERN_C HRESULT WINAPI
153 D3D10ReflectShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10ShaderReflection **ppReflector) {
154 const char *_name = "D3D10ReflectShader";
156 if (!_D3D10ReflectShader_ptr) {
157 _D3D10ReflectShader_ptr = (PFN_D3D10REFLECTSHADER)_getD3D10ProcAddress(_name);
158 if (!_D3D10ReflectShader_ptr) {
159 os::log("error: unavailable function %s\n", _name);
163 return _D3D10ReflectShader_ptr(pShaderBytecode, BytecodeLength, ppReflector);
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;
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";
173 if (!_D3D10PreprocessShader_ptr) {
174 _D3D10PreprocessShader_ptr = (PFN_D3D10PREPROCESSSHADER)_getD3D10ProcAddress(_name);
175 if (!_D3D10PreprocessShader_ptr) {
176 os::log("error: unavailable function %s\n", _name);
180 return _D3D10PreprocessShader_ptr(pSrcData, SrcDataSize, pFileName, pDefines, pInclude, ppShaderText, ppErrorMsgs);
183 typedef HRESULT (WINAPI *PFN_D3D10GETINPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob);
184 static PFN_D3D10GETINPUTSIGNATUREBLOB _D3D10GetInputSignatureBlob_ptr = NULL;
186 EXTERN_C HRESULT WINAPI
187 D3D10GetInputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) {
188 const char *_name = "D3D10GetInputSignatureBlob";
190 if (!_D3D10GetInputSignatureBlob_ptr) {
191 _D3D10GetInputSignatureBlob_ptr = (PFN_D3D10GETINPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name);
192 if (!_D3D10GetInputSignatureBlob_ptr) {
193 os::log("error: unavailable function %s\n", _name);
197 return _D3D10GetInputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob);
200 typedef HRESULT (WINAPI *PFN_D3D10GETOUTPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob);
201 static PFN_D3D10GETOUTPUTSIGNATUREBLOB _D3D10GetOutputSignatureBlob_ptr = NULL;
203 EXTERN_C HRESULT WINAPI
204 D3D10GetOutputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) {
205 const char *_name = "D3D10GetOutputSignatureBlob";
207 if (!_D3D10GetOutputSignatureBlob_ptr) {
208 _D3D10GetOutputSignatureBlob_ptr = (PFN_D3D10GETOUTPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name);
209 if (!_D3D10GetOutputSignatureBlob_ptr) {
210 os::log("error: unavailable function %s\n", _name);
214 return _D3D10GetOutputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob);
217 typedef HRESULT (WINAPI *PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob);
218 static PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB _D3D10GetInputAndOutputSignatureBlob_ptr = NULL;
220 EXTERN_C HRESULT WINAPI
221 D3D10GetInputAndOutputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) {
222 const char *_name = "D3D10GetInputAndOutputSignatureBlob";
224 if (!_D3D10GetInputAndOutputSignatureBlob_ptr) {
225 _D3D10GetInputAndOutputSignatureBlob_ptr = (PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name);
226 if (!_D3D10GetInputAndOutputSignatureBlob_ptr) {
227 os::log("error: unavailable function %s\n", _name);
231 return _D3D10GetInputAndOutputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob);
234 typedef HRESULT (WINAPI *PFN_D3D10GETSHADERDEBUGINFO)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppDebugInfo);
235 static PFN_D3D10GETSHADERDEBUGINFO _D3D10GetShaderDebugInfo_ptr = NULL;
237 EXTERN_C HRESULT WINAPI
238 D3D10GetShaderDebugInfo(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppDebugInfo) {
239 const char *_name = "D3D10GetShaderDebugInfo";
241 if (!_D3D10GetShaderDebugInfo_ptr) {
242 _D3D10GetShaderDebugInfo_ptr = (PFN_D3D10GETSHADERDEBUGINFO)_getD3D10ProcAddress(_name);
243 if (!_D3D10GetShaderDebugInfo_ptr) {
244 os::log("error: unavailable function %s\n", _name);
248 return _D3D10GetShaderDebugInfo_ptr(pShaderBytecode, BytecodeLength, ppDebugInfo);
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;
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";
258 if (!_D3D10StateBlockMaskUnion_ptr) {
259 _D3D10StateBlockMaskUnion_ptr = (PFN_D3D10STATEBLOCKMASKUNION)_getD3D10ProcAddress(_name);
260 if (!_D3D10StateBlockMaskUnion_ptr) {
261 os::log("error: unavailable function %s\n", _name);
265 return _D3D10StateBlockMaskUnion_ptr(pA, pB, pResult);
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;
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";
275 if (!_D3D10StateBlockMaskIntersect_ptr) {
276 _D3D10StateBlockMaskIntersect_ptr = (PFN_D3D10STATEBLOCKMASKINTERSECT)_getD3D10ProcAddress(_name);
277 if (!_D3D10StateBlockMaskIntersect_ptr) {
278 os::log("error: unavailable function %s\n", _name);
282 return _D3D10StateBlockMaskIntersect_ptr(pA, pB, pResult);
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;
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";
292 if (!_D3D10StateBlockMaskDifference_ptr) {
293 _D3D10StateBlockMaskDifference_ptr = (PFN_D3D10STATEBLOCKMASKDIFFERENCE)_getD3D10ProcAddress(_name);
294 if (!_D3D10StateBlockMaskDifference_ptr) {
295 os::log("error: unavailable function %s\n", _name);
299 return _D3D10StateBlockMaskDifference_ptr(pA, pB, pResult);
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;
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";
309 if (!_D3D10StateBlockMaskEnableCapture_ptr) {
310 _D3D10StateBlockMaskEnableCapture_ptr = (PFN_D3D10STATEBLOCKMASKENABLECAPTURE)_getD3D10ProcAddress(_name);
311 if (!_D3D10StateBlockMaskEnableCapture_ptr) {
312 os::log("error: unavailable function %s\n", _name);
316 return _D3D10StateBlockMaskEnableCapture_ptr(pMask, StateType, RangeStart, RangeLength);
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;
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";
326 if (!_D3D10StateBlockMaskDisableCapture_ptr) {
327 _D3D10StateBlockMaskDisableCapture_ptr = (PFN_D3D10STATEBLOCKMASKDISABLECAPTURE)_getD3D10ProcAddress(_name);
328 if (!_D3D10StateBlockMaskDisableCapture_ptr) {
329 os::log("error: unavailable function %s\n", _name);
333 return _D3D10StateBlockMaskDisableCapture_ptr(pMask, StateType, RangeStart, RangeLength);
336 typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKENABLEALL)(D3D10_STATE_BLOCK_MASK *pMask);
337 static PFN_D3D10STATEBLOCKMASKENABLEALL _D3D10StateBlockMaskEnableAll_ptr = NULL;
339 EXTERN_C HRESULT WINAPI
340 D3D10StateBlockMaskEnableAll(D3D10_STATE_BLOCK_MASK *pMask) {
341 const char *_name = "D3D10StateBlockMaskEnableAll";
343 if (!_D3D10StateBlockMaskEnableAll_ptr) {
344 _D3D10StateBlockMaskEnableAll_ptr = (PFN_D3D10STATEBLOCKMASKENABLEALL)_getD3D10ProcAddress(_name);
345 if (!_D3D10StateBlockMaskEnableAll_ptr) {
346 os::log("error: unavailable function %s\n", _name);
350 return _D3D10StateBlockMaskEnableAll_ptr(pMask);
353 typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDISABLEALL)(D3D10_STATE_BLOCK_MASK *pMask);
354 static PFN_D3D10STATEBLOCKMASKDISABLEALL _D3D10StateBlockMaskDisableAll_ptr = NULL;
356 EXTERN_C HRESULT WINAPI
357 D3D10StateBlockMaskDisableAll(D3D10_STATE_BLOCK_MASK *pMask) {
358 const char *_name = "D3D10StateBlockMaskDisableAll";
360 if (!_D3D10StateBlockMaskDisableAll_ptr) {
361 _D3D10StateBlockMaskDisableAll_ptr = (PFN_D3D10STATEBLOCKMASKDISABLEALL)_getD3D10ProcAddress(_name);
362 if (!_D3D10StateBlockMaskDisableAll_ptr) {
363 os::log("error: unavailable function %s\n", _name);
367 return _D3D10StateBlockMaskDisableAll_ptr(pMask);
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;
374 D3D10StateBlockMaskGetSetting(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT Entry) {
375 const char *_name = "D3D10StateBlockMaskGetSetting";
377 if (!_D3D10StateBlockMaskGetSetting_ptr) {
378 _D3D10StateBlockMaskGetSetting_ptr = (PFN_D3D10STATEBLOCKMASKGETSETTING)_getD3D10ProcAddress(_name);
379 if (!_D3D10StateBlockMaskGetSetting_ptr) {
380 os::log("error: unavailable function %s\n", _name);
384 return _D3D10StateBlockMaskGetSetting_ptr(pMask, StateType, Entry);
387 typedef HRESULT (WINAPI *PFN_D3D10CREATESTATEBLOCK)(ID3D10Device *pDevice, D3D10_STATE_BLOCK_MASK *pStateBlockMask, ID3D10StateBlock **ppStateBlock);
388 static PFN_D3D10CREATESTATEBLOCK _D3D10CreateStateBlock_ptr = NULL;
390 EXTERN_C HRESULT WINAPI
391 D3D10CreateStateBlock(ID3D10Device *pDevice, D3D10_STATE_BLOCK_MASK *pStateBlockMask, ID3D10StateBlock **ppStateBlock) {
392 const char *_name = "D3D10CreateStateBlock";
394 if (!_D3D10CreateStateBlock_ptr) {
395 _D3D10CreateStateBlock_ptr = (PFN_D3D10CREATESTATEBLOCK)_getD3D10ProcAddress(_name);
396 if (!_D3D10CreateStateBlock_ptr) {
397 os::log("error: unavailable function %s\n", _name);
401 return _D3D10CreateStateBlock_ptr(pDevice, pStateBlockMask, ppStateBlock);
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;
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";
411 if (!_D3D10CompileEffectFromMemory_ptr) {
412 _D3D10CompileEffectFromMemory_ptr = (PFN_D3D10COMPILEEFFECTFROMMEMORY)_getD3D10ProcAddress(_name);
413 if (!_D3D10CompileEffectFromMemory_ptr) {
414 os::log("error: unavailable function %s\n", _name);
418 return _D3D10CompileEffectFromMemory_ptr(pData, DataLength, pSrcFileName, pDefines, pInclude, HLSLFlags, FXFlags, ppCompiledEffect, ppErrors);
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;
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";
428 if (!_D3D10CreateEffectFromMemory_ptr) {
429 _D3D10CreateEffectFromMemory_ptr = (PFN_D3D10CREATEEFFECTFROMMEMORY)_getD3D10ProcAddress(_name);
430 if (!_D3D10CreateEffectFromMemory_ptr) {
431 os::log("error: unavailable function %s\n", _name);
435 return _D3D10CreateEffectFromMemory_ptr(pData, DataLength, FXFlags, pDevice, pEffectPool, ppEffect);
438 typedef HRESULT (WINAPI *PFN_D3D10CREATEEFFECTPOOLFROMMEMORY)(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool **ppEffectPool);
439 static PFN_D3D10CREATEEFFECTPOOLFROMMEMORY _D3D10CreateEffectPoolFromMemory_ptr = NULL;
441 EXTERN_C HRESULT WINAPI
442 D3D10CreateEffectPoolFromMemory(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool **ppEffectPool) {
443 const char *_name = "D3D10CreateEffectPoolFromMemory";
445 if (!_D3D10CreateEffectPoolFromMemory_ptr) {
446 _D3D10CreateEffectPoolFromMemory_ptr = (PFN_D3D10CREATEEFFECTPOOLFROMMEMORY)_getD3D10ProcAddress(_name);
447 if (!_D3D10CreateEffectPoolFromMemory_ptr) {
448 os::log("error: unavailable function %s\n", _name);
452 return _D3D10CreateEffectPoolFromMemory_ptr(pData, DataLength, FXFlags, pDevice, ppEffectPool);
455 typedef HRESULT (WINAPI *PFN_D3D10DISASSEMBLEEFFECT)(ID3D10Effect *pEffect, BOOL EnableColorCode, ID3D10Blob **ppDisassembly);
456 static PFN_D3D10DISASSEMBLEEFFECT _D3D10DisassembleEffect_ptr = NULL;
458 EXTERN_C HRESULT WINAPI
459 D3D10DisassembleEffect(ID3D10Effect *pEffect, BOOL EnableColorCode, ID3D10Blob **ppDisassembly) {
460 const char *_name = "D3D10DisassembleEffect";
462 if (!_D3D10DisassembleEffect_ptr) {
463 _D3D10DisassembleEffect_ptr = (PFN_D3D10DISASSEMBLEEFFECT)_getD3D10ProcAddress(_name);
464 if (!_D3D10DisassembleEffect_ptr) {
465 os::log("error: unavailable function %s\n", _name);
469 return _D3D10DisassembleEffect_ptr(pEffect, EnableColorCode, ppDisassembly);
472 typedef HRESULT (WINAPI *PFN_D3D10CREATEBLOB)(SIZE_T NumBytes, ID3D10Blob **ppBuffer);
473 static PFN_D3D10CREATEBLOB _D3D10CreateBlob_ptr = NULL;
475 EXTERN_C HRESULT WINAPI
476 D3D10CreateBlob(SIZE_T NumBytes, ID3D10Blob **ppBuffer) {
477 const char *_name = "D3D10CreateBlob";
479 if (!_D3D10CreateBlob_ptr) {
480 _D3D10CreateBlob_ptr = (PFN_D3D10CREATEBLOB)_getD3D10ProcAddress(_name);
481 if (!_D3D10CreateBlob_ptr) {
482 os::log("error: unavailable function %s\n", _name);
486 return _D3D10CreateBlob_ptr(NumBytes, ppBuffer);
489 typedef DWORD (WINAPI *PFN_D3D10GETVERSION)(void);
490 static PFN_D3D10GETVERSION _D3D10GetVersion_ptr = NULL;
492 EXTERN_C DWORD WINAPI
493 D3D10GetVersion(void) {
494 const char *_name = "D3D10GetVersion";
496 if (!_D3D10GetVersion_ptr) {
497 _D3D10GetVersion_ptr = (PFN_D3D10GETVERSION)_getD3D10ProcAddress(_name);
498 if (!_D3D10GetVersion_ptr) {
499 os::log("error: unavailable function %s\n", _name);
503 return _D3D10GetVersion_ptr();
506 typedef DWORD (WINAPI *PFN_D3D10REGISTERLAYERS)(void);
507 static PFN_D3D10REGISTERLAYERS _D3D10RegisterLayers_ptr = NULL;
509 EXTERN_C DWORD WINAPI
510 D3D10RegisterLayers(void) {
511 const char *_name = "D3D10RegisterLayers";
513 if (!_D3D10RegisterLayers_ptr) {
514 _D3D10RegisterLayers_ptr = (PFN_D3D10REGISTERLAYERS)_getD3D10ProcAddress(_name);
515 if (!_D3D10RegisterLayers_ptr) {
516 os::log("error: unavailable function %s\n", _name);
520 return _D3D10RegisterLayers_ptr();