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     struct d3dx_parameter *param = is_valid_parameter(This, parameter);
1573
1574     TRACE("iface %p, parameter %p, texture %p\n", This, parameter, texture);
1575
1576     if (texture && param && !param->element_count &&
1577             (param->type == D3DXPT_TEXTURE || param->type == D3DXPT_TEXTURE1D
1578             || param->type == D3DXPT_TEXTURE2D || param->type ==  D3DXPT_TEXTURE3D
1579             || param->type == D3DXPT_TEXTURECUBE))
1580     {
1581         *texture = *(LPDIRECT3DBASETEXTURE9 *)param->data;
1582         if (*texture) IDirect3DBaseTexture9_AddRef(*texture);
1583         TRACE("Returning %p\n", *texture);
1584         return D3D_OK;
1585     }
1586
1587     WARN("Invalid argument specified\n");
1588
1589     return D3DERR_INVALIDCALL;
1590 }
1591
1592 static HRESULT WINAPI ID3DXBaseEffectImpl_GetPixelShader(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
1593 {
1594     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1595     struct d3dx_parameter *param = is_valid_parameter(This, parameter);
1596
1597     TRACE("iface %p, parameter %p, pshader %p\n", This, parameter, pshader);
1598
1599     if (!param) param = get_parameter_by_name(This, NULL, parameter);
1600
1601     if (pshader && param && !param->element_count && param->type == D3DXPT_PIXELSHADER)
1602     {
1603         *pshader = *(LPDIRECT3DPIXELSHADER9 *)param->data;
1604         if (*pshader) IDirect3DPixelShader9_AddRef(*pshader);
1605         TRACE("Returning %p\n", *pshader);
1606         return D3D_OK;
1607     }
1608
1609     WARN("Invalid argument specified\n");
1610
1611     return D3DERR_INVALIDCALL;
1612 }
1613
1614 static HRESULT WINAPI ID3DXBaseEffectImpl_GetVertexShader(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
1615 {
1616     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1617     struct d3dx_parameter *param = is_valid_parameter(This, parameter);
1618
1619     TRACE("iface %p, parameter %p, vshader %p\n", This, parameter, vshader);
1620
1621     if (!param) param = get_parameter_by_name(This, NULL, parameter);
1622
1623     if (vshader && param && !param->element_count && param->type == D3DXPT_VERTEXSHADER)
1624     {
1625         *vshader = *(LPDIRECT3DVERTEXSHADER9 *)param->data;
1626         if (*vshader) IDirect3DVertexShader9_AddRef(*vshader);
1627         TRACE("Returning %p\n", *vshader);
1628         return D3D_OK;
1629     }
1630
1631     WARN("Invalid argument specified\n");
1632
1633     return D3DERR_INVALIDCALL;
1634 }
1635
1636 static HRESULT WINAPI ID3DXBaseEffectImpl_SetArrayRange(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
1637 {
1638     struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1639
1640     FIXME("iface %p, parameter %p, start %u, end %u stub\n", This, parameter, start, end);
1641
1642     return E_NOTIMPL;
1643 }
1644
1645 static const struct ID3DXBaseEffectVtbl ID3DXBaseEffect_Vtbl =
1646 {
1647     /*** IUnknown methods ***/
1648     ID3DXBaseEffectImpl_QueryInterface,
1649     ID3DXBaseEffectImpl_AddRef,
1650     ID3DXBaseEffectImpl_Release,
1651     /*** ID3DXBaseEffect methods ***/
1652     ID3DXBaseEffectImpl_GetDesc,
1653     ID3DXBaseEffectImpl_GetParameterDesc,
1654     ID3DXBaseEffectImpl_GetTechniqueDesc,
1655     ID3DXBaseEffectImpl_GetPassDesc,
1656     ID3DXBaseEffectImpl_GetFunctionDesc,
1657     ID3DXBaseEffectImpl_GetParameter,
1658     ID3DXBaseEffectImpl_GetParameterByName,
1659     ID3DXBaseEffectImpl_GetParameterBySemantic,
1660     ID3DXBaseEffectImpl_GetParameterElement,
1661     ID3DXBaseEffectImpl_GetTechnique,
1662     ID3DXBaseEffectImpl_GetTechniqueByName,
1663     ID3DXBaseEffectImpl_GetPass,
1664     ID3DXBaseEffectImpl_GetPassByName,
1665     ID3DXBaseEffectImpl_GetFunction,
1666     ID3DXBaseEffectImpl_GetFunctionByName,
1667     ID3DXBaseEffectImpl_GetAnnotation,
1668     ID3DXBaseEffectImpl_GetAnnotationByName,
1669     ID3DXBaseEffectImpl_SetValue,
1670     ID3DXBaseEffectImpl_GetValue,
1671     ID3DXBaseEffectImpl_SetBool,
1672     ID3DXBaseEffectImpl_GetBool,
1673     ID3DXBaseEffectImpl_SetBoolArray,
1674     ID3DXBaseEffectImpl_GetBoolArray,
1675     ID3DXBaseEffectImpl_SetInt,
1676     ID3DXBaseEffectImpl_GetInt,
1677     ID3DXBaseEffectImpl_SetIntArray,
1678     ID3DXBaseEffectImpl_GetIntArray,
1679     ID3DXBaseEffectImpl_SetFloat,
1680     ID3DXBaseEffectImpl_GetFloat,
1681     ID3DXBaseEffectImpl_SetFloatArray,
1682     ID3DXBaseEffectImpl_GetFloatArray,
1683     ID3DXBaseEffectImpl_SetVector,
1684     ID3DXBaseEffectImpl_GetVector,
1685     ID3DXBaseEffectImpl_SetVectorArray,
1686     ID3DXBaseEffectImpl_GetVectorArray,
1687     ID3DXBaseEffectImpl_SetMatrix,
1688     ID3DXBaseEffectImpl_GetMatrix,
1689     ID3DXBaseEffectImpl_SetMatrixArray,
1690     ID3DXBaseEffectImpl_GetMatrixArray,
1691     ID3DXBaseEffectImpl_SetMatrixPointerArray,
1692     ID3DXBaseEffectImpl_GetMatrixPointerArray,
1693     ID3DXBaseEffectImpl_SetMatrixTranspose,
1694     ID3DXBaseEffectImpl_GetMatrixTranspose,
1695     ID3DXBaseEffectImpl_SetMatrixTransposeArray,
1696     ID3DXBaseEffectImpl_GetMatrixTransposeArray,
1697     ID3DXBaseEffectImpl_SetMatrixTransposePointerArray,
1698     ID3DXBaseEffectImpl_GetMatrixTransposePointerArray,
1699     ID3DXBaseEffectImpl_SetString,
1700     ID3DXBaseEffectImpl_GetString,
1701     ID3DXBaseEffectImpl_SetTexture,
1702     ID3DXBaseEffectImpl_GetTexture,
1703     ID3DXBaseEffectImpl_GetPixelShader,
1704     ID3DXBaseEffectImpl_GetVertexShader,
1705     ID3DXBaseEffectImpl_SetArrayRange,
1706 };
1707
1708 static inline struct ID3DXEffectImpl *impl_from_ID3DXEffect(ID3DXEffect *iface)
1709 {
1710     return CONTAINING_RECORD(iface, struct ID3DXEffectImpl, ID3DXEffect_iface);
1711 }
1712
1713 /*** IUnknown methods ***/
1714 static HRESULT WINAPI ID3DXEffectImpl_QueryInterface(ID3DXEffect *iface, REFIID riid, void **object)
1715 {
1716     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1717
1718     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
1719
1720     if (IsEqualGUID(riid, &IID_IUnknown) ||
1721         IsEqualGUID(riid, &IID_ID3DXEffect))
1722     {
1723         This->ID3DXEffect_iface.lpVtbl->AddRef(iface);
1724         *object = This;
1725         return S_OK;
1726     }
1727
1728     ERR("Interface %s not found\n", debugstr_guid(riid));
1729
1730     return E_NOINTERFACE;
1731 }
1732
1733 static ULONG WINAPI ID3DXEffectImpl_AddRef(ID3DXEffect *iface)
1734 {
1735     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1736
1737     TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
1738
1739     return InterlockedIncrement(&This->ref);
1740 }
1741
1742 static ULONG WINAPI ID3DXEffectImpl_Release(ID3DXEffect *iface)
1743 {
1744     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1745     ULONG ref = InterlockedDecrement(&This->ref);
1746
1747     TRACE("(%p)->(): Release from %u\n", This, ref + 1);
1748
1749     if (!ref)
1750     {
1751         free_effect(This);
1752         HeapFree(GetProcessHeap(), 0, This);
1753     }
1754
1755     return ref;
1756 }
1757
1758 /*** ID3DXBaseEffect methods ***/
1759 static HRESULT WINAPI ID3DXEffectImpl_GetDesc(ID3DXEffect *iface, D3DXEFFECT_DESC *desc)
1760 {
1761     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1762     ID3DXBaseEffect *base = This->base_effect;
1763
1764     TRACE("Forward iface %p, base %p\n", This, base);
1765
1766     return ID3DXBaseEffectImpl_GetDesc(base, desc);
1767 }
1768
1769 static HRESULT WINAPI ID3DXEffectImpl_GetParameterDesc(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
1770 {
1771     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1772     ID3DXBaseEffect *base = This->base_effect;
1773
1774     TRACE("Forward iface %p, base %p\n", This, base);
1775
1776     return ID3DXBaseEffectImpl_GetParameterDesc(base, parameter, desc);
1777 }
1778
1779 static HRESULT WINAPI ID3DXEffectImpl_GetTechniqueDesc(ID3DXEffect *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
1780 {
1781     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1782     ID3DXBaseEffect *base = This->base_effect;
1783
1784     TRACE("Forward iface %p, base %p\n", This, base);
1785
1786     return ID3DXBaseEffectImpl_GetTechniqueDesc(base, technique, desc);
1787 }
1788
1789 static HRESULT WINAPI ID3DXEffectImpl_GetPassDesc(ID3DXEffect *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
1790 {
1791     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1792     ID3DXBaseEffect *base = This->base_effect;
1793
1794     TRACE("Forward iface %p, base %p\n", This, base);
1795
1796     return ID3DXBaseEffectImpl_GetPassDesc(base, pass, desc);
1797 }
1798
1799 static HRESULT WINAPI ID3DXEffectImpl_GetFunctionDesc(ID3DXEffect *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
1800 {
1801     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1802     ID3DXBaseEffect *base = This->base_effect;
1803
1804     TRACE("Forward iface %p, base %p\n", This, base);
1805
1806     return ID3DXBaseEffectImpl_GetFunctionDesc(base, shader, desc);
1807 }
1808
1809 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameter(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
1810 {
1811     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1812     ID3DXBaseEffect *base = This->base_effect;
1813
1814     TRACE("Forward iface %p, base %p\n", This, base);
1815
1816     return ID3DXBaseEffectImpl_GetParameter(base, parameter, index);
1817 }
1818
1819 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterByName(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR name)
1820 {
1821     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1822     ID3DXBaseEffect *base = This->base_effect;
1823
1824     TRACE("Forward iface %p, base %p\n", This, base);
1825
1826     return ID3DXBaseEffectImpl_GetParameterByName(base, parameter, name);
1827 }
1828
1829 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterBySemantic(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR semantic)
1830 {
1831     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1832     ID3DXBaseEffect *base = This->base_effect;
1833
1834     TRACE("Forward iface %p, base %p\n", This, base);
1835
1836     return ID3DXBaseEffectImpl_GetParameterBySemantic(base, parameter, semantic);
1837 }
1838
1839 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterElement(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
1840 {
1841     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1842     ID3DXBaseEffect *base = This->base_effect;
1843
1844     TRACE("Forward iface %p, base %p\n", This, base);
1845
1846     return ID3DXBaseEffectImpl_GetParameterElement(base, parameter, index);
1847 }
1848
1849 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechnique(ID3DXEffect *iface, UINT index)
1850 {
1851     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1852     ID3DXBaseEffect *base = This->base_effect;
1853
1854     TRACE("Forward iface %p, base %p\n", This, base);
1855
1856     return ID3DXBaseEffectImpl_GetTechnique(base, index);
1857 }
1858
1859 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechniqueByName(ID3DXEffect *iface, LPCSTR name)
1860 {
1861     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1862     ID3DXBaseEffect *base = This->base_effect;
1863
1864     TRACE("Forward iface %p, base %p\n", This, base);
1865
1866     return ID3DXBaseEffectImpl_GetTechniqueByName(base, name);
1867 }
1868
1869 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPass(ID3DXEffect *iface, D3DXHANDLE technique, UINT index)
1870 {
1871     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1872     ID3DXBaseEffect *base = This->base_effect;
1873
1874     TRACE("Forward iface %p, base %p\n", This, base);
1875
1876     return ID3DXBaseEffectImpl_GetPass(base, technique, index);
1877 }
1878
1879 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPassByName(ID3DXEffect *iface, D3DXHANDLE technique, LPCSTR name)
1880 {
1881     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1882     ID3DXBaseEffect *base = This->base_effect;
1883
1884     TRACE("Forward iface %p, base %p\n", This, base);
1885
1886     return ID3DXBaseEffectImpl_GetPassByName(base, technique, name);
1887 }
1888
1889 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunction(ID3DXEffect *iface, UINT index)
1890 {
1891     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1892     ID3DXBaseEffect *base = This->base_effect;
1893
1894     TRACE("Forward iface %p, base %p\n", This, base);
1895
1896     return ID3DXBaseEffectImpl_GetFunction(base, index);
1897 }
1898
1899 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunctionByName(ID3DXEffect *iface, LPCSTR name)
1900 {
1901     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1902     ID3DXBaseEffect *base = This->base_effect;
1903
1904     TRACE("Forward iface %p, base %p\n", This, base);
1905
1906     return ID3DXBaseEffectImpl_GetFunctionByName(base, name);
1907 }
1908
1909 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotation(ID3DXEffect *iface, D3DXHANDLE object, UINT index)
1910 {
1911     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1912     ID3DXBaseEffect *base = This->base_effect;
1913
1914     TRACE("Forward iface %p, base %p\n", This, base);
1915
1916     return ID3DXBaseEffectImpl_GetAnnotation(base, object, index);
1917 }
1918
1919 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotationByName(ID3DXEffect *iface, D3DXHANDLE object, LPCSTR name)
1920 {
1921     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1922     ID3DXBaseEffect *base = This->base_effect;
1923
1924     TRACE("Forward iface %p, base %p\n", This, base);
1925
1926     return ID3DXBaseEffectImpl_GetAnnotationByName(base, object, name);
1927 }
1928
1929 static HRESULT WINAPI ID3DXEffectImpl_SetValue(ID3DXEffect *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
1930 {
1931     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1932     ID3DXBaseEffect *base = This->base_effect;
1933
1934     TRACE("Forward iface %p, base %p\n", This, base);
1935
1936     return ID3DXBaseEffectImpl_SetValue(base, parameter, data, bytes);
1937 }
1938
1939 static HRESULT WINAPI ID3DXEffectImpl_GetValue(ID3DXEffect *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
1940 {
1941     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1942     ID3DXBaseEffect *base = This->base_effect;
1943
1944     TRACE("Forward iface %p, base %p\n", This, base);
1945
1946     return ID3DXBaseEffectImpl_GetValue(base, parameter, data, bytes);
1947 }
1948
1949 static HRESULT WINAPI ID3DXEffectImpl_SetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL b)
1950 {
1951     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1952     ID3DXBaseEffect *base = This->base_effect;
1953
1954     TRACE("Forward iface %p, base %p\n", This, base);
1955
1956     return ID3DXBaseEffectImpl_SetBool(base, parameter, b);
1957 }
1958
1959 static HRESULT WINAPI ID3DXEffectImpl_GetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b)
1960 {
1961     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1962     ID3DXBaseEffect *base = This->base_effect;
1963
1964     TRACE("Forward iface %p, base %p\n", This, base);
1965
1966     return ID3DXBaseEffectImpl_GetBool(base, parameter, b);
1967 }
1968
1969 static HRESULT WINAPI ID3DXEffectImpl_SetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
1970 {
1971     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1972     ID3DXBaseEffect *base = This->base_effect;
1973
1974     TRACE("Forward iface %p, base %p\n", This, base);
1975
1976     return ID3DXBaseEffectImpl_SetBoolArray(base, parameter, b, count);
1977 }
1978
1979 static HRESULT WINAPI ID3DXEffectImpl_GetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
1980 {
1981     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1982     ID3DXBaseEffect *base = This->base_effect;
1983
1984     TRACE("Forward iface %p, base %p\n", This, base);
1985
1986     return ID3DXBaseEffectImpl_GetBoolArray(base, parameter, b, count);
1987 }
1988
1989 static HRESULT WINAPI ID3DXEffectImpl_SetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT n)
1990 {
1991     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
1992     ID3DXBaseEffect *base = This->base_effect;
1993
1994     TRACE("Forward iface %p, base %p\n", This, base);
1995
1996     return ID3DXBaseEffectImpl_SetInt(base, parameter, n);
1997 }
1998
1999 static HRESULT WINAPI ID3DXEffectImpl_GetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n)
2000 {
2001     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2002     ID3DXBaseEffect *base = This->base_effect;
2003
2004     TRACE("Forward iface %p, base %p\n", This, base);
2005
2006     return ID3DXBaseEffectImpl_GetInt(base, parameter, n);
2007 }
2008
2009 static HRESULT WINAPI ID3DXEffectImpl_SetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
2010 {
2011     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2012     ID3DXBaseEffect *base = This->base_effect;
2013
2014     TRACE("Forward iface %p, base %p\n", This, base);
2015
2016     return ID3DXBaseEffectImpl_SetIntArray(base, parameter, n, count);
2017 }
2018
2019 static HRESULT WINAPI ID3DXEffectImpl_GetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n, UINT count)
2020 {
2021     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2022     ID3DXBaseEffect *base = This->base_effect;
2023
2024     TRACE("Forward iface %p, base %p\n", This, base);
2025
2026     return ID3DXBaseEffectImpl_GetIntArray(base, parameter, n, count);
2027 }
2028
2029 static HRESULT WINAPI ID3DXEffectImpl_SetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT f)
2030 {
2031     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2032     ID3DXBaseEffect *base = This->base_effect;
2033
2034     TRACE("Forward iface %p, base %p\n", This, base);
2035
2036     return ID3DXBaseEffectImpl_SetFloat(base, parameter, f);
2037 }
2038
2039 static HRESULT WINAPI ID3DXEffectImpl_GetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT *f)
2040 {
2041     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2042     ID3DXBaseEffect *base = This->base_effect;
2043
2044     TRACE("Forward iface %p, base %p\n", This, base);
2045
2046     return ID3DXBaseEffectImpl_GetFloat(base, parameter, f);
2047 }
2048
2049 static HRESULT WINAPI ID3DXEffectImpl_SetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
2050 {
2051     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2052     ID3DXBaseEffect *base = This->base_effect;
2053
2054     TRACE("Forward iface %p, base %p\n", This, base);
2055
2056     return ID3DXBaseEffectImpl_SetFloatArray(base, parameter, f, count);
2057 }
2058
2059 static HRESULT WINAPI ID3DXEffectImpl_GetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
2060 {
2061     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2062     ID3DXBaseEffect *base = This->base_effect;
2063
2064     TRACE("Forward iface %p, base %p\n", This, base);
2065
2066     return ID3DXBaseEffectImpl_GetFloatArray(base, parameter, f, count);
2067 }
2068
2069 static HRESULT WINAPI ID3DXEffectImpl_SetVector(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector)
2070 {
2071     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2072     ID3DXBaseEffect *base = This->base_effect;
2073
2074     TRACE("Forward iface %p, base %p\n", This, base);
2075
2076     return ID3DXBaseEffectImpl_SetVector(base, parameter, vector);
2077 }
2078
2079 static HRESULT WINAPI ID3DXEffectImpl_GetVector(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
2080 {
2081     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2082     ID3DXBaseEffect *base = This->base_effect;
2083
2084     TRACE("Forward iface %p, base %p\n", This, base);
2085
2086     return ID3DXBaseEffectImpl_GetVector(base, parameter, vector);
2087 }
2088
2089 static HRESULT WINAPI ID3DXEffectImpl_SetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
2090 {
2091     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2092     ID3DXBaseEffect *base = This->base_effect;
2093
2094     TRACE("Forward iface %p, base %p\n", This, base);
2095
2096     return ID3DXBaseEffectImpl_SetVectorArray(base, parameter, vector, count);
2097 }
2098
2099 static HRESULT WINAPI ID3DXEffectImpl_GetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
2100 {
2101     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2102     ID3DXBaseEffect *base = This->base_effect;
2103
2104     TRACE("Forward iface %p, base %p\n", This, base);
2105
2106     return ID3DXBaseEffectImpl_GetVectorArray(base, parameter, vector, count);
2107 }
2108
2109 static HRESULT WINAPI ID3DXEffectImpl_SetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
2110 {
2111     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2112     ID3DXBaseEffect *base = This->base_effect;
2113
2114     TRACE("Forward iface %p, base %p\n", This, base);
2115
2116     return ID3DXBaseEffectImpl_SetMatrix(base, parameter, matrix);
2117 }
2118
2119 static HRESULT WINAPI ID3DXEffectImpl_GetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
2120 {
2121     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2122     ID3DXBaseEffect *base = This->base_effect;
2123
2124     TRACE("Forward iface %p, base %p\n", This, base);
2125
2126     return ID3DXBaseEffectImpl_GetMatrix(base, parameter, matrix);
2127 }
2128
2129 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
2130 {
2131     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2132     ID3DXBaseEffect *base = This->base_effect;
2133
2134     TRACE("Forward iface %p, base %p\n", This, base);
2135
2136     return ID3DXBaseEffectImpl_SetMatrixArray(base, parameter, matrix, count);
2137 }
2138
2139 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
2140 {
2141     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2142     ID3DXBaseEffect *base = This->base_effect;
2143
2144     TRACE("Forward iface %p, base %p\n", This, base);
2145
2146     return ID3DXBaseEffectImpl_GetMatrixArray(base, parameter, matrix, count);
2147 }
2148
2149 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
2150 {
2151     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2152     ID3DXBaseEffect *base = This->base_effect;
2153
2154     TRACE("Forward iface %p, base %p\n", This, base);
2155
2156     return ID3DXBaseEffectImpl_SetMatrixPointerArray(base, parameter, matrix, count);
2157 }
2158
2159 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
2160 {
2161     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2162     ID3DXBaseEffect *base = This->base_effect;
2163
2164     TRACE("Forward iface %p, base %p\n", This, base);
2165
2166     return ID3DXBaseEffectImpl_GetMatrixPointerArray(base, parameter, matrix, count);
2167 }
2168
2169 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
2170 {
2171     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2172     ID3DXBaseEffect *base = This->base_effect;
2173
2174     TRACE("Forward iface %p, base %p\n", This, base);
2175
2176     return ID3DXBaseEffectImpl_SetMatrixTranspose(base, parameter, matrix);
2177 }
2178
2179 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
2180 {
2181     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2182     ID3DXBaseEffect *base = This->base_effect;
2183
2184     TRACE("Forward iface %p, base %p\n", This, base);
2185
2186     return ID3DXBaseEffectImpl_GetMatrixTranspose(base, parameter, matrix);
2187 }
2188
2189 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
2190 {
2191     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2192     ID3DXBaseEffect *base = This->base_effect;
2193
2194     TRACE("Forward iface %p, base %p\n", This, base);
2195
2196     return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base, parameter, matrix, count);
2197 }
2198
2199 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
2200 {
2201     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2202     ID3DXBaseEffect *base = This->base_effect;
2203
2204     TRACE("Forward iface %p, base %p\n", This, base);
2205
2206     return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base, parameter, matrix, count);
2207 }
2208
2209 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
2210 {
2211     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2212     ID3DXBaseEffect *base = This->base_effect;
2213
2214     TRACE("Forward iface %p, base %p\n", This, base);
2215
2216     return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base, parameter, matrix, count);
2217 }
2218
2219 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
2220 {
2221     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2222     ID3DXBaseEffect *base = This->base_effect;
2223
2224     TRACE("Forward iface %p, base %p\n", This, base);
2225
2226     return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base, parameter, matrix, count);
2227 }
2228
2229 static HRESULT WINAPI ID3DXEffectImpl_SetString(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR string)
2230 {
2231     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2232     ID3DXBaseEffect *base = This->base_effect;
2233
2234     TRACE("Forward iface %p, base %p\n", This, base);
2235
2236     return ID3DXBaseEffectImpl_SetString(base, parameter, string);
2237 }
2238
2239 static HRESULT WINAPI ID3DXEffectImpl_GetString(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR *string)
2240 {
2241     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2242     ID3DXBaseEffect *base = This->base_effect;
2243
2244     TRACE("Forward iface %p, base %p\n", This, base);
2245
2246     return ID3DXBaseEffectImpl_GetString(base, parameter, string);
2247 }
2248
2249 static HRESULT WINAPI ID3DXEffectImpl_SetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
2250 {
2251     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2252     ID3DXBaseEffect *base = This->base_effect;
2253
2254     TRACE("Forward iface %p, base %p\n", This, base);
2255
2256     return ID3DXBaseEffectImpl_SetTexture(base, parameter, texture);
2257 }
2258
2259 static HRESULT WINAPI ID3DXEffectImpl_GetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
2260 {
2261     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2262     ID3DXBaseEffect *base = This->base_effect;
2263
2264     TRACE("Forward iface %p, base %p\n", This, base);
2265
2266     return ID3DXBaseEffectImpl_GetTexture(base, parameter, texture);
2267 }
2268
2269 static HRESULT WINAPI ID3DXEffectImpl_GetPixelShader(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
2270 {
2271     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2272     ID3DXBaseEffect *base = This->base_effect;
2273
2274     TRACE("Forward iface %p, base %p\n", This, base);
2275
2276     return ID3DXBaseEffectImpl_GetPixelShader(base, parameter, pshader);
2277 }
2278
2279 static HRESULT WINAPI ID3DXEffectImpl_GetVertexShader(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
2280 {
2281     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2282     ID3DXBaseEffect *base = This->base_effect;
2283
2284     TRACE("Forward iface %p, base %p\n", This, base);
2285
2286     return ID3DXBaseEffectImpl_GetVertexShader(base, parameter, vshader);
2287 }
2288
2289 static HRESULT WINAPI ID3DXEffectImpl_SetArrayRange(ID3DXEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
2290 {
2291     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2292     ID3DXBaseEffect *base = This->base_effect;
2293
2294     TRACE("Forward iface %p, base %p\n", This, base);
2295
2296     return ID3DXBaseEffectImpl_SetArrayRange(base, parameter, start, end);
2297 }
2298
2299 /*** ID3DXEffect methods ***/
2300 static HRESULT WINAPI ID3DXEffectImpl_GetPool(ID3DXEffect *iface, LPD3DXEFFECTPOOL *pool)
2301 {
2302     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2303
2304     TRACE("iface %p, pool %p\n", This, pool);
2305
2306     if (!pool)
2307     {
2308         WARN("Invalid argument supplied.\n");
2309         return D3DERR_INVALIDCALL;
2310     }
2311
2312     if (This->pool)
2313     {
2314         This->pool->lpVtbl->AddRef(This->pool);
2315     }
2316
2317     *pool = This->pool;
2318
2319     TRACE("Returning pool %p\n", *pool);
2320
2321     return S_OK;
2322 }
2323
2324 static HRESULT WINAPI ID3DXEffectImpl_SetTechnique(ID3DXEffect* iface, D3DXHANDLE technique)
2325 {
2326     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2327
2328     FIXME("(%p)->(%p): stub\n", This, technique);
2329
2330     return E_NOTIMPL;
2331 }
2332
2333 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetCurrentTechnique(ID3DXEffect* iface)
2334 {
2335     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2336
2337     FIXME("(%p)->(): stub\n", This);
2338
2339     return NULL;
2340 }
2341
2342 static HRESULT WINAPI ID3DXEffectImpl_ValidateTechnique(ID3DXEffect* iface, D3DXHANDLE technique)
2343 {
2344     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2345
2346     FIXME("(%p)->(%p): stub\n", This, technique);
2347
2348     return D3D_OK;
2349 }
2350
2351 static HRESULT WINAPI ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect* iface, D3DXHANDLE technique, D3DXHANDLE* next_technique)
2352 {
2353     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2354
2355     FIXME("(%p)->(%p, %p): stub\n", This, technique, next_technique);
2356
2357     return E_NOTIMPL;
2358 }
2359
2360 static BOOL WINAPI ID3DXEffectImpl_IsParameterUsed(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXHANDLE technique)
2361 {
2362     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2363
2364     FIXME("(%p)->(%p, %p): stub\n", This, parameter, technique);
2365
2366     return FALSE;
2367 }
2368
2369 static HRESULT WINAPI ID3DXEffectImpl_Begin(ID3DXEffect* iface, UINT *passes, DWORD flags)
2370 {
2371     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2372
2373     FIXME("(%p)->(%p, %#x): stub\n", This, passes, flags);
2374
2375     return E_NOTIMPL;
2376 }
2377
2378 static HRESULT WINAPI ID3DXEffectImpl_BeginPass(ID3DXEffect* iface, UINT pass)
2379 {
2380     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2381
2382     FIXME("(%p)->(%u): stub\n", This, pass);
2383
2384     return E_NOTIMPL;
2385 }
2386
2387 static HRESULT WINAPI ID3DXEffectImpl_CommitChanges(ID3DXEffect* iface)
2388 {
2389     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2390
2391     FIXME("(%p)->(): stub\n", This);
2392
2393     return E_NOTIMPL;
2394 }
2395
2396 static HRESULT WINAPI ID3DXEffectImpl_EndPass(ID3DXEffect* iface)
2397 {
2398     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2399
2400     FIXME("(%p)->(): stub\n", This);
2401
2402     return E_NOTIMPL;
2403 }
2404
2405 static HRESULT WINAPI ID3DXEffectImpl_End(ID3DXEffect* iface)
2406 {
2407     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2408
2409     FIXME("(%p)->(): stub\n", This);
2410
2411     return E_NOTIMPL;
2412 }
2413
2414 static HRESULT WINAPI ID3DXEffectImpl_GetDevice(ID3DXEffect *iface, LPDIRECT3DDEVICE9 *device)
2415 {
2416     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2417
2418     TRACE("iface %p, device %p\n", This, device);
2419
2420     if (!device)
2421     {
2422         WARN("Invalid argument supplied.\n");
2423         return D3DERR_INVALIDCALL;
2424     }
2425
2426     IDirect3DDevice9_AddRef(This->device);
2427
2428     *device = This->device;
2429
2430     TRACE("Returning device %p\n", *device);
2431
2432     return S_OK;
2433 }
2434
2435 static HRESULT WINAPI ID3DXEffectImpl_OnLostDevice(ID3DXEffect* iface)
2436 {
2437     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2438
2439     FIXME("(%p)->(): stub\n", This);
2440
2441     return E_NOTIMPL;
2442 }
2443
2444 static HRESULT WINAPI ID3DXEffectImpl_OnResetDevice(ID3DXEffect* iface)
2445 {
2446     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2447
2448     FIXME("(%p)->(): stub\n", This);
2449
2450     return E_NOTIMPL;
2451 }
2452
2453 static HRESULT WINAPI ID3DXEffectImpl_SetStateManager(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 (This->manager) IUnknown_Release(This->manager);
2460     if (manager) IUnknown_AddRef(manager);
2461
2462     This->manager = manager;
2463
2464     return D3D_OK;
2465 }
2466
2467 static HRESULT WINAPI ID3DXEffectImpl_GetStateManager(ID3DXEffect *iface, LPD3DXEFFECTSTATEMANAGER *manager)
2468 {
2469     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2470
2471     TRACE("iface %p, manager %p\n", This, manager);
2472
2473     if (!manager)
2474     {
2475         WARN("Invalid argument supplied.\n");
2476         return D3DERR_INVALIDCALL;
2477     }
2478
2479     if (This->manager) IUnknown_AddRef(This->manager);
2480     *manager = This->manager;
2481
2482     return D3D_OK;
2483 }
2484
2485 static HRESULT WINAPI ID3DXEffectImpl_BeginParameterBlock(ID3DXEffect* iface)
2486 {
2487     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2488
2489     FIXME("(%p)->(): stub\n", This);
2490
2491     return E_NOTIMPL;
2492 }
2493
2494 static D3DXHANDLE WINAPI ID3DXEffectImpl_EndParameterBlock(ID3DXEffect* iface)
2495 {
2496     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2497
2498     FIXME("(%p)->(): stub\n", This);
2499
2500     return NULL;
2501 }
2502
2503 static HRESULT WINAPI ID3DXEffectImpl_ApplyParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
2504 {
2505     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2506
2507     FIXME("(%p)->(%p): stub\n", This, parameter_block);
2508
2509     return E_NOTIMPL;
2510 }
2511
2512 static HRESULT WINAPI ID3DXEffectImpl_DeleteParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
2513 {
2514     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2515
2516     FIXME("(%p)->(%p): stub\n", This, parameter_block);
2517
2518     return E_NOTIMPL;
2519 }
2520
2521 static HRESULT WINAPI ID3DXEffectImpl_CloneEffect(ID3DXEffect* iface, LPDIRECT3DDEVICE9 device, LPD3DXEFFECT* effect)
2522 {
2523     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2524
2525     FIXME("(%p)->(%p, %p): stub\n", This, device, effect);
2526
2527     return E_NOTIMPL;
2528 }
2529
2530 static HRESULT WINAPI ID3DXEffectImpl_SetRawValue(ID3DXEffect* iface, D3DXHANDLE parameter, LPCVOID data, UINT byte_offset, UINT bytes)
2531 {
2532     struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2533
2534     FIXME("(%p)->(%p, %p, %u, %u): stub\n", This, parameter, data, byte_offset, bytes);
2535
2536     return E_NOTIMPL;
2537 }
2538
2539 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl =
2540 {
2541     /*** IUnknown methods ***/
2542     ID3DXEffectImpl_QueryInterface,
2543     ID3DXEffectImpl_AddRef,
2544     ID3DXEffectImpl_Release,
2545     /*** ID3DXBaseEffect methods ***/
2546     ID3DXEffectImpl_GetDesc,
2547     ID3DXEffectImpl_GetParameterDesc,
2548     ID3DXEffectImpl_GetTechniqueDesc,
2549     ID3DXEffectImpl_GetPassDesc,
2550     ID3DXEffectImpl_GetFunctionDesc,
2551     ID3DXEffectImpl_GetParameter,
2552     ID3DXEffectImpl_GetParameterByName,
2553     ID3DXEffectImpl_GetParameterBySemantic,
2554     ID3DXEffectImpl_GetParameterElement,
2555     ID3DXEffectImpl_GetTechnique,
2556     ID3DXEffectImpl_GetTechniqueByName,
2557     ID3DXEffectImpl_GetPass,
2558     ID3DXEffectImpl_GetPassByName,
2559     ID3DXEffectImpl_GetFunction,
2560     ID3DXEffectImpl_GetFunctionByName,
2561     ID3DXEffectImpl_GetAnnotation,
2562     ID3DXEffectImpl_GetAnnotationByName,
2563     ID3DXEffectImpl_SetValue,
2564     ID3DXEffectImpl_GetValue,
2565     ID3DXEffectImpl_SetBool,
2566     ID3DXEffectImpl_GetBool,
2567     ID3DXEffectImpl_SetBoolArray,
2568     ID3DXEffectImpl_GetBoolArray,
2569     ID3DXEffectImpl_SetInt,
2570     ID3DXEffectImpl_GetInt,
2571     ID3DXEffectImpl_SetIntArray,
2572     ID3DXEffectImpl_GetIntArray,
2573     ID3DXEffectImpl_SetFloat,
2574     ID3DXEffectImpl_GetFloat,
2575     ID3DXEffectImpl_SetFloatArray,
2576     ID3DXEffectImpl_GetFloatArray,
2577     ID3DXEffectImpl_SetVector,
2578     ID3DXEffectImpl_GetVector,
2579     ID3DXEffectImpl_SetVectorArray,
2580     ID3DXEffectImpl_GetVectorArray,
2581     ID3DXEffectImpl_SetMatrix,
2582     ID3DXEffectImpl_GetMatrix,
2583     ID3DXEffectImpl_SetMatrixArray,
2584     ID3DXEffectImpl_GetMatrixArray,
2585     ID3DXEffectImpl_SetMatrixPointerArray,
2586     ID3DXEffectImpl_GetMatrixPointerArray,
2587     ID3DXEffectImpl_SetMatrixTranspose,
2588     ID3DXEffectImpl_GetMatrixTranspose,
2589     ID3DXEffectImpl_SetMatrixTransposeArray,
2590     ID3DXEffectImpl_GetMatrixTransposeArray,
2591     ID3DXEffectImpl_SetMatrixTransposePointerArray,
2592     ID3DXEffectImpl_GetMatrixTransposePointerArray,
2593     ID3DXEffectImpl_SetString,
2594     ID3DXEffectImpl_GetString,
2595     ID3DXEffectImpl_SetTexture,
2596     ID3DXEffectImpl_GetTexture,
2597     ID3DXEffectImpl_GetPixelShader,
2598     ID3DXEffectImpl_GetVertexShader,
2599     ID3DXEffectImpl_SetArrayRange,
2600     /*** ID3DXEffect methods ***/
2601     ID3DXEffectImpl_GetPool,
2602     ID3DXEffectImpl_SetTechnique,
2603     ID3DXEffectImpl_GetCurrentTechnique,
2604     ID3DXEffectImpl_ValidateTechnique,
2605     ID3DXEffectImpl_FindNextValidTechnique,
2606     ID3DXEffectImpl_IsParameterUsed,
2607     ID3DXEffectImpl_Begin,
2608     ID3DXEffectImpl_BeginPass,
2609     ID3DXEffectImpl_CommitChanges,
2610     ID3DXEffectImpl_EndPass,
2611     ID3DXEffectImpl_End,
2612     ID3DXEffectImpl_GetDevice,
2613     ID3DXEffectImpl_OnLostDevice,
2614     ID3DXEffectImpl_OnResetDevice,
2615     ID3DXEffectImpl_SetStateManager,
2616     ID3DXEffectImpl_GetStateManager,
2617     ID3DXEffectImpl_BeginParameterBlock,
2618     ID3DXEffectImpl_EndParameterBlock,
2619     ID3DXEffectImpl_ApplyParameterBlock,
2620     ID3DXEffectImpl_DeleteParameterBlock,
2621     ID3DXEffectImpl_CloneEffect,
2622     ID3DXEffectImpl_SetRawValue
2623 };
2624
2625 static inline struct ID3DXEffectCompilerImpl *impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler *iface)
2626 {
2627     return CONTAINING_RECORD(iface, struct ID3DXEffectCompilerImpl, ID3DXEffectCompiler_iface);
2628 }
2629
2630 /*** IUnknown methods ***/
2631 static HRESULT WINAPI ID3DXEffectCompilerImpl_QueryInterface(ID3DXEffectCompiler *iface, REFIID riid, void **object)
2632 {
2633     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2634
2635     TRACE("iface %p, riid %s, object %p\n", This, debugstr_guid(riid), object);
2636
2637     if (IsEqualGUID(riid, &IID_IUnknown) ||
2638         IsEqualGUID(riid, &IID_ID3DXEffectCompiler))
2639     {
2640         This->ID3DXEffectCompiler_iface.lpVtbl->AddRef(iface);
2641         *object = This;
2642         return S_OK;
2643     }
2644
2645     ERR("Interface %s not found\n", debugstr_guid(riid));
2646
2647     return E_NOINTERFACE;
2648 }
2649
2650 static ULONG WINAPI ID3DXEffectCompilerImpl_AddRef(ID3DXEffectCompiler *iface)
2651 {
2652     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2653
2654     TRACE("iface %p: AddRef from %u\n", iface, This->ref);
2655
2656     return InterlockedIncrement(&This->ref);
2657 }
2658
2659 static ULONG WINAPI ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler *iface)
2660 {
2661     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2662     ULONG ref = InterlockedDecrement(&This->ref);
2663
2664     TRACE("iface %p: Release from %u\n", iface, ref + 1);
2665
2666     if (!ref)
2667     {
2668         free_effect_compiler(This);
2669         HeapFree(GetProcessHeap(), 0, This);
2670     }
2671
2672     return ref;
2673 }
2674
2675 /*** ID3DXBaseEffect methods ***/
2676 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetDesc(ID3DXEffectCompiler *iface, D3DXEFFECT_DESC *desc)
2677 {
2678     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2679     ID3DXBaseEffect *base = This->base_effect;
2680
2681     TRACE("Forward iface %p, base %p\n", This, base);
2682
2683     return ID3DXBaseEffectImpl_GetDesc(base, desc);
2684 }
2685
2686 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetParameterDesc(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
2687 {
2688     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2689     ID3DXBaseEffect *base = This->base_effect;
2690
2691     TRACE("Forward iface %p, base %p\n", This, base);
2692
2693     return ID3DXBaseEffectImpl_GetParameterDesc(base, parameter, desc);
2694 }
2695
2696 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTechniqueDesc(ID3DXEffectCompiler *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
2697 {
2698     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2699     ID3DXBaseEffect *base = This->base_effect;
2700
2701     TRACE("Forward iface %p, base %p\n", This, base);
2702
2703     return ID3DXBaseEffectImpl_GetTechniqueDesc(base, technique, desc);
2704 }
2705
2706 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPassDesc(ID3DXEffectCompiler *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
2707 {
2708     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2709     ID3DXBaseEffect *base = This->base_effect;
2710
2711     TRACE("Forward iface %p, base %p\n", This, base);
2712
2713     return ID3DXBaseEffectImpl_GetPassDesc(base, pass, desc);
2714 }
2715
2716 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFunctionDesc(ID3DXEffectCompiler *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
2717 {
2718     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2719     ID3DXBaseEffect *base = This->base_effect;
2720
2721     TRACE("Forward iface %p, base %p\n", This, base);
2722
2723     return ID3DXBaseEffectImpl_GetFunctionDesc(base, shader, desc);
2724 }
2725
2726 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameter(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
2727 {
2728     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2729     ID3DXBaseEffect *base = This->base_effect;
2730
2731     TRACE("Forward iface %p, base %p\n", This, base);
2732
2733     return ID3DXBaseEffectImpl_GetParameter(base, parameter, index);
2734 }
2735
2736 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterByName(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR name)
2737 {
2738     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2739     ID3DXBaseEffect *base = This->base_effect;
2740
2741     TRACE("Forward iface %p, base %p\n", This, base);
2742
2743     return ID3DXBaseEffectImpl_GetParameterByName(base, parameter, name);
2744 }
2745
2746 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterBySemantic(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR semantic)
2747 {
2748     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2749     ID3DXBaseEffect *base = This->base_effect;
2750
2751     TRACE("Forward iface %p, base %p\n", This, base);
2752
2753     return ID3DXBaseEffectImpl_GetParameterBySemantic(base, parameter, semantic);
2754 }
2755
2756 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterElement(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
2757 {
2758     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2759     ID3DXBaseEffect *base = This->base_effect;
2760
2761     TRACE("Forward iface %p, base %p\n", This, base);
2762
2763     return ID3DXBaseEffectImpl_GetParameterElement(base, parameter, index);
2764 }
2765
2766 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechnique(ID3DXEffectCompiler *iface, UINT index)
2767 {
2768     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2769     ID3DXBaseEffect *base = This->base_effect;
2770
2771     TRACE("Forward iface %p, base %p\n", This, base);
2772
2773     return ID3DXBaseEffectImpl_GetTechnique(base, index);
2774 }
2775
2776 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechniqueByName(ID3DXEffectCompiler *iface, LPCSTR name)
2777 {
2778     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2779     ID3DXBaseEffect *base = This->base_effect;
2780
2781     TRACE("Forward iface %p, base %p\n", This, base);
2782
2783     return ID3DXBaseEffectImpl_GetTechniqueByName(base, name);
2784 }
2785
2786 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPass(ID3DXEffectCompiler *iface, D3DXHANDLE technique, UINT index)
2787 {
2788     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2789     ID3DXBaseEffect *base = This->base_effect;
2790
2791     TRACE("Forward iface %p, base %p\n", This, base);
2792
2793     return ID3DXBaseEffectImpl_GetPass(base, technique, index);
2794 }
2795
2796 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPassByName(ID3DXEffectCompiler *iface, D3DXHANDLE technique, LPCSTR name)
2797 {
2798     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2799     ID3DXBaseEffect *base = This->base_effect;
2800
2801     TRACE("Forward iface %p, base %p\n", This, base);
2802
2803     return ID3DXBaseEffectImpl_GetPassByName(base, technique, name);
2804 }
2805
2806 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunction(ID3DXEffectCompiler *iface, UINT index)
2807 {
2808     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2809     ID3DXBaseEffect *base = This->base_effect;
2810
2811     TRACE("Forward iface %p, base %p\n", This, base);
2812
2813     return ID3DXBaseEffectImpl_GetFunction(base, index);
2814 }
2815
2816 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunctionByName(ID3DXEffectCompiler *iface, LPCSTR name)
2817 {
2818     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2819     ID3DXBaseEffect *base = This->base_effect;
2820
2821     TRACE("Forward iface %p, base %p\n", This, base);
2822
2823     return ID3DXBaseEffectImpl_GetFunctionByName(base, name);
2824 }
2825
2826 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotation(ID3DXEffectCompiler *iface, D3DXHANDLE object, UINT index)
2827 {
2828     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2829     ID3DXBaseEffect *base = This->base_effect;
2830
2831     TRACE("Forward iface %p, base %p\n", This, base);
2832
2833     return ID3DXBaseEffectImpl_GetAnnotation(base, object, index);
2834 }
2835
2836 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotationByName(ID3DXEffectCompiler *iface, D3DXHANDLE object, LPCSTR name)
2837 {
2838     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2839     ID3DXBaseEffect *base = This->base_effect;
2840
2841     TRACE("Forward iface %p, base %p\n", This, base);
2842
2843     return ID3DXBaseEffectImpl_GetAnnotationByName(base, object, name);
2844 }
2845
2846 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
2847 {
2848     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2849     ID3DXBaseEffect *base = This->base_effect;
2850
2851     TRACE("Forward iface %p, base %p\n", This, base);
2852
2853     return ID3DXBaseEffectImpl_SetValue(base, parameter, data, bytes);
2854 }
2855
2856 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
2857 {
2858     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2859     ID3DXBaseEffect *base = This->base_effect;
2860
2861     TRACE("Forward iface %p, base %p\n", This, base);
2862
2863     return ID3DXBaseEffectImpl_GetValue(base, parameter, data, bytes);
2864 }
2865
2866 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL b)
2867 {
2868     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2869     ID3DXBaseEffect *base = This->base_effect;
2870
2871     TRACE("Forward iface %p, base %p\n", This, base);
2872
2873     return ID3DXBaseEffectImpl_SetBool(base, parameter, b);
2874 }
2875
2876 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b)
2877 {
2878     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2879     ID3DXBaseEffect *base = This->base_effect;
2880
2881     TRACE("Forward iface %p, base %p\n", This, base);
2882
2883     return ID3DXBaseEffectImpl_GetBool(base, parameter, b);
2884 }
2885
2886 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
2887 {
2888     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2889     ID3DXBaseEffect *base = This->base_effect;
2890
2891     TRACE("Forward iface %p, base %p\n", This, base);
2892
2893     return ID3DXBaseEffectImpl_SetBoolArray(base, parameter, b, count);
2894 }
2895
2896 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
2897 {
2898     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2899     ID3DXBaseEffect *base = This->base_effect;
2900
2901     TRACE("Forward iface %p, base %p\n", This, base);
2902
2903     return ID3DXBaseEffectImpl_GetBoolArray(base, parameter, b, count);
2904 }
2905
2906 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT n)
2907 {
2908     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2909     ID3DXBaseEffect *base = This->base_effect;
2910
2911     TRACE("Forward iface %p, base %p\n", This, base);
2912
2913     return ID3DXBaseEffectImpl_SetInt(base, parameter, n);
2914 }
2915
2916 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n)
2917 {
2918     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2919     ID3DXBaseEffect *base = This->base_effect;
2920
2921     TRACE("Forward iface %p, base %p\n", This, base);
2922
2923     return ID3DXBaseEffectImpl_GetInt(base, parameter, n);
2924 }
2925
2926 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
2927 {
2928     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2929     ID3DXBaseEffect *base = This->base_effect;
2930
2931     TRACE("Forward iface %p, base %p\n", This, base);
2932
2933     return ID3DXBaseEffectImpl_SetIntArray(base, parameter, n, count);
2934 }
2935
2936 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n, UINT count)
2937 {
2938     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2939     ID3DXBaseEffect *base = This->base_effect;
2940
2941     TRACE("Forward iface %p, base %p\n", This, base);
2942
2943     return ID3DXBaseEffectImpl_GetIntArray(base, parameter, n, count);
2944 }
2945
2946 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT f)
2947 {
2948     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2949     ID3DXBaseEffect *base = This->base_effect;
2950
2951     TRACE("Forward iface %p, base %p\n", This, base);
2952
2953     return ID3DXBaseEffectImpl_SetFloat(base, parameter, f);
2954 }
2955
2956 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT *f)
2957 {
2958     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2959     ID3DXBaseEffect *base = This->base_effect;
2960
2961     TRACE("Forward iface %p, base %p\n", This, base);
2962
2963     return ID3DXBaseEffectImpl_GetFloat(base, parameter, f);
2964 }
2965
2966 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
2967 {
2968     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2969     ID3DXBaseEffect *base = This->base_effect;
2970
2971     TRACE("Forward iface %p, base %p\n", This, base);
2972
2973     return ID3DXBaseEffectImpl_SetFloatArray(base, parameter, f, count);
2974 }
2975
2976 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
2977 {
2978     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2979     ID3DXBaseEffect *base = This->base_effect;
2980
2981     TRACE("Forward iface %p, base %p\n", This, base);
2982
2983     return ID3DXBaseEffectImpl_GetFloatArray(base, parameter, f, count);
2984 }
2985
2986 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector)
2987 {
2988     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2989     ID3DXBaseEffect *base = This->base_effect;
2990
2991     TRACE("Forward iface %p, base %p\n", This, base);
2992
2993     return ID3DXBaseEffectImpl_SetVector(base, parameter, vector);
2994 }
2995
2996 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
2997 {
2998     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
2999     ID3DXBaseEffect *base = This->base_effect;
3000
3001     TRACE("Forward iface %p, base %p\n", This, base);
3002
3003     return ID3DXBaseEffectImpl_GetVector(base, parameter, vector);
3004 }
3005
3006 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
3007 {
3008     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3009     ID3DXBaseEffect *base = This->base_effect;
3010
3011     TRACE("Forward iface %p, base %p\n", This, base);
3012
3013     return ID3DXBaseEffectImpl_SetVectorArray(base, parameter, vector, count);
3014 }
3015
3016 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
3017 {
3018     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3019     ID3DXBaseEffect *base = This->base_effect;
3020
3021     TRACE("Forward iface %p, base %p\n", This, base);
3022
3023     return ID3DXBaseEffectImpl_GetVectorArray(base, parameter, vector, count);
3024 }
3025
3026 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
3027 {
3028     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3029     ID3DXBaseEffect *base = This->base_effect;
3030
3031     TRACE("Forward iface %p, base %p\n", This, base);
3032
3033     return ID3DXBaseEffectImpl_SetMatrix(base, parameter, matrix);
3034 }
3035
3036 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
3037 {
3038     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3039     ID3DXBaseEffect *base = This->base_effect;
3040
3041     TRACE("Forward iface %p, base %p\n", This, base);
3042
3043     return ID3DXBaseEffectImpl_GetMatrix(base, parameter, matrix);
3044 }
3045
3046 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
3047 {
3048     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3049     ID3DXBaseEffect *base = This->base_effect;
3050
3051     TRACE("Forward iface %p, base %p\n", This, base);
3052
3053     return ID3DXBaseEffectImpl_SetMatrixArray(base, parameter, matrix, count);
3054 }
3055
3056 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
3057 {
3058     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3059     ID3DXBaseEffect *base = This->base_effect;
3060
3061     TRACE("Forward iface %p, base %p\n", This, base);
3062
3063     return ID3DXBaseEffectImpl_GetMatrixArray(base, parameter, matrix, count);
3064 }
3065
3066 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
3067 {
3068     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3069     ID3DXBaseEffect *base = This->base_effect;
3070
3071     TRACE("Forward iface %p, base %p\n", This, base);
3072
3073     return ID3DXBaseEffectImpl_SetMatrixPointerArray(base, parameter, matrix, count);
3074 }
3075
3076 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
3077 {
3078     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3079     ID3DXBaseEffect *base = This->base_effect;
3080
3081     TRACE("Forward iface %p, base %p\n", This, base);
3082
3083     return ID3DXBaseEffectImpl_GetMatrixPointerArray(base, parameter, matrix, count);
3084 }
3085
3086 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
3087 {
3088     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3089     ID3DXBaseEffect *base = This->base_effect;
3090
3091     TRACE("Forward iface %p, base %p\n", This, base);
3092
3093     return ID3DXBaseEffectImpl_SetMatrixTranspose(base, parameter, matrix);
3094 }
3095
3096 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
3097 {
3098     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3099     ID3DXBaseEffect *base = This->base_effect;
3100
3101     TRACE("Forward iface %p, base %p\n", This, base);
3102
3103     return ID3DXBaseEffectImpl_GetMatrixTranspose(base, parameter, matrix);
3104 }
3105
3106 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
3107 {
3108     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3109     ID3DXBaseEffect *base = This->base_effect;
3110
3111     TRACE("Forward iface %p, base %p\n", This, base);
3112
3113     return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base, parameter, matrix, count);
3114 }
3115
3116 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
3117 {
3118     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3119     ID3DXBaseEffect *base = This->base_effect;
3120
3121     TRACE("Forward iface %p, base %p\n", This, base);
3122
3123     return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base, parameter, matrix, count);
3124 }
3125
3126 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
3127 {
3128     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3129     ID3DXBaseEffect *base = This->base_effect;
3130
3131     TRACE("Forward iface %p, base %p\n", This, base);
3132
3133     return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base, parameter, matrix, count);
3134 }
3135
3136 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
3137 {
3138     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3139     ID3DXBaseEffect *base = This->base_effect;
3140
3141     TRACE("Forward iface %p, base %p\n", This, base);
3142
3143     return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base, parameter, matrix, count);
3144 }
3145
3146 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR string)
3147 {
3148     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3149     ID3DXBaseEffect *base = This->base_effect;
3150
3151     TRACE("Forward iface %p, base %p\n", This, base);
3152
3153     return ID3DXBaseEffectImpl_SetString(base, parameter, string);
3154 }
3155
3156 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR *string)
3157 {
3158     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3159     ID3DXBaseEffect *base = This->base_effect;
3160
3161     TRACE("Forward iface %p, base %p\n", This, base);
3162
3163     return ID3DXBaseEffectImpl_GetString(base, parameter, string);
3164 }
3165
3166 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetTexture(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
3167 {
3168     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3169     ID3DXBaseEffect *base = This->base_effect;
3170
3171     TRACE("Forward iface %p, base %p\n", This, base);
3172
3173     return ID3DXBaseEffectImpl_SetTexture(base, parameter, texture);
3174 }
3175
3176 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTexture(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
3177 {
3178     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3179     ID3DXBaseEffect *base = This->base_effect;
3180
3181     TRACE("Forward iface %p, base %p\n", This, base);
3182
3183     return ID3DXBaseEffectImpl_GetTexture(base, parameter, texture);
3184 }
3185
3186 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPixelShader(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
3187 {
3188     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3189     ID3DXBaseEffect *base = This->base_effect;
3190
3191     TRACE("Forward iface %p, base %p\n", This, base);
3192
3193     return ID3DXBaseEffectImpl_GetPixelShader(base, parameter, pshader);
3194 }
3195
3196 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVertexShader(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
3197 {
3198     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3199     ID3DXBaseEffect *base = This->base_effect;
3200
3201     TRACE("Forward iface %p, base %p\n", This, base);
3202
3203     return ID3DXBaseEffectImpl_GetVertexShader(base, parameter, vshader);
3204 }
3205
3206 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetArrayRange(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT start, UINT end)
3207 {
3208     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3209     ID3DXBaseEffect *base = This->base_effect;
3210
3211     TRACE("Forward iface %p, base %p\n", This, base);
3212
3213     return ID3DXBaseEffectImpl_SetArrayRange(base, parameter, start, end);
3214 }
3215
3216 /*** ID3DXEffectCompiler methods ***/
3217 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL literal)
3218 {
3219     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3220
3221     FIXME("iface %p, parameter %p, literal %u\n", This, parameter, literal);
3222
3223     return E_NOTIMPL;
3224 }
3225
3226 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *literal)
3227 {
3228     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3229
3230     FIXME("iface %p, parameter %p, literal %p\n", This, parameter, literal);
3231
3232     return E_NOTIMPL;
3233 }
3234
3235 static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileEffect(ID3DXEffectCompiler *iface, DWORD flags,
3236         LPD3DXBUFFER *effect, LPD3DXBUFFER *error_msgs)
3237 {
3238     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3239
3240     FIXME("iface %p, flags %#x, effect %p, error_msgs %p stub\n", This, flags, effect, error_msgs);
3241
3242     return E_NOTIMPL;
3243 }
3244
3245 static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileShader(ID3DXEffectCompiler *iface, D3DXHANDLE function,
3246         LPCSTR target, DWORD flags, LPD3DXBUFFER *shader, LPD3DXBUFFER *error_msgs, LPD3DXCONSTANTTABLE *constant_table)
3247 {
3248     struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3249
3250     FIXME("iface %p, function %p, target %p, flags %#x, shader %p, error_msgs %p, constant_table %p stub\n",
3251             This, function, target, flags, shader, error_msgs, constant_table);
3252
3253     return E_NOTIMPL;
3254 }
3255
3256 static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl =
3257 {
3258     /*** IUnknown methods ***/
3259     ID3DXEffectCompilerImpl_QueryInterface,
3260     ID3DXEffectCompilerImpl_AddRef,
3261     ID3DXEffectCompilerImpl_Release,
3262     /*** ID3DXBaseEffect methods ***/
3263     ID3DXEffectCompilerImpl_GetDesc,
3264     ID3DXEffectCompilerImpl_GetParameterDesc,
3265     ID3DXEffectCompilerImpl_GetTechniqueDesc,
3266     ID3DXEffectCompilerImpl_GetPassDesc,
3267     ID3DXEffectCompilerImpl_GetFunctionDesc,
3268     ID3DXEffectCompilerImpl_GetParameter,
3269     ID3DXEffectCompilerImpl_GetParameterByName,
3270     ID3DXEffectCompilerImpl_GetParameterBySemantic,
3271     ID3DXEffectCompilerImpl_GetParameterElement,
3272     ID3DXEffectCompilerImpl_GetTechnique,
3273     ID3DXEffectCompilerImpl_GetTechniqueByName,
3274     ID3DXEffectCompilerImpl_GetPass,
3275     ID3DXEffectCompilerImpl_GetPassByName,
3276     ID3DXEffectCompilerImpl_GetFunction,
3277     ID3DXEffectCompilerImpl_GetFunctionByName,
3278     ID3DXEffectCompilerImpl_GetAnnotation,
3279     ID3DXEffectCompilerImpl_GetAnnotationByName,
3280     ID3DXEffectCompilerImpl_SetValue,
3281     ID3DXEffectCompilerImpl_GetValue,
3282     ID3DXEffectCompilerImpl_SetBool,
3283     ID3DXEffectCompilerImpl_GetBool,
3284     ID3DXEffectCompilerImpl_SetBoolArray,
3285     ID3DXEffectCompilerImpl_GetBoolArray,
3286     ID3DXEffectCompilerImpl_SetInt,
3287     ID3DXEffectCompilerImpl_GetInt,
3288     ID3DXEffectCompilerImpl_SetIntArray,
3289     ID3DXEffectCompilerImpl_GetIntArray,
3290     ID3DXEffectCompilerImpl_SetFloat,
3291     ID3DXEffectCompilerImpl_GetFloat,
3292     ID3DXEffectCompilerImpl_SetFloatArray,
3293     ID3DXEffectCompilerImpl_GetFloatArray,
3294     ID3DXEffectCompilerImpl_SetVector,
3295     ID3DXEffectCompilerImpl_GetVector,
3296     ID3DXEffectCompilerImpl_SetVectorArray,
3297     ID3DXEffectCompilerImpl_GetVectorArray,
3298     ID3DXEffectCompilerImpl_SetMatrix,
3299     ID3DXEffectCompilerImpl_GetMatrix,
3300     ID3DXEffectCompilerImpl_SetMatrixArray,
3301     ID3DXEffectCompilerImpl_GetMatrixArray,
3302     ID3DXEffectCompilerImpl_SetMatrixPointerArray,
3303     ID3DXEffectCompilerImpl_GetMatrixPointerArray,
3304     ID3DXEffectCompilerImpl_SetMatrixTranspose,
3305     ID3DXEffectCompilerImpl_GetMatrixTranspose,
3306     ID3DXEffectCompilerImpl_SetMatrixTransposeArray,
3307     ID3DXEffectCompilerImpl_GetMatrixTransposeArray,
3308     ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray,
3309     ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray,
3310     ID3DXEffectCompilerImpl_SetString,
3311     ID3DXEffectCompilerImpl_GetString,
3312     ID3DXEffectCompilerImpl_SetTexture,
3313     ID3DXEffectCompilerImpl_GetTexture,
3314     ID3DXEffectCompilerImpl_GetPixelShader,
3315     ID3DXEffectCompilerImpl_GetVertexShader,
3316     ID3DXEffectCompilerImpl_SetArrayRange,
3317     /*** ID3DXEffectCompiler methods ***/
3318     ID3DXEffectCompilerImpl_SetLiteral,
3319     ID3DXEffectCompilerImpl_GetLiteral,
3320     ID3DXEffectCompilerImpl_CompileEffect,
3321     ID3DXEffectCompilerImpl_CompileShader,
3322 };
3323
3324 static HRESULT d3dx9_parse_value(struct d3dx_parameter *param, void *value, const char **ptr)
3325 {
3326     unsigned int i;
3327     HRESULT hr;
3328     UINT old_size = 0;
3329     DWORD id;
3330
3331     if (param->element_count)
3332     {
3333         param->data = value;
3334
3335         for (i = 0; i < param->element_count; ++i)
3336         {
3337             struct d3dx_parameter *member = get_parameter_struct(param->member_handles[i]);
3338
3339             hr = d3dx9_parse_value(member, (char *)value + old_size, ptr);
3340             if (hr != D3D_OK)
3341             {
3342                 WARN("Failed to parse value\n");
3343                 return hr;
3344             }
3345
3346             old_size += member->bytes;
3347         }
3348
3349         return D3D_OK;
3350     }
3351
3352     switch(param->class)
3353     {
3354         case D3DXPC_SCALAR:
3355         case D3DXPC_VECTOR:
3356         case D3DXPC_MATRIX_ROWS:
3357         case D3DXPC_MATRIX_COLUMNS:
3358             param->data = value;
3359             break;
3360
3361         case D3DXPC_STRUCT:
3362             param->data = value;
3363
3364             for (i = 0; i < param->member_count; ++i)
3365             {
3366                 struct d3dx_parameter *member = get_parameter_struct(param->member_handles[i]);
3367
3368                 hr = d3dx9_parse_value(member, (char *)value + old_size, ptr);
3369                 if (hr != D3D_OK)
3370                 {
3371                     WARN("Failed to parse value\n");
3372                     return hr;
3373                 }
3374
3375                 old_size += member->bytes;
3376             }
3377             break;
3378
3379         case D3DXPC_OBJECT:
3380             switch (param->type)
3381             {
3382                 case D3DXPT_STRING:
3383                 case D3DXPT_TEXTURE:
3384                 case D3DXPT_TEXTURE1D:
3385                 case D3DXPT_TEXTURE2D:
3386                 case D3DXPT_TEXTURE3D:
3387                 case D3DXPT_TEXTURECUBE:
3388                 case D3DXPT_PIXELSHADER:
3389                 case D3DXPT_VERTEXSHADER:
3390                     read_dword(ptr, &id);
3391                     TRACE("Id: %u\n", id);
3392                     param->base->objects[id] = get_parameter_handle(param);
3393                     param->data = value;
3394                     break;
3395
3396                 default:
3397                     FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
3398                     break;
3399             }
3400             break;
3401
3402         default:
3403             FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
3404             break;
3405     }
3406
3407     return D3D_OK;
3408 }
3409
3410 static HRESULT d3dx9_parse_init_value(struct d3dx_parameter *param, const char *ptr)
3411 {
3412     UINT size = param->bytes;
3413     HRESULT hr;
3414     void *value = NULL;
3415
3416     TRACE("param size: %u\n", size);
3417
3418     value = HeapAlloc(GetProcessHeap(), 0, size);
3419     if (!value)
3420     {
3421         ERR("Failed to allocate data memory.\n");
3422         return E_OUTOFMEMORY;
3423     }
3424
3425     TRACE("Data: %s.\n", debugstr_an(ptr, size));
3426     memcpy(value, ptr, size);
3427
3428     hr = d3dx9_parse_value(param, value, &ptr);
3429     if (hr != D3D_OK)
3430     {
3431         WARN("Failed to parse value\n");
3432         HeapFree(GetProcessHeap(), 0, value);
3433         return hr;
3434     }
3435
3436     param->data = value;
3437
3438     return D3D_OK;
3439 }
3440
3441 static HRESULT d3dx9_parse_name(char **name, const char *ptr)
3442 {
3443     DWORD size;
3444
3445     read_dword(&ptr, &size);
3446     TRACE("Name size: %#x\n", size);
3447
3448     if (!size)
3449     {
3450         return D3D_OK;
3451     }
3452
3453     *name = HeapAlloc(GetProcessHeap(), 0, size);
3454     if (!*name)
3455     {
3456         ERR("Failed to allocate name memory.\n");
3457         return E_OUTOFMEMORY;
3458     }
3459
3460     TRACE("Name: %s.\n", debugstr_an(ptr, size));
3461     memcpy(*name, ptr, size);
3462
3463     return D3D_OK;
3464 }
3465
3466 static HRESULT d3dx9_parse_data(struct d3dx_parameter *param, const char **ptr)
3467 {
3468     DWORD size;
3469     HRESULT hr;
3470
3471     TRACE("Parse data for parameter %s, type %s\n", debugstr_a(param->name), debug_d3dxparameter_type(param->type));
3472
3473     read_dword(ptr, &size);
3474     TRACE("Data size: %#x\n", size);
3475
3476     if (!size)
3477     {
3478         TRACE("Size is 0\n");
3479         *(void **)param->data = NULL;
3480         return D3D_OK;
3481     }
3482
3483     switch (param->type)
3484     {
3485         case D3DXPT_STRING:
3486             /* re-read with size (sizeof(DWORD) = 4) */
3487             hr = d3dx9_parse_name((LPSTR *)param->data, *ptr - 4);
3488             if (hr != D3D_OK)
3489             {
3490                 WARN("Failed to parse string data\n");
3491                 return hr;
3492             }
3493             break;
3494
3495         case D3DXPT_VERTEXSHADER:
3496             hr = IDirect3DDevice9_CreateVertexShader(param->base->effect->device, (DWORD *)*ptr, (LPDIRECT3DVERTEXSHADER9 *)param->data);
3497             if (hr != D3D_OK)
3498             {
3499                 WARN("Failed to create vertex shader\n");
3500                 return hr;
3501             }
3502             break;
3503
3504         case D3DXPT_PIXELSHADER:
3505             hr = IDirect3DDevice9_CreatePixelShader(param->base->effect->device, (DWORD *)*ptr, (LPDIRECT3DPIXELSHADER9 *)param->data);
3506             if (hr != D3D_OK)
3507             {
3508                 WARN("Failed to create pixel shader\n");
3509                 return hr;
3510             }
3511             break;
3512
3513         default:
3514             FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
3515             break;
3516     }
3517
3518
3519     *ptr += ((size + 3) & ~3);
3520
3521     return D3D_OK;
3522 }
3523
3524 static HRESULT d3dx9_parse_effect_typedef(struct d3dx_parameter *param, const char *data, const char **ptr,
3525         struct d3dx_parameter *parent, UINT flags)
3526 {
3527     DWORD offset;
3528     HRESULT hr;
3529     D3DXHANDLE *member_handles = NULL;
3530     UINT i;
3531
3532     param->flags = flags;
3533
3534     if (!parent)
3535     {
3536         read_dword(ptr, &param->type);
3537         TRACE("Type: %s\n", debug_d3dxparameter_type(param->type));
3538
3539         read_dword(ptr, &param->class);
3540         TRACE("Class: %s\n", debug_d3dxparameter_class(param->class));
3541
3542         read_dword(ptr, &offset);
3543         TRACE("Type name offset: %#x\n", offset);
3544         hr = d3dx9_parse_name(&param->name, data + offset);
3545         if (hr != D3D_OK)
3546         {
3547             WARN("Failed to parse name\n");
3548             goto err_out;
3549         }
3550
3551         read_dword(ptr, &offset);
3552         TRACE("Type semantic offset: %#x\n", offset);
3553         hr = d3dx9_parse_name(&param->semantic, data + offset);
3554         if (hr != D3D_OK)
3555         {
3556             WARN("Failed to parse semantic\n");
3557             goto err_out;
3558         }
3559
3560         read_dword(ptr, &param->element_count);
3561         TRACE("Elements: %u\n", param->element_count);
3562
3563         switch (param->class)
3564         {
3565             case D3DXPC_VECTOR:
3566                 read_dword(ptr, &param->columns);
3567                 TRACE("Columns: %u\n", param->columns);
3568
3569                 read_dword(ptr, &param->rows);
3570                 TRACE("Rows: %u\n", param->rows);
3571
3572                 /* sizeof(DWORD) * rows * columns */
3573                 param->bytes = 4 * param->rows * param->columns;
3574                 break;
3575
3576             case D3DXPC_SCALAR:
3577             case D3DXPC_MATRIX_ROWS:
3578             case D3DXPC_MATRIX_COLUMNS:
3579                 read_dword(ptr, &param->rows);
3580                 TRACE("Rows: %u\n", param->rows);
3581
3582                 read_dword(ptr, &param->columns);
3583                 TRACE("Columns: %u\n", param->columns);
3584
3585                 /* sizeof(DWORD) * rows * columns */
3586                 param->bytes = 4 * param->rows * param->columns;
3587                 break;
3588
3589             case D3DXPC_STRUCT:
3590                 read_dword(ptr, &param->member_count);
3591                 TRACE("Members: %u\n", param->member_count);
3592                 break;
3593
3594             case D3DXPC_OBJECT:
3595                 switch (param->type)
3596                 {
3597                     case D3DXPT_STRING:
3598                         param->bytes = sizeof(LPCSTR);
3599                         break;
3600
3601                     case D3DXPT_PIXELSHADER:
3602                         param->bytes = sizeof(LPDIRECT3DPIXELSHADER9);
3603                         break;
3604
3605                     case D3DXPT_VERTEXSHADER:
3606                         param->bytes = sizeof(LPDIRECT3DVERTEXSHADER9);
3607                         break;
3608
3609                     case D3DXPT_TEXTURE:
3610                     case D3DXPT_TEXTURE1D:
3611                     case D3DXPT_TEXTURE2D:
3612                     case D3DXPT_TEXTURE3D:
3613                     case D3DXPT_TEXTURECUBE:
3614                         param->bytes = sizeof(LPDIRECT3DBASETEXTURE9);
3615                         break;
3616
3617                     default:
3618                         FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
3619                         break;
3620                 }
3621                 break;
3622
3623             default:
3624                 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
3625                 break;
3626         }
3627     }
3628     else
3629     {
3630         /* elements */
3631         param->type = parent->type;
3632         param->class = parent->class;
3633         param->name = parent->name;
3634         param->semantic = parent->semantic;
3635         param->element_count = 0;
3636         param->annotation_count = 0;
3637         param->member_count = parent->member_count;
3638         param->bytes = parent->bytes;
3639         param->rows = parent->rows;
3640         param->columns = parent->columns;
3641     }
3642
3643     if (param->element_count)
3644     {
3645         unsigned int param_bytes = 0;
3646         const char *save_ptr = *ptr;
3647
3648         member_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member_handles) * param->element_count);
3649         if (!member_handles)
3650         {
3651             ERR("Out of memory\n");
3652             hr = E_OUTOFMEMORY;
3653             goto err_out;
3654         }
3655
3656         for (i = 0; i < param->element_count; ++i)
3657         {
3658             struct d3dx_parameter *member;
3659             *ptr = save_ptr;
3660
3661             member = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member));
3662             if (!member)
3663             {
3664                 ERR("Out of memory\n");
3665                 hr = E_OUTOFMEMORY;
3666                 goto err_out;
3667             }
3668
3669             member_handles[i] = get_parameter_handle(member);
3670             member->base = param->base;
3671
3672             hr = d3dx9_parse_effect_typedef(member, data, ptr, param, flags);
3673             if (hr != D3D_OK)
3674             {
3675                 WARN("Failed to parse member\n");
3676                 goto err_out;
3677             }
3678
3679             param_bytes += member->bytes;
3680         }
3681
3682         param->bytes = param_bytes;
3683     }
3684     else if (param->member_count)
3685     {
3686         member_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member_handles) * param->member_count);
3687         if (!member_handles)
3688         {
3689             ERR("Out of memory\n");
3690             hr = E_OUTOFMEMORY;
3691             goto err_out;
3692         }
3693
3694         for (i = 0; i < param->member_count; ++i)
3695         {
3696             struct d3dx_parameter *member;
3697
3698             member = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member));
3699             if (!member)
3700             {
3701                 ERR("Out of memory\n");
3702                 hr = E_OUTOFMEMORY;
3703                 goto err_out;
3704             }
3705
3706             member_handles[i] = get_parameter_handle(member);
3707             member->base = param->base;
3708
3709             hr = d3dx9_parse_effect_typedef(member, data, ptr, NULL, flags);
3710             if (hr != D3D_OK)
3711             {
3712                 WARN("Failed to parse member\n");
3713                 goto err_out;
3714             }
3715
3716             param->bytes += member->bytes;
3717         }
3718     }
3719
3720     param->member_handles = member_handles;
3721
3722     return D3D_OK;
3723
3724 err_out:
3725
3726     if (member_handles)
3727     {
3728         unsigned int count;
3729
3730         if (param->element_count) count = param->element_count;
3731         else count = param->member_count;
3732
3733         for (i = 0; i < count; ++i)
3734         {
3735             free_parameter(member_handles[i], param->element_count != 0, TRUE);
3736         }
3737         HeapFree(GetProcessHeap(), 0, member_handles);
3738     }
3739
3740     if (!parent)
3741     {
3742         HeapFree(GetProcessHeap(), 0, param->name);
3743         HeapFree(GetProcessHeap(), 0, param->semantic);
3744     }
3745     param->name = NULL;
3746     param->semantic = NULL;
3747
3748     return hr;
3749 }
3750
3751 static HRESULT d3dx9_parse_effect_annotation(struct d3dx_parameter *anno, const char *data, const char **ptr)
3752 {
3753     DWORD offset;
3754     const char *ptr2;
3755     HRESULT hr;
3756
3757     anno->flags = D3DX_PARAMETER_ANNOTATION;
3758
3759     read_dword(ptr, &offset);
3760     TRACE("Typedef offset: %#x\n", offset);
3761     ptr2 = data + offset;
3762     hr = d3dx9_parse_effect_typedef(anno, data, &ptr2, NULL, D3DX_PARAMETER_ANNOTATION);
3763     if (hr != D3D_OK)
3764     {
3765         WARN("Failed to parse type definition\n");
3766         return hr;
3767     }
3768
3769     read_dword(ptr, &offset);
3770     TRACE("Value offset: %#x\n", offset);
3771     hr = d3dx9_parse_init_value(anno, data + offset);
3772     if (hr != D3D_OK)
3773     {
3774         WARN("Failed to parse value\n");
3775         return hr;
3776     }
3777
3778     return D3D_OK;
3779 }
3780
3781 static HRESULT d3dx9_parse_effect_parameter(struct d3dx_parameter *param, const char *data, const char **ptr)
3782 {
3783     DWORD offset;
3784     HRESULT hr;
3785     unsigned int i;
3786     D3DXHANDLE *annotation_handles = NULL;
3787     const char *ptr2;
3788
3789     read_dword(ptr, &offset);
3790     TRACE("Typedef offset: %#x\n", offset);
3791     ptr2 = data + offset;
3792
3793     read_dword(ptr, &offset);
3794     TRACE("Value offset: %#x\n", offset);
3795
3796     read_dword(ptr, &param->flags);
3797     TRACE("Flags: %#x\n", param->flags);
3798
3799     read_dword(ptr, &param->annotation_count);
3800     TRACE("Annotation count: %u\n", param->annotation_count);
3801
3802     hr = d3dx9_parse_effect_typedef(param, data, &ptr2, NULL, param->flags);
3803     if (hr != D3D_OK)
3804     {
3805         WARN("Failed to parse type definition\n");
3806         return hr;
3807     }
3808
3809     hr = d3dx9_parse_init_value(param, data + offset);
3810     if (hr != D3D_OK)
3811     {
3812         WARN("Failed to parse value\n");
3813         return hr;
3814     }
3815
3816     if (param->annotation_count)
3817     {
3818         annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * param->annotation_count);
3819         if (!annotation_handles)
3820         {
3821             ERR("Out of memory\n");
3822             hr = E_OUTOFMEMORY;
3823             goto err_out;
3824         }
3825
3826         for (i = 0; i < param->annotation_count; ++i)
3827         {
3828             struct d3dx_parameter *annotation;
3829
3830             annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
3831             if (!annotation)
3832             {
3833                 ERR("Out of memory\n");
3834                 hr = E_OUTOFMEMORY;
3835                 goto err_out;
3836             }
3837
3838             annotation_handles[i] = get_parameter_handle(annotation);
3839             annotation->base = param->base;
3840
3841             hr = d3dx9_parse_effect_annotation(annotation, data, ptr);
3842             if (hr != D3D_OK)
3843             {
3844                 WARN("Failed to parse annotation\n");
3845                 goto err_out;
3846             }
3847         }
3848     }
3849
3850     param->annotation_handles = annotation_handles;
3851
3852     return D3D_OK;
3853
3854 err_out:
3855
3856     if (annotation_handles)
3857     {
3858         for (i = 0; i < param->annotation_count; ++i)
3859         {
3860             free_parameter(annotation_handles[i], FALSE, FALSE);
3861         }
3862         HeapFree(GetProcessHeap(), 0, annotation_handles);
3863     }
3864
3865     return hr;
3866 }
3867
3868 static HRESULT d3dx9_parse_effect_pass(struct d3dx_pass *pass, const char *data, const char **ptr)
3869 {
3870     DWORD offset;
3871     HRESULT hr;
3872     unsigned int i;
3873     D3DXHANDLE *annotation_handles = NULL;
3874     char *name = NULL;
3875
3876     read_dword(ptr, &offset);
3877     TRACE("Pass name offset: %#x\n", offset);
3878     hr = d3dx9_parse_name(&name, data + offset);
3879     if (hr != D3D_OK)
3880     {
3881         WARN("Failed to parse name\n");
3882         goto err_out;
3883     }
3884
3885     read_dword(ptr, &pass->annotation_count);
3886     TRACE("Annotation count: %u\n", pass->annotation_count);
3887
3888     read_dword(ptr, &pass->state_count);
3889     TRACE("State count: %u\n", pass->state_count);
3890
3891     if (pass->annotation_count)
3892     {
3893         annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * pass->annotation_count);
3894         if (!annotation_handles)
3895         {
3896             ERR("Out of memory\n");
3897             hr = E_OUTOFMEMORY;
3898             goto err_out;
3899         }
3900
3901         for (i = 0; i < pass->annotation_count; ++i)
3902         {
3903             struct d3dx_parameter *annotation;
3904
3905             annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
3906             if (!annotation)
3907             {
3908                 ERR("Out of memory\n");
3909                 hr = E_OUTOFMEMORY;
3910                 goto err_out;
3911             }
3912
3913             annotation_handles[i] = get_parameter_handle(annotation);
3914             annotation->base = pass->base;
3915
3916             hr = d3dx9_parse_effect_annotation(annotation, data, ptr);
3917             if (hr != D3D_OK)
3918             {
3919                 WARN("Failed to parse annotations\n");
3920                 goto err_out;
3921             }
3922         }
3923     }
3924
3925     if (pass->state_count)
3926     {
3927         for (i = 0; i < pass->state_count; ++i)
3928         {
3929             skip_dword_unknown(ptr, 4);
3930         }
3931     }
3932
3933     pass->name = name;
3934     pass->annotation_handles = annotation_handles;
3935
3936     return D3D_OK;
3937
3938 err_out:
3939
3940     if (annotation_handles)
3941     {
3942         for (i = 0; i < pass->annotation_count; ++i)
3943         {
3944             free_parameter(annotation_handles[i], FALSE, FALSE);
3945         }
3946         HeapFree(GetProcessHeap(), 0, annotation_handles);
3947     }
3948
3949     HeapFree(GetProcessHeap(), 0, name);
3950
3951     return hr;
3952 }
3953
3954 static HRESULT d3dx9_parse_effect_technique(struct d3dx_technique *technique, const char *data, const char **ptr)
3955 {
3956     DWORD offset;
3957     HRESULT hr;
3958     unsigned int i;
3959     D3DXHANDLE *annotation_handles = NULL;
3960     D3DXHANDLE *pass_handles = NULL;
3961     char *name = NULL;
3962
3963     read_dword(ptr, &offset);
3964     TRACE("Technique name offset: %#x\n", offset);
3965     hr = d3dx9_parse_name(&name, data + offset);
3966     if (hr != D3D_OK)
3967     {
3968         WARN("Failed to parse name\n");
3969         goto err_out;
3970     }
3971
3972     read_dword(ptr, &technique->annotation_count);
3973     TRACE("Annotation count: %u\n", technique->annotation_count);
3974
3975     read_dword(ptr, &technique->pass_count);
3976     TRACE("Pass count: %u\n", technique->pass_count);
3977
3978     if (technique->annotation_count)
3979     {
3980         annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * technique->annotation_count);
3981         if (!annotation_handles)
3982         {
3983             ERR("Out of memory\n");
3984             hr = E_OUTOFMEMORY;
3985             goto err_out;
3986         }
3987
3988         for (i = 0; i < technique->annotation_count; ++i)
3989         {
3990             struct d3dx_parameter *annotation;
3991
3992             annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
3993             if (!annotation)
3994             {
3995                 ERR("Out of memory\n");
3996                 hr = E_OUTOFMEMORY;
3997                 goto err_out;
3998             }
3999
4000             annotation_handles[i] = get_parameter_handle(annotation);
4001             annotation->base = technique->base;
4002
4003             hr = d3dx9_parse_effect_annotation(annotation, data, ptr);
4004             if (hr != D3D_OK)
4005             {
4006                 WARN("Failed to parse annotations\n");
4007                 goto err_out;
4008             }
4009         }
4010     }
4011
4012     if (technique->pass_count)
4013     {
4014         pass_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pass_handles) * technique->pass_count);
4015         if (!pass_handles)
4016         {
4017             ERR("Out of memory\n");
4018             hr = E_OUTOFMEMORY;
4019             goto err_out;
4020         }
4021
4022         for (i = 0; i < technique->pass_count; ++i)
4023         {
4024             struct d3dx_pass *pass;
4025
4026             pass = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pass));
4027             if (!pass)
4028             {
4029                 ERR("Out of memory\n");
4030                 hr = E_OUTOFMEMORY;
4031                 goto err_out;
4032             }
4033
4034             pass_handles[i] = get_pass_handle(pass);
4035             pass->base = technique->base;
4036
4037             hr = d3dx9_parse_effect_pass(pass, data, ptr);
4038             if (hr != D3D_OK)
4039             {
4040                 WARN("Failed to parse passes\n");
4041                 goto err_out;
4042             }
4043         }
4044     }
4045
4046     technique->name = name;
4047     technique->pass_handles = pass_handles;
4048     technique->annotation_handles = annotation_handles;
4049
4050     return D3D_OK;
4051
4052 err_out:
4053
4054     if (pass_handles)
4055     {
4056         for (i = 0; i < technique->pass_count; ++i)
4057         {
4058             free_pass(pass_handles[i]);
4059         }
4060         HeapFree(GetProcessHeap(), 0, pass_handles);
4061     }
4062
4063     if (annotation_handles)
4064     {
4065         for (i = 0; i < technique->annotation_count; ++i)
4066         {
4067             free_parameter(annotation_handles[i], FALSE, FALSE);
4068         }
4069         HeapFree(GetProcessHeap(), 0, annotation_handles);
4070     }
4071
4072     HeapFree(GetProcessHeap(), 0, name);
4073
4074     return hr;
4075 }
4076
4077 static HRESULT d3dx9_parse_effect(struct ID3DXBaseEffectImpl *base, const char *data, UINT data_size, DWORD start)
4078 {
4079     const char *ptr = data + start;
4080     D3DXHANDLE *parameter_handles = NULL;
4081     D3DXHANDLE *technique_handles = NULL;
4082     D3DXHANDLE *objects = NULL;
4083     unsigned int stringcount;
4084     HRESULT hr;
4085     unsigned int i;
4086
4087     read_dword(&ptr, &base->parameter_count);
4088     TRACE("Parameter count: %u\n", base->parameter_count);
4089
4090     read_dword(&ptr, &base->technique_count);
4091     TRACE("Technique count: %u\n", base->technique_count);
4092
4093     skip_dword_unknown(&ptr, 1);
4094
4095     read_dword(&ptr, &base->object_count);
4096     TRACE("Object count: %u\n", base->object_count);
4097
4098     objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*objects) * base->object_count);
4099     if (!objects)
4100     {
4101         ERR("Out of memory\n");
4102         hr = E_OUTOFMEMORY;
4103         goto err_out;
4104     }
4105
4106     base->objects = objects;
4107
4108     if (base->parameter_count)
4109     {
4110         parameter_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter_handles) * base->parameter_count);
4111         if (!parameter_handles)
4112         {
4113             ERR("Out of memory\n");
4114             hr = E_OUTOFMEMORY;
4115             goto err_out;
4116         }
4117
4118         for (i = 0; i < base->parameter_count; ++i)
4119         {
4120             struct d3dx_parameter *parameter;
4121
4122             parameter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter));
4123             if (!parameter)
4124             {
4125                 ERR("Out of memory\n");
4126                 hr = E_OUTOFMEMORY;
4127                 goto err_out;
4128             }
4129
4130             parameter_handles[i] = get_parameter_handle(parameter);
4131             parameter->base = base;
4132
4133             hr = d3dx9_parse_effect_parameter(parameter, data, &ptr);
4134             if (hr != D3D_OK)
4135             {
4136                 WARN("Failed to parse parameter\n");
4137                 goto err_out;
4138             }
4139         }
4140     }
4141
4142     if (base->technique_count)
4143     {
4144         technique_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*technique_handles) * base->technique_count);
4145         if (!technique_handles)
4146         {
4147             ERR("Out of memory\n");
4148             hr = E_OUTOFMEMORY;
4149             goto err_out;
4150         }
4151
4152         for (i = 0; i < base->technique_count; ++i)
4153         {
4154             struct d3dx_technique *technique;
4155
4156             technique = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*technique));
4157             if (!technique)
4158             {
4159                 ERR("Out of memory\n");
4160                 hr = E_OUTOFMEMORY;
4161                 goto err_out;
4162             }
4163
4164             technique_handles[i] = get_technique_handle(technique);
4165             technique->base = base;
4166
4167             hr = d3dx9_parse_effect_technique(technique, data, &ptr);
4168             if (hr != D3D_OK)
4169             {
4170                 WARN("Failed to parse technique\n");
4171                 goto err_out;
4172             }
4173         }
4174     }
4175
4176     read_dword(&ptr, &stringcount);
4177     TRACE("String count: %u\n", stringcount);
4178
4179     skip_dword_unknown(&ptr, 1);
4180
4181     for (i = 0; i < stringcount; ++i)
4182     {
4183         DWORD id;
4184         struct d3dx_parameter *param;
4185
4186         read_dword(&ptr, &id);
4187         TRACE("Id: %u\n", id);
4188
4189         param = get_parameter_struct(base->objects[id]);
4190
4191         hr = d3dx9_parse_data(param, &ptr);
4192         if (hr != D3D_OK)
4193         {
4194             WARN("Failed to parse data\n");
4195             goto err_out;
4196         }
4197     }
4198
4199     HeapFree(GetProcessHeap(), 0, objects);
4200     base->objects = NULL;
4201
4202     base->technique_handles = technique_handles;
4203     base->parameter_handles = parameter_handles;
4204
4205     return D3D_OK;
4206
4207 err_out:
4208
4209     if (technique_handles)
4210     {
4211         for (i = 0; i < base->technique_count; ++i)
4212         {
4213             free_technique(technique_handles[i]);
4214         }
4215         HeapFree(GetProcessHeap(), 0, technique_handles);
4216     }
4217
4218     if (parameter_handles)
4219     {
4220         for (i = 0; i < base->parameter_count; ++i)
4221         {
4222             free_parameter(parameter_handles[i], FALSE, FALSE);
4223         }
4224         HeapFree(GetProcessHeap(), 0, parameter_handles);
4225     }
4226
4227     HeapFree(GetProcessHeap(), 0, objects);
4228
4229     return hr;
4230 }
4231
4232 static HRESULT d3dx9_base_effect_init(struct ID3DXBaseEffectImpl *base,
4233         const char *data, SIZE_T data_size, struct ID3DXEffectImpl *effect)
4234 {
4235     DWORD tag, offset;
4236     const char *ptr = data;
4237     HRESULT hr;
4238
4239     TRACE("base %p, data %p, data_size %lu, effect %p\n", base, data, data_size, effect);
4240
4241     base->ID3DXBaseEffect_iface.lpVtbl = &ID3DXBaseEffect_Vtbl;
4242     base->ref = 1;
4243     base->effect = effect;
4244
4245     read_dword(&ptr, &tag);
4246     TRACE("Tag: %x\n", tag);
4247
4248     if (tag != d3dx9_effect_version(9, 1))
4249     {
4250         /* todo: compile hlsl ascii code */
4251         FIXME("HLSL ascii effects not supported, yet\n");
4252
4253         /* Show the start of the shader for debugging info. */
4254         TRACE("effect:\n%s\n", debugstr_an(data, data_size > 40 ? 40 : data_size));
4255     }
4256     else
4257     {
4258         read_dword(&ptr, &offset);
4259         TRACE("Offset: %x\n", offset);
4260
4261         hr = d3dx9_parse_effect(base, ptr, data_size, offset);
4262         if (hr != D3D_OK)
4263         {
4264             FIXME("Failed to parse effect.\n");
4265             return hr;
4266         }
4267     }
4268
4269     return D3D_OK;
4270 }
4271
4272 static HRESULT d3dx9_effect_init(struct ID3DXEffectImpl *effect, LPDIRECT3DDEVICE9 device,
4273         const char *data, SIZE_T data_size, LPD3DXEFFECTPOOL pool)
4274 {
4275     HRESULT hr;
4276     struct ID3DXBaseEffectImpl *object = NULL;
4277
4278     TRACE("effect %p, device %p, data %p, data_size %lu, pool %p\n", effect, device, data, data_size, pool);
4279
4280     effect->ID3DXEffect_iface.lpVtbl = &ID3DXEffect_Vtbl;
4281     effect->ref = 1;
4282
4283     if (pool) pool->lpVtbl->AddRef(pool);
4284     effect->pool = pool;
4285
4286     IDirect3DDevice9_AddRef(device);
4287     effect->device = device;
4288
4289     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4290     if (!object)
4291     {
4292         ERR("Out of memory\n");
4293         hr = E_OUTOFMEMORY;
4294         goto err_out;
4295     }
4296
4297     hr = d3dx9_base_effect_init(object, data, data_size, effect);
4298     if (hr != D3D_OK)
4299     {
4300         FIXME("Failed to parse effect.\n");
4301         goto err_out;
4302     }
4303
4304     effect->base_effect = &object->ID3DXBaseEffect_iface;
4305
4306     return D3D_OK;
4307
4308 err_out:
4309
4310     HeapFree(GetProcessHeap(), 0, object);
4311     free_effect(effect);
4312
4313     return hr;
4314 }
4315
4316 HRESULT WINAPI D3DXCreateEffectEx(LPDIRECT3DDEVICE9 device,
4317                                   LPCVOID srcdata,
4318                                   UINT srcdatalen,
4319                                   CONST D3DXMACRO* defines,
4320                                   LPD3DXINCLUDE include,
4321                                   LPCSTR skip_constants,
4322                                   DWORD flags,
4323                                   LPD3DXEFFECTPOOL pool,
4324                                   LPD3DXEFFECT* effect,
4325                                   LPD3DXBUFFER* compilation_errors)
4326 {
4327     struct ID3DXEffectImpl *object;
4328     HRESULT hr;
4329
4330     FIXME("(%p, %p, %u, %p, %p, %p, %#x, %p, %p, %p): semi-stub\n", device, srcdata, srcdatalen, defines, include,
4331         skip_constants, flags, pool, effect, compilation_errors);
4332
4333     if (!device || !srcdata)
4334         return D3DERR_INVALIDCALL;
4335
4336     if (!srcdatalen)
4337         return E_FAIL;
4338
4339     /* Native dll allows effect to be null so just return D3D_OK after doing basic checks */
4340     if (!effect)
4341         return D3D_OK;
4342
4343     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4344     if (!object)
4345     {
4346         ERR("Out of memory\n");
4347         return E_OUTOFMEMORY;
4348     }
4349
4350     hr = d3dx9_effect_init(object, device, srcdata, srcdatalen, pool);
4351     if (FAILED(hr))
4352     {
4353         WARN("Failed to initialize shader reflection\n");
4354         HeapFree(GetProcessHeap(), 0, object);
4355         return hr;
4356     }
4357
4358     *effect = &object->ID3DXEffect_iface;
4359
4360     TRACE("Created ID3DXEffect %p\n", object);
4361
4362     return D3D_OK;
4363 }
4364
4365 HRESULT WINAPI D3DXCreateEffect(LPDIRECT3DDEVICE9 device,
4366                                 LPCVOID srcdata,
4367                                 UINT srcdatalen,
4368                                 CONST D3DXMACRO* defines,
4369                                 LPD3DXINCLUDE include,
4370                                 DWORD flags,
4371                                 LPD3DXEFFECTPOOL pool,
4372                                 LPD3DXEFFECT* effect,
4373                                 LPD3DXBUFFER* compilation_errors)
4374 {
4375     TRACE("(%p, %p, %u, %p, %p, %#x, %p, %p, %p): Forwarded to D3DXCreateEffectEx\n", device, srcdata, srcdatalen, defines,
4376         include, flags, pool, effect, compilation_errors);
4377
4378     return D3DXCreateEffectEx(device, srcdata, srcdatalen, defines, include, NULL, flags, pool, effect, compilation_errors);
4379 }
4380
4381 static HRESULT d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl *compiler, const char *data, SIZE_T data_size)
4382 {
4383     HRESULT hr;
4384     struct ID3DXBaseEffectImpl *object = NULL;
4385
4386     TRACE("effect %p, data %p, data_size %lu\n", compiler, data, data_size);
4387
4388     compiler->ID3DXEffectCompiler_iface.lpVtbl = &ID3DXEffectCompiler_Vtbl;
4389     compiler->ref = 1;
4390
4391     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4392     if (!object)
4393     {
4394         ERR("Out of memory\n");
4395         hr = E_OUTOFMEMORY;
4396         goto err_out;
4397     }
4398
4399     hr = d3dx9_base_effect_init(object, data, data_size, NULL);
4400     if (hr != D3D_OK)
4401     {
4402         FIXME("Failed to parse effect.\n");
4403         goto err_out;
4404     }
4405
4406     compiler->base_effect = &object->ID3DXBaseEffect_iface;
4407
4408     return D3D_OK;
4409
4410 err_out:
4411
4412     HeapFree(GetProcessHeap(), 0, object);
4413     free_effect_compiler(compiler);
4414
4415     return hr;
4416 }
4417
4418 HRESULT WINAPI D3DXCreateEffectCompiler(LPCSTR srcdata,
4419                                         UINT srcdatalen,
4420                                         CONST D3DXMACRO *defines,
4421                                         LPD3DXINCLUDE include,
4422                                         DWORD flags,
4423                                         LPD3DXEFFECTCOMPILER *compiler,
4424                                         LPD3DXBUFFER *parse_errors)
4425 {
4426     struct ID3DXEffectCompilerImpl *object;
4427     HRESULT hr;
4428
4429     TRACE("srcdata %p, srcdatalen %u, defines %p, include %p, flags %#x, compiler %p, parse_errors %p\n",
4430             srcdata, srcdatalen, defines, include, flags, compiler, parse_errors);
4431
4432     if (!srcdata || !compiler)
4433     {
4434         WARN("Invalid arguments supplied\n");
4435         return D3DERR_INVALIDCALL;
4436     }
4437
4438     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4439     if (!object)
4440     {
4441         ERR("Out of memory\n");
4442         return E_OUTOFMEMORY;
4443     }
4444
4445     hr = d3dx9_effect_compiler_init(object, srcdata, srcdatalen);
4446     if (FAILED(hr))
4447     {
4448         WARN("Failed to initialize effect compiler\n");
4449         HeapFree(GetProcessHeap(), 0, object);
4450         return hr;
4451     }
4452
4453     *compiler = &object->ID3DXEffectCompiler_iface;
4454
4455     TRACE("Created ID3DXEffectCompiler %p\n", object);
4456
4457     return D3D_OK;
4458 }
4459
4460 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl;
4461
4462 struct ID3DXEffectPoolImpl
4463 {
4464     ID3DXEffectPool ID3DXEffectPool_iface;
4465     LONG ref;
4466 };
4467
4468 static inline struct ID3DXEffectPoolImpl *impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
4469 {
4470     return CONTAINING_RECORD(iface, struct ID3DXEffectPoolImpl, ID3DXEffectPool_iface);
4471 }
4472
4473 /*** IUnknown methods ***/
4474 static HRESULT WINAPI ID3DXEffectPoolImpl_QueryInterface(ID3DXEffectPool *iface, REFIID riid, void **object)
4475 {
4476     struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
4477
4478     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
4479
4480     if (IsEqualGUID(riid, &IID_IUnknown) ||
4481         IsEqualGUID(riid, &IID_ID3DXEffectPool))
4482     {
4483         This->ID3DXEffectPool_iface.lpVtbl->AddRef(iface);
4484         *object = This;
4485         return S_OK;
4486     }
4487
4488     WARN("Interface %s not found\n", debugstr_guid(riid));
4489
4490     return E_NOINTERFACE;
4491 }
4492
4493 static ULONG WINAPI ID3DXEffectPoolImpl_AddRef(ID3DXEffectPool *iface)
4494 {
4495     struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
4496
4497     TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
4498
4499     return InterlockedIncrement(&This->ref);
4500 }
4501
4502 static ULONG WINAPI ID3DXEffectPoolImpl_Release(ID3DXEffectPool *iface)
4503 {
4504     struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
4505     ULONG ref = InterlockedDecrement(&This->ref);
4506
4507     TRACE("(%p)->(): Release from %u\n", This, ref + 1);
4508
4509     if (!ref)
4510         HeapFree(GetProcessHeap(), 0, This);
4511
4512     return ref;
4513 }
4514
4515 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl =
4516 {
4517     /*** IUnknown methods ***/
4518     ID3DXEffectPoolImpl_QueryInterface,
4519     ID3DXEffectPoolImpl_AddRef,
4520     ID3DXEffectPoolImpl_Release
4521 };
4522
4523 HRESULT WINAPI D3DXCreateEffectPool(LPD3DXEFFECTPOOL *pool)
4524 {
4525     struct ID3DXEffectPoolImpl *object;
4526
4527     TRACE("(%p)\n", pool);
4528
4529     if (!pool)
4530         return D3DERR_INVALIDCALL;
4531
4532     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4533     if (!object)
4534     {
4535         ERR("Out of memory\n");
4536         return E_OUTOFMEMORY;
4537     }
4538
4539     object->ID3DXEffectPool_iface.lpVtbl = &ID3DXEffectPool_Vtbl;
4540     object->ref = 1;
4541
4542     *pool = &object->ID3DXEffectPool_iface;
4543
4544     return S_OK;
4545 }
4546
4547 HRESULT WINAPI D3DXCreateEffectFromFileExW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
4548     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
4549     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
4550 {
4551     LPVOID buffer;
4552     HRESULT ret;
4553     DWORD size;
4554
4555     TRACE("(%s): relay\n", debugstr_w(srcfile));
4556
4557     if (!device || !srcfile)
4558         return D3DERR_INVALIDCALL;
4559
4560     ret = map_view_of_file(srcfile, &buffer, &size);
4561
4562     if (FAILED(ret))
4563         return D3DXERR_INVALIDDATA;
4564
4565     ret = D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
4566     UnmapViewOfFile(buffer);
4567
4568     return ret;
4569 }
4570
4571 HRESULT WINAPI D3DXCreateEffectFromFileExA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
4572     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
4573     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
4574 {
4575     LPWSTR srcfileW;
4576     HRESULT ret;
4577     DWORD len;
4578
4579     TRACE("(void): relay\n");
4580
4581     if (!srcfile)
4582         return D3DERR_INVALIDCALL;
4583
4584     len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
4585     srcfileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*srcfileW));
4586     MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
4587
4588     ret = D3DXCreateEffectFromFileExW(device, srcfileW, defines, include, skipconstants, flags, pool, effect, compilationerrors);
4589     HeapFree(GetProcessHeap(), 0, srcfileW);
4590
4591     return ret;
4592 }
4593
4594 HRESULT WINAPI D3DXCreateEffectFromFileW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
4595     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
4596     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
4597 {
4598     TRACE("(void): relay\n");
4599     return D3DXCreateEffectFromFileExW(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
4600 }
4601
4602 HRESULT WINAPI D3DXCreateEffectFromFileA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
4603     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
4604     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
4605 {
4606     TRACE("(void): relay\n");
4607     return D3DXCreateEffectFromFileExA(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
4608 }
4609
4610 HRESULT WINAPI D3DXCreateEffectFromResourceExW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
4611     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
4612     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
4613 {
4614     HRSRC resinfo;
4615
4616     TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
4617
4618     if (!device)
4619         return D3DERR_INVALIDCALL;
4620
4621     resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
4622
4623     if (resinfo)
4624     {
4625         LPVOID buffer;
4626         HRESULT ret;
4627         DWORD size;
4628
4629         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
4630
4631         if (FAILED(ret))
4632             return D3DXERR_INVALIDDATA;
4633
4634         return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
4635     }
4636
4637     return D3DXERR_INVALIDDATA;
4638 }
4639
4640 HRESULT WINAPI D3DXCreateEffectFromResourceExA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
4641     const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
4642     LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
4643 {
4644     HRSRC resinfo;
4645
4646     TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
4647
4648     if (!device)
4649         return D3DERR_INVALIDCALL;
4650
4651     resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
4652
4653     if (resinfo)
4654     {
4655         LPVOID buffer;
4656         HRESULT ret;
4657         DWORD size;
4658
4659         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
4660
4661         if (FAILED(ret))
4662             return D3DXERR_INVALIDDATA;
4663
4664         return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
4665     }
4666
4667     return D3DXERR_INVALIDDATA;
4668 }
4669
4670 HRESULT WINAPI D3DXCreateEffectFromResourceW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
4671     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
4672     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
4673 {
4674     TRACE("(void): relay\n");
4675     return D3DXCreateEffectFromResourceExW(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
4676 }
4677
4678 HRESULT WINAPI D3DXCreateEffectFromResourceA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
4679     const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
4680     LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
4681 {
4682     TRACE("(void): relay\n");
4683     return D3DXCreateEffectFromResourceExA(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
4684 }
4685
4686 HRESULT WINAPI D3DXCreateEffectCompilerFromFileW(LPCWSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
4687     DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
4688 {
4689     LPVOID buffer;
4690     HRESULT ret;
4691     DWORD size;
4692
4693     TRACE("(%s): relay\n", debugstr_w(srcfile));
4694
4695     if (!srcfile)
4696         return D3DERR_INVALIDCALL;
4697
4698     ret = map_view_of_file(srcfile, &buffer, &size);
4699
4700     if (FAILED(ret))
4701         return D3DXERR_INVALIDDATA;
4702
4703     ret = D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
4704     UnmapViewOfFile(buffer);
4705
4706     return ret;
4707 }
4708
4709 HRESULT WINAPI D3DXCreateEffectCompilerFromFileA(LPCSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
4710     DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
4711 {
4712     LPWSTR srcfileW;
4713     HRESULT ret;
4714     DWORD len;
4715
4716     TRACE("(void): relay\n");
4717
4718     if (!srcfile)
4719         return D3DERR_INVALIDCALL;
4720
4721     len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
4722     srcfileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*srcfileW));
4723     MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
4724
4725     ret = D3DXCreateEffectCompilerFromFileW(srcfileW, defines, include, flags, effectcompiler, parseerrors);
4726     HeapFree(GetProcessHeap(), 0, srcfileW);
4727
4728     return ret;
4729 }
4730
4731 HRESULT WINAPI D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule, LPCSTR srcresource, const D3DXMACRO *defines,
4732     LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
4733 {
4734     HRSRC resinfo;
4735
4736     TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
4737
4738     resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
4739
4740     if (resinfo)
4741     {
4742         LPVOID buffer;
4743         HRESULT ret;
4744         DWORD size;
4745
4746         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
4747
4748         if (FAILED(ret))
4749             return D3DXERR_INVALIDDATA;
4750
4751         return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
4752     }
4753
4754     return D3DXERR_INVALIDDATA;
4755 }
4756
4757 HRESULT WINAPI D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule, LPCWSTR srcresource, const D3DXMACRO *defines,
4758     LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
4759 {
4760     HRSRC resinfo;
4761
4762     TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
4763
4764     resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
4765
4766     if (resinfo)
4767     {
4768         LPVOID buffer;
4769         HRESULT ret;
4770         DWORD size;
4771
4772         ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
4773
4774         if (FAILED(ret))
4775             return D3DXERR_INVALIDDATA;
4776
4777         return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
4778     }
4779
4780     return D3DXERR_INVALIDDATA;
4781 }