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

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