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

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   3  * Copyright 2009 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
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include "d3d10_private.h"
  25
  26 #include <float.h>
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(d3d10);
  29
  30 #define D3D10_FX10_TYPE_COLUMN_SHIFT    11
  31 #define D3D10_FX10_TYPE_COLUMN_MASK     (0x7 << D3D10_FX10_TYPE_COLUMN_SHIFT)
  32
  33 #define D3D10_FX10_TYPE_ROW_SHIFT       8
  34 #define D3D10_FX10_TYPE_ROW_MASK        (0x7 << D3D10_FX10_TYPE_ROW_SHIFT)
  35
  36 #define D3D10_FX10_TYPE_BASETYPE_SHIFT  3
  37 #define D3D10_FX10_TYPE_BASETYPE_MASK   (0x1f << D3D10_FX10_TYPE_BASETYPE_SHIFT)
  38
  39 #define D3D10_FX10_TYPE_CLASS_SHIFT     0
  40 #define D3D10_FX10_TYPE_CLASS_MASK      (0x7 << D3D10_FX10_TYPE_CLASS_SHIFT)
  41
  42 #define D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK 0x4000
  43
  44 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl;
  45 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl;
  46 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl;
  47 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl;
  48 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl;
  49 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl;
  50 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl;
  51 static const struct ID3D10EffectStringVariableVtbl d3d10_effect_string_variable_vtbl;
  52 static const struct ID3D10EffectShaderResourceVariableVtbl d3d10_effect_shader_resource_variable_vtbl;
  53 static const struct ID3D10EffectRenderTargetViewVariableVtbl d3d10_effect_render_target_view_variable_vtbl;
  54 static const struct ID3D10EffectDepthStencilViewVariableVtbl d3d10_effect_depth_stencil_view_variable_vtbl;
  55 static const struct ID3D10EffectShaderVariableVtbl d3d10_effect_shader_variable_vtbl;
  56 static const struct ID3D10EffectBlendVariableVtbl d3d10_effect_blend_variable_vtbl;
  57 static const struct ID3D10EffectDepthStencilVariableVtbl d3d10_effect_depth_stencil_variable_vtbl;
  58 static const struct ID3D10EffectRasterizerVariableVtbl d3d10_effect_rasterizer_variable_vtbl;
  59 static const struct ID3D10EffectSamplerVariableVtbl d3d10_effect_sampler_variable_vtbl;
  60 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl;
  61
  62 /* null objects - needed for invalid calls */
  63 static struct d3d10_effect_technique null_technique = {{&d3d10_effect_technique_vtbl}};
  64 static struct d3d10_effect_pass null_pass = {{&d3d10_effect_pass_vtbl}};
  65 static struct d3d10_effect_type null_type = {{&d3d10_effect_type_vtbl}};
  66 static struct d3d10_effect_variable null_local_buffer = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl},
  67         &null_local_buffer, &null_type};
  68 static struct d3d10_effect_variable null_variable = {{&d3d10_effect_variable_vtbl},
  69         &null_local_buffer, &null_type};
  70 static struct d3d10_effect_variable null_scalar_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl},
  71         &null_local_buffer, &null_type};
  72 static struct d3d10_effect_variable null_vector_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl},
  73         &null_local_buffer, &null_type};
  74 static struct d3d10_effect_variable null_matrix_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl},
  75         &null_local_buffer, &null_type};
  76 static struct d3d10_effect_variable null_string_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl},
  77         &null_local_buffer, &null_type};
  78 static struct d3d10_effect_variable null_shader_resource_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl},
  79         &null_local_buffer, &null_type};
  80 static struct d3d10_effect_variable null_render_target_view_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl},
  81         &null_local_buffer, &null_type};
  82 static struct d3d10_effect_variable null_depth_stencil_view_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl},
  83         &null_local_buffer, &null_type};
  84 static struct d3d10_effect_variable null_shader_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
  85         &null_local_buffer, &null_type};
  86 static struct d3d10_effect_variable null_blend_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl},
  87         &null_local_buffer, &null_type};
  88 static struct d3d10_effect_variable null_depth_stencil_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl},
  89         &null_local_buffer, &null_type};
  90 static struct d3d10_effect_variable null_rasterizer_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl},
  91         &null_local_buffer, &null_type};
  92 static struct d3d10_effect_variable null_sampler_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl},
  93         &null_local_buffer, &null_type};
  94
  95 /* anonymous_shader_type and anonymous_shader */
  96 static char anonymous_name[] = "$Anonymous";
  97 static char anonymous_vertexshader_name[] = "vertexshader";
  98 static char anonymous_pixelshader_name[] = "pixelshader";
  99 static char anonymous_geometryshader_name[] = "geometryshader";
 100 static struct d3d10_effect_type anonymous_vs_type = {{&d3d10_effect_type_vtbl},
 101         anonymous_vertexshader_name, D3D10_SVT_VERTEXSHADER, D3D10_SVC_OBJECT};
 102 static struct d3d10_effect_type anonymous_ps_type = {{&d3d10_effect_type_vtbl},
 103         anonymous_pixelshader_name, D3D10_SVT_PIXELSHADER, D3D10_SVC_OBJECT};
 104 static struct d3d10_effect_type anonymous_gs_type = {{&d3d10_effect_type_vtbl},
 105         anonymous_geometryshader_name, D3D10_SVT_GEOMETRYSHADER, D3D10_SVC_OBJECT};
 106 static struct d3d10_effect_variable anonymous_vs = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
 107         &null_local_buffer, &anonymous_vs_type, &null_shader_variable, anonymous_name};
 108 static struct d3d10_effect_variable anonymous_ps = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
 109         &null_local_buffer, &anonymous_ps_type, &null_shader_variable, anonymous_name};
 110 static struct d3d10_effect_variable anonymous_gs = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
 111         &null_local_buffer, &anonymous_gs_type, &null_shader_variable, anonymous_name};
 112
 113 static struct d3d10_effect_type *get_fx10_type(struct d3d10_effect *effect, const char *data, DWORD offset);
 114
 115 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectVariable(ID3D10EffectVariable *iface)
 116 {
 117     return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
 118 }
 119
 120 struct d3d10_effect_state_property_info
 121 {
 122     UINT id;
 123     const char *name;
 124     D3D_SHADER_VARIABLE_TYPE type;
 125     UINT size;
 126     UINT count;
 127     D3D_SHADER_VARIABLE_TYPE container_type;
 128     LONG offset;
 129 };
 130
 131 static const struct d3d10_effect_state_property_info property_info[] =
 132 {
 133     {0x0c, "RasterizerState.FillMode",                    D3D10_SVT_INT,   1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, FillMode)                       },
 134     {0x0d, "RasterizerState.CullMode",                    D3D10_SVT_INT,   1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, CullMode)                       },
 135     {0x0e, "RasterizerState.FrontCounterClockwise",       D3D10_SVT_BOOL,  1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, FrontCounterClockwise)          },
 136     {0x0f, "RasterizerState.DepthBias",                   D3D10_SVT_INT,   1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, DepthBias)                      },
 137     {0x10, "RasterizerState.DepthBiasClamp",              D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, DepthBiasClamp)                 },
 138     {0x11, "RasterizerState.SlopeScaledDepthBias",        D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, SlopeScaledDepthBias)           },
 139     {0x12, "RasterizerState.DepthClipEnable",             D3D10_SVT_BOOL,  1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, DepthClipEnable)                },
 140     {0x13, "RasterizerState.ScissorEnable",               D3D10_SVT_BOOL,  1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, ScissorEnable)                  },
 141     {0x14, "RasterizerState.MultisampleEnable",           D3D10_SVT_BOOL,  1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, MultisampleEnable)              },
 142     {0x15, "RasterizerState.AntialiasedLineEnable",       D3D10_SVT_BOOL,  1, 1, D3D10_SVT_RASTERIZER,   FIELD_OFFSET(D3D10_RASTERIZER_DESC, AntialiasedLineEnable)          },
 143     {0x16, "DepthStencilState.DepthEnable",               D3D10_SVT_BOOL,  1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, DepthEnable)                 },
 144     {0x17, "DepthStencilState.DepthWriteMask",            D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, DepthWriteMask)              },
 145     {0x18, "DepthStencilState.DepthFunc",                 D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, DepthFunc)                   },
 146     {0x19, "DepthStencilState.StencilEnable",             D3D10_SVT_BOOL,  1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, StencilEnable)               },
 147     {0x1a, "DepthStencilState.StencilReadMask",           D3D10_SVT_UINT8, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, StencilReadMask)             },
 148     {0x1b, "DepthStencilState.StencilWriteMask",          D3D10_SVT_UINT8, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, StencilWriteMask)            },
 149     {0x1c, "DepthStencilState.FrontFaceStencilFail",      D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilFailOp)     },
 150     {0x1d, "DepthStencilState.FrontFaceStencilDepthFail", D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilDepthFailOp)},
 151     {0x1e, "DepthStencilState.FrontFaceStencilPass",      D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilPassOp)     },
 152     {0x1f, "DepthStencilState.FrontFaceStencilFunc",      D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilFunc)       },
 153     {0x20, "DepthStencilState.BackFaceStencilFail",       D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilFailOp)      },
 154     {0x21, "DepthStencilState.BackFaceStencilDepthFail",  D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilDepthFailOp) },
 155     {0x22, "DepthStencilState.BackFaceStencilPass",       D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilPassOp)      },
 156     {0x23, "DepthStencilState.BackFaceStencilFunc",       D3D10_SVT_INT,   1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilFunc)        },
 157     {0x24, "BlendState.AlphaToCoverageEnable",            D3D10_SVT_BOOL,  1, 1, D3D10_SVT_BLEND,        FIELD_OFFSET(D3D10_BLEND_DESC,         AlphaToCoverageEnable)       },
 158     {0x25, "BlendState.BlendEnable",                      D3D10_SVT_BOOL,  1, 8, D3D10_SVT_BLEND,        FIELD_OFFSET(D3D10_BLEND_DESC,         BlendEnable)                 },
 159     {0x26, "BlendState.SrcBlend",                         D3D10_SVT_INT,   1, 1, D3D10_SVT_BLEND,        FIELD_OFFSET(D3D10_BLEND_DESC,         SrcBlend)                    },
 160     {0x27, "BlendState.DestBlend",                        D3D10_SVT_INT,   1, 1, D3D10_SVT_BLEND,        FIELD_OFFSET(D3D10_BLEND_DESC,         DestBlend)                   },
 161     {0x28, "BlendState.BlendOp",                          D3D10_SVT_INT,   1, 1, D3D10_SVT_BLEND,        FIELD_OFFSET(D3D10_BLEND_DESC,         BlendOp)                     },
 162     {0x29, "BlendState.SrcBlendAlpha",                    D3D10_SVT_INT,   1, 1, D3D10_SVT_BLEND,        FIELD_OFFSET(D3D10_BLEND_DESC,         SrcBlendAlpha)               },
 163     {0x2a, "BlendState.DestBlendAlpha",                   D3D10_SVT_INT,   1, 1, D3D10_SVT_BLEND,        FIELD_OFFSET(D3D10_BLEND_DESC,         DestBlendAlpha)              },
 164     {0x2b, "BlendState.BlendOpAlpha",                     D3D10_SVT_INT,   1, 1, D3D10_SVT_BLEND,        FIELD_OFFSET(D3D10_BLEND_DESC,         BlendOpAlpha)                },
 165     {0x2c, "BlendState.RenderTargetWriteMask",            D3D10_SVT_UINT8, 1, 8, D3D10_SVT_BLEND,        FIELD_OFFSET(D3D10_BLEND_DESC,         RenderTargetWriteMask)       },
 166     {0x2d, "SamplerState.Filter",                         D3D10_SVT_INT,   1, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       Filter)                      },
 167     {0x2e, "SamplerState.AddressU",                       D3D10_SVT_INT,   1, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       AddressU)                    },
 168     {0x2f, "SamplerState.AddressV",                       D3D10_SVT_INT,   1, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       AddressV)                    },
 169     {0x30, "SamplerState.AddressW",                       D3D10_SVT_INT,   1, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       AddressW)                    },
 170     {0x31, "SamplerState.MipMapLODBias",                  D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       MipLODBias)                  },
 171     {0x32, "SamplerState.MaxAnisotropy",                  D3D10_SVT_UINT,  1, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       MaxAnisotropy)               },
 172     {0x33, "SamplerState.ComparisonFunc",                 D3D10_SVT_INT,   1, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       ComparisonFunc)              },
 173     {0x34, "SamplerState.BorderColor",                    D3D10_SVT_FLOAT, 4, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       BorderColor)                 },
 174     {0x35, "SamplerState.MinLOD",                         D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       MinLOD)                      },
 175     {0x36, "SamplerState.MaxLOD",                         D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_SAMPLER,      FIELD_OFFSET(D3D10_SAMPLER_DESC,       MaxLOD)                      },
 176 };
 177
 178 static const D3D10_RASTERIZER_DESC default_rasterizer_desc =
 179 {
 180     D3D10_FILL_SOLID,
 181     D3D10_CULL_BACK,
 182     FALSE,
 183     0,
 184     0.0f,
 185     0.0f,
 186     TRUE,
 187     FALSE,
 188     FALSE,
 189     FALSE,
 190 };
 191
 192 static const D3D10_DEPTH_STENCIL_DESC default_depth_stencil_desc =
 193 {
 194     TRUE,
 195     D3D10_DEPTH_WRITE_MASK_ALL,
 196     D3D10_COMPARISON_LESS,
 197     FALSE,
 198     D3D10_DEFAULT_STENCIL_READ_MASK,
 199     D3D10_DEFAULT_STENCIL_WRITE_MASK,
 200     {D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_COMPARISON_ALWAYS},
 201     {D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_COMPARISON_ALWAYS},
 202 };
 203
 204 static const D3D10_BLEND_DESC default_blend_desc =
 205 {
 206     FALSE,
 207     {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE},
 208     D3D10_BLEND_SRC_ALPHA,
 209     D3D10_BLEND_INV_SRC_ALPHA,
 210     D3D10_BLEND_OP_ADD,
 211     D3D10_BLEND_SRC_ALPHA,
 212     D3D10_BLEND_INV_SRC_ALPHA,
 213     D3D10_BLEND_OP_ADD,
 214     {0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf},
 215 };
 216
 217 static const D3D10_SAMPLER_DESC default_sampler_desc =
 218 {
 219     D3D10_FILTER_MIN_MAG_MIP_POINT,
 220     D3D10_TEXTURE_ADDRESS_WRAP,
 221     D3D10_TEXTURE_ADDRESS_WRAP,
 222     D3D10_TEXTURE_ADDRESS_WRAP,
 223     0.0f,
 224     16,
 225     D3D10_COMPARISON_NEVER,
 226     {0.0f, 0.0f, 0.0f, 0.0f},
 227     0.0f,
 228     FLT_MAX,
 229 };
 230
 231 struct d3d10_effect_state_storage_info
 232 {
 233     D3D_SHADER_VARIABLE_TYPE id;
 234     size_t size;
 235     const void *default_state;
 236 };
 237
 238 static const struct d3d10_effect_state_storage_info d3d10_effect_state_storage_info[] =
 239 {
 240     {D3D10_SVT_RASTERIZER,   sizeof(default_rasterizer_desc),    &default_rasterizer_desc   },
 241     {D3D10_SVT_DEPTHSTENCIL, sizeof(default_depth_stencil_desc), &default_depth_stencil_desc},
 242     {D3D10_SVT_BLEND,        sizeof(default_blend_desc),         &default_blend_desc        },
 243     {D3D10_SVT_SAMPLER,      sizeof(default_sampler_desc),       &default_sampler_desc      },
 244 };
 245
 246 static BOOL copy_name(const char *ptr, char **name)
 247 {
 248     size_t name_len;
 249
 250     if (!ptr) return TRUE;
 251
 252     name_len = strlen(ptr) + 1;
 253     if (name_len == 1)
 254     {
 255         return TRUE;
 256     }
 257
 258     *name = HeapAlloc(GetProcessHeap(), 0, name_len);
 259     if (!*name)
 260     {
 261         ERR("Failed to allocate name memory.\n");
 262         return FALSE;
 263     }
 264
 265     memcpy(*name, ptr, name_len);
 266
 267     return TRUE;
 268 }
 269
 270 static HRESULT shader_parse_signature(const char *data, DWORD data_size, struct d3d10_effect_shader_signature *s)
 271 {
 272     D3D10_SIGNATURE_PARAMETER_DESC *e;
 273     const char *ptr = data;
 274     unsigned int i;
 275     DWORD count;
 276
 277     read_dword(&ptr, &count);
 278     TRACE("%u elements\n", count);
 279
 280     skip_dword_unknown("shader signature", &ptr, 1);
 281
 282     e = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*e));
 283     if (!e)
 284     {
 285         ERR("Failed to allocate signature memory.\n");
 286         return E_OUTOFMEMORY;
 287     }
 288
 289     for (i = 0; i < count; ++i)
 290     {
 291         UINT name_offset;
 292         UINT mask;
 293
 294         read_dword(&ptr, &name_offset);
 295         e[i].SemanticName = data + name_offset;
 296         read_dword(&ptr, &e[i].SemanticIndex);
 297         read_dword(&ptr, &e[i].SystemValueType);
 298         read_dword(&ptr, &e[i].ComponentType);
 299         read_dword(&ptr, &e[i].Register);
 300         read_dword(&ptr, &mask);
 301
 302         e[i].ReadWriteMask = mask >> 8;
 303         e[i].Mask = mask & 0xff;
 304
 305         TRACE("semantic: %s, semantic idx: %u, sysval_semantic %#x, "
 306                 "type %u, register idx: %u, use_mask %#x, input_mask %#x\n",
 307                 debugstr_a(e[i].SemanticName), e[i].SemanticIndex, e[i].SystemValueType,
 308                 e[i].ComponentType, e[i].Register, e[i].Mask, e[i].ReadWriteMask);
 309     }
 310
 311     s->elements = e;
 312     s->element_count = count;
 313
 314     return S_OK;
 315 }
 316
 317 static void shader_free_signature(struct d3d10_effect_shader_signature *s)
 318 {
 319     HeapFree(GetProcessHeap(), 0, s->signature);
 320     HeapFree(GetProcessHeap(), 0, s->elements);
 321 }
 322
 323 static HRESULT shader_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
 324 {
 325     struct d3d10_effect_shader_variable *s = ctx;
 326     HRESULT hr;
 327
 328     TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
 329
 330     TRACE("chunk size: %#x\n", data_size);
 331
 332     switch(tag)
 333     {
 334         case TAG_ISGN:
 335         case TAG_OSGN:
 336         {
 337             /* 32 (DXBC header) + 1 * 4 (chunk index) + 2 * 4 (chunk header) + data_size (chunk data) */
 338             UINT size = 44 + data_size;
 339             struct d3d10_effect_shader_signature *sig;
 340             char *ptr;
 341
 342             if (tag == TAG_ISGN) sig = &s->input_signature;
 343             else sig = &s->output_signature;
 344
 345             sig->signature = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 346             if (!sig->signature)
 347             {
 348                 ERR("Failed to allocate input signature data\n");
 349                 return E_OUTOFMEMORY;
 350             }
 351             sig->signature_size = size;
 352
 353             ptr = sig->signature;
 354
 355             write_dword(&ptr, TAG_DXBC);
 356
 357             /* signature(?) */
 358             write_dword_unknown(&ptr, 0);
 359             write_dword_unknown(&ptr, 0);
 360             write_dword_unknown(&ptr, 0);
 361             write_dword_unknown(&ptr, 0);
 362
 363             /* seems to be always 1 */
 364             write_dword_unknown(&ptr, 1);
 365
 366             /* DXBC size */
 367             write_dword(&ptr, size);
 368
 369             /* chunk count */
 370             write_dword(&ptr, 1);
 371
 372             /* chunk index */
 373             write_dword(&ptr, (ptr - sig->signature) + 4);
 374
 375             /* chunk */
 376             write_dword(&ptr, tag);
 377             write_dword(&ptr, data_size);
 378             memcpy(ptr, data, data_size);
 379
 380             hr = shader_parse_signature(ptr, data_size, sig);
 381             if (FAILED(hr))
 382             {
 383                 ERR("Failed to parse shader, hr %#x\n", hr);
 384                 shader_free_signature(sig);
 385             }
 386
 387             break;
 388         }
 389
 390         default:
 391             FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
 392             break;
 393     }
 394
 395     return S_OK;
 396 }
 397
 398 static HRESULT parse_shader(struct d3d10_effect_variable *v, const char *data)
 399 {
 400     ID3D10Device *device = v->effect->device;
 401     struct d3d10_effect_shader_variable *s;
 402     const char *ptr = data;
 403     DWORD dxbc_size;
 404     HRESULT hr;
 405
 406     s = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*s));
 407     if (!s)
 408     {
 409         ERR("Failed to allocate shader variable memory\n");
 410         return E_OUTOFMEMORY;
 411     }
 412
 413     v->data = s;
 414
 415     if (v->effect->used_shader_current >= v->effect->used_shader_count)
 416     {
 417         WARN("Invalid shader? Used shader current(%u) >= used shader count(%u)\n", v->effect->used_shader_current, v->effect->used_shader_count);
 418         return E_FAIL;
 419     }
 420
 421     v->effect->used_shaders[v->effect->used_shader_current] = v;
 422     ++v->effect->used_shader_current;
 423
 424     if (!ptr) return S_OK;
 425
 426     read_dword(&ptr, &dxbc_size);
 427     TRACE("dxbc size: %#x\n", dxbc_size);
 428
 429     /* We got a shader VertexShader vs = NULL, so it is fine to skip this. */
 430     if (!dxbc_size) return S_OK;
 431
 432     switch (v->type->basetype)
 433     {
 434         case D3D10_SVT_VERTEXSHADER:
 435             hr = ID3D10Device_CreateVertexShader(device, ptr, dxbc_size, &s->shader.vs);
 436             if (FAILED(hr)) return hr;
 437             break;
 438
 439         case D3D10_SVT_PIXELSHADER:
 440             hr = ID3D10Device_CreatePixelShader(device, ptr, dxbc_size, &s->shader.ps);
 441             if (FAILED(hr)) return hr;
 442             break;
 443
 444         case D3D10_SVT_GEOMETRYSHADER:
 445             hr = ID3D10Device_CreateGeometryShader(device, ptr, dxbc_size, &s->shader.gs);
 446             if (FAILED(hr)) return hr;
 447             break;
 448
 449         default:
 450             ERR("This should not happen!\n");
 451             return E_FAIL;
 452     }
 453
 454     return parse_dxbc(ptr, dxbc_size, shader_chunk_handler, s);
 455 }
 456
 457 static D3D10_SHADER_VARIABLE_CLASS d3d10_variable_class(DWORD c, BOOL is_column_major)
 458 {
 459     switch (c)
 460     {
 461         case 1: return D3D10_SVC_SCALAR;
 462         case 2: return D3D10_SVC_VECTOR;
 463         case 3: if (is_column_major) return D3D10_SVC_MATRIX_COLUMNS;
 464                 else return D3D10_SVC_MATRIX_ROWS;
 465         default:
 466             FIXME("Unknown variable class %#x.\n", c);
 467             return 0;
 468     }
 469 }
 470
 471 static D3D10_SHADER_VARIABLE_TYPE d3d10_variable_type(DWORD t, BOOL is_object)
 472 {
 473     if(is_object)
 474     {
 475         switch (t)
 476         {
 477             case 1: return D3D10_SVT_STRING;
 478             case 2: return D3D10_SVT_BLEND;
 479             case 3: return D3D10_SVT_DEPTHSTENCIL;
 480             case 4: return D3D10_SVT_RASTERIZER;
 481             case 5: return D3D10_SVT_PIXELSHADER;
 482             case 6: return D3D10_SVT_VERTEXSHADER;
 483             case 7: return D3D10_SVT_GEOMETRYSHADER;
 484
 485             case 10: return D3D10_SVT_TEXTURE1D;
 486             case 11: return D3D10_SVT_TEXTURE1DARRAY;
 487             case 12: return D3D10_SVT_TEXTURE2D;
 488             case 13: return D3D10_SVT_TEXTURE2DARRAY;
 489             case 14: return D3D10_SVT_TEXTURE2DMS;
 490             case 15: return D3D10_SVT_TEXTURE2DMSARRAY;
 491             case 16: return D3D10_SVT_TEXTURE3D;
 492             case 17: return D3D10_SVT_TEXTURECUBE;
 493
 494             case 19: return D3D10_SVT_RENDERTARGETVIEW;
 495             case 20: return D3D10_SVT_DEPTHSTENCILVIEW;
 496             case 21: return D3D10_SVT_SAMPLER;
 497             case 22: return D3D10_SVT_BUFFER;
 498             default:
 499                 FIXME("Unknown variable type %#x.\n", t);
 500                 return D3D10_SVT_VOID;
 501         }
 502     }
 503     else
 504     {
 505         switch (t)
 506         {
 507             case 1: return D3D10_SVT_FLOAT;
 508             case 2: return D3D10_SVT_INT;
 509             case 3: return D3D10_SVT_UINT;
 510             case 4: return D3D10_SVT_BOOL;
 511             default:
 512                 FIXME("Unknown variable type %#x.\n", t);
 513                 return D3D10_SVT_VOID;
 514         }
 515     }
 516 }
 517
 518 static HRESULT parse_fx10_type(struct d3d10_effect_type *t, const char *ptr, const char *data)
 519 {
 520     DWORD unknown0;
 521     DWORD offset;
 522     DWORD typeinfo;
 523     unsigned int i;
 524
 525     read_dword(&ptr, &offset);
 526     TRACE("Type name at offset %#x.\n", offset);
 527
 528     if (!copy_name(data + offset, &t->name))
 529     {
 530         ERR("Failed to copy name.\n");
 531         return E_OUTOFMEMORY;
 532     }
 533     TRACE("Type name: %s.\n", debugstr_a(t->name));
 534
 535     read_dword(&ptr, &unknown0);
 536     TRACE("Unknown 0: %u.\n", unknown0);
 537
 538     read_dword(&ptr, &t->element_count);
 539     TRACE("Element count: %u.\n", t->element_count);
 540
 541     read_dword(&ptr, &t->size_unpacked);
 542     TRACE("Unpacked size: %#x.\n", t->size_unpacked);
 543
 544     read_dword(&ptr, &t->stride);
 545     TRACE("Stride: %#x.\n", t->stride);
 546
 547     read_dword(&ptr, &t->size_packed);
 548     TRACE("Packed size %#x.\n", t->size_packed);
 549
 550     switch (unknown0)
 551     {
 552         case 1:
 553             t->member_count = 0;
 554
 555             read_dword(&ptr, &typeinfo);
 556             t->column_count = (typeinfo & D3D10_FX10_TYPE_COLUMN_MASK) >> D3D10_FX10_TYPE_COLUMN_SHIFT;
 557             t->row_count = (typeinfo & D3D10_FX10_TYPE_ROW_MASK) >> D3D10_FX10_TYPE_ROW_SHIFT;
 558             t->basetype = d3d10_variable_type((typeinfo & D3D10_FX10_TYPE_BASETYPE_MASK) >> D3D10_FX10_TYPE_BASETYPE_SHIFT, FALSE);
 559             t->type_class = d3d10_variable_class((typeinfo & D3D10_FX10_TYPE_CLASS_MASK) >> D3D10_FX10_TYPE_CLASS_SHIFT, typeinfo & D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK);
 560
 561             TRACE("Type description: %#x.\n", typeinfo);
 562             TRACE("\tcolumns: %u.\n", t->column_count);
 563             TRACE("\trows: %u.\n", t->row_count);
 564             TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t->basetype));
 565             TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t->type_class));
 566             TRACE("\tunknown bits: %#x.\n", typeinfo & ~(D3D10_FX10_TYPE_COLUMN_MASK | D3D10_FX10_TYPE_ROW_MASK
 567                     | D3D10_FX10_TYPE_BASETYPE_MASK | D3D10_FX10_TYPE_CLASS_MASK | D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK));
 568             break;
 569
 570         case 2:
 571             TRACE("Type is an object.\n");
 572
 573             t->member_count = 0;
 574             t->column_count = 0;
 575             t->row_count = 0;
 576             t->type_class = D3D10_SVC_OBJECT;
 577
 578             read_dword(&ptr, &typeinfo);
 579             t->basetype = d3d10_variable_type(typeinfo, TRUE);
 580
 581             TRACE("Type description: %#x.\n", typeinfo);
 582             TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t->basetype));
 583             TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t->type_class));
 584             break;
 585
 586          case 3:
 587             TRACE("Type is a structure.\n");
 588
 589             read_dword(&ptr, &t->member_count);
 590             TRACE("Member count: %u.\n", t->member_count);
 591
 592             t->column_count = 0;
 593             t->row_count = 0;
 594             t->basetype = 0;
 595             t->type_class = D3D10_SVC_STRUCT;
 596
 597             t->members = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->member_count * sizeof(*t->members));
 598             if (!t->members)
 599             {
 600                 ERR("Failed to allocate members memory.\n");
 601                 return E_OUTOFMEMORY;
 602             }
 603
 604             for (i = 0; i < t->member_count; ++i)
 605             {
 606                 struct d3d10_effect_type_member *typem = &t->members[i];
 607
 608                 read_dword(&ptr, &offset);
 609                 TRACE("Member name at offset %#x.\n", offset);
 610
 611                 if (!copy_name(data + offset, &typem->name))
 612                 {
 613                     ERR("Failed to copy name.\n");
 614                     return E_OUTOFMEMORY;
 615                 }
 616                 TRACE("Member name: %s.\n", debugstr_a(typem->name));
 617
 618                 read_dword(&ptr, &offset);
 619                 TRACE("Member semantic at offset %#x.\n", offset);
 620
 621                 if (!copy_name(data + offset, &typem->semantic))
 622                 {
 623                     ERR("Failed to copy semantic.\n");
 624                     return E_OUTOFMEMORY;
 625                 }
 626                 TRACE("Member semantic: %s.\n", debugstr_a(typem->semantic));
 627
 628                 read_dword(&ptr, &typem->buffer_offset);
 629                 TRACE("Member offset in struct: %#x.\n", typem->buffer_offset);
 630
 631                 read_dword(&ptr, &offset);
 632                 TRACE("Member type info at offset %#x.\n", offset);
 633
 634                 typem->type = get_fx10_type(t->effect, data, offset);
 635                 if (!typem->type)
 636                 {
 637                     ERR("Failed to get variable type.\n");
 638                     return E_FAIL;
 639                 }
 640             }
 641             break;
 642
 643         default:
 644             FIXME("Unhandled case %#x.\n", unknown0);
 645             return E_FAIL;
 646     }
 647
 648     if (t->element_count)
 649     {
 650         TRACE("Elementtype for type at offset: %#x\n", t->id);
 651
 652         /* allocate elementtype - we need only one, because all elements have the same type */
 653         t->elementtype = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*t->elementtype));
 654         if (!t->elementtype)
 655         {
 656             ERR("Failed to allocate members memory.\n");
 657             return E_OUTOFMEMORY;
 658         }
 659
 660         /* create a copy of the original type with some minor changes */
 661         t->elementtype->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
 662         t->elementtype->effect = t->effect;
 663
 664         if (!copy_name(t->name, &t->elementtype->name))
 665         {
 666              ERR("Failed to copy name.\n");
 667              return E_OUTOFMEMORY;
 668         }
 669         TRACE("\tType name: %s.\n", debugstr_a(t->elementtype->name));
 670
 671         t->elementtype->element_count = 0;
 672         TRACE("\tElement count: %u.\n", t->elementtype->element_count);
 673
 674         /*
 675          * Not sure if this calculation is 100% correct, but a test
 676          * shows that these values work.
 677          */
 678         t->elementtype->size_unpacked = t->size_packed / t->element_count;
 679         TRACE("\tUnpacked size: %#x.\n", t->elementtype->size_unpacked);
 680
 681         t->elementtype->stride = t->stride;
 682         TRACE("\tStride: %#x.\n", t->elementtype->stride);
 683
 684         t->elementtype->size_packed = t->size_packed / t->element_count;
 685         TRACE("\tPacked size: %#x.\n", t->elementtype->size_packed);
 686
 687         t->elementtype->member_count = t->member_count;
 688         TRACE("\tMember count: %u.\n", t->elementtype->member_count);
 689
 690         t->elementtype->column_count = t->column_count;
 691         TRACE("\tColumns: %u.\n", t->elementtype->column_count);
 692
 693         t->elementtype->row_count = t->row_count;
 694         TRACE("\tRows: %u.\n", t->elementtype->row_count);
 695
 696         t->elementtype->basetype = t->basetype;
 697         TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(t->elementtype->basetype));
 698
 699         t->elementtype->type_class = t->type_class;
 700         TRACE("\tClass: %s.\n", debug_d3d10_shader_variable_class(t->elementtype->type_class));
 701
 702         t->elementtype->members = t->members;
 703     }
 704
 705     return S_OK;
 706 }
 707
 708 static struct d3d10_effect_type *get_fx10_type(struct d3d10_effect *effect, const char *data, DWORD offset)
 709 {
 710     struct d3d10_effect_type *type;
 711     struct wine_rb_entry *entry;
 712     HRESULT hr;
 713
 714     entry = wine_rb_get(&effect->types, &offset);
 715     if (entry)
 716     {
 717         TRACE("Returning existing type.\n");
 718         return WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
 719     }
 720
 721     type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*type));
 722     if (!type)
 723     {
 724         ERR("Failed to allocate type memory.\n");
 725         return NULL;
 726     }
 727
 728     type->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
 729     type->id = offset;
 730     type->effect = effect;
 731     hr = parse_fx10_type(type, data + offset, data);
 732     if (FAILED(hr))
 733     {
 734         ERR("Failed to parse type info, hr %#x.\n", hr);
 735         HeapFree(GetProcessHeap(), 0, type);
 736         return NULL;
 737     }
 738
 739     if (wine_rb_put(&effect->types, &offset, &type->entry) == -1)
 740     {
 741         ERR("Failed to insert type entry.\n");
 742         HeapFree(GetProcessHeap(), 0, type);
 743         return NULL;
 744     }
 745
 746     return type;
 747 }
 748
 749 static void set_variable_vtbl(struct d3d10_effect_variable *v)
 750 {
 751     const ID3D10EffectVariableVtbl **vtbl = &v->ID3D10EffectVariable_iface.lpVtbl;
 752
 753     switch (v->type->type_class)
 754     {
 755         case D3D10_SVC_SCALAR:
 756             *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl;
 757             break;
 758
 759         case D3D10_SVC_VECTOR:
 760             *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl;
 761             break;
 762
 763         case D3D10_SVC_MATRIX_ROWS:
 764         case D3D10_SVC_MATRIX_COLUMNS:
 765             *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl;
 766             break;
 767
 768         case D3D10_SVC_STRUCT:
 769             *vtbl = &d3d10_effect_variable_vtbl;
 770             break;
 771
 772         case D3D10_SVC_OBJECT:
 773             switch(v->type->basetype)
 774             {
 775                 case D3D10_SVT_STRING:
 776                     *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl;
 777                     break;
 778
 779                 case D3D10_SVT_TEXTURE1D:
 780                 case D3D10_SVT_TEXTURE1DARRAY:
 781                 case D3D10_SVT_TEXTURE2D:
 782                 case D3D10_SVT_TEXTURE2DARRAY:
 783                 case D3D10_SVT_TEXTURE2DMS:
 784                 case D3D10_SVT_TEXTURE2DMSARRAY:
 785                 case D3D10_SVT_TEXTURE3D:
 786                 case D3D10_SVT_TEXTURECUBE:
 787                 case D3D10_SVT_BUFFER: /* Either resource or constant buffer. */
 788                     *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl;
 789                     break;
 790
 791                 case D3D10_SVT_RENDERTARGETVIEW:
 792                     *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl;
 793                     break;
 794
 795                 case D3D10_SVT_DEPTHSTENCILVIEW:
 796                     *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl;
 797                     break;
 798
 799                 case D3D10_SVT_DEPTHSTENCIL:
 800                     *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl;
 801                     break;
 802
 803                 case D3D10_SVT_VERTEXSHADER:
 804                 case D3D10_SVT_GEOMETRYSHADER:
 805                 case D3D10_SVT_PIXELSHADER:
 806                     *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl;
 807                     break;
 808
 809                 case D3D10_SVT_BLEND:
 810                     *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl;
 811                     break;
 812
 813                 case D3D10_SVT_RASTERIZER:
 814                     *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl;
 815                     break;
 816
 817                 case D3D10_SVT_SAMPLER:
 818                     *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl;
 819                     break;
 820
 821                 default:
 822                     FIXME("Unhandled basetype %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
 823                     *vtbl = &d3d10_effect_variable_vtbl;
 824                     break;
 825             }
 826             break;
 827
 828         default:
 829             FIXME("Unhandled type class %s.\n", debug_d3d10_shader_variable_class(v->type->type_class));
 830             *vtbl = &d3d10_effect_variable_vtbl;
 831             break;
 832     }
 833 }
 834
 835 static HRESULT copy_variableinfo_from_type(struct d3d10_effect_variable *v)
 836 {
 837     unsigned int i;
 838     HRESULT hr;
 839
 840     if (v->type->member_count)
 841     {
 842         v->members = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, v->type->member_count * sizeof(*v->members));
 843         if (!v->members)
 844         {
 845             ERR("Failed to allocate members memory.\n");
 846             return E_OUTOFMEMORY;
 847         }
 848
 849         for (i = 0; i < v->type->member_count; ++i)
 850         {
 851             struct d3d10_effect_variable *var = &v->members[i];
 852             struct d3d10_effect_type_member *typem = &v->type->members[i];
 853
 854             var->buffer = v->buffer;
 855             var->effect = v->effect;
 856             var->type = typem->type;
 857             set_variable_vtbl(var);
 858
 859             if (!copy_name(typem->name, &var->name))
 860             {
 861                 ERR("Failed to copy name.\n");
 862                 return E_OUTOFMEMORY;
 863             }
 864             TRACE("Variable name: %s.\n", debugstr_a(var->name));
 865
 866             if (!copy_name(typem->semantic, &var->semantic))
 867             {
 868                 ERR("Failed to copy name.\n");
 869                 return E_OUTOFMEMORY;
 870             }
 871             TRACE("Variable semantic: %s.\n", debugstr_a(var->semantic));
 872
 873             var->buffer_offset = v->buffer_offset + typem->buffer_offset;
 874             TRACE("Variable buffer offset: %u.\n", var->buffer_offset);
 875
 876             hr = copy_variableinfo_from_type(var);
 877             if (FAILED(hr)) return hr;
 878         }
 879     }
 880
 881     if (v->type->element_count)
 882     {
 883         unsigned int bufferoffset = v->buffer_offset;
 884
 885         v->elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, v->type->element_count * sizeof(*v->elements));
 886         if (!v->elements)
 887         {
 888             ERR("Failed to allocate elements memory.\n");
 889             return E_OUTOFMEMORY;
 890         }
 891
 892         for (i = 0; i < v->type->element_count; ++i)
 893         {
 894             struct d3d10_effect_variable *var = &v->elements[i];
 895
 896             var->buffer = v->buffer;
 897             var->effect = v->effect;
 898             var->type = v->type->elementtype;
 899             set_variable_vtbl(var);
 900
 901             if (!copy_name(v->name, &var->name))
 902             {
 903                 ERR("Failed to copy name.\n");
 904                 return E_OUTOFMEMORY;
 905             }
 906             TRACE("Variable name: %s.\n", debugstr_a(var->name));
 907
 908             if (!copy_name(v->semantic, &var->semantic))
 909             {
 910                 ERR("Failed to copy name.\n");
 911                 return E_OUTOFMEMORY;
 912             }
 913             TRACE("Variable semantic: %s.\n", debugstr_a(var->semantic));
 914
 915             if (i != 0)
 916             {
 917                 bufferoffset += v->type->stride;
 918             }
 919             var->buffer_offset = bufferoffset;
 920             TRACE("Variable buffer offset: %u.\n", var->buffer_offset);
 921
 922             hr = copy_variableinfo_from_type(var);
 923             if (FAILED(hr)) return hr;
 924         }
 925     }
 926
 927     return S_OK;
 928 }
 929
 930 static HRESULT parse_fx10_variable_head(struct d3d10_effect_variable *v, const char **ptr, const char *data)
 931 {
 932     DWORD offset;
 933
 934     read_dword(ptr, &offset);
 935     TRACE("Variable name at offset %#x.\n", offset);
 936
 937     if (!copy_name(data + offset, &v->name))
 938     {
 939         ERR("Failed to copy name.\n");
 940         return E_OUTOFMEMORY;
 941     }
 942     TRACE("Variable name: %s.\n", debugstr_a(v->name));
 943
 944     read_dword(ptr, &offset);
 945     TRACE("Variable type info at offset %#x.\n", offset);
 946
 947     v->type = get_fx10_type(v->effect, data, offset);
 948     if (!v->type)
 949     {
 950         ERR("Failed to get variable type.\n");
 951         return E_FAIL;
 952     }
 953     set_variable_vtbl(v);
 954
 955     return copy_variableinfo_from_type(v);
 956 }
 957
 958 static HRESULT parse_fx10_annotation(struct d3d10_effect_variable *a, const char **ptr, const char *data)
 959 {
 960     HRESULT hr;
 961
 962     hr = parse_fx10_variable_head(a, ptr, data);
 963     if (FAILED(hr)) return hr;
 964
 965     skip_dword_unknown("annotation", ptr, 1);
 966
 967     /* mark the variable as annotation */
 968     a->flag = D3D10_EFFECT_VARIABLE_ANNOTATION;
 969
 970     return S_OK;
 971 }
 972
 973 static HRESULT parse_fx10_anonymous_shader(struct d3d10_effect *e, struct d3d10_effect_anonymous_shader *s,
 974     enum d3d10_effect_object_type otype)
 975 {
 976     struct d3d10_effect_variable *v = &s->shader;
 977     struct d3d10_effect_type *t = &s->type;
 978     const char *shader = NULL;
 979
 980     switch (otype)
 981     {
 982         case D3D10_EOT_VERTEXSHADER:
 983             shader = "vertexshader";
 984             t->basetype = D3D10_SVT_VERTEXSHADER;
 985             break;
 986
 987         case D3D10_EOT_PIXELSHADER:
 988             shader = "pixelshader";
 989             t->basetype = D3D10_SVT_PIXELSHADER;
 990             break;
 991
 992         case D3D10_EOT_GEOMETRYSHADER:
 993             shader = "geometryshader";
 994             t->basetype = D3D10_SVT_GEOMETRYSHADER;
 995             break;
 996
 997         default:
 998             FIXME("Unhandled object type %#x.\n", otype);
 999             return E_FAIL;
1000     }
1001
1002     if (!copy_name(shader, &t->name))
1003     {
1004         ERR("Failed to copy name.\n");
1005         return E_OUTOFMEMORY;
1006     }
1007     TRACE("Type name: %s.\n", debugstr_a(t->name));
1008
1009     t->type_class = D3D10_SVC_OBJECT;
1010
1011     t->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
1012
1013     v->type = t;
1014     v->effect = e;
1015     set_variable_vtbl(v);
1016
1017     if (!copy_name("$Anonymous", &v->name))
1018     {
1019         ERR("Failed to copy semantic.\n");
1020         return E_OUTOFMEMORY;
1021     }
1022     TRACE("Variable name: %s.\n", debugstr_a(v->name));
1023
1024     if (!copy_name(NULL, &v->semantic))
1025     {
1026         ERR("Failed to copy semantic.\n");
1027         return E_OUTOFMEMORY;
1028     }
1029     TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
1030
1031     return S_OK;
1032 }
1033
1034 static const struct d3d10_effect_state_property_info *get_property_info(UINT id)
1035 {
1036     unsigned int i;
1037
1038     for (i = 0; i < sizeof(property_info) / sizeof(*property_info); ++i)
1039     {
1040         if (property_info[i].id == id)
1041             return &property_info[i];
1042     }
1043
1044     return NULL;
1045 }
1046
1047 static const struct d3d10_effect_state_storage_info *get_storage_info(D3D_SHADER_VARIABLE_TYPE id)
1048 {
1049     unsigned int i;
1050
1051     for (i = 0; i < sizeof(d3d10_effect_state_storage_info) / sizeof(*d3d10_effect_state_storage_info); ++i)
1052     {
1053         if (d3d10_effect_state_storage_info[i].id == id)
1054             return &d3d10_effect_state_storage_info[i];
1055     }
1056
1057     return NULL;
1058 }
1059
1060 static BOOL read_float_value(DWORD value, D3D_SHADER_VARIABLE_TYPE in_type, float *out_data, UINT idx)
1061 {
1062     switch (in_type)
1063     {
1064         case D3D10_SVT_FLOAT:
1065             out_data[idx] = *(float *)&value;
1066             return TRUE;
1067
1068         case D3D10_SVT_INT:
1069             out_data[idx] = (INT)value;
1070             return TRUE;
1071
1072         default:
1073             FIXME("Unhandled in_type %#x.\n", in_type);
1074             return FALSE;
1075     }
1076 }
1077
1078 static BOOL read_int32_value(DWORD value, D3D_SHADER_VARIABLE_TYPE in_type, INT *out_data, UINT idx)
1079 {
1080     switch (in_type)
1081     {
1082         case D3D10_SVT_FLOAT:
1083             out_data[idx] = *(float *)&value;
1084             return TRUE;
1085
1086         case D3D10_SVT_INT:
1087         case D3D10_SVT_UINT:
1088         case D3D10_SVT_BOOL:
1089             out_data[idx] = value;
1090             return TRUE;
1091
1092         default:
1093             FIXME("Unhandled in_type %#x.\n", in_type);
1094             return FALSE;
1095     }
1096 }
1097
1098 static BOOL read_int8_value(DWORD value, D3D_SHADER_VARIABLE_TYPE in_type, INT8 *out_data, UINT idx)
1099 {
1100     switch (in_type)
1101     {
1102         case D3D10_SVT_INT:
1103         case D3D10_SVT_UINT:
1104             out_data[idx] = value;
1105             return TRUE;
1106
1107         default:
1108             FIXME("Unhandled in_type %#x.\n", in_type);
1109             return FALSE;
1110     }
1111 }
1112
1113 static BOOL read_value_list(const char *ptr, D3D_SHADER_VARIABLE_TYPE out_type,
1114         UINT out_base, UINT out_size, void *out_data)
1115 {
1116     D3D_SHADER_VARIABLE_TYPE in_type;
1117     DWORD t, value;
1118     DWORD count, i;
1119
1120     read_dword(&ptr, &count);
1121     if (count != out_size)
1122         return FALSE;
1123
1124     TRACE("%u values:\n", count);
1125     for (i = 0; i < count; ++i)
1126     {
1127         UINT out_idx = out_base * out_size + i;
1128
1129         read_dword(&ptr, &t);
1130         read_dword(&ptr, &value);
1131
1132         in_type = d3d10_variable_type(t, FALSE);
1133         TRACE("\t%s: %#x.\n", debug_d3d10_shader_variable_type(in_type), value);
1134
1135         switch (out_type)
1136         {
1137             case D3D10_SVT_FLOAT:
1138                 if (!read_float_value(value, in_type, out_data, out_idx))
1139                     return FALSE;
1140                 break;
1141
1142             case D3D10_SVT_INT:
1143             case D3D10_SVT_UINT:
1144             case D3D10_SVT_BOOL:
1145                 if (!read_int32_value(value, in_type, out_data, out_idx))
1146                     return FALSE;
1147                 break;
1148
1149             case D3D10_SVT_UINT8:
1150                 if (!read_int8_value(value, in_type, out_data, out_idx))
1151                     return FALSE;
1152                 break;
1153
1154             default:
1155                 FIXME("Unhandled out_type %#x.\n", out_type);
1156                 return FALSE;
1157         }
1158     }
1159
1160     return TRUE;
1161 }
1162
1163 static BOOL parse_fx10_state_group(const char **ptr, const char *data,
1164         D3D_SHADER_VARIABLE_TYPE container_type, void *container)
1165 {
1166     const struct d3d10_effect_state_property_info *property_info;
1167     UINT value_offset;
1168     unsigned int i;
1169     DWORD count;
1170     UINT idx;
1171     UINT id;
1172
1173     read_dword(ptr, &count);
1174     TRACE("Property count: %#x.\n", count);
1175
1176     for (i = 0; i < count; ++i)
1177     {
1178         read_dword(ptr, &id);
1179         read_dword(ptr, &idx);
1180         skip_dword_unknown("read property", ptr, 1);
1181         read_dword(ptr, &value_offset);
1182
1183         if (!(property_info = get_property_info(id)))
1184         {
1185             FIXME("Failed to find property info for property %#x.\n", id);
1186             return FALSE;
1187         }
1188
1189         TRACE("Property %s[%#x] = value list @ offset %#x.\n",
1190                 property_info->name, idx, value_offset);
1191
1192         if (property_info->container_type != container_type)
1193         {
1194             ERR("Invalid container type %#x for property %#x.\n", container_type, id);
1195             return FALSE;
1196         }
1197
1198         if (idx >= property_info->count)
1199         {
1200             ERR("Invalid index %#x for property %#x.\n", idx, id);
1201             return FALSE;
1202         }
1203
1204         if (!read_value_list(data + value_offset, property_info->type, idx,
1205                 property_info->size, (char *)container + property_info->offset))
1206         {
1207             ERR("Failed to read values for property %#x.\n", id);
1208             return FALSE;
1209         }
1210     }
1211
1212     return TRUE;
1213 }
1214
1215 static HRESULT parse_fx10_object(struct d3d10_effect_object *o, const char **ptr, const char *data)
1216 {
1217     const char *data_ptr = NULL;
1218     DWORD offset;
1219     enum d3d10_effect_object_operation operation;
1220     HRESULT hr;
1221     struct d3d10_effect *effect = o->pass->technique->effect;
1222     ID3D10Effect *e = &effect->ID3D10Effect_iface;
1223
1224     read_dword(ptr, &o->type);
1225     TRACE("Effect object is of type %#x.\n", o->type);
1226
1227     read_dword(ptr, &o->index);
1228     TRACE("Effect object index %#x.\n", o->index);
1229
1230     read_dword(ptr, &operation);
1231     TRACE("Effect object operation %#x.\n", operation);
1232
1233     read_dword(ptr, &offset);
1234     TRACE("Effect object idx is at offset %#x.\n", offset);
1235
1236     switch(operation)
1237     {
1238         case D3D10_EOO_VALUE:
1239             TRACE("Copy variable values\n");
1240
1241             switch (o->type)
1242             {
1243                 case D3D10_EOT_VERTEXSHADER:
1244                     TRACE("Vertex shader\n");
1245                     o->data = &anonymous_vs;
1246                     hr = S_OK;
1247                     break;
1248
1249                 case D3D10_EOT_PIXELSHADER:
1250                     TRACE("Pixel shader\n");
1251                     o->data = &anonymous_ps;
1252                     hr = S_OK;
1253                     break;
1254
1255                 case D3D10_EOT_GEOMETRYSHADER:
1256                     TRACE("Geometry shader\n");
1257                     o->data = &anonymous_gs;
1258                     hr = S_OK;
1259                     break;
1260
1261                 case D3D10_EOT_STENCIL_REF:
1262                     if (!read_value_list(data + offset, D3D10_SVT_UINT, 0, 1, &o->pass->stencil_ref))
1263                     {
1264                         ERR("Failed to read stencil ref.\n");
1265                         return E_FAIL;
1266                     }
1267
1268                     hr = S_OK;
1269                     break;
1270
1271                 case D3D10_EOT_SAMPLE_MASK:
1272                     if (!read_value_list(data + offset, D3D10_SVT_UINT, 0, 1, &o->pass->sample_mask))
1273                     {
1274                         FIXME("Failed to read sample mask.\n");
1275                         return E_FAIL;
1276                     }
1277
1278                     hr = S_OK;
1279                     break;
1280
1281                 case D3D10_EOT_BLEND_FACTOR:
1282                     if (!read_value_list(data + offset, D3D10_SVT_FLOAT, 0, 4, &o->pass->blend_factor[0]))
1283                     {
1284                         FIXME("Failed to read blend factor.\n");
1285                         return E_FAIL;
1286                     }
1287
1288                     hr = S_OK;
1289                     break;
1290
1291                 default:
1292                     FIXME("Unhandled object type %#x\n", o->type);
1293                     hr = E_FAIL;
1294                     break;
1295             }
1296             break;
1297
1298         case D3D10_EOO_PARSED_OBJECT:
1299             /* This is a local object, we've parsed in parse_fx10_local_object. */
1300             TRACE("Shader = %s.\n", data + offset);
1301
1302             o->data = e->lpVtbl->GetVariableByName(e, data + offset);
1303             hr = S_OK;
1304             break;
1305
1306         case D3D10_EOO_PARSED_OBJECT_INDEX:
1307             /* This is a local object, we've parsed in parse_fx10_local_object, which has an array index. */
1308             data_ptr = data + offset;
1309             read_dword(&data_ptr, &offset);
1310             read_dword(&data_ptr, &o->index);
1311             TRACE("Shader = %s[%u].\n", data + offset, o->index);
1312
1313             o->data = e->lpVtbl->GetVariableByName(e, data + offset);
1314             hr = S_OK;
1315             break;
1316
1317         case D3D10_EOO_ANONYMOUS_SHADER:
1318             TRACE("Anonymous shader\n");
1319
1320             /* check anonymous_shader_current for validity */
1321             if (effect->anonymous_shader_current >= effect->anonymous_shader_count)
1322             {
1323                 ERR("Anonymous shader count is wrong!\n");
1324                 return E_FAIL;
1325             }
1326
1327             data_ptr = data + offset;
1328             read_dword(&data_ptr, &offset);
1329             TRACE("Effect object starts at offset %#x.\n", offset);
1330
1331             data_ptr = data + offset;
1332
1333             hr = parse_fx10_anonymous_shader(effect, &effect->anonymous_shaders[effect->anonymous_shader_current], o->type);
1334             if (FAILED(hr)) return hr;
1335
1336             o->data = &effect->anonymous_shaders[effect->anonymous_shader_current].shader;
1337             ++effect->anonymous_shader_current;
1338
1339             switch (o->type)
1340             {
1341                 case D3D10_EOT_VERTEXSHADER:
1342                     TRACE("Vertex shader\n");
1343                     hr = parse_shader(o->data, data_ptr);
1344                     break;
1345
1346                 case D3D10_EOT_PIXELSHADER:
1347                     TRACE("Pixel shader\n");
1348                     hr = parse_shader(o->data, data_ptr);
1349                     break;
1350
1351                 case D3D10_EOT_GEOMETRYSHADER:
1352                     TRACE("Geometry shader\n");
1353                     hr = parse_shader(o->data, data_ptr);
1354                     break;
1355
1356                 default:
1357                     FIXME("Unhandled object type %#x\n", o->type);
1358                     hr = E_FAIL;
1359                     break;
1360             }
1361             break;
1362
1363         default:
1364             hr = E_FAIL;
1365             FIXME("Unhandled operation %#x.\n", operation);
1366             break;
1367     }
1368
1369     return hr;
1370 }
1371
1372 static HRESULT parse_fx10_pass(struct d3d10_effect_pass *p, const char **ptr, const char *data)
1373 {
1374     HRESULT hr = S_OK;
1375     unsigned int i;
1376     DWORD offset;
1377
1378     read_dword(ptr, &offset);
1379     TRACE("Pass name at offset %#x.\n", offset);
1380
1381     if (!copy_name(data + offset, &p->name))
1382     {
1383         ERR("Failed to copy name.\n");
1384         return E_OUTOFMEMORY;
1385     }
1386     TRACE("Pass name: %s.\n", debugstr_a(p->name));
1387
1388     read_dword(ptr, &p->object_count);
1389     TRACE("Pass has %u effect objects.\n", p->object_count);
1390
1391     read_dword(ptr, &p->annotation_count);
1392     TRACE("Pass has %u annotations.\n", p->annotation_count);
1393
1394     p->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, p->annotation_count * sizeof(*p->annotations));
1395     if (!p->annotations)
1396     {
1397         ERR("Failed to allocate pass annotations memory.\n");
1398         return E_OUTOFMEMORY;
1399     }
1400
1401     for (i = 0; i < p->annotation_count; ++i)
1402     {
1403         struct d3d10_effect_variable *a = &p->annotations[i];
1404
1405         a->effect = p->technique->effect;
1406         a->buffer = &null_local_buffer;
1407
1408         hr = parse_fx10_annotation(a, ptr, data);
1409         if (FAILED(hr)) return hr;
1410     }
1411
1412     p->objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, p->object_count * sizeof(*p->objects));
1413     if (!p->objects)
1414     {
1415         ERR("Failed to allocate effect objects memory.\n");
1416         return E_OUTOFMEMORY;
1417     }
1418
1419     for (i = 0; i < p->object_count; ++i)
1420     {
1421         struct d3d10_effect_object *o = &p->objects[i];
1422
1423         o->pass = p;
1424
1425         hr = parse_fx10_object(o, ptr, data);
1426         if (FAILED(hr)) return hr;
1427     }
1428
1429     return hr;
1430 }
1431
1432 static HRESULT parse_fx10_technique(struct d3d10_effect_technique *t, const char **ptr, const char *data)
1433 {
1434     unsigned int i;
1435     DWORD offset;
1436     HRESULT hr;
1437
1438     read_dword(ptr, &offset);
1439     TRACE("Technique name at offset %#x.\n", offset);
1440
1441     if (!copy_name(data + offset, &t->name))
1442     {
1443         ERR("Failed to copy name.\n");
1444         return E_OUTOFMEMORY;
1445     }
1446     TRACE("Technique name: %s.\n", debugstr_a(t->name));
1447
1448     read_dword(ptr, &t->pass_count);
1449     TRACE("Technique has %u passes\n", t->pass_count);
1450
1451     read_dword(ptr, &t->annotation_count);
1452     TRACE("Technique has %u annotations.\n", t->annotation_count);
1453
1454     t->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->annotation_count * sizeof(*t->annotations));
1455     if (!t->annotations)
1456     {
1457         ERR("Failed to allocate technique annotations memory.\n");
1458         return E_OUTOFMEMORY;
1459     }
1460
1461     for (i = 0; i < t->annotation_count; ++i)
1462     {
1463         struct d3d10_effect_variable *a = &t->annotations[i];
1464
1465         a->effect = t->effect;
1466         a->buffer = &null_local_buffer;
1467
1468         hr = parse_fx10_annotation(a, ptr, data);
1469         if (FAILED(hr)) return hr;
1470     }
1471
1472     t->passes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->pass_count * sizeof(*t->passes));
1473     if (!t->passes)
1474     {
1475         ERR("Failed to allocate passes memory\n");
1476         return E_OUTOFMEMORY;
1477     }
1478
1479     for (i = 0; i < t->pass_count; ++i)
1480     {
1481         struct d3d10_effect_pass *p = &t->passes[i];
1482
1483         p->ID3D10EffectPass_iface.lpVtbl = &d3d10_effect_pass_vtbl;
1484         p->technique = t;
1485
1486         hr = parse_fx10_pass(p, ptr, data);
1487         if (FAILED(hr)) return hr;
1488     }
1489
1490     return S_OK;
1491 }
1492
1493 static HRESULT parse_fx10_variable(struct d3d10_effect_variable *v, const char **ptr, const char *data)
1494 {
1495     DWORD offset;
1496     unsigned int i;
1497     HRESULT hr;
1498
1499     hr = parse_fx10_variable_head(v, ptr, data);
1500     if (FAILED(hr)) return hr;
1501
1502     read_dword(ptr, &offset);
1503     TRACE("Variable semantic at offset %#x.\n", offset);
1504
1505     if (!copy_name(data + offset, &v->semantic))
1506     {
1507         ERR("Failed to copy semantic.\n");
1508         return E_OUTOFMEMORY;
1509     }
1510     TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
1511
1512     read_dword(ptr, &v->buffer_offset);
1513     TRACE("Variable offset in buffer: %#x.\n", v->buffer_offset);
1514
1515     skip_dword_unknown("variable", ptr, 1);
1516
1517     read_dword(ptr, &v->flag);
1518     TRACE("Variable flag: %#x.\n", v->flag);
1519
1520     read_dword(ptr, &v->annotation_count);
1521     TRACE("Variable has %u annotations.\n", v->annotation_count);
1522
1523     v->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, v->annotation_count * sizeof(*v->annotations));
1524     if (!v->annotations)
1525     {
1526         ERR("Failed to allocate variable annotations memory.\n");
1527         return E_OUTOFMEMORY;
1528     }
1529
1530     for (i = 0; i < v->annotation_count; ++i)
1531     {
1532         struct d3d10_effect_variable *a = &v->annotations[i];
1533
1534         a->effect = v->effect;
1535         a->buffer = &null_local_buffer;
1536
1537         hr = parse_fx10_annotation(a, ptr, data);
1538         if (FAILED(hr)) return hr;
1539     }
1540
1541     return S_OK;
1542 }
1543
1544 static HRESULT parse_fx10_local_variable(struct d3d10_effect_variable *v, const char **ptr, const char *data)
1545 {
1546     unsigned int i;
1547     HRESULT hr;
1548     DWORD offset;
1549
1550     hr = parse_fx10_variable_head(v, ptr, data);
1551     if (FAILED(hr)) return hr;
1552
1553     read_dword(ptr, &offset);
1554     TRACE("Variable semantic at offset %#x.\n", offset);
1555
1556     if (!copy_name(data + offset, &v->semantic))
1557     {
1558         ERR("Failed to copy semantic.\n");
1559         return E_OUTOFMEMORY;
1560     }
1561     TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
1562
1563     skip_dword_unknown("local variable", ptr, 1);
1564
1565     switch (v->type->basetype)
1566     {
1567         case D3D10_SVT_TEXTURE1D:
1568         case D3D10_SVT_TEXTURE1DARRAY:
1569         case D3D10_SVT_TEXTURE2D:
1570         case D3D10_SVT_TEXTURE2DARRAY:
1571         case D3D10_SVT_TEXTURE2DMS:
1572         case D3D10_SVT_TEXTURE2DMSARRAY:
1573         case D3D10_SVT_TEXTURE3D:
1574         case D3D10_SVT_TEXTURECUBE:
1575         case D3D10_SVT_RENDERTARGETVIEW:
1576         case D3D10_SVT_DEPTHSTENCILVIEW:
1577         case D3D10_SVT_BUFFER:
1578             TRACE("SVT could not have elements.\n");
1579             break;
1580
1581         case D3D10_SVT_VERTEXSHADER:
1582         case D3D10_SVT_PIXELSHADER:
1583         case D3D10_SVT_GEOMETRYSHADER:
1584             TRACE("Shader type is %s\n", debug_d3d10_shader_variable_type(v->type->basetype));
1585             for (i = 0; i < max(v->type->element_count, 1); ++i)
1586             {
1587                 DWORD shader_offset;
1588                 struct d3d10_effect_variable *var;
1589
1590                 if (!v->type->element_count)
1591                 {
1592                     var = v;
1593                 }
1594                 else
1595                 {
1596                     var = &v->elements[i];
1597                 }
1598
1599                 read_dword(ptr, &shader_offset);
1600                 TRACE("Shader offset: %#x.\n", shader_offset);
1601
1602                 hr = parse_shader(var, data + shader_offset);
1603                 if (FAILED(hr)) return hr;
1604             }
1605             break;
1606
1607         case D3D10_SVT_DEPTHSTENCIL:
1608         case D3D10_SVT_BLEND:
1609         case D3D10_SVT_RASTERIZER:
1610         case D3D10_SVT_SAMPLER:
1611             {
1612                 const struct d3d10_effect_state_storage_info *storage_info;
1613                 unsigned int count = max(v->type->element_count, 1);
1614                 unsigned char *desc;
1615
1616                 if (!(storage_info = get_storage_info(v->type->basetype)))
1617                 {
1618                     FIXME("Failed to get backing store info for type %s.\n",
1619                             debug_d3d10_shader_variable_type(v->type->basetype));
1620                     return E_FAIL;
1621                 }
1622
1623                 if (!(desc = HeapAlloc(GetProcessHeap(), 0, count * storage_info->size)))
1624                 {
1625                     ERR("Failed to allocate backing store memory.\n");
1626                     return E_OUTOFMEMORY;
1627                 }
1628
1629                 for (i = 0; i < count; ++i)
1630                 {
1631                     memcpy(&desc[i * storage_info->size], storage_info->default_state, storage_info->size);
1632
1633                     if (!parse_fx10_state_group(ptr, data, v->type->basetype, &desc[i * storage_info->size]))
1634                     {
1635                         ERR("Failed to read property list.\n");
1636                         HeapFree(GetProcessHeap(), 0, desc);
1637                         return E_FAIL;
1638                     }
1639                 }
1640
1641                 v->data = desc;
1642             }
1643             break;
1644
1645         default:
1646             FIXME("Unhandled case %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
1647             return E_FAIL;
1648     }
1649
1650     read_dword(ptr, &v->annotation_count);
1651     TRACE("Variable has %u annotations.\n", v->annotation_count);
1652
1653     v->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, v->annotation_count * sizeof(*v->annotations));
1654     if (!v->annotations)
1655     {
1656         ERR("Failed to allocate variable annotations memory.\n");
1657         return E_OUTOFMEMORY;
1658     }
1659
1660     for (i = 0; i < v->annotation_count; ++i)
1661     {
1662         struct d3d10_effect_variable *a = &v->annotations[i];
1663
1664         a->effect = v->effect;
1665         a->buffer = &null_local_buffer;
1666
1667         hr = parse_fx10_annotation(a, ptr, data);
1668         if (FAILED(hr)) return hr;
1669     }
1670
1671     return S_OK;
1672 }
1673
1674 static HRESULT parse_fx10_local_buffer(struct d3d10_effect_variable *l, const char **ptr, const char *data)
1675 {
1676     unsigned int i;
1677     DWORD offset;
1678     D3D10_CBUFFER_TYPE d3d10_cbuffer_type;
1679     HRESULT hr;
1680     unsigned int stride = 0;
1681
1682     /* Generate our own type, it isn't in the fx blob. */
1683     l->type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*l->type));
1684     if (!l->type)
1685     {
1686         ERR("Failed to allocate local buffer type memory.\n");
1687         return E_OUTOFMEMORY;
1688     }
1689     l->type->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
1690     l->type->type_class = D3D10_SVC_OBJECT;
1691     l->type->effect = l->effect;
1692
1693     read_dword(ptr, &offset);
1694     TRACE("Local buffer name at offset %#x.\n", offset);
1695
1696     if (!copy_name(data + offset, &l->name))
1697     {
1698         ERR("Failed to copy name.\n");
1699         return E_OUTOFMEMORY;
1700     }
1701     TRACE("Local buffer name: %s.\n", debugstr_a(l->name));
1702
1703     read_dword(ptr, &l->data_size);
1704     TRACE("Local buffer data size: %#x.\n", l->data_size);
1705
1706     read_dword(ptr, &d3d10_cbuffer_type);
1707     TRACE("Local buffer type: %#x.\n", d3d10_cbuffer_type);
1708
1709     switch(d3d10_cbuffer_type)
1710     {
1711         case D3D10_CT_CBUFFER:
1712             l->type->basetype = D3D10_SVT_CBUFFER;
1713             if (!copy_name("cbuffer", &l->type->name))
1714             {
1715                 ERR("Failed to copy name.\n");
1716                 return E_OUTOFMEMORY;
1717             }
1718             break;
1719
1720         case D3D10_CT_TBUFFER:
1721             l->type->basetype = D3D10_SVT_TBUFFER;
1722             if (!copy_name("tbuffer", &l->type->name))
1723             {
1724                 ERR("Failed to copy name.\n");
1725                 return E_OUTOFMEMORY;
1726             }
1727             break;
1728
1729         default:
1730             ERR("Unexpected D3D10_CBUFFER_TYPE %#x!\n", d3d10_cbuffer_type);
1731             return E_FAIL;
1732     }
1733
1734     read_dword(ptr, &l->type->member_count);
1735     TRACE("Local buffer member count: %#x.\n", l->type->member_count);
1736
1737     skip_dword_unknown("local buffer", ptr, 1);
1738
1739     read_dword(ptr, &l->annotation_count);
1740     TRACE("Local buffer has %u annotations.\n", l->annotation_count);
1741
1742     l->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->annotation_count * sizeof(*l->annotations));
1743     if (!l->annotations)
1744     {
1745         ERR("Failed to allocate local buffer annotations memory.\n");
1746         return E_OUTOFMEMORY;
1747     }
1748
1749     for (i = 0; i < l->annotation_count; ++i)
1750     {
1751         struct d3d10_effect_variable *a = &l->annotations[i];
1752
1753         a->effect = l->effect;
1754         a->buffer = &null_local_buffer;
1755
1756         hr = parse_fx10_annotation(a, ptr, data);
1757         if (FAILED(hr)) return hr;
1758     }
1759
1760     l->members = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->type->member_count * sizeof(*l->members));
1761     if (!l->members)
1762     {
1763         ERR("Failed to allocate members memory.\n");
1764         return E_OUTOFMEMORY;
1765     }
1766
1767     l->type->members = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->type->member_count * sizeof(*l->type->members));
1768     if (!l->type->members)
1769     {
1770         ERR("Failed to allocate type members memory.\n");
1771         return E_OUTOFMEMORY;
1772     }
1773
1774     for (i = 0; i < l->type->member_count; ++i)
1775     {
1776         struct d3d10_effect_variable *v = &l->members[i];
1777         struct d3d10_effect_type_member *typem = &l->type->members[i];
1778
1779         v->buffer = l;
1780         v->effect = l->effect;
1781
1782         hr = parse_fx10_variable(v, ptr, data);
1783         if (FAILED(hr)) return hr;
1784
1785         /*
1786          * Copy the values from the variable type to the constant buffers type
1787          * members structure, because it is our own generated type.
1788          */
1789         typem->type = v->type;
1790
1791         if (!copy_name(v->name, &typem->name))
1792         {
1793             ERR("Failed to copy name.\n");
1794             return E_OUTOFMEMORY;
1795         }
1796         TRACE("Variable name: %s.\n", debugstr_a(typem->name));
1797
1798         if (!copy_name(v->semantic, &typem->semantic))
1799         {
1800             ERR("Failed to copy name.\n");
1801             return E_OUTOFMEMORY;
1802         }
1803         TRACE("Variable semantic: %s.\n", debugstr_a(typem->semantic));
1804
1805         typem->buffer_offset = v->buffer_offset;
1806         TRACE("Variable buffer offset: %u.\n", typem->buffer_offset);
1807
1808         l->type->size_packed += v->type->size_packed;
1809
1810         /*
1811          * For the complete constantbuffer the size_unpacked = stride,
1812          * the stride is calculated like this:
1813          *
1814          * 1) if the constant buffer variables are packed with packoffset
1815          *    - stride = the highest used constant
1816          *    - the complete stride has to be a multiple of 0x10
1817          *
1818          * 2) if the constant buffer variables are NOT packed with packoffset
1819          *    - sum of unpacked size for all variables which fit in a 0x10 part
1820          *    - if the size exceeds a 0x10 part, the rest of the old part is skipped
1821          *      and a new part is started
1822          *    - if the variable is a struct it is always used a new part
1823          *    - the complete stride has to be a multiple of 0x10
1824          *
1825          *    e.g.:
1826          *             0x4, 0x4, 0x4, 0x8, 0x4, 0x14, 0x4
1827          *        part 0x10           0x10      0x20     -> 0x40
1828          */
1829         if (v->flag & D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
1830         {
1831             if ((v->type->size_unpacked + v->buffer_offset) > stride)
1832             {
1833                 stride = v->type->size_unpacked + v->buffer_offset;
1834             }
1835         }
1836         else
1837         {
1838             if (v->type->type_class == D3D10_SVC_STRUCT)
1839             {
1840                 stride = (stride + 0xf) & ~0xf;
1841             }
1842
1843             if ( ((stride & 0xf) + v->type->size_unpacked) > 0x10)
1844             {
1845                 stride = (stride + 0xf) & ~0xf;
1846             }
1847
1848             stride += v->type->size_unpacked;
1849         }
1850     }
1851     l->type->stride = l->type->size_unpacked = (stride + 0xf) & ~0xf;
1852
1853     TRACE("Constant buffer:\n");
1854     TRACE("\tType name: %s.\n", debugstr_a(l->type->name));
1855     TRACE("\tElement count: %u.\n", l->type->element_count);
1856     TRACE("\tMember count: %u.\n", l->type->member_count);
1857     TRACE("\tUnpacked size: %#x.\n", l->type->size_unpacked);
1858     TRACE("\tStride: %#x.\n", l->type->stride);
1859     TRACE("\tPacked size %#x.\n", l->type->size_packed);
1860     TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(l->type->basetype));
1861     TRACE("\tTypeclass: %s.\n", debug_d3d10_shader_variable_class(l->type->type_class));
1862
1863     return S_OK;
1864 }
1865
1866 static int d3d10_effect_type_compare(const void *key, const struct wine_rb_entry *entry)
1867 {
1868     const struct d3d10_effect_type *t = WINE_RB_ENTRY_VALUE(entry, const struct d3d10_effect_type, entry);
1869     const DWORD *id = key;
1870
1871     return *id - t->id;
1872 }
1873
1874 static void d3d10_effect_type_member_destroy(struct d3d10_effect_type_member *typem)
1875 {
1876     TRACE("effect type member %p.\n", typem);
1877
1878     /* Do not release typem->type, it will be covered by d3d10_effect_type_destroy(). */
1879     HeapFree(GetProcessHeap(), 0, typem->semantic);
1880     HeapFree(GetProcessHeap(), 0, typem->name);
1881 }
1882
1883 static void d3d10_effect_type_destroy(struct wine_rb_entry *entry, void *context)
1884 {
1885     struct d3d10_effect_type *t = WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
1886
1887     TRACE("effect type %p.\n", t);
1888
1889     if (t->elementtype)
1890     {
1891         HeapFree(GetProcessHeap(), 0, t->elementtype->name);
1892         HeapFree(GetProcessHeap(), 0, t->elementtype);
1893     }
1894
1895     if (t->members)
1896     {
1897         unsigned int i;
1898
1899         for (i = 0; i < t->member_count; ++i)
1900         {
1901             d3d10_effect_type_member_destroy(&t->members[i]);
1902         }
1903         HeapFree(GetProcessHeap(), 0, t->members);
1904     }
1905
1906     HeapFree(GetProcessHeap(), 0, t->name);
1907     HeapFree(GetProcessHeap(), 0, t);
1908 }
1909
1910 static const struct wine_rb_functions d3d10_effect_type_rb_functions =
1911 {
1912     d3d10_rb_alloc,
1913     d3d10_rb_realloc,
1914     d3d10_rb_free,
1915     d3d10_effect_type_compare,
1916 };
1917
1918 static HRESULT parse_fx10_body(struct d3d10_effect *e, const char *data, DWORD data_size)
1919 {
1920     const char *ptr = data + e->index_offset;
1921     unsigned int i;
1922     HRESULT hr;
1923
1924     if (wine_rb_init(&e->types, &d3d10_effect_type_rb_functions) == -1)
1925     {
1926         ERR("Failed to initialize type rbtree.\n");
1927         return E_FAIL;
1928     }
1929
1930     e->local_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->local_buffer_count * sizeof(*e->local_buffers));
1931     if (!e->local_buffers)
1932     {
1933         ERR("Failed to allocate local buffer memory.\n");
1934         return E_OUTOFMEMORY;
1935     }
1936
1937     e->local_variables = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->local_variable_count * sizeof(*e->local_variables));
1938     if (!e->local_variables)
1939     {
1940         ERR("Failed to allocate local variable memory.\n");
1941         return E_OUTOFMEMORY;
1942     }
1943
1944     e->anonymous_shaders = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->anonymous_shader_count * sizeof(*e->anonymous_shaders));
1945     if (!e->anonymous_shaders)
1946     {
1947         ERR("Failed to allocate anonymous shaders memory\n");
1948         return E_OUTOFMEMORY;
1949     }
1950
1951     e->used_shaders = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->used_shader_count * sizeof(*e->used_shaders));
1952     if (!e->used_shaders)
1953     {
1954         ERR("Failed to allocate used shaders memory\n");
1955         return E_OUTOFMEMORY;
1956     }
1957
1958     e->techniques = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->technique_count * sizeof(*e->techniques));
1959     if (!e->techniques)
1960     {
1961         ERR("Failed to allocate techniques memory\n");
1962         return E_OUTOFMEMORY;
1963     }
1964
1965     for (i = 0; i < e->local_buffer_count; ++i)
1966     {
1967         struct d3d10_effect_variable *l = &e->local_buffers[i];
1968         l->ID3D10EffectVariable_iface.lpVtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl;
1969         l->effect = e;
1970         l->buffer = &null_local_buffer;
1971
1972         hr = parse_fx10_local_buffer(l, &ptr, data);
1973         if (FAILED(hr)) return hr;
1974     }
1975
1976     for (i = 0; i < e->local_variable_count; ++i)
1977     {
1978         struct d3d10_effect_variable *v = &e->local_variables[i];
1979
1980         v->effect = e;
1981         v->ID3D10EffectVariable_iface.lpVtbl = &d3d10_effect_variable_vtbl;
1982         v->buffer = &null_local_buffer;
1983
1984         hr = parse_fx10_local_variable(v, &ptr, data);
1985         if (FAILED(hr)) return hr;
1986     }
1987
1988     for (i = 0; i < e->technique_count; ++i)
1989     {
1990         struct d3d10_effect_technique *t = &e->techniques[i];
1991
1992         t->ID3D10EffectTechnique_iface.lpVtbl = &d3d10_effect_technique_vtbl;
1993         t->effect = e;
1994
1995         hr = parse_fx10_technique(t, &ptr, data);
1996         if (FAILED(hr)) return hr;
1997     }
1998
1999     return S_OK;
2000 }
2001
2002 static HRESULT parse_fx10(struct d3d10_effect *e, const char *data, DWORD data_size)
2003 {
2004     const char *ptr = data;
2005     DWORD unknown;
2006
2007     /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
2008     read_dword(&ptr, &e->version);
2009     TRACE("Target: %#x\n", e->version);
2010
2011     read_dword(&ptr, &e->local_buffer_count);
2012     TRACE("Local buffer count: %u.\n", e->local_buffer_count);
2013
2014     read_dword(&ptr, &e->variable_count);
2015     TRACE("Variable count: %u\n", e->variable_count);
2016
2017     read_dword(&ptr, &e->local_variable_count);
2018     TRACE("Object count: %u\n", e->local_variable_count);
2019
2020     read_dword(&ptr, &e->sharedbuffers_count);
2021     TRACE("Sharedbuffers count: %u\n", e->sharedbuffers_count);
2022
2023     /* Number of variables in shared buffers? */
2024     read_dword(&ptr, &unknown);
2025     FIXME("Unknown 0: %u\n", unknown);
2026
2027     read_dword(&ptr, &e->sharedobjects_count);
2028     TRACE("Sharedobjects count: %u\n", e->sharedobjects_count);
2029
2030     read_dword(&ptr, &e->technique_count);
2031     TRACE("Technique count: %u\n", e->technique_count);
2032
2033     read_dword(&ptr, &e->index_offset);
2034     TRACE("Index offset: %#x\n", e->index_offset);
2035
2036     read_dword(&ptr, &unknown);
2037     FIXME("Unknown 1: %u\n", unknown);
2038
2039     read_dword(&ptr, &e->texture_count);
2040     TRACE("Texture count: %u\n", e->texture_count);
2041
2042     read_dword(&ptr, &e->dephstencilstate_count);
2043     TRACE("Depthstencilstate count: %u\n", e->dephstencilstate_count);
2044
2045     read_dword(&ptr, &e->blendstate_count);
2046     TRACE("Blendstate count: %u\n", e->blendstate_count);
2047
2048     read_dword(&ptr, &e->rasterizerstate_count);
2049     TRACE("Rasterizerstate count: %u\n", e->rasterizerstate_count);
2050
2051     read_dword(&ptr, &e->samplerstate_count);
2052     TRACE("Samplerstate count: %u\n", e->samplerstate_count);
2053
2054     read_dword(&ptr, &e->rendertargetview_count);
2055     TRACE("Rendertargetview count: %u\n", e->rendertargetview_count);
2056
2057     read_dword(&ptr, &e->depthstencilview_count);
2058     TRACE("Depthstencilview count: %u\n", e->depthstencilview_count);
2059
2060     read_dword(&ptr, &e->used_shader_count);
2061     TRACE("Used shader count: %u\n", e->used_shader_count);
2062
2063     read_dword(&ptr, &e->anonymous_shader_count);
2064     TRACE("Anonymous shader count: %u\n", e->anonymous_shader_count);
2065
2066     return parse_fx10_body(e, ptr, data_size - (ptr - data));
2067 }
2068
2069 static HRESULT fx10_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
2070 {
2071     struct d3d10_effect *e = ctx;
2072
2073     TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
2074
2075     TRACE("chunk size: %#x\n", data_size);
2076
2077     switch(tag)
2078     {
2079         case TAG_FX10:
2080             return parse_fx10(e, data, data_size);
2081
2082         default:
2083             FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
2084             return S_OK;
2085     }
2086 }
2087
2088 HRESULT d3d10_effect_parse(struct d3d10_effect *This, const void *data, SIZE_T data_size)
2089 {
2090     return parse_dxbc(data, data_size, fx10_chunk_handler, This);
2091 }
2092
2093 static HRESULT d3d10_effect_object_apply(struct d3d10_effect_object *o)
2094 {
2095     ID3D10Device *device = o->pass->technique->effect->device;
2096     struct d3d10_effect_variable *v = (struct d3d10_effect_variable*) o->data;
2097
2098     TRACE("effect object %p, type %#x.\n", o, o->type);
2099
2100     switch(o->type)
2101     {
2102         case D3D10_EOT_VERTEXSHADER:
2103             ID3D10Device_VSSetShader(device, ((struct d3d10_effect_shader_variable *)v->data)->shader.vs);
2104             return S_OK;
2105
2106         case D3D10_EOT_PIXELSHADER:
2107             ID3D10Device_PSSetShader(device, ((struct d3d10_effect_shader_variable *)v->data)->shader.ps);
2108             return S_OK;
2109
2110         case D3D10_EOT_GEOMETRYSHADER:
2111             ID3D10Device_GSSetShader(device, ((struct d3d10_effect_shader_variable *)v->data)->shader.gs);
2112             return S_OK;
2113
2114         default:
2115             FIXME("Unhandled effect object type %#x.\n", o->type);
2116             return E_FAIL;
2117     }
2118 }
2119
2120 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable *v)
2121 {
2122     unsigned int i;
2123
2124     TRACE("variable %p.\n", v);
2125
2126     HeapFree(GetProcessHeap(), 0, v->name);
2127     HeapFree(GetProcessHeap(), 0, v->semantic);
2128     if (v->annotations)
2129     {
2130         for (i = 0; i < v->annotation_count; ++i)
2131         {
2132             d3d10_effect_variable_destroy(&v->annotations[i]);
2133         }
2134         HeapFree(GetProcessHeap(), 0, v->annotations);
2135     }
2136
2137     if (v->members)
2138     {
2139         for (i = 0; i < v->type->member_count; ++i)
2140         {
2141             d3d10_effect_variable_destroy(&v->members[i]);
2142         }
2143         HeapFree(GetProcessHeap(), 0, v->members);
2144     }
2145
2146     if (v->elements)
2147     {
2148         for (i = 0; i < v->type->element_count; ++i)
2149         {
2150             d3d10_effect_variable_destroy(&v->elements[i]);
2151         }
2152         HeapFree(GetProcessHeap(), 0, v->elements);
2153     }
2154
2155     if (v->data)
2156     {
2157         switch(v->type->basetype)
2158         {
2159             case D3D10_SVT_VERTEXSHADER:
2160             case D3D10_SVT_PIXELSHADER:
2161             case D3D10_SVT_GEOMETRYSHADER:
2162                 shader_free_signature(&((struct d3d10_effect_shader_variable *)v->data)->input_signature);
2163                 shader_free_signature(&((struct d3d10_effect_shader_variable *)v->data)->output_signature);
2164                 break;
2165
2166             default:
2167                 break;
2168         }
2169         HeapFree(GetProcessHeap(), 0, v->data);
2170     }
2171 }
2172
2173 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass *p)
2174 {
2175     unsigned int i;
2176
2177     TRACE("pass %p\n", p);
2178
2179     HeapFree(GetProcessHeap(), 0, p->name);
2180     HeapFree(GetProcessHeap(), 0, p->objects);
2181
2182     if (p->annotations)
2183     {
2184         for (i = 0; i < p->annotation_count; ++i)
2185         {
2186             d3d10_effect_variable_destroy(&p->annotations[i]);
2187         }
2188         HeapFree(GetProcessHeap(), 0, p->annotations);
2189     }
2190 }
2191
2192 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique *t)
2193 {
2194     unsigned int i;
2195
2196     TRACE("technique %p\n", t);
2197
2198     HeapFree(GetProcessHeap(), 0, t->name);
2199     if (t->passes)
2200     {
2201         for (i = 0; i < t->pass_count; ++i)
2202         {
2203             d3d10_effect_pass_destroy(&t->passes[i]);
2204         }
2205         HeapFree(GetProcessHeap(), 0, t->passes);
2206     }
2207
2208     if (t->annotations)
2209     {
2210         for (i = 0; i < t->annotation_count; ++i)
2211         {
2212             d3d10_effect_variable_destroy(&t->annotations[i]);
2213         }
2214         HeapFree(GetProcessHeap(), 0, t->annotations);
2215     }
2216 }
2217
2218 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_variable *l)
2219 {
2220     unsigned int i;
2221
2222     TRACE("local buffer %p.\n", l);
2223
2224     HeapFree(GetProcessHeap(), 0, l->name);
2225     if (l->members)
2226     {
2227         for (i = 0; i < l->type->member_count; ++i)
2228         {
2229             d3d10_effect_variable_destroy(&l->members[i]);
2230         }
2231         HeapFree(GetProcessHeap(), 0, l->members);
2232     }
2233
2234     if (l->type->members)
2235     {
2236         for (i = 0; i < l->type->member_count; ++i)
2237         {
2238             /* Do not release l->type->members[i].type, it will be covered by d3d10_effect_type_destroy(). */
2239             HeapFree(GetProcessHeap(), 0, l->type->members[i].semantic);
2240             HeapFree(GetProcessHeap(), 0, l->type->members[i].name);
2241         }
2242         HeapFree(GetProcessHeap(), 0, l->type->members);
2243     }
2244     HeapFree(GetProcessHeap(), 0, l->type->name);
2245     HeapFree(GetProcessHeap(), 0, l->type);
2246
2247     if (l->annotations)
2248     {
2249         for (i = 0; i < l->annotation_count; ++i)
2250         {
2251             d3d10_effect_variable_destroy(&l->annotations[i]);
2252         }
2253         HeapFree(GetProcessHeap(), 0, l->annotations);
2254     }
2255 }
2256
2257 /* IUnknown methods */
2258
2259 static inline struct d3d10_effect *impl_from_ID3D10Effect(ID3D10Effect *iface)
2260 {
2261     return CONTAINING_RECORD(iface, struct d3d10_effect, ID3D10Effect_iface);
2262 }
2263
2264 static HRESULT STDMETHODCALLTYPE d3d10_effect_QueryInterface(ID3D10Effect *iface, REFIID riid, void **object)
2265 {
2266     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
2267
2268     if (IsEqualGUID(riid, &IID_ID3D10Effect)
2269             || IsEqualGUID(riid, &IID_IUnknown))
2270     {
2271         IUnknown_AddRef(iface);
2272         *object = iface;
2273         return S_OK;
2274     }
2275
2276     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
2277
2278     *object = NULL;
2279     return E_NOINTERFACE;
2280 }
2281
2282 static ULONG STDMETHODCALLTYPE d3d10_effect_AddRef(ID3D10Effect *iface)
2283 {
2284     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2285     ULONG refcount = InterlockedIncrement(&This->refcount);
2286
2287     TRACE("%p increasing refcount to %u\n", This, refcount);
2288
2289     return refcount;
2290 }
2291
2292 static ULONG STDMETHODCALLTYPE d3d10_effect_Release(ID3D10Effect *iface)
2293 {
2294     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2295     ULONG refcount = InterlockedDecrement(&This->refcount);
2296
2297     TRACE("%p decreasing refcount to %u\n", This, refcount);
2298
2299     if (!refcount)
2300     {
2301         unsigned int i;
2302
2303         if (This->techniques)
2304         {
2305             for (i = 0; i < This->technique_count; ++i)
2306             {
2307                 d3d10_effect_technique_destroy(&This->techniques[i]);
2308             }
2309             HeapFree(GetProcessHeap(), 0, This->techniques);
2310         }
2311
2312         if (This->local_variables)
2313         {
2314             for (i = 0; i < This->local_variable_count; ++i)
2315             {
2316                 d3d10_effect_variable_destroy(&This->local_variables[i]);
2317             }
2318             HeapFree(GetProcessHeap(), 0, This->local_variables);
2319         }
2320
2321         if (This->local_buffers)
2322         {
2323             for (i = 0; i < This->local_buffer_count; ++i)
2324             {
2325                 d3d10_effect_local_buffer_destroy(&This->local_buffers[i]);
2326             }
2327             HeapFree(GetProcessHeap(), 0, This->local_buffers);
2328         }
2329
2330         if (This->anonymous_shaders)
2331         {
2332             for (i = 0; i < This->anonymous_shader_count; ++i)
2333             {
2334                 d3d10_effect_variable_destroy(&This->anonymous_shaders[i].shader);
2335                 HeapFree(GetProcessHeap(), 0, This->anonymous_shaders[i].type.name);
2336             }
2337             HeapFree(GetProcessHeap(), 0, This->anonymous_shaders);
2338         }
2339
2340         HeapFree(GetProcessHeap(), 0, This->used_shaders);
2341
2342         wine_rb_destroy(&This->types, d3d10_effect_type_destroy, NULL);
2343
2344         ID3D10Device_Release(This->device);
2345         HeapFree(GetProcessHeap(), 0, This);
2346     }
2347
2348     return refcount;
2349 }
2350
2351 /* ID3D10Effect methods */
2352
2353 static BOOL STDMETHODCALLTYPE d3d10_effect_IsValid(ID3D10Effect *iface)
2354 {
2355     FIXME("iface %p stub!\n", iface);
2356
2357     return FALSE;
2358 }
2359
2360 static BOOL STDMETHODCALLTYPE d3d10_effect_IsPool(ID3D10Effect *iface)
2361 {
2362     FIXME("iface %p stub!\n", iface);
2363
2364     return FALSE;
2365 }
2366
2367 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDevice(ID3D10Effect *iface, ID3D10Device **device)
2368 {
2369     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2370
2371     TRACE("iface %p, device %p\n", iface, device);
2372
2373     ID3D10Device_AddRef(This->device);
2374     *device = This->device;
2375
2376     return S_OK;
2377 }
2378
2379 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDesc(ID3D10Effect *iface, D3D10_EFFECT_DESC *desc)
2380 {
2381     FIXME("iface %p, desc %p stub!\n", iface, desc);
2382
2383     return E_NOTIMPL;
2384 }
2385
2386 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByIndex(ID3D10Effect *iface,
2387         UINT index)
2388 {
2389     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2390     struct d3d10_effect_variable *l;
2391
2392     TRACE("iface %p, index %u\n", iface, index);
2393
2394     if (index >= This->local_buffer_count)
2395     {
2396         WARN("Invalid index specified\n");
2397         return (ID3D10EffectConstantBuffer *)&null_local_buffer;
2398     }
2399
2400     l = &This->local_buffers[index];
2401
2402     TRACE("Returning buffer %p, %s.\n", l, debugstr_a(l->name));
2403
2404     return (ID3D10EffectConstantBuffer *)l;
2405 }
2406
2407 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByName(ID3D10Effect *iface,
2408         LPCSTR name)
2409 {
2410     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2411     unsigned int i;
2412
2413     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2414
2415     for (i = 0; i < This->local_buffer_count; ++i)
2416     {
2417         struct d3d10_effect_variable *l = &This->local_buffers[i];
2418
2419         if (!strcmp(l->name, name))
2420         {
2421             TRACE("Returning buffer %p.\n", l);
2422             return (ID3D10EffectConstantBuffer *)l;
2423         }
2424     }
2425
2426     WARN("Invalid name specified\n");
2427
2428     return (ID3D10EffectConstantBuffer *)&null_local_buffer;
2429 }
2430
2431 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByIndex(ID3D10Effect *iface, UINT index)
2432 {
2433     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2434     unsigned int i;
2435
2436     TRACE("iface %p, index %u\n", iface, index);
2437
2438     for (i = 0; i < This->local_buffer_count; ++i)
2439     {
2440         struct d3d10_effect_variable *l = &This->local_buffers[i];
2441
2442         if (index < l->type->member_count)
2443         {
2444             struct d3d10_effect_variable *v = &l->members[index];
2445
2446             TRACE("Returning variable %p.\n", v);
2447             return &v->ID3D10EffectVariable_iface;
2448         }
2449         index -= l->type->member_count;
2450     }
2451
2452     if (index < This->local_variable_count)
2453     {
2454         struct d3d10_effect_variable *v = &This->local_variables[index];
2455
2456         TRACE("Returning variable %p.\n", v);
2457         return &v->ID3D10EffectVariable_iface;
2458     }
2459
2460     WARN("Invalid index specified\n");
2461
2462     return &null_variable.ID3D10EffectVariable_iface;
2463 }
2464
2465 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByName(ID3D10Effect *iface, LPCSTR name)
2466 {
2467     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2468     unsigned int i;
2469
2470     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2471
2472     if (!name)
2473     {
2474         WARN("Invalid name specified\n");
2475         return &null_variable.ID3D10EffectVariable_iface;
2476     }
2477
2478     for (i = 0; i < This->local_buffer_count; ++i)
2479     {
2480         struct d3d10_effect_variable *l = &This->local_buffers[i];
2481         unsigned int j;
2482
2483         for (j = 0; j < l->type->member_count; ++j)
2484         {
2485             struct d3d10_effect_variable *v = &l->members[j];
2486
2487             if (!strcmp(v->name, name))
2488             {
2489                 TRACE("Returning variable %p.\n", v);
2490                 return &v->ID3D10EffectVariable_iface;
2491             }
2492         }
2493     }
2494
2495     for (i = 0; i < This->local_variable_count; ++i)
2496     {
2497         struct d3d10_effect_variable *v = &This->local_variables[i];
2498
2499         if (!strcmp(v->name, name))
2500         {
2501             TRACE("Returning variable %p.\n", v);
2502             return &v->ID3D10EffectVariable_iface;
2503         }
2504     }
2505
2506     WARN("Invalid name specified\n");
2507
2508     return &null_variable.ID3D10EffectVariable_iface;
2509 }
2510
2511 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableBySemantic(ID3D10Effect *iface,
2512         LPCSTR semantic)
2513 {
2514     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2515     unsigned int i;
2516
2517     TRACE("iface %p, semantic %s\n", iface, debugstr_a(semantic));
2518
2519     if (!semantic)
2520     {
2521         WARN("Invalid semantic specified\n");
2522         return &null_variable.ID3D10EffectVariable_iface;
2523     }
2524
2525     for (i = 0; i < This->local_buffer_count; ++i)
2526     {
2527         struct d3d10_effect_variable *l = &This->local_buffers[i];
2528         unsigned int j;
2529
2530         for (j = 0; j < l->type->member_count; ++j)
2531         {
2532             struct d3d10_effect_variable *v = &l->members[j];
2533
2534             if (!strcmp(v->semantic, semantic))
2535             {
2536                 TRACE("Returning variable %p.\n", v);
2537                 return &v->ID3D10EffectVariable_iface;
2538             }
2539         }
2540     }
2541
2542     for (i = 0; i < This->local_variable_count; ++i)
2543     {
2544         struct d3d10_effect_variable *v = &This->local_variables[i];
2545
2546         if (!strcmp(v->semantic, semantic))
2547         {
2548             TRACE("Returning variable %p.\n", v);
2549             return &v->ID3D10EffectVariable_iface;
2550         }
2551     }
2552
2553     WARN("Invalid semantic specified\n");
2554
2555     return &null_variable.ID3D10EffectVariable_iface;
2556 }
2557
2558 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByIndex(ID3D10Effect *iface,
2559         UINT index)
2560 {
2561     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2562     struct d3d10_effect_technique *t;
2563
2564     TRACE("iface %p, index %u\n", iface, index);
2565
2566     if (index >= This->technique_count)
2567     {
2568         WARN("Invalid index specified\n");
2569         return &null_technique.ID3D10EffectTechnique_iface;
2570     }
2571
2572     t = &This->techniques[index];
2573
2574     TRACE("Returning technique %p, %s.\n", t, debugstr_a(t->name));
2575
2576     return &t->ID3D10EffectTechnique_iface;
2577 }
2578
2579 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByName(ID3D10Effect *iface,
2580         LPCSTR name)
2581 {
2582     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2583     unsigned int i;
2584
2585     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2586
2587     if (!name)
2588     {
2589         WARN("Invalid name specified\n");
2590         return &null_technique.ID3D10EffectTechnique_iface;
2591     }
2592
2593     for (i = 0; i < This->technique_count; ++i)
2594     {
2595         struct d3d10_effect_technique *t = &This->techniques[i];
2596         if (!strcmp(t->name, name))
2597         {
2598             TRACE("Returning technique %p\n", t);
2599             return &t->ID3D10EffectTechnique_iface;
2600         }
2601     }
2602
2603     WARN("Invalid name specified\n");
2604
2605     return &null_technique.ID3D10EffectTechnique_iface;
2606 }
2607
2608 static HRESULT STDMETHODCALLTYPE d3d10_effect_Optimize(ID3D10Effect *iface)
2609 {
2610     FIXME("iface %p stub!\n", iface);
2611
2612     return E_NOTIMPL;
2613 }
2614
2615 static BOOL STDMETHODCALLTYPE d3d10_effect_IsOptimized(ID3D10Effect *iface)
2616 {
2617     FIXME("iface %p stub!\n", iface);
2618
2619     return FALSE;
2620 }
2621
2622 const struct ID3D10EffectVtbl d3d10_effect_vtbl =
2623 {
2624     /* IUnknown methods */
2625     d3d10_effect_QueryInterface,
2626     d3d10_effect_AddRef,
2627     d3d10_effect_Release,
2628     /* ID3D10Effect methods */
2629     d3d10_effect_IsValid,
2630     d3d10_effect_IsPool,
2631     d3d10_effect_GetDevice,
2632     d3d10_effect_GetDesc,
2633     d3d10_effect_GetConstantBufferByIndex,
2634     d3d10_effect_GetConstantBufferByName,
2635     d3d10_effect_GetVariableByIndex,
2636     d3d10_effect_GetVariableByName,
2637     d3d10_effect_GetVariableBySemantic,
2638     d3d10_effect_GetTechniqueByIndex,
2639     d3d10_effect_GetTechniqueByName,
2640     d3d10_effect_Optimize,
2641     d3d10_effect_IsOptimized,
2642 };
2643
2644 /* ID3D10EffectTechnique methods */
2645
2646 static inline struct d3d10_effect_technique *impl_from_ID3D10EffectTechnique(ID3D10EffectTechnique *iface)
2647 {
2648     return CONTAINING_RECORD(iface, struct d3d10_effect_technique, ID3D10EffectTechnique_iface);
2649 }
2650
2651 static BOOL STDMETHODCALLTYPE d3d10_effect_technique_IsValid(ID3D10EffectTechnique *iface)
2652 {
2653     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2654
2655     TRACE("iface %p\n", iface);
2656
2657     return This != &null_technique;
2658 }
2659
2660 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_GetDesc(ID3D10EffectTechnique *iface,
2661         D3D10_TECHNIQUE_DESC *desc)
2662 {
2663     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2664
2665     TRACE("iface %p, desc %p\n", iface, desc);
2666
2667     if(This == &null_technique)
2668     {
2669         WARN("Null technique specified\n");
2670         return E_FAIL;
2671     }
2672
2673     if(!desc)
2674     {
2675         WARN("Invalid argument specified\n");
2676         return E_INVALIDARG;
2677     }
2678
2679     desc->Name = This->name;
2680     desc->Passes = This->pass_count;
2681     desc->Annotations = This->annotation_count;
2682
2683     return S_OK;
2684 }
2685
2686 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByIndex(
2687         ID3D10EffectTechnique *iface, UINT index)
2688 {
2689     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2690     struct d3d10_effect_variable *a;
2691
2692     TRACE("iface %p, index %u\n", iface, index);
2693
2694     if (index >= This->annotation_count)
2695     {
2696         WARN("Invalid index specified\n");
2697         return &null_variable.ID3D10EffectVariable_iface;
2698     }
2699
2700     a = &This->annotations[index];
2701
2702     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
2703
2704     return &a->ID3D10EffectVariable_iface;
2705 }
2706
2707 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByName(
2708         ID3D10EffectTechnique *iface, LPCSTR name)
2709 {
2710     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2711     unsigned int i;
2712
2713     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2714
2715     for (i = 0; i < This->annotation_count; ++i)
2716     {
2717         struct d3d10_effect_variable *a = &This->annotations[i];
2718         if (!strcmp(a->name, name))
2719         {
2720             TRACE("Returning annotation %p\n", a);
2721             return &a->ID3D10EffectVariable_iface;
2722         }
2723     }
2724
2725     WARN("Invalid name specified\n");
2726
2727     return &null_variable.ID3D10EffectVariable_iface;
2728 }
2729
2730 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique *iface,
2731         UINT index)
2732 {
2733     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2734     struct d3d10_effect_pass *p;
2735
2736     TRACE("iface %p, index %u\n", iface, index);
2737
2738     if (index >= This->pass_count)
2739     {
2740         WARN("Invalid index specified\n");
2741         return &null_pass.ID3D10EffectPass_iface;
2742     }
2743
2744     p = &This->passes[index];
2745
2746     TRACE("Returning pass %p, %s.\n", p, debugstr_a(p->name));
2747
2748     return &p->ID3D10EffectPass_iface;
2749 }
2750
2751 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique *iface,
2752         LPCSTR name)
2753 {
2754     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2755     unsigned int i;
2756
2757     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2758
2759     /* Do not check for name==NULL, W7/DX10 crashes in that case. */
2760
2761     for (i = 0; i < This->pass_count; ++i)
2762     {
2763         struct d3d10_effect_pass *p = &This->passes[i];
2764         if (!strcmp(p->name, name))
2765         {
2766             TRACE("Returning pass %p\n", p);
2767             return &p->ID3D10EffectPass_iface;
2768         }
2769     }
2770
2771     WARN("Invalid name specified\n");
2772
2773     return &null_pass.ID3D10EffectPass_iface;
2774 }
2775
2776 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique *iface,
2777         D3D10_STATE_BLOCK_MASK *mask)
2778 {
2779     FIXME("iface %p,mask %p stub!\n", iface, mask);
2780
2781     return E_NOTIMPL;
2782 }
2783
2784 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl =
2785 {
2786     /* ID3D10EffectTechnique methods */
2787     d3d10_effect_technique_IsValid,
2788     d3d10_effect_technique_GetDesc,
2789     d3d10_effect_technique_GetAnnotationByIndex,
2790     d3d10_effect_technique_GetAnnotationByName,
2791     d3d10_effect_technique_GetPassByIndex,
2792     d3d10_effect_technique_GetPassByName,
2793     d3d10_effect_technique_ComputeStateBlockMask,
2794 };
2795
2796 /* ID3D10EffectPass methods */
2797
2798 static inline struct d3d10_effect_pass *impl_from_ID3D10EffectPass(ID3D10EffectPass *iface)
2799 {
2800     return CONTAINING_RECORD(iface, struct d3d10_effect_pass, ID3D10EffectPass_iface);
2801 }
2802
2803 static BOOL STDMETHODCALLTYPE d3d10_effect_pass_IsValid(ID3D10EffectPass *iface)
2804 {
2805     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2806
2807     TRACE("iface %p\n", iface);
2808
2809     return This != &null_pass;
2810 }
2811
2812 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetDesc(ID3D10EffectPass *iface,
2813         D3D10_PASS_DESC *desc)
2814 {
2815     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2816     unsigned int i;
2817
2818     FIXME("iface %p, desc %p partial stub!\n", iface, desc);
2819
2820     if(This == &null_pass)
2821     {
2822         WARN("Null pass specified\n");
2823         return E_FAIL;
2824     }
2825
2826     if(!desc)
2827     {
2828         WARN("Invalid argument specified\n");
2829         return E_INVALIDARG;
2830     }
2831
2832     memset(desc, 0, sizeof(*desc));
2833     desc->Name = This->name;
2834     for (i = 0; i < This->object_count; ++i)
2835     {
2836         struct d3d10_effect_object *o = &This->objects[i];
2837         if (o->type == D3D10_EOT_VERTEXSHADER)
2838         {
2839             struct d3d10_effect_variable *v = o->data;
2840             struct d3d10_effect_shader_variable *s = v->data;
2841             desc->pIAInputSignature = (BYTE *)s->input_signature.signature;
2842             desc->IAInputSignatureSize = s->input_signature.signature_size;
2843             break;
2844         }
2845     }
2846
2847     desc->StencilRef = This->stencil_ref;
2848     desc->SampleMask = This->sample_mask;
2849     memcpy(desc->BlendFactor, This->blend_factor, 4 * sizeof(float));
2850
2851     return S_OK;
2852 }
2853
2854 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass *iface,
2855         D3D10_PASS_SHADER_DESC *desc)
2856 {
2857     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2858     unsigned int i;
2859
2860     TRACE("iface %p, desc %p\n", iface, desc);
2861
2862     if (This == &null_pass)
2863     {
2864         WARN("Null pass specified\n");
2865         return E_FAIL;
2866     }
2867
2868     if (!desc)
2869     {
2870         WARN("Invalid argument specified\n");
2871         return E_INVALIDARG;
2872     }
2873
2874     for (i = 0; i < This->object_count; ++i)
2875     {
2876         struct d3d10_effect_object *o = &This->objects[i];
2877
2878         if (o->type == D3D10_EOT_VERTEXSHADER)
2879         {
2880             desc->pShaderVariable = o->data;
2881             desc->ShaderIndex = o->index;
2882             return S_OK;
2883         }
2884     }
2885
2886     TRACE("Returning null_shader_variable\n");
2887     desc->pShaderVariable = (ID3D10EffectShaderVariable *)&null_shader_variable;
2888     desc->ShaderIndex = 0;
2889
2890     return S_OK;
2891 }
2892
2893 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass *iface,
2894         D3D10_PASS_SHADER_DESC *desc)
2895 {
2896     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2897     unsigned int i;
2898
2899     TRACE("iface %p, desc %p\n", iface, desc);
2900
2901     if (This == &null_pass)
2902     {
2903         WARN("Null pass specified\n");
2904         return E_FAIL;
2905     }
2906
2907     if (!desc)
2908     {
2909         WARN("Invalid argument specified\n");
2910         return E_INVALIDARG;
2911     }
2912
2913     for (i = 0; i < This->object_count; ++i)
2914     {
2915         struct d3d10_effect_object *o = &This->objects[i];
2916
2917         if (o->type == D3D10_EOT_GEOMETRYSHADER)
2918         {
2919             desc->pShaderVariable = o->data;
2920             desc->ShaderIndex = o->index;
2921             return S_OK;
2922         }
2923     }
2924
2925     TRACE("Returning null_shader_variable\n");
2926     desc->pShaderVariable = (ID3D10EffectShaderVariable *)&null_shader_variable;
2927     desc->ShaderIndex = 0;
2928
2929     return S_OK;
2930 }
2931
2932 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass *iface,
2933         D3D10_PASS_SHADER_DESC *desc)
2934 {
2935     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2936     unsigned int i;
2937
2938     TRACE("iface %p, desc %p\n", iface, desc);
2939
2940     if (This == &null_pass)
2941     {
2942         WARN("Null pass specified\n");
2943         return E_FAIL;
2944     }
2945
2946     if (!desc)
2947     {
2948         WARN("Invalid argument specified\n");
2949         return E_INVALIDARG;
2950     }
2951
2952     for (i = 0; i < This->object_count; ++i)
2953     {
2954         struct d3d10_effect_object *o = &This->objects[i];
2955
2956         if (o->type == D3D10_EOT_PIXELSHADER)
2957         {
2958             desc->pShaderVariable = o->data;
2959             desc->ShaderIndex = o->index;
2960             return S_OK;
2961         }
2962     }
2963
2964     TRACE("Returning null_shader_variable\n");
2965     desc->pShaderVariable = (ID3D10EffectShaderVariable *)&null_shader_variable;
2966     desc->ShaderIndex = 0;
2967
2968     return S_OK;
2969 }
2970
2971 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass *iface,
2972         UINT index)
2973 {
2974     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2975     struct d3d10_effect_variable *a;
2976
2977     TRACE("iface %p, index %u\n", iface, index);
2978
2979     if (index >= This->annotation_count)
2980     {
2981         WARN("Invalid index specified\n");
2982         return &null_variable.ID3D10EffectVariable_iface;
2983     }
2984
2985     a = &This->annotations[index];
2986
2987     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
2988
2989     return &a->ID3D10EffectVariable_iface;
2990 }
2991
2992 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass *iface,
2993         LPCSTR name)
2994 {
2995     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2996     unsigned int i;
2997
2998     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2999
3000     for (i = 0; i < This->annotation_count; ++i)
3001     {
3002         struct d3d10_effect_variable *a = &This->annotations[i];
3003         if (!strcmp(a->name, name))
3004         {
3005             TRACE("Returning annotation %p\n", a);
3006             return &a->ID3D10EffectVariable_iface;
3007         }
3008     }
3009
3010     WARN("Invalid name specified\n");
3011
3012     return &null_variable.ID3D10EffectVariable_iface;
3013 }
3014
3015 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_Apply(ID3D10EffectPass *iface, UINT flags)
3016 {
3017     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
3018     HRESULT hr = S_OK;
3019     unsigned int i;
3020
3021     TRACE("iface %p, flags %#x\n", iface, flags);
3022
3023     if (flags) FIXME("Ignoring flags (%#x)\n", flags);
3024
3025     for (i = 0; i < This->object_count; ++i)
3026     {
3027         hr = d3d10_effect_object_apply(&This->objects[i]);
3028         if (FAILED(hr)) break;
3029     }
3030
3031     return hr;
3032 }
3033
3034 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass *iface,
3035         D3D10_STATE_BLOCK_MASK *mask)
3036 {
3037     FIXME("iface %p, mask %p stub!\n", iface, mask);
3038
3039     return E_NOTIMPL;
3040 }
3041
3042 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl =
3043 {
3044     /* ID3D10EffectPass methods */
3045     d3d10_effect_pass_IsValid,
3046     d3d10_effect_pass_GetDesc,
3047     d3d10_effect_pass_GetVertexShaderDesc,
3048     d3d10_effect_pass_GetGeometryShaderDesc,
3049     d3d10_effect_pass_GetPixelShaderDesc,
3050     d3d10_effect_pass_GetAnnotationByIndex,
3051     d3d10_effect_pass_GetAnnotationByName,
3052     d3d10_effect_pass_Apply,
3053     d3d10_effect_pass_ComputeStateBlockMask,
3054 };
3055
3056 /* ID3D10EffectVariable methods */
3057
3058 static BOOL STDMETHODCALLTYPE d3d10_effect_variable_IsValid(ID3D10EffectVariable *iface)
3059 {
3060     TRACE("iface %p\n", iface);
3061
3062     return impl_from_ID3D10EffectVariable(iface) != &null_variable;
3063 }
3064
3065 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_variable_GetType(ID3D10EffectVariable *iface)
3066 {
3067     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3068
3069     TRACE("iface %p\n", iface);
3070
3071     return &This->type->ID3D10EffectType_iface;
3072 }
3073
3074 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetDesc(ID3D10EffectVariable *iface,
3075         D3D10_EFFECT_VARIABLE_DESC *desc)
3076 {
3077     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3078
3079     TRACE("iface %p, desc %p\n", iface, desc);
3080
3081     if (!iface->lpVtbl->IsValid(iface))
3082     {
3083         WARN("Null variable specified\n");
3084         return E_FAIL;
3085     }
3086
3087     if (!desc)
3088     {
3089         WARN("Invalid argument specified\n");
3090         return E_INVALIDARG;
3091     }
3092
3093     /* FIXME: This isn't correct. Anonymous shaders let desc->ExplicitBindPoint untouched, but normal shaders set it! */
3094     memset(desc, 0, sizeof(*desc));
3095     desc->Name = This->name;
3096     desc->Semantic = This->semantic;
3097     desc->Flags = This->flag;
3098     desc->Annotations = This->annotation_count;
3099     desc->BufferOffset = This->buffer_offset;
3100
3101     if (This->flag & D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
3102     {
3103         desc->ExplicitBindPoint = This->buffer_offset;
3104     }
3105
3106     return S_OK;
3107 }
3108
3109 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByIndex(
3110         ID3D10EffectVariable *iface, UINT index)
3111 {
3112     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3113     struct d3d10_effect_variable *a;
3114
3115     TRACE("iface %p, index %u\n", iface, index);
3116
3117     if (index >= This->annotation_count)
3118     {
3119         WARN("Invalid index specified\n");
3120         return &null_variable.ID3D10EffectVariable_iface;
3121     }
3122
3123     a = &This->annotations[index];
3124
3125     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
3126
3127     return &a->ID3D10EffectVariable_iface;
3128 }
3129
3130 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByName(
3131         ID3D10EffectVariable *iface, LPCSTR name)
3132 {
3133     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3134     unsigned int i;
3135
3136     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3137
3138     for (i = 0; i < This->annotation_count; ++i)
3139     {
3140         struct d3d10_effect_variable *a = &This->annotations[i];
3141         if (!strcmp(a->name, name))
3142         {
3143             TRACE("Returning annotation %p\n", a);
3144             return &a->ID3D10EffectVariable_iface;
3145         }
3146     }
3147
3148     WARN("Invalid name specified\n");
3149
3150     return &null_variable.ID3D10EffectVariable_iface;
3151 }
3152
3153 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByIndex(
3154         ID3D10EffectVariable *iface, UINT index)
3155 {
3156     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3157     struct d3d10_effect_variable *m;
3158
3159     TRACE("iface %p, index %u\n", iface, index);
3160
3161     if (index >= This->type->member_count)
3162     {
3163         WARN("Invalid index specified\n");
3164         return &null_variable.ID3D10EffectVariable_iface;
3165     }
3166
3167     m = &This->members[index];
3168
3169     TRACE("Returning member %p, %s\n", m, debugstr_a(m->name));
3170
3171     return &m->ID3D10EffectVariable_iface;
3172 }
3173
3174 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByName(
3175         ID3D10EffectVariable *iface, LPCSTR name)
3176 {
3177     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3178     unsigned int i;
3179
3180     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3181
3182     if (!name)
3183     {
3184         WARN("Invalid name specified\n");
3185         return &null_variable.ID3D10EffectVariable_iface;
3186     }
3187
3188     for (i = 0; i < This->type->member_count; ++i)
3189     {
3190         struct d3d10_effect_variable *m = &This->members[i];
3191
3192         if (m->name)
3193         {
3194             if (!strcmp(m->name, name))
3195             {
3196                 TRACE("Returning member %p\n", m);
3197                 return &m->ID3D10EffectVariable_iface;
3198             }
3199         }
3200     }
3201
3202     WARN("Invalid name specified\n");
3203
3204     return &null_variable.ID3D10EffectVariable_iface;
3205 }
3206
3207 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberBySemantic(
3208         ID3D10EffectVariable *iface, LPCSTR semantic)
3209 {
3210     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3211     unsigned int i;
3212
3213     TRACE("iface %p, semantic %s.\n", iface, debugstr_a(semantic));
3214
3215     if (!semantic)
3216     {
3217         WARN("Invalid semantic specified\n");
3218         return &null_variable.ID3D10EffectVariable_iface;
3219     }
3220
3221     for (i = 0; i < This->type->member_count; ++i)
3222     {
3223         struct d3d10_effect_variable *m = &This->members[i];
3224
3225         if (m->semantic)
3226         {
3227             if (!strcmp(m->semantic, semantic))
3228             {
3229                 TRACE("Returning member %p\n", m);
3230                 return &m->ID3D10EffectVariable_iface;
3231             }
3232         }
3233     }
3234
3235     WARN("Invalid semantic specified\n");
3236
3237     return &null_variable.ID3D10EffectVariable_iface;
3238 }
3239
3240 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetElement(
3241         ID3D10EffectVariable *iface, UINT index)
3242 {
3243     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3244     struct d3d10_effect_variable *v;
3245
3246     TRACE("iface %p, index %u\n", iface, index);
3247
3248     if (index >= This->type->element_count)
3249     {
3250         WARN("Invalid index specified\n");
3251         return &null_variable.ID3D10EffectVariable_iface;
3252     }
3253
3254     v = &This->elements[index];
3255
3256     TRACE("Returning element %p, %s\n", v, debugstr_a(v->name));
3257
3258     return &v->ID3D10EffectVariable_iface;
3259 }
3260
3261 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_GetParentConstantBuffer(
3262         ID3D10EffectVariable *iface)
3263 {
3264     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3265
3266     TRACE("iface %p\n", iface);
3267
3268     return (ID3D10EffectConstantBuffer *)This->buffer;
3269 }
3270
3271 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsScalar(
3272         ID3D10EffectVariable *iface)
3273 {
3274     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3275
3276     TRACE("iface %p\n", iface);
3277
3278     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl)
3279         return (ID3D10EffectScalarVariable *)&This->ID3D10EffectVariable_iface;
3280
3281     return (ID3D10EffectScalarVariable *)&null_scalar_variable.ID3D10EffectVariable_iface;
3282 }
3283
3284 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsVector(
3285         ID3D10EffectVariable *iface)
3286 {
3287     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3288
3289     TRACE("iface %p\n", iface);
3290
3291     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl)
3292         return (ID3D10EffectVectorVariable *)&This->ID3D10EffectVariable_iface;
3293
3294     return (ID3D10EffectVectorVariable *)&null_vector_variable.ID3D10EffectVariable_iface;
3295 }
3296
3297 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsMatrix(
3298         ID3D10EffectVariable *iface)
3299 {
3300     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3301
3302     TRACE("iface %p\n", iface);
3303
3304     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl)
3305         return (ID3D10EffectMatrixVariable *)&This->ID3D10EffectVariable_iface;
3306
3307     return (ID3D10EffectMatrixVariable *)&null_matrix_variable.ID3D10EffectVariable_iface;
3308 }
3309
3310 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsString(
3311         ID3D10EffectVariable *iface)
3312 {
3313     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3314
3315     TRACE("iface %p\n", iface);
3316
3317     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl)
3318         return (ID3D10EffectStringVariable *)&This->ID3D10EffectVariable_iface;
3319
3320     return (ID3D10EffectStringVariable *)&null_string_variable.ID3D10EffectVariable_iface;
3321 }
3322
3323 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShaderResource(
3324         ID3D10EffectVariable *iface)
3325 {
3326     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3327
3328     TRACE("iface %p\n", iface);
3329
3330     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl)
3331         return (ID3D10EffectShaderResourceVariable *)&This->ID3D10EffectVariable_iface;
3332
3333     return (ID3D10EffectShaderResourceVariable *)&null_shader_resource_variable.ID3D10EffectVariable_iface;
3334 }
3335
3336 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRenderTargetView(
3337         ID3D10EffectVariable *iface)
3338 {
3339     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3340
3341     TRACE("iface %p\n", iface);
3342
3343     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl)
3344         return (ID3D10EffectRenderTargetViewVariable *)&This->ID3D10EffectVariable_iface;
3345
3346     return (ID3D10EffectRenderTargetViewVariable *)&null_render_target_view_variable.ID3D10EffectVariable_iface;
3347 }
3348
3349 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencilView(
3350         ID3D10EffectVariable *iface)
3351 {
3352     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3353
3354     TRACE("iface %p\n", iface);
3355
3356     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl)
3357         return (ID3D10EffectDepthStencilViewVariable *)&This->ID3D10EffectVariable_iface;
3358
3359     return (ID3D10EffectDepthStencilViewVariable *)&null_depth_stencil_view_variable.ID3D10EffectVariable_iface;
3360 }
3361
3362 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_AsConstantBuffer(
3363         ID3D10EffectVariable *iface)
3364 {
3365     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3366
3367     TRACE("iface %p\n", iface);
3368
3369     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl)
3370         return (ID3D10EffectConstantBuffer *)&This->ID3D10EffectVariable_iface;
3371
3372     return (ID3D10EffectConstantBuffer *)&null_local_buffer.ID3D10EffectVariable_iface;
3373 }
3374
3375 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShader(
3376         ID3D10EffectVariable *iface)
3377 {
3378     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3379
3380     TRACE("iface %p\n", iface);
3381
3382     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl)
3383         return (ID3D10EffectShaderVariable *)&This->ID3D10EffectVariable_iface;
3384
3385     return (ID3D10EffectShaderVariable *)&null_shader_variable.ID3D10EffectVariable_iface;
3386 }
3387
3388 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsBlend(ID3D10EffectVariable *iface)
3389 {
3390     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3391
3392     TRACE("iface %p\n", iface);
3393
3394     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl)
3395         return (ID3D10EffectBlendVariable *)&This->ID3D10EffectVariable_iface;
3396
3397     return (ID3D10EffectBlendVariable *)&null_blend_variable.ID3D10EffectVariable_iface;
3398 }
3399
3400 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencil(
3401         ID3D10EffectVariable *iface)
3402 {
3403     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3404
3405     TRACE("iface %p\n", iface);
3406
3407     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl)
3408         return (ID3D10EffectDepthStencilVariable *)&This->ID3D10EffectVariable_iface;
3409
3410     return (ID3D10EffectDepthStencilVariable *)&null_depth_stencil_variable.ID3D10EffectVariable_iface;
3411 }
3412
3413 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRasterizer(
3414         ID3D10EffectVariable *iface)
3415 {
3416     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3417
3418     TRACE("iface %p\n", iface);
3419
3420     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl)
3421         return (ID3D10EffectRasterizerVariable *)&This->ID3D10EffectVariable_iface;
3422
3423     return (ID3D10EffectRasterizerVariable *)&null_rasterizer_variable.ID3D10EffectVariable_iface;
3424 }
3425
3426 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsSampler(
3427         ID3D10EffectVariable *iface)
3428 {
3429     struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3430
3431     TRACE("iface %p\n", iface);
3432
3433     if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl)
3434         return (ID3D10EffectSamplerVariable *)&This->ID3D10EffectVariable_iface;
3435
3436     return (ID3D10EffectSamplerVariable *)&null_sampler_variable.ID3D10EffectVariable_iface;
3437 }
3438
3439 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_SetRawValue(ID3D10EffectVariable *iface,
3440         void *data, UINT offset, UINT count)
3441 {
3442     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
3443
3444     return E_NOTIMPL;
3445 }
3446
3447 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetRawValue(ID3D10EffectVariable *iface,
3448         void *data, UINT offset, UINT count)
3449 {
3450     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
3451
3452     return E_NOTIMPL;
3453 }
3454
3455 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl =
3456 {
3457     /* ID3D10EffectVariable methods */
3458     d3d10_effect_variable_IsValid,
3459     d3d10_effect_variable_GetType,
3460     d3d10_effect_variable_GetDesc,
3461     d3d10_effect_variable_GetAnnotationByIndex,
3462     d3d10_effect_variable_GetAnnotationByName,
3463     d3d10_effect_variable_GetMemberByIndex,
3464     d3d10_effect_variable_GetMemberByName,
3465     d3d10_effect_variable_GetMemberBySemantic,
3466     d3d10_effect_variable_GetElement,
3467     d3d10_effect_variable_GetParentConstantBuffer,
3468     d3d10_effect_variable_AsScalar,
3469     d3d10_effect_variable_AsVector,
3470     d3d10_effect_variable_AsMatrix,
3471     d3d10_effect_variable_AsString,
3472     d3d10_effect_variable_AsShaderResource,
3473     d3d10_effect_variable_AsRenderTargetView,
3474     d3d10_effect_variable_AsDepthStencilView,
3475     d3d10_effect_variable_AsConstantBuffer,
3476     d3d10_effect_variable_AsShader,
3477     d3d10_effect_variable_AsBlend,
3478     d3d10_effect_variable_AsDepthStencil,
3479     d3d10_effect_variable_AsRasterizer,
3480     d3d10_effect_variable_AsSampler,
3481     d3d10_effect_variable_SetRawValue,
3482     d3d10_effect_variable_GetRawValue,
3483 };
3484
3485 /* ID3D10EffectVariable methods */
3486 static BOOL STDMETHODCALLTYPE d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer *iface)
3487 {
3488     TRACE("iface %p\n", iface);
3489
3490     return (struct d3d10_effect_variable *)iface != &null_local_buffer;
3491 }
3492
3493 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer *iface)
3494 {
3495     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
3496 }
3497
3498 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer *iface,
3499         D3D10_EFFECT_VARIABLE_DESC *desc)
3500 {
3501     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
3502 }
3503
3504 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByIndex(
3505         ID3D10EffectConstantBuffer *iface, UINT index)
3506 {
3507     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
3508 }
3509
3510 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByName(
3511         ID3D10EffectConstantBuffer *iface, LPCSTR name)
3512 {
3513     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
3514 }
3515
3516 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByIndex(
3517         ID3D10EffectConstantBuffer *iface, UINT index)
3518 {
3519     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
3520 }
3521
3522 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByName(
3523         ID3D10EffectConstantBuffer *iface, LPCSTR name)
3524 {
3525     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
3526 }
3527
3528 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberBySemantic(
3529         ID3D10EffectConstantBuffer *iface, LPCSTR semantic)
3530 {
3531     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
3532 }
3533
3534 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetElement(
3535         ID3D10EffectConstantBuffer *iface, UINT index)
3536 {
3537     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
3538 }
3539
3540 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetParentConstantBuffer(
3541         ID3D10EffectConstantBuffer *iface)
3542 {
3543     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
3544 }
3545
3546 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsScalar(
3547         ID3D10EffectConstantBuffer *iface)
3548 {
3549     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
3550 }
3551
3552 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsVector(
3553         ID3D10EffectConstantBuffer *iface)
3554 {
3555     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
3556 }
3557
3558 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsMatrix(
3559         ID3D10EffectConstantBuffer *iface)
3560 {
3561     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
3562 }
3563
3564 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsString(
3565         ID3D10EffectConstantBuffer *iface)
3566 {
3567     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
3568 }
3569
3570 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShaderResource(
3571         ID3D10EffectConstantBuffer *iface)
3572 {
3573     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
3574 }
3575
3576 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRenderTargetView(
3577         ID3D10EffectConstantBuffer *iface)
3578 {
3579     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
3580 }
3581
3582 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencilView(
3583         ID3D10EffectConstantBuffer *iface)
3584 {
3585     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
3586 }
3587
3588 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsConstantBuffer(
3589         ID3D10EffectConstantBuffer *iface)
3590 {
3591     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
3592 }
3593
3594 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShader(
3595         ID3D10EffectConstantBuffer *iface)
3596 {
3597     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
3598 }
3599
3600 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer *iface)
3601 {
3602     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
3603 }
3604
3605 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencil(
3606         ID3D10EffectConstantBuffer *iface)
3607 {
3608     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
3609 }
3610
3611 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRasterizer(
3612         ID3D10EffectConstantBuffer *iface)
3613 {
3614     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
3615 }
3616
3617 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsSampler(
3618         ID3D10EffectConstantBuffer *iface)
3619 {
3620     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
3621 }
3622
3623 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer *iface,
3624         void *data, UINT offset, UINT count)
3625 {
3626     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3627 }
3628
3629 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer *iface,
3630         void *data, UINT offset, UINT count)
3631 {
3632     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3633 }
3634
3635 /* ID3D10EffectConstantBuffer methods */
3636 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer *iface,
3637         ID3D10Buffer *buffer)
3638 {
3639     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
3640
3641     return E_NOTIMPL;
3642 }
3643
3644 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer *iface,
3645         ID3D10Buffer **buffer)
3646 {
3647     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
3648
3649     return E_NOTIMPL;
3650 }
3651
3652 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer *iface,
3653         ID3D10ShaderResourceView *view)
3654 {
3655     FIXME("iface %p, view %p stub!\n", iface, view);
3656
3657     return E_NOTIMPL;
3658 }
3659
3660 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer *iface,
3661         ID3D10ShaderResourceView **view)
3662 {
3663     FIXME("iface %p, view %p stub!\n", iface, view);
3664
3665     return E_NOTIMPL;
3666 }
3667
3668 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl =
3669 {
3670     /* ID3D10EffectVariable methods */
3671     d3d10_effect_constant_buffer_IsValid,
3672     d3d10_effect_constant_buffer_GetType,
3673     d3d10_effect_constant_buffer_GetDesc,
3674     d3d10_effect_constant_buffer_GetAnnotationByIndex,
3675     d3d10_effect_constant_buffer_GetAnnotationByName,
3676     d3d10_effect_constant_buffer_GetMemberByIndex,
3677     d3d10_effect_constant_buffer_GetMemberByName,
3678     d3d10_effect_constant_buffer_GetMemberBySemantic,
3679     d3d10_effect_constant_buffer_GetElement,
3680     d3d10_effect_constant_buffer_GetParentConstantBuffer,
3681     d3d10_effect_constant_buffer_AsScalar,
3682     d3d10_effect_constant_buffer_AsVector,
3683     d3d10_effect_constant_buffer_AsMatrix,
3684     d3d10_effect_constant_buffer_AsString,
3685     d3d10_effect_constant_buffer_AsShaderResource,
3686     d3d10_effect_constant_buffer_AsRenderTargetView,
3687     d3d10_effect_constant_buffer_AsDepthStencilView,
3688     d3d10_effect_constant_buffer_AsConstantBuffer,
3689     d3d10_effect_constant_buffer_AsShader,
3690     d3d10_effect_constant_buffer_AsBlend,
3691     d3d10_effect_constant_buffer_AsDepthStencil,
3692     d3d10_effect_constant_buffer_AsRasterizer,
3693     d3d10_effect_constant_buffer_AsSampler,
3694     d3d10_effect_constant_buffer_SetRawValue,
3695     d3d10_effect_constant_buffer_GetRawValue,
3696     /* ID3D10EffectConstantBuffer methods */
3697     d3d10_effect_constant_buffer_SetConstantBuffer,
3698     d3d10_effect_constant_buffer_GetConstantBuffer,
3699     d3d10_effect_constant_buffer_SetTextureBuffer,
3700     d3d10_effect_constant_buffer_GetTextureBuffer,
3701 };
3702
3703 /* ID3D10EffectVariable methods */
3704
3705 static BOOL STDMETHODCALLTYPE d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable *iface)
3706 {
3707     TRACE("iface %p\n", iface);
3708
3709     return (struct d3d10_effect_variable *)iface != &null_scalar_variable;
3710 }
3711
3712 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetType(
3713         ID3D10EffectScalarVariable *iface)
3714 {
3715     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
3716 }
3717
3718 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetDesc(ID3D10EffectScalarVariable *iface,
3719         D3D10_EFFECT_VARIABLE_DESC *desc)
3720 {
3721     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
3722 }
3723
3724 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByIndex(
3725         ID3D10EffectScalarVariable *iface, UINT index)
3726 {
3727     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
3728 }
3729
3730 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByName(
3731         ID3D10EffectScalarVariable *iface, LPCSTR name)
3732 {
3733     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
3734 }
3735
3736 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByIndex(
3737         ID3D10EffectScalarVariable *iface, UINT index)
3738 {
3739     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
3740 }
3741
3742 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByName(
3743         ID3D10EffectScalarVariable *iface, LPCSTR name)
3744 {
3745     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
3746 }
3747
3748 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberBySemantic(
3749         ID3D10EffectScalarVariable *iface, LPCSTR semantic)
3750 {
3751     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
3752 }
3753
3754 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetElement(
3755         ID3D10EffectScalarVariable *iface, UINT index)
3756 {
3757     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
3758 }
3759
3760 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetParentConstantBuffer(
3761         ID3D10EffectScalarVariable *iface)
3762 {
3763     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
3764 }
3765
3766 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsScalar(
3767         ID3D10EffectScalarVariable *iface)
3768 {
3769     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
3770 }
3771
3772 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsVector(
3773         ID3D10EffectScalarVariable *iface)
3774 {
3775     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
3776 }
3777
3778 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsMatrix(
3779         ID3D10EffectScalarVariable *iface)
3780 {
3781     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
3782 }
3783
3784 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsString(
3785         ID3D10EffectScalarVariable *iface)
3786 {
3787     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
3788 }
3789
3790 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShaderResource(
3791         ID3D10EffectScalarVariable *iface)
3792 {
3793     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
3794 }
3795
3796 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRenderTargetView(
3797         ID3D10EffectScalarVariable *iface)
3798 {
3799     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
3800 }
3801
3802 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencilView(
3803         ID3D10EffectScalarVariable *iface)
3804 {
3805     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
3806 }
3807
3808 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsConstantBuffer(
3809         ID3D10EffectScalarVariable *iface)
3810 {
3811     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
3812 }
3813
3814 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShader(
3815         ID3D10EffectScalarVariable *iface)
3816 {
3817     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
3818 }
3819
3820 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsBlend(
3821         ID3D10EffectScalarVariable *iface)
3822 {
3823     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
3824 }
3825
3826 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencil(
3827         ID3D10EffectScalarVariable *iface)
3828 {
3829     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
3830 }
3831
3832 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRasterizer(
3833         ID3D10EffectScalarVariable *iface)
3834 {
3835     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
3836 }
3837
3838 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsSampler(
3839         ID3D10EffectScalarVariable *iface)
3840 {
3841     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
3842 }
3843
3844 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetRawValue(ID3D10EffectScalarVariable *iface,
3845         void *data, UINT offset, UINT count)
3846 {
3847     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3848 }
3849
3850 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetRawValue(ID3D10EffectScalarVariable *iface,
3851         void *data, UINT offset, UINT count)
3852 {
3853     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3854 }
3855
3856 /* ID3D10EffectScalarVariable methods */
3857
3858 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable *iface,
3859         float value)
3860 {
3861     FIXME("iface %p, value %.8e stub!\n", iface, value);
3862
3863     return E_NOTIMPL;
3864 }
3865
3866 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable *iface,
3867         float *value)
3868 {
3869     FIXME("iface %p, value %p stub!\n", iface, value);
3870
3871     return E_NOTIMPL;
3872 }
3873
3874 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable *iface,
3875         float *values, UINT offset, UINT count)
3876 {
3877     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3878
3879     return E_NOTIMPL;
3880 }
3881
3882 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable *iface,
3883         float *values, UINT offset, UINT count)
3884 {
3885     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3886
3887     return E_NOTIMPL;
3888 }
3889
3890 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable *iface,
3891         int value)
3892 {
3893     FIXME("iface %p, value %d stub!\n", iface, value);
3894
3895     return E_NOTIMPL;
3896 }
3897
3898 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable *iface,
3899         int *value)
3900 {
3901     FIXME("iface %p, value %p stub!\n", iface, value);
3902
3903     return E_NOTIMPL;
3904 }
3905
3906 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable *iface,
3907         int *values, UINT offset, UINT count)
3908 {
3909     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3910
3911     return E_NOTIMPL;
3912 }
3913
3914 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable *iface,
3915         int *values, UINT offset, UINT count)
3916 {
3917     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3918
3919     return E_NOTIMPL;
3920 }
3921
3922 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable *iface,
3923         BOOL value)
3924 {
3925     FIXME("iface %p, value %d stub!\n", iface, value);
3926
3927     return E_NOTIMPL;
3928 }
3929
3930 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable *iface,
3931         BOOL *value)
3932 {
3933     FIXME("iface %p, value %p stub!\n", iface, value);
3934
3935     return E_NOTIMPL;
3936 }
3937
3938 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable *iface,
3939         BOOL *values, UINT offset, UINT count)
3940 {
3941     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3942
3943     return E_NOTIMPL;
3944 }
3945
3946 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable *iface,
3947         BOOL *values, UINT offset, UINT count)
3948 {
3949     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3950
3951     return E_NOTIMPL;
3952 }
3953
3954 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl =
3955 {
3956     /* ID3D10EffectVariable methods */
3957     d3d10_effect_scalar_variable_IsValid,
3958     d3d10_effect_scalar_variable_GetType,
3959     d3d10_effect_scalar_variable_GetDesc,
3960     d3d10_effect_scalar_variable_GetAnnotationByIndex,
3961     d3d10_effect_scalar_variable_GetAnnotationByName,
3962     d3d10_effect_scalar_variable_GetMemberByIndex,
3963     d3d10_effect_scalar_variable_GetMemberByName,
3964     d3d10_effect_scalar_variable_GetMemberBySemantic,
3965     d3d10_effect_scalar_variable_GetElement,
3966     d3d10_effect_scalar_variable_GetParentConstantBuffer,
3967     d3d10_effect_scalar_variable_AsScalar,
3968     d3d10_effect_scalar_variable_AsVector,
3969     d3d10_effect_scalar_variable_AsMatrix,
3970     d3d10_effect_scalar_variable_AsString,
3971     d3d10_effect_scalar_variable_AsShaderResource,
3972     d3d10_effect_scalar_variable_AsRenderTargetView,
3973     d3d10_effect_scalar_variable_AsDepthStencilView,
3974     d3d10_effect_scalar_variable_AsConstantBuffer,
3975     d3d10_effect_scalar_variable_AsShader,
3976     d3d10_effect_scalar_variable_AsBlend,
3977     d3d10_effect_scalar_variable_AsDepthStencil,
3978     d3d10_effect_scalar_variable_AsRasterizer,
3979     d3d10_effect_scalar_variable_AsSampler,
3980     d3d10_effect_scalar_variable_SetRawValue,
3981     d3d10_effect_scalar_variable_GetRawValue,
3982     /* ID3D10EffectScalarVariable methods */
3983     d3d10_effect_scalar_variable_SetFloat,
3984     d3d10_effect_scalar_variable_GetFloat,
3985     d3d10_effect_scalar_variable_SetFloatArray,
3986     d3d10_effect_scalar_variable_GetFloatArray,
3987     d3d10_effect_scalar_variable_SetInt,
3988     d3d10_effect_scalar_variable_GetInt,
3989     d3d10_effect_scalar_variable_SetIntArray,
3990     d3d10_effect_scalar_variable_GetIntArray,
3991     d3d10_effect_scalar_variable_SetBool,
3992     d3d10_effect_scalar_variable_GetBool,
3993     d3d10_effect_scalar_variable_SetBoolArray,
3994     d3d10_effect_scalar_variable_GetBoolArray,
3995 };
3996
3997 /* ID3D10EffectVariable methods */
3998
3999 static BOOL STDMETHODCALLTYPE d3d10_effect_vector_variable_IsValid(ID3D10EffectVectorVariable *iface)
4000 {
4001     TRACE("iface %p\n", iface);
4002
4003     return (struct d3d10_effect_variable *)iface != &null_vector_variable;
4004 }
4005
4006 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetType(
4007         ID3D10EffectVectorVariable *iface)
4008 {
4009     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4010 }
4011
4012 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetDesc(ID3D10EffectVectorVariable *iface,
4013         D3D10_EFFECT_VARIABLE_DESC *desc)
4014 {
4015     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4016 }
4017
4018 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByIndex(
4019         ID3D10EffectVectorVariable *iface, UINT index)
4020 {
4021     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4022 }
4023
4024 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByName(
4025         ID3D10EffectVectorVariable *iface, LPCSTR name)
4026 {
4027     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4028 }
4029
4030 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByIndex(
4031         ID3D10EffectVectorVariable *iface, UINT index)
4032 {
4033     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4034 }
4035
4036 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByName(
4037         ID3D10EffectVectorVariable *iface, LPCSTR name)
4038 {
4039     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4040 }
4041
4042 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberBySemantic(
4043         ID3D10EffectVectorVariable *iface, LPCSTR semantic)
4044 {
4045     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4046 }
4047
4048 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetElement(
4049         ID3D10EffectVectorVariable *iface, UINT index)
4050 {
4051     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4052 }
4053
4054 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetParentConstantBuffer(
4055         ID3D10EffectVectorVariable *iface)
4056 {
4057     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4058 }
4059
4060 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsScalar(
4061         ID3D10EffectVectorVariable *iface)
4062 {
4063     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4064 }
4065
4066 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsVector(
4067         ID3D10EffectVectorVariable *iface)
4068 {
4069     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4070 }
4071
4072 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsMatrix(
4073         ID3D10EffectVectorVariable *iface)
4074 {
4075     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4076 }
4077
4078 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsString(
4079         ID3D10EffectVectorVariable *iface)
4080 {
4081     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4082 }
4083
4084 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShaderResource(
4085         ID3D10EffectVectorVariable *iface)
4086 {
4087     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4088 }
4089
4090 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRenderTargetView(
4091         ID3D10EffectVectorVariable *iface)
4092 {
4093     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4094 }
4095
4096 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencilView(
4097         ID3D10EffectVectorVariable *iface)
4098 {
4099     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4100 }
4101
4102 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsConstantBuffer(
4103         ID3D10EffectVectorVariable *iface)
4104 {
4105     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4106 }
4107
4108 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShader(
4109         ID3D10EffectVectorVariable *iface)
4110 {
4111     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4112 }
4113
4114 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsBlend(
4115         ID3D10EffectVectorVariable *iface)
4116 {
4117     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4118 }
4119
4120 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencil(
4121         ID3D10EffectVectorVariable *iface)
4122 {
4123     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4124 }
4125
4126 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRasterizer(
4127         ID3D10EffectVectorVariable *iface)
4128 {
4129     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4130 }
4131
4132 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsSampler(
4133         ID3D10EffectVectorVariable *iface)
4134 {
4135     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4136 }
4137
4138 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetRawValue(ID3D10EffectVectorVariable *iface,
4139         void *data, UINT offset, UINT count)
4140 {
4141     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4142 }
4143
4144 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetRawValue(ID3D10EffectVectorVariable *iface,
4145         void *data, UINT offset, UINT count)
4146 {
4147     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4148 }
4149
4150 /* ID3D10EffectVectorVariable methods */
4151
4152 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVector(ID3D10EffectVectorVariable *iface,
4153         BOOL *value)
4154 {
4155     FIXME("iface %p, value %p stub!\n", iface, value);
4156
4157     return E_NOTIMPL;
4158 }
4159
4160 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVector(ID3D10EffectVectorVariable *iface,
4161         int *value)
4162 {
4163     FIXME("iface %p, value %p stub!\n", iface, value);
4164
4165     return E_NOTIMPL;
4166 }
4167
4168 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVector(ID3D10EffectVectorVariable *iface,
4169         float *value)
4170 {
4171     FIXME("iface %p, value %p stub!\n", iface, value);
4172
4173     return E_NOTIMPL;
4174 }
4175
4176 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVector(ID3D10EffectVectorVariable *iface,
4177         BOOL *value)
4178 {
4179     FIXME("iface %p, value %p stub!\n", iface, value);
4180
4181     return E_NOTIMPL;
4182 }
4183
4184 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVector(ID3D10EffectVectorVariable *iface,
4185         int *value)
4186 {
4187     FIXME("iface %p, value %p stub!\n", iface, value);
4188
4189     return E_NOTIMPL;
4190 }
4191
4192 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVector(ID3D10EffectVectorVariable *iface,
4193         float *value)
4194 {
4195     FIXME("iface %p, value %p stub!\n", iface, value);
4196
4197     return E_NOTIMPL;
4198 }
4199
4200 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVectorArray(ID3D10EffectVectorVariable *iface,
4201         BOOL *values, UINT offset, UINT count)
4202 {
4203     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4204
4205     return E_NOTIMPL;
4206 }
4207
4208 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVectorArray(ID3D10EffectVectorVariable *iface,
4209         int *values, UINT offset, UINT count)
4210 {
4211     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4212
4213     return E_NOTIMPL;
4214 }
4215
4216 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVectorArray(ID3D10EffectVectorVariable *iface,
4217         float *values, UINT offset, UINT count)
4218 {
4219     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4220
4221     return E_NOTIMPL;
4222 }
4223
4224 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVectorArray(ID3D10EffectVectorVariable *iface,
4225         BOOL *values, UINT offset, UINT count)
4226 {
4227     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4228
4229     return E_NOTIMPL;
4230 }
4231
4232 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVectorArray(ID3D10EffectVectorVariable *iface,
4233         int *values, UINT offset, UINT count)
4234 {
4235     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4236
4237     return E_NOTIMPL;
4238 }
4239
4240 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVectorArray(ID3D10EffectVectorVariable *iface,
4241         float *values, UINT offset, UINT count)
4242 {
4243     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4244
4245     return E_NOTIMPL;
4246 }
4247
4248 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl =
4249 {
4250     /* ID3D10EffectVariable methods */
4251     d3d10_effect_vector_variable_IsValid,
4252     d3d10_effect_vector_variable_GetType,
4253     d3d10_effect_vector_variable_GetDesc,
4254     d3d10_effect_vector_variable_GetAnnotationByIndex,
4255     d3d10_effect_vector_variable_GetAnnotationByName,
4256     d3d10_effect_vector_variable_GetMemberByIndex,
4257     d3d10_effect_vector_variable_GetMemberByName,
4258     d3d10_effect_vector_variable_GetMemberBySemantic,
4259     d3d10_effect_vector_variable_GetElement,
4260     d3d10_effect_vector_variable_GetParentConstantBuffer,
4261     d3d10_effect_vector_variable_AsScalar,
4262     d3d10_effect_vector_variable_AsVector,
4263     d3d10_effect_vector_variable_AsMatrix,
4264     d3d10_effect_vector_variable_AsString,
4265     d3d10_effect_vector_variable_AsShaderResource,
4266     d3d10_effect_vector_variable_AsRenderTargetView,
4267     d3d10_effect_vector_variable_AsDepthStencilView,
4268     d3d10_effect_vector_variable_AsConstantBuffer,
4269     d3d10_effect_vector_variable_AsShader,
4270     d3d10_effect_vector_variable_AsBlend,
4271     d3d10_effect_vector_variable_AsDepthStencil,
4272     d3d10_effect_vector_variable_AsRasterizer,
4273     d3d10_effect_vector_variable_AsSampler,
4274     d3d10_effect_vector_variable_SetRawValue,
4275     d3d10_effect_vector_variable_GetRawValue,
4276     /* ID3D10EffectVectorVariable methods */
4277     d3d10_effect_vector_variable_SetBoolVector,
4278     d3d10_effect_vector_variable_SetIntVector,
4279     d3d10_effect_vector_variable_SetFloatVector,
4280     d3d10_effect_vector_variable_GetBoolVector,
4281     d3d10_effect_vector_variable_GetIntVector,
4282     d3d10_effect_vector_variable_GetFloatVector,
4283     d3d10_effect_vector_variable_SetBoolVectorArray,
4284     d3d10_effect_vector_variable_SetIntVectorArray,
4285     d3d10_effect_vector_variable_SetFloatVectorArray,
4286     d3d10_effect_vector_variable_GetBoolVectorArray,
4287     d3d10_effect_vector_variable_GetIntVectorArray,
4288     d3d10_effect_vector_variable_GetFloatVectorArray,
4289 };
4290
4291 /* ID3D10EffectVariable methods */
4292
4293 static BOOL STDMETHODCALLTYPE d3d10_effect_matrix_variable_IsValid(ID3D10EffectMatrixVariable *iface)
4294 {
4295     TRACE("iface %p\n", iface);
4296
4297     return (struct d3d10_effect_variable *)iface != &null_matrix_variable;
4298 }
4299
4300 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetType(
4301         ID3D10EffectMatrixVariable *iface)
4302 {
4303     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4304 }
4305
4306 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetDesc(ID3D10EffectMatrixVariable *iface,
4307         D3D10_EFFECT_VARIABLE_DESC *desc)
4308 {
4309     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4310 }
4311
4312 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByIndex(
4313         ID3D10EffectMatrixVariable *iface, UINT index)
4314 {
4315     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4316 }
4317
4318 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByName(
4319         ID3D10EffectMatrixVariable *iface, LPCSTR name)
4320 {
4321     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4322 }
4323
4324 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByIndex(
4325         ID3D10EffectMatrixVariable *iface, UINT index)
4326 {
4327     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4328 }
4329
4330 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByName(
4331         ID3D10EffectMatrixVariable *iface, LPCSTR name)
4332 {
4333     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4334 }
4335
4336 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberBySemantic(
4337         ID3D10EffectMatrixVariable *iface, LPCSTR semantic)
4338 {
4339     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4340 }
4341
4342 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetElement(
4343         ID3D10EffectMatrixVariable *iface, UINT index)
4344 {
4345     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4346 }
4347
4348 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetParentConstantBuffer(
4349         ID3D10EffectMatrixVariable *iface)
4350 {
4351     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4352 }
4353
4354 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsScalar(
4355         ID3D10EffectMatrixVariable *iface)
4356 {
4357     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4358 }
4359
4360 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsVector(
4361         ID3D10EffectMatrixVariable *iface)
4362 {
4363     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4364 }
4365
4366 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsMatrix(
4367         ID3D10EffectMatrixVariable *iface)
4368 {
4369     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4370 }
4371
4372 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsString(
4373         ID3D10EffectMatrixVariable *iface)
4374 {
4375     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4376 }
4377
4378 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShaderResource(
4379         ID3D10EffectMatrixVariable *iface)
4380 {
4381     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4382 }
4383
4384 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRenderTargetView(
4385         ID3D10EffectMatrixVariable *iface)
4386 {
4387     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4388 }
4389
4390 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencilView(
4391         ID3D10EffectMatrixVariable *iface)
4392 {
4393     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4394 }
4395
4396 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsConstantBuffer(
4397         ID3D10EffectMatrixVariable *iface)
4398 {
4399     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4400 }
4401
4402 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShader(
4403         ID3D10EffectMatrixVariable *iface)
4404 {
4405     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4406 }
4407
4408 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsBlend(
4409         ID3D10EffectMatrixVariable *iface)
4410 {
4411     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4412 }
4413
4414 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencil(
4415         ID3D10EffectMatrixVariable *iface)
4416 {
4417     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4418 }
4419
4420 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRasterizer(
4421         ID3D10EffectMatrixVariable *iface)
4422 {
4423     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4424 }
4425
4426 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsSampler(
4427         ID3D10EffectMatrixVariable *iface)
4428 {
4429     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4430 }
4431
4432 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetRawValue(ID3D10EffectMatrixVariable *iface,
4433         void *data, UINT offset, UINT count)
4434 {
4435     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4436 }
4437
4438 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetRawValue(ID3D10EffectMatrixVariable *iface,
4439         void *data, UINT offset, UINT count)
4440 {
4441     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4442 }
4443
4444 /* ID3D10EffectMatrixVariable methods */
4445
4446 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrix(ID3D10EffectMatrixVariable *iface,
4447         float *data)
4448 {
4449     FIXME("iface %p, data %p stub!\n", iface, data);
4450
4451     return E_NOTIMPL;
4452 }
4453
4454 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrix(ID3D10EffectMatrixVariable *iface,
4455         float *data)
4456 {
4457     FIXME("iface %p, data %p stub!\n", iface, data);
4458
4459     return E_NOTIMPL;
4460 }
4461
4462 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixArray(ID3D10EffectMatrixVariable *iface,
4463         float *data, UINT offset, UINT count)
4464 {
4465     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4466
4467     return E_NOTIMPL;
4468 }
4469
4470 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixArray(ID3D10EffectMatrixVariable *iface,
4471         float *data, UINT offset, UINT count)
4472 {
4473     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4474
4475     return E_NOTIMPL;
4476 }
4477
4478 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
4479         float *data)
4480 {
4481     FIXME("iface %p, data %p stub!\n", iface, data);
4482
4483     return E_NOTIMPL;
4484 }
4485
4486 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
4487         float *data)
4488 {
4489     FIXME("iface %p, data %p stub!\n", iface, data);
4490
4491     return E_NOTIMPL;
4492 }
4493
4494 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
4495         float *data, UINT offset, UINT count)
4496 {
4497     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4498
4499     return E_NOTIMPL;
4500 }
4501
4502 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
4503         float *data, UINT offset, UINT count)
4504 {
4505     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4506
4507     return E_NOTIMPL;
4508 }
4509
4510
4511 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl =
4512 {
4513     /* ID3D10EffectVariable methods */
4514     d3d10_effect_matrix_variable_IsValid,
4515     d3d10_effect_matrix_variable_GetType,
4516     d3d10_effect_matrix_variable_GetDesc,
4517     d3d10_effect_matrix_variable_GetAnnotationByIndex,
4518     d3d10_effect_matrix_variable_GetAnnotationByName,
4519     d3d10_effect_matrix_variable_GetMemberByIndex,
4520     d3d10_effect_matrix_variable_GetMemberByName,
4521     d3d10_effect_matrix_variable_GetMemberBySemantic,
4522     d3d10_effect_matrix_variable_GetElement,
4523     d3d10_effect_matrix_variable_GetParentConstantBuffer,
4524     d3d10_effect_matrix_variable_AsScalar,
4525     d3d10_effect_matrix_variable_AsVector,
4526     d3d10_effect_matrix_variable_AsMatrix,
4527     d3d10_effect_matrix_variable_AsString,
4528     d3d10_effect_matrix_variable_AsShaderResource,
4529     d3d10_effect_matrix_variable_AsRenderTargetView,
4530     d3d10_effect_matrix_variable_AsDepthStencilView,
4531     d3d10_effect_matrix_variable_AsConstantBuffer,
4532     d3d10_effect_matrix_variable_AsShader,
4533     d3d10_effect_matrix_variable_AsBlend,
4534     d3d10_effect_matrix_variable_AsDepthStencil,
4535     d3d10_effect_matrix_variable_AsRasterizer,
4536     d3d10_effect_matrix_variable_AsSampler,
4537     d3d10_effect_matrix_variable_SetRawValue,
4538     d3d10_effect_matrix_variable_GetRawValue,
4539     /* ID3D10EffectMatrixVariable methods */
4540     d3d10_effect_matrix_variable_SetMatrix,
4541     d3d10_effect_matrix_variable_GetMatrix,
4542     d3d10_effect_matrix_variable_SetMatrixArray,
4543     d3d10_effect_matrix_variable_GetMatrixArray,
4544     d3d10_effect_matrix_variable_SetMatrixTranspose,
4545     d3d10_effect_matrix_variable_GetMatrixTranspose,
4546     d3d10_effect_matrix_variable_SetMatrixTransposeArray,
4547     d3d10_effect_matrix_variable_GetMatrixTransposeArray,
4548 };
4549
4550 /* ID3D10EffectVariable methods */
4551
4552 static BOOL STDMETHODCALLTYPE d3d10_effect_string_variable_IsValid(ID3D10EffectStringVariable *iface)
4553 {
4554     TRACE("iface %p\n", iface);
4555
4556     return (struct d3d10_effect_variable *)iface != &null_string_variable;
4557 }
4558
4559 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_string_variable_GetType(
4560         ID3D10EffectStringVariable *iface)
4561 {
4562     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4563 }
4564
4565 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetDesc(ID3D10EffectStringVariable *iface,
4566         D3D10_EFFECT_VARIABLE_DESC *desc)
4567 {
4568     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4569 }
4570
4571 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetAnnotationByIndex(
4572         ID3D10EffectStringVariable *iface, UINT index)
4573 {
4574     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4575 }
4576
4577 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetAnnotationByName(
4578         ID3D10EffectStringVariable *iface, LPCSTR name)
4579 {
4580     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4581 }
4582
4583 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberByIndex(
4584         ID3D10EffectStringVariable *iface, UINT index)
4585 {
4586     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4587 }
4588
4589 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberByName(
4590         ID3D10EffectStringVariable *iface, LPCSTR name)
4591 {
4592     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4593 }
4594
4595 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberBySemantic(
4596         ID3D10EffectStringVariable *iface, LPCSTR semantic)
4597 {
4598     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4599 }
4600
4601 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetElement(
4602         ID3D10EffectStringVariable *iface, UINT index)
4603 {
4604     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4605 }
4606
4607 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_string_variable_GetParentConstantBuffer(
4608         ID3D10EffectStringVariable *iface)
4609 {
4610     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4611 }
4612
4613 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsScalar(
4614         ID3D10EffectStringVariable *iface)
4615 {
4616     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4617 }
4618
4619 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsVector(
4620         ID3D10EffectStringVariable *iface)
4621 {
4622     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4623 }
4624
4625 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsMatrix(
4626         ID3D10EffectStringVariable *iface)
4627 {
4628     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4629 }
4630
4631 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsString(
4632         ID3D10EffectStringVariable *iface)
4633 {
4634     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4635 }
4636
4637 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsShaderResource(
4638         ID3D10EffectStringVariable *iface)
4639 {
4640     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4641 }
4642
4643 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsRenderTargetView(
4644         ID3D10EffectStringVariable *iface)
4645 {
4646     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4647 }
4648
4649 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsDepthStencilView(
4650         ID3D10EffectStringVariable *iface)
4651 {
4652     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4653 }
4654
4655 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_string_variable_AsConstantBuffer(
4656         ID3D10EffectStringVariable *iface)
4657 {
4658     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4659 }
4660
4661 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsShader(
4662         ID3D10EffectStringVariable *iface)
4663 {
4664     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4665 }
4666
4667 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsBlend(
4668         ID3D10EffectStringVariable *iface)
4669 {
4670     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4671 }
4672
4673 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsDepthStencil(
4674         ID3D10EffectStringVariable *iface)
4675 {
4676     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4677 }
4678
4679 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsRasterizer(
4680         ID3D10EffectStringVariable *iface)
4681 {
4682     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4683 }
4684
4685 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsSampler(
4686         ID3D10EffectStringVariable *iface)
4687 {
4688     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4689 }
4690
4691 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_SetRawValue(ID3D10EffectStringVariable *iface,
4692         void *data, UINT offset, UINT count)
4693 {
4694     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4695 }
4696
4697 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetRawValue(ID3D10EffectStringVariable *iface,
4698         void *data, UINT offset, UINT count)
4699 {
4700     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4701 }
4702
4703 /* ID3D10EffectStringVariable methods */
4704
4705 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetString(ID3D10EffectStringVariable *iface,
4706         LPCSTR *str)
4707 {
4708     FIXME("iface %p, str %p stub!\n", iface, str);
4709
4710     return E_NOTIMPL;
4711 }
4712
4713 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetStringArray(ID3D10EffectStringVariable *iface,
4714         LPCSTR *strs, UINT offset, UINT count)
4715 {
4716     FIXME("iface %p, strs %p, offset %u, count %u stub!\n", iface, strs, offset, count);
4717
4718     return E_NOTIMPL;
4719 }
4720
4721
4722 static const struct ID3D10EffectStringVariableVtbl d3d10_effect_string_variable_vtbl =
4723 {
4724     /* ID3D10EffectVariable methods */
4725     d3d10_effect_string_variable_IsValid,
4726     d3d10_effect_string_variable_GetType,
4727     d3d10_effect_string_variable_GetDesc,
4728     d3d10_effect_string_variable_GetAnnotationByIndex,
4729     d3d10_effect_string_variable_GetAnnotationByName,
4730     d3d10_effect_string_variable_GetMemberByIndex,
4731     d3d10_effect_string_variable_GetMemberByName,
4732     d3d10_effect_string_variable_GetMemberBySemantic,
4733     d3d10_effect_string_variable_GetElement,
4734     d3d10_effect_string_variable_GetParentConstantBuffer,
4735     d3d10_effect_string_variable_AsScalar,
4736     d3d10_effect_string_variable_AsVector,
4737     d3d10_effect_string_variable_AsMatrix,
4738     d3d10_effect_string_variable_AsString,
4739     d3d10_effect_string_variable_AsShaderResource,
4740     d3d10_effect_string_variable_AsRenderTargetView,
4741     d3d10_effect_string_variable_AsDepthStencilView,
4742     d3d10_effect_string_variable_AsConstantBuffer,
4743     d3d10_effect_string_variable_AsShader,
4744     d3d10_effect_string_variable_AsBlend,
4745     d3d10_effect_string_variable_AsDepthStencil,
4746     d3d10_effect_string_variable_AsRasterizer,
4747     d3d10_effect_string_variable_AsSampler,
4748     d3d10_effect_string_variable_SetRawValue,
4749     d3d10_effect_string_variable_GetRawValue,
4750     /* ID3D10EffectStringVariable methods */
4751     d3d10_effect_string_variable_GetString,
4752     d3d10_effect_string_variable_GetStringArray,
4753 };
4754
4755 /* ID3D10EffectVariable methods */
4756
4757 static BOOL STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_IsValid(ID3D10EffectShaderResourceVariable *iface)
4758 {
4759     TRACE("iface %p\n", iface);
4760
4761     return (struct d3d10_effect_variable *)iface != &null_shader_resource_variable;
4762 }
4763
4764 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetType(
4765         ID3D10EffectShaderResourceVariable *iface)
4766 {
4767     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4768 }
4769
4770 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetDesc(
4771         ID3D10EffectShaderResourceVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
4772 {
4773     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4774 }
4775
4776 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetAnnotationByIndex(
4777         ID3D10EffectShaderResourceVariable *iface, UINT index)
4778 {
4779     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4780 }
4781
4782 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetAnnotationByName(
4783         ID3D10EffectShaderResourceVariable *iface, LPCSTR name)
4784 {
4785     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4786 }
4787
4788 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberByIndex(
4789         ID3D10EffectShaderResourceVariable *iface, UINT index)
4790 {
4791     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4792 }
4793
4794 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberByName(
4795         ID3D10EffectShaderResourceVariable *iface, LPCSTR name)
4796 {
4797     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4798 }
4799
4800 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberBySemantic(
4801         ID3D10EffectShaderResourceVariable *iface, LPCSTR semantic)
4802 {
4803     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4804 }
4805
4806 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetElement(
4807         ID3D10EffectShaderResourceVariable *iface, UINT index)
4808 {
4809     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4810 }
4811
4812 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetParentConstantBuffer(
4813         ID3D10EffectShaderResourceVariable *iface)
4814 {
4815     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4816 }
4817
4818 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsScalar(
4819         ID3D10EffectShaderResourceVariable *iface)
4820 {
4821     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4822 }
4823
4824 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsVector(
4825         ID3D10EffectShaderResourceVariable *iface)
4826 {
4827     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4828 }
4829
4830 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsMatrix(
4831         ID3D10EffectShaderResourceVariable *iface)
4832 {
4833     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4834 }
4835
4836 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsString(
4837         ID3D10EffectShaderResourceVariable *iface)
4838 {
4839     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4840 }
4841
4842 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsShaderResource(
4843         ID3D10EffectShaderResourceVariable *iface)
4844 {
4845     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4846 }
4847
4848 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsRenderTargetView(
4849         ID3D10EffectShaderResourceVariable *iface)
4850 {
4851     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4852 }
4853
4854 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsDepthStencilView(
4855         ID3D10EffectShaderResourceVariable *iface)
4856 {
4857     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4858 }
4859
4860 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsConstantBuffer(
4861         ID3D10EffectShaderResourceVariable *iface)
4862 {
4863     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4864 }
4865
4866 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsShader(
4867         ID3D10EffectShaderResourceVariable *iface)
4868 {
4869     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4870 }
4871
4872 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsBlend(
4873         ID3D10EffectShaderResourceVariable *iface)
4874 {
4875     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4876 }
4877
4878 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsDepthStencil(
4879         ID3D10EffectShaderResourceVariable *iface)
4880 {
4881     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4882 }
4883
4884 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsRasterizer(
4885         ID3D10EffectShaderResourceVariable *iface)
4886 {
4887     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4888 }
4889
4890 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsSampler(
4891         ID3D10EffectShaderResourceVariable *iface)
4892 {
4893     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4894 }
4895
4896 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetRawValue(
4897         ID3D10EffectShaderResourceVariable *iface, void *data, UINT offset, UINT count)
4898 {
4899     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4900 }
4901
4902 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetRawValue(
4903         ID3D10EffectShaderResourceVariable *iface, void *data, UINT offset, UINT count)
4904 {
4905     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4906 }
4907
4908 /* ID3D10EffectShaderResourceVariable methods */
4909
4910 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetResource(
4911         ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView *resource)
4912 {
4913     FIXME("iface %p, resource %p stub!\n", iface, resource);
4914
4915     return E_NOTIMPL;
4916 }
4917
4918 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetResource(
4919         ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resource)
4920 {
4921     FIXME("iface %p, resource %p stub!\n", iface, resource);
4922
4923     return E_NOTIMPL;
4924 }
4925
4926 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetResourceArray(
4927         ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resources, UINT offset, UINT count)
4928 {
4929     FIXME("iface %p, resources %p, offset %u, count %u stub!\n", iface, resources, offset, count);
4930
4931     return E_NOTIMPL;
4932 }
4933
4934 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetResourceArray(
4935         ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resources, UINT offset, UINT count)
4936 {
4937     FIXME("iface %p, resources %p, offset %u, count %u stub!\n", iface, resources, offset, count);
4938
4939     return E_NOTIMPL;
4940 }
4941
4942
4943 static const struct ID3D10EffectShaderResourceVariableVtbl d3d10_effect_shader_resource_variable_vtbl =
4944 {
4945     /* ID3D10EffectVariable methods */
4946     d3d10_effect_shader_resource_variable_IsValid,
4947     d3d10_effect_shader_resource_variable_GetType,
4948     d3d10_effect_shader_resource_variable_GetDesc,
4949     d3d10_effect_shader_resource_variable_GetAnnotationByIndex,
4950     d3d10_effect_shader_resource_variable_GetAnnotationByName,
4951     d3d10_effect_shader_resource_variable_GetMemberByIndex,
4952     d3d10_effect_shader_resource_variable_GetMemberByName,
4953     d3d10_effect_shader_resource_variable_GetMemberBySemantic,
4954     d3d10_effect_shader_resource_variable_GetElement,
4955     d3d10_effect_shader_resource_variable_GetParentConstantBuffer,
4956     d3d10_effect_shader_resource_variable_AsScalar,
4957     d3d10_effect_shader_resource_variable_AsVector,
4958     d3d10_effect_shader_resource_variable_AsMatrix,
4959     d3d10_effect_shader_resource_variable_AsString,
4960     d3d10_effect_shader_resource_variable_AsShaderResource,
4961     d3d10_effect_shader_resource_variable_AsRenderTargetView,
4962     d3d10_effect_shader_resource_variable_AsDepthStencilView,
4963     d3d10_effect_shader_resource_variable_AsConstantBuffer,
4964     d3d10_effect_shader_resource_variable_AsShader,
4965     d3d10_effect_shader_resource_variable_AsBlend,
4966     d3d10_effect_shader_resource_variable_AsDepthStencil,
4967     d3d10_effect_shader_resource_variable_AsRasterizer,
4968     d3d10_effect_shader_resource_variable_AsSampler,
4969     d3d10_effect_shader_resource_variable_SetRawValue,
4970     d3d10_effect_shader_resource_variable_GetRawValue,
4971     /* ID3D10EffectShaderResourceVariable methods */
4972     d3d10_effect_shader_resource_variable_SetResource,
4973     d3d10_effect_shader_resource_variable_GetResource,
4974     d3d10_effect_shader_resource_variable_SetResourceArray,
4975     d3d10_effect_shader_resource_variable_GetResourceArray,
4976 };
4977
4978 /* ID3D10EffectVariable methods */
4979
4980 static BOOL STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_IsValid(
4981         ID3D10EffectRenderTargetViewVariable *iface)
4982 {
4983     TRACE("iface %p\n", iface);
4984
4985     return (struct d3d10_effect_variable *)iface != &null_render_target_view_variable;
4986 }
4987
4988 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetType(
4989         ID3D10EffectRenderTargetViewVariable *iface)
4990 {
4991     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4992 }
4993
4994 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetDesc(
4995         ID3D10EffectRenderTargetViewVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
4996 {
4997     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4998 }
4999
5000 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetAnnotationByIndex(
5001         ID3D10EffectRenderTargetViewVariable *iface, UINT index)
5002 {
5003     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5004 }
5005
5006 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetAnnotationByName(
5007         ID3D10EffectRenderTargetViewVariable *iface, LPCSTR name)
5008 {
5009     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5010 }
5011
5012 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberByIndex(
5013         ID3D10EffectRenderTargetViewVariable *iface, UINT index)
5014 {
5015     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5016 }
5017
5018 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberByName(
5019         ID3D10EffectRenderTargetViewVariable *iface, LPCSTR name)
5020 {
5021     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5022 }
5023
5024 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberBySemantic(
5025         ID3D10EffectRenderTargetViewVariable *iface, LPCSTR semantic)
5026 {
5027     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5028 }
5029
5030 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetElement(
5031         ID3D10EffectRenderTargetViewVariable *iface, UINT index)
5032 {
5033     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5034 }
5035
5036 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetParentConstantBuffer(
5037         ID3D10EffectRenderTargetViewVariable *iface)
5038 {
5039     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5040 }
5041
5042 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsScalar(
5043         ID3D10EffectRenderTargetViewVariable *iface)
5044 {
5045     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5046 }
5047
5048 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsVector(
5049         ID3D10EffectRenderTargetViewVariable *iface)
5050 {
5051     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5052 }
5053
5054 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsMatrix(
5055         ID3D10EffectRenderTargetViewVariable *iface)
5056 {
5057     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5058 }
5059
5060 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsString(
5061         ID3D10EffectRenderTargetViewVariable *iface)
5062 {
5063     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5064 }
5065
5066 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsShaderResource(
5067         ID3D10EffectRenderTargetViewVariable *iface)
5068 {
5069     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5070 }
5071
5072 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsRenderTargetView(
5073         ID3D10EffectRenderTargetViewVariable *iface)
5074 {
5075     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5076 }
5077
5078 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsDepthStencilView(
5079         ID3D10EffectRenderTargetViewVariable *iface)
5080 {
5081     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5082 }
5083
5084 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsConstantBuffer(
5085         ID3D10EffectRenderTargetViewVariable *iface)
5086 {
5087     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5088 }
5089
5090 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsShader(
5091         ID3D10EffectRenderTargetViewVariable *iface)
5092 {
5093     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5094 }
5095
5096 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsBlend(
5097         ID3D10EffectRenderTargetViewVariable *iface)
5098 {
5099     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5100 }
5101
5102 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsDepthStencil(
5103         ID3D10EffectRenderTargetViewVariable *iface)
5104 {
5105     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5106 }
5107
5108 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsRasterizer(
5109         ID3D10EffectRenderTargetViewVariable *iface)
5110 {
5111     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5112 }
5113
5114 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsSampler(
5115         ID3D10EffectRenderTargetViewVariable *iface)
5116 {
5117     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5118 }
5119
5120 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRawValue(
5121         ID3D10EffectRenderTargetViewVariable *iface, void *data, UINT offset, UINT count)
5122 {
5123     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5124 }
5125
5126 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRawValue(
5127         ID3D10EffectRenderTargetViewVariable *iface, void *data, UINT offset, UINT count)
5128 {
5129     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5130 }
5131
5132 /* ID3D10EffectRenderTargetViewVariable methods */
5133
5134 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRenderTarget(
5135         ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView *view)
5136 {
5137     FIXME("iface %p, view %p stub!\n", iface, view);
5138
5139     return E_NOTIMPL;
5140 }
5141
5142 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRenderTarget(
5143         ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **view)
5144 {
5145     FIXME("iface %p, view %p stub!\n", iface, view);
5146
5147     return E_NOTIMPL;
5148 }
5149
5150 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRenderTargetArray(
5151         ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **views, UINT offset, UINT count)
5152 {
5153     FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5154
5155     return E_NOTIMPL;
5156 }
5157
5158 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRenderTargetArray(
5159         ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **views, UINT offset, UINT count)
5160 {
5161     FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5162
5163     return E_NOTIMPL;
5164 }
5165
5166
5167 static const struct ID3D10EffectRenderTargetViewVariableVtbl d3d10_effect_render_target_view_variable_vtbl =
5168 {
5169     /* ID3D10EffectVariable methods */
5170     d3d10_effect_render_target_view_variable_IsValid,
5171     d3d10_effect_render_target_view_variable_GetType,
5172     d3d10_effect_render_target_view_variable_GetDesc,
5173     d3d10_effect_render_target_view_variable_GetAnnotationByIndex,
5174     d3d10_effect_render_target_view_variable_GetAnnotationByName,
5175     d3d10_effect_render_target_view_variable_GetMemberByIndex,
5176     d3d10_effect_render_target_view_variable_GetMemberByName,
5177     d3d10_effect_render_target_view_variable_GetMemberBySemantic,
5178     d3d10_effect_render_target_view_variable_GetElement,
5179     d3d10_effect_render_target_view_variable_GetParentConstantBuffer,
5180     d3d10_effect_render_target_view_variable_AsScalar,
5181     d3d10_effect_render_target_view_variable_AsVector,
5182     d3d10_effect_render_target_view_variable_AsMatrix,
5183     d3d10_effect_render_target_view_variable_AsString,
5184     d3d10_effect_render_target_view_variable_AsShaderResource,
5185     d3d10_effect_render_target_view_variable_AsRenderTargetView,
5186     d3d10_effect_render_target_view_variable_AsDepthStencilView,
5187     d3d10_effect_render_target_view_variable_AsConstantBuffer,
5188     d3d10_effect_render_target_view_variable_AsShader,
5189     d3d10_effect_render_target_view_variable_AsBlend,
5190     d3d10_effect_render_target_view_variable_AsDepthStencil,
5191     d3d10_effect_render_target_view_variable_AsRasterizer,
5192     d3d10_effect_render_target_view_variable_AsSampler,
5193     d3d10_effect_render_target_view_variable_SetRawValue,
5194     d3d10_effect_render_target_view_variable_GetRawValue,
5195     /* ID3D10EffectRenderTargetViewVariable methods */
5196     d3d10_effect_render_target_view_variable_SetRenderTarget,
5197     d3d10_effect_render_target_view_variable_GetRenderTarget,
5198     d3d10_effect_render_target_view_variable_SetRenderTargetArray,
5199     d3d10_effect_render_target_view_variable_GetRenderTargetArray,
5200 };
5201
5202 /* ID3D10EffectVariable methods */
5203
5204 static BOOL STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_IsValid(
5205         ID3D10EffectDepthStencilViewVariable *iface)
5206 {
5207     TRACE("iface %p\n", iface);
5208
5209     return (struct d3d10_effect_variable *)iface != &null_depth_stencil_view_variable;
5210 }
5211
5212 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetType(
5213         ID3D10EffectDepthStencilViewVariable *iface)
5214 {
5215     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5216 }
5217
5218 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDesc(
5219         ID3D10EffectDepthStencilViewVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
5220 {
5221     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5222 }
5223
5224 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetAnnotationByIndex(
5225         ID3D10EffectDepthStencilViewVariable *iface, UINT index)
5226 {
5227     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5228 }
5229
5230 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetAnnotationByName(
5231         ID3D10EffectDepthStencilViewVariable *iface, LPCSTR name)
5232 {
5233     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5234 }
5235
5236 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberByIndex(
5237         ID3D10EffectDepthStencilViewVariable *iface, UINT index)
5238 {
5239     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5240 }
5241
5242 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberByName(
5243         ID3D10EffectDepthStencilViewVariable *iface, LPCSTR name)
5244 {
5245     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5246 }
5247
5248 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberBySemantic(
5249         ID3D10EffectDepthStencilViewVariable *iface, LPCSTR semantic)
5250 {
5251     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5252 }
5253
5254 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetElement(
5255         ID3D10EffectDepthStencilViewVariable *iface, UINT index)
5256 {
5257     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5258 }
5259
5260 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetParentConstantBuffer(
5261         ID3D10EffectDepthStencilViewVariable *iface)
5262 {
5263     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5264 }
5265
5266 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsScalar(
5267         ID3D10EffectDepthStencilViewVariable *iface)
5268 {
5269     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5270 }
5271
5272 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsVector(
5273         ID3D10EffectDepthStencilViewVariable *iface)
5274 {
5275     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5276 }
5277
5278 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsMatrix(
5279         ID3D10EffectDepthStencilViewVariable *iface)
5280 {
5281     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5282 }
5283
5284 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsString(
5285         ID3D10EffectDepthStencilViewVariable *iface)
5286 {
5287     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5288 }
5289
5290 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsShaderResource(
5291         ID3D10EffectDepthStencilViewVariable *iface)
5292 {
5293     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5294 }
5295
5296 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsRenderTargetView(
5297         ID3D10EffectDepthStencilViewVariable *iface)
5298 {
5299     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5300 }
5301
5302 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsDepthStencilView(
5303         ID3D10EffectDepthStencilViewVariable *iface)
5304 {
5305     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5306 }
5307
5308 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsConstantBuffer(
5309         ID3D10EffectDepthStencilViewVariable *iface)
5310 {
5311     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5312 }
5313
5314 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsShader(
5315         ID3D10EffectDepthStencilViewVariable *iface)
5316 {
5317     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5318 }
5319
5320 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsBlend(
5321         ID3D10EffectDepthStencilViewVariable *iface)
5322 {
5323     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5324 }
5325
5326 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsDepthStencil(
5327         ID3D10EffectDepthStencilViewVariable *iface)
5328 {
5329     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5330 }
5331
5332 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsRasterizer(
5333         ID3D10EffectDepthStencilViewVariable *iface)
5334 {
5335     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5336 }
5337
5338 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsSampler(
5339         ID3D10EffectDepthStencilViewVariable *iface)
5340 {
5341     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5342 }
5343
5344 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetRawValue(
5345         ID3D10EffectDepthStencilViewVariable *iface, void *data, UINT offset, UINT count)
5346 {
5347     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5348 }
5349
5350 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetRawValue(
5351         ID3D10EffectDepthStencilViewVariable *iface, void *data, UINT offset, UINT count)
5352 {
5353     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5354 }
5355
5356 /* ID3D10EffectDepthStencilViewVariable methods */
5357
5358 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetDepthStencil(
5359         ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView *view)
5360 {
5361     FIXME("iface %p, view %p stub!\n", iface, view);
5362
5363     return E_NOTIMPL;
5364 }
5365
5366 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDepthStencil(
5367         ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **view)
5368 {
5369     FIXME("iface %p, view %p stub!\n", iface, view);
5370
5371     return E_NOTIMPL;
5372 }
5373
5374 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetDepthStencilArray(
5375         ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **views, UINT offset, UINT count)
5376 {
5377     FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5378
5379     return E_NOTIMPL;
5380 }
5381
5382 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDepthStencilArray(
5383         ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **views, UINT offset, UINT count)
5384 {
5385     FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5386
5387     return E_NOTIMPL;
5388 }
5389
5390
5391 static const struct ID3D10EffectDepthStencilViewVariableVtbl d3d10_effect_depth_stencil_view_variable_vtbl =
5392 {
5393     /* ID3D10EffectVariable methods */
5394     d3d10_effect_depth_stencil_view_variable_IsValid,
5395     d3d10_effect_depth_stencil_view_variable_GetType,
5396     d3d10_effect_depth_stencil_view_variable_GetDesc,
5397     d3d10_effect_depth_stencil_view_variable_GetAnnotationByIndex,
5398     d3d10_effect_depth_stencil_view_variable_GetAnnotationByName,
5399     d3d10_effect_depth_stencil_view_variable_GetMemberByIndex,
5400     d3d10_effect_depth_stencil_view_variable_GetMemberByName,
5401     d3d10_effect_depth_stencil_view_variable_GetMemberBySemantic,
5402     d3d10_effect_depth_stencil_view_variable_GetElement,
5403     d3d10_effect_depth_stencil_view_variable_GetParentConstantBuffer,
5404     d3d10_effect_depth_stencil_view_variable_AsScalar,
5405     d3d10_effect_depth_stencil_view_variable_AsVector,
5406     d3d10_effect_depth_stencil_view_variable_AsMatrix,
5407     d3d10_effect_depth_stencil_view_variable_AsString,
5408     d3d10_effect_depth_stencil_view_variable_AsShaderResource,
5409     d3d10_effect_depth_stencil_view_variable_AsRenderTargetView,
5410     d3d10_effect_depth_stencil_view_variable_AsDepthStencilView,
5411     d3d10_effect_depth_stencil_view_variable_AsConstantBuffer,
5412     d3d10_effect_depth_stencil_view_variable_AsShader,
5413     d3d10_effect_depth_stencil_view_variable_AsBlend,
5414     d3d10_effect_depth_stencil_view_variable_AsDepthStencil,
5415     d3d10_effect_depth_stencil_view_variable_AsRasterizer,
5416     d3d10_effect_depth_stencil_view_variable_AsSampler,
5417     d3d10_effect_depth_stencil_view_variable_SetRawValue,
5418     d3d10_effect_depth_stencil_view_variable_GetRawValue,
5419     /* ID3D10EffectDepthStencilViewVariable methods */
5420     d3d10_effect_depth_stencil_view_variable_SetDepthStencil,
5421     d3d10_effect_depth_stencil_view_variable_GetDepthStencil,
5422     d3d10_effect_depth_stencil_view_variable_SetDepthStencilArray,
5423     d3d10_effect_depth_stencil_view_variable_GetDepthStencilArray,
5424 };
5425
5426 /* ID3D10EffectVariable methods */
5427
5428 static BOOL STDMETHODCALLTYPE d3d10_effect_shader_variable_IsValid(ID3D10EffectShaderVariable *iface)
5429 {
5430     TRACE("iface %p\n", iface);
5431
5432     return (struct d3d10_effect_variable *)iface != &null_shader_variable;
5433 }
5434
5435 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetType(
5436         ID3D10EffectShaderVariable *iface)
5437 {
5438     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5439 }
5440
5441 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetDesc(ID3D10EffectShaderVariable *iface,
5442         D3D10_EFFECT_VARIABLE_DESC *desc)
5443 {
5444     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5445 }
5446
5447 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetAnnotationByIndex(
5448         ID3D10EffectShaderVariable *iface, UINT index)
5449 {
5450     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5451 }
5452
5453 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetAnnotationByName(
5454         ID3D10EffectShaderVariable *iface, LPCSTR name)
5455 {
5456     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5457 }
5458
5459 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberByIndex(
5460         ID3D10EffectShaderVariable *iface, UINT index)
5461 {
5462     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5463 }
5464
5465 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberByName(
5466         ID3D10EffectShaderVariable *iface, LPCSTR name)
5467 {
5468     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5469 }
5470
5471 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberBySemantic(
5472         ID3D10EffectShaderVariable *iface, LPCSTR semantic)
5473 {
5474     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5475 }
5476
5477 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetElement(
5478         ID3D10EffectShaderVariable *iface, UINT index)
5479 {
5480     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5481 }
5482
5483 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetParentConstantBuffer(
5484         ID3D10EffectShaderVariable *iface)
5485 {
5486     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5487 }
5488
5489 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsScalar(
5490         ID3D10EffectShaderVariable *iface)
5491 {
5492     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5493 }
5494
5495 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsVector(
5496         ID3D10EffectShaderVariable *iface)
5497 {
5498     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5499 }
5500
5501 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsMatrix(
5502         ID3D10EffectShaderVariable *iface)
5503 {
5504     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5505 }
5506
5507 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsString(
5508         ID3D10EffectShaderVariable *iface)
5509 {
5510     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5511 }
5512
5513 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsShaderResource(
5514         ID3D10EffectShaderVariable *iface)
5515 {
5516     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5517 }
5518
5519 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsRenderTargetView(
5520         ID3D10EffectShaderVariable *iface)
5521 {
5522     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5523 }
5524
5525 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsDepthStencilView(
5526         ID3D10EffectShaderVariable *iface)
5527 {
5528     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5529 }
5530
5531 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsConstantBuffer(
5532         ID3D10EffectShaderVariable *iface)
5533 {
5534     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5535 }
5536
5537 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsShader(
5538         ID3D10EffectShaderVariable *iface)
5539 {
5540     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5541 }
5542
5543 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsBlend(
5544         ID3D10EffectShaderVariable *iface)
5545 {
5546     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5547 }
5548
5549 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsDepthStencil(
5550         ID3D10EffectShaderVariable *iface)
5551 {
5552     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5553 }
5554
5555 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsRasterizer(
5556         ID3D10EffectShaderVariable *iface)
5557 {
5558     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5559 }
5560
5561 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsSampler(
5562         ID3D10EffectShaderVariable *iface)
5563 {
5564     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5565 }
5566
5567 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_SetRawValue(
5568         ID3D10EffectShaderVariable *iface, void *data, UINT offset, UINT count)
5569 {
5570     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5571 }
5572
5573 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetRawValue(
5574         ID3D10EffectShaderVariable *iface, void *data, UINT offset, UINT count)
5575 {
5576     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5577 }
5578
5579 /* ID3D10EffectShaderVariable methods */
5580
5581 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetShaderDesc(
5582         ID3D10EffectShaderVariable *iface, UINT index, D3D10_EFFECT_SHADER_DESC *desc)
5583 {
5584     FIXME("iface %p, index %u, desc %p stub!\n", iface, index, desc);
5585
5586     return E_NOTIMPL;
5587 }
5588
5589 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetVertexShader(
5590         ID3D10EffectShaderVariable *iface, UINT index, ID3D10VertexShader **shader)
5591 {
5592     FIXME("iface %p, index %u, shader %p stub!\n", iface, index, shader);
5593
5594     return E_NOTIMPL;
5595 }
5596
5597 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetGeometryShader(
5598         ID3D10EffectShaderVariable *iface, UINT index, ID3D10GeometryShader **shader)
5599 {
5600     FIXME("iface %p, index %u, shader %p stub!\n", iface, index, shader);
5601
5602     return E_NOTIMPL;
5603 }
5604
5605 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetPixelShader(
5606         ID3D10EffectShaderVariable *iface, UINT index, ID3D10PixelShader **shader)
5607 {
5608     FIXME("iface %p, index %u, shader %p stub!\n", iface, index, shader);
5609
5610     return E_NOTIMPL;
5611 }
5612
5613 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetInputSignatureElementDesc(
5614         ID3D10EffectShaderVariable *iface, UINT shader_index, UINT element_index,
5615         D3D10_SIGNATURE_PARAMETER_DESC *desc)
5616 {
5617     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
5618     struct d3d10_effect_shader_variable *s;
5619     D3D10_SIGNATURE_PARAMETER_DESC *d;
5620
5621     TRACE("iface %p, shader_index %u, element_index %u, desc %p\n",
5622             iface, shader_index, element_index, desc);
5623
5624     if (!iface->lpVtbl->IsValid(iface))
5625     {
5626         WARN("Null variable specified\n");
5627         return E_FAIL;
5628     }
5629
5630     /* Check shader_index, this crashes on W7/DX10 */
5631     if (shader_index >= This->effect->used_shader_count)
5632     {
5633         WARN("This should crash on W7/DX10!\n");
5634         return E_FAIL;
5635     }
5636
5637     s = This->effect->used_shaders[shader_index]->data;
5638     if (!s->input_signature.signature)
5639     {
5640         WARN("No shader signature\n");
5641         return D3DERR_INVALIDCALL;
5642     }
5643
5644     /* Check desc for NULL, this crashes on W7/DX10 */
5645     if (!desc)
5646     {
5647         WARN("This should crash on W7/DX10!\n");
5648         return E_FAIL;
5649     }
5650
5651     if (element_index >= s->input_signature.element_count)
5652     {
5653         WARN("Invalid element index specified\n");
5654         return E_INVALIDARG;
5655     }
5656
5657     d = &s->input_signature.elements[element_index];
5658     desc->SemanticName = d->SemanticName;
5659     desc->SemanticIndex  =  d->SemanticIndex;
5660     desc->SystemValueType =  d->SystemValueType;
5661     desc->ComponentType =  d->ComponentType;
5662     desc->Register =  d->Register;
5663     desc->ReadWriteMask  =  d->ReadWriteMask;
5664     desc->Mask =  d->Mask;
5665
5666     return S_OK;
5667 }
5668
5669 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetOutputSignatureElementDesc(
5670         ID3D10EffectShaderVariable *iface, UINT shader_index, UINT element_index,
5671         D3D10_SIGNATURE_PARAMETER_DESC *desc)
5672 {
5673     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
5674     struct d3d10_effect_shader_variable *s;
5675     D3D10_SIGNATURE_PARAMETER_DESC *d;
5676
5677     TRACE("iface %p, shader_index %u, element_index %u, desc %p\n",
5678             iface, shader_index, element_index, desc);
5679
5680     if (!iface->lpVtbl->IsValid(iface))
5681     {
5682         WARN("Null variable specified\n");
5683         return E_FAIL;
5684     }
5685
5686     /* Check shader_index, this crashes on W7/DX10 */
5687     if (shader_index >= This->effect->used_shader_count)
5688     {
5689         WARN("This should crash on W7/DX10!\n");
5690         return E_FAIL;
5691     }
5692
5693     s = This->effect->used_shaders[shader_index]->data;
5694     if (!s->output_signature.signature)
5695     {
5696         WARN("No shader signature\n");
5697         return D3DERR_INVALIDCALL;
5698     }
5699
5700     /* Check desc for NULL, this crashes on W7/DX10 */
5701     if (!desc)
5702     {
5703         WARN("This should crash on W7/DX10!\n");
5704         return E_FAIL;
5705     }
5706
5707     if (element_index >= s->output_signature.element_count)
5708     {
5709         WARN("Invalid element index specified\n");
5710         return E_INVALIDARG;
5711     }
5712
5713     d = &s->output_signature.elements[element_index];
5714     desc->SemanticName = d->SemanticName;
5715     desc->SemanticIndex  =  d->SemanticIndex;
5716     desc->SystemValueType =  d->SystemValueType;
5717     desc->ComponentType =  d->ComponentType;
5718     desc->Register =  d->Register;
5719     desc->ReadWriteMask  =  d->ReadWriteMask;
5720     desc->Mask =  d->Mask;
5721
5722     return S_OK;
5723 }
5724
5725
5726 static const struct ID3D10EffectShaderVariableVtbl d3d10_effect_shader_variable_vtbl =
5727 {
5728     /* ID3D10EffectVariable methods */
5729     d3d10_effect_shader_variable_IsValid,
5730     d3d10_effect_shader_variable_GetType,
5731     d3d10_effect_shader_variable_GetDesc,
5732     d3d10_effect_shader_variable_GetAnnotationByIndex,
5733     d3d10_effect_shader_variable_GetAnnotationByName,
5734     d3d10_effect_shader_variable_GetMemberByIndex,
5735     d3d10_effect_shader_variable_GetMemberByName,
5736     d3d10_effect_shader_variable_GetMemberBySemantic,
5737     d3d10_effect_shader_variable_GetElement,
5738     d3d10_effect_shader_variable_GetParentConstantBuffer,
5739     d3d10_effect_shader_variable_AsScalar,
5740     d3d10_effect_shader_variable_AsVector,
5741     d3d10_effect_shader_variable_AsMatrix,
5742     d3d10_effect_shader_variable_AsString,
5743     d3d10_effect_shader_variable_AsShaderResource,
5744     d3d10_effect_shader_variable_AsRenderTargetView,
5745     d3d10_effect_shader_variable_AsDepthStencilView,
5746     d3d10_effect_shader_variable_AsConstantBuffer,
5747     d3d10_effect_shader_variable_AsShader,
5748     d3d10_effect_shader_variable_AsBlend,
5749     d3d10_effect_shader_variable_AsDepthStencil,
5750     d3d10_effect_shader_variable_AsRasterizer,
5751     d3d10_effect_shader_variable_AsSampler,
5752     d3d10_effect_shader_variable_SetRawValue,
5753     d3d10_effect_shader_variable_GetRawValue,
5754     /* ID3D10EffectShaderVariable methods */
5755     d3d10_effect_shader_variable_GetShaderDesc,
5756     d3d10_effect_shader_variable_GetVertexShader,
5757     d3d10_effect_shader_variable_GetGeometryShader,
5758     d3d10_effect_shader_variable_GetPixelShader,
5759     d3d10_effect_shader_variable_GetInputSignatureElementDesc,
5760     d3d10_effect_shader_variable_GetOutputSignatureElementDesc,
5761 };
5762
5763 /* ID3D10EffectVariable methods */
5764
5765 static BOOL STDMETHODCALLTYPE d3d10_effect_blend_variable_IsValid(ID3D10EffectBlendVariable *iface)
5766 {
5767     TRACE("iface %p\n", iface);
5768
5769     return (struct d3d10_effect_variable *)iface != &null_blend_variable;
5770 }
5771
5772 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetType(
5773         ID3D10EffectBlendVariable *iface)
5774 {
5775     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5776 }
5777
5778 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetDesc(ID3D10EffectBlendVariable *iface,
5779         D3D10_EFFECT_VARIABLE_DESC *desc)
5780 {
5781     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5782 }
5783
5784 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetAnnotationByIndex(
5785         ID3D10EffectBlendVariable *iface, UINT index)
5786 {
5787     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5788 }
5789
5790 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetAnnotationByName(
5791         ID3D10EffectBlendVariable *iface, LPCSTR name)
5792 {
5793     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5794 }
5795
5796 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberByIndex(
5797         ID3D10EffectBlendVariable *iface, UINT index)
5798 {
5799     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5800 }
5801
5802 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberByName(
5803         ID3D10EffectBlendVariable *iface, LPCSTR name)
5804 {
5805     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5806 }
5807
5808 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberBySemantic(
5809         ID3D10EffectBlendVariable *iface, LPCSTR semantic)
5810 {
5811     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5812 }
5813
5814 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetElement(
5815         ID3D10EffectBlendVariable *iface, UINT index)
5816 {
5817     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5818 }
5819
5820 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetParentConstantBuffer(
5821         ID3D10EffectBlendVariable *iface)
5822 {
5823     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5824 }
5825
5826 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsScalar(
5827         ID3D10EffectBlendVariable *iface)
5828 {
5829     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5830 }
5831
5832 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsVector(
5833         ID3D10EffectBlendVariable *iface)
5834 {
5835     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5836 }
5837
5838 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsMatrix(
5839         ID3D10EffectBlendVariable *iface)
5840 {
5841     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5842 }
5843
5844 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsString(
5845         ID3D10EffectBlendVariable *iface)
5846 {
5847     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5848 }
5849
5850 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsShaderResource(
5851         ID3D10EffectBlendVariable *iface)
5852 {
5853     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5854 }
5855
5856 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsRenderTargetView(
5857         ID3D10EffectBlendVariable *iface)
5858 {
5859     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5860 }
5861
5862 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsDepthStencilView(
5863         ID3D10EffectBlendVariable *iface)
5864 {
5865     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5866 }
5867
5868 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsConstantBuffer(
5869         ID3D10EffectBlendVariable *iface)
5870 {
5871     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5872 }
5873
5874 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsShader(
5875         ID3D10EffectBlendVariable *iface)
5876 {
5877     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5878 }
5879
5880 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsBlend(
5881         ID3D10EffectBlendVariable *iface)
5882 {
5883     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5884 }
5885
5886 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsDepthStencil(
5887         ID3D10EffectBlendVariable *iface)
5888 {
5889     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5890 }
5891
5892 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsRasterizer(
5893         ID3D10EffectBlendVariable *iface)
5894 {
5895     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5896 }
5897
5898 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsSampler(
5899         ID3D10EffectBlendVariable *iface)
5900 {
5901     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5902 }
5903
5904 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_SetRawValue(ID3D10EffectBlendVariable *iface,
5905         void *data, UINT offset, UINT count)
5906 {
5907     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5908 }
5909
5910 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetRawValue(ID3D10EffectBlendVariable *iface,
5911         void *data, UINT offset, UINT count)
5912 {
5913     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5914 }
5915
5916 /* ID3D10EffectBlendVariable methods */
5917
5918 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetBlendState(ID3D10EffectBlendVariable *iface,
5919         UINT index, ID3D10BlendState **blend_state)
5920 {
5921     FIXME("iface %p, index %u, blend_state %p stub!\n", iface, index, blend_state);
5922
5923     return E_NOTIMPL;
5924 }
5925
5926 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetBackingStore(ID3D10EffectBlendVariable *iface,
5927         UINT index, D3D10_BLEND_DESC *desc)
5928 {
5929     struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
5930
5931     TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
5932
5933     if (index >= max(v->type->element_count, 1))
5934     {
5935         WARN("Invalid index %u.\n", index);
5936         return E_FAIL;
5937     }
5938
5939     *desc = ((D3D10_BLEND_DESC *)v->data)[index];
5940
5941     return S_OK;
5942 }
5943
5944
5945 static const struct ID3D10EffectBlendVariableVtbl d3d10_effect_blend_variable_vtbl =
5946 {
5947     /* ID3D10EffectVariable methods */
5948     d3d10_effect_blend_variable_IsValid,
5949     d3d10_effect_blend_variable_GetType,
5950     d3d10_effect_blend_variable_GetDesc,
5951     d3d10_effect_blend_variable_GetAnnotationByIndex,
5952     d3d10_effect_blend_variable_GetAnnotationByName,
5953     d3d10_effect_blend_variable_GetMemberByIndex,
5954     d3d10_effect_blend_variable_GetMemberByName,
5955     d3d10_effect_blend_variable_GetMemberBySemantic,
5956     d3d10_effect_blend_variable_GetElement,
5957     d3d10_effect_blend_variable_GetParentConstantBuffer,
5958     d3d10_effect_blend_variable_AsScalar,
5959     d3d10_effect_blend_variable_AsVector,
5960     d3d10_effect_blend_variable_AsMatrix,
5961     d3d10_effect_blend_variable_AsString,
5962     d3d10_effect_blend_variable_AsShaderResource,
5963     d3d10_effect_blend_variable_AsRenderTargetView,
5964     d3d10_effect_blend_variable_AsDepthStencilView,
5965     d3d10_effect_blend_variable_AsConstantBuffer,
5966     d3d10_effect_blend_variable_AsShader,
5967     d3d10_effect_blend_variable_AsBlend,
5968     d3d10_effect_blend_variable_AsDepthStencil,
5969     d3d10_effect_blend_variable_AsRasterizer,
5970     d3d10_effect_blend_variable_AsSampler,
5971     d3d10_effect_blend_variable_SetRawValue,
5972     d3d10_effect_blend_variable_GetRawValue,
5973     /* ID3D10EffectBlendVariable methods */
5974     d3d10_effect_blend_variable_GetBlendState,
5975     d3d10_effect_blend_variable_GetBackingStore,
5976 };
5977
5978 /* ID3D10EffectVariable methods */
5979
5980 static BOOL STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_IsValid(ID3D10EffectDepthStencilVariable *iface)
5981 {
5982     TRACE("iface %p\n", iface);
5983
5984     return (struct d3d10_effect_variable *)iface != &null_depth_stencil_variable;
5985 }
5986
5987 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetType(
5988         ID3D10EffectDepthStencilVariable *iface)
5989 {
5990     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5991 }
5992
5993 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetDesc(ID3D10EffectDepthStencilVariable *iface,
5994         D3D10_EFFECT_VARIABLE_DESC *desc)
5995 {
5996     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5997 }
5998
5999 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetAnnotationByIndex(
6000         ID3D10EffectDepthStencilVariable *iface, UINT index)
6001 {
6002     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6003 }
6004
6005 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetAnnotationByName(
6006         ID3D10EffectDepthStencilVariable *iface, LPCSTR name)
6007 {
6008     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6009 }
6010
6011 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberByIndex(
6012         ID3D10EffectDepthStencilVariable *iface, UINT index)
6013 {
6014     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6015 }
6016
6017 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberByName(
6018         ID3D10EffectDepthStencilVariable *iface, LPCSTR name)
6019 {
6020     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6021 }
6022
6023 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberBySemantic(
6024         ID3D10EffectDepthStencilVariable *iface, LPCSTR semantic)
6025 {
6026     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6027 }
6028
6029 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetElement(
6030         ID3D10EffectDepthStencilVariable *iface, UINT index)
6031 {
6032     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6033 }
6034
6035 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetParentConstantBuffer(
6036         ID3D10EffectDepthStencilVariable *iface)
6037 {
6038     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6039 }
6040
6041 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsScalar(
6042         ID3D10EffectDepthStencilVariable *iface)
6043 {
6044     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6045 }
6046
6047 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsVector(
6048         ID3D10EffectDepthStencilVariable *iface)
6049 {
6050     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6051 }
6052
6053 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsMatrix(
6054         ID3D10EffectDepthStencilVariable *iface)
6055 {
6056     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6057 }
6058
6059 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsString(
6060         ID3D10EffectDepthStencilVariable *iface)
6061 {
6062     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6063 }
6064
6065 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsShaderResource(
6066         ID3D10EffectDepthStencilVariable *iface)
6067 {
6068     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6069 }
6070
6071 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsRenderTargetView(
6072         ID3D10EffectDepthStencilVariable *iface)
6073 {
6074     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6075 }
6076
6077 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsDepthStencilView(
6078         ID3D10EffectDepthStencilVariable *iface)
6079 {
6080     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6081 }
6082
6083 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsConstantBuffer(
6084         ID3D10EffectDepthStencilVariable *iface)
6085 {
6086     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6087 }
6088
6089 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsShader(
6090         ID3D10EffectDepthStencilVariable *iface)
6091 {
6092     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6093 }
6094
6095 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsBlend(
6096         ID3D10EffectDepthStencilVariable *iface)
6097 {
6098     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6099 }
6100
6101 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsDepthStencil(
6102         ID3D10EffectDepthStencilVariable *iface)
6103 {
6104     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6105 }
6106
6107 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsRasterizer(
6108         ID3D10EffectDepthStencilVariable *iface)
6109 {
6110     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6111 }
6112
6113 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsSampler(
6114         ID3D10EffectDepthStencilVariable *iface)
6115 {
6116     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6117 }
6118
6119 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_SetRawValue(ID3D10EffectDepthStencilVariable *iface,
6120         void *data, UINT offset, UINT count)
6121 {
6122     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6123 }
6124
6125 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetRawValue(ID3D10EffectDepthStencilVariable *iface,
6126         void *data, UINT offset, UINT count)
6127 {
6128     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6129 }
6130
6131 /* ID3D10EffectDepthStencilVariable methods */
6132
6133 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetDepthStencilState(ID3D10EffectDepthStencilVariable *iface,
6134         UINT index, ID3D10DepthStencilState **depth_stencil_state)
6135 {
6136     FIXME("iface %p, index %u, depth_stencil_state %p stub!\n", iface, index, depth_stencil_state);
6137
6138     return E_NOTIMPL;
6139 }
6140
6141 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetBackingStore(ID3D10EffectDepthStencilVariable *iface,
6142         UINT index, D3D10_DEPTH_STENCIL_DESC *desc)
6143 {
6144     struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6145
6146     TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
6147
6148     if (index >= max(v->type->element_count, 1))
6149     {
6150         WARN("Invalid index %u.\n", index);
6151         return E_FAIL;
6152     }
6153
6154     *desc = ((D3D10_DEPTH_STENCIL_DESC *)v->data)[index];
6155
6156     return S_OK;
6157 }
6158
6159
6160 static const struct ID3D10EffectDepthStencilVariableVtbl d3d10_effect_depth_stencil_variable_vtbl =
6161 {
6162     /* ID3D10EffectVariable methods */
6163     d3d10_effect_depth_stencil_variable_IsValid,
6164     d3d10_effect_depth_stencil_variable_GetType,
6165     d3d10_effect_depth_stencil_variable_GetDesc,
6166     d3d10_effect_depth_stencil_variable_GetAnnotationByIndex,
6167     d3d10_effect_depth_stencil_variable_GetAnnotationByName,
6168     d3d10_effect_depth_stencil_variable_GetMemberByIndex,
6169     d3d10_effect_depth_stencil_variable_GetMemberByName,
6170     d3d10_effect_depth_stencil_variable_GetMemberBySemantic,
6171     d3d10_effect_depth_stencil_variable_GetElement,
6172     d3d10_effect_depth_stencil_variable_GetParentConstantBuffer,
6173     d3d10_effect_depth_stencil_variable_AsScalar,
6174     d3d10_effect_depth_stencil_variable_AsVector,
6175     d3d10_effect_depth_stencil_variable_AsMatrix,
6176     d3d10_effect_depth_stencil_variable_AsString,
6177     d3d10_effect_depth_stencil_variable_AsShaderResource,
6178     d3d10_effect_depth_stencil_variable_AsRenderTargetView,
6179     d3d10_effect_depth_stencil_variable_AsDepthStencilView,
6180     d3d10_effect_depth_stencil_variable_AsConstantBuffer,
6181     d3d10_effect_depth_stencil_variable_AsShader,
6182     d3d10_effect_depth_stencil_variable_AsBlend,
6183     d3d10_effect_depth_stencil_variable_AsDepthStencil,
6184     d3d10_effect_depth_stencil_variable_AsRasterizer,
6185     d3d10_effect_depth_stencil_variable_AsSampler,
6186     d3d10_effect_depth_stencil_variable_SetRawValue,
6187     d3d10_effect_depth_stencil_variable_GetRawValue,
6188     /* ID3D10EffectDepthStencilVariable methods */
6189     d3d10_effect_depth_stencil_variable_GetDepthStencilState,
6190     d3d10_effect_depth_stencil_variable_GetBackingStore,
6191 };
6192
6193 /* ID3D10EffectVariable methods */
6194
6195 static BOOL STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_IsValid(ID3D10EffectRasterizerVariable *iface)
6196 {
6197     TRACE("iface %p\n", iface);
6198
6199     return (struct d3d10_effect_variable *)iface != &null_rasterizer_variable;
6200 }
6201
6202 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetType(
6203         ID3D10EffectRasterizerVariable *iface)
6204 {
6205     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
6206 }
6207
6208 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetDesc(ID3D10EffectRasterizerVariable *iface,
6209         D3D10_EFFECT_VARIABLE_DESC *desc)
6210 {
6211     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
6212 }
6213
6214 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetAnnotationByIndex(
6215         ID3D10EffectRasterizerVariable *iface, UINT index)
6216 {
6217     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6218 }
6219
6220 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetAnnotationByName(
6221         ID3D10EffectRasterizerVariable *iface, LPCSTR name)
6222 {
6223     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6224 }
6225
6226 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberByIndex(
6227         ID3D10EffectRasterizerVariable *iface, UINT index)
6228 {
6229     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6230 }
6231
6232 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberByName(
6233         ID3D10EffectRasterizerVariable *iface, LPCSTR name)
6234 {
6235     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6236 }
6237
6238 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberBySemantic(
6239         ID3D10EffectRasterizerVariable *iface, LPCSTR semantic)
6240 {
6241     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6242 }
6243
6244 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetElement(
6245         ID3D10EffectRasterizerVariable *iface, UINT index)
6246 {
6247     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6248 }
6249
6250 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetParentConstantBuffer(
6251         ID3D10EffectRasterizerVariable *iface)
6252 {
6253     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6254 }
6255
6256 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsScalar(
6257         ID3D10EffectRasterizerVariable *iface)
6258 {
6259     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6260 }
6261
6262 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsVector(
6263         ID3D10EffectRasterizerVariable *iface)
6264 {
6265     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6266 }
6267
6268 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsMatrix(
6269         ID3D10EffectRasterizerVariable *iface)
6270 {
6271     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6272 }
6273
6274 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsString(
6275         ID3D10EffectRasterizerVariable *iface)
6276 {
6277     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6278 }
6279
6280 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsShaderResource(
6281         ID3D10EffectRasterizerVariable *iface)
6282 {
6283     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6284 }
6285
6286 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsRenderTargetView(
6287         ID3D10EffectRasterizerVariable *iface)
6288 {
6289     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6290 }
6291
6292 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsDepthStencilView(
6293         ID3D10EffectRasterizerVariable *iface)
6294 {
6295     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6296 }
6297
6298 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsConstantBuffer(
6299         ID3D10EffectRasterizerVariable *iface)
6300 {
6301     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6302 }
6303
6304 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsShader(
6305         ID3D10EffectRasterizerVariable *iface)
6306 {
6307     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6308 }
6309
6310 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsBlend(
6311         ID3D10EffectRasterizerVariable *iface)
6312 {
6313     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6314 }
6315
6316 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsDepthStencil(
6317         ID3D10EffectRasterizerVariable *iface)
6318 {
6319     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6320 }
6321
6322 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsRasterizer(
6323         ID3D10EffectRasterizerVariable *iface)
6324 {
6325     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6326 }
6327
6328 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsSampler(
6329         ID3D10EffectRasterizerVariable *iface)
6330 {
6331     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6332 }
6333
6334 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_SetRawValue(ID3D10EffectRasterizerVariable *iface,
6335         void *data, UINT offset, UINT count)
6336 {
6337     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6338 }
6339
6340 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetRawValue(ID3D10EffectRasterizerVariable *iface,
6341         void *data, UINT offset, UINT count)
6342 {
6343     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6344 }
6345
6346 /* ID3D10EffectRasterizerVariable methods */
6347
6348 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetRasterizerState(ID3D10EffectRasterizerVariable *iface,
6349         UINT index, ID3D10RasterizerState **rasterizer_state)
6350 {
6351     FIXME("iface %p, index %u, rasterizer_state %p stub!\n", iface, index, rasterizer_state);
6352
6353     return E_NOTIMPL;
6354 }
6355
6356 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetBackingStore(ID3D10EffectRasterizerVariable *iface,
6357         UINT index, D3D10_RASTERIZER_DESC *desc)
6358 {
6359     struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6360
6361     TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
6362
6363     if (index >= max(v->type->element_count, 1))
6364     {
6365         WARN("Invalid index %u.\n", index);
6366         return E_FAIL;
6367     }
6368
6369     *desc = ((D3D10_RASTERIZER_DESC *)v->data)[index];
6370
6371     return S_OK;
6372 }
6373
6374
6375 static const struct ID3D10EffectRasterizerVariableVtbl d3d10_effect_rasterizer_variable_vtbl =
6376 {
6377     /* ID3D10EffectVariable methods */
6378     d3d10_effect_rasterizer_variable_IsValid,
6379     d3d10_effect_rasterizer_variable_GetType,
6380     d3d10_effect_rasterizer_variable_GetDesc,
6381     d3d10_effect_rasterizer_variable_GetAnnotationByIndex,
6382     d3d10_effect_rasterizer_variable_GetAnnotationByName,
6383     d3d10_effect_rasterizer_variable_GetMemberByIndex,
6384     d3d10_effect_rasterizer_variable_GetMemberByName,
6385     d3d10_effect_rasterizer_variable_GetMemberBySemantic,
6386     d3d10_effect_rasterizer_variable_GetElement,
6387     d3d10_effect_rasterizer_variable_GetParentConstantBuffer,
6388     d3d10_effect_rasterizer_variable_AsScalar,
6389     d3d10_effect_rasterizer_variable_AsVector,
6390     d3d10_effect_rasterizer_variable_AsMatrix,
6391     d3d10_effect_rasterizer_variable_AsString,
6392     d3d10_effect_rasterizer_variable_AsShaderResource,
6393     d3d10_effect_rasterizer_variable_AsRenderTargetView,
6394     d3d10_effect_rasterizer_variable_AsDepthStencilView,
6395     d3d10_effect_rasterizer_variable_AsConstantBuffer,
6396     d3d10_effect_rasterizer_variable_AsShader,
6397     d3d10_effect_rasterizer_variable_AsBlend,
6398     d3d10_effect_rasterizer_variable_AsDepthStencil,
6399     d3d10_effect_rasterizer_variable_AsRasterizer,
6400     d3d10_effect_rasterizer_variable_AsSampler,
6401     d3d10_effect_rasterizer_variable_SetRawValue,
6402     d3d10_effect_rasterizer_variable_GetRawValue,
6403     /* ID3D10EffectRasterizerVariable methods */
6404     d3d10_effect_rasterizer_variable_GetRasterizerState,
6405     d3d10_effect_rasterizer_variable_GetBackingStore,
6406 };
6407
6408 /* ID3D10EffectVariable methods */
6409
6410 static BOOL STDMETHODCALLTYPE d3d10_effect_sampler_variable_IsValid(ID3D10EffectSamplerVariable *iface)
6411 {
6412     TRACE("iface %p\n", iface);
6413
6414     return (struct d3d10_effect_variable *)iface != &null_sampler_variable;
6415 }
6416
6417 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetType(
6418         ID3D10EffectSamplerVariable *iface)
6419 {
6420     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
6421 }
6422
6423 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetDesc(ID3D10EffectSamplerVariable *iface,
6424         D3D10_EFFECT_VARIABLE_DESC *desc)
6425 {
6426     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
6427 }
6428
6429 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetAnnotationByIndex(
6430         ID3D10EffectSamplerVariable *iface, UINT index)
6431 {
6432     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6433 }
6434
6435 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetAnnotationByName(
6436         ID3D10EffectSamplerVariable *iface, LPCSTR name)
6437 {
6438     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6439 }
6440
6441 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberByIndex(
6442         ID3D10EffectSamplerVariable *iface, UINT index)
6443 {
6444     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6445 }
6446
6447 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberByName(
6448         ID3D10EffectSamplerVariable *iface, LPCSTR name)
6449 {
6450     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6451 }
6452
6453 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberBySemantic(
6454         ID3D10EffectSamplerVariable *iface, LPCSTR semantic)
6455 {
6456     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6457 }
6458
6459 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetElement(
6460         ID3D10EffectSamplerVariable *iface, UINT index)
6461 {
6462     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6463 }
6464
6465 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetParentConstantBuffer(
6466         ID3D10EffectSamplerVariable *iface)
6467 {
6468     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6469 }
6470
6471 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsScalar(
6472         ID3D10EffectSamplerVariable *iface)
6473 {
6474     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6475 }
6476
6477 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsVector(
6478         ID3D10EffectSamplerVariable *iface)
6479 {
6480     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6481 }
6482
6483 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsMatrix(
6484         ID3D10EffectSamplerVariable *iface)
6485 {
6486     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6487 }
6488
6489 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsString(
6490         ID3D10EffectSamplerVariable *iface)
6491 {
6492     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6493 }
6494
6495 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsShaderResource(
6496         ID3D10EffectSamplerVariable *iface)
6497 {
6498     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6499 }
6500
6501 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsRenderTargetView(
6502         ID3D10EffectSamplerVariable *iface)
6503 {
6504     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6505 }
6506
6507 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsDepthStencilView(
6508         ID3D10EffectSamplerVariable *iface)
6509 {
6510     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6511 }
6512
6513 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsConstantBuffer(
6514         ID3D10EffectSamplerVariable *iface)
6515 {
6516     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6517 }
6518
6519 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsShader(
6520         ID3D10EffectSamplerVariable *iface)
6521 {
6522     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6523 }
6524
6525 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsBlend(
6526         ID3D10EffectSamplerVariable *iface)
6527 {
6528     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6529 }
6530
6531 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsDepthStencil(
6532         ID3D10EffectSamplerVariable *iface)
6533 {
6534     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6535 }
6536
6537 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsRasterizer(
6538         ID3D10EffectSamplerVariable *iface)
6539 {
6540     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6541 }
6542
6543 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsSampler(
6544         ID3D10EffectSamplerVariable *iface)
6545 {
6546     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6547 }
6548
6549 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_SetRawValue(ID3D10EffectSamplerVariable *iface,
6550         void *data, UINT offset, UINT count)
6551 {
6552     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6553 }
6554
6555 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetRawValue(ID3D10EffectSamplerVariable *iface,
6556         void *data, UINT offset, UINT count)
6557 {
6558     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6559 }
6560
6561 /* ID3D10EffectSamplerVariable methods */
6562
6563 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetSampler(ID3D10EffectSamplerVariable *iface,
6564         UINT index, ID3D10SamplerState **sampler)
6565 {
6566     FIXME("iface %p, index %u, sampler %p stub!\n", iface, index, sampler);
6567
6568     return E_NOTIMPL;
6569 }
6570
6571 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetBackingStore(ID3D10EffectSamplerVariable *iface,
6572         UINT index, D3D10_SAMPLER_DESC *desc)
6573 {
6574     struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6575
6576     TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
6577
6578     if (index >= max(v->type->element_count, 1))
6579     {
6580         WARN("Invalid index %u.\n", index);
6581         return E_FAIL;
6582     }
6583
6584     *desc = ((D3D10_SAMPLER_DESC *)v->data)[index];
6585
6586     return S_OK;
6587 }
6588
6589
6590 static const struct ID3D10EffectSamplerVariableVtbl d3d10_effect_sampler_variable_vtbl =
6591 {
6592     /* ID3D10EffectVariable methods */
6593     d3d10_effect_sampler_variable_IsValid,
6594     d3d10_effect_sampler_variable_GetType,
6595     d3d10_effect_sampler_variable_GetDesc,
6596     d3d10_effect_sampler_variable_GetAnnotationByIndex,
6597     d3d10_effect_sampler_variable_GetAnnotationByName,
6598     d3d10_effect_sampler_variable_GetMemberByIndex,
6599     d3d10_effect_sampler_variable_GetMemberByName,
6600     d3d10_effect_sampler_variable_GetMemberBySemantic,
6601     d3d10_effect_sampler_variable_GetElement,
6602     d3d10_effect_sampler_variable_GetParentConstantBuffer,
6603     d3d10_effect_sampler_variable_AsScalar,
6604     d3d10_effect_sampler_variable_AsVector,
6605     d3d10_effect_sampler_variable_AsMatrix,
6606     d3d10_effect_sampler_variable_AsString,
6607     d3d10_effect_sampler_variable_AsShaderResource,
6608     d3d10_effect_sampler_variable_AsRenderTargetView,
6609     d3d10_effect_sampler_variable_AsDepthStencilView,
6610     d3d10_effect_sampler_variable_AsConstantBuffer,
6611     d3d10_effect_sampler_variable_AsShader,
6612     d3d10_effect_sampler_variable_AsBlend,
6613     d3d10_effect_sampler_variable_AsDepthStencil,
6614     d3d10_effect_sampler_variable_AsRasterizer,
6615     d3d10_effect_sampler_variable_AsSampler,
6616     d3d10_effect_sampler_variable_SetRawValue,
6617     d3d10_effect_sampler_variable_GetRawValue,
6618     /* ID3D10EffectSamplerVariable methods */
6619     d3d10_effect_sampler_variable_GetSampler,
6620     d3d10_effect_sampler_variable_GetBackingStore,
6621 };
6622
6623 /* ID3D10EffectType methods */
6624
6625 static inline struct d3d10_effect_type *impl_from_ID3D10EffectType(ID3D10EffectType *iface)
6626 {
6627     return CONTAINING_RECORD(iface, struct d3d10_effect_type, ID3D10EffectType_iface);
6628 }
6629
6630 static BOOL STDMETHODCALLTYPE d3d10_effect_type_IsValid(ID3D10EffectType *iface)
6631 {
6632     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6633
6634     TRACE("iface %p\n", iface);
6635
6636     return This != &null_type;
6637 }
6638
6639 static HRESULT STDMETHODCALLTYPE d3d10_effect_type_GetDesc(ID3D10EffectType *iface, D3D10_EFFECT_TYPE_DESC *desc)
6640 {
6641     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6642
6643     TRACE("iface %p, desc %p\n", iface, desc);
6644
6645     if (This == &null_type)
6646     {
6647         WARN("Null type specified\n");
6648         return E_FAIL;
6649     }
6650
6651     if (!desc)
6652     {
6653         WARN("Invalid argument specified\n");
6654         return E_INVALIDARG;
6655     }
6656
6657     desc->TypeName = This->name;
6658     desc->Class = This->type_class;
6659     desc->Type = This->basetype;
6660     desc->Elements = This->element_count;
6661     desc->Members = This->member_count;
6662     desc->Rows = This->row_count;
6663     desc->Columns = This->column_count;
6664     desc->PackedSize = This->size_packed;
6665     desc->UnpackedSize = This->size_unpacked;
6666     desc->Stride = This->stride;
6667
6668     return S_OK;
6669 }
6670
6671 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByIndex(ID3D10EffectType *iface,
6672         UINT index)
6673 {
6674     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6675     struct d3d10_effect_type *t;
6676
6677     TRACE("iface %p, index %u\n", iface, index);
6678
6679     if (index >= This->member_count)
6680     {
6681         WARN("Invalid index specified\n");
6682         return &null_type.ID3D10EffectType_iface;
6683     }
6684
6685     t = (&This->members[index])->type;
6686
6687     TRACE("Returning member %p, %s\n", t, debugstr_a(t->name));
6688
6689     return &t->ID3D10EffectType_iface;
6690 }
6691
6692 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByName(ID3D10EffectType *iface,
6693         LPCSTR name)
6694 {
6695     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6696     unsigned int i;
6697
6698     TRACE("iface %p, name %s\n", iface, debugstr_a(name));
6699
6700     if (!name)
6701     {
6702         WARN("Invalid name specified\n");
6703         return &null_type.ID3D10EffectType_iface;
6704     }
6705
6706     for (i = 0; i < This->member_count; ++i)
6707     {
6708         struct d3d10_effect_type_member *typem = &This->members[i];
6709
6710         if (typem->name)
6711         {
6712             if (!strcmp(typem->name, name))
6713             {
6714                 TRACE("Returning type %p.\n", typem->type);
6715                 return &typem->type->ID3D10EffectType_iface;
6716             }
6717         }
6718     }
6719
6720     WARN("Invalid name specified\n");
6721
6722     return &null_type.ID3D10EffectType_iface;
6723 }
6724
6725 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeBySemantic(ID3D10EffectType *iface,
6726         LPCSTR semantic)
6727 {
6728     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6729     unsigned int i;
6730
6731     TRACE("iface %p, semantic %s\n", iface, debugstr_a(semantic));
6732
6733     if (!semantic)
6734     {
6735         WARN("Invalid semantic specified\n");
6736         return &null_type.ID3D10EffectType_iface;
6737     }
6738
6739     for (i = 0; i < This->member_count; ++i)
6740     {
6741         struct d3d10_effect_type_member *typem = &This->members[i];
6742
6743         if (typem->semantic)
6744         {
6745             if (!strcmp(typem->semantic, semantic))
6746             {
6747                 TRACE("Returning type %p.\n", typem->type);
6748                 return &typem->type->ID3D10EffectType_iface;
6749             }
6750         }
6751     }
6752
6753     WARN("Invalid semantic specified\n");
6754
6755     return &null_type.ID3D10EffectType_iface;
6756 }
6757
6758 static LPCSTR STDMETHODCALLTYPE d3d10_effect_type_GetMemberName(ID3D10EffectType *iface, UINT index)
6759 {
6760     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6761     struct d3d10_effect_type_member *typem;
6762
6763     TRACE("iface %p, index %u\n", iface, index);
6764
6765     if (index >= This->member_count)
6766     {
6767         WARN("Invalid index specified\n");
6768         return NULL;
6769     }
6770
6771     typem = &This->members[index];
6772
6773     TRACE("Returning name %s\n", debugstr_a(typem->name));
6774
6775     return typem->name;
6776 }
6777
6778 static LPCSTR STDMETHODCALLTYPE d3d10_effect_type_GetMemberSemantic(ID3D10EffectType *iface, UINT index)
6779 {
6780     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6781     struct d3d10_effect_type_member *typem;
6782
6783     TRACE("iface %p, index %u\n", iface, index);
6784
6785     if (index >= This->member_count)
6786     {
6787         WARN("Invalid index specified\n");
6788         return NULL;
6789     }
6790
6791     typem = &This->members[index];
6792
6793     TRACE("Returning semantic %s\n", debugstr_a(typem->semantic));
6794
6795     return typem->semantic;
6796 }
6797
6798 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl =
6799 {
6800     /* ID3D10EffectType */
6801     d3d10_effect_type_IsValid,
6802     d3d10_effect_type_GetDesc,
6803     d3d10_effect_type_GetMemberTypeByIndex,
6804     d3d10_effect_type_GetMemberTypeByName,
6805     d3d10_effect_type_GetMemberTypeBySemantic,
6806     d3d10_effect_type_GetMemberName,
6807     d3d10_effect_type_GetMemberSemantic,
6808 };