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