2 * Copyright 2008 Luis Busquets
3 * Copyright 2009 Matteo Bruni
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include "wine/port.h"
22 #include "wine/debug.h"
23 #include "wine/unicode.h"
27 #include "d3dcommon.h"
28 #include "d3dcompiler.h"
29 #include "d3dx9_36_private.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(d3dx
);
33 /* This function is not declared in the SDK headers yet */
34 HRESULT WINAPI
D3DAssemble(LPCVOID data
, SIZE_T datasize
, LPCSTR filename
,
35 const D3D_SHADER_MACRO
*defines
, ID3DInclude
*include
,
37 ID3DBlob
**shader
, ID3DBlob
**error_messages
);
39 LPCSTR WINAPI
D3DXGetPixelShaderProfile(LPDIRECT3DDEVICE9 device
)
43 TRACE("device %p\n", device
);
45 if (!device
) return NULL
;
47 IDirect3DDevice9_GetDeviceCaps(device
,&caps
);
49 switch (caps
.PixelShaderVersion
)
51 case D3DPS_VERSION(1, 1):
54 case D3DPS_VERSION(1, 2):
57 case D3DPS_VERSION(1, 3):
60 case D3DPS_VERSION(1, 4):
63 case D3DPS_VERSION(2, 0):
64 if ((caps
.PS20Caps
.NumTemps
>=22) &&
65 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_ARBITRARYSWIZZLE
) &&
66 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_GRADIENTINSTRUCTIONS
) &&
67 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_PREDICATION
) &&
68 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_NODEPENDENTREADLIMIT
) &&
69 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT
))
73 if ((caps
.PS20Caps
.NumTemps
>=32) &&
74 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT
))
80 case D3DPS_VERSION(3, 0):
87 UINT WINAPI
D3DXGetShaderSize(const DWORD
*byte_code
)
89 const DWORD
*ptr
= byte_code
;
91 TRACE("byte_code %p\n", byte_code
);
95 /* Look for the END token, skipping the VERSION token */
96 while (*++ptr
!= D3DSIO_END
)
99 if ((*ptr
& D3DSI_OPCODE_MASK
) == D3DSIO_COMMENT
)
101 ptr
+= ((*ptr
& D3DSI_COMMENTSIZE_MASK
) >> D3DSI_COMMENTSIZE_SHIFT
);
106 /* Return the shader size in bytes */
107 return (ptr
- byte_code
) * sizeof(*ptr
);
110 DWORD WINAPI
D3DXGetShaderVersion(const DWORD
*byte_code
)
112 TRACE("byte_code %p\n", byte_code
);
114 return byte_code
? *byte_code
: 0;
117 LPCSTR WINAPI
D3DXGetVertexShaderProfile(LPDIRECT3DDEVICE9 device
)
121 TRACE("device %p\n", device
);
123 if (!device
) return NULL
;
125 IDirect3DDevice9_GetDeviceCaps(device
,&caps
);
127 switch (caps
.VertexShaderVersion
)
129 case D3DVS_VERSION(1, 1):
131 case D3DVS_VERSION(2, 0):
132 if ((caps
.VS20Caps
.NumTemps
>=13) &&
133 (caps
.VS20Caps
.DynamicFlowControlDepth
==24) &&
134 (caps
.VS20Caps
.Caps
&D3DPS20CAPS_PREDICATION
))
139 case D3DVS_VERSION(3, 0):
146 HRESULT WINAPI
D3DXFindShaderComment(CONST DWORD
* byte_code
, DWORD fourcc
, LPCVOID
* data
, UINT
* size
)
148 CONST DWORD
*ptr
= byte_code
;
150 TRACE("(%p, %x, %p, %p)\n", byte_code
, fourcc
, data
, size
);
153 return D3DERR_INVALIDCALL
;
155 while (*++ptr
!= D3DSIO_END
)
157 /* Check if it is a comment */
158 if ((*ptr
& D3DSI_OPCODE_MASK
) == D3DSIO_COMMENT
)
160 DWORD comment_size
= (*ptr
& D3DSI_COMMENTSIZE_MASK
) >> D3DSI_COMMENTSIZE_SHIFT
;
162 /* Check if this is the comment we are looking for */
163 if (*(ptr
+ 1) == fourcc
)
165 UINT ctab_size
= (comment_size
- 1) * sizeof(DWORD
);
166 LPCVOID ctab_data
= ptr
+ 2;
171 TRACE("Returning comment data at %p with size %d\n", ctab_data
, ctab_size
);
181 HRESULT WINAPI
D3DXAssembleShader(LPCSTR data
,
183 CONST D3DXMACRO
* defines
,
184 LPD3DXINCLUDE include
,
186 LPD3DXBUFFER
* shader
,
187 LPD3DXBUFFER
* error_messages
)
189 /* Forward to d3dcompiler: the parameter types aren't really different,
190 the actual data types are equivalent */
191 HRESULT hr
= D3DAssemble(data
, data_len
, NULL
, (D3D_SHADER_MACRO
*)defines
,
192 (ID3DInclude
*)include
, flags
, (ID3DBlob
**)shader
,
193 (ID3DBlob
**)error_messages
);
195 if(hr
== E_FAIL
) hr
= D3DXERR_INVALIDDATA
;
199 /* D3DXInclude private implementation, used to implement
200 D3DXAssembleShaderFromFile from D3DXAssembleShader */
201 /* To be able to correctly resolve include search paths we have to store
202 the pathname of each include file. We store the pathname pointer right
203 before the file data. */
204 static HRESULT WINAPI
d3dincludefromfile_open(ID3DXInclude
*iface
,
205 D3DXINCLUDE_TYPE include_type
,
206 LPCSTR filename
, LPCVOID parent_data
,
207 LPCVOID
*data
, UINT
*bytes
) {
208 const char *p
, *parent_name
= "";
209 char *pathname
= NULL
;
210 char **buffer
= NULL
;
214 if(parent_data
!= NULL
)
215 parent_name
= *((const char **)parent_data
- 1);
217 TRACE("Looking up for include file %s, parent %s\n", debugstr_a(filename
), debugstr_a(parent_name
));
219 if ((p
= strrchr(parent_name
, '\\')) || (p
= strrchr(parent_name
, '/'))) p
++;
220 else p
= parent_name
;
221 pathname
= HeapAlloc(GetProcessHeap(), 0, (p
- parent_name
) + strlen(filename
) + 1);
223 return HRESULT_FROM_WIN32(GetLastError());
225 memcpy(pathname
, parent_name
, p
- parent_name
);
226 strcpy(pathname
+ (p
- parent_name
), filename
);
228 file
= CreateFileA(pathname
, GENERIC_READ
, FILE_SHARE_READ
, 0, OPEN_EXISTING
, 0, 0);
229 if(file
== INVALID_HANDLE_VALUE
)
232 TRACE("Include file found at pathname = %s\n", debugstr_a(pathname
));
234 size
= GetFileSize(file
, NULL
);
235 if(size
== INVALID_FILE_SIZE
)
238 buffer
= HeapAlloc(GetProcessHeap(), 0, size
+ sizeof(char *));
242 if(!ReadFile(file
, buffer
+ 1, size
, bytes
, NULL
))
252 HeapFree(GetProcessHeap(), 0, pathname
);
253 HeapFree(GetProcessHeap(), 0, buffer
);
254 return HRESULT_FROM_WIN32(GetLastError());
257 static HRESULT WINAPI
d3dincludefromfile_close(ID3DXInclude
*iface
, LPCVOID data
) {
258 HeapFree(GetProcessHeap(), 0, *((char **)data
- 1));
259 HeapFree(GetProcessHeap(), 0, (char **)data
- 1);
263 static const struct ID3DXIncludeVtbl D3DXInclude_Vtbl
= {
264 d3dincludefromfile_open
,
265 d3dincludefromfile_close
268 struct D3DXIncludeImpl
{
269 const ID3DXIncludeVtbl
*lpVtbl
;
272 HRESULT WINAPI
D3DXAssembleShaderFromFileA(LPCSTR filename
,
273 CONST D3DXMACRO
* defines
,
274 LPD3DXINCLUDE include
,
276 LPD3DXBUFFER
* shader
,
277 LPD3DXBUFFER
* error_messages
)
279 LPWSTR filename_w
= NULL
;
283 if (!filename
) return D3DXERR_INVALIDDATA
;
285 len
= MultiByteToWideChar(CP_ACP
, 0, filename
, -1, NULL
, 0);
286 filename_w
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
287 if (!filename_w
) return E_OUTOFMEMORY
;
288 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filename_w
, len
);
290 ret
= D3DXAssembleShaderFromFileW(filename_w
, defines
, include
, flags
, shader
, error_messages
);
292 HeapFree(GetProcessHeap(), 0, filename_w
);
296 HRESULT WINAPI
D3DXAssembleShaderFromFileW(LPCWSTR filename
,
297 CONST D3DXMACRO
* defines
,
298 LPD3DXINCLUDE include
,
300 LPD3DXBUFFER
* shader
,
301 LPD3DXBUFFER
* error_messages
)
306 struct D3DXIncludeImpl includefromfile
;
308 if(FAILED(map_view_of_file(filename
, &buffer
, &len
)))
309 return D3DXERR_INVALIDDATA
;
313 includefromfile
.lpVtbl
= &D3DXInclude_Vtbl
;
314 include
= (LPD3DXINCLUDE
)&includefromfile
;
317 hr
= D3DXAssembleShader(buffer
, len
, defines
, include
, flags
,
318 shader
, error_messages
);
320 UnmapViewOfFile(buffer
);
324 HRESULT WINAPI
D3DXAssembleShaderFromResourceA(HMODULE module
,
326 CONST D3DXMACRO
* defines
,
327 LPD3DXINCLUDE include
,
329 LPD3DXBUFFER
* shader
,
330 LPD3DXBUFFER
* error_messages
)
336 if (!(res
= FindResourceA(module
, resource
, (LPCSTR
)RT_RCDATA
)))
337 return D3DXERR_INVALIDDATA
;
338 if (FAILED(load_resource_into_memory(module
, res
, (LPVOID
*)&buffer
, &len
)))
339 return D3DXERR_INVALIDDATA
;
340 return D3DXAssembleShader(buffer
, len
, defines
, include
, flags
,
341 shader
, error_messages
);
344 HRESULT WINAPI
D3DXAssembleShaderFromResourceW(HMODULE module
,
346 CONST D3DXMACRO
* defines
,
347 LPD3DXINCLUDE include
,
349 LPD3DXBUFFER
* shader
,
350 LPD3DXBUFFER
* error_messages
)
356 if (!(res
= FindResourceW(module
, resource
, (LPCWSTR
)RT_RCDATA
)))
357 return D3DXERR_INVALIDDATA
;
358 if (FAILED(load_resource_into_memory(module
, res
, (LPVOID
*)&buffer
, &len
)))
359 return D3DXERR_INVALIDDATA
;
360 return D3DXAssembleShader(buffer
, len
, defines
, include
, flags
,
361 shader
, error_messages
);
364 HRESULT WINAPI
D3DXCompileShader(LPCSTR pSrcData
,
366 CONST D3DXMACRO
* pDefines
,
367 LPD3DXINCLUDE pInclude
,
368 LPCSTR pFunctionName
,
371 LPD3DXBUFFER
* ppShader
,
372 LPD3DXBUFFER
* ppErrorMsgs
,
373 LPD3DXCONSTANTTABLE
* ppConstantTable
)
375 HRESULT hr
= D3DCompile(pSrcData
, srcDataLen
, NULL
,
376 (D3D_SHADER_MACRO
*)pDefines
, (ID3DInclude
*)pInclude
,
377 pFunctionName
, pProfile
, Flags
, 0,
378 (ID3DBlob
**)ppShader
, (ID3DBlob
**)ppErrorMsgs
);
380 if(SUCCEEDED(hr
) && ppConstantTable
)
381 return D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*ppShader
),
386 HRESULT WINAPI
D3DXCompileShaderFromFileA(LPCSTR filename
,
387 CONST D3DXMACRO
* defines
,
388 LPD3DXINCLUDE include
,
392 LPD3DXBUFFER
* shader
,
393 LPD3DXBUFFER
* error_messages
,
394 LPD3DXCONSTANTTABLE
* constant_table
)
396 LPWSTR filename_w
= NULL
;
400 if (!filename
) return D3DXERR_INVALIDDATA
;
402 len
= MultiByteToWideChar(CP_ACP
, 0, filename
, -1, NULL
, 0);
403 filename_w
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
404 if (!filename_w
) return E_OUTOFMEMORY
;
405 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filename_w
, len
);
407 ret
= D3DXCompileShaderFromFileW(filename_w
, defines
, include
,
408 entrypoint
, profile
, flags
,
409 shader
, error_messages
, constant_table
);
411 HeapFree(GetProcessHeap(), 0, filename_w
);
415 HRESULT WINAPI
D3DXCompileShaderFromFileW(LPCWSTR filename
,
416 CONST D3DXMACRO
* defines
,
417 LPD3DXINCLUDE include
,
421 LPD3DXBUFFER
* shader
,
422 LPD3DXBUFFER
* error_messages
,
423 LPD3DXCONSTANTTABLE
* constant_table
)
426 DWORD len
, filename_len
;
428 struct D3DXIncludeImpl includefromfile
;
431 if (FAILED(map_view_of_file(filename
, &buffer
, &len
)))
432 return D3DXERR_INVALIDDATA
;
436 includefromfile
.lpVtbl
= &D3DXInclude_Vtbl
;
437 include
= (LPD3DXINCLUDE
)&includefromfile
;
440 filename_len
= WideCharToMultiByte(CP_ACP
, 0, filename
, -1, NULL
, 0, NULL
, NULL
);
441 filename_a
= HeapAlloc(GetProcessHeap(), 0, filename_len
* sizeof(char));
444 UnmapViewOfFile(buffer
);
445 return E_OUTOFMEMORY
;
447 WideCharToMultiByte(CP_ACP
, 0, filename
, -1, filename_a
, filename_len
, NULL
, NULL
);
449 hr
= D3DCompile(buffer
, len
, filename_a
, (const D3D_SHADER_MACRO
*)defines
,
450 (ID3DInclude
*)include
, entrypoint
, profile
, flags
, 0,
451 (ID3DBlob
**)shader
, (ID3DBlob
**)error_messages
);
453 if (SUCCEEDED(hr
) && constant_table
)
454 hr
= D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*shader
),
457 HeapFree(GetProcessHeap(), 0, filename_a
);
458 UnmapViewOfFile(buffer
);
462 HRESULT WINAPI
D3DXCompileShaderFromResourceA(HMODULE module
,
464 CONST D3DXMACRO
* defines
,
465 LPD3DXINCLUDE include
,
469 LPD3DXBUFFER
* shader
,
470 LPD3DXBUFFER
* error_messages
,
471 LPD3DXCONSTANTTABLE
* constant_table
)
477 if (!(res
= FindResourceA(module
, resource
, (LPCSTR
)RT_RCDATA
)))
478 return D3DXERR_INVALIDDATA
;
479 if (FAILED(load_resource_into_memory(module
, res
, (LPVOID
*)&buffer
, &len
)))
480 return D3DXERR_INVALIDDATA
;
481 return D3DXCompileShader(buffer
, len
, defines
, include
, entrypoint
, profile
,
482 flags
, shader
, error_messages
, constant_table
);
485 HRESULT WINAPI
D3DXCompileShaderFromResourceW(HMODULE module
,
487 CONST D3DXMACRO
* defines
,
488 LPD3DXINCLUDE include
,
492 LPD3DXBUFFER
* shader
,
493 LPD3DXBUFFER
* error_messages
,
494 LPD3DXCONSTANTTABLE
* constant_table
)
500 if (!(res
= FindResourceW(module
, resource
, (LPCWSTR
)RT_RCDATA
)))
501 return D3DXERR_INVALIDDATA
;
502 if (FAILED(load_resource_into_memory(module
, res
, (LPVOID
*)&buffer
, &len
)))
503 return D3DXERR_INVALIDDATA
;
504 return D3DXCompileShader(buffer
, len
, defines
, include
, entrypoint
, profile
,
505 flags
, shader
, error_messages
, constant_table
);
508 HRESULT WINAPI
D3DXPreprocessShader(LPCSTR data
,
510 CONST D3DXMACRO
* defines
,
511 LPD3DXINCLUDE include
,
512 LPD3DXBUFFER
* shader
,
513 LPD3DXBUFFER
* error_messages
)
515 TRACE("Forward to D3DPreprocess\n");
516 return D3DPreprocess(data
, data_len
, NULL
,
517 (const D3D_SHADER_MACRO
*)defines
, (ID3DInclude
*)include
,
518 (ID3DBlob
**)shader
, (ID3DBlob
**)error_messages
);
521 HRESULT WINAPI
D3DXPreprocessShaderFromFileA(LPCSTR filename
,
522 CONST D3DXMACRO
* defines
,
523 LPD3DXINCLUDE include
,
524 LPD3DXBUFFER
* shader
,
525 LPD3DXBUFFER
* error_messages
)
527 WCHAR
*filename_w
= NULL
;
531 if (!filename
) return D3DXERR_INVALIDDATA
;
533 len
= MultiByteToWideChar(CP_ACP
, 0, filename
, -1, NULL
, 0);
534 filename_w
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
535 if (!filename_w
) return E_OUTOFMEMORY
;
536 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filename_w
, len
);
538 ret
= D3DXPreprocessShaderFromFileW(filename_w
, defines
, include
, shader
, error_messages
);
540 HeapFree(GetProcessHeap(), 0, filename_w
);
544 HRESULT WINAPI
D3DXPreprocessShaderFromFileW(LPCWSTR filename
,
545 CONST D3DXMACRO
* defines
,
546 LPD3DXINCLUDE include
,
547 LPD3DXBUFFER
* shader
,
548 LPD3DXBUFFER
* error_messages
)
553 struct D3DXIncludeImpl includefromfile
;
555 if (FAILED(map_view_of_file(filename
, &buffer
, &len
)))
556 return D3DXERR_INVALIDDATA
;
560 includefromfile
.lpVtbl
= &D3DXInclude_Vtbl
;
561 include
= (LPD3DXINCLUDE
)&includefromfile
;
564 hr
= D3DPreprocess(buffer
, len
, NULL
,
565 (const D3D_SHADER_MACRO
*)defines
,
566 (ID3DInclude
*) include
,
567 (ID3DBlob
**)shader
, (ID3DBlob
**)error_messages
);
569 UnmapViewOfFile(buffer
);
573 HRESULT WINAPI
D3DXPreprocessShaderFromResourceA(HMODULE module
,
575 CONST D3DXMACRO
* defines
,
576 LPD3DXINCLUDE include
,
577 LPD3DXBUFFER
* shader
,
578 LPD3DXBUFFER
* error_messages
)
584 if (!(res
= FindResourceA(module
, resource
, (LPCSTR
)RT_RCDATA
)))
585 return D3DXERR_INVALIDDATA
;
586 if (FAILED(load_resource_into_memory(module
, res
, (LPVOID
*)&buffer
, &len
)))
587 return D3DXERR_INVALIDDATA
;
588 return D3DXPreprocessShader(buffer
, len
, defines
, include
,
589 shader
, error_messages
);
592 HRESULT WINAPI
D3DXPreprocessShaderFromResourceW(HMODULE module
,
594 CONST D3DXMACRO
* defines
,
595 LPD3DXINCLUDE include
,
596 LPD3DXBUFFER
* shader
,
597 LPD3DXBUFFER
* error_messages
)
603 if (!(res
= FindResourceW(module
, resource
, (const WCHAR
*)RT_RCDATA
)))
604 return D3DXERR_INVALIDDATA
;
605 if (FAILED(load_resource_into_memory(module
, res
, (void **)&buffer
, &len
)))
606 return D3DXERR_INVALIDDATA
;
607 return D3DXPreprocessShader(buffer
, len
, defines
, include
,
608 shader
, error_messages
);
612 typedef struct ctab_constant
{
613 D3DXCONSTANT_DESC desc
;
614 struct ctab_constant
*members
;
617 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl
;
619 typedef struct ID3DXConstantTableImpl
{
620 const ID3DXConstantTableVtbl
*lpVtbl
;
624 D3DXCONSTANTTABLE_DESC desc
;
625 ctab_constant
*constants
;
626 } ID3DXConstantTableImpl
;
628 /*** IUnknown methods ***/
629 static HRESULT WINAPI
ID3DXConstantTableImpl_QueryInterface(ID3DXConstantTable
* iface
, REFIID riid
, void** ppvObject
)
631 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
633 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), ppvObject
);
635 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
636 IsEqualGUID(riid
, &IID_ID3DXBuffer
) ||
637 IsEqualGUID(riid
, &IID_ID3DXConstantTable
))
639 ID3DXConstantTable_AddRef(iface
);
644 WARN("Interface %s not found.\n", debugstr_guid(riid
));
646 return E_NOINTERFACE
;
649 static ULONG WINAPI
ID3DXConstantTableImpl_AddRef(ID3DXConstantTable
* iface
)
651 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
653 TRACE("(%p)->(): AddRef from %d\n", This
, This
->ref
);
655 return InterlockedIncrement(&This
->ref
);
658 static ULONG WINAPI
ID3DXConstantTableImpl_Release(ID3DXConstantTable
* iface
)
660 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
661 ULONG ref
= InterlockedDecrement(&This
->ref
);
663 TRACE("(%p)->(): Release from %d\n", This
, ref
+ 1);
667 HeapFree(GetProcessHeap(), 0, This
->constants
);
668 HeapFree(GetProcessHeap(), 0, This
->ctab
);
669 HeapFree(GetProcessHeap(), 0, This
);
675 /*** ID3DXBuffer methods ***/
676 static LPVOID WINAPI
ID3DXConstantTableImpl_GetBufferPointer(ID3DXConstantTable
* iface
)
678 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
680 TRACE("(%p)->()\n", This
);
685 static DWORD WINAPI
ID3DXConstantTableImpl_GetBufferSize(ID3DXConstantTable
* iface
)
687 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
689 TRACE("(%p)->()\n", This
);
694 /*** ID3DXConstantTable methods ***/
695 static HRESULT WINAPI
ID3DXConstantTableImpl_GetDesc(ID3DXConstantTable
* iface
, D3DXCONSTANTTABLE_DESC
*desc
)
697 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
699 TRACE("(%p)->(%p)\n", This
, desc
);
702 return D3DERR_INVALIDCALL
;
704 memcpy(desc
, &This
->desc
, sizeof(This
->desc
));
709 static HRESULT WINAPI
ID3DXConstantTableImpl_GetConstantDesc(ID3DXConstantTable
* iface
, D3DXHANDLE constant
,
710 D3DXCONSTANT_DESC
*desc
, UINT
*count
)
712 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
713 ctab_constant
*constant_info
;
715 TRACE("(%p)->(%p, %p, %p)\n", This
, constant
, desc
, count
);
718 return D3DERR_INVALIDCALL
;
720 /* Applications can pass the name of the constant in place of the handle */
721 if (!((UINT_PTR
)constant
>> 16))
722 constant_info
= &This
->constants
[(UINT_PTR
)constant
- 1];
725 D3DXHANDLE c
= ID3DXConstantTable_GetConstantByName(iface
, NULL
, constant
);
727 return D3DERR_INVALIDCALL
;
729 constant_info
= &This
->constants
[(UINT_PTR
)c
- 1];
733 *desc
= constant_info
->desc
;
740 static UINT WINAPI
ID3DXConstantTableImpl_GetSamplerIndex(LPD3DXCONSTANTTABLE iface
, D3DXHANDLE constant
)
742 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
744 FIXME("(%p)->(%p): stub\n", This
, constant
);
749 static D3DXHANDLE WINAPI
ID3DXConstantTableImpl_GetConstant(ID3DXConstantTable
* iface
, D3DXHANDLE constant
, UINT index
)
751 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
753 TRACE("(%p)->(%p, %d)\n", This
, constant
, index
);
757 FIXME("Only top level constants supported\n");
761 if (index
>= This
->desc
.Constants
)
764 return (D3DXHANDLE
)(DWORD_PTR
)(index
+ 1);
767 static D3DXHANDLE WINAPI
ID3DXConstantTableImpl_GetConstantByName(ID3DXConstantTable
* iface
, D3DXHANDLE constant
, LPCSTR name
)
769 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
772 TRACE("(%p)->(%p, %s)\n", This
, constant
, name
);
779 FIXME("Only top level constants supported\n");
783 for (i
= 0; i
< This
->desc
.Constants
; i
++)
784 if (!strcmp(This
->constants
[i
].desc
.Name
, name
))
785 return (D3DXHANDLE
)(DWORD_PTR
)(i
+ 1);
790 static D3DXHANDLE WINAPI
ID3DXConstantTableImpl_GetConstantElement(ID3DXConstantTable
* iface
, D3DXHANDLE constant
, UINT index
)
792 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
794 FIXME("(%p)->(%p, %d): stub\n", This
, constant
, index
);
799 static HRESULT WINAPI
ID3DXConstantTableImpl_SetDefaults(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
)
801 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
803 FIXME("(%p)->(%p): stub\n", This
, device
);
808 static HRESULT WINAPI
ID3DXConstantTableImpl_SetValue(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
809 D3DXHANDLE constant
, LPCVOID data
, UINT bytes
)
811 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
813 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This
, device
, constant
, data
, bytes
);
818 static HRESULT WINAPI
ID3DXConstantTableImpl_SetBool(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
819 D3DXHANDLE constant
, BOOL b
)
821 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
823 FIXME("(%p)->(%p, %p, %d): stub\n", This
, device
, constant
, b
);
828 static HRESULT WINAPI
ID3DXConstantTableImpl_SetBoolArray(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
829 D3DXHANDLE constant
, CONST BOOL
* b
, UINT count
)
831 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
833 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This
, device
, constant
, b
, count
);
838 static HRESULT WINAPI
ID3DXConstantTableImpl_SetInt(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
, D3DXHANDLE constant
, INT n
)
840 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
842 FIXME("(%p)->(%p, %p, %d): stub\n", This
, device
, constant
, n
);
847 static HRESULT WINAPI
ID3DXConstantTableImpl_SetIntArray(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
848 D3DXHANDLE constant
, CONST INT
* n
, UINT count
)
850 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
852 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This
, device
, constant
, n
, count
);
857 static HRESULT WINAPI
ID3DXConstantTableImpl_SetFloat(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
858 D3DXHANDLE constant
, FLOAT f
)
860 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
862 FIXME("(%p)->(%p, %p, %f): stub\n", This
, device
, constant
, f
);
867 static HRESULT WINAPI
ID3DXConstantTableImpl_SetFloatArray(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
868 D3DXHANDLE constant
, CONST FLOAT
* f
, UINT count
)
870 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
872 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This
, device
, constant
, f
, count
);
877 static HRESULT WINAPI
ID3DXConstantTableImpl_SetVector(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
878 D3DXHANDLE constant
, CONST D3DXVECTOR4
* vector
)
880 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
882 FIXME("(%p)->(%p, %p, %p): stub\n", This
, device
, constant
, vector
);
887 static HRESULT WINAPI
ID3DXConstantTableImpl_SetVectorArray(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
888 D3DXHANDLE constant
, CONST D3DXVECTOR4
* vector
, UINT count
)
890 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
892 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This
, device
, constant
, vector
, count
);
897 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrix(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
898 D3DXHANDLE constant
, CONST D3DXMATRIX
* matrix
)
900 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
902 FIXME("(%p)->(%p, %p, %p): stub\n", This
, device
, constant
, matrix
);
907 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixArray(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
908 D3DXHANDLE constant
, CONST D3DXMATRIX
* matrix
, UINT count
)
910 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
912 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This
, device
, constant
, matrix
, count
);
917 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixPointerArray(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
918 D3DXHANDLE constant
, CONST D3DXMATRIX
** matrix
, UINT count
)
920 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
922 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This
, device
, constant
, matrix
, count
);
927 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixTranspose(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
928 D3DXHANDLE constant
, CONST D3DXMATRIX
* matrix
)
930 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
932 FIXME("(%p)->(%p, %p, %p): stub\n", This
, device
, constant
, matrix
);
937 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixTransposeArray(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
938 D3DXHANDLE constant
, CONST D3DXMATRIX
* matrix
, UINT count
)
940 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
942 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This
, device
, constant
, matrix
, count
);
947 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixTransposePointerArray(ID3DXConstantTable
* iface
, LPDIRECT3DDEVICE9 device
,
948 D3DXHANDLE constant
, CONST D3DXMATRIX
** matrix
, UINT count
)
950 ID3DXConstantTableImpl
*This
= (ID3DXConstantTableImpl
*)iface
;
952 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This
, device
, constant
, matrix
, count
);
957 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl
=
959 /*** IUnknown methods ***/
960 ID3DXConstantTableImpl_QueryInterface
,
961 ID3DXConstantTableImpl_AddRef
,
962 ID3DXConstantTableImpl_Release
,
963 /*** ID3DXBuffer methods ***/
964 ID3DXConstantTableImpl_GetBufferPointer
,
965 ID3DXConstantTableImpl_GetBufferSize
,
966 /*** ID3DXConstantTable methods ***/
967 ID3DXConstantTableImpl_GetDesc
,
968 ID3DXConstantTableImpl_GetConstantDesc
,
969 ID3DXConstantTableImpl_GetSamplerIndex
,
970 ID3DXConstantTableImpl_GetConstant
,
971 ID3DXConstantTableImpl_GetConstantByName
,
972 ID3DXConstantTableImpl_GetConstantElement
,
973 ID3DXConstantTableImpl_SetDefaults
,
974 ID3DXConstantTableImpl_SetValue
,
975 ID3DXConstantTableImpl_SetBool
,
976 ID3DXConstantTableImpl_SetBoolArray
,
977 ID3DXConstantTableImpl_SetInt
,
978 ID3DXConstantTableImpl_SetIntArray
,
979 ID3DXConstantTableImpl_SetFloat
,
980 ID3DXConstantTableImpl_SetFloatArray
,
981 ID3DXConstantTableImpl_SetVector
,
982 ID3DXConstantTableImpl_SetVectorArray
,
983 ID3DXConstantTableImpl_SetMatrix
,
984 ID3DXConstantTableImpl_SetMatrixArray
,
985 ID3DXConstantTableImpl_SetMatrixPointerArray
,
986 ID3DXConstantTableImpl_SetMatrixTranspose
,
987 ID3DXConstantTableImpl_SetMatrixTransposeArray
,
988 ID3DXConstantTableImpl_SetMatrixTransposePointerArray
991 static HRESULT
parse_ctab_constant_type(const D3DXSHADER_TYPEINFO
*type
, ctab_constant
*constant
)
993 constant
->desc
.Class
= type
->Class
;
994 constant
->desc
.Type
= type
->Type
;
995 constant
->desc
.Rows
= type
->Rows
;
996 constant
->desc
.Columns
= type
->Columns
;
997 constant
->desc
.StructMembers
= type
->StructMembers
;
999 TRACE("class = %d, type = %d, rows = %d, columns = %d, struct_members = %d\n",
1000 constant
->desc
.Class
, constant
->desc
.Type
,
1001 constant
->desc
.Rows
, constant
->desc
.Columns
, constant
->desc
.StructMembers
);
1003 if ((constant
->desc
.Class
== D3DXPC_STRUCT
) && constant
->desc
.StructMembers
)
1005 FIXME("Struct not supported yet\n");
1012 HRESULT WINAPI
D3DXGetShaderConstantTableEx(CONST DWORD
* byte_code
,
1014 LPD3DXCONSTANTTABLE
* constant_table
)
1016 ID3DXConstantTableImpl
* object
= NULL
;
1020 const D3DXSHADER_CONSTANTTABLE
* ctab_header
;
1021 D3DXSHADER_CONSTANTINFO
* constant_info
;
1024 TRACE("(%p, %x, %p)\n", byte_code
, flags
, constant_table
);
1026 if (!byte_code
|| !constant_table
)
1027 return D3DERR_INVALIDCALL
;
1029 hr
= D3DXFindShaderComment(byte_code
, MAKEFOURCC('C','T','A','B'), &data
, &size
);
1031 return D3DXERR_INVALIDDATA
;
1033 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(ID3DXConstantTableImpl
));
1036 ERR("Out of memory\n");
1037 return E_OUTOFMEMORY
;
1040 object
->lpVtbl
= &ID3DXConstantTable_Vtbl
;
1043 if (size
< sizeof(D3DXSHADER_CONSTANTTABLE
))
1045 hr
= D3DXERR_INVALIDDATA
;
1049 object
->ctab
= HeapAlloc(GetProcessHeap(), 0, size
);
1052 ERR("Out of memory\n");
1056 object
->size
= size
;
1057 memcpy(object
->ctab
, data
, object
->size
);
1059 ctab_header
= (const D3DXSHADER_CONSTANTTABLE
*)data
;
1060 if (ctab_header
->Size
!= sizeof(D3DXSHADER_CONSTANTTABLE
))
1062 hr
= D3DXERR_INVALIDDATA
;
1065 object
->desc
.Creator
= ctab_header
->Creator
? object
->ctab
+ ctab_header
->Creator
: NULL
;
1066 object
->desc
.Version
= ctab_header
->Version
;
1067 object
->desc
.Constants
= ctab_header
->Constants
;
1068 if (object
->desc
.Creator
)
1069 TRACE("Creator = %s\n", object
->desc
.Creator
);
1070 TRACE("Version = %x\n", object
->desc
.Version
);
1071 TRACE("Constants = %d\n", ctab_header
->Constants
);
1072 if (ctab_header
->Target
)
1073 TRACE("Target = %s\n", object
->ctab
+ ctab_header
->Target
);
1075 if (object
->desc
.Constants
> 65535)
1077 FIXME("Too many constants (%u)\n", object
->desc
.Constants
);
1082 object
->constants
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
1083 sizeof(*object
->constants
) * object
->desc
.Constants
);
1084 if (!object
->constants
)
1086 ERR("Out of memory\n");
1091 constant_info
= (LPD3DXSHADER_CONSTANTINFO
)(object
->ctab
+ ctab_header
->ConstantInfo
);
1092 for (i
= 0; i
< ctab_header
->Constants
; i
++)
1094 TRACE("name = %s\n", object
->ctab
+ constant_info
[i
].Name
);
1095 object
->constants
[i
].desc
.Name
= object
->ctab
+ constant_info
[i
].Name
;
1096 object
->constants
[i
].desc
.RegisterSet
= constant_info
[i
].RegisterSet
;
1097 object
->constants
[i
].desc
.RegisterIndex
= constant_info
[i
].RegisterIndex
;
1098 object
->constants
[i
].desc
.RegisterCount
= 0;
1099 hr
= parse_ctab_constant_type((LPD3DXSHADER_TYPEINFO
)(object
->ctab
+ constant_info
[i
].TypeInfo
),
1100 &object
->constants
[i
]);
1105 *constant_table
= (LPD3DXCONSTANTTABLE
)object
;
1111 HeapFree(GetProcessHeap(), 0, object
->constants
);
1112 HeapFree(GetProcessHeap(), 0, object
->ctab
);
1113 HeapFree(GetProcessHeap(), 0, object
);
1118 HRESULT WINAPI
D3DXGetShaderConstantTable(CONST DWORD
* byte_code
,
1119 LPD3DXCONSTANTTABLE
* constant_table
)
1121 TRACE("(%p, %p): Forwarded to D3DXGetShaderConstantTableEx\n", byte_code
, constant_table
);
1123 return D3DXGetShaderConstantTableEx(byte_code
, 0, constant_table
);