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