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