dlls/d3dx9_36/shader.c

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