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