dlls/d3dx9_36/effect.c

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