git.oblomov.eu Git - wine/blob - dlls/d3d10/effect.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include "d3d10_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d10);
  26
  27 #define MAKE_TAG(ch0, ch1, ch2, ch3) \
  28     ((DWORD)(ch0) | ((DWORD)(ch1) << 8) | \
  29     ((DWORD)(ch2) << 16) | ((DWORD)(ch3) << 24 ))
  30 #define TAG_DXBC MAKE_TAG('D', 'X', 'B', 'C')
  31 #define TAG_FX10 MAKE_TAG('F', 'X', '1', '0')
  32 #define TAG_ISGN MAKE_TAG('I', 'S', 'G', 'N')
  33
  34 #define D3D10_FX10_TYPE_COLUMN_SHIFT    11
  35 #define D3D10_FX10_TYPE_COLUMN_MASK     (0x7 << D3D10_FX10_TYPE_COLUMN_SHIFT)
  36
  37 #define D3D10_FX10_TYPE_ROW_SHIFT       8
  38 #define D3D10_FX10_TYPE_ROW_MASK        (0x7 << D3D10_FX10_TYPE_ROW_SHIFT)
  39
  40 #define D3D10_FX10_TYPE_BASETYPE_SHIFT  3
  41 #define D3D10_FX10_TYPE_BASETYPE_MASK   (0x1f << D3D10_FX10_TYPE_BASETYPE_SHIFT)
  42
  43 #define D3D10_FX10_TYPE_CLASS_SHIFT     0
  44 #define D3D10_FX10_TYPE_CLASS_MASK      (0x7 << D3D10_FX10_TYPE_CLASS_SHIFT)
  45
  46 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl;
  47 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl;
  48 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl;
  49 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl;
  50 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl;
  51 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl;
  52 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl;
  53 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl;
  54
  55 /* null objects - needed for invalid calls */
  56 static struct d3d10_effect_technique null_technique =
  57         {&d3d10_effect_technique_vtbl, NULL, NULL, 0, 0, NULL, NULL};
  58 static struct d3d10_effect_pass null_pass =
  59         {&d3d10_effect_pass_vtbl, NULL, NULL, 0, 0, 0, NULL, NULL};
  60 static struct d3d10_effect_local_buffer null_local_buffer =
  61         {&d3d10_effect_constant_buffer_vtbl, NULL, NULL, 0, 0, 0, NULL, NULL};
  62 static struct d3d10_effect_variable null_variable =
  63         {&d3d10_effect_variable_vtbl, NULL, NULL, NULL, 0, 0, 0, NULL, NULL};
  64 static struct d3d10_effect_variable null_scalar_variable =
  65         {(ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl, NULL, NULL, NULL, 0, 0, 0, NULL, NULL};
  66 static struct d3d10_effect_variable null_vector_variable =
  67         {(ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl, NULL, NULL, NULL, 0, 0, 0, NULL, NULL};
  68 static struct d3d10_effect_variable null_matrix_variable =
  69         {(ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl, NULL, NULL, NULL, 0, 0, 0, NULL, NULL};
  70
  71 static inline void read_dword(const char **ptr, DWORD *d)
  72 {
  73     memcpy(d, *ptr, sizeof(*d));
  74     *ptr += sizeof(*d);
  75 }
  76
  77 static inline void skip_dword_unknown(const char **ptr, unsigned int count)
  78 {
  79     unsigned int i;
  80     DWORD d;
  81
  82     FIXME("Skipping %u unknown DWORDs:\n", count);
  83     for (i = 0; i < count; ++i)
  84     {
  85         read_dword(ptr, &d);
  86         FIXME("\t0x%08x\n", d);
  87     }
  88 }
  89
  90 static inline void write_dword(char **ptr, DWORD d)
  91 {
  92     memcpy(*ptr, &d, sizeof(d));
  93     *ptr += sizeof(d);
  94 }
  95
  96 static inline void write_dword_unknown(char **ptr, DWORD d)
  97 {
  98     FIXME("Writing unknown DWORD 0x%08x\n", d);
  99     write_dword(ptr, d);
 100 }
 101
 102 static HRESULT parse_dxbc(const char *data, SIZE_T data_size,
 103         HRESULT (*chunk_handler)(const char *data, DWORD data_size, DWORD tag, void *ctx), void *ctx)
 104 {
 105     const char *ptr = data;
 106     HRESULT hr = S_OK;
 107     DWORD chunk_count;
 108     DWORD total_size;
 109     unsigned int i;
 110     DWORD tag;
 111
 112     read_dword(&ptr, &tag);
 113     TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
 114
 115     if (tag != TAG_DXBC)
 116     {
 117         WARN("Wrong tag.\n");
 118         return E_FAIL;
 119     }
 120
 121     /* checksum? */
 122     skip_dword_unknown(&ptr, 4);
 123
 124     skip_dword_unknown(&ptr, 1);
 125
 126     read_dword(&ptr, &total_size);
 127     TRACE("total size: %#x\n", total_size);
 128
 129     read_dword(&ptr, &chunk_count);
 130     TRACE("chunk count: %#x\n", chunk_count);
 131
 132     for (i = 0; i < chunk_count; ++i)
 133     {
 134         DWORD chunk_tag, chunk_size;
 135         const char *chunk_ptr;
 136         DWORD chunk_offset;
 137
 138         read_dword(&ptr, &chunk_offset);
 139         TRACE("chunk %u at offset %#x\n", i, chunk_offset);
 140
 141         chunk_ptr = data + chunk_offset;
 142
 143         read_dword(&chunk_ptr, &chunk_tag);
 144         read_dword(&chunk_ptr, &chunk_size);
 145
 146         hr = chunk_handler(chunk_ptr, chunk_size, chunk_tag, ctx);
 147         if (FAILED(hr)) break;
 148     }
 149
 150     return hr;
 151 }
 152
 153 static char *copy_name(const char *ptr)
 154 {
 155     size_t name_len;
 156     char *name;
 157
 158     name_len = strlen(ptr) + 1;
 159     name = HeapAlloc(GetProcessHeap(), 0, name_len);
 160     if (!name)
 161     {
 162         ERR("Failed to allocate name memory.\n");
 163         return NULL;
 164     }
 165
 166     memcpy(name, ptr, name_len);
 167
 168     return name;
 169 }
 170
 171 static HRESULT shader_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
 172 {
 173     struct d3d10_effect_shader_variable *s = ctx;
 174
 175     TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
 176
 177     TRACE("chunk size: %#x\n", data_size);
 178
 179     switch(tag)
 180     {
 181         case TAG_ISGN:
 182         {
 183             /* 32 (DXBC header) + 1 * 4 (chunk index) + 2 * 4 (chunk header) + data_size (chunk data) */
 184             UINT size = 44 + data_size;
 185             char *ptr;
 186
 187             s->input_signature = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 188             if (!s->input_signature)
 189             {
 190                 ERR("Failed to allocate input signature data\n");
 191                 return E_OUTOFMEMORY;
 192             }
 193             s->input_signature_size = size;
 194
 195             ptr = s->input_signature;
 196
 197             write_dword(&ptr, TAG_DXBC);
 198
 199             /* signature(?) */
 200             write_dword_unknown(&ptr, 0);
 201             write_dword_unknown(&ptr, 0);
 202             write_dword_unknown(&ptr, 0);
 203             write_dword_unknown(&ptr, 0);
 204
 205             /* seems to be always 1 */
 206             write_dword_unknown(&ptr, 1);
 207
 208             /* DXBC size */
 209             write_dword(&ptr, size);
 210
 211             /* chunk count */
 212             write_dword(&ptr, 1);
 213
 214             /* chunk index */
 215             write_dword(&ptr, (ptr - s->input_signature) + 4);
 216
 217             /* chunk */
 218             write_dword(&ptr, TAG_ISGN);
 219             write_dword(&ptr, data_size);
 220             memcpy(ptr, data, data_size);
 221             break;
 222         }
 223
 224         default:
 225             FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
 226             break;
 227     }
 228
 229     return S_OK;
 230 }
 231
 232 static HRESULT parse_shader(struct d3d10_effect_object *o, const char *data)
 233 {
 234     ID3D10Device *device = o->pass->technique->effect->device;
 235     struct d3d10_effect_shader_variable *s;
 236     const char *ptr = data;
 237     DWORD dxbc_size;
 238     HRESULT hr;
 239
 240     o->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct d3d10_effect_shader_variable));
 241     if (!o->data)
 242     {
 243         ERR("Failed to allocate shader variable memory\n");
 244         return E_OUTOFMEMORY;
 245     }
 246
 247     if (!ptr) return S_OK;
 248
 249     s = o->data;
 250
 251     read_dword(&ptr, &dxbc_size);
 252     TRACE("dxbc size: %#x\n", dxbc_size);
 253
 254     switch (o->type)
 255     {
 256         case D3D10_EOT_VERTEXSHADER:
 257             hr = ID3D10Device_CreateVertexShader(device, ptr, dxbc_size, &s->shader.vs);
 258             if (FAILED(hr)) return hr;
 259             break;
 260
 261         case D3D10_EOT_PIXELSHADER:
 262             hr = ID3D10Device_CreatePixelShader(device, ptr, dxbc_size, &s->shader.ps);
 263             if (FAILED(hr)) return hr;
 264             break;
 265         case D3D10_EOT_GEOMETRYSHADER:
 266             hr = ID3D10Device_CreateGeometryShader(device, ptr, dxbc_size, &s->shader.gs);
 267             if (FAILED(hr)) return hr;
 268             break;
 269     }
 270
 271     return parse_dxbc(ptr, dxbc_size, shader_chunk_handler, s);
 272 }
 273
 274 static D3D10_SHADER_VARIABLE_CLASS d3d10_variable_class(DWORD c)
 275 {
 276     switch (c)
 277     {
 278         case 1: return D3D10_SVC_SCALAR;
 279         case 2: return D3D10_SVC_VECTOR;
 280         case 3: return D3D10_SVC_MATRIX_ROWS;
 281         default:
 282             FIXME("Unknown variable class %#x.\n", c);
 283             return 0;
 284     }
 285 }
 286
 287 static D3D10_SHADER_VARIABLE_TYPE d3d10_variable_type(DWORD t)
 288 {
 289     switch (t)
 290     {
 291         case 1: return D3D10_SVT_FLOAT;
 292         case 2: return D3D10_SVT_INT;
 293         case 3: return D3D10_SVT_UINT;
 294         case 4: return D3D10_SVT_BOOL;
 295         default:
 296             FIXME("Unknown variable type %#x.\n", t);
 297             return 0;
 298     }
 299 }
 300
 301 static HRESULT parse_fx10_type(struct d3d10_effect_type *t, const char *ptr, const char *data)
 302 {
 303     DWORD unknown0;
 304     DWORD offset;
 305
 306     read_dword(&ptr, &offset);
 307     TRACE("Type name at offset %#x.\n", offset);
 308
 309     t->name = copy_name(data + offset);
 310     if (!t->name)
 311     {
 312         ERR("Failed to copy name.\n");
 313         return E_OUTOFMEMORY;
 314     }
 315     TRACE("Type name: %s.\n", debugstr_a(t->name));
 316
 317     read_dword(&ptr, &unknown0);
 318     TRACE("Unknown 0: %u.\n", unknown0);
 319
 320     read_dword(&ptr, &t->element_count);
 321     TRACE("Element count: %u.\n", t->element_count);
 322
 323     read_dword(&ptr, &t->size_unpacked);
 324     TRACE("Unpacked size: %#x.\n", t->size_unpacked);
 325
 326     read_dword(&ptr, &t->stride);
 327     TRACE("Stride: %#x.\n", t->stride);
 328
 329     read_dword(&ptr, &t->size_packed);
 330     TRACE("Packed size %#x.\n", t->size_packed);
 331
 332     if (unknown0 == 1)
 333     {
 334         DWORD tmp;
 335
 336         t->member_count = 0;
 337
 338         read_dword(&ptr, &tmp);
 339         t->column_count = (tmp & D3D10_FX10_TYPE_COLUMN_MASK) >> D3D10_FX10_TYPE_COLUMN_SHIFT;
 340         t->row_count = (tmp & D3D10_FX10_TYPE_ROW_MASK) >> D3D10_FX10_TYPE_ROW_SHIFT;
 341         t->basetype = d3d10_variable_type((tmp & D3D10_FX10_TYPE_BASETYPE_MASK) >> D3D10_FX10_TYPE_BASETYPE_SHIFT);
 342         t->type_class = d3d10_variable_class((tmp & D3D10_FX10_TYPE_CLASS_MASK) >> D3D10_FX10_TYPE_CLASS_SHIFT);
 343
 344         TRACE("Type description: %#x.\n", tmp);
 345         TRACE("\tcolumns: %u.\n", t->column_count);
 346         TRACE("\trows: %u.\n", t->row_count);
 347         TRACE("\tbasetype: %#x.\n", t->basetype);
 348         TRACE("\tclass: %#x.\n", t->type_class);
 349         TRACE("\tunknown bits: %#x.\n", tmp & ~(D3D10_FX10_TYPE_COLUMN_MASK | D3D10_FX10_TYPE_ROW_MASK
 350                 | D3D10_FX10_TYPE_BASETYPE_MASK | D3D10_FX10_TYPE_CLASS_MASK));
 351     }
 352     else if (unknown0 == 3)
 353     {
 354         unsigned int i;
 355         DWORD tmp;
 356
 357         TRACE("Type is a structure.\n");
 358
 359         read_dword(&ptr, &t->member_count);
 360         TRACE("Member count: %u.\n", t->member_count);
 361
 362         t->column_count = 0;
 363         t->row_count = 0;
 364         t->basetype = 0;
 365         t->type_class = D3D10_SVC_STRUCT;
 366
 367         for (i = 0; i < t->member_count; ++i)
 368         {
 369             read_dword(&ptr, &tmp);
 370             TRACE("Member %u name at offset %#x.\n", i, tmp);
 371             TRACE("Member %u name: %s.\n", i, debugstr_a(data + tmp));
 372
 373             /* Member semantic? */
 374             skip_dword_unknown(&ptr, 1);
 375
 376             read_dword(&ptr, &tmp);
 377             TRACE("Member %u offset in struct: %#x.\n", i, tmp);
 378
 379             read_dword(&ptr, &tmp);
 380             TRACE("Member %u type info at offset %#x.\n", i, tmp);
 381         }
 382     }
 383
 384     return S_OK;
 385 }
 386
 387 static struct d3d10_effect_type *get_fx10_type(struct d3d10_effect *effect, const char *data, DWORD offset)
 388 {
 389     struct d3d10_effect_type *type;
 390     struct wine_rb_entry *entry;
 391     HRESULT hr;
 392
 393     entry = wine_rb_get(&effect->types, &offset);
 394     if (entry)
 395     {
 396         TRACE("Returning existing type.\n");
 397         return WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
 398     }
 399
 400     type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*type));
 401     if (!type)
 402     {
 403         ERR("Failed to allocate type memory.\n");
 404         return NULL;
 405     }
 406
 407     type->vtbl = &d3d10_effect_type_vtbl;
 408     type->id = offset;
 409     hr = parse_fx10_type(type, data + offset, data);
 410     if (FAILED(hr))
 411     {
 412         ERR("Failed to parse type info, hr %#x.\n", hr);
 413         HeapFree(GetProcessHeap(), 0, type);
 414         return NULL;
 415     }
 416
 417     if (wine_rb_put(&effect->types, &offset, &type->entry) == -1)
 418     {
 419         ERR("Failed to insert type entry.\n");
 420         HeapFree(GetProcessHeap(), 0, type);
 421         return NULL;
 422     }
 423
 424     return type;
 425 }
 426
 427 static HRESULT parse_fx10_variable_head(struct d3d10_effect_variable *v, const char **ptr, const char *data)
 428 {
 429     DWORD offset;
 430
 431     read_dword(ptr, &offset);
 432     TRACE("Variable name at offset %#x.\n", offset);
 433
 434     v->name = copy_name(data + offset);
 435     if (!v->name)
 436     {
 437         ERR("Failed to copy name.\n");
 438         return E_OUTOFMEMORY;
 439     }
 440     TRACE("Variable name: %s.\n", debugstr_a(v->name));
 441
 442     read_dword(ptr, &offset);
 443     TRACE("Variable type info at offset %#x.\n", offset);
 444
 445     v->type = get_fx10_type(v->effect, data, offset);
 446     if (!v->type)
 447     {
 448         ERR("Failed to get variable type.\n");
 449         return E_FAIL;
 450     }
 451
 452     return S_OK;
 453 }
 454
 455 static HRESULT parse_fx10_annotation(struct d3d10_effect_variable *a, const char **ptr, const char *data)
 456 {
 457     HRESULT hr;
 458
 459     hr = parse_fx10_variable_head(a, ptr, data);
 460     if (FAILED(hr)) return hr;
 461
 462     skip_dword_unknown(ptr, 1);
 463
 464     return S_OK;
 465 }
 466
 467 static HRESULT parse_fx10_object(struct d3d10_effect_object *o, const char **ptr, const char *data)
 468 {
 469     const char *data_ptr;
 470     DWORD offset;
 471     HRESULT hr;
 472
 473     read_dword(ptr, &o->type);
 474     TRACE("Effect object is of type %#x.\n", o->type);
 475
 476     skip_dword_unknown(ptr, 2);
 477
 478     read_dword(ptr, &offset);
 479     TRACE("Effect object idx is at offset %#x.\n", offset);
 480
 481     data_ptr = data + offset;
 482     read_dword(&data_ptr, &offset);
 483
 484     TRACE("Effect object starts at offset %#x.\n", offset);
 485
 486     /* FIXME: This probably isn't completely correct. */
 487     if (offset == 1)
 488     {
 489         WARN("Skipping effect object.\n");
 490         data_ptr = NULL;
 491     }
 492     else
 493     {
 494         data_ptr = data + offset;
 495     }
 496
 497     switch (o->type)
 498     {
 499         case D3D10_EOT_VERTEXSHADER:
 500             TRACE("Vertex shader\n");
 501             hr = parse_shader(o, data_ptr);
 502             break;
 503
 504         case D3D10_EOT_PIXELSHADER:
 505             TRACE("Pixel shader\n");
 506             hr = parse_shader(o, data_ptr);
 507             break;
 508
 509         case D3D10_EOT_GEOMETRYSHADER:
 510             TRACE("Geometry shader\n");
 511             hr = parse_shader(o, data_ptr);
 512             break;
 513
 514         default:
 515             FIXME("Unhandled object type %#x\n", o->type);
 516             hr = E_FAIL;
 517             break;
 518     }
 519
 520     return hr;
 521 }
 522
 523 static HRESULT parse_fx10_pass(struct d3d10_effect_pass *p, const char **ptr, const char *data)
 524 {
 525     HRESULT hr = S_OK;
 526     unsigned int i;
 527     DWORD offset;
 528
 529     read_dword(ptr, &offset);
 530     TRACE("Pass name at offset %#x.\n", offset);
 531
 532     p->name = copy_name(data + offset);
 533     if (!p->name)
 534     {
 535         ERR("Failed to copy name.\n");
 536         return E_OUTOFMEMORY;
 537     }
 538     TRACE("Pass name: %s.\n", debugstr_a(p->name));
 539
 540     read_dword(ptr, &p->object_count);
 541     TRACE("Pass has %u effect objects.\n", p->object_count);
 542
 543     read_dword(ptr, &p->annotation_count);
 544     TRACE("Pass has %u annotations.\n", p->annotation_count);
 545
 546     p->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, p->annotation_count * sizeof(*p->annotations));
 547     if (!p->annotations)
 548     {
 549         ERR("Failed to allocate pass annotations memory.\n");
 550         return E_OUTOFMEMORY;
 551     }
 552
 553     for(i = 0; i < p->annotation_count; ++i)
 554     {
 555         struct d3d10_effect_variable *a = &p->annotations[i];
 556
 557         a->vtbl = &d3d10_effect_variable_vtbl;
 558         a->effect = p->technique->effect;
 559
 560         hr = parse_fx10_annotation(a, ptr, data);
 561         if (FAILED(hr)) return hr;
 562     }
 563
 564     p->objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, p->object_count * sizeof(*p->objects));
 565     if (!p->objects)
 566     {
 567         ERR("Failed to allocate effect objects memory.\n");
 568         return E_OUTOFMEMORY;
 569     }
 570
 571     for (i = 0; i < p->object_count; ++i)
 572     {
 573         struct d3d10_effect_object *o = &p->objects[i];
 574
 575         o->pass = p;
 576
 577         hr = parse_fx10_object(o, ptr, data);
 578         if (FAILED(hr)) return hr;
 579     }
 580
 581     return hr;
 582 }
 583
 584 static HRESULT parse_fx10_technique(struct d3d10_effect_technique *t, const char **ptr, const char *data)
 585 {
 586     unsigned int i;
 587     DWORD offset;
 588     HRESULT hr;
 589
 590     read_dword(ptr, &offset);
 591     TRACE("Technique name at offset %#x.\n", offset);
 592
 593     t->name = copy_name(data + offset);
 594     if (!t->name)
 595     {
 596         ERR("Failed to copy name.\n");
 597         return E_OUTOFMEMORY;
 598     }
 599     TRACE("Technique name: %s.\n", debugstr_a(t->name));
 600
 601     read_dword(ptr, &t->pass_count);
 602     TRACE("Technique has %u passes\n", t->pass_count);
 603
 604     read_dword(ptr, &t->annotation_count);
 605     TRACE("Technique has %u annotations.\n", t->annotation_count);
 606
 607     t->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->annotation_count * sizeof(*t->annotations));
 608     if (!t->annotations)
 609     {
 610         ERR("Failed to allocate technique annotations memory.\n");
 611         return E_OUTOFMEMORY;
 612     }
 613
 614     for(i = 0; i < t->annotation_count; ++i)
 615     {
 616         struct d3d10_effect_variable *a = &t->annotations[i];
 617
 618         a->vtbl = &d3d10_effect_variable_vtbl;
 619         a->effect = t->effect;
 620
 621         hr = parse_fx10_annotation(a, ptr, data);
 622         if (FAILED(hr)) return hr;
 623     }
 624
 625     t->passes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->pass_count * sizeof(*t->passes));
 626     if (!t->passes)
 627     {
 628         ERR("Failed to allocate passes memory\n");
 629         return E_OUTOFMEMORY;
 630     }
 631
 632     for (i = 0; i < t->pass_count; ++i)
 633     {
 634         struct d3d10_effect_pass *p = &t->passes[i];
 635
 636         p->vtbl = &d3d10_effect_pass_vtbl;
 637         p->technique = t;
 638
 639         hr = parse_fx10_pass(p, ptr, data);
 640         if (FAILED(hr)) return hr;
 641     }
 642
 643     return S_OK;
 644 }
 645
 646 static HRESULT parse_fx10_variable(struct d3d10_effect_variable *v, const char **ptr, const char *data)
 647 {
 648     unsigned int i;
 649     HRESULT hr;
 650
 651     hr = parse_fx10_variable_head(v, ptr, data);
 652     if (FAILED(hr)) return hr;
 653
 654     switch (v->type->type_class)
 655     {
 656         case D3D10_SVC_SCALAR:
 657             v->vtbl = (ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl;
 658             break;
 659
 660         case D3D10_SVC_VECTOR:
 661             v->vtbl = (ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl;
 662             break;
 663
 664         case D3D10_SVC_MATRIX_ROWS:
 665         case D3D10_SVC_MATRIX_COLUMNS:
 666             v->vtbl = (ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl;
 667             break;
 668
 669         default:
 670             FIXME("Unhandled type class %s.\n", debug_d3d10_shader_variable_class(v->type->type_class));
 671             v->vtbl = &d3d10_effect_variable_vtbl;
 672             break;
 673     }
 674
 675     skip_dword_unknown(ptr, 1);
 676
 677     read_dword(ptr, &v->buffer_offset);
 678     TRACE("Variable offset in buffer: %#x.\n", v->buffer_offset);
 679
 680     skip_dword_unknown(ptr, 1);
 681
 682     read_dword(ptr, &v->flag);
 683     TRACE("Variable flag: %#x.\n", v->flag);
 684
 685     read_dword(ptr, &v->annotation_count);
 686     TRACE("Variable has %u annotations.\n", v->annotation_count);
 687
 688     v->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, v->annotation_count * sizeof(*v->annotations));
 689     if (!v->annotations)
 690     {
 691         ERR("Failed to allocate variable annotations memory.\n");
 692         return E_OUTOFMEMORY;
 693     }
 694
 695     for(i = 0; i < v->annotation_count; ++i)
 696     {
 697         struct d3d10_effect_variable *a = &v->annotations[i];
 698         HRESULT hr;
 699
 700         a->vtbl = &d3d10_effect_variable_vtbl;
 701         a->effect = v->effect;
 702
 703         hr = parse_fx10_annotation(a, ptr, data);
 704         if (FAILED(hr)) return hr;
 705     }
 706
 707     return S_OK;
 708 }
 709
 710 static HRESULT parse_fx10_local_buffer(struct d3d10_effect_local_buffer *l, const char **ptr, const char *data)
 711 {
 712     unsigned int i;
 713     DWORD offset;
 714     HRESULT hr;
 715
 716     read_dword(ptr, &offset);
 717     TRACE("Local buffer name at offset %#x.\n", offset);
 718
 719     l->name = copy_name(data + offset);
 720     if (!l->name)
 721     {
 722         ERR("Failed to copy name.\n");
 723         return E_OUTOFMEMORY;
 724     }
 725     TRACE("Local buffer name: %s.\n", debugstr_a(l->name));
 726
 727     read_dword(ptr, &l->data_size);
 728     TRACE("Local buffer data size: %#x.\n", l->data_size);
 729
 730     skip_dword_unknown(ptr, 1);
 731
 732     read_dword(ptr, &l->variable_count);
 733     TRACE("Local buffer variable count: %#x.\n", l->variable_count);
 734
 735     skip_dword_unknown(ptr, 1);
 736
 737     read_dword(ptr, &l->annotation_count);
 738     TRACE("Local buffer has %u annotations.\n", l->annotation_count);
 739
 740     l->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->annotation_count * sizeof(*l->annotations));
 741     if (!l->annotations)
 742     {
 743         ERR("Failed to allocate local buffer annotations memory.\n");
 744         return E_OUTOFMEMORY;
 745     }
 746
 747     for(i = 0; i < l->annotation_count; ++i)
 748     {
 749         struct d3d10_effect_variable *a = &l->annotations[i];
 750
 751         a->vtbl = &d3d10_effect_variable_vtbl;
 752         a->effect = l->effect;
 753
 754         hr = parse_fx10_annotation(a, ptr, data);
 755         if (FAILED(hr)) return hr;
 756     }
 757
 758     l->variables = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->variable_count * sizeof(*l->variables));
 759     if (!l->variables)
 760     {
 761         ERR("Failed to allocate variables memory.\n");
 762         return E_OUTOFMEMORY;
 763     }
 764
 765     for (i = 0; i < l->variable_count; ++i)
 766     {
 767         struct d3d10_effect_variable *v = &l->variables[i];
 768
 769         v->buffer = l;
 770         v->effect = l->effect;
 771
 772         hr = parse_fx10_variable(v, ptr, data);
 773         if (FAILED(hr)) return hr;
 774     }
 775
 776     return S_OK;
 777 }
 778
 779 static int d3d10_effect_type_compare(const void *key, const struct wine_rb_entry *entry)
 780 {
 781     const struct d3d10_effect_type *t = WINE_RB_ENTRY_VALUE(entry, const struct d3d10_effect_type, entry);
 782     const DWORD *id = key;
 783
 784     return *id - t->id;
 785 }
 786
 787 static void d3d10_effect_type_destroy(struct wine_rb_entry *entry, void *context)
 788 {
 789     struct d3d10_effect_type *t = WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
 790
 791     TRACE("effect type %p.\n", t);
 792
 793     HeapFree(GetProcessHeap(), 0, t->name);
 794     HeapFree(GetProcessHeap(), 0, t);
 795 }
 796
 797 static const struct wine_rb_functions d3d10_effect_type_rb_functions =
 798 {
 799     d3d10_rb_alloc,
 800     d3d10_rb_realloc,
 801     d3d10_rb_free,
 802     d3d10_effect_type_compare,
 803 };
 804
 805 static HRESULT parse_fx10_body(struct d3d10_effect *e, const char *data, DWORD data_size)
 806 {
 807     const char *ptr = data + e->index_offset;
 808     unsigned int i;
 809     HRESULT hr;
 810
 811     if (wine_rb_init(&e->types, &d3d10_effect_type_rb_functions) == -1)
 812     {
 813         ERR("Failed to initialize type rbtree.\n");
 814         return E_FAIL;
 815     }
 816
 817     e->local_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->local_buffer_count * sizeof(*e->local_buffers));
 818     if (!e->local_buffers)
 819     {
 820         ERR("Failed to allocate local buffer memory.\n");
 821         return E_OUTOFMEMORY;
 822     }
 823
 824     e->techniques = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->technique_count * sizeof(*e->techniques));
 825     if (!e->techniques)
 826     {
 827         ERR("Failed to allocate techniques memory\n");
 828         return E_OUTOFMEMORY;
 829     }
 830
 831     for (i = 0; i < e->local_buffer_count; ++i)
 832     {
 833         struct d3d10_effect_local_buffer *l = &e->local_buffers[i];
 834         l->vtbl = &d3d10_effect_constant_buffer_vtbl;
 835         l->effect = e;
 836
 837         hr = parse_fx10_local_buffer(l, &ptr, data);
 838         if (FAILED(hr)) return hr;
 839     }
 840
 841     for (i = 0; i < e->technique_count; ++i)
 842     {
 843         struct d3d10_effect_technique *t = &e->techniques[i];
 844
 845         t->vtbl = &d3d10_effect_technique_vtbl;
 846         t->effect = e;
 847
 848         hr = parse_fx10_technique(t, &ptr, data);
 849         if (FAILED(hr)) return hr;
 850     }
 851
 852     return S_OK;
 853 }
 854
 855 static HRESULT parse_fx10(struct d3d10_effect *e, const char *data, DWORD data_size)
 856 {
 857     const char *ptr = data;
 858     DWORD unknown;
 859
 860     /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
 861     read_dword(&ptr, &e->version);
 862     TRACE("Target: %#x\n", e->version);
 863
 864     read_dword(&ptr, &e->local_buffer_count);
 865     TRACE("Local buffer count: %u.\n", e->local_buffer_count);
 866
 867     read_dword(&ptr, &e->variable_count);
 868     TRACE("Variable count: %u\n", e->variable_count);
 869
 870     read_dword(&ptr, &e->object_count);
 871     TRACE("Object count: %u\n", e->object_count);
 872
 873     read_dword(&ptr, &e->sharedbuffers_count);
 874     TRACE("Sharedbuffers count: %u\n", e->sharedbuffers_count);
 875
 876     /* Number of variables in shared buffers? */
 877     read_dword(&ptr, &unknown);
 878     FIXME("Unknown 0: %u\n", unknown);
 879
 880     read_dword(&ptr, &e->sharedobjects_count);
 881     TRACE("Sharedobjects count: %u\n", e->sharedobjects_count);
 882
 883     read_dword(&ptr, &e->technique_count);
 884     TRACE("Technique count: %u\n", e->technique_count);
 885
 886     read_dword(&ptr, &e->index_offset);
 887     TRACE("Index offset: %#x\n", e->index_offset);
 888
 889     read_dword(&ptr, &unknown);
 890     FIXME("Unknown 1: %u\n", unknown);
 891
 892     read_dword(&ptr, &e->texture_count);
 893     TRACE("Texture count: %u\n", e->texture_count);
 894
 895     read_dword(&ptr, &e->dephstencilstate_count);
 896     TRACE("Depthstencilstate count: %u\n", e->dephstencilstate_count);
 897
 898     read_dword(&ptr, &e->blendstate_count);
 899     TRACE("Blendstate count: %u\n", e->blendstate_count);
 900
 901     read_dword(&ptr, &e->rasterizerstate_count);
 902     TRACE("Rasterizerstate count: %u\n", e->rasterizerstate_count);
 903
 904     read_dword(&ptr, &e->samplerstate_count);
 905     TRACE("Samplerstate count: %u\n", e->samplerstate_count);
 906
 907     read_dword(&ptr, &e->rendertargetview_count);
 908     TRACE("Rendertargetview count: %u\n", e->rendertargetview_count);
 909
 910     read_dword(&ptr, &e->depthstencilview_count);
 911     TRACE("Depthstencilview count: %u\n", e->depthstencilview_count);
 912
 913     read_dword(&ptr, &e->shader_call_count);
 914     TRACE("Shader call count: %u\n", e->shader_call_count);
 915
 916     read_dword(&ptr, &e->shader_compile_count);
 917     TRACE("Shader compile count: %u\n", e->shader_compile_count);
 918
 919     return parse_fx10_body(e, ptr, data_size - (ptr - data));
 920 }
 921
 922 static HRESULT fx10_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
 923 {
 924     struct d3d10_effect *e = ctx;
 925
 926     TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
 927
 928     TRACE("chunk size: %#x\n", data_size);
 929
 930     switch(tag)
 931     {
 932         case TAG_FX10:
 933             return parse_fx10(e, data, data_size);
 934
 935         default:
 936             FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
 937             return S_OK;
 938     }
 939 }
 940
 941 HRESULT d3d10_effect_parse(struct d3d10_effect *This, const void *data, SIZE_T data_size)
 942 {
 943     return parse_dxbc(data, data_size, fx10_chunk_handler, This);
 944 }
 945
 946 static void d3d10_effect_object_destroy(struct d3d10_effect_object *o)
 947 {
 948     TRACE("effect object %p.\n", o);
 949
 950     switch(o->type)
 951     {
 952         case D3D10_EOT_VERTEXSHADER:
 953         case D3D10_EOT_PIXELSHADER:
 954         case D3D10_EOT_GEOMETRYSHADER:
 955             HeapFree(GetProcessHeap(), 0, ((struct d3d10_effect_shader_variable *)o->data)->input_signature);
 956             break;
 957
 958         default:
 959             break;
 960     }
 961     HeapFree(GetProcessHeap(), 0, o->data);
 962 }
 963
 964 static HRESULT d3d10_effect_object_apply(struct d3d10_effect_object *o)
 965 {
 966     ID3D10Device *device = o->pass->technique->effect->device;
 967
 968     TRACE("effect object %p, type %#x.\n", o, o->type);
 969
 970     switch(o->type)
 971     {
 972         case D3D10_EOT_VERTEXSHADER:
 973             ID3D10Device_VSSetShader(device, ((struct d3d10_effect_shader_variable *)o->data)->shader.vs);
 974             return S_OK;
 975
 976         case D3D10_EOT_PIXELSHADER:
 977             ID3D10Device_PSSetShader(device, ((struct d3d10_effect_shader_variable *)o->data)->shader.ps);
 978             return S_OK;
 979
 980         case D3D10_EOT_GEOMETRYSHADER:
 981             ID3D10Device_GSSetShader(device, ((struct d3d10_effect_shader_variable *)o->data)->shader.gs);
 982             return S_OK;
 983
 984         default:
 985             FIXME("Unhandled effect object type %#x.\n", o->type);
 986             return E_FAIL;
 987     }
 988 }
 989
 990 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable *v)
 991 {
 992     TRACE("variable %p.\n", v);
 993
 994     HeapFree(GetProcessHeap(), 0, v->name);
 995     if (v->annotations)
 996     {
 997         unsigned int i;
 998         for (i = 0; i < v->annotation_count; ++i)
 999         {
1000             d3d10_effect_variable_destroy(&v->annotations[i]);
1001         }
1002         HeapFree(GetProcessHeap(), 0, v->annotations);
1003     }
1004 }
1005
1006 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass *p)
1007 {
1008     unsigned int i;
1009
1010     TRACE("pass %p\n", p);
1011
1012     HeapFree(GetProcessHeap(), 0, p->name);
1013     if (p->objects)
1014     {
1015         for (i = 0; i < p->object_count; ++i)
1016         {
1017             d3d10_effect_object_destroy(&p->objects[i]);
1018         }
1019         HeapFree(GetProcessHeap(), 0, p->objects);
1020     }
1021
1022     if (p->annotations)
1023     {
1024         for (i = 0; i < p->annotation_count; ++i)
1025         {
1026             d3d10_effect_variable_destroy(&p->annotations[i]);
1027         }
1028         HeapFree(GetProcessHeap(), 0, p->annotations);
1029     }
1030
1031 }
1032
1033 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique *t)
1034 {
1035     unsigned int i;
1036
1037     TRACE("technique %p\n", t);
1038
1039     HeapFree(GetProcessHeap(), 0, t->name);
1040     if (t->passes)
1041     {
1042         for (i = 0; i < t->pass_count; ++i)
1043         {
1044             d3d10_effect_pass_destroy(&t->passes[i]);
1045         }
1046         HeapFree(GetProcessHeap(), 0, t->passes);
1047     }
1048
1049     if (t->annotations)
1050     {
1051         for (i = 0; i < t->annotation_count; ++i)
1052         {
1053             d3d10_effect_variable_destroy(&t->annotations[i]);
1054         }
1055         HeapFree(GetProcessHeap(), 0, t->annotations);
1056     }
1057 }
1058
1059 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_local_buffer *l)
1060 {
1061     unsigned int i;
1062
1063     TRACE("local buffer %p.\n", l);
1064
1065     HeapFree(GetProcessHeap(), 0, l->name);
1066     if (l->variables)
1067     {
1068         for (i = 0; i < l->variable_count; ++i)
1069         {
1070             d3d10_effect_variable_destroy(&l->variables[i]);
1071         }
1072         HeapFree(GetProcessHeap(), 0, l->variables);
1073     }
1074
1075     if (l->annotations)
1076     {
1077         for (i = 0; i < l->annotation_count; ++i)
1078         {
1079             d3d10_effect_variable_destroy(&l->annotations[i]);
1080         }
1081         HeapFree(GetProcessHeap(), 0, l->annotations);
1082     }
1083 }
1084
1085 /* IUnknown methods */
1086
1087 static HRESULT STDMETHODCALLTYPE d3d10_effect_QueryInterface(ID3D10Effect *iface, REFIID riid, void **object)
1088 {
1089     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
1090
1091     if (IsEqualGUID(riid, &IID_ID3D10Effect)
1092             || IsEqualGUID(riid, &IID_IUnknown))
1093     {
1094         IUnknown_AddRef(iface);
1095         *object = iface;
1096         return S_OK;
1097     }
1098
1099     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
1100
1101     *object = NULL;
1102     return E_NOINTERFACE;
1103 }
1104
1105 static ULONG STDMETHODCALLTYPE d3d10_effect_AddRef(ID3D10Effect *iface)
1106 {
1107     struct d3d10_effect *This = (struct d3d10_effect *)iface;
1108     ULONG refcount = InterlockedIncrement(&This->refcount);
1109
1110     TRACE("%p increasing refcount to %u\n", This, refcount);
1111
1112     return refcount;
1113 }
1114
1115 static ULONG STDMETHODCALLTYPE d3d10_effect_Release(ID3D10Effect *iface)
1116 {
1117     struct d3d10_effect *This = (struct d3d10_effect *)iface;
1118     ULONG refcount = InterlockedDecrement(&This->refcount);
1119
1120     TRACE("%p decreasing refcount to %u\n", This, refcount);
1121
1122     if (!refcount)
1123     {
1124         unsigned int i;
1125
1126         if (This->techniques)
1127         {
1128             for (i = 0; i < This->technique_count; ++i)
1129             {
1130                 d3d10_effect_technique_destroy(&This->techniques[i]);
1131             }
1132             HeapFree(GetProcessHeap(), 0, This->techniques);
1133         }
1134
1135         if (This->local_buffers)
1136         {
1137             for (i = 0; i < This->local_buffer_count; ++i)
1138             {
1139                 d3d10_effect_local_buffer_destroy(&This->local_buffers[i]);
1140             }
1141             HeapFree(GetProcessHeap(), 0, This->local_buffers);
1142         }
1143
1144         wine_rb_destroy(&This->types, d3d10_effect_type_destroy, NULL);
1145
1146         ID3D10Device_Release(This->device);
1147         HeapFree(GetProcessHeap(), 0, This);
1148     }
1149
1150     return refcount;
1151 }
1152
1153 /* ID3D10Effect methods */
1154
1155 static BOOL STDMETHODCALLTYPE d3d10_effect_IsValid(ID3D10Effect *iface)
1156 {
1157     FIXME("iface %p stub!\n", iface);
1158
1159     return FALSE;
1160 }
1161
1162 static BOOL STDMETHODCALLTYPE d3d10_effect_IsPool(ID3D10Effect *iface)
1163 {
1164     FIXME("iface %p stub!\n", iface);
1165
1166     return FALSE;
1167 }
1168
1169 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDevice(ID3D10Effect *iface, ID3D10Device **device)
1170 {
1171     struct d3d10_effect *This = (struct d3d10_effect *)iface;
1172
1173     TRACE("iface %p, device %p\n", iface, device);
1174
1175     ID3D10Device_AddRef(This->device);
1176     *device = This->device;
1177
1178     return S_OK;
1179 }
1180
1181 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDesc(ID3D10Effect *iface, D3D10_EFFECT_DESC *desc)
1182 {
1183     FIXME("iface %p, desc %p stub!\n", iface, desc);
1184
1185     return E_NOTIMPL;
1186 }
1187
1188 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByIndex(ID3D10Effect *iface,
1189         UINT index)
1190 {
1191     struct d3d10_effect *This = (struct d3d10_effect *)iface;
1192     struct d3d10_effect_local_buffer *l;
1193
1194     TRACE("iface %p, index %u\n", iface, index);
1195
1196     if (index >= This->local_buffer_count)
1197     {
1198         WARN("Invalid index specified\n");
1199         return (ID3D10EffectConstantBuffer *)&null_local_buffer;
1200     }
1201
1202     l = &This->local_buffers[index];
1203
1204     TRACE("Returning buffer %p, %s.\n", l, debugstr_a(l->name));
1205
1206     return (ID3D10EffectConstantBuffer *)l;
1207 }
1208
1209 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByName(ID3D10Effect *iface,
1210         LPCSTR name)
1211 {
1212     struct d3d10_effect *This = (struct d3d10_effect *)iface;
1213     unsigned int i;
1214
1215     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
1216
1217     for (i = 0; i < This->local_buffer_count; ++i)
1218     {
1219         struct d3d10_effect_local_buffer *l = &This->local_buffers[i];
1220
1221         if (!strcmp(l->name, name))
1222         {
1223             TRACE("Returning buffer %p.\n", l);
1224             return (ID3D10EffectConstantBuffer *)l;
1225         }
1226     }
1227
1228     WARN("Invalid name specified\n");
1229
1230     return (ID3D10EffectConstantBuffer *)&null_local_buffer;
1231 }
1232
1233 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByIndex(ID3D10Effect *iface, UINT index)
1234 {
1235     FIXME("iface %p, index %u stub!\n", iface, index);
1236
1237     return NULL;
1238 }
1239
1240 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByName(ID3D10Effect *iface, LPCSTR name)
1241 {
1242     struct d3d10_effect *This = (struct d3d10_effect *)iface;
1243     unsigned int i;
1244
1245     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
1246
1247     for (i = 0; i < This->local_buffer_count; ++i)
1248     {
1249         struct d3d10_effect_local_buffer *l = &This->local_buffers[i];
1250         unsigned int j;
1251
1252         for (j = 0; j < l->variable_count; ++j)
1253         {
1254             struct d3d10_effect_variable *v = &l->variables[j];
1255
1256             if (!strcmp(v->name, name))
1257             {
1258                 TRACE("Returning variable %p.\n", v);
1259                 return (ID3D10EffectVariable *)v;
1260             }
1261         }
1262     }
1263
1264     WARN("Invalid name specified\n");
1265
1266     return (ID3D10EffectVariable *)&null_variable;
1267 }
1268
1269 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableBySemantic(ID3D10Effect *iface,
1270         LPCSTR semantic)
1271 {
1272     FIXME("iface %p, semantic %s stub!\n", iface, debugstr_a(semantic));
1273
1274     return NULL;
1275 }
1276
1277 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByIndex(ID3D10Effect *iface,
1278         UINT index)
1279 {
1280     struct d3d10_effect *This = (struct d3d10_effect *)iface;
1281     struct d3d10_effect_technique *t;
1282
1283     TRACE("iface %p, index %u\n", iface, index);
1284
1285     if (index >= This->technique_count)
1286     {
1287         WARN("Invalid index specified\n");
1288         return (ID3D10EffectTechnique *)&null_technique;
1289     }
1290
1291     t = &This->techniques[index];
1292
1293     TRACE("Returning technique %p, %s.\n", t, debugstr_a(t->name));
1294
1295     return (ID3D10EffectTechnique *)t;
1296 }
1297
1298 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByName(ID3D10Effect *iface,
1299         LPCSTR name)
1300 {
1301     struct d3d10_effect *This = (struct d3d10_effect *)iface;
1302     unsigned int i;
1303
1304     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
1305
1306     for (i = 0; i < This->technique_count; ++i)
1307     {
1308         struct d3d10_effect_technique *t = &This->techniques[i];
1309         if (!strcmp(t->name, name))
1310         {
1311             TRACE("Returning technique %p\n", t);
1312             return (ID3D10EffectTechnique *)t;
1313         }
1314     }
1315
1316     WARN("Invalid name specified\n");
1317
1318     return (ID3D10EffectTechnique *)&null_technique;
1319 }
1320
1321 static HRESULT STDMETHODCALLTYPE d3d10_effect_Optimize(ID3D10Effect *iface)
1322 {
1323     FIXME("iface %p stub!\n", iface);
1324
1325     return E_NOTIMPL;
1326 }
1327
1328 static BOOL STDMETHODCALLTYPE d3d10_effect_IsOptimized(ID3D10Effect *iface)
1329 {
1330     FIXME("iface %p stub!\n", iface);
1331
1332     return FALSE;
1333 }
1334
1335 const struct ID3D10EffectVtbl d3d10_effect_vtbl =
1336 {
1337     /* IUnknown methods */
1338     d3d10_effect_QueryInterface,
1339     d3d10_effect_AddRef,
1340     d3d10_effect_Release,
1341     /* ID3D10Effect methods */
1342     d3d10_effect_IsValid,
1343     d3d10_effect_IsPool,
1344     d3d10_effect_GetDevice,
1345     d3d10_effect_GetDesc,
1346     d3d10_effect_GetConstantBufferByIndex,
1347     d3d10_effect_GetConstantBufferByName,
1348     d3d10_effect_GetVariableByIndex,
1349     d3d10_effect_GetVariableByName,
1350     d3d10_effect_GetVariableBySemantic,
1351     d3d10_effect_GetTechniqueByIndex,
1352     d3d10_effect_GetTechniqueByName,
1353     d3d10_effect_Optimize,
1354     d3d10_effect_IsOptimized,
1355 };
1356
1357 /* ID3D10EffectTechnique methods */
1358
1359 static BOOL STDMETHODCALLTYPE d3d10_effect_technique_IsValid(ID3D10EffectTechnique *iface)
1360 {
1361     TRACE("iface %p\n", iface);
1362
1363     return (struct d3d10_effect_technique *)iface != &null_technique;
1364 }
1365
1366 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_GetDesc(ID3D10EffectTechnique *iface,
1367         D3D10_TECHNIQUE_DESC *desc)
1368 {
1369     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1370
1371     TRACE("iface %p, desc %p\n", iface, desc);
1372
1373     if(This == &null_technique)
1374     {
1375         WARN("Null technique specified\n");
1376         return E_FAIL;
1377     }
1378
1379     if(!desc)
1380     {
1381         WARN("Invalid argument specified\n");
1382         return E_INVALIDARG;
1383     }
1384
1385     desc->Name = This->name;
1386     desc->Passes = This->pass_count;
1387     desc->Annotations = This->annotation_count;
1388
1389     return S_OK;
1390 }
1391
1392 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByIndex(
1393         ID3D10EffectTechnique *iface, UINT index)
1394 {
1395     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1396     struct d3d10_effect_variable *a;
1397
1398     TRACE("iface %p, index %u\n", iface, index);
1399
1400     if (index >= This->annotation_count)
1401     {
1402         WARN("Invalid index specified\n");
1403         return (ID3D10EffectVariable *)&null_variable;
1404     }
1405
1406     a = &This->annotations[index];
1407
1408     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
1409
1410     return (ID3D10EffectVariable *)a;
1411 }
1412
1413 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByName(
1414         ID3D10EffectTechnique *iface, LPCSTR name)
1415 {
1416     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1417     unsigned int i;
1418
1419     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
1420
1421     for (i = 0; i < This->annotation_count; ++i)
1422     {
1423         struct d3d10_effect_variable *a = &This->annotations[i];
1424         if (!strcmp(a->name, name))
1425         {
1426             TRACE("Returning annotation %p\n", a);
1427             return (ID3D10EffectVariable *)a;
1428         }
1429     }
1430
1431     WARN("Invalid name specified\n");
1432
1433     return (ID3D10EffectVariable *)&null_variable;
1434 }
1435
1436 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique *iface,
1437         UINT index)
1438 {
1439     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1440     struct d3d10_effect_pass *p;
1441
1442     TRACE("iface %p, index %u\n", iface, index);
1443
1444     if (index >= This->pass_count)
1445     {
1446         WARN("Invalid index specified\n");
1447         return (ID3D10EffectPass *)&null_pass;
1448     }
1449
1450     p = &This->passes[index];
1451
1452     TRACE("Returning pass %p, %s.\n", p, debugstr_a(p->name));
1453
1454     return (ID3D10EffectPass *)p;
1455 }
1456
1457 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique *iface,
1458         LPCSTR name)
1459 {
1460     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1461     unsigned int i;
1462
1463     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
1464
1465     for (i = 0; i < This->pass_count; ++i)
1466     {
1467         struct d3d10_effect_pass *p = &This->passes[i];
1468         if (!strcmp(p->name, name))
1469         {
1470             TRACE("Returning pass %p\n", p);
1471             return (ID3D10EffectPass *)p;
1472         }
1473     }
1474
1475     WARN("Invalid name specified\n");
1476
1477     return (ID3D10EffectPass *)&null_pass;
1478 }
1479
1480 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique *iface,
1481         D3D10_STATE_BLOCK_MASK *mask)
1482 {
1483     FIXME("iface %p,mask %p stub!\n", iface, mask);
1484
1485     return E_NOTIMPL;
1486 }
1487
1488 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl =
1489 {
1490     /* ID3D10EffectTechnique methods */
1491     d3d10_effect_technique_IsValid,
1492     d3d10_effect_technique_GetDesc,
1493     d3d10_effect_technique_GetAnnotationByIndex,
1494     d3d10_effect_technique_GetAnnotationByName,
1495     d3d10_effect_technique_GetPassByIndex,
1496     d3d10_effect_technique_GetPassByName,
1497     d3d10_effect_technique_ComputeStateBlockMask,
1498 };
1499
1500 /* ID3D10EffectPass methods */
1501
1502 static BOOL STDMETHODCALLTYPE d3d10_effect_pass_IsValid(ID3D10EffectPass *iface)
1503 {
1504     TRACE("iface %p\n", iface);
1505
1506     return (struct d3d10_effect_pass *)iface != &null_pass;
1507 }
1508
1509 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetDesc(ID3D10EffectPass *iface, D3D10_PASS_DESC *desc)
1510 {
1511     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1512     unsigned int i;
1513
1514     FIXME("iface %p, desc %p partial stub!\n", iface, desc);
1515
1516     if(This == &null_pass)
1517     {
1518         WARN("Null pass specified\n");
1519         return E_FAIL;
1520     }
1521
1522     if(!desc)
1523     {
1524         WARN("Invalid argument specified\n");
1525         return E_INVALIDARG;
1526     }
1527
1528     memset(desc, 0, sizeof(*desc));
1529     desc->Name = This->name;
1530     for (i = 0; i < This->object_count; ++i)
1531     {
1532         struct d3d10_effect_object *o = &This->objects[i];
1533         if (o->type == D3D10_EOT_VERTEXSHADER)
1534         {
1535             struct d3d10_effect_shader_variable *s = o->data;
1536             desc->pIAInputSignature = (BYTE *)s->input_signature;
1537             desc->IAInputSignatureSize = s->input_signature_size;
1538             break;
1539         }
1540     }
1541
1542     return S_OK;
1543 }
1544
1545 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass *iface,
1546         D3D10_PASS_SHADER_DESC *desc)
1547 {
1548     FIXME("iface %p, desc %p stub!\n", iface, desc);
1549
1550     return E_NOTIMPL;
1551 }
1552
1553 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass *iface,
1554         D3D10_PASS_SHADER_DESC *desc)
1555 {
1556     FIXME("iface %p, desc %p stub!\n", iface, desc);
1557
1558     return E_NOTIMPL;
1559 }
1560
1561 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass *iface,
1562         D3D10_PASS_SHADER_DESC *desc)
1563 {
1564     FIXME("iface %p, desc %p stub!\n", iface, desc);
1565
1566     return E_NOTIMPL;
1567 }
1568
1569 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass *iface,
1570         UINT index)
1571 {
1572     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1573     struct d3d10_effect_variable *a;
1574
1575     TRACE("iface %p, index %u\n", iface, index);
1576
1577     if (index >= This->annotation_count)
1578     {
1579         WARN("Invalid index specified\n");
1580         return (ID3D10EffectVariable *)&null_variable;
1581     }
1582
1583     a = &This->annotations[index];
1584
1585     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
1586
1587     return (ID3D10EffectVariable *)a;
1588 }
1589
1590 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass *iface,
1591         LPCSTR name)
1592 {
1593     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1594
1595     return NULL;
1596 }
1597
1598 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_Apply(ID3D10EffectPass *iface, UINT flags)
1599 {
1600     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1601     HRESULT hr = S_OK;
1602     unsigned int i;
1603
1604     TRACE("iface %p, flags %#x\n", iface, flags);
1605
1606     if (flags) FIXME("Ignoring flags (%#x)\n", flags);
1607
1608     for (i = 0; i < This->object_count; ++i)
1609     {
1610         hr = d3d10_effect_object_apply(&This->objects[i]);
1611         if (FAILED(hr)) break;
1612     }
1613
1614     return hr;
1615 }
1616
1617 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass *iface,
1618         D3D10_STATE_BLOCK_MASK *mask)
1619 {
1620     FIXME("iface %p, mask %p stub!\n", iface, mask);
1621
1622     return E_NOTIMPL;
1623 }
1624
1625 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl =
1626 {
1627     /* ID3D10EffectPass methods */
1628     d3d10_effect_pass_IsValid,
1629     d3d10_effect_pass_GetDesc,
1630     d3d10_effect_pass_GetVertexShaderDesc,
1631     d3d10_effect_pass_GetGeometryShaderDesc,
1632     d3d10_effect_pass_GetPixelShaderDesc,
1633     d3d10_effect_pass_GetAnnotationByIndex,
1634     d3d10_effect_pass_GetAnnotationByName,
1635     d3d10_effect_pass_Apply,
1636     d3d10_effect_pass_ComputeStateBlockMask,
1637 };
1638
1639 /* ID3D10EffectVariable methods */
1640
1641 static BOOL STDMETHODCALLTYPE d3d10_effect_variable_IsValid(ID3D10EffectVariable *iface)
1642 {
1643     TRACE("iface %p\n", iface);
1644
1645     return (struct d3d10_effect_variable *)iface != &null_variable;
1646 }
1647
1648 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_variable_GetType(ID3D10EffectVariable *iface)
1649 {
1650     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1651
1652     TRACE("iface %p\n", iface);
1653
1654     return (ID3D10EffectType *)This->type;
1655 }
1656
1657 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetDesc(ID3D10EffectVariable *iface,
1658         D3D10_EFFECT_VARIABLE_DESC *desc)
1659 {
1660     FIXME("iface %p, desc %p stub!\n", iface, desc);
1661
1662     return E_NOTIMPL;
1663 }
1664
1665 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByIndex(
1666         ID3D10EffectVariable *iface, UINT index)
1667 {
1668     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1669     struct d3d10_effect_variable *a;
1670
1671     TRACE("iface %p, index %u\n", iface, index);
1672
1673     if (index >= This->annotation_count)
1674     {
1675         WARN("Invalid index specified\n");
1676         return (ID3D10EffectVariable *)&null_variable;
1677     }
1678
1679     a = &This->annotations[index];
1680
1681     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
1682
1683     return (ID3D10EffectVariable *)a;
1684 }
1685
1686 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByName(
1687         ID3D10EffectVariable *iface, LPCSTR name)
1688 {
1689     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1690
1691     return NULL;
1692 }
1693
1694 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByIndex(
1695         ID3D10EffectVariable *iface, UINT index)
1696 {
1697     FIXME("iface %p, index %u stub!\n", iface, index);
1698
1699     return NULL;
1700 }
1701
1702 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByName(
1703         ID3D10EffectVariable *iface, LPCSTR name)
1704 {
1705     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1706
1707     return NULL;
1708 }
1709
1710 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberBySemantic(
1711         ID3D10EffectVariable *iface, LPCSTR semantic)
1712 {
1713     FIXME("iface %p, semantic %s stub!\n", iface, debugstr_a(semantic));
1714
1715     return NULL;
1716 }
1717
1718 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetElement(
1719         ID3D10EffectVariable *iface, UINT index)
1720 {
1721     FIXME("iface %p, index %u stub!\n", iface, index);
1722
1723     return NULL;
1724 }
1725
1726 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_GetParentConstantBuffer(
1727         ID3D10EffectVariable *iface)
1728 {
1729     FIXME("iface %p stub!\n", iface);
1730
1731     return NULL;
1732 }
1733
1734 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsScalar(
1735         ID3D10EffectVariable *iface)
1736 {
1737     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1738
1739     TRACE("iface %p\n", iface);
1740
1741     if (This->vtbl == (ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl)
1742         return (ID3D10EffectScalarVariable *)This;
1743
1744     return (ID3D10EffectScalarVariable *)&null_scalar_variable;
1745 }
1746
1747 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsVector(
1748         ID3D10EffectVariable *iface)
1749 {
1750     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1751
1752     TRACE("iface %p\n", iface);
1753
1754     if (This->vtbl == (ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl)
1755         return (ID3D10EffectVectorVariable *)This;
1756
1757     return (ID3D10EffectVectorVariable *)&null_vector_variable;
1758 }
1759
1760 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsMatrix(
1761         ID3D10EffectVariable *iface)
1762 {
1763     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1764
1765     TRACE("iface %p\n", iface);
1766
1767     if (This->vtbl == (ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl)
1768         return (ID3D10EffectMatrixVariable *)This;
1769
1770     return (ID3D10EffectMatrixVariable *)&null_matrix_variable;
1771 }
1772
1773 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsString(
1774         ID3D10EffectVariable *iface)
1775 {
1776     FIXME("iface %p stub!\n", iface);
1777
1778     return NULL;
1779 }
1780
1781 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShaderResource(
1782         ID3D10EffectVariable *iface)
1783 {
1784     FIXME("iface %p stub!\n", iface);
1785
1786     return NULL;
1787 }
1788
1789 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRenderTargetView(
1790         ID3D10EffectVariable *iface)
1791 {
1792     FIXME("iface %p stub!\n", iface);
1793
1794     return NULL;
1795 }
1796
1797 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencilView(
1798         ID3D10EffectVariable *iface)
1799 {
1800     FIXME("iface %p stub!\n", iface);
1801
1802     return NULL;
1803 }
1804
1805 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_AsConstantBuffer(
1806         ID3D10EffectVariable *iface)
1807 {
1808     FIXME("iface %p stub!\n", iface);
1809
1810     return NULL;
1811 }
1812
1813 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShader(
1814         ID3D10EffectVariable *iface)
1815 {
1816     FIXME("iface %p stub!\n", iface);
1817
1818     return NULL;
1819 }
1820
1821 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsBlend(ID3D10EffectVariable *iface)
1822 {
1823     FIXME("iface %p stub!\n", iface);
1824
1825     return NULL;
1826 }
1827
1828 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencil(
1829         ID3D10EffectVariable *iface)
1830 {
1831     FIXME("iface %p stub!\n", iface);
1832
1833     return NULL;
1834 }
1835
1836 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRasterizer(
1837         ID3D10EffectVariable *iface)
1838 {
1839     FIXME("iface %p stub!\n", iface);
1840
1841     return NULL;
1842 }
1843
1844 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsSampler(
1845         ID3D10EffectVariable *iface)
1846 {
1847     FIXME("iface %p stub!\n", iface);
1848
1849     return NULL;
1850 }
1851
1852 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_SetRawValue(ID3D10EffectVariable *iface,
1853         void *data, UINT offset, UINT count)
1854 {
1855     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1856
1857     return E_NOTIMPL;
1858 }
1859
1860 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetRawValue(ID3D10EffectVariable *iface,
1861         void *data, UINT offset, UINT count)
1862 {
1863     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1864
1865     return E_NOTIMPL;
1866 }
1867
1868 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl =
1869 {
1870     /* ID3D10EffectVariable methods */
1871     d3d10_effect_variable_IsValid,
1872     d3d10_effect_variable_GetType,
1873     d3d10_effect_variable_GetDesc,
1874     d3d10_effect_variable_GetAnnotationByIndex,
1875     d3d10_effect_variable_GetAnnotationByName,
1876     d3d10_effect_variable_GetMemberByIndex,
1877     d3d10_effect_variable_GetMemberByName,
1878     d3d10_effect_variable_GetMemberBySemantic,
1879     d3d10_effect_variable_GetElement,
1880     d3d10_effect_variable_GetParentConstantBuffer,
1881     d3d10_effect_variable_AsScalar,
1882     d3d10_effect_variable_AsVector,
1883     d3d10_effect_variable_AsMatrix,
1884     d3d10_effect_variable_AsString,
1885     d3d10_effect_variable_AsShaderResource,
1886     d3d10_effect_variable_AsRenderTargetView,
1887     d3d10_effect_variable_AsDepthStencilView,
1888     d3d10_effect_variable_AsConstantBuffer,
1889     d3d10_effect_variable_AsShader,
1890     d3d10_effect_variable_AsBlend,
1891     d3d10_effect_variable_AsDepthStencil,
1892     d3d10_effect_variable_AsRasterizer,
1893     d3d10_effect_variable_AsSampler,
1894     d3d10_effect_variable_SetRawValue,
1895     d3d10_effect_variable_GetRawValue,
1896 };
1897
1898 /* ID3D10EffectVariable methods */
1899 static BOOL STDMETHODCALLTYPE d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer *iface)
1900 {
1901     TRACE("iface %p\n", iface);
1902
1903     return (struct d3d10_effect_local_buffer *)iface != &null_local_buffer;
1904 }
1905
1906 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer *iface)
1907 {
1908     FIXME("iface %p stub!\n", iface);
1909
1910     return NULL;
1911 }
1912
1913 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer *iface,
1914         D3D10_EFFECT_VARIABLE_DESC *desc)
1915 {
1916     FIXME("iface %p, desc %p stub!\n", iface, desc);
1917
1918     return E_NOTIMPL;
1919 }
1920
1921 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByIndex(
1922         ID3D10EffectConstantBuffer *iface, UINT index)
1923 {
1924     struct d3d10_effect_local_buffer *This = (struct d3d10_effect_local_buffer *)iface;
1925     struct d3d10_effect_variable *a;
1926
1927     TRACE("iface %p, index %u\n", iface, index);
1928
1929     if (index >= This->annotation_count)
1930     {
1931         WARN("Invalid index specified\n");
1932         return (ID3D10EffectVariable *)&null_variable;
1933     }
1934
1935     a = &This->annotations[index];
1936
1937     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
1938
1939     return (ID3D10EffectVariable *)a;
1940 }
1941
1942 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByName(
1943         ID3D10EffectConstantBuffer *iface, LPCSTR name)
1944 {
1945     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1946
1947     return NULL;
1948 }
1949
1950 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByIndex(
1951         ID3D10EffectConstantBuffer *iface, UINT index)
1952 {
1953     FIXME("iface %p, index %u stub!\n", iface, index);
1954
1955     return NULL;
1956 }
1957
1958 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByName(
1959         ID3D10EffectConstantBuffer *iface, LPCSTR name)
1960 {
1961     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1962
1963     return NULL;
1964 }
1965
1966 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberBySemantic(
1967         ID3D10EffectConstantBuffer *iface, LPCSTR semantic)
1968 {
1969     FIXME("iface %p, semantic %s stub!\n", iface, debugstr_a(semantic));
1970
1971     return NULL;
1972 }
1973
1974 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetElement(
1975         ID3D10EffectConstantBuffer *iface, UINT index)
1976 {
1977     FIXME("iface %p, index %u stub!\n", iface, index);
1978
1979     return NULL;
1980 }
1981
1982 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetParentConstantBuffer(
1983         ID3D10EffectConstantBuffer *iface)
1984 {
1985     FIXME("iface %p stub!\n", iface);
1986
1987     return NULL;
1988 }
1989
1990 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsScalar(
1991         ID3D10EffectConstantBuffer *iface)
1992 {
1993     FIXME("iface %p stub!\n", iface);
1994
1995     return NULL;
1996 }
1997
1998 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsVector(
1999         ID3D10EffectConstantBuffer *iface)
2000 {
2001     FIXME("iface %p stub!\n", iface);
2002
2003     return NULL;
2004 }
2005
2006 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsMatrix(
2007         ID3D10EffectConstantBuffer *iface)
2008 {
2009     FIXME("iface %p stub!\n", iface);
2010
2011     return NULL;
2012 }
2013
2014 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsString(
2015         ID3D10EffectConstantBuffer *iface)
2016 {
2017     FIXME("iface %p stub!\n", iface);
2018
2019     return NULL;
2020 }
2021
2022 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShaderResource(
2023         ID3D10EffectConstantBuffer *iface)
2024 {
2025     FIXME("iface %p stub!\n", iface);
2026
2027     return NULL;
2028 }
2029
2030 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRenderTargetView(
2031         ID3D10EffectConstantBuffer *iface)
2032 {
2033     FIXME("iface %p stub!\n", iface);
2034
2035     return NULL;
2036 }
2037
2038 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencilView(
2039         ID3D10EffectConstantBuffer *iface)
2040 {
2041     FIXME("iface %p stub!\n", iface);
2042
2043     return NULL;
2044 }
2045
2046 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsConstantBuffer(
2047         ID3D10EffectConstantBuffer *iface)
2048 {
2049     FIXME("iface %p stub!\n", iface);
2050
2051     return NULL;
2052 }
2053
2054 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShader(
2055         ID3D10EffectConstantBuffer *iface)
2056 {
2057     FIXME("iface %p stub!\n", iface);
2058
2059     return NULL;
2060 }
2061
2062 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer *iface)
2063 {
2064     FIXME("iface %p stub!\n", iface);
2065
2066     return NULL;
2067 }
2068
2069 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencil(
2070         ID3D10EffectConstantBuffer *iface)
2071 {
2072     FIXME("iface %p stub!\n", iface);
2073
2074     return NULL;
2075 }
2076
2077 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRasterizer(
2078         ID3D10EffectConstantBuffer *iface)
2079 {
2080     FIXME("iface %p stub!\n", iface);
2081
2082     return NULL;
2083 }
2084
2085 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsSampler(
2086         ID3D10EffectConstantBuffer *iface)
2087 {
2088     FIXME("iface %p stub!\n", iface);
2089
2090     return NULL;
2091 }
2092
2093 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer *iface,
2094         void *data, UINT offset, UINT count)
2095 {
2096     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2097
2098     return E_NOTIMPL;
2099 }
2100
2101 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer *iface,
2102         void *data, UINT offset, UINT count)
2103 {
2104     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2105
2106     return E_NOTIMPL;
2107 }
2108
2109 /* ID3D10EffectConstantBuffer methods */
2110 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer *iface,
2111         ID3D10Buffer *buffer)
2112 {
2113     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
2114
2115     return E_NOTIMPL;
2116 }
2117
2118 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer *iface,
2119         ID3D10Buffer **buffer)
2120 {
2121     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
2122
2123     return E_NOTIMPL;
2124 }
2125
2126 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer *iface,
2127         ID3D10ShaderResourceView *view)
2128 {
2129     FIXME("iface %p, view %p stub!\n", iface, view);
2130
2131     return E_NOTIMPL;
2132 }
2133
2134 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer *iface,
2135         ID3D10ShaderResourceView **view)
2136 {
2137     FIXME("iface %p, view %p stub!\n", iface, view);
2138
2139     return E_NOTIMPL;
2140 }
2141
2142 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl =
2143 {
2144     /* ID3D10EffectVariable methods */
2145     d3d10_effect_constant_buffer_IsValid,
2146     d3d10_effect_constant_buffer_GetType,
2147     d3d10_effect_constant_buffer_GetDesc,
2148     d3d10_effect_constant_buffer_GetAnnotationByIndex,
2149     d3d10_effect_constant_buffer_GetAnnotationByName,
2150     d3d10_effect_constant_buffer_GetMemberByIndex,
2151     d3d10_effect_constant_buffer_GetMemberByName,
2152     d3d10_effect_constant_buffer_GetMemberBySemantic,
2153     d3d10_effect_constant_buffer_GetElement,
2154     d3d10_effect_constant_buffer_GetParentConstantBuffer,
2155     d3d10_effect_constant_buffer_AsScalar,
2156     d3d10_effect_constant_buffer_AsVector,
2157     d3d10_effect_constant_buffer_AsMatrix,
2158     d3d10_effect_constant_buffer_AsString,
2159     d3d10_effect_constant_buffer_AsShaderResource,
2160     d3d10_effect_constant_buffer_AsRenderTargetView,
2161     d3d10_effect_constant_buffer_AsDepthStencilView,
2162     d3d10_effect_constant_buffer_AsConstantBuffer,
2163     d3d10_effect_constant_buffer_AsShader,
2164     d3d10_effect_constant_buffer_AsBlend,
2165     d3d10_effect_constant_buffer_AsDepthStencil,
2166     d3d10_effect_constant_buffer_AsRasterizer,
2167     d3d10_effect_constant_buffer_AsSampler,
2168     d3d10_effect_constant_buffer_SetRawValue,
2169     d3d10_effect_constant_buffer_GetRawValue,
2170     /* ID3D10EffectConstantBuffer methods */
2171     d3d10_effect_constant_buffer_SetConstantBuffer,
2172     d3d10_effect_constant_buffer_GetConstantBuffer,
2173     d3d10_effect_constant_buffer_SetTextureBuffer,
2174     d3d10_effect_constant_buffer_GetTextureBuffer,
2175 };
2176
2177 /* ID3D10EffectVariable methods */
2178
2179 static BOOL STDMETHODCALLTYPE d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable *iface)
2180 {
2181     TRACE("iface %p\n", iface);
2182
2183     return (struct d3d10_effect_variable *)iface != &null_scalar_variable;
2184 }
2185
2186 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetType(
2187         ID3D10EffectScalarVariable *iface)
2188 {
2189     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
2190 }
2191
2192 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetDesc(ID3D10EffectScalarVariable *iface,
2193         D3D10_EFFECT_VARIABLE_DESC *desc)
2194 {
2195     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
2196 }
2197
2198 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByIndex(
2199         ID3D10EffectScalarVariable *iface, UINT index)
2200 {
2201     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
2202 }
2203
2204 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByName(
2205         ID3D10EffectScalarVariable *iface, LPCSTR name)
2206 {
2207     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
2208 }
2209
2210 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByIndex(
2211         ID3D10EffectScalarVariable *iface, UINT index)
2212 {
2213     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
2214 }
2215
2216 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByName(
2217         ID3D10EffectScalarVariable *iface, LPCSTR name)
2218 {
2219     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
2220 }
2221
2222 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberBySemantic(
2223         ID3D10EffectScalarVariable *iface, LPCSTR semantic)
2224 {
2225     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
2226 }
2227
2228 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetElement(
2229         ID3D10EffectScalarVariable *iface, UINT index)
2230 {
2231     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
2232 }
2233
2234 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetParentConstantBuffer(
2235         ID3D10EffectScalarVariable *iface)
2236 {
2237     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
2238 }
2239
2240 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsScalar(
2241         ID3D10EffectScalarVariable *iface)
2242 {
2243     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
2244 }
2245
2246 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsVector(
2247         ID3D10EffectScalarVariable *iface)
2248 {
2249     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
2250 }
2251
2252 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsMatrix(
2253         ID3D10EffectScalarVariable *iface)
2254 {
2255     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
2256 }
2257
2258 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsString(
2259         ID3D10EffectScalarVariable *iface)
2260 {
2261     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
2262 }
2263
2264 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShaderResource(
2265         ID3D10EffectScalarVariable *iface)
2266 {
2267     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
2268 }
2269
2270 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRenderTargetView(
2271         ID3D10EffectScalarVariable *iface)
2272 {
2273     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
2274 }
2275
2276 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencilView(
2277         ID3D10EffectScalarVariable *iface)
2278 {
2279     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
2280 }
2281
2282 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsConstantBuffer(
2283         ID3D10EffectScalarVariable *iface)
2284 {
2285     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
2286 }
2287
2288 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShader(
2289         ID3D10EffectScalarVariable *iface)
2290 {
2291     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
2292 }
2293
2294 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsBlend(
2295         ID3D10EffectScalarVariable *iface)
2296 {
2297     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
2298 }
2299
2300 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencil(
2301         ID3D10EffectScalarVariable *iface)
2302 {
2303     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
2304 }
2305
2306 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRasterizer(
2307         ID3D10EffectScalarVariable *iface)
2308 {
2309     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
2310 }
2311
2312 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsSampler(
2313         ID3D10EffectScalarVariable *iface)
2314 {
2315     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
2316 }
2317
2318 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetRawValue(ID3D10EffectScalarVariable *iface,
2319         void *data, UINT offset, UINT count)
2320 {
2321     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2322 }
2323
2324 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetRawValue(ID3D10EffectScalarVariable *iface,
2325         void *data, UINT offset, UINT count)
2326 {
2327     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2328 }
2329
2330 /* ID3D10EffectScalarVariable methods */
2331
2332 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable *iface,
2333         float value)
2334 {
2335     FIXME("iface %p, value %.8e stub!\n", iface, value);
2336
2337     return E_NOTIMPL;
2338 }
2339
2340 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable *iface,
2341         float *value)
2342 {
2343     FIXME("iface %p, value %p stub!\n", iface, value);
2344
2345     return E_NOTIMPL;
2346 }
2347
2348 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable *iface,
2349         float *values, UINT offset, UINT count)
2350 {
2351     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2352
2353     return E_NOTIMPL;
2354 }
2355
2356 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable *iface,
2357         float *values, UINT offset, UINT count)
2358 {
2359     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2360
2361     return E_NOTIMPL;
2362 }
2363
2364 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable *iface,
2365         int value)
2366 {
2367     FIXME("iface %p, value %d stub!\n", iface, value);
2368
2369     return E_NOTIMPL;
2370 }
2371
2372 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable *iface,
2373         int *value)
2374 {
2375     FIXME("iface %p, value %p stub!\n", iface, value);
2376
2377     return E_NOTIMPL;
2378 }
2379
2380 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable *iface,
2381         int *values, UINT offset, UINT count)
2382 {
2383     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2384
2385     return E_NOTIMPL;
2386 }
2387
2388 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable *iface,
2389         int *values, UINT offset, UINT count)
2390 {
2391     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2392
2393     return E_NOTIMPL;
2394 }
2395
2396 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable *iface,
2397         BOOL value)
2398 {
2399     FIXME("iface %p, value %d stub!\n", iface, value);
2400
2401     return E_NOTIMPL;
2402 }
2403
2404 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable *iface,
2405         BOOL *value)
2406 {
2407     FIXME("iface %p, value %p stub!\n", iface, value);
2408
2409     return E_NOTIMPL;
2410 }
2411
2412 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable *iface,
2413         BOOL *values, UINT offset, UINT count)
2414 {
2415     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2416
2417     return E_NOTIMPL;
2418 }
2419
2420 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable *iface,
2421         BOOL *values, UINT offset, UINT count)
2422 {
2423     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2424
2425     return E_NOTIMPL;
2426 }
2427
2428 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl =
2429 {
2430     /* ID3D10EffectVariable methods */
2431     d3d10_effect_scalar_variable_IsValid,
2432     d3d10_effect_scalar_variable_GetType,
2433     d3d10_effect_scalar_variable_GetDesc,
2434     d3d10_effect_scalar_variable_GetAnnotationByIndex,
2435     d3d10_effect_scalar_variable_GetAnnotationByName,
2436     d3d10_effect_scalar_variable_GetMemberByIndex,
2437     d3d10_effect_scalar_variable_GetMemberByName,
2438     d3d10_effect_scalar_variable_GetMemberBySemantic,
2439     d3d10_effect_scalar_variable_GetElement,
2440     d3d10_effect_scalar_variable_GetParentConstantBuffer,
2441     d3d10_effect_scalar_variable_AsScalar,
2442     d3d10_effect_scalar_variable_AsVector,
2443     d3d10_effect_scalar_variable_AsMatrix,
2444     d3d10_effect_scalar_variable_AsString,
2445     d3d10_effect_scalar_variable_AsShaderResource,
2446     d3d10_effect_scalar_variable_AsRenderTargetView,
2447     d3d10_effect_scalar_variable_AsDepthStencilView,
2448     d3d10_effect_scalar_variable_AsConstantBuffer,
2449     d3d10_effect_scalar_variable_AsShader,
2450     d3d10_effect_scalar_variable_AsBlend,
2451     d3d10_effect_scalar_variable_AsDepthStencil,
2452     d3d10_effect_scalar_variable_AsRasterizer,
2453     d3d10_effect_scalar_variable_AsSampler,
2454     d3d10_effect_scalar_variable_SetRawValue,
2455     d3d10_effect_scalar_variable_GetRawValue,
2456     /* ID3D10EffectScalarVariable methods */
2457     d3d10_effect_scalar_variable_SetFloat,
2458     d3d10_effect_scalar_variable_GetFloat,
2459     d3d10_effect_scalar_variable_SetFloatArray,
2460     d3d10_effect_scalar_variable_GetFloatArray,
2461     d3d10_effect_scalar_variable_SetInt,
2462     d3d10_effect_scalar_variable_GetInt,
2463     d3d10_effect_scalar_variable_SetIntArray,
2464     d3d10_effect_scalar_variable_GetIntArray,
2465     d3d10_effect_scalar_variable_SetBool,
2466     d3d10_effect_scalar_variable_GetBool,
2467     d3d10_effect_scalar_variable_SetBoolArray,
2468     d3d10_effect_scalar_variable_GetBoolArray,
2469 };
2470
2471 /* ID3D10EffectVariable methods */
2472
2473 static BOOL STDMETHODCALLTYPE d3d10_effect_vector_variable_IsValid(ID3D10EffectVectorVariable *iface)
2474 {
2475     TRACE("iface %p\n", iface);
2476
2477     return (struct d3d10_effect_variable *)iface != &null_vector_variable;
2478 }
2479
2480 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetType(
2481         ID3D10EffectVectorVariable *iface)
2482 {
2483     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
2484 }
2485
2486 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetDesc(ID3D10EffectVectorVariable *iface,
2487         D3D10_EFFECT_VARIABLE_DESC *desc)
2488 {
2489     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
2490 }
2491
2492 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByIndex(
2493         ID3D10EffectVectorVariable *iface, UINT index)
2494 {
2495     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
2496 }
2497
2498 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByName(
2499         ID3D10EffectVectorVariable *iface, LPCSTR name)
2500 {
2501     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
2502 }
2503
2504 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByIndex(
2505         ID3D10EffectVectorVariable *iface, UINT index)
2506 {
2507     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
2508 }
2509
2510 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByName(
2511         ID3D10EffectVectorVariable *iface, LPCSTR name)
2512 {
2513     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
2514 }
2515
2516 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberBySemantic(
2517         ID3D10EffectVectorVariable *iface, LPCSTR semantic)
2518 {
2519     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
2520 }
2521
2522 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetElement(
2523         ID3D10EffectVectorVariable *iface, UINT index)
2524 {
2525     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
2526 }
2527
2528 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetParentConstantBuffer(
2529         ID3D10EffectVectorVariable *iface)
2530 {
2531     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
2532 }
2533
2534 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsScalar(
2535         ID3D10EffectVectorVariable *iface)
2536 {
2537     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
2538 }
2539
2540 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsVector(
2541         ID3D10EffectVectorVariable *iface)
2542 {
2543     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
2544 }
2545
2546 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsMatrix(
2547         ID3D10EffectVectorVariable *iface)
2548 {
2549     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
2550 }
2551
2552 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsString(
2553         ID3D10EffectVectorVariable *iface)
2554 {
2555     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
2556 }
2557
2558 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShaderResource(
2559         ID3D10EffectVectorVariable *iface)
2560 {
2561     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
2562 }
2563
2564 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRenderTargetView(
2565         ID3D10EffectVectorVariable *iface)
2566 {
2567     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
2568 }
2569
2570 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencilView(
2571         ID3D10EffectVectorVariable *iface)
2572 {
2573     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
2574 }
2575
2576 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsConstantBuffer(
2577         ID3D10EffectVectorVariable *iface)
2578 {
2579     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
2580 }
2581
2582 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShader(
2583         ID3D10EffectVectorVariable *iface)
2584 {
2585     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
2586 }
2587
2588 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsBlend(
2589         ID3D10EffectVectorVariable *iface)
2590 {
2591     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
2592 }
2593
2594 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencil(
2595         ID3D10EffectVectorVariable *iface)
2596 {
2597     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
2598 }
2599
2600 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRasterizer(
2601         ID3D10EffectVectorVariable *iface)
2602 {
2603     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
2604 }
2605
2606 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsSampler(
2607         ID3D10EffectVectorVariable *iface)
2608 {
2609     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
2610 }
2611
2612 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetRawValue(ID3D10EffectVectorVariable *iface,
2613         void *data, UINT offset, UINT count)
2614 {
2615     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2616 }
2617
2618 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetRawValue(ID3D10EffectVectorVariable *iface,
2619         void *data, UINT offset, UINT count)
2620 {
2621     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2622 }
2623
2624 /* ID3D10EffectVectorVariable methods */
2625
2626 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVector(ID3D10EffectVectorVariable *iface,
2627         BOOL *value)
2628 {
2629     FIXME("iface %p, value %p stub!\n", iface, value);
2630
2631     return E_NOTIMPL;
2632 }
2633
2634 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVector(ID3D10EffectVectorVariable *iface,
2635         int *value)
2636 {
2637     FIXME("iface %p, value %p stub!\n", iface, value);
2638
2639     return E_NOTIMPL;
2640 }
2641
2642 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVector(ID3D10EffectVectorVariable *iface,
2643         float *value)
2644 {
2645     FIXME("iface %p, value %p stub!\n", iface, value);
2646
2647     return E_NOTIMPL;
2648 }
2649
2650 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVector(ID3D10EffectVectorVariable *iface,
2651         BOOL *value)
2652 {
2653     FIXME("iface %p, value %p stub!\n", iface, value);
2654
2655     return E_NOTIMPL;
2656 }
2657
2658 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVector(ID3D10EffectVectorVariable *iface,
2659         int *value)
2660 {
2661     FIXME("iface %p, value %p stub!\n", iface, value);
2662
2663     return E_NOTIMPL;
2664 }
2665
2666 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVector(ID3D10EffectVectorVariable *iface,
2667         float *value)
2668 {
2669     FIXME("iface %p, value %p stub!\n", iface, value);
2670
2671     return E_NOTIMPL;
2672 }
2673
2674 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVectorArray(ID3D10EffectVectorVariable *iface,
2675         BOOL *values, UINT offset, UINT count)
2676 {
2677     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2678
2679     return E_NOTIMPL;
2680 }
2681
2682 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVectorArray(ID3D10EffectVectorVariable *iface,
2683         int *values, UINT offset, UINT count)
2684 {
2685     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2686
2687     return E_NOTIMPL;
2688 }
2689
2690 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVectorArray(ID3D10EffectVectorVariable *iface,
2691         float *values, UINT offset, UINT count)
2692 {
2693     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2694
2695     return E_NOTIMPL;
2696 }
2697
2698 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVectorArray(ID3D10EffectVectorVariable *iface,
2699         BOOL *values, UINT offset, UINT count)
2700 {
2701     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2702
2703     return E_NOTIMPL;
2704 }
2705
2706 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVectorArray(ID3D10EffectVectorVariable *iface,
2707         int *values, UINT offset, UINT count)
2708 {
2709     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2710
2711     return E_NOTIMPL;
2712 }
2713
2714 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVectorArray(ID3D10EffectVectorVariable *iface,
2715         float *values, UINT offset, UINT count)
2716 {
2717     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2718
2719     return E_NOTIMPL;
2720 }
2721
2722 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl =
2723 {
2724     /* ID3D10EffectVariable methods */
2725     d3d10_effect_vector_variable_IsValid,
2726     d3d10_effect_vector_variable_GetType,
2727     d3d10_effect_vector_variable_GetDesc,
2728     d3d10_effect_vector_variable_GetAnnotationByIndex,
2729     d3d10_effect_vector_variable_GetAnnotationByName,
2730     d3d10_effect_vector_variable_GetMemberByIndex,
2731     d3d10_effect_vector_variable_GetMemberByName,
2732     d3d10_effect_vector_variable_GetMemberBySemantic,
2733     d3d10_effect_vector_variable_GetElement,
2734     d3d10_effect_vector_variable_GetParentConstantBuffer,
2735     d3d10_effect_vector_variable_AsScalar,
2736     d3d10_effect_vector_variable_AsVector,
2737     d3d10_effect_vector_variable_AsMatrix,
2738     d3d10_effect_vector_variable_AsString,
2739     d3d10_effect_vector_variable_AsShaderResource,
2740     d3d10_effect_vector_variable_AsRenderTargetView,
2741     d3d10_effect_vector_variable_AsDepthStencilView,
2742     d3d10_effect_vector_variable_AsConstantBuffer,
2743     d3d10_effect_vector_variable_AsShader,
2744     d3d10_effect_vector_variable_AsBlend,
2745     d3d10_effect_vector_variable_AsDepthStencil,
2746     d3d10_effect_vector_variable_AsRasterizer,
2747     d3d10_effect_vector_variable_AsSampler,
2748     d3d10_effect_vector_variable_SetRawValue,
2749     d3d10_effect_vector_variable_GetRawValue,
2750     /* ID3D10EffectVectorVariable methods */
2751     d3d10_effect_vector_variable_SetBoolVector,
2752     d3d10_effect_vector_variable_SetIntVector,
2753     d3d10_effect_vector_variable_SetFloatVector,
2754     d3d10_effect_vector_variable_GetBoolVector,
2755     d3d10_effect_vector_variable_GetIntVector,
2756     d3d10_effect_vector_variable_GetFloatVector,
2757     d3d10_effect_vector_variable_SetBoolVectorArray,
2758     d3d10_effect_vector_variable_SetIntVectorArray,
2759     d3d10_effect_vector_variable_SetFloatVectorArray,
2760     d3d10_effect_vector_variable_GetBoolVectorArray,
2761     d3d10_effect_vector_variable_GetIntVectorArray,
2762     d3d10_effect_vector_variable_GetFloatVectorArray,
2763 };
2764
2765 /* ID3D10EffectVariable methods */
2766
2767 static BOOL STDMETHODCALLTYPE d3d10_effect_matrix_variable_IsValid(ID3D10EffectMatrixVariable *iface)
2768 {
2769     TRACE("iface %p\n", iface);
2770
2771     return (struct d3d10_effect_variable *)iface != &null_matrix_variable;
2772 }
2773
2774 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetType(
2775         ID3D10EffectMatrixVariable *iface)
2776 {
2777     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
2778 }
2779
2780 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetDesc(ID3D10EffectMatrixVariable *iface,
2781         D3D10_EFFECT_VARIABLE_DESC *desc)
2782 {
2783     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
2784 }
2785
2786 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByIndex(
2787         ID3D10EffectMatrixVariable *iface, UINT index)
2788 {
2789     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
2790 }
2791
2792 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByName(
2793         ID3D10EffectMatrixVariable *iface, LPCSTR name)
2794 {
2795     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
2796 }
2797
2798 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByIndex(
2799         ID3D10EffectMatrixVariable *iface, UINT index)
2800 {
2801     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
2802 }
2803
2804 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByName(
2805         ID3D10EffectMatrixVariable *iface, LPCSTR name)
2806 {
2807     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
2808 }
2809
2810 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberBySemantic(
2811         ID3D10EffectMatrixVariable *iface, LPCSTR semantic)
2812 {
2813     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
2814 }
2815
2816 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetElement(
2817         ID3D10EffectMatrixVariable *iface, UINT index)
2818 {
2819     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
2820 }
2821
2822 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetParentConstantBuffer(
2823         ID3D10EffectMatrixVariable *iface)
2824 {
2825     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
2826 }
2827
2828 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsScalar(
2829         ID3D10EffectMatrixVariable *iface)
2830 {
2831     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
2832 }
2833
2834 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsVector(
2835         ID3D10EffectMatrixVariable *iface)
2836 {
2837     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
2838 }
2839
2840 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsMatrix(
2841         ID3D10EffectMatrixVariable *iface)
2842 {
2843     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
2844 }
2845
2846 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsString(
2847         ID3D10EffectMatrixVariable *iface)
2848 {
2849     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
2850 }
2851
2852 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShaderResource(
2853         ID3D10EffectMatrixVariable *iface)
2854 {
2855     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
2856 }
2857
2858 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRenderTargetView(
2859         ID3D10EffectMatrixVariable *iface)
2860 {
2861     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
2862 }
2863
2864 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencilView(
2865         ID3D10EffectMatrixVariable *iface)
2866 {
2867     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
2868 }
2869
2870 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsConstantBuffer(
2871         ID3D10EffectMatrixVariable *iface)
2872 {
2873     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
2874 }
2875
2876 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShader(
2877         ID3D10EffectMatrixVariable *iface)
2878 {
2879     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
2880 }
2881
2882 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsBlend(
2883         ID3D10EffectMatrixVariable *iface)
2884 {
2885     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
2886 }
2887
2888 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencil(
2889         ID3D10EffectMatrixVariable *iface)
2890 {
2891     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
2892 }
2893
2894 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRasterizer(
2895         ID3D10EffectMatrixVariable *iface)
2896 {
2897     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
2898 }
2899
2900 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsSampler(
2901         ID3D10EffectMatrixVariable *iface)
2902 {
2903     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
2904 }
2905
2906 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetRawValue(ID3D10EffectMatrixVariable *iface,
2907         void *data, UINT offset, UINT count)
2908 {
2909     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2910 }
2911
2912 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetRawValue(ID3D10EffectMatrixVariable *iface,
2913         void *data, UINT offset, UINT count)
2914 {
2915     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2916 }
2917
2918 /* ID3D10EffectMatrixVariable methods */
2919
2920 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrix(ID3D10EffectMatrixVariable *iface,
2921         float *data)
2922 {
2923     FIXME("iface %p, data %p stub!\n", iface, data);
2924
2925     return E_NOTIMPL;
2926 }
2927
2928 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrix(ID3D10EffectMatrixVariable *iface,
2929         float *data)
2930 {
2931     FIXME("iface %p, data %p stub!\n", iface, data);
2932
2933     return E_NOTIMPL;
2934 }
2935
2936 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixArray(ID3D10EffectMatrixVariable *iface,
2937         float *data, UINT offset, UINT count)
2938 {
2939     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2940
2941     return E_NOTIMPL;
2942 }
2943
2944 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixArray(ID3D10EffectMatrixVariable *iface,
2945         float *data, UINT offset, UINT count)
2946 {
2947     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2948
2949     return E_NOTIMPL;
2950 }
2951
2952 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
2953         float *data)
2954 {
2955     FIXME("iface %p, data %p stub!\n", iface, data);
2956
2957     return E_NOTIMPL;
2958 }
2959
2960 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
2961         float *data)
2962 {
2963     FIXME("iface %p, data %p stub!\n", iface, data);
2964
2965     return E_NOTIMPL;
2966 }
2967
2968 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
2969         float *data, UINT offset, UINT count)
2970 {
2971     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2972
2973     return E_NOTIMPL;
2974 }
2975
2976 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
2977         float *data, UINT offset, UINT count)
2978 {
2979     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2980
2981     return E_NOTIMPL;
2982 }
2983
2984
2985 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl =
2986 {
2987     /* ID3D10EffectVariable methods */
2988     d3d10_effect_matrix_variable_IsValid,
2989     d3d10_effect_matrix_variable_GetType,
2990     d3d10_effect_matrix_variable_GetDesc,
2991     d3d10_effect_matrix_variable_GetAnnotationByIndex,
2992     d3d10_effect_matrix_variable_GetAnnotationByName,
2993     d3d10_effect_matrix_variable_GetMemberByIndex,
2994     d3d10_effect_matrix_variable_GetMemberByName,
2995     d3d10_effect_matrix_variable_GetMemberBySemantic,
2996     d3d10_effect_matrix_variable_GetElement,
2997     d3d10_effect_matrix_variable_GetParentConstantBuffer,
2998     d3d10_effect_matrix_variable_AsScalar,
2999     d3d10_effect_matrix_variable_AsVector,
3000     d3d10_effect_matrix_variable_AsMatrix,
3001     d3d10_effect_matrix_variable_AsString,
3002     d3d10_effect_matrix_variable_AsShaderResource,
3003     d3d10_effect_matrix_variable_AsRenderTargetView,
3004     d3d10_effect_matrix_variable_AsDepthStencilView,
3005     d3d10_effect_matrix_variable_AsConstantBuffer,
3006     d3d10_effect_matrix_variable_AsShader,
3007     d3d10_effect_matrix_variable_AsBlend,
3008     d3d10_effect_matrix_variable_AsDepthStencil,
3009     d3d10_effect_matrix_variable_AsRasterizer,
3010     d3d10_effect_matrix_variable_AsSampler,
3011     d3d10_effect_matrix_variable_SetRawValue,
3012     d3d10_effect_matrix_variable_GetRawValue,
3013     /* ID3D10EffectMatrixVariable methods */
3014     d3d10_effect_matrix_variable_SetMatrix,
3015     d3d10_effect_matrix_variable_GetMatrix,
3016     d3d10_effect_matrix_variable_SetMatrixArray,
3017     d3d10_effect_matrix_variable_GetMatrixArray,
3018     d3d10_effect_matrix_variable_SetMatrixTranspose,
3019     d3d10_effect_matrix_variable_GetMatrixTranspose,
3020     d3d10_effect_matrix_variable_SetMatrixTransposeArray,
3021     d3d10_effect_matrix_variable_GetMatrixTransposeArray,
3022 };
3023
3024 static BOOL STDMETHODCALLTYPE d3d10_effect_type_IsValid(ID3D10EffectType *iface)
3025 {
3026     FIXME("iface %p stub!\n", iface);
3027
3028     return FALSE;
3029 }
3030
3031 static HRESULT STDMETHODCALLTYPE d3d10_effect_type_GetDesc(ID3D10EffectType *iface, D3D10_EFFECT_TYPE_DESC *desc)
3032 {
3033     struct d3d10_effect_type *This = (struct d3d10_effect_type *)iface;
3034
3035     TRACE("iface %p, desc %p\n", iface, desc);
3036
3037     if (!desc) return E_INVALIDARG;
3038
3039     desc->TypeName = This->name;
3040     desc->Class = This->type_class;
3041     desc->Type = This->basetype;
3042     desc->Elements = This->element_count;
3043     desc->Members = This->member_count;
3044     desc->Rows = This->row_count;
3045     desc->Columns = This->column_count;
3046     desc->PackedSize = This->size_packed;
3047     desc->UnpackedSize = This->size_unpacked;
3048     desc->Stride = This->stride;
3049
3050     return S_OK;
3051 }
3052
3053 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByIndex(ID3D10EffectType *iface,
3054         UINT index)
3055 {
3056     FIXME("iface %p, index %u stub!\n", iface, index);
3057
3058     return NULL;
3059 }
3060
3061 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByName(ID3D10EffectType *iface,
3062         LPCSTR name)
3063 {
3064     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
3065
3066     return NULL;
3067 }
3068
3069 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeBySemantic(ID3D10EffectType *iface,
3070         LPCSTR semantic)
3071 {
3072     FIXME("iface %p, semantic %s stub!\n", iface, debugstr_a(semantic));
3073
3074     return NULL;
3075 }
3076
3077 static LPCSTR STDMETHODCALLTYPE d3d10_effect_type_GetMemberName(ID3D10EffectType *iface, UINT index)
3078 {
3079     FIXME("iface %p, index %u stub!\n", iface, index);
3080
3081     return NULL;
3082 }
3083
3084 static LPCSTR STDMETHODCALLTYPE d3d10_effect_type_GetMemberSemantic(ID3D10EffectType *iface, UINT index)
3085 {
3086     FIXME("iface %p, index %u stub!\n", iface, index);
3087
3088     return NULL;
3089 }
3090
3091 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl =
3092 {
3093     /* ID3D10EffectType */
3094     d3d10_effect_type_IsValid,
3095     d3d10_effect_type_GetDesc,
3096     d3d10_effect_type_GetMemberTypeByIndex,
3097     d3d10_effect_type_GetMemberTypeByName,
3098     d3d10_effect_type_GetMemberTypeBySemantic,
3099     d3d10_effect_type_GetMemberName,
3100     d3d10_effect_type_GetMemberSemantic,
3101 };