dlls/d3dx9_36/effect.c

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