dlls/d3dx9_36/shader.c

   1 /*
   2  * Copyright 2008 Luis Busquets
   3  * Copyright 2009 Matteo Bruni
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22 #include "wine/debug.h"
  23 #include "wine/unicode.h"
  24 #include "windef.h"
  25 #include "wingdi.h"
  26 #include "objbase.h"
  27 #include "d3dcommon.h"
  28 #include "d3dx9_36_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  31
  32 /* This function is not declared in the SDK headers yet */
  33 HRESULT WINAPI D3DAssemble(LPCVOID data, SIZE_T datasize, LPCSTR filename,
  34                            const D3D_SHADER_MACRO *defines, ID3DInclude *include,
  35                            UINT flags,
  36                            ID3DBlob **shader, ID3DBlob **error_messages);
  37
  38 LPCSTR WINAPI D3DXGetPixelShaderProfile(LPDIRECT3DDEVICE9 device)
  39 {
  40     D3DCAPS9 caps;
  41
  42     TRACE("device %p\n", device);
  43
  44     if (!device) return NULL;
  45
  46     IDirect3DDevice9_GetDeviceCaps(device,&caps);
  47
  48     switch (caps.PixelShaderVersion)
  49     {
  50     case D3DPS_VERSION(1, 1):
  51         return "ps_1_1";
  52
  53     case D3DPS_VERSION(1, 2):
  54         return "ps_1_2";
  55
  56     case D3DPS_VERSION(1, 3):
  57         return "ps_1_3";
  58
  59     case D3DPS_VERSION(1, 4):
  60         return "ps_1_4";
  61
  62     case D3DPS_VERSION(2, 0):
  63         if ((caps.PS20Caps.NumTemps>=22)                          &&
  64             (caps.PS20Caps.Caps&D3DPS20CAPS_ARBITRARYSWIZZLE)     &&
  65             (caps.PS20Caps.Caps&D3DPS20CAPS_GRADIENTINSTRUCTIONS) &&
  66             (caps.PS20Caps.Caps&D3DPS20CAPS_PREDICATION)          &&
  67             (caps.PS20Caps.Caps&D3DPS20CAPS_NODEPENDENTREADLIMIT) &&
  68             (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
  69         {
  70             return "ps_2_a";
  71         }
  72         if ((caps.PS20Caps.NumTemps>=32)                          &&
  73             (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
  74         {
  75             return "ps_2_b";
  76         }
  77         return "ps_2_0";
  78
  79     case D3DPS_VERSION(3, 0):
  80         return "ps_3_0";
  81     }
  82
  83     return NULL;
  84 }
  85
  86 UINT WINAPI D3DXGetShaderSize(const DWORD *byte_code)
  87 {
  88     const DWORD *ptr = byte_code;
  89
  90     TRACE("byte_code %p\n", byte_code);
  91
  92     if (!ptr) return 0;
  93
  94     /* Look for the END token, skipping the VERSION token */
  95     while (*++ptr != D3DSIO_END)
  96     {
  97         /* Skip comments */
  98         if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
  99         {
 100             ptr += ((*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT);
 101         }
 102     }
 103     ++ptr;
 104
 105     /* Return the shader size in bytes */
 106     return (ptr - byte_code) * sizeof(*ptr);
 107 }
 108
 109 DWORD WINAPI D3DXGetShaderVersion(const DWORD *byte_code)
 110 {
 111     TRACE("byte_code %p\n", byte_code);
 112
 113     return byte_code ? *byte_code : 0;
 114 }
 115
 116 LPCSTR WINAPI D3DXGetVertexShaderProfile(LPDIRECT3DDEVICE9 device)
 117 {
 118     D3DCAPS9 caps;
 119
 120     TRACE("device %p\n", device);
 121
 122     if (!device) return NULL;
 123
 124     IDirect3DDevice9_GetDeviceCaps(device,&caps);
 125
 126     switch (caps.VertexShaderVersion)
 127     {
 128     case D3DVS_VERSION(1, 1):
 129         return "vs_1_1";
 130     case D3DVS_VERSION(2, 0):
 131         if ((caps.VS20Caps.NumTemps>=13) &&
 132             (caps.VS20Caps.DynamicFlowControlDepth==24) &&
 133             (caps.VS20Caps.Caps&D3DPS20CAPS_PREDICATION))
 134         {
 135             return "vs_2_a";
 136         }
 137         return "vs_2_0";
 138     case D3DVS_VERSION(3, 0):
 139         return "vs_3_0";
 140     }
 141
 142     return NULL;
 143 }
 144
 145 HRESULT WINAPI D3DXFindShaderComment(CONST DWORD* byte_code, DWORD fourcc, LPCVOID* data, UINT* size)
 146 {
 147     CONST DWORD *ptr = byte_code;
 148
 149     TRACE("(%p, %x, %p, %p)\n", byte_code, fourcc, data, size);
 150
 151     if (!byte_code)
 152         return D3DERR_INVALIDCALL;
 153
 154     while (*++ptr != D3DSIO_END)
 155     {
 156         /* Check if it is a comment */
 157         if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
 158         {
 159             DWORD comment_size = (*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
 160
 161             /* Check if this is the comment we are looking for */
 162             if (*(ptr + 1) == fourcc)
 163             {
 164                 UINT ctab_size = (comment_size - 1) * sizeof(DWORD);
 165                 LPCVOID ctab_data = ptr + 2;
 166                 if (size)
 167                     *size = ctab_size;
 168                 if (data)
 169                     *data = ctab_data;
 170                 TRACE("Returning comment data at %p with size %d\n", ctab_data, ctab_size);
 171                 return D3D_OK;
 172             }
 173             ptr += comment_size;
 174         }
 175     }
 176
 177     return S_FALSE;
 178 }
 179
 180 HRESULT WINAPI D3DXAssembleShader(LPCSTR data,
 181                                   UINT data_len,
 182                                   CONST D3DXMACRO* defines,
 183                                   LPD3DXINCLUDE include,
 184                                   DWORD flags,
 185                                   LPD3DXBUFFER* shader,
 186                                   LPD3DXBUFFER* error_messages)
 187 {
 188     /* Forward to d3dcompiler: the parameter types aren't really different,
 189        the actual data types are equivalent */
 190     HRESULT hr = D3DAssemble(data, data_len, NULL, (D3D_SHADER_MACRO *)defines,
 191                              (ID3DInclude *)include, flags, (ID3DBlob **)shader,
 192                              (ID3DBlob **)error_messages);
 193
 194     if(hr == E_FAIL) hr = D3DXERR_INVALIDDATA;
 195     return hr;
 196 }
 197
 198 /* D3DXInclude private implementation, used to implement
 199    D3DXAssembleShaderFromFile from D3DXAssembleShader */
 200 /* To be able to correctly resolve include search paths we have to store
 201    the pathname of each include file. We store the pathname pointer right
 202    before the file data. */
 203 static HRESULT WINAPI d3dincludefromfile_open(ID3DXInclude *iface,
 204                                               D3DXINCLUDE_TYPE include_type,
 205                                               LPCSTR filename, LPCVOID parent_data,
 206                                               LPCVOID *data, UINT *bytes) {
 207     const char *p, *parent_name = "";
 208     char *pathname = NULL;
 209     char **buffer = NULL;
 210     HANDLE file;
 211     UINT size;
 212
 213     if(parent_data != NULL)
 214         parent_name = *((const char **)parent_data - 1);
 215
 216     TRACE("Looking up for include file %s, parent %s\n", debugstr_a(filename), debugstr_a(parent_name));
 217
 218     if ((p = strrchr(parent_name, '\\')) || (p = strrchr(parent_name, '/'))) p++;
 219     else p = parent_name;
 220     pathname = HeapAlloc(GetProcessHeap(), 0, (p - parent_name) + strlen(filename) + 1);
 221     if(!pathname)
 222         return HRESULT_FROM_WIN32(GetLastError());
 223
 224     memcpy(pathname, parent_name, p - parent_name);
 225     strcpy(pathname + (p - parent_name), filename);
 226
 227     file = CreateFileA(pathname, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
 228     if(file == INVALID_HANDLE_VALUE)
 229         goto error;
 230
 231     TRACE("Include file found at pathname = %s\n", debugstr_a(pathname));
 232
 233     size = GetFileSize(file, NULL);
 234     if(size == INVALID_FILE_SIZE)
 235         goto error;
 236
 237     buffer = HeapAlloc(GetProcessHeap(), 0, size + sizeof(char *));
 238     if(!buffer)
 239         goto error;
 240     *buffer = pathname;
 241     if(!ReadFile(file, buffer + 1, size, bytes, NULL))
 242         goto error;
 243
 244     *data = buffer + 1;
 245
 246     CloseHandle(file);
 247     return S_OK;
 248
 249 error:
 250     CloseHandle(file);
 251     HeapFree(GetProcessHeap(), 0, pathname);
 252     HeapFree(GetProcessHeap(), 0, buffer);
 253     return HRESULT_FROM_WIN32(GetLastError());
 254 }
 255
 256 static HRESULT WINAPI d3dincludefromfile_close(ID3DXInclude *iface, LPCVOID data) {
 257     HeapFree(GetProcessHeap(), 0, *((char **)data - 1));
 258     HeapFree(GetProcessHeap(), 0, (char **)data - 1);
 259     return S_OK;
 260 }
 261
 262 static const struct ID3DXIncludeVtbl D3DXInclude_Vtbl = {
 263     d3dincludefromfile_open,
 264     d3dincludefromfile_close
 265 };
 266
 267 struct D3DXIncludeImpl {
 268     const ID3DXIncludeVtbl *lpVtbl;
 269 };
 270
 271 HRESULT WINAPI D3DXAssembleShaderFromFileA(LPCSTR filename,
 272                                            CONST D3DXMACRO* defines,
 273                                            LPD3DXINCLUDE include,
 274                                            DWORD flags,
 275                                            LPD3DXBUFFER* shader,
 276                                            LPD3DXBUFFER* error_messages)
 277 {
 278     LPWSTR filename_w = NULL;
 279     DWORD len;
 280     HRESULT ret;
 281
 282     if (!filename) return D3DXERR_INVALIDDATA;
 283
 284     len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
 285     filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 286     if (!filename_w) return E_OUTOFMEMORY;
 287     MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 288
 289     ret = D3DXAssembleShaderFromFileW(filename_w, defines, include, flags, shader, error_messages);
 290
 291     HeapFree(GetProcessHeap(), 0, filename_w);
 292     return ret;
 293 }
 294
 295 HRESULT WINAPI D3DXAssembleShaderFromFileW(LPCWSTR filename,
 296                                            CONST D3DXMACRO* defines,
 297                                            LPD3DXINCLUDE include,
 298                                            DWORD flags,
 299                                            LPD3DXBUFFER* shader,
 300                                            LPD3DXBUFFER* error_messages)
 301 {
 302     void *buffer;
 303     DWORD len;
 304     HRESULT hr;
 305     struct D3DXIncludeImpl includefromfile;
 306
 307     if(FAILED(map_view_of_file(filename, &buffer, &len)))
 308         return D3DXERR_INVALIDDATA;
 309
 310     if(!include)
 311     {
 312         includefromfile.lpVtbl = &D3DXInclude_Vtbl;
 313         include = (LPD3DXINCLUDE)&includefromfile;
 314     }
 315
 316     hr = D3DXAssembleShader(buffer, len, defines, include, flags,
 317                             shader, error_messages);
 318
 319     UnmapViewOfFile(buffer);
 320     return hr;
 321 }
 322
 323 HRESULT WINAPI D3DXAssembleShaderFromResourceA(HMODULE module,
 324                                                LPCSTR resource,
 325                                                CONST D3DXMACRO* defines,
 326                                                LPD3DXINCLUDE include,
 327                                                DWORD flags,
 328                                                LPD3DXBUFFER* shader,
 329                                                LPD3DXBUFFER* error_messages)
 330 {
 331     HRSRC res;
 332     LPCSTR buffer;
 333     DWORD len;
 334
 335     if (!(res = FindResourceA(module, resource, (LPCSTR)RT_RCDATA)))
 336         return D3DXERR_INVALIDDATA;
 337     if (FAILED(load_resource_into_memory(module, res, (LPVOID *)&buffer, &len)))
 338         return D3DXERR_INVALIDDATA;
 339     return D3DXAssembleShader(buffer, len, defines, include, flags,
 340                               shader, error_messages);
 341 }
 342
 343 HRESULT WINAPI D3DXAssembleShaderFromResourceW(HMODULE module,
 344                                                LPCWSTR resource,
 345                                                CONST D3DXMACRO* defines,
 346                                                LPD3DXINCLUDE include,
 347                                                DWORD flags,
 348                                                LPD3DXBUFFER* shader,
 349                                                LPD3DXBUFFER* error_messages)
 350 {
 351     HRSRC res;
 352     LPCSTR buffer;
 353     DWORD len;
 354
 355     if (!(res = FindResourceW(module, resource, (LPCWSTR)RT_RCDATA)))
 356         return D3DXERR_INVALIDDATA;
 357     if (FAILED(load_resource_into_memory(module, res, (LPVOID *)&buffer, &len)))
 358         return D3DXERR_INVALIDDATA;
 359     return D3DXAssembleShader(buffer, len, defines, include, flags,
 360                               shader, error_messages);
 361 }
 362
 363 HRESULT WINAPI D3DXCompileShader(LPCSTR pSrcData,
 364                                  UINT srcDataLen,
 365                                  CONST D3DXMACRO* pDefines,
 366                                  LPD3DXINCLUDE pInclude,
 367                                  LPCSTR pFunctionName,
 368                                  LPCSTR pProfile,
 369                                  DWORD Flags,
 370                                  LPD3DXBUFFER* ppShader,
 371                                  LPD3DXBUFFER* ppErrorMsgs,
 372                                  LPD3DXCONSTANTTABLE * ppConstantTable)
 373 {
 374     FIXME("(%p, %d, %p, %p, %s, %s, %x, %p, %p, %p): stub\n",
 375           pSrcData, srcDataLen, pDefines, pInclude, debugstr_a(pFunctionName),
 376           debugstr_a(pProfile), Flags, ppShader, ppErrorMsgs, ppConstantTable);
 377
 378     TRACE("Shader source:\n");
 379     TRACE("%s\n", debugstr_an(pSrcData, srcDataLen));
 380
 381     if (ppErrorMsgs)
 382         D3DXCreateBuffer(1, ppErrorMsgs); /* zero fill used as string end */
 383     return D3DERR_INVALIDCALL;
 384 }
 385
 386 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl;
 387
 388 typedef struct ID3DXConstantTableImpl {
 389     const ID3DXConstantTableVtbl *lpVtbl;
 390     LONG ref;
 391     LPVOID ctab;
 392     DWORD size;
 393     D3DXCONSTANTTABLE_DESC desc;
 394 } ID3DXConstantTableImpl;
 395
 396 /*** IUnknown methods ***/
 397 static HRESULT WINAPI ID3DXConstantTableImpl_QueryInterface(ID3DXConstantTable* iface, REFIID riid, void** ppvObject)
 398 {
 399     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 400
 401     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 402
 403     if (IsEqualGUID(riid, &IID_IUnknown) ||
 404         IsEqualGUID(riid, &IID_ID3DXBuffer) ||
 405         IsEqualGUID(riid, &IID_ID3DXConstantTable))
 406     {
 407         ID3DXConstantTable_AddRef(iface);
 408         *ppvObject = This;
 409         return S_OK;
 410     }
 411
 412     WARN("Interface %s not found.\n", debugstr_guid(riid));
 413
 414     return E_NOINTERFACE;
 415 }
 416
 417 static ULONG WINAPI ID3DXConstantTableImpl_AddRef(ID3DXConstantTable* iface)
 418 {
 419     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 420
 421     TRACE("(%p)->(): AddRef from %d\n", This, This->ref);
 422
 423     return InterlockedIncrement(&This->ref);
 424 }
 425
 426 static ULONG WINAPI ID3DXConstantTableImpl_Release(ID3DXConstantTable* iface)
 427 {
 428     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 429     ULONG ref = InterlockedDecrement(&This->ref);
 430
 431     TRACE("(%p)->(): Release from %d\n", This, ref + 1);
 432
 433     if (!ref)
 434     {
 435         HeapFree(GetProcessHeap(), 0, This->ctab);
 436         HeapFree(GetProcessHeap(), 0, This);
 437     }
 438
 439     return ref;
 440 }
 441
 442 /*** ID3DXBuffer methods ***/
 443 static LPVOID WINAPI ID3DXConstantTableImpl_GetBufferPointer(ID3DXConstantTable* iface)
 444 {
 445     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 446
 447     TRACE("(%p)->()\n", This);
 448
 449     return This->ctab;
 450 }
 451
 452 static DWORD WINAPI ID3DXConstantTableImpl_GetBufferSize(ID3DXConstantTable* iface)
 453 {
 454     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 455
 456     TRACE("(%p)->()\n", This);
 457
 458     return This->size;
 459 }
 460
 461 /*** ID3DXConstantTable methods ***/
 462 static HRESULT WINAPI ID3DXConstantTableImpl_GetDesc(ID3DXConstantTable* iface, D3DXCONSTANTTABLE_DESC *desc)
 463 {
 464     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 465
 466     TRACE("(%p)->(%p)\n", This, desc);
 467
 468     if (!desc)
 469         return D3DERR_INVALIDCALL;
 470
 471     memcpy(desc, &This->desc, sizeof(This->desc));
 472
 473     return D3D_OK;
 474 }
 475
 476 static HRESULT WINAPI ID3DXConstantTableImpl_GetConstantDesc(ID3DXConstantTable* iface, D3DXHANDLE constant,
 477                                                              D3DXCONSTANT_DESC *desc, UINT *count)
 478 {
 479     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 480
 481     FIXME("(%p)->(%p, %p, %p): stub\n", This, constant, desc, count);
 482
 483     return E_NOTIMPL;
 484 }
 485
 486 static UINT WINAPI ID3DXConstantTableImpl_GetSamplerIndex(LPD3DXCONSTANTTABLE iface, D3DXHANDLE constant)
 487 {
 488     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 489
 490     FIXME("(%p)->(%p): stub\n", This, constant);
 491
 492     return (UINT)-1;
 493 }
 494
 495 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstant(ID3DXConstantTable* iface, D3DXHANDLE constant, UINT index)
 496 {
 497     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 498
 499     FIXME("(%p)->(%p, %d): stub\n", This, constant, index);
 500
 501     return NULL;
 502 }
 503
 504 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantByName(ID3DXConstantTable* iface, D3DXHANDLE constant, LPCSTR name)
 505 {
 506     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 507
 508     FIXME("(%p)->(%p, %s): stub\n", This, constant, name);
 509
 510     return NULL;
 511 }
 512
 513 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantElement(ID3DXConstantTable* iface, D3DXHANDLE constant, UINT index)
 514 {
 515     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 516
 517     FIXME("(%p)->(%p, %d): stub\n", This, constant, index);
 518
 519     return NULL;
 520 }
 521
 522 static HRESULT WINAPI ID3DXConstantTableImpl_SetDefaults(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device)
 523 {
 524     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 525
 526     FIXME("(%p)->(%p): stub\n", This, device);
 527
 528     return E_NOTIMPL;
 529 }
 530
 531 static HRESULT WINAPI ID3DXConstantTableImpl_SetValue(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 532                                                       D3DXHANDLE constant, LPCVOID data, UINT bytes)
 533 {
 534     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 535
 536     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, data, bytes);
 537
 538     return E_NOTIMPL;
 539 }
 540
 541 static HRESULT WINAPI ID3DXConstantTableImpl_SetBool(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 542                                                      D3DXHANDLE constant, BOOL b)
 543 {
 544     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 545
 546     FIXME("(%p)->(%p, %p, %d): stub\n", This, device, constant, b);
 547
 548     return E_NOTIMPL;
 549 }
 550
 551 static HRESULT WINAPI ID3DXConstantTableImpl_SetBoolArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 552                                                           D3DXHANDLE constant, CONST BOOL* b, UINT count)
 553 {
 554     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 555
 556     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, b, count);
 557
 558     return E_NOTIMPL;
 559 }
 560
 561 static HRESULT WINAPI ID3DXConstantTableImpl_SetInt(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device, D3DXHANDLE constant, INT n)
 562 {
 563     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 564
 565     FIXME("(%p)->(%p, %p, %d): stub\n", This, device, constant, n);
 566
 567     return E_NOTIMPL;
 568 }
 569
 570 static HRESULT WINAPI ID3DXConstantTableImpl_SetIntArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 571                                                          D3DXHANDLE constant, CONST INT* n, UINT count)
 572 {
 573     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 574
 575     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, n, count);
 576
 577     return E_NOTIMPL;
 578 }
 579
 580 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloat(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 581                                                       D3DXHANDLE constant, FLOAT f)
 582 {
 583     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 584
 585     FIXME("(%p)->(%p, %p, %f): stub\n", This, device, constant, f);
 586
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloatArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 591                                                            D3DXHANDLE constant, CONST FLOAT* f, UINT count)
 592 {
 593     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 594
 595     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, f, count);
 596
 597     return E_NOTIMPL;
 598 }
 599
 600 static HRESULT WINAPI ID3DXConstantTableImpl_SetVector(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 601                                                        D3DXHANDLE constant, CONST D3DXVECTOR4* vector)
 602 {
 603     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 604
 605     FIXME("(%p)->(%p, %p, %p): stub\n", This, device, constant, vector);
 606
 607     return E_NOTIMPL;
 608 }
 609
 610 static HRESULT WINAPI ID3DXConstantTableImpl_SetVectorArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 611                                                             D3DXHANDLE constant, CONST D3DXVECTOR4* vector, UINT count)
 612 {
 613     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 614
 615     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, vector, count);
 616
 617     return E_NOTIMPL;
 618 }
 619
 620 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrix(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 621                                                        D3DXHANDLE constant, CONST D3DXMATRIX* matrix)
 622 {
 623     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 624
 625     FIXME("(%p)->(%p, %p, %p): stub\n", This, device, constant, matrix);
 626
 627     return E_NOTIMPL;
 628 }
 629
 630 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 631                                                             D3DXHANDLE constant, CONST D3DXMATRIX* matrix, UINT count)
 632 {
 633     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 634
 635     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
 636
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixPointerArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 641                                                                    D3DXHANDLE constant, CONST D3DXMATRIX** matrix, UINT count)
 642 {
 643     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 644
 645     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
 646
 647     return E_NOTIMPL;
 648 }
 649
 650 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTranspose(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 651                                                                 D3DXHANDLE constant, CONST D3DXMATRIX* matrix)
 652 {
 653     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 654
 655     FIXME("(%p)->(%p, %p, %p): stub\n", This, device, constant, matrix);
 656
 657     return E_NOTIMPL;
 658 }
 659
 660 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposeArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 661                                                                      D3DXHANDLE constant, CONST D3DXMATRIX* matrix, UINT count)
 662 {
 663     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 664
 665     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
 666
 667     return E_NOTIMPL;
 668 }
 669
 670 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposePointerArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 671                                                                             D3DXHANDLE constant, CONST D3DXMATRIX** matrix, UINT count)
 672 {
 673     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 674
 675     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
 676
 677     return E_NOTIMPL;
 678 }
 679
 680 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl =
 681 {
 682     /*** IUnknown methods ***/
 683     ID3DXConstantTableImpl_QueryInterface,
 684     ID3DXConstantTableImpl_AddRef,
 685     ID3DXConstantTableImpl_Release,
 686     /*** ID3DXBuffer methods ***/
 687     ID3DXConstantTableImpl_GetBufferPointer,
 688     ID3DXConstantTableImpl_GetBufferSize,
 689     /*** ID3DXConstantTable methods ***/
 690     ID3DXConstantTableImpl_GetDesc,
 691     ID3DXConstantTableImpl_GetConstantDesc,
 692     ID3DXConstantTableImpl_GetSamplerIndex,
 693     ID3DXConstantTableImpl_GetConstant,
 694     ID3DXConstantTableImpl_GetConstantByName,
 695     ID3DXConstantTableImpl_GetConstantElement,
 696     ID3DXConstantTableImpl_SetDefaults,
 697     ID3DXConstantTableImpl_SetValue,
 698     ID3DXConstantTableImpl_SetBool,
 699     ID3DXConstantTableImpl_SetBoolArray,
 700     ID3DXConstantTableImpl_SetInt,
 701     ID3DXConstantTableImpl_SetIntArray,
 702     ID3DXConstantTableImpl_SetFloat,
 703     ID3DXConstantTableImpl_SetFloatArray,
 704     ID3DXConstantTableImpl_SetVector,
 705     ID3DXConstantTableImpl_SetVectorArray,
 706     ID3DXConstantTableImpl_SetMatrix,
 707     ID3DXConstantTableImpl_SetMatrixArray,
 708     ID3DXConstantTableImpl_SetMatrixPointerArray,
 709     ID3DXConstantTableImpl_SetMatrixTranspose,
 710     ID3DXConstantTableImpl_SetMatrixTransposeArray,
 711     ID3DXConstantTableImpl_SetMatrixTransposePointerArray
 712 };
 713
 714 HRESULT WINAPI D3DXGetShaderConstantTableEx(CONST DWORD* byte_code,
 715                                             DWORD flags,
 716                                             LPD3DXCONSTANTTABLE* constant_table)
 717 {
 718     ID3DXConstantTableImpl* object = NULL;
 719     HRESULT hr;
 720     LPCVOID data;
 721     UINT size;
 722     const D3DXSHADER_CONSTANTTABLE* ctab_header;
 723
 724     FIXME("(%p, %x, %p): semi-stub\n", byte_code, flags, constant_table);
 725
 726     if (!byte_code || !constant_table)
 727         return D3DERR_INVALIDCALL;
 728
 729     hr = D3DXFindShaderComment(byte_code, MAKEFOURCC('C','T','A','B'), &data, &size);
 730     if (hr != D3D_OK)
 731         return D3DXERR_INVALIDDATA;
 732
 733     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ID3DXConstantTableImpl));
 734     if (!object)
 735     {
 736         ERR("Out of memory\n");
 737         return E_OUTOFMEMORY;
 738     }
 739
 740     object->lpVtbl = &ID3DXConstantTable_Vtbl;
 741     object->ref = 1;
 742
 743     if (size < sizeof(D3DXSHADER_CONSTANTTABLE))
 744         goto error;
 745
 746     object->ctab = HeapAlloc(GetProcessHeap(), 0, size);
 747     if (!object->ctab)
 748     {
 749         HeapFree(GetProcessHeap(), 0, object);
 750         ERR("Out of memory\n");
 751         return E_OUTOFMEMORY;
 752     }
 753     object->size = size;
 754     memcpy(object->ctab, data, object->size);
 755
 756     ctab_header = (const D3DXSHADER_CONSTANTTABLE*)data;
 757     if (ctab_header->Size != sizeof(D3DXSHADER_CONSTANTTABLE))
 758         goto error;
 759     object->desc.Creator = ctab_header->Creator ? (LPCSTR)object->ctab + ctab_header->Creator : NULL;
 760     object->desc.Version = ctab_header->Version;
 761     object->desc.Constants = ctab_header->Constants;
 762
 763     *constant_table = (LPD3DXCONSTANTTABLE)object;
 764
 765     return D3D_OK;
 766
 767 error:
 768
 769     HeapFree(GetProcessHeap(), 0, object->ctab);
 770     HeapFree(GetProcessHeap(), 0, object);
 771
 772     return D3DXERR_INVALIDDATA;
 773 }
 774
 775 HRESULT WINAPI D3DXGetShaderConstantTable(CONST DWORD* byte_code,
 776                                           LPD3DXCONSTANTTABLE* constant_table)
 777 {
 778     TRACE("(%p, %p): Forwarded to D3DXGetShaderConstantTableEx\n", byte_code, constant_table);
 779
 780     return D3DXGetShaderConstantTableEx(byte_code, 0, constant_table);
 781 }