?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
opengl32: Correctly interpret glMapBuffer() access in wow64 mapping.
[wine.git] / dlls / d3dx9_36 / shader.c
blob7d06090aa1586a400a31b0cd60cfc8cdf415b017
1 /*
2 * Copyright 2008 Luis Busquets
3 * Copyright 2009 Matteo Bruni
4 * Copyright 2011 Travis Athougies
5 *
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.
10 *
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.
15 *
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
19 */
20
21 #include <assert.h>
22
23 #include "d3dx9_private.h"
24 #include "d3dcommon.h"
25 #include "d3dcompiler.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
28
29 static inline BOOL is_valid_bytecode(DWORD token)
30 {
31 return (token & 0xfffe0000) == 0xfffe0000;
32 }
33
34 const char * WINAPI D3DXGetPixelShaderProfile(struct IDirect3DDevice9 *device)
35 {
36 D3DCAPS9 caps;
37
38 TRACE("device %p\n", device);
39
40 if (!device) return NULL;
41
42 IDirect3DDevice9_GetDeviceCaps(device,&caps);
43
44 switch (caps.PixelShaderVersion)
45 {
46 case D3DPS_VERSION(1, 1):
47 return "ps_1_1";
48
49 case D3DPS_VERSION(1, 2):
50 return "ps_1_2";
51
52 case D3DPS_VERSION(1, 3):
53 return "ps_1_3";
54
55 case D3DPS_VERSION(1, 4):
56 return "ps_1_4";
57
58 case D3DPS_VERSION(2, 0):
59 if ((caps.PS20Caps.NumTemps>=22) &&
60 (caps.PS20Caps.Caps&D3DPS20CAPS_ARBITRARYSWIZZLE) &&
61 (caps.PS20Caps.Caps&D3DPS20CAPS_GRADIENTINSTRUCTIONS) &&
62 (caps.PS20Caps.Caps&D3DPS20CAPS_PREDICATION) &&
63 (caps.PS20Caps.Caps&D3DPS20CAPS_NODEPENDENTREADLIMIT) &&
64 (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
65 {
66 return "ps_2_a";
67 }
68 if ((caps.PS20Caps.NumTemps>=32) &&
69 (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
70 {
71 return "ps_2_b";
72 }
73 return "ps_2_0";
74
75 case D3DPS_VERSION(3, 0):
76 return "ps_3_0";
77 }
78
79 return NULL;
80 }
81
82 UINT WINAPI D3DXGetShaderSize(const DWORD *byte_code)
83 {
84 const DWORD *ptr = byte_code;
85
86 TRACE("byte_code %p\n", byte_code);
87
88 if (!ptr) return 0;
89
90 /* Look for the END token, skipping the VERSION token */
91 while (*++ptr != D3DSIO_END)
92 {
93 /* Skip comments */
94 if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
95 {
96 ptr += ((*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT);
97 }
98 }
99 ++ptr;
100
101 /* Return the shader size in bytes */
102 return (ptr - byte_code) * sizeof(*ptr);
103 }
104
105 DWORD WINAPI D3DXGetShaderVersion(const DWORD *byte_code)
106 {
107 TRACE("byte_code %p\n", byte_code);
108
109 return byte_code ? *byte_code : 0;
110 }
111
112 const char * WINAPI D3DXGetVertexShaderProfile(struct IDirect3DDevice9 *device)
113 {
114 D3DCAPS9 caps;
115
116 TRACE("device %p\n", device);
117
118 if (!device) return NULL;
119
120 IDirect3DDevice9_GetDeviceCaps(device,&caps);
121
122 switch (caps.VertexShaderVersion)
123 {
124 case D3DVS_VERSION(1, 1):
125 return "vs_1_1";
126 case D3DVS_VERSION(2, 0):
127 if ((caps.VS20Caps.NumTemps>=13) &&
128 (caps.VS20Caps.DynamicFlowControlDepth==24) &&
129 (caps.VS20Caps.Caps&D3DPS20CAPS_PREDICATION))
130 {
131 return "vs_2_a";
132 }
133 return "vs_2_0";
134 case D3DVS_VERSION(3, 0):
135 return "vs_3_0";
136 }
137
138 return NULL;
139 }
140
141 HRESULT WINAPI D3DXFindShaderComment(const DWORD *byte_code, DWORD fourcc, const void **data, UINT *size)
142 {
143 const DWORD *ptr = byte_code;
144 DWORD version;
145
146 TRACE("byte_code %p, fourcc %#lx, data %p, size %p.\n", byte_code, fourcc, data, size);
147
148 if (data) *data = NULL;
149 if (size) *size = 0;
150
151 if (!byte_code) return D3DERR_INVALIDCALL;
152
153 version = *ptr >> 16;
154 if (version != 0x4658 /* FX */
155 && version != 0x5458 /* TX */
156 && version != 0x7ffe
157 && version != 0x7fff
158 && version != 0xfffe /* VS */
159 && version != 0xffff) /* PS */
160 {
161 WARN("Invalid data supplied\n");
162 return D3DXERR_INVALIDDATA;
163 }
164
165 while (*++ptr != D3DSIO_END)
166 {
167 /* Check if it is a comment */
168 if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
169 {
170 DWORD comment_size = (*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
171
172 /* Check if this is the comment we are looking for */
173 if (*(ptr + 1) == fourcc)
174 {
175 UINT ctab_size = (comment_size - 1) * sizeof(DWORD);
176 const void *ctab_data = ptr + 2;
177 if (size)
178 *size = ctab_size;
179 if (data)
180 *data = ctab_data;
181 TRACE("Returning comment data at %p with size %d\n", ctab_data, ctab_size);
182 return D3D_OK;
183 }
184 ptr += comment_size;
185 }
186 }
187
188 return S_FALSE;
189 }
190
191 static BOOL WINAPI load_d3dassemble_once(INIT_ONCE *once, void *param, void **context)
192 {
193 /* FIXME: This assumes that d3dcompiler.h and dlls/d3dcompiler_XX/Makefile.in stay
194 * in sync regarding which library creates the unnumbered d3dcompiler.lib implib.
195 * GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, D3DCompile) would
196 * be nice, but "D3DCompile" will point to the IAT stub, not d3dcompiler_xy.dll */
197 HMODULE mod = GetModuleHandleW(D3DCOMPILER_DLL_W);
198 void **assemble = param;
199
200 if (!mod)
201 ERR("%s not found - which d3dcompiler are we linked against?\n", D3DCOMPILER_DLL_A);
202
203 *assemble = (void *)GetProcAddress(mod, "D3DAssemble");
204 return TRUE;
205 }
206
207 HRESULT WINAPI D3DXAssembleShader(const char *data, UINT data_len, const D3DXMACRO *defines,
208 ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
209 {
210 static HRESULT (WINAPI *pD3DAssemble)(const void *data, SIZE_T datasize, const char *filename,
211 const D3D_SHADER_MACRO * defines, ID3DInclude * include, UINT flags,
212 ID3DBlob * *shader, ID3DBlob * *error_messages);
213 static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
214 HRESULT hr;
215
216 TRACE("data %p, data_len %u, defines %p, include %p, flags %#lx, shader %p, error_messages %p.\n",
217 data, data_len, defines, include, flags, shader, error_messages);
218
219 InitOnceExecuteOnce(&init_once, load_d3dassemble_once, &pD3DAssemble, NULL);
220
221 /* Forward to d3dcompiler: the parameter types aren't really different,
222 the actual data types are equivalent */
223 hr = pD3DAssemble(data, data_len, NULL, (D3D_SHADER_MACRO *)defines,
224 (ID3DInclude *)include, flags, (ID3DBlob **)shader,
225 (ID3DBlob **)error_messages);
226
227 if(hr == E_FAIL) hr = D3DXERR_INVALIDDATA;
228 return hr;
229 }
230
231 static const void *main_file_data;
232
233 static CRITICAL_SECTION_DEBUG from_file_mutex_debug =
234 {
235 0, 0, &from_file_mutex,
236 {
237 &from_file_mutex_debug.ProcessLocksList,
238 &from_file_mutex_debug.ProcessLocksList
239 },
240 0, 0, {(DWORD_PTR)(__FILE__ ": from_file_mutex")}
241 };
242 CRITICAL_SECTION from_file_mutex = {&from_file_mutex_debug, -1, 0, 0, 0, 0};
243
244 /* D3DXInclude private implementation, used to implement
245 * D3DXAssembleShaderFromFile() from D3DXAssembleShader(). */
246 /* To be able to correctly resolve include search paths we have to store the
247 * pathname of each include file. We store the pathname pointer right before
248 * the file data. */
249 static HRESULT WINAPI d3dx_include_from_file_open(ID3DXInclude *iface, D3DXINCLUDE_TYPE include_type,
250 const char *filename, const void *parent_data, const void **data, UINT *bytes)
251 {
252 const char *p, *parent_name = "";
253 char *pathname = NULL, *ptr;
254 char **buffer = NULL;
255 HANDLE file;
256 UINT size;
257
258 if (parent_data)
259 {
260 parent_name = *((const char **)parent_data - 1);
261 }
262 else
263 {
264 if (main_file_data)
265 parent_name = *((const char **)main_file_data - 1);
266 }
267
268 TRACE("Looking up include file %s, parent %s.\n", debugstr_a(filename), debugstr_a(parent_name));
269
270 if ((p = strrchr(parent_name, '\\')))
271 ++p;
272 else
273 p = parent_name;
274 pathname = HeapAlloc(GetProcessHeap(), 0, (p - parent_name) + strlen(filename) + 1);
275 if(!pathname)
276 return HRESULT_FROM_WIN32(GetLastError());
277
278 memcpy(pathname, parent_name, p - parent_name);
279 strcpy(pathname + (p - parent_name), filename);
280 ptr = pathname + (p - parent_name);
281 while (*ptr)
282 {
283 if (*ptr == '/')
284 *ptr = '\\';
285 ++ptr;
286 }
287
288 file = CreateFileA(pathname, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
289 if(file == INVALID_HANDLE_VALUE)
290 goto error;
291
292 TRACE("Include file found at pathname = %s\n", debugstr_a(pathname));
293
294 size = GetFileSize(file, NULL);
295 if(size == INVALID_FILE_SIZE)
296 goto error;
297
298 buffer = HeapAlloc(GetProcessHeap(), 0, size + sizeof(char *));
299 if(!buffer)
300 goto error;
301 *buffer = pathname;
302 if (!ReadFile(file, buffer + 1, size, (DWORD *)bytes, NULL))
303 goto error;
304
305 *data = buffer + 1;
306 if (!main_file_data)
307 main_file_data = *data;
308
309 CloseHandle(file);
310 return S_OK;
311
312 error:
313 CloseHandle(file);
314 HeapFree(GetProcessHeap(), 0, pathname);
315 HeapFree(GetProcessHeap(), 0, buffer);
316 return HRESULT_FROM_WIN32(GetLastError());
317 }
318
319 static HRESULT WINAPI d3dx_include_from_file_close(ID3DXInclude *iface, const void *data)
320 {
321 HeapFree(GetProcessHeap(), 0, *((char **)data - 1));
322 HeapFree(GetProcessHeap(), 0, (char **)data - 1);
323 if (main_file_data == data)
324 main_file_data = NULL;
325 return S_OK;
326 }
327
328 const struct ID3DXIncludeVtbl d3dx_include_from_file_vtbl =
329 {
330 d3dx_include_from_file_open,
331 d3dx_include_from_file_close
332 };
333
334 HRESULT WINAPI D3DXAssembleShaderFromFileA(const char *filename, const D3DXMACRO *defines,
335 ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
336 {
337 WCHAR *filename_w;
338 DWORD len;
339 HRESULT ret;
340
341 TRACE("filename %s, defines %p, include %p, flags %#lx, shader %p, error_messages %p.\n",
342 debugstr_a(filename), defines, include, flags, shader, error_messages);
343
344 if (!filename) return D3DXERR_INVALIDDATA;
345
346 len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
347 filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
348 if (!filename_w) return E_OUTOFMEMORY;
349 MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
350
351 ret = D3DXAssembleShaderFromFileW(filename_w, defines, include, flags, shader, error_messages);
352
353 HeapFree(GetProcessHeap(), 0, filename_w);
354 return ret;
355 }
356
357 HRESULT WINAPI D3DXAssembleShaderFromFileW(const WCHAR *filename, const D3DXMACRO *defines,
358 ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
359 {
360 struct d3dx_include_from_file include_from_file;
361 const void *buffer;
362 unsigned int len;
363 char *filename_a;
364 HRESULT hr;
365
366 TRACE("filename %s, defines %p, include %p, flags %#lx, shader %p, error_messages %p.\n",
367 debugstr_w(filename), defines, include, flags, shader, error_messages);
368
369 if(!include)
370 {
371 include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
372 include = &include_from_file.ID3DXInclude_iface;
373 }
374
375 len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
376 filename_a = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
377 if (!filename_a)
378 return E_OUTOFMEMORY;
379 WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, len, NULL, NULL);
380
381 EnterCriticalSection(&from_file_mutex);
382 hr = ID3DXInclude_Open(include, D3DXINC_LOCAL, filename_a, NULL, &buffer, &len);
383 if (FAILED(hr))
384 {
385 LeaveCriticalSection(&from_file_mutex);
386 HeapFree(GetProcessHeap(), 0, filename_a);
387 return D3DXERR_INVALIDDATA;
388 }
389
390 hr = D3DXAssembleShader(buffer, len, defines, include, flags, shader, error_messages);
391
392 ID3DXInclude_Close(include, buffer);
393 LeaveCriticalSection(&from_file_mutex);
394 HeapFree(GetProcessHeap(), 0, filename_a);
395 return hr;
396 }
397
398 HRESULT WINAPI D3DXAssembleShaderFromResourceA(HMODULE module, const char *resource, const D3DXMACRO *defines,
399 ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
400 {
401 void *buffer;
402 HRSRC res;
403 DWORD len;
404
405 TRACE("module %p, resource %s, defines %p, include %p, flags %#lx, shader %p, error_messages %p.\n",
406 module, debugstr_a(resource), defines, include, flags, shader, error_messages);
407
408 if (!(res = FindResourceA(module, resource, (const char *)RT_RCDATA)))
409 return D3DXERR_INVALIDDATA;
410 if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
411 return D3DXERR_INVALIDDATA;
412 return D3DXAssembleShader(buffer, len, defines, include, flags,
413 shader, error_messages);
414 }
415
416 HRESULT WINAPI D3DXAssembleShaderFromResourceW(HMODULE module, const WCHAR *resource, const D3DXMACRO *defines,
417 ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
418 {
419 void *buffer;
420 HRSRC res;
421 DWORD len;
422
423 TRACE("module %p, resource %s, defines %p, include %p, flags %#lx, shader %p, error_messages %p.\n",
424 module, debugstr_w(resource), defines, include, flags, shader, error_messages);
425
426 if (!(res = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
427 return D3DXERR_INVALIDDATA;
428 if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
429 return D3DXERR_INVALIDDATA;
430 return D3DXAssembleShader(buffer, len, defines, include, flags,
431 shader, error_messages);
432 }
433
434 HRESULT WINAPI D3DXCompileShader(const char *data, UINT length, const D3DXMACRO *defines,
435 ID3DXInclude *include, const char *function, const char *profile, DWORD flags,
436 ID3DXBuffer **shader, ID3DXBuffer **error_msgs, ID3DXConstantTable **constant_table)
437 {
438 HRESULT hr;
439
440 TRACE("data %s, length %u, defines %p, include %p, function %s, profile %s, "
441 "flags %#lx, shader %p, error_msgs %p, constant_table %p.\n",
442 debugstr_a(data), length, defines, include, debugstr_a(function), debugstr_a(profile),
443 flags, shader, error_msgs, constant_table);
444
445 if (D3DX_SDK_VERSION <= 36)
446 flags |= D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
447
448 hr = D3DCompile(data, length, NULL, (D3D_SHADER_MACRO *)defines, (ID3DInclude *)include,
449 function, profile, flags, 0, (ID3DBlob **)shader, (ID3DBlob **)error_msgs);
450
451 if (SUCCEEDED(hr) && constant_table)
452 {
453 hr = D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*shader), constant_table);
454 if (FAILED(hr))
455 {
456 ID3DXBuffer_Release(*shader);
457 *shader = NULL;
458 }
459 }
460
461 return hr;
462 }
463
464 HRESULT WINAPI D3DXCompileShaderFromFileA(const char *filename, const D3DXMACRO *defines,
465 ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags,
466 ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
467 {
468 WCHAR *filename_w;
469 DWORD len;
470 HRESULT ret;
471
472 TRACE("filename %s, defines %p, include %p, entrypoint %s, profile %s, "
473 "flags %#lx, shader %p, error_messages %p, constant_table %p.\n",
474 debugstr_a(filename), defines, include, debugstr_a(entrypoint),
475 debugstr_a(profile), flags, shader, error_messages, constant_table);
476
477 if (!filename) return D3DXERR_INVALIDDATA;
478
479 len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
480 filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
481 if (!filename_w) return E_OUTOFMEMORY;
482 MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
483
484 ret = D3DXCompileShaderFromFileW(filename_w, defines, include,
485 entrypoint, profile, flags,
486 shader, error_messages, constant_table);
487
488 HeapFree(GetProcessHeap(), 0, filename_w);
489 return ret;
490 }
491
492 HRESULT WINAPI D3DXCompileShaderFromFileW(const WCHAR *filename, const D3DXMACRO *defines,
493 ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags,
494 ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
495 {
496 struct d3dx_include_from_file include_from_file;
497 unsigned int filename_len;
498 const void *buffer;
499 char *filename_a;
500 HRESULT hr;
501 UINT len;
502
503 TRACE("filename %s, defines %p, include %p, entrypoint %s, profile %s, "
504 "flags %#lx, shader %p, error_messages %p, constant_table %p.\n",
505 debugstr_w(filename), defines, include, debugstr_a(entrypoint), debugstr_a(profile),
506 flags, shader, error_messages, constant_table);
507
508 if (!include)
509 {
510 include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
511 include = &include_from_file.ID3DXInclude_iface;
512 }
513
514 filename_len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
515 filename_a = HeapAlloc(GetProcessHeap(), 0, filename_len * sizeof(char));
516 if (!filename_a)
517 return E_OUTOFMEMORY;
518 WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, filename_len, NULL, NULL);
519
520 EnterCriticalSection(&from_file_mutex);
521 hr = ID3DXInclude_Open(include, D3DXINC_LOCAL, filename_a, NULL, &buffer, &len);
522 if (FAILED(hr))
523 {
524 LeaveCriticalSection(&from_file_mutex);
525 HeapFree(GetProcessHeap(), 0, filename_a);
526 return D3DXERR_INVALIDDATA;
527 }
528
529 if (D3DX_SDK_VERSION <= 36)
530 flags |= D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
531
532 hr = D3DCompile(buffer, len, filename_a, (const D3D_SHADER_MACRO *)defines,
533 (ID3DInclude *)include, entrypoint, profile, flags, 0,
534 (ID3DBlob **)shader, (ID3DBlob **)error_messages);
535
536 if (SUCCEEDED(hr) && constant_table)
537 hr = D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*shader),
538 constant_table);
539
540 ID3DXInclude_Close(include, buffer);
541 LeaveCriticalSection(&from_file_mutex);
542 HeapFree(GetProcessHeap(), 0, filename_a);
543 return hr;
544 }
545
546 HRESULT WINAPI D3DXCompileShaderFromResourceA(HMODULE module, const char *resource, const D3DXMACRO *defines,
547 ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags,
548 ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
549 {
550 void *buffer;
551 HRSRC res;
552 DWORD len;
553
554 TRACE("module %p, resource %s, defines %p, include %p, entrypoint %s, profile %s, "
555 "flags %#lx, shader %p, error_messages %p, constant_table %p.\n",
556 module, debugstr_a(resource), defines, include, debugstr_a(entrypoint), debugstr_a(profile),
557 flags, shader, error_messages, constant_table);
558
559 if (!(res = FindResourceA(module, resource, (const char *)RT_RCDATA)))
560 return D3DXERR_INVALIDDATA;
561 if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
562 return D3DXERR_INVALIDDATA;
563 return D3DXCompileShader(buffer, len, defines, include, entrypoint, profile,
564 flags, shader, error_messages, constant_table);
565 }
566
567 HRESULT WINAPI D3DXCompileShaderFromResourceW(HMODULE module, const WCHAR *resource, const D3DXMACRO *defines,
568 ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags,
569 ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
570 {
571 void *buffer;
572 HRSRC res;
573 DWORD len;
574
575 TRACE("module %p, resource %s, defines %p, include %p, entrypoint %s, profile %s, "
576 "flags %#lx, shader %p, error_messages %p, constant_table %p.\n",
577 module, debugstr_w(resource), defines, include, debugstr_a(entrypoint), debugstr_a(profile),
578 flags, shader, error_messages, constant_table);
579
580 if (!(res = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
581 return D3DXERR_INVALIDDATA;
582 if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
583 return D3DXERR_INVALIDDATA;
584 return D3DXCompileShader(buffer, len, defines, include, entrypoint, profile,
585 flags, shader, error_messages, constant_table);
586 }
587
588 HRESULT WINAPI D3DXPreprocessShader(const char *data, UINT data_len, const D3DXMACRO *defines,
589 ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
590 {
591 TRACE("data %s, data_len %u, defines %p, include %p, shader %p, error_messages %p.\n",
592 debugstr_a(data), data_len, defines, include, shader, error_messages);
593
594 return D3DPreprocess(data, data_len, NULL,
595 (const D3D_SHADER_MACRO *)defines, (ID3DInclude *)include,
596 (ID3DBlob **)shader, (ID3DBlob **)error_messages);
597 }
598
599 HRESULT WINAPI D3DXPreprocessShaderFromFileA(const char *filename, const D3DXMACRO *defines,
600 ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
601 {
602 WCHAR *filename_w = NULL;
603 DWORD len;
604 HRESULT ret;
605
606 TRACE("filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
607 debugstr_a(filename), defines, include, shader, error_messages);
608
609 if (!filename) return D3DXERR_INVALIDDATA;
610
611 len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
612 filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
613 if (!filename_w) return E_OUTOFMEMORY;
614 MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
615
616 ret = D3DXPreprocessShaderFromFileW(filename_w, defines, include, shader, error_messages);
617
618 HeapFree(GetProcessHeap(), 0, filename_w);
619 return ret;
620 }
621
622 HRESULT WINAPI D3DXPreprocessShaderFromFileW(const WCHAR *filename, const D3DXMACRO *defines,
623 ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
624 {
625 struct d3dx_include_from_file include_from_file;
626 const void *buffer;
627 char *filename_a;
628 HRESULT hr;
629 UINT len;
630
631 TRACE("filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
632 debugstr_w(filename), defines, include, shader, error_messages);
633
634 if (!include)
635 {
636 include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
637 include = &include_from_file.ID3DXInclude_iface;
638 }
639
640 len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
641 filename_a = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
642 if (!filename_a)
643 return E_OUTOFMEMORY;
644 WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, len, NULL, NULL);
645
646 EnterCriticalSection(&from_file_mutex);
647 hr = ID3DXInclude_Open(include, D3DXINC_LOCAL, filename_a, NULL, &buffer, &len);
648 if (FAILED(hr))
649 {
650 LeaveCriticalSection(&from_file_mutex);
651 HeapFree(GetProcessHeap(), 0, filename_a);
652 return D3DXERR_INVALIDDATA;
653 }
654
655 hr = D3DPreprocess(buffer, len, NULL,
656 (const D3D_SHADER_MACRO *)defines,
657 (ID3DInclude *) include,
658 (ID3DBlob **)shader, (ID3DBlob **)error_messages);
659
660 ID3DXInclude_Close(include, buffer);
661 LeaveCriticalSection(&from_file_mutex);
662 HeapFree(GetProcessHeap(), 0, filename_a);
663 return hr;
664 }
665
666 HRESULT WINAPI D3DXPreprocessShaderFromResourceA(HMODULE module, const char *resource, const D3DXMACRO *defines,
667 ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
668 {
669 void *buffer;
670 HRSRC res;
671 DWORD len;
672
673 TRACE("module %p, resource %s, defines %p, include %p, shader %p, error_messages %p.\n",
674 module, debugstr_a(resource), defines, include, shader, error_messages);
675
676 if (!(res = FindResourceA(module, resource, (const char *)RT_RCDATA)))
677 return D3DXERR_INVALIDDATA;
678 if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
679 return D3DXERR_INVALIDDATA;
680 return D3DXPreprocessShader(buffer, len, defines, include,
681 shader, error_messages);
682 }
683
684 HRESULT WINAPI D3DXPreprocessShaderFromResourceW(HMODULE module, const WCHAR *resource, const D3DXMACRO *defines,
685 ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
686 {
687 void *buffer;
688 HRSRC res;
689 DWORD len;
690
691 TRACE("module %p, resource %s, defines %p, include %p, shader %p, error_messages %p.\n",
692 module, debugstr_w(resource), defines, include, shader, error_messages);
693
694 if (!(res = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
695 return D3DXERR_INVALIDDATA;
696 if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
697 return D3DXERR_INVALIDDATA;
698 return D3DXPreprocessShader(buffer, len, defines, include,
699 shader, error_messages);
700
701 }
702
703 struct ID3DXConstantTableImpl
704 {
705 ID3DXConstantTable ID3DXConstantTable_iface;
706 LONG ref;
707 char *ctab;
708 DWORD size;
709 DWORD flags;
710 D3DXCONSTANTTABLE_DESC desc;
711 struct ctab_constant *constants;
712 };
713
714 static void free_constant(struct ctab_constant *constant)
715 {
716 if (constant->constants)
717 {
718 UINT i, count = constant->desc.Elements > 1 ? constant->desc.Elements : constant->desc.StructMembers;
719
720 for (i = 0; i < count; ++i)
721 {
722 free_constant(&constant->constants[i]);
723 }
724 HeapFree(GetProcessHeap(), 0, constant->constants);
725 }
726 }
727
728 static void free_constant_table(struct ID3DXConstantTableImpl *table)
729 {
730 if (table->constants)
731 {
732 UINT i;
733
734 for (i = 0; i < table->desc.Constants; ++i)
735 {
736 free_constant(&table->constants[i]);
737 }
738 HeapFree(GetProcessHeap(), 0, table->constants);
739 }
740 HeapFree(GetProcessHeap(), 0, table->ctab);
741 }
742
743 static inline struct ID3DXConstantTableImpl *impl_from_ID3DXConstantTable(ID3DXConstantTable *iface)
744 {
745 return CONTAINING_RECORD(iface, struct ID3DXConstantTableImpl, ID3DXConstantTable_iface);
746 }
747
748 static inline BOOL is_vertex_shader(DWORD version)
749 {
750 return (version & 0xffff0000) == 0xfffe0000;
751 }
752
753 static inline D3DXHANDLE handle_from_constant(struct ctab_constant *constant)
754 {
755 return (D3DXHANDLE)constant;
756 }
757
758 static struct ctab_constant *get_constant_by_name(struct ID3DXConstantTableImpl *table,
759 struct ctab_constant *constant, const char *name);
760
761 static struct ctab_constant *get_constant_element_by_name(struct ctab_constant *constant, const char *name)
762 {
763 const char *part;
764 UINT element;
765
766 TRACE("constant %p, name %s\n", constant, debugstr_a(name));
767
768 if (!name || !*name) return NULL;
769
770 element = atoi(name);
771 part = strchr(name, ']') + 1;
772
773 if (constant->desc.Elements > element)
774 {
775 struct ctab_constant *c = constant->constants ? &constant->constants[element] : constant;
776
777 switch (*part++)
778 {
779 case '.':
780 return get_constant_by_name(NULL, c, part);
781
782 case '[':
783 return get_constant_element_by_name(c, part);
784
785 case '\0':
786 TRACE("Returning parameter %p\n", c);
787 return c;
788
789 default:
790 FIXME("Unhandled case \"%c\"\n", *--part);
791 break;
792 }
793 }
794
795 TRACE("Constant not found\n");
796 return NULL;
797 }
798
799 static struct ctab_constant *get_constant_by_name(struct ID3DXConstantTableImpl *table,
800 struct ctab_constant *constant, const char *name)
801 {
802 UINT i, count, length;
803 struct ctab_constant *handles;
804 const char *part;
805
806 TRACE("table %p, constant %p, name %s\n", table, constant, debugstr_a(name));
807
808 if (!name || !*name) return NULL;
809
810 if (!constant)
811 {
812 count = table->desc.Constants;
813 handles = table->constants;
814 }
815 else
816 {
817 count = constant->desc.StructMembers;
818 handles = constant->constants;
819 }
820
821 length = strcspn(name, "[.");
822 part = name + length;
823
824 for (i = 0; i < count; i++)
825 {
826 if (strlen(handles[i].desc.Name) == length && !strncmp(handles[i].desc.Name, name, length))
827 {
828 switch (*part++)
829 {
830 case '.':
831 return get_constant_by_name(NULL, &handles[i], part);
832
833 case '[':
834 return get_constant_element_by_name(&handles[i], part);
835
836 default:
837 TRACE("Returning parameter %p\n", &handles[i]);
838 return &handles[i];
839 }
840 }
841 }
842
843 TRACE("Constant not found\n");
844 return NULL;
845 }
846
847 static struct ctab_constant *is_valid_sub_constant(struct ctab_constant *parent, D3DXHANDLE handle)
848 {
849 struct ctab_constant *c;
850 UINT i, count;
851
852 /* all variable have at least elements = 1, but not always elements */
853 if (!parent->constants) return NULL;
854
855 count = parent->desc.Elements > 1 ? parent->desc.Elements : parent->desc.StructMembers;
856 for (i = 0; i < count; ++i)
857 {
858 if (handle_from_constant(&parent->constants[i]) == handle)
859 return &parent->constants[i];
860
861 c = is_valid_sub_constant(&parent->constants[i], handle);
862 if (c) return c;
863 }
864
865 return NULL;
866 }
867
868 static inline struct ctab_constant *get_valid_constant(struct ID3DXConstantTableImpl *table, D3DXHANDLE handle)
869 {
870 struct ctab_constant *c;
871 UINT i;
872
873 if (!handle) return NULL;
874
875 for (i = 0; i < table->desc.Constants; ++i)
876 {
877 if (handle_from_constant(&table->constants[i]) == handle)
878 return &table->constants[i];
879
880 c = is_valid_sub_constant(&table->constants[i], handle);
881 if (c) return c;
882 }
883
884 if (table->flags & D3DXCONSTTABLE_LARGEADDRESSAWARE)
885 return NULL;
886
887 return get_constant_by_name(table, NULL, handle);
888 }
889
890 /*** IUnknown methods ***/
891 static HRESULT WINAPI ID3DXConstantTableImpl_QueryInterface(ID3DXConstantTable *iface, REFIID riid, void **out)
892 {
893 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
894
895 if (IsEqualGUID(riid, &IID_IUnknown) ||
896 IsEqualGUID(riid, &IID_ID3DXBuffer) ||
897 IsEqualGUID(riid, &IID_ID3DXConstantTable))
898 {
899 ID3DXConstantTable_AddRef(iface);
900 *out = iface;
901 return S_OK;
902 }
903
904 WARN("Interface %s not found.\n", debugstr_guid(riid));
905
906 return E_NOINTERFACE;
907 }
908
909 static ULONG WINAPI ID3DXConstantTableImpl_AddRef(ID3DXConstantTable *iface)
910 {
911 struct ID3DXConstantTableImpl *table = impl_from_ID3DXConstantTable(iface);
912 ULONG refcount = InterlockedIncrement(&table->ref);
913
914 TRACE("%p increasing refcount to %lu.\n", table, refcount);
915
916 return refcount;
917 }
918
919 static ULONG WINAPI ID3DXConstantTableImpl_Release(ID3DXConstantTable *iface)
920 {
921 struct ID3DXConstantTableImpl *table = impl_from_ID3DXConstantTable(iface);
922 ULONG refcount = InterlockedDecrement(&table->ref);
923
924 TRACE("%p decreasing refcount to %lu.\n", table, refcount);
925
926 if (!refcount)
927 {
928 free_constant_table(table);
929 HeapFree(GetProcessHeap(), 0, table);
930 }
931
932 return refcount;
933 }
934
935 /*** ID3DXBuffer methods ***/
936 static void * WINAPI ID3DXConstantTableImpl_GetBufferPointer(ID3DXConstantTable *iface)
937 {
938 struct ID3DXConstantTableImpl *table = impl_from_ID3DXConstantTable(iface);
939
940 TRACE("iface %p.\n", iface);
941
942 return table->ctab;
943 }
944
945 static DWORD WINAPI ID3DXConstantTableImpl_GetBufferSize(ID3DXConstantTable *iface)
946 {
947 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
948
949 TRACE("(%p)->()\n", This);
950
951 return This->size;
952 }
953
954 /*** ID3DXConstantTable methods ***/
955 static HRESULT WINAPI ID3DXConstantTableImpl_GetDesc(ID3DXConstantTable *iface, D3DXCONSTANTTABLE_DESC *desc)
956 {
957 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
958
959 TRACE("(%p)->(%p)\n", This, desc);
960
961 if (!desc)
962 return D3DERR_INVALIDCALL;
963
964 *desc = This->desc;
965
966 return D3D_OK;
967 }
968
969 const struct ctab_constant *d3dx_shader_get_ctab_constant(ID3DXConstantTable *iface, D3DXHANDLE constant)
970 {
971 struct ID3DXConstantTableImpl *ctab = impl_from_ID3DXConstantTable(iface);
972
973 return get_valid_constant(ctab, constant);
974 }
975
976 static HRESULT WINAPI ID3DXConstantTableImpl_GetConstantDesc(ID3DXConstantTable *iface, D3DXHANDLE constant,
977 D3DXCONSTANT_DESC *desc, UINT *count)
978 {
979 struct ID3DXConstantTableImpl *ctab = impl_from_ID3DXConstantTable(iface);
980 struct ctab_constant *c = get_valid_constant(ctab, constant);
981
982 TRACE("(%p)->(%p, %p, %p)\n", ctab, constant, desc, count);
983
984 if (!c)
985 {
986 WARN("Invalid argument specified\n");
987 return D3DERR_INVALIDCALL;
988 }
989
990 if (desc) *desc = c->desc;
991 if (count) *count = 1;
992
993 return D3D_OK;
994 }
995
996 static UINT WINAPI ID3DXConstantTableImpl_GetSamplerIndex(ID3DXConstantTable *iface, D3DXHANDLE constant)
997 {
998 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
999 struct ctab_constant *c = get_valid_constant(This, constant);
1000
1001 TRACE("(%p)->(%p)\n", This, constant);
1002
1003 if (!c || c->desc.RegisterSet != D3DXRS_SAMPLER)
1004 {
1005 WARN("Invalid argument specified\n");
1006 return (UINT)-1;
1007 }
1008
1009 TRACE("Returning RegisterIndex %u\n", c->desc.RegisterIndex);
1010 return c->desc.RegisterIndex;
1011 }
1012
1013 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstant(ID3DXConstantTable *iface, D3DXHANDLE constant, UINT index)
1014 {
1015 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1016 struct ctab_constant *c;
1017
1018 TRACE("(%p)->(%p, %d)\n", This, constant, index);
1019
1020 if (constant)
1021 {
1022 c = get_valid_constant(This, constant);
1023 if (c && index < c->desc.StructMembers)
1024 {
1025 c = &c->constants[index];
1026 TRACE("Returning constant %p\n", c);
1027 return handle_from_constant(c);
1028 }
1029 }
1030 else
1031 {
1032 if (index < This->desc.Constants)
1033 {
1034 c = &This->constants[index];
1035 TRACE("Returning constant %p\n", c);
1036 return handle_from_constant(c);
1037 }
1038 }
1039
1040 WARN("Index out of range\n");
1041 return NULL;
1042 }
1043
1044 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantByName(ID3DXConstantTable *iface,
1045 D3DXHANDLE constant, const char *name)
1046 {
1047 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1048 struct ctab_constant *c = get_valid_constant(This, constant);
1049
1050 TRACE("iface %p, constant %p, name %s.\n", iface, constant, debugstr_a(name));
1051
1052 c = get_constant_by_name(This, c, name);
1053 TRACE("Returning constant %p\n", c);
1054
1055 return handle_from_constant(c);
1056 }
1057
1058 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantElement(ID3DXConstantTable *iface, D3DXHANDLE constant, UINT index)
1059 {
1060 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1061 struct ctab_constant *c = get_valid_constant(This, constant);
1062
1063 TRACE("(%p)->(%p, %d)\n", This, constant, index);
1064
1065 if (c && index < c->desc.Elements)
1066 {
1067 if (c->desc.Elements > 1) c = &c->constants[index];
1068 TRACE("Returning constant %p\n", c);
1069 return handle_from_constant(c);
1070 }
1071
1072 WARN("Invalid argument specified\n");
1073 return NULL;
1074 }
1075
1076 static inline DWORD get_index(const void **indata, UINT index, BOOL is_pointer)
1077 {
1078 if (!indata)
1079 return 0;
1080
1081 if (is_pointer)
1082 return ((DWORD **)indata)[index / 16][index % 16];
1083
1084 return (*((DWORD **)indata))[index];
1085 }
1086
1087 static UINT set(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, struct ctab_constant *constant,
1088 const void **indata, D3DXPARAMETER_TYPE intype, UINT *size, UINT incol, D3DXPARAMETER_CLASS inclass, UINT index,
1089 BOOL is_pointer)
1090 {
1091 D3DXCONSTANT_DESC *desc = &constant->desc;
1092 UINT l, i, regcount = 1, regsize = 1, cin = 1, rin = 1, ret, last = 0;
1093 DWORD tmp;
1094
1095 /* size too small to set anything */
1096 if (*size < desc->Rows * desc->Columns)
1097 {
1098 *size = 0;
1099 return 0;
1100 }
1101
1102 /* D3DXPC_STRUCT is somewhat special */
1103 if (desc->Class == D3DXPC_STRUCT)
1104 {
1105 /*
1106 * Struct array sets the last complete input to the first struct element, all other
1107 * elements are not set.
1108 * E.g.: struct {int i;} s1[2];
1109 * SetValue(device, "s1", [1, 2], 8) => s1 = {2, x};
1110 *
1111 * struct {int i; int n} s2[2];
1112 * SetValue(device, "s2", [1, 2, 3, 4, 5], 20) => s1 = {{3, 4}, {x, x}};
1113 */
1114 if (desc->Elements > 1)
1115 {
1116 UINT offset = *size / (desc->Rows * desc->Columns) - 1;
1117
1118 offset = min(desc->Elements - 1, offset);
1119 last = offset * desc->Rows * desc->Columns;
1120
1121 if ((is_pointer || inclass == D3DXPC_MATRIX_ROWS) && desc->RegisterSet != D3DXRS_BOOL)
1122 {
1123 set(table, device, &constant->constants[0], NULL, intype, size, incol, inclass, 0, is_pointer);
1124 }
1125 else
1126 {
1127 last += set(table, device, &constant->constants[0], indata, intype, size, incol, inclass,
1128 index + last, is_pointer);
1129 }
1130 }
1131 else
1132 {
1133 /*
1134 * D3DXRS_BOOL is always set. As there are only 16 bools and there are
1135 * exactly 16 input values, use matrix transpose.
1136 */
1137 if (inclass == D3DXPC_MATRIX_ROWS && desc->RegisterSet == D3DXRS_BOOL)
1138 {
1139 D3DXMATRIX mat, *m, min;
1140
1141 if (is_pointer)
1142 min = *(D3DXMATRIX *)(indata[index / 16]);
1143 else
1144 min = **(D3DXMATRIX **)indata;
1145
1146 D3DXMatrixTranspose(&mat, &min);
1147 m = &mat;
1148 for (i = 0; i < desc->StructMembers; ++i)
1149 {
1150 last += set(table, device, &constant->constants[i], (const void **)&m, intype, size, incol,
1151 D3DXPC_SCALAR, index + last, is_pointer);
1152 }
1153 }
1154 /*
1155 * For pointers or for matrix rows, only the first member is set.
1156 * All other members are set to 0. This is not true for D3DXRS_BOOL.
1157 * E.g.: struct {int i; int n} s;
1158 * SetValue(device, "s", [1, 2], 8) => s = {1, 0};
1159 */
1160 else if ((is_pointer || inclass == D3DXPC_MATRIX_ROWS) && desc->RegisterSet != D3DXRS_BOOL)
1161 {
1162 last = set(table, device, &constant->constants[0], indata, intype, size, incol, inclass,
1163 index + last, is_pointer);
1164
1165 for (i = 1; i < desc->StructMembers; ++i)
1166 {
1167 set(table, device, &constant->constants[i], NULL, intype, size, incol, inclass, 0, is_pointer);
1168 }
1169 }
1170 else
1171 {
1172 for (i = 0; i < desc->StructMembers; ++i)
1173 {
1174 last += set(table, device, &constant->constants[i], indata, intype, size, incol, D3DXPC_SCALAR,
1175 index + last, is_pointer);
1176 }
1177 }
1178 }
1179
1180 return last;
1181 }
1182
1183 /* elements */
1184 if (desc->Elements > 1)
1185 {
1186 for (i = 0; i < desc->Elements && *size > 0; ++i)
1187 {
1188 last += set(table, device, &constant->constants[i], indata, intype, size, incol, inclass,
1189 index + last, is_pointer);
1190
1191 /* adjust the vector size for matrix rows */
1192 if (inclass == D3DXPC_MATRIX_ROWS && desc->Class == D3DXPC_VECTOR && (i % 4) == 3)
1193 {
1194 last += 12;
1195 *size = *size < 12 ? 0 : *size - 12;
1196 }
1197 }
1198
1199 return last;
1200 }
1201
1202 switch (desc->Class)
1203 {
1204 case D3DXPC_SCALAR:
1205 case D3DXPC_VECTOR:
1206 case D3DXPC_MATRIX_ROWS:
1207 regcount = min(desc->RegisterCount, desc->Rows);
1208 if (inclass == D3DXPC_MATRIX_ROWS) cin = incol;
1209 else rin = incol;
1210 regsize = desc->Columns;
1211 break;
1212
1213 case D3DXPC_MATRIX_COLUMNS:
1214 regcount = min(desc->RegisterCount, desc->Columns);
1215 if (inclass == D3DXPC_MATRIX_ROWS) rin = incol;
1216 else cin = incol;
1217 regsize = desc->Rows;
1218 break;
1219
1220 default:
1221 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc->Class));
1222 return 0;
1223 }
1224
1225 /* specific stuff for different in types */
1226 switch (inclass)
1227 {
1228 case D3DXPC_SCALAR:
1229 ret = desc->Columns * desc->Rows;
1230 *size -= desc->Columns * desc->Rows;
1231 break;
1232
1233 case D3DXPC_VECTOR:
1234 switch (desc->Class)
1235 {
1236 case D3DXPC_MATRIX_ROWS:
1237 if (*size < regcount * 4)
1238 {
1239 *size = 0;
1240 return 0;
1241 }
1242 ret = 4 * regcount;
1243 *size -= 4 * regcount;
1244 break;
1245
1246 case D3DXPC_MATRIX_COLUMNS:
1247 ret = 4 * regsize;
1248 *size -= 4 * regcount;
1249 break;
1250
1251 case D3DXPC_SCALAR:
1252 ret = 1;
1253 *size -= ret;
1254 break;
1255
1256 case D3DXPC_VECTOR:
1257 ret = 4;
1258 *size -= ret;
1259 break;
1260
1261 default:
1262 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc->Class));
1263 return 0;
1264 }
1265 break;
1266
1267 case D3DXPC_MATRIX_ROWS:
1268 switch (desc->Class)
1269 {
1270 case D3DXPC_MATRIX_ROWS:
1271 case D3DXPC_MATRIX_COLUMNS:
1272 if (*size < 16)
1273 {
1274 *size = 0;
1275 return 0;
1276 }
1277 ret = 16;
1278 break;
1279
1280 case D3DXPC_SCALAR:
1281 ret = 4;
1282 break;
1283
1284 case D3DXPC_VECTOR:
1285 ret = 1;
1286 break;
1287
1288 default:
1289 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc->Class));
1290 return 0;
1291 }
1292 *size -= ret;
1293 break;
1294
1295 case D3DXPC_MATRIX_COLUMNS:
1296 switch (desc->Class)
1297 {
1298 case D3DXPC_MATRIX_ROWS:
1299 case D3DXPC_MATRIX_COLUMNS:
1300 if (*size < 16)
1301 {
1302 *size = 0;
1303 return 0;
1304 }
1305 ret = 16;
1306 break;
1307
1308 case D3DXPC_SCALAR:
1309 ret = 1;
1310 break;
1311
1312 case D3DXPC_VECTOR:
1313 ret = 4;
1314 break;
1315
1316 default:
1317 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc->Class));
1318 return 0;
1319 }
1320 *size -= ret;
1321 break;
1322
1323 default:
1324 FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(inclass));
1325 return 0;
1326 }
1327
1328 /* set the registers */
1329 switch (desc->RegisterSet)
1330 {
1331 case D3DXRS_BOOL:
1332 regcount = min(desc->RegisterCount, desc->Columns * desc->Rows);
1333 l = 0;
1334 for (i = 0; i < regcount; ++i)
1335 {
1336 BOOL out;
1337 DWORD t = get_index(indata, index + i / regsize * rin + l * cin, is_pointer);
1338
1339 set_number(&tmp, desc->Type, &t, intype);
1340 set_number(&out, D3DXPT_BOOL, &tmp, desc->Type);
1341 if (is_vertex_shader(table->desc.Version))
1342 IDirect3DDevice9_SetVertexShaderConstantB(device, desc->RegisterIndex + i, &out, 1);
1343 else
1344 IDirect3DDevice9_SetPixelShaderConstantB(device, desc->RegisterIndex + i, &out, 1);
1345
1346 if (++l >= regsize) l = 0;
1347 }
1348 return ret;
1349
1350 case D3DXRS_INT4:
1351 for (i = 0; i < regcount; ++i)
1352 {
1353 INT vec[4] = {0, 0, 1, 0};
1354
1355 for (l = 0; l < regsize; ++l)
1356 {
1357 DWORD t = get_index(indata, index + i * rin + l * cin, is_pointer);
1358
1359 set_number(&tmp, desc->Type, &t, intype);
1360 set_number(&vec[l], D3DXPT_INT, &tmp, desc->Type);
1361 }
1362 if (is_vertex_shader(table->desc.Version))
1363 IDirect3DDevice9_SetVertexShaderConstantI(device, desc->RegisterIndex + i, vec, 1);
1364 else
1365 IDirect3DDevice9_SetPixelShaderConstantI(device, desc->RegisterIndex + i, vec, 1);
1366 }
1367 return ret;
1368
1369 case D3DXRS_FLOAT4:
1370 for (i = 0; i < regcount; ++i)
1371 {
1372 FLOAT vec[4] = {0};
1373
1374 for (l = 0; l < regsize; ++l)
1375 {
1376 DWORD t = get_index(indata, index + i * rin + l * cin, is_pointer);
1377
1378 set_number(&tmp, desc->Type, &t, intype);
1379 set_number(&vec[l], D3DXPT_FLOAT, &tmp, desc->Type);
1380 }
1381 if (is_vertex_shader(table->desc.Version))
1382 IDirect3DDevice9_SetVertexShaderConstantF(device, desc->RegisterIndex + i, vec, 1);
1383 else
1384 IDirect3DDevice9_SetPixelShaderConstantF(device, desc->RegisterIndex + i, vec, 1);
1385 }
1386 return ret;
1387
1388 default:
1389 FIXME("Unhandled register set %s\n", debug_d3dxparameter_registerset(desc->RegisterSet));
1390 return 0;
1391 }
1392 }
1393
1394 static HRESULT set_scalar(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1395 const void *indata, D3DXPARAMETER_TYPE intype)
1396 {
1397 struct ctab_constant *c = get_valid_constant(table, constant);
1398 UINT count = 1;
1399
1400 if (!c)
1401 {
1402 WARN("Invalid argument specified\n");
1403 return D3DERR_INVALIDCALL;
1404 }
1405
1406 switch (c->desc.Class)
1407 {
1408 case D3DXPC_SCALAR:
1409 set(table, device, c, &indata, intype, &count, c->desc.Columns, D3DXPC_SCALAR, 0, FALSE);
1410 return D3D_OK;
1411
1412 case D3DXPC_VECTOR:
1413 case D3DXPC_MATRIX_ROWS:
1414 case D3DXPC_MATRIX_COLUMNS:
1415 case D3DXPC_STRUCT:
1416 return D3D_OK;
1417
1418 default:
1419 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1420 return D3DERR_INVALIDCALL;
1421 }
1422 }
1423
1424 static HRESULT set_scalar_array(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1425 const void *indata, UINT count, D3DXPARAMETER_TYPE intype)
1426 {
1427 struct ctab_constant *c = get_valid_constant(table, constant);
1428
1429 if (!c)
1430 {
1431 WARN("Invalid argument specified\n");
1432 return D3DERR_INVALIDCALL;
1433 }
1434
1435 switch (c->desc.Class)
1436 {
1437 case D3DXPC_SCALAR:
1438 case D3DXPC_VECTOR:
1439 case D3DXPC_MATRIX_ROWS:
1440 case D3DXPC_MATRIX_COLUMNS:
1441 case D3DXPC_STRUCT:
1442 set(table, device, c, &indata, intype, &count, c->desc.Columns, D3DXPC_SCALAR, 0, FALSE);
1443 return D3D_OK;
1444
1445 default:
1446 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1447 return D3DERR_INVALIDCALL;
1448 }
1449 }
1450
1451 static HRESULT set_vector(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1452 const void *indata, D3DXPARAMETER_TYPE intype)
1453 {
1454 struct ctab_constant *c = get_valid_constant(table, constant);
1455 UINT count = 4;
1456
1457 if (!c)
1458 {
1459 WARN("Invalid argument specified\n");
1460 return D3DERR_INVALIDCALL;
1461 }
1462
1463 switch (c->desc.Class)
1464 {
1465 case D3DXPC_SCALAR:
1466 case D3DXPC_VECTOR:
1467 case D3DXPC_STRUCT:
1468 set(table, device, c, &indata, intype, &count, 4, D3DXPC_VECTOR, 0, FALSE);
1469 return D3D_OK;
1470
1471 case D3DXPC_MATRIX_ROWS:
1472 case D3DXPC_MATRIX_COLUMNS:
1473 return D3D_OK;
1474
1475 default:
1476 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1477 return D3DERR_INVALIDCALL;
1478 }
1479 }
1480
1481 static HRESULT set_vector_array(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1482 const void *indata, UINT count, D3DXPARAMETER_TYPE intype)
1483 {
1484 struct ctab_constant *c = get_valid_constant(table, constant);
1485
1486 if (!c)
1487 {
1488 WARN("Invalid argument specified\n");
1489 return D3DERR_INVALIDCALL;
1490 }
1491
1492 switch (c->desc.Class)
1493 {
1494 case D3DXPC_SCALAR:
1495 case D3DXPC_VECTOR:
1496 case D3DXPC_MATRIX_ROWS:
1497 case D3DXPC_MATRIX_COLUMNS:
1498 case D3DXPC_STRUCT:
1499 count *= 4;
1500 set(table, device, c, &indata, intype, &count, 4, D3DXPC_VECTOR, 0, FALSE);
1501 return D3D_OK;
1502
1503 default:
1504 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1505 return D3DERR_INVALIDCALL;
1506 }
1507 }
1508
1509 static HRESULT set_matrix_array(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1510 const void *indata, UINT count, BOOL transpose)
1511 {
1512 struct ctab_constant *c = get_valid_constant(table, constant);
1513
1514 if (!c)
1515 {
1516 WARN("Invalid argument specified\n");
1517 return D3DERR_INVALIDCALL;
1518 }
1519
1520 switch (c->desc.Class)
1521 {
1522 case D3DXPC_SCALAR:
1523 case D3DXPC_VECTOR:
1524 case D3DXPC_MATRIX_ROWS:
1525 case D3DXPC_MATRIX_COLUMNS:
1526 case D3DXPC_STRUCT:
1527 count *= 16;
1528 set(table, device, c, &indata, D3DXPT_FLOAT, &count, 4,
1529 transpose ? D3DXPC_MATRIX_ROWS : D3DXPC_MATRIX_COLUMNS, 0, FALSE);
1530 return D3D_OK;
1531
1532 default:
1533 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1534 return D3DERR_INVALIDCALL;
1535 }
1536 }
1537
1538 static HRESULT set_matrix_pointer_array(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device,
1539 D3DXHANDLE constant, const void **indata, UINT count, BOOL transpose)
1540 {
1541 struct ctab_constant *c = get_valid_constant(table, constant);
1542
1543 if (!c)
1544 {
1545 WARN("Invalid argument specified\n");
1546 return D3DERR_INVALIDCALL;
1547 }
1548
1549 switch (c->desc.Class)
1550 {
1551 case D3DXPC_SCALAR:
1552 case D3DXPC_VECTOR:
1553 case D3DXPC_MATRIX_ROWS:
1554 case D3DXPC_MATRIX_COLUMNS:
1555 case D3DXPC_STRUCT:
1556 count *= 16;
1557 set(table, device, c, indata, D3DXPT_FLOAT, &count, 4,
1558 transpose ? D3DXPC_MATRIX_ROWS : D3DXPC_MATRIX_COLUMNS, 0, TRUE);
1559 return D3D_OK;
1560
1561 default:
1562 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1563 return D3DERR_INVALIDCALL;
1564 }
1565 }
1566
1567 static HRESULT WINAPI ID3DXConstantTableImpl_SetDefaults(struct ID3DXConstantTable *iface,
1568 struct IDirect3DDevice9 *device)
1569 {
1570 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1571 UINT i;
1572
1573 TRACE("iface %p, device %p\n", iface, device);
1574
1575 if (!device)
1576 {
1577 WARN("Invalid argument specified\n");
1578 return D3DERR_INVALIDCALL;
1579 }
1580
1581 for (i = 0; i < This->desc.Constants; i++)
1582 {
1583 D3DXCONSTANT_DESC *desc = &This->constants[i].desc;
1584 HRESULT hr;
1585
1586 if (!desc->DefaultValue)
1587 continue;
1588
1589 switch (desc->RegisterSet)
1590 {
1591 case D3DXRS_BOOL:
1592 if (is_vertex_shader(This->desc.Version))
1593 hr = IDirect3DDevice9_SetVertexShaderConstantB(device, desc->RegisterIndex, desc->DefaultValue,
1594 desc->RegisterCount);
1595 else
1596 hr = IDirect3DDevice9_SetPixelShaderConstantB(device, desc->RegisterIndex, desc->DefaultValue,
1597 desc->RegisterCount);
1598 break;
1599
1600 case D3DXRS_INT4:
1601 if (is_vertex_shader(This->desc.Version))
1602 hr = IDirect3DDevice9_SetVertexShaderConstantI(device, desc->RegisterIndex, desc->DefaultValue,
1603 desc->RegisterCount);
1604 else
1605 hr = IDirect3DDevice9_SetPixelShaderConstantI(device, desc->RegisterIndex, desc->DefaultValue,
1606 desc->RegisterCount);
1607 break;
1608
1609 case D3DXRS_FLOAT4:
1610 if (is_vertex_shader(This->desc.Version))
1611 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, desc->RegisterIndex, desc->DefaultValue,
1612 desc->RegisterCount);
1613 else
1614 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, desc->RegisterIndex, desc->DefaultValue,
1615 desc->RegisterCount);
1616 break;
1617
1618 default:
1619 FIXME("Unhandled register set %s\n", debug_d3dxparameter_registerset(desc->RegisterSet));
1620 hr = E_NOTIMPL;
1621 break;
1622 }
1623
1624 if (hr != D3D_OK)
1625 return hr;
1626 }
1627
1628 return D3D_OK;
1629 }
1630
1631 static HRESULT WINAPI ID3DXConstantTableImpl_SetValue(struct ID3DXConstantTable *iface,
1632 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const void *data, unsigned int bytes)
1633 {
1634 struct ID3DXConstantTableImpl *table = impl_from_ID3DXConstantTable(iface);
1635 struct ctab_constant *c = get_valid_constant(table, constant);
1636 D3DXCONSTANT_DESC *desc;
1637
1638 TRACE("iface %p, device %p, constant %p, data %p, bytes %u\n", iface, device, constant, data, bytes);
1639
1640 if (!device || !c || !data)
1641 {
1642 WARN("Invalid argument specified\n");
1643 return D3DERR_INVALIDCALL;
1644 }
1645
1646 desc = &c->desc;
1647
1648 switch (desc->Class)
1649 {
1650 case D3DXPC_SCALAR:
1651 case D3DXPC_VECTOR:
1652 case D3DXPC_MATRIX_ROWS:
1653 case D3DXPC_MATRIX_COLUMNS:
1654 case D3DXPC_STRUCT:
1655 bytes /= 4;
1656 set(table, device, c, &data, desc->Type, &bytes, desc->Columns, D3DXPC_SCALAR, 0, FALSE);
1657 return D3D_OK;
1658
1659 default:
1660 FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(desc->Class));
1661 return D3DERR_INVALIDCALL;
1662 }
1663 }
1664
1665 static HRESULT WINAPI ID3DXConstantTableImpl_SetBool(struct ID3DXConstantTable *iface,
1666 struct IDirect3DDevice9 *device, D3DXHANDLE constant, BOOL b)
1667 {
1668 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1669
1670 TRACE("iface %p, device %p, constant %p, b %d\n", iface, device, constant, b);
1671
1672 return set_scalar(This, device, constant, &b, D3DXPT_BOOL);
1673 }
1674
1675 static HRESULT WINAPI ID3DXConstantTableImpl_SetBoolArray(struct ID3DXConstantTable *iface,
1676 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const BOOL *b, UINT count)
1677 {
1678 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1679
1680 TRACE("iface %p, device %p, constant %p, b %p, count %d\n", iface, device, constant, b, count);
1681
1682 return set_scalar_array(This, device, constant, b, count, D3DXPT_BOOL);
1683 }
1684
1685 static HRESULT WINAPI ID3DXConstantTableImpl_SetInt(struct ID3DXConstantTable *iface,
1686 struct IDirect3DDevice9 *device, D3DXHANDLE constant, INT n)
1687 {
1688 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1689
1690 TRACE("iface %p, device %p, constant %p, n %d\n", iface, device, constant, n);
1691
1692 return set_scalar(This, device, constant, &n, D3DXPT_INT);
1693 }
1694
1695 static HRESULT WINAPI ID3DXConstantTableImpl_SetIntArray(struct ID3DXConstantTable *iface,
1696 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const INT *n, UINT count)
1697 {
1698 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1699
1700 TRACE("iface %p, device %p, constant %p, n %p, count %d\n", iface, device, constant, n, count);
1701
1702 return set_scalar_array(This, device, constant, n, count, D3DXPT_INT);
1703 }
1704
1705 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloat(struct ID3DXConstantTable *iface,
1706 struct IDirect3DDevice9 *device, D3DXHANDLE constant, float f)
1707 {
1708 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1709
1710 TRACE("iface %p, device %p, constant %p, f %f\n", iface, device, constant, f);
1711
1712 return set_scalar(This, device, constant, &f, D3DXPT_FLOAT);
1713 }
1714
1715 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloatArray(struct ID3DXConstantTable *iface,
1716 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const float *f, UINT count)
1717 {
1718 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1719
1720 TRACE("iface %p, device %p, constant %p, f %p, count %d\n", iface, device, constant, f, count);
1721
1722 return set_scalar_array(This, device, constant, f, count, D3DXPT_FLOAT);
1723 }
1724
1725 static HRESULT WINAPI ID3DXConstantTableImpl_SetVector(struct ID3DXConstantTable *iface,
1726 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXVECTOR4 *vector)
1727 {
1728 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1729
1730 TRACE("iface %p, device %p, constant %p, vector %p\n", iface, device, constant, vector);
1731
1732 return set_vector(This, device, constant, vector, D3DXPT_FLOAT);
1733 }
1734
1735 static HRESULT WINAPI ID3DXConstantTableImpl_SetVectorArray(struct ID3DXConstantTable *iface,
1736 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXVECTOR4 *vector, UINT count)
1737 {
1738 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1739
1740 TRACE("iface %p, device %p, constant %p, vector %p, count %u\n", iface, device, constant, vector, count);
1741
1742 return set_vector_array(This, device, constant, vector, count, D3DXPT_FLOAT);
1743 }
1744
1745 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrix(struct ID3DXConstantTable *iface,
1746 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *matrix)
1747 {
1748 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1749
1750 TRACE("iface %p, device %p, constant %p, matrix %p\n", iface, device, constant, matrix);
1751
1752 return set_matrix_array(This, device, constant, matrix, 1, FALSE);
1753 }
1754
1755 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixArray(struct ID3DXConstantTable *iface,
1756 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *matrix, UINT count)
1757 {
1758 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1759
1760 TRACE("iface %p, device %p, constant %p, matrix %p, count %u\n", iface, device, constant, matrix, count);
1761
1762 return set_matrix_array(This, device, constant, matrix, count, FALSE);
1763 }
1764
1765 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixPointerArray(struct ID3DXConstantTable *iface,
1766 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX **matrix, UINT count)
1767 {
1768 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1769
1770 TRACE("iface %p, device %p, constant %p, matrix %p, count %u)\n", iface, device, constant, matrix, count);
1771
1772 return set_matrix_pointer_array(This, device, constant, (const void **)matrix, count, FALSE);
1773 }
1774
1775 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTranspose(struct ID3DXConstantTable *iface,
1776 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *matrix)
1777 {
1778 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1779
1780 TRACE("iface %p, device %p, constant %p, matrix %p\n", iface, device, constant, matrix);
1781
1782 return set_matrix_array(This, device, constant, matrix, 1, TRUE);
1783 }
1784
1785 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposeArray(struct ID3DXConstantTable *iface,
1786 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *matrix, UINT count)
1787 {
1788 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1789
1790 TRACE("iface %p, device %p, constant %p, matrix %p, count %u\n", iface, device, constant, matrix, count);
1791
1792 return set_matrix_array(This, device, constant, matrix, count, TRUE);
1793 }
1794
1795 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposePointerArray(struct ID3DXConstantTable *iface,
1796 struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX **matrix, UINT count)
1797 {
1798 struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1799
1800 TRACE("iface %p, device %p, constant %p, matrix %p, count %u)\n", iface, device, constant, matrix, count);
1801
1802 return set_matrix_pointer_array(This, device, constant, (const void **)matrix, count, TRUE);
1803 }
1804
1805 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl =
1806 {
1807 /*** IUnknown methods ***/
1808 ID3DXConstantTableImpl_QueryInterface,
1809 ID3DXConstantTableImpl_AddRef,
1810 ID3DXConstantTableImpl_Release,
1811 /*** ID3DXBuffer methods ***/
1812 ID3DXConstantTableImpl_GetBufferPointer,
1813 ID3DXConstantTableImpl_GetBufferSize,
1814 /*** ID3DXConstantTable methods ***/
1815 ID3DXConstantTableImpl_GetDesc,
1816 ID3DXConstantTableImpl_GetConstantDesc,
1817 ID3DXConstantTableImpl_GetSamplerIndex,
1818 ID3DXConstantTableImpl_GetConstant,
1819 ID3DXConstantTableImpl_GetConstantByName,
1820 ID3DXConstantTableImpl_GetConstantElement,
1821 ID3DXConstantTableImpl_SetDefaults,
1822 ID3DXConstantTableImpl_SetValue,
1823 ID3DXConstantTableImpl_SetBool,
1824 ID3DXConstantTableImpl_SetBoolArray,
1825 ID3DXConstantTableImpl_SetInt,
1826 ID3DXConstantTableImpl_SetIntArray,
1827 ID3DXConstantTableImpl_SetFloat,
1828 ID3DXConstantTableImpl_SetFloatArray,
1829 ID3DXConstantTableImpl_SetVector,
1830 ID3DXConstantTableImpl_SetVectorArray,
1831 ID3DXConstantTableImpl_SetMatrix,
1832 ID3DXConstantTableImpl_SetMatrixArray,
1833 ID3DXConstantTableImpl_SetMatrixPointerArray,
1834 ID3DXConstantTableImpl_SetMatrixTranspose,
1835 ID3DXConstantTableImpl_SetMatrixTransposeArray,
1836 ID3DXConstantTableImpl_SetMatrixTransposePointerArray
1837 };
1838
1839 static HRESULT parse_ctab_constant_type(const char *ctab, DWORD typeoffset, struct ctab_constant *constant,
1840 BOOL is_element, WORD index, WORD max_index, DWORD *offset, DWORD nameoffset, UINT regset)
1841 {
1842 const D3DXSHADER_TYPEINFO *type = (LPD3DXSHADER_TYPEINFO)(ctab + typeoffset);
1843 const D3DXSHADER_STRUCTMEMBERINFO *memberinfo = NULL;
1844 HRESULT hr = D3D_OK;
1845 UINT i, count = 0;
1846 WORD size = 0;
1847
1848 constant->desc.DefaultValue = offset ? ctab + *offset : NULL;
1849 constant->desc.Class = type->Class;
1850 constant->desc.Type = type->Type;
1851 constant->desc.Rows = type->Rows;
1852 constant->desc.Columns = type->Columns;
1853 constant->desc.Elements = is_element ? 1 : type->Elements;
1854 constant->desc.StructMembers = type->StructMembers;
1855 constant->desc.Name = ctab + nameoffset;
1856 constant->desc.RegisterSet = regset;
1857 constant->desc.RegisterIndex = index;
1858
1859 TRACE("name %s, elements %u, index %u, defaultvalue %p, regset %s\n", constant->desc.Name,
1860 constant->desc.Elements, index, constant->desc.DefaultValue,
1861 debug_d3dxparameter_registerset(regset));
1862 TRACE("class %s, type %s, rows %d, columns %d, elements %d, struct_members %d\n",
1863 debug_d3dxparameter_class(type->Class), debug_d3dxparameter_type(type->Type),
1864 type->Rows, type->Columns, type->Elements, type->StructMembers);
1865
1866 if (type->Elements > 1 && !is_element)
1867 {
1868 count = type->Elements;
1869 }
1870 else if ((type->Class == D3DXPC_STRUCT) && type->StructMembers)
1871 {
1872 memberinfo = (D3DXSHADER_STRUCTMEMBERINFO*)(ctab + type->StructMemberInfo);
1873 count = type->StructMembers;
1874 }
1875
1876 if (count)
1877 {
1878 constant->constants = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*constant->constants) * count);
1879 if (!constant->constants)
1880 {
1881 ERR("Out of memory\n");
1882 hr = E_OUTOFMEMORY;
1883 goto error;
1884 }
1885
1886 for (i = 0; i < count; ++i)
1887 {
1888 hr = parse_ctab_constant_type(ctab, memberinfo ? memberinfo[i].TypeInfo : typeoffset,
1889 &constant->constants[i], memberinfo == NULL, index + size, max_index, offset,
1890 memberinfo ? memberinfo[i].Name : nameoffset, regset);
1891 if (hr != D3D_OK)
1892 goto error;
1893
1894 size += constant->constants[i].desc.RegisterCount;
1895 }
1896 }
1897 else
1898 {
1899 WORD offsetdiff = type->Columns * type->Rows;
1900 BOOL fail = FALSE;
1901
1902 size = type->Columns * type->Rows;
1903
1904 switch (regset)
1905 {
1906 case D3DXRS_BOOL:
1907 fail = type->Class != D3DXPC_SCALAR && type->Class != D3DXPC_VECTOR
1908 && type->Class != D3DXPC_MATRIX_ROWS && type->Class != D3DXPC_MATRIX_COLUMNS;
1909 break;
1910
1911 case D3DXRS_FLOAT4:
1912 case D3DXRS_INT4:
1913 switch (type->Class)
1914 {
1915 case D3DXPC_VECTOR:
1916 size = 1;
1917 /* fall through */
1918 case D3DXPC_SCALAR:
1919 offsetdiff = type->Rows * 4;
1920 break;
1921
1922 case D3DXPC_MATRIX_ROWS:
1923 offsetdiff = type->Rows * 4;
1924 size = type->Rows;
1925 break;
1926
1927 case D3DXPC_MATRIX_COLUMNS:
1928 offsetdiff = type->Columns * 4;
1929 size = type->Columns;
1930 break;
1931
1932 default:
1933 fail = TRUE;
1934 break;
1935 }
1936 break;
1937
1938 case D3DXRS_SAMPLER:
1939 size = 1;
1940 fail = type->Class != D3DXPC_OBJECT;
1941 break;
1942
1943 default:
1944 fail = TRUE;
1945 break;
1946 }
1947
1948 if (fail)
1949 {
1950 FIXME("Unhandled register set %s, type class %s\n", debug_d3dxparameter_registerset(regset),
1951 debug_d3dxparameter_class(type->Class));
1952 }
1953
1954 /* offset in bytes => offsetdiff * sizeof(DWORD) */
1955 if (offset) *offset += offsetdiff * 4;
1956 }
1957
1958 constant->desc.RegisterCount = max(0, min(max_index - index, size));
1959 constant->desc.Bytes = 4 * constant->desc.Elements * type->Rows * type->Columns;
1960
1961 return D3D_OK;
1962
1963 error:
1964 if (constant->constants)
1965 {
1966 for (i = 0; i < count; ++i)
1967 {
1968 free_constant(&constant->constants[i]);
1969 }
1970 HeapFree(GetProcessHeap(), 0, constant->constants);
1971 constant->constants = NULL;
1972 }
1973
1974 return hr;
1975 }
1976
1977 HRESULT WINAPI D3DXGetShaderConstantTableEx(const DWORD *byte_code, DWORD flags, ID3DXConstantTable **constant_table)
1978 {
1979 struct ID3DXConstantTableImpl *object = NULL;
1980 const void *data;
1981 HRESULT hr;
1982 UINT size;
1983 const D3DXSHADER_CONSTANTTABLE *ctab_header;
1984 const D3DXSHADER_CONSTANTINFO *constant_info;
1985 DWORD i;
1986
1987 TRACE("byte_code %p, flags %#lx, constant_table %p.\n", byte_code, flags, constant_table);
1988
1989 if (constant_table)
1990 *constant_table = NULL;
1991
1992 if (!byte_code || !constant_table)
1993 {
1994 WARN("Invalid argument specified.\n");
1995 return D3DERR_INVALIDCALL;
1996 }
1997
1998 if (!is_valid_bytecode(*byte_code))
1999 {
2000 WARN("Invalid byte_code specified.\n");
2001 return D3D_OK;
2002 }
2003
2004 if (flags & ~D3DXCONSTTABLE_LARGEADDRESSAWARE)
2005 FIXME("Flags %#lx not handled.\n", flags);
2006
2007 hr = D3DXFindShaderComment(byte_code, MAKEFOURCC('C','T','A','B'), &data, &size);
2008 if (hr != D3D_OK)
2009 {
2010 WARN("CTAB not found.\n");
2011 return D3DXERR_INVALIDDATA;
2012 }
2013
2014 if (size < sizeof(*ctab_header))
2015 {
2016 WARN("Invalid CTAB size.\n");
2017 return D3DXERR_INVALIDDATA;
2018 }
2019
2020 ctab_header = (const D3DXSHADER_CONSTANTTABLE *)data;
2021 if (ctab_header->Size != sizeof(*ctab_header))
2022 {
2023 WARN("Invalid D3DXSHADER_CONSTANTTABLE size.\n");
2024 return D3DXERR_INVALIDDATA;
2025 }
2026
2027 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2028 if (!object)
2029 return E_OUTOFMEMORY;
2030
2031 object->ID3DXConstantTable_iface.lpVtbl = &ID3DXConstantTable_Vtbl;
2032 object->ref = 1;
2033
2034 object->ctab = HeapAlloc(GetProcessHeap(), 0, size);
2035 if (!object->ctab)
2036 {
2037 ERR("Out of memory\n");
2038 HeapFree(GetProcessHeap(), 0, object);
2039 return E_OUTOFMEMORY;
2040 }
2041 object->size = size;
2042 memcpy(object->ctab, data, object->size);
2043
2044 object->flags = flags;
2045 object->desc.Creator = ctab_header->Creator ? object->ctab + ctab_header->Creator : NULL;
2046 object->desc.Version = ctab_header->Version;
2047 object->desc.Constants = ctab_header->Constants;
2048 TRACE("Creator %s, Version %#lx, Constants %u, Target %s.\n",
2049 debugstr_a(object->desc.Creator), object->desc.Version, object->desc.Constants,
2050 debugstr_a(ctab_header->Target ? object->ctab + ctab_header->Target : NULL));
2051
2052 object->constants = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2053 sizeof(*object->constants) * object->desc.Constants);
2054 if (!object->constants)
2055 {
2056 ERR("Out of memory\n");
2057 hr = E_OUTOFMEMORY;
2058 goto error;
2059 }
2060
2061 constant_info = (const D3DXSHADER_CONSTANTINFO *)(object->ctab + ctab_header->ConstantInfo);
2062 for (i = 0; i < ctab_header->Constants; i++)
2063 {
2064 DWORD offset = constant_info[i].DefaultValue;
2065
2066 hr = parse_ctab_constant_type(object->ctab, constant_info[i].TypeInfo,
2067 &object->constants[i], FALSE, constant_info[i].RegisterIndex,
2068 constant_info[i].RegisterIndex + constant_info[i].RegisterCount,
2069 offset ? &offset : NULL, constant_info[i].Name, constant_info[i].RegisterSet);
2070 if (hr != D3D_OK)
2071 goto error;
2072
2073 /*
2074 * Set the register count, it may differ for D3DXRS_INT4, because somehow
2075 * it makes the assumption that the register size is 1 instead of 4, so the
2076 * count is 4 times bigger. This holds true only for toplevel shader
2077 * constants. The count of elements and members is always based on a
2078 * register size of 4.
2079 */
2080 if (object->constants[i].desc.RegisterSet == D3DXRS_INT4)
2081 {
2082 object->constants[i].desc.RegisterCount = constant_info[i].RegisterCount;
2083 }
2084 object->constants[i].constantinfo_reserved = constant_info[i].Reserved;
2085 }
2086
2087 *constant_table = &object->ID3DXConstantTable_iface;
2088
2089 return D3D_OK;
2090
2091 error:
2092 free_constant_table(object);
2093 HeapFree(GetProcessHeap(), 0, object);
2094
2095 return hr;
2096 }
2097
2098 HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
2099 {
2100 TRACE("(%p, %p): Forwarded to D3DXGetShaderConstantTableEx\n", byte_code, constant_table);
2101
2102 return D3DXGetShaderConstantTableEx(byte_code, 0, constant_table);
2103 }
2104
2105 struct d3dx9_fragment_linker
2106 {
2107 ID3DXFragmentLinker ID3DXFragmentLinker_iface;
2108 LONG ref;
2109
2110 struct IDirect3DDevice9 *device;
2111 DWORD flags;
2112 };
2113
2114 static inline struct d3dx9_fragment_linker *impl_from_ID3DXFragmentLinker(ID3DXFragmentLinker *iface)
2115 {
2116 return CONTAINING_RECORD(iface, struct d3dx9_fragment_linker, ID3DXFragmentLinker_iface);
2117 }
2118
2119 static HRESULT WINAPI d3dx9_fragment_linker_QueryInterface(ID3DXFragmentLinker *iface, REFIID riid, void **out)
2120 {
2121 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
2122
2123 if (IsEqualGUID(riid, &IID_IUnknown)
2124 || IsEqualGUID(riid, &IID_ID3DXFragmentLinker))
2125 {
2126 iface->lpVtbl->AddRef(iface);
2127 *out = iface;
2128 return D3D_OK;
2129 }
2130
2131 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
2132 *out = NULL;
2133 return E_NOINTERFACE;
2134 }
2135
2136 static ULONG WINAPI d3dx9_fragment_linker_AddRef(ID3DXFragmentLinker *iface)
2137 {
2138 struct d3dx9_fragment_linker *linker = impl_from_ID3DXFragmentLinker(iface);
2139 ULONG refcount = InterlockedIncrement(&linker->ref);
2140
2141 TRACE("%p increasing refcount to %lu.\n", linker, refcount);
2142
2143 return refcount;
2144 }
2145
2146 static ULONG WINAPI d3dx9_fragment_linker_Release(ID3DXFragmentLinker *iface)
2147 {
2148 struct d3dx9_fragment_linker *linker = impl_from_ID3DXFragmentLinker(iface);
2149 ULONG refcount = InterlockedDecrement(&linker->ref);
2150
2151 TRACE("%p decreasing refcount to %lu.\n", linker, refcount);
2152
2153 if (!refcount)
2154 {
2155 IDirect3DDevice9_Release(linker->device);
2156 heap_free(linker);
2157 }
2158
2159 return refcount;
2160 }
2161
2162 static HRESULT WINAPI d3dx9_fragment_linker_GetDevice(ID3DXFragmentLinker *iface, struct IDirect3DDevice9 **device)
2163 {
2164 struct d3dx9_fragment_linker *linker = impl_from_ID3DXFragmentLinker(iface);
2165
2166 TRACE("iface %p, device %p.\n", linker, device);
2167
2168 if (!device)
2169 {
2170 WARN("Invalid argument supplied.\n");
2171 return D3DERR_INVALIDCALL;
2172 }
2173
2174 IDirect3DDevice9_AddRef(linker->device);
2175 *device = linker->device;
2176 TRACE("Returning device %p.\n", *device);
2177
2178 return S_OK;
2179 }
2180
2181 static UINT WINAPI d3dx9_fragment_linker_GetNumberOfFragments(ID3DXFragmentLinker *iface)
2182 {
2183 FIXME("iface %p: stub.\n", iface);
2184
2185 return E_NOTIMPL;
2186 }
2187
2188 static D3DXHANDLE WINAPI d3dx9_fragment_linker_GetFragmentHandleByIndex(ID3DXFragmentLinker *iface, UINT index)
2189 {
2190 FIXME("iface %p, index %u: stub.\n", iface, index);
2191
2192 return NULL;
2193 }
2194
2195 static D3DXHANDLE WINAPI d3dx9_fragment_linker_GetFragmentHandleByName(ID3DXFragmentLinker *iface,
2196 const char *name)
2197 {
2198 FIXME("iface %p, name %s: stub.\n", iface, debugstr_a(name));
2199
2200 return NULL;
2201 }
2202
2203 static HRESULT WINAPI d3dx9_fragment_linker_GetFragmentDesc(ID3DXFragmentLinker *iface, D3DXHANDLE name,
2204 D3DXFRAGMENT_DESC *desc)
2205 {
2206 FIXME("iface %p, name %p, desc %p: stub.\n", iface, name, desc);
2207
2208 return E_NOTIMPL;
2209 }
2210
2211 static HRESULT WINAPI d3dx9_fragment_linker_AddFragments(ID3DXFragmentLinker *iface, const DWORD *fragments)
2212 {
2213 FIXME("iface %p, fragments %p: stub.\n", iface, fragments);
2214
2215 return E_NOTIMPL;
2216 }
2217
2218 static HRESULT WINAPI d3dx9_fragment_linker_GetAllFragments(ID3DXFragmentLinker *iface, ID3DXBuffer **buffer)
2219 {
2220 FIXME("iface %p, buffer %p: stub.\n", iface, buffer);
2221
2222 return E_NOTIMPL;
2223 }
2224
2225 static HRESULT WINAPI d3dx9_fragment_linker_GetFragment(ID3DXFragmentLinker *iface, D3DXHANDLE name,
2226 ID3DXBuffer **buffer)
2227 {
2228 FIXME("iface %p, name %p, buffer %p: stub.\n", iface, name, buffer);
2229
2230 return E_NOTIMPL;
2231 }
2232
2233 static HRESULT WINAPI d3dx9_fragment_linker_LinkShader(ID3DXFragmentLinker *iface, const char *profile,
2234 DWORD flags, const D3DXHANDLE *handles, UINT fragment_count, ID3DXBuffer **buffer,
2235 ID3DXBuffer **errors)
2236 {
2237 FIXME("iface %p, profile %s, flags %#lx, handles %p, fragment_count %u, buffer %p, errors %p: stub.\n",
2238 iface, debugstr_a(profile), flags, handles, fragment_count, buffer, errors);
2239
2240 return E_NOTIMPL;
2241 }
2242
2243 static HRESULT WINAPI d3dx9_fragment_linker_LinkVertexShader(ID3DXFragmentLinker *iface, const char *profile,
2244 DWORD flags, const D3DXHANDLE *handles, UINT fragment_count, IDirect3DVertexShader9 **shader,
2245 ID3DXBuffer **errors)
2246 {
2247 FIXME("iface %p, profile %s, flags %#lx, handles %p, fragment_count %u, shader %p, errors %p: stub.\n",
2248 iface, debugstr_a(profile), flags, handles, fragment_count, shader, errors);
2249
2250 return E_NOTIMPL;
2251 }
2252
2253 static HRESULT WINAPI d3dx9_fragment_linker_LinkPixelShader(ID3DXFragmentLinker *iface, const char *profile,
2254 DWORD flags, const D3DXHANDLE *handles, UINT fragment_count, IDirect3DPixelShader9 **shader,
2255 ID3DXBuffer **errors)
2256 {
2257 FIXME("iface %p, profile %s, flags %#lx, handles %p, fragment_count %u, shader %p, errors %p: stub.\n",
2258 iface, debugstr_a(profile), flags, handles, fragment_count, shader, errors);
2259
2260 return E_NOTIMPL;
2261 }
2262
2263 static HRESULT WINAPI d3dx9_fragment_linker_ClearCache(ID3DXFragmentLinker *iface)
2264 {
2265 FIXME("iface %p: stub.\n", iface);
2266
2267 return E_NOTIMPL;
2268 }
2269
2270 static const struct ID3DXFragmentLinkerVtbl d3dx9_fragment_linker_vtbl =
2271 {
2272 d3dx9_fragment_linker_QueryInterface,
2273 d3dx9_fragment_linker_AddRef,
2274 d3dx9_fragment_linker_Release,
2275 d3dx9_fragment_linker_GetDevice,
2276 d3dx9_fragment_linker_GetNumberOfFragments,
2277 d3dx9_fragment_linker_GetFragmentHandleByIndex,
2278 d3dx9_fragment_linker_GetFragmentHandleByName,
2279 d3dx9_fragment_linker_GetFragmentDesc,
2280 d3dx9_fragment_linker_AddFragments,
2281 d3dx9_fragment_linker_GetAllFragments,
2282 d3dx9_fragment_linker_GetFragment,
2283 d3dx9_fragment_linker_LinkShader,
2284 d3dx9_fragment_linker_LinkVertexShader,
2285 d3dx9_fragment_linker_LinkPixelShader,
2286 d3dx9_fragment_linker_ClearCache
2287 };
2288
2289 HRESULT WINAPI D3DXCreateFragmentLinkerEx(IDirect3DDevice9 *device, UINT size, DWORD flags,
2290 ID3DXFragmentLinker **linker)
2291 {
2292 struct d3dx9_fragment_linker *object;
2293
2294 TRACE("device %p, size %u, flags %#lx, linker %p.\n", device, size, flags, linker);
2295
2296 object = heap_alloc(sizeof(*object));
2297 if (!object)
2298 return E_OUTOFMEMORY;
2299
2300 object->ID3DXFragmentLinker_iface.lpVtbl = &d3dx9_fragment_linker_vtbl;
2301 object->ref = 1;
2302
2303 IDirect3DDevice9_AddRef(device);
2304 object->device = device;
2305 object->flags = flags;
2306
2307 *linker = &object->ID3DXFragmentLinker_iface;
2308
2309 return S_OK;
2310 }
2311
2312 HRESULT WINAPI D3DXCreateFragmentLinker(IDirect3DDevice9 *device, UINT size, ID3DXFragmentLinker **linker)
2313 {
2314 TRACE("device %p, size %u, linker %p.\n", device, size, linker);
2315
2316 return D3DXCreateFragmentLinkerEx(device, size, 0, linker);
2317 }
2318
2319 HRESULT WINAPI D3DXGetShaderSamplers(const DWORD *byte_code, const char **samplers, UINT *count)
2320 {
2321 UINT i, sampler_count = 0;
2322 UINT size;
2323 const char *data;
2324 const D3DXSHADER_CONSTANTTABLE *ctab_header;
2325 const D3DXSHADER_CONSTANTINFO *constant_info;
2326
2327 TRACE("byte_code %p, samplers %p, count %p\n", byte_code, samplers, count);
2328
2329 if (count) *count = 0;
2330
2331 if (D3DXFindShaderComment(byte_code, MAKEFOURCC('C','T','A','B'), (const void **)&data, &size) != D3D_OK)
2332 return D3D_OK;
2333
2334 if (size < sizeof(*ctab_header)) return D3D_OK;
2335
2336 ctab_header = (const D3DXSHADER_CONSTANTTABLE *)data;
2337 if (ctab_header->Size != sizeof(*ctab_header)) return D3D_OK;
2338
2339 constant_info = (const D3DXSHADER_CONSTANTINFO *)(data + ctab_header->ConstantInfo);
2340 for (i = 0; i < ctab_header->Constants; i++)
2341 {
2342 const D3DXSHADER_TYPEINFO *type;
2343
2344 TRACE("name = %s\n", data + constant_info[i].Name);
2345
2346 type = (const D3DXSHADER_TYPEINFO *)(data + constant_info[i].TypeInfo);
2347
2348 if (type->Type == D3DXPT_SAMPLER
2349 || type->Type == D3DXPT_SAMPLER1D
2350 || type->Type == D3DXPT_SAMPLER2D
2351 || type->Type == D3DXPT_SAMPLER3D
2352 || type->Type == D3DXPT_SAMPLERCUBE)
2353 {
2354 if (samplers) samplers[sampler_count] = data + constant_info[i].Name;
2355
2356 ++sampler_count;
2357 }
2358 }
2359
2360 TRACE("Found %u samplers\n", sampler_count);
2361
2362 if (count) *count = sampler_count;
2363
2364 return D3D_OK;
2365 }
2366
2367 HRESULT WINAPI D3DXDisassembleShader(const DWORD *shader, BOOL colorcode, const char *comments,
2368 ID3DXBuffer **buffer)
2369 {
2370 TRACE("shader %p, colorcode %d, comments %s, buffer %p.\n", shader, colorcode, debugstr_a(comments), buffer);
2371
2372 return D3DDisassemble(shader, D3DXGetShaderSize(shader), colorcode ? D3D_DISASM_ENABLE_COLOR_CODE : 0,
2373 comments, (ID3DBlob **)buffer);
2374 }
2375
2376 struct d3dx9_texture_shader
2377 {
2378 ID3DXTextureShader ID3DXTextureShader_iface;
2379 LONG ref;
2380
2381 ID3DXBuffer *byte_code;
2382 ULONG64 version_counter;
2383 struct d3dx_parameters_store parameters;
2384 struct d3dx_param_eval *eval;
2385 };
2386
2387 static inline struct d3dx9_texture_shader *impl_from_ID3DXTextureShader(ID3DXTextureShader *iface)
2388 {
2389 return CONTAINING_RECORD(iface, struct d3dx9_texture_shader, ID3DXTextureShader_iface);
2390 }
2391
2392 static HRESULT WINAPI d3dx9_texture_shader_QueryInterface(ID3DXTextureShader *iface, REFIID riid, void **out)
2393 {
2394 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
2395
2396 if (IsEqualGUID(riid, &IID_IUnknown) ||
2397 IsEqualGUID(riid, &IID_ID3DXTextureShader))
2398 {
2399 iface->lpVtbl->AddRef(iface);
2400 *out = iface;
2401 return D3D_OK;
2402 }
2403
2404 WARN("Interface %s not found.\n", debugstr_guid(riid));
2405 *out = NULL;
2406 return E_NOINTERFACE;
2407 }
2408
2409 static ULONG WINAPI d3dx9_texture_shader_AddRef(ID3DXTextureShader *iface)
2410 {
2411 struct d3dx9_texture_shader *texture_shader = impl_from_ID3DXTextureShader(iface);
2412 ULONG refcount = InterlockedIncrement(&texture_shader->ref);
2413
2414 TRACE("%p increasing refcount to %lu.\n", texture_shader, refcount);
2415
2416 return refcount;
2417 }
2418
2419 static ULONG WINAPI d3dx9_texture_shader_Release(ID3DXTextureShader *iface)
2420 {
2421 struct d3dx9_texture_shader *texture_shader = impl_from_ID3DXTextureShader(iface);
2422 ULONG refcount = InterlockedDecrement(&texture_shader->ref);
2423
2424 TRACE("%p decreasing refcount to %lu.\n", texture_shader, refcount);
2425
2426 if (!refcount)
2427 {
2428 if (texture_shader->byte_code)
2429 ID3DXBuffer_Release(texture_shader->byte_code);
2430 d3dx_free_param_eval(texture_shader->eval);
2431 d3dx_parameters_store_cleanup(&texture_shader->parameters);
2432 HeapFree(GetProcessHeap(), 0, texture_shader);
2433 }
2434
2435 return refcount;
2436 }
2437
2438 static HRESULT WINAPI d3dx9_texture_shader_GetFunction(ID3DXTextureShader *iface, struct ID3DXBuffer **function)
2439 {
2440 struct d3dx9_texture_shader *texture_shader = impl_from_ID3DXTextureShader(iface);
2441
2442 TRACE("iface %p, function %p.\n", iface, function);
2443
2444 *function = texture_shader->byte_code;
2445 ID3DXBuffer_AddRef(*function);
2446
2447 return S_OK;
2448 }
2449
2450 static HRESULT WINAPI d3dx9_texture_shader_GetConstantBuffer(ID3DXTextureShader *iface, struct ID3DXBuffer **constant_buffer)
2451 {
2452 FIXME("iface %p, constant_buffer %p stub.\n", iface, constant_buffer);
2453
2454 return E_NOTIMPL;
2455 }
2456
2457 static HRESULT WINAPI d3dx9_texture_shader_GetDesc(ID3DXTextureShader *iface, D3DXCONSTANTTABLE_DESC *desc)
2458 {
2459 FIXME("iface %p, desc %p stub.\n", iface, desc);
2460
2461 return E_NOTIMPL;
2462 }
2463
2464 static HRESULT WINAPI d3dx9_texture_shader_GetConstantDesc(ID3DXTextureShader *iface, D3DXHANDLE constant, D3DXCONSTANT_DESC *constant_desc, UINT *count)
2465 {
2466 FIXME("iface %p, constant %p, constant_desc %p, count %p stub.\n", iface, constant, constant_desc, count);
2467
2468 return E_NOTIMPL;
2469 }
2470
2471 static D3DXHANDLE WINAPI d3dx9_texture_shader_GetConstant(ID3DXTextureShader *iface, D3DXHANDLE constant, UINT index)
2472 {
2473 FIXME("iface %p, constant %p, index %u stub.\n", iface, constant, index);
2474
2475 return NULL;
2476 }
2477
2478 static D3DXHANDLE WINAPI d3dx9_texture_shader_GetConstantByName(ID3DXTextureShader *iface, D3DXHANDLE constant, const char *name)
2479 {
2480 FIXME("iface %p, constant %p, name %s stub.\n", iface, constant, debugstr_a(name));
2481
2482 return NULL;
2483 }
2484
2485 static D3DXHANDLE WINAPI d3dx9_texture_shader_GetConstantElement(ID3DXTextureShader *iface, D3DXHANDLE constant, UINT index)
2486 {
2487 FIXME("iface %p, constant %p, index %u stub.\n", iface, constant, index);
2488
2489 return NULL;
2490 }
2491
2492 static HRESULT WINAPI d3dx9_texture_shader_SetDefaults(ID3DXTextureShader *iface)
2493 {
2494 FIXME("iface %p stub.\n", iface);
2495
2496 return E_NOTIMPL;
2497 }
2498
2499 static HRESULT WINAPI d3dx9_texture_shader_SetValue(ID3DXTextureShader *iface, D3DXHANDLE constant, const void *data, UINT bytes)
2500 {
2501 FIXME("iface %p, constant %p, data %p, bytes %u stub.\n", iface, constant, data, bytes);
2502
2503 return E_NOTIMPL;
2504 }
2505
2506 static HRESULT WINAPI d3dx9_texture_shader_SetBool(ID3DXTextureShader *iface, D3DXHANDLE constant, BOOL b)
2507 {
2508 FIXME("iface %p, constant %p, b %u stub.\n", iface, constant, b);
2509
2510 return E_NOTIMPL;
2511 }
2512
2513 static HRESULT WINAPI d3dx9_texture_shader_SetBoolArray(ID3DXTextureShader *iface, D3DXHANDLE constant, const BOOL *b, UINT count)
2514 {
2515 FIXME("iface %p, constant %p, b %p, count %u stub.\n", iface, constant, b, count);
2516
2517 return E_NOTIMPL;
2518 }
2519
2520 static HRESULT WINAPI d3dx9_texture_shader_SetInt(ID3DXTextureShader *iface, D3DXHANDLE constant, INT n)
2521 {
2522 FIXME("iface %p, constant %p, n %d stub.\n", iface, constant, n);
2523
2524 return E_NOTIMPL;
2525 }
2526
2527 static HRESULT WINAPI d3dx9_texture_shader_SetIntArray(ID3DXTextureShader *iface, D3DXHANDLE constant, const INT *n, UINT count)
2528 {
2529 FIXME("iface %p, constant %p, n %p, count %u stub.\n", iface, constant, n, count);
2530
2531 return E_NOTIMPL;
2532 }
2533
2534 static HRESULT WINAPI d3dx9_texture_shader_SetFloat(ID3DXTextureShader *iface, D3DXHANDLE constant, FLOAT f)
2535 {
2536 FIXME("iface %p, constant %p, f %f stub.\n", iface, constant, f);
2537
2538 return E_NOTIMPL;
2539 }
2540
2541 static HRESULT WINAPI d3dx9_texture_shader_SetFloatArray(ID3DXTextureShader *iface, D3DXHANDLE constant, const FLOAT *f, UINT count)
2542 {
2543 FIXME("iface %p, constant %p, f %p, count %u stub.\n", iface, constant, f, count);
2544
2545 return E_NOTIMPL;
2546 }
2547
2548 static HRESULT WINAPI d3dx9_texture_shader_SetVector(ID3DXTextureShader *iface, D3DXHANDLE constant, const D3DXVECTOR4 *vector)
2549 {
2550 FIXME("iface %p, constant %p, vector %p stub.\n", iface, constant, vector);
2551
2552 return E_NOTIMPL;
2553 }
2554
2555 static HRESULT WINAPI d3dx9_texture_shader_SetVectorArray(ID3DXTextureShader *iface, D3DXHANDLE constant, const D3DXVECTOR4 *vector, UINT count)
2556 {
2557 FIXME("iface %p, constant %p, vector %p, count %u stub.\n", iface, constant, vector, count);
2558
2559 return E_NOTIMPL;
2560 }
2561
2562 static HRESULT WINAPI d3dx9_texture_shader_SetMatrix(ID3DXTextureShader *iface, D3DXHANDLE constant, const D3DXMATRIX *matrix)
2563 {
2564 FIXME("iface %p, constant %p, matrix %p stub.\n", iface, constant, matrix);
2565
2566 return E_NOTIMPL;
2567 }
2568
2569 static HRESULT WINAPI d3dx9_texture_shader_SetMatrixArray(ID3DXTextureShader *iface, D3DXHANDLE constant, const D3DXMATRIX *matrix, UINT count)
2570 {
2571 FIXME("iface %p, constant %p, matrix %p, count %u stub.\n", iface, constant, matrix, count);
2572
2573 return E_NOTIMPL;
2574 }
2575
2576 static HRESULT WINAPI d3dx9_texture_shader_SetMatrixPointerArray(ID3DXTextureShader *iface, D3DXHANDLE constant, const D3DXMATRIX **matrix, UINT count)
2577 {
2578 FIXME("iface %p, constant %p, matrix %p, count %u stub.\n", iface, constant, matrix, count);
2579
2580 return E_NOTIMPL;
2581 }
2582
2583 static HRESULT WINAPI d3dx9_texture_shader_SetMatrixTranspose(ID3DXTextureShader *iface, D3DXHANDLE constant, const D3DXMATRIX *matrix)
2584 {
2585 FIXME("iface %p, constant %p, matrix %p stub.\n", iface, constant, matrix);
2586
2587 return E_NOTIMPL;
2588 }
2589
2590 static HRESULT WINAPI d3dx9_texture_shader_SetMatrixTransposeArray(ID3DXTextureShader *iface, D3DXHANDLE constant, const D3DXMATRIX *matrix, UINT count)
2591 {
2592 FIXME("iface %p, constant %p, matrix %p, count %u stub.\n", iface, constant, matrix, count);
2593
2594 return E_NOTIMPL;
2595 }
2596
2597 static HRESULT WINAPI d3dx9_texture_shader_SetMatrixTransposePointerArray(ID3DXTextureShader *iface, D3DXHANDLE constant, const D3DXMATRIX **matrix, UINT count)
2598 {
2599 FIXME("iface %p, constant %p, matrix %p, count %u stub.\n", iface, constant, matrix, count);
2600
2601 return E_NOTIMPL;
2602 }
2603
2604 static const struct ID3DXTextureShaderVtbl d3dx9_texture_shader_vtbl =
2605 {
2606 /*** IUnknown methods ***/
2607 d3dx9_texture_shader_QueryInterface,
2608 d3dx9_texture_shader_AddRef,
2609 d3dx9_texture_shader_Release,
2610 /*** ID3DXTextureShader methods ***/
2611 d3dx9_texture_shader_GetFunction,
2612 d3dx9_texture_shader_GetConstantBuffer,
2613 d3dx9_texture_shader_GetDesc,
2614 d3dx9_texture_shader_GetConstantDesc,
2615 d3dx9_texture_shader_GetConstant,
2616 d3dx9_texture_shader_GetConstantByName,
2617 d3dx9_texture_shader_GetConstantElement,
2618 d3dx9_texture_shader_SetDefaults,
2619 d3dx9_texture_shader_SetValue,
2620 d3dx9_texture_shader_SetBool,
2621 d3dx9_texture_shader_SetBoolArray,
2622 d3dx9_texture_shader_SetInt,
2623 d3dx9_texture_shader_SetIntArray,
2624 d3dx9_texture_shader_SetFloat,
2625 d3dx9_texture_shader_SetFloatArray,
2626 d3dx9_texture_shader_SetVector,
2627 d3dx9_texture_shader_SetVectorArray,
2628 d3dx9_texture_shader_SetMatrix,
2629 d3dx9_texture_shader_SetMatrixArray,
2630 d3dx9_texture_shader_SetMatrixPointerArray,
2631 d3dx9_texture_shader_SetMatrixTranspose,
2632 d3dx9_texture_shader_SetMatrixTransposeArray,
2633 d3dx9_texture_shader_SetMatrixTransposePointerArray
2634 };
2635
2636 static inline struct d3dx9_texture_shader *unsafe_impl_from_ID3DXTextureShader(ID3DXTextureShader *iface)
2637 {
2638 if (!iface)
2639 return NULL;
2640
2641 assert(iface->lpVtbl == &d3dx9_texture_shader_vtbl);
2642 return impl_from_ID3DXTextureShader(iface);
2643 }
2644
2645 HRESULT WINAPI D3DXCreateTextureShader(const DWORD *function, ID3DXTextureShader **texture_shader)
2646 {
2647 struct d3dx9_texture_shader *object;
2648 unsigned int size;
2649 HRESULT hr;
2650
2651 TRACE("function %p, texture_shader %p.\n", function, texture_shader);
2652
2653 if (!function || !texture_shader)
2654 return D3DERR_INVALIDCALL;
2655
2656 if (!(size = D3DXGetShaderSize(function)))
2657 return D3DXERR_INVALIDDATA;
2658
2659 if (!(object = heap_alloc_zero(sizeof(*object))))
2660 return E_OUTOFMEMORY;
2661
2662 object->ID3DXTextureShader_iface.lpVtbl = &d3dx9_texture_shader_vtbl;
2663 object->ref = 1;
2664
2665 if (FAILED(hr = D3DXCreateBuffer(size, &object->byte_code)))
2666 {
2667 IUnknown_Release(&object->ID3DXTextureShader_iface);
2668 return hr;
2669 }
2670 memcpy(ID3DXBuffer_GetBufferPointer(object->byte_code), function, size);
2671
2672 if (FAILED(hr = d3dx_init_parameters_store(&object->parameters, 0)))
2673 {
2674 IUnknown_Release(&object->ID3DXTextureShader_iface);
2675 return hr;
2676 }
2677
2678 if (FAILED(hr = d3dx_create_param_eval(&object->parameters, ID3DXBuffer_GetBufferPointer(object->byte_code),
2679 size, D3DXPT_FLOAT, &object->eval, &object->version_counter, NULL, 0)))
2680 {
2681 IUnknown_Release(&object->ID3DXTextureShader_iface);
2682 return hr;
2683 }
2684
2685 *texture_shader = &object->ID3DXTextureShader_iface;
2686
2687 return D3D_OK;
2688 }
2689
2690 void WINAPI texture_shader_fill_2d(D3DXVECTOR4 *out, const D3DXVECTOR2 *texcoord,
2691 const D3DXVECTOR2 *texelsize, void *data)
2692 {
2693 struct d3dx9_texture_shader *shader = data;
2694 struct d3dx_parameter param = { 0 };
2695 float *inputs;
2696
2697 inputs = (float *)shader->eval->pres.regs.tables[PRES_REGTAB_INPUT];
2698
2699 *(inputs++) = texcoord->x;
2700 *(inputs++) = texcoord->y;
2701 *(inputs++) = 0.0f;
2702 *(inputs++) = 0.0f;
2703
2704 *(inputs++) = texelsize->x;
2705 *(inputs++) = texelsize->y;
2706 *(inputs++) = 0.0f;
2707 *(inputs++) = 0.0f;
2708
2709 param.type = D3DXPT_FLOAT;
2710 param.bytes = 4 * sizeof(float);
2711 d3dx_evaluate_parameter(shader->eval, &param, out);
2712 }
2713
2714 void WINAPI texture_shader_fill_3d(D3DXVECTOR4 *out, const D3DXVECTOR3 *texcoord,
2715 const D3DXVECTOR3 *texelsize, void *data)
2716 {
2717 struct d3dx9_texture_shader *shader = data;
2718 struct d3dx_parameter param = { 0 };
2719 float *inputs;
2720
2721 inputs = (float *)shader->eval->pres.regs.tables[PRES_REGTAB_INPUT];
2722
2723 *(inputs++) = texcoord->x;
2724 *(inputs++) = texcoord->y;
2725 *(inputs++) = texcoord->z;
2726 *(inputs++) = 0.0f;
2727
2728 *(inputs++) = texelsize->x;
2729 *(inputs++) = texelsize->y;
2730 *(inputs++) = texelsize->z;
2731 *(inputs++) = 0.0f;
2732
2733 param.type = D3DXPT_FLOAT;
2734 param.bytes = 4 * sizeof(float);
2735 d3dx_evaluate_parameter(shader->eval, &param, out);
2736 }
2737
2738 HRESULT WINAPI D3DXFillTextureTX(struct IDirect3DTexture9 *texture, ID3DXTextureShader *texture_shader)
2739 {
2740 struct d3dx9_texture_shader *shader = unsafe_impl_from_ID3DXTextureShader(texture_shader);
2741
2742 TRACE("texture %p, texture_shader %p.\n", texture, texture_shader);
2743
2744 return D3DXFillTexture(texture, texture_shader_fill_2d, shader);
2745 }
2746
2747 HRESULT WINAPI D3DXFillCubeTextureTX(struct IDirect3DCubeTexture9 *cube, ID3DXTextureShader *texture_shader)
2748 {
2749 struct d3dx9_texture_shader *shader = unsafe_impl_from_ID3DXTextureShader(texture_shader);
2750
2751 TRACE("cube %p, texture_shader %p.\n", cube, texture_shader);
2752
2753 return D3DXFillCubeTexture(cube, texture_shader_fill_3d, shader);
2754 }
2755
2756 static unsigned int get_instr_length(const DWORD *byte_code, unsigned int major, unsigned int minor)
2757 {
2758 DWORD opcode = *byte_code & 0xffff;
2759 unsigned int len = 0;
2760
2761 if (opcode == D3DSIO_COMMENT)
2762 return (*byte_code & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
2763
2764 if (major > 1)
2765 return (*byte_code & D3DSI_INSTLENGTH_MASK) >> D3DSI_INSTLENGTH_SHIFT;
2766
2767 switch (opcode)
2768 {
2769 case D3DSIO_END:
2770 ERR("Unexpected END token.\n");
2771 return 0;
2772 case D3DSIO_DEF:
2773 case D3DSIO_DEFI:
2774 return 5;
2775 case D3DSIO_DEFB:
2776 return 2;
2777 default:
2778 ++byte_code;
2779 while (*byte_code & 0x80000000)
2780 {
2781 ++byte_code;
2782 ++len;
2783 }
2784 }
2785
2786 return len;
2787 }
2788
2789 static HRESULT get_shader_semantics(const DWORD *byte_code, D3DXSEMANTIC *semantics, UINT *count, BOOL output)
2790 {
2791 static const D3DDECLUSAGE regtype_usage[] =
2792 {
2793 D3DDECLUSAGE_COLOR,
2794 D3DDECLUSAGE_COLOR,
2795 0,
2796 D3DDECLUSAGE_TEXCOORD,
2797 0,
2798 D3DDECLUSAGE_COLOR,
2799 D3DDECLUSAGE_TEXCOORD,
2800 0,
2801 0,
2802 D3DDECLUSAGE_DEPTH
2803 };
2804 static const D3DDECLUSAGE rast_usage[] =
2805 {
2806 D3DDECLUSAGE_POSITION,
2807 D3DDECLUSAGE_FOG,
2808 D3DDECLUSAGE_PSIZE
2809 };
2810 uint32_t reg_type, usage, index, version_token = *byte_code;
2811 BOOL is_ps = version_token >> 16 == 0xffff;
2812 unsigned int major, minor, i = 0, j;
2813 BYTE colors = 0, rastout = 0;
2814 BOOL has_dcl, depth = 0;
2815 WORD texcoords = 0;
2816
2817 if ((version_token & 0xffff0000) != 0xfffe0000 && (version_token & 0xffff0000) != 0xffff0000)
2818 return D3DXERR_INVALIDDATA;
2819
2820 major = version_token >> 8 & 0xff;
2821 minor = version_token & 0xff;
2822
2823 TRACE("%s shader, version %u.%u.\n", is_ps ? "Pixel" : "Vertex", major, minor);
2824 ++byte_code;
2825
2826 has_dcl = (!is_ps && (!output || major == 3)) || (is_ps && !output && major >= 2);
2827
2828 while (*byte_code != D3DSIO_END)
2829 {
2830 if (has_dcl && (*byte_code & 0xffff) == D3DSIO_DCL)
2831 {
2832 uint32_t usage_token = byte_code[1];
2833 uint32_t reg = byte_code[2];
2834
2835 reg_type = ((reg & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT)
2836 | ((reg & D3DSP_REGTYPE_MASK2) >> D3DSP_REGTYPE_SHIFT2);
2837
2838 if (is_ps && !output && major == 2)
2839 {
2840 /* dcl with no explicit usage, look at the register. */
2841 reg_type = ((reg & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT)
2842 | ((reg & D3DSP_REGTYPE_MASK2) >> D3DSP_REGTYPE_SHIFT2);
2843 index = reg & D3DSP_REGNUM_MASK;
2844 if (reg_type >= ARRAY_SIZE(regtype_usage))
2845 {
2846 WARN("Invalid register type %u.\n", reg_type);
2847 reg_type = 0;
2848 }
2849 usage = regtype_usage[reg_type];
2850 if (semantics)
2851 {
2852 semantics[i].Usage = usage;
2853 semantics[i].UsageIndex = index;
2854 }
2855 ++i;
2856 }
2857 else if ((!output && reg_type == D3DSPR_INPUT) || (output && reg_type == D3DSPR_OUTPUT))
2858 {
2859 if (semantics)
2860 {
2861 semantics[i].Usage =
2862 (usage_token & D3DSP_DCL_USAGE_MASK) >> D3DSP_DCL_USAGE_SHIFT;
2863 semantics[i].UsageIndex =
2864 (usage_token & D3DSP_DCL_USAGEINDEX_MASK) >> D3DSP_DCL_USAGEINDEX_SHIFT;
2865 }
2866 ++i;
2867 }
2868 byte_code += 3;
2869 }
2870 else if (!has_dcl)
2871 {
2872 unsigned int len = get_instr_length(byte_code, major, minor) + 1;
2873
2874 switch (*byte_code & 0xffff)
2875 {
2876 case D3DSIO_COMMENT:
2877 case D3DSIO_DEF:
2878 case D3DSIO_DEFB:
2879 case D3DSIO_DEFI:
2880 byte_code += len;
2881 break;
2882 default:
2883 ++byte_code;
2884 while (*byte_code & 0x80000000)
2885 {
2886 reg_type = ((*byte_code & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT)
2887 | ((*byte_code & D3DSP_REGTYPE_MASK2) >> D3DSP_REGTYPE_SHIFT2);
2888 index = *byte_code & D3DSP_REGNUM_MASK;
2889
2890 if ((reg_type == D3DSPR_TEMP && is_ps && major == 1)
2891 || (reg_type == D3DSPR_INPUT && is_ps)
2892 || (reg_type == D3DSPR_TEXTURE && is_ps && !output)
2893 || reg_type == D3DSPR_RASTOUT
2894 || reg_type == D3DSPR_ATTROUT
2895 || reg_type == D3DSPR_OUTPUT
2896 || reg_type == D3DSPR_DEPTHOUT)
2897 {
2898 if (reg_type == D3DSPR_RASTOUT)
2899 rastout |= 1u << index;
2900 else if (reg_type == D3DSPR_DEPTHOUT)
2901 depth = TRUE;
2902 else if (reg_type == D3DSPR_TEXTURE || reg_type == D3DSPR_OUTPUT)
2903 texcoords |= 1u << index;
2904 else
2905 colors |= 1u << index;
2906 }
2907 ++byte_code;
2908 }
2909 }
2910 }
2911 else
2912 {
2913 byte_code += get_instr_length(byte_code, major, minor) + 1;
2914 }
2915 }
2916
2917 if (!has_dcl)
2918 {
2919 i = j = 0;
2920 while (texcoords)
2921 {
2922 if (texcoords & 1)
2923 {
2924 if (semantics)
2925 {
2926 semantics[i].Usage = D3DDECLUSAGE_TEXCOORD;
2927 semantics[i].UsageIndex = j;
2928 }
2929 ++i;
2930 }
2931 texcoords >>= 1;
2932 ++j;
2933 }
2934 j = 0;
2935 while (colors)
2936 {
2937 if (colors & 1)
2938 {
2939 if (semantics)
2940 {
2941 semantics[i].Usage = D3DDECLUSAGE_COLOR;
2942 semantics[i].UsageIndex = j;
2943 }
2944 ++i;
2945 }
2946 colors >>= 1;
2947 ++j;
2948 }
2949 j = 0;
2950 while (rastout)
2951 {
2952 if (rastout & 1)
2953 {
2954 if (j >= ARRAY_SIZE(rast_usage))
2955 {
2956 WARN("Invalid RASTOUT register index.\n");
2957 usage = 0;
2958 }
2959 else
2960 {
2961 usage = rast_usage[j];
2962 }
2963 if (semantics)
2964 {
2965 semantics[i].Usage = usage;
2966 semantics[i].UsageIndex = 0;
2967 }
2968 ++i;
2969 }
2970 rastout >>= 1;
2971 ++j;
2972 }
2973 if (depth)
2974 {
2975 if (semantics)
2976 {
2977 semantics[i].Usage = D3DDECLUSAGE_DEPTH;
2978 semantics[i].UsageIndex = 0;
2979 }
2980 ++i;
2981 }
2982 }
2983
2984 if (count)
2985 *count = i;
2986
2987 return D3D_OK;
2988 }
2989
2990 HRESULT WINAPI D3DXGetShaderInputSemantics(const DWORD *byte_code, D3DXSEMANTIC *semantics, UINT *count)
2991 {
2992 TRACE("byte_code %p, semantics %p, count %p.\n", byte_code, semantics, count);
2993
2994 return get_shader_semantics(byte_code, semantics, count, FALSE);
2995 }
2996
2997 HRESULT WINAPI D3DXGetShaderOutputSemantics(const DWORD *byte_code, D3DXSEMANTIC *semantics, UINT *count)
2998 {
2999 TRACE("byte_code %p, semantics %p, count %p.\n", byte_code, semantics, count);
3000
3001 return get_shader_semantics(byte_code, semantics, count, TRUE);
3002 }
Windows API implementation