git.oblomov.eu Git - wine/blob - dlls/d3dx9_36/effect.c

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