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 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl;
  35 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl;
  36 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl;
  37 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl;
  38
  39 /* null objects - needed for invalid calls */
  40 static struct d3d10_effect_technique null_technique = {&d3d10_effect_technique_vtbl, NULL, NULL, 0, 0, NULL};
  41 static struct d3d10_effect_pass null_pass = {&d3d10_effect_pass_vtbl, NULL, NULL, 0, 0, 0, NULL};
  42 static struct d3d10_effect_local_buffer null_local_buffer = {&d3d10_effect_constant_buffer_vtbl, NULL, 0, 0, 0, NULL};
  43 static struct d3d10_effect_variable null_variable = {&d3d10_effect_variable_vtbl, NULL, 0, 0};
  44
  45 static inline void read_dword(const char **ptr, DWORD *d)
  46 {
  47     memcpy(d, *ptr, sizeof(*d));
  48     *ptr += sizeof(*d);
  49 }
  50
  51 static inline void skip_dword_unknown(const char **ptr, unsigned int count)
  52 {
  53     unsigned int i;
  54     DWORD d;
  55
  56     FIXME("Skipping %u unknown DWORDs:\n", count);
  57     for (i = 0; i < count; ++i)
  58     {
  59         read_dword(ptr, &d);
  60         FIXME("\t0x%08x\n", d);
  61     }
  62 }
  63
  64 static inline void write_dword(char **ptr, DWORD d)
  65 {
  66     memcpy(*ptr, &d, sizeof(d));
  67     *ptr += sizeof(d);
  68 }
  69
  70 static inline void write_dword_unknown(char **ptr, DWORD d)
  71 {
  72     FIXME("Writing unknown DWORD 0x%08x\n", d);
  73     write_dword(ptr, d);
  74 }
  75
  76 static inline void read_tag(const char **ptr, DWORD *t, char t_str[5])
  77 {
  78     read_dword(ptr, t);
  79     memcpy(t_str, t, 4);
  80     t_str[4] = '\0';
  81 }
  82
  83 static HRESULT parse_dxbc(const char *data, SIZE_T data_size,
  84         HRESULT (*chunk_handler)(const char *data, DWORD data_size, DWORD tag, void *ctx), void *ctx)
  85 {
  86     const char *ptr = data;
  87     HRESULT hr = S_OK;
  88     DWORD chunk_count;
  89     DWORD total_size;
  90     char tag_str[5];
  91     unsigned int i;
  92     DWORD tag;
  93
  94     read_tag(&ptr, &tag, tag_str);
  95     TRACE("tag: %s\n", tag_str);
  96
  97     if (tag != TAG_DXBC)
  98     {
  99         WARN("Wrong tag.\n");
 100         return E_FAIL;
 101     }
 102
 103     /* checksum? */
 104     skip_dword_unknown(&ptr, 4);
 105
 106     skip_dword_unknown(&ptr, 1);
 107
 108     read_dword(&ptr, &total_size);
 109     TRACE("total size: %#x\n", total_size);
 110
 111     read_dword(&ptr, &chunk_count);
 112     TRACE("chunk count: %#x\n", chunk_count);
 113
 114     for (i = 0; i < chunk_count; ++i)
 115     {
 116         DWORD chunk_tag, chunk_size;
 117         const char *chunk_ptr;
 118         DWORD chunk_offset;
 119
 120         read_dword(&ptr, &chunk_offset);
 121         TRACE("chunk %u at offset %#x\n", i, chunk_offset);
 122
 123         chunk_ptr = data + chunk_offset;
 124
 125         read_dword(&chunk_ptr, &chunk_tag);
 126         read_dword(&chunk_ptr, &chunk_size);
 127
 128         hr = chunk_handler(chunk_ptr, chunk_size, chunk_tag, ctx);
 129         if (FAILED(hr)) break;
 130     }
 131
 132     return hr;
 133 }
 134
 135 static char *copy_name(const char *ptr)
 136 {
 137     size_t name_len;
 138     char *name;
 139
 140     name_len = strlen(ptr) + 1;
 141     name = HeapAlloc(GetProcessHeap(), 0, name_len);
 142     if (!name)
 143     {
 144         ERR("Failed to allocate name memory.\n");
 145         return NULL;
 146     }
 147
 148     memcpy(name, ptr, name_len);
 149
 150     return name;
 151 }
 152
 153 static HRESULT shader_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
 154 {
 155     struct d3d10_effect_shader_variable *s = ctx;
 156     char tag_str[5];
 157
 158     memcpy(tag_str, &tag, 4);
 159     tag_str[4] = '\0';
 160     TRACE("tag: %s\n", tag_str);
 161
 162     TRACE("chunk size: %#x\n", data_size);
 163
 164     switch(tag)
 165     {
 166         case TAG_ISGN:
 167         {
 168             /* 32 (DXBC header) + 1 * 4 (chunk index) + 2 * 4 (chunk header) + data_size (chunk data) */
 169             UINT size = 44 + data_size;
 170             char *ptr;
 171
 172             s->input_signature = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 173             if (!s->input_signature)
 174             {
 175                 ERR("Failed to allocate input signature data\n");
 176                 return E_OUTOFMEMORY;
 177             }
 178             s->input_signature_size = size;
 179
 180             ptr = s->input_signature;
 181
 182             write_dword(&ptr, TAG_DXBC);
 183
 184             /* signature(?) */
 185             write_dword_unknown(&ptr, 0);
 186             write_dword_unknown(&ptr, 0);
 187             write_dword_unknown(&ptr, 0);
 188             write_dword_unknown(&ptr, 0);
 189
 190             /* seems to be always 1 */
 191             write_dword_unknown(&ptr, 1);
 192
 193             /* DXBC size */
 194             write_dword(&ptr, size);
 195
 196             /* chunk count */
 197             write_dword(&ptr, 1);
 198
 199             /* chunk index */
 200             write_dword(&ptr, (ptr - s->input_signature) + 4);
 201
 202             /* chunk */
 203             write_dword(&ptr, TAG_ISGN);
 204             write_dword(&ptr, data_size);
 205             memcpy(ptr, data, data_size);
 206             break;
 207         }
 208
 209         default:
 210             FIXME("Unhandled chunk %s\n", tag_str);
 211             break;
 212     }
 213
 214     return S_OK;
 215 }
 216
 217 static HRESULT parse_shader(struct d3d10_effect_object *o, const char *data)
 218 {
 219     ID3D10Device *device = o->pass->technique->effect->device;
 220     struct d3d10_effect_shader_variable *s;
 221     const char *ptr = data;
 222     DWORD dxbc_size;
 223     HRESULT hr;
 224
 225     o->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct d3d10_effect_shader_variable));
 226     if (!o->data)
 227     {
 228         ERR("Failed to allocate shader variable memory\n");
 229         return E_OUTOFMEMORY;
 230     }
 231
 232     if (!ptr) return S_OK;
 233
 234     s = o->data;
 235
 236     read_dword(&ptr, &dxbc_size);
 237     TRACE("dxbc size: %#x\n", dxbc_size);
 238
 239     switch (o->type)
 240     {
 241         case D3D10_EOT_VERTEXSHADER:
 242             hr = ID3D10Device_CreateVertexShader(device, ptr, dxbc_size, &s->shader.vs);
 243             if (FAILED(hr)) return hr;
 244             break;
 245
 246         case D3D10_EOT_PIXELSHADER:
 247             hr = ID3D10Device_CreatePixelShader(device, ptr, dxbc_size, &s->shader.ps);
 248             if (FAILED(hr)) return hr;
 249             break;
 250         case D3D10_EOT_GEOMETRYSHADER:
 251             hr = ID3D10Device_CreateGeometryShader(device, ptr, dxbc_size, &s->shader.gs);
 252             if (FAILED(hr)) return hr;
 253             break;
 254     }
 255
 256     return parse_dxbc(ptr, dxbc_size, shader_chunk_handler, s);
 257 }
 258
 259 static void parse_fx10_annotation(const char **ptr)
 260 {
 261     skip_dword_unknown(ptr, 3);
 262 }
 263
 264 static HRESULT parse_fx10_object(struct d3d10_effect_object *o, const char **ptr, const char *data)
 265 {
 266     const char *data_ptr;
 267     DWORD offset;
 268     HRESULT hr;
 269
 270     read_dword(ptr, &o->type);
 271     TRACE("Effect object is of type %#x.\n", o->type);
 272
 273     skip_dword_unknown(ptr, 2);
 274
 275     read_dword(ptr, &offset);
 276     TRACE("Effect object idx is at offset %#x.\n", offset);
 277
 278     data_ptr = data + offset;
 279     read_dword(&data_ptr, &offset);
 280
 281     TRACE("Effect object starts at offset %#x.\n", offset);
 282
 283     /* FIXME: This probably isn't completely correct. */
 284     if (offset == 1)
 285     {
 286         WARN("Skipping effect object.\n");
 287         data_ptr = NULL;
 288     }
 289     else
 290     {
 291         data_ptr = data + offset;
 292     }
 293
 294     switch (o->type)
 295     {
 296         case D3D10_EOT_VERTEXSHADER:
 297             TRACE("Vertex shader\n");
 298             hr = parse_shader(o, data_ptr);
 299             break;
 300
 301         case D3D10_EOT_PIXELSHADER:
 302             TRACE("Pixel shader\n");
 303             hr = parse_shader(o, data_ptr);
 304             break;
 305
 306         case D3D10_EOT_GEOMETRYSHADER:
 307             TRACE("Geometry shader\n");
 308             hr = parse_shader(o, data_ptr);
 309             break;
 310
 311         default:
 312             FIXME("Unhandled object type %#x\n", o->type);
 313             hr = E_FAIL;
 314             break;
 315     }
 316
 317     return hr;
 318 }
 319
 320 static HRESULT parse_fx10_pass(struct d3d10_effect_pass *p, const char **ptr, const char *data)
 321 {
 322     HRESULT hr = S_OK;
 323     unsigned int i;
 324     DWORD offset;
 325
 326     read_dword(ptr, &offset);
 327     TRACE("Pass name at offset %#x.\n", offset);
 328
 329     p->name = copy_name(data + offset);
 330     if (!p->name)
 331     {
 332         ERR("Failed to copy name.\n");
 333         return E_OUTOFMEMORY;
 334     }
 335     TRACE("Pass name: %s.\n", p->name);
 336
 337     read_dword(ptr, &p->object_count);
 338     TRACE("Pass has %u effect objects.\n", p->object_count);
 339
 340     read_dword(ptr, &p->annotation_count);
 341     for(i = 0; i < p->annotation_count; ++i)
 342     {
 343         parse_fx10_annotation(ptr);
 344     }
 345
 346     p->objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, p->object_count * sizeof(*p->objects));
 347     if (!p->objects)
 348     {
 349         ERR("Failed to allocate effect objects memory.\n");
 350         return E_OUTOFMEMORY;
 351     }
 352
 353     for (i = 0; i < p->object_count; ++i)
 354     {
 355         struct d3d10_effect_object *o = &p->objects[i];
 356
 357         o->pass = p;
 358
 359         hr = parse_fx10_object(o, ptr, data);
 360         if (FAILED(hr)) return hr;
 361     }
 362
 363     return hr;
 364 }
 365
 366 static HRESULT parse_fx10_technique(struct d3d10_effect_technique *t, const char **ptr, const char *data)
 367 {
 368     unsigned int i;
 369     DWORD offset;
 370
 371     read_dword(ptr, &offset);
 372     TRACE("Technique name at offset %#x.\n", offset);
 373
 374     t->name = copy_name(data + offset);
 375     if (!t->name)
 376     {
 377         ERR("Failed to copy name.\n");
 378         return E_OUTOFMEMORY;
 379     }
 380     TRACE("Technique name: %s.\n", t->name);
 381
 382     read_dword(ptr, &t->pass_count);
 383     TRACE("Technique has %u passes\n", t->pass_count);
 384
 385     read_dword(ptr, &t->annotation_count);
 386     for(i = 0; i < t->annotation_count; ++i)
 387     {
 388         parse_fx10_annotation(ptr);
 389     }
 390
 391     t->passes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->pass_count * sizeof(*t->passes));
 392     if (!t->passes)
 393     {
 394         ERR("Failed to allocate passes memory\n");
 395         return E_OUTOFMEMORY;
 396     }
 397
 398     for (i = 0; i < t->pass_count; ++i)
 399     {
 400         struct d3d10_effect_pass *p = &t->passes[i];
 401         HRESULT hr;
 402
 403         p->vtbl = &d3d10_effect_pass_vtbl;
 404         p->technique = t;
 405
 406         hr = parse_fx10_pass(p, ptr, data);
 407         if (FAILED(hr)) return hr;
 408     }
 409
 410     return S_OK;
 411 }
 412
 413 static HRESULT parse_fx10_variable(struct d3d10_effect_variable *v, const char **ptr, const char *data)
 414 {
 415     DWORD offset;
 416     unsigned int i;
 417
 418     read_dword(ptr, &offset);
 419     TRACE("Variable name at offset %#x.\n", offset);
 420
 421     v->name = copy_name(data + offset);
 422     if (!v->name)
 423     {
 424         ERR("Failed to copy name.\n");
 425         return E_OUTOFMEMORY;
 426     }
 427     TRACE("Variable name: %s.\n", v->name);
 428
 429     read_dword(ptr, &offset);
 430     TRACE("Variable type info at offset %#x.\n", offset);
 431
 432     skip_dword_unknown(ptr, 1);
 433
 434     read_dword(ptr, &v->buffer_offset);
 435     TRACE("Variable offset in buffer: %#x.\n", v->buffer_offset);
 436
 437     skip_dword_unknown(ptr, 1);
 438
 439     read_dword(ptr, &v->flag);
 440     TRACE("Variable flag: %#x.\n", v->flag);
 441
 442     read_dword(ptr, &v->annotation_count);
 443     for(i = 0; i < v->annotation_count; ++i)
 444     {
 445         parse_fx10_annotation(ptr);
 446     }
 447
 448     return S_OK;
 449 }
 450
 451 static HRESULT parse_fx10_local_buffer(struct d3d10_effect_local_buffer *l, const char **ptr, const char *data)
 452 {
 453     unsigned int i;
 454     DWORD offset;
 455
 456     read_dword(ptr, &offset);
 457     TRACE("Local buffer name at offset %#x.\n", offset);
 458
 459     l->name = copy_name(data + offset);
 460     if (!l->name)
 461     {
 462         ERR("Failed to copy name.\n");
 463         return E_OUTOFMEMORY;
 464     }
 465     TRACE("Local buffer name: %s.\n", l->name);
 466
 467     read_dword(ptr, &l->data_size);
 468     TRACE("Local buffer data size: %#x.\n", l->data_size);
 469
 470     skip_dword_unknown(ptr, 1);
 471
 472     read_dword(ptr, &l->variable_count);
 473     TRACE("Local buffer variable count: %#x.\n", l->variable_count);
 474
 475     skip_dword_unknown(ptr, 1);
 476
 477     read_dword(ptr, &l->annotation_count);
 478     for(i = 0; i < l->annotation_count; ++i)
 479     {
 480         parse_fx10_annotation(ptr);
 481     }
 482
 483     l->variables = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->variable_count * sizeof(*l->variables));
 484     if (!l->variables)
 485     {
 486         ERR("Failed to allocate variables memory.\n");
 487         return E_OUTOFMEMORY;
 488     }
 489
 490     for (i = 0; i < l->variable_count; ++i)
 491     {
 492         struct d3d10_effect_variable *v = &l->variables[i];
 493         HRESULT hr;
 494
 495         v->vtbl = &d3d10_effect_variable_vtbl;
 496
 497         hr = parse_fx10_variable(v, ptr, data);
 498         if (FAILED(hr)) return hr;
 499     }
 500
 501     return S_OK;
 502 }
 503
 504 static HRESULT parse_fx10_body(struct d3d10_effect *e, const char *data, DWORD data_size)
 505 {
 506     const char *ptr = data + e->index_offset;
 507     unsigned int i;
 508     HRESULT hr;
 509
 510     e->local_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->local_buffer_count * sizeof(*e->local_buffers));
 511     if (!e->local_buffers)
 512     {
 513         ERR("Failed to allocate local buffer memory.\n");
 514         return E_OUTOFMEMORY;
 515     }
 516
 517     e->techniques = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->technique_count * sizeof(*e->techniques));
 518     if (!e->techniques)
 519     {
 520         ERR("Failed to allocate techniques memory\n");
 521         return E_OUTOFMEMORY;
 522     }
 523
 524     for (i = 0; i < e->local_buffer_count; ++i)
 525     {
 526         struct d3d10_effect_local_buffer *l = &e->local_buffers[i];
 527         l->vtbl = &d3d10_effect_constant_buffer_vtbl;
 528
 529         hr = parse_fx10_local_buffer(l, &ptr, data);
 530         if (FAILED(hr)) return hr;
 531     }
 532
 533     for (i = 0; i < e->technique_count; ++i)
 534     {
 535         struct d3d10_effect_technique *t = &e->techniques[i];
 536
 537         t->vtbl = &d3d10_effect_technique_vtbl;
 538         t->effect = e;
 539
 540         hr = parse_fx10_technique(t, &ptr, data);
 541         if (FAILED(hr)) return hr;
 542     }
 543
 544     return S_OK;
 545 }
 546
 547 static HRESULT parse_fx10(struct d3d10_effect *e, const char *data, DWORD data_size)
 548 {
 549     const char *ptr = data;
 550     DWORD unknown;
 551
 552     /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
 553     read_dword(&ptr, &e->version);
 554     TRACE("Target: %#x\n", e->version);
 555
 556     read_dword(&ptr, &e->local_buffer_count);
 557     TRACE("Local buffer count: %u.\n", e->local_buffer_count);
 558
 559     read_dword(&ptr, &e->variable_count);
 560     TRACE("Variable count: %u\n", e->variable_count);
 561
 562     read_dword(&ptr, &e->object_count);
 563     TRACE("Object count: %u\n", e->object_count);
 564
 565     read_dword(&ptr, &e->sharedbuffers_count);
 566     TRACE("Sharedbuffers count: %u\n", e->sharedbuffers_count);
 567
 568     /* Number of variables in shared buffers? */
 569     read_dword(&ptr, &unknown);
 570     FIXME("Unknown 0: %u\n", unknown);
 571
 572     read_dword(&ptr, &e->sharedobjects_count);
 573     TRACE("Sharedobjects count: %u\n", e->sharedobjects_count);
 574
 575     read_dword(&ptr, &e->technique_count);
 576     TRACE("Technique count: %u\n", e->technique_count);
 577
 578     read_dword(&ptr, &e->index_offset);
 579     TRACE("Index offset: %#x\n", e->index_offset);
 580
 581     read_dword(&ptr, &unknown);
 582     FIXME("Unknown 1: %u\n", unknown);
 583
 584     read_dword(&ptr, &e->texture_count);
 585     TRACE("Texture count: %u\n", e->texture_count);
 586
 587     read_dword(&ptr, &e->dephstencilstate_count);
 588     TRACE("Depthstencilstate count: %u\n", e->dephstencilstate_count);
 589
 590     read_dword(&ptr, &e->blendstate_count);
 591     TRACE("Blendstate count: %u\n", e->blendstate_count);
 592
 593     read_dword(&ptr, &e->rasterizerstate_count);
 594     TRACE("Rasterizerstate count: %u\n", e->rasterizerstate_count);
 595
 596     read_dword(&ptr, &e->samplerstate_count);
 597     TRACE("Samplerstate count: %u\n", e->samplerstate_count);
 598
 599     read_dword(&ptr, &e->rendertargetview_count);
 600     TRACE("Rendertargetview count: %u\n", e->rendertargetview_count);
 601
 602     read_dword(&ptr, &e->depthstencilview_count);
 603     TRACE("Depthstencilview count: %u\n", e->depthstencilview_count);
 604
 605     read_dword(&ptr, &e->shader_call_count);
 606     TRACE("Shader call count: %u\n", e->shader_call_count);
 607
 608     read_dword(&ptr, &e->shader_compile_count);
 609     TRACE("Shader compile count: %u\n", e->shader_compile_count);
 610
 611     return parse_fx10_body(e, ptr, data_size - (ptr - data));
 612 }
 613
 614 static HRESULT fx10_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
 615 {
 616     struct d3d10_effect *e = ctx;
 617     char tag_str[5];
 618
 619     memcpy(tag_str, &tag, 4);
 620     tag_str[4] = '\0';
 621     TRACE("tag: %s\n", tag_str);
 622
 623     TRACE("chunk size: %#x\n", data_size);
 624
 625     switch(tag)
 626     {
 627         case TAG_FX10:
 628             return parse_fx10(e, data, data_size);
 629
 630         default:
 631             FIXME("Unhandled chunk %s\n", tag_str);
 632             return S_OK;
 633     }
 634 }
 635
 636 HRESULT d3d10_effect_parse(struct d3d10_effect *This, const void *data, SIZE_T data_size)
 637 {
 638     return parse_dxbc(data, data_size, fx10_chunk_handler, This);
 639 }
 640
 641 static void d3d10_effect_object_destroy(struct d3d10_effect_object *o)
 642 {
 643     TRACE("effect object %p.\n", o);
 644
 645     switch(o->type)
 646     {
 647         case D3D10_EOT_VERTEXSHADER:
 648         case D3D10_EOT_PIXELSHADER:
 649         case D3D10_EOT_GEOMETRYSHADER:
 650             HeapFree(GetProcessHeap(), 0, ((struct d3d10_effect_shader_variable *)o->data)->input_signature);
 651             break;
 652
 653         default:
 654             break;
 655     }
 656     HeapFree(GetProcessHeap(), 0, o->data);
 657 }
 658
 659 static HRESULT d3d10_effect_object_apply(struct d3d10_effect_object *o)
 660 {
 661     ID3D10Device *device = o->pass->technique->effect->device;
 662
 663     TRACE("effect object %p, type %#x.\n", o, o->type);
 664
 665     switch(o->type)
 666     {
 667         case D3D10_EOT_VERTEXSHADER:
 668             ID3D10Device_VSSetShader(device, ((struct d3d10_effect_shader_variable *)o->data)->shader.vs);
 669             return S_OK;
 670
 671         case D3D10_EOT_PIXELSHADER:
 672             ID3D10Device_PSSetShader(device, ((struct d3d10_effect_shader_variable *)o->data)->shader.ps);
 673             return S_OK;
 674
 675         case D3D10_EOT_GEOMETRYSHADER:
 676             ID3D10Device_GSSetShader(device, ((struct d3d10_effect_shader_variable *)o->data)->shader.gs);
 677             return S_OK;
 678
 679         default:
 680             FIXME("Unhandled effect object type %#x.\n", o->type);
 681             return E_FAIL;
 682     }
 683 }
 684
 685 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass *p)
 686 {
 687     TRACE("pass %p\n", p);
 688
 689     HeapFree(GetProcessHeap(), 0, p->name);
 690     if (p->objects)
 691     {
 692         unsigned int i;
 693         for (i = 0; i < p->object_count; ++i)
 694         {
 695             d3d10_effect_object_destroy(&p->objects[i]);
 696         }
 697         HeapFree(GetProcessHeap(), 0, p->objects);
 698     }
 699 }
 700
 701 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique *t)
 702 {
 703     TRACE("technique %p\n", t);
 704
 705     HeapFree(GetProcessHeap(), 0, t->name);
 706     if (t->passes)
 707     {
 708         unsigned int i;
 709         for (i = 0; i < t->pass_count; ++i)
 710         {
 711             d3d10_effect_pass_destroy(&t->passes[i]);
 712         }
 713         HeapFree(GetProcessHeap(), 0, t->passes);
 714     }
 715 }
 716
 717 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable *v)
 718 {
 719     TRACE("variable %p.\n", v);
 720
 721     HeapFree(GetProcessHeap(), 0, v->name);
 722 }
 723
 724 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_local_buffer *l)
 725 {
 726     TRACE("local buffer %p.\n", l);
 727
 728     HeapFree(GetProcessHeap(), 0, l->name);
 729     if (l->variables)
 730     {
 731         unsigned int i;
 732         for (i = 0; i < l->variable_count; ++i)
 733         {
 734             d3d10_effect_variable_destroy(&l->variables[i]);
 735         }
 736         HeapFree(GetProcessHeap(), 0, l->variables);
 737     }
 738 }
 739
 740 /* IUnknown methods */
 741
 742 static HRESULT STDMETHODCALLTYPE d3d10_effect_QueryInterface(ID3D10Effect *iface, REFIID riid, void **object)
 743 {
 744     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 745
 746     if (IsEqualGUID(riid, &IID_ID3D10Effect)
 747             || IsEqualGUID(riid, &IID_IUnknown))
 748     {
 749         IUnknown_AddRef(iface);
 750         *object = iface;
 751         return S_OK;
 752     }
 753
 754     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 755
 756     *object = NULL;
 757     return E_NOINTERFACE;
 758 }
 759
 760 static ULONG STDMETHODCALLTYPE d3d10_effect_AddRef(ID3D10Effect *iface)
 761 {
 762     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 763     ULONG refcount = InterlockedIncrement(&This->refcount);
 764
 765     TRACE("%p increasing refcount to %u\n", This, refcount);
 766
 767     return refcount;
 768 }
 769
 770 static ULONG STDMETHODCALLTYPE d3d10_effect_Release(ID3D10Effect *iface)
 771 {
 772     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 773     ULONG refcount = InterlockedDecrement(&This->refcount);
 774
 775     TRACE("%p decreasing refcount to %u\n", This, refcount);
 776
 777     if (!refcount)
 778     {
 779         unsigned int i;
 780
 781         if (This->techniques)
 782         {
 783             for (i = 0; i < This->technique_count; ++i)
 784             {
 785                 d3d10_effect_technique_destroy(&This->techniques[i]);
 786             }
 787             HeapFree(GetProcessHeap(), 0, This->techniques);
 788         }
 789
 790         if (This->local_buffers)
 791         {
 792             for (i = 0; i < This->local_buffer_count; ++i)
 793             {
 794                 d3d10_effect_local_buffer_destroy(&This->local_buffers[i]);
 795             }
 796             HeapFree(GetProcessHeap(), 0, This->local_buffers);
 797         }
 798
 799         ID3D10Device_Release(This->device);
 800         HeapFree(GetProcessHeap(), 0, This);
 801     }
 802
 803     return refcount;
 804 }
 805
 806 /* ID3D10Effect methods */
 807
 808 static BOOL STDMETHODCALLTYPE d3d10_effect_IsValid(ID3D10Effect *iface)
 809 {
 810     FIXME("iface %p stub!\n", iface);
 811
 812     return FALSE;
 813 }
 814
 815 static BOOL STDMETHODCALLTYPE d3d10_effect_IsPool(ID3D10Effect *iface)
 816 {
 817     FIXME("iface %p stub!\n", iface);
 818
 819     return FALSE;
 820 }
 821
 822 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDevice(ID3D10Effect *iface, ID3D10Device **device)
 823 {
 824     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 825
 826     TRACE("iface %p, device %p\n", iface, device);
 827
 828     ID3D10Device_AddRef(This->device);
 829     *device = This->device;
 830
 831     return S_OK;
 832 }
 833
 834 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDesc(ID3D10Effect *iface, D3D10_EFFECT_DESC *desc)
 835 {
 836     FIXME("iface %p, desc %p stub!\n", iface, desc);
 837
 838     return E_NOTIMPL;
 839 }
 840
 841 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByIndex(ID3D10Effect *iface,
 842         UINT index)
 843 {
 844     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 845     struct d3d10_effect_local_buffer *l;
 846
 847     TRACE("iface %p, index %u\n", iface, index);
 848
 849     if (index >= This->local_buffer_count)
 850     {
 851         WARN("Invalid index specified\n");
 852         return (ID3D10EffectConstantBuffer *)&null_local_buffer;
 853     }
 854
 855     l = &This->local_buffers[index];
 856
 857     TRACE("Returning buffer %p, \"%s\"\n", l, l->name);
 858
 859     return (ID3D10EffectConstantBuffer *)l;
 860 }
 861
 862 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByName(ID3D10Effect *iface,
 863         LPCSTR name)
 864 {
 865     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 866     unsigned int i;
 867
 868     TRACE("iface %p, name \"%s\"\n", iface, name);
 869
 870     for (i = 0; i < This->local_buffer_count; ++i)
 871     {
 872         struct d3d10_effect_local_buffer *l = &This->local_buffers[i];
 873
 874         if (!strcmp(l->name, name))
 875         {
 876             TRACE("Returning buffer %p.\n", l);
 877             return (ID3D10EffectConstantBuffer *)l;
 878         }
 879     }
 880
 881     WARN("Invalid name specified\n");
 882
 883     return (ID3D10EffectConstantBuffer *)&null_local_buffer;
 884 }
 885
 886 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByIndex(ID3D10Effect *iface, UINT index)
 887 {
 888     FIXME("iface %p, index %u stub!\n", iface, index);
 889
 890     return NULL;
 891 }
 892
 893 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByName(ID3D10Effect *iface, LPCSTR name)
 894 {
 895     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 896     unsigned int i;
 897
 898     TRACE("iface %p, name \"%s\"\n", iface, name);
 899
 900     for (i = 0; i < This->local_buffer_count; ++i)
 901     {
 902         struct d3d10_effect_local_buffer *l = &This->local_buffers[i];
 903         unsigned int j;
 904
 905         for (j = 0; j < l->variable_count; ++j)
 906         {
 907             struct d3d10_effect_variable *v = &l->variables[j];
 908
 909             if (!strcmp(v->name, name))
 910             {
 911                 TRACE("Returning variable %p.\n", v);
 912                 return (ID3D10EffectVariable *)v;
 913             }
 914         }
 915     }
 916
 917     WARN("Invalid name specified\n");
 918
 919     return (ID3D10EffectVariable *)&null_variable;
 920 }
 921
 922 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableBySemantic(ID3D10Effect *iface,
 923         LPCSTR semantic)
 924 {
 925     FIXME("iface %p, semantic \"%s\" stub!\n", iface, semantic);
 926
 927     return NULL;
 928 }
 929
 930 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByIndex(ID3D10Effect *iface,
 931         UINT index)
 932 {
 933     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 934     struct d3d10_effect_technique *t;
 935
 936     TRACE("iface %p, index %u\n", iface, index);
 937
 938     if (index >= This->technique_count)
 939     {
 940         WARN("Invalid index specified\n");
 941         return (ID3D10EffectTechnique *)&null_technique;
 942     }
 943
 944     t = &This->techniques[index];
 945
 946     TRACE("Returning technique %p, \"%s\"\n", t, t->name);
 947
 948     return (ID3D10EffectTechnique *)t;
 949 }
 950
 951 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByName(ID3D10Effect *iface,
 952         LPCSTR name)
 953 {
 954     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 955     unsigned int i;
 956
 957     TRACE("iface %p, name \"%s\"\n", iface, name);
 958
 959     for (i = 0; i < This->technique_count; ++i)
 960     {
 961         struct d3d10_effect_technique *t = &This->techniques[i];
 962         if (!strcmp(t->name, name))
 963         {
 964             TRACE("Returning technique %p\n", t);
 965             return (ID3D10EffectTechnique *)t;
 966         }
 967     }
 968
 969     WARN("Invalid name specified\n");
 970
 971     return (ID3D10EffectTechnique *)&null_technique;
 972 }
 973
 974 static HRESULT STDMETHODCALLTYPE d3d10_effect_Optimize(ID3D10Effect *iface)
 975 {
 976     FIXME("iface %p stub!\n", iface);
 977
 978     return E_NOTIMPL;
 979 }
 980
 981 static BOOL STDMETHODCALLTYPE d3d10_effect_IsOptimized(ID3D10Effect *iface)
 982 {
 983     FIXME("iface %p stub!\n", iface);
 984
 985     return FALSE;
 986 }
 987
 988 const struct ID3D10EffectVtbl d3d10_effect_vtbl =
 989 {
 990     /* IUnknown methods */
 991     d3d10_effect_QueryInterface,
 992     d3d10_effect_AddRef,
 993     d3d10_effect_Release,
 994     /* ID3D10Effect methods */
 995     d3d10_effect_IsValid,
 996     d3d10_effect_IsPool,
 997     d3d10_effect_GetDevice,
 998     d3d10_effect_GetDesc,
 999     d3d10_effect_GetConstantBufferByIndex,
1000     d3d10_effect_GetConstantBufferByName,
1001     d3d10_effect_GetVariableByIndex,
1002     d3d10_effect_GetVariableByName,
1003     d3d10_effect_GetVariableBySemantic,
1004     d3d10_effect_GetTechniqueByIndex,
1005     d3d10_effect_GetTechniqueByName,
1006     d3d10_effect_Optimize,
1007     d3d10_effect_IsOptimized,
1008 };
1009
1010 /* ID3D10EffectTechnique methods */
1011
1012 static BOOL STDMETHODCALLTYPE d3d10_effect_technique_IsValid(ID3D10EffectTechnique *iface)
1013 {
1014     FIXME("iface %p stub!\n", iface);
1015
1016     return FALSE;
1017 }
1018
1019 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_GetDesc(ID3D10EffectTechnique *iface,
1020         D3D10_TECHNIQUE_DESC *desc)
1021 {
1022     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1023
1024     TRACE("iface %p, desc %p\n", iface, desc);
1025
1026     if(This == &null_technique)
1027     {
1028         WARN("Null technique specified\n");
1029         return E_FAIL;
1030     }
1031
1032     if(!desc)
1033     {
1034         WARN("Invalid argument specified\n");
1035         return E_INVALIDARG;
1036     }
1037
1038     desc->Name = This->name;
1039     desc->Passes = This->pass_count;
1040     WARN("Annotations not implemented\n");
1041     desc->Annotations = 0;
1042
1043     return S_OK;
1044 }
1045
1046 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByIndex(
1047         ID3D10EffectTechnique *iface, UINT index)
1048 {
1049     FIXME("iface %p, index %u stub!\n", iface, index);
1050
1051     return NULL;
1052 }
1053
1054 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByName(
1055         ID3D10EffectTechnique *iface, LPCSTR name)
1056 {
1057     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
1058
1059     return NULL;
1060 }
1061
1062 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique *iface,
1063         UINT index)
1064 {
1065     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1066     struct d3d10_effect_pass *p;
1067
1068     TRACE("iface %p, index %u\n", iface, index);
1069
1070     if (index >= This->pass_count)
1071     {
1072         WARN("Invalid index specified\n");
1073         return (ID3D10EffectPass *)&null_pass;
1074     }
1075
1076     p = &This->passes[index];
1077
1078     TRACE("Returning pass %p, \"%s\"\n", p, p->name);
1079
1080     return (ID3D10EffectPass *)p;
1081 }
1082
1083 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique *iface,
1084         LPCSTR name)
1085 {
1086     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1087     unsigned int i;
1088
1089     TRACE("iface %p, name \"%s\"\n", iface, name);
1090
1091     for (i = 0; i < This->pass_count; ++i)
1092     {
1093         struct d3d10_effect_pass *p = &This->passes[i];
1094         if (!strcmp(p->name, name))
1095         {
1096             TRACE("Returning pass %p\n", p);
1097             return (ID3D10EffectPass *)p;
1098         }
1099     }
1100
1101     WARN("Invalid name specified\n");
1102
1103     return (ID3D10EffectPass *)&null_pass;
1104 }
1105
1106 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique *iface,
1107         D3D10_STATE_BLOCK_MASK *mask)
1108 {
1109     FIXME("iface %p,mask %p stub!\n", iface, mask);
1110
1111     return E_NOTIMPL;
1112 }
1113
1114 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl =
1115 {
1116     /* ID3D10EffectTechnique methods */
1117     d3d10_effect_technique_IsValid,
1118     d3d10_effect_technique_GetDesc,
1119     d3d10_effect_technique_GetAnnotationByIndex,
1120     d3d10_effect_technique_GetAnnotationByName,
1121     d3d10_effect_technique_GetPassByIndex,
1122     d3d10_effect_technique_GetPassByName,
1123     d3d10_effect_technique_ComputeStateBlockMask,
1124 };
1125
1126 /* ID3D10EffectPass methods */
1127
1128 static BOOL STDMETHODCALLTYPE d3d10_effect_pass_IsValid(ID3D10EffectPass *iface)
1129 {
1130     FIXME("iface %p stub!\n", iface);
1131
1132     return FALSE;
1133 }
1134
1135 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetDesc(ID3D10EffectPass *iface, D3D10_PASS_DESC *desc)
1136 {
1137     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1138     unsigned int i;
1139
1140     FIXME("iface %p, desc %p partial stub!\n", iface, desc);
1141
1142     if(This == &null_pass)
1143     {
1144         WARN("Null pass specified\n");
1145         return E_FAIL;
1146     }
1147
1148     if(!desc)
1149     {
1150         WARN("Invalid argument specified\n");
1151         return E_INVALIDARG;
1152     }
1153
1154     memset(desc, 0, sizeof(*desc));
1155     desc->Name = This->name;
1156     for (i = 0; i < This->object_count; ++i)
1157     {
1158         struct d3d10_effect_object *o = &This->objects[i];
1159         if (o->type == D3D10_EOT_VERTEXSHADER)
1160         {
1161             struct d3d10_effect_shader_variable *s = o->data;
1162             desc->pIAInputSignature = (BYTE *)s->input_signature;
1163             desc->IAInputSignatureSize = s->input_signature_size;
1164             break;
1165         }
1166     }
1167
1168     return S_OK;
1169 }
1170
1171 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass *iface,
1172         D3D10_PASS_SHADER_DESC *desc)
1173 {
1174     FIXME("iface %p, desc %p stub!\n", iface, desc);
1175
1176     return E_NOTIMPL;
1177 }
1178
1179 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass *iface,
1180         D3D10_PASS_SHADER_DESC *desc)
1181 {
1182     FIXME("iface %p, desc %p stub!\n", iface, desc);
1183
1184     return E_NOTIMPL;
1185 }
1186
1187 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass *iface,
1188         D3D10_PASS_SHADER_DESC *desc)
1189 {
1190     FIXME("iface %p, desc %p stub!\n", iface, desc);
1191
1192     return E_NOTIMPL;
1193 }
1194
1195 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass *iface,
1196         UINT index)
1197 {
1198     FIXME("iface %p, index %u stub!\n", iface, index);
1199
1200     return NULL;
1201 }
1202
1203 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass *iface,
1204         LPCSTR name)
1205 {
1206     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
1207
1208     return NULL;
1209 }
1210
1211 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_Apply(ID3D10EffectPass *iface, UINT flags)
1212 {
1213     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1214     HRESULT hr = S_OK;
1215     unsigned int i;
1216
1217     TRACE("iface %p, flags %#x\n", iface, flags);
1218
1219     if (flags) FIXME("Ignoring flags (%#x)\n", flags);
1220
1221     for (i = 0; i < This->object_count; ++i)
1222     {
1223         hr = d3d10_effect_object_apply(&This->objects[i]);
1224         if (FAILED(hr)) break;
1225     }
1226
1227     return hr;
1228 }
1229
1230 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass *iface,
1231         D3D10_STATE_BLOCK_MASK *mask)
1232 {
1233     FIXME("iface %p, mask %p stub!\n", iface, mask);
1234
1235     return E_NOTIMPL;
1236 }
1237
1238 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl =
1239 {
1240     /* ID3D10EffectPass methods */
1241     d3d10_effect_pass_IsValid,
1242     d3d10_effect_pass_GetDesc,
1243     d3d10_effect_pass_GetVertexShaderDesc,
1244     d3d10_effect_pass_GetGeometryShaderDesc,
1245     d3d10_effect_pass_GetPixelShaderDesc,
1246     d3d10_effect_pass_GetAnnotationByIndex,
1247     d3d10_effect_pass_GetAnnotationByName,
1248     d3d10_effect_pass_Apply,
1249     d3d10_effect_pass_ComputeStateBlockMask,
1250 };
1251
1252 /* ID3D10EffectVariable methods */
1253
1254 static BOOL STDMETHODCALLTYPE d3d10_effect_variable_IsValid(ID3D10EffectVariable *iface)
1255 {
1256     FIXME("iface %p stub!\n", iface);
1257
1258     return FALSE;
1259 }
1260
1261 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_variable_GetType(ID3D10EffectVariable *iface)
1262 {
1263     FIXME("iface %p stub!\n", iface);
1264
1265     return NULL;
1266 }
1267
1268 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetDesc(ID3D10EffectVariable *iface,
1269         D3D10_EFFECT_VARIABLE_DESC *desc)
1270 {
1271     FIXME("iface %p, desc %p stub!\n", iface, desc);
1272
1273     return E_NOTIMPL;
1274 }
1275
1276 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByIndex(
1277         ID3D10EffectVariable *iface, UINT index)
1278 {
1279     FIXME("iface %p, index %u stub!\n", iface, index);
1280
1281     return NULL;
1282 }
1283
1284 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByName(
1285         ID3D10EffectVariable *iface, LPCSTR name)
1286 {
1287     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
1288
1289     return NULL;
1290 }
1291
1292 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByIndex(
1293         ID3D10EffectVariable *iface, UINT index)
1294 {
1295     FIXME("iface %p, index %u stub!\n", iface, index);
1296
1297     return NULL;
1298 }
1299
1300 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByName(
1301         ID3D10EffectVariable *iface, LPCSTR name)
1302 {
1303     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
1304
1305     return NULL;
1306 }
1307
1308 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberBySemantic(
1309         ID3D10EffectVariable *iface, LPCSTR semantic)
1310 {
1311     FIXME("iface %p, semantic \"%s\" stub!\n", iface, semantic);
1312
1313     return NULL;
1314 }
1315
1316 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetElement(
1317         ID3D10EffectVariable *iface, UINT index)
1318 {
1319     FIXME("iface %p, index %u stub!\n", iface, index);
1320
1321     return NULL;
1322 }
1323
1324 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_GetParentConstantBuffer(
1325         ID3D10EffectVariable *iface)
1326 {
1327     FIXME("iface %p stub!\n", iface);
1328
1329     return NULL;
1330 }
1331
1332 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsScalar(
1333         ID3D10EffectVariable *iface)
1334 {
1335     FIXME("iface %p stub!\n", iface);
1336
1337     return NULL;
1338 }
1339
1340 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsVector(
1341         ID3D10EffectVariable *iface)
1342 {
1343     FIXME("iface %p stub!\n", iface);
1344
1345     return NULL;
1346 }
1347
1348 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsMatrix(
1349         ID3D10EffectVariable *iface)
1350 {
1351     FIXME("iface %p stub!\n", iface);
1352
1353     return NULL;
1354 }
1355
1356 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsString(
1357         ID3D10EffectVariable *iface)
1358 {
1359     FIXME("iface %p stub!\n", iface);
1360
1361     return NULL;
1362 }
1363
1364 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShaderResource(
1365         ID3D10EffectVariable *iface)
1366 {
1367     FIXME("iface %p stub!\n", iface);
1368
1369     return NULL;
1370 }
1371
1372 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRenderTargetView(
1373         ID3D10EffectVariable *iface)
1374 {
1375     FIXME("iface %p stub!\n", iface);
1376
1377     return NULL;
1378 }
1379
1380 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencilView(
1381         ID3D10EffectVariable *iface)
1382 {
1383     FIXME("iface %p stub!\n", iface);
1384
1385     return NULL;
1386 }
1387
1388 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_AsConstantBuffer(
1389         ID3D10EffectVariable *iface)
1390 {
1391     FIXME("iface %p stub!\n", iface);
1392
1393     return NULL;
1394 }
1395
1396 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShader(
1397         ID3D10EffectVariable *iface)
1398 {
1399     FIXME("iface %p stub!\n", iface);
1400
1401     return NULL;
1402 }
1403
1404 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsBlend(ID3D10EffectVariable *iface)
1405 {
1406     FIXME("iface %p stub!\n", iface);
1407
1408     return NULL;
1409 }
1410
1411 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencil(
1412         ID3D10EffectVariable *iface)
1413 {
1414     FIXME("iface %p stub!\n", iface);
1415
1416     return NULL;
1417 }
1418
1419 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRasterizer(
1420         ID3D10EffectVariable *iface)
1421 {
1422     FIXME("iface %p stub!\n", iface);
1423
1424     return NULL;
1425 }
1426
1427 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsSampler(
1428         ID3D10EffectVariable *iface)
1429 {
1430     FIXME("iface %p stub!\n", iface);
1431
1432     return NULL;
1433 }
1434
1435 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_SetRawValue(ID3D10EffectVariable *iface,
1436         void *data, UINT offset, UINT count)
1437 {
1438     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1439
1440     return E_NOTIMPL;
1441 }
1442
1443 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetRawValue(ID3D10EffectVariable *iface,
1444         void *data, UINT offset, UINT count)
1445 {
1446     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1447
1448     return E_NOTIMPL;
1449 }
1450
1451 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl =
1452 {
1453     /* ID3D10EffectVariable methods */
1454     d3d10_effect_variable_IsValid,
1455     d3d10_effect_variable_GetType,
1456     d3d10_effect_variable_GetDesc,
1457     d3d10_effect_variable_GetAnnotationByIndex,
1458     d3d10_effect_variable_GetAnnotationByName,
1459     d3d10_effect_variable_GetMemberByIndex,
1460     d3d10_effect_variable_GetMemberByName,
1461     d3d10_effect_variable_GetMemberBySemantic,
1462     d3d10_effect_variable_GetElement,
1463     d3d10_effect_variable_GetParentConstantBuffer,
1464     d3d10_effect_variable_AsScalar,
1465     d3d10_effect_variable_AsVector,
1466     d3d10_effect_variable_AsMatrix,
1467     d3d10_effect_variable_AsString,
1468     d3d10_effect_variable_AsShaderResource,
1469     d3d10_effect_variable_AsRenderTargetView,
1470     d3d10_effect_variable_AsDepthStencilView,
1471     d3d10_effect_variable_AsConstantBuffer,
1472     d3d10_effect_variable_AsShader,
1473     d3d10_effect_variable_AsBlend,
1474     d3d10_effect_variable_AsDepthStencil,
1475     d3d10_effect_variable_AsRasterizer,
1476     d3d10_effect_variable_AsSampler,
1477     d3d10_effect_variable_SetRawValue,
1478     d3d10_effect_variable_GetRawValue,
1479 };
1480
1481 /* ID3D10EffectVariable methods */
1482 static BOOL STDMETHODCALLTYPE d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer *iface)
1483 {
1484     FIXME("iface %p stub!\n", iface);
1485
1486     return FALSE;
1487 }
1488
1489 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer *iface)
1490 {
1491     FIXME("iface %p stub!\n", iface);
1492
1493     return NULL;
1494 }
1495
1496 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer *iface,
1497         D3D10_EFFECT_VARIABLE_DESC *desc)
1498 {
1499     FIXME("iface %p, desc %p stub!\n", iface, desc);
1500
1501     return E_NOTIMPL;
1502 }
1503
1504 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByIndex(
1505         ID3D10EffectConstantBuffer *iface, UINT index)
1506 {
1507     FIXME("iface %p, index %u stub!\n", iface, index);
1508
1509     return NULL;
1510 }
1511
1512 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByName(
1513         ID3D10EffectConstantBuffer *iface, LPCSTR name)
1514 {
1515     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
1516
1517     return NULL;
1518 }
1519
1520 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByIndex(
1521         ID3D10EffectConstantBuffer *iface, UINT index)
1522 {
1523     FIXME("iface %p, index %u stub!\n", iface, index);
1524
1525     return NULL;
1526 }
1527
1528 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByName(
1529         ID3D10EffectConstantBuffer *iface, LPCSTR name)
1530 {
1531     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
1532
1533     return NULL;
1534 }
1535
1536 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberBySemantic(
1537         ID3D10EffectConstantBuffer *iface, LPCSTR semantic)
1538 {
1539     FIXME("iface %p, semantic \"%s\" stub!\n", iface, semantic);
1540
1541     return NULL;
1542 }
1543
1544 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetElement(
1545         ID3D10EffectConstantBuffer *iface, UINT index)
1546 {
1547     FIXME("iface %p, index %u stub!\n", iface, index);
1548
1549     return NULL;
1550 }
1551
1552 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetParentConstantBuffer(
1553         ID3D10EffectConstantBuffer *iface)
1554 {
1555     FIXME("iface %p stub!\n", iface);
1556
1557     return NULL;
1558 }
1559
1560 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsScalar(
1561         ID3D10EffectConstantBuffer *iface)
1562 {
1563     FIXME("iface %p stub!\n", iface);
1564
1565     return NULL;
1566 }
1567
1568 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsVector(
1569         ID3D10EffectConstantBuffer *iface)
1570 {
1571     FIXME("iface %p stub!\n", iface);
1572
1573     return NULL;
1574 }
1575
1576 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsMatrix(
1577         ID3D10EffectConstantBuffer *iface)
1578 {
1579     FIXME("iface %p stub!\n", iface);
1580
1581     return NULL;
1582 }
1583
1584 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsString(
1585         ID3D10EffectConstantBuffer *iface)
1586 {
1587     FIXME("iface %p stub!\n", iface);
1588
1589     return NULL;
1590 }
1591
1592 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShaderResource(
1593         ID3D10EffectConstantBuffer *iface)
1594 {
1595     FIXME("iface %p stub!\n", iface);
1596
1597     return NULL;
1598 }
1599
1600 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRenderTargetView(
1601         ID3D10EffectConstantBuffer *iface)
1602 {
1603     FIXME("iface %p stub!\n", iface);
1604
1605     return NULL;
1606 }
1607
1608 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencilView(
1609         ID3D10EffectConstantBuffer *iface)
1610 {
1611     FIXME("iface %p stub!\n", iface);
1612
1613     return NULL;
1614 }
1615
1616 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsConstantBuffer(
1617         ID3D10EffectConstantBuffer *iface)
1618 {
1619     FIXME("iface %p stub!\n", iface);
1620
1621     return NULL;
1622 }
1623
1624 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShader(
1625         ID3D10EffectConstantBuffer *iface)
1626 {
1627     FIXME("iface %p stub!\n", iface);
1628
1629     return NULL;
1630 }
1631
1632 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer *iface)
1633 {
1634     FIXME("iface %p stub!\n", iface);
1635
1636     return NULL;
1637 }
1638
1639 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencil(
1640         ID3D10EffectConstantBuffer *iface)
1641 {
1642     FIXME("iface %p stub!\n", iface);
1643
1644     return NULL;
1645 }
1646
1647 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRasterizer(
1648         ID3D10EffectConstantBuffer *iface)
1649 {
1650     FIXME("iface %p stub!\n", iface);
1651
1652     return NULL;
1653 }
1654
1655 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsSampler(
1656         ID3D10EffectConstantBuffer *iface)
1657 {
1658     FIXME("iface %p stub!\n", iface);
1659
1660     return NULL;
1661 }
1662
1663 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer *iface,
1664         void *data, UINT offset, UINT count)
1665 {
1666     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1667
1668     return E_NOTIMPL;
1669 }
1670
1671 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer *iface,
1672         void *data, UINT offset, UINT count)
1673 {
1674     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1675
1676     return E_NOTIMPL;
1677 }
1678
1679 /* ID3D10EffectConstantBuffer methods */
1680 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer *iface,
1681         ID3D10Buffer *buffer)
1682 {
1683     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
1684
1685     return E_NOTIMPL;
1686 }
1687
1688 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer *iface,
1689         ID3D10Buffer **buffer)
1690 {
1691     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
1692
1693     return E_NOTIMPL;
1694 }
1695
1696 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer *iface,
1697         ID3D10ShaderResourceView *view)
1698 {
1699     FIXME("iface %p, view %p stub!\n", iface, view);
1700
1701     return E_NOTIMPL;
1702 }
1703
1704 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer *iface,
1705         ID3D10ShaderResourceView **view)
1706 {
1707     FIXME("iface %p, view %p stub!\n", iface, view);
1708
1709     return E_NOTIMPL;
1710 }
1711
1712 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl =
1713 {
1714     /* ID3D10EffectVariable methods */
1715     d3d10_effect_constant_buffer_IsValid,
1716     d3d10_effect_constant_buffer_GetType,
1717     d3d10_effect_constant_buffer_GetDesc,
1718     d3d10_effect_constant_buffer_GetAnnotationByIndex,
1719     d3d10_effect_constant_buffer_GetAnnotationByName,
1720     d3d10_effect_constant_buffer_GetMemberByIndex,
1721     d3d10_effect_constant_buffer_GetMemberByName,
1722     d3d10_effect_constant_buffer_GetMemberBySemantic,
1723     d3d10_effect_constant_buffer_GetElement,
1724     d3d10_effect_constant_buffer_GetParentConstantBuffer,
1725     d3d10_effect_constant_buffer_AsScalar,
1726     d3d10_effect_constant_buffer_AsVector,
1727     d3d10_effect_constant_buffer_AsMatrix,
1728     d3d10_effect_constant_buffer_AsString,
1729     d3d10_effect_constant_buffer_AsShaderResource,
1730     d3d10_effect_constant_buffer_AsRenderTargetView,
1731     d3d10_effect_constant_buffer_AsDepthStencilView,
1732     d3d10_effect_constant_buffer_AsConstantBuffer,
1733     d3d10_effect_constant_buffer_AsShader,
1734     d3d10_effect_constant_buffer_AsBlend,
1735     d3d10_effect_constant_buffer_AsDepthStencil,
1736     d3d10_effect_constant_buffer_AsRasterizer,
1737     d3d10_effect_constant_buffer_AsSampler,
1738     d3d10_effect_constant_buffer_SetRawValue,
1739     d3d10_effect_constant_buffer_GetRawValue,
1740     /* ID3D10EffectConstantBuffer methods */
1741     d3d10_effect_constant_buffer_SetConstantBuffer,
1742     d3d10_effect_constant_buffer_GetConstantBuffer,
1743     d3d10_effect_constant_buffer_SetTextureBuffer,
1744     d3d10_effect_constant_buffer_GetTextureBuffer,
1745 };