git.oblomov.eu Git - wine/blob - dlls/d3d10/effect.c

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