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