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