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
  38 static inline void read_dword(const char **ptr, DWORD *d)
  39 {
  40     memcpy(d, *ptr, sizeof(*d));
  41     *ptr += sizeof(*d);
  42 }
  43
  44 static inline void skip_dword_unknown(const char **ptr, unsigned int count)
  45 {
  46     unsigned int i;
  47     DWORD d;
  48
  49     FIXME("Skipping %u unknown DWORDs:\n", count);
  50     for (i = 0; i < count; ++i)
  51     {
  52         read_dword(ptr, &d);
  53         FIXME("\t0x%08x\n", d);
  54     }
  55 }
  56
  57 static inline void write_dword(char **ptr, DWORD d)
  58 {
  59     memcpy(*ptr, &d, sizeof(d));
  60     *ptr += sizeof(d);
  61 }
  62
  63 static inline void write_dword_unknown(char **ptr, DWORD d)
  64 {
  65     FIXME("Writing unknown DWORD 0x%08x\n", d);
  66     write_dword(ptr, d);
  67 }
  68
  69 static inline void read_tag(const char **ptr, DWORD *t, char t_str[5])
  70 {
  71     read_dword(ptr, t);
  72     memcpy(t_str, t, 4);
  73     t_str[4] = '\0';
  74 }
  75
  76 static HRESULT parse_dxbc(const char *data, SIZE_T data_size,
  77         HRESULT (*chunk_handler)(const char *data, DWORD data_size, DWORD tag, void *ctx), void *ctx)
  78 {
  79     const char *ptr = data;
  80     HRESULT hr = S_OK;
  81     DWORD chunk_count;
  82     DWORD total_size;
  83     char tag_str[5];
  84     unsigned int i;
  85     DWORD tag;
  86
  87     read_tag(&ptr, &tag, tag_str);
  88     TRACE("tag: %s\n", tag_str);
  89
  90     if (tag != TAG_DXBC)
  91     {
  92         WARN("Wrong tag.\n");
  93         return E_FAIL;
  94     }
  95
  96     /* checksum? */
  97     skip_dword_unknown(&ptr, 4);
  98
  99     skip_dword_unknown(&ptr, 1);
 100
 101     read_dword(&ptr, &total_size);
 102     TRACE("total size: %#x\n", total_size);
 103
 104     read_dword(&ptr, &chunk_count);
 105     TRACE("chunk count: %#x\n", chunk_count);
 106
 107     for (i = 0; i < chunk_count; ++i)
 108     {
 109         DWORD chunk_tag, chunk_size;
 110         const char *chunk_ptr;
 111         DWORD chunk_offset;
 112
 113         read_dword(&ptr, &chunk_offset);
 114         TRACE("chunk %u at offset %#x\n", i, chunk_offset);
 115
 116         chunk_ptr = data + chunk_offset;
 117
 118         read_dword(&chunk_ptr, &chunk_tag);
 119         read_dword(&chunk_ptr, &chunk_size);
 120
 121         hr = chunk_handler(chunk_ptr, chunk_size, chunk_tag, ctx);
 122         if (FAILED(hr)) break;
 123     }
 124
 125     return hr;
 126 }
 127
 128 static char *copy_name(const char *ptr)
 129 {
 130     size_t name_len;
 131     char *name;
 132
 133     name_len = strlen(ptr) + 1;
 134     name = HeapAlloc(GetProcessHeap(), 0, name_len);
 135     if (!name)
 136     {
 137         ERR("Failed to allocate name memory.\n");
 138         return NULL;
 139     }
 140
 141     memcpy(name, ptr, name_len);
 142
 143     return name;
 144 }
 145
 146 static HRESULT shader_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
 147 {
 148     struct d3d10_effect_shader_variable *s = ctx;
 149     char tag_str[5];
 150
 151     memcpy(tag_str, &tag, 4);
 152     tag_str[4] = '\0';
 153     TRACE("tag: %s\n", tag_str);
 154
 155     TRACE("chunk size: %#x\n", data_size);
 156
 157     switch(tag)
 158     {
 159         case TAG_ISGN:
 160         {
 161             /* 32 (DXBC header) + 1 * 4 (chunk index) + 2 * 4 (chunk header) + data_size (chunk data) */
 162             UINT size = 44 + data_size;
 163             char *ptr;
 164
 165             s->input_signature = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 166             if (!s->input_signature)
 167             {
 168                 ERR("Failed to allocate input signature data\n");
 169                 return E_OUTOFMEMORY;
 170             }
 171             s->input_signature_size = size;
 172
 173             ptr = s->input_signature;
 174
 175             write_dword(&ptr, TAG_DXBC);
 176
 177             /* signature(?) */
 178             write_dword_unknown(&ptr, 0);
 179             write_dword_unknown(&ptr, 0);
 180             write_dword_unknown(&ptr, 0);
 181             write_dword_unknown(&ptr, 0);
 182
 183             /* seems to be always 1 */
 184             write_dword_unknown(&ptr, 1);
 185
 186             /* DXBC size */
 187             write_dword(&ptr, size);
 188
 189             /* chunk count */
 190             write_dword(&ptr, 1);
 191
 192             /* chunk index */
 193             write_dword(&ptr, (ptr - s->input_signature) + 4);
 194
 195             /* chunk */
 196             write_dword(&ptr, TAG_ISGN);
 197             write_dword(&ptr, data_size);
 198             memcpy(ptr, data, data_size);
 199             break;
 200         }
 201
 202         default:
 203             FIXME("Unhandled chunk %s\n", tag_str);
 204             break;
 205     }
 206
 207     return S_OK;
 208 }
 209
 210 static HRESULT parse_shader(struct d3d10_effect_object *o, const char *data)
 211 {
 212     ID3D10Device *device = o->pass->technique->effect->device;
 213     struct d3d10_effect_shader_variable *s;
 214     const char *ptr = data;
 215     DWORD dxbc_size;
 216     HRESULT hr;
 217
 218     o->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct d3d10_effect_shader_variable));
 219     if (!o->data)
 220     {
 221         ERR("Failed to allocate shader variable memory\n");
 222         return E_OUTOFMEMORY;
 223     }
 224
 225     if (!ptr) return S_OK;
 226
 227     s = o->data;
 228
 229     read_dword(&ptr, &dxbc_size);
 230     TRACE("dxbc size: %#x\n", dxbc_size);
 231
 232     switch (o->type)
 233     {
 234         case D3D10_EOT_VERTEXSHADER:
 235             hr = ID3D10Device_CreateVertexShader(device, ptr, dxbc_size, &s->shader.vs);
 236             if (FAILED(hr)) return hr;
 237             break;
 238
 239         case D3D10_EOT_PIXELSHADER:
 240             hr = ID3D10Device_CreatePixelShader(device, ptr, dxbc_size, &s->shader.ps);
 241             if (FAILED(hr)) return hr;
 242             break;
 243         case D3D10_EOT_GEOMETRYSHADER:
 244             hr = ID3D10Device_CreateGeometryShader(device, ptr, dxbc_size, &s->shader.gs);
 245             if (FAILED(hr)) return hr;
 246             break;
 247     }
 248
 249     return parse_dxbc(ptr, dxbc_size, shader_chunk_handler, s);
 250 }
 251
 252 static HRESULT parse_fx10_object(struct d3d10_effect_object *o, const char **ptr, const char *data)
 253 {
 254     const char *data_ptr;
 255     DWORD offset;
 256     HRESULT hr;
 257
 258     read_dword(ptr, &o->type);
 259     TRACE("Effect object is of type %#x.\n", o->type);
 260
 261     skip_dword_unknown(ptr, 2);
 262
 263     read_dword(ptr, &offset);
 264     TRACE("Effect object idx is at offset %#x.\n", offset);
 265
 266     data_ptr = data + offset;
 267     read_dword(&data_ptr, &offset);
 268
 269     TRACE("Effect object starts at offset %#x.\n", offset);
 270
 271     /* FIXME: This probably isn't completely correct. */
 272     if (offset == 1)
 273     {
 274         WARN("Skipping effect object.\n");
 275         data_ptr = NULL;
 276     }
 277     else
 278     {
 279         data_ptr = data + offset;
 280     }
 281
 282     switch (o->type)
 283     {
 284         case D3D10_EOT_VERTEXSHADER:
 285             TRACE("Vertex shader\n");
 286             hr = parse_shader(o, data_ptr);
 287             break;
 288
 289         case D3D10_EOT_PIXELSHADER:
 290             TRACE("Pixel shader\n");
 291             hr = parse_shader(o, data_ptr);
 292             break;
 293
 294         case D3D10_EOT_GEOMETRYSHADER:
 295             TRACE("Geometry shader\n");
 296             hr = parse_shader(o, data_ptr);
 297             break;
 298
 299         default:
 300             FIXME("Unhandled object type %#x\n", o->type);
 301             hr = E_FAIL;
 302             break;
 303     }
 304
 305     return hr;
 306 }
 307
 308 static HRESULT parse_fx10_pass(struct d3d10_effect_pass *p, const char **ptr, const char *data)
 309 {
 310     HRESULT hr = S_OK;
 311     unsigned int i;
 312     DWORD offset;
 313
 314     read_dword(ptr, &offset);
 315     TRACE("Pass name at offset %#x.\n", offset);
 316
 317     p->name = copy_name(data + offset);
 318     if (!p->name)
 319     {
 320         ERR("Failed to copy name.\n");
 321         return E_OUTOFMEMORY;
 322     }
 323     TRACE("Pass name: %s.\n", p->name);
 324
 325     read_dword(ptr, &p->object_count);
 326     TRACE("Pass has %u effect objects.\n", p->object_count);
 327
 328     skip_dword_unknown(ptr, 1);
 329
 330     p->objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, p->object_count * sizeof(*p->objects));
 331     if (!p->objects)
 332     {
 333         ERR("Failed to allocate effect objects memory.\n");
 334         return E_OUTOFMEMORY;
 335     }
 336
 337     for (i = 0; i < p->object_count; ++i)
 338     {
 339         struct d3d10_effect_object *o = &p->objects[i];
 340
 341         o->pass = p;
 342
 343         hr = parse_fx10_object(o, ptr, data);
 344         if (FAILED(hr)) return hr;
 345     }
 346
 347     return hr;
 348 }
 349
 350 static HRESULT parse_fx10_technique(struct d3d10_effect_technique *t, const char **ptr, const char *data)
 351 {
 352     unsigned int i;
 353     DWORD offset;
 354
 355     read_dword(ptr, &offset);
 356     TRACE("Technique name at offset %#x.\n", offset);
 357
 358     t->name = copy_name(data + offset);
 359     if (!t->name)
 360     {
 361         ERR("Failed to copy name.\n");
 362         return E_OUTOFMEMORY;
 363     }
 364     TRACE("Technique name: %s.\n", t->name);
 365
 366     read_dword(ptr, &t->pass_count);
 367     TRACE("Technique has %u passes\n", t->pass_count);
 368
 369     skip_dword_unknown(ptr, 1);
 370
 371     t->passes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->pass_count * sizeof(*t->passes));
 372     if (!t->passes)
 373     {
 374         ERR("Failed to allocate passes memory\n");
 375         return E_OUTOFMEMORY;
 376     }
 377
 378     for (i = 0; i < t->pass_count; ++i)
 379     {
 380         struct d3d10_effect_pass *p = &t->passes[i];
 381         HRESULT hr;
 382
 383         p->vtbl = &d3d10_effect_pass_vtbl;
 384         p->technique = t;
 385
 386         hr = parse_fx10_pass(p, ptr, data);
 387         if (FAILED(hr)) return hr;
 388     }
 389
 390     return S_OK;
 391 }
 392
 393 static HRESULT parse_fx10_variable(struct d3d10_effect_variable *v, const char **ptr, const char *data)
 394 {
 395     DWORD offset;
 396
 397     read_dword(ptr, &offset);
 398     TRACE("Variable name at offset %#x.\n", offset);
 399
 400     v->name = copy_name(data + offset);
 401     if (!v->name)
 402     {
 403         ERR("Failed to copy name.\n");
 404         return E_OUTOFMEMORY;
 405     }
 406     TRACE("Variable name: %s.\n", v->name);
 407
 408     read_dword(ptr, &offset);
 409     TRACE("Variable type info at offset %#x.\n", offset);
 410
 411     skip_dword_unknown(ptr, 1);
 412
 413     read_dword(ptr, &v->buffer_offset);
 414     TRACE("Variable offset in buffer: %#x.\n", v->buffer_offset);
 415
 416     skip_dword_unknown(ptr, 3);
 417
 418     return S_OK;
 419 }
 420
 421 static HRESULT parse_fx10_local_buffer(struct d3d10_effect_local_buffer *l, const char **ptr, const char *data)
 422 {
 423     unsigned int i;
 424     DWORD offset;
 425
 426     read_dword(ptr, &offset);
 427     TRACE("Local buffer name at offset %#x.\n", offset);
 428
 429     l->name = copy_name(data + offset);
 430     if (!l->name)
 431     {
 432         ERR("Failed to copy name.\n");
 433         return E_OUTOFMEMORY;
 434     }
 435     TRACE("Local buffer name: %s.\n", l->name);
 436
 437     read_dword(ptr, &l->data_size);
 438     TRACE("Local buffer data size: %#x.\n", l->data_size);
 439
 440     skip_dword_unknown(ptr, 1);
 441
 442     read_dword(ptr, &l->variable_count);
 443     TRACE("Local buffer variable count: %#x.\n", l->variable_count);
 444
 445     skip_dword_unknown(ptr, 2);
 446
 447     l->variables = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->variable_count * sizeof(*l->variables));
 448     if (!l->variables)
 449     {
 450         ERR("Failed to allocate variables memory.\n");
 451         return E_OUTOFMEMORY;
 452     }
 453
 454     for (i = 0; i < l->variable_count; ++i)
 455     {
 456         struct d3d10_effect_variable *v = &l->variables[i];
 457         HRESULT hr;
 458
 459         v->vtbl = &d3d10_effect_variable_vtbl;
 460
 461         hr = parse_fx10_variable(v, ptr, data);
 462         if (FAILED(hr)) return hr;
 463     }
 464
 465     return S_OK;
 466 }
 467
 468 static HRESULT parse_fx10_body(struct d3d10_effect *e, const char *data, DWORD data_size)
 469 {
 470     const char *ptr = data + e->index_offset;
 471     unsigned int i;
 472     HRESULT hr;
 473
 474     e->local_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->local_buffer_count * sizeof(*e->local_buffers));
 475     if (!e->local_buffers)
 476     {
 477         ERR("Failed to allocate local buffer memory.\n");
 478         return E_OUTOFMEMORY;
 479     }
 480
 481     e->techniques = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->technique_count * sizeof(*e->techniques));
 482     if (!e->techniques)
 483     {
 484         ERR("Failed to allocate techniques memory\n");
 485         return E_OUTOFMEMORY;
 486     }
 487
 488     for (i = 0; i < e->local_buffer_count; ++i)
 489     {
 490         struct d3d10_effect_local_buffer *l = &e->local_buffers[i];
 491
 492         hr = parse_fx10_local_buffer(l, &ptr, data);
 493         if (FAILED(hr)) return hr;
 494     }
 495
 496     for (i = 0; i < e->technique_count; ++i)
 497     {
 498         struct d3d10_effect_technique *t = &e->techniques[i];
 499
 500         t->vtbl = &d3d10_effect_technique_vtbl;
 501         t->effect = e;
 502
 503         hr = parse_fx10_technique(t, &ptr, data);
 504         if (FAILED(hr)) return hr;
 505     }
 506
 507     return S_OK;
 508 }
 509
 510 static HRESULT parse_fx10(struct d3d10_effect *e, const char *data, DWORD data_size)
 511 {
 512     const char *ptr = data;
 513     DWORD unknown;
 514
 515     /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
 516     read_dword(&ptr, &e->version);
 517     TRACE("Target: %#x\n", e->version);
 518
 519     read_dword(&ptr, &e->local_buffer_count);
 520     TRACE("Local buffer count: %u.\n", e->local_buffer_count);
 521
 522     /* Number of variables in local buffers? */
 523     read_dword(&ptr, &unknown);
 524     FIXME("Unknown 0: %u\n", unknown);
 525
 526     read_dword(&ptr, &e->localobjects_count);
 527     TRACE("Localobjects count: %u\n", e->localobjects_count);
 528
 529     read_dword(&ptr, &e->sharedbuffers_count);
 530     TRACE("Sharedbuffers count: %u\n", e->sharedbuffers_count);
 531
 532     /* Number of variables in shared buffers? */
 533     read_dword(&ptr, &unknown);
 534     FIXME("Unknown 1: %u\n", unknown);
 535
 536     read_dword(&ptr, &e->sharedobjects_count);
 537     TRACE("Sharedobjects count: %u\n", e->sharedobjects_count);
 538
 539     read_dword(&ptr, &e->technique_count);
 540     TRACE("Technique count: %u\n", e->technique_count);
 541
 542     read_dword(&ptr, &e->index_offset);
 543     TRACE("Index offset: %#x\n", e->index_offset);
 544
 545     read_dword(&ptr, &unknown);
 546     FIXME("Unknown 2: %u\n", unknown);
 547     read_dword(&ptr, &unknown);
 548     FIXME("Unknown 3: %u\n", unknown);
 549
 550     read_dword(&ptr, &e->dephstencilstate_count);
 551     TRACE("Depthstencilstate count: %u\n", e->dephstencilstate_count);
 552
 553     read_dword(&ptr, &e->blendstate_count);
 554     TRACE("Blendstate count: %u\n", e->blendstate_count);
 555
 556     read_dword(&ptr, &e->rasterizerstate_count);
 557     TRACE("Rasterizerstate count: %u\n", e->rasterizerstate_count);
 558
 559     read_dword(&ptr, &e->samplerstate_count);
 560     TRACE("Samplerstate count: %u\n", e->samplerstate_count);
 561
 562     read_dword(&ptr, &unknown);
 563     FIXME("Unknown 4: %u\n", unknown);
 564     read_dword(&ptr, &unknown);
 565     FIXME("Unknown 5: %u\n", unknown);
 566
 567     /* Number of function calls in all passes? */
 568     read_dword(&ptr, &unknown);
 569     FIXME("Unknown 6: %u\n", unknown);
 570     read_dword(&ptr, &unknown);
 571     FIXME("Unknown 7: %u\n", unknown);
 572
 573     return parse_fx10_body(e, ptr, data_size - (ptr - data));
 574 }
 575
 576 static HRESULT fx10_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
 577 {
 578     struct d3d10_effect *e = ctx;
 579     char tag_str[5];
 580
 581     memcpy(tag_str, &tag, 4);
 582     tag_str[4] = '\0';
 583     TRACE("tag: %s\n", tag_str);
 584
 585     TRACE("chunk size: %#x\n", data_size);
 586
 587     switch(tag)
 588     {
 589         case TAG_FX10:
 590             return parse_fx10(e, data, data_size);
 591
 592         default:
 593             FIXME("Unhandled chunk %s\n", tag_str);
 594             return S_OK;
 595     }
 596 }
 597
 598 HRESULT d3d10_effect_parse(struct d3d10_effect *This, const void *data, SIZE_T data_size)
 599 {
 600     return parse_dxbc(data, data_size, fx10_chunk_handler, This);
 601 }
 602
 603 static void d3d10_effect_object_destroy(struct d3d10_effect_object *o)
 604 {
 605     TRACE("effect object %p.\n", o);
 606
 607     switch(o->type)
 608     {
 609         case D3D10_EOT_VERTEXSHADER:
 610         case D3D10_EOT_PIXELSHADER:
 611         case D3D10_EOT_GEOMETRYSHADER:
 612             HeapFree(GetProcessHeap(), 0, ((struct d3d10_effect_shader_variable *)o->data)->input_signature);
 613             break;
 614
 615         default:
 616             break;
 617     }
 618     HeapFree(GetProcessHeap(), 0, o->data);
 619 }
 620
 621 static HRESULT d3d10_effect_object_apply(struct d3d10_effect_object *o)
 622 {
 623     ID3D10Device *device = o->pass->technique->effect->device;
 624
 625     TRACE("effect object %p, type %#x.\n", o, o->type);
 626
 627     switch(o->type)
 628     {
 629         case D3D10_EOT_VERTEXSHADER:
 630             ID3D10Device_VSSetShader(device, ((struct d3d10_effect_shader_variable *)o->data)->shader.vs);
 631             return S_OK;
 632
 633         case D3D10_EOT_PIXELSHADER:
 634             ID3D10Device_PSSetShader(device, ((struct d3d10_effect_shader_variable *)o->data)->shader.ps);
 635             return S_OK;
 636
 637         case D3D10_EOT_GEOMETRYSHADER:
 638             ID3D10Device_GSSetShader(device, ((struct d3d10_effect_shader_variable *)o->data)->shader.gs);
 639             return S_OK;
 640
 641         default:
 642             FIXME("Unhandled effect object type %#x.\n", o->type);
 643             return E_FAIL;
 644     }
 645 }
 646
 647 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass *p)
 648 {
 649     TRACE("pass %p\n", p);
 650
 651     HeapFree(GetProcessHeap(), 0, p->name);
 652     if (p->objects)
 653     {
 654         unsigned int i;
 655         for (i = 0; i < p->object_count; ++i)
 656         {
 657             d3d10_effect_object_destroy(&p->objects[i]);
 658         }
 659         HeapFree(GetProcessHeap(), 0, p->objects);
 660     }
 661 }
 662
 663 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique *t)
 664 {
 665     TRACE("technique %p\n", t);
 666
 667     HeapFree(GetProcessHeap(), 0, t->name);
 668     if (t->passes)
 669     {
 670         unsigned int i;
 671         for (i = 0; i < t->pass_count; ++i)
 672         {
 673             d3d10_effect_pass_destroy(&t->passes[i]);
 674         }
 675         HeapFree(GetProcessHeap(), 0, t->passes);
 676     }
 677 }
 678
 679 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable *v)
 680 {
 681     TRACE("variable %p.\n", v);
 682
 683     HeapFree(GetProcessHeap(), 0, v->name);
 684 }
 685
 686 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_local_buffer *l)
 687 {
 688     TRACE("local buffer %p.\n", l);
 689
 690     HeapFree(GetProcessHeap(), 0, l->name);
 691     if (l->variables)
 692     {
 693         unsigned int i;
 694         for (i = 0; i < l->variable_count; ++i)
 695         {
 696             d3d10_effect_variable_destroy(&l->variables[i]);
 697         }
 698         HeapFree(GetProcessHeap(), 0, l->variables);
 699     }
 700 }
 701
 702 /* IUnknown methods */
 703
 704 static HRESULT STDMETHODCALLTYPE d3d10_effect_QueryInterface(ID3D10Effect *iface, REFIID riid, void **object)
 705 {
 706     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 707
 708     if (IsEqualGUID(riid, &IID_ID3D10Effect)
 709             || IsEqualGUID(riid, &IID_IUnknown))
 710     {
 711         IUnknown_AddRef(iface);
 712         *object = iface;
 713         return S_OK;
 714     }
 715
 716     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 717
 718     *object = NULL;
 719     return E_NOINTERFACE;
 720 }
 721
 722 static ULONG STDMETHODCALLTYPE d3d10_effect_AddRef(ID3D10Effect *iface)
 723 {
 724     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 725     ULONG refcount = InterlockedIncrement(&This->refcount);
 726
 727     TRACE("%p increasing refcount to %u\n", This, refcount);
 728
 729     return refcount;
 730 }
 731
 732 static ULONG STDMETHODCALLTYPE d3d10_effect_Release(ID3D10Effect *iface)
 733 {
 734     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 735     ULONG refcount = InterlockedDecrement(&This->refcount);
 736
 737     TRACE("%p decreasing refcount to %u\n", This, refcount);
 738
 739     if (!refcount)
 740     {
 741         unsigned int i;
 742
 743         if (This->techniques)
 744         {
 745             for (i = 0; i < This->technique_count; ++i)
 746             {
 747                 d3d10_effect_technique_destroy(&This->techniques[i]);
 748             }
 749             HeapFree(GetProcessHeap(), 0, This->techniques);
 750         }
 751
 752         if (This->local_buffers)
 753         {
 754             for (i = 0; i < This->local_buffer_count; ++i)
 755             {
 756                 d3d10_effect_local_buffer_destroy(&This->local_buffers[i]);
 757             }
 758             HeapFree(GetProcessHeap(), 0, This->local_buffers);
 759         }
 760
 761         ID3D10Device_Release(This->device);
 762         HeapFree(GetProcessHeap(), 0, This);
 763     }
 764
 765     return refcount;
 766 }
 767
 768 /* ID3D10Effect methods */
 769
 770 static BOOL STDMETHODCALLTYPE d3d10_effect_IsValid(ID3D10Effect *iface)
 771 {
 772     FIXME("iface %p stub!\n", iface);
 773
 774     return FALSE;
 775 }
 776
 777 static BOOL STDMETHODCALLTYPE d3d10_effect_IsPool(ID3D10Effect *iface)
 778 {
 779     FIXME("iface %p stub!\n", iface);
 780
 781     return FALSE;
 782 }
 783
 784 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDevice(ID3D10Effect *iface, ID3D10Device **device)
 785 {
 786     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 787
 788     TRACE("iface %p, device %p\n", iface, device);
 789
 790     ID3D10Device_AddRef(This->device);
 791     *device = This->device;
 792
 793     return S_OK;
 794 }
 795
 796 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDesc(ID3D10Effect *iface, D3D10_EFFECT_DESC *desc)
 797 {
 798     FIXME("iface %p, desc %p stub!\n", iface, desc);
 799
 800     return E_NOTIMPL;
 801 }
 802
 803 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByIndex(ID3D10Effect *iface,
 804         UINT index)
 805 {
 806     FIXME("iface %p, index %u stub!\n", iface, index);
 807
 808     return NULL;
 809 }
 810
 811 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByName(ID3D10Effect *iface,
 812         LPCSTR name)
 813 {
 814     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
 815
 816     return NULL;
 817 }
 818
 819 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByIndex(ID3D10Effect *iface, UINT index)
 820 {
 821     FIXME("iface %p, index %u stub!\n", iface, index);
 822
 823     return NULL;
 824 }
 825
 826 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByName(ID3D10Effect *iface, LPCSTR name)
 827 {
 828     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 829     unsigned int i;
 830
 831     TRACE("iface %p, name \"%s\"\n", iface, name);
 832
 833     for (i = 0; i < This->local_buffer_count; ++i)
 834     {
 835         struct d3d10_effect_local_buffer *l = &This->local_buffers[i];
 836         unsigned int j;
 837
 838         for (j = 0; j < l->variable_count; ++j)
 839         {
 840             struct d3d10_effect_variable *v = &l->variables[j];
 841
 842             if (!strcmp(v->name, name))
 843             {
 844                 TRACE("Returning variable %p.\n", v);
 845                 return (ID3D10EffectVariable *)v;
 846             }
 847         }
 848     }
 849
 850     return NULL;
 851 }
 852
 853 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableBySemantic(ID3D10Effect *iface,
 854         LPCSTR semantic)
 855 {
 856     FIXME("iface %p, semantic \"%s\" stub!\n", iface, semantic);
 857
 858     return NULL;
 859 }
 860
 861 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByIndex(ID3D10Effect *iface,
 862         UINT index)
 863 {
 864     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 865     struct d3d10_effect_technique *t;
 866
 867     TRACE("iface %p, index %u\n", iface, index);
 868
 869     if (index >= This->technique_count)
 870     {
 871         WARN("Invalid index specified\n");
 872         return NULL;
 873     }
 874
 875     t = &This->techniques[index];
 876
 877     TRACE("Returning technique %p, \"%s\"\n", t, t->name);
 878
 879     return (ID3D10EffectTechnique *)t;
 880 }
 881
 882 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByName(ID3D10Effect *iface,
 883         LPCSTR name)
 884 {
 885     struct d3d10_effect *This = (struct d3d10_effect *)iface;
 886     unsigned int i;
 887
 888     TRACE("iface %p, name \"%s\"\n", iface, name);
 889
 890     for (i = 0; i < This->technique_count; ++i)
 891     {
 892         struct d3d10_effect_technique *t = &This->techniques[i];
 893         if (!strcmp(t->name, name))
 894         {
 895             TRACE("Returning technique %p\n", t);
 896             return (ID3D10EffectTechnique *)t;
 897         }
 898     }
 899
 900     return NULL;
 901 }
 902
 903 static HRESULT STDMETHODCALLTYPE d3d10_effect_Optimize(ID3D10Effect *iface)
 904 {
 905     FIXME("iface %p stub!\n", iface);
 906
 907     return E_NOTIMPL;
 908 }
 909
 910 static BOOL STDMETHODCALLTYPE d3d10_effect_IsOptimized(ID3D10Effect *iface)
 911 {
 912     FIXME("iface %p stub!\n", iface);
 913
 914     return FALSE;
 915 }
 916
 917 const struct ID3D10EffectVtbl d3d10_effect_vtbl =
 918 {
 919     /* IUnknown methods */
 920     d3d10_effect_QueryInterface,
 921     d3d10_effect_AddRef,
 922     d3d10_effect_Release,
 923     /* ID3D10Effect methods */
 924     d3d10_effect_IsValid,
 925     d3d10_effect_IsPool,
 926     d3d10_effect_GetDevice,
 927     d3d10_effect_GetDesc,
 928     d3d10_effect_GetConstantBufferByIndex,
 929     d3d10_effect_GetConstantBufferByName,
 930     d3d10_effect_GetVariableByIndex,
 931     d3d10_effect_GetVariableByName,
 932     d3d10_effect_GetVariableBySemantic,
 933     d3d10_effect_GetTechniqueByIndex,
 934     d3d10_effect_GetTechniqueByName,
 935     d3d10_effect_Optimize,
 936     d3d10_effect_IsOptimized,
 937 };
 938
 939 /* ID3D10EffectTechnique methods */
 940
 941 static BOOL STDMETHODCALLTYPE d3d10_effect_technique_IsValid(ID3D10EffectTechnique *iface)
 942 {
 943     FIXME("iface %p stub!\n", iface);
 944
 945     return FALSE;
 946 }
 947
 948 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_GetDesc(ID3D10EffectTechnique *iface,
 949         D3D10_TECHNIQUE_DESC *desc)
 950 {
 951     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
 952
 953     TRACE("iface %p, desc %p\n", iface, desc);
 954
 955     desc->Name = This->name;
 956     desc->Passes = This->pass_count;
 957     WARN("Annotations not implemented\n");
 958     desc->Annotations = 0;
 959
 960     return S_OK;
 961 }
 962
 963 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByIndex(
 964         ID3D10EffectTechnique *iface, UINT index)
 965 {
 966     FIXME("iface %p, index %u stub!\n", iface, index);
 967
 968     return NULL;
 969 }
 970
 971 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByName(
 972         ID3D10EffectTechnique *iface, LPCSTR name)
 973 {
 974     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
 975
 976     return NULL;
 977 }
 978
 979 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique *iface,
 980         UINT index)
 981 {
 982     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
 983     struct d3d10_effect_pass *p;
 984
 985     TRACE("iface %p, index %u\n", iface, index);
 986
 987     if (index >= This->pass_count)
 988     {
 989         WARN("Invalid index specified\n");
 990         return NULL;
 991     }
 992
 993     p = &This->passes[index];
 994
 995     TRACE("Returning pass %p, \"%s\"\n", p, p->name);
 996
 997     return (ID3D10EffectPass *)p;
 998 }
 999
