dlls/d3dx9_36/shader.c

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