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