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 static const struct ID3DXBaseEffectVtbl ID3DXBaseEffect_Vtbl;
  31 static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl;
  32
  33 struct d3dx_parameter
  34 {
  35     struct ID3DXBaseEffectImpl *base;
  36
  37     char *name;
  38     char *semantic;
  39     void *data;
  40     D3DXPARAMETER_CLASS class;
  41     D3DXPARAMETER_TYPE  type;
  42     UINT rows;
  43     UINT columns;
  44     UINT element_count;
  45     UINT annotation_count;
  46     UINT member_count;
  47     DWORD flags;
  48     UINT bytes;
  49
  50     D3DXHANDLE *annotation_handles;
  51     D3DXHANDLE *member_handles;
  52 };
  53
  54 struct d3dx_pass
  55 {
  56     struct ID3DXBaseEffectImpl *base;
  57
  58     char *name;
  59     UINT state_count;
  60     UINT annotation_count;
  61
  62     D3DXHANDLE *annotation_handles;
  63 };
  64
  65 struct d3dx_technique
  66 {
  67     struct ID3DXBaseEffectImpl *base;
  68
  69     char *name;
  70     UINT pass_count;
  71     UINT annotation_count;
  72
  73     D3DXHANDLE *annotation_handles;
  74     D3DXHANDLE *pass_handles;
  75 };
  76
  77 struct ID3DXBaseEffectImpl
  78 {
  79     ID3DXBaseEffect ID3DXBaseEffect_iface;
  80     LONG ref;
  81
  82     struct ID3DXEffectImpl *effect;
  83
  84     UINT parameter_count;
  85     UINT technique_count;
  86
  87     D3DXHANDLE *parameter_handles;
  88     D3DXHANDLE *technique_handles;
  89 };
  90
  91 struct ID3DXEffectImpl
  92 {
  93     ID3DXEffect ID3DXEffect_iface;
  94     LONG ref;
  95
  96     LPDIRECT3DDEVICE9 device;
  97     LPD3DXEFFECTPOOL pool;
  98
  99     ID3DXBaseEffect *base_effect;
 100 };
 101
 102 struct ID3DXEffectCompilerImpl
 103 {
 104     ID3DXEffectCompiler ID3DXEffectCompiler_iface;
 105     LONG ref;
 106
 107     ID3DXBaseEffect *base_effect;
 108 };
 109
 110 static inline void read_dword(const char **ptr, DWORD *d)
 111 {
 112     memcpy(d, *ptr, sizeof(*d));
 113     *ptr += sizeof(*d);
 114 }
 115
 116 static void skip_dword_unknown(const char **ptr, unsigned int count)
 117 {
 118     unsigned int i;
 119     DWORD d;
 120
 121     FIXME("Skipping %u unknown DWORDs:\n", count);
 122     for (i = 0; i < count; ++i)
 123     {
 124         read_dword(ptr, &d);
 125         FIXME("\t0x%08x\n", d);
 126     }
 127 }
 128
 129 static inline struct d3dx_parameter *get_parameter_struct(D3DXHANDLE handle)
 130 {
 131     return (struct d3dx_parameter *) handle;
 132 }
 133
 134 static inline struct d3dx_pass *get_pass_struct(D3DXHANDLE handle)
 135 {
 136     return (struct d3dx_pass *) handle;
 137 }
 138
 139 static inline struct d3dx_technique *get_technique_struct(D3DXHANDLE handle)
 140 {
 141     return (struct d3dx_technique *) handle;
 142 }
 143
 144 static inline D3DXHANDLE get_parameter_handle(struct d3dx_parameter *parameter)
 145 {
 146     return (D3DXHANDLE) parameter;
 147 }
 148
 149 static inline D3DXHANDLE get_technique_handle(struct d3dx_technique *technique)
 150 {
 151     return (D3DXHANDLE) technique;
 152 }
 153
 154 static inline D3DXHANDLE get_pass_handle(struct d3dx_pass *pass)
 155 {
 156     return (D3DXHANDLE) pass;
 157 }
 158
 159 struct d3dx_technique *is_valid_technique(struct ID3DXBaseEffectImpl *base, D3DXHANDLE technique)
 160 {
 161     unsigned int i;
 162
 163     for (i = 0; i < base->technique_count; ++i)
 164     {
 165         if (base->technique_handles[i] == technique)
 166         {
 167             return get_technique_struct(technique);
 168         }
 169     }
 170
 171     return NULL;
 172 }
 173
 174 struct d3dx_parameter *is_valid_sub_parameter(struct d3dx_parameter *param, D3DXHANDLE parameter)
 175 {
 176     unsigned int i, count;
 177     struct d3dx_parameter *p;
 178
 179     for (i = 0; i < param->annotation_count; ++i)
 180     {
 181         if (param->annotation_handles[i] == parameter)
 182         {
 183             return get_parameter_struct(parameter);
 184         }
 185
 186         p = is_valid_sub_parameter(get_parameter_struct(param->annotation_handles[i]), parameter);
 187         if (p) return p;
 188     }
 189
 190     if (param->element_count) count = param->element_count;
 191     else count = param->member_count;
 192
 193     for (i = 0; i < count; ++i)
 194     {
 195         if (param->member_handles[i] == parameter)
 196         {
 197             return get_parameter_struct(parameter);
 198         }
 199
 200         p = is_valid_sub_parameter(get_parameter_struct(param->member_handles[i]), parameter);
 201         if (p) return p;
 202     }
 203
 204     return NULL;
 205 }
 206
 207 struct d3dx_parameter *is_valid_parameter(struct ID3DXBaseEffectImpl *base, D3DXHANDLE parameter)
 208 {
 209     unsigned int i, k, m;
 210     struct d3dx_parameter *p;
 211
 212     for (i = 0; i < base->parameter_count; ++i)
 213     {
 214         if (base->parameter_handles[i] == parameter)
 215         {
 216             return get_parameter_struct(parameter);
 217         }
 218
 219         p = is_valid_sub_parameter(get_parameter_struct(base->parameter_handles[i]), parameter);
 220         if (p) return p;
 221     }
 222
 223     for (i = 0; i < base->technique_count; ++i)
 224     {
 225         struct d3dx_technique *technique = get_technique_struct(base->technique_handles[i]);
 226
 227         for (k = 0; k < technique->pass_count; ++k)
 228         {
 229             struct d3dx_pass *pass = get_pass_struct(technique->pass_handles[k]);
 230
 231             for (m = 0; m < pass->annotation_count; ++m)
 232             {
 233                 if (pass->annotation_handles[i] == parameter)
 234                 {
 235                     return get_parameter_struct(parameter);
 236                 }
 237
 238                 p = is_valid_sub_parameter(get_parameter_struct(pass->annotation_handles[m]), parameter);
 239                 if (p) return p;
 240             }
 241         }
 242
 243         for (k = 0; k < technique->annotation_count; ++k)
 244         {
 245             if (technique->annotation_handles[k] == parameter)
 246             {
 247                 return get_parameter_struct(parameter);
 248             }
 249
 250             p = is_valid_sub_parameter(get_parameter_struct(technique->annotation_handles[k]), parameter);
 251             if (p) return p;
 252         }
 253     }
 254
 255     return NULL;
 256 }
 257
 258 static void free_parameter(D3DXHANDLE handle, BOOL element, BOOL child)
 259 {
 260     unsigned int i;
 261     struct d3dx_parameter *param = get_parameter_struct(handle);
 262
 263     TRACE("Free parameter %p, child %s\n", param, child ? "yes" : "no");
 264
 265     if (!param)
 266     {
 267         return;
 268     }
 269
 270     if (!child)
 271     {
 272         HeapFree(GetProcessHeap(), 0, param->data);
 273     }
 274
 275     if (param->annotation_handles)
 276     {
 277         for (i = 0; i < param->annotation_count; ++i)
 278         {
 279             free_parameter(param->annotation_handles[i], FALSE, FALSE);
 280         }
 281         HeapFree(GetProcessHeap(), 0, param->annotation_handles);
 282     }
 283
 284     if (param->member_handles)
 285     {
 286         unsigned int count;
 287
 288         if (param->element_count) count = param->element_count;
 289         else count = param->member_count;
 290
 291         for (i = 0; i < count; ++i)
 292         {
 293             free_parameter(param->member_handles[i], param->element_count != 0, TRUE);
 294         }
 295         HeapFree(GetProcessHeap(), 0, param->member_handles);
 296     }
 297
 298     /* only the parent has to release name and semantic */
 299     if (!element)
 300     {
 301         HeapFree(GetProcessHeap(), 0, param->name);
 302         HeapFree(GetProcessHeap(), 0, param->semantic);
 303     }
 304
 305     HeapFree(GetProcessHeap(), 0, param);
 306 }
 307
 308 static void free_pass(D3DXHANDLE handle)
 309 {
 310     unsigned int i;
 311     struct d3dx_pass *pass = get_pass_struct(handle);
 312
 313     TRACE("Free pass %p\n", pass);
 314
 315     if (!pass)
 316     {
 317         return;
 318     }
 319
 320     if (pass->annotation_handles)
 321     {
 322         for (i = 0; i < pass->annotation_count; ++i)
 323         {
 324             free_parameter(pass->annotation_handles[i], FALSE, FALSE);
 325         }
 326         HeapFree(GetProcessHeap(), 0, pass->annotation_handles);
 327     }
 328
 329     HeapFree(GetProcessHeap(), 0, pass->name);
 330     HeapFree(GetProcessHeap(), 0, pass);
 331 }
 332
 333 static void free_technique(D3DXHANDLE handle)
 334 {
 335     unsigned int i;
 336     struct d3dx_technique *technique = get_technique_struct(handle);
 337
 338     TRACE("Free technique %p\n", technique);
 339
 340     if (!technique)
 341     {
 342         return;
 343     }
 344
 345     if (technique->annotation_handles)
 346     {
 347         for (i = 0; i < technique->annotation_count; ++i)
 348         {
 349             free_parameter(technique->annotation_handles[i], FALSE, FALSE);
 350         }
 351         HeapFree(GetProcessHeap(), 0, technique->annotation_handles);
 352     }
 353
 354     if (technique->pass_handles)
 355     {
 356         for (i = 0; i < technique->pass_count; ++i)
 357         {
 358             free_pass(technique->pass_handles[i]);
 359         }
 360         HeapFree(GetProcessHeap(), 0, technique->pass_handles);
 361     }
 362
 363     HeapFree(GetProcessHeap(), 0, technique->name);
 364     HeapFree(GetProcessHeap(), 0, technique);
 365 }
 366
 367 static void free_base_effect(struct ID3DXBaseEffectImpl *base)
 368 {
 369     unsigned int i;
 370
 371     TRACE("Free base effect %p\n", base);
 372
 373     if (base->parameter_handles)
 374     {
 375         for (i = 0; i < base->parameter_count; ++i)
 376         {
 377             free_parameter(base->parameter_handles[i], FALSE, FALSE);
 378         }
 379         HeapFree(GetProcessHeap(), 0, base->parameter_handles);
 380     }
 381
 382     if (base->technique_handles)
 383     {
 384         for (i = 0; i < base->technique_count; ++i)
 385         {
 386             free_technique(base->technique_handles[i]);
 387         }
 388         HeapFree(GetProcessHeap(), 0, base->technique_handles);
 389     }
 390 }
 391
 392 static void free_effect(struct ID3DXEffectImpl *effect)
 393 {
 394     TRACE("Free effect %p\n", effect);
 395
 396     if (effect->base_effect)
 397     {
 398         effect->base_effect->lpVtbl->Release(effect->base_effect);
 399     }
 400
 401     if (effect->pool)
 402     {
 403         effect->pool->lpVtbl->Release(effect->pool);
 404     }
 405
 406     IDirect3DDevice9_Release(effect->device);
 407 }
 408
 409 static void free_effect_compiler(struct ID3DXEffectCompilerImpl *compiler)
 410 {
 411     TRACE("Free effect compiler %p\n", compiler);
 412
 413     if (compiler->base_effect)
 414     {
 415         compiler->base_effect->lpVtbl->Release(compiler->base_effect);
 416     }
 417 }
 418
 419 static inline DWORD d3dx9_effect_version(DWORD major, DWORD minor)
 420 {
 421     return (0xfeff0000 | ((major) << 8) | (minor));
 422 }
 423
 424 static inline struct ID3DXBaseEffectImpl *impl_from_ID3DXBaseEffect(ID3DXBaseEffect *iface)
 425 {
 426     return CONTAINING_RECORD(iface, struct ID3DXBaseEffectImpl, ID3DXBaseEffect_iface);
 427 }
 428
 429 /*** IUnknown methods ***/
 430 static HRESULT WINAPI ID3DXBaseEffectImpl_QueryInterface(ID3DXBaseEffect *iface, REFIID riid, void **object)
 431 {
 432     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 433
 434     TRACE("iface %p, riid %s, object %p\n", This, debugstr_guid(riid), object);
 435
 436     if (IsEqualGUID(riid, &IID_IUnknown) ||
 437         IsEqualGUID(riid, &IID_ID3DXBaseEffect))
 438     {
 439         This->ID3DXBaseEffect_iface.lpVtbl->AddRef(iface);
 440         *object = This;
 441         return S_OK;
 442     }
 443
 444     ERR("Interface %s not found\n", debugstr_guid(riid));
 445
 446     return E_NOINTERFACE;
 447 }
 448
 449 static ULONG WINAPI ID3DXBaseEffectImpl_AddRef(ID3DXBaseEffect *iface)
 450 {
 451     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 452
 453     TRACE("iface %p: AddRef from %u\n", iface, This->ref);
 454
 455     return InterlockedIncrement(&This->ref);
 456 }
 457
 458 static ULONG WINAPI ID3DXBaseEffectImpl_Release(ID3DXBaseEffect *iface)
 459 {
 460     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 461     ULONG ref = InterlockedDecrement(&This->ref);
 462
 463     TRACE("iface %p: Release from %u\n", iface, ref + 1);
 464
 465     if (!ref)
 466     {
 467         free_base_effect(This);
 468         HeapFree(GetProcessHeap(), 0, This);
 469     }
 470
 471     return ref;
 472 }
 473
 474 /*** ID3DXBaseEffect methods ***/
 475 static HRESULT WINAPI ID3DXBaseEffectImpl_GetDesc(ID3DXBaseEffect *iface, D3DXEFFECT_DESC *desc)
 476 {
 477     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 478
 479     FIXME("iface %p, desc %p stub\n", This, desc);
 480
 481     return E_NOTIMPL;
 482 }
 483
 484 static HRESULT WINAPI ID3DXBaseEffectImpl_GetParameterDesc(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
 485 {
 486     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 487
 488     FIXME("iface %p, parameter %p, desc %p stub\n", This, parameter, desc);
 489
 490     return E_NOTIMPL;
 491 }
 492
 493 static HRESULT WINAPI ID3DXBaseEffectImpl_GetTechniqueDesc(ID3DXBaseEffect *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
 494 {
 495     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 496     struct d3dx_technique *tech = technique ? is_valid_technique(This, technique) : get_technique_struct(This->technique_handles[0]);
 497
 498     TRACE("iface %p, technique %p, desc %p\n", This, technique, desc);
 499
 500     if (!desc || !tech)
 501     {
 502         WARN("Invalid argument specified.\n");
 503         return D3DERR_INVALIDCALL;
 504     }
 505
 506     desc->Name = tech->name;
 507     desc->Passes = tech->pass_count;
 508     desc->Annotations = tech->annotation_count;
 509
 510     return D3D_OK;
 511 }
 512
 513 static HRESULT WINAPI ID3DXBaseEffectImpl_GetPassDesc(ID3DXBaseEffect *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
 514 {
 515     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 516
 517     FIXME("iface %p, pass %p, desc %p stub\n", This, pass, desc);
 518
 519     return E_NOTIMPL;
 520 }
 521
 522 static HRESULT WINAPI ID3DXBaseEffectImpl_GetFunctionDesc(ID3DXBaseEffect *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
 523 {
 524     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 525
 526     FIXME("iface %p, shader %p, desc %p stub\n", This, shader, desc);
 527
 528     return E_NOTIMPL;
 529 }
 530
 531 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameter(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT index)
 532 {
 533     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 534
 535     TRACE("iface %p, parameter %p, index %u\n", This, parameter, index);
 536
 537     if (!parameter)
 538     {
 539         if (index < This->parameter_count)
 540         {
 541             TRACE("Returning parameter %p\n", This->parameter_handles[index]);
 542             return This->parameter_handles[index];
 543         }
 544     }
 545     else
 546     {
 547         struct d3dx_parameter *param = is_valid_parameter(This, parameter);
 548
 549         if (param && !param->element_count && index < param->member_count)
 550         {
 551             TRACE("Returning parameter %p\n", param->member_handles[index]);
 552             return param->member_handles[index];
 553         }
 554     }
 555
 556     WARN("Invalid argument specified.\n");
 557
 558     return NULL;
 559 }
 560
 561 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameterByName(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR name)
 562 {
 563     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 564
 565     FIXME("iface %p, parameter %p, name %s stub\n", This, parameter, debugstr_a(name));
 566
 567     return NULL;
 568 }
 569
 570 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameterBySemantic(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR semantic)
 571 {
 572     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 573
 574     FIXME("iface %p, parameter %p, semantic %s stub\n", This, parameter, debugstr_a(semantic));
 575
 576     return NULL;
 577 }
 578
 579 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameterElement(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT index)
 580 {
 581     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 582
 583     FIXME("iface %p, parameter %p, index %u stub\n", This, parameter, index);
 584
 585     return NULL;
 586 }
 587
 588 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetTechnique(ID3DXBaseEffect *iface, UINT index)
 589 {
 590     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 591
 592     TRACE("iface %p, index %u\n", This, index);
 593
 594     if (index >= This->technique_count)
 595     {
 596         WARN("Invalid argument specified.\n");
 597         return NULL;
 598     }
 599
 600     TRACE("Returning technique %p\n", This->technique_handles[index]);
 601
 602     return This->technique_handles[index];
 603 }
 604
 605 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetTechniqueByName(ID3DXBaseEffect *iface, LPCSTR name)
 606 {
 607     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 608     unsigned int i;
 609
 610     TRACE("iface %p, name %s stub\n", This, debugstr_a(name));
 611
 612     if (!name)
 613     {
 614         WARN("Invalid argument specified.\n");
 615         return NULL;
 616     }
 617
 618     for (i = 0; i < This->technique_count; ++i)
 619     {
 620         struct d3dx_technique *tech = get_technique_struct(This->technique_handles[i]);
 621
 622         if (!strcmp(tech->name, name))
 623         {
 624             TRACE("Returning technique %p\n", This->technique_handles[i]);
 625             return This->technique_handles[i];
 626         }
 627     }
 628
 629     WARN("Invalid argument specified.\n");
 630
 631     return NULL;
 632 }
 633
 634 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetPass(ID3DXBaseEffect *iface, D3DXHANDLE technique, UINT index)
 635 {
 636     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 637
 638     FIXME("iface %p, technique %p, index %u stub\n", This, technique, index);
 639
 640     return NULL;
 641 }
 642
 643 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetPassByName(ID3DXBaseEffect *iface, D3DXHANDLE technique, LPCSTR name)
 644 {
 645     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 646
 647     FIXME("iface %p, technique %p, name %s stub\n", This, technique, debugstr_a(name));
 648
 649     return NULL;
 650 }
 651
 652 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetFunction(ID3DXBaseEffect *iface, UINT index)
 653 {
 654     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 655
 656     FIXME("iface %p, index %u stub\n", This, index);
 657
 658     return NULL;
 659 }
 660
 661 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetFunctionByName(ID3DXBaseEffect *iface, LPCSTR name)
 662 {
 663     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 664
 665     FIXME("iface %p, name %s stub\n", This, debugstr_a(name));
 666
 667     return NULL;
 668 }
 669
 670 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetAnnotation(ID3DXBaseEffect *iface, D3DXHANDLE object, UINT index)
 671 {
 672     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 673
 674     FIXME("iface %p, object %p, index %u stub\n", This, object, index);
 675
 676     return NULL;
 677 }
 678
 679 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetAnnotationByName(ID3DXBaseEffect *iface, D3DXHANDLE object, LPCSTR name)
 680 {
 681     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 682
 683     FIXME("iface %p, object %p, name %s stub\n", This, object, debugstr_a(name));
 684
 685     return NULL;
 686 }
 687
 688 static HRESULT WINAPI ID3DXBaseEffectImpl_SetValue(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
 689 {
 690     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 691
 692     FIXME("iface %p, parameter %p, data %p, bytes %u stub\n", This, parameter, data, bytes);
 693
 694     return E_NOTIMPL;
 695 }
 696
 697 static HRESULT WINAPI ID3DXBaseEffectImpl_GetValue(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
 698 {
 699     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 700
 701     FIXME("iface %p, parameter %p, data %p, bytes %u stub\n", This, parameter, data, bytes);
 702
 703     return E_NOTIMPL;
 704 }
 705
 706 static HRESULT WINAPI ID3DXBaseEffectImpl_SetBool(ID3DXBaseEffect *iface, D3DXHANDLE parameter, BOOL b)
 707 {
 708     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 709
 710     FIXME("iface %p, parameter %p, b %u stub\n", This, parameter, b);
 711
 712     return E_NOTIMPL;
 713 }
 714
 715 static HRESULT WINAPI ID3DXBaseEffectImpl_GetBool(ID3DXBaseEffect *iface, D3DXHANDLE parameter, BOOL *b)
 716 {
 717     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 718
 719     FIXME("iface %p, parameter %p, b %p stub\n", This, parameter, b);
 720
 721     return E_NOTIMPL;
 722 }
 723
 724 static HRESULT WINAPI ID3DXBaseEffectImpl_SetBoolArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
 725 {
 726     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 727
 728     FIXME("iface %p, parameter %p, b %p, count %u stub\n", This, parameter, b, count);
 729
 730     return E_NOTIMPL;
 731 }
 732
 733 static HRESULT WINAPI ID3DXBaseEffectImpl_GetBoolArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
 734 {
 735     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 736
 737     FIXME("iface %p, parameter %p, b %p, count %u stub\n", This, parameter, b, count);
 738
 739     return E_NOTIMPL;
 740 }
 741
 742 static HRESULT WINAPI ID3DXBaseEffectImpl_SetInt(ID3DXBaseEffect *iface, D3DXHANDLE parameter, INT n)
 743 {
 744     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 745
 746     FIXME("iface %p, parameter %p, n %u stub\n", This, parameter, n);
 747
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI ID3DXBaseEffectImpl_GetInt(ID3DXBaseEffect *iface, D3DXHANDLE parameter, INT *n)
 752 {
 753     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 754
 755     FIXME("iface %p, parameter %p, n %p stub\n", This, parameter, n);
 756
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI ID3DXBaseEffectImpl_SetIntArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
 761 {
 762     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 763
 764     FIXME("iface %p, parameter %p, n %p, count %u stub\n", This, parameter, n, count);
 765
 766     return E_NOTIMPL;
 767 }
 768
 769 static HRESULT WINAPI ID3DXBaseEffectImpl_GetIntArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, INT *n, UINT count)
 770 {
 771     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 772
 773     FIXME("iface %p, parameter %p, n %p, count %u stub\n", This, parameter, n, count);
 774
 775     return E_NOTIMPL;
 776 }
 777
 778 static HRESULT WINAPI ID3DXBaseEffectImpl_SetFloat(ID3DXBaseEffect *iface, D3DXHANDLE parameter, FLOAT f)
 779 {
 780     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 781
 782     FIXME("iface %p, parameter %p, f %f stub\n", This, parameter, f);
 783
 784     return E_NOTIMPL;
 785 }
 786
 787 static HRESULT WINAPI ID3DXBaseEffectImpl_GetFloat(ID3DXBaseEffect *iface, D3DXHANDLE parameter, FLOAT *f)
 788 {
 789     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 790
 791     FIXME("iface %p, parameter %p, f %p stub\n", This, parameter, f);
 792
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI ID3DXBaseEffectImpl_SetFloatArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
 797 {
 798     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 799
 800     FIXME("iface %p, parameter %p, f %p, count %u stub\n", This, parameter, f, count);
 801
 802     return E_NOTIMPL;
 803 }
 804
 805 static HRESULT WINAPI ID3DXBaseEffectImpl_GetFloatArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
 806 {
 807     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 808
 809     FIXME("iface %p, parameter %p, f %p, count %u stub\n", This, parameter, f, count);
 810
 811     return E_NOTIMPL;
 812 }
 813
 814 static HRESULT WINAPI ID3DXBaseEffectImpl_SetVector(ID3DXBaseEffect* iface, D3DXHANDLE parameter, CONST D3DXVECTOR4* vector)
 815 {
 816     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 817
 818     FIXME("iface %p, parameter %p, vector %p stub\n", This, parameter, vector);
 819
 820     return E_NOTIMPL;
 821 }
 822
 823 static HRESULT WINAPI ID3DXBaseEffectImpl_GetVector(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
 824 {
 825     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 826
 827     FIXME("iface %p, parameter %p, vector %p stub\n", This, parameter, vector);
 828
 829     return E_NOTIMPL;
 830 }
 831
 832 static HRESULT WINAPI ID3DXBaseEffectImpl_SetVectorArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
 833 {
 834     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 835
 836     FIXME("iface %p, parameter %p, vector %p, count %u stub\n", This, parameter, vector, count);
 837
 838     return E_NOTIMPL;
 839 }
 840
 841 static HRESULT WINAPI ID3DXBaseEffectImpl_GetVectorArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
 842 {
 843     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 844
 845     FIXME("iface %p, parameter %p, vector %p, count %u stub\n", This, parameter, vector, count);
 846
 847     return E_NOTIMPL;
 848 }
 849
 850 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrix(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
 851 {
 852     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 853
 854     FIXME("iface %p, parameter %p, matrix %p stub\n", This, parameter, matrix);
 855
 856     return E_NOTIMPL;
 857 }
 858
 859 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrix(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
 860 {
 861     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 862
 863     FIXME("iface %p, parameter %p, matrix %p stub\n", This, parameter, matrix);
 864
 865     return E_NOTIMPL;
 866 }
 867
 868 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
 869 {
 870     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 871
 872     FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
 873
 874     return E_NOTIMPL;
 875 }
 876
 877 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
 878 {
 879     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 880
 881     FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
 882
 883     return E_NOTIMPL;
 884 }
 885
 886 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixPointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
 887 {
 888     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 889
 890     FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
 891
 892     return E_NOTIMPL;
 893 }
 894
 895 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixPointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
 896 {
 897     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 898
 899     FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
 900
 901     return E_NOTIMPL;
 902 }
 903
 904 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixTranspose(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
 905 {
 906     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 907
 908     FIXME("iface %p, parameter %p, matrix %p stub\n", This, parameter, matrix);
 909
 910     return E_NOTIMPL;
 911 }
 912
 913 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixTranspose(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
 914 {
 915     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 916
 917     FIXME("iface %p, parameter %p, matrix %p stub\n", This, parameter, matrix);
 918
 919     return E_NOTIMPL;
 920 }
 921
 922 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixTransposeArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
 923 {
 924     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 925
 926     FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
 927
 928     return E_NOTIMPL;
 929 }
 930
 931 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixTransposeArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
 932 {
 933     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 934
 935     FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
 936
 937     return E_NOTIMPL;
 938 }
 939
 940 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
 941 {
 942     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 943
 944     FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
 945
 946     return E_NOTIMPL;
 947 }
 948
 949 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
 950 {
 951     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 952
 953     FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
 954
 955     return E_NOTIMPL;
 956 }
 957
 958 static HRESULT WINAPI ID3DXBaseEffectImpl_SetString(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR string)
 959 {
 960     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 961
 962     FIXME("iface %p, parameter %p, string %p stub\n", This, parameter, string);
 963
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI ID3DXBaseEffectImpl_GetString(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR *string)
 968 {
 969     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 970
 971     FIXME("iface %p, parameter %p, string %p stub\n", This, parameter, string);
 972
 973     return E_NOTIMPL;
 974 }
 975
 976 static HRESULT WINAPI ID3DXBaseEffectImpl_SetTexture(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
 977 {
 978     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 979
 980     FIXME("iface %p, parameter %p, texture %p stub\n", This, parameter, texture);
 981
 982     return E_NOTIMPL;
 983 }
 984
 985 static HRESULT WINAPI ID3DXBaseEffectImpl_GetTexture(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
 986 {
 987     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 988
 989     FIXME("iface %p, parameter %p, texture %p stub\n", This, parameter, texture);
 990
 991     return E_NOTIMPL;
 992 }
 993
 994 static HRESULT WINAPI ID3DXBaseEffectImpl_GetPixelShader(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
 995 {
 996     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
 997
 998     FIXME("iface %p, parameter %p, pshader %p stub\n", This, parameter, pshader);
 999
1000     return E_NOTIMPL;
1001 }
1002
1003 static HRESULT WINAPI ID3DXBaseEffectImpl_GetVertexShader(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
1004 {
1005     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1006
1007     FIXME("iface %p, parameter %p, vshader %p stub\n", This, parameter, vshader);
1008
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI ID3DXBaseEffectImpl_SetArrayRange(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
1013 {
1014     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1015
1016     FIXME("iface %p, parameter %p, start %u, end %u stub\n", This, parameter, start, end);
1017
1018     return E_NOTIMPL;
1019 }
1020
1021 static const struct ID3DXBaseEffectVtbl ID3DXBaseEffect_Vtbl =
1022 {
1023     /*** IUnknown methods ***/
1024     ID3DXBaseEffectImpl_QueryInterface,
1025     ID3DXBaseEffectImpl_AddRef,
1026     ID3DXBaseEffectImpl_Release,
1027     /*** ID3DXBaseEffect methods ***/
1028     ID3DXBaseEffectImpl_GetDesc,
1029     ID3DXBaseEffectImpl_GetParameterDesc,
1030     ID3DXBaseEffectImpl_GetTechniqueDesc,
1031     ID3DXBaseEffectImpl_GetPassDesc,
1032     ID3DXBaseEffectImpl_GetFunctionDesc,
1033     ID3DXBaseEffectImpl_GetParameter,
1034     ID3DXBaseEffectImpl_GetParameterByName,
1035     ID3DXBaseEffectImpl_GetParameterBySemantic,
1036     ID3DXBaseEffectImpl_GetParameterElement,
1037     ID3DXBaseEffectImpl_GetTechnique,
1038     ID3DXBaseEffectImpl_GetTechniqueByName,
1039     ID3DXBaseEffectImpl_GetPass,
1040     ID3DXBaseEffectImpl_GetPassByName,
1041     ID3DXBaseEffectImpl_GetFunction,
1042     ID3DXBaseEffectImpl_GetFunctionByName,
1043     ID3DXBaseEffectImpl_GetAnnotation,
1044     ID3DXBaseEffectImpl_GetAnnotationByName,
1045     ID3DXBaseEffectImpl_SetValue,
1046     ID3DXBaseEffectImpl_GetValue,
1047     ID3DXBaseEffectImpl_SetBool,
1048     ID3DXBaseEffectImpl_GetBool,
1049     ID3DXBaseEffectImpl_SetBoolArray,
1050     ID3DXBaseEffectImpl_GetBoolArray,
1051     ID3DXBaseEffectImpl_SetInt,
1052     ID3DXBaseEffectImpl_GetInt,
1053     ID3DXBaseEffectImpl_SetIntArray,
1054     ID3DXBaseEffectImpl_GetIntArray,
1055     ID3DXBaseEffectImpl_SetFloat,
1056     ID3DXBaseEffectImpl_GetFloat,
1057     ID3DXBaseEffectImpl_SetFloatArray,
1058     ID3DXBaseEffectImpl_GetFloatArray,
1059     ID3DXBaseEffectImpl_SetVector,
1060     ID3DXBaseEffectImpl_GetVector,
1061     ID3DXBaseEffectImpl_SetVectorArray,
1062     ID3DXBaseEffectImpl_GetVectorArray,
1063     ID3DXBaseEffectImpl_SetMatrix,
1064     ID3DXBaseEffectImpl_GetMatrix,
1065     ID3DXBaseEffectImpl_SetMatrixArray,
1066     ID3DXBaseEffectImpl_GetMatrixArray,
1067     ID3DXBaseEffectImpl_SetMatrixPointerArray,
1068     ID3DXBaseEffectImpl_GetMatrixPointerArray,
1069     ID3DXBaseEffectImpl_SetMatrixTranspose,
1070     ID3DXBaseEffectImpl_GetMatrixTranspose,
1071     ID3DXBaseEffectImpl_SetMatrixTransposeArray,
1072     ID3DXBaseEffectImpl_GetMatrixTransposeArray,
1073     ID3DXBaseEffectImpl_SetMatrixTransposePointerArray,
1074     ID3DXBaseEffectImpl_GetMatrixTransposePointerArray,
1075     ID3DXBaseEffectImpl_SetString,
1076     ID3DXBaseEffectImpl_GetString,
1077     ID3DXBaseEffectImpl_SetTexture,
1078     ID3DXBaseEffectImpl_GetTexture,
1079     ID3DXBaseEffectImpl_GetPixelShader,
1080     ID3DXBaseEffectImpl_GetVertexShader,
1081     ID3DXBaseEffectImpl_SetArrayRange,
1082 };
1083
1084 static inline struct ID3DXEffectImpl *impl_from_ID3DXEffect(ID3DXEffect *iface)
1085 {
1086     return CONTAINING_RECORD(iface, struct ID3DXEffectImpl, ID3DXEffect_iface);
1087 }
1088
1089 /*** IUnknown methods ***/
1090 static HRESULT WINAPI ID3DXEffectImpl_QueryInterface(ID3DXEffect *iface, REFIID riid, void **object)
1091 {
1092     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1093
1094     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
1095
1096     if (IsEqualGUID(riid, &IID_IUnknown) ||
1097         IsEqualGUID(riid, &IID_ID3DXEffect))
1098     {
1099         This->ID3DXEffect_iface.lpVtbl->AddRef(iface);
1100         *object = This;
1101         return S_OK;
1102     }
1103
1104     ERR("Interface %s not found\n", debugstr_guid(riid));
1105
1106     return E_NOINTERFACE;
1107 }
1108
1109 static ULONG WINAPI ID3DXEffectImpl_AddRef(ID3DXEffect *iface)
1110 {
1111     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1112
1113     TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
1114
1115     return InterlockedIncrement(&This->ref);
1116 }
1117
1118 static ULONG WINAPI ID3DXEffectImpl_Release(ID3DXEffect *iface)
1119 {
1120     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1121     ULONG ref = InterlockedDecrement(&This->ref);
1122
1123     TRACE("(%p)->(): Release from %u\n", This, ref + 1);
1124
1125     if (!ref)
1126     {
1127         free_effect(This);
1128         HeapFree(GetProcessHeap(), 0, This);
1129     }
1130
1131     return ref;
1132 }
1133
1134 /*** ID3DXBaseEffect methods ***/
1135 static HRESULT WINAPI ID3DXEffectImpl_GetDesc(ID3DXEffect *iface, D3DXEFFECT_DESC *desc)
1136 {
1137     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1138     ID3DXBaseEffect *base = This->base_effect;
1139
1140     TRACE("Forward iface %p, base %p\n", This, base);
1141
1142     return ID3DXBaseEffectImpl_GetDesc(base, desc);
1143 }
1144
1145 static HRESULT WINAPI ID3DXEffectImpl_GetParameterDesc(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
1146 {
1147     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1148     ID3DXBaseEffect *base = This->base_effect;
1149
1150     TRACE("Forward iface %p, base %p\n", This, base);
1151
1152     return ID3DXBaseEffectImpl_GetParameterDesc(base, parameter, desc);
1153 }
1154
1155 static HRESULT WINAPI ID3DXEffectImpl_GetTechniqueDesc(ID3DXEffect *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
1156 {
1157     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1158     ID3DXBaseEffect *base = This->base_effect;
1159
1160     TRACE("Forward iface %p, base %p\n", This, base);
1161
1162     return ID3DXBaseEffectImpl_GetTechniqueDesc(base, technique, desc);
1163 }
1164
1165 static HRESULT WINAPI ID3DXEffectImpl_GetPassDesc(ID3DXEffect *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
1166 {
1167     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1168     ID3DXBaseEffect *base = This->base_effect;
1169
1170     TRACE("Forward iface %p, base %p\n", This, base);
1171
1172     return ID3DXBaseEffectImpl_GetPassDesc(base, pass, desc);
1173 }
1174
1175 static HRESULT WINAPI ID3DXEffectImpl_GetFunctionDesc(ID3DXEffect *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
1176 {
1177     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1178     ID3DXBaseEffect *base = This->base_effect;
1179
1180     TRACE("Forward iface %p, base %p\n", This, base);
1181
1182     return ID3DXBaseEffectImpl_GetFunctionDesc(base, shader, desc);
1183 }
1184
1185 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameter(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
1186 {
1187     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1188     ID3DXBaseEffect *base = This->base_effect;
1189
1190     TRACE("Forward iface %p, base %p\n", This, base);
1191
1192     return ID3DXBaseEffectImpl_GetParameter(base, parameter, index);
1193 }
1194
1195 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterByName(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR name)
1196 {
1197     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1198     ID3DXBaseEffect *base = This->base_effect;
1199
1200     TRACE("Forward iface %p, base %p\n", This, base);
1201
1202     return ID3DXBaseEffectImpl_GetParameterByName(base, parameter, name);
1203 }
1204
1205 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterBySemantic(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR semantic)
1206 {
1207     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1208     ID3DXBaseEffect *base = This->base_effect;
1209
1210     TRACE("Forward iface %p, base %p\n", This, base);
1211
1212     return ID3DXBaseEffectImpl_GetParameterBySemantic(base, parameter, semantic);
1213 }
1214
1215 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterElement(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
1216 {
1217     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1218     ID3DXBaseEffect *base = This->base_effect;
1219
1220     TRACE("Forward iface %p, base %p\n", This, base);
1221
1222     return ID3DXBaseEffectImpl_GetParameterElement(base, parameter, index);
1223 }
1224
1225 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechnique(ID3DXEffect *iface, UINT index)
1226 {
1227     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1228     ID3DXBaseEffect *base = This->base_effect;
1229
1230     TRACE("Forward iface %p, base %p\n", This, base);
1231
1232     return ID3DXBaseEffectImpl_GetTechnique(base, index);
1233 }
1234
1235 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechniqueByName(ID3DXEffect *iface, LPCSTR name)
1236 {
1237     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1238     ID3DXBaseEffect *base = This->base_effect;
1239
1240     TRACE("Forward iface %p, base %p\n", This, base);
1241
1242     return ID3DXBaseEffectImpl_GetTechniqueByName(base, name);
1243 }
1244
1245 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPass(ID3DXEffect *iface, D3DXHANDLE technique, UINT index)
1246 {
1247     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1248     ID3DXBaseEffect *base = This->base_effect;
1249
1250     TRACE("Forward iface %p, base %p\n", This, base);
1251
1252     return ID3DXBaseEffectImpl_GetPass(base, technique, index);
1253 }
1254
1255 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPassByName(ID3DXEffect *iface, D3DXHANDLE technique, LPCSTR name)
1256 {
1257     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1258     ID3DXBaseEffect *base = This->base_effect;
1259
1260     TRACE("Forward iface %p, base %p\n", This, base);
1261
1262     return ID3DXBaseEffectImpl_GetPassByName(base, technique, name);
1263 }
1264
1265 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunction(ID3DXEffect *iface, UINT index)
1266 {
1267     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1268     ID3DXBaseEffect *base = This->base_effect;
1269
1270     TRACE("Forward iface %p, base %p\n", This, base);
1271
1272     return ID3DXBaseEffectImpl_GetFunction(base, index);
1273 }
1274
1275 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunctionByName(ID3DXEffect *iface, LPCSTR name)
1276 {
1277     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1278     ID3DXBaseEffect *base = This->base_effect;
1279
1280     TRACE("Forward iface %p, base %p\n", This, base);
1281
1282     return ID3DXBaseEffectImpl_GetFunctionByName(base, name);
1283 }
1284
1285 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotation(ID3DXEffect *iface, D3DXHANDLE object, UINT index)
1286 {
1287     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1288     ID3DXBaseEffect *base = This->base_effect;
1289
1290     TRACE("Forward iface %p, base %p\n", This, base);
1291
1292     return ID3DXBaseEffectImpl_GetAnnotation(base, object, index);
1293 }
1294
1295 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotationByName(ID3DXEffect *iface, D3DXHANDLE object, LPCSTR name)
1296 {
1297     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1298     ID3DXBaseEffect *base = This->base_effect;
1299
1300     TRACE("Forward iface %p, base %p\n", This, base);
1301
1302     return ID3DXBaseEffectImpl_GetAnnotationByName(base, object, name);
1303 }
1304
1305 static HRESULT WINAPI ID3DXEffectImpl_SetValue(ID3DXEffect *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
1306 {
1307     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1308     ID3DXBaseEffect *base = This->base_effect;
1309
1310     TRACE("Forward iface %p, base %p\n", This, base);
1311
1312     return ID3DXBaseEffectImpl_SetValue(base, parameter, data, bytes);
1313 }
1314
1315 static HRESULT WINAPI ID3DXEffectImpl_GetValue(ID3DXEffect *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
1316 {
1317     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1318     ID3DXBaseEffect *base = This->base_effect;
1319
1320     TRACE("Forward iface %p, base %p\n", This, base);
1321
1322     return ID3DXBaseEffectImpl_GetValue(base, parameter, data, bytes);
1323 }
1324
1325 static HRESULT WINAPI ID3DXEffectImpl_SetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL b)
1326 {
1327     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1328     ID3DXBaseEffect *base = This->base_effect;
1329
1330     TRACE("Forward iface %p, base %p\n", This, base);
1331
1332     return ID3DXBaseEffectImpl_SetBool(base, parameter, b);
1333 }
1334
1335 static HRESULT WINAPI ID3DXEffectImpl_GetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b)
1336 {
1337     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1338     ID3DXBaseEffect *base = This->base_effect;
1339
1340     TRACE("Forward iface %p, base %p\n", This, base);
1341
1342     return ID3DXBaseEffectImpl_GetBool(base, parameter, b);
1343 }
1344
1345 static HRESULT WINAPI ID3DXEffectImpl_SetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
1346 {
1347     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1348     ID3DXBaseEffect *base = This->base_effect;
1349
1350     TRACE("Forward iface %p, base %p\n", This, base);
1351
1352     return ID3DXBaseEffectImpl_SetBoolArray(base, parameter, b, count);
1353 }
1354
1355 static HRESULT WINAPI ID3DXEffectImpl_GetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
1356 {
1357     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1358     ID3DXBaseEffect *base = This->base_effect;
1359
1360     TRACE("Forward iface %p, base %p\n", This, base);
1361
1362     return ID3DXBaseEffectImpl_GetBoolArray(base, parameter, b, count);
1363 }
1364
1365 static HRESULT WINAPI ID3DXEffectImpl_SetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT n)
1366 {
1367     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1368     ID3DXBaseEffect *base = This->base_effect;
1369
1370     TRACE("Forward iface %p, base %p\n", This, base);
1371
1372     return ID3DXBaseEffectImpl_SetInt(base, parameter, n);
1373 }
1374
1375 static HRESULT WINAPI ID3DXEffectImpl_GetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n)
1376 {
1377     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1378     ID3DXBaseEffect *base = This->base_effect;
1379
1380     TRACE("Forward iface %p, base %p\n", This, base);
1381
1382     return ID3DXBaseEffectImpl_GetInt(base, parameter, n);
1383 }
1384
1385 static HRESULT WINAPI ID3DXEffectImpl_SetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
1386 {
1387     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1388     ID3DXBaseEffect *base = This->base_effect;
1389
1390     TRACE("Forward iface %p, base %p\n", This, base);
1391
1392     return ID3DXBaseEffectImpl_SetIntArray(base, parameter, n, count);
1393 }
1394
1395 static HRESULT WINAPI ID3DXEffectImpl_GetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n, UINT count)
1396 {
1397     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1398     ID3DXBaseEffect *base = This->base_effect;
1399
1400     TRACE("Forward iface %p, base %p\n", This, base);
1401
1402     return ID3DXBaseEffectImpl_GetIntArray(base, parameter, n, count);
1403 }
1404
1405 static HRESULT WINAPI ID3DXEffectImpl_SetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT f)
1406 {
1407     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1408     ID3DXBaseEffect *base = This->base_effect;
1409
1410     TRACE("Forward iface %p, base %p\n", This, base);
1411
1412     return ID3DXBaseEffectImpl_SetFloat(base, parameter, f);
1413 }
1414
1415 static HRESULT WINAPI ID3DXEffectImpl_GetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT *f)
1416 {
1417     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1418     ID3DXBaseEffect *base = This->base_effect;
1419
1420     TRACE("Forward iface %p, base %p\n", This, base);
1421
1422     return ID3DXBaseEffectImpl_GetFloat(base, parameter, f);
1423 }
1424
1425 static HRESULT WINAPI ID3DXEffectImpl_SetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
1426 {
1427     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1428     ID3DXBaseEffect *base = This->base_effect;
1429
1430     TRACE("Forward iface %p, base %p\n", This, base);
1431
1432     return ID3DXBaseEffectImpl_SetFloatArray(base, parameter, f, count);
1433 }
1434
1435 static HRESULT WINAPI ID3DXEffectImpl_GetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
1436 {
1437     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1438     ID3DXBaseEffect *base = This->base_effect;
1439
1440     TRACE("Forward iface %p, base %p\n", This, base);
1441
1442     return ID3DXBaseEffectImpl_GetFloatArray(base, parameter, f, count);
1443 }
1444
1445 static HRESULT WINAPI ID3DXEffectImpl_SetVector(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector)
1446 {
1447     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1448     ID3DXBaseEffect *base = This->base_effect;
1449
1450     TRACE("Forward iface %p, base %p\n", This, base);
1451
1452     return ID3DXBaseEffectImpl_SetVector(base, parameter, vector);
1453 }
1454
1455 static HRESULT WINAPI ID3DXEffectImpl_GetVector(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
1456 {
1457     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1458     ID3DXBaseEffect *base = This->base_effect;
1459
1460     TRACE("Forward iface %p, base %p\n", This, base);
1461
1462     return ID3DXBaseEffectImpl_GetVector(base, parameter, vector);
1463 }
1464
1465 static HRESULT WINAPI ID3DXEffectImpl_SetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
1466 {
1467     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1468     ID3DXBaseEffect *base = This->base_effect;
1469
1470     TRACE("Forward iface %p, base %p\n", This, base);
1471
1472     return ID3DXBaseEffectImpl_SetVectorArray(base, parameter, vector, count);
1473 }
1474
1475 static HRESULT WINAPI ID3DXEffectImpl_GetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
1476 {
1477     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1478     ID3DXBaseEffect *base = This->base_effect;
1479
1480     TRACE("Forward iface %p, base %p\n", This, base);
1481
1482     return ID3DXBaseEffectImpl_GetVectorArray(base, parameter, vector, count);
1483 }
1484
1485 static HRESULT WINAPI ID3DXEffectImpl_SetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
1486 {
1487     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1488     ID3DXBaseEffect *base = This->base_effect;
1489
1490     TRACE("Forward iface %p, base %p\n", This, base);
1491
1492     return ID3DXBaseEffectImpl_SetMatrix(base, parameter, matrix);
1493 }
1494
1495 static HRESULT WINAPI ID3DXEffectImpl_GetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
1496 {
1497     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1498     ID3DXBaseEffect *base = This->base_effect;
1499
1500     TRACE("Forward iface %p, base %p\n", This, base);
1501
1502     return ID3DXBaseEffectImpl_GetMatrix(base, parameter, matrix);
1503 }
1504
1505 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
1506 {
1507     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1508     ID3DXBaseEffect *base = This->base_effect;
1509
1510     TRACE("Forward iface %p, base %p\n", This, base);
1511
1512     return ID3DXBaseEffectImpl_SetMatrixArray(base, parameter, matrix, count);
1513 }
1514
1515 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
1516 {
1517     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1518     ID3DXBaseEffect *base = This->base_effect;
1519
1520     TRACE("Forward iface %p, base %p\n", This, base);
1521
1522     return ID3DXBaseEffectImpl_GetMatrixArray(base, parameter, matrix, count);
1523 }
1524
1525 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
1526 {
1527     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1528     ID3DXBaseEffect *base = This->base_effect;
1529
1530     TRACE("Forward iface %p, base %p\n", This, base);
1531
1532     return ID3DXBaseEffectImpl_SetMatrixPointerArray(base, parameter, matrix, count);
1533 }
1534
1535 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
1536 {
1537     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1538     ID3DXBaseEffect *base = This->base_effect;
1539
1540     TRACE("Forward iface %p, base %p\n", This, base);
1541
1542     return ID3DXBaseEffectImpl_GetMatrixPointerArray(base, parameter, matrix, count);
1543 }
1544
1545 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
1546 {
1547     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1548     ID3DXBaseEffect *base = This->base_effect;
1549
1550     TRACE("Forward iface %p, base %p\n", This, base);
1551
1552     return ID3DXBaseEffectImpl_SetMatrixTranspose(base, parameter, matrix);
1553 }
1554
1555 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
1556 {
1557     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1558     ID3DXBaseEffect *base = This->base_effect;
1559
1560     TRACE("Forward iface %p, base %p\n", This, base);
1561
1562     return ID3DXBaseEffectImpl_GetMatrixTranspose(base, parameter, matrix);
1563 }
1564
1565 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
1566 {
1567     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1568     ID3DXBaseEffect *base = This->base_effect;
1569
1570     TRACE("Forward iface %p, base %p\n", This, base);
1571
1572     return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base, parameter, matrix, count);
1573 }
1574
1575 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
1576 {
1577     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1578     ID3DXBaseEffect *base = This->base_effect;
1579
1580     TRACE("Forward iface %p, base %p\n", This, base);
1581
1582     return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base, parameter, matrix, count);
1583 }
1584
1585 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
1586 {
1587     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1588     ID3DXBaseEffect *base = This->base_effect;
1589
1590     TRACE("Forward iface %p, base %p\n", This, base);
1591
1592     return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base, parameter, matrix, count);
1593 }
1594
1595 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
1596 {
1597     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1598     ID3DXBaseEffect *base = This->base_effect;
1599
1600     TRACE("Forward iface %p, base %p\n", This, base);
1601
1602     return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base, parameter, matrix, count);
1603 }
1604
1605 static HRESULT WINAPI ID3DXEffectImpl_SetString(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR string)
1606 {
1607     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1608     ID3DXBaseEffect *base = This->base_effect;
1609
1610     TRACE("Forward iface %p, base %p\n", This, base);
1611
1612     return ID3DXBaseEffectImpl_SetString(base, parameter, string);
1613 }
1614
1615 static HRESULT WINAPI ID3DXEffectImpl_GetString(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR *string)
1616 {
1617     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1618     ID3DXBaseEffect *base = This->base_effect;
1619
1620     TRACE("Forward iface %p, base %p\n", This, base);
1621
1622     return ID3DXBaseEffectImpl_GetString(base, parameter, string);
1623 }
1624
1625 static HRESULT WINAPI ID3DXEffectImpl_SetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
1626 {
1627     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1628     ID3DXBaseEffect *base = This->base_effect;
1629
1630     TRACE("Forward iface %p, base %p\n", This, base);
1631
1632     return ID3DXBaseEffectImpl_SetTexture(base, parameter, texture);
1633 }
1634
1635 static HRESULT WINAPI ID3DXEffectImpl_GetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
1636 {
1637     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1638     ID3DXBaseEffect *base = This->base_effect;
1639
1640     TRACE("Forward iface %p, base %p\n", This, base);
1641
1642     return ID3DXBaseEffectImpl_GetTexture(base, parameter, texture);
1643 }
1644
1645 static HRESULT WINAPI ID3DXEffectImpl_GetPixelShader(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
1646 {
1647     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1648     ID3DXBaseEffect *base = This->base_effect;
1649
1650     TRACE("Forward iface %p, base %p\n", This, base);
1651
1652     return ID3DXBaseEffectImpl_GetPixelShader(base, parameter, pshader);
1653 }
1654
1655 static HRESULT WINAPI ID3DXEffectImpl_GetVertexShader(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
1656 {
1657     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1658     ID3DXBaseEffect *base = This->base_effect;
1659
1660     TRACE("Forward iface %p, base %p\n", This, base);
1661
1662     return ID3DXBaseEffectImpl_GetVertexShader(base, parameter, vshader);
1663 }
1664
1665 static HRESULT WINAPI ID3DXEffectImpl_SetArrayRange(ID3DXEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
1666 {
1667     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1668     ID3DXBaseEffect *base = This->base_effect;
1669
1670     TRACE("Forward iface %p, base %p\n", This, base);
1671
1672     return ID3DXBaseEffectImpl_SetArrayRange(base, parameter, start, end);
1673 }
1674
1675 /*** ID3DXEffect methods ***/
1676 static HRESULT WINAPI ID3DXEffectImpl_GetPool(ID3DXEffect *iface, LPD3DXEFFECTPOOL *pool)
1677 {
1678     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1679
1680     TRACE("iface %p, pool %p\n", This, pool);
1681
1682     if (!pool)
1683     {
1684         WARN("Invalid argument supplied.\n");
1685         return D3DERR_INVALIDCALL;
1686     }
1687
1688     if (This->pool)
1689     {
1690         This->pool->lpVtbl->AddRef(This->pool);
1691     }
1692
1693     *pool = This->pool;
1694
1695     TRACE("Returning pool %p\n", *pool);
1696
1697     return S_OK;
1698 }
1699
1700 static HRESULT WINAPI ID3DXEffectImpl_SetTechnique(ID3DXEffect* iface, D3DXHANDLE technique)
1701 {
1702     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1703
1704     FIXME("(%p)->(%p): stub\n", This, technique);
1705
1706     return E_NOTIMPL;
1707 }
1708
1709 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetCurrentTechnique(ID3DXEffect* iface)
1710 {
1711     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1712
1713     FIXME("(%p)->(): stub\n", This);
1714
1715     return NULL;
1716 }
1717
1718 static HRESULT WINAPI ID3DXEffectImpl_ValidateTechnique(ID3DXEffect* iface, D3DXHANDLE technique)
1719 {
1720     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1721
1722     FIXME("(%p)->(%p): stub\n", This, technique);
1723
1724     return D3D_OK;
1725 }
1726
1727 static HRESULT WINAPI ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect* iface, D3DXHANDLE technique, D3DXHANDLE* next_technique)
1728 {
1729     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1730
1731     FIXME("(%p)->(%p, %p): stub\n", This, technique, next_technique);
1732
1733     return E_NOTIMPL;
1734 }
1735
1736 static BOOL WINAPI ID3DXEffectImpl_IsParameterUsed(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXHANDLE technique)
1737 {
1738     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1739
1740     FIXME("(%p)->(%p, %p): stub\n", This, parameter, technique);
1741
1742     return FALSE;
1743 }
1744
1745 static HRESULT WINAPI ID3DXEffectImpl_Begin(ID3DXEffect* iface, UINT *passes, DWORD flags)
1746 {
1747     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1748
1749     FIXME("(%p)->(%p, %#x): stub\n", This, passes, flags);
1750
1751     return E_NOTIMPL;
1752 }
1753
1754 static HRESULT WINAPI ID3DXEffectImpl_BeginPass(ID3DXEffect* iface, UINT pass)
1755 {
1756     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1757
1758     FIXME("(%p)->(%u): stub\n", This, pass);
1759
1760     return E_NOTIMPL;
1761 }
1762
1763 static HRESULT WINAPI ID3DXEffectImpl_CommitChanges(ID3DXEffect* iface)
1764 {
1765     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1766
1767     FIXME("(%p)->(): stub\n", This);
1768
1769     return E_NOTIMPL;
1770 }
1771
1772 static HRESULT WINAPI ID3DXEffectImpl_EndPass(ID3DXEffect* iface)
1773 {
1774     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1775
1776     FIXME("(%p)->(): stub\n", This);
1777
1778     return E_NOTIMPL;
1779 }
1780
1781 static HRESULT WINAPI ID3DXEffectImpl_End(ID3DXEffect* iface)
1782 {
1783     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1784
1785     FIXME("(%p)->(): stub\n", This);
1786
1787     return E_NOTIMPL;
1788 }
1789
1790 static HRESULT WINAPI ID3DXEffectImpl_GetDevice(ID3DXEffect *iface, LPDIRECT3DDEVICE9 *device)
1791 {
1792     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1793
1794     TRACE("iface %p, device %p\n", This, device);
1795
1796     if (!device)
1797     {
1798         WARN("Invalid argument supplied.\n");
1799         return D3DERR_INVALIDCALL;
1800     }
1801
1802     IDirect3DDevice9_AddRef(This->device);
1803
1804     *device = This->device;
1805
1806     TRACE("Returning device %p\n", *device);
1807
1808     return S_OK;
1809 }
1810
1811 static HRESULT WINAPI ID3DXEffectImpl_OnLostDevice(ID3DXEffect* iface)
1812 {
1813     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1814
1815     FIXME("(%p)->(): stub\n", This);
1816
1817     return E_NOTIMPL;
1818 }
1819
1820 static HRESULT WINAPI ID3DXEffectImpl_OnResetDevice(ID3DXEffect* iface)
1821 {
1822     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1823
1824     FIXME("(%p)->(): stub\n", This);
1825
1826     return E_NOTIMPL;
1827 }
1828
1829 static HRESULT WINAPI ID3DXEffectImpl_SetStateManager(ID3DXEffect* iface, LPD3DXEFFECTSTATEMANAGER manager)
1830 {
1831     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1832
1833     FIXME("(%p)->(%p): stub\n", This, manager);
1834
1835     return E_NOTIMPL;
1836 }
1837
1838 static HRESULT WINAPI ID3DXEffectImpl_GetStateManager(ID3DXEffect* iface, LPD3DXEFFECTSTATEMANAGER* manager)
1839 {
1840     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1841
1842     FIXME("(%p)->(%p): stub\n", This, manager);
1843
1844     return E_NOTIMPL;
1845 }
1846
1847 static HRESULT WINAPI ID3DXEffectImpl_BeginParameterBlock(ID3DXEffect* iface)
1848 {
1849     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1850
1851     FIXME("(%p)->(): stub\n", This);
1852
1853     return E_NOTIMPL;
1854 }
1855
1856 static D3DXHANDLE WINAPI ID3DXEffectImpl_EndParameterBlock(ID3DXEffect* iface)
1857 {
1858     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1859
1860     FIXME("(%p)->(): stub\n", This);
1861
1862     return NULL;
1863 }
1864
1865 static HRESULT WINAPI ID3DXEffectImpl_ApplyParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
1866 {
1867     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1868
1869     FIXME("(%p)->(%p): stub\n", This, parameter_block);
1870
1871     return E_NOTIMPL;
1872 }
1873
1874 static HRESULT WINAPI ID3DXEffectImpl_DeleteParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
1875 {
1876     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1877
1878     FIXME("(%p)->(%p): stub\n", This, parameter_block);
1879
1880     return E_NOTIMPL;
1881 }
1882
1883 static HRESULT WINAPI ID3DXEffectImpl_CloneEffect(ID3DXEffect* iface, LPDIRECT3DDEVICE9 device, LPD3DXEFFECT* effect)
1884 {
1885     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1886
1887     FIXME("(%p)->(%p, %p): stub\n", This, device, effect);
1888
1889     return E_NOTIMPL;
1890 }
1891
1892 static HRESULT WINAPI ID3DXEffectImpl_SetRawValue(ID3DXEffect* iface, D3DXHANDLE parameter, LPCVOID data, UINT byte_offset, UINT bytes)
1893 {
1894     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1895
1896     FIXME("(%p)->(%p, %p, %u, %u): stub\n", This, parameter, data, byte_offset, bytes);
1897
1898     return E_NOTIMPL;
1899 }
1900
1901 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl =
1902 {
1903     /*** IUnknown methods ***/
1904     ID3DXEffectImpl_QueryInterface,
1905     ID3DXEffectImpl_AddRef,
1906     ID3DXEffectImpl_Release,
1907     /*** ID3DXBaseEffect methods ***/
1908     ID3DXEffectImpl_GetDesc,
1909     ID3DXEffectImpl_GetParameterDesc,
1910     ID3DXEffectImpl_GetTechniqueDesc,
1911     ID3DXEffectImpl_GetPassDesc,
1912     ID3DXEffectImpl_GetFunctionDesc,
1913     ID3DXEffectImpl_GetParameter,
1914     ID3DXEffectImpl_GetParameterByName,
1915     ID3DXEffectImpl_GetParameterBySemantic,
1916     ID3DXEffectImpl_GetParameterElement,
1917     ID3DXEffectImpl_GetTechnique,
1918     ID3DXEffectImpl_GetTechniqueByName,
1919     ID3DXEffectImpl_GetPass,
1920     ID3DXEffectImpl_GetPassByName,
1921     ID3DXEffectImpl_GetFunction,
1922     ID3DXEffectImpl_GetFunctionByName,
1923     ID3DXEffectImpl_GetAnnotation,
1924     ID3DXEffectImpl_GetAnnotationByName,
1925     ID3DXEffectImpl_SetValue,
1926     ID3DXEffectImpl_GetValue,
1927     ID3DXEffectImpl_SetBool,
1928     ID3DXEffectImpl_GetBool,
1929     ID3DXEffectImpl_SetBoolArray,
1930     ID3DXEffectImpl_GetBoolArray,
1931     ID3DXEffectImpl_SetInt,
1932     ID3DXEffectImpl_GetInt,
1933     ID3DXEffectImpl_SetIntArray,
1934     ID3DXEffectImpl_GetIntArray,
1935     ID3DXEffectImpl_SetFloat,
1936     ID3DXEffectImpl_GetFloat,
1937     ID3DXEffectImpl_SetFloatArray,
1938     ID3DXEffectImpl_GetFloatArray,
1939     ID3DXEffectImpl_SetVector,
1940     ID3DXEffectImpl_GetVector,
1941     ID3DXEffectImpl_SetVectorArray,
1942     ID3DXEffectImpl_GetVectorArray,
1943     ID3DXEffectImpl_SetMatrix,
1944     ID3DXEffectImpl_GetMatrix,
1945     ID3DXEffectImpl_SetMatrixArray,
1946     ID3DXEffectImpl_GetMatrixArray,
1947     ID3DXEffectImpl_SetMatrixPointerArray,
1948     ID3DXEffectImpl_GetMatrixPointerArray,
1949     ID3DXEffectImpl_SetMatrixTranspose,
1950     ID3DXEffectImpl_GetMatrixTranspose,
1951     ID3DXEffectImpl_SetMatrixTransposeArray,
1952     ID3DXEffectImpl_GetMatrixTransposeArray,
1953     ID3DXEffectImpl_SetMatrixTransposePointerArray,
1954     ID3DXEffectImpl_GetMatrixTransposePointerArray,
1955     ID3DXEffectImpl_SetString,
1956     ID3DXEffectImpl_GetString,
1957     ID3DXEffectImpl_SetTexture,
1958     ID3DXEffectImpl_GetTexture,
1959     ID3DXEffectImpl_GetPixelShader,
1960     ID3DXEffectImpl_GetVertexShader,
1961     ID3DXEffectImpl_SetArrayRange,
1962     /*** ID3DXEffect methods ***/
1963     ID3DXEffectImpl_GetPool,
1964     ID3DXEffectImpl_SetTechnique,
1965     ID3DXEffectImpl_GetCurrentTechnique,
1966     ID3DXEffectImpl_ValidateTechnique,
1967     ID3DXEffectImpl_FindNextValidTechnique,
1968     ID3DXEffectImpl_IsParameterUsed,
1969     ID3DXEffectImpl_Begin,
1970     ID3DXEffectImpl_BeginPass,
1971     ID3DXEffectImpl_CommitChanges,
1972     ID3DXEffectImpl_EndPass,
1973     ID3DXEffectImpl_End,
1974     ID3DXEffectImpl_GetDevice,
1975     ID3DXEffectImpl_OnLostDevice,
1976     ID3DXEffectImpl_OnResetDevice,
1977     ID3DXEffectImpl_SetStateManager,
1978     ID3DXEffectImpl_GetStateManager,
1979     ID3DXEffectImpl_BeginParameterBlock,
1980     ID3DXEffectImpl_EndParameterBlock,
1981     ID3DXEffectImpl_ApplyParameterBlock,
1982     ID3DXEffectImpl_DeleteParameterBlock,
1983     ID3DXEffectImpl_CloneEffect,
1984     ID3DXEffectImpl_SetRawValue
1985 };
1986
1987 static inline struct ID3DXEffectCompilerImpl *impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler *iface)
1988 {
1989     return CONTAINING_RECORD(iface, struct ID3DXEffectCompilerImpl, ID3DXEffectCompiler_iface);
1990 }
1991
1992 /*** IUnknown methods ***/
1993 static HRESULT WINAPI ID3DXEffectCompilerImpl_QueryInterface(ID3DXEffectCompiler *iface, REFIID riid, void **object)
1994 {
1995     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
1996
1997     TRACE("iface %p, riid %s, object %p\n", This, debugstr_guid(riid), object);
1998
1999     if (IsEqualGUID(riid, &IID_IUnknown) ||
2000         IsEqualGUID(riid, &IID_ID3DXEffectCompiler))
2001     {
2002         This->ID3DXEffectCompiler_iface.lpVtbl->AddRef(iface);
2003         *object = This;
2004         return S_OK;
2005     }
2006
2007     ERR("Interface %s not found\n", debugstr_guid(riid));
2008
2009     return E_NOINTERFACE;
2010 }
2011
2012 static ULONG WINAPI ID3DXEffectCompilerImpl_AddRef(ID3DXEffectCompiler *iface)
2013 {
2014     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2015
2016     TRACE("iface %p: AddRef from %u\n", iface, This->ref);
2017
2018     return InterlockedIncrement(&This->ref);
2019 }
2020
2021 static ULONG WINAPI ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler *iface)
2022 {
2023     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2024     ULONG ref = InterlockedDecrement(&This->ref);
2025
2026     TRACE("iface %p: Release from %u\n", iface, ref + 1);
2027
2028     if (!ref)
2029     {
2030         free_effect_compiler(This);
2031         HeapFree(GetProcessHeap(), 0, This);
2032     }
2033
2034     return ref;
2035 }
2036
2037 /*** ID3DXBaseEffect methods ***/
2038 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetDesc(ID3DXEffectCompiler *iface, D3DXEFFECT_DESC *desc)
2039 {
2040     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2041     ID3DXBaseEffect *base = This->base_effect;
2042
2043     TRACE("Forward iface %p, base %p\n", This, base);
2044
2045     return ID3DXBaseEffectImpl_GetDesc(base, desc);
2046 }
2047
2048 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetParameterDesc(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
2049 {
2050     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2051     ID3DXBaseEffect *base = This->base_effect;
2052
2053     TRACE("Forward iface %p, base %p\n", This, base);
2054
2055     return ID3DXBaseEffectImpl_GetParameterDesc(base, parameter, desc);
2056 }
2057
2058 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTechniqueDesc(ID3DXEffectCompiler *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
2059 {
2060     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2061     ID3DXBaseEffect *base = This->base_effect;
2062
2063     TRACE("Forward iface %p, base %p\n", This, base);
2064
2065     return ID3DXBaseEffectImpl_GetTechniqueDesc(base, technique, desc);
2066 }
2067
2068 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPassDesc(ID3DXEffectCompiler *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
2069 {
2070     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2071     ID3DXBaseEffect *base = This->base_effect;
2072
2073     TRACE("Forward iface %p, base %p\n", This, base);
2074
2075     return ID3DXBaseEffectImpl_GetPassDesc(base, pass, desc);
2076 }
2077
2078 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFunctionDesc(ID3DXEffectCompiler *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
2079 {
2080     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2081     ID3DXBaseEffect *base = This->base_effect;
2082
2083     TRACE("Forward iface %p, base %p\n", This, base);
2084
2085     return ID3DXBaseEffectImpl_GetFunctionDesc(base, shader, desc);
2086 }
2087
2088 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameter(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
2089 {
2090     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2091     ID3DXBaseEffect *base = This->base_effect;
2092
2093     TRACE("Forward iface %p, base %p\n", This, base);
2094
2095     return ID3DXBaseEffectImpl_GetParameter(base, parameter, index);
2096 }
2097
2098 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterByName(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR name)
2099 {
2100     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2101     ID3DXBaseEffect *base = This->base_effect;
2102
2103     TRACE("Forward iface %p, base %p\n", This, base);
2104
2105     return ID3DXBaseEffectImpl_GetParameterByName(base, parameter, name);
2106 }
2107
2108 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterBySemantic(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR semantic)
2109 {
2110     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2111     ID3DXBaseEffect *base = This->base_effect;
2112
2113     TRACE("Forward iface %p, base %p\n", This, base);
2114
2115     return ID3DXBaseEffectImpl_GetParameterBySemantic(base, parameter, semantic);
2116 }
2117
2118 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterElement(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
2119 {
2120     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2121     ID3DXBaseEffect *base = This->base_effect;
2122
2123     TRACE("Forward iface %p, base %p\n", This, base);
2124
2125     return ID3DXBaseEffectImpl_GetParameterElement(base, parameter, index);
2126 }
2127
2128 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechnique(ID3DXEffectCompiler *iface, UINT index)
2129 {
2130     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2131     ID3DXBaseEffect *base = This->base_effect;
2132
2133     TRACE("Forward iface %p, base %p\n", This, base);
2134
2135     return ID3DXBaseEffectImpl_GetTechnique(base, index);
2136 }
2137
2138 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechniqueByName(ID3DXEffectCompiler *iface, LPCSTR name)
2139 {
2140     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2141     ID3DXBaseEffect *base = This->base_effect;
2142
2143     TRACE("Forward iface %p, base %p\n", This, base);
2144
2145     return ID3DXBaseEffectImpl_GetTechniqueByName(base, name);
2146 }
2147
2148 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPass(ID3DXEffectCompiler *iface, D3DXHANDLE technique, UINT index)
2149 {
2150     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2151     ID3DXBaseEffect *base = This->base_effect;
2152
2153     TRACE("Forward iface %p, base %p\n", This, base);
2154
2155     return ID3DXBaseEffectImpl_GetPass(base, technique, index);
2156 }
2157
2158 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPassByName(ID3DXEffectCompiler *iface, D3DXHANDLE technique, LPCSTR name)
2159 {
2160     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2161     ID3DXBaseEffect *base = This->base_effect;
2162
2163     TRACE("Forward iface %p, base %p\n", This, base);
2164
2165     return ID3DXBaseEffectImpl_GetPassByName(base, technique, name);
2166 }
2167
2168 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunction(ID3DXEffectCompiler *iface, UINT index)
2169 {
2170     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2171     ID3DXBaseEffect *base = This->base_effect;
2172
2173     TRACE("Forward iface %p, base %p\n", This, base);
2174
2175     return ID3DXBaseEffectImpl_GetFunction(base, index);
2176 }
2177
2178 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunctionByName(ID3DXEffectCompiler *iface, LPCSTR name)
2179 {
2180     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2181     ID3DXBaseEffect *base = This->base_effect;
2182
2183     TRACE("Forward iface %p, base %p\n", This, base);
2184
2185     return ID3DXBaseEffectImpl_GetFunctionByName(base, name);
2186 }
2187
2188 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotation(ID3DXEffectCompiler *iface, D3DXHANDLE object, UINT index)
2189 {
2190     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2191     ID3DXBaseEffect *base = This->base_effect;
2192
2193     TRACE("Forward iface %p, base %p\n", This, base);
2194
2195     return ID3DXBaseEffectImpl_GetAnnotation(base, object, index);
2196 }
2197
2198 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotationByName(ID3DXEffectCompiler *iface, D3DXHANDLE object, LPCSTR name)
2199 {
2200     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2201     ID3DXBaseEffect *base = This->base_effect;
2202
2203     TRACE("Forward iface %p, base %p\n", This, base);
2204
2205     return ID3DXBaseEffectImpl_GetAnnotationByName(base, object, name);
2206 }
2207
2208 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
2209 {
2210     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2211     ID3DXBaseEffect *base = This->base_effect;
2212
2213     TRACE("Forward iface %p, base %p\n", This, base);
2214
2215     return ID3DXBaseEffectImpl_SetValue(base, parameter, data, bytes);
2216 }
2217
2218 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
2219 {
2220     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2221     ID3DXBaseEffect *base = This->base_effect;
2222
2223     TRACE("Forward iface %p, base %p\n", This, base);
2224
2225     return ID3DXBaseEffectImpl_GetValue(base, parameter, data, bytes);
2226 }
2227
2228 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL b)
2229 {
2230     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2231     ID3DXBaseEffect *base = This->base_effect;
2232
2233     TRACE("Forward iface %p, base %p\n", This, base);
2234
2235     return ID3DXBaseEffectImpl_SetBool(base, parameter, b);
2236 }
2237
2238 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b)
2239 {
2240     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2241     ID3DXBaseEffect *base = This->base_effect;
2242
2243     TRACE("Forward iface %p, base %p\n", This, base);
2244
2245     return ID3DXBaseEffectImpl_GetBool(base, parameter, b);
2246 }
2247
2248 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
2249 {
2250     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2251     ID3DXBaseEffect *base = This->base_effect;
2252
2253     TRACE("Forward iface %p, base %p\n", This, base);
2254
2255     return ID3DXBaseEffectImpl_SetBoolArray(base, parameter, b, count);
2256 }
2257
2258 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
2259 {
2260     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2261     ID3DXBaseEffect *base = This->base_effect;
2262
2263     TRACE("Forward iface %p, base %p\n", This, base);
2264
2265     return ID3DXBaseEffectImpl_GetBoolArray(base, parameter, b, count);
2266 }
2267
2268 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT n)
2269 {
2270     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2271     ID3DXBaseEffect *base = This->base_effect;
2272
2273     TRACE("Forward iface %p, base %p\n", This, base);
2274
2275     return ID3DXBaseEffectImpl_SetInt(base, parameter, n);
2276 }
2277
2278 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n)
2279 {
2280     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2281     ID3DXBaseEffect *base = This->base_effect;
2282
2283     TRACE("Forward iface %p, base %p\n", This, base);
2284
2285     return ID3DXBaseEffectImpl_GetInt(base, parameter, n);
2286 }
2287
2288 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
2289 {
2290     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2291     ID3DXBaseEffect *base = This->base_effect;
2292
2293     TRACE("Forward iface %p, base %p\n", This, base);
2294
2295     return ID3DXBaseEffectImpl_SetIntArray(base, parameter, n, count);
2296 }
2297
2298 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n, UINT count)
2299 {
2300     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2301     ID3DXBaseEffect *base = This->base_effect;
2302
2303     TRACE("Forward iface %p, base %p\n", This, base);
2304
2305     return ID3DXBaseEffectImpl_GetIntArray(base, parameter, n, count);
2306 }
2307
2308 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT f)
2309 {
2310     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2311     ID3DXBaseEffect *base = This->base_effect;
2312
2313     TRACE("Forward iface %p, base %p\n", This, base);
2314
2315     return ID3DXBaseEffectImpl_SetFloat(base, parameter, f);
2316 }
2317
2318 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT *f)
2319 {
2320     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2321     ID3DXBaseEffect *base = This->base_effect;
2322
2323     TRACE("Forward iface %p, base %p\n", This, base);
2324
2325     return ID3DXBaseEffectImpl_GetFloat(base, parameter, f);
2326 }
2327
2328 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
2329 {
2330     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2331     ID3DXBaseEffect *base = This->base_effect;
2332
2333     TRACE("Forward iface %p, base %p\n", This, base);
2334
2335     return ID3DXBaseEffectImpl_SetFloatArray(base, parameter, f, count);
2336 }
2337
2338 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
2339 {
2340     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2341     ID3DXBaseEffect *base = This->base_effect;
2342
2343     TRACE("Forward iface %p, base %p\n", This, base);
2344
2345     return ID3DXBaseEffectImpl_GetFloatArray(base, parameter, f, count);
2346 }
2347
2348 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector)
2349 {
2350     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2351     ID3DXBaseEffect *base = This->base_effect;
2352
2353     TRACE("Forward iface %p, base %p\n", This, base);
2354
2355     return ID3DXBaseEffectImpl_SetVector(base, parameter, vector);
2356 }
2357
2358 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
2359 {
2360     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2361     ID3DXBaseEffect *base = This->base_effect;
2362
2363     TRACE("Forward iface %p, base %p\n", This, base);
2364
2365     return ID3DXBaseEffectImpl_GetVector(base, parameter, vector);
2366 }
2367
2368 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
2369 {
2370     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2371     ID3DXBaseEffect *base = This->base_effect;
2372
2373     TRACE("Forward iface %p, base %p\n", This, base);
2374
2375     return ID3DXBaseEffectImpl_SetVectorArray(base, parameter, vector, count);
2376 }
2377
2378 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
2379 {
2380     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2381     ID3DXBaseEffect *base = This->base_effect;
2382
2383     TRACE("Forward iface %p, base %p\n", This, base);
2384
2385     return ID3DXBaseEffectImpl_GetVectorArray(base, parameter, vector, count);
2386 }
2387
2388 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
2389 {
2390     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2391     ID3DXBaseEffect *base = This->base_effect;
2392
2393     TRACE("Forward iface %p, base %p\n", This, base);
2394
2395     return ID3DXBaseEffectImpl_SetMatrix(base, parameter, matrix);
2396 }
2397
2398 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
2399 {
2400     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2401     ID3DXBaseEffect *base = This->base_effect;
2402
2403     TRACE("Forward iface %p, base %p\n", This, base);
2404
2405     return ID3DXBaseEffectImpl_GetMatrix(base, parameter, matrix);
2406 }
2407
2408 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
2409 {
2410     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2411     ID3DXBaseEffect *base = This->base_effect;
2412
2413     TRACE("Forward iface %p, base %p\n", This, base);
2414
2415     return ID3DXBaseEffectImpl_SetMatrixArray(base, parameter, matrix, count);
2416 }
2417
2418 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
2419 {
2420     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2421     ID3DXBaseEffect *base = This->base_effect;
2422
2423     TRACE("Forward iface %p, base %p\n", This, base);
2424
2425     return ID3DXBaseEffectImpl_GetMatrixArray(base, parameter, matrix, count);
2426 }
2427
2428 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
2429 {
2430     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2431     ID3DXBaseEffect *base = This->base_effect;
2432
2433     TRACE("Forward iface %p, base %p\n", This, base);
2434
2435     return ID3DXBaseEffectImpl_SetMatrixPointerArray(base, parameter, matrix, count);
2436 }
2437
2438 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
2439 {
2440     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2441     ID3DXBaseEffect *base = This->base_effect;
2442
2443     TRACE("Forward iface %p, base %p\n", This, base);
2444
2445     return ID3DXBaseEffectImpl_GetMatrixPointerArray(base, parameter, matrix, count);
2446 }
2447
2448 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
2449 {
2450     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2451     ID3DXBaseEffect *base = This->base_effect;
2452
2453     TRACE("Forward iface %p, base %p\n", This, base);
2454
2455     return ID3DXBaseEffectImpl_SetMatrixTranspose(base, parameter, matrix);
2456 }
2457
2458 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
2459 {
2460     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2461     ID3DXBaseEffect *base = This->base_effect;
2462
2463     TRACE("Forward iface %p, base %p\n", This, base);
2464
2465     return ID3DXBaseEffectImpl_GetMatrixTranspose(base, parameter, matrix);
2466 }
2467
2468 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
2469 {
2470     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2471     ID3DXBaseEffect *base = This->base_effect;
2472
2473     TRACE("Forward iface %p, base %p\n", This, base);
2474
2475     return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base, parameter, matrix, count);
2476 }
2477
2478 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
2479 {
2480     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2481     ID3DXBaseEffect *base = This->base_effect;
2482
2483     TRACE("Forward iface %p, base %p\n", This, base);
2484
2485     return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base, parameter, matrix, count);
2486 }
2487
2488 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
2489 {
2490     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2491     ID3DXBaseEffect *base = This->base_effect;
2492
2493     TRACE("Forward iface %p, base %p\n", This, base);
2494
2495     return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base, parameter, matrix, count);
2496 }
2497
2498 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
2499 {
2500     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2501     ID3DXBaseEffect *base = This->base_effect;
2502
2503     TRACE("Forward iface %p, base %p\n", This, base);
2504
2505     return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base, parameter, matrix, count);
2506 }
2507
2508 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR string)
2509 {
2510     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2511     ID3DXBaseEffect *base = This->base_effect;
2512
2513     TRACE("Forward iface %p, base %p\n", This, base);
2514
2515     return ID3DXBaseEffectImpl_SetString(base, parameter, string);
2516 }
2517
2518 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR *string)
2519 {
2520     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2521     ID3DXBaseEffect *base = This->base_effect;
2522
2523     TRACE("Forward iface %p, base %p\n", This, base);
2524
2525     return ID3DXBaseEffectImpl_GetString(base, parameter, string);
2526 }
2527
2528 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetTexture(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
2529 {
2530     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2531     ID3DXBaseEffect *base = This->base_effect;
2532
2533     TRACE("Forward iface %p, base %p\n", This, base);
2534
2535     return ID3DXBaseEffectImpl_SetTexture(base, parameter, texture);
2536 }
2537
2538 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTexture(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
2539 {
2540     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2541     ID3DXBaseEffect *base = This->base_effect;
2542
2543     TRACE("Forward iface %p, base %p\n", This, base);
2544
2545     return ID3DXBaseEffectImpl_GetTexture(base, parameter, texture);
2546 }
2547
2548 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPixelShader(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
2549 {
2550     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2551     ID3DXBaseEffect *base = This->base_effect;
2552
2553     TRACE("Forward iface %p, base %p\n", This, base);
2554
2555     return ID3DXBaseEffectImpl_GetPixelShader(base, parameter, pshader);
2556 }
2557
2558 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVertexShader(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
2559 {
2560     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2561     ID3DXBaseEffect *base = This->base_effect;
2562
2563     TRACE("Forward iface %p, base %p\n", This, base);
2564
2565     return ID3DXBaseEffectImpl_GetVertexShader(base, parameter, vshader);
2566 }
2567
2568 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetArrayRange(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT start, UINT end)
2569 {
2570     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2571     ID3DXBaseEffect *base = This->base_effect;
2572
2573     TRACE("Forward iface %p, base %p\n", This, base);
2574
2575     return ID3DXBaseEffectImpl_SetArrayRange(base, parameter, start, end);
2576 }
2577
2578 /*** ID3DXEffectCompiler methods ***/
2579 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL literal)
2580 {
2581     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2582
2583     FIXME("iface %p, parameter %p, literal %u\n", This, parameter, literal);
2584
2585     return E_NOTIMPL;
2586 }
2587
2588 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *literal)
2589 {
2590     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2591
2592     FIXME("iface %p, parameter %p, literal %p\n", This, parameter, literal);
2593
2594     return E_NOTIMPL;
2595 }
2596
2597 static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileEffect(ID3DXEffectCompiler *iface, DWORD flags,
2598         LPD3DXBUFFER *effect, LPD3DXBUFFER *error_msgs)
2599 {
2600     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2601
2602     FIXME("iface %p, flags %#x, effect %p, error_msgs %p stub\n", This, flags, effect, error_msgs);
2603
2604     return E_NOTIMPL;
2605 }
2606
2607 static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileShader(ID3DXEffectCompiler *iface, D3DXHANDLE function,
2608         LPCSTR target, DWORD flags, LPD3DXBUFFER *shader, LPD3DXBUFFER *error_msgs, LPD3DXCONSTANTTABLE *constant_table)
2609 {
2610     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2611
2612     FIXME("iface %p, function %p, target %p, flags %#x, shader %p, error_msgs %p, constant_table %p stub\n",
2613             This, function, target, flags, shader, error_msgs, constant_table);
2614
2615     return E_NOTIMPL;
2616 }
2617
2618 static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl =
2619 {
2620     /*** IUnknown methods ***/
2621     ID3DXEffectCompilerImpl_QueryInterface,
2622     ID3DXEffectCompilerImpl_AddRef,
2623     ID3DXEffectCompilerImpl_Release,
2624     /*** ID3DXBaseEffect methods ***/
2625     ID3DXEffectCompilerImpl_GetDesc,
2626     ID3DXEffectCompilerImpl_GetParameterDesc,
2627     ID3DXEffectCompilerImpl_GetTechniqueDesc,
2628     ID3DXEffectCompilerImpl_GetPassDesc,
2629     ID3DXEffectCompilerImpl_GetFunctionDesc,
2630     ID3DXEffectCompilerImpl_GetParameter,
2631     ID3DXEffectCompilerImpl_GetParameterByName,
2632     ID3DXEffectCompilerImpl_GetParameterBySemantic,
2633     ID3DXEffectCompilerImpl_GetParameterElement,
2634     ID3DXEffectCompilerImpl_GetTechnique,
2635     ID3DXEffectCompilerImpl_GetTechniqueByName,
2636     ID3DXEffectCompilerImpl_GetPass,
2637     ID3DXEffectCompilerImpl_GetPassByName,
2638     ID3DXEffectCompilerImpl_GetFunction,
2639     ID3DXEffectCompilerImpl_GetFunctionByName,
2640     ID3DXEffectCompilerImpl_GetAnnotation,
2641     ID3DXEffectCompilerImpl_GetAnnotationByName,
2642     ID3DXEffectCompilerImpl_SetValue,
2643     ID3DXEffectCompilerImpl_GetValue,
2644     ID3DXEffectCompilerImpl_SetBool,
2645     ID3DXEffectCompilerImpl_GetBool,
2646     ID3DXEffectCompilerImpl_SetBoolArray,
2647     ID3DXEffectCompilerImpl_GetBoolArray,
2648     ID3DXEffectCompilerImpl_SetInt,
2649     ID3DXEffectCompilerImpl_GetInt,
2650     ID3DXEffectCompilerImpl_SetIntArray,
2651     ID3DXEffectCompilerImpl_GetIntArray,
2652     ID3DXEffectCompilerImpl_SetFloat,
2653     ID3DXEffectCompilerImpl_GetFloat,
2654     ID3DXEffectCompilerImpl_SetFloatArray,
2655     ID3DXEffectCompilerImpl_GetFloatArray,
2656     ID3DXEffectCompilerImpl_SetVector,
2657     ID3DXEffectCompilerImpl_GetVector,
2658     ID3DXEffectCompilerImpl_SetVectorArray,
2659     ID3DXEffectCompilerImpl_GetVectorArray,
2660     ID3DXEffectCompilerImpl_SetMatrix,
2661     ID3DXEffectCompilerImpl_GetMatrix,
2662     ID3DXEffectCompilerImpl_SetMatrixArray,
2663     ID3DXEffectCompilerImpl_GetMatrixArray,
2664     ID3DXEffectCompilerImpl_SetMatrixPointerArray,
2665     ID3DXEffectCompilerImpl_GetMatrixPointerArray,
2666     ID3DXEffectCompilerImpl_SetMatrixTranspose,
2667     ID3DXEffectCompilerImpl_GetMatrixTranspose,
2668     ID3DXEffectCompilerImpl_SetMatrixTransposeArray,
2669     ID3DXEffectCompilerImpl_GetMatrixTransposeArray,
2670     ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray,
2671     ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray,
2672     ID3DXEffectCompilerImpl_SetString,
2673     ID3DXEffectCompilerImpl_GetString,
2674     ID3DXEffectCompilerImpl_SetTexture,
2675     ID3DXEffectCompilerImpl_GetTexture,
2676     ID3DXEffectCompilerImpl_GetPixelShader,
2677     ID3DXEffectCompilerImpl_GetVertexShader,
2678     ID3DXEffectCompilerImpl_SetArrayRange,
2679     /*** ID3DXEffectCompiler methods ***/
2680     ID3DXEffectCompilerImpl_SetLiteral,
2681     ID3DXEffectCompilerImpl_GetLiteral,
2682     ID3DXEffectCompilerImpl_CompileEffect,
2683     ID3DXEffectCompilerImpl_CompileShader,
2684 };
2685
2686 static HRESULT d3dx9_parse_value(struct d3dx_parameter *param, void *value)
2687 {
2688     unsigned int i;
2689     HRESULT hr;
2690     UINT old_size = 0;
2691
2692     if (param->element_count)
2693     {
2694         param->data = value;
2695
2696         for (i = 0; i < param->element_count; ++i)
2697         {
2698             struct d3dx_parameter *member = get_parameter_struct(param->member_handles[i]);
2699
2700             hr = d3dx9_parse_value(member, (char *)value + old_size);
2701             if (hr != D3D_OK)
2702             {
2703                 WARN("Failed to parse value\n");
2704                 return hr;
2705             }
2706
2707             old_size += member->bytes;
2708         }
2709
2710         return D3D_OK;
2711     }
2712
2713     switch(param->class)
2714     {
2715         case D3DXPC_SCALAR:
2716         case D3DXPC_VECTOR:
2717         case D3DXPC_MATRIX_ROWS:
2718         case D3DXPC_MATRIX_COLUMNS:
2719             param->data = value;
2720             break;
2721
2722         case D3DXPC_STRUCT:
2723             param->data = value;
2724
2725             for (i = 0; i < param->member_count; ++i)
2726             {
2727                 struct d3dx_parameter *member = get_parameter_struct(param->member_handles[i]);
2728
2729                 hr = d3dx9_parse_value(member, (char *)value + old_size);
2730                 if (hr != D3D_OK)
2731                 {
2732                     WARN("Failed to parse value\n");
2733                     return hr;
2734                 }
2735
2736                 old_size += member->bytes;
2737             }
2738             break;
2739
2740         default:
2741             FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
2742             break;
2743     }
2744
2745     return D3D_OK;
2746 }
2747
2748
2749 static HRESULT d3dx9_parse_init_value(struct d3dx_parameter *param, const char *ptr)
2750 {
2751     UINT size = param->bytes;
2752     HRESULT hr;
2753     void *value;
2754
2755     TRACE("param size: %u\n", size);
2756
2757     value = HeapAlloc(GetProcessHeap(), 0, size);
2758     if (!value)
2759     {
2760         ERR("Failed to allocate data memory.\n");
2761         return E_OUTOFMEMORY;
2762     }
2763
2764     TRACE("Data: %s.\n", debugstr_an(ptr, size));
2765     memcpy(value, ptr, size);
2766
2767     hr = d3dx9_parse_value(param, value);
2768     if (hr != D3D_OK)
2769     {
2770         WARN("Failed to parse value\n");
2771         HeapFree(GetProcessHeap(), 0, value);
2772         return hr;
2773     }
2774
2775     param->data = value;
2776
2777     return D3D_OK;
2778 }
2779
2780 static HRESULT d3dx9_parse_name(char **name, const char *ptr)
2781 {
2782     DWORD size;
2783
2784     read_dword(&ptr, &size);
2785     TRACE("Name size: %#x\n", size);
2786
2787     if (!size)
2788     {
2789         return D3D_OK;
2790     }
2791
2792     *name = HeapAlloc(GetProcessHeap(), 0, size);
2793     if (!*name)
2794     {
2795         ERR("Failed to allocate name memory.\n");
2796         return E_OUTOFMEMORY;
2797     }
2798
2799     TRACE("Name: %s.\n", debugstr_an(ptr, size));
2800     memcpy(*name, ptr, size);
2801
2802     return D3D_OK;
2803 }
2804
2805 static HRESULT d3dx9_parse_effect_typedef(struct d3dx_parameter *param, const char *data, const char **ptr, struct d3dx_parameter *parent)
2806 {
2807     DWORD offset;
2808     HRESULT hr;
2809     D3DXHANDLE *member_handles = NULL;
2810     UINT i;
2811
2812     if (!parent)
2813     {
2814         read_dword(ptr, &param->type);
2815         TRACE("Type: %s\n", debug_d3dxparameter_type(param->type));
2816
2817         read_dword(ptr, &param->class);
2818         TRACE("Class: %s\n", debug_d3dxparameter_class(param->class));
2819
2820         read_dword(ptr, &offset);
2821         TRACE("Type name offset: %#x\n", offset);
2822         hr = d3dx9_parse_name(&param->name, data + offset);
2823         if (hr != D3D_OK)
2824         {
2825             WARN("Failed to parse name\n");
2826             goto err_out;
2827         }
2828
2829         read_dword(ptr, &offset);
2830         TRACE("Type semantic offset: %#x\n", offset);
2831         hr = d3dx9_parse_name(&param->semantic, data + offset);
2832         if (hr != D3D_OK)
2833         {
2834             WARN("Failed to parse semantic\n");
2835             goto err_out;
2836         }
2837
2838         read_dword(ptr, &param->element_count);
2839         TRACE("Elements: %u\n", param->element_count);
2840
2841         switch (param->class)
2842         {
2843             case D3DXPC_VECTOR:
2844                 read_dword(ptr, &param->columns);
2845                 TRACE("Columns: %u\n", param->columns);
2846
2847                 read_dword(ptr, &param->rows);
2848                 TRACE("Rows: %u\n", param->rows);
2849
2850                 /* sizeof(DWORD) * rows * columns */
2851                 param->bytes = 4 * param->rows * param->columns;
2852                 break;
2853
2854             case D3DXPC_SCALAR:
2855             case D3DXPC_MATRIX_ROWS:
2856             case D3DXPC_MATRIX_COLUMNS:
2857                 read_dword(ptr, &param->rows);
2858                 TRACE("Rows: %u\n", param->rows);
2859
2860                 read_dword(ptr, &param->columns);
2861                 TRACE("Columns: %u\n", param->columns);
2862
2863                 /* sizeof(DWORD) * rows * columns */
2864                 param->bytes = 4 * param->rows * param->columns;
2865                 break;
2866
2867             case D3DXPC_STRUCT:
2868                 read_dword(ptr, &param->member_count);
2869                 TRACE("Members: %u\n", param->member_count);
2870                 break;
2871
2872             default:
2873                 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
2874                 break;
2875         }
2876     }
2877     else
2878     {
2879         /* elements */
2880         param->type = parent->type;
2881         param->class = parent->class;
2882         param->name = parent->name;
2883         param->semantic = parent->semantic;
2884         param->element_count = 0;
2885         param->annotation_count = 0;
2886         param->member_count = parent->member_count;
2887         param->bytes = parent->bytes;
2888         param->flags = parent->flags;
2889         param->rows = parent->rows;
2890         param->columns = parent->columns;
2891     }
2892
2893     if (param->element_count)
2894     {
2895         unsigned int param_bytes = 0;
2896         const char *save_ptr = *ptr;
2897
2898         member_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member_handles) * param->element_count);
2899         if (!member_handles)
2900         {
2901             ERR("Out of memory\n");
2902             hr = E_OUTOFMEMORY;
2903             goto err_out;
2904         }
2905
2906         for (i = 0; i < param->element_count; ++i)
2907         {
2908             struct d3dx_parameter *member;
2909             *ptr = save_ptr;
2910
2911             member = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member));
2912             if (!member)
2913             {
2914                 ERR("Out of memory\n");
2915                 hr = E_OUTOFMEMORY;
2916                 goto err_out;
2917             }
2918
2919             member_handles[i] = get_parameter_handle(member);
2920             member->base = param->base;
2921
2922             hr = d3dx9_parse_effect_typedef(member, data, ptr, param);
2923             if (hr != D3D_OK)
2924             {
2925                 WARN("Failed to parse member\n");
2926                 goto err_out;
2927             }
2928
2929             param_bytes += member->bytes;
2930         }
2931
2932         param->bytes = param_bytes;
2933     }
2934     else if (param->member_count)
2935     {
2936         member_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member_handles) * param->member_count);
2937         if (!member_handles)
2938         {
2939             ERR("Out of memory\n");
2940             hr = E_OUTOFMEMORY;
2941             goto err_out;
2942         }
2943
2944         for (i = 0; i < param->member_count; ++i)
2945         {
2946             struct d3dx_parameter *member;
2947
2948             member = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member));
2949             if (!member)
2950             {
2951                 ERR("Out of memory\n");
2952                 hr = E_OUTOFMEMORY;
2953                 goto err_out;
2954             }
2955
2956             member_handles[i] = get_parameter_handle(member);
2957             member->base = param->base;
2958
2959             hr = d3dx9_parse_effect_typedef(member, data, ptr, NULL);
2960             if (hr != D3D_OK)
2961             {
2962                 WARN("Failed to parse member\n");
2963                 goto err_out;
2964             }
2965
2966             param->bytes += member->bytes;
2967         }
2968     }
2969
2970     param->member_handles = member_handles;
2971
2972     return D3D_OK;
2973
2974 err_out:
2975
2976     if (member_handles)
2977     {
2978         unsigned int count;
2979
2980         if (param->element_count) count = param->element_count;
2981         else count = param->member_count;
2982
2983         for (i = 0; i < count; ++i)
2984         {
2985             free_parameter(member_handles[i], param->element_count != 0, TRUE);
2986         }
2987         HeapFree(GetProcessHeap(), 0, member_handles);
2988     }
2989
2990     if (!parent)
2991     {
2992         HeapFree(GetProcessHeap(), 0, param->name);
2993         HeapFree(GetProcessHeap(), 0, param->semantic);
2994     }
2995     param->name = NULL;
2996     param->semantic = NULL;
2997
2998     return hr;
2999 }
3000
3001 static HRESULT d3dx9_parse_effect_annotation(struct d3dx_parameter *anno, const char *data, const char **ptr)
3002 {
3003     DWORD offset;
3004     const char *ptr2;
3005     HRESULT hr;
3006
3007     anno->flags = D3DX_PARAMETER_ANNOTATION;
3008
3009     read_dword(ptr, &offset);
3010     TRACE("Typedef offset: %#x\n", offset);
3011     ptr2 = data + offset;
3012     hr = d3dx9_parse_effect_typedef(anno, data, &ptr2, NULL);
3013     if (hr != D3D_OK)
3014     {
3015         WARN("Failed to parse type definition\n");
3016         return hr;
3017     }
3018
3019     read_dword(ptr, &offset);
3020     TRACE("Value offset: %#x\n", offset);
3021     hr = d3dx9_parse_init_value(anno, data + offset);
3022     if (hr != D3D_OK)
3023     {
3024         WARN("Failed to parse value\n");
3025         return hr;
3026     }
3027
3028     return D3D_OK;
3029 }
3030
3031 static HRESULT d3dx9_parse_effect_parameter(struct d3dx_parameter *param, const char *data, const char **ptr)
3032 {
3033     DWORD offset;
3034     HRESULT hr;
3035     unsigned int i;
3036     D3DXHANDLE *annotation_handles = NULL;
3037     const char *ptr2;
3038
3039     read_dword(ptr, &offset);
3040     TRACE("Typedef offset: %#x\n", offset);
3041     ptr2 = data + offset;
3042
3043     read_dword(ptr, &offset);
3044     TRACE("Value offset: %#x\n", offset);
3045
3046     read_dword(ptr, &param->flags);
3047     TRACE("Flags: %#x\n", param->flags);
3048
3049     read_dword(ptr, &param->annotation_count);
3050     TRACE("Annotation count: %u\n", param->annotation_count);
3051
3052     hr = d3dx9_parse_effect_typedef(param, data, &ptr2, NULL);
3053     if (hr != D3D_OK)
3054     {
3055         WARN("Failed to parse type definition\n");
3056         return hr;
3057     }
3058
3059     hr = d3dx9_parse_init_value(param, data + offset);
3060     if (hr != D3D_OK)
3061     {
3062         WARN("Failed to parse value\n");
3063         return hr;
3064     }
3065
3066     if (param->annotation_count)
3067     {
3068         annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * param->annotation_count);
3069         if (!annotation_handles)
3070         {
3071             ERR("Out of memory\n");
3072             hr = E_OUTOFMEMORY;
3073             goto err_out;
3074         }
3075
3076         for (i = 0; i < param->annotation_count; ++i)
3077         {
3078             struct d3dx_parameter *annotation;
3079
3080             annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
3081             if (!annotation)
3082             {
3083                 ERR("Out of memory\n");
3084                 hr = E_OUTOFMEMORY;
3085                 goto err_out;
3086             }
3087
3088             annotation_handles[i] = get_parameter_handle(annotation);
3089             annotation->base = param->base;
3090
3091             hr = d3dx9_parse_effect_annotation(annotation, data, ptr);
3092             if (hr != D3D_OK)
3093             {
3094                 WARN("Failed to parse annotation\n");
3095                 goto err_out;
3096             }
3097         }
3098     }
3099
3100     param->annotation_handles = annotation_handles;
3101
3102     return D3D_OK;
3103
3104 err_out:
3105
3106     if (annotation_handles)
3107     {
3108         for (i = 0; i < param->annotation_count; ++i)
3109         {
3110             free_parameter(annotation_handles[i], FALSE, FALSE);
3111         }
3112         HeapFree(GetProcessHeap(), 0, annotation_handles);
3113     }
3114
3115     return hr;
3116 }
3117
3118 static HRESULT d3dx9_parse_effect_pass(struct d3dx_pass *pass, const char *data, const char **ptr)
3119 {
3120     DWORD offset;
3121     HRESULT hr;
3122     unsigned int i;
3123     D3DXHANDLE *annotation_handles = NULL;
3124     char *name = NULL;
3125
3126     read_dword(ptr, &offset);
3127     TRACE("Pass name offset: %#x\n", offset);
3128     hr = d3dx9_parse_name(&name, data + offset);
3129     if (hr != D3D_OK)
3130     {
3131         WARN("Failed to parse name\n");
3132         goto err_out;
3133     }
3134
3135     read_dword(ptr, &pass->annotation_count);
3136     TRACE("Annotation count: %u\n", pass->annotation_count);
3137
3138     read_dword(ptr, &pass->state_count);
3139     TRACE("State count: %u\n", pass->state_count);
3140
3141     if (pass->annotation_count)
3142     {
3143         annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * pass->annotation_count);
3144         if (!annotation_handles)
3145         {
3146             ERR("Out of memory\n");
3147             hr = E_OUTOFMEMORY;
3148             goto err_out;
3149         }
3150
3151         for (i = 0; i < pass->annotation_count; ++i)
3152         {
3153             struct d3dx_parameter *annotation;
3154
3155             annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
3156             if (!annotation)
3157             {
3158                 ERR("Out of memory\n");
3159                 hr = E_OUTOFMEMORY;
3160                 goto err_out;
3161             }
3162
3163             annotation_handles[i] = get_parameter_handle(annotation);
3164             annotation->base = pass->base;
3165
3166             hr = d3dx9_parse_effect_annotation(annotation, data, ptr);
3167             if (hr != D3D_OK)
3168             {
3169                 WARN("Failed to parse annotations\n");
3170                 goto err_out;
3171             }
3172         }
3173     }
3174
3175     if (pass->state_count)
3176     {
3177         for (i = 0; i < pass->state_count; ++i)
3178         {
3179             skip_dword_unknown(ptr, 4);
3180         }
3181     }
3182
3183     pass->name = name;
3184     pass->annotation_handles = annotation_handles;
3185
3186     return D3D_OK;
3187
3188 err_out:
3189
3190     if (annotation_handles)
3191     {
3192         for (i = 0; i < pass->annotation_count; ++i)
3193         {
3194             free_parameter(annotation_handles[i], FALSE, FALSE);
3195         }
3196         HeapFree(GetProcessHeap(), 0, annotation_handles);
3197     }
3198
3199     HeapFree(GetProcessHeap(), 0, name);
3200
3201     return hr;
3202 }
3203
3204 static HRESULT d3dx9_parse_effect_technique(struct d3dx_technique *technique, const char *data, const char **ptr)
3205 {
3206     DWORD offset;
3207     HRESULT hr;
3208     unsigned int i;
3209     D3DXHANDLE *annotation_handles = NULL;
3210     D3DXHANDLE *pass_handles = NULL;
3211     char *name = NULL;
3212
3213     read_dword(ptr, &offset);
3214     TRACE("Technique name offset: %#x\n", offset);
3215     hr = d3dx9_parse_name(&name, data + offset);
3216     if (hr != D3D_OK)
3217     {
3218         WARN("Failed to parse name\n");
3219         goto err_out;
3220     }
3221
3222     read_dword(ptr, &technique->annotation_count);
3223     TRACE("Annotation count: %u\n", technique->annotation_count);
3224
3225     read_dword(ptr, &technique->pass_count);
3226     TRACE("Pass count: %u\n", technique->pass_count);
3227
3228     if (technique->annotation_count)
3229     {
3230         annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * technique->annotation_count);
3231         if (!annotation_handles)
3232         {
3233             ERR("Out of memory\n");
3234             hr = E_OUTOFMEMORY;
3235             goto err_out;
3236         }
3237
3238         for (i = 0; i < technique->annotation_count; ++i)
3239         {
3240             struct d3dx_parameter *annotation;
3241
3242             annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
3243             if (!annotation)
3244             {
3245                 ERR("Out of memory\n");
3246                 hr = E_OUTOFMEMORY;
3247                 goto err_out;
3248             }
3249
3250             annotation_handles[i] = get_parameter_handle(annotation);
3251             annotation->base = technique->base;
3252
3253             hr = d3dx9_parse_effect_annotation(annotation, data, ptr);
3254             if (hr != D3D_OK)
3255             {
3256                 WARN("Failed to parse annotations\n");
3257                 goto err_out;
3258             }
3259         }
3260     }
3261
3262     if (technique->pass_count)
3263     {
3264         pass_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pass_handles) * technique->pass_count);
3265         if (!pass_handles)
3266         {
3267             ERR("Out of memory\n");
3268             hr = E_OUTOFMEMORY;
3269             goto err_out;
3270         }
3271
3272         for (i = 0; i < technique->pass_count; ++i)
3273         {
3274             struct d3dx_pass *pass;
3275
3276             pass = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pass));
3277             if (!pass)
3278             {
3279                 ERR("Out of memory\n");
3280                 hr = E_OUTOFMEMORY;
3281                 goto err_out;
3282             }
3283
3284             pass_handles[i] = get_pass_handle(pass);
3285             pass->base = technique->base;
3286
3287             hr = d3dx9_parse_effect_pass(pass, data, ptr);
3288             if (hr != D3D_OK)
3289             {
3290                 WARN("Failed to parse passes\n");
3291                 goto err_out;
3292             }
3293         }
3294     }
3295
3296     technique->name = name;
3297     technique->pass_handles = pass_handles;
3298     technique->annotation_handles = annotation_handles;
3299
3300     return D3D_OK;
3301
3302 err_out:
3303
3304     if (pass_handles)
3305     {
3306         for (i = 0; i < technique->pass_count; ++i)
3307         {
3308             free_pass(pass_handles[i]);
3309         }
3310         HeapFree(GetProcessHeap(), 0, pass_handles);
3311     }
3312
3313     if (annotation_handles)
3314     {
3315         for (i = 0; i < technique->annotation_count; ++i)
3316         {
3317             free_parameter(annotation_handles[i], FALSE, FALSE);
3318         }
3319         HeapFree(GetProcessHeap(), 0, annotation_handles);
3320     }
3321
3322     HeapFree(GetProcessHeap(), 0, name);
3323
3324     return hr;
3325 }
3326
3327 static HRESULT d3dx9_parse_effect(struct ID3DXBaseEffectImpl *base, const char *data, UINT data_size, DWORD start)
3328 {
3329     const char *ptr = data + start;
3330     D3DXHANDLE *parameter_handles = NULL;
3331     D3DXHANDLE *technique_handles = NULL;
3332     HRESULT hr;
3333     unsigned int i;
3334
3335     read_dword(&ptr, &base->parameter_count);
3336     TRACE("Parameter count: %u\n", base->parameter_count);
3337
3338     read_dword(&ptr, &base->technique_count);
3339     TRACE("Technique count: %u\n", base->technique_count);
3340
3341     skip_dword_unknown(&ptr, 2);
3342
3343     if (base->parameter_count)
3344     {
3345         parameter_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter_handles) * base->parameter_count);
3346         if (!parameter_handles)
3347         {
3348             ERR("Out of memory\n");
3349             hr = E_OUTOFMEMORY;
3350             goto err_out;
3351         }
3352
3353         for (i = 0; i < base->parameter_count; ++i)
3354         {
3355             struct d3dx_parameter *parameter;
3356
3357             parameter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter));
3358             if (!parameter)
3359             {
3360                 ERR("Out of memory\n");
3361                 hr = E_OUTOFMEMORY;
3362                 goto err_out;
3363             }
3364
3365             parameter_handles[i] = get_parameter_handle(parameter);
3366             parameter->base = base;
3367
3368             hr = d3dx9_parse_effect_parameter(parameter, data, &ptr);
3369             if (hr != D3D_OK)
3370             {
3371                 WARN("Failed to parse parameter\n");
3372                 goto err_out;
3373             }
3374         }
3375     }
3376
3377     if (base->technique_count)
3378     {
3379         technique_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*technique_handles) * base->technique_count);
3380         if (!technique_handles)
3381         {
3382             ERR("Out of memory\n");
3383             hr = E_OUTOFMEMORY;
3384             goto err_out;
3385         }
3386
3387         for (i = 0; i < base->technique_count; ++i)
3388         {
3389             struct d3dx_technique *technique;
3390
3391             technique = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*technique));
3392             if (!technique)
3393             {
3394                 ERR("Out of memory\n");
3395                 hr = E_OUTOFMEMORY;
3396                 goto err_out;
3397             }
3398
3399             technique_handles[i] = get_technique_handle(technique);
3400             technique->base = base;
3401
3402             hr = d3dx9_parse_effect_technique(technique, data, &ptr);
3403             if (hr != D3D_OK)
3404             {
3405                 WARN("Failed to parse technique\n");
3406                 goto err_out;
3407             }
3408         }
3409     }
3410
3411     base->technique_handles = technique_handles;
3412     base->parameter_handles = parameter_handles;
3413
3414     return D3D_OK;
3415
3416 err_out:
3417
3418     if (technique_handles)
3419     {
3420         for (i = 0; i < base->technique_count; ++i)
3421         {
3422             free_technique(technique_handles[i]);
3423         }
3424         HeapFree(GetProcessHeap(), 0, technique_handles);
3425     }
3426
3427     if (parameter_handles)
3428     {
3429         for (i = 0; i < base->parameter_count; ++i)
3430         {
3431             free_parameter(parameter_handles[i], FALSE, FALSE);
3432         }
3433         HeapFree(GetProcessHeap(), 0, parameter_handles);
3434     }
3435
3436     return hr;
3437 }
3438
3439 static HRESULT d3dx9_base_effect_init(struct ID3DXBaseEffectImpl *base,
3440         const char *data, SIZE_T data_size, struct ID3DXEffectImpl *effect)
3441 {
3442     DWORD tag, offset;
3443     const char *ptr = data;
3444     HRESULT hr;
3445
3446     TRACE("base %p, data %p, data_size %lu, effect %p\n", base, data, data_size, effect);
3447
3448     base->ID3DXBaseEffect_iface.lpVtbl = &ID3DXBaseEffect_Vtbl;
3449     base->ref = 1;
3450     base->effect = effect;
3451
3452     read_dword(&ptr, &tag);
3453     TRACE("Tag: %x\n", tag);
3454
3455     if (tag != d3dx9_effect_version(9, 1))
3456     {
3457         /* todo: compile hlsl ascii code */
3458         FIXME("HLSL ascii effects not supported, yet\n");
3459
3460         /* Show the start of the shader for debugging info. */
3461         TRACE("effect:\n%s\n", debugstr_an(data, data_size > 40 ? 40 : data_size));
3462     }
3463     else
3464     {
3465         read_dword(&ptr, &offset);
3466         TRACE("Offset: %x\n", offset);
3467
3468         hr = d3dx9_parse_effect(base, ptr, data_size, offset);
3469         if (hr != D3D_OK)
3470         {
3471             FIXME("Failed to parse effect.\n");
3472             return hr;
3473         }
3474     }
3475
3476     return D3D_OK;
3477 }
3478
3479 static HRESULT d3dx9_effect_init(struct ID3DXEffectImpl *effect, LPDIRECT3DDEVICE9 device,
3480         const char *data, SIZE_T data_size, LPD3DXEFFECTPOOL pool)
3481 {
3482     HRESULT hr;
3483     struct ID3DXBaseEffectImpl *object = NULL;
3484
3485     TRACE("effect %p, device %p, data %p, data_size %lu, pool %p\n", effect, device, data, data_size, pool);
3486
3487     effect->ID3DXEffect_iface.lpVtbl = &ID3DXEffect_Vtbl;
3488     effect->ref = 1;
3489
3490     if (pool) pool->lpVtbl->AddRef(pool);
3491     effect->pool = pool;
3492
3493     IDirect3DDevice9_AddRef(device);
3494     effect->device = device;
3495
3496     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3497     if (!object)
3498     {
3499         ERR("Out of memory\n");
3500         hr = E_OUTOFMEMORY;
3501         goto err_out;
3502     }
3503
3504     hr = d3dx9_base_effect_init(object, data, data_size, effect);
3505     if (hr != D3D_OK)
3506     {
3507         FIXME("Failed to parse effect.\n");
3508         goto err_out;
3509     }
3510
3511     effect->base_effect = &object->ID3DXBaseEffect_iface;
3512
3513     return D3D_OK;
3514
3515 err_out:
3516
3517     HeapFree(GetProcessHeap(), 0, object);
3518     free_effect(effect);
3519
3520     return hr;
3521 }
3522
3523 HRESULT WINAPI D3DXCreateEffectEx(LPDIRECT3DDEVICE9 device,
3524                                   LPCVOID srcdata,
3525                                   UINT srcdatalen,
3526                                   CONST D3DXMACRO* defines,
3527                                   LPD3DXINCLUDE include,
3528                                   LPCSTR skip_constants,
3529                                   DWORD flags,
3530                                   LPD3DXEFFECTPOOL pool,
3531                                   LPD3DXEFFECT* effect,
3532                                   LPD3DXBUFFER* compilation_errors)
3533 {
3534     struct ID3DXEffectImpl *object;
3535     HRESULT hr;
3536
3537     FIXME("(%p, %p, %u, %p, %p, %p, %#x, %p, %p, %p): semi-stub\n", device, srcdata, srcdatalen, defines, include,
3538         skip_constants, flags, pool, effect, compilation_errors);
3539
3540     if (!device || !srcdata)
3541         return D3DERR_INVALIDCALL;
3542
3543     if (!srcdatalen)
3544         return E_FAIL;
3545
3546     /* Native dll allows effect to be null so just return D3D_OK after doing basic checks */
3547     if (!effect)
3548         return D3D_OK;
3549
3550     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3551     if (!object)
3552     {
3553         ERR("Out of memory\n");
3554         return E_OUTOFMEMORY;
3555     }
3556
3557     hr = d3dx9_effect_init(object, device, srcdata, srcdatalen, pool);
3558     if (FAILED(hr))
3559     {
3560         WARN("Failed to initialize shader reflection\n");
3561         HeapFree(GetProcessHeap(), 0, object);
3562         return hr;
3563     }
3564
3565     *effect = &object->ID3DXEffect_iface;
3566
3567     TRACE("Created ID3DXEffect %p\n", object);
3568
3569     return D3D_OK;
3570 }
3571
3572 HRESULT WINAPI D3DXCreateEffect(LPDIRECT3DDEVICE9 device,
3573                                 LPCVOID srcdata,
3574                                 UINT srcdatalen,
3575                                 CONST D3DXMACRO* defines,
3576                                 LPD3DXINCLUDE include,
3577                                 DWORD flags,
3578                                 LPD3DXEFFECTPOOL pool,
3579                                 LPD3DXEFFECT* effect,
3580                                 LPD3DXBUFFER* compilation_errors)
3581 {
3582     TRACE("(%p, %p, %u, %p, %p, %#x, %p, %p, %p): Forwarded to D3DXCreateEffectEx\n", device, srcdata, srcdatalen, defines,
3583         include, flags, pool, effect, compilation_errors);
3584
3585     return D3DXCreateEffectEx(device, srcdata, srcdatalen, defines, include, NULL, flags, pool, effect, compilation_errors);
3586 }
3587
3588 static HRESULT d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl *compiler, const char *data, SIZE_T data_size)
3589 {
3590     HRESULT hr;
3591     struct ID3DXBaseEffectImpl *object = NULL;
3592
3593     TRACE("effect %p, data %p, data_size %lu\n", compiler, data, data_size);
3594
3595     compiler->ID3DXEffectCompiler_iface.lpVtbl = &ID3DXEffectCompiler_Vtbl;
3596     compiler->ref = 1;
3597
3598     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3599     if (!object)
3600     {
3601         ERR("Out of memory\n");
3602         hr = E_OUTOFMEMORY;
3603         goto err_out;
3604     }
3605
3606     hr = d3dx9_base_effect_init(object, data, data_size, NULL);
3607     if (hr != D3D_OK)
3608     {
3609         FIXME("Failed to parse effect.\n");
3610         goto err_out;
3611     }
3612
3613     compiler->base_effect = &object->ID3DXBaseEffect_iface;
3614
3615     return D3D_OK;
3616
3617 err_out:
3618
3619     HeapFree(GetProcessHeap(), 0, object);
3620     free_effect_compiler(compiler);
3621
3622     return hr;
3623 }
3624
3625 HRESULT WINAPI D3DXCreateEffectCompiler(LPCSTR srcdata,
3626                                         UINT srcdatalen,
3627                                         CONST D3DXMACRO *defines,
3628                                         LPD3DXINCLUDE include,
3629                                         DWORD flags,
3630                                         LPD3DXEFFECTCOMPILER *compiler,
3631                                         LPD3DXBUFFER *parse_errors)
3632 {
3633     struct ID3DXEffectCompilerImpl *object;
3634     HRESULT hr;
3635
3636     TRACE("srcdata %p, srcdatalen %u, defines %p, include %p, flags %#x, compiler %p, parse_errors %p\n",
3637             srcdata, srcdatalen, defines, include, flags, compiler, parse_errors);
3638
3639     if (!srcdata || !compiler)
3640     {
3641         WARN("Invalid arguments supplied\n");
3642         return D3DERR_INVALIDCALL;
3643     }
3644
3645     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3646     if (!object)
3647     {
3648         ERR("Out of memory\n");
3649         return E_OUTOFMEMORY;
3650     }
3651
3652     hr = d3dx9_effect_compiler_init(object, srcdata, srcdatalen);
3653     if (FAILED(hr))
3654     {
3655         WARN("Failed to initialize effect compiler\n");
3656         HeapFree(GetProcessHeap(), 0, object);
3657         return hr;
3658     }
3659
3660     *compiler = &object->ID3DXEffectCompiler_iface;
3661
3662     TRACE("Created ID3DXEffectCompiler %p\n", object);
3663
3664     return D3D_OK;
3665 }
3666
3667 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl;
3668
3669 struct ID3DXEffectPoolImpl
3670 {
3671     ID3DXEffectPool ID3DXEffectPool_iface;
3672     LONG ref;
3673 };
3674
3675 static inline struct ID3DXEffectPoolImpl *impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
3676 {
3677     return CONTAINING_RECORD(iface, struct ID3DXEffectPoolImpl, ID3DXEffectPool_iface);
3678 }
3679
3680 /*** IUnknown methods ***/
3681 static HRESULT WINAPI ID3DXEffectPoolImpl_QueryInterface(ID3DXEffectPool *iface, REFIID riid, void **object)
3682 {
3683     struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
3684
3685     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
3686
3687     if (IsEqualGUID(riid, &IID_IUnknown) ||
3688         IsEqualGUID(riid, &IID_ID3DXEffectPool))
3689     {
3690         This->ID3DXEffectPool_iface.lpVtbl->AddRef(iface);
3691         *object = This;
3692         return S_OK;
3693     }
3694
3695     WARN("Interface %s not found\n", debugstr_guid(riid));
3696
3697     return E_NOINTERFACE;
3698 }
3699
3700 static ULONG WINAPI ID3DXEffectPoolImpl_AddRef(ID3DXEffectPool *iface)
3701 {
3702     struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
3703
3704     TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
3705
3706     return InterlockedIncrement(&This->ref);
3707 }
3708
3709 static ULONG WINAPI ID3DXEffectPoolImpl_Release(ID3DXEffectPool *iface)
3710 {
3711     struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
3712     ULONG ref = InterlockedDecrement(&This->ref);
3713
3714     TRACE("(%p)->(): Release from %u\n", This, ref + 1);
3715
3716     if (!ref)
3717         HeapFree(GetProcessHeap(), 0, This);
3718
3719     return ref;
3720 }
3721
3722 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl =
3723 {
3724     /*** IUnknown methods ***/
3725     ID3DXEffectPoolImpl_QueryInterface,
3726     ID3DXEffectPoolImpl_AddRef,
3727     ID3DXEffectPoolImpl_Release
3728 };
3729
3730 HRESULT WINAPI D3DXCreateEffectPool(LPD3DXEFFECTPOOL *pool)
3731 {
3732     struct ID3DXEffectPoolImpl *object;
3733
3734     TRACE("(%p)\n", pool);
3735
3736     if (!pool)
3737         return D3DERR_INVALIDCALL;
3738
3739     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3740     if (!object)
3741     {
3742         ERR("Out of memory\n");
3743         return E_OUTOFMEMORY;
3744     }
3745
3746     object->ID3DXEffectPool_iface.lpVtbl = &ID3DXEffectPool_Vtbl;
3747     object->ref = 1;
3748
3749     *pool = &object->ID3DXEffectPool_iface;
3750
3751     return S_OK;
3752 }
3753
3754 HRESULT WINAPI D3DXCreateEffectFromFileExW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
3755     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
3756     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
3757 {
3758     LPVOID buffer;
3759     HRESULT ret;
3760     DWORD size;
3761
3762     TRACE("(%s): relay\n", debugstr_w(srcfile));
3763
3764     if (!device || !srcfile || !defines)
3765         return D3DERR_INVALIDCALL;
3766
3767     ret = map_view_of_file(srcfile, &buffer, &size);
3768
3769     if (FAILED(ret))
3770         return D3DXERR_INVALIDDATA;
3771
3772     ret = D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
3773     UnmapViewOfFile(buffer);
3774
3775     return ret;
3776 }
3777
3778 HRESULT WINAPI D3DXCreateEffectFromFileExA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
3779     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
3780     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
3781 {
3782     LPWSTR srcfileW;
3783     HRESULT ret;
3784     DWORD len;
3785
3786     TRACE("(void): relay\n");
3787
3788     if (!srcfile || !defines)
3789         return D3DERR_INVALIDCALL;
3790
3791     len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
3792     srcfileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*srcfileW));
3793     MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
3794
3795     ret = D3DXCreateEffectFromFileExW(device, srcfileW, defines, include, skipconstants, flags, pool, effect, compilationerrors);
3796     HeapFree(GetProcessHeap(), 0, srcfileW);
3797
3798     return ret;
3799 }
3800
3801 HRESULT WINAPI D3DXCreateEffectFromFileW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
3802     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
3803     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
3804 {
3805     TRACE("(void): relay\n");
3806     return D3DXCreateEffectFromFileExW(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
3807 }
3808
3809 HRESULT WINAPI D3DXCreateEffectFromFileA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
3810     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
3811     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
3812 {
3813     TRACE("(void): relay\n");
3814     return D3DXCreateEffectFromFileExA(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
3815 }
3816
3817 HRESULT WINAPI D3DXCreateEffectFromResourceExW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
3818     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
3819     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
3820 {
3821     HRSRC resinfo;
3822
3823     TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
3824
3825     if (!device || !defines)
3826         return D3DERR_INVALIDCALL;
3827
3828     resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
3829
3830     if (resinfo)
3831     {
3832         LPVOID buffer;
3833         HRESULT ret;
3834         DWORD size;
3835
3836         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
3837
3838         if (FAILED(ret))
3839             return D3DXERR_INVALIDDATA;
3840
3841         return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
3842     }
3843
3844     return D3DXERR_INVALIDDATA;
3845 }
3846
3847 HRESULT WINAPI D3DXCreateEffectFromResourceExA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
3848     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
3849     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
3850 {
3851     HRSRC resinfo;
3852
3853     TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
3854
3855     if (!device || !defines)
3856         return D3DERR_INVALIDCALL;
3857
3858     resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
3859
3860     if (resinfo)
3861     {
3862         LPVOID buffer;
3863         HRESULT ret;
3864         DWORD size;
3865
3866         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
3867
3868         if (FAILED(ret))
3869             return D3DXERR_INVALIDDATA;
3870
3871         return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
3872     }
3873
3874     return D3DXERR_INVALIDDATA;
3875 }
3876
3877 HRESULT WINAPI D3DXCreateEffectFromResourceW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
3878     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
3879     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
3880 {
3881     TRACE("(void): relay\n");
3882     return D3DXCreateEffectFromResourceExW(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
3883 }
3884
3885 HRESULT WINAPI D3DXCreateEffectFromResourceA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
3886     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
3887     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
3888 {
3889     TRACE("(void): relay\n");
3890     return D3DXCreateEffectFromResourceExA(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
3891 }
3892
3893 HRESULT WINAPI D3DXCreateEffectCompilerFromFileW(LPCWSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
3894     DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
3895 {
3896     LPVOID buffer;
3897     HRESULT ret;
3898     DWORD size;
3899
3900     TRACE("(%s): relay\n", debugstr_w(srcfile));
3901
3902     if (!srcfile || !defines)
3903         return D3DERR_INVALIDCALL;
3904
3905     ret = map_view_of_file(srcfile, &buffer, &size);
3906
3907     if (FAILED(ret))
3908         return D3DXERR_INVALIDDATA;
3909
3910     ret = D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
3911     UnmapViewOfFile(buffer);
3912
3913     return ret;
3914 }
3915
3916 HRESULT WINAPI D3DXCreateEffectCompilerFromFileA(LPCSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
3917     DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
3918 {
3919     LPWSTR srcfileW;
3920     HRESULT ret;
3921     DWORD len;
3922
3923     TRACE("(void): relay\n");
3924
3925     if (!srcfile || !defines)
3926         return D3DERR_INVALIDCALL;
3927
3928     len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
3929     srcfileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*srcfileW));
3930     MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
3931
3932     ret = D3DXCreateEffectCompilerFromFileW(srcfileW, defines, include, flags, effectcompiler, parseerrors);
3933     HeapFree(GetProcessHeap(), 0, srcfileW);
3934
3935     return ret;
3936 }
3937
3938 HRESULT WINAPI D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule, LPCSTR srcresource, const D3DXMACRO *defines,
3939     LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
3940 {
3941     HRSRC resinfo;
3942
3943     TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
3944
3945     resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
3946
3947     if (resinfo)
3948     {
3949         LPVOID buffer;
3950         HRESULT ret;
3951         DWORD size;
3952
3953         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
3954
3955         if (FAILED(ret))
3956             return D3DXERR_INVALIDDATA;
3957
3958         return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
3959     }
3960
3961     return D3DXERR_INVALIDDATA;
3962 }
3963
3964 HRESULT WINAPI D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule, LPCWSTR srcresource, const D3DXMACRO *defines,
3965     LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
3966 {
3967     HRSRC resinfo;
3968
3969     TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
3970
3971     resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
3972
3973     if (resinfo)
3974     {
3975         LPVOID buffer;
3976         HRESULT ret;
3977         DWORD size;
3978
3979         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
3980
3981         if (FAILED(ret))
3982             return D3DXERR_INVALIDDATA;
3983
3984         return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
3985     }
3986
3987     return D3DXERR_INVALIDDATA;
3988 }