dlls/d3dx9_36/effect.c

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