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