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
);