dll/directx/wine/d3dx9_36/shader.c

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