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