dlls/d3d10/effect.c

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