1000 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique *iface,
1001         LPCSTR name)
1002 {
1003     struct d3d10_effect_technique *This = (struct d3d10_effect_technique *)iface;
1004     unsigned int i;
1005
1006     TRACE("iface %p, name \"%s\"\n", iface, name);
1007
1008     for (i = 0; i < This->pass_count; ++i)
1009     {
1010         struct d3d10_effect_pass *p = &This->passes[i];
1011         if (!strcmp(p->name, name))
1012         {
1013             TRACE("Returning pass %p\n", p);
1014             return (ID3D10EffectPass *)p;
1015         }
1016     }
1017
1018     return NULL;
1019 }
1020
1021 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique *iface,
1022         D3D10_STATE_BLOCK_MASK *mask)
1023 {
1024     FIXME("iface %p,mask %p stub!\n", iface, mask);
1025
1026     return E_NOTIMPL;
1027 }
1028
1029 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl =
1030 {
1031     /* ID3D10EffectTechnique methods */
1032     d3d10_effect_technique_IsValid,
1033     d3d10_effect_technique_GetDesc,
1034     d3d10_effect_technique_GetAnnotationByIndex,
1035     d3d10_effect_technique_GetAnnotationByName,
1036     d3d10_effect_technique_GetPassByIndex,
1037     d3d10_effect_technique_GetPassByName,
1038     d3d10_effect_technique_ComputeStateBlockMask,
1039 };
1040
1041 /* ID3D10EffectPass methods */
1042
1043 static BOOL STDMETHODCALLTYPE d3d10_effect_pass_IsValid(ID3D10EffectPass *iface)
1044 {
1045     FIXME("iface %p stub!\n", iface);
1046
1047     return FALSE;
1048 }
1049
1050 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetDesc(ID3D10EffectPass *iface, D3D10_PASS_DESC *desc)
1051 {
1052     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1053     unsigned int i;
1054
1055     FIXME("iface %p, desc %p partial stub!\n", iface, desc);
1056
1057     memset(desc, 0, sizeof(*desc));
1058     desc->Name = This->name;
1059     for (i = 0; i < This->object_count; ++i)
1060     {
1061         struct d3d10_effect_object *o = &This->objects[i];
1062         if (o->type == D3D10_EOT_VERTEXSHADER)
1063         {
1064             struct d3d10_effect_shader_variable *s = o->data;
1065             desc->pIAInputSignature = (BYTE *)s->input_signature;
1066             desc->IAInputSignatureSize = s->input_signature_size;
1067             break;
1068         }
1069     }
1070
1071     return S_OK;
1072 }
1073
1074 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass *iface,
1075         D3D10_PASS_SHADER_DESC *desc)
1076 {
1077     FIXME("iface %p, desc %p stub!\n", iface, desc);
1078
1079     return E_NOTIMPL;
1080 }
1081
1082 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass *iface,
1083         D3D10_PASS_SHADER_DESC *desc)
1084 {
1085     FIXME("iface %p, desc %p stub!\n", iface, desc);
1086
1087     return E_NOTIMPL;
1088 }
1089
1090 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass *iface,
1091         D3D10_PASS_SHADER_DESC *desc)
1092 {
1093     FIXME("iface %p, desc %p stub!\n", iface, desc);
1094
1095     return E_NOTIMPL;
1096 }
1097
1098 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass *iface,
1099         UINT index)
1100 {
1101     FIXME("iface %p, index %u stub!\n", iface, index);
1102
1103     return NULL;
1104 }
1105
1106 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass *iface,
1107         LPCSTR name)
1108 {
1109     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
1110
1111     return NULL;
1112 }
1113
1114 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_Apply(ID3D10EffectPass *iface, UINT flags)
1115 {
1116     struct d3d10_effect_pass *This = (struct d3d10_effect_pass *)iface;
1117     HRESULT hr = S_OK;
1118     unsigned int i;
1119
1120     TRACE("iface %p, flags %#x\n", iface, flags);
1121
1122     if (flags) FIXME("Ignoring flags (%#x)\n", flags);
1123
1124     for (i = 0; i < This->object_count; ++i)
1125     {
1126         hr = d3d10_effect_object_apply(&This->objects[i]);
1127         if (FAILED(hr)) break;
1128     }
1129
1130     return hr;
1131 }
1132
1133 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass *iface,
1134         D3D10_STATE_BLOCK_MASK *mask)
1135 {
1136     FIXME("iface %p, mask %p stub!\n", iface, mask);
1137
1138     return E_NOTIMPL;
1139 }
1140
1141 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl =
1142 {
1143     /* ID3D10EffectPass methods */
1144     d3d10_effect_pass_IsValid,
1145     d3d10_effect_pass_GetDesc,
1146     d3d10_effect_pass_GetVertexShaderDesc,
1147     d3d10_effect_pass_GetGeometryShaderDesc,
1148     d3d10_effect_pass_GetPixelShaderDesc,
1149     d3d10_effect_pass_GetAnnotationByIndex,
1150     d3d10_effect_pass_GetAnnotationByName,
1151     d3d10_effect_pass_Apply,
1152     d3d10_effect_pass_ComputeStateBlockMask,
1153 };
1154
1155 /* ID3D10EffectVariable methods */
1156
1157 static BOOL STDMETHODCALLTYPE d3d10_effect_variable_IsValid(ID3D10EffectVariable *iface)
1158 {
1159     FIXME("iface %p stub!\n", iface);
1160
1161     return FALSE;
1162 }
1163
1164 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_variable_GetType(ID3D10EffectVariable *iface)
1165 {
1166     FIXME("iface %p stub!\n", iface);
1167
1168     return NULL;
1169 }
1170
1171 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetDesc(ID3D10EffectVariable *iface,
1172         D3D10_EFFECT_VARIABLE_DESC *desc)
1173 {
1174     FIXME("iface %p, desc %p stub!\n", iface, desc);
1175
1176     return E_NOTIMPL;
1177 }
1178
1179 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByIndex(
1180         ID3D10EffectVariable *iface, UINT index)
1181 {
1182     FIXME("iface %p, index %u stub!\n", iface, index);
1183
1184     return NULL;
1185 }
1186
1187 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByName(
1188         ID3D10EffectVariable *iface, LPCSTR name)
1189 {
1190     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
1191
1192     return NULL;
1193 }
1194
1195 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByIndex(
1196         ID3D10EffectVariable *iface, 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_variable_GetMemberByName(
1204         ID3D10EffectVariable *iface, LPCSTR name)
1205 {
1206     FIXME("iface %p, name \"%s\" stub!\n", iface, name);
1207
1208     return NULL;
1209 }
1210
1211 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberBySemantic(
1212         ID3D10EffectVariable *iface, LPCSTR semantic)
1213 {
1214     FIXME("iface %p, semantic \"%s\" stub!\n", iface, semantic);
1215
1216     return NULL;
1217 }
1218
1219 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetElement(
1220         ID3D10EffectVariable *iface, UINT index)
1221 {
1222     FIXME("iface %p, index %u stub!\n", iface, index);
1223
1224     return NULL;
1225 }
1226
1227 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_GetParentConstantBuffer(
1228         ID3D10EffectVariable *iface)
1229 {
1230     FIXME("iface %p stub!\n", iface);
1231
1232     return NULL;
1233 }
1234
1235 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsScalar(
1236         ID3D10EffectVariable *iface)
1237 {
1238     FIXME("iface %p stub!\n", iface);
1239
1240     return NULL;
1241 }
1242
1243 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsVector(
1244         ID3D10EffectVariable *iface)
1245 {
1246     FIXME("iface %p stub!\n", iface);
1247
1248     return NULL;
1249 }
1250
1251 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsMatrix(
1252         ID3D10EffectVariable *iface)
1253 {
1254     FIXME("iface %p stub!\n", iface);
1255
1256     return NULL;
1257 }
1258
1259 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsString(
1260         ID3D10EffectVariable *iface)
1261 {
1262     FIXME("iface %p stub!\n", iface);
1263
1264     return NULL;
1265 }
1266
1267 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShaderResource(
1268         ID3D10EffectVariable *iface)
1269 {
1270     FIXME("iface %p stub!\n", iface);
1271
1272     return NULL;
1273 }
1274
1275 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRenderTargetView(
1276         ID3D10EffectVariable *iface)
1277 {
1278     FIXME("iface %p stub!\n", iface);
1279
1280     return NULL;
1281 }
1282
1283 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencilView(
1284         ID3D10EffectVariable *iface)
1285 {
1286     FIXME("iface %p stub!\n", iface);
1287
1288     return NULL;
1289 }
1290
1291 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_AsConstantBuffer(
1292         ID3D10EffectVariable *iface)
1293 {
1294     FIXME("iface %p stub!\n", iface);
1295
1296     return NULL;
1297 }
1298
1299 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShader(
1300         ID3D10EffectVariable *iface)
1301 {
1302     FIXME("iface %p stub!\n", iface);
1303
1304     return NULL;
1305 }
1306
1307 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsBlend(ID3D10EffectVariable *iface)
1308 {
1309     FIXME("iface %p stub!\n", iface);
1310
1311     return NULL;
1312 }
1313
1314 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencil(
1315         ID3D10EffectVariable *iface)
1316 {
1317     FIXME("iface %p stub!\n", iface);
1318
1319     return NULL;
1320 }
1321
1322 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRasterizer(
1323         ID3D10EffectVariable *iface)
1324 {
1325     FIXME("iface %p stub!\n", iface);
1326
1327     return NULL;
1328 }
1329
1330 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsSampler(
1331         ID3D10EffectVariable *iface)
1332 {
1333     FIXME("iface %p stub!\n", iface);
1334
1335     return NULL;
1336 }
1337
1338 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_SetRawValue(ID3D10EffectVariable *iface,
1339         void *data, UINT offset, UINT count)
1340 {
1341     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1342
1343     return E_NOTIMPL;
1344 }
1345
1346 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetRawValue(ID3D10EffectVariable *iface,
1347         void *data, UINT offset, UINT count)
1348 {
1349     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
1350
1351     return E_NOTIMPL;
1352 }
1353
1354 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl =
1355 {
1356     /* ID3D10EffectVariable methods */
1357     d3d10_effect_variable_IsValid,
1358     d3d10_effect_variable_GetType,
1359     d3d10_effect_variable_GetDesc,
1360     d3d10_effect_variable_GetAnnotationByIndex,
1361     d3d10_effect_variable_GetAnnotationByName,
1362     d3d10_effect_variable_GetMemberByIndex,
1363     d3d10_effect_variable_GetMemberByName,
1364     d3d10_effect_variable_GetMemberBySemantic,
1365     d3d10_effect_variable_GetElement,
1366     d3d10_effect_variable_GetParentConstantBuffer,
1367     d3d10_effect_variable_AsScalar,
1368     d3d10_effect_variable_AsVector,
1369     d3d10_effect_variable_AsMatrix,
1370     d3d10_effect_variable_AsString,
1371     d3d10_effect_variable_AsShaderResource,
1372     d3d10_effect_variable_AsRenderTargetView,
1373     d3d10_effect_variable_AsDepthStencilView,
1374     d3d10_effect_variable_AsConstantBuffer,
1375     d3d10_effect_variable_AsShader,
1376     d3d10_effect_variable_AsBlend,
1377     d3d10_effect_variable_AsDepthStencil,
1378     d3d10_effect_variable_AsRasterizer,
1379     d3d10_effect_variable_AsSampler,
1380     d3d10_effect_variable_SetRawValue,
1381     d3d10_effect_variable_GetRawValue,
1382 };