dlls/d3dx9_36/shader.c

   1 /*
   2  * Copyright 2008 Luis Busquets
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21 #include "wine/debug.h"
  22 #include "wine/unicode.h"
  23 #include "windef.h"
  24 #include "wingdi.h"
  25 #include "d3dx9.h"
  26 #include "d3dx9shader.h"
  27 #include "d3dx9_36_private.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  30
  31 LPCSTR WINAPI D3DXGetPixelShaderProfile(LPDIRECT3DDEVICE9 device)
  32 {
  33     D3DCAPS9 caps;
  34
  35     TRACE("device %p\n", device);
  36
  37     if (!device) return NULL;
  38
  39     IDirect3DDevice9_GetDeviceCaps(device,&caps);
  40
  41     switch (caps.PixelShaderVersion)
  42     {
  43     case D3DPS_VERSION(1, 1):
  44         return "ps_1_1";
  45
  46     case D3DPS_VERSION(1, 2):
  47         return "ps_1_2";
  48
  49     case D3DPS_VERSION(1, 3):
  50         return "ps_1_3";
  51
  52     case D3DPS_VERSION(1, 4):
  53         return "ps_1_4";
  54
  55     case D3DPS_VERSION(2, 0):
  56         if ((caps.PS20Caps.NumTemps>=22)                          &&
  57             (caps.PS20Caps.Caps&D3DPS20CAPS_ARBITRARYSWIZZLE)     &&
  58             (caps.PS20Caps.Caps&D3DPS20CAPS_GRADIENTINSTRUCTIONS) &&
  59             (caps.PS20Caps.Caps&D3DPS20CAPS_PREDICATION)          &&
  60             (caps.PS20Caps.Caps&D3DPS20CAPS_NODEPENDENTREADLIMIT) &&
  61             (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
  62         {
  63             return "ps_2_a";
  64         }
  65         if ((caps.PS20Caps.NumTemps>=32)                          &&
  66             (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
  67         {
  68             return "ps_2_b";
  69         }
  70         return "ps_2_0";
  71
  72     case D3DPS_VERSION(3, 0):
  73         return "ps_3_0";
  74     }
  75
  76     return NULL;
  77 }
  78
  79 UINT WINAPI D3DXGetShaderSize(const DWORD *byte_code)
  80 {
  81     const DWORD *ptr = byte_code;
  82
  83     TRACE("byte_code %p\n", byte_code);
  84
  85     if (!ptr) return 0;
  86
  87     /* Look for the END token, skipping the VERSION token */
  88     while (*++ptr != D3DSIO_END)
  89     {
  90         /* Skip comments */
  91         if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
  92         {
  93             ptr += ((*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT);
  94         }
  95     }
  96     ++ptr;
  97
  98     /* Return the shader size in bytes */
  99     return (ptr - byte_code) * sizeof(*ptr);
 100 }
 101
 102 DWORD WINAPI D3DXGetShaderVersion(const DWORD *byte_code)
 103 {
 104     TRACE("byte_code %p\n", byte_code);
 105
 106     return byte_code ? *byte_code : 0;
 107 }
 108
 109 LPCSTR WINAPI D3DXGetVertexShaderProfile(LPDIRECT3DDEVICE9 device)
 110 {
 111     D3DCAPS9 caps;
 112
 113     TRACE("device %p\n", device);
 114
 115     if (!device) return NULL;
 116
 117     IDirect3DDevice9_GetDeviceCaps(device,&caps);
 118
 119     switch (caps.VertexShaderVersion)
 120     {
 121     case D3DVS_VERSION(1, 1):
 122         return "vs_1_1";
 123     case D3DVS_VERSION(2, 0):
 124         if ((caps.VS20Caps.NumTemps>=13) &&
 125             (caps.VS20Caps.DynamicFlowControlDepth==24) &&
 126             (caps.VS20Caps.Caps&D3DPS20CAPS_PREDICATION))
 127         {
 128             return "vs_2_a";
 129         }
 130         return "vs_2_0";
 131     case D3DVS_VERSION(3, 0):
 132         return "vs_3_0";
 133     }
 134
 135     return NULL;
 136 }
 137
 138 HRESULT WINAPI D3DXAssembleShader(LPCSTR data,
 139                                   UINT data_len,
 140                                   CONST D3DXMACRO* defines,
 141                                   LPD3DXINCLUDE include,
 142                                   DWORD flags,
 143                                   LPD3DXBUFFER* shader,
 144                                   LPD3DXBUFFER* error_messages)
 145 {
 146     FIXME("(%p, %d, %p, %p, %x, %p, %p): stub\n", data, data_len, defines, include, flags, shader, error_messages);
 147     return D3DERR_INVALIDCALL;
 148 }
 149
 150 HRESULT WINAPI D3DXAssembleShaderFromFileA(LPCSTR filename,
 151                                            CONST D3DXMACRO* defines,
 152                                            LPD3DXINCLUDE include,
 153                                            DWORD flags,
 154                                            LPD3DXBUFFER* shader,
 155                                            LPD3DXBUFFER* error_messages)
 156 {
 157     LPWSTR filename_w = NULL;
 158     DWORD len;
 159     HRESULT ret;
 160
 161     if (!filename) return D3DXERR_INVALIDDATA;
 162
 163     len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
 164     filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 165     if (!filename_w) return E_OUTOFMEMORY;
 166     MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 167
 168     ret = D3DXAssembleShaderFromFileW(filename_w, defines, include, flags, shader, error_messages);
 169
 170     HeapFree(GetProcessHeap(), 0, filename_w);
 171     return ret;
 172 }
 173
 174 HRESULT WINAPI D3DXAssembleShaderFromFileW(LPCWSTR filename,
 175                                            CONST D3DXMACRO* defines,
 176                                            LPD3DXINCLUDE include,
 177                                            DWORD flags,
 178                                            LPD3DXBUFFER* shader,
 179                                            LPD3DXBUFFER* error_messages)
 180 {
 181     FIXME("(%s, %p, %p, %x, %p, %p): stub\n", debugstr_w(filename), defines, include, flags, shader, error_messages);
 182     return D3DERR_INVALIDCALL;
 183 }
 184
 185 HRESULT WINAPI D3DXAssembleShaderFromResourceA(HMODULE module,
 186                                                LPCSTR resource,
 187                                                CONST D3DXMACRO* defines,
 188                                                LPD3DXINCLUDE include,
 189                                                DWORD flags,
 190                                                LPD3DXBUFFER* shader,
 191                                                LPD3DXBUFFER* error_messages)
 192 {
 193     HRSRC res;
 194     LPCSTR buffer;
 195     DWORD len;
 196
 197     if (!(res = FindResourceA(module, resource, (LPCSTR)RT_RCDATA)))
 198         return D3DXERR_INVALIDDATA;
 199     if (FAILED(load_resource_into_memory(module, res, (LPVOID *)&buffer, &len)))
 200         return D3DXERR_INVALIDDATA;
 201     return D3DXAssembleShader(buffer, len, defines, include, flags,
 202                               shader, error_messages);
 203 }
 204
 205 HRESULT WINAPI D3DXAssembleShaderFromResourceW(HMODULE module,
 206                                                LPCWSTR resource,
 207                                                CONST D3DXMACRO* defines,
 208                                                LPD3DXINCLUDE include,
 209                                                DWORD flags,
 210                                                LPD3DXBUFFER* shader,
 211                                                LPD3DXBUFFER* error_messages)
 212 {
 213     HRSRC res;
 214     LPCSTR buffer;
 215     DWORD len;
 216
 217     if (!(res = FindResourceW(module, resource, (LPCWSTR)RT_RCDATA)))
 218         return D3DXERR_INVALIDDATA;
 219     if (FAILED(load_resource_into_memory(module, res, (LPVOID *)&buffer, &len)))
 220         return D3DXERR_INVALIDDATA;
 221     return D3DXAssembleShader(buffer, len, defines, include, flags,
 222                               shader, error_messages);
 223 }
 224
 225 HRESULT WINAPI D3DXCompileShader(LPCSTR pSrcData,
 226                                  UINT srcDataLen,
 227                                  CONST D3DXMACRO* pDefines,
 228                                  LPD3DXINCLUDE pInclude,
 229                                  LPCSTR pFunctionName,
 230                                  LPCSTR pProfile,
 231                                  DWORD Flags,
 232                                  LPD3DXBUFFER* ppShader,
 233                                  LPD3DXBUFFER* ppErrorMsgs,
 234                                  LPD3DXCONSTANTTABLE * ppConstantTable)
 235 {
 236     FIXME("(%p, %d, %p, %p, %p, %p, %d, %p, %p, %p): stub\n",
 237           pSrcData, srcDataLen, pDefines, pInclude, pFunctionName,
 238           pProfile, Flags, ppShader, ppErrorMsgs, ppConstantTable);
 239     return D3DERR_INVALIDCALL;
 240 }
 241
 242 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl;
 243
 244 typedef struct ID3DXConstantTableImpl {
 245     const ID3DXConstantTableVtbl *lpVtbl;
 246     LONG ref;
 247 } ID3DXConstantTableImpl;
 248
 249 /*** IUnknown methods ***/
 250 static HRESULT WINAPI ID3DXConstantTableImpl_QueryInterface(ID3DXConstantTable* iface, REFIID riid, void** ppvObject)
 251 {
 252     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 253
 254     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 255
 256     if (IsEqualGUID(riid, &IID_IUnknown) ||
 257         IsEqualGUID(riid, &IID_ID3DXConstantTable))
 258     {
 259         ID3DXConstantTable_AddRef(iface);
 260         *ppvObject = This;
 261         return S_OK;
 262     }
 263
 264     ERR("Interface %s not found\n", debugstr_guid(riid));
 265
 266     return E_NOINTERFACE;
 267 }
 268
 269 static ULONG WINAPI ID3DXConstantTableImpl_AddRef(ID3DXConstantTable* iface)
 270 {
 271     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 272
 273     TRACE("(%p)->(): AddRef from %d\n", This, This->ref);
 274
 275     return InterlockedIncrement(&This->ref);
 276 }
 277
 278 static ULONG WINAPI ID3DXConstantTableImpl_Release(ID3DXConstantTable* iface)
 279 {
 280     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 281     ULONG ref = InterlockedDecrement(&This->ref);
 282
 283     TRACE("(%p)->(): Release from %d\n", This, ref + 1);
 284
 285     if (!ref)
 286         HeapFree(GetProcessHeap(), 0, This);
 287
 288     return ref;
 289 }
 290
 291 /*** ID3DXBuffer methods ***/
 292 static LPVOID WINAPI ID3DXConstantTableImpl_GetBufferPointer(ID3DXConstantTable* iface)
 293 {
 294     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 295
 296     FIXME("(%p)->(): stub\n", This);
 297
 298     return NULL;
 299 }
 300
 301 static DWORD WINAPI ID3DXConstantTableImpl_GetBufferSize(ID3DXConstantTable* iface)
 302 {
 303     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 304
 305     FIXME("(%p)->(): stub\n", This);
 306
 307     return 0;
 308 }
 309
 310 /*** ID3DXConstantTable methods ***/
 311 static HRESULT WINAPI ID3DXConstantTableImpl_GetDesc(ID3DXConstantTable* iface, D3DXCONSTANTTABLE_DESC *desc)
 312 {
 313     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 314
 315     FIXME("(%p)->(%p): stub\n", This, desc);
 316
 317     return E_NOTIMPL;
 318 }
 319
 320 static HRESULT WINAPI ID3DXConstantTableImpl_GetConstantDesc(ID3DXConstantTable* iface, D3DXHANDLE constant,
 321                                                              D3DXCONSTANT_DESC *desc, UINT *count)
 322 {
 323     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 324
 325     FIXME("(%p)->(%p, %p, %p): stub\n", This, constant, desc, count);
 326
 327     return E_NOTIMPL;
 328 }
 329
 330 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstant(ID3DXConstantTable* iface, D3DXHANDLE constant, UINT index)
 331 {
 332     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 333
 334     FIXME("(%p)->(%p, %d): stub\n", This, constant, index);
 335
 336     return NULL;
 337 }
 338
 339 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantByName(ID3DXConstantTable* iface, D3DXHANDLE constant, LPCSTR name)
 340 {
 341     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 342
 343     FIXME("(%p)->(%p, %s): stub\n", This, constant, name);
 344
 345     return NULL;
 346 }
 347
 348 static D3DXHANDLE WINAPI ID3DXConstantTableImpl_GetConstantByElement(ID3DXConstantTable* iface, D3DXHANDLE constant, UINT index)
 349 {
 350     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 351
 352     FIXME("(%p)->(%p, %d): stub\n", This, constant, index);
 353
 354     return NULL;
 355 }
 356
 357 static HRESULT WINAPI ID3DXConstantTableImpl_SetDefaults(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device)
 358 {
 359     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 360
 361     FIXME("(%p)->(%p): stub\n", This, device);
 362
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI ID3DXConstantTableImpl_SetValue(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 367                                                       D3DXHANDLE constant, LPCVOID data, UINT bytes)
 368 {
 369     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 370
 371     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, data, bytes);
 372
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI ID3DXConstantTableImpl_SetBool(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 377                                                      D3DXHANDLE constant, BOOL b)
 378 {
 379     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 380
 381     FIXME("(%p)->(%p, %p, %d): stub\n", This, device, constant, b);
 382
 383     return E_NOTIMPL;
 384 }
 385
 386 static HRESULT WINAPI ID3DXConstantTableImpl_SetBoolArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 387                                                           D3DXHANDLE constant, CONST BOOL* b, UINT count)
 388 {
 389     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 390
 391     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, b, count);
 392
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI ID3DXConstantTableImpl_SetInt(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device, D3DXHANDLE constant, INT n)
 397 {
 398     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 399
 400     FIXME("(%p)->(%p, %p, %d): stub\n", This, device, constant, n);
 401
 402     return E_NOTIMPL;
 403 }
 404
 405 static HRESULT WINAPI ID3DXConstantTableImpl_SetIntArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 406                                                          D3DXHANDLE constant, CONST INT* n, UINT count)
 407 {
 408     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 409
 410     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, n, count);
 411
 412     return E_NOTIMPL;
 413 }
 414
 415 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloat(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 416                                                       D3DXHANDLE constant, FLOAT f)
 417 {
 418     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 419
 420     FIXME("(%p)->(%p, %p, %f): stub\n", This, device, constant, f);
 421
 422     return E_NOTIMPL;
 423 }
 424
 425 static HRESULT WINAPI ID3DXConstantTableImpl_SetFloatArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 426                                                            D3DXHANDLE constant, CONST FLOAT* f, UINT count)
 427 {
 428     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 429
 430     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, f, count);
 431
 432     return E_NOTIMPL;
 433 }
 434
 435 static HRESULT WINAPI ID3DXConstantTableImpl_SetVector(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 436                                                        D3DXHANDLE constant, CONST D3DXVECTOR4* vector)
 437 {
 438     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 439
 440     FIXME("(%p)->(%p, %p, %p): stub\n", This, device, constant, vector);
 441
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI ID3DXConstantTableImpl_SetVectorArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 446                                                             D3DXHANDLE constant, CONST D3DXVECTOR4* vector, UINT count)
 447 {
 448     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 449
 450     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, vector, count);
 451
 452     return E_NOTIMPL;
 453 }
 454
 455 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrix(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 456                                                        D3DXHANDLE constant, CONST D3DXMATRIX* matrix)
 457 {
 458     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 459
 460     FIXME("(%p)->(%p, %p, %p): stub\n", This, device, constant, matrix);
 461
 462     return E_NOTIMPL;
 463 }
 464
 465 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 466                                                             D3DXHANDLE constant, CONST D3DXMATRIX* matrix, UINT count)
 467 {
 468     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 469
 470     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
 471
 472     return E_NOTIMPL;
 473 }
 474
 475 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixPointerArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 476                                                                    D3DXHANDLE constant, CONST D3DXMATRIX** matrix, UINT count)
 477 {
 478     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 479
 480     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
 481
 482     return E_NOTIMPL;
 483 }
 484
 485 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTranspose(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 486                                                                 D3DXHANDLE constant, CONST D3DXMATRIX* matrix)
 487 {
 488     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 489
 490     FIXME("(%p)->(%p, %p, %p): stub\n", This, device, constant, matrix);
 491
 492     return E_NOTIMPL;
 493 }
 494
 495 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposeArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 496                                                                      D3DXHANDLE constant, CONST D3DXMATRIX* matrix, UINT count)
 497 {
 498     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 499
 500     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
 501
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI ID3DXConstantTableImpl_SetMatrixTransposePointerArray(ID3DXConstantTable* iface, LPDIRECT3DDEVICE9 device,
 506                                                                             D3DXHANDLE constant, CONST D3DXMATRIX** matrix, UINT count)
 507 {
 508     ID3DXConstantTableImpl *This = (ID3DXConstantTableImpl *)iface;
 509
 510     FIXME("(%p)->(%p, %p, %p, %d): stub\n", This, device, constant, matrix, count);
 511
 512     return E_NOTIMPL;
 513 }
 514
 515 static const struct ID3DXConstantTableVtbl ID3DXConstantTable_Vtbl =
 516 {
 517     /*** IUnknown methods ***/
 518     ID3DXConstantTableImpl_QueryInterface,
 519     ID3DXConstantTableImpl_AddRef,
 520     ID3DXConstantTableImpl_Release,
 521     /*** ID3DXBuffer methods ***/
 522     ID3DXConstantTableImpl_GetBufferPointer,
 523     ID3DXConstantTableImpl_GetBufferSize,
 524     /*** ID3DXConstantTable methods ***/
 525     ID3DXConstantTableImpl_GetDesc,
 526     ID3DXConstantTableImpl_GetConstantDesc,
 527     ID3DXConstantTableImpl_GetConstant,
 528     ID3DXConstantTableImpl_GetConstantByName,
 529     ID3DXConstantTableImpl_GetConstantByElement,
 530     ID3DXConstantTableImpl_SetDefaults,
 531     ID3DXConstantTableImpl_SetValue,
 532     ID3DXConstantTableImpl_SetBool,
 533     ID3DXConstantTableImpl_SetBoolArray,
 534     ID3DXConstantTableImpl_SetInt,
 535     ID3DXConstantTableImpl_SetIntArray,
 536     ID3DXConstantTableImpl_SetFloat,
 537     ID3DXConstantTableImpl_SetFloatArray,
 538     ID3DXConstantTableImpl_SetVector,
 539     ID3DXConstantTableImpl_SetVectorArray,
 540     ID3DXConstantTableImpl_SetMatrix,
 541     ID3DXConstantTableImpl_SetMatrixArray,
 542     ID3DXConstantTableImpl_SetMatrixPointerArray,
 543     ID3DXConstantTableImpl_SetMatrixTranspose,
 544     ID3DXConstantTableImpl_SetMatrixTransposeArray,
 545     ID3DXConstantTableImpl_SetMatrixTransposePointerArray
 546 };
 547
 548 HRESULT WINAPI D3DXGetShaderConstantTableEx(CONST DWORD* pFunction,
 549                                             DWORD flags,
 550                                             LPD3DXCONSTANTTABLE* ppConstantTable)
 551 {
 552     ID3DXConstantTableImpl* object;
 553
 554     FIXME("(%p, %x, %p): semi-stub\n", pFunction, flags, ppConstantTable);
 555
 556     if (!pFunction || !ppConstantTable)
 557         return D3DERR_INVALIDCALL;
 558
 559     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ID3DXConstantTableImpl));
 560     if (!object)
 561     {
 562         ERR("Out of memory\n");
 563         return E_OUTOFMEMORY;
 564     }
 565
 566     object->lpVtbl = &ID3DXConstantTable_Vtbl;
 567     object->ref = 1;
 568
 569     *ppConstantTable = (LPD3DXCONSTANTTABLE)object;
 570
 571     return D3D_OK;
 572 }
 573
 574 HRESULT WINAPI D3DXGetShaderConstantTable(CONST DWORD* pFunction,
 575                                           LPD3DXCONSTANTTABLE* ppConstantTable)
 576 {
 577     TRACE("(%p, %p): Forwarded to D3DXGetShaderConstantTableEx\n", pFunction, ppConstantTable);
 578
 579     return D3DXGetShaderConstantTableEx(pFunction, 0, ppConstantTable);
 580 }