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     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1417
1418     return NULL;
1419 }
1420
1421 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique *iface,
1422         UINT index)
1423 {
1424     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1425     struct d3d10_effect_pass *p;
1426
1427     TRACE("iface %p, index %u\n", iface, index);
1428
1429     if (index >= This->pass_count)
1430     {
1431         WARN("Invalid index specified\n");
1432         return (ID3D10EffectPass *)&null_pass;
1433     }
1434
1435     p = &This->passes[index];
1436
1437     TRACE("Returning pass %p, %s.\n", p, debugstr_a(p->name));
1438
1439     return (ID3D10EffectPass *)p;
1440 }
1441
1442 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique *iface,
1443         LPCSTR name)
1444 {
1445     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1446     unsigned int i;
1447
1448     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
1449
1450     for (i = 0; i < This->pass_count; ++i)
1451     {
1452         struct d3d10_effect_pass *p = &This->passes[i];
1453         if (!strcmp(p->name, name))
1454         {
1455             TRACE("Returning pass %p\n", p);
1456             return (ID3D10EffectPass *)p;
1457         }
1458     }
1459
1460     WARN("Invalid name specified\n");
1461
1462     return (ID3D10EffectPass *)&null_pass;
1463 }
1464
1465 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique *iface,
1466         D3D10_STATE_BLOCK_MASK *mask)
1467 {
1468     FIXME("iface %p,mask %p stub!\n", iface, mask);
1469
1470     return E_NOTIMPL;
1471 }
1472
1473 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl =
1474 {
1475     /* ID3D10EffectTechnique methods */
1476     d3d10_effect_technique_IsValid,
1477     d3d10_effect_technique_GetDesc,
1478     d3d10_effect_technique_GetAnnotationByIndex,
1479     d3d10_effect_technique_GetAnnotationByName,
1480     d3d10_effect_technique_GetPassByIndex,
1481     d3d10_effect_technique_GetPassByName,
1482     d3d10_effect_technique_ComputeStateBlockMask,
1483 };
1484
1485 /* ID3D10EffectPass methods */
1486
1487 static BOOL STDMETHODCALLTYPE d3d10_effect_pass_IsValid(ID3D10EffectPass *iface)
1488 {
1489     TRACE("iface %p\n", iface);
1490
1491     return (struct d3d10_effect_pass *)iface != &null_pass;
1492 }
1493
1494 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetDesc(ID3D10EffectPass *iface, D3D10_PASS_DESC *desc)
1495 {
1496     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1497     unsigned int i;
1498
1499     FIXME("iface %p, desc %p partial stub!\n", iface, desc);
1500
1501     if(This == &null_pass)
1502     {
1503         WARN("Null pass specified\n");
1504         return E_FAIL;
1505     }
1506
1507     if(!desc)
1508     {
1509         WARN("Invalid argument specified\n");
1510         return E_INVALIDARG;
1511     }
1512
1513     memset(desc, 0, sizeof(*desc));
1514     desc->Name = This->name;
1515     for (i = 0; i < This->object_count; ++i)
1516     {
1517         struct d3d10_effect_object *o = &This->objects[i];
1518         if (o->type == D3D10_EOT_VERTEXSHADER)
1519         {
1520             struct d3d10_effect_shader_variable *s = o->data;
1521             desc->pIAInputSignature = (BYTE *)s->input_signature;
1522             desc->IAInputSignatureSize = s->input_signature_size;
1523             break;
1524         }
1525     }
1526
1527     return S_OK;
1528 }
1529
1530 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass *iface,
1531         D3D10_PASS_SHADER_DESC *desc)
1532 {
1533     FIXME("iface %p, desc %p stub!\n", iface, desc);
1534
1535     return E_NOTIMPL;
1536 }
1537
1538 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass *iface,
1539         D3D10_PASS_SHADER_DESC *desc)
1540 {
1541     FIXME("iface %p, desc %p stub!\n", iface, desc);
1542
1543     return E_NOTIMPL;
1544 }
1545
1546 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass *iface,
1547         D3D10_PASS_SHADER_DESC *desc)
1548 {
1549     FIXME("iface %p, desc %p stub!\n", iface, desc);
1550
1551     return E_NOTIMPL;
1552 }
1553
1554 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass *iface,
1555         UINT index)
1556 {
1557     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1558     struct d3d10_effect_variable *a;
1559
1560     TRACE("iface %p, index %u\n", iface, index);
1561
1562     if (index >= This->annotation_count)
1563     {
1564         WARN("Invalid index specified\n");
1565         return (ID3D10EffectVariable *)&null_variable;
1566     }
1567
1568     a = &This->annotations[index];
1569
1570     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
1571
1572     return (ID3D10EffectVariable *)a;
1573 }
1574
1575 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass *iface,
1576         LPCSTR name)
1577 {
1578     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1579
1580     return NULL;
1581 }
1582
1583 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_Apply(ID3D10EffectPass *iface, UINT flags)
1584 {
1585     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1586     HRESULT hr = S_OK;
1587     unsigned int i;
1588
1589     TRACE("iface %p, flags %#x\n", iface, flags);
1590
1591     if (flags) FIXME("Ignoring flags (%#x)\n", flags);
1592
1593     for (i = 0; i < This->object_count; ++i)
1594     {
1595         hr = d3d10_effect_object_apply(&This->objects[i]);
1596         if (FAILED(hr)) break;
1597     }
1598
1599     return hr;
1600 }
1601
1602 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass *iface,
1603         D3D10_STATE_BLOCK_MASK *mask)
1604 {
1605     FIXME("iface %p, mask %p stub!\n", iface, mask);
1606
1607     return E_NOTIMPL;
1608 }
1609
1610 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl =
1611 {
1612     /* ID3D10EffectPass methods */
1613     d3d10_effect_pass_IsValid,
1614     d3d10_effect_pass_GetDesc,
1615     d3d10_effect_pass_GetVertexShaderDesc,
1616     d3d10_effect_pass_GetGeometryShaderDesc,
1617     d3d10_effect_pass_GetPixelShaderDesc,
1618     d3d10_effect_pass_GetAnnotationByIndex,
1619     d3d10_effect_pass_GetAnnotationByName,
1620     d3d10_effect_pass_Apply,
1621     d3d10_effect_pass_ComputeStateBlockMask,
1622 };
1623
1624 /* ID3D10EffectVariable methods */
1625
1626 static BOOL STDMETHODCALLTYPE d3d10_effect_variable_IsValid(ID3D10EffectVariable *iface)
1627 {
1628     TRACE("iface %p\n", iface);
1629
1630     return (struct d3d10_effect_variable *)iface != &null_variable;
1631 }
1632
1633 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_variable_GetType(ID3D10EffectVariable *iface)
1634 {
1635     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1636
1637     TRACE("iface %p\n", iface);
1638
1639     return (ID3D10EffectType *)This->type;
1640 }
1641
1642 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetDesc(ID3D10EffectVariable *iface,
1643         D3D10_EFFECT_VARIABLE_DESC *desc)
1644 {
1645     FIXME("iface %p, desc %p stub!\n", iface, desc);
1646
1647     return E_NOTIMPL;
1648 }
1649
1650 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByIndex(
1651         ID3D10EffectVariable *iface, UINT index)
1652 {
1653     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1654     struct d3d10_effect_variable *a;
1655
1656     TRACE("iface %p, index %u\n", iface, index);
1657
1658     if (index >= This->annotation_count)
1659     {
1660         WARN("Invalid index specified\n");
1661         return (ID3D10EffectVariable *)&null_variable;
1662     }
1663
1664     a = &This->annotations[index];
1665
1666     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
1667
1668     return (ID3D10EffectVariable *)a;
1669 }
1670
1671 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByName(
1672         ID3D10EffectVariable *iface, LPCSTR name)
1673 {
1674     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1675
1676     return NULL;
1677 }
1678
1679 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByIndex(
1680         ID3D10EffectVariable *iface, UINT index)
1681 {
1682     FIXME("iface %p, index %u stub!\n", iface, index);
1683
1684     return NULL;
1685 }
1686
1687 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByName(
1688         ID3D10EffectVariable *iface, LPCSTR name)
1689 {
1690     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1691
1692     return NULL;
1693 }
1694
1695 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberBySemantic(
1696         ID3D10EffectVariable *iface, LPCSTR semantic)
1697 {
1698     FIXME("iface %p, semantic %s stub!\n", iface, debugstr_a(semantic));
1699
1700     return NULL;
1701 }
1702
1703 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetElement(
1704         ID3D10EffectVariable *iface, UINT index)
1705 {
1706     FIXME("iface %p, index %u stub!\n", iface, index);
1707
1708     return NULL;
1709 }
1710
1711 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_GetParentConstantBuffer(
1712         ID3D10EffectVariable *iface)
1713 {
1714     FIXME("iface %p stub!\n", iface);
1715
1716     return NULL;
1717 }
1718
1719 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsScalar(
1720         ID3D10EffectVariable *iface)
1721 {
1722     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1723
1724     TRACE("iface %p\n", iface);
1725
1726     if (This->vtbl == (ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl)
1727         return (ID3D10EffectScalarVariable *)This;
1728
1729     return (ID3D10EffectScalarVariable *)&null_scalar_variable;
1730 }
1731
1732 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsVector(
1733         ID3D10EffectVariable *iface)
1734 {
1735     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1736
1737     TRACE("iface %p\n", iface);
1738
1739     if (This->vtbl == (ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl)
1740         return (ID3D10EffectVectorVariable *)This;
1741
1742     return (ID3D10EffectVectorVariable *)&null_vector_variable;
1743 }
1744
1745 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsMatrix(
1746         ID3D10EffectVariable *iface)
1747 {
1748     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
1749
1750     TRACE("iface %p\n", iface);
1751
1752     if (This->vtbl == (ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl)
1753         return (ID3D10EffectMatrixVariable *)This;
1754
1755     return (ID3D10EffectMatrixVariable *)&null_matrix_variable;
1756 }
1757
1758 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsString(
1759         ID3D10EffectVariable *iface)
1760 {
1761     FIXME("iface %p stub!\n", iface);
1762
1763     return NULL;
1764 }
1765
1766 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShaderResource(
1767         ID3D10EffectVariable *iface)
1768 {
1769     FIXME("iface %p stub!\n", iface);
1770
1771     return NULL;
1772 }
1773
1774 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRenderTargetView(
1775         ID3D10EffectVariable *iface)
1776 {
1777     FIXME("iface %p stub!\n", iface);
1778
1779     return NULL;
1780 }
1781
1782 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencilView(
1783         ID3D10EffectVariable *iface)
1784 {
1785     FIXME("iface %p stub!\n", iface);
1786
1787     return NULL;
1788 }
1789
1790 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_AsConstantBuffer(
1791         ID3D10EffectVariable *iface)
1792 {
1793     FIXME("iface %p stub!\n", iface);
1794
1795     return NULL;
1796 }
1797
1798 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShader(
1799         ID3D10EffectVariable *iface)
1800 {
1801     FIXME("iface %p stub!\n", iface);
1802
1803     return NULL;
1804 }
1805
1806 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsBlend(ID3D10EffectVariable *iface)
1807 {
1808     FIXME("iface %p stub!\n", iface);
1809
1810     return NULL;
1811 }
1812
1813 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencil(
1814         ID3D10EffectVariable *iface)
1815 {
1816     FIXME("iface %p stub!\n", iface);
1817
1818     return NULL;
1819 }
1820
1821 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRasterizer(
1822         ID3D10EffectVariable *iface)
1823 {
1824     FIXME("iface %p stub!\n", iface);
1825
1826     return NULL;
1827 }
1828
1829 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsSampler(
1830         ID3D10EffectVariable *iface)
1831 {
1832     FIXME("iface %p stub!\n", iface);
1833
1834     return NULL;
1835 }
1836
1837 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_SetRawValue(ID3D10EffectVariable *iface,
1838         void *data, UINT offset, UINT count)
1839 {
1840     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1841
1842     return E_NOTIMPL;
1843 }
1844
1845 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetRawValue(ID3D10EffectVariable *iface,
1846         void *data, UINT offset, UINT count)
1847 {
1848     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1849
1850     return E_NOTIMPL;
1851 }
1852
1853 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl =
1854 {
1855     /* ID3D10EffectVariable methods */
1856     d3d10_effect_variable_IsValid,
1857     d3d10_effect_variable_GetType,
1858     d3d10_effect_variable_GetDesc,
1859     d3d10_effect_variable_GetAnnotationByIndex,
1860     d3d10_effect_variable_GetAnnotationByName,
1861     d3d10_effect_variable_GetMemberByIndex,
1862     d3d10_effect_variable_GetMemberByName,
1863     d3d10_effect_variable_GetMemberBySemantic,
1864     d3d10_effect_variable_GetElement,
1865     d3d10_effect_variable_GetParentConstantBuffer,
1866     d3d10_effect_variable_AsScalar,
1867     d3d10_effect_variable_AsVector,
1868     d3d10_effect_variable_AsMatrix,
1869     d3d10_effect_variable_AsString,
1870     d3d10_effect_variable_AsShaderResource,
1871     d3d10_effect_variable_AsRenderTargetView,
1872     d3d10_effect_variable_AsDepthStencilView,
1873     d3d10_effect_variable_AsConstantBuffer,
1874     d3d10_effect_variable_AsShader,
1875     d3d10_effect_variable_AsBlend,
1876     d3d10_effect_variable_AsDepthStencil,
1877     d3d10_effect_variable_AsRasterizer,
1878     d3d10_effect_variable_AsSampler,
1879     d3d10_effect_variable_SetRawValue,
1880     d3d10_effect_variable_GetRawValue,
1881 };
1882
1883 /* ID3D10EffectVariable methods */
1884 static BOOL STDMETHODCALLTYPE d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer *iface)
1885 {
1886     TRACE("iface %p\n", iface);
1887
1888     return (struct d3d10_effect_local_buffer *)iface != &null_local_buffer;
1889 }
1890
1891 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer *iface)
1892 {
1893     FIXME("iface %p stub!\n", iface);
1894
1895     return NULL;
1896 }
1897
1898 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer *iface,
1899         D3D10_EFFECT_VARIABLE_DESC *desc)
1900 {
1901     FIXME("iface %p, desc %p stub!\n", iface, desc);
1902
1903     return E_NOTIMPL;
1904 }
1905
1906 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByIndex(
1907         ID3D10EffectConstantBuffer *iface, UINT index)
1908 {
1909     struct d3d10_effect_local_buffer *This = (struct d3d10_effect_local_buffer *)iface;
1910     struct d3d10_effect_variable *a;
1911
1912     TRACE("iface %p, index %u\n", iface, index);
1913
1914     if (index >= This->annotation_count)
1915     {
1916         WARN("Invalid index specified\n");
1917         return (ID3D10EffectVariable *)&null_variable;
1918     }
1919
1920     a = &This->annotations[index];
1921
1922     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
1923
1924     return (ID3D10EffectVariable *)a;
1925 }
1926
1927 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByName(
1928         ID3D10EffectConstantBuffer *iface, LPCSTR name)
1929 {
1930     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1931
1932     return NULL;
1933 }
1934
1935 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByIndex(
1936         ID3D10EffectConstantBuffer *iface, UINT index)
1937 {
1938     FIXME("iface %p, index %u stub!\n", iface, index);
1939
1940     return NULL;
1941 }
1942
1943 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByName(
1944         ID3D10EffectConstantBuffer *iface, LPCSTR name)
1945 {
1946     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1947
1948     return NULL;
1949 }
1950
1951 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberBySemantic(
1952         ID3D10EffectConstantBuffer *iface, LPCSTR semantic)
1953 {
1954     FIXME("iface %p, semantic %s stub!\n", iface, debugstr_a(semantic));
1955
1956     return NULL;
1957 }
1958
1959 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetElement(
1960         ID3D10EffectConstantBuffer *iface, UINT index)
1961 {
1962     FIXME("iface %p, index %u stub!\n", iface, index);
1963
1964     return NULL;
1965 }
1966
1967 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetParentConstantBuffer(
1968         ID3D10EffectConstantBuffer *iface)
1969 {
1970     FIXME("iface %p stub!\n", iface);
1971
1972     return NULL;
1973 }
1974
1975 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsScalar(
1976         ID3D10EffectConstantBuffer *iface)
1977 {
1978     FIXME("iface %p stub!\n", iface);
1979
1980     return NULL;
1981 }
1982
1983 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsVector(
1984         ID3D10EffectConstantBuffer *iface)
1985 {
1986     FIXME("iface %p stub!\n", iface);
1987
1988     return NULL;
1989 }
1990
1991 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsMatrix(
1992         ID3D10EffectConstantBuffer *iface)
1993 {
1994     FIXME("iface %p stub!\n", iface);
1995
1996     return NULL;
1997 }
1998
1999 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsString(
2000         ID3D10EffectConstantBuffer *iface)
2001 {
2002     FIXME("iface %p stub!\n", iface);
2003
2004     return NULL;
2005 }
2006
2007 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShaderResource(
2008         ID3D10EffectConstantBuffer *iface)
2009 {
2010     FIXME("iface %p stub!\n", iface);
2011
2012     return NULL;
2013 }
2014
2015 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRenderTargetView(
2016         ID3D10EffectConstantBuffer *iface)
2017 {
2018     FIXME("iface %p stub!\n", iface);
2019
2020     return NULL;
2021 }
2022
2023 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencilView(
2024         ID3D10EffectConstantBuffer *iface)
2025 {
2026     FIXME("iface %p stub!\n", iface);
2027
2028     return NULL;
2029 }
2030
2031 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsConstantBuffer(
2032         ID3D10EffectConstantBuffer *iface)
2033 {
2034     FIXME("iface %p stub!\n", iface);
2035
2036     return NULL;
2037 }
2038
2039 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShader(
2040         ID3D10EffectConstantBuffer *iface)
2041 {
2042     FIXME("iface %p stub!\n", iface);
2043
2044     return NULL;
2045 }
2046
2047 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer *iface)
2048 {
2049     FIXME("iface %p stub!\n", iface);
2050
2051     return NULL;
2052 }
2053
2054 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencil(
2055         ID3D10EffectConstantBuffer *iface)
2056 {
2057     FIXME("iface %p stub!\n", iface);
2058
2059     return NULL;
2060 }
2061
2062 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRasterizer(
2063         ID3D10EffectConstantBuffer *iface)
2064 {
2065     FIXME("iface %p stub!\n", iface);
2066
2067     return NULL;
2068 }
2069
2070 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsSampler(
2071         ID3D10EffectConstantBuffer *iface)
2072 {
2073     FIXME("iface %p stub!\n", iface);
2074
2075     return NULL;
2076 }
2077
2078 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer *iface,
2079         void *data, UINT offset, UINT count)
2080 {
2081     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2082
2083     return E_NOTIMPL;
2084 }
2085
2086 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer *iface,
2087         void *data, UINT offset, UINT count)
2088 {
2089     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2090
2091     return E_NOTIMPL;
2092 }
2093
2094 /* ID3D10EffectConstantBuffer methods */
2095 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer *iface,
2096         ID3D10Buffer *buffer)
2097 {
2098     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
2099
2100     return E_NOTIMPL;
2101 }
2102
2103 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer *iface,
2104         ID3D10Buffer **buffer)
2105 {
2106     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
2107
2108     return E_NOTIMPL;
2109 }
2110
2111 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer *iface,
2112         ID3D10ShaderResourceView *view)
2113 {
2114     FIXME("iface %p, view %p stub!\n", iface, view);
2115
2116     return E_NOTIMPL;
2117 }
2118
2119 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer *iface,
2120         ID3D10ShaderResourceView **view)
2121 {
2122     FIXME("iface %p, view %p stub!\n", iface, view);
2123
2124     return E_NOTIMPL;
2125 }
2126
2127 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl =
2128 {
2129     /* ID3D10EffectVariable methods */
2130     d3d10_effect_constant_buffer_IsValid,
2131     d3d10_effect_constant_buffer_GetType,
2132     d3d10_effect_constant_buffer_GetDesc,
2133     d3d10_effect_constant_buffer_GetAnnotationByIndex,
2134     d3d10_effect_constant_buffer_GetAnnotationByName,
2135     d3d10_effect_constant_buffer_GetMemberByIndex,
2136     d3d10_effect_constant_buffer_GetMemberByName,
2137     d3d10_effect_constant_buffer_GetMemberBySemantic,
2138     d3d10_effect_constant_buffer_GetElement,
2139     d3d10_effect_constant_buffer_GetParentConstantBuffer,
2140     d3d10_effect_constant_buffer_AsScalar,
2141     d3d10_effect_constant_buffer_AsVector,
2142     d3d10_effect_constant_buffer_AsMatrix,
2143     d3d10_effect_constant_buffer_AsString,
2144     d3d10_effect_constant_buffer_AsShaderResource,
2145     d3d10_effect_constant_buffer_AsRenderTargetView,
2146     d3d10_effect_constant_buffer_AsDepthStencilView,
2147     d3d10_effect_constant_buffer_AsConstantBuffer,
2148     d3d10_effect_constant_buffer_AsShader,
2149     d3d10_effect_constant_buffer_AsBlend,
2150     d3d10_effect_constant_buffer_AsDepthStencil,
2151     d3d10_effect_constant_buffer_AsRasterizer,
2152     d3d10_effect_constant_buffer_AsSampler,
2153     d3d10_effect_constant_buffer_SetRawValue,
2154     d3d10_effect_constant_buffer_GetRawValue,
2155     /* ID3D10EffectConstantBuffer methods */
2156     d3d10_effect_constant_buffer_SetConstantBuffer,
2157     d3d10_effect_constant_buffer_GetConstantBuffer,
2158     d3d10_effect_constant_buffer_SetTextureBuffer,
2159     d3d10_effect_constant_buffer_GetTextureBuffer,
2160 };
2161
2162 /* ID3D10EffectVariable methods */
2163
2164 static BOOL STDMETHODCALLTYPE d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable *iface)
2165 {
2166     TRACE("iface %p\n", iface);
2167
2168     return (struct d3d10_effect_variable *)iface != &null_scalar_variable;
2169 }
2170
2171 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetType(
2172         ID3D10EffectScalarVariable *iface)
2173 {
2174     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
2175 }
2176
2177 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetDesc(ID3D10EffectScalarVariable *iface,
2178         D3D10_EFFECT_VARIABLE_DESC *desc)
2179 {
2180     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
2181 }
2182
2183 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByIndex(
2184         ID3D10EffectScalarVariable *iface, UINT index)
2185 {
2186     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
2187 }
2188
2189 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByName(
2190         ID3D10EffectScalarVariable *iface, LPCSTR name)
2191 {
2192     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
2193 }
2194
2195 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByIndex(
2196         ID3D10EffectScalarVariable *iface, UINT index)
2197 {
2198     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
2199 }
2200
2201 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByName(
2202         ID3D10EffectScalarVariable *iface, LPCSTR name)
2203 {
2204     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
2205 }
2206
2207 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberBySemantic(
2208         ID3D10EffectScalarVariable *iface, LPCSTR semantic)
2209 {
2210     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
2211 }
2212
2213 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetElement(
2214         ID3D10EffectScalarVariable *iface, UINT index)
2215 {
2216     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
2217 }
2218
2219 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetParentConstantBuffer(
2220         ID3D10EffectScalarVariable *iface)
2221 {
2222     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
2223 }
2224
2225 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsScalar(
2226         ID3D10EffectScalarVariable *iface)
2227 {
2228     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
2229 }
2230
2231 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsVector(
2232         ID3D10EffectScalarVariable *iface)
2233 {
2234     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
2235 }
2236
2237 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsMatrix(
2238         ID3D10EffectScalarVariable *iface)
2239 {
2240     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
2241 }
2242
2243 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsString(
2244         ID3D10EffectScalarVariable *iface)
2245 {
2246     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
2247 }
2248
2249 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShaderResource(
2250         ID3D10EffectScalarVariable *iface)
2251 {
2252     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
2253 }
2254
2255 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRenderTargetView(
2256         ID3D10EffectScalarVariable *iface)
2257 {
2258     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
2259 }
2260
2261 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencilView(
2262         ID3D10EffectScalarVariable *iface)
2263 {
2264     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
2265 }
2266
2267 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsConstantBuffer(
2268         ID3D10EffectScalarVariable *iface)
2269 {
2270     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
2271 }
2272
2273 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShader(
2274         ID3D10EffectScalarVariable *iface)
2275 {
2276     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
2277 }
2278
2279 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsBlend(
2280         ID3D10EffectScalarVariable *iface)
2281 {
2282     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
2283 }
2284
2285 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencil(
2286         ID3D10EffectScalarVariable *iface)
2287 {
2288     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
2289 }
2290
2291 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRasterizer(
2292         ID3D10EffectScalarVariable *iface)
2293 {
2294     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
2295 }
2296
2297 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsSampler(
2298         ID3D10EffectScalarVariable *iface)
2299 {
2300     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
2301 }
2302
2303 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetRawValue(ID3D10EffectScalarVariable *iface,
2304         void *data, UINT offset, UINT count)
2305 {
2306     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2307 }
2308
2309 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetRawValue(ID3D10EffectScalarVariable *iface,
2310         void *data, UINT offset, UINT count)
2311 {
2312     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2313 }
2314
2315 /* ID3D10EffectScalarVariable methods */
2316
2317 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable *iface,
2318         float value)
2319 {
2320     FIXME("iface %p, value %.8e stub!\n", iface, value);
2321
2322     return E_NOTIMPL;
2323 }
2324
2325 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable *iface,
2326         float *value)
2327 {
2328     FIXME("iface %p, value %p stub!\n", iface, value);
2329
2330     return E_NOTIMPL;
2331 }
2332
2333 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable *iface,
2334         float *values, UINT offset, UINT count)
2335 {
2336     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2337
2338     return E_NOTIMPL;
2339 }
2340
2341 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable *iface,
2342         float *values, UINT offset, UINT count)
2343 {
2344     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2345
2346     return E_NOTIMPL;
2347 }
2348
2349 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable *iface,
2350         int value)
2351 {
2352     FIXME("iface %p, value %d stub!\n", iface, value);
2353
2354     return E_NOTIMPL;
2355 }
2356
2357 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable *iface,
2358         int *value)
2359 {
2360     FIXME("iface %p, value %p stub!\n", iface, value);
2361
2362     return E_NOTIMPL;
2363 }
2364
2365 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable *iface,
2366         int *values, UINT offset, UINT count)
2367 {
2368     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2369
2370     return E_NOTIMPL;
2371 }
2372
2373 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable *iface,
2374         int *values, UINT offset, UINT count)
2375 {
2376     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2377
2378     return E_NOTIMPL;
2379 }
2380
2381 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable *iface,
2382         BOOL value)
2383 {
2384     FIXME("iface %p, value %d stub!\n", iface, value);
2385
2386     return E_NOTIMPL;
2387 }
2388
2389 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable *iface,
2390         BOOL *value)
2391 {
2392     FIXME("iface %p, value %p stub!\n", iface, value);
2393
2394     return E_NOTIMPL;
2395 }
2396
2397 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable *iface,
2398         BOOL *values, UINT offset, UINT count)
2399 {
2400     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2401
2402     return E_NOTIMPL;
2403 }
2404
2405 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable *iface,
2406         BOOL *values, UINT offset, UINT count)
2407 {
2408     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2409
2410     return E_NOTIMPL;
2411 }
2412
2413 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl =
2414 {
2415     /* ID3D10EffectVariable methods */
2416     d3d10_effect_scalar_variable_IsValid,
2417     d3d10_effect_scalar_variable_GetType,
2418     d3d10_effect_scalar_variable_GetDesc,
2419     d3d10_effect_scalar_variable_GetAnnotationByIndex,
2420     d3d10_effect_scalar_variable_GetAnnotationByName,
2421     d3d10_effect_scalar_variable_GetMemberByIndex,
2422     d3d10_effect_scalar_variable_GetMemberByName,
2423     d3d10_effect_scalar_variable_GetMemberBySemantic,
2424     d3d10_effect_scalar_variable_GetElement,
2425     d3d10_effect_scalar_variable_GetParentConstantBuffer,
2426     d3d10_effect_scalar_variable_AsScalar,
2427     d3d10_effect_scalar_variable_AsVector,
2428     d3d10_effect_scalar_variable_AsMatrix,
2429     d3d10_effect_scalar_variable_AsString,
2430     d3d10_effect_scalar_variable_AsShaderResource,
2431     d3d10_effect_scalar_variable_AsRenderTargetView,
2432     d3d10_effect_scalar_variable_AsDepthStencilView,
2433     d3d10_effect_scalar_variable_AsConstantBuffer,
2434     d3d10_effect_scalar_variable_AsShader,
2435     d3d10_effect_scalar_variable_AsBlend,
2436     d3d10_effect_scalar_variable_AsDepthStencil,
2437     d3d10_effect_scalar_variable_AsRasterizer,
2438     d3d10_effect_scalar_variable_AsSampler,
2439     d3d10_effect_scalar_variable_SetRawValue,
2440     d3d10_effect_scalar_variable_GetRawValue,
2441     /* ID3D10EffectScalarVariable methods */
2442     d3d10_effect_scalar_variable_SetFloat,
2443     d3d10_effect_scalar_variable_GetFloat,
2444     d3d10_effect_scalar_variable_SetFloatArray,
2445     d3d10_effect_scalar_variable_GetFloatArray,
2446     d3d10_effect_scalar_variable_SetInt,
2447     d3d10_effect_scalar_variable_GetInt,
2448     d3d10_effect_scalar_variable_SetIntArray,
2449     d3d10_effect_scalar_variable_GetIntArray,
2450     d3d10_effect_scalar_variable_SetBool,
2451     d3d10_effect_scalar_variable_GetBool,
2452     d3d10_effect_scalar_variable_SetBoolArray,
2453     d3d10_effect_scalar_variable_GetBoolArray,
2454 };
2455
2456 /* ID3D10EffectVariable methods */
2457
2458 static BOOL STDMETHODCALLTYPE d3d10_effect_vector_variable_IsValid(ID3D10EffectVectorVariable *iface)
2459 {
2460     TRACE("iface %p\n", iface);
2461
2462     return (struct d3d10_effect_variable *)iface != &null_vector_variable;
2463 }
2464
2465 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetType(
2466         ID3D10EffectVectorVariable *iface)
2467 {
2468     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
2469 }
2470
2471 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetDesc(ID3D10EffectVectorVariable *iface,
2472         D3D10_EFFECT_VARIABLE_DESC *desc)
2473 {
2474     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
2475 }
2476
2477 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByIndex(
2478         ID3D10EffectVectorVariable *iface, UINT index)
2479 {
2480     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
2481 }
2482
2483 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByName(
2484         ID3D10EffectVectorVariable *iface, LPCSTR name)
2485 {
2486     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
2487 }
2488
2489 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByIndex(
2490         ID3D10EffectVectorVariable *iface, UINT index)
2491 {
2492     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
2493 }
2494
2495 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByName(
2496         ID3D10EffectVectorVariable *iface, LPCSTR name)
2497 {
2498     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
2499 }
2500
2501 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberBySemantic(
2502         ID3D10EffectVectorVariable *iface, LPCSTR semantic)
2503 {
2504     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
2505 }
2506
2507 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetElement(
2508         ID3D10EffectVectorVariable *iface, UINT index)
2509 {
2510     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
2511 }
2512
2513 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetParentConstantBuffer(
2514         ID3D10EffectVectorVariable *iface)
2515 {
2516     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
2517 }
2518
2519 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsScalar(
2520         ID3D10EffectVectorVariable *iface)
2521 {
2522     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
2523 }
2524
2525 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsVector(
2526         ID3D10EffectVectorVariable *iface)
2527 {
2528     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
2529 }
2530
2531 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsMatrix(
2532         ID3D10EffectVectorVariable *iface)
2533 {
2534     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
2535 }
2536
2537 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsString(
2538         ID3D10EffectVectorVariable *iface)
2539 {
2540     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
2541 }
2542
2543 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShaderResource(
2544         ID3D10EffectVectorVariable *iface)
2545 {
2546     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
2547 }
2548
2549 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRenderTargetView(
2550         ID3D10EffectVectorVariable *iface)
2551 {
2552     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
2553 }
2554
2555 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencilView(
2556         ID3D10EffectVectorVariable *iface)
2557 {
2558     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
2559 }
2560
2561 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsConstantBuffer(
2562         ID3D10EffectVectorVariable *iface)
2563 {
2564     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
2565 }
2566
2567 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShader(
2568         ID3D10EffectVectorVariable *iface)
2569 {
2570     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
2571 }
2572
2573 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsBlend(
2574         ID3D10EffectVectorVariable *iface)
2575 {
2576     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
2577 }
2578
2579 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencil(
2580         ID3D10EffectVectorVariable *iface)
2581 {
2582     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
2583 }
2584
2585 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRasterizer(
2586         ID3D10EffectVectorVariable *iface)
2587 {
2588     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
2589 }
2590
2591 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsSampler(
2592         ID3D10EffectVectorVariable *iface)
2593 {
2594     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
2595 }
2596
2597 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetRawValue(ID3D10EffectVectorVariable *iface,
2598         void *data, UINT offset, UINT count)
2599 {
2600     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2601 }
2602
2603 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetRawValue(ID3D10EffectVectorVariable *iface,
2604         void *data, UINT offset, UINT count)
2605 {
2606     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2607 }
2608
2609 /* ID3D10EffectVectorVariable methods */
2610
2611 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVector(ID3D10EffectVectorVariable *iface,
2612         BOOL *value)
2613 {
2614     FIXME("iface %p, value %p stub!\n", iface, value);
2615
2616     return E_NOTIMPL;
2617 }
2618
2619 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVector(ID3D10EffectVectorVariable *iface,
2620         int *value)
2621 {
2622     FIXME("iface %p, value %p stub!\n", iface, value);
2623
2624     return E_NOTIMPL;
2625 }
2626
2627 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVector(ID3D10EffectVectorVariable *iface,
2628         float *value)
2629 {
2630     FIXME("iface %p, value %p stub!\n", iface, value);
2631
2632     return E_NOTIMPL;
2633 }
2634
2635 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVector(ID3D10EffectVectorVariable *iface,
2636         BOOL *value)
2637 {
2638     FIXME("iface %p, value %p stub!\n", iface, value);
2639
2640     return E_NOTIMPL;
2641 }
2642
2643 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVector(ID3D10EffectVectorVariable *iface,
2644         int *value)
2645 {
2646     FIXME("iface %p, value %p stub!\n", iface, value);
2647
2648     return E_NOTIMPL;
2649 }
2650
2651 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVector(ID3D10EffectVectorVariable *iface,
2652         float *value)
2653 {
2654     FIXME("iface %p, value %p stub!\n", iface, value);
2655
2656     return E_NOTIMPL;
2657 }
2658
2659 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVectorArray(ID3D10EffectVectorVariable *iface,
2660         BOOL *values, UINT offset, UINT count)
2661 {
2662     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2663
2664     return E_NOTIMPL;
2665 }
2666
2667 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVectorArray(ID3D10EffectVectorVariable *iface,
2668         int *values, UINT offset, UINT count)
2669 {
2670     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2671
2672     return E_NOTIMPL;
2673 }
2674
2675 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVectorArray(ID3D10EffectVectorVariable *iface,
2676         float *values, UINT offset, UINT count)
2677 {
2678     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2679
2680     return E_NOTIMPL;
2681 }
2682
2683 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVectorArray(ID3D10EffectVectorVariable *iface,
2684         BOOL *values, UINT offset, UINT count)
2685 {
2686     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2687
2688     return E_NOTIMPL;
2689 }
2690
2691 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVectorArray(ID3D10EffectVectorVariable *iface,
2692         int *values, UINT offset, UINT count)
2693 {
2694     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2695
2696     return E_NOTIMPL;
2697 }
2698
2699 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVectorArray(ID3D10EffectVectorVariable *iface,
2700         float *values, UINT offset, UINT count)
2701 {
2702     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
2703
2704     return E_NOTIMPL;
2705 }
2706
2707 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl =
2708 {
2709     /* ID3D10EffectVariable methods */
2710     d3d10_effect_vector_variable_IsValid,
2711     d3d10_effect_vector_variable_GetType,
2712     d3d10_effect_vector_variable_GetDesc,
2713     d3d10_effect_vector_variable_GetAnnotationByIndex,
2714     d3d10_effect_vector_variable_GetAnnotationByName,
2715     d3d10_effect_vector_variable_GetMemberByIndex,
2716     d3d10_effect_vector_variable_GetMemberByName,
2717     d3d10_effect_vector_variable_GetMemberBySemantic,
2718     d3d10_effect_vector_variable_GetElement,
2719     d3d10_effect_vector_variable_GetParentConstantBuffer,
2720     d3d10_effect_vector_variable_AsScalar,
2721     d3d10_effect_vector_variable_AsVector,
2722     d3d10_effect_vector_variable_AsMatrix,
2723     d3d10_effect_vector_variable_AsString,
2724     d3d10_effect_vector_variable_AsShaderResource,
2725     d3d10_effect_vector_variable_AsRenderTargetView,
2726     d3d10_effect_vector_variable_AsDepthStencilView,
2727     d3d10_effect_vector_variable_AsConstantBuffer,
2728     d3d10_effect_vector_variable_AsShader,
2729     d3d10_effect_vector_variable_AsBlend,
2730     d3d10_effect_vector_variable_AsDepthStencil,
2731     d3d10_effect_vector_variable_AsRasterizer,
2732     d3d10_effect_vector_variable_AsSampler,
2733     d3d10_effect_vector_variable_SetRawValue,
2734     d3d10_effect_vector_variable_GetRawValue,
2735     /* ID3D10EffectVectorVariable methods */
2736     d3d10_effect_vector_variable_SetBoolVector,
2737     d3d10_effect_vector_variable_SetIntVector,
2738     d3d10_effect_vector_variable_SetFloatVector,
2739     d3d10_effect_vector_variable_GetBoolVector,
2740     d3d10_effect_vector_variable_GetIntVector,
2741     d3d10_effect_vector_variable_GetFloatVector,
2742     d3d10_effect_vector_variable_SetBoolVectorArray,
2743     d3d10_effect_vector_variable_SetIntVectorArray,
2744     d3d10_effect_vector_variable_SetFloatVectorArray,
2745     d3d10_effect_vector_variable_GetBoolVectorArray,
2746     d3d10_effect_vector_variable_GetIntVectorArray,
2747     d3d10_effect_vector_variable_GetFloatVectorArray,
2748 };
2749
2750 /* ID3D10EffectVariable methods */
2751
2752 static BOOL STDMETHODCALLTYPE d3d10_effect_matrix_variable_IsValid(ID3D10EffectMatrixVariable *iface)
2753 {
2754     TRACE("iface %p\n", iface);
2755
2756     return (struct d3d10_effect_variable *)iface != &null_matrix_variable;
2757 }
2758
2759 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetType(
2760         ID3D10EffectMatrixVariable *iface)
2761 {
2762     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
2763 }
2764
2765 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetDesc(ID3D10EffectMatrixVariable *iface,
2766         D3D10_EFFECT_VARIABLE_DESC *desc)
2767 {
2768     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
2769 }
2770
2771 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByIndex(
2772         ID3D10EffectMatrixVariable *iface, UINT index)
2773 {
2774     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
2775 }
2776
2777 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByName(
2778         ID3D10EffectMatrixVariable *iface, LPCSTR name)
2779 {
2780     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
2781 }
2782
2783 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByIndex(
2784         ID3D10EffectMatrixVariable *iface, UINT index)
2785 {
2786     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
2787 }
2788
2789 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByName(
2790         ID3D10EffectMatrixVariable *iface, LPCSTR name)
2791 {
2792     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
2793 }
2794
2795 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberBySemantic(
2796         ID3D10EffectMatrixVariable *iface, LPCSTR semantic)
2797 {
2798     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
2799 }
2800
2801 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetElement(
2802         ID3D10EffectMatrixVariable *iface, UINT index)
2803 {
2804     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
2805 }
2806
2807 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetParentConstantBuffer(
2808         ID3D10EffectMatrixVariable *iface)
2809 {
2810     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
2811 }
2812
2813 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsScalar(
2814         ID3D10EffectMatrixVariable *iface)
2815 {
2816     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
2817 }
2818
2819 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsVector(
2820         ID3D10EffectMatrixVariable *iface)
2821 {
2822     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
2823 }
2824
2825 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsMatrix(
2826         ID3D10EffectMatrixVariable *iface)
2827 {
2828     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
2829 }
2830
2831 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsString(
2832         ID3D10EffectMatrixVariable *iface)
2833 {
2834     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
2835 }
2836
2837 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShaderResource(
2838         ID3D10EffectMatrixVariable *iface)
2839 {
2840     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
2841 }
2842
2843 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRenderTargetView(
2844         ID3D10EffectMatrixVariable *iface)
2845 {
2846     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
2847 }
2848
2849 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencilView(
2850         ID3D10EffectMatrixVariable *iface)
2851 {
2852     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
2853 }
2854
2855 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsConstantBuffer(
2856         ID3D10EffectMatrixVariable *iface)
2857 {
2858     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
2859 }
2860
2861 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShader(
2862         ID3D10EffectMatrixVariable *iface)
2863 {
2864     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
2865 }
2866
2867 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsBlend(
2868         ID3D10EffectMatrixVariable *iface)
2869 {
2870     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
2871 }
2872
2873 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencil(
2874         ID3D10EffectMatrixVariable *iface)
2875 {
2876     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
2877 }
2878
2879 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRasterizer(
2880         ID3D10EffectMatrixVariable *iface)
2881 {
2882     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
2883 }
2884
2885 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsSampler(
2886         ID3D10EffectMatrixVariable *iface)
2887 {
2888     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
2889 }
2890
2891 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetRawValue(ID3D10EffectMatrixVariable *iface,
2892         void *data, UINT offset, UINT count)
2893 {
2894     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2895 }
2896
2897 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetRawValue(ID3D10EffectMatrixVariable *iface,
2898         void *data, UINT offset, UINT count)
2899 {
2900     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
2901 }
2902
2903 /* ID3D10EffectMatrixVariable methods */
2904
2905 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrix(ID3D10EffectMatrixVariable *iface,
2906         float *data)
2907 {
2908     FIXME("iface %p, data %p stub!\n", iface, data);
2909
2910     return E_NOTIMPL;
2911 }
2912
2913 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrix(ID3D10EffectMatrixVariable *iface,
2914         float *data)
2915 {
2916     FIXME("iface %p, data %p stub!\n", iface, data);
2917
2918     return E_NOTIMPL;
2919 }
2920
2921 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixArray(ID3D10EffectMatrixVariable *iface,
2922         float *data, UINT offset, UINT count)
2923 {
2924     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2925
2926     return E_NOTIMPL;
2927 }
2928
2929 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixArray(ID3D10EffectMatrixVariable *iface,
2930         float *data, UINT offset, UINT count)
2931 {
2932     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2933
2934     return E_NOTIMPL;
2935 }
2936
2937 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
2938         float *data)
2939 {
2940     FIXME("iface %p, data %p stub!\n", iface, data);
2941
2942     return E_NOTIMPL;
2943 }
2944
2945 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
2946         float *data)
2947 {
2948     FIXME("iface %p, data %p stub!\n", iface, data);
2949
2950     return E_NOTIMPL;
2951 }
2952
2953 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
2954         float *data, UINT offset, UINT count)
2955 {
2956     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2957
2958     return E_NOTIMPL;
2959 }
2960
2961 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
2962         float *data, UINT offset, UINT count)
2963 {
2964     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
2965
2966     return E_NOTIMPL;
2967 }
2968
2969
2970 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl =
2971 {
2972     /* ID3D10EffectVariable methods */
2973     d3d10_effect_matrix_variable_IsValid,
2974     d3d10_effect_matrix_variable_GetType,
2975     d3d10_effect_matrix_variable_GetDesc,
2976     d3d10_effect_matrix_variable_GetAnnotationByIndex,
2977     d3d10_effect_matrix_variable_GetAnnotationByName,
2978     d3d10_effect_matrix_variable_GetMemberByIndex,
2979     d3d10_effect_matrix_variable_GetMemberByName,
2980     d3d10_effect_matrix_variable_GetMemberBySemantic,
2981     d3d10_effect_matrix_variable_GetElement,
2982     d3d10_effect_matrix_variable_GetParentConstantBuffer,
2983     d3d10_effect_matrix_variable_AsScalar,
2984     d3d10_effect_matrix_variable_AsVector,
2985     d3d10_effect_matrix_variable_AsMatrix,
2986     d3d10_effect_matrix_variable_AsString,
2987     d3d10_effect_matrix_variable_AsShaderResource,
2988     d3d10_effect_matrix_variable_AsRenderTargetView,
2989     d3d10_effect_matrix_variable_AsDepthStencilView,
2990     d3d10_effect_matrix_variable_AsConstantBuffer,
2991     d3d10_effect_matrix_variable_AsShader,
2992     d3d10_effect_matrix_variable_AsBlend,
2993     d3d10_effect_matrix_variable_AsDepthStencil,
2994     d3d10_effect_matrix_variable_AsRasterizer,
2995     d3d10_effect_matrix_variable_AsSampler,
2996     d3d10_effect_matrix_variable_SetRawValue,
2997     d3d10_effect_matrix_variable_GetRawValue,
2998     /* ID3D10EffectMatrixVariable methods */
2999     d3d10_effect_matrix_variable_SetMatrix,
3000     d3d10_effect_matrix_variable_GetMatrix,
3001     d3d10_effect_matrix_variable_SetMatrixArray,
3002     d3d10_effect_matrix_variable_GetMatrixArray,
3003     d3d10_effect_matrix_variable_SetMatrixTranspose,
3004     d3d10_effect_matrix_variable_GetMatrixTranspose,
3005     d3d10_effect_matrix_variable_SetMatrixTransposeArray,
3006     d3d10_effect_matrix_variable_GetMatrixTransposeArray,
3007 };
3008
3009 static BOOL STDMETHODCALLTYPE d3d10_effect_type_IsValid(ID3D10EffectType *iface)
3010 {
3011     FIXME("iface %p stub!\n", iface);
3012
3013     return FALSE;
3014 }
3015
3016 static HRESULT STDMETHODCALLTYPE d3d10_effect_type_GetDesc(ID3D10EffectType *iface, D3D10_EFFECT_TYPE_DESC *desc)
3017 {
3018     struct d3d10_effect_type *This = (struct d3d10_effect_type *)iface;
3019
3020     TRACE("iface %p, desc %p\n", iface, desc);
3021
3022     if (!desc) return E_INVALIDARG;
3023
3024     desc->TypeName = This->name;
3025     desc->Class = This->type_class;
3026     desc->Type = This->basetype;
3027     desc->Elements = This->element_count;
3028     desc->Members = This->member_count;
3029     desc->Rows = This->row_count;
3030     desc->Columns = This->column_count;
3031     desc->PackedSize = This->size_packed;
3032     desc->UnpackedSize = This->size_unpacked;
3033     desc->Stride = This->stride;
3034
3035     return S_OK;
3036 }
3037
3038 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByIndex(ID3D10EffectType *iface,
3039         UINT index)
3040 {
3041     FIXME("iface %p, index %u stub!\n", iface, index);
3042
3043     return NULL;
3044 }
3045
3046 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByName(ID3D10EffectType *iface,
3047         LPCSTR name)
3048 {
3049     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
3050
3051     return NULL;
3052 }
3053
3054 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeBySemantic(ID3D10EffectType *iface,
3055         LPCSTR semantic)
3056 {
3057     FIXME("iface %p, semantic %s stub!\n", iface, debugstr_a(semantic));
3058
3059     return NULL;
3060 }
3061
3062 static LPCSTR STDMETHODCALLTYPE d3d10_effect_type_GetMemberName(ID3D10EffectType *iface, UINT index)
3063 {
3064     FIXME("iface %p, index %u stub!\n", iface, index);
3065
3066     return NULL;
3067 }
3068
3069 static LPCSTR STDMETHODCALLTYPE d3d10_effect_type_GetMemberSemantic(ID3D10EffectType *iface, UINT index)
3070 {
3071     FIXME("iface %p, index %u stub!\n", iface, index);
3072
3073     return NULL;
3074 }
3075
3076 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl =
3077 {
3078     /* ID3D10EffectType */
3079     d3d10_effect_type_IsValid,
3080     d3d10_effect_type_GetDesc,
3081     d3d10_effect_type_GetMemberTypeByIndex,
3082     d3d10_effect_type_GetMemberTypeByName,
3083     d3d10_effect_type_GetMemberTypeBySemantic,
3084     d3d10_effect_type_GetMemberName,
3085     d3d10_effect_type_GetMemberSemantic,
3086 };