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