dlls/d3dx9_36/effect.c

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