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