dlls/d3d10/effect.c

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