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