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