dlls/d3dx9_36/effect.c

   1 /*
   2  * Copyright 2010 Christian Costa
   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_36_private.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  28
  29 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl;
  30
  31 typedef struct ID3DXEffectImpl {
  32     ID3DXEffect ID3DXEffect_iface;
  33     LONG ref;
  34
  35     UINT parameter_count;
  36     UINT technique_count;
  37 } ID3DXEffectImpl;
  38
  39 static inline void read_dword(const char **ptr, DWORD *d)
  40 {
  41     memcpy(d, *ptr, sizeof(*d));
  42     *ptr += sizeof(*d);
  43 }
  44
  45 static void skip_dword_unknown(const char **ptr, unsigned int count)
  46 {
  47     unsigned int i;
  48     DWORD d;
  49
  50     FIXME("Skipping %u unknown DWORDs:\n", count);
  51     for (i = 0; i < count; ++i)
  52     {
  53         read_dword(ptr, &d);
  54         FIXME("\t0x%08x\n", d);
  55     }
  56 }
  57
  58 static inline DWORD d3dx9_effect_version(DWORD major, DWORD minor)
  59 {
  60     return (0xfeff0000 | ((major) << 8) | (minor));
  61 }
  62
  63 static inline ID3DXEffectImpl *impl_from_ID3DXEffect(ID3DXEffect *iface)
  64 {
  65     return CONTAINING_RECORD(iface, ID3DXEffectImpl, ID3DXEffect_iface);
  66 }
  67
  68 /*** IUnknown methods ***/
  69 static HRESULT WINAPI ID3DXEffectImpl_QueryInterface(ID3DXEffect* iface, REFIID riid, void** object)
  70 {
  71     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
  72
  73     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
  74
  75     if (IsEqualGUID(riid, &IID_IUnknown) ||
  76         IsEqualGUID(riid, &IID_ID3DXBaseEffect) ||
  77         IsEqualGUID(riid, &IID_ID3DXEffect))
  78     {
  79         This->ID3DXEffect_iface.lpVtbl->AddRef(iface);
  80         *object = This;
  81         return S_OK;
  82     }
  83
  84     ERR("Interface %s not found\n", debugstr_guid(riid));
  85
  86     return E_NOINTERFACE;
  87 }
  88
  89 static ULONG WINAPI ID3DXEffectImpl_AddRef(ID3DXEffect* iface)
  90 {
  91     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
  92
  93     TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
  94
  95     return InterlockedIncrement(&This->ref);
  96 }
  97
  98 static ULONG WINAPI ID3DXEffectImpl_Release(ID3DXEffect* iface)
  99 {
 100     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 101     ULONG ref = InterlockedDecrement(&This->ref);
 102
 103     TRACE("(%p)->(): Release from %u\n", This, ref + 1);
 104
 105     if (!ref)
 106         HeapFree(GetProcessHeap(), 0, This);
 107
 108     return ref;
 109 }
 110
 111 /*** ID3DXBaseEffect methods ***/
 112 static HRESULT WINAPI ID3DXEffectImpl_GetDesc(ID3DXEffect* iface, D3DXEFFECT_DESC* desc)
 113 {
 114     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 115
 116     FIXME("(%p)->(%p): stub\n", This, desc);
 117
 118     return E_NOTIMPL;
 119 }
 120
 121 static HRESULT WINAPI ID3DXEffectImpl_GetParameterDesc(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC* desc)
 122 {
 123     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 124
 125     FIXME("(%p)->(%p, %p): stub\n", This, parameter, desc);
 126
 127     return E_NOTIMPL;
 128 }
 129
 130 static HRESULT WINAPI ID3DXEffectImpl_GetTechniqueDesc(ID3DXEffect* iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC* desc)
 131 {
 132     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 133
 134     FIXME("(%p)->(%p, %p): stub\n", This, technique, desc);
 135
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI ID3DXEffectImpl_GetPassDesc(ID3DXEffect* iface, D3DXHANDLE pass, D3DXPASS_DESC* desc)
 140 {
 141     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 142
 143     FIXME("(%p)->(%p, %p): stub\n", This, pass, desc);
 144
 145     return E_NOTIMPL;
 146 }
 147
 148 static HRESULT WINAPI ID3DXEffectImpl_GetFunctionDesc(ID3DXEffect* iface, D3DXHANDLE shader, D3DXFUNCTION_DESC* desc)
 149 {
 150     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 151
 152     FIXME("(%p)->(%p, %p): stub\n", This, shader, desc);
 153
 154     return E_NOTIMPL;
 155 }
 156
 157 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameter(ID3DXEffect* iface, D3DXHANDLE parameter, UINT index)
 158 {
 159     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 160
 161     FIXME("(%p)->(%p, %u): stub\n", This, parameter, index);
 162
 163     return NULL;
 164 }
 165
 166 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterByName(ID3DXEffect* iface, D3DXHANDLE parameter, LPCSTR name)
 167 {
 168     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 169
 170     FIXME("(%p)->(%p, %s): stub\n", This, parameter, name);
 171
 172     return NULL;
 173 }
 174
 175 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterBySemantic(ID3DXEffect* iface, D3DXHANDLE parameter, LPCSTR semantic)
 176 {
 177     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 178
 179     FIXME("(%p)->(%p, %s): stub\n", This, parameter, semantic);
 180
 181     return NULL;
 182 }
 183
 184 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterElement(ID3DXEffect* iface, D3DXHANDLE parameter, UINT index)
 185 {
 186     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 187
 188     FIXME("(%p)->(%p, %u): stub\n", This, parameter, index);
 189
 190     return NULL;
 191 }
 192
 193 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechnique(ID3DXEffect* iface, UINT index)
 194 {
 195     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 196
 197     FIXME("(%p)->(%u): stub\n", This, index);
 198
 199     return NULL;
 200 }
 201
 202 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechniqueByName(ID3DXEffect* iface, LPCSTR name)
 203 {
 204     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 205
 206     FIXME("(%p)->(%s): stub\n", This, name);
 207
 208     return NULL;
 209 }
 210
 211 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPass(ID3DXEffect* iface, D3DXHANDLE technique, UINT index)
 212 {
 213     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 214
 215     FIXME("(%p)->(%p, %u): stub\n", This, technique, index);
 216
 217     return NULL;
 218 }
 219
 220 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPassByName(ID3DXEffect* iface, D3DXHANDLE technique, LPCSTR name)
 221 {
 222     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 223
 224     FIXME("(%p)->(%p, %s): stub\n", This, technique, name);
 225
 226     return NULL;
 227 }
 228
 229 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunction(ID3DXEffect* iface, UINT index)
 230 {
 231     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 232
 233     FIXME("(%p)->(%u): stub\n", This, index);
 234
 235     return NULL;
 236 }
 237
 238 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunctionByName(ID3DXEffect* iface, LPCSTR name)
 239 {
 240     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 241
 242     FIXME("(%p)->(%s): stub\n", This, name);
 243
 244     return NULL;
 245 }
 246
 247 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotation(ID3DXEffect* iface, D3DXHANDLE object, UINT index)
 248 {
 249     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 250
 251     FIXME("(%p)->(%p, %u): stub\n", This, object, index);
 252
 253     return NULL;
 254 }
 255
 256 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotationByName(ID3DXEffect* iface, D3DXHANDLE object, LPCSTR name)
 257 {
 258     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 259
 260     FIXME("(%p)->(%p, %s): stub\n", This, object, name);
 261
 262     return NULL;
 263 }
 264
 265 static HRESULT WINAPI ID3DXEffectImpl_SetValue(ID3DXEffect* iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
 266 {
 267     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 268
 269     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, data, bytes);
 270
 271     return E_NOTIMPL;
 272 }
 273
 274 static HRESULT WINAPI ID3DXEffectImpl_GetValue(ID3DXEffect* iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
 275 {
 276     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 277
 278     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, data, bytes);
 279
 280     return E_NOTIMPL;
 281 }
 282
 283 static HRESULT WINAPI ID3DXEffectImpl_SetBool(ID3DXEffect* iface, D3DXHANDLE parameter, BOOL b)
 284 {
 285     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 286
 287     FIXME("(%p)->(%p, %u): stub\n", This, parameter, b);
 288
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI ID3DXEffectImpl_GetBool(ID3DXEffect* iface, D3DXHANDLE parameter, BOOL* b)
 293 {
 294     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 295
 296     FIXME("(%p)->(%p, %p): stub\n", This, parameter, b);
 297
 298     return E_NOTIMPL;
 299 }
 300
 301 static HRESULT WINAPI ID3DXEffectImpl_SetBoolArray(ID3DXEffect* iface, D3DXHANDLE parameter, CONST BOOL* b, UINT count)
 302 {
 303     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 304
 305     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, b, count);
 306
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI ID3DXEffectImpl_GetBoolArray(ID3DXEffect* iface, D3DXHANDLE parameter, BOOL* b, UINT count)
 311 {
 312     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 313
 314     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, b, count);
 315
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI ID3DXEffectImpl_SetInt(ID3DXEffect* iface, D3DXHANDLE parameter, INT n)
 320 {
 321     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 322
 323     FIXME("(%p)->(%p, %d): stub\n", This, parameter, n);
 324
 325     return E_NOTIMPL;
 326 }
 327
 328 static HRESULT WINAPI ID3DXEffectImpl_GetInt(ID3DXEffect* iface, D3DXHANDLE parameter, INT* n)
 329 {
 330     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 331
 332     FIXME("(%p)->(%p, %p): stub\n", This, parameter, n);
 333
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI ID3DXEffectImpl_SetIntArray(ID3DXEffect* iface, D3DXHANDLE parameter, CONST INT* n, UINT count)
 338 {
 339     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 340
 341     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, n, count);
 342
 343     return E_NOTIMPL;
 344 }
 345
 346 static HRESULT WINAPI ID3DXEffectImpl_GetIntArray(ID3DXEffect* iface, D3DXHANDLE parameter, INT* n, UINT count)
 347 {
 348     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 349
 350     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, n, count);
 351
 352     return E_NOTIMPL;
 353 }
 354
 355 static HRESULT WINAPI ID3DXEffectImpl_SetFloat(ID3DXEffect* iface, D3DXHANDLE parameter, FLOAT f)
 356 {
 357     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 358
 359     FIXME("(%p)->(%p, %f): stub\n", This, parameter, f);
 360
 361     return E_NOTIMPL;
 362 }
 363
 364 static HRESULT WINAPI ID3DXEffectImpl_GetFloat(ID3DXEffect* iface, D3DXHANDLE parameter, FLOAT* f)
 365 {
 366     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 367
 368     FIXME("(%p)->(%p, %p): stub\n", This, parameter, f);
 369
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT WINAPI ID3DXEffectImpl_SetFloatArray(ID3DXEffect* iface, D3DXHANDLE parameter, CONST FLOAT* f, UINT count)
 374 {
 375     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 376
 377     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, f, count);
 378
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI ID3DXEffectImpl_GetFloatArray(ID3DXEffect* iface, D3DXHANDLE parameter, FLOAT* f, UINT count)
 383 {
 384     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 385
 386     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, f, count);
 387
 388     return E_NOTIMPL;
 389 }
 390
 391 static HRESULT WINAPI ID3DXEffectImpl_SetVector(ID3DXEffect* iface, D3DXHANDLE parameter, CONST D3DXVECTOR4* vector)
 392 {
 393     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 394
 395     FIXME("(%p)->(%p, %p): stub\n", This, parameter, vector);
 396
 397     return E_NOTIMPL;
 398 }
 399
 400 static HRESULT WINAPI ID3DXEffectImpl_GetVector(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXVECTOR4* vector)
 401 {
 402     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 403
 404     FIXME("(%p)->(%p, %p): stub\n", This, parameter, vector);
 405
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI ID3DXEffectImpl_SetVectorArray(ID3DXEffect* iface, D3DXHANDLE parameter, CONST D3DXVECTOR4* vector, UINT count)
 410 {
 411     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 412
 413     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, vector, count);
 414
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT WINAPI ID3DXEffectImpl_GetVectorArray(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXVECTOR4* vector, UINT count)
 419 {
 420     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 421
 422     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, vector, count);
 423
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI ID3DXEffectImpl_SetMatrix(ID3DXEffect* iface, D3DXHANDLE parameter, CONST D3DXMATRIX* matrix)
 428 {
 429     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 430
 431     FIXME("(%p)->(%p, %p): stub\n", This, parameter, matrix);
 432
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT WINAPI ID3DXEffectImpl_GetMatrix(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXMATRIX* matrix)
 437 {
 438     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 439
 440     FIXME("(%p)->(%p, %p): stub\n", This, parameter, matrix);
 441
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixArray(ID3DXEffect* iface, D3DXHANDLE parameter, CONST D3DXMATRIX* matrix, UINT count)
 446 {
 447     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 448
 449     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, matrix, count);
 450
 451     return E_NOTIMPL;
 452 }
 453
 454 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixArray(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count)
 455 {
 456     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 457
 458     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, matrix, count);
 459
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixPointerArray(ID3DXEffect* iface, D3DXHANDLE parameter, CONST D3DXMATRIX** matrix, UINT count)
 464 {
 465     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 466
 467     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, matrix, count);
 468
 469     return E_NOTIMPL;
 470 }
 471
 472 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixPointerArray(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count)
 473 {
 474     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 475
 476     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, matrix, count);
 477
 478     return E_NOTIMPL;
 479 }
 480
 481 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTranspose(ID3DXEffect* iface, D3DXHANDLE parameter, CONST D3DXMATRIX* matrix)
 482 {
 483     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 484
 485     FIXME("(%p)->(%p, %p): stub\n", This, parameter, matrix);
 486
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTranspose(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXMATRIX* matrix)
 491 {
 492     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 493
 494     FIXME("(%p)->(%p, %p): stub\n", This, parameter, matrix);
 495
 496     return E_NOTIMPL;
 497 }
 498
 499 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposeArray(ID3DXEffect* iface, D3DXHANDLE parameter, CONST D3DXMATRIX* matrix, UINT count)
 500 {
 501     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 502
 503     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, matrix, count);
 504
 505     return E_NOTIMPL;
 506 }
 507
 508 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposeArray(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count)
 509 {
 510     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 511
 512     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, matrix, count);
 513
 514     return E_NOTIMPL;
 515 }
 516
 517 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposePointerArray(ID3DXEffect* iface, D3DXHANDLE parameter, CONST D3DXMATRIX** matrix, UINT count)
 518 {
 519     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 520
 521     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, matrix, count);
 522
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposePointerArray(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count)
 527 {
 528     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 529
 530     FIXME("(%p)->(%p, %p, %u): stub\n", This, parameter, matrix, count);
 531
 532     return E_NOTIMPL;
 533 }
 534
 535 static HRESULT WINAPI ID3DXEffectImpl_SetString(ID3DXEffect* iface, D3DXHANDLE parameter, LPCSTR string)
 536 {
 537     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 538
 539     FIXME("(%p)->(%p, %p): stub\n", This, parameter, string);
 540
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI ID3DXEffectImpl_GetString(ID3DXEffect* iface, D3DXHANDLE parameter, LPCSTR* string)
 545 {
 546     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 547
 548     FIXME("(%p)->(%p, %p): stub\n", This, parameter, string);
 549
 550     return E_NOTIMPL;
 551 }
 552
 553 static HRESULT WINAPI ID3DXEffectImpl_SetTexture(ID3DXEffect* iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
 554 {
 555     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 556
 557     FIXME("(%p)->(%p, %p): stub\n", This, parameter, texture);
 558
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI ID3DXEffectImpl_GetTexture(ID3DXEffect* iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9* texture)
 563 {
 564     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 565
 566     FIXME("(%p)->(%p, %p): stub\n", This, parameter, texture);
 567
 568     return E_NOTIMPL;
 569 }
 570
 571 static HRESULT WINAPI ID3DXEffectImpl_GetPixelShader(ID3DXEffect* iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9* pshader)
 572 {
 573     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 574
 575     FIXME("(%p)->(%p, %p): stub\n", This, parameter, pshader);
 576
 577     return E_NOTIMPL;
 578 }
 579
 580 static HRESULT WINAPI ID3DXEffectImpl_GetVertexShader(ID3DXEffect* iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9* vshader)
 581 {
 582     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 583
 584     FIXME("(%p)->(%p, %p): stub\n", This, parameter, vshader);
 585
 586     return E_NOTIMPL;
 587 }
 588
 589 static HRESULT WINAPI ID3DXEffectImpl_SetArrayRange(ID3DXEffect* iface, D3DXHANDLE parameter, UINT start, UINT end)
 590 {
 591     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 592
 593     FIXME("(%p)->(%p, %u, %u): stub\n", This, parameter, start, end);
 594
 595     return E_NOTIMPL;
 596 }
 597
 598 /*** ID3DXEffect methods ***/
 599 static HRESULT WINAPI ID3DXEffectImpl_GetPool(ID3DXEffect* iface, LPD3DXEFFECTPOOL* pool)
 600 {
 601     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 602
 603     FIXME("(%p)->(%p): stub\n", This, pool);
 604
 605     return E_NOTIMPL;
 606 }
 607
 608 static HRESULT WINAPI ID3DXEffectImpl_SetTechnique(ID3DXEffect* iface, D3DXHANDLE technique)
 609 {
 610     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 611
 612     FIXME("(%p)->(%p): stub\n", This, technique);
 613
 614     return E_NOTIMPL;
 615 }
 616
 617 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetCurrentTechnique(ID3DXEffect* iface)
 618 {
 619     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 620
 621     FIXME("(%p)->(): stub\n", This);
 622
 623     return NULL;
 624 }
 625
 626 static HRESULT WINAPI ID3DXEffectImpl_ValidateTechnique(ID3DXEffect* iface, D3DXHANDLE technique)
 627 {
 628     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 629
 630     FIXME("(%p)->(%p): stub\n", This, technique);
 631
 632     return D3D_OK;
 633 }
 634
 635 static HRESULT WINAPI ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect* iface, D3DXHANDLE technique, D3DXHANDLE* next_technique)
 636 {
 637     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 638
 639     FIXME("(%p)->(%p, %p): stub\n", This, technique, next_technique);
 640
 641     return E_NOTIMPL;
 642 }
 643
 644 static BOOL WINAPI ID3DXEffectImpl_IsParameterUsed(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXHANDLE technique)
 645 {
 646     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 647
 648     FIXME("(%p)->(%p, %p): stub\n", This, parameter, technique);
 649
 650     return FALSE;
 651 }
 652
 653 static HRESULT WINAPI ID3DXEffectImpl_Begin(ID3DXEffect* iface, UINT *passes, DWORD flags)
 654 {
 655     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 656
 657     FIXME("(%p)->(%p, %#x): stub\n", This, passes, flags);
 658
 659     return E_NOTIMPL;
 660 }
 661
 662 static HRESULT WINAPI ID3DXEffectImpl_BeginPass(ID3DXEffect* iface, UINT pass)
 663 {
 664     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 665
 666     FIXME("(%p)->(%u): stub\n", This, pass);
 667
 668     return E_NOTIMPL;
 669 }
 670
 671 static HRESULT WINAPI ID3DXEffectImpl_CommitChanges(ID3DXEffect* iface)
 672 {
 673     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 674
 675     FIXME("(%p)->(): stub\n", This);
 676
 677     return E_NOTIMPL;
 678 }
 679
 680 static HRESULT WINAPI ID3DXEffectImpl_EndPass(ID3DXEffect* iface)
 681 {
 682     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 683
 684     FIXME("(%p)->(): stub\n", This);
 685
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI ID3DXEffectImpl_End(ID3DXEffect* iface)
 690 {
 691     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 692
 693     FIXME("(%p)->(): stub\n", This);
 694
 695     return E_NOTIMPL;
 696 }
 697
 698 static HRESULT WINAPI ID3DXEffectImpl_GetDevice(ID3DXEffect* iface, LPDIRECT3DDEVICE9* device)
 699 {
 700     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 701
 702     FIXME("(%p)->(%p): stub\n", This, device);
 703
 704     return E_NOTIMPL;
 705 }
 706
 707 static HRESULT WINAPI ID3DXEffectImpl_OnLostDevice(ID3DXEffect* iface)
 708 {
 709     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 710
 711     FIXME("(%p)->(): stub\n", This);
 712
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI ID3DXEffectImpl_OnResetDevice(ID3DXEffect* iface)
 717 {
 718     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 719
 720     FIXME("(%p)->(): stub\n", This);
 721
 722     return E_NOTIMPL;
 723 }
 724
 725 static HRESULT WINAPI ID3DXEffectImpl_SetStateManager(ID3DXEffect* iface, LPD3DXEFFECTSTATEMANAGER manager)
 726 {
 727     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 728
 729     FIXME("(%p)->(%p): stub\n", This, manager);
 730
 731     return E_NOTIMPL;
 732 }
 733
 734 static HRESULT WINAPI ID3DXEffectImpl_GetStateManager(ID3DXEffect* iface, LPD3DXEFFECTSTATEMANAGER* manager)
 735 {
 736     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 737
 738     FIXME("(%p)->(%p): stub\n", This, manager);
 739
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI ID3DXEffectImpl_BeginParameterBlock(ID3DXEffect* iface)
 744 {
 745     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 746
 747     FIXME("(%p)->(): stub\n", This);
 748
 749     return E_NOTIMPL;
 750 }
 751
 752 static D3DXHANDLE WINAPI ID3DXEffectImpl_EndParameterBlock(ID3DXEffect* iface)
 753 {
 754     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 755
 756     FIXME("(%p)->(): stub\n", This);
 757
 758     return NULL;
 759 }
 760
 761 static HRESULT WINAPI ID3DXEffectImpl_ApplyParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
 762 {
 763     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 764
 765     FIXME("(%p)->(%p): stub\n", This, parameter_block);
 766
 767     return E_NOTIMPL;
 768 }
 769
 770 static HRESULT WINAPI ID3DXEffectImpl_DeleteParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
 771 {
 772     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 773
 774     FIXME("(%p)->(%p): stub\n", This, parameter_block);
 775
 776     return E_NOTIMPL;
 777 }
 778
 779 static HRESULT WINAPI ID3DXEffectImpl_CloneEffect(ID3DXEffect* iface, LPDIRECT3DDEVICE9 device, LPD3DXEFFECT* effect)
 780 {
 781     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 782
 783     FIXME("(%p)->(%p, %p): stub\n", This, device, effect);
 784
 785     return E_NOTIMPL;
 786 }
 787
 788 static HRESULT WINAPI ID3DXEffectImpl_SetRawValue(ID3DXEffect* iface, D3DXHANDLE parameter, LPCVOID data, UINT byte_offset, UINT bytes)
 789 {
 790     ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
 791
 792     FIXME("(%p)->(%p, %p, %u, %u): stub\n", This, parameter, data, byte_offset, bytes);
 793
 794     return E_NOTIMPL;
 795 }
 796
 797 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl =
 798 {
 799     /*** IUnknown methods ***/
 800     ID3DXEffectImpl_QueryInterface,
 801     ID3DXEffectImpl_AddRef,
 802     ID3DXEffectImpl_Release,
 803     /*** ID3DXBaseEffect methods ***/
 804     ID3DXEffectImpl_GetDesc,
 805     ID3DXEffectImpl_GetParameterDesc,
 806     ID3DXEffectImpl_GetTechniqueDesc,
 807     ID3DXEffectImpl_GetPassDesc,
 808     ID3DXEffectImpl_GetFunctionDesc,
 809     ID3DXEffectImpl_GetParameter,
 810     ID3DXEffectImpl_GetParameterByName,
 811     ID3DXEffectImpl_GetParameterBySemantic,
 812     ID3DXEffectImpl_GetParameterElement,
 813     ID3DXEffectImpl_GetTechnique,
 814     ID3DXEffectImpl_GetTechniqueByName,
 815     ID3DXEffectImpl_GetPass,
 816     ID3DXEffectImpl_GetPassByName,
 817     ID3DXEffectImpl_GetFunction,
 818     ID3DXEffectImpl_GetFunctionByName,
 819     ID3DXEffectImpl_GetAnnotation,
 820     ID3DXEffectImpl_GetAnnotationByName,
 821     ID3DXEffectImpl_SetValue,
 822     ID3DXEffectImpl_GetValue,
 823     ID3DXEffectImpl_SetBool,
 824     ID3DXEffectImpl_GetBool,
 825     ID3DXEffectImpl_SetBoolArray,
 826     ID3DXEffectImpl_GetBoolArray,
 827     ID3DXEffectImpl_SetInt,
 828     ID3DXEffectImpl_GetInt,
 829     ID3DXEffectImpl_SetIntArray,
 830     ID3DXEffectImpl_GetIntArray,
 831     ID3DXEffectImpl_SetFloat,
 832     ID3DXEffectImpl_GetFloat,
 833     ID3DXEffectImpl_SetFloatArray,
 834     ID3DXEffectImpl_GetFloatArray,
 835     ID3DXEffectImpl_SetVector,
 836     ID3DXEffectImpl_GetVector,
 837     ID3DXEffectImpl_SetVectorArray,
 838     ID3DXEffectImpl_GetVectorArray,
 839     ID3DXEffectImpl_SetMatrix,
 840     ID3DXEffectImpl_GetMatrix,
 841     ID3DXEffectImpl_SetMatrixArray,
 842     ID3DXEffectImpl_GetMatrixArray,
 843     ID3DXEffectImpl_SetMatrixPointerArray,
 844     ID3DXEffectImpl_GetMatrixPointerArray,
 845     ID3DXEffectImpl_SetMatrixTranspose,
 846     ID3DXEffectImpl_GetMatrixTranspose,
 847     ID3DXEffectImpl_SetMatrixTransposeArray,
 848     ID3DXEffectImpl_GetMatrixTransposeArray,
 849     ID3DXEffectImpl_SetMatrixTransposePointerArray,
 850     ID3DXEffectImpl_GetMatrixTransposePointerArray,
 851     ID3DXEffectImpl_SetString,
 852     ID3DXEffectImpl_GetString,
 853     ID3DXEffectImpl_SetTexture,
 854     ID3DXEffectImpl_GetTexture,
 855     ID3DXEffectImpl_GetPixelShader,
 856     ID3DXEffectImpl_GetVertexShader,
 857     ID3DXEffectImpl_SetArrayRange,
 858     /*** ID3DXEffect methods ***/
 859     ID3DXEffectImpl_GetPool,
 860     ID3DXEffectImpl_SetTechnique,
 861     ID3DXEffectImpl_GetCurrentTechnique,
 862     ID3DXEffectImpl_ValidateTechnique,
 863     ID3DXEffectImpl_FindNextValidTechnique,
 864     ID3DXEffectImpl_IsParameterUsed,
 865     ID3DXEffectImpl_Begin,
 866     ID3DXEffectImpl_BeginPass,
 867     ID3DXEffectImpl_CommitChanges,
 868     ID3DXEffectImpl_EndPass,
 869     ID3DXEffectImpl_End,
 870     ID3DXEffectImpl_GetDevice,
 871     ID3DXEffectImpl_OnLostDevice,
 872     ID3DXEffectImpl_OnResetDevice,
 873     ID3DXEffectImpl_SetStateManager,
 874     ID3DXEffectImpl_GetStateManager,
 875     ID3DXEffectImpl_BeginParameterBlock,
 876     ID3DXEffectImpl_EndParameterBlock,
 877     ID3DXEffectImpl_ApplyParameterBlock,
 878     ID3DXEffectImpl_DeleteParameterBlock,
 879     ID3DXEffectImpl_CloneEffect,
 880     ID3DXEffectImpl_SetRawValue
 881 };
 882
 883 static HRESULT d3dx9_parse_effect(ID3DXEffectImpl *effect, const char *data, UINT data_size, DWORD start)
 884 {
 885     const char *ptr = data + start;
 886
 887     read_dword(&ptr, &effect->parameter_count);
 888     TRACE("Parameter count: %u\n", effect->parameter_count);
 889
 890     read_dword(&ptr, &effect->technique_count);
 891     TRACE("Technique count: %u\n", effect->technique_count);
 892
 893     skip_dword_unknown(&ptr, 2);
 894
 895     /* todo: Parse parameter */
 896
 897     /* todo: Parse techniques */
 898
 899     return S_OK;
 900 }
 901
 902 static HRESULT d3dx9_effect_init(ID3DXEffectImpl *effect, const char *data, SIZE_T data_size)
 903 {
 904     DWORD tag, offset;
 905     const char *ptr = data;
 906     HRESULT hr;
 907
 908     effect->ID3DXEffect_iface.lpVtbl = &ID3DXEffect_Vtbl;
 909     effect->ref = 1;
 910
 911     read_dword(&ptr, &tag);
 912     TRACE("Tag: %x\n", tag);
 913
 914     if (tag != d3dx9_effect_version(9, 1))
 915     {
 916         /* todo: compile hlsl ascii code */
 917         FIXME("HLSL ascii effects not supported, yet\n");
 918
 919         /* Show the start of the shader for debugging info. */
 920         TRACE("effect:\n%s\n", debugstr_an(data, data_size > 40 ? 40 : data_size));
 921     }
 922     else
 923     {
 924         read_dword(&ptr, &offset);
 925         TRACE("Offset: %x\n", offset);
 926
 927         hr = d3dx9_parse_effect(effect, ptr, data_size, offset);
 928         if (hr != S_OK)
 929         {
 930             FIXME("Failed to parse effect.\n");
 931             return hr;
 932         }
 933     }
 934
 935     return S_OK;
 936 }
 937
 938 HRESULT WINAPI D3DXCreateEffectEx(LPDIRECT3DDEVICE9 device,
 939                                   LPCVOID srcdata,
 940                                   UINT srcdatalen,
 941                                   CONST D3DXMACRO* defines,
 942                                   LPD3DXINCLUDE include,
 943                                   LPCSTR skip_constants,
 944                                   DWORD flags,
 945                                   LPD3DXEFFECTPOOL pool,
 946                                   LPD3DXEFFECT* effect,
 947                                   LPD3DXBUFFER* compilation_errors)
 948 {
 949     ID3DXEffectImpl *object;
 950     HRESULT hr;
 951
 952     FIXME("(%p, %p, %u, %p, %p, %p, %#x, %p, %p, %p): semi-stub\n", device, srcdata, srcdatalen, defines, include,
 953         skip_constants, flags, pool, effect, compilation_errors);
 954
 955     if (!device || !srcdata)
 956         return D3DERR_INVALIDCALL;
 957
 958     if (!srcdatalen)
 959         return E_FAIL;
 960
 961     /* Native dll allows effect to be null so just return D3D_OK after doing basic checks */
 962     if (!effect)
 963         return D3D_OK;
 964
 965     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 966     if (!object)
 967     {
 968         ERR("Out of memory\n");
 969         return E_OUTOFMEMORY;
 970     }
 971
 972     hr = d3dx9_effect_init(object, srcdata, srcdatalen);
 973     if (FAILED(hr))
 974     {
 975         WARN("Failed to initialize shader reflection\n");
 976         HeapFree(GetProcessHeap(), 0, object);
 977         return hr;
 978     }
 979
 980     *effect = &object->ID3DXEffect_iface;
 981
 982     TRACE("Created ID3DXEffect %p\n", object);
 983
 984     return D3D_OK;
 985 }
 986
 987 HRESULT WINAPI D3DXCreateEffect(LPDIRECT3DDEVICE9 device,
 988                                 LPCVOID srcdata,
 989                                 UINT srcdatalen,
 990                                 CONST D3DXMACRO* defines,
 991                                 LPD3DXINCLUDE include,
 992                                 DWORD flags,
 993                                 LPD3DXEFFECTPOOL pool,
 994                                 LPD3DXEFFECT* effect,
 995                                 LPD3DXBUFFER* compilation_errors)
 996 {
 997     TRACE("(%p, %p, %u, %p, %p, %#x, %p, %p, %p): Forwarded to D3DXCreateEffectEx\n", device, srcdata, srcdatalen, defines,
 998         include, flags, pool, effect, compilation_errors);
 999
1000     return D3DXCreateEffectEx(device, srcdata, srcdatalen, defines, include, NULL, flags, pool, effect, compilation_errors);
1001 }
1002
1003 HRESULT WINAPI D3DXCreateEffectCompiler(LPCSTR srcdata,
1004                                         UINT srcdatalen,
1005                                         CONST D3DXMACRO* defines,
1006                                         LPD3DXINCLUDE include,
1007                                         DWORD flags,
1008                                         LPD3DXEFFECTCOMPILER* compiler,
1009                                         LPD3DXBUFFER* parse_errors)
1010 {
1011     FIXME("(%p, %u, %p, %p, %#x, %p, %p): stub\n", srcdata, srcdatalen, defines, include, flags, compiler, parse_errors);
1012
1013     return E_NOTIMPL;
1014 }
1015
1016 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl;
1017
1018 typedef struct ID3DXEffectPoolImpl {
1019     ID3DXEffectPool ID3DXEffectPool_iface;
1020     LONG ref;
1021 } ID3DXEffectPoolImpl;
1022
1023 static inline ID3DXEffectPoolImpl *impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
1024 {
1025     return CONTAINING_RECORD(iface, ID3DXEffectPoolImpl, ID3DXEffectPool_iface);
1026 }
1027
1028 /*** IUnknown methods ***/
1029 static HRESULT WINAPI ID3DXEffectPoolImpl_QueryInterface(ID3DXEffectPool* iface, REFIID riid, void** object)
1030 {
1031     ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
1032
1033     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
1034
1035     if (IsEqualGUID(riid, &IID_IUnknown) ||
1036         IsEqualGUID(riid, &IID_ID3DXEffectPool))
1037     {
1038         This->ID3DXEffectPool_iface.lpVtbl->AddRef(iface);
1039         *object = This;
1040         return S_OK;
1041     }
1042
1043     WARN("Interface %s not found\n", debugstr_guid(riid));
1044
1045     return E_NOINTERFACE;
1046 }
1047
1048 static ULONG WINAPI ID3DXEffectPoolImpl_AddRef(ID3DXEffectPool* iface)
1049 {
1050     ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
1051
1052     TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
1053
1054     return InterlockedIncrement(&This->ref);
1055 }
1056
1057 static ULONG WINAPI ID3DXEffectPoolImpl_Release(ID3DXEffectPool* iface)
1058 {
1059     ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
1060     ULONG ref = InterlockedDecrement(&This->ref);
1061
1062     TRACE("(%p)->(): Release from %u\n", This, ref + 1);
1063
1064     if (!ref)
1065         HeapFree(GetProcessHeap(), 0, This);
1066
1067     return ref;
1068 }
1069
1070 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl =
1071 {
1072     /*** IUnknown methods ***/
1073     ID3DXEffectPoolImpl_QueryInterface,
1074     ID3DXEffectPoolImpl_AddRef,
1075     ID3DXEffectPoolImpl_Release
1076 };
1077
1078 HRESULT WINAPI D3DXCreateEffectPool(LPD3DXEFFECTPOOL* pool)
1079 {
1080     ID3DXEffectPoolImpl* object;
1081
1082     TRACE("(%p)\n", pool);
1083
1084     if (!pool)
1085         return D3DERR_INVALIDCALL;
1086
1087     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1088     if (!object)
1089     {
1090         ERR("Out of memory\n");
1091         return E_OUTOFMEMORY;
1092     }
1093
1094     object->ID3DXEffectPool_iface.lpVtbl = &ID3DXEffectPool_Vtbl;
1095     object->ref = 1;
1096
1097     *pool = &object->ID3DXEffectPool_iface;
1098
1099     return S_OK;
1100 }
1101
1102 HRESULT WINAPI D3DXCreateEffectFromFileExW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
1103     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
1104     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
1105 {
1106     LPVOID buffer;
1107     HRESULT ret;
1108     DWORD size;
1109
1110     TRACE("(%s): relay\n", debugstr_w(srcfile));
1111
1112     if (!device || !srcfile || !defines)
1113         return D3DERR_INVALIDCALL;
1114
1115     ret = map_view_of_file(srcfile, &buffer, &size);
1116
1117     if (FAILED(ret))
1118         return D3DXERR_INVALIDDATA;
1119
1120     ret = D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
1121     UnmapViewOfFile(buffer);
1122
1123     return ret;
1124 }
1125
1126 HRESULT WINAPI D3DXCreateEffectFromFileExA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
1127     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
1128     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
1129 {
1130     LPWSTR srcfileW;
1131     HRESULT ret;
1132     DWORD len;
1133
1134     TRACE("(void): relay\n");
1135
1136     if (!srcfile || !defines)
1137         return D3DERR_INVALIDCALL;
1138
1139     len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
1140     srcfileW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(*srcfileW));
1141     MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
1142
1143     ret = D3DXCreateEffectFromFileExW(device, srcfileW, defines, include, skipconstants, flags, pool, effect, compilationerrors);
1144     HeapFree(GetProcessHeap(), 0, srcfileW);
1145
1146     return ret;
1147 }
1148
1149 HRESULT WINAPI D3DXCreateEffectFromFileW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
1150     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
1151     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
1152 {
1153     TRACE("(void): relay\n");
1154     return D3DXCreateEffectFromFileExW(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
1155 }
1156
1157 HRESULT WINAPI D3DXCreateEffectFromFileA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
1158     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
1159     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
1160 {
1161     TRACE("(void): relay\n");
1162     return D3DXCreateEffectFromFileExA(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
1163 }
1164
1165 HRESULT WINAPI D3DXCreateEffectFromResourceExW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
1166     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
1167     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
1168 {
1169     HRSRC resinfo;
1170
1171     TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
1172
1173     if (!device || !defines)
1174         return D3DERR_INVALIDCALL;
1175
1176     resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
1177
1178     if (resinfo)
1179     {
1180         LPVOID buffer;
1181         HRESULT ret;
1182         DWORD size;
1183
1184         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
1185
1186         if (FAILED(ret))
1187             return D3DXERR_INVALIDDATA;
1188
1189         return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
1190     }
1191
1192     return D3DXERR_INVALIDDATA;
1193 }
1194
1195 HRESULT WINAPI D3DXCreateEffectFromResourceExA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
1196     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
1197     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
1198 {
1199     HRSRC resinfo;
1200
1201     TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
1202
1203     if (!device || !defines)
1204         return D3DERR_INVALIDCALL;
1205
1206     resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
1207
1208     if (resinfo)
1209     {
1210         LPVOID buffer;
1211         HRESULT ret;
1212         DWORD size;
1213
1214         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
1215
1216         if (FAILED(ret))
1217             return D3DXERR_INVALIDDATA;
1218
1219         return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
1220     }
1221
1222     return D3DXERR_INVALIDDATA;
1223 }
1224
1225 HRESULT WINAPI D3DXCreateEffectFromResourceW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
1226     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
1227     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
1228 {
1229     TRACE("(void): relay\n");
1230     return D3DXCreateEffectFromResourceExW(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
1231 }
1232
1233 HRESULT WINAPI D3DXCreateEffectFromResourceA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
1234     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
1235     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
1236 {
1237     TRACE("(void): relay\n");
1238     return D3DXCreateEffectFromResourceExA(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
1239 }
1240
1241 HRESULT WINAPI D3DXCreateEffectCompilerFromFileW(LPCWSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
1242     DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
1243 {
1244     LPVOID buffer;
1245     HRESULT ret;
1246     DWORD size;
1247
1248     TRACE("(%s): relay\n", debugstr_w(srcfile));
1249
1250     if (!srcfile || !defines)
1251         return D3DERR_INVALIDCALL;
1252
1253     ret = map_view_of_file(srcfile, &buffer, &size);
1254
1255     if (FAILED(ret))
1256         return D3DXERR_INVALIDDATA;
1257
1258     ret = D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
1259     UnmapViewOfFile(buffer);
1260
1261     return ret;
1262 }
1263
1264 HRESULT WINAPI D3DXCreateEffectCompilerFromFileA(LPCSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
1265     DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
1266 {
1267     LPWSTR srcfileW;
1268     HRESULT ret;
1269     DWORD len;
1270
1271     TRACE("(void): relay\n");
1272
1273     if (!srcfile || !defines)
1274         return D3DERR_INVALIDCALL;
1275
1276     len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
1277     srcfileW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(*srcfileW));
1278     MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
1279
1280     ret = D3DXCreateEffectCompilerFromFileW(srcfileW, defines, include, flags, effectcompiler, parseerrors);
1281     HeapFree(GetProcessHeap(), 0, srcfileW);
1282
1283     return ret;
1284 }
1285
1286 HRESULT WINAPI D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule, LPCSTR srcresource, const D3DXMACRO *defines,
1287     LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
1288 {
1289     HRSRC resinfo;
1290
1291     TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
1292
1293     resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
1294
1295     if (resinfo)
1296     {
1297         LPVOID buffer;
1298         HRESULT ret;
1299         DWORD size;
1300
1301         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
1302
1303         if (FAILED(ret))
1304             return D3DXERR_INVALIDDATA;
1305
1306         return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
1307     }
1308
1309     return D3DXERR_INVALIDDATA;
1310 }
1311
1312 HRESULT WINAPI D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule, LPCWSTR srcresource, const D3DXMACRO *defines,
1313     LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
1314 {
1315     HRSRC resinfo;
1316
1317     TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
1318
1319     resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
1320
1321     if (resinfo)
1322     {
1323         LPVOID buffer;
1324         HRESULT ret;
1325         DWORD size;
1326
1327         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
1328
1329         if (FAILED(ret))
1330             return D3DXERR_INVALIDDATA;
1331
1332         return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
1333     }
1334
1335     return D3DXERR_INVALIDDATA;
1336 }