dlls/d3d10/effect.c

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