dlls/d3dx9_36/effect.c

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