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