2 * Copyright 2008 Luis Busquets
3 * Copyright 2009 Matteo Bruni
4 * Copyright 2011 Travis Athougies
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
24 #define NONAMELESSUNION
25 #define NONAMELESSSTRUCT
26 #include "wine/debug.h"
27 #include "wine/unicode.h"
31 #include "d3dcommon.h"
32 #include "d3dcompiler.h"
33 #include "d3dx9_36_private.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(d3dx
);
37 /* This function is not declared in the SDK headers yet. */
38 HRESULT WINAPI
D3DAssemble(const void *data
, SIZE_T datasize
, const char *filename
,
39 const D3D_SHADER_MACRO
*defines
, ID3DInclude
*include
, UINT flags
,
40 ID3DBlob
**shader
, ID3DBlob
**error_messages
);
42 static inline BOOL
is_valid_bytecode(DWORD token
)
44 return (token
& 0xfffe0000) == 0xfffe0000;
47 const char * WINAPI
D3DXGetPixelShaderProfile(struct IDirect3DDevice9
*device
)
51 TRACE("device %p\n", device
);
53 if (!device
) return NULL
;
55 IDirect3DDevice9_GetDeviceCaps(device
,&caps
);
57 switch (caps
.PixelShaderVersion
)
59 case D3DPS_VERSION(1, 1):
62 case D3DPS_VERSION(1, 2):
65 case D3DPS_VERSION(1, 3):
68 case D3DPS_VERSION(1, 4):
71 case D3DPS_VERSION(2, 0):
72 if ((caps
.PS20Caps
.NumTemps
>=22) &&
73 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_ARBITRARYSWIZZLE
) &&
74 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_GRADIENTINSTRUCTIONS
) &&
75 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_PREDICATION
) &&
76 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_NODEPENDENTREADLIMIT
) &&
77 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT
))
81 if ((caps
.PS20Caps
.NumTemps
>=32) &&
82 (caps
.PS20Caps
.Caps
&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT
))
88 case D3DPS_VERSION(3, 0):
95 UINT WINAPI
D3DXGetShaderSize(const DWORD
*byte_code
)
97 const DWORD
*ptr
= byte_code
;
99 TRACE("byte_code %p\n", byte_code
);
103 /* Look for the END token, skipping the VERSION token */
104 while (*++ptr
!= D3DSIO_END
)
107 if ((*ptr
& D3DSI_OPCODE_MASK
) == D3DSIO_COMMENT
)
109 ptr
+= ((*ptr
& D3DSI_COMMENTSIZE_MASK
) >> D3DSI_COMMENTSIZE_SHIFT
);
114 /* Return the shader size in bytes */
115 return (ptr
- byte_code
) * sizeof(*ptr
);
118 DWORD WINAPI
D3DXGetShaderVersion(const DWORD
*byte_code
)
120 TRACE("byte_code %p\n", byte_code
);
122 return byte_code
? *byte_code
: 0;
125 const char * WINAPI
D3DXGetVertexShaderProfile(struct IDirect3DDevice9
*device
)
129 TRACE("device %p\n", device
);
131 if (!device
) return NULL
;
133 IDirect3DDevice9_GetDeviceCaps(device
,&caps
);
135 switch (caps
.VertexShaderVersion
)
137 case D3DVS_VERSION(1, 1):
139 case D3DVS_VERSION(2, 0):
140 if ((caps
.VS20Caps
.NumTemps
>=13) &&
141 (caps
.VS20Caps
.DynamicFlowControlDepth
==24) &&
142 (caps
.VS20Caps
.Caps
&D3DPS20CAPS_PREDICATION
))
147 case D3DVS_VERSION(3, 0):
154 HRESULT WINAPI
D3DXFindShaderComment(const DWORD
*byte_code
, DWORD fourcc
, const void **data
, UINT
*size
)
156 const DWORD
*ptr
= byte_code
;
159 TRACE("byte_code %p, fourcc %x, data %p, size %p\n", byte_code
, fourcc
, data
, size
);
161 if (data
) *data
= NULL
;
164 if (!byte_code
) return D3DERR_INVALIDCALL
;
166 version
= *ptr
>> 16;
167 if (version
!= 0x4658 /* FX */
168 && version
!= 0x5458 /* TX */
171 && version
!= 0xfffe /* VS */
172 && version
!= 0xffff) /* PS */
174 WARN("Invalid data supplied\n");
175 return D3DXERR_INVALIDDATA
;
178 while (*++ptr
!= D3DSIO_END
)
180 /* Check if it is a comment */
181 if ((*ptr
& D3DSI_OPCODE_MASK
) == D3DSIO_COMMENT
)
183 DWORD comment_size
= (*ptr
& D3DSI_COMMENTSIZE_MASK
) >> D3DSI_COMMENTSIZE_SHIFT
;
185 /* Check if this is the comment we are looking for */
186 if (*(ptr
+ 1) == fourcc
)
188 UINT ctab_size
= (comment_size
- 1) * sizeof(DWORD
);
189 const void *ctab_data
= ptr
+ 2;
194 TRACE("Returning comment data at %p with size %d\n", ctab_data
, ctab_size
);
204 HRESULT WINAPI
D3DXAssembleShader(const char *data
, UINT data_len
, const D3DXMACRO
*defines
,
205 ID3DXInclude
*include
, DWORD flags
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
209 TRACE("data %p, data_len %u, defines %p, include %p, flags %#x, shader %p, error_messages %p\n",
210 data
, data_len
, defines
, include
, flags
, shader
, error_messages
);
212 /* Forward to d3dcompiler: the parameter types aren't really different,
213 the actual data types are equivalent */
214 hr
= D3DAssemble(data
, data_len
, NULL
, (D3D_SHADER_MACRO
*)defines
,
215 (ID3DInclude
*)include
, flags
, (ID3DBlob
**)shader
,
216 (ID3DBlob
**)error_messages
);
218 if(hr
== E_FAIL
) hr
= D3DXERR_INVALIDDATA
;
222 static const void *main_file_data
;
224 static CRITICAL_SECTION from_file_mutex
;
225 static CRITICAL_SECTION_DEBUG from_file_mutex_debug
=
227 0, 0, &from_file_mutex
,
229 &from_file_mutex_debug
.ProcessLocksList
,
230 &from_file_mutex_debug
.ProcessLocksList
232 0, 0, {(DWORD_PTR
)(__FILE__
": from_file_mutex")}
234 static CRITICAL_SECTION from_file_mutex
= {&from_file_mutex_debug
, -1, 0, 0, 0, 0};
236 /* D3DXInclude private implementation, used to implement
237 * D3DXAssembleShaderFromFile() from D3DXAssembleShader(). */
238 /* To be able to correctly resolve include search paths we have to store the
239 * pathname of each include file. We store the pathname pointer right before
241 static HRESULT WINAPI
d3dincludefromfile_open(ID3DXInclude
*iface
, D3DXINCLUDE_TYPE include_type
,
242 const char *filename
, const void *parent_data
, const void **data
, UINT
*bytes
)
244 const char *p
, *parent_name
= "";
245 char *pathname
= NULL
, *ptr
;
246 char **buffer
= NULL
;
252 parent_name
= *((const char **)parent_data
- 1);
257 parent_name
= *((const char **)main_file_data
- 1);
260 TRACE("Looking up for include file %s, parent %s\n", debugstr_a(filename
), debugstr_a(parent_name
));
262 if ((p
= strrchr(parent_name
, '\\')))
266 pathname
= HeapAlloc(GetProcessHeap(), 0, (p
- parent_name
) + strlen(filename
) + 1);
268 return HRESULT_FROM_WIN32(GetLastError());
270 memcpy(pathname
, parent_name
, p
- parent_name
);
271 strcpy(pathname
+ (p
- parent_name
), filename
);
272 ptr
= pathname
+ (p
- parent_name
);
280 file
= CreateFileA(pathname
, GENERIC_READ
, FILE_SHARE_READ
, 0, OPEN_EXISTING
, 0, 0);
281 if(file
== INVALID_HANDLE_VALUE
)
284 TRACE("Include file found at pathname = %s\n", debugstr_a(pathname
));
286 size
= GetFileSize(file
, NULL
);
287 if(size
== INVALID_FILE_SIZE
)
290 buffer
= HeapAlloc(GetProcessHeap(), 0, size
+ sizeof(char *));
294 if(!ReadFile(file
, buffer
+ 1, size
, bytes
, NULL
))
299 main_file_data
= *data
;
306 HeapFree(GetProcessHeap(), 0, pathname
);
307 HeapFree(GetProcessHeap(), 0, buffer
);
308 return HRESULT_FROM_WIN32(GetLastError());
311 static HRESULT WINAPI
d3dincludefromfile_close(ID3DXInclude
*iface
, const void *data
)
313 HeapFree(GetProcessHeap(), 0, *((char **)data
- 1));
314 HeapFree(GetProcessHeap(), 0, (char **)data
- 1);
315 if (main_file_data
== data
)
316 main_file_data
= NULL
;
320 static const struct ID3DXIncludeVtbl D3DXInclude_Vtbl
= {
321 d3dincludefromfile_open
,
322 d3dincludefromfile_close
325 struct D3DXIncludeImpl
{
326 ID3DXInclude ID3DXInclude_iface
;
329 HRESULT WINAPI
D3DXAssembleShaderFromFileA(const char *filename
, const D3DXMACRO
*defines
,
330 ID3DXInclude
*include
, DWORD flags
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
336 TRACE("filename %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
337 debugstr_a(filename
), defines
, include
, flags
, shader
, error_messages
);
339 if (!filename
) return D3DXERR_INVALIDDATA
;
341 len
= MultiByteToWideChar(CP_ACP
, 0, filename
, -1, NULL
, 0);
342 filename_w
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
343 if (!filename_w
) return E_OUTOFMEMORY
;
344 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filename_w
, len
);
346 ret
= D3DXAssembleShaderFromFileW(filename_w
, defines
, include
, flags
, shader
, error_messages
);
348 HeapFree(GetProcessHeap(), 0, filename_w
);
352 HRESULT WINAPI
D3DXAssembleShaderFromFileW(const WCHAR
*filename
, const D3DXMACRO
*defines
,
353 ID3DXInclude
*include
, DWORD flags
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
358 struct D3DXIncludeImpl includefromfile
;
361 TRACE("filename %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
362 debugstr_w(filename
), defines
, include
, flags
, shader
, error_messages
);
366 includefromfile
.ID3DXInclude_iface
.lpVtbl
= &D3DXInclude_Vtbl
;
367 include
= &includefromfile
.ID3DXInclude_iface
;
370 len
= WideCharToMultiByte(CP_ACP
, 0, filename
, -1, NULL
, 0, NULL
, NULL
);
371 filename_a
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(char));
373 return E_OUTOFMEMORY
;
374 WideCharToMultiByte(CP_ACP
, 0, filename
, -1, filename_a
, len
, NULL
, NULL
);
376 EnterCriticalSection(&from_file_mutex
);
377 hr
= ID3DXInclude_Open(include
, D3D_INCLUDE_LOCAL
, filename_a
, NULL
, &buffer
, &len
);
380 LeaveCriticalSection(&from_file_mutex
);
381 HeapFree(GetProcessHeap(), 0, filename_a
);
382 return D3DXERR_INVALIDDATA
;
385 hr
= D3DXAssembleShader(buffer
, len
, defines
, include
, flags
, shader
, error_messages
);
387 ID3DXInclude_Close(include
, buffer
);
388 LeaveCriticalSection(&from_file_mutex
);
389 HeapFree(GetProcessHeap(), 0, filename_a
);
393 HRESULT WINAPI
D3DXAssembleShaderFromResourceA(HMODULE module
, const char *resource
, const D3DXMACRO
*defines
,
394 ID3DXInclude
*include
, DWORD flags
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
400 TRACE("module %p, resource %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
401 module
, debugstr_a(resource
), defines
, include
, flags
, shader
, error_messages
);
403 if (!(res
= FindResourceA(module
, resource
, (const char *)RT_RCDATA
)))
404 return D3DXERR_INVALIDDATA
;
405 if (FAILED(load_resource_into_memory(module
, res
, &buffer
, &len
)))
406 return D3DXERR_INVALIDDATA
;
407 return D3DXAssembleShader(buffer
, len
, defines
, include
, flags
,
408 shader
, error_messages
);
411 HRESULT WINAPI
D3DXAssembleShaderFromResourceW(HMODULE module
, const WCHAR
*resource
, const D3DXMACRO
*defines
,
412 ID3DXInclude
*include
, DWORD flags
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
418 TRACE("module %p, resource %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
419 module
, debugstr_w(resource
), defines
, include
, flags
, shader
, error_messages
);
421 if (!(res
= FindResourceW(module
, resource
, (const WCHAR
*)RT_RCDATA
)))
422 return D3DXERR_INVALIDDATA
;
423 if (FAILED(load_resource_into_memory(module
, res
, &buffer
, &len
)))
424 return D3DXERR_INVALIDDATA
;
425 return D3DXAssembleShader(buffer
, len
, defines
, include
, flags
,
426 shader
, error_messages
);
429 HRESULT WINAPI
D3DXCompileShader(const char *data
, UINT length
, const D3DXMACRO
*defines
,
430 ID3DXInclude
*include
, const char *function
, const char *profile
, DWORD flags
,
431 ID3DXBuffer
**shader
, ID3DXBuffer
**error_msgs
, ID3DXConstantTable
**constant_table
)
435 TRACE("data %s, length %u, defines %p, include %p, function %s, profile %s, "
436 "flags %#x, shader %p, error_msgs %p, constant_table %p.\n",
437 debugstr_a(data
), length
, defines
, include
, debugstr_a(function
), debugstr_a(profile
),
438 flags
, shader
, error_msgs
, constant_table
);
440 hr
= D3DCompile(data
, length
, NULL
, (D3D_SHADER_MACRO
*)defines
, (ID3DInclude
*)include
,
441 function
, profile
, flags
, 0, (ID3DBlob
**)shader
, (ID3DBlob
**)error_msgs
);
443 if (SUCCEEDED(hr
) && constant_table
)
445 hr
= D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*shader
), constant_table
);
448 ID3DXBuffer_Release(*shader
);
456 HRESULT WINAPI
D3DXCompileShaderFromFileA(const char *filename
, const D3DXMACRO
*defines
,
457 ID3DXInclude
*include
, const char *entrypoint
, const char *profile
, DWORD flags
,
458 ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
, ID3DXConstantTable
**constant_table
)
464 TRACE("filename %s, defines %p, include %p, entrypoint %s, profile %s, "
465 "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
466 debugstr_a(filename
), defines
, include
, debugstr_a(entrypoint
),
467 debugstr_a(profile
), flags
, shader
, error_messages
, constant_table
);
469 if (!filename
) return D3DXERR_INVALIDDATA
;
471 len
= MultiByteToWideChar(CP_ACP
, 0, filename
, -1, NULL
, 0);
472 filename_w
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
473 if (!filename_w
) return E_OUTOFMEMORY
;
474 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filename_w
, len
);
476 ret
= D3DXCompileShaderFromFileW(filename_w
, defines
, include
,
477 entrypoint
, profile
, flags
,
478 shader
, error_messages
, constant_table
);
480 HeapFree(GetProcessHeap(), 0, filename_w
);
484 HRESULT WINAPI
D3DXCompileShaderFromFileW(const WCHAR
*filename
, const D3DXMACRO
*defines
,
485 ID3DXInclude
*include
, const char *entrypoint
, const char *profile
, DWORD flags
,
486 ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
, ID3DXConstantTable
**constant_table
)
489 DWORD len
, filename_len
;
491 struct D3DXIncludeImpl includefromfile
;
494 TRACE("filename %s, defines %p, include %p, entrypoint %s, profile %s, "
495 "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
496 debugstr_w(filename
), defines
, include
, debugstr_a(entrypoint
), debugstr_a(profile
),
497 flags
, shader
, error_messages
, constant_table
);
501 includefromfile
.ID3DXInclude_iface
.lpVtbl
= &D3DXInclude_Vtbl
;
502 include
= &includefromfile
.ID3DXInclude_iface
;
505 filename_len
= WideCharToMultiByte(CP_ACP
, 0, filename
, -1, NULL
, 0, NULL
, NULL
);
506 filename_a
= HeapAlloc(GetProcessHeap(), 0, filename_len
* sizeof(char));
508 return E_OUTOFMEMORY
;
509 WideCharToMultiByte(CP_ACP
, 0, filename
, -1, filename_a
, filename_len
, NULL
, NULL
);
511 EnterCriticalSection(&from_file_mutex
);
512 hr
= ID3DXInclude_Open(include
, D3D_INCLUDE_LOCAL
, filename_a
, NULL
, &buffer
, &len
);
515 LeaveCriticalSection(&from_file_mutex
);
516 HeapFree(GetProcessHeap(), 0, filename_a
);
517 return D3DXERR_INVALIDDATA
;
520 hr
= D3DCompile(buffer
, len
, filename_a
, (const D3D_SHADER_MACRO
*)defines
,
521 (ID3DInclude
*)include
, entrypoint
, profile
, flags
, 0,
522 (ID3DBlob
**)shader
, (ID3DBlob
**)error_messages
);
524 if (SUCCEEDED(hr
) && constant_table
)
525 hr
= D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*shader
),
528 ID3DXInclude_Close(include
, buffer
);
529 LeaveCriticalSection(&from_file_mutex
);
530 HeapFree(GetProcessHeap(), 0, filename_a
);
534 HRESULT WINAPI
D3DXCompileShaderFromResourceA(HMODULE module
, const char *resource
, const D3DXMACRO
*defines
,
535 ID3DXInclude
*include
, const char *entrypoint
, const char *profile
, DWORD flags
,
536 ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
, ID3DXConstantTable
**constant_table
)
542 TRACE("module %p, resource %s, defines %p, include %p, entrypoint %s, profile %s, "
543 "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
544 module
, debugstr_a(resource
), defines
, include
, debugstr_a(entrypoint
), debugstr_a(profile
),
545 flags
, shader
, error_messages
, constant_table
);
547 if (!(res
= FindResourceA(module
, resource
, (const char *)RT_RCDATA
)))
548 return D3DXERR_INVALIDDATA
;
549 if (FAILED(load_resource_into_memory(module
, res
, &buffer
, &len
)))
550 return D3DXERR_INVALIDDATA
;
551 return D3DXCompileShader(buffer
, len
, defines
, include
, entrypoint
, profile
,
552 flags
, shader
, error_messages
, constant_table
);
555 HRESULT WINAPI
D3DXCompileShaderFromResourceW(HMODULE module
, const WCHAR
*resource
, const D3DXMACRO
*defines
,
556 ID3DXInclude
*include
, const char *entrypoint
, const char *profile
, DWORD flags
,
557 ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
, ID3DXConstantTable
**constant_table
)
563 TRACE("module %p, resource %s, defines %p, include %p, entrypoint %s, profile %s, "
564 "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
565 module
, debugstr_w(resource
), defines
, include
, debugstr_a(entrypoint
), debugstr_a(profile
),
566 flags
, shader
, error_messages
, constant_table
);
568 if (!(res
= FindResourceW(module
, resource
, (const WCHAR
*)RT_RCDATA
)))
569 return D3DXERR_INVALIDDATA
;
570 if (FAILED(load_resource_into_memory(module
, res
, &buffer
, &len
)))
571 return D3DXERR_INVALIDDATA
;
572 return D3DXCompileShader(buffer
, len
, defines
, include
, entrypoint
, profile
,
573 flags
, shader
, error_messages
, constant_table
);
576 HRESULT WINAPI
D3DXPreprocessShader(const char *data
, UINT data_len
, const D3DXMACRO
*defines
,
577 ID3DXInclude
*include
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
579 TRACE("data %s, data_len %u, defines %p, include %p, shader %p, error_messages %p.\n",
580 debugstr_a(data
), data_len
, defines
, include
, shader
, error_messages
);
582 return D3DPreprocess(data
, data_len
, NULL
,
583 (const D3D_SHADER_MACRO
*)defines
, (ID3DInclude
*)include
,
584 (ID3DBlob
**)shader
, (ID3DBlob
**)error_messages
);
587 HRESULT WINAPI
D3DXPreprocessShaderFromFileA(const char *filename
, const D3DXMACRO
*defines
,
588 ID3DXInclude
*include
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
590 WCHAR
*filename_w
= NULL
;
594 TRACE("filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
595 debugstr_a(filename
), defines
, include
, shader
, error_messages
);
597 if (!filename
) return D3DXERR_INVALIDDATA
;
599 len
= MultiByteToWideChar(CP_ACP
, 0, filename
, -1, NULL
, 0);
600 filename_w
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
601 if (!filename_w
) return E_OUTOFMEMORY
;
602 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filename_w
, len
);
604 ret
= D3DXPreprocessShaderFromFileW(filename_w
, defines
, include
, shader
, error_messages
);
606 HeapFree(GetProcessHeap(), 0, filename_w
);
610 HRESULT WINAPI
D3DXPreprocessShaderFromFileW(const WCHAR
*filename
, const D3DXMACRO
*defines
,
611 ID3DXInclude
*include
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
616 struct D3DXIncludeImpl includefromfile
;
619 TRACE("filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
620 debugstr_w(filename
), defines
, include
, shader
, error_messages
);
624 includefromfile
.ID3DXInclude_iface
.lpVtbl
= &D3DXInclude_Vtbl
;
625 include
= &includefromfile
.ID3DXInclude_iface
;
628 len
= WideCharToMultiByte(CP_ACP
, 0, filename
, -1, NULL
, 0, NULL
, NULL
);
629 filename_a
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(char));
631 return E_OUTOFMEMORY
;
632 WideCharToMultiByte(CP_ACP
, 0, filename
, -1, filename_a
, len
, NULL
, NULL
);
634 EnterCriticalSection(&from_file_mutex
);
635 hr
= ID3DXInclude_Open(include
, D3D_INCLUDE_LOCAL
, filename_a
, NULL
, &buffer
, &len
);
638 LeaveCriticalSection(&from_file_mutex
);
639 HeapFree(GetProcessHeap(), 0, filename_a
);
640 return D3DXERR_INVALIDDATA
;
643 hr
= D3DPreprocess(buffer
, len
, NULL
,
644 (const D3D_SHADER_MACRO
*)defines
,
645 (ID3DInclude
*) include
,
646 (ID3DBlob
**)shader
, (ID3DBlob
**)error_messages
);
648 ID3DXInclude_Close(include
, buffer
);
649 LeaveCriticalSection(&from_file_mutex
);
650 HeapFree(GetProcessHeap(), 0, filename_a
);
654 HRESULT WINAPI
D3DXPreprocessShaderFromResourceA(HMODULE module
, const char *resource
, const D3DXMACRO
*defines
,
655 ID3DXInclude
*include
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
661 TRACE("module %p, resource %s, defines %p, include %p, shader %p, error_messages %p.\n",
662 module
, debugstr_a(resource
), defines
, include
, shader
, error_messages
);
664 if (!(res
= FindResourceA(module
, resource
, (const char *)RT_RCDATA
)))
665 return D3DXERR_INVALIDDATA
;
666 if (FAILED(load_resource_into_memory(module
, res
, &buffer
, &len
)))
667 return D3DXERR_INVALIDDATA
;
668 return D3DXPreprocessShader(buffer
, len
, defines
, include
,
669 shader
, error_messages
);
672 HRESULT WINAPI
D3DXPreprocessShaderFromResourceW(HMODULE module
, const WCHAR
*resource
, const D3DXMACRO
*defines
,
673 ID3DXInclude
*include
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_messages
)
679 TRACE("module %p, resource %s, defines %p, include %p, shader %p, error_messages %p.\n",
680 module
, debugstr_w(resource
), defines
, include
, shader
, error_messages
);
682 if (!(res
= FindResourceW(module
, resource
, (const WCHAR
*)RT_RCDATA
)))
683 return D3DXERR_INVALIDDATA
;
684 if (FAILED(load_resource_into_memory(module
, res
, &buffer
, &len
)))
685 return D3DXERR_INVALIDDATA
;
686 return D3DXPreprocessShader(buffer
, len
, defines
, include
,
687 shader
, error_messages
);
691 struct ctab_constant
{
692 D3DXCONSTANT_DESC desc
;
693 struct ctab_constant
*constants
;
696 struct ID3DXConstantTableImpl
{
697 ID3DXConstantTable ID3DXConstantTable_iface
;
701 D3DXCONSTANTTABLE_DESC desc
;
702 struct ctab_constant
*constants
;
705 static void free_constant(struct ctab_constant
*constant
)
707 if (constant
->constants
)
709 UINT i
, count
= constant
->desc
.Elements
> 1 ? constant
->desc
.Elements
: constant
->desc
.StructMembers
;
711 for (i
= 0; i
< count
; ++i
)
713 free_constant(&constant
->constants
[i
]);
715 HeapFree(GetProcessHeap(), 0, constant
->constants
);
719 static void free_constant_table(struct ID3DXConstantTableImpl
*table
)
721 if (table
->constants
)
725 for (i
= 0; i
< table
->desc
.Constants
; ++i
)
727 free_constant(&table
->constants
[i
]);
729 HeapFree(GetProcessHeap(), 0, table
->constants
);
731 HeapFree(GetProcessHeap(), 0, table
->ctab
);
734 static inline struct ID3DXConstantTableImpl
*impl_from_ID3DXConstantTable(ID3DXConstantTable
*iface
)
736 return CONTAINING_RECORD(iface
, struct ID3DXConstantTableImpl
, ID3DXConstantTable_iface
);
739 static inline BOOL
is_vertex_shader(DWORD version
)
741 return (version
& 0xffff0000) == 0xfffe0000;
744 static inline D3DXHANDLE
handle_from_constant(struct ctab_constant
*constant
)
746 return (D3DXHANDLE
)constant
;
749 static struct ctab_constant
*get_constant_by_name(struct ID3DXConstantTableImpl
*table
,
750 struct ctab_constant
*constant
, const char *name
);
752 static struct ctab_constant
*get_constant_element_by_name(struct ctab_constant
*constant
, const char *name
)
757 TRACE("constant %p, name %s\n", constant
, debugstr_a(name
));
759 if (!name
|| !*name
) return NULL
;
761 element
= atoi(name
);
762 part
= strchr(name
, ']') + 1;
764 if (constant
->desc
.Elements
> element
)
766 struct ctab_constant
*c
= constant
->constants
? &constant
->constants
[element
] : constant
;
771 return get_constant_by_name(NULL
, c
, part
);
774 return get_constant_element_by_name(c
, part
);
777 TRACE("Returning parameter %p\n", c
);
781 FIXME("Unhandled case \"%c\"\n", *--part
);
786 TRACE("Constant not found\n");
790 static struct ctab_constant
*get_constant_by_name(struct ID3DXConstantTableImpl
*table
,
791 struct ctab_constant
*constant
, const char *name
)
793 UINT i
, count
, length
;
794 struct ctab_constant
*handles
;
797 TRACE("table %p, constant %p, name %s\n", table
, constant
, debugstr_a(name
));
799 if (!name
|| !*name
) return NULL
;
803 count
= table
->desc
.Constants
;
804 handles
= table
->constants
;
808 count
= constant
->desc
.StructMembers
;
809 handles
= constant
->constants
;
812 length
= strcspn(name
, "[.");
813 part
= name
+ length
;
815 for (i
= 0; i
< count
; i
++)
817 if (strlen(handles
[i
].desc
.Name
) == length
&& !strncmp(handles
[i
].desc
.Name
, name
, length
))
822 return get_constant_by_name(NULL
, &handles
[i
], part
);
825 return get_constant_element_by_name(&handles
[i
], part
);
828 TRACE("Returning parameter %p\n", &handles
[i
]);
834 TRACE("Constant not found\n");
838 static struct ctab_constant
*is_valid_sub_constant(struct ctab_constant
*parent
, D3DXHANDLE handle
)
840 struct ctab_constant
*c
;
843 /* all variable have at least elements = 1, but not always elements */
844 if (!parent
->constants
) return NULL
;
846 count
= parent
->desc
.Elements
> 1 ? parent
->desc
.Elements
: parent
->desc
.StructMembers
;
847 for (i
= 0; i
< count
; ++i
)
849 if (handle_from_constant(&parent
->constants
[i
]) == handle
)
850 return &parent
->constants
[i
];
852 c
= is_valid_sub_constant(&parent
->constants
[i
], handle
);
859 static inline struct ctab_constant
*get_valid_constant(struct ID3DXConstantTableImpl
*table
, D3DXHANDLE handle
)
861 struct ctab_constant
*c
;
864 if (!handle
) return NULL
;
866 for (i
= 0; i
< table
->desc
.Constants
; ++i
)
868 if (handle_from_constant(&table
->constants
[i
]) == handle
)
869 return &table
->constants
[i
];
871 c
= is_valid_sub_constant(&table
->constants
[i
], handle
);
875 return get_constant_by_name(table
, NULL
, handle
);
878 /*** IUnknown methods ***/
879 static HRESULT WINAPI
ID3DXConstantTableImpl_QueryInterface(ID3DXConstantTable
*iface
, REFIID riid
, void **out
)
881 TRACE("iface %p, riid %s, out %p.\n", iface
, debugstr_guid(riid
), out
);
883 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
884 IsEqualGUID(riid
, &IID_ID3DXBuffer
) ||
885 IsEqualGUID(riid
, &IID_ID3DXConstantTable
))
887 ID3DXConstantTable_AddRef(iface
);
892 WARN("Interface %s not found.\n", debugstr_guid(riid
));
894 return E_NOINTERFACE
;
897 static ULONG WINAPI
ID3DXConstantTableImpl_AddRef(ID3DXConstantTable
*iface
)
899 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
901 TRACE("(%p)->(): AddRef from %d\n", This
, This
->ref
);
903 return InterlockedIncrement(&This
->ref
);
906 static ULONG WINAPI
ID3DXConstantTableImpl_Release(ID3DXConstantTable
*iface
)
908 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
909 ULONG ref
= InterlockedDecrement(&This
->ref
);
911 TRACE("(%p)->(): Release from %d\n", This
, ref
+ 1);
915 free_constant_table(This
);
916 HeapFree(GetProcessHeap(), 0, This
);
922 /*** ID3DXBuffer methods ***/
923 static void * WINAPI
ID3DXConstantTableImpl_GetBufferPointer(ID3DXConstantTable
*iface
)
925 struct ID3DXConstantTableImpl
*table
= impl_from_ID3DXConstantTable(iface
);
927 TRACE("iface %p.\n", iface
);
932 static DWORD WINAPI
ID3DXConstantTableImpl_GetBufferSize(ID3DXConstantTable
*iface
)
934 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
936 TRACE("(%p)->()\n", This
);
941 /*** ID3DXConstantTable methods ***/
942 static HRESULT WINAPI
ID3DXConstantTableImpl_GetDesc(ID3DXConstantTable
*iface
, D3DXCONSTANTTABLE_DESC
*desc
)
944 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
946 TRACE("(%p)->(%p)\n", This
, desc
);
949 return D3DERR_INVALIDCALL
;
956 static HRESULT WINAPI
ID3DXConstantTableImpl_GetConstantDesc(ID3DXConstantTable
*iface
, D3DXHANDLE constant
,
957 D3DXCONSTANT_DESC
*desc
, UINT
*count
)
959 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
960 struct ctab_constant
*c
= get_valid_constant(This
, constant
);
962 TRACE("(%p)->(%p, %p, %p)\n", This
, constant
, desc
, count
);
966 WARN("Invalid argument specified\n");
967 return D3DERR_INVALIDCALL
;
970 if (desc
) *desc
= c
->desc
;
971 if (count
) *count
= 1;
976 static UINT WINAPI
ID3DXConstantTableImpl_GetSamplerIndex(ID3DXConstantTable
*iface
, D3DXHANDLE constant
)
978 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
979 struct ctab_constant
*c
= get_valid_constant(This
, constant
);
981 TRACE("(%p)->(%p)\n", This
, constant
);
983 if (!c
|| c
->desc
.RegisterSet
!= D3DXRS_SAMPLER
)
985 WARN("Invalid argument specified\n");
989 TRACE("Returning RegisterIndex %u\n", c
->desc
.RegisterIndex
);
990 return c
->desc
.RegisterIndex
;
993 static D3DXHANDLE WINAPI
ID3DXConstantTableImpl_GetConstant(ID3DXConstantTable
*iface
, D3DXHANDLE constant
, UINT index
)
995 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
996 struct ctab_constant
*c
;
998 TRACE("(%p)->(%p, %d)\n", This
, constant
, index
);
1002 c
= get_valid_constant(This
, constant
);
1003 if (c
&& index
< c
->desc
.StructMembers
)
1005 c
= &c
->constants
[index
];
1006 TRACE("Returning constant %p\n", c
);
1007 return handle_from_constant(c
);
1012 if (index
< This
->desc
.Constants
)
1014 c
= &This
->constants
[index
];
1015 TRACE("Returning constant %p\n", c
);
1016 return handle_from_constant(c
);
1020 WARN("Index out of range\n");
1024 static D3DXHANDLE WINAPI
ID3DXConstantTableImpl_GetConstantByName(ID3DXConstantTable
*iface
,
1025 D3DXHANDLE constant
, const char *name
)
1027 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1028 struct ctab_constant
*c
= get_valid_constant(This
, constant
);
1030 TRACE("iface %p, constant %p, name %s.\n", iface
, constant
, debugstr_a(name
));
1032 c
= get_constant_by_name(This
, c
, name
);
1033 TRACE("Returning constant %p\n", c
);
1035 return handle_from_constant(c
);
1038 static D3DXHANDLE WINAPI
ID3DXConstantTableImpl_GetConstantElement(ID3DXConstantTable
*iface
, D3DXHANDLE constant
, UINT index
)
1040 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1041 struct ctab_constant
*c
= get_valid_constant(This
, constant
);
1043 TRACE("(%p)->(%p, %d)\n", This
, constant
, index
);
1045 if (c
&& index
< c
->desc
.Elements
)
1047 if (c
->desc
.Elements
> 1) c
= &c
->constants
[index
];
1048 TRACE("Returning constant %p\n", c
);
1049 return handle_from_constant(c
);
1052 WARN("Invalid argument specified\n");
1056 static inline DWORD
get_index(const void **indata
, UINT index
, BOOL is_pointer
)
1062 return ((DWORD
**)indata
)[index
/ 16][index
% 16];
1064 return (*((DWORD
**)indata
))[index
];
1067 static UINT
set(struct ID3DXConstantTableImpl
*table
, IDirect3DDevice9
*device
, struct ctab_constant
*constant
,
1068 const void **indata
, D3DXPARAMETER_TYPE intype
, UINT
*size
, UINT incol
, D3DXPARAMETER_CLASS inclass
, UINT index
,
1071 D3DXCONSTANT_DESC
*desc
= &constant
->desc
;
1072 UINT l
, i
, regcount
= 1, regsize
= 1, cin
= 1, rin
= 1, ret
, last
= 0;
1075 /* size too small to set anything */
1076 if (*size
< desc
->Rows
* desc
->Columns
)
1082 /* D3DXPC_STRUCT is somewhat special */
1083 if (desc
->Class
== D3DXPC_STRUCT
)
1086 * Struct array sets the last complete input to the first struct element, all other
1087 * elements are not set.
1088 * E.g.: struct {int i;} s1[2];
1089 * SetValue(device, "s1", [1, 2], 8) => s1 = {2, x};
1091 * struct {int i; int n} s2[2];
1092 * SetValue(device, "s2", [1, 2, 3, 4, 5], 20) => s1 = {{3, 4}, {x, x}};
1094 if (desc
->Elements
> 1)
1096 UINT offset
= *size
/ (desc
->Rows
* desc
->Columns
) - 1;
1098 offset
= min(desc
->Elements
- 1, offset
);
1099 last
= offset
* desc
->Rows
* desc
->Columns
;
1101 if ((is_pointer
|| (!is_pointer
&& inclass
== D3DXPC_MATRIX_ROWS
)) && desc
->RegisterSet
!= D3DXRS_BOOL
)
1103 set(table
, device
, &constant
->constants
[0], NULL
, intype
, size
, incol
, inclass
, 0, is_pointer
);
1107 last
+= set(table
, device
, &constant
->constants
[0], indata
, intype
, size
, incol
, inclass
,
1108 index
+ last
, is_pointer
);
1114 * D3DXRS_BOOL is always set. As there are only 16 bools and there are
1115 * exactly 16 input values, use matrix transpose.
1117 if (inclass
== D3DXPC_MATRIX_ROWS
&& desc
->RegisterSet
== D3DXRS_BOOL
)
1119 D3DXMATRIX mat
, *m
, min
;
1120 D3DXMatrixTranspose(&mat
, &min
);
1123 min
= *(D3DXMATRIX
*)(indata
[index
/ 16]);
1125 min
= **(D3DXMATRIX
**)indata
;
1127 D3DXMatrixTranspose(&mat
, &min
);
1129 for (i
= 0; i
< desc
->StructMembers
; ++i
)
1131 last
+= set(table
, device
, &constant
->constants
[i
], (const void **)&m
, intype
, size
, incol
,
1132 D3DXPC_SCALAR
, index
+ last
, is_pointer
);
1136 * For pointers or for matrix rows, only the first member is set.
1137 * All other members are set to 0. This is not true for D3DXRS_BOOL.
1138 * E.g.: struct {int i; int n} s;
1139 * SetValue(device, "s", [1, 2], 8) => s = {1, 0};
1141 else if ((is_pointer
|| (!is_pointer
&& inclass
== D3DXPC_MATRIX_ROWS
)) && desc
->RegisterSet
!= D3DXRS_BOOL
)
1143 last
= set(table
, device
, &constant
->constants
[0], indata
, intype
, size
, incol
, inclass
,
1144 index
+ last
, is_pointer
);
1146 for (i
= 1; i
< desc
->StructMembers
; ++i
)
1148 set(table
, device
, &constant
->constants
[i
], NULL
, intype
, size
, incol
, inclass
, 0, is_pointer
);
1153 for (i
= 0; i
< desc
->StructMembers
; ++i
)
1155 last
+= set(table
, device
, &constant
->constants
[i
], indata
, intype
, size
, incol
, D3DXPC_SCALAR
,
1156 index
+ last
, is_pointer
);
1165 if (desc
->Elements
> 1)
1167 for (i
= 0; i
< desc
->Elements
&& *size
> 0; ++i
)
1169 last
+= set(table
, device
, &constant
->constants
[i
], indata
, intype
, size
, incol
, inclass
,
1170 index
+ last
, is_pointer
);
1172 /* adjust the vector size for matrix rows */
1173 if (inclass
== D3DXPC_MATRIX_ROWS
&& desc
->Class
== D3DXPC_VECTOR
&& (i
% 4) == 3)
1176 *size
= *size
< 12 ? 0 : *size
- 12;
1183 switch (desc
->Class
)
1187 case D3DXPC_MATRIX_ROWS
:
1188 regcount
= min(desc
->RegisterCount
, desc
->Rows
);
1189 if (inclass
== D3DXPC_MATRIX_ROWS
) cin
= incol
;
1191 regsize
= desc
->Columns
;
1194 case D3DXPC_MATRIX_COLUMNS
:
1195 regcount
= min(desc
->RegisterCount
, desc
->Columns
);
1196 if (inclass
== D3DXPC_MATRIX_ROWS
) rin
= incol
;
1198 regsize
= desc
->Rows
;
1202 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc
->Class
));
1206 /* specific stuff for different in types */
1210 ret
= desc
->Columns
* desc
->Rows
;
1211 *size
-= desc
->Columns
* desc
->Rows
;
1215 switch (desc
->Class
)
1217 case D3DXPC_MATRIX_ROWS
:
1218 if (*size
< regcount
* 4)
1224 *size
-= 4 * regcount
;
1227 case D3DXPC_MATRIX_COLUMNS
:
1229 *size
-= 4 * regcount
;
1243 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc
->Class
));
1248 case D3DXPC_MATRIX_ROWS
:
1249 switch (desc
->Class
)
1251 case D3DXPC_MATRIX_ROWS
:
1252 case D3DXPC_MATRIX_COLUMNS
:
1270 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc
->Class
));
1276 case D3DXPC_MATRIX_COLUMNS
:
1277 switch (desc
->Class
)
1279 case D3DXPC_MATRIX_ROWS
:
1280 case D3DXPC_MATRIX_COLUMNS
:
1298 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc
->Class
));
1305 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(inclass
));
1309 /* set the registers */
1310 switch (desc
->RegisterSet
)
1313 regcount
= min(desc
->RegisterCount
, desc
->Columns
* desc
->Rows
);
1315 for (i
= 0; i
< regcount
; ++i
)
1318 DWORD t
= get_index(indata
, index
+ i
/ regsize
* rin
+ l
* cin
, is_pointer
);
1320 set_number(&tmp
, desc
->Type
, &t
, intype
);
1321 set_number(&out
, D3DXPT_BOOL
, &tmp
, desc
->Type
);
1322 if (is_vertex_shader(table
->desc
.Version
))
1323 IDirect3DDevice9_SetVertexShaderConstantB(device
, desc
->RegisterIndex
+ i
, &out
, 1);
1325 IDirect3DDevice9_SetPixelShaderConstantB(device
, desc
->RegisterIndex
+ i
, &out
, 1);
1327 if (++l
>= regsize
) l
= 0;
1332 for (i
= 0; i
< regcount
; ++i
)
1334 INT vec
[4] = {0, 0, 1, 0};
1336 for (l
= 0; l
< regsize
; ++l
)
1338 DWORD t
= get_index(indata
, index
+ i
* rin
+ l
* cin
, is_pointer
);
1340 set_number(&tmp
, desc
->Type
, &t
, intype
);
1341 set_number(&vec
[l
], D3DXPT_INT
, &tmp
, desc
->Type
);
1343 if (is_vertex_shader(table
->desc
.Version
))
1344 IDirect3DDevice9_SetVertexShaderConstantI(device
, desc
->RegisterIndex
+ i
, vec
, 1);
1346 IDirect3DDevice9_SetPixelShaderConstantI(device
, desc
->RegisterIndex
+ i
, vec
, 1);
1351 for (i
= 0; i
< regcount
; ++i
)
1355 for (l
= 0; l
< regsize
; ++l
)
1357 DWORD t
= get_index(indata
, index
+ i
* rin
+ l
* cin
, is_pointer
);
1359 set_number(&tmp
, desc
->Type
, &t
, intype
);
1360 set_number(&vec
[l
], D3DXPT_FLOAT
, &tmp
, desc
->Type
);
1362 if (is_vertex_shader(table
->desc
.Version
))
1363 IDirect3DDevice9_SetVertexShaderConstantF(device
, desc
->RegisterIndex
+ i
, vec
, 1);
1365 IDirect3DDevice9_SetPixelShaderConstantF(device
, desc
->RegisterIndex
+ i
, vec
, 1);
1370 FIXME("Unhandled register set %s\n", debug_d3dxparameter_registerset(desc
->RegisterSet
));
1375 static HRESULT
set_scalar(struct ID3DXConstantTableImpl
*table
, IDirect3DDevice9
*device
, D3DXHANDLE constant
,
1376 const void *indata
, D3DXPARAMETER_TYPE intype
)
1378 struct ctab_constant
*c
= get_valid_constant(table
, constant
);
1383 WARN("Invalid argument specified\n");
1384 return D3DERR_INVALIDCALL
;
1387 switch (c
->desc
.Class
)
1390 set(table
, device
, c
, &indata
, intype
, &count
, c
->desc
.Columns
, D3DXPC_SCALAR
, 0, FALSE
);
1394 case D3DXPC_MATRIX_ROWS
:
1395 case D3DXPC_MATRIX_COLUMNS
:
1400 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c
->desc
.Class
));
1401 return D3DERR_INVALIDCALL
;
1405 static HRESULT
set_scalar_array(struct ID3DXConstantTableImpl
*table
, IDirect3DDevice9
*device
, D3DXHANDLE constant
,
1406 const void *indata
, UINT count
, D3DXPARAMETER_TYPE intype
)
1408 struct ctab_constant
*c
= get_valid_constant(table
, constant
);
1412 WARN("Invalid argument specified\n");
1413 return D3DERR_INVALIDCALL
;
1416 switch (c
->desc
.Class
)
1420 case D3DXPC_MATRIX_ROWS
:
1421 case D3DXPC_MATRIX_COLUMNS
:
1423 set(table
, device
, c
, &indata
, intype
, &count
, c
->desc
.Columns
, D3DXPC_SCALAR
, 0, FALSE
);
1427 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c
->desc
.Class
));
1428 return D3DERR_INVALIDCALL
;
1432 static HRESULT
set_vector(struct ID3DXConstantTableImpl
*table
, IDirect3DDevice9
*device
, D3DXHANDLE constant
,
1433 const void *indata
, D3DXPARAMETER_TYPE intype
)
1435 struct ctab_constant
*c
= get_valid_constant(table
, constant
);
1440 WARN("Invalid argument specified\n");
1441 return D3DERR_INVALIDCALL
;
1444 switch (c
->desc
.Class
)
1449 set(table
, device
, c
, &indata
, intype
, &count
, 4, D3DXPC_VECTOR
, 0, FALSE
);
1452 case D3DXPC_MATRIX_ROWS
:
1453 case D3DXPC_MATRIX_COLUMNS
:
1457 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c
->desc
.Class
));
1458 return D3DERR_INVALIDCALL
;
1462 static HRESULT
set_vector_array(struct ID3DXConstantTableImpl
*table
, IDirect3DDevice9
*device
, D3DXHANDLE constant
,
1463 const void *indata
, UINT count
, D3DXPARAMETER_TYPE intype
)
1465 struct ctab_constant
*c
= get_valid_constant(table
, constant
);
1469 WARN("Invalid argument specified\n");
1470 return D3DERR_INVALIDCALL
;
1473 switch (c
->desc
.Class
)
1477 case D3DXPC_MATRIX_ROWS
:
1478 case D3DXPC_MATRIX_COLUMNS
:
1481 set(table
, device
, c
, &indata
, intype
, &count
, 4, D3DXPC_VECTOR
, 0, FALSE
);
1485 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c
->desc
.Class
));
1486 return D3DERR_INVALIDCALL
;
1490 static HRESULT
set_matrix_array(struct ID3DXConstantTableImpl
*table
, IDirect3DDevice9
*device
, D3DXHANDLE constant
,
1491 const void *indata
, UINT count
, BOOL transpose
)
1493 struct ctab_constant
*c
= get_valid_constant(table
, constant
);
1497 WARN("Invalid argument specified\n");
1498 return D3DERR_INVALIDCALL
;
1501 switch (c
->desc
.Class
)
1505 case D3DXPC_MATRIX_ROWS
:
1506 case D3DXPC_MATRIX_COLUMNS
:
1509 set(table
, device
, c
, &indata
, D3DXPT_FLOAT
, &count
, 4,
1510 transpose
? D3DXPC_MATRIX_ROWS
: D3DXPC_MATRIX_COLUMNS
, 0, FALSE
);
1514 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c
->desc
.Class
));
1515 return D3DERR_INVALIDCALL
;
1519 static HRESULT
set_matrix_pointer_array(struct ID3DXConstantTableImpl
*table
, IDirect3DDevice9
*device
,
1520 D3DXHANDLE constant
, const void **indata
, UINT count
, BOOL transpose
)
1522 struct ctab_constant
*c
= get_valid_constant(table
, constant
);
1526 WARN("Invalid argument specified\n");
1527 return D3DERR_INVALIDCALL
;
1530 switch (c
->desc
.Class
)
1534 case D3DXPC_MATRIX_ROWS
:
1535 case D3DXPC_MATRIX_COLUMNS
:
1538 set(table
, device
, c
, indata
, D3DXPT_FLOAT
, &count
, 4,
1539 transpose
? D3DXPC_MATRIX_ROWS
: D3DXPC_MATRIX_COLUMNS
, 0, TRUE
);
1543 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c
->desc
.Class
));
1544 return D3DERR_INVALIDCALL
;
1548 static HRESULT WINAPI
ID3DXConstantTableImpl_SetDefaults(struct ID3DXConstantTable
*iface
,
1549 struct IDirect3DDevice9
*device
)
1551 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1554 TRACE("iface %p, device %p\n", iface
, device
);
1558 WARN("Invalid argument specified\n");
1559 return D3DERR_INVALIDCALL
;
1562 for (i
= 0; i
< This
->desc
.Constants
; i
++)
1564 D3DXCONSTANT_DESC
*desc
= &This
->constants
[i
].desc
;
1567 if (!desc
->DefaultValue
)
1570 switch (desc
->RegisterSet
)
1573 if (is_vertex_shader(This
->desc
.Version
))
1574 hr
= IDirect3DDevice9_SetVertexShaderConstantB(device
, desc
->RegisterIndex
, desc
->DefaultValue
,
1575 desc
->RegisterCount
);
1577 hr
= IDirect3DDevice9_SetPixelShaderConstantB(device
, desc
->RegisterIndex
, desc
->DefaultValue
,
1578 desc
->RegisterCount
);
1582 if (is_vertex_shader(This
->desc
.Version
))
1583 hr
= IDirect3DDevice9_SetVertexShaderConstantI(device
, desc
->RegisterIndex
, desc
->DefaultValue
,
1584 desc
->RegisterCount
);
1586 hr
= IDirect3DDevice9_SetPixelShaderConstantI(device
, desc
->RegisterIndex
, desc
->DefaultValue
,
1587 desc
->RegisterCount
);
1591 if (is_vertex_shader(This
->desc
.Version
))
1592 hr
= IDirect3DDevice9_SetVertexShaderConstantF(device
, desc
->RegisterIndex
, desc
->DefaultValue
,
1593 desc
->RegisterCount
);
1595 hr
= IDirect3DDevice9_SetPixelShaderConstantF(device
, desc
->RegisterIndex
, desc
->DefaultValue
,
1596 desc
->RegisterCount
);
1600 FIXME("Unhandled register set %s\n", debug_d3dxparameter_registerset(desc
->RegisterSet
));
1612 static HRESULT WINAPI
ID3DXConstantTableImpl_SetValue(struct ID3DXConstantTable
*iface
,
1613 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const void *data
, unsigned int bytes
)
1615 struct ID3DXConstantTableImpl
*table
= impl_from_ID3DXConstantTable(iface
);
1616 struct ctab_constant
*c
= get_valid_constant(table
, constant
);
1617 D3DXCONSTANT_DESC
*desc
;
1619 TRACE("iface %p, device %p, constant %p, data %p, bytes %u\n", iface
, device
, constant
, data
, bytes
);
1621 if (!device
|| !c
|| !data
)
1623 WARN("Invalid argument specified\n");
1624 return D3DERR_INVALIDCALL
;
1629 switch (desc
->Class
)
1633 case D3DXPC_MATRIX_ROWS
:
1634 case D3DXPC_MATRIX_COLUMNS
:
1637 set(table
, device
, c
, &data
, desc
->Type
, &bytes
, desc
->Columns
, D3DXPC_SCALAR
, 0, FALSE
);
1641 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(desc
->Class
));
1642 return D3DERR_INVALIDCALL
;
1646 static HRESULT WINAPI
ID3DXConstantTableImpl_SetBool(struct ID3DXConstantTable
*iface
,
1647 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, BOOL b
)
1649 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1651 TRACE("iface %p, device %p, constant %p, b %d\n", iface
, device
, constant
, b
);
1653 return set_scalar(This
, device
, constant
, &b
, D3DXPT_BOOL
);
1656 static HRESULT WINAPI
ID3DXConstantTableImpl_SetBoolArray(struct ID3DXConstantTable
*iface
,
1657 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const BOOL
*b
, UINT count
)
1659 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1661 TRACE("iface %p, device %p, constant %p, b %p, count %d\n", iface
, device
, constant
, b
, count
);
1663 return set_scalar_array(This
, device
, constant
, b
, count
, D3DXPT_BOOL
);
1666 static HRESULT WINAPI
ID3DXConstantTableImpl_SetInt(struct ID3DXConstantTable
*iface
,
1667 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, INT n
)
1669 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1671 TRACE("iface %p, device %p, constant %p, n %d\n", iface
, device
, constant
, n
);
1673 return set_scalar(This
, device
, constant
, &n
, D3DXPT_INT
);
1676 static HRESULT WINAPI
ID3DXConstantTableImpl_SetIntArray(struct ID3DXConstantTable
*iface
,
1677 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const INT
*n
, UINT count
)
1679 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1681 TRACE("iface %p, device %p, constant %p, n %p, count %d\n", iface
, device
, constant
, n
, count
);
1683 return set_scalar_array(This
, device
, constant
, n
, count
, D3DXPT_INT
);
1686 static HRESULT WINAPI
ID3DXConstantTableImpl_SetFloat(struct ID3DXConstantTable
*iface
,
1687 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, float f
)
1689 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1691 TRACE("iface %p, device %p, constant %p, f %f\n", iface
, device
, constant
, f
);
1693 return set_scalar(This
, device
, constant
, &f
, D3DXPT_FLOAT
);
1696 static HRESULT WINAPI
ID3DXConstantTableImpl_SetFloatArray(struct ID3DXConstantTable
*iface
,
1697 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const float *f
, UINT count
)
1699 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1701 TRACE("iface %p, device %p, constant %p, f %p, count %d\n", iface
, device
, constant
, f
, count
);
1703 return set_scalar_array(This
, device
, constant
, f
, count
, D3DXPT_FLOAT
);
1706 static HRESULT WINAPI
ID3DXConstantTableImpl_SetVector(struct ID3DXConstantTable
*iface
,
1707 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const D3DXVECTOR4
*vector
)
1709 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1711 TRACE("iface %p, device %p, constant %p, vector %p\n", iface
, device
, constant
, vector
);
1713 return set_vector(This
, device
, constant
, vector
, D3DXPT_FLOAT
);
1716 static HRESULT WINAPI
ID3DXConstantTableImpl_SetVectorArray(struct ID3DXConstantTable
*iface
,
1717 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const D3DXVECTOR4
*vector
, UINT count
)
1719 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1721 TRACE("iface %p, device %p, constant %p, vector %p, count %u\n", iface
, device
, constant
, vector
, count
);
1723 return set_vector_array(This
, device
, constant
, vector
, count
, D3DXPT_FLOAT
);
1726 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrix(struct ID3DXConstantTable
*iface
,
1727 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const D3DXMATRIX
*matrix
)
1729 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1731 TRACE("iface %p, device %p, constant %p, matrix %p\n", iface
, device
, constant
, matrix
);
1733 return set_matrix_array(This
, device
, constant
, matrix
, 1, FALSE
);
1736 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixArray(struct ID3DXConstantTable
*iface
,
1737 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const D3DXMATRIX
*matrix
, UINT count
)
1739 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1741 TRACE("iface %p, device %p, constant %p, matrix %p, count %u\n", iface
, device
, constant
, matrix
, count
);
1743 return set_matrix_array(This
, device
, constant
, matrix
, count
, FALSE
);
1746 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixPointerArray(struct ID3DXConstantTable
*iface
,
1747 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const D3DXMATRIX
**matrix
, UINT count
)
1749 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1751 TRACE("iface %p, device %p, constant %p, matrix %p, count %u)\n", iface
, device
, constant
, matrix
, count
);
1753 return set_matrix_pointer_array(This
, device
, constant
, (const void **)matrix
, count
, FALSE
);
1756 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixTranspose(struct ID3DXConstantTable
*iface
,
1757 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const D3DXMATRIX
*matrix
)
1759 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1761 TRACE("iface %p, device %p, constant %p, matrix %p\n", iface
, device
, constant
, matrix
);
1763 return set_matrix_array(This
, device
, constant
, matrix
, 1, TRUE
);
1766 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixTransposeArray(struct ID3DXConstantTable
*iface
,
1767 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const D3DXMATRIX
*matrix
, UINT count
)
1769 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1771 TRACE("iface %p, device %p, constant %p, matrix %p, count %u\n", iface
, device
, constant
, matrix
, count
);
1773 return set_matrix_array(This
, device
, constant
, matrix
, count
, TRUE
);
1776 static HRESULT WINAPI
ID3DXConstantTableImpl_SetMatrixTransposePointerArray(struct ID3DXConstantTable
*iface
,
1777 struct IDirect3DDevice9
*device
, D3DXHANDLE constant
, const D3DXMATRIX
**matrix
, UINT count
)
1779 struct ID3DXConstantTableImpl
*This
= impl_from_ID3DXConstantTable(iface
);
1781 TRACE("iface %p, device %p, constant %p, matrix %p, count %u)\n", iface
, device
, constant
, matrix
, count
);
1783 return set_matrix_pointer_array(This
, device
, constant
, (const void **)matrix
, count
, TRUE
);
1786 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl
=
1788 /*** IUnknown methods ***/
1789 ID3DXConstantTableImpl_QueryInterface
,
1790 ID3DXConstantTableImpl_AddRef
,
1791 ID3DXConstantTableImpl_Release
,
1792 /*** ID3DXBuffer methods ***/
1793 ID3DXConstantTableImpl_GetBufferPointer
,
1794 ID3DXConstantTableImpl_GetBufferSize
,
1795 /*** ID3DXConstantTable methods ***/
1796 ID3DXConstantTableImpl_GetDesc
,
1797 ID3DXConstantTableImpl_GetConstantDesc
,
1798 ID3DXConstantTableImpl_GetSamplerIndex
,
1799 ID3DXConstantTableImpl_GetConstant
,
1800 ID3DXConstantTableImpl_GetConstantByName
,
1801 ID3DXConstantTableImpl_GetConstantElement
,
1802 ID3DXConstantTableImpl_SetDefaults
,
1803 ID3DXConstantTableImpl_SetValue
,
1804 ID3DXConstantTableImpl_SetBool
,
1805 ID3DXConstantTableImpl_SetBoolArray
,
1806 ID3DXConstantTableImpl_SetInt
,
1807 ID3DXConstantTableImpl_SetIntArray
,
1808 ID3DXConstantTableImpl_SetFloat
,
1809 ID3DXConstantTableImpl_SetFloatArray
,
1810 ID3DXConstantTableImpl_SetVector
,
1811 ID3DXConstantTableImpl_SetVectorArray
,
1812 ID3DXConstantTableImpl_SetMatrix
,
1813 ID3DXConstantTableImpl_SetMatrixArray
,
1814 ID3DXConstantTableImpl_SetMatrixPointerArray
,
1815 ID3DXConstantTableImpl_SetMatrixTranspose
,
1816 ID3DXConstantTableImpl_SetMatrixTransposeArray
,
1817 ID3DXConstantTableImpl_SetMatrixTransposePointerArray
1820 static HRESULT
parse_ctab_constant_type(const char *ctab
, DWORD typeoffset
, struct ctab_constant
*constant
,
1821 BOOL is_element
, WORD index
, WORD max_index
, DWORD
*offset
, DWORD nameoffset
, UINT regset
)
1823 const D3DXSHADER_TYPEINFO
*type
= (LPD3DXSHADER_TYPEINFO
)(ctab
+ typeoffset
);
1824 const D3DXSHADER_STRUCTMEMBERINFO
*memberinfo
= NULL
;
1825 HRESULT hr
= D3D_OK
;
1829 constant
->desc
.DefaultValue
= offset
? ctab
+ *offset
: NULL
;
1830 constant
->desc
.Class
= type
->Class
;
1831 constant
->desc
.Type
= type
->Type
;
1832 constant
->desc
.Rows
= type
->Rows
;
1833 constant
->desc
.Columns
= type
->Columns
;
1834 constant
->desc
.Elements
= is_element
? 1 : type
->Elements
;
1835 constant
->desc
.StructMembers
= type
->StructMembers
;
1836 constant
->desc
.Name
= ctab
+ nameoffset
;
1837 constant
->desc
.RegisterSet
= regset
;
1838 constant
->desc
.RegisterIndex
= index
;
1840 TRACE("name %s, elements %u, index %u, defaultvalue %p, regset %s\n", constant
->desc
.Name
,
1841 constant
->desc
.Elements
, index
, constant
->desc
.DefaultValue
,
1842 debug_d3dxparameter_registerset(regset
));
1843 TRACE("class %s, type %s, rows %d, columns %d, elements %d, struct_members %d\n",
1844 debug_d3dxparameter_class(type
->Class
), debug_d3dxparameter_type(type
->Type
),
1845 type
->Rows
, type
->Columns
, type
->Elements
, type
->StructMembers
);
1847 if (type
->Elements
> 1 && !is_element
)
1849 count
= type
->Elements
;
1851 else if ((type
->Class
== D3DXPC_STRUCT
) && type
->StructMembers
)
1853 memberinfo
= (D3DXSHADER_STRUCTMEMBERINFO
*)(ctab
+ type
->StructMemberInfo
);
1854 count
= type
->StructMembers
;
1859 constant
->constants
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*constant
->constants
) * count
);
1860 if (!constant
->constants
)
1862 ERR("Out of memory\n");
1867 for (i
= 0; i
< count
; ++i
)
1869 hr
= parse_ctab_constant_type(ctab
, memberinfo
? memberinfo
[i
].TypeInfo
: typeoffset
,
1870 &constant
->constants
[i
], memberinfo
== NULL
, index
+ size
, max_index
, offset
,
1871 memberinfo
? memberinfo
[i
].Name
: nameoffset
, regset
);
1875 size
+= constant
->constants
[i
].desc
.RegisterCount
;
1880 WORD offsetdiff
= type
->Columns
* type
->Rows
;
1883 size
= type
->Columns
* type
->Rows
;
1888 fail
= type
->Class
!= D3DXPC_SCALAR
&& type
->Class
!= D3DXPC_VECTOR
1889 && type
->Class
!= D3DXPC_MATRIX_ROWS
&& type
->Class
!= D3DXPC_MATRIX_COLUMNS
;
1894 switch (type
->Class
)
1900 offsetdiff
= type
->Rows
* 4;
1903 case D3DXPC_MATRIX_ROWS
:
1904 offsetdiff
= type
->Rows
* 4;
1908 case D3DXPC_MATRIX_COLUMNS
:
1909 offsetdiff
= type
->Columns
* 4;
1910 size
= type
->Columns
;
1919 case D3DXRS_SAMPLER
:
1921 fail
= type
->Class
!= D3DXPC_OBJECT
;
1931 FIXME("Unhandled register set %s, type class %s\n", debug_d3dxparameter_registerset(regset
),
1932 debug_d3dxparameter_class(type
->Class
));
1935 /* offset in bytes => offsetdiff * sizeof(DWORD) */
1936 if (offset
) *offset
+= offsetdiff
* 4;
1939 constant
->desc
.RegisterCount
= max(0, min(max_index
- index
, size
));
1940 constant
->desc
.Bytes
= 4 * constant
->desc
.Elements
* type
->Rows
* type
->Columns
;
1945 if (constant
->constants
)
1947 for (i
= 0; i
< count
; ++i
)
1949 free_constant(&constant
->constants
[i
]);
1951 HeapFree(GetProcessHeap(), 0, constant
->constants
);
1952 constant
->constants
= NULL
;
1958 HRESULT WINAPI
D3DXGetShaderConstantTableEx(const DWORD
*byte_code
, DWORD flags
, ID3DXConstantTable
**constant_table
)
1960 struct ID3DXConstantTableImpl
*object
= NULL
;
1964 const D3DXSHADER_CONSTANTTABLE
*ctab_header
;
1965 const D3DXSHADER_CONSTANTINFO
*constant_info
;
1968 TRACE("byte_code %p, flags %x, constant_table %p\n", byte_code
, flags
, constant_table
);
1970 if (constant_table
) *constant_table
= NULL
;
1972 if (!byte_code
|| !constant_table
)
1974 WARN("Invalid argument specified.\n");
1975 return D3DERR_INVALIDCALL
;
1978 if (!is_valid_bytecode(*byte_code
))
1980 WARN("Invalid byte_code specified.\n");
1984 if (flags
) FIXME("Flags (%#x) are not handled, yet!\n", flags
);
1986 hr
= D3DXFindShaderComment(byte_code
, MAKEFOURCC('C','T','A','B'), &data
, &size
);
1989 WARN("CTAB not found.\n");
1990 return D3DXERR_INVALIDDATA
;
1993 if (size
< sizeof(*ctab_header
))
1995 WARN("Invalid CTAB size.\n");
1996 return D3DXERR_INVALIDDATA
;
1999 ctab_header
= (const D3DXSHADER_CONSTANTTABLE
*)data
;
2000 if (ctab_header
->Size
!= sizeof(*ctab_header
))
2002 WARN("Invalid D3DXSHADER_CONSTANTTABLE size.\n");
2003 return D3DXERR_INVALIDDATA
;
2006 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
2008 return E_OUTOFMEMORY
;
2010 object
->ID3DXConstantTable_iface
.lpVtbl
= &ID3DXConstantTable_Vtbl
;
2013 object
->ctab
= HeapAlloc(GetProcessHeap(), 0, size
);
2016 ERR("Out of memory\n");
2017 HeapFree(GetProcessHeap(), 0, object
);
2018 return E_OUTOFMEMORY
;
2020 object
->size
= size
;
2021 memcpy(object
->ctab
, data
, object
->size
);
2023 object
->desc
.Creator
= ctab_header
->Creator
? object
->ctab
+ ctab_header
->Creator
: NULL
;
2024 object
->desc
.Version
= ctab_header
->Version
;
2025 object
->desc
.Constants
= ctab_header
->Constants
;
2026 TRACE("Creator %s, Version %x, Constants %u, Target %s\n",
2027 debugstr_a(object
->desc
.Creator
), object
->desc
.Version
, object
->desc
.Constants
,
2028 debugstr_a(ctab_header
->Target
? object
->ctab
+ ctab_header
->Target
: NULL
));
2030 object
->constants
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2031 sizeof(*object
->constants
) * object
->desc
.Constants
);
2032 if (!object
->constants
)
2034 ERR("Out of memory\n");
2039 constant_info
= (const D3DXSHADER_CONSTANTINFO
*)(object
->ctab
+ ctab_header
->ConstantInfo
);
2040 for (i
= 0; i
< ctab_header
->Constants
; i
++)
2042 DWORD offset
= constant_info
[i
].DefaultValue
;
2044 hr
= parse_ctab_constant_type(object
->ctab
, constant_info
[i
].TypeInfo
,
2045 &object
->constants
[i
], FALSE
, constant_info
[i
].RegisterIndex
,
2046 constant_info
[i
].RegisterIndex
+ constant_info
[i
].RegisterCount
,
2047 offset
? &offset
: NULL
, constant_info
[i
].Name
, constant_info
[i
].RegisterSet
);
2052 * Set the register count, it may differ for D3DXRS_INT4, because somehow
2053 * it makes the assumption that the register size is 1 instead of 4, so the
2054 * count is 4 times bigger. This holds true only for toplevel shader
2055 * constants. The count of elements and members is always based on a
2056 * register size of 4.
2058 if (object
->constants
[i
].desc
.RegisterSet
== D3DXRS_INT4
)
2060 object
->constants
[i
].desc
.RegisterCount
= constant_info
[i
].RegisterCount
;
2064 *constant_table
= &object
->ID3DXConstantTable_iface
;
2069 free_constant_table(object
);
2070 HeapFree(GetProcessHeap(), 0, object
);
2075 HRESULT WINAPI
D3DXGetShaderConstantTable(const DWORD
*byte_code
, ID3DXConstantTable
**constant_table
)
2077 TRACE("(%p, %p): Forwarded to D3DXGetShaderConstantTableEx\n", byte_code
, constant_table
);
2079 return D3DXGetShaderConstantTableEx(byte_code
, 0, constant_table
);
2082 HRESULT WINAPI
D3DXGetShaderSamplers(const DWORD
*byte_code
, const char **samplers
, UINT
*count
)
2084 UINT i
, sampler_count
= 0;
2087 const D3DXSHADER_CONSTANTTABLE
*ctab_header
;
2088 const D3DXSHADER_CONSTANTINFO
*constant_info
;
2090 TRACE("byte_code %p, samplers %p, count %p\n", byte_code
, samplers
, count
);
2092 if (count
) *count
= 0;
2094 if (D3DXFindShaderComment(byte_code
, MAKEFOURCC('C','T','A','B'), (const void **)&data
, &size
) != D3D_OK
)
2097 if (size
< sizeof(*ctab_header
)) return D3D_OK
;
2099 ctab_header
= (const D3DXSHADER_CONSTANTTABLE
*)data
;
2100 if (ctab_header
->Size
!= sizeof(*ctab_header
)) return D3D_OK
;
2102 constant_info
= (const D3DXSHADER_CONSTANTINFO
*)(data
+ ctab_header
->ConstantInfo
);
2103 for (i
= 0; i
< ctab_header
->Constants
; i
++)
2105 const D3DXSHADER_TYPEINFO
*type
;
2107 TRACE("name = %s\n", data
+ constant_info
[i
].Name
);
2109 type
= (const D3DXSHADER_TYPEINFO
*)(data
+ constant_info
[i
].TypeInfo
);
2111 if (type
->Type
== D3DXPT_SAMPLER
2112 || type
->Type
== D3DXPT_SAMPLER1D
2113 || type
->Type
== D3DXPT_SAMPLER2D
2114 || type
->Type
== D3DXPT_SAMPLER3D
2115 || type
->Type
== D3DXPT_SAMPLERCUBE
)
2117 if (samplers
) samplers
[sampler_count
] = data
+ constant_info
[i
].Name
;
2123 TRACE("Found %u samplers\n", sampler_count
);
2125 if (count
) *count
= sampler_count
;