dlls/d3dx9_36/shader.c

   1 /*
   2  * Copyright 2008 Luis Busquets
   3  * Copyright 2009 Matteo Bruni
   4  * Copyright 2011 Travis Athougies
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #define NONAMELESSUNION
  25 #define NONAMELESSSTRUCT
  26 #include "wine/debug.h"
  27 #include "wine/unicode.h"
  28 #include "windef.h"
  29 #include "wingdi.h"
  30 #include "objbase.h"
  31 #include "d3dcommon.h"
  32 #include "d3dcompiler.h"
  33 #include "d3dx9_36_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  36
  37 /* This function is not declared in the SDK headers yet. */
  38 HRESULT WINAPI D3DAssemble(const void *data, SIZE_T datasize, const char *filename,
  39         const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT flags,
  40         ID3DBlob **shader, ID3DBlob **error_messages);
  41
  42 static inline BOOL is_valid_bytecode(DWORD token)
  43 {
  44     return (token & 0xfffe0000) == 0xfffe0000;
  45 }
  46
  47 const char * WINAPI D3DXGetPixelShaderProfile(struct IDirect3DDevice9 *device)
  48 {
  49     D3DCAPS9 caps;
  50
  51     TRACE("device %p\n", device);
  52
  53     if (!device) return NULL;
  54
  55     IDirect3DDevice9_GetDeviceCaps(device,&caps);
  56
  57     switch (caps.PixelShaderVersion)
  58     {
  59     case D3DPS_VERSION(1, 1):
  60         return "ps_1_1";
  61
  62     case D3DPS_VERSION(1, 2):
  63         return "ps_1_2";
  64
  65     case D3DPS_VERSION(1, 3):
  66         return "ps_1_3";
  67
  68     case D3DPS_VERSION(1, 4):
  69         return "ps_1_4";
  70
  71     case D3DPS_VERSION(2, 0):
  72         if ((caps.PS20Caps.NumTemps>=22)                          &&
  73             (caps.PS20Caps.Caps&D3DPS20CAPS_ARBITRARYSWIZZLE)     &&
  74             (caps.PS20Caps.Caps&D3DPS20CAPS_GRADIENTINSTRUCTIONS) &&
  75             (caps.PS20Caps.Caps&D3DPS20CAPS_PREDICATION)          &&
  76             (caps.PS20Caps.Caps&D3DPS20CAPS_NODEPENDENTREADLIMIT) &&
  77             (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
  78         {
  79             return "ps_2_a";
  80         }
  81         if ((caps.PS20Caps.NumTemps>=32)                          &&
  82             (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
  83         {
  84             return "ps_2_b";
  85         }
  86         return "ps_2_0";
  87
  88     case D3DPS_VERSION(3, 0):
  89         return "ps_3_0";
  90     }
  91
  92     return NULL;
  93 }
  94
  95 UINT WINAPI D3DXGetShaderSize(const DWORD *byte_code)
  96 {
  97     const DWORD *ptr = byte_code;
  98
  99     TRACE("byte_code %p\n", byte_code);
 100
 101     if (!ptr) return 0;
 102
 103     /* Look for the END token, skipping the VERSION token */
 104     while (*++ptr != D3DSIO_END)
 105     {
 106         /* Skip comments */
 107         if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
 108         {
 109             ptr += ((*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT);
 110         }
 111     }
 112     ++ptr;
 113
 114     /* Return the shader size in bytes */
 115     return (ptr - byte_code) * sizeof(*ptr);
 116 }
 117
 118 DWORD WINAPI D3DXGetShaderVersion(const DWORD *byte_code)
 119 {
 120     TRACE("byte_code %p\n", byte_code);
 121
 122     return byte_code ? *byte_code : 0;
 123 }
 124
 125 const char * WINAPI D3DXGetVertexShaderProfile(struct IDirect3DDevice9 *device)
 126 {
 127     D3DCAPS9 caps;
 128
 129     TRACE("device %p\n", device);
 130
 131     if (!device) return NULL;
 132
 133     IDirect3DDevice9_GetDeviceCaps(device,&caps);
 134
 135     switch (caps.VertexShaderVersion)
 136     {
 137     case D3DVS_VERSION(1, 1):
 138         return "vs_1_1";
 139     case D3DVS_VERSION(2, 0):
 140         if ((caps.VS20Caps.NumTemps>=13) &&
 141             (caps.VS20Caps.DynamicFlowControlDepth==24) &&
 142             (caps.VS20Caps.Caps&D3DPS20CAPS_PREDICATION))
 143         {
 144             return "vs_2_a";
 145         }
 146         return "vs_2_0";
 147     case D3DVS_VERSION(3, 0):
 148         return "vs_3_0";
 149     }
 150
 151     return NULL;
 152 }
 153
 154 HRESULT WINAPI D3DXFindShaderComment(const DWORD *byte_code, DWORD fourcc, const void **data, UINT *size)
 155 {
 156     const DWORD *ptr = byte_code;
 157     DWORD version;
 158
 159     TRACE("byte_code %p, fourcc %x, data %p, size %p\n", byte_code, fourcc, data, size);
 160
 161     if (data) *data = NULL;
 162     if (size) *size = 0;
 163
 164     if (!byte_code) return D3DERR_INVALIDCALL;
 165
 166     version = *ptr >> 16;
 167     if (version != 0x4658         /* FX */
 168             && version != 0x5458  /* TX */
 169             && version != 0x7ffe
 170             && version != 0x7fff
 171             && version != 0xfffe  /* VS */
 172             && version != 0xffff) /* PS */
 173     {
 174         WARN("Invalid data supplied\n");
 175         return D3DXERR_INVALIDDATA;
 176     }
 177
 178     while (*++ptr != D3DSIO_END)
 179     {
 180         /* Check if it is a comment */
 181         if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
 182         {
 183             DWORD comment_size = (*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
 184
 185             /* Check if this is the comment we are looking for */
 186             if (*(ptr + 1) == fourcc)
 187             {
 188                 UINT ctab_size = (comment_size - 1) * sizeof(DWORD);
 189                 const void *ctab_data = ptr + 2;
 190                 if (size)
 191                     *size = ctab_size;
 192                 if (data)
 193                     *data = ctab_data;
 194                 TRACE("Returning comment data at %p with size %d\n", ctab_data, ctab_size);
 195                 return D3D_OK;
 196             }
 197             ptr += comment_size;
 198         }
 199     }
 200
 201     return S_FALSE;
 202 }
 203
 204 HRESULT WINAPI D3DXAssembleShader(const char *data, UINT data_len, const D3DXMACRO *defines,
 205         ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 206 {
 207     HRESULT hr;
 208
 209     TRACE("data %p, data_len %u, defines %p, include %p, flags %#x, shader %p, error_messages %p\n",
 210           data, data_len, defines, include, flags, shader, error_messages);
 211
 212     /* Forward to d3dcompiler: the parameter types aren't really different,
 213        the actual data types are equivalent */
 214     hr = D3DAssemble(data, data_len, NULL, (D3D_SHADER_MACRO *)defines,
 215                      (ID3DInclude *)include, flags, (ID3DBlob **)shader,
 216                      (ID3DBlob **)error_messages);
 217
 218     if(hr == E_FAIL) hr = D3DXERR_INVALIDDATA;
 219     return hr;
 220 }
 221
 222 static const void *main_file_data;
 223
 224 static CRITICAL_SECTION from_file_mutex;
 225 static CRITICAL_SECTION_DEBUG from_file_mutex_debug =
 226 {
 227     0, 0, &from_file_mutex,
 228     {
 229         &from_file_mutex_debug.ProcessLocksList,
 230         &from_file_mutex_debug.ProcessLocksList
 231     },
 232     0, 0, {(DWORD_PTR)(__FILE__ ": from_file_mutex")}
 233 };
 234 static CRITICAL_SECTION from_file_mutex = {&from_file_mutex_debug, -1, 0, 0, 0, 0};
 235
 236 /* D3DXInclude private implementation, used to implement
 237  * D3DXAssembleShaderFromFile() from D3DXAssembleShader(). */
 238 /* To be able to correctly resolve include search paths we have to store the
 239  * pathname of each include file. We store the pathname pointer right before
 240  * the file data. */
 241 static HRESULT WINAPI d3dincludefromfile_open(ID3DXInclude *iface, D3DXINCLUDE_TYPE include_type,
 242         const char *filename, const void *parent_data, const void **data, UINT *bytes)
 243 {
 244     const char *p, *parent_name = "";
 245     char *pathname = NULL, *ptr;
 246     char **buffer = NULL;
 247     HANDLE file;
 248     UINT size;
 249
 250     if (parent_data)
 251     {
 252         parent_name = *((const char **)parent_data - 1);
 253     }
 254     else
 255     {
 256         if (main_file_data)
 257             parent_name = *((const char **)main_file_data - 1);
 258     }
 259
 260     TRACE("Looking up for include file %s, parent %s\n", debugstr_a(filename), debugstr_a(parent_name));
 261
 262     if ((p = strrchr(parent_name, '\\')))
 263         ++p;
 264     else
 265         p = parent_name;
 266     pathname = HeapAlloc(GetProcessHeap(), 0, (p - parent_name) + strlen(filename) + 1);
 267     if(!pathname)
 268         return HRESULT_FROM_WIN32(GetLastError());
 269
 270     memcpy(pathname, parent_name, p - parent_name);
 271     strcpy(pathname + (p - parent_name), filename);
 272     ptr = pathname + (p - parent_name);
 273     while (*ptr)
 274     {
 275         if (*ptr == '/')
 276             *ptr = '\\';
 277         ++ptr;
 278     }
 279
 280     file = CreateFileA(pathname, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
 281     if(file == INVALID_HANDLE_VALUE)
 282         goto error;
 283
 284     TRACE("Include file found at pathname = %s\n", debugstr_a(pathname));
 285
 286     size = GetFileSize(file, NULL);
 287     if(size == INVALID_FILE_SIZE)
 288         goto error;
 289
 290     buffer = HeapAlloc(GetProcessHeap(), 0, size + sizeof(char *));
 291     if(!buffer)
 292         goto error;
 293     *buffer = pathname;
 294     if(!ReadFile(file, buffer + 1, size, bytes, NULL))
 295         goto error;
 296
 297     *data = buffer + 1;
 298     if (!main_file_data)
 299         main_file_data = *data;
 300
 301     CloseHandle(file);
 302     return S_OK;
 303
 304 error:
 305     CloseHandle(file);
 306     HeapFree(GetProcessHeap(), 0, pathname);
 307     HeapFree(GetProcessHeap(), 0, buffer);
 308     return HRESULT_FROM_WIN32(GetLastError());
 309 }
 310
 311 static HRESULT WINAPI d3dincludefromfile_close(ID3DXInclude *iface, const void *data)
 312 {
 313     HeapFree(GetProcessHeap(), 0, *((char **)data - 1));
 314     HeapFree(GetProcessHeap(), 0, (char **)data - 1);
 315     if (main_file_data == data)
 316         main_file_data = NULL;
 317     return S_OK;
 318 }
 319
 320 static const struct ID3DXIncludeVtbl D3DXInclude_Vtbl = {
 321     d3dincludefromfile_open,
 322     d3dincludefromfile_close
 323 };
 324
 325 struct D3DXIncludeImpl {
 326     ID3DXInclude ID3DXInclude_iface;
 327 };
 328
 329 HRESULT WINAPI D3DXAssembleShaderFromFileA(const char *filename, const D3DXMACRO *defines,
 330         ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 331 {
 332     WCHAR *filename_w;
 333     DWORD len;
 334     HRESULT ret;
 335
 336     TRACE("filename %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
 337             debugstr_a(filename), defines, include, flags, shader, error_messages);
 338
 339     if (!filename) return D3DXERR_INVALIDDATA;
 340
 341     len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
 342     filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 343     if (!filename_w) return E_OUTOFMEMORY;
 344     MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 345
 346     ret = D3DXAssembleShaderFromFileW(filename_w, defines, include, flags, shader, error_messages);
 347
 348     HeapFree(GetProcessHeap(), 0, filename_w);
 349     return ret;
 350 }
 351
 352 HRESULT WINAPI D3DXAssembleShaderFromFileW(const WCHAR *filename, const D3DXMACRO *defines,
 353         ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 354 {
 355     const void *buffer;
 356     DWORD len;
 357     HRESULT hr;
 358     struct D3DXIncludeImpl includefromfile;
 359     char *filename_a;
 360
 361     TRACE("filename %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
 362             debugstr_w(filename), defines, include, flags, shader, error_messages);
 363
 364     if(!include)
 365     {
 366         includefromfile.ID3DXInclude_iface.lpVtbl = &D3DXInclude_Vtbl;
 367         include = &includefromfile.ID3DXInclude_iface;
 368     }
 369
 370     len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
 371     filename_a = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
 372     if (!filename_a)
 373         return E_OUTOFMEMORY;
 374     WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, len, NULL, NULL);
 375
 376     EnterCriticalSection(&from_file_mutex);
 377     hr = ID3DXInclude_Open(include, D3D_INCLUDE_LOCAL, filename_a, NULL, &buffer, &len);
 378     if (FAILED(hr))
 379     {
 380         LeaveCriticalSection(&from_file_mutex);
 381         HeapFree(GetProcessHeap(), 0, filename_a);
 382         return D3DXERR_INVALIDDATA;
 383     }
 384
 385     hr = D3DXAssembleShader(buffer, len, defines, include, flags, shader, error_messages);
 386
 387     ID3DXInclude_Close(include, buffer);
 388     LeaveCriticalSection(&from_file_mutex);
 389     HeapFree(GetProcessHeap(), 0, filename_a);
 390     return hr;
 391 }
 392
 393 HRESULT WINAPI D3DXAssembleShaderFromResourceA(HMODULE module, const char *resource, const D3DXMACRO *defines,
 394         ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 395 {
 396     void *buffer;
 397     HRSRC res;
 398     DWORD len;
 399
 400     TRACE("module %p, resource %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
 401             module, debugstr_a(resource), defines, include, flags, shader, error_messages);
 402
 403     if (!(res = FindResourceA(module, resource, (const char *)RT_RCDATA)))
 404         return D3DXERR_INVALIDDATA;
 405     if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
 406         return D3DXERR_INVALIDDATA;
 407     return D3DXAssembleShader(buffer, len, defines, include, flags,
 408                               shader, error_messages);
 409 }
 410
 411 HRESULT WINAPI D3DXAssembleShaderFromResourceW(HMODULE module, const WCHAR *resource, const D3DXMACRO *defines,
 412         ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 413 {
 414     void *buffer;
 415     HRSRC res;
 416     DWORD len;
 417
 418     TRACE("module %p, resource %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
 419             module, debugstr_w(resource), defines, include, flags, shader, error_messages);
 420
 421     if (!(res = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
 422         return D3DXERR_INVALIDDATA;
 423     if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
 424         return D3DXERR_INVALIDDATA;
 425     return D3DXAssembleShader(buffer, len, defines, include, flags,
 426                               shader, error_messages);
 427 }
 428
 429 HRESULT WINAPI D3DXCompileShader(const char *data, UINT length, const D3DXMACRO *defines,
 430         ID3DXInclude *include, const char *function, const char *profile, DWORD flags,
 431         ID3DXBuffer **shader, ID3DXBuffer **error_msgs, ID3DXConstantTable **constant_table)
 432 {
 433     HRESULT hr;
 434
 435     TRACE("data %s, length %u, defines %p, include %p, function %s, profile %s, "
 436             "flags %#x, shader %p, error_msgs %p, constant_table %p.\n",
 437             debugstr_a(data), length, defines, include, debugstr_a(function), debugstr_a(profile),
 438             flags, shader, error_msgs, constant_table);
 439
 440     hr = D3DCompile(data, length, NULL, (D3D_SHADER_MACRO *)defines, (ID3DInclude *)include,
 441                     function, profile, flags, 0, (ID3DBlob **)shader, (ID3DBlob **)error_msgs);
 442
 443     if (SUCCEEDED(hr) && constant_table)
 444     {
 445         hr = D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*shader), constant_table);
 446         if (FAILED(hr))
 447         {
 448             ID3DXBuffer_Release(*shader);
 449             *shader = NULL;
 450         }
 451     }
 452
 453     return hr;
 454 }
 455
 456 HRESULT WINAPI D3DXCompileShaderFromFileA(const char *filename, const D3DXMACRO *defines,
 457         ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags,
 458         ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
 459 {
 460     WCHAR *filename_w;
 461     DWORD len;
 462     HRESULT ret;
 463
 464     TRACE("filename %s, defines %p, include %p, entrypoint %s, profile %s, "
 465             "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
 466             debugstr_a(filename), defines, include, debugstr_a(entrypoint),
 467             debugstr_a(profile), flags, shader, error_messages, constant_table);
 468
 469     if (!filename) return D3DXERR_INVALIDDATA;
 470
 471     len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
 472     filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 473     if (!filename_w) return E_OUTOFMEMORY;
 474     MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 475
 476     ret = D3DXCompileShaderFromFileW(filename_w, defines, include,
 477                                      entrypoint, profile, flags,
 478                                      shader, error_messages, constant_table);
 479
 480     HeapFree(GetProcessHeap(), 0, filename_w);
 481     return ret;
 482 }
 483
 484 HRESULT WINAPI D3DXCompileShaderFromFileW(const WCHAR *filename, const D3DXMACRO *defines,
 485         ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags,
 486         ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
 487 {
 488     const void *buffer;
 489     DWORD len, filename_len;
 490     HRESULT hr;
 491     struct D3DXIncludeImpl includefromfile;
 492     char *filename_a;
 493
 494     TRACE("filename %s, defines %p, include %p, entrypoint %s, profile %s, "
 495             "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
 496             debugstr_w(filename), defines, include, debugstr_a(entrypoint), debugstr_a(profile),
 497             flags, shader, error_messages, constant_table);
 498
 499     if (!include)
 500     {
 501         includefromfile.ID3DXInclude_iface.lpVtbl = &D3DXInclude_Vtbl;
 502         include = &includefromfile.ID3DXInclude_iface;
 503     }
 504
 505     filename_len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
 506     filename_a = HeapAlloc(GetProcessHeap(), 0, filename_len * sizeof(char));
 507     if (!filename_a)
 508         return E_OUTOFMEMORY;
 509     WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, filename_len, NULL, NULL);
 510
 511     EnterCriticalSection(&from_file_mutex);
 512     hr = ID3DXInclude_Open(include, D3D_INCLUDE_LOCAL, filename_a, NULL, &buffer, &len);
 513     if (FAILED(hr))
 514     {
 515         LeaveCriticalSection(&from_file_mutex);
 516         HeapFree(GetProcessHeap(), 0, filename_a);
 517         return D3DXERR_INVALIDDATA;
 518     }
 519
 520     hr = D3DCompile(buffer, len, filename_a, (const D3D_SHADER_MACRO *)defines,
 521                     (ID3DInclude *)include, entrypoint, profile, flags, 0,
 522                     (ID3DBlob **)shader, (ID3DBlob **)error_messages);
 523
 524     if (SUCCEEDED(hr) && constant_table)
 525         hr = D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*shader),
 526                                         constant_table);
 527
 528     ID3DXInclude_Close(include, buffer);
 529     LeaveCriticalSection(&from_file_mutex);
 530     HeapFree(GetProcessHeap(), 0, filename_a);
 531     return hr;
 532 }
 533
 534 HRESULT WINAPI D3DXCompileShaderFromResourceA(HMODULE module, const char *resource, const D3DXMACRO *defines,
 535         ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags,
 536         ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
 537 {
 538     void *buffer;
 539     HRSRC res;
 540     DWORD len;
 541
 542     TRACE("module %p, resource %s, defines %p, include %p, entrypoint %s, profile %s, "
 543             "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
 544             module, debugstr_a(resource), defines, include, debugstr_a(entrypoint), debugstr_a(profile),
 545             flags, shader, error_messages, constant_table);
 546
 547     if (!(res = FindResourceA(module, resource, (const char *)RT_RCDATA)))
 548         return D3DXERR_INVALIDDATA;
 549     if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
 550         return D3DXERR_INVALIDDATA;
 551     return D3DXCompileShader(buffer, len, defines, include, entrypoint, profile,
 552                              flags, shader, error_messages, constant_table);
 553 }
 554
 555 HRESULT WINAPI D3DXCompileShaderFromResourceW(HMODULE module, const WCHAR *resource, const D3DXMACRO *defines,
 556         ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags,
 557         ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
 558 {
 559     void *buffer;
 560     HRSRC res;
 561     DWORD len;
 562
 563     TRACE("module %p, resource %s, defines %p, include %p, entrypoint %s, profile %s, "
 564             "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
 565             module, debugstr_w(resource), defines, include, debugstr_a(entrypoint), debugstr_a(profile),
 566             flags, shader, error_messages, constant_table);
 567
 568     if (!(res = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
 569         return D3DXERR_INVALIDDATA;
 570     if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
 571         return D3DXERR_INVALIDDATA;
 572     return D3DXCompileShader(buffer, len, defines, include, entrypoint, profile,
 573                              flags, shader, error_messages, constant_table);
 574 }
 575
 576 HRESULT WINAPI D3DXPreprocessShader(const char *data, UINT data_len, const D3DXMACRO *defines,
 577         ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 578 {
 579     TRACE("data %s, data_len %u, defines %p, include %p, shader %p, error_messages %p.\n",
 580             debugstr_a(data), data_len, defines, include, shader, error_messages);
 581
 582     return D3DPreprocess(data, data_len, NULL,
 583                          (const D3D_SHADER_MACRO *)defines, (ID3DInclude *)include,
 584                          (ID3DBlob **)shader, (ID3DBlob **)error_messages);
 585 }
 586
 587 HRESULT WINAPI D3DXPreprocessShaderFromFileA(const char *filename, const D3DXMACRO *defines,
 588         ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 589 {
 590     WCHAR *filename_w = NULL;
 591     DWORD len;
 592     HRESULT ret;
 593
 594     TRACE("filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
 595             debugstr_a(filename), defines, include, shader, error_messages);
 596
 597     if (!filename) return D3DXERR_INVALIDDATA;
 598
 599     len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
 600     filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 601     if (!filename_w) return E_OUTOFMEMORY;
 602     MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 603
 604     ret = D3DXPreprocessShaderFromFileW(filename_w, defines, include, shader, error_messages);
 605
 606     HeapFree(GetProcessHeap(), 0, filename_w);
 607     return ret;
 608 }
 609
 610 HRESULT WINAPI D3DXPreprocessShaderFromFileW(const WCHAR *filename, const D3DXMACRO *defines,
 611         ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 612 {
 613     const void *buffer;
 614     DWORD len;
 615     HRESULT hr;
 616     struct D3DXIncludeImpl includefromfile;
 617     char *filename_a;
 618
 619     TRACE("filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
 620             debugstr_w(filename), defines, include, shader, error_messages);
 621
 622     if (!include)
 623     {
 624         includefromfile.ID3DXInclude_iface.lpVtbl = &D3DXInclude_Vtbl;
 625         include = &includefromfile.ID3DXInclude_iface;
 626     }
 627
 628     len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
 629     filename_a = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
 630     if (!filename_a)
 631         return E_OUTOFMEMORY;
 632     WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, len, NULL, NULL);
 633
 634     EnterCriticalSection(&from_file_mutex);
 635     hr = ID3DXInclude_Open(include, D3D_INCLUDE_LOCAL, filename_a, NULL, &buffer, &len);
 636     if (FAILED(hr))
 637     {
 638         LeaveCriticalSection(&from_file_mutex);
 639         HeapFree(GetProcessHeap(), 0, filename_a);
 640         return D3DXERR_INVALIDDATA;
 641     }
 642
 643     hr = D3DPreprocess(buffer, len, NULL,
 644                        (const D3D_SHADER_MACRO *)defines,
 645                        (ID3DInclude *) include,
 646                        (ID3DBlob **)shader, (ID3DBlob **)error_messages);
 647
 648     ID3DXInclude_Close(include, buffer);
 649     LeaveCriticalSection(&from_file_mutex);
 650     HeapFree(GetProcessHeap(), 0, filename_a);
 651     return hr;
 652 }
 653
 654 HRESULT WINAPI D3DXPreprocessShaderFromResourceA(HMODULE module, const char *resource, const D3DXMACRO *defines,
 655         ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 656 {
 657     void *buffer;
 658     HRSRC res;
 659     DWORD len;
 660
 661     TRACE("module %p, resource %s, defines %p, include %p, shader %p, error_messages %p.\n",
 662             module, debugstr_a(resource), defines, include, shader, error_messages);
 663
 664     if (!(res = FindResourceA(module, resource, (const char *)RT_RCDATA)))
 665         return D3DXERR_INVALIDDATA;
 666     if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
 667         return D3DXERR_INVALIDDATA;
 668     return D3DXPreprocessShader(buffer, len, defines, include,
 669                                 shader, error_messages);
 670 }
 671
 672 HRESULT WINAPI D3DXPreprocessShaderFromResourceW(HMODULE module, const WCHAR *resource, const D3DXMACRO *defines,
 673         ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
 674 {
 675     void *buffer;
 676     HRSRC res;
 677     DWORD len;
 678
 679     TRACE("module %p, resource %s, defines %p, include %p, shader %p, error_messages %p.\n",
 680             module, debugstr_w(resource), defines, include, shader, error_messages);
 681
 682     if (!(res = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
 683         return D3DXERR_INVALIDDATA;
 684     if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
 685         return D3DXERR_INVALIDDATA;
 686     return D3DXPreprocessShader(buffer, len, defines, include,
 687                                 shader, error_messages);
 688
 689 }
 690
 691 struct ctab_constant {
 692     D3DXCONSTANT_DESC desc;
 693     struct ctab_constant *constants;
 694 };
 695
 696 struct ID3DXConstantTableImpl {
 697     ID3DXConstantTable ID3DXConstantTable_iface;
 698     LONG ref;
 699     char *ctab;
 700     DWORD size;
 701     D3DXCONSTANTTABLE_DESC desc;
 702     struct ctab_constant *constants;
 703 };
 704
 705 static void free_constant(struct ctab_constant *constant)
 706 {
 707     if (constant->constants)
 708     {
 709         UINT i, count = constant->desc.Elements > 1 ? constant->desc.Elements : constant->desc.StructMembers;
 710
 711         for (i = 0; i < count; ++i)
 712         {
 713             free_constant(&constant->constants[i]);
 714         }
 715         HeapFree(GetProcessHeap(), 0, constant->constants);
 716     }
 717 }
 718
 719 static void free_constant_table(struct ID3DXConstantTableImpl *table)
 720 {
 721     if (table->constants)
 722     {
 723         UINT i;
 724
 725         for (i = 0; i < table->desc.Constants; ++i)
 726         {
 727             free_constant(&table->constants[i]);
 728         }
 729         HeapFree(GetProcessHeap(), 0, table->constants);
 730     }
 731     HeapFree(GetProcessHeap(), 0, table->ctab);
 732 }
 733
 734 static inline struct ID3DXConstantTableImpl *impl_from_ID3DXConstantTable(ID3DXConstantTable *iface)
 735 {
 736     return CONTAINING_RECORD(iface, struct ID3DXConstantTableImpl, ID3DXConstantTable_iface);
 737 }
 738
 739 static inline BOOL is_vertex_shader(DWORD version)
 740 {
 741     return (version & 0xffff0000) == 0xfffe0000;
 742 }
 743
 744 static inline D3DXHANDLE handle_from_constant(struct ctab_constant *constant)
 745 {
 746     return (D3DXHANDLE)constant;
 747 }
 748
 749 static struct ctab_constant *get_constant_by_name(struct ID3DXConstantTableImpl *table,
 750         struct ctab_constant *constant, const char *name);
 751
 752 static struct ctab_constant *get_constant_element_by_name(struct ctab_constant *constant, const char *name)
 753 {
 754     const char *part;
 755     UINT element;
 756
 757     TRACE("constant %p, name %s\n", constant, debugstr_a(name));
 758
 759     if (!name || !*name) return NULL;
 760
 761     element = atoi(name);
 762     part = strchr(name, ']') + 1;
 763
 764     if (constant->desc.Elements > element)
 765     {
 766         struct ctab_constant *c = constant->constants ? &constant->constants[element] : constant;
 767
 768         switch (*part++)
 769         {
 770             case '.':
 771                 return get_constant_by_name(NULL, c, part);
 772
 773             case '[':
 774                 return get_constant_element_by_name(c, part);
 775
 776             case '\0':
 777                 TRACE("Returning parameter %p\n", c);
 778                 return c;
 779
 780             default:
 781                 FIXME("Unhandled case \"%c\"\n", *--part);
 782                 break;
 783         }
 784     }
 785
 786     TRACE("Constant not found\n");
 787     return NULL;
 788 }
 789
 790 static struct ctab_constant *get_constant_by_name(struct ID3DXConstantTableImpl *table,
 791         struct ctab_constant *constant, const char *name)
 792 {
 793     UINT i, count, length;
 794     struct ctab_constant *handles;
 795     const char *part;
 796
 797     TRACE("table %p, constant %p, name %s\n", table, constant, debugstr_a(name));
 798
 799     if (!name || !*name) return NULL;
 800
 801     if (!constant)
 802     {
 803         count = table->desc.Constants;
 804         handles = table->constants;
 805     }
 806     else
 807     {
 808         count = constant->desc.StructMembers;
 809         handles = constant->constants;
 810     }
 811
 812     length = strcspn(name, "[.");
 813     part = name + length;
 814
 815     for (i = 0; i < count; i++)
 816     {
 817         if (strlen(handles[i].desc.Name) == length && !strncmp(handles[i].desc.Name, name, length))
 818         {
 819             switch (*part++)
 820             {
 821                 case '.':
 822                     return get_constant_by_name(NULL, &handles[i], part);
 823
 824                 case '[':
 825                     return get_constant_element_by_name(&handles[i], part);
 826
 827                 default:
 828                     TRACE("Returning parameter %p\n", &handles[i]);
 829                     return &handles[i];
 830             }
 831         }
 832     }
 833
 834     TRACE("Constant not found\n");
 835     return NULL;
 836 }
 837
 838 static struct ctab_constant *is_valid_sub_constant(struct ctab_constant *parent, D3DXHANDLE handle)
 839 {
 840     struct ctab_constant *c;
 841     UINT i, count;
 842
 843     /* all variable have at least elements = 1, but not always elements */
 844     if (!parent->constants) return NULL;
 845
 846     count = parent->desc.Elements > 1 ? parent->desc.Elements : parent->desc.StructMembers;
 847     for (i = 0; i < count; ++i)
 848     {
 849         if (handle_from_constant(&parent->constants[i]) == handle)
 850             return &parent->constants[i];
 851
 852         c = is_valid_sub_constant(&parent->constants[i], handle);
 853         if (c) return c;
 854     }
 855
 856     return NULL;
 857 }
 858
 859 static inline struct ctab_constant *get_valid_constant(struct ID3DXConstantTableImpl *table, D3DXHANDLE handle)
 860 {
 861     struct ctab_constant *c;
 862     UINT i;
 863
 864     if (!handle) return NULL;
 865
 866     for (i = 0; i < table->desc.Constants; ++i)
 867     {
 868         if (handle_from_constant(&table->constants[i]) == handle)
 869             return &table->constants[i];
 870
 871         c = is_valid_sub_constant(&table->constants[i], handle);
 872         if (c) return c;
 873     }
 874
 875     return get_constant_by_name(table, NULL, handle);
 876 }
 877
 878 /*** IUnknown methods ***/
 879 static HRESULT WINAPI ID3DXConstantTableImpl_QueryInterface(ID3DXConstantTable *iface, REFIID riid, void **out)
 880 {
 881     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 882
 883     if (IsEqualGUID(riid, &IID_IUnknown) ||
 884         IsEqualGUID(riid, &IID_ID3DXBuffer) ||
 885         IsEqualGUID(riid, &IID_ID3DXConstantTable))
 886     {
 887         ID3DXConstantTable_AddRef(iface);
 888         *out = iface;
 889         return S_OK;
 890     }
 891
 892     WARN("Interface %s not found.\n", debugstr_guid(riid));
 893
 894     return E_NOINTERFACE;
 895 }
 896
 897 static ULONG WINAPI ID3DXConstantTableImpl_AddRef(ID3DXConstantTable *iface)
 898 {
 899     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
 900
 901     TRACE("(%p)->(): AddRef from %d\n", This, This->ref);
 902
 903     return InterlockedIncrement(&This->ref);
 904 }
 905
 906 static ULONG WINAPI ID3DXConstantTableImpl_Release(ID3DXConstantTable *iface)
 907 {
 908     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
 909     ULONG ref = InterlockedDecrement(&This->ref);
 910
 911     TRACE("(%p)->(): Release from %d\n", This, ref + 1);
 912
 913     if (!ref)
 914     {
 915         free_constant_table(This);
 916         HeapFree(GetProcessHeap(), 0, This);
 917     }
 918
 919     return ref;
 920 }
 921
 922 /*** ID3DXBuffer methods ***/
 923 static void * WINAPI ID3DXConstantTableImpl_GetBufferPointer(ID3DXConstantTable *iface)
 924 {
 925     struct ID3DXConstantTableImpl *table = impl_from_ID3DXConstantTable(iface);
 926
 927     TRACE("iface %p.\n", iface);
 928
 929     return table->ctab;
 930 }
 931
 932 static DWORD WINAPI ID3DXConstantTableImpl_GetBufferSize(ID3DXConstantTable *iface)
 933 {
 934     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
 935
 936     TRACE("(%p)->()\n", This);
 937
 938     return This->size;
 939 }
 940
 941 /*** ID3DXConstantTable methods ***/
 942 static HRESULT WINAPI ID3DXConstantTableImpl_GetDesc(ID3DXConstantTable *iface, D3DXCONSTANTTABLE_DESC *desc)
 943 {
 944     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
 945
 946     TRACE("(%p)->(%p)\n", This, desc);
 947
 948     if (!desc)
 949         return D3DERR_INVALIDCALL;
 950
 951     *desc = This->desc;
 952
 953     return D3D_OK;
 954 }
 955
 956 static HRESULT WINAPI ID3DXConstantTableImpl_GetConstantDesc(ID3DXConstantTable *iface, D3DXHANDLE constant,
 957                                                              D3DXCONSTANT_DESC *desc, UINT *count)
 958 {
 959     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
 960     struct ctab_constant *c = get_valid_constant(This, constant);
 961
 962     TRACE("(%p)->(%p, %p, %p)\n", This, constant, desc, count);
 963
 964     if (!c)
 965     {
 966         WARN("Invalid argument specified\n");
 967         return D3DERR_INVALIDCALL;
 968     }
 969
 970     if (desc) *desc = c->desc;
 971     if (count) *count = 1;
 972
 973     return D3D_OK;
 974 }
 975
 976 static UINT WINAPI ID3DXConstantTableImpl_GetSamplerIndex(ID3DXConstantTable *iface, D3DXHANDLE constant)
 977 {
 978     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
 979     struct ctab_constant *c = get_valid_constant(This, constant);
 980
 981     TRACE("(%p)->(%p)\n", This, constant);
 982
 983     if (!c || c->desc.RegisterSet != D3DXRS_SAMPLER)
 984     {
 985         WARN("Invalid argument specified\n");
 986         return (UINT)-1;
 987     }
 988
 989     TRACE("Returning RegisterIndex %u\n", c->desc.RegisterIndex);
 990     return c->desc.RegisterIndex;
 991 }
 992
 993 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstant(ID3DXConstantTable *iface, D3DXHANDLE constant, UINT index)
 994 {
 995     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
 996     struct ctab_constant *c;
 997
 998     TRACE("(%p)->(%p, %d)\n", This, constant, index);
 999
1000     if (constant)
1001     {
1002         c = get_valid_constant(This, constant);
1003         if (c && index < c->desc.StructMembers)
1004         {
1005             c = &c->constants[index];
1006             TRACE("Returning constant %p\n", c);
1007             return handle_from_constant(c);
1008         }
1009     }
1010     else
1011     {
1012         if (index < This->desc.Constants)
1013         {
1014             c = &This->constants[index];
1015             TRACE("Returning constant %p\n", c);
1016             return handle_from_constant(c);
1017         }
1018     }
1019
1020     WARN("Index out of range\n");
1021     return NULL;
1022 }
1023
1024 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantByName(ID3DXConstantTable *iface,
1025         D3DXHANDLE constant, const char *name)
1026 {
1027     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1028     struct ctab_constant *c = get_valid_constant(This, constant);
1029
1030     TRACE("iface %p, constant %p, name %s.\n", iface, constant, debugstr_a(name));
1031
1032     c = get_constant_by_name(This, c, name);
1033     TRACE("Returning constant %p\n", c);
1034
1035     return handle_from_constant(c);
1036 }
1037
1038 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantElement(ID3DXConstantTable *iface, D3DXHANDLE constant, UINT index)
1039 {
1040     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1041     struct ctab_constant *c = get_valid_constant(This, constant);
1042
1043     TRACE("(%p)->(%p, %d)\n", This, constant, index);
1044
1045     if (c && index < c->desc.Elements)
1046     {
1047         if (c->desc.Elements > 1) c = &c->constants[index];
1048         TRACE("Returning constant %p\n", c);
1049         return handle_from_constant(c);
1050     }
1051
1052     WARN("Invalid argument specified\n");
1053     return NULL;
1054 }
1055
1056 static inline DWORD get_index(const void **indata, UINT index, BOOL is_pointer)
1057 {
1058     if (!indata)
1059         return 0;
1060
1061     if (is_pointer)
1062         return ((DWORD **)indata)[index / 16][index % 16];
1063
1064     return (*((DWORD **)indata))[index];
1065 }
1066
1067 static UINT set(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, struct ctab_constant *constant,
1068         const void **indata, D3DXPARAMETER_TYPE intype, UINT *size, UINT incol, D3DXPARAMETER_CLASS inclass, UINT index,
1069         BOOL is_pointer)
1070 {
1071     D3DXCONSTANT_DESC *desc = &constant->desc;
1072     UINT l, i, regcount = 1, regsize = 1, cin = 1, rin = 1, ret, last = 0;
1073     DWORD tmp;
1074
1075     /* size too small to set anything */
1076     if (*size < desc->Rows * desc->Columns)
1077     {
1078         *size = 0;
1079         return 0;
1080     }
1081
1082     /* D3DXPC_STRUCT is somewhat special */
1083     if (desc->Class == D3DXPC_STRUCT)
1084     {
1085         /*
1086          * Struct array sets the last complete input to the first struct element, all other
1087          * elements are not set.
1088          * E.g.: struct {int i;} s1[2];
1089          *       SetValue(device, "s1", [1, 2], 8) => s1 = {2, x};
1090          *
1091          *       struct {int i; int n} s2[2];
1092          *       SetValue(device, "s2", [1, 2, 3, 4, 5], 20) => s1 = {{3, 4}, {x, x}};
1093          */
1094         if (desc->Elements > 1)
1095         {
1096             UINT offset = *size / (desc->Rows * desc->Columns) - 1;
1097
1098             offset = min(desc->Elements - 1, offset);
1099             last = offset * desc->Rows * desc->Columns;
1100
1101             if ((is_pointer || (!is_pointer && inclass == D3DXPC_MATRIX_ROWS)) && desc->RegisterSet != D3DXRS_BOOL)
1102             {
1103                 set(table, device, &constant->constants[0], NULL, intype, size, incol, inclass, 0, is_pointer);
1104             }
1105             else
1106             {
1107                 last += set(table, device, &constant->constants[0], indata, intype, size, incol, inclass,
1108                         index + last, is_pointer);
1109             }
1110         }
1111         else
1112         {
1113             /*
1114              * D3DXRS_BOOL is always set. As there are only 16 bools and there are
1115              * exactly 16 input values, use matrix transpose.
1116              */
1117             if (inclass == D3DXPC_MATRIX_ROWS && desc->RegisterSet == D3DXRS_BOOL)
1118             {
1119                 D3DXMATRIX mat, *m, min;
1120                 D3DXMatrixTranspose(&mat, &min);
1121
1122                 if (is_pointer)
1123                     min = *(D3DXMATRIX *)(indata[index / 16]);
1124                 else
1125                     min = **(D3DXMATRIX **)indata;
1126
1127                 D3DXMatrixTranspose(&mat, &min);
1128                 m = &mat;
1129                 for (i = 0; i < desc->StructMembers; ++i)
1130                 {
1131                     last += set(table, device, &constant->constants[i], (const void **)&m, intype, size, incol,
1132                             D3DXPC_SCALAR, index + last, is_pointer);
1133                 }
1134             }
1135             /*
1136              * For pointers or for matrix rows, only the first member is set.
1137              * All other members are set to 0. This is not true for D3DXRS_BOOL.
1138              * E.g.: struct {int i; int n} s;
1139              *       SetValue(device, "s", [1, 2], 8) => s = {1, 0};
1140              */
1141             else if ((is_pointer || (!is_pointer && inclass == D3DXPC_MATRIX_ROWS)) && desc->RegisterSet != D3DXRS_BOOL)
1142             {
1143                 last = set(table, device, &constant->constants[0], indata, intype, size, incol, inclass,
1144                         index + last, is_pointer);
1145
1146                 for (i = 1; i < desc->StructMembers; ++i)
1147                 {
1148                     set(table, device, &constant->constants[i], NULL, intype, size, incol, inclass, 0, is_pointer);
1149                 }
1150             }
1151             else
1152             {
1153                 for (i = 0; i < desc->StructMembers; ++i)
1154                 {
1155                     last += set(table, device, &constant->constants[i], indata, intype, size, incol, D3DXPC_SCALAR,
1156                             index + last, is_pointer);
1157                 }
1158             }
1159         }
1160
1161         return last;
1162     }
1163
1164     /* elements */
1165     if (desc->Elements > 1)
1166     {
1167         for (i = 0; i < desc->Elements && *size > 0; ++i)
1168         {
1169             last += set(table, device, &constant->constants[i], indata, intype, size, incol, inclass,
1170                     index + last, is_pointer);
1171
1172             /* adjust the vector size for matrix rows */
1173             if (inclass == D3DXPC_MATRIX_ROWS && desc->Class == D3DXPC_VECTOR && (i % 4) == 3)
1174             {
1175                 last += 12;
1176                 *size = *size < 12 ? 0 : *size - 12;
1177             }
1178         }
1179
1180         return last;
1181     }
1182
1183     switch (desc->Class)
1184     {
1185         case D3DXPC_SCALAR:
1186         case D3DXPC_VECTOR:
1187         case D3DXPC_MATRIX_ROWS:
1188             regcount = min(desc->RegisterCount, desc->Rows);
1189             if (inclass == D3DXPC_MATRIX_ROWS) cin = incol;
1190             else rin = incol;
1191             regsize = desc->Columns;
1192             break;
1193
1194         case D3DXPC_MATRIX_COLUMNS:
1195             regcount = min(desc->RegisterCount, desc->Columns);
1196             if (inclass == D3DXPC_MATRIX_ROWS) rin = incol;
1197             else cin = incol;
1198             regsize = desc->Rows;
1199             break;
1200
1201         default:
1202             FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc->Class));
1203             return 0;
1204     }
1205
1206     /* specific stuff for different in types */
1207     switch (inclass)
1208     {
1209         case D3DXPC_SCALAR:
1210             ret = desc->Columns * desc->Rows;
1211             *size -= desc->Columns * desc->Rows;
1212             break;
1213
1214         case D3DXPC_VECTOR:
1215             switch (desc->Class)
1216             {
1217                 case D3DXPC_MATRIX_ROWS:
1218                     if (*size < regcount * 4)
1219                     {
1220                         *size = 0;
1221                         return 0;
1222                     }
1223                     ret = 4 * regcount;
1224                     *size -= 4 * regcount;
1225                     break;
1226
1227                 case D3DXPC_MATRIX_COLUMNS:
1228                     ret = 4 * regsize;
1229                     *size -= 4 * regcount;
1230                     break;
1231
1232                 case D3DXPC_SCALAR:
1233                     ret = 1;
1234                     *size -= ret;
1235                     break;
1236
1237                 case D3DXPC_VECTOR:
1238                     ret = 4;
1239                     *size -= ret;
1240                     break;
1241
1242                 default:
1243                     FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc->Class));
1244                     return 0;
1245             }
1246             break;
1247
1248         case D3DXPC_MATRIX_ROWS:
1249             switch (desc->Class)
1250             {
1251                 case D3DXPC_MATRIX_ROWS:
1252                 case D3DXPC_MATRIX_COLUMNS:
1253                     if (*size < 16)
1254                     {
1255                         *size = 0;
1256                         return 0;
1257                     }
1258                     ret = 16;
1259                     break;
1260
1261                 case D3DXPC_SCALAR:
1262                     ret = 4;
1263                     break;
1264
1265                 case D3DXPC_VECTOR:
1266                     ret = 1;
1267                     break;
1268
1269                 default:
1270                     FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(desc->Class));
1271                     return 0;
1272             }
1273             *size -= ret;
1274             break;
1275
1276         case D3DXPC_MATRIX_COLUMNS:
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 = 1;
1291                     break;
1292
1293                 case D3DXPC_VECTOR:
1294                     ret = 4;
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         default:
1305             FIXME("Unhandled variable class %s\n", debug_d3dxparameter_class(inclass));
1306             return 0;
1307     }
1308
1309     /* set the registers */
1310     switch (desc->RegisterSet)
1311     {
1312         case D3DXRS_BOOL:
1313             regcount = min(desc->RegisterCount, desc->Columns * desc->Rows);
1314             l = 0;
1315             for (i = 0; i < regcount; ++i)
1316             {
1317                 BOOL out;
1318                 DWORD t = get_index(indata, index + i / regsize * rin + l * cin, is_pointer);
1319
1320                 set_number(&tmp, desc->Type, &t, intype);
1321                 set_number(&out, D3DXPT_BOOL, &tmp, desc->Type);
1322                 if (is_vertex_shader(table->desc.Version))
1323                     IDirect3DDevice9_SetVertexShaderConstantB(device, desc->RegisterIndex + i, &out, 1);
1324                 else
1325                     IDirect3DDevice9_SetPixelShaderConstantB(device, desc->RegisterIndex + i, &out, 1);
1326
1327                 if (++l >= regsize) l = 0;
1328             }
1329             return ret;
1330
1331         case D3DXRS_INT4:
1332             for (i = 0; i < regcount; ++i)
1333             {
1334                 INT vec[4] = {0, 0, 1, 0};
1335
1336                 for (l = 0; l < regsize; ++l)
1337                 {
1338                     DWORD t = get_index(indata, index + i * rin + l * cin, is_pointer);
1339
1340                     set_number(&tmp, desc->Type, &t, intype);
1341                     set_number(&vec[l], D3DXPT_INT, &tmp, desc->Type);
1342                 }
1343                 if (is_vertex_shader(table->desc.Version))
1344                     IDirect3DDevice9_SetVertexShaderConstantI(device, desc->RegisterIndex + i, vec, 1);
1345                 else
1346                     IDirect3DDevice9_SetPixelShaderConstantI(device, desc->RegisterIndex + i, vec, 1);
1347             }
1348             return ret;
1349
1350         case D3DXRS_FLOAT4:
1351             for (i = 0; i < regcount; ++i)
1352             {
1353                 FLOAT vec[4] = {0};
1354
1355                 for (l = 0; l < regsize; ++l)
1356                 {
1357                     DWORD t = get_index(indata, index + i * rin + l * cin, is_pointer);
1358
1359                     set_number(&tmp, desc->Type, &t, intype);
1360                     set_number(&vec[l], D3DXPT_FLOAT, &tmp, desc->Type);
1361                 }
1362                 if (is_vertex_shader(table->desc.Version))
1363                     IDirect3DDevice9_SetVertexShaderConstantF(device, desc->RegisterIndex + i, vec, 1);
1364                 else
1365                     IDirect3DDevice9_SetPixelShaderConstantF(device, desc->RegisterIndex + i, vec, 1);
1366             }
1367             return ret;
1368
1369         default:
1370             FIXME("Unhandled register set %s\n", debug_d3dxparameter_registerset(desc->RegisterSet));
1371             return 0;
1372     }
1373 }
1374
1375 static HRESULT set_scalar(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1376         const void *indata, D3DXPARAMETER_TYPE intype)
1377 {
1378     struct ctab_constant *c = get_valid_constant(table, constant);
1379     UINT count = 1;
1380
1381     if (!c)
1382     {
1383         WARN("Invalid argument specified\n");
1384         return D3DERR_INVALIDCALL;
1385     }
1386
1387     switch (c->desc.Class)
1388     {
1389         case D3DXPC_SCALAR:
1390             set(table, device, c, &indata, intype, &count, c->desc.Columns, D3DXPC_SCALAR, 0, FALSE);
1391             return D3D_OK;
1392
1393         case D3DXPC_VECTOR:
1394         case D3DXPC_MATRIX_ROWS:
1395         case D3DXPC_MATRIX_COLUMNS:
1396         case D3DXPC_STRUCT:
1397             return D3D_OK;
1398
1399         default:
1400             FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1401             return D3DERR_INVALIDCALL;
1402     }
1403 }
1404
1405 static HRESULT set_scalar_array(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1406         const void *indata, UINT count, D3DXPARAMETER_TYPE intype)
1407 {
1408     struct ctab_constant *c = get_valid_constant(table, constant);
1409
1410     if (!c)
1411     {
1412         WARN("Invalid argument specified\n");
1413         return D3DERR_INVALIDCALL;
1414     }
1415
1416     switch (c->desc.Class)
1417     {
1418         case D3DXPC_SCALAR:
1419         case D3DXPC_VECTOR:
1420         case D3DXPC_MATRIX_ROWS:
1421         case D3DXPC_MATRIX_COLUMNS:
1422         case D3DXPC_STRUCT:
1423             set(table, device, c, &indata, intype, &count, c->desc.Columns, D3DXPC_SCALAR, 0, FALSE);
1424             return D3D_OK;
1425
1426         default:
1427             FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1428             return D3DERR_INVALIDCALL;
1429     }
1430 }
1431
1432 static HRESULT set_vector(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1433         const void *indata, D3DXPARAMETER_TYPE intype)
1434 {
1435     struct ctab_constant *c = get_valid_constant(table, constant);
1436     UINT count = 4;
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_STRUCT:
1449             set(table, device, c, &indata, intype, &count, 4, D3DXPC_VECTOR, 0, FALSE);
1450             return D3D_OK;
1451
1452         case D3DXPC_MATRIX_ROWS:
1453         case D3DXPC_MATRIX_COLUMNS:
1454             return D3D_OK;
1455
1456         default:
1457             FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1458             return D3DERR_INVALIDCALL;
1459     }
1460 }
1461
1462 static HRESULT set_vector_array(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1463         const void *indata, UINT count, D3DXPARAMETER_TYPE intype)
1464 {
1465     struct ctab_constant *c = get_valid_constant(table, constant);
1466
1467     if (!c)
1468     {
1469         WARN("Invalid argument specified\n");
1470         return D3DERR_INVALIDCALL;
1471     }
1472
1473     switch (c->desc.Class)
1474     {
1475         case D3DXPC_SCALAR:
1476         case D3DXPC_VECTOR:
1477         case D3DXPC_MATRIX_ROWS:
1478         case D3DXPC_MATRIX_COLUMNS:
1479         case D3DXPC_STRUCT:
1480             count *= 4;
1481             set(table, device, c, &indata, intype, &count, 4, D3DXPC_VECTOR, 0, FALSE);
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_matrix_array(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, D3DXHANDLE constant,
1491         const void *indata, UINT count, BOOL transpose)
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 *= 16;
1509             set(table, device, c, &indata, D3DXPT_FLOAT, &count, 4,
1510                     transpose ? D3DXPC_MATRIX_ROWS : D3DXPC_MATRIX_COLUMNS, 0, FALSE);
1511             return D3D_OK;
1512
1513         default:
1514             FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1515             return D3DERR_INVALIDCALL;
1516     }
1517 }
1518
1519 static HRESULT set_matrix_pointer_array(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device,
1520         D3DXHANDLE constant, const void **indata, UINT count, BOOL transpose)
1521 {
1522     struct ctab_constant *c = get_valid_constant(table, constant);
1523
1524     if (!c)
1525     {
1526         WARN("Invalid argument specified\n");
1527         return D3DERR_INVALIDCALL;
1528     }
1529
1530     switch (c->desc.Class)
1531     {
1532         case D3DXPC_SCALAR:
1533         case D3DXPC_VECTOR:
1534         case D3DXPC_MATRIX_ROWS:
1535         case D3DXPC_MATRIX_COLUMNS:
1536         case D3DXPC_STRUCT:
1537             count *= 16;
1538             set(table, device, c, indata, D3DXPT_FLOAT, &count, 4,
1539                     transpose ? D3DXPC_MATRIX_ROWS : D3DXPC_MATRIX_COLUMNS, 0, TRUE);
1540             return D3D_OK;
1541
1542         default:
1543             FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(c->desc.Class));
1544             return D3DERR_INVALIDCALL;
1545     }
1546 }
1547
1548 static HRESULT WINAPI ID3DXConstantTableImpl_SetDefaults(struct ID3DXConstantTable *iface,
1549         struct IDirect3DDevice9 *device)
1550 {
1551     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1552     UINT i;
1553
1554     TRACE("iface %p, device %p\n", iface, device);
1555
1556     if (!device)
1557     {
1558         WARN("Invalid argument specified\n");
1559         return D3DERR_INVALIDCALL;
1560     }
1561
1562     for (i = 0; i < This->desc.Constants; i++)
1563     {
1564         D3DXCONSTANT_DESC *desc = &This->constants[i].desc;
1565         HRESULT hr;
1566
1567         if (!desc->DefaultValue)
1568             continue;
1569
1570         switch (desc->RegisterSet)
1571         {
1572             case D3DXRS_BOOL:
1573                 if (is_vertex_shader(This->desc.Version))
1574                     hr = IDirect3DDevice9_SetVertexShaderConstantB(device, desc->RegisterIndex, desc->DefaultValue,
1575                             desc->RegisterCount);
1576                 else
1577                     hr = IDirect3DDevice9_SetPixelShaderConstantB(device, desc->RegisterIndex, desc->DefaultValue,
1578                             desc->RegisterCount);
1579                 break;
1580
1581             case D3DXRS_INT4:
1582                 if (is_vertex_shader(This->desc.Version))
1583                     hr = IDirect3DDevice9_SetVertexShaderConstantI(device, desc->RegisterIndex, desc->DefaultValue,
1584                             desc->RegisterCount);
1585                 else
1586                     hr = IDirect3DDevice9_SetPixelShaderConstantI(device, desc->RegisterIndex, desc->DefaultValue,
1587                         desc->RegisterCount);
1588                 break;
1589
1590             case D3DXRS_FLOAT4:
1591                 if (is_vertex_shader(This->desc.Version))
1592                     hr = IDirect3DDevice9_SetVertexShaderConstantF(device, desc->RegisterIndex, desc->DefaultValue,
1593                             desc->RegisterCount);
1594                 else
1595                     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, desc->RegisterIndex, desc->DefaultValue,
1596                         desc->RegisterCount);
1597                 break;
1598
1599             default:
1600                 FIXME("Unhandled register set %s\n", debug_d3dxparameter_registerset(desc->RegisterSet));
1601                 hr = E_NOTIMPL;
1602                 break;
1603         }
1604
1605         if (hr != D3D_OK)
1606             return hr;
1607     }
1608
1609     return D3D_OK;
1610 }
1611
1612 static HRESULT WINAPI ID3DXConstantTableImpl_SetValue(struct ID3DXConstantTable *iface,
1613         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const void *data, unsigned int bytes)
1614 {
1615     struct ID3DXConstantTableImpl *table = impl_from_ID3DXConstantTable(iface);
1616     struct ctab_constant *c = get_valid_constant(table, constant);
1617     D3DXCONSTANT_DESC *desc;
1618
1619     TRACE("iface %p, device %p, constant %p, data %p, bytes %u\n", iface, device, constant, data, bytes);
1620
1621     if (!device || !c || !data)
1622     {
1623         WARN("Invalid argument specified\n");
1624         return D3DERR_INVALIDCALL;
1625     }
1626
1627     desc = &c->desc;
1628
1629     switch (desc->Class)
1630     {
1631         case D3DXPC_SCALAR:
1632         case D3DXPC_VECTOR:
1633         case D3DXPC_MATRIX_ROWS:
1634         case D3DXPC_MATRIX_COLUMNS:
1635         case D3DXPC_STRUCT:
1636             bytes /= 4;
1637             set(table, device, c, &data, desc->Type, &bytes, desc->Columns, D3DXPC_SCALAR, 0, FALSE);
1638             return D3D_OK;
1639
1640         default:
1641             FIXME("Unhandled parameter class %s\n", debug_d3dxparameter_class(desc->Class));
1642             return D3DERR_INVALIDCALL;
1643     }
1644 }
1645
1646 static HRESULT WINAPI ID3DXConstantTableImpl_SetBool(struct ID3DXConstantTable *iface,
1647         struct IDirect3DDevice9 *device, D3DXHANDLE constant, BOOL b)
1648 {
1649     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1650
1651     TRACE("iface %p, device %p, constant %p, b %d\n", iface, device, constant, b);
1652
1653     return set_scalar(This, device, constant, &b, D3DXPT_BOOL);
1654 }
1655
1656 static HRESULT WINAPI ID3DXConstantTableImpl_SetBoolArray(struct ID3DXConstantTable *iface,
1657         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const BOOL *b, UINT count)
1658 {
1659     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1660
1661     TRACE("iface %p, device %p, constant %p, b %p, count %d\n", iface, device, constant, b, count);
1662
1663     return set_scalar_array(This, device, constant, b, count, D3DXPT_BOOL);
1664 }
1665
1666 static HRESULT WINAPI ID3DXConstantTableImpl_SetInt(struct ID3DXConstantTable *iface,
1667         struct IDirect3DDevice9 *device, D3DXHANDLE constant, INT n)
1668 {
1669     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1670
1671     TRACE("iface %p, device %p, constant %p, n %d\n", iface, device, constant, n);
1672
1673     return set_scalar(This, device, constant, &n, D3DXPT_INT);
1674 }
1675
1676 static HRESULT WINAPI ID3DXConstantTableImpl_SetIntArray(struct ID3DXConstantTable *iface,
1677         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const INT *n, UINT count)
1678 {
1679     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1680
1681     TRACE("iface %p, device %p, constant %p, n %p, count %d\n", iface, device, constant, n, count);
1682
1683     return set_scalar_array(This, device, constant, n, count, D3DXPT_INT);
1684 }
1685
1686 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloat(struct ID3DXConstantTable *iface,
1687         struct IDirect3DDevice9 *device, D3DXHANDLE constant, float f)
1688 {
1689     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1690
1691     TRACE("iface %p, device %p, constant %p, f %f\n", iface, device, constant, f);
1692
1693     return set_scalar(This, device, constant, &f, D3DXPT_FLOAT);
1694 }
1695
1696 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloatArray(struct ID3DXConstantTable *iface,
1697         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const float *f, UINT count)
1698 {
1699     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1700
1701     TRACE("iface %p, device %p, constant %p, f %p, count %d\n", iface, device, constant, f, count);
1702
1703     return set_scalar_array(This, device, constant, f, count, D3DXPT_FLOAT);
1704 }
1705
1706 static HRESULT WINAPI ID3DXConstantTableImpl_SetVector(struct ID3DXConstantTable *iface,
1707         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXVECTOR4 *vector)
1708 {
1709     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1710
1711     TRACE("iface %p, device %p, constant %p, vector %p\n", iface, device, constant, vector);
1712
1713     return set_vector(This, device, constant, vector, D3DXPT_FLOAT);
1714 }
1715
1716 static HRESULT WINAPI ID3DXConstantTableImpl_SetVectorArray(struct ID3DXConstantTable *iface,
1717         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXVECTOR4 *vector, UINT count)
1718 {
1719     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1720
1721     TRACE("iface %p, device %p, constant %p, vector %p, count %u\n", iface, device, constant, vector, count);
1722
1723     return set_vector_array(This, device, constant, vector, count, D3DXPT_FLOAT);
1724 }
1725
1726 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrix(struct ID3DXConstantTable *iface,
1727         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *matrix)
1728 {
1729     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1730
1731     TRACE("iface %p, device %p, constant %p, matrix %p\n", iface, device, constant, matrix);
1732
1733     return set_matrix_array(This, device, constant, matrix, 1, FALSE);
1734 }
1735
1736 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixArray(struct ID3DXConstantTable *iface,
1737         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *matrix, UINT count)
1738 {
1739     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1740
1741     TRACE("iface %p, device %p, constant %p, matrix %p, count %u\n", iface, device, constant, matrix, count);
1742
1743     return set_matrix_array(This, device, constant, matrix, count, FALSE);
1744 }
1745
1746 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixPointerArray(struct ID3DXConstantTable *iface,
1747         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX **matrix, UINT count)
1748 {
1749     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1750
1751     TRACE("iface %p, device %p, constant %p, matrix %p, count %u)\n", iface, device, constant, matrix, count);
1752
1753     return set_matrix_pointer_array(This, device, constant, (const void **)matrix, count, FALSE);
1754 }
1755
1756 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTranspose(struct ID3DXConstantTable *iface,
1757         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *matrix)
1758 {
1759     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1760
1761     TRACE("iface %p, device %p, constant %p, matrix %p\n", iface, device, constant, matrix);
1762
1763     return set_matrix_array(This, device, constant, matrix, 1, TRUE);
1764 }
1765
1766 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposeArray(struct ID3DXConstantTable *iface,
1767         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *matrix, UINT count)
1768 {
1769     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1770
1771     TRACE("iface %p, device %p, constant %p, matrix %p, count %u\n", iface, device, constant, matrix, count);
1772
1773     return set_matrix_array(This, device, constant, matrix, count, TRUE);
1774 }
1775
1776 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposePointerArray(struct ID3DXConstantTable *iface,
1777         struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX **matrix, UINT count)
1778 {
1779     struct ID3DXConstantTableImpl *This = impl_from_ID3DXConstantTable(iface);
1780
1781     TRACE("iface %p, device %p, constant %p, matrix %p, count %u)\n", iface, device, constant, matrix, count);
1782
1783     return set_matrix_pointer_array(This, device, constant, (const void **)matrix, count, TRUE);
1784 }
1785
1786 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl =
1787 {
1788     /*** IUnknown methods ***/
1789     ID3DXConstantTableImpl_QueryInterface,
1790     ID3DXConstantTableImpl_AddRef,
1791     ID3DXConstantTableImpl_Release,
1792     /*** ID3DXBuffer methods ***/
1793     ID3DXConstantTableImpl_GetBufferPointer,
1794     ID3DXConstantTableImpl_GetBufferSize,
1795     /*** ID3DXConstantTable methods ***/
1796     ID3DXConstantTableImpl_GetDesc,
1797     ID3DXConstantTableImpl_GetConstantDesc,
1798     ID3DXConstantTableImpl_GetSamplerIndex,
1799     ID3DXConstantTableImpl_GetConstant,
1800     ID3DXConstantTableImpl_GetConstantByName,
1801     ID3DXConstantTableImpl_GetConstantElement,
1802     ID3DXConstantTableImpl_SetDefaults,
1803     ID3DXConstantTableImpl_SetValue,
1804     ID3DXConstantTableImpl_SetBool,
1805     ID3DXConstantTableImpl_SetBoolArray,
1806     ID3DXConstantTableImpl_SetInt,
1807     ID3DXConstantTableImpl_SetIntArray,
1808     ID3DXConstantTableImpl_SetFloat,
1809     ID3DXConstantTableImpl_SetFloatArray,
1810     ID3DXConstantTableImpl_SetVector,
1811     ID3DXConstantTableImpl_SetVectorArray,
1812     ID3DXConstantTableImpl_SetMatrix,
1813     ID3DXConstantTableImpl_SetMatrixArray,
1814     ID3DXConstantTableImpl_SetMatrixPointerArray,
1815     ID3DXConstantTableImpl_SetMatrixTranspose,
1816     ID3DXConstantTableImpl_SetMatrixTransposeArray,
1817     ID3DXConstantTableImpl_SetMatrixTransposePointerArray
1818 };
1819
1820 static HRESULT parse_ctab_constant_type(const char *ctab, DWORD typeoffset, struct ctab_constant *constant,
1821         BOOL is_element, WORD index, WORD max_index, DWORD *offset, DWORD nameoffset, UINT regset)
1822 {
1823     const D3DXSHADER_TYPEINFO *type = (LPD3DXSHADER_TYPEINFO)(ctab + typeoffset);
1824     const D3DXSHADER_STRUCTMEMBERINFO *memberinfo = NULL;
1825     HRESULT hr = D3D_OK;
1826     UINT i, count = 0;
1827     WORD size = 0;
1828
1829     constant->desc.DefaultValue = offset ? ctab + *offset : NULL;
1830     constant->desc.Class = type->Class;
1831     constant->desc.Type = type->Type;
1832     constant->desc.Rows = type->Rows;
1833     constant->desc.Columns = type->Columns;
1834     constant->desc.Elements = is_element ? 1 : type->Elements;
1835     constant->desc.StructMembers = type->StructMembers;
1836     constant->desc.Name = ctab + nameoffset;
1837     constant->desc.RegisterSet = regset;
1838     constant->desc.RegisterIndex = index;
1839
1840     TRACE("name %s, elements %u, index %u, defaultvalue %p, regset %s\n", constant->desc.Name,
1841             constant->desc.Elements, index, constant->desc.DefaultValue,
1842             debug_d3dxparameter_registerset(regset));
1843     TRACE("class %s, type %s, rows %d, columns %d, elements %d, struct_members %d\n",
1844             debug_d3dxparameter_class(type->Class), debug_d3dxparameter_type(type->Type),
1845             type->Rows, type->Columns, type->Elements, type->StructMembers);
1846
1847     if (type->Elements > 1 && !is_element)
1848     {
1849         count = type->Elements;
1850     }
1851     else if ((type->Class == D3DXPC_STRUCT) && type->StructMembers)
1852     {
1853         memberinfo = (D3DXSHADER_STRUCTMEMBERINFO*)(ctab + type->StructMemberInfo);
1854         count = type->StructMembers;
1855     }
1856
1857     if (count)
1858     {
1859         constant->constants = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*constant->constants) * count);
1860         if (!constant->constants)
1861         {
1862              ERR("Out of memory\n");
1863              hr = E_OUTOFMEMORY;
1864              goto error;
1865         }
1866
1867         for (i = 0; i < count; ++i)
1868         {
1869             hr = parse_ctab_constant_type(ctab, memberinfo ? memberinfo[i].TypeInfo : typeoffset,
1870                     &constant->constants[i], memberinfo == NULL, index + size, max_index, offset,
1871                     memberinfo ? memberinfo[i].Name : nameoffset, regset);
1872             if (hr != D3D_OK)
1873                 goto error;
1874
1875             size += constant->constants[i].desc.RegisterCount;
1876         }
1877     }
1878     else
1879     {
1880         WORD offsetdiff = type->Columns * type->Rows;
1881         BOOL fail = FALSE;
1882
1883         size = type->Columns * type->Rows;
1884
1885         switch (regset)
1886         {
1887             case D3DXRS_BOOL:
1888                 fail = type->Class != D3DXPC_SCALAR && type->Class != D3DXPC_VECTOR
1889                         && type->Class != D3DXPC_MATRIX_ROWS && type->Class != D3DXPC_MATRIX_COLUMNS;
1890                 break;
1891
1892             case D3DXRS_FLOAT4:
1893             case D3DXRS_INT4:
1894                 switch (type->Class)
1895                 {
1896                     case D3DXPC_VECTOR:
1897                         size = 1;
1898                         /* fall through */
1899                     case D3DXPC_SCALAR:
1900                         offsetdiff = type->Rows * 4;
1901                         break;
1902
1903                     case D3DXPC_MATRIX_ROWS:
1904                         offsetdiff = type->Rows * 4;
1905                         size = type->Rows;
1906                         break;
1907
1908                     case D3DXPC_MATRIX_COLUMNS:
1909                         offsetdiff = type->Columns * 4;
1910                         size = type->Columns;
1911                         break;
1912
1913                     default:
1914                         fail = TRUE;
1915                         break;
1916                 }
1917                 break;
1918
1919             case D3DXRS_SAMPLER:
1920                 size = 1;
1921                 fail = type->Class != D3DXPC_OBJECT;
1922                 break;
1923
1924             default:
1925                 fail = TRUE;
1926                 break;
1927         }
1928
1929         if (fail)
1930         {
1931             FIXME("Unhandled register set %s, type class %s\n", debug_d3dxparameter_registerset(regset),
1932                     debug_d3dxparameter_class(type->Class));
1933         }
1934
1935         /* offset in bytes => offsetdiff * sizeof(DWORD) */
1936         if (offset) *offset += offsetdiff * 4;
1937     }
1938
1939     constant->desc.RegisterCount = max(0, min(max_index - index, size));
1940     constant->desc.Bytes = 4 * constant->desc.Elements * type->Rows * type->Columns;
1941
1942     return D3D_OK;
1943
1944 error:
1945     if (constant->constants)
1946     {
1947         for (i = 0; i < count; ++i)
1948         {
1949             free_constant(&constant->constants[i]);
1950         }
1951         HeapFree(GetProcessHeap(), 0, constant->constants);
1952         constant->constants = NULL;
1953     }
1954
1955     return hr;
1956 }
1957
1958 HRESULT WINAPI D3DXGetShaderConstantTableEx(const DWORD *byte_code, DWORD flags, ID3DXConstantTable **constant_table)
1959 {
1960     struct ID3DXConstantTableImpl *object = NULL;
1961     const void *data;
1962     HRESULT hr;
1963     UINT size;
1964     const D3DXSHADER_CONSTANTTABLE *ctab_header;
1965     const D3DXSHADER_CONSTANTINFO *constant_info;
1966     DWORD i;
1967
1968     TRACE("byte_code %p, flags %x, constant_table %p\n", byte_code, flags, constant_table);
1969
1970     if (constant_table) *constant_table = NULL;
1971
1972     if (!byte_code || !constant_table)
1973     {
1974         WARN("Invalid argument specified.\n");
1975         return D3DERR_INVALIDCALL;
1976     }
1977
1978     if (!is_valid_bytecode(*byte_code))
1979     {
1980         WARN("Invalid byte_code specified.\n");
1981         return D3D_OK;
1982     }
1983
1984     if (flags) FIXME("Flags (%#x) are not handled, yet!\n", flags);
1985
1986     hr = D3DXFindShaderComment(byte_code, MAKEFOURCC('C','T','A','B'), &data, &size);
1987     if (hr != D3D_OK)
1988     {
1989         WARN("CTAB not found.\n");
1990         return D3DXERR_INVALIDDATA;
1991     }
1992
1993     if (size < sizeof(*ctab_header))
1994     {
1995         WARN("Invalid CTAB size.\n");
1996         return D3DXERR_INVALIDDATA;
1997     }
1998
1999     ctab_header = (const D3DXSHADER_CONSTANTTABLE *)data;
2000     if (ctab_header->Size != sizeof(*ctab_header))
2001     {
2002         WARN("Invalid D3DXSHADER_CONSTANTTABLE size.\n");
2003         return D3DXERR_INVALIDDATA;
2004     }
2005
2006     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2007     if (!object)
2008         return E_OUTOFMEMORY;
2009
2010     object->ID3DXConstantTable_iface.lpVtbl = &ID3DXConstantTable_Vtbl;
2011     object->ref = 1;
2012
2013     object->ctab = HeapAlloc(GetProcessHeap(), 0, size);
2014     if (!object->ctab)
2015     {
2016         ERR("Out of memory\n");
2017         HeapFree(GetProcessHeap(), 0, object);
2018         return E_OUTOFMEMORY;
2019     }
2020     object->size = size;
2021     memcpy(object->ctab, data, object->size);
2022
2023     object->desc.Creator = ctab_header->Creator ? object->ctab + ctab_header->Creator : NULL;
2024     object->desc.Version = ctab_header->Version;
2025     object->desc.Constants = ctab_header->Constants;
2026     TRACE("Creator %s, Version %x, Constants %u, Target %s\n",
2027             debugstr_a(object->desc.Creator), object->desc.Version, object->desc.Constants,
2028             debugstr_a(ctab_header->Target ? object->ctab + ctab_header->Target : NULL));
2029
2030     object->constants = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2031                                   sizeof(*object->constants) * object->desc.Constants);
2032     if (!object->constants)
2033     {
2034          ERR("Out of memory\n");
2035          hr = E_OUTOFMEMORY;
2036          goto error;
2037     }
2038
2039     constant_info = (const D3DXSHADER_CONSTANTINFO *)(object->ctab + ctab_header->ConstantInfo);
2040     for (i = 0; i < ctab_header->Constants; i++)
2041     {
2042         DWORD offset = constant_info[i].DefaultValue;
2043
2044         hr = parse_ctab_constant_type(object->ctab, constant_info[i].TypeInfo,
2045                 &object->constants[i], FALSE, constant_info[i].RegisterIndex,
2046                 constant_info[i].RegisterIndex + constant_info[i].RegisterCount,
2047                 offset ? &offset : NULL, constant_info[i].Name, constant_info[i].RegisterSet);
2048         if (hr != D3D_OK)
2049             goto error;
2050
2051         /*
2052          * Set the register count, it may differ for D3DXRS_INT4, because somehow
2053          * it makes the assumption that the register size is 1 instead of 4, so the
2054          * count is 4 times bigger. This holds true only for toplevel shader
2055          * constants. The count of elements and members is always based on a
2056          * register size of 4.
2057          */
2058         if (object->constants[i].desc.RegisterSet == D3DXRS_INT4)
2059         {
2060             object->constants[i].desc.RegisterCount = constant_info[i].RegisterCount;
2061         }
2062     }
2063
2064     *constant_table = &object->ID3DXConstantTable_iface;
2065
2066     return D3D_OK;
2067
2068 error:
2069     free_constant_table(object);
2070     HeapFree(GetProcessHeap(), 0, object);
2071
2072     return hr;
2073 }
2074
2075 HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
2076 {
2077     TRACE("(%p, %p): Forwarded to D3DXGetShaderConstantTableEx\n", byte_code, constant_table);
2078
2079     return D3DXGetShaderConstantTableEx(byte_code, 0, constant_table);
2080 }
2081
2082 HRESULT WINAPI D3DXGetShaderSamplers(const DWORD *byte_code, const char **samplers, UINT *count)
2083 {
2084     UINT i, sampler_count = 0;
2085     UINT size;
2086     const char *data;
2087     const D3DXSHADER_CONSTANTTABLE *ctab_header;
2088     const D3DXSHADER_CONSTANTINFO *constant_info;
2089
2090     TRACE("byte_code %p, samplers %p, count %p\n", byte_code, samplers, count);
2091
2092     if (count) *count = 0;
2093
2094     if (D3DXFindShaderComment(byte_code, MAKEFOURCC('C','T','A','B'), (const void **)&data, &size) != D3D_OK)
2095         return D3D_OK;
2096
2097     if (size < sizeof(*ctab_header)) return D3D_OK;
2098
2099     ctab_header = (const D3DXSHADER_CONSTANTTABLE *)data;
2100     if (ctab_header->Size != sizeof(*ctab_header)) return D3D_OK;
2101
2102     constant_info = (const D3DXSHADER_CONSTANTINFO *)(data + ctab_header->ConstantInfo);
2103     for (i = 0; i < ctab_header->Constants; i++)
2104     {
2105         const D3DXSHADER_TYPEINFO *type;
2106
2107         TRACE("name = %s\n", data + constant_info[i].Name);
2108
2109         type = (const D3DXSHADER_TYPEINFO *)(data + constant_info[i].TypeInfo);
2110
2111         if (type->Type == D3DXPT_SAMPLER
2112                 || type->Type == D3DXPT_SAMPLER1D
2113                 || type->Type == D3DXPT_SAMPLER2D
2114                 || type->Type == D3DXPT_SAMPLER3D
2115                 || type->Type == D3DXPT_SAMPLERCUBE)
2116         {
2117             if (samplers) samplers[sampler_count] = data + constant_info[i].Name;
2118
2119             ++sampler_count;
2120         }
2121     }
2122
2123     TRACE("Found %u samplers\n", sampler_count);
2124
2125     if (count) *count = sampler_count;
2126
2127     return D3D_OK;
2128 }