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