2 * Copyright 2008 Luis Busquets
3 * Copyright 2009 Matteo Bruni
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include "wine/port.h"
22 #include "wine/debug.h"
23 #include "wine/unicode.h"
27 #include "d3dx9_36_private.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
31 LPCSTR WINAPI D3DXGetPixelShaderProfile(LPDIRECT3DDEVICE9 device)
35 TRACE("device %p\n", device);
37 if (!device) return NULL;
39 IDirect3DDevice9_GetDeviceCaps(device,&caps);
41 switch (caps.PixelShaderVersion)
43 case D3DPS_VERSION(1, 1):
46 case D3DPS_VERSION(1, 2):
49 case D3DPS_VERSION(1, 3):
52 case D3DPS_VERSION(1, 4):
55 case D3DPS_VERSION(2, 0):
56 if ((caps.PS20Caps.NumTemps>=22) &&
57 (caps.PS20Caps.Caps&D3DPS20CAPS_ARBITRARYSWIZZLE) &&
58 (caps.PS20Caps.Caps&D3DPS20CAPS_GRADIENTINSTRUCTIONS) &&
59 (caps.PS20Caps.Caps&D3DPS20CAPS_PREDICATION) &&
60 (caps.PS20Caps.Caps&D3DPS20CAPS_NODEPENDENTREADLIMIT) &&
61 (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
65 if ((caps.PS20Caps.NumTemps>=32) &&
66 (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
72 case D3DPS_VERSION(3, 0):
79 UINT WINAPI D3DXGetShaderSize(const DWORD *byte_code)
81 const DWORD *ptr = byte_code;
83 TRACE("byte_code %p\n", byte_code);
87 /* Look for the END token, skipping the VERSION token */
88 while (*++ptr != D3DSIO_END)
91 if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
93 ptr += ((*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT);
98 /* Return the shader size in bytes */
99 return (ptr - byte_code) * sizeof(*ptr);
102 DWORD WINAPI D3DXGetShaderVersion(const DWORD *byte_code)
104 TRACE("byte_code %p\n", byte_code);
106 return byte_code ? *byte_code : 0;
109 LPCSTR WINAPI D3DXGetVertexShaderProfile(LPDIRECT3DDEVICE9 device)
113 TRACE("device %p\n", device);
115 if (!device) return NULL;
117 IDirect3DDevice9_GetDeviceCaps(device,&caps);
119 switch (caps.VertexShaderVersion)
121 case D3DVS_VERSION(1, 1):
123 case D3DVS_VERSION(2, 0):
124 if ((caps.VS20Caps.NumTemps>=13) &&
125 (caps.VS20Caps.DynamicFlowControlDepth==24) &&
126 (caps.VS20Caps.Caps&D3DPS20CAPS_PREDICATION))
131 case D3DVS_VERSION(3, 0):
138 HRESULT WINAPI D3DXFindShaderComment(CONST DWORD* byte_code, DWORD fourcc, LPCVOID* data, UINT* size)
140 CONST DWORD *ptr = byte_code;
142 TRACE("(%p, %x, %p, %p)\n", byte_code, fourcc, data, size);
145 return D3DERR_INVALIDCALL;
147 while (*++ptr != D3DSIO_END)
149 /* Check if it is a comment */
150 if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
152 DWORD comment_size = (*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
154 /* Check if this is the comment we are looking for */
155 if (*(ptr + 1) == fourcc)
157 UINT ctab_size = (comment_size - 1) * sizeof(DWORD);
158 LPCVOID ctab_data = ptr + 2;
163 TRACE("Returning comment data at %p with size %d\n", ctab_data, ctab_size);
173 #define BUFFER_INITIAL_CAPACITY 256
182 struct mem_file_desc current_shader;
183 LPD3DXINCLUDE current_include;
185 int wpp_output_capacity, wpp_output_size;
188 int wpp_messages_capacity, wpp_messages_size;
190 /* Mutex used to guarantee a single invocation
191 of the D3DXAssembleShader function (or its variants) at a time.
192 This is needed as wpp isn't thread-safe */
193 static CRITICAL_SECTION wpp_mutex;
194 static CRITICAL_SECTION_DEBUG wpp_mutex_debug =
197 { &wpp_mutex_debug.ProcessLocksList,
198 &wpp_mutex_debug.ProcessLocksList },
199 0, 0, { (DWORD_PTR)(__FILE__ ": wpp_mutex") }
201 static CRITICAL_SECTION wpp_mutex = { &wpp_mutex_debug, -1, 0, 0, 0, 0 };
203 /* Preprocessor error reporting functions */
204 static void wpp_write_message(const char *fmt, va_list args)
209 if(wpp_messages_capacity == 0)
211 wpp_messages = HeapAlloc(GetProcessHeap(), 0, MESSAGEBUFFER_INITIAL_SIZE);
212 if(wpp_messages == NULL)
214 ERR("Error allocating memory for parser messages\n");
217 wpp_messages_capacity = MESSAGEBUFFER_INITIAL_SIZE;
222 rc = vsnprintf(wpp_messages + wpp_messages_size,
223 wpp_messages_capacity - wpp_messages_size, fmt, args);
225 if (rc < 0 || /* C89 */
226 rc >= wpp_messages_capacity - wpp_messages_size) { /* C99 */
227 /* Resize the buffer */
228 newsize = wpp_messages_capacity * 2;
229 newbuffer = HeapReAlloc(GetProcessHeap(), 0, wpp_messages, newsize);
230 if(newbuffer == NULL)
232 ERR("Error reallocating memory for parser messages\n");
235 wpp_messages = newbuffer;
236 wpp_messages_capacity = newsize;
240 wpp_messages_size += rc;
246 static void PRINTF_ATTR(1,2) wpp_write_message_var(const char *fmt, ...)
251 wpp_write_message(fmt, args);
255 static void wpp_error(const char *file, int line, int col, const char *near,
256 const char *msg, va_list ap)
258 wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'",
260 wpp_write_message(msg, ap);
261 wpp_write_message_var("\n");
264 static void wpp_warning(const char *file, int line, int col, const char *near,
265 const char *msg, va_list ap)
267 wpp_write_message_var("%s:%d:%d: %s: ", file ? file : "'main file'",
268 line, col, "Warning");
269 wpp_write_message(msg, ap);
270 wpp_write_message_var("\n");
273 static char *wpp_lookup_mem(const char *filename, const char *parent_name,
274 char **include_path, int include_path_count)
276 /* Here we return always ok. We will maybe fail on the next wpp_open_mem */
279 path = malloc(strlen(filename) + 1);
280 if(!path) return NULL;
281 memcpy(path, filename, strlen(filename) + 1);
285 static void *wpp_open_mem(const char *filename, int type)
287 struct mem_file_desc *desc;
290 if(filename[0] == '\0') /* "" means to load the initial shader */
292 current_shader.pos = 0;
293 return ¤t_shader;
296 if(current_include == NULL) return NULL;
297 desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*desc));
300 ERR("Error allocating memory\n");
303 hr = ID3DXInclude_Open(current_include,
304 type ? D3DXINC_SYSTEM : D3DXINC_LOCAL,
305 filename, NULL, (LPCVOID *)&desc->buffer,
309 HeapFree(GetProcessHeap(), 0, desc);
316 static void wpp_close_mem(void *file)
318 struct mem_file_desc *desc = file;
320 if(desc != ¤t_shader)
323 ID3DXInclude_Close(current_include, desc->buffer);
325 ERR("current_include == NULL, desc == %p, buffer = %s\n",
328 HeapFree(GetProcessHeap(), 0, desc);
332 static int wpp_read_mem(void *file, char *buffer, unsigned int len)
334 struct mem_file_desc *desc = file;
336 len = min(len, desc->size - desc->pos);
337 memcpy(buffer, desc->buffer + desc->pos, len);
342 static void wpp_write_mem(const char *buffer, unsigned int len)
344 char *new_wpp_output;
346 if(wpp_output_capacity == 0)
348 wpp_output = HeapAlloc(GetProcessHeap(), 0, BUFFER_INITIAL_CAPACITY);
351 ERR("Error allocating memory\n");
354 wpp_output_capacity = BUFFER_INITIAL_CAPACITY;
356 if(len > wpp_output_capacity - wpp_output_size)
358 while(len > wpp_output_capacity - wpp_output_size)
360 wpp_output_capacity *= 2;
362 new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
363 wpp_output_capacity);
366 ERR("Error allocating memory\n");
369 wpp_output = new_wpp_output;
371 memcpy(wpp_output + wpp_output_size, buffer, len);
372 wpp_output_size += len;
375 static int wpp_close_output(void)
377 char *new_wpp_output = HeapReAlloc(GetProcessHeap(), 0, wpp_output,
378 wpp_output_size + 1);
379 if(!new_wpp_output) return 0;
380 wpp_output = new_wpp_output;
381 wpp_output[wpp_output_size]='\0';
385 HRESULT assemble_shader(const char *preprocShader, const char *preprocMessages,
386 LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs)
388 struct bwriter_shader *shader;
389 char *messages = NULL;
396 shader = SlAssembleShader(preprocShader, &messages);
398 if(messages || preprocMessages)
402 TRACE("Preprocessor messages:\n");
403 TRACE("%s", preprocMessages);
407 TRACE("Assembler messages:\n");
408 TRACE("%s", messages);
411 TRACE("Shader source:\n");
412 TRACE("%s\n", debugstr_a(preprocShader));
416 size = (messages ? strlen(messages) : 0) +
417 (preprocMessages ? strlen(preprocMessages) : 0) + 1;
418 hr = D3DXCreateBuffer(size, &buffer);
421 HeapFree(GetProcessHeap(), 0, messages);
422 if(shader) SlDeleteShader(shader);
425 pos = ID3DXBuffer_GetBufferPointer(buffer);
428 CopyMemory(pos, preprocMessages, strlen(preprocMessages) + 1);
429 pos += strlen(preprocMessages);
432 CopyMemory(pos, messages, strlen(messages) + 1);
434 *ppErrorMsgs = buffer;
437 HeapFree(GetProcessHeap(), 0, messages);
442 ERR("Asm reading failed\n");
443 return D3DXERR_INVALIDDATA;
446 hr = SlWriteBytecode(shader, 9, &res);
447 SlDeleteShader(shader);
450 ERR("SlWriteBytecode failed with 0x%08x\n", hr);
451 return D3DXERR_INVALIDDATA;
456 size = HeapSize(GetProcessHeap(), 0, res);
457 hr = D3DXCreateBuffer(size, &buffer);
460 HeapFree(GetProcessHeap(), 0, res);
463 CopyMemory(ID3DXBuffer_GetBufferPointer(buffer), res, size);
467 HeapFree(GetProcessHeap(), 0, res);
472 HRESULT WINAPI D3DXAssembleShader(LPCSTR data,
474 CONST D3DXMACRO* defines,
475 LPD3DXINCLUDE include,
477 LPD3DXBUFFER* shader,
478 LPD3DXBUFFER* error_messages)
482 CONST D3DXMACRO* def = defines;
484 static const struct wpp_callbacks wpp_callbacks = {
494 EnterCriticalSection(&wpp_mutex);
497 if(flags) FIXME("flags: %x\n", flags);
501 while(def->Name != NULL)
503 wpp_add_define(def->Name, def->Definition);
507 current_include = include;
509 if(shader) *shader = NULL;
510 if(error_messages) *error_messages = NULL;
511 wpp_output_size = wpp_output_capacity = 0;
514 /* Preprocess shader */
515 wpp_set_callbacks(&wpp_callbacks);
516 wpp_messages_size = wpp_messages_capacity = 0;
518 current_shader.buffer = data;
519 current_shader.size = data_len;
521 ret = wpp_parse("", NULL);
522 if(!wpp_close_output())
526 TRACE("Error during shader preprocessing\n");
532 TRACE("Preprocessor messages:\n");
533 TRACE("%s", wpp_messages);
537 size = strlen(wpp_messages) + 1;
538 hr = D3DXCreateBuffer(size, &buffer);
539 if(FAILED(hr)) goto cleanup;
540 CopyMemory(ID3DXBuffer_GetBufferPointer(buffer), wpp_messages, size);
541 *error_messages = buffer;
546 TRACE("Shader source:\n");
547 TRACE("%s\n", debugstr_an(data, data_len));
549 hr = D3DXERR_INVALIDDATA;
553 hr = assemble_shader(wpp_output, wpp_messages, shader, error_messages);
556 /* Remove the previously added defines */
559 while(defines->Name != NULL)
561 wpp_del_define(defines->Name);
565 HeapFree(GetProcessHeap(), 0, wpp_messages);
566 HeapFree(GetProcessHeap(), 0, wpp_output);
567 LeaveCriticalSection(&wpp_mutex);
571 HRESULT WINAPI D3DXAssembleShaderFromFileA(LPCSTR filename,
572 CONST D3DXMACRO* defines,
573 LPD3DXINCLUDE include,
575 LPD3DXBUFFER* shader,
576 LPD3DXBUFFER* error_messages)
578 LPWSTR filename_w = NULL;
582 if (!filename) return D3DXERR_INVALIDDATA;
584 len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
585 filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
586 if (!filename_w) return E_OUTOFMEMORY;
587 MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
589 ret = D3DXAssembleShaderFromFileW(filename_w, defines, include, flags, shader, error_messages);
591 HeapFree(GetProcessHeap(), 0, filename_w);
595 HRESULT WINAPI D3DXAssembleShaderFromFileW(LPCWSTR filename,
596 CONST D3DXMACRO* defines,
597 LPD3DXINCLUDE include,
599 LPD3DXBUFFER* shader,
600 LPD3DXBUFFER* error_messages)
602 FIXME("(%s, %p, %p, %x, %p, %p): stub\n", debugstr_w(filename), defines, include, flags, shader, error_messages);
603 return D3DERR_INVALIDCALL;
606 HRESULT WINAPI D3DXAssembleShaderFromResourceA(HMODULE module,
608 CONST D3DXMACRO* defines,
609 LPD3DXINCLUDE include,
611 LPD3DXBUFFER* shader,
612 LPD3DXBUFFER* error_messages)
618 if (!(res = FindResourceA(module, resource, (LPCSTR)RT_RCDATA)))
619 return D3DXERR_INVALIDDATA;
620 if (FAILED(load_resource_into_memory(module, res, (LPVOID *)&buffer, &len)))
621 return D3DXERR_INVALIDDATA;
622 return D3DXAssembleShader(buffer, len, defines, include, flags,
623 shader, error_messages);
626 HRESULT WINAPI D3DXAssembleShaderFromResourceW(HMODULE module,
628 CONST D3DXMACRO* defines,
629 LPD3DXINCLUDE include,
631 LPD3DXBUFFER* shader,
632 LPD3DXBUFFER* error_messages)
638 if (!(res = FindResourceW(module, resource, (LPCWSTR)RT_RCDATA)))
639 return D3DXERR_INVALIDDATA;
640 if (FAILED(load_resource_into_memory(module, res, (LPVOID *)&buffer, &len)))
641 return D3DXERR_INVALIDDATA;
642 return D3DXAssembleShader(buffer, len, defines, include, flags,
643 shader, error_messages);
646 HRESULT WINAPI D3DXCompileShader(LPCSTR pSrcData,
648 CONST D3DXMACRO* pDefines,
649 LPD3DXINCLUDE pInclude,
650 LPCSTR pFunctionName,
653 LPD3DXBUFFER* ppShader,
654 LPD3DXBUFFER* ppErrorMsgs,
655 LPD3DXCONSTANTTABLE * ppConstantTable)
657 FIXME("(%p, %d, %p, %p, %s, %s, %x, %p, %p, %p): stub\n",
658 pSrcData, srcDataLen, pDefines, pInclude, debugstr_a(pFunctionName),
659 debugstr_a(pProfile), Flags, ppShader, ppErrorMsgs, ppConstantTable);
661 TRACE("Shader source:\n");
662 TRACE("%s\n", debugstr_an(pSrcData, srcDataLen));
664 return D3DERR_INVALIDCALL;
667 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl;
669 typedef struct ID3DXConstantTableImpl {
670 const ID3DXConstantTableVtbl *lpVtbl;
674 D3DXCONSTANTTABLE_DESC desc;
675 } ID3DXConstantTableImpl;
677 /*** IUnknown methods ***/
678 static HRESULT WINAPI ID3DXConstantTableImpl_QueryInterface(ID3DXConstantTable* iface, REFIID riid, void** ppvObject)
680 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
682 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
684 if (IsEqualGUID(riid, &IID_IUnknown) ||
685 IsEqualGUID(riid, &IID_ID3DXBuffer) ||
686 IsEqualGUID(riid, &IID_ID3DXConstantTable))
688 ID3DXConstantTable_AddRef(iface);
693 WARN("Interface %s not found.\n", debugstr_guid(riid));
695 return E_NOINTERFACE;
698 static ULONG WINAPI ID3DXConstantTableImpl_AddRef(ID3DXConstantTable* iface)
700 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
702 TRACE("(%p)->(): AddRef from %d\n", This, This->ref);
704 return InterlockedIncrement(&This->ref);
707 static ULONG WINAPI ID3DXConstantTableImpl_Release(ID3DXConstantTable* iface)
709 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
710 ULONG ref = InterlockedDecrement(&This->ref);
712 TRACE("(%p)->(): Release from %d\n", This, ref + 1);
716 HeapFree(GetProcessHeap(), 0, This->ctab);
717 HeapFree(GetProcessHeap(), 0, This);
723 /*** ID3DXBuffer methods ***/
724 static LPVOID WINAPI ID3DXConstantTableImpl_GetBufferPointer(ID3DXConstantTable* iface)
726 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
728 TRACE("(%p)->()\n", This);
733 static DWORD WINAPI ID3DXConstantTableImpl_GetBufferSize(ID3DXConstantTable* iface)
735 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
737 TRACE("(%p)->()\n", This);
742 /*** ID3DXConstantTable methods ***/
743 static HRESULT WINAPI ID3DXConstantTableImpl_GetDesc(ID3DXConstantTable* iface, D3DXCONSTANTTABLE_DESC *desc)
745 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
747 TRACE("(%p)->(%p)\n", This, desc);
750 return D3DERR_INVALIDCALL;
752 memcpy(desc, &This->desc, sizeof(This->desc));
757 static HRESULT WINAPI ID3DXConstantTableImpl_GetConstantDesc(ID3DXConstantTable* iface, D3DXHANDLE constant,
758 D3DXCONSTANT_DESC *desc, UINT *count)
760 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
762 FIXME("(%p)->(%p, %p, %p): stub\n", This, constant, desc, count);
767 static UINT WINAPI ID3DXConstantTableImpl_GetSamplerIndex(LPD3DXCONSTANTTABLE iface, D3DXHANDLE constant)
769 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
771 FIXME("(%p)->(%p): stub\n", This, constant);
776 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstant(ID3DXConstantTable* iface, D3DXHANDLE constant, UINT index)
778 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
780 FIXME("(%p)->(%p, %d): stub\n", This, constant, index);
785 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantByName(ID3DXConstantTable* iface, D3DXHANDLE constant, LPCSTR name)
787 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
789 FIXME("(%p)->(%p, %s): stub\n", This, constant, name);
794 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantElement(ID3DXConstantTable* iface, D3DXHANDLE constant, UINT index)
796 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
798 FIXME("(%p)->(%p, %d): stub\n", This, constant, index);
803 static HRESULT WINAPI ID3DXConstantTableImpl_SetDefaults(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device)
805 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
807 FIXME("(%p)->(%p): stub\n", This, device);
812 static HRESULT WINAPI ID3DXConstantTableImpl_SetValue(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
813 D3DXHANDLE constant, LPCVOID data, UINT bytes)
815 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
817 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, data, bytes);
822 static HRESULT WINAPI ID3DXConstantTableImpl_SetBool(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
823 D3DXHANDLE constant, BOOL b)
825 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
827 FIXME("(%p)->(%p, %p, %d): stub\n", This, device, constant, b);
832 static HRESULT WINAPI ID3DXConstantTableImpl_SetBoolArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
833 D3DXHANDLE constant, CONST BOOL* b, UINT count)
835 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
837 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, b, count);
842 static HRESULT WINAPI ID3DXConstantTableImpl_SetInt(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device, D3DXHANDLE constant, INT n)
844 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
846 FIXME("(%p)->(%p, %p, %d): stub\n", This, device, constant, n);
851 static HRESULT WINAPI ID3DXConstantTableImpl_SetIntArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
852 D3DXHANDLE constant, CONST INT* n, UINT count)
854 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
856 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, n, count);
861 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloat(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
862 D3DXHANDLE constant, FLOAT f)
864 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
866 FIXME("(%p)->(%p, %p, %f): stub\n", This, device, constant, f);
871 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloatArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
872 D3DXHANDLE constant, CONST FLOAT* f, UINT count)
874 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
876 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, f, count);
881 static HRESULT WINAPI ID3DXConstantTableImpl_SetVector(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
882 D3DXHANDLE constant, CONST D3DXVECTOR4* vector)
884 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
886 FIXME("(%p)->(%p, %p, %p): stub\n", This, device, constant, vector);
891 static HRESULT WINAPI ID3DXConstantTableImpl_SetVectorArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
892 D3DXHANDLE constant, CONST D3DXVECTOR4* vector, UINT count)
894 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
896 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, vector, count);
901 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrix(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
902 D3DXHANDLE constant, CONST D3DXMATRIX* matrix)
904 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
906 FIXME("(%p)->(%p, %p, %p): stub\n", This, device, constant, matrix);
911 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
912 D3DXHANDLE constant, CONST D3DXMATRIX* matrix, UINT count)
914 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
916 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
921 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixPointerArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
922 D3DXHANDLE constant, CONST D3DXMATRIX** matrix, UINT count)
924 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
926 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
931 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTranspose(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
932 D3DXHANDLE constant, CONST D3DXMATRIX* matrix)
934 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
936 FIXME("(%p)->(%p, %p, %p): stub\n", This, device, constant, matrix);
941 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposeArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
942 D3DXHANDLE constant, CONST D3DXMATRIX* matrix, UINT count)
944 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
946 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
951 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposePointerArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
952 D3DXHANDLE constant, CONST D3DXMATRIX** matrix, UINT count)
954 ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
956 FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
961 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl =
963 /*** IUnknown methods ***/
964 ID3DXConstantTableImpl_QueryInterface,
965 ID3DXConstantTableImpl_AddRef,
966 ID3DXConstantTableImpl_Release,
967 /*** ID3DXBuffer methods ***/
968 ID3DXConstantTableImpl_GetBufferPointer,
969 ID3DXConstantTableImpl_GetBufferSize,
970 /*** ID3DXConstantTable methods ***/
971 ID3DXConstantTableImpl_GetDesc,
972 ID3DXConstantTableImpl_GetConstantDesc,
973 ID3DXConstantTableImpl_GetSamplerIndex,
974 ID3DXConstantTableImpl_GetConstant,
975 ID3DXConstantTableImpl_GetConstantByName,
976 ID3DXConstantTableImpl_GetConstantElement,
977 ID3DXConstantTableImpl_SetDefaults,
978 ID3DXConstantTableImpl_SetValue,
979 ID3DXConstantTableImpl_SetBool,
980 ID3DXConstantTableImpl_SetBoolArray,
981 ID3DXConstantTableImpl_SetInt,
982 ID3DXConstantTableImpl_SetIntArray,
983 ID3DXConstantTableImpl_SetFloat,
984 ID3DXConstantTableImpl_SetFloatArray,
985 ID3DXConstantTableImpl_SetVector,
986 ID3DXConstantTableImpl_SetVectorArray,
987 ID3DXConstantTableImpl_SetMatrix,
988 ID3DXConstantTableImpl_SetMatrixArray,
989 ID3DXConstantTableImpl_SetMatrixPointerArray,
990 ID3DXConstantTableImpl_SetMatrixTranspose,
991 ID3DXConstantTableImpl_SetMatrixTransposeArray,
992 ID3DXConstantTableImpl_SetMatrixTransposePointerArray
995 HRESULT WINAPI D3DXGetShaderConstantTableEx(CONST DWORD* byte_code,
997 LPD3DXCONSTANTTABLE* constant_table)
999 ID3DXConstantTableImpl* object = NULL;
1003 const D3DXSHADER_CONSTANTTABLE* ctab_header;
1005 FIXME("(%p, %x, %p): semi-stub\n", byte_code, flags, constant_table);
1007 if (!byte_code || !constant_table)
1008 return D3DERR_INVALIDCALL;
1010 hr = D3DXFindShaderComment(byte_code, MAKEFOURCC('C','T','A','B'), &data, &size);
1012 return D3DXERR_INVALIDDATA;
1014 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ID3DXConstantTableImpl));
1017 ERR("Out of memory\n");
1018 return E_OUTOFMEMORY;
1021 object->lpVtbl = &ID3DXConstantTable_Vtbl;
1024 if (size < sizeof(D3DXSHADER_CONSTANTTABLE))
1027 object->ctab = HeapAlloc(GetProcessHeap(), 0, size);
1030 HeapFree(GetProcessHeap(), 0, object);
1031 ERR("Out of memory\n");
1032 return E_OUTOFMEMORY;
1034 object->size = size;
1035 memcpy(object->ctab, data, object->size);
1037 ctab_header = (const D3DXSHADER_CONSTANTTABLE*)data;
1038 if (ctab_header->Size != sizeof(D3DXSHADER_CONSTANTTABLE))
1040 object->desc.Creator = ctab_header->Creator ? (LPCSTR)object->ctab + ctab_header->Creator : NULL;
1041 object->desc.Version = ctab_header->Version;
1042 object->desc.Constants = ctab_header->Constants;
1044 *constant_table = (LPD3DXCONSTANTTABLE)object;
1050 HeapFree(GetProcessHeap(), 0, object->ctab);
1051 HeapFree(GetProcessHeap(), 0, object);
1053 return D3DXERR_INVALIDDATA;
1056 HRESULT WINAPI D3DXGetShaderConstantTable(CONST DWORD* byte_code,
1057 LPD3DXCONSTANTTABLE* constant_table)
1059 TRACE("(%p, %p): Forwarded to D3DXGetShaderConstantTableEx\n", byte_code, constant_table);
1061 return D3DXGetShaderConstantTableEx(byte_code, 0, constant_table);