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

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