dlls/d3d10/effect.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   3  * Copyright 2009 Rico Schüller
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  *
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include "d3d10_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d3d10);
  27
  28 #define D3D10_FX10_TYPE_COLUMN_SHIFT    11
  29 #define D3D10_FX10_TYPE_COLUMN_MASK     (0x7 << D3D10_FX10_TYPE_COLUMN_SHIFT)
  30
  31 #define D3D10_FX10_TYPE_ROW_SHIFT       8
  32 #define D3D10_FX10_TYPE_ROW_MASK        (0x7 << D3D10_FX10_TYPE_ROW_SHIFT)
  33
  34 #define D3D10_FX10_TYPE_BASETYPE_SHIFT  3
  35 #define D3D10_FX10_TYPE_BASETYPE_MASK   (0x1f << D3D10_FX10_TYPE_BASETYPE_SHIFT)
  36
  37 #define D3D10_FX10_TYPE_CLASS_SHIFT     0
  38 #define D3D10_FX10_TYPE_CLASS_MASK      (0x7 << D3D10_FX10_TYPE_CLASS_SHIFT)
  39
  40 #define D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK 0x4000
  41
  42 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl;
  43 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl;
  44 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl;
  45 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl;
  46 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl;
  47 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl;
  48 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl;
  49 static const struct ID3D10EffectStringVariableVtbl d3d10_effect_string_variable_vtbl;
  50 static const struct ID3D10EffectShaderResourceVariableVtbl d3d10_effect_shader_resource_variable_vtbl;
  51 static const struct ID3D10EffectRenderTargetViewVariableVtbl d3d10_effect_render_target_view_variable_vtbl;
  52 static const struct ID3D10EffectDepthStencilViewVariableVtbl d3d10_effect_depth_stencil_view_variable_vtbl;
  53 static const struct ID3D10EffectShaderVariableVtbl d3d10_effect_shader_variable_vtbl;
  54 static const struct ID3D10EffectBlendVariableVtbl d3d10_effect_blend_variable_vtbl;
  55 static const struct ID3D10EffectDepthStencilVariableVtbl d3d10_effect_depth_stencil_variable_vtbl;
  56 static const struct ID3D10EffectRasterizerVariableVtbl d3d10_effect_rasterizer_variable_vtbl;
  57 static const struct ID3D10EffectSamplerVariableVtbl d3d10_effect_sampler_variable_vtbl;
  58 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl;
  59
  60 /* null objects - needed for invalid calls */
  61 static struct d3d10_effect_technique null_technique = {{&d3d10_effect_technique_vtbl}};
  62 static struct d3d10_effect_pass null_pass = {{&d3d10_effect_pass_vtbl}};
  63 static struct d3d10_effect_type null_type = {{&d3d10_effect_type_vtbl}};
  64 static struct d3d10_effect_variable null_local_buffer = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl,
  65         &null_local_buffer, &null_type};
  66 static struct d3d10_effect_variable null_variable = {&d3d10_effect_variable_vtbl,
  67         &null_local_buffer, &null_type};
  68 static struct d3d10_effect_variable null_scalar_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl,
  69         &null_local_buffer, &null_type};
  70 static struct d3d10_effect_variable null_vector_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl,
  71         &null_local_buffer, &null_type};
  72 static struct d3d10_effect_variable null_matrix_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl,
  73         &null_local_buffer, &null_type};
  74 static struct d3d10_effect_variable null_string_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl,
  75         &null_local_buffer, &null_type};
  76 static struct d3d10_effect_variable null_shader_resource_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl,
  77         &null_local_buffer, &null_type};
  78 static struct d3d10_effect_variable null_render_target_view_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl,
  79         &null_local_buffer, &null_type};
  80 static struct d3d10_effect_variable null_depth_stencil_view_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl,
  81         &null_local_buffer, &null_type};
  82 static struct d3d10_effect_variable null_shader_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl,
  83         &null_local_buffer, &null_type};
  84 static struct d3d10_effect_variable null_blend_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl,
  85         &null_local_buffer, &null_type};
  86 static struct d3d10_effect_variable null_depth_stencil_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl,
  87         &null_local_buffer, &null_type};
  88 static struct d3d10_effect_variable null_rasterizer_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl,
  89         &null_local_buffer, &null_type};
  90 static struct d3d10_effect_variable null_sampler_variable = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl,
  91         &null_local_buffer, &null_type};
  92
  93 /* anonymous_shader_type and anonymous_shader */
  94 static char anonymous_name[] = "$Anonymous";
  95 static char anonymous_vertexshader_name[] = "vertexshader";
  96 static char anonymous_pixelshader_name[] = "pixelshader";
  97 static char anonymous_geometryshader_name[] = "geometryshader";
  98 static struct d3d10_effect_type anonymous_vs_type = {{&d3d10_effect_type_vtbl},
  99         anonymous_vertexshader_name, D3D10_SVT_VERTEXSHADER, D3D10_SVC_OBJECT};
 100 static struct d3d10_effect_type anonymous_ps_type = {{&d3d10_effect_type_vtbl},
 101         anonymous_pixelshader_name, D3D10_SVT_PIXELSHADER, D3D10_SVC_OBJECT};
 102 static struct d3d10_effect_type anonymous_gs_type = {{&d3d10_effect_type_vtbl},
 103         anonymous_geometryshader_name, D3D10_SVT_GEOMETRYSHADER, D3D10_SVC_OBJECT};
 104 static struct d3d10_effect_variable anonymous_vs = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl,
 105         &null_local_buffer, &anonymous_vs_type, &null_shader_variable, anonymous_name};
 106 static struct d3d10_effect_variable anonymous_ps = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl,
 107         &null_local_buffer, &anonymous_ps_type, &null_shader_variable, anonymous_name};
 108 static struct d3d10_effect_variable anonymous_gs = {(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl,
 109         &null_local_buffer, &anonymous_gs_type, &null_shader_variable, anonymous_name};
 110
 111 static struct d3d10_effect_type *get_fx10_type(struct d3d10_effect *effect, const char *data, DWORD offset);
 112
 113 static BOOL copy_name(const char *ptr, char **name)
 114 {
 115     size_t name_len;
 116
 117     if (!ptr) return TRUE;
 118
 119     name_len = strlen(ptr) + 1;
 120     if (name_len == 1)
 121     {
 122         return TRUE;
 123     }
 124
 125     *name = HeapAlloc(GetProcessHeap(), 0, name_len);
 126     if (!*name)
 127     {
 128         ERR("Failed to allocate name memory.\n");
 129         return FALSE;
 130     }
 131
 132     memcpy(*name, ptr, name_len);
 133
 134     return TRUE;
 135 }
 136
 137 static HRESULT shader_parse_signature(const char *data, DWORD data_size, struct d3d10_effect_shader_signature *s)
 138 {
 139     D3D10_SIGNATURE_PARAMETER_DESC *e;
 140     const char *ptr = data;
 141     unsigned int i;
 142     DWORD count;
 143
 144     read_dword(&ptr, &count);
 145     TRACE("%u elements\n", count);
 146
 147     skip_dword_unknown("shader signature", &ptr, 1);
 148
 149     e = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*e));
 150     if (!e)
 151     {
 152         ERR("Failed to allocate signature memory.\n");
 153         return E_OUTOFMEMORY;
 154     }
 155
 156     for (i = 0; i < count; ++i)
 157     {
 158         UINT name_offset;
 159         UINT mask;
 160
 161         read_dword(&ptr, &name_offset);
 162         e[i].SemanticName = data + name_offset;
 163         read_dword(&ptr, &e[i].SemanticIndex);
 164         read_dword(&ptr, &e[i].SystemValueType);
 165         read_dword(&ptr, &e[i].ComponentType);
 166         read_dword(&ptr, &e[i].Register);
 167         read_dword(&ptr, &mask);
 168
 169         e[i].ReadWriteMask = mask >> 8;
 170         e[i].Mask = mask & 0xff;
 171
 172         TRACE("semantic: %s, semantic idx: %u, sysval_semantic %#x, "
 173                 "type %u, register idx: %u, use_mask %#x, input_mask %#x\n",
 174                 debugstr_a(e[i].SemanticName), e[i].SemanticIndex, e[i].SystemValueType,
 175                 e[i].ComponentType, e[i].Register, e[i].Mask, e[i].ReadWriteMask);
 176     }
 177
 178     s->elements = e;
 179     s->element_count = count;
 180
 181     return S_OK;
 182 }
 183
 184 static void shader_free_signature(struct d3d10_effect_shader_signature *s)
 185 {
 186     HeapFree(GetProcessHeap(), 0, s->signature);
 187     HeapFree(GetProcessHeap(), 0, s->elements);
 188 }
 189
 190 static HRESULT shader_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
 191 {
 192     struct d3d10_effect_shader_variable *s = ctx;
 193     HRESULT hr;
 194
 195     TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
 196
 197     TRACE("chunk size: %#x\n", data_size);
 198
 199     switch(tag)
 200     {
 201         case TAG_ISGN:
 202         case TAG_OSGN:
 203         {
 204             /* 32 (DXBC header) + 1 * 4 (chunk index) + 2 * 4 (chunk header) + data_size (chunk data) */
 205             UINT size = 44 + data_size;
 206             struct d3d10_effect_shader_signature *sig;
 207             char *ptr;
 208
 209             if (tag == TAG_ISGN) sig = &s->input_signature;
 210             else sig = &s->output_signature;
 211
 212             sig->signature = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 213             if (!sig->signature)
 214             {
 215                 ERR("Failed to allocate input signature data\n");
 216                 return E_OUTOFMEMORY;
 217             }
 218             sig->signature_size = size;
 219
 220             ptr = sig->signature;
 221
 222             write_dword(&ptr, TAG_DXBC);
 223
 224             /* signature(?) */
 225             write_dword_unknown(&ptr, 0);
 226             write_dword_unknown(&ptr, 0);
 227             write_dword_unknown(&ptr, 0);
 228             write_dword_unknown(&ptr, 0);
 229
 230             /* seems to be always 1 */
 231             write_dword_unknown(&ptr, 1);
 232
 233             /* DXBC size */
 234             write_dword(&ptr, size);
 235
 236             /* chunk count */
 237             write_dword(&ptr, 1);
 238
 239             /* chunk index */
 240             write_dword(&ptr, (ptr - sig->signature) + 4);
 241
 242             /* chunk */
 243             write_dword(&ptr, tag);
 244             write_dword(&ptr, data_size);
 245             memcpy(ptr, data, data_size);
 246
 247             hr = shader_parse_signature(ptr, data_size, sig);
 248             if (FAILED(hr))
 249             {
 250                 ERR("Failed to parse shader, hr %#x\n", hr);
 251                 shader_free_signature(sig);
 252             }
 253
 254             break;
 255         }
 256
 257         default:
 258             FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
 259             break;
 260     }
 261
 262     return S_OK;
 263 }
 264
 265 static HRESULT parse_shader(struct d3d10_effect_variable *v, const char *data)
 266 {
 267     ID3D10Device *device = v->effect->device;
 268     struct d3d10_effect_shader_variable *s;
 269     const char *ptr = data;
 270     DWORD dxbc_size;
 271     HRESULT hr;
 272
 273     s = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*s));
 274     if (!s)
 275     {
 276         ERR("Failed to allocate shader variable memory\n");
 277         return E_OUTOFMEMORY;
 278     }
 279
 280     v->data = s;
 281
 282     if (v->effect->used_shader_current >= v->effect->used_shader_count)
 283     {
 284         WARN("Invalid shader? Used shader current(%u) >= used shader count(%u)\n", v->effect->used_shader_current, v->effect->used_shader_count);
 285         return E_FAIL;
 286     }
 287
 288     v->effect->used_shaders[v->effect->used_shader_current] = v;
 289     ++v->effect->used_shader_current;
 290
 291     if (!ptr) return S_OK;
 292
 293     read_dword(&ptr, &dxbc_size);
 294     TRACE("dxbc size: %#x\n", dxbc_size);
 295
 296     /* We got a shader VertexShader vs = NULL, so it is fine to skip this. */
 297     if (!dxbc_size) return S_OK;
 298
 299     switch (v->type->basetype)
 300     {
 301         case D3D10_SVT_VERTEXSHADER:
 302             hr = ID3D10Device_CreateVertexShader(device, ptr, dxbc_size, &s->shader.vs);
 303             if (FAILED(hr)) return hr;
 304             break;
 305
 306         case D3D10_SVT_PIXELSHADER:
 307             hr = ID3D10Device_CreatePixelShader(device, ptr, dxbc_size, &s->shader.ps);
 308             if (FAILED(hr)) return hr;
 309             break;
 310
 311         case D3D10_SVT_GEOMETRYSHADER:
 312             hr = ID3D10Device_CreateGeometryShader(device, ptr, dxbc_size, &s->shader.gs);
 313             if (FAILED(hr)) return hr;
 314             break;
 315
 316         default:
 317             ERR("This should not happen!\n");
 318             return E_FAIL;
 319     }
 320
 321     return parse_dxbc(ptr, dxbc_size, shader_chunk_handler, s);
 322 }
 323
 324 static D3D10_SHADER_VARIABLE_CLASS d3d10_variable_class(DWORD c, BOOL is_column_major)
 325 {
 326     switch (c)
 327     {
 328         case 1: return D3D10_SVC_SCALAR;
 329         case 2: return D3D10_SVC_VECTOR;
 330         case 3: if (is_column_major) return D3D10_SVC_MATRIX_COLUMNS;
 331                 else return D3D10_SVC_MATRIX_ROWS;
 332         default:
 333             FIXME("Unknown variable class %#x.\n", c);
 334             return 0;
 335     }
 336 }
 337
 338 static D3D10_SHADER_VARIABLE_TYPE d3d10_variable_type(DWORD t, BOOL is_object)
 339 {
 340     if(is_object)
 341     {
 342         switch (t)
 343         {
 344             case 1: return D3D10_SVT_STRING;
 345             case 2: return D3D10_SVT_BLEND;
 346             case 3: return D3D10_SVT_DEPTHSTENCIL;
 347             case 4: return D3D10_SVT_RASTERIZER;
 348             case 5: return D3D10_SVT_PIXELSHADER;
 349             case 6: return D3D10_SVT_VERTEXSHADER;
 350             case 7: return D3D10_SVT_GEOMETRYSHADER;
 351
 352             case 10: return D3D10_SVT_TEXTURE1D;
 353             case 11: return D3D10_SVT_TEXTURE1DARRAY;
 354             case 12: return D3D10_SVT_TEXTURE2D;
 355             case 13: return D3D10_SVT_TEXTURE2DARRAY;
 356             case 14: return D3D10_SVT_TEXTURE2DMS;
 357             case 15: return D3D10_SVT_TEXTURE2DMSARRAY;
 358             case 16: return D3D10_SVT_TEXTURE3D;
 359             case 17: return D3D10_SVT_TEXTURECUBE;
 360
 361             case 19: return D3D10_SVT_RENDERTARGETVIEW;
 362             case 20: return D3D10_SVT_DEPTHSTENCILVIEW;
 363             case 21: return D3D10_SVT_SAMPLER;
 364             case 22: return D3D10_SVT_BUFFER;
 365             default:
 366                 FIXME("Unknown variable type %#x.\n", t);
 367                 return D3D10_SVT_VOID;
 368         }
 369     }
 370     else
 371     {
 372         switch (t)
 373         {
 374             case 1: return D3D10_SVT_FLOAT;
 375             case 2: return D3D10_SVT_INT;
 376             case 3: return D3D10_SVT_UINT;
 377             case 4: return D3D10_SVT_BOOL;
 378             default:
 379                 FIXME("Unknown variable type %#x.\n", t);
 380                 return D3D10_SVT_VOID;
 381         }
 382     }
 383 }
 384
 385 static HRESULT parse_fx10_type(struct d3d10_effect_type *t, const char *ptr, const char *data)
 386 {
 387     DWORD unknown0;
 388     DWORD offset;
 389     DWORD typeinfo;
 390     unsigned int i;
 391
 392     read_dword(&ptr, &offset);
 393     TRACE("Type name at offset %#x.\n", offset);
 394
 395     if (!copy_name(data + offset, &t->name))
 396     {
 397         ERR("Failed to copy name.\n");
 398         return E_OUTOFMEMORY;
 399     }
 400     TRACE("Type name: %s.\n", debugstr_a(t->name));
 401
 402     read_dword(&ptr, &unknown0);
 403     TRACE("Unknown 0: %u.\n", unknown0);
 404
 405     read_dword(&ptr, &t->element_count);
 406     TRACE("Element count: %u.\n", t->element_count);
 407
 408     read_dword(&ptr, &t->size_unpacked);
 409     TRACE("Unpacked size: %#x.\n", t->size_unpacked);
 410
 411     read_dword(&ptr, &t->stride);
 412     TRACE("Stride: %#x.\n", t->stride);
 413
 414     read_dword(&ptr, &t->size_packed);
 415     TRACE("Packed size %#x.\n", t->size_packed);
 416
 417     switch (unknown0)
 418     {
 419         case 1:
 420             t->member_count = 0;
 421
 422             read_dword(&ptr, &typeinfo);
 423             t->column_count = (typeinfo & D3D10_FX10_TYPE_COLUMN_MASK) >> D3D10_FX10_TYPE_COLUMN_SHIFT;
 424             t->row_count = (typeinfo & D3D10_FX10_TYPE_ROW_MASK) >> D3D10_FX10_TYPE_ROW_SHIFT;
 425             t->basetype = d3d10_variable_type((typeinfo & D3D10_FX10_TYPE_BASETYPE_MASK) >> D3D10_FX10_TYPE_BASETYPE_SHIFT, FALSE);
 426             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);
 427
 428             TRACE("Type description: %#x.\n", typeinfo);
 429             TRACE("\tcolumns: %u.\n", t->column_count);
 430             TRACE("\trows: %u.\n", t->row_count);
 431             TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t->basetype));
 432             TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t->type_class));
 433             TRACE("\tunknown bits: %#x.\n", typeinfo & ~(D3D10_FX10_TYPE_COLUMN_MASK | D3D10_FX10_TYPE_ROW_MASK
 434                     | D3D10_FX10_TYPE_BASETYPE_MASK | D3D10_FX10_TYPE_CLASS_MASK | D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK));
 435             break;
 436
 437         case 2:
 438             TRACE("Type is an object.\n");
 439
 440             t->member_count = 0;
 441             t->column_count = 0;
 442             t->row_count = 0;
 443             t->type_class = D3D10_SVC_OBJECT;
 444
 445             read_dword(&ptr, &typeinfo);
 446             t->basetype = d3d10_variable_type(typeinfo, TRUE);
 447
 448             TRACE("Type description: %#x.\n", typeinfo);
 449             TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t->basetype));
 450             TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t->type_class));
 451             break;
 452
 453          case 3:
 454             TRACE("Type is a structure.\n");
 455
 456             read_dword(&ptr, &t->member_count);
 457             TRACE("Member count: %u.\n", t->member_count);
 458
 459             t->column_count = 0;
 460             t->row_count = 0;
 461             t->basetype = 0;
 462             t->type_class = D3D10_SVC_STRUCT;
 463
 464             t->members = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->member_count * sizeof(*t->members));
 465             if (!t->members)
 466             {
 467                 ERR("Failed to allocate members memory.\n");
 468                 return E_OUTOFMEMORY;
 469             }
 470
 471             for (i = 0; i < t->member_count; ++i)
 472             {
 473                 struct d3d10_effect_type_member *typem = &t->members[i];
 474
 475                 read_dword(&ptr, &offset);
 476                 TRACE("Member name at offset %#x.\n", offset);
 477
 478                 if (!copy_name(data + offset, &typem->name))
 479                 {
 480                     ERR("Failed to copy name.\n");
 481                     return E_OUTOFMEMORY;
 482                 }
 483                 TRACE("Member name: %s.\n", debugstr_a(typem->name));
 484
 485                 read_dword(&ptr, &offset);
 486                 TRACE("Member semantic at offset %#x.\n", offset);
 487
 488                 if (!copy_name(data + offset, &typem->semantic))
 489                 {
 490                     ERR("Failed to copy semantic.\n");
 491                     return E_OUTOFMEMORY;
 492                 }
 493                 TRACE("Member semantic: %s.\n", debugstr_a(typem->semantic));
 494
 495                 read_dword(&ptr, &typem->buffer_offset);
 496                 TRACE("Member offset in struct: %#x.\n", typem->buffer_offset);
 497
 498                 read_dword(&ptr, &offset);
 499                 TRACE("Member type info at offset %#x.\n", offset);
 500
 501                 typem->type = get_fx10_type(t->effect, data, offset);
 502                 if (!typem->type)
 503                 {
 504                     ERR("Failed to get variable type.\n");
 505                     return E_FAIL;
 506                 }
 507             }
 508             break;
 509
 510         default:
 511             FIXME("Unhandled case %#x.\n", unknown0);
 512             return E_FAIL;
 513     }
 514
 515     if (t->element_count)
 516     {
 517         TRACE("Elementtype for type at offset: %#x\n", t->id);
 518
 519         /* allocate elementtype - we need only one, because all elements have the same type */
 520         t->elementtype = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*t->elementtype));
 521         if (!t->elementtype)
 522         {
 523             ERR("Failed to allocate members memory.\n");
 524             return E_OUTOFMEMORY;
 525         }
 526
 527         /* create a copy of the original type with some minor changes */
 528         t->elementtype->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
 529         t->elementtype->effect = t->effect;
 530
 531         if (!copy_name(t->name, &t->elementtype->name))
 532         {
 533              ERR("Failed to copy name.\n");
 534              return E_OUTOFMEMORY;
 535         }
 536         TRACE("\tType name: %s.\n", debugstr_a(t->elementtype->name));
 537
 538         t->elementtype->element_count = 0;
 539         TRACE("\tElement count: %u.\n", t->elementtype->element_count);
 540
 541         /*
 542          * Not sure if this calculation is 100% correct, but a test
 543          * shows that these values work.
 544          */
 545         t->elementtype->size_unpacked = t->size_packed / t->element_count;
 546         TRACE("\tUnpacked size: %#x.\n", t->elementtype->size_unpacked);
 547
 548         t->elementtype->stride = t->stride;
 549         TRACE("\tStride: %#x.\n", t->elementtype->stride);
 550
 551         t->elementtype->size_packed = t->size_packed / t->element_count;
 552         TRACE("\tPacked size: %#x.\n", t->elementtype->size_packed);
 553
 554         t->elementtype->member_count = t->member_count;
 555         TRACE("\tMember count: %u.\n", t->elementtype->member_count);
 556
 557         t->elementtype->column_count = t->column_count;
 558         TRACE("\tColumns: %u.\n", t->elementtype->column_count);
 559
 560         t->elementtype->row_count = t->row_count;
 561         TRACE("\tRows: %u.\n", t->elementtype->row_count);
 562
 563         t->elementtype->basetype = t->basetype;
 564         TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(t->elementtype->basetype));
 565
 566         t->elementtype->type_class = t->type_class;
 567         TRACE("\tClass: %s.\n", debug_d3d10_shader_variable_class(t->elementtype->type_class));
 568
 569         t->elementtype->members = t->members;
 570     }
 571
 572     return S_OK;
 573 }
 574
 575 static struct d3d10_effect_type *get_fx10_type(struct d3d10_effect *effect, const char *data, DWORD offset)
 576 {
 577     struct d3d10_effect_type *type;
 578     struct wine_rb_entry *entry;
 579     HRESULT hr;
 580
 581     entry = wine_rb_get(&effect->types, &offset);
 582     if (entry)
 583     {
 584         TRACE("Returning existing type.\n");
 585         return WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
 586     }
 587
 588     type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*type));
 589     if (!type)
 590     {
 591         ERR("Failed to allocate type memory.\n");
 592         return NULL;
 593     }
 594
 595     type->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
 596     type->id = offset;
 597     type->effect = effect;
 598     hr = parse_fx10_type(type, data + offset, data);
 599     if (FAILED(hr))
 600     {
 601         ERR("Failed to parse type info, hr %#x.\n", hr);
 602         HeapFree(GetProcessHeap(), 0, type);
 603         return NULL;
 604     }
 605
 606     if (wine_rb_put(&effect->types, &offset, &type->entry) == -1)
 607     {
 608         ERR("Failed to insert type entry.\n");
 609         HeapFree(GetProcessHeap(), 0, type);
 610         return NULL;
 611     }
 612
 613     return type;
 614 }
 615
 616 static void set_variable_vtbl(struct d3d10_effect_variable *v)
 617 {
 618     switch (v->type->type_class)
 619     {
 620         case D3D10_SVC_SCALAR:
 621             v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl;
 622             break;
 623
 624         case D3D10_SVC_VECTOR:
 625             v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl;
 626             break;
 627
 628         case D3D10_SVC_MATRIX_ROWS:
 629         case D3D10_SVC_MATRIX_COLUMNS:
 630             v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl;
 631             break;
 632
 633         case D3D10_SVC_STRUCT:
 634             v->vtbl = &d3d10_effect_variable_vtbl;
 635             break;
 636
 637         case D3D10_SVC_OBJECT:
 638             switch(v->type->basetype)
 639             {
 640                 case D3D10_SVT_STRING:
 641                     v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl;
 642                     break;
 643
 644                 case D3D10_SVT_TEXTURE1D:
 645                 case D3D10_SVT_TEXTURE1DARRAY:
 646                 case D3D10_SVT_TEXTURE2D:
 647                 case D3D10_SVT_TEXTURE2DARRAY:
 648                 case D3D10_SVT_TEXTURE2DMS:
 649                 case D3D10_SVT_TEXTURE2DMSARRAY:
 650                 case D3D10_SVT_TEXTURE3D:
 651                 case D3D10_SVT_TEXTURECUBE:
 652                 case D3D10_SVT_BUFFER: /* Either resource or constant buffer. */
 653                     v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl;
 654                     break;
 655
 656                 case D3D10_SVT_RENDERTARGETVIEW:
 657                     v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl;
 658                     break;
 659
 660                 case D3D10_SVT_DEPTHSTENCILVIEW:
 661                     v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl;
 662                     break;
 663
 664                 case D3D10_SVT_DEPTHSTENCIL:
 665                     v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl;
 666                     break;
 667
 668                 case D3D10_SVT_VERTEXSHADER:
 669                 case D3D10_SVT_GEOMETRYSHADER:
 670                 case D3D10_SVT_PIXELSHADER:
 671                     v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl;
 672                     break;
 673
 674                 case D3D10_SVT_BLEND:
 675                     v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl;
 676                     break;
 677
 678                 case D3D10_SVT_RASTERIZER:
 679                     v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl;
 680                     break;
 681
 682                 case D3D10_SVT_SAMPLER:
 683                     v->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl;
 684                     break;
 685
 686                 default:
 687                     FIXME("Unhandled basetype %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
 688                     v->vtbl = &d3d10_effect_variable_vtbl;
 689                     break;
 690             }
 691             break;
 692
 693         default:
 694             FIXME("Unhandled type class %s.\n", debug_d3d10_shader_variable_class(v->type->type_class));
 695             v->vtbl = &d3d10_effect_variable_vtbl;
 696             break;
 697     }
 698 }
 699
 700 static HRESULT copy_variableinfo_from_type(struct d3d10_effect_variable *v)
 701 {
 702     unsigned int i;
 703     HRESULT hr;
 704
 705     if (v->type->member_count)
 706     {
 707         v->members = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, v->type->member_count * sizeof(*v->members));
 708         if (!v->members)
 709         {
 710             ERR("Failed to allocate members memory.\n");
 711             return E_OUTOFMEMORY;
 712         }
 713
 714         for (i = 0; i < v->type->member_count; ++i)
 715         {
 716             struct d3d10_effect_variable *var = &v->members[i];
 717             struct d3d10_effect_type_member *typem = &v->type->members[i];
 718
 719             var->buffer = v->buffer;
 720             var->effect = v->effect;
 721             var->type = typem->type;
 722             set_variable_vtbl(var);
 723
 724             if (!copy_name(typem->name, &var->name))
 725             {
 726                 ERR("Failed to copy name.\n");
 727                 return E_OUTOFMEMORY;
 728             }
 729             TRACE("Variable name: %s.\n", debugstr_a(var->name));
 730
 731             if (!copy_name(typem->semantic, &var->semantic))
 732             {
 733                 ERR("Failed to copy name.\n");
 734                 return E_OUTOFMEMORY;
 735             }
 736             TRACE("Variable semantic: %s.\n", debugstr_a(var->semantic));
 737
 738             var->buffer_offset = v->buffer_offset + typem->buffer_offset;
 739             TRACE("Variable buffer offset: %u.\n", var->buffer_offset);
 740
 741             hr = copy_variableinfo_from_type(var);
 742             if (FAILED(hr)) return hr;
 743         }
 744     }
 745
 746     if (v->type->element_count)
 747     {
 748         unsigned int bufferoffset = v->buffer_offset;
 749
 750         v->elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, v->type->element_count * sizeof(*v->elements));
 751         if (!v->elements)
 752         {
 753             ERR("Failed to allocate elements memory.\n");
 754             return E_OUTOFMEMORY;
 755         }
 756
 757         for (i = 0; i < v->type->element_count; ++i)
 758         {
 759             struct d3d10_effect_variable *var = &v->elements[i];
 760
 761             var->buffer = v->buffer;
 762             var->effect = v->effect;
 763             var->type = v->type->elementtype;
 764             set_variable_vtbl(var);
 765
 766             if (!copy_name(v->name, &var->name))
 767             {
 768                 ERR("Failed to copy name.\n");
 769                 return E_OUTOFMEMORY;
 770             }
 771             TRACE("Variable name: %s.\n", debugstr_a(var->name));
 772
 773             if (!copy_name(v->semantic, &var->semantic))
 774             {
 775                 ERR("Failed to copy name.\n");
 776                 return E_OUTOFMEMORY;
 777             }
 778             TRACE("Variable semantic: %s.\n", debugstr_a(var->semantic));
 779
 780             if (i != 0)
 781             {
 782                 bufferoffset += v->type->stride;
 783             }
 784             var->buffer_offset = bufferoffset;
 785             TRACE("Variable buffer offset: %u.\n", var->buffer_offset);
 786
 787             hr = copy_variableinfo_from_type(var);
 788             if (FAILED(hr)) return hr;
 789         }
 790     }
 791
 792     return S_OK;
 793 }
 794
 795 static HRESULT parse_fx10_variable_head(struct d3d10_effect_variable *v, const char **ptr, const char *data)
 796 {
 797     DWORD offset;
 798
 799     read_dword(ptr, &offset);
 800     TRACE("Variable name at offset %#x.\n", offset);
 801
 802     if (!copy_name(data + offset, &v->name))
 803     {
 804         ERR("Failed to copy name.\n");
 805         return E_OUTOFMEMORY;
 806     }
 807     TRACE("Variable name: %s.\n", debugstr_a(v->name));
 808
 809     read_dword(ptr, &offset);
 810     TRACE("Variable type info at offset %#x.\n", offset);
 811
 812     v->type = get_fx10_type(v->effect, data, offset);
 813     if (!v->type)
 814     {
 815         ERR("Failed to get variable type.\n");
 816         return E_FAIL;
 817     }
 818     set_variable_vtbl(v);
 819
 820     return copy_variableinfo_from_type(v);
 821 }
 822
 823 static HRESULT parse_fx10_annotation(struct d3d10_effect_variable *a, const char **ptr, const char *data)
 824 {
 825     HRESULT hr;
 826
 827     hr = parse_fx10_variable_head(a, ptr, data);
 828     if (FAILED(hr)) return hr;
 829
 830     skip_dword_unknown("annotation", ptr, 1);
 831
 832     /* mark the variable as annotation */
 833     a->flag = D3D10_EFFECT_VARIABLE_ANNOTATION;
 834
 835     return S_OK;
 836 }
 837
 838 static HRESULT parse_fx10_anonymous_shader(struct d3d10_effect *e, struct d3d10_effect_anonymous_shader *s,
 839     enum d3d10_effect_object_type otype)
 840 {
 841     struct d3d10_effect_variable *v = &s->shader;
 842     struct d3d10_effect_type *t = &s->type;
 843     const char *shader = NULL;
 844
 845     switch (otype)
 846     {
 847         case D3D10_EOT_VERTEXSHADER:
 848             shader = "vertexshader";
 849             t->basetype = D3D10_SVT_VERTEXSHADER;
 850             break;
 851
 852         case D3D10_EOT_PIXELSHADER:
 853             shader = "pixelshader";
 854             t->basetype = D3D10_SVT_PIXELSHADER;
 855             break;
 856
 857         case D3D10_EOT_GEOMETRYSHADER:
 858             shader = "geometryshader";
 859             t->basetype = D3D10_SVT_GEOMETRYSHADER;
 860             break;
 861     }
 862
 863     if (!copy_name(shader, &t->name))
 864     {
 865         ERR("Failed to copy name.\n");
 866         return E_OUTOFMEMORY;
 867     }
 868     TRACE("Type name: %s.\n", debugstr_a(t->name));
 869
 870     t->type_class = D3D10_SVC_OBJECT;
 871
 872     t->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
 873
 874     v->type = t;
 875     v->effect = e;
 876     set_variable_vtbl(v);
 877
 878     if (!copy_name("$Anonymous", &v->name))
 879     {
 880         ERR("Failed to copy semantic.\n");
 881         return E_OUTOFMEMORY;
 882     }
 883     TRACE("Variable name: %s.\n", debugstr_a(v->name));
 884
 885     if (!copy_name(NULL, &v->semantic))
 886     {
 887         ERR("Failed to copy semantic.\n");
 888         return E_OUTOFMEMORY;
 889     }
 890     TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
 891
 892     return S_OK;
 893 }
 894
 895 static HRESULT parse_fx10_object(struct d3d10_effect_object *o, const char **ptr, const char *data)
 896 {
 897     const char *data_ptr = NULL;
 898     DWORD offset;
 899     enum d3d10_effect_object_operation operation;
 900     HRESULT hr;
 901     struct d3d10_effect *effect = o->pass->technique->effect;
 902     ID3D10Effect *e = &effect->ID3D10Effect_iface;
 903
 904     read_dword(ptr, &o->type);
 905     TRACE("Effect object is of type %#x.\n", o->type);
 906
 907     read_dword(ptr, &o->index);
 908     TRACE("Effect object index %#x.\n", o->index);
 909
 910     read_dword(ptr, &operation);
 911     TRACE("Effect object operation %#x.\n", operation);
 912
 913     read_dword(ptr, &offset);
 914     TRACE("Effect object idx is at offset %#x.\n", offset);
 915
 916     switch(operation)
 917     {
 918         case D3D10_EOO_VALUE:
 919             TRACE("Copy variable values\n");
 920
 921             switch (o->type)
 922             {
 923                 case D3D10_EOT_VERTEXSHADER:
 924                     TRACE("Vertex shader\n");
 925                     o->data = &anonymous_vs;
 926                     hr = S_OK;
 927                     break;
 928
 929                 case D3D10_EOT_PIXELSHADER:
 930                     TRACE("Pixel shader\n");
 931                     o->data = &anonymous_ps;
 932                     hr = S_OK;
 933                     break;
 934
 935                 case D3D10_EOT_GEOMETRYSHADER:
 936                     TRACE("Geometry shader\n");
 937                     o->data = &anonymous_gs;
 938                     hr = S_OK;
 939                     break;
 940
 941                 default:
 942                     FIXME("Unhandled object type %#x\n", o->type);
 943                     hr = E_FAIL;
 944                     break;
 945             }
 946             break;
 947
 948         case D3D10_EOO_PARSED_OBJECT:
 949             /* This is a local object, we've parsed in parse_fx10_local_object. */
 950             TRACE("Shader = %s.\n", data + offset);
 951
 952             o->data = e->lpVtbl->GetVariableByName(e, data + offset);
 953             hr = S_OK;
 954             break;
 955
 956         case D3D10_EOO_PARSED_OBJECT_INDEX:
 957             /* This is a local object, we've parsed in parse_fx10_local_object, which has an array index. */
 958             data_ptr = data + offset;
 959             read_dword(&data_ptr, &offset);
 960             read_dword(&data_ptr, &o->index);
 961             TRACE("Shader = %s[%u].\n", data + offset, o->index);
 962
 963             o->data = e->lpVtbl->GetVariableByName(e, data + offset);
 964             hr = S_OK;
 965             break;
 966
 967         case D3D10_EOO_ANONYMOUS_SHADER:
 968             TRACE("Anonymous shader\n");
 969
 970             /* check anonymous_shader_current for validity */
 971             if (effect->anonymous_shader_current >= effect->anonymous_shader_count)
 972             {
 973                 ERR("Anonymous shader count is wrong!\n");
 974                 return E_FAIL;
 975             }
 976
 977             data_ptr = data + offset;
 978             read_dword(&data_ptr, &offset);
 979             TRACE("Effect object starts at offset %#x.\n", offset);
 980
 981             data_ptr = data + offset;
 982
 983             hr = parse_fx10_anonymous_shader(effect, &effect->anonymous_shaders[effect->anonymous_shader_current], o->type);
 984             if (FAILED(hr)) return hr;
 985
 986             o->data = &effect->anonymous_shaders[effect->anonymous_shader_current].shader;
 987             ++effect->anonymous_shader_current;
 988
 989             switch (o->type)
 990             {
 991                 case D3D10_EOT_VERTEXSHADER:
 992                     TRACE("Vertex shader\n");
 993                     hr = parse_shader(o->data, data_ptr);
 994                     break;
 995
 996                 case D3D10_EOT_PIXELSHADER:
 997                     TRACE("Pixel shader\n");
 998                     hr = parse_shader(o->data, data_ptr);
 999                     break;
1000
1001                 case D3D10_EOT_GEOMETRYSHADER:
1002                     TRACE("Geometry shader\n");
1003                     hr = parse_shader(o->data, data_ptr);
1004                     break;
1005
1006                 default:
1007                     FIXME("Unhandled object type %#x\n", o->type);
1008                     hr = E_FAIL;
1009                     break;
1010             }
1011             break;
1012
1013         default:
1014             hr = E_FAIL;
1015             FIXME("Unhandled operation %#x.\n", operation);
1016             break;
1017     }
1018
1019     return hr;
1020 }
1021
1022 static HRESULT parse_fx10_pass(struct d3d10_effect_pass *p, const char **ptr, const char *data)
1023 {
1024     HRESULT hr = S_OK;
1025     unsigned int i;
1026     DWORD offset;
1027
1028     read_dword(ptr, &offset);
1029     TRACE("Pass name at offset %#x.\n", offset);
1030
1031     if (!copy_name(data + offset, &p->name))
1032     {
1033         ERR("Failed to copy name.\n");
1034         return E_OUTOFMEMORY;
1035     }
1036     TRACE("Pass name: %s.\n", debugstr_a(p->name));
1037
1038     read_dword(ptr, &p->object_count);
1039     TRACE("Pass has %u effect objects.\n", p->object_count);
1040
1041     read_dword(ptr, &p->annotation_count);
1042     TRACE("Pass has %u annotations.\n", p->annotation_count);
1043
1044     p->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, p->annotation_count * sizeof(*p->annotations));
1045     if (!p->annotations)
1046     {
1047         ERR("Failed to allocate pass annotations memory.\n");
1048         return E_OUTOFMEMORY;
1049     }
1050
1051     for (i = 0; i < p->annotation_count; ++i)
1052     {
1053         struct d3d10_effect_variable *a = &p->annotations[i];
1054
1055         a->effect = p->technique->effect;
1056         a->buffer = &null_local_buffer;
1057
1058         hr = parse_fx10_annotation(a, ptr, data);
1059         if (FAILED(hr)) return hr;
1060     }
1061
1062     p->objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, p->object_count * sizeof(*p->objects));
1063     if (!p->objects)
1064     {
1065         ERR("Failed to allocate effect objects memory.\n");
1066         return E_OUTOFMEMORY;
1067     }
1068
1069     for (i = 0; i < p->object_count; ++i)
1070     {
1071         struct d3d10_effect_object *o = &p->objects[i];
1072
1073         o->pass = p;
1074
1075         hr = parse_fx10_object(o, ptr, data);
1076         if (FAILED(hr)) return hr;
1077     }
1078
1079     return hr;
1080 }
1081
1082 static HRESULT parse_fx10_technique(struct d3d10_effect_technique *t, const char **ptr, const char *data)
1083 {
1084     unsigned int i;
1085     DWORD offset;
1086     HRESULT hr;
1087
1088     read_dword(ptr, &offset);
1089     TRACE("Technique name at offset %#x.\n", offset);
1090
1091     if (!copy_name(data + offset, &t->name))
1092     {
1093         ERR("Failed to copy name.\n");
1094         return E_OUTOFMEMORY;
1095     }
1096     TRACE("Technique name: %s.\n", debugstr_a(t->name));
1097
1098     read_dword(ptr, &t->pass_count);
1099     TRACE("Technique has %u passes\n", t->pass_count);
1100
1101     read_dword(ptr, &t->annotation_count);
1102     TRACE("Technique has %u annotations.\n", t->annotation_count);
1103
1104     t->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->annotation_count * sizeof(*t->annotations));
1105     if (!t->annotations)
1106     {
1107         ERR("Failed to allocate technique annotations memory.\n");
1108         return E_OUTOFMEMORY;
1109     }
1110
1111     for (i = 0; i < t->annotation_count; ++i)
1112     {
1113         struct d3d10_effect_variable *a = &t->annotations[i];
1114
1115         a->effect = t->effect;
1116         a->buffer = &null_local_buffer;
1117
1118         hr = parse_fx10_annotation(a, ptr, data);
1119         if (FAILED(hr)) return hr;
1120     }
1121
1122     t->passes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t->pass_count * sizeof(*t->passes));
1123     if (!t->passes)
1124     {
1125         ERR("Failed to allocate passes memory\n");
1126         return E_OUTOFMEMORY;
1127     }
1128
1129     for (i = 0; i < t->pass_count; ++i)
1130     {
1131         struct d3d10_effect_pass *p = &t->passes[i];
1132
1133         p->ID3D10EffectPass_iface.lpVtbl = &d3d10_effect_pass_vtbl;
1134         p->technique = t;
1135
1136         hr = parse_fx10_pass(p, ptr, data);
1137         if (FAILED(hr)) return hr;
1138     }
1139
1140     return S_OK;
1141 }
1142
1143 static HRESULT parse_fx10_variable(struct d3d10_effect_variable *v, const char **ptr, const char *data)
1144 {
1145     DWORD offset;
1146     unsigned int i;
1147     HRESULT hr;
1148
1149     hr = parse_fx10_variable_head(v, ptr, data);
1150     if (FAILED(hr)) return hr;
1151
1152     read_dword(ptr, &offset);
1153     TRACE("Variable semantic at offset %#x.\n", offset);
1154
1155     if (!copy_name(data + offset, &v->semantic))
1156     {
1157         ERR("Failed to copy semantic.\n");
1158         return E_OUTOFMEMORY;
1159     }
1160     TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
1161
1162     read_dword(ptr, &v->buffer_offset);
1163     TRACE("Variable offset in buffer: %#x.\n", v->buffer_offset);
1164
1165     skip_dword_unknown("variable", ptr, 1);
1166
1167     read_dword(ptr, &v->flag);
1168     TRACE("Variable flag: %#x.\n", v->flag);
1169
1170     read_dword(ptr, &v->annotation_count);
1171     TRACE("Variable has %u annotations.\n", v->annotation_count);
1172
1173     v->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, v->annotation_count * sizeof(*v->annotations));
1174     if (!v->annotations)
1175     {
1176         ERR("Failed to allocate variable annotations memory.\n");
1177         return E_OUTOFMEMORY;
1178     }
1179
1180     for (i = 0; i < v->annotation_count; ++i)
1181     {
1182         struct d3d10_effect_variable *a = &v->annotations[i];
1183
1184         a->effect = v->effect;
1185         a->buffer = &null_local_buffer;
1186
1187         hr = parse_fx10_annotation(a, ptr, data);
1188         if (FAILED(hr)) return hr;
1189     }
1190
1191     return S_OK;
1192 }
1193
1194 static HRESULT parse_fx10_local_variable(struct d3d10_effect_variable *v, const char **ptr, const char *data)
1195 {
1196     unsigned int i;
1197     HRESULT hr;
1198     DWORD offset;
1199
1200     hr = parse_fx10_variable_head(v, ptr, data);
1201     if (FAILED(hr)) return hr;
1202
1203     read_dword(ptr, &offset);
1204     TRACE("Variable semantic at offset %#x.\n", offset);
1205
1206     if (!copy_name(data + offset, &v->semantic))
1207     {
1208         ERR("Failed to copy semantic.\n");
1209         return E_OUTOFMEMORY;
1210     }
1211     TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
1212
1213     skip_dword_unknown("local variable", ptr, 1);
1214
1215     switch (v->type->basetype)
1216     {
1217         case D3D10_SVT_TEXTURE1D:
1218         case D3D10_SVT_TEXTURE1DARRAY:
1219         case D3D10_SVT_TEXTURE2D:
1220         case D3D10_SVT_TEXTURE2DARRAY:
1221         case D3D10_SVT_TEXTURE2DMS:
1222         case D3D10_SVT_TEXTURE2DMSARRAY:
1223         case D3D10_SVT_TEXTURE3D:
1224         case D3D10_SVT_TEXTURECUBE:
1225         case D3D10_SVT_RENDERTARGETVIEW:
1226         case D3D10_SVT_DEPTHSTENCILVIEW:
1227         case D3D10_SVT_BUFFER:
1228             TRACE("SVT could not have elements.\n");
1229             break;
1230
1231         case D3D10_SVT_VERTEXSHADER:
1232         case D3D10_SVT_PIXELSHADER:
1233         case D3D10_SVT_GEOMETRYSHADER:
1234             TRACE("Shader type is %s\n", debug_d3d10_shader_variable_type(v->type->basetype));
1235             for (i = 0; i < max(v->type->element_count, 1); ++i)
1236             {
1237                 DWORD shader_offset;
1238                 struct d3d10_effect_variable *var;
1239
1240                 if (!v->type->element_count)
1241                 {
1242                     var = v;
1243                 }
1244                 else
1245                 {
1246                     var = &v->elements[i];
1247                 }
1248
1249                 read_dword(ptr, &shader_offset);
1250                 TRACE("Shader offset: %#x.\n", shader_offset);
1251
1252                 hr = parse_shader(var, data + shader_offset);
1253                 if (FAILED(hr)) return hr;
1254             }
1255             break;
1256
1257         case D3D10_SVT_DEPTHSTENCIL:
1258         case D3D10_SVT_BLEND:
1259         case D3D10_SVT_RASTERIZER:
1260         case D3D10_SVT_SAMPLER:
1261             TRACE("SVT is a state.\n");
1262             for (i = 0; i < max(v->type->element_count, 1); ++i)
1263             {
1264                 unsigned int j;
1265                 DWORD object_count;
1266
1267                 read_dword(ptr, &object_count);
1268                 TRACE("Object count: %#x.\n", object_count);
1269
1270                 for (j = 0; j < object_count; ++j)
1271                 {
1272                     skip_dword_unknown("state object attribute", ptr, 4);
1273                 }
1274             }
1275             break;
1276
1277         default:
1278             FIXME("Unhandled case %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
1279             return E_FAIL;
1280     }
1281
1282     read_dword(ptr, &v->annotation_count);
1283     TRACE("Variable has %u annotations.\n", v->annotation_count);
1284
1285     v->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, v->annotation_count * sizeof(*v->annotations));
1286     if (!v->annotations)
1287     {
1288         ERR("Failed to allocate variable annotations memory.\n");
1289         return E_OUTOFMEMORY;
1290     }
1291
1292     for (i = 0; i < v->annotation_count; ++i)
1293     {
1294         struct d3d10_effect_variable *a = &v->annotations[i];
1295
1296         a->effect = v->effect;
1297         a->buffer = &null_local_buffer;
1298
1299         hr = parse_fx10_annotation(a, ptr, data);
1300         if (FAILED(hr)) return hr;
1301     }
1302
1303     return S_OK;
1304 }
1305
1306 static HRESULT parse_fx10_local_buffer(struct d3d10_effect_variable *l, const char **ptr, const char *data)
1307 {
1308     unsigned int i;
1309     DWORD offset;
1310     D3D10_CBUFFER_TYPE d3d10_cbuffer_type;
1311     HRESULT hr;
1312     unsigned int stride = 0;
1313
1314     /* Generate our own type, it isn't in the fx blob. */
1315     l->type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*l->type));
1316     if (!l->type)
1317     {
1318         ERR("Failed to allocate local buffer type memory.\n");
1319         return E_OUTOFMEMORY;
1320     }
1321     l->type->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
1322     l->type->type_class = D3D10_SVC_OBJECT;
1323     l->type->effect = l->effect;
1324
1325     read_dword(ptr, &offset);
1326     TRACE("Local buffer name at offset %#x.\n", offset);
1327
1328     if (!copy_name(data + offset, &l->name))
1329     {
1330         ERR("Failed to copy name.\n");
1331         return E_OUTOFMEMORY;
1332     }
1333     TRACE("Local buffer name: %s.\n", debugstr_a(l->name));
1334
1335     read_dword(ptr, &l->data_size);
1336     TRACE("Local buffer data size: %#x.\n", l->data_size);
1337
1338     read_dword(ptr, &d3d10_cbuffer_type);
1339     TRACE("Local buffer type: %#x.\n", d3d10_cbuffer_type);
1340
1341     switch(d3d10_cbuffer_type)
1342     {
1343         case D3D10_CT_CBUFFER:
1344             l->type->basetype = D3D10_SVT_CBUFFER;
1345             if (!copy_name("cbuffer", &l->type->name))
1346             {
1347                 ERR("Failed to copy name.\n");
1348                 return E_OUTOFMEMORY;
1349             }
1350             break;
1351
1352         case D3D10_CT_TBUFFER:
1353             l->type->basetype = D3D10_SVT_TBUFFER;
1354             if (!copy_name("tbuffer", &l->type->name))
1355             {
1356                 ERR("Failed to copy name.\n");
1357                 return E_OUTOFMEMORY;
1358             }
1359             break;
1360
1361         default:
1362             ERR("Unexpected D3D10_CBUFFER_TYPE %#x!\n", d3d10_cbuffer_type);
1363             return E_FAIL;
1364     }
1365
1366     read_dword(ptr, &l->type->member_count);
1367     TRACE("Local buffer member count: %#x.\n", l->type->member_count);
1368
1369     skip_dword_unknown("local buffer", ptr, 1);
1370
1371     read_dword(ptr, &l->annotation_count);
1372     TRACE("Local buffer has %u annotations.\n", l->annotation_count);
1373
1374     l->annotations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->annotation_count * sizeof(*l->annotations));
1375     if (!l->annotations)
1376     {
1377         ERR("Failed to allocate local buffer annotations memory.\n");
1378         return E_OUTOFMEMORY;
1379     }
1380
1381     for (i = 0; i < l->annotation_count; ++i)
1382     {
1383         struct d3d10_effect_variable *a = &l->annotations[i];
1384
1385         a->effect = l->effect;
1386         a->buffer = &null_local_buffer;
1387
1388         hr = parse_fx10_annotation(a, ptr, data);
1389         if (FAILED(hr)) return hr;
1390     }
1391
1392     l->members = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->type->member_count * sizeof(*l->members));
1393     if (!l->members)
1394     {
1395         ERR("Failed to allocate members memory.\n");
1396         return E_OUTOFMEMORY;
1397     }
1398
1399     l->type->members = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, l->type->member_count * sizeof(*l->type->members));
1400     if (!l->type->members)
1401     {
1402         ERR("Failed to allocate type members memory.\n");
1403         return E_OUTOFMEMORY;
1404     }
1405
1406     for (i = 0; i < l->type->member_count; ++i)
1407     {
1408         struct d3d10_effect_variable *v = &l->members[i];
1409         struct d3d10_effect_type_member *typem = &l->type->members[i];
1410
1411         v->buffer = l;
1412         v->effect = l->effect;
1413
1414         hr = parse_fx10_variable(v, ptr, data);
1415         if (FAILED(hr)) return hr;
1416
1417         /*
1418          * Copy the values from the variable type to the constant buffers type
1419          * members structure, because it is our own generated type.
1420          */
1421         typem->type = v->type;
1422
1423         if (!copy_name(v->name, &typem->name))
1424         {
1425             ERR("Failed to copy name.\n");
1426             return E_OUTOFMEMORY;
1427         }
1428         TRACE("Variable name: %s.\n", debugstr_a(typem->name));
1429
1430         if (!copy_name(v->semantic, &typem->semantic))
1431         {
1432             ERR("Failed to copy name.\n");
1433             return E_OUTOFMEMORY;
1434         }
1435         TRACE("Variable semantic: %s.\n", debugstr_a(typem->semantic));
1436
1437         typem->buffer_offset = v->buffer_offset;
1438         TRACE("Variable buffer offset: %u.\n", typem->buffer_offset);
1439
1440         l->type->size_packed += v->type->size_packed;
1441
1442         /*
1443          * For the complete constantbuffer the size_unpacked = stride,
1444          * the stride is calculated like this:
1445          *
1446          * 1) if the constant buffer variables are packed with packoffset
1447          *    - stride = the highest used constant
1448          *    - the complete stride has to be a multiple of 0x10
1449          *
1450          * 2) if the constant buffer variables are NOT packed with packoffset
1451          *    - sum of unpacked size for all variables which fit in a 0x10 part
1452          *    - if the size exceeds a 0x10 part, the rest of the old part is skipped
1453          *      and a new part is started
1454          *    - if the variable is a struct it is always used a new part
1455          *    - the complete stride has to be a multiple of 0x10
1456          *
1457          *    e.g.:
1458          *             0x4, 0x4, 0x4, 0x8, 0x4, 0x14, 0x4
1459          *        part 0x10           0x10      0x20     -> 0x40
1460          */
1461         if (v->flag & D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
1462         {
1463             if ((v->type->size_unpacked + v->buffer_offset) > stride)
1464             {
1465                 stride = v->type->size_unpacked + v->buffer_offset;
1466             }
1467         }
1468         else
1469         {
1470             if (v->type->type_class == D3D10_SVC_STRUCT)
1471             {
1472                 stride = (stride + 0xf) & ~0xf;
1473             }
1474
1475             if ( ((stride & 0xf) + v->type->size_unpacked) > 0x10)
1476             {
1477                 stride = (stride + 0xf) & ~0xf;
1478             }
1479
1480             stride += v->type->size_unpacked;
1481         }
1482     }
1483     l->type->stride = l->type->size_unpacked = (stride + 0xf) & ~0xf;
1484
1485     TRACE("Constant buffer:\n");
1486     TRACE("\tType name: %s.\n", debugstr_a(l->type->name));
1487     TRACE("\tElement count: %u.\n", l->type->element_count);
1488     TRACE("\tMember count: %u.\n", l->type->member_count);
1489     TRACE("\tUnpacked size: %#x.\n", l->type->size_unpacked);
1490     TRACE("\tStride: %#x.\n", l->type->stride);
1491     TRACE("\tPacked size %#x.\n", l->type->size_packed);
1492     TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(l->type->basetype));
1493     TRACE("\tTypeclass: %s.\n", debug_d3d10_shader_variable_class(l->type->type_class));
1494
1495     return S_OK;
1496 }
1497
1498 static int d3d10_effect_type_compare(const void *key, const struct wine_rb_entry *entry)
1499 {
1500     const struct d3d10_effect_type *t = WINE_RB_ENTRY_VALUE(entry, const struct d3d10_effect_type, entry);
1501     const DWORD *id = key;
1502
1503     return *id - t->id;
1504 }
1505
1506 static void d3d10_effect_type_member_destroy(struct d3d10_effect_type_member *typem)
1507 {
1508     TRACE("effect type member %p.\n", typem);
1509
1510     /* Do not release typem->type, it will be covered by d3d10_effect_type_destroy(). */
1511     HeapFree(GetProcessHeap(), 0, typem->semantic);
1512     HeapFree(GetProcessHeap(), 0, typem->name);
1513 }
1514
1515 static void d3d10_effect_type_destroy(struct wine_rb_entry *entry, void *context)
1516 {
1517     struct d3d10_effect_type *t = WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
1518
1519     TRACE("effect type %p.\n", t);
1520
1521     if (t->elementtype)
1522     {
1523         HeapFree(GetProcessHeap(), 0, t->elementtype->name);
1524         HeapFree(GetProcessHeap(), 0, t->elementtype);
1525     }
1526
1527     if (t->members)
1528     {
1529         unsigned int i;
1530
1531         for (i = 0; i < t->member_count; ++i)
1532         {
1533             d3d10_effect_type_member_destroy(&t->members[i]);
1534         }
1535         HeapFree(GetProcessHeap(), 0, t->members);
1536     }
1537
1538     HeapFree(GetProcessHeap(), 0, t->name);
1539     HeapFree(GetProcessHeap(), 0, t);
1540 }
1541
1542 static const struct wine_rb_functions d3d10_effect_type_rb_functions =
1543 {
1544     d3d10_rb_alloc,
1545     d3d10_rb_realloc,
1546     d3d10_rb_free,
1547     d3d10_effect_type_compare,
1548 };
1549
1550 static HRESULT parse_fx10_body(struct d3d10_effect *e, const char *data, DWORD data_size)
1551 {
1552     const char *ptr = data + e->index_offset;
1553     unsigned int i;
1554     HRESULT hr;
1555
1556     if (wine_rb_init(&e->types, &d3d10_effect_type_rb_functions) == -1)
1557     {
1558         ERR("Failed to initialize type rbtree.\n");
1559         return E_FAIL;
1560     }
1561
1562     e->local_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->local_buffer_count * sizeof(*e->local_buffers));
1563     if (!e->local_buffers)
1564     {
1565         ERR("Failed to allocate local buffer memory.\n");
1566         return E_OUTOFMEMORY;
1567     }
1568
1569     e->local_variables = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->local_variable_count * sizeof(*e->local_variables));
1570     if (!e->local_variables)
1571     {
1572         ERR("Failed to allocate local variable memory.\n");
1573         return E_OUTOFMEMORY;
1574     }
1575
1576     e->anonymous_shaders = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->anonymous_shader_count * sizeof(*e->anonymous_shaders));
1577     if (!e->anonymous_shaders)
1578     {
1579         ERR("Failed to allocate anonymous shaders memory\n");
1580         return E_OUTOFMEMORY;
1581     }
1582
1583     e->used_shaders = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->used_shader_count * sizeof(*e->used_shaders));
1584     if (!e->used_shaders)
1585     {
1586         ERR("Failed to allocate used shaders memory\n");
1587         return E_OUTOFMEMORY;
1588     }
1589
1590     e->techniques = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, e->technique_count * sizeof(*e->techniques));
1591     if (!e->techniques)
1592     {
1593         ERR("Failed to allocate techniques memory\n");
1594         return E_OUTOFMEMORY;
1595     }
1596
1597     for (i = 0; i < e->local_buffer_count; ++i)
1598     {
1599         struct d3d10_effect_variable *l = &e->local_buffers[i];
1600         l->vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl;
1601         l->effect = e;
1602         l->buffer = &null_local_buffer;
1603
1604         hr = parse_fx10_local_buffer(l, &ptr, data);
1605         if (FAILED(hr)) return hr;
1606     }
1607
1608     for (i = 0; i < e->local_variable_count; ++i)
1609     {
1610         struct d3d10_effect_variable *v = &e->local_variables[i];
1611
1612         v->effect = e;
1613         v->vtbl = &d3d10_effect_variable_vtbl;
1614         v->buffer = &null_local_buffer;
1615
1616         hr = parse_fx10_local_variable(v, &ptr, data);
1617         if (FAILED(hr)) return hr;
1618     }
1619
1620     for (i = 0; i < e->technique_count; ++i)
1621     {
1622         struct d3d10_effect_technique *t = &e->techniques[i];
1623
1624         t->ID3D10EffectTechnique_iface.lpVtbl = &d3d10_effect_technique_vtbl;
1625         t->effect = e;
1626
1627         hr = parse_fx10_technique(t, &ptr, data);
1628         if (FAILED(hr)) return hr;
1629     }
1630
1631     return S_OK;
1632 }
1633
1634 static HRESULT parse_fx10(struct d3d10_effect *e, const char *data, DWORD data_size)
1635 {
1636     const char *ptr = data;
1637     DWORD unknown;
1638
1639     /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
1640     read_dword(&ptr, &e->version);
1641     TRACE("Target: %#x\n", e->version);
1642
1643     read_dword(&ptr, &e->local_buffer_count);
1644     TRACE("Local buffer count: %u.\n", e->local_buffer_count);
1645
1646     read_dword(&ptr, &e->variable_count);
1647     TRACE("Variable count: %u\n", e->variable_count);
1648
1649     read_dword(&ptr, &e->local_variable_count);
1650     TRACE("Object count: %u\n", e->local_variable_count);
1651
1652     read_dword(&ptr, &e->sharedbuffers_count);
1653     TRACE("Sharedbuffers count: %u\n", e->sharedbuffers_count);
1654
1655     /* Number of variables in shared buffers? */
1656     read_dword(&ptr, &unknown);
1657     FIXME("Unknown 0: %u\n", unknown);
1658
1659     read_dword(&ptr, &e->sharedobjects_count);
1660     TRACE("Sharedobjects count: %u\n", e->sharedobjects_count);
1661
1662     read_dword(&ptr, &e->technique_count);
1663     TRACE("Technique count: %u\n", e->technique_count);
1664
1665     read_dword(&ptr, &e->index_offset);
1666     TRACE("Index offset: %#x\n", e->index_offset);
1667
1668     read_dword(&ptr, &unknown);
1669     FIXME("Unknown 1: %u\n", unknown);
1670
1671     read_dword(&ptr, &e->texture_count);
1672     TRACE("Texture count: %u\n", e->texture_count);
1673
1674     read_dword(&ptr, &e->dephstencilstate_count);
1675     TRACE("Depthstencilstate count: %u\n", e->dephstencilstate_count);
1676
1677     read_dword(&ptr, &e->blendstate_count);
1678     TRACE("Blendstate count: %u\n", e->blendstate_count);
1679
1680     read_dword(&ptr, &e->rasterizerstate_count);
1681     TRACE("Rasterizerstate count: %u\n", e->rasterizerstate_count);
1682
1683     read_dword(&ptr, &e->samplerstate_count);
1684     TRACE("Samplerstate count: %u\n", e->samplerstate_count);
1685
1686     read_dword(&ptr, &e->rendertargetview_count);
1687     TRACE("Rendertargetview count: %u\n", e->rendertargetview_count);
1688
1689     read_dword(&ptr, &e->depthstencilview_count);
1690     TRACE("Depthstencilview count: %u\n", e->depthstencilview_count);
1691
1692     read_dword(&ptr, &e->used_shader_count);
1693     TRACE("Used shader count: %u\n", e->used_shader_count);
1694
1695     read_dword(&ptr, &e->anonymous_shader_count);
1696     TRACE("Anonymous shader count: %u\n", e->anonymous_shader_count);
1697
1698     return parse_fx10_body(e, ptr, data_size - (ptr - data));
1699 }
1700
1701 static HRESULT fx10_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
1702 {
1703     struct d3d10_effect *e = ctx;
1704
1705     TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
1706
1707     TRACE("chunk size: %#x\n", data_size);
1708
1709     switch(tag)
1710     {
1711         case TAG_FX10:
1712             return parse_fx10(e, data, data_size);
1713
1714         default:
1715             FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
1716             return S_OK;
1717     }
1718 }
1719
1720 HRESULT d3d10_effect_parse(struct d3d10_effect *This, const void *data, SIZE_T data_size)
1721 {
1722     return parse_dxbc(data, data_size, fx10_chunk_handler, This);
1723 }
1724
1725 static HRESULT d3d10_effect_object_apply(struct d3d10_effect_object *o)
1726 {
1727     ID3D10Device *device = o->pass->technique->effect->device;
1728     struct d3d10_effect_variable *v = (struct d3d10_effect_variable*) o->data;
1729
1730     TRACE("effect object %p, type %#x.\n", o, o->type);
1731
1732     switch(o->type)
1733     {
1734         case D3D10_EOT_VERTEXSHADER:
1735             ID3D10Device_VSSetShader(device, ((struct d3d10_effect_shader_variable *)v->data)->shader.vs);
1736             return S_OK;
1737
1738         case D3D10_EOT_PIXELSHADER:
1739             ID3D10Device_PSSetShader(device, ((struct d3d10_effect_shader_variable *)v->data)->shader.ps);
1740             return S_OK;
1741
1742         case D3D10_EOT_GEOMETRYSHADER:
1743             ID3D10Device_GSSetShader(device, ((struct d3d10_effect_shader_variable *)v->data)->shader.gs);
1744             return S_OK;
1745
1746         default:
1747             FIXME("Unhandled effect object type %#x.\n", o->type);
1748             return E_FAIL;
1749     }
1750 }
1751
1752 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable *v)
1753 {
1754     unsigned int i;
1755
1756     TRACE("variable %p.\n", v);
1757
1758     HeapFree(GetProcessHeap(), 0, v->name);
1759     HeapFree(GetProcessHeap(), 0, v->semantic);
1760     if (v->annotations)
1761     {
1762         for (i = 0; i < v->annotation_count; ++i)
1763         {
1764             d3d10_effect_variable_destroy(&v->annotations[i]);
1765         }
1766         HeapFree(GetProcessHeap(), 0, v->annotations);
1767     }
1768
1769     if (v->members)
1770     {
1771         for (i = 0; i < v->type->member_count; ++i)
1772         {
1773             d3d10_effect_variable_destroy(&v->members[i]);
1774         }
1775         HeapFree(GetProcessHeap(), 0, v->members);
1776     }
1777
1778     if (v->elements)
1779     {
1780         for (i = 0; i < v->type->element_count; ++i)
1781         {
1782             d3d10_effect_variable_destroy(&v->elements[i]);
1783         }
1784         HeapFree(GetProcessHeap(), 0, v->elements);
1785     }
1786
1787     if (v->data)
1788     {
1789         switch(v->type->basetype)
1790         {
1791             case D3D10_SVT_VERTEXSHADER:
1792             case D3D10_SVT_PIXELSHADER:
1793             case D3D10_SVT_GEOMETRYSHADER:
1794                 shader_free_signature(&((struct d3d10_effect_shader_variable *)v->data)->input_signature);
1795                 shader_free_signature(&((struct d3d10_effect_shader_variable *)v->data)->output_signature);
1796                 break;
1797
1798             default:
1799                 break;
1800         }
1801         HeapFree(GetProcessHeap(), 0, v->data);
1802     }
1803 }
1804
1805 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass *p)
1806 {
1807     unsigned int i;
1808
1809     TRACE("pass %p\n", p);
1810
1811     HeapFree(GetProcessHeap(), 0, p->name);
1812     HeapFree(GetProcessHeap(), 0, p->objects);
1813
1814     if (p->annotations)
1815     {
1816         for (i = 0; i < p->annotation_count; ++i)
1817         {
1818             d3d10_effect_variable_destroy(&p->annotations[i]);
1819         }
1820         HeapFree(GetProcessHeap(), 0, p->annotations);
1821     }
1822 }
1823
1824 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique *t)
1825 {
1826     unsigned int i;
1827
1828     TRACE("technique %p\n", t);
1829
1830     HeapFree(GetProcessHeap(), 0, t->name);
1831     if (t->passes)
1832     {
1833         for (i = 0; i < t->pass_count; ++i)
1834         {
1835             d3d10_effect_pass_destroy(&t->passes[i]);
1836         }
1837         HeapFree(GetProcessHeap(), 0, t->passes);
1838     }
1839
1840     if (t->annotations)
1841     {
1842         for (i = 0; i < t->annotation_count; ++i)
1843         {
1844             d3d10_effect_variable_destroy(&t->annotations[i]);
1845         }
1846         HeapFree(GetProcessHeap(), 0, t->annotations);
1847     }
1848 }
1849
1850 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_variable *l)
1851 {
1852     unsigned int i;
1853
1854     TRACE("local buffer %p.\n", l);
1855
1856     HeapFree(GetProcessHeap(), 0, l->name);
1857     if (l->members)
1858     {
1859         for (i = 0; i < l->type->member_count; ++i)
1860         {
1861             d3d10_effect_variable_destroy(&l->members[i]);
1862         }
1863         HeapFree(GetProcessHeap(), 0, l->members);
1864     }
1865
1866     if (l->type->members)
1867     {
1868         for (i = 0; i < l->type->member_count; ++i)
1869         {
1870             /* Do not release l->type->members[i].type, it will be covered by d3d10_effect_type_destroy(). */
1871             HeapFree(GetProcessHeap(), 0, l->type->members[i].semantic);
1872             HeapFree(GetProcessHeap(), 0, l->type->members[i].name);
1873         }
1874         HeapFree(GetProcessHeap(), 0, l->type->members);
1875     }
1876     HeapFree(GetProcessHeap(), 0, l->type->name);
1877     HeapFree(GetProcessHeap(), 0, l->type);
1878
1879     if (l->annotations)
1880     {
1881         for (i = 0; i < l->annotation_count; ++i)
1882         {
1883             d3d10_effect_variable_destroy(&l->annotations[i]);
1884         }
1885         HeapFree(GetProcessHeap(), 0, l->annotations);
1886     }
1887 }
1888
1889 /* IUnknown methods */
1890
1891 static inline struct d3d10_effect *impl_from_ID3D10Effect(ID3D10Effect *iface)
1892 {
1893     return CONTAINING_RECORD(iface, struct d3d10_effect, ID3D10Effect_iface);
1894 }
1895
1896 static HRESULT STDMETHODCALLTYPE d3d10_effect_QueryInterface(ID3D10Effect *iface, REFIID riid, void **object)
1897 {
1898     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
1899
1900     if (IsEqualGUID(riid, &IID_ID3D10Effect)
1901             || IsEqualGUID(riid, &IID_IUnknown))
1902     {
1903         IUnknown_AddRef(iface);
1904         *object = iface;
1905         return S_OK;
1906     }
1907
1908     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
1909
1910     *object = NULL;
1911     return E_NOINTERFACE;
1912 }
1913
1914 static ULONG STDMETHODCALLTYPE d3d10_effect_AddRef(ID3D10Effect *iface)
1915 {
1916     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
1917     ULONG refcount = InterlockedIncrement(&This->refcount);
1918
1919     TRACE("%p increasing refcount to %u\n", This, refcount);
1920
1921     return refcount;
1922 }
1923
1924 static ULONG STDMETHODCALLTYPE d3d10_effect_Release(ID3D10Effect *iface)
1925 {
1926     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
1927     ULONG refcount = InterlockedDecrement(&This->refcount);
1928
1929     TRACE("%p decreasing refcount to %u\n", This, refcount);
1930
1931     if (!refcount)
1932     {
1933         unsigned int i;
1934
1935         if (This->techniques)
1936         {
1937             for (i = 0; i < This->technique_count; ++i)
1938             {
1939                 d3d10_effect_technique_destroy(&This->techniques[i]);
1940             }
1941             HeapFree(GetProcessHeap(), 0, This->techniques);
1942         }
1943
1944         if (This->local_variables)
1945         {
1946             for (i = 0; i < This->local_variable_count; ++i)
1947             {
1948                 d3d10_effect_variable_destroy(&This->local_variables[i]);
1949             }
1950             HeapFree(GetProcessHeap(), 0, This->local_variables);
1951         }
1952
1953         if (This->local_buffers)
1954         {
1955             for (i = 0; i < This->local_buffer_count; ++i)
1956             {
1957                 d3d10_effect_local_buffer_destroy(&This->local_buffers[i]);
1958             }
1959             HeapFree(GetProcessHeap(), 0, This->local_buffers);
1960         }
1961
1962         if (This->anonymous_shaders)
1963         {
1964             for (i = 0; i < This->anonymous_shader_count; ++i)
1965             {
1966                 d3d10_effect_variable_destroy(&This->anonymous_shaders[i].shader);
1967                 HeapFree(GetProcessHeap(), 0, This->anonymous_shaders[i].type.name);
1968             }
1969             HeapFree(GetProcessHeap(), 0, This->anonymous_shaders);
1970         }
1971
1972         HeapFree(GetProcessHeap(), 0, This->used_shaders);
1973
1974         wine_rb_destroy(&This->types, d3d10_effect_type_destroy, NULL);
1975
1976         ID3D10Device_Release(This->device);
1977         HeapFree(GetProcessHeap(), 0, This);
1978     }
1979
1980     return refcount;
1981 }
1982
1983 /* ID3D10Effect methods */
1984
1985 static BOOL STDMETHODCALLTYPE d3d10_effect_IsValid(ID3D10Effect *iface)
1986 {
1987     FIXME("iface %p stub!\n", iface);
1988
1989     return FALSE;
1990 }
1991
1992 static BOOL STDMETHODCALLTYPE d3d10_effect_IsPool(ID3D10Effect *iface)
1993 {
1994     FIXME("iface %p stub!\n", iface);
1995
1996     return FALSE;
1997 }
1998
1999 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDevice(ID3D10Effect *iface, ID3D10Device **device)
2000 {
2001     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2002
2003     TRACE("iface %p, device %p\n", iface, device);
2004
2005     ID3D10Device_AddRef(This->device);
2006     *device = This->device;
2007
2008     return S_OK;
2009 }
2010
2011 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDesc(ID3D10Effect *iface, D3D10_EFFECT_DESC *desc)
2012 {
2013     FIXME("iface %p, desc %p stub!\n", iface, desc);
2014
2015     return E_NOTIMPL;
2016 }
2017
2018 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByIndex(ID3D10Effect *iface,
2019         UINT index)
2020 {
2021     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2022     struct d3d10_effect_variable *l;
2023
2024     TRACE("iface %p, index %u\n", iface, index);
2025
2026     if (index >= This->local_buffer_count)
2027     {
2028         WARN("Invalid index specified\n");
2029         return (ID3D10EffectConstantBuffer *)&null_local_buffer;
2030     }
2031
2032     l = &This->local_buffers[index];
2033
2034     TRACE("Returning buffer %p, %s.\n", l, debugstr_a(l->name));
2035
2036     return (ID3D10EffectConstantBuffer *)l;
2037 }
2038
2039 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByName(ID3D10Effect *iface,
2040         LPCSTR name)
2041 {
2042     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2043     unsigned int i;
2044
2045     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2046
2047     for (i = 0; i < This->local_buffer_count; ++i)
2048     {
2049         struct d3d10_effect_variable *l = &This->local_buffers[i];
2050
2051         if (!strcmp(l->name, name))
2052         {
2053             TRACE("Returning buffer %p.\n", l);
2054             return (ID3D10EffectConstantBuffer *)l;
2055         }
2056     }
2057
2058     WARN("Invalid name specified\n");
2059
2060     return (ID3D10EffectConstantBuffer *)&null_local_buffer;
2061 }
2062
2063 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByIndex(ID3D10Effect *iface, UINT index)
2064 {
2065     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2066     unsigned int i;
2067
2068     TRACE("iface %p, index %u\n", iface, index);
2069
2070     for (i = 0; i < This->local_buffer_count; ++i)
2071     {
2072         struct d3d10_effect_variable *l = &This->local_buffers[i];
2073
2074         if (index < l->type->member_count)
2075         {
2076             struct d3d10_effect_variable *v = &l->members[index];
2077
2078             TRACE("Returning variable %p.\n", v);
2079             return (ID3D10EffectVariable *)v;
2080         }
2081         index -= l->type->member_count;
2082     }
2083
2084     if (index < This->local_variable_count)
2085     {
2086         struct d3d10_effect_variable *v = &This->local_variables[index];
2087
2088         TRACE("Returning variable %p.\n", v);
2089         return (ID3D10EffectVariable *)v;
2090     }
2091
2092     WARN("Invalid index specified\n");
2093
2094     return (ID3D10EffectVariable *)&null_variable;
2095 }
2096
2097 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByName(ID3D10Effect *iface, LPCSTR name)
2098 {
2099     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2100     unsigned int i;
2101
2102     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2103
2104     if (!name)
2105     {
2106         WARN("Invalid name specified\n");
2107         return (ID3D10EffectVariable *)&null_variable;
2108     }
2109
2110     for (i = 0; i < This->local_buffer_count; ++i)
2111     {
2112         struct d3d10_effect_variable *l = &This->local_buffers[i];
2113         unsigned int j;
2114
2115         for (j = 0; j < l->type->member_count; ++j)
2116         {
2117             struct d3d10_effect_variable *v = &l->members[j];
2118
2119             if (!strcmp(v->name, name))
2120             {
2121                 TRACE("Returning variable %p.\n", v);
2122                 return (ID3D10EffectVariable *)v;
2123             }
2124         }
2125     }
2126
2127     for (i = 0; i < This->local_variable_count; ++i)
2128     {
2129         struct d3d10_effect_variable *v = &This->local_variables[i];
2130
2131         if (!strcmp(v->name, name))
2132         {
2133             TRACE("Returning variable %p.\n", v);
2134             return (ID3D10EffectVariable *)v;
2135         }
2136     }
2137
2138     WARN("Invalid name specified\n");
2139
2140     return (ID3D10EffectVariable *)&null_variable;
2141 }
2142
2143 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableBySemantic(ID3D10Effect *iface,
2144         LPCSTR semantic)
2145 {
2146     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2147     unsigned int i;
2148
2149     TRACE("iface %p, semantic %s\n", iface, debugstr_a(semantic));
2150
2151     if (!semantic)
2152     {
2153         WARN("Invalid semantic specified\n");
2154         return (ID3D10EffectVariable *)&null_variable;
2155     }
2156
2157     for (i = 0; i < This->local_buffer_count; ++i)
2158     {
2159         struct d3d10_effect_variable *l = &This->local_buffers[i];
2160         unsigned int j;
2161
2162         for (j = 0; j < l->type->member_count; ++j)
2163         {
2164             struct d3d10_effect_variable *v = &l->members[j];
2165
2166             if (!strcmp(v->semantic, semantic))
2167             {
2168                 TRACE("Returning variable %p.\n", v);
2169                 return (ID3D10EffectVariable *)v;
2170             }
2171         }
2172     }
2173
2174     for (i = 0; i < This->local_variable_count; ++i)
2175     {
2176         struct d3d10_effect_variable *v = &This->local_variables[i];
2177
2178         if (!strcmp(v->semantic, semantic))
2179         {
2180             TRACE("Returning variable %p.\n", v);
2181             return (ID3D10EffectVariable *)v;
2182         }
2183     }
2184
2185     WARN("Invalid semantic specified\n");
2186
2187     return (ID3D10EffectVariable *)&null_variable;
2188 }
2189
2190 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByIndex(ID3D10Effect *iface,
2191         UINT index)
2192 {
2193     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2194     struct d3d10_effect_technique *t;
2195
2196     TRACE("iface %p, index %u\n", iface, index);
2197
2198     if (index >= This->technique_count)
2199     {
2200         WARN("Invalid index specified\n");
2201         return &null_technique.ID3D10EffectTechnique_iface;
2202     }
2203
2204     t = &This->techniques[index];
2205
2206     TRACE("Returning technique %p, %s.\n", t, debugstr_a(t->name));
2207
2208     return &t->ID3D10EffectTechnique_iface;
2209 }
2210
2211 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByName(ID3D10Effect *iface,
2212         LPCSTR name)
2213 {
2214     struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2215     unsigned int i;
2216
2217     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2218
2219     if (!name)
2220     {
2221         WARN("Invalid name specified\n");
2222         return &null_technique.ID3D10EffectTechnique_iface;
2223     }
2224
2225     for (i = 0; i < This->technique_count; ++i)
2226     {
2227         struct d3d10_effect_technique *t = &This->techniques[i];
2228         if (!strcmp(t->name, name))
2229         {
2230             TRACE("Returning technique %p\n", t);
2231             return &t->ID3D10EffectTechnique_iface;
2232         }
2233     }
2234
2235     WARN("Invalid name specified\n");
2236
2237     return &null_technique.ID3D10EffectTechnique_iface;
2238 }
2239
2240 static HRESULT STDMETHODCALLTYPE d3d10_effect_Optimize(ID3D10Effect *iface)
2241 {
2242     FIXME("iface %p stub!\n", iface);
2243
2244     return E_NOTIMPL;
2245 }
2246
2247 static BOOL STDMETHODCALLTYPE d3d10_effect_IsOptimized(ID3D10Effect *iface)
2248 {
2249     FIXME("iface %p stub!\n", iface);
2250
2251     return FALSE;
2252 }
2253
2254 const struct ID3D10EffectVtbl d3d10_effect_vtbl =
2255 {
2256     /* IUnknown methods */
2257     d3d10_effect_QueryInterface,
2258     d3d10_effect_AddRef,
2259     d3d10_effect_Release,
2260     /* ID3D10Effect methods */
2261     d3d10_effect_IsValid,
2262     d3d10_effect_IsPool,
2263     d3d10_effect_GetDevice,
2264     d3d10_effect_GetDesc,
2265     d3d10_effect_GetConstantBufferByIndex,
2266     d3d10_effect_GetConstantBufferByName,
2267     d3d10_effect_GetVariableByIndex,
2268     d3d10_effect_GetVariableByName,
2269     d3d10_effect_GetVariableBySemantic,
2270     d3d10_effect_GetTechniqueByIndex,
2271     d3d10_effect_GetTechniqueByName,
2272     d3d10_effect_Optimize,
2273     d3d10_effect_IsOptimized,
2274 };
2275
2276 /* ID3D10EffectTechnique methods */
2277
2278 static inline struct d3d10_effect_technique *impl_from_ID3D10EffectTechnique(ID3D10EffectTechnique *iface)
2279 {
2280     return CONTAINING_RECORD(iface, struct d3d10_effect_technique, ID3D10EffectTechnique_iface);
2281 }
2282
2283 static BOOL STDMETHODCALLTYPE d3d10_effect_technique_IsValid(ID3D10EffectTechnique *iface)
2284 {
2285     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2286
2287     TRACE("iface %p\n", iface);
2288
2289     return This != &null_technique;
2290 }
2291
2292 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_GetDesc(ID3D10EffectTechnique *iface,
2293         D3D10_TECHNIQUE_DESC *desc)
2294 {
2295     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2296
2297     TRACE("iface %p, desc %p\n", iface, desc);
2298
2299     if(This == &null_technique)
2300     {
2301         WARN("Null technique specified\n");
2302         return E_FAIL;
2303     }
2304
2305     if(!desc)
2306     {
2307         WARN("Invalid argument specified\n");
2308         return E_INVALIDARG;
2309     }
2310
2311     desc->Name = This->name;
2312     desc->Passes = This->pass_count;
2313     desc->Annotations = This->annotation_count;
2314
2315     return S_OK;
2316 }
2317
2318 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByIndex(
2319         ID3D10EffectTechnique *iface, UINT index)
2320 {
2321     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2322     struct d3d10_effect_variable *a;
2323
2324     TRACE("iface %p, index %u\n", iface, index);
2325
2326     if (index >= This->annotation_count)
2327     {
2328         WARN("Invalid index specified\n");
2329         return (ID3D10EffectVariable *)&null_variable;
2330     }
2331
2332     a = &This->annotations[index];
2333
2334     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
2335
2336     return (ID3D10EffectVariable *)a;
2337 }
2338
2339 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByName(
2340         ID3D10EffectTechnique *iface, LPCSTR name)
2341 {
2342     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2343     unsigned int i;
2344
2345     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2346
2347     for (i = 0; i < This->annotation_count; ++i)
2348     {
2349         struct d3d10_effect_variable *a = &This->annotations[i];
2350         if (!strcmp(a->name, name))
2351         {
2352             TRACE("Returning annotation %p\n", a);
2353             return (ID3D10EffectVariable *)a;
2354         }
2355     }
2356
2357     WARN("Invalid name specified\n");
2358
2359     return (ID3D10EffectVariable *)&null_variable;
2360 }
2361
2362 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique *iface,
2363         UINT index)
2364 {
2365     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2366     struct d3d10_effect_pass *p;
2367
2368     TRACE("iface %p, index %u\n", iface, index);
2369
2370     if (index >= This->pass_count)
2371     {
2372         WARN("Invalid index specified\n");
2373         return &null_pass.ID3D10EffectPass_iface;
2374     }
2375
2376     p = &This->passes[index];
2377
2378     TRACE("Returning pass %p, %s.\n", p, debugstr_a(p->name));
2379
2380     return &p->ID3D10EffectPass_iface;
2381 }
2382
2383 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique *iface,
2384         LPCSTR name)
2385 {
2386     struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2387     unsigned int i;
2388
2389     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2390
2391     /* Do not check for name==NULL, W7/DX10 crashes in that case. */
2392
2393     for (i = 0; i < This->pass_count; ++i)
2394     {
2395         struct d3d10_effect_pass *p = &This->passes[i];
2396         if (!strcmp(p->name, name))
2397         {
2398             TRACE("Returning pass %p\n", p);
2399             return &p->ID3D10EffectPass_iface;
2400         }
2401     }
2402
2403     WARN("Invalid name specified\n");
2404
2405     return &null_pass.ID3D10EffectPass_iface;
2406 }
2407
2408 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique *iface,
2409         D3D10_STATE_BLOCK_MASK *mask)
2410 {
2411     FIXME("iface %p,mask %p stub!\n", iface, mask);
2412
2413     return E_NOTIMPL;
2414 }
2415
2416 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl =
2417 {
2418     /* ID3D10EffectTechnique methods */
2419     d3d10_effect_technique_IsValid,
2420     d3d10_effect_technique_GetDesc,
2421     d3d10_effect_technique_GetAnnotationByIndex,
2422     d3d10_effect_technique_GetAnnotationByName,
2423     d3d10_effect_technique_GetPassByIndex,
2424     d3d10_effect_technique_GetPassByName,
2425     d3d10_effect_technique_ComputeStateBlockMask,
2426 };
2427
2428 /* ID3D10EffectPass methods */
2429
2430 static inline struct d3d10_effect_pass *impl_from_ID3D10EffectPass(ID3D10EffectPass *iface)
2431 {
2432     return CONTAINING_RECORD(iface, struct d3d10_effect_pass, ID3D10EffectPass_iface);
2433 }
2434
2435 static BOOL STDMETHODCALLTYPE d3d10_effect_pass_IsValid(ID3D10EffectPass *iface)
2436 {
2437     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2438
2439     TRACE("iface %p\n", iface);
2440
2441     return This != &null_pass;
2442 }
2443
2444 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetDesc(ID3D10EffectPass *iface,
2445         D3D10_PASS_DESC *desc)
2446 {
2447     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2448     unsigned int i;
2449
2450     FIXME("iface %p, desc %p partial stub!\n", iface, desc);
2451
2452     if(This == &null_pass)
2453     {
2454         WARN("Null pass specified\n");
2455         return E_FAIL;
2456     }
2457
2458     if(!desc)
2459     {
2460         WARN("Invalid argument specified\n");
2461         return E_INVALIDARG;
2462     }
2463
2464     memset(desc, 0, sizeof(*desc));
2465     desc->Name = This->name;
2466     for (i = 0; i < This->object_count; ++i)
2467     {
2468         struct d3d10_effect_object *o = &This->objects[i];
2469         if (o->type == D3D10_EOT_VERTEXSHADER)
2470         {
2471             struct d3d10_effect_variable *v = o->data;
2472             struct d3d10_effect_shader_variable *s = v->data;
2473             desc->pIAInputSignature = (BYTE *)s->input_signature.signature;
2474             desc->IAInputSignatureSize = s->input_signature.signature_size;
2475             break;
2476         }
2477     }
2478
2479     return S_OK;
2480 }
2481
2482 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass *iface,
2483         D3D10_PASS_SHADER_DESC *desc)
2484 {
2485     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2486     unsigned int i;
2487
2488     TRACE("iface %p, desc %p\n", iface, desc);
2489
2490     if (This == &null_pass)
2491     {
2492         WARN("Null pass specified\n");
2493         return E_FAIL;
2494     }
2495
2496     if (!desc)
2497     {
2498         WARN("Invalid argument specified\n");
2499         return E_INVALIDARG;
2500     }
2501
2502     for (i = 0; i < This->object_count; ++i)
2503     {
2504         struct d3d10_effect_object *o = &This->objects[i];
2505
2506         if (o->type == D3D10_EOT_VERTEXSHADER)
2507         {
2508             desc->pShaderVariable = o->data;
2509             desc->ShaderIndex = o->index;
2510             return S_OK;
2511         }
2512     }
2513
2514     TRACE("Returning null_shader_variable\n");
2515     desc->pShaderVariable = (ID3D10EffectShaderVariable *)&null_shader_variable;
2516     desc->ShaderIndex = 0;
2517
2518     return S_OK;
2519 }
2520
2521 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass *iface,
2522         D3D10_PASS_SHADER_DESC *desc)
2523 {
2524     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2525     unsigned int i;
2526
2527     TRACE("iface %p, desc %p\n", iface, desc);
2528
2529     if (This == &null_pass)
2530     {
2531         WARN("Null pass specified\n");
2532         return E_FAIL;
2533     }
2534
2535     if (!desc)
2536     {
2537         WARN("Invalid argument specified\n");
2538         return E_INVALIDARG;
2539     }
2540
2541     for (i = 0; i < This->object_count; ++i)
2542     {
2543         struct d3d10_effect_object *o = &This->objects[i];
2544
2545         if (o->type == D3D10_EOT_GEOMETRYSHADER)
2546         {
2547             desc->pShaderVariable = o->data;
2548             desc->ShaderIndex = o->index;
2549             return S_OK;
2550         }
2551     }
2552
2553     TRACE("Returning null_shader_variable\n");
2554     desc->pShaderVariable = (ID3D10EffectShaderVariable *)&null_shader_variable;
2555     desc->ShaderIndex = 0;
2556
2557     return S_OK;
2558 }
2559
2560 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass *iface,
2561         D3D10_PASS_SHADER_DESC *desc)
2562 {
2563     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2564     unsigned int i;
2565
2566     TRACE("iface %p, desc %p\n", iface, desc);
2567
2568     if (This == &null_pass)
2569     {
2570         WARN("Null pass specified\n");
2571         return E_FAIL;
2572     }
2573
2574     if (!desc)
2575     {
2576         WARN("Invalid argument specified\n");
2577         return E_INVALIDARG;
2578     }
2579
2580     for (i = 0; i < This->object_count; ++i)
2581     {
2582         struct d3d10_effect_object *o = &This->objects[i];
2583
2584         if (o->type == D3D10_EOT_PIXELSHADER)
2585         {
2586             desc->pShaderVariable = o->data;
2587             desc->ShaderIndex = o->index;
2588             return S_OK;
2589         }
2590     }
2591
2592     TRACE("Returning null_shader_variable\n");
2593     desc->pShaderVariable = (ID3D10EffectShaderVariable *)&null_shader_variable;
2594     desc->ShaderIndex = 0;
2595
2596     return S_OK;
2597 }
2598
2599 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass *iface,
2600         UINT index)
2601 {
2602     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2603     struct d3d10_effect_variable *a;
2604
2605     TRACE("iface %p, index %u\n", iface, index);
2606
2607     if (index >= This->annotation_count)
2608     {
2609         WARN("Invalid index specified\n");
2610         return (ID3D10EffectVariable *)&null_variable;
2611     }
2612
2613     a = &This->annotations[index];
2614
2615     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
2616
2617     return (ID3D10EffectVariable *)a;
2618 }
2619
2620 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass *iface,
2621         LPCSTR name)
2622 {
2623     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2624     unsigned int i;
2625
2626     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2627
2628     for (i = 0; i < This->annotation_count; ++i)
2629     {
2630         struct d3d10_effect_variable *a = &This->annotations[i];
2631         if (!strcmp(a->name, name))
2632         {
2633             TRACE("Returning annotation %p\n", a);
2634             return (ID3D10EffectVariable *)a;
2635         }
2636     }
2637
2638     WARN("Invalid name specified\n");
2639
2640     return (ID3D10EffectVariable *)&null_variable;
2641 }
2642
2643 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_Apply(ID3D10EffectPass *iface, UINT flags)
2644 {
2645     struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
2646     HRESULT hr = S_OK;
2647     unsigned int i;
2648
2649     TRACE("iface %p, flags %#x\n", iface, flags);
2650
2651     if (flags) FIXME("Ignoring flags (%#x)\n", flags);
2652
2653     for (i = 0; i < This->object_count; ++i)
2654     {
2655         hr = d3d10_effect_object_apply(&This->objects[i]);
2656         if (FAILED(hr)) break;
2657     }
2658
2659     return hr;
2660 }
2661
2662 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass *iface,
2663         D3D10_STATE_BLOCK_MASK *mask)
2664 {
2665     FIXME("iface %p, mask %p stub!\n", iface, mask);
2666
2667     return E_NOTIMPL;
2668 }
2669
2670 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl =
2671 {
2672     /* ID3D10EffectPass methods */
2673     d3d10_effect_pass_IsValid,
2674     d3d10_effect_pass_GetDesc,
2675     d3d10_effect_pass_GetVertexShaderDesc,
2676     d3d10_effect_pass_GetGeometryShaderDesc,
2677     d3d10_effect_pass_GetPixelShaderDesc,
2678     d3d10_effect_pass_GetAnnotationByIndex,
2679     d3d10_effect_pass_GetAnnotationByName,
2680     d3d10_effect_pass_Apply,
2681     d3d10_effect_pass_ComputeStateBlockMask,
2682 };
2683
2684 /* ID3D10EffectVariable methods */
2685
2686 static BOOL STDMETHODCALLTYPE d3d10_effect_variable_IsValid(ID3D10EffectVariable *iface)
2687 {
2688     TRACE("iface %p\n", iface);
2689
2690     return (struct d3d10_effect_variable *)iface != &null_variable;
2691 }
2692
2693 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_variable_GetType(ID3D10EffectVariable *iface)
2694 {
2695     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2696
2697     TRACE("iface %p\n", iface);
2698
2699     return &This->type->ID3D10EffectType_iface;
2700 }
2701
2702 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetDesc(ID3D10EffectVariable *iface,
2703         D3D10_EFFECT_VARIABLE_DESC *desc)
2704 {
2705     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2706
2707     TRACE("iface %p, desc %p\n", iface, desc);
2708
2709     if (!iface->lpVtbl->IsValid(iface))
2710     {
2711         WARN("Null variable specified\n");
2712         return E_FAIL;
2713     }
2714
2715     if (!desc)
2716     {
2717         WARN("Invalid argument specified\n");
2718         return E_INVALIDARG;
2719     }
2720
2721     /* FIXME: This isn't correct. Anonymous shaders let desc->ExplicitBindPoint untouched, but normal shaders set it! */
2722     memset(desc, 0, sizeof(*desc));
2723     desc->Name = This->name;
2724     desc->Semantic = This->semantic;
2725     desc->Flags = This->flag;
2726     desc->Annotations = This->annotation_count;
2727     desc->BufferOffset = This->buffer_offset;
2728
2729     if (This->flag & D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
2730     {
2731         desc->ExplicitBindPoint = This->buffer_offset;
2732     }
2733
2734     return S_OK;
2735 }
2736
2737 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByIndex(
2738         ID3D10EffectVariable *iface, UINT index)
2739 {
2740     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2741     struct d3d10_effect_variable *a;
2742
2743     TRACE("iface %p, index %u\n", iface, index);
2744
2745     if (index >= This->annotation_count)
2746     {
2747         WARN("Invalid index specified\n");
2748         return (ID3D10EffectVariable *)&null_variable;
2749     }
2750
2751     a = &This->annotations[index];
2752
2753     TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
2754
2755     return (ID3D10EffectVariable *)a;
2756 }
2757
2758 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByName(
2759         ID3D10EffectVariable *iface, LPCSTR name)
2760 {
2761     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2762     unsigned int i;
2763
2764     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2765
2766     for (i = 0; i < This->annotation_count; ++i)
2767     {
2768         struct d3d10_effect_variable *a = &This->annotations[i];
2769         if (!strcmp(a->name, name))
2770         {
2771             TRACE("Returning annotation %p\n", a);
2772             return (ID3D10EffectVariable *)a;
2773         }
2774     }
2775
2776     WARN("Invalid name specified\n");
2777
2778     return (ID3D10EffectVariable *)&null_variable;
2779 }
2780
2781 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByIndex(
2782         ID3D10EffectVariable *iface, UINT index)
2783 {
2784     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2785     struct d3d10_effect_variable *m;
2786
2787     TRACE("iface %p, index %u\n", iface, index);
2788
2789     if (index >= This->type->member_count)
2790     {
2791         WARN("Invalid index specified\n");
2792         return (ID3D10EffectVariable *)&null_variable;
2793     }
2794
2795     m = &This->members[index];
2796
2797     TRACE("Returning member %p, %s\n", m, debugstr_a(m->name));
2798
2799     return (ID3D10EffectVariable *)m;
2800 }
2801
2802 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByName(
2803         ID3D10EffectVariable *iface, LPCSTR name)
2804 {
2805     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2806     unsigned int i;
2807
2808     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2809
2810     if (!name)
2811     {
2812         WARN("Invalid name specified\n");
2813         return (ID3D10EffectVariable *)&null_variable;
2814     }
2815
2816     for (i = 0; i < This->type->member_count; ++i)
2817     {
2818         struct d3d10_effect_variable *m = &This->members[i];
2819
2820         if (m->name)
2821         {
2822             if (!strcmp(m->name, name))
2823             {
2824                 TRACE("Returning member %p\n", m);
2825                 return (ID3D10EffectVariable *)m;
2826             }
2827         }
2828     }
2829
2830     WARN("Invalid name specified\n");
2831
2832     return (ID3D10EffectVariable *)&null_variable;
2833 }
2834
2835 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberBySemantic(
2836         ID3D10EffectVariable *iface, LPCSTR semantic)
2837 {
2838     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2839     unsigned int i;
2840
2841     TRACE("iface %p, semantic %s.\n", iface, debugstr_a(semantic));
2842
2843     if (!semantic)
2844     {
2845         WARN("Invalid semantic specified\n");
2846         return (ID3D10EffectVariable *)&null_variable;
2847     }
2848
2849     for (i = 0; i < This->type->member_count; ++i)
2850     {
2851         struct d3d10_effect_variable *m = &This->members[i];
2852
2853         if (m->semantic)
2854         {
2855             if (!strcmp(m->semantic, semantic))
2856             {
2857                 TRACE("Returning member %p\n", m);
2858                 return (ID3D10EffectVariable *)m;
2859             }
2860         }
2861     }
2862
2863     WARN("Invalid semantic specified\n");
2864
2865     return (ID3D10EffectVariable *)&null_variable;
2866 }
2867
2868 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetElement(
2869         ID3D10EffectVariable *iface, UINT index)
2870 {
2871     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2872     struct d3d10_effect_variable *v;
2873
2874     TRACE("iface %p, index %u\n", iface, index);
2875
2876     if (index >= This->type->element_count)
2877     {
2878         WARN("Invalid index specified\n");
2879         return (ID3D10EffectVariable *)&null_variable;
2880     }
2881
2882     v = &This->elements[index];
2883
2884     TRACE("Returning element %p, %s\n", v, debugstr_a(v->name));
2885
2886     return (ID3D10EffectVariable *)v;
2887 }
2888
2889 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_GetParentConstantBuffer(
2890         ID3D10EffectVariable *iface)
2891 {
2892     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2893
2894     TRACE("iface %p\n", iface);
2895
2896     return (ID3D10EffectConstantBuffer *)This->buffer;
2897 }
2898
2899 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsScalar(
2900         ID3D10EffectVariable *iface)
2901 {
2902     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2903
2904     TRACE("iface %p\n", iface);
2905
2906     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl)
2907         return (ID3D10EffectScalarVariable *)This;
2908
2909     return (ID3D10EffectScalarVariable *)&null_scalar_variable;
2910 }
2911
2912 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsVector(
2913         ID3D10EffectVariable *iface)
2914 {
2915     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2916
2917     TRACE("iface %p\n", iface);
2918
2919     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl)
2920         return (ID3D10EffectVectorVariable *)This;
2921
2922     return (ID3D10EffectVectorVariable *)&null_vector_variable;
2923 }
2924
2925 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsMatrix(
2926         ID3D10EffectVariable *iface)
2927 {
2928     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2929
2930     TRACE("iface %p\n", iface);
2931
2932     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl)
2933         return (ID3D10EffectMatrixVariable *)This;
2934
2935     return (ID3D10EffectMatrixVariable *)&null_matrix_variable;
2936 }
2937
2938 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsString(
2939         ID3D10EffectVariable *iface)
2940 {
2941     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2942
2943     TRACE("iface %p\n", iface);
2944
2945     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl)
2946         return (ID3D10EffectStringVariable *)This;
2947
2948     return (ID3D10EffectStringVariable *)&null_string_variable;
2949 }
2950
2951 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShaderResource(
2952         ID3D10EffectVariable *iface)
2953 {
2954     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2955
2956     TRACE("iface %p\n", iface);
2957
2958     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl)
2959         return (ID3D10EffectShaderResourceVariable *)This;
2960
2961     return (ID3D10EffectShaderResourceVariable *)&null_shader_resource_variable;
2962 }
2963
2964 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRenderTargetView(
2965         ID3D10EffectVariable *iface)
2966 {
2967     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2968
2969     TRACE("iface %p\n", iface);
2970
2971     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl)
2972         return (ID3D10EffectRenderTargetViewVariable *)This;
2973
2974     return (ID3D10EffectRenderTargetViewVariable *)&null_render_target_view_variable;
2975 }
2976
2977 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencilView(
2978         ID3D10EffectVariable *iface)
2979 {
2980     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2981
2982     TRACE("iface %p\n", iface);
2983
2984     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl)
2985         return (ID3D10EffectDepthStencilViewVariable *)This;
2986
2987     return (ID3D10EffectDepthStencilViewVariable *)&null_depth_stencil_view_variable;
2988 }
2989
2990 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_AsConstantBuffer(
2991         ID3D10EffectVariable *iface)
2992 {
2993     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
2994
2995     TRACE("iface %p\n", iface);
2996
2997     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl)
2998         return (ID3D10EffectConstantBuffer *)This;
2999
3000     return (ID3D10EffectConstantBuffer *)&null_local_buffer;
3001 }
3002
3003 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShader(
3004         ID3D10EffectVariable *iface)
3005 {
3006     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
3007
3008     TRACE("iface %p\n", iface);
3009
3010     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl)
3011         return (ID3D10EffectShaderVariable *)This;
3012
3013     return (ID3D10EffectShaderVariable *)&null_shader_variable;
3014 }
3015
3016 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsBlend(ID3D10EffectVariable *iface)
3017 {
3018     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
3019
3020     TRACE("iface %p\n", iface);
3021
3022     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl)
3023         return (ID3D10EffectBlendVariable *)This;
3024
3025     return (ID3D10EffectBlendVariable *)&null_blend_variable;
3026 }
3027
3028 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencil(
3029         ID3D10EffectVariable *iface)
3030 {
3031     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
3032
3033     TRACE("iface %p\n", iface);
3034
3035     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl)
3036         return (ID3D10EffectDepthStencilVariable *)This;
3037
3038     return (ID3D10EffectDepthStencilVariable *)&null_depth_stencil_variable;
3039 }
3040
3041 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRasterizer(
3042         ID3D10EffectVariable *iface)
3043 {
3044     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
3045
3046     TRACE("iface %p\n", iface);
3047
3048     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl)
3049         return (ID3D10EffectRasterizerVariable *)This;
3050
3051     return (ID3D10EffectRasterizerVariable *)&null_rasterizer_variable;
3052 }
3053
3054 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsSampler(
3055         ID3D10EffectVariable *iface)
3056 {
3057     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
3058
3059     TRACE("iface %p\n", iface);
3060
3061     if (This->vtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl)
3062         return (ID3D10EffectSamplerVariable *)This;
3063
3064     return (ID3D10EffectSamplerVariable *)&null_sampler_variable;
3065 }
3066
3067 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_SetRawValue(ID3D10EffectVariable *iface,
3068         void *data, UINT offset, UINT count)
3069 {
3070     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
3071
3072     return E_NOTIMPL;
3073 }
3074
3075 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetRawValue(ID3D10EffectVariable *iface,
3076         void *data, UINT offset, UINT count)
3077 {
3078     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
3079
3080     return E_NOTIMPL;
3081 }
3082
3083 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl =
3084 {
3085     /* ID3D10EffectVariable methods */
3086     d3d10_effect_variable_IsValid,
3087     d3d10_effect_variable_GetType,
3088     d3d10_effect_variable_GetDesc,
3089     d3d10_effect_variable_GetAnnotationByIndex,
3090     d3d10_effect_variable_GetAnnotationByName,
3091     d3d10_effect_variable_GetMemberByIndex,
3092     d3d10_effect_variable_GetMemberByName,
3093     d3d10_effect_variable_GetMemberBySemantic,
3094     d3d10_effect_variable_GetElement,
3095     d3d10_effect_variable_GetParentConstantBuffer,
3096     d3d10_effect_variable_AsScalar,
3097     d3d10_effect_variable_AsVector,
3098     d3d10_effect_variable_AsMatrix,
3099     d3d10_effect_variable_AsString,
3100     d3d10_effect_variable_AsShaderResource,
3101     d3d10_effect_variable_AsRenderTargetView,
3102     d3d10_effect_variable_AsDepthStencilView,
3103     d3d10_effect_variable_AsConstantBuffer,
3104     d3d10_effect_variable_AsShader,
3105     d3d10_effect_variable_AsBlend,
3106     d3d10_effect_variable_AsDepthStencil,
3107     d3d10_effect_variable_AsRasterizer,
3108     d3d10_effect_variable_AsSampler,
3109     d3d10_effect_variable_SetRawValue,
3110     d3d10_effect_variable_GetRawValue,
3111 };
3112
3113 /* ID3D10EffectVariable methods */
3114 static BOOL STDMETHODCALLTYPE d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer *iface)
3115 {
3116     TRACE("iface %p\n", iface);
3117
3118     return (struct d3d10_effect_variable *)iface != &null_local_buffer;
3119 }
3120
3121 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer *iface)
3122 {
3123     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
3124 }
3125
3126 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer *iface,
3127         D3D10_EFFECT_VARIABLE_DESC *desc)
3128 {
3129     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
3130 }
3131
3132 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByIndex(
3133         ID3D10EffectConstantBuffer *iface, UINT index)
3134 {
3135     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
3136 }
3137
3138 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByName(
3139         ID3D10EffectConstantBuffer *iface, LPCSTR name)
3140 {
3141     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
3142 }
3143
3144 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByIndex(
3145         ID3D10EffectConstantBuffer *iface, UINT index)
3146 {
3147     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
3148 }
3149
3150 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByName(
3151         ID3D10EffectConstantBuffer *iface, LPCSTR name)
3152 {
3153     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
3154 }
3155
3156 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberBySemantic(
3157         ID3D10EffectConstantBuffer *iface, LPCSTR semantic)
3158 {
3159     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
3160 }
3161
3162 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetElement(
3163         ID3D10EffectConstantBuffer *iface, UINT index)
3164 {
3165     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
3166 }
3167
3168 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetParentConstantBuffer(
3169         ID3D10EffectConstantBuffer *iface)
3170 {
3171     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
3172 }
3173
3174 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsScalar(
3175         ID3D10EffectConstantBuffer *iface)
3176 {
3177     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
3178 }
3179
3180 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsVector(
3181         ID3D10EffectConstantBuffer *iface)
3182 {
3183     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
3184 }
3185
3186 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsMatrix(
3187         ID3D10EffectConstantBuffer *iface)
3188 {
3189     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
3190 }
3191
3192 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsString(
3193         ID3D10EffectConstantBuffer *iface)
3194 {
3195     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
3196 }
3197
3198 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShaderResource(
3199         ID3D10EffectConstantBuffer *iface)
3200 {
3201     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
3202 }
3203
3204 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRenderTargetView(
3205         ID3D10EffectConstantBuffer *iface)
3206 {
3207     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
3208 }
3209
3210 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencilView(
3211         ID3D10EffectConstantBuffer *iface)
3212 {
3213     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
3214 }
3215
3216 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsConstantBuffer(
3217         ID3D10EffectConstantBuffer *iface)
3218 {
3219     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
3220 }
3221
3222 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShader(
3223         ID3D10EffectConstantBuffer *iface)
3224 {
3225     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
3226 }
3227
3228 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer *iface)
3229 {
3230     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
3231 }
3232
3233 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencil(
3234         ID3D10EffectConstantBuffer *iface)
3235 {
3236     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
3237 }
3238
3239 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRasterizer(
3240         ID3D10EffectConstantBuffer *iface)
3241 {
3242     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
3243 }
3244
3245 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsSampler(
3246         ID3D10EffectConstantBuffer *iface)
3247 {
3248     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
3249 }
3250
3251 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer *iface,
3252         void *data, UINT offset, UINT count)
3253 {
3254     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3255 }
3256
3257 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer *iface,
3258         void *data, UINT offset, UINT count)
3259 {
3260     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3261 }
3262
3263 /* ID3D10EffectConstantBuffer methods */
3264 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer *iface,
3265         ID3D10Buffer *buffer)
3266 {
3267     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
3268
3269     return E_NOTIMPL;
3270 }
3271
3272 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer *iface,
3273         ID3D10Buffer **buffer)
3274 {
3275     FIXME("iface %p, buffer %p stub!\n", iface, buffer);
3276
3277     return E_NOTIMPL;
3278 }
3279
3280 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer *iface,
3281         ID3D10ShaderResourceView *view)
3282 {
3283     FIXME("iface %p, view %p stub!\n", iface, view);
3284
3285     return E_NOTIMPL;
3286 }
3287
3288 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer *iface,
3289         ID3D10ShaderResourceView **view)
3290 {
3291     FIXME("iface %p, view %p stub!\n", iface, view);
3292
3293     return E_NOTIMPL;
3294 }
3295
3296 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl =
3297 {
3298     /* ID3D10EffectVariable methods */
3299     d3d10_effect_constant_buffer_IsValid,
3300     d3d10_effect_constant_buffer_GetType,
3301     d3d10_effect_constant_buffer_GetDesc,
3302     d3d10_effect_constant_buffer_GetAnnotationByIndex,
3303     d3d10_effect_constant_buffer_GetAnnotationByName,
3304     d3d10_effect_constant_buffer_GetMemberByIndex,
3305     d3d10_effect_constant_buffer_GetMemberByName,
3306     d3d10_effect_constant_buffer_GetMemberBySemantic,
3307     d3d10_effect_constant_buffer_GetElement,
3308     d3d10_effect_constant_buffer_GetParentConstantBuffer,
3309     d3d10_effect_constant_buffer_AsScalar,
3310     d3d10_effect_constant_buffer_AsVector,
3311     d3d10_effect_constant_buffer_AsMatrix,
3312     d3d10_effect_constant_buffer_AsString,
3313     d3d10_effect_constant_buffer_AsShaderResource,
3314     d3d10_effect_constant_buffer_AsRenderTargetView,
3315     d3d10_effect_constant_buffer_AsDepthStencilView,
3316     d3d10_effect_constant_buffer_AsConstantBuffer,
3317     d3d10_effect_constant_buffer_AsShader,
3318     d3d10_effect_constant_buffer_AsBlend,
3319     d3d10_effect_constant_buffer_AsDepthStencil,
3320     d3d10_effect_constant_buffer_AsRasterizer,
3321     d3d10_effect_constant_buffer_AsSampler,
3322     d3d10_effect_constant_buffer_SetRawValue,
3323     d3d10_effect_constant_buffer_GetRawValue,
3324     /* ID3D10EffectConstantBuffer methods */
3325     d3d10_effect_constant_buffer_SetConstantBuffer,
3326     d3d10_effect_constant_buffer_GetConstantBuffer,
3327     d3d10_effect_constant_buffer_SetTextureBuffer,
3328     d3d10_effect_constant_buffer_GetTextureBuffer,
3329 };
3330
3331 /* ID3D10EffectVariable methods */
3332
3333 static BOOL STDMETHODCALLTYPE d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable *iface)
3334 {
3335     TRACE("iface %p\n", iface);
3336
3337     return (struct d3d10_effect_variable *)iface != &null_scalar_variable;
3338 }
3339
3340 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetType(
3341         ID3D10EffectScalarVariable *iface)
3342 {
3343     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
3344 }
3345
3346 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetDesc(ID3D10EffectScalarVariable *iface,
3347         D3D10_EFFECT_VARIABLE_DESC *desc)
3348 {
3349     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
3350 }
3351
3352 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByIndex(
3353         ID3D10EffectScalarVariable *iface, UINT index)
3354 {
3355     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
3356 }
3357
3358 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByName(
3359         ID3D10EffectScalarVariable *iface, LPCSTR name)
3360 {
3361     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
3362 }
3363
3364 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByIndex(
3365         ID3D10EffectScalarVariable *iface, UINT index)
3366 {
3367     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
3368 }
3369
3370 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByName(
3371         ID3D10EffectScalarVariable *iface, LPCSTR name)
3372 {
3373     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
3374 }
3375
3376 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberBySemantic(
3377         ID3D10EffectScalarVariable *iface, LPCSTR semantic)
3378 {
3379     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
3380 }
3381
3382 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetElement(
3383         ID3D10EffectScalarVariable *iface, UINT index)
3384 {
3385     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
3386 }
3387
3388 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetParentConstantBuffer(
3389         ID3D10EffectScalarVariable *iface)
3390 {
3391     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
3392 }
3393
3394 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsScalar(
3395         ID3D10EffectScalarVariable *iface)
3396 {
3397     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
3398 }
3399
3400 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsVector(
3401         ID3D10EffectScalarVariable *iface)
3402 {
3403     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
3404 }
3405
3406 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsMatrix(
3407         ID3D10EffectScalarVariable *iface)
3408 {
3409     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
3410 }
3411
3412 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsString(
3413         ID3D10EffectScalarVariable *iface)
3414 {
3415     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
3416 }
3417
3418 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShaderResource(
3419         ID3D10EffectScalarVariable *iface)
3420 {
3421     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
3422 }
3423
3424 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRenderTargetView(
3425         ID3D10EffectScalarVariable *iface)
3426 {
3427     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
3428 }
3429
3430 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencilView(
3431         ID3D10EffectScalarVariable *iface)
3432 {
3433     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
3434 }
3435
3436 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsConstantBuffer(
3437         ID3D10EffectScalarVariable *iface)
3438 {
3439     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
3440 }
3441
3442 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShader(
3443         ID3D10EffectScalarVariable *iface)
3444 {
3445     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
3446 }
3447
3448 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsBlend(
3449         ID3D10EffectScalarVariable *iface)
3450 {
3451     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
3452 }
3453
3454 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencil(
3455         ID3D10EffectScalarVariable *iface)
3456 {
3457     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
3458 }
3459
3460 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRasterizer(
3461         ID3D10EffectScalarVariable *iface)
3462 {
3463     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
3464 }
3465
3466 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsSampler(
3467         ID3D10EffectScalarVariable *iface)
3468 {
3469     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
3470 }
3471
3472 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetRawValue(ID3D10EffectScalarVariable *iface,
3473         void *data, UINT offset, UINT count)
3474 {
3475     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3476 }
3477
3478 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetRawValue(ID3D10EffectScalarVariable *iface,
3479         void *data, UINT offset, UINT count)
3480 {
3481     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3482 }
3483
3484 /* ID3D10EffectScalarVariable methods */
3485
3486 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable *iface,
3487         float value)
3488 {
3489     FIXME("iface %p, value %.8e stub!\n", iface, value);
3490
3491     return E_NOTIMPL;
3492 }
3493
3494 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable *iface,
3495         float *value)
3496 {
3497     FIXME("iface %p, value %p stub!\n", iface, value);
3498
3499     return E_NOTIMPL;
3500 }
3501
3502 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable *iface,
3503         float *values, UINT offset, UINT count)
3504 {
3505     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3506
3507     return E_NOTIMPL;
3508 }
3509
3510 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable *iface,
3511         float *values, UINT offset, UINT count)
3512 {
3513     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3514
3515     return E_NOTIMPL;
3516 }
3517
3518 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable *iface,
3519         int value)
3520 {
3521     FIXME("iface %p, value %d stub!\n", iface, value);
3522
3523     return E_NOTIMPL;
3524 }
3525
3526 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable *iface,
3527         int *value)
3528 {
3529     FIXME("iface %p, value %p stub!\n", iface, value);
3530
3531     return E_NOTIMPL;
3532 }
3533
3534 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable *iface,
3535         int *values, UINT offset, UINT count)
3536 {
3537     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3538
3539     return E_NOTIMPL;
3540 }
3541
3542 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable *iface,
3543         int *values, UINT offset, UINT count)
3544 {
3545     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3546
3547     return E_NOTIMPL;
3548 }
3549
3550 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable *iface,
3551         BOOL value)
3552 {
3553     FIXME("iface %p, value %d stub!\n", iface, value);
3554
3555     return E_NOTIMPL;
3556 }
3557
3558 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable *iface,
3559         BOOL *value)
3560 {
3561     FIXME("iface %p, value %p stub!\n", iface, value);
3562
3563     return E_NOTIMPL;
3564 }
3565
3566 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable *iface,
3567         BOOL *values, UINT offset, UINT count)
3568 {
3569     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3570
3571     return E_NOTIMPL;
3572 }
3573
3574 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable *iface,
3575         BOOL *values, UINT offset, UINT count)
3576 {
3577     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3578
3579     return E_NOTIMPL;
3580 }
3581
3582 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl =
3583 {
3584     /* ID3D10EffectVariable methods */
3585     d3d10_effect_scalar_variable_IsValid,
3586     d3d10_effect_scalar_variable_GetType,
3587     d3d10_effect_scalar_variable_GetDesc,
3588     d3d10_effect_scalar_variable_GetAnnotationByIndex,
3589     d3d10_effect_scalar_variable_GetAnnotationByName,
3590     d3d10_effect_scalar_variable_GetMemberByIndex,
3591     d3d10_effect_scalar_variable_GetMemberByName,
3592     d3d10_effect_scalar_variable_GetMemberBySemantic,
3593     d3d10_effect_scalar_variable_GetElement,
3594     d3d10_effect_scalar_variable_GetParentConstantBuffer,
3595     d3d10_effect_scalar_variable_AsScalar,
3596     d3d10_effect_scalar_variable_AsVector,
3597     d3d10_effect_scalar_variable_AsMatrix,
3598     d3d10_effect_scalar_variable_AsString,
3599     d3d10_effect_scalar_variable_AsShaderResource,
3600     d3d10_effect_scalar_variable_AsRenderTargetView,
3601     d3d10_effect_scalar_variable_AsDepthStencilView,
3602     d3d10_effect_scalar_variable_AsConstantBuffer,
3603     d3d10_effect_scalar_variable_AsShader,
3604     d3d10_effect_scalar_variable_AsBlend,
3605     d3d10_effect_scalar_variable_AsDepthStencil,
3606     d3d10_effect_scalar_variable_AsRasterizer,
3607     d3d10_effect_scalar_variable_AsSampler,
3608     d3d10_effect_scalar_variable_SetRawValue,
3609     d3d10_effect_scalar_variable_GetRawValue,
3610     /* ID3D10EffectScalarVariable methods */
3611     d3d10_effect_scalar_variable_SetFloat,
3612     d3d10_effect_scalar_variable_GetFloat,
3613     d3d10_effect_scalar_variable_SetFloatArray,
3614     d3d10_effect_scalar_variable_GetFloatArray,
3615     d3d10_effect_scalar_variable_SetInt,
3616     d3d10_effect_scalar_variable_GetInt,
3617     d3d10_effect_scalar_variable_SetIntArray,
3618     d3d10_effect_scalar_variable_GetIntArray,
3619     d3d10_effect_scalar_variable_SetBool,
3620     d3d10_effect_scalar_variable_GetBool,
3621     d3d10_effect_scalar_variable_SetBoolArray,
3622     d3d10_effect_scalar_variable_GetBoolArray,
3623 };
3624
3625 /* ID3D10EffectVariable methods */
3626
3627 static BOOL STDMETHODCALLTYPE d3d10_effect_vector_variable_IsValid(ID3D10EffectVectorVariable *iface)
3628 {
3629     TRACE("iface %p\n", iface);
3630
3631     return (struct d3d10_effect_variable *)iface != &null_vector_variable;
3632 }
3633
3634 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetType(
3635         ID3D10EffectVectorVariable *iface)
3636 {
3637     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
3638 }
3639
3640 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetDesc(ID3D10EffectVectorVariable *iface,
3641         D3D10_EFFECT_VARIABLE_DESC *desc)
3642 {
3643     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
3644 }
3645
3646 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByIndex(
3647         ID3D10EffectVectorVariable *iface, UINT index)
3648 {
3649     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
3650 }
3651
3652 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByName(
3653         ID3D10EffectVectorVariable *iface, LPCSTR name)
3654 {
3655     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
3656 }
3657
3658 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByIndex(
3659         ID3D10EffectVectorVariable *iface, UINT index)
3660 {
3661     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
3662 }
3663
3664 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByName(
3665         ID3D10EffectVectorVariable *iface, LPCSTR name)
3666 {
3667     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
3668 }
3669
3670 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberBySemantic(
3671         ID3D10EffectVectorVariable *iface, LPCSTR semantic)
3672 {
3673     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
3674 }
3675
3676 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetElement(
3677         ID3D10EffectVectorVariable *iface, UINT index)
3678 {
3679     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
3680 }
3681
3682 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetParentConstantBuffer(
3683         ID3D10EffectVectorVariable *iface)
3684 {
3685     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
3686 }
3687
3688 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsScalar(
3689         ID3D10EffectVectorVariable *iface)
3690 {
3691     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
3692 }
3693
3694 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsVector(
3695         ID3D10EffectVectorVariable *iface)
3696 {
3697     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
3698 }
3699
3700 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsMatrix(
3701         ID3D10EffectVectorVariable *iface)
3702 {
3703     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
3704 }
3705
3706 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsString(
3707         ID3D10EffectVectorVariable *iface)
3708 {
3709     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
3710 }
3711
3712 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShaderResource(
3713         ID3D10EffectVectorVariable *iface)
3714 {
3715     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
3716 }
3717
3718 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRenderTargetView(
3719         ID3D10EffectVectorVariable *iface)
3720 {
3721     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
3722 }
3723
3724 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencilView(
3725         ID3D10EffectVectorVariable *iface)
3726 {
3727     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
3728 }
3729
3730 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsConstantBuffer(
3731         ID3D10EffectVectorVariable *iface)
3732 {
3733     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
3734 }
3735
3736 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShader(
3737         ID3D10EffectVectorVariable *iface)
3738 {
3739     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
3740 }
3741
3742 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsBlend(
3743         ID3D10EffectVectorVariable *iface)
3744 {
3745     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
3746 }
3747
3748 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencil(
3749         ID3D10EffectVectorVariable *iface)
3750 {
3751     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
3752 }
3753
3754 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRasterizer(
3755         ID3D10EffectVectorVariable *iface)
3756 {
3757     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
3758 }
3759
3760 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsSampler(
3761         ID3D10EffectVectorVariable *iface)
3762 {
3763     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
3764 }
3765
3766 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetRawValue(ID3D10EffectVectorVariable *iface,
3767         void *data, UINT offset, UINT count)
3768 {
3769     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3770 }
3771
3772 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetRawValue(ID3D10EffectVectorVariable *iface,
3773         void *data, UINT offset, UINT count)
3774 {
3775     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3776 }
3777
3778 /* ID3D10EffectVectorVariable methods */
3779
3780 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVector(ID3D10EffectVectorVariable *iface,
3781         BOOL *value)
3782 {
3783     FIXME("iface %p, value %p stub!\n", iface, value);
3784
3785     return E_NOTIMPL;
3786 }
3787
3788 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVector(ID3D10EffectVectorVariable *iface,
3789         int *value)
3790 {
3791     FIXME("iface %p, value %p stub!\n", iface, value);
3792
3793     return E_NOTIMPL;
3794 }
3795
3796 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVector(ID3D10EffectVectorVariable *iface,
3797         float *value)
3798 {
3799     FIXME("iface %p, value %p stub!\n", iface, value);
3800
3801     return E_NOTIMPL;
3802 }
3803
3804 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVector(ID3D10EffectVectorVariable *iface,
3805         BOOL *value)
3806 {
3807     FIXME("iface %p, value %p stub!\n", iface, value);
3808
3809     return E_NOTIMPL;
3810 }
3811
3812 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVector(ID3D10EffectVectorVariable *iface,
3813         int *value)
3814 {
3815     FIXME("iface %p, value %p stub!\n", iface, value);
3816
3817     return E_NOTIMPL;
3818 }
3819
3820 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVector(ID3D10EffectVectorVariable *iface,
3821         float *value)
3822 {
3823     FIXME("iface %p, value %p stub!\n", iface, value);
3824
3825     return E_NOTIMPL;
3826 }
3827
3828 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVectorArray(ID3D10EffectVectorVariable *iface,
3829         BOOL *values, UINT offset, UINT count)
3830 {
3831     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3832
3833     return E_NOTIMPL;
3834 }
3835
3836 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVectorArray(ID3D10EffectVectorVariable *iface,
3837         int *values, UINT offset, UINT count)
3838 {
3839     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3840
3841     return E_NOTIMPL;
3842 }
3843
3844 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVectorArray(ID3D10EffectVectorVariable *iface,
3845         float *values, UINT offset, UINT count)
3846 {
3847     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3848
3849     return E_NOTIMPL;
3850 }
3851
3852 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVectorArray(ID3D10EffectVectorVariable *iface,
3853         BOOL *values, UINT offset, UINT count)
3854 {
3855     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3856
3857     return E_NOTIMPL;
3858 }
3859
3860 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVectorArray(ID3D10EffectVectorVariable *iface,
3861         int *values, UINT offset, UINT count)
3862 {
3863     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3864
3865     return E_NOTIMPL;
3866 }
3867
3868 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVectorArray(ID3D10EffectVectorVariable *iface,
3869         float *values, UINT offset, UINT count)
3870 {
3871     FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
3872
3873     return E_NOTIMPL;
3874 }
3875
3876 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl =
3877 {
3878     /* ID3D10EffectVariable methods */
3879     d3d10_effect_vector_variable_IsValid,
3880     d3d10_effect_vector_variable_GetType,
3881     d3d10_effect_vector_variable_GetDesc,
3882     d3d10_effect_vector_variable_GetAnnotationByIndex,
3883     d3d10_effect_vector_variable_GetAnnotationByName,
3884     d3d10_effect_vector_variable_GetMemberByIndex,
3885     d3d10_effect_vector_variable_GetMemberByName,
3886     d3d10_effect_vector_variable_GetMemberBySemantic,
3887     d3d10_effect_vector_variable_GetElement,
3888     d3d10_effect_vector_variable_GetParentConstantBuffer,
3889     d3d10_effect_vector_variable_AsScalar,
3890     d3d10_effect_vector_variable_AsVector,
3891     d3d10_effect_vector_variable_AsMatrix,
3892     d3d10_effect_vector_variable_AsString,
3893     d3d10_effect_vector_variable_AsShaderResource,
3894     d3d10_effect_vector_variable_AsRenderTargetView,
3895     d3d10_effect_vector_variable_AsDepthStencilView,
3896     d3d10_effect_vector_variable_AsConstantBuffer,
3897     d3d10_effect_vector_variable_AsShader,
3898     d3d10_effect_vector_variable_AsBlend,
3899     d3d10_effect_vector_variable_AsDepthStencil,
3900     d3d10_effect_vector_variable_AsRasterizer,
3901     d3d10_effect_vector_variable_AsSampler,
3902     d3d10_effect_vector_variable_SetRawValue,
3903     d3d10_effect_vector_variable_GetRawValue,
3904     /* ID3D10EffectVectorVariable methods */
3905     d3d10_effect_vector_variable_SetBoolVector,
3906     d3d10_effect_vector_variable_SetIntVector,
3907     d3d10_effect_vector_variable_SetFloatVector,
3908     d3d10_effect_vector_variable_GetBoolVector,
3909     d3d10_effect_vector_variable_GetIntVector,
3910     d3d10_effect_vector_variable_GetFloatVector,
3911     d3d10_effect_vector_variable_SetBoolVectorArray,
3912     d3d10_effect_vector_variable_SetIntVectorArray,
3913     d3d10_effect_vector_variable_SetFloatVectorArray,
3914     d3d10_effect_vector_variable_GetBoolVectorArray,
3915     d3d10_effect_vector_variable_GetIntVectorArray,
3916     d3d10_effect_vector_variable_GetFloatVectorArray,
3917 };
3918
3919 /* ID3D10EffectVariable methods */
3920
3921 static BOOL STDMETHODCALLTYPE d3d10_effect_matrix_variable_IsValid(ID3D10EffectMatrixVariable *iface)
3922 {
3923     TRACE("iface %p\n", iface);
3924
3925     return (struct d3d10_effect_variable *)iface != &null_matrix_variable;
3926 }
3927
3928 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetType(
3929         ID3D10EffectMatrixVariable *iface)
3930 {
3931     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
3932 }
3933
3934 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetDesc(ID3D10EffectMatrixVariable *iface,
3935         D3D10_EFFECT_VARIABLE_DESC *desc)
3936 {
3937     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
3938 }
3939
3940 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByIndex(
3941         ID3D10EffectMatrixVariable *iface, UINT index)
3942 {
3943     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
3944 }
3945
3946 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByName(
3947         ID3D10EffectMatrixVariable *iface, LPCSTR name)
3948 {
3949     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
3950 }
3951
3952 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByIndex(
3953         ID3D10EffectMatrixVariable *iface, UINT index)
3954 {
3955     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
3956 }
3957
3958 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByName(
3959         ID3D10EffectMatrixVariable *iface, LPCSTR name)
3960 {
3961     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
3962 }
3963
3964 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberBySemantic(
3965         ID3D10EffectMatrixVariable *iface, LPCSTR semantic)
3966 {
3967     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
3968 }
3969
3970 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetElement(
3971         ID3D10EffectMatrixVariable *iface, UINT index)
3972 {
3973     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
3974 }
3975
3976 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetParentConstantBuffer(
3977         ID3D10EffectMatrixVariable *iface)
3978 {
3979     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
3980 }
3981
3982 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsScalar(
3983         ID3D10EffectMatrixVariable *iface)
3984 {
3985     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
3986 }
3987
3988 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsVector(
3989         ID3D10EffectMatrixVariable *iface)
3990 {
3991     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
3992 }
3993
3994 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsMatrix(
3995         ID3D10EffectMatrixVariable *iface)
3996 {
3997     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
3998 }
3999
4000 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsString(
4001         ID3D10EffectMatrixVariable *iface)
4002 {
4003     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4004 }
4005
4006 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShaderResource(
4007         ID3D10EffectMatrixVariable *iface)
4008 {
4009     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4010 }
4011
4012 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRenderTargetView(
4013         ID3D10EffectMatrixVariable *iface)
4014 {
4015     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4016 }
4017
4018 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencilView(
4019         ID3D10EffectMatrixVariable *iface)
4020 {
4021     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4022 }
4023
4024 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsConstantBuffer(
4025         ID3D10EffectMatrixVariable *iface)
4026 {
4027     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4028 }
4029
4030 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShader(
4031         ID3D10EffectMatrixVariable *iface)
4032 {
4033     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4034 }
4035
4036 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsBlend(
4037         ID3D10EffectMatrixVariable *iface)
4038 {
4039     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4040 }
4041
4042 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencil(
4043         ID3D10EffectMatrixVariable *iface)
4044 {
4045     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4046 }
4047
4048 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRasterizer(
4049         ID3D10EffectMatrixVariable *iface)
4050 {
4051     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4052 }
4053
4054 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsSampler(
4055         ID3D10EffectMatrixVariable *iface)
4056 {
4057     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4058 }
4059
4060 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetRawValue(ID3D10EffectMatrixVariable *iface,
4061         void *data, UINT offset, UINT count)
4062 {
4063     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4064 }
4065
4066 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetRawValue(ID3D10EffectMatrixVariable *iface,
4067         void *data, UINT offset, UINT count)
4068 {
4069     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4070 }
4071
4072 /* ID3D10EffectMatrixVariable methods */
4073
4074 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrix(ID3D10EffectMatrixVariable *iface,
4075         float *data)
4076 {
4077     FIXME("iface %p, data %p stub!\n", iface, data);
4078
4079     return E_NOTIMPL;
4080 }
4081
4082 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrix(ID3D10EffectMatrixVariable *iface,
4083         float *data)
4084 {
4085     FIXME("iface %p, data %p stub!\n", iface, data);
4086
4087     return E_NOTIMPL;
4088 }
4089
4090 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixArray(ID3D10EffectMatrixVariable *iface,
4091         float *data, UINT offset, UINT count)
4092 {
4093     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4094
4095     return E_NOTIMPL;
4096 }
4097
4098 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixArray(ID3D10EffectMatrixVariable *iface,
4099         float *data, UINT offset, UINT count)
4100 {
4101     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4102
4103     return E_NOTIMPL;
4104 }
4105
4106 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
4107         float *data)
4108 {
4109     FIXME("iface %p, data %p stub!\n", iface, data);
4110
4111     return E_NOTIMPL;
4112 }
4113
4114 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
4115         float *data)
4116 {
4117     FIXME("iface %p, data %p stub!\n", iface, data);
4118
4119     return E_NOTIMPL;
4120 }
4121
4122 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
4123         float *data, UINT offset, UINT count)
4124 {
4125     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4126
4127     return E_NOTIMPL;
4128 }
4129
4130 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
4131         float *data, UINT offset, UINT count)
4132 {
4133     FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4134
4135     return E_NOTIMPL;
4136 }
4137
4138
4139 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl =
4140 {
4141     /* ID3D10EffectVariable methods */
4142     d3d10_effect_matrix_variable_IsValid,
4143     d3d10_effect_matrix_variable_GetType,
4144     d3d10_effect_matrix_variable_GetDesc,
4145     d3d10_effect_matrix_variable_GetAnnotationByIndex,
4146     d3d10_effect_matrix_variable_GetAnnotationByName,
4147     d3d10_effect_matrix_variable_GetMemberByIndex,
4148     d3d10_effect_matrix_variable_GetMemberByName,
4149     d3d10_effect_matrix_variable_GetMemberBySemantic,
4150     d3d10_effect_matrix_variable_GetElement,
4151     d3d10_effect_matrix_variable_GetParentConstantBuffer,
4152     d3d10_effect_matrix_variable_AsScalar,
4153     d3d10_effect_matrix_variable_AsVector,
4154     d3d10_effect_matrix_variable_AsMatrix,
4155     d3d10_effect_matrix_variable_AsString,
4156     d3d10_effect_matrix_variable_AsShaderResource,
4157     d3d10_effect_matrix_variable_AsRenderTargetView,
4158     d3d10_effect_matrix_variable_AsDepthStencilView,
4159     d3d10_effect_matrix_variable_AsConstantBuffer,
4160     d3d10_effect_matrix_variable_AsShader,
4161     d3d10_effect_matrix_variable_AsBlend,
4162     d3d10_effect_matrix_variable_AsDepthStencil,
4163     d3d10_effect_matrix_variable_AsRasterizer,
4164     d3d10_effect_matrix_variable_AsSampler,
4165     d3d10_effect_matrix_variable_SetRawValue,
4166     d3d10_effect_matrix_variable_GetRawValue,
4167     /* ID3D10EffectMatrixVariable methods */
4168     d3d10_effect_matrix_variable_SetMatrix,
4169     d3d10_effect_matrix_variable_GetMatrix,
4170     d3d10_effect_matrix_variable_SetMatrixArray,
4171     d3d10_effect_matrix_variable_GetMatrixArray,
4172     d3d10_effect_matrix_variable_SetMatrixTranspose,
4173     d3d10_effect_matrix_variable_GetMatrixTranspose,
4174     d3d10_effect_matrix_variable_SetMatrixTransposeArray,
4175     d3d10_effect_matrix_variable_GetMatrixTransposeArray,
4176 };
4177
4178 /* ID3D10EffectVariable methods */
4179
4180 static BOOL STDMETHODCALLTYPE d3d10_effect_string_variable_IsValid(ID3D10EffectStringVariable *iface)
4181 {
4182     TRACE("iface %p\n", iface);
4183
4184     return (struct d3d10_effect_variable *)iface != &null_string_variable;
4185 }
4186
4187 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_string_variable_GetType(
4188         ID3D10EffectStringVariable *iface)
4189 {
4190     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4191 }
4192
4193 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetDesc(ID3D10EffectStringVariable *iface,
4194         D3D10_EFFECT_VARIABLE_DESC *desc)
4195 {
4196     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4197 }
4198
4199 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetAnnotationByIndex(
4200         ID3D10EffectStringVariable *iface, UINT index)
4201 {
4202     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4203 }
4204
4205 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetAnnotationByName(
4206         ID3D10EffectStringVariable *iface, LPCSTR name)
4207 {
4208     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4209 }
4210
4211 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberByIndex(
4212         ID3D10EffectStringVariable *iface, UINT index)
4213 {
4214     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4215 }
4216
4217 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberByName(
4218         ID3D10EffectStringVariable *iface, LPCSTR name)
4219 {
4220     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4221 }
4222
4223 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberBySemantic(
4224         ID3D10EffectStringVariable *iface, LPCSTR semantic)
4225 {
4226     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4227 }
4228
4229 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetElement(
4230         ID3D10EffectStringVariable *iface, UINT index)
4231 {
4232     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4233 }
4234
4235 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_string_variable_GetParentConstantBuffer(
4236         ID3D10EffectStringVariable *iface)
4237 {
4238     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4239 }
4240
4241 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsScalar(
4242         ID3D10EffectStringVariable *iface)
4243 {
4244     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4245 }
4246
4247 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsVector(
4248         ID3D10EffectStringVariable *iface)
4249 {
4250     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4251 }
4252
4253 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsMatrix(
4254         ID3D10EffectStringVariable *iface)
4255 {
4256     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4257 }
4258
4259 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsString(
4260         ID3D10EffectStringVariable *iface)
4261 {
4262     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4263 }
4264
4265 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsShaderResource(
4266         ID3D10EffectStringVariable *iface)
4267 {
4268     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4269 }
4270
4271 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsRenderTargetView(
4272         ID3D10EffectStringVariable *iface)
4273 {
4274     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4275 }
4276
4277 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsDepthStencilView(
4278         ID3D10EffectStringVariable *iface)
4279 {
4280     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4281 }
4282
4283 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_string_variable_AsConstantBuffer(
4284         ID3D10EffectStringVariable *iface)
4285 {
4286     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4287 }
4288
4289 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsShader(
4290         ID3D10EffectStringVariable *iface)
4291 {
4292     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4293 }
4294
4295 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsBlend(
4296         ID3D10EffectStringVariable *iface)
4297 {
4298     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4299 }
4300
4301 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsDepthStencil(
4302         ID3D10EffectStringVariable *iface)
4303 {
4304     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4305 }
4306
4307 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsRasterizer(
4308         ID3D10EffectStringVariable *iface)
4309 {
4310     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4311 }
4312
4313 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsSampler(
4314         ID3D10EffectStringVariable *iface)
4315 {
4316     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4317 }
4318
4319 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_SetRawValue(ID3D10EffectStringVariable *iface,
4320         void *data, UINT offset, UINT count)
4321 {
4322     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4323 }
4324
4325 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetRawValue(ID3D10EffectStringVariable *iface,
4326         void *data, UINT offset, UINT count)
4327 {
4328     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4329 }
4330
4331 /* ID3D10EffectStringVariable methods */
4332
4333 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetString(ID3D10EffectStringVariable *iface,
4334         LPCSTR *str)
4335 {
4336     FIXME("iface %p, str %p stub!\n", iface, str);
4337
4338     return E_NOTIMPL;
4339 }
4340
4341 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetStringArray(ID3D10EffectStringVariable *iface,
4342         LPCSTR *strs, UINT offset, UINT count)
4343 {
4344     FIXME("iface %p, strs %p, offset %u, count %u stub!\n", iface, strs, offset, count);
4345
4346     return E_NOTIMPL;
4347 }
4348
4349
4350 static const struct ID3D10EffectStringVariableVtbl d3d10_effect_string_variable_vtbl =
4351 {
4352     /* ID3D10EffectVariable methods */
4353     d3d10_effect_string_variable_IsValid,
4354     d3d10_effect_string_variable_GetType,
4355     d3d10_effect_string_variable_GetDesc,
4356     d3d10_effect_string_variable_GetAnnotationByIndex,
4357     d3d10_effect_string_variable_GetAnnotationByName,
4358     d3d10_effect_string_variable_GetMemberByIndex,
4359     d3d10_effect_string_variable_GetMemberByName,
4360     d3d10_effect_string_variable_GetMemberBySemantic,
4361     d3d10_effect_string_variable_GetElement,
4362     d3d10_effect_string_variable_GetParentConstantBuffer,
4363     d3d10_effect_string_variable_AsScalar,
4364     d3d10_effect_string_variable_AsVector,
4365     d3d10_effect_string_variable_AsMatrix,
4366     d3d10_effect_string_variable_AsString,
4367     d3d10_effect_string_variable_AsShaderResource,
4368     d3d10_effect_string_variable_AsRenderTargetView,
4369     d3d10_effect_string_variable_AsDepthStencilView,
4370     d3d10_effect_string_variable_AsConstantBuffer,
4371     d3d10_effect_string_variable_AsShader,
4372     d3d10_effect_string_variable_AsBlend,
4373     d3d10_effect_string_variable_AsDepthStencil,
4374     d3d10_effect_string_variable_AsRasterizer,
4375     d3d10_effect_string_variable_AsSampler,
4376     d3d10_effect_string_variable_SetRawValue,
4377     d3d10_effect_string_variable_GetRawValue,
4378     /* ID3D10EffectStringVariable methods */
4379     d3d10_effect_string_variable_GetString,
4380     d3d10_effect_string_variable_GetStringArray,
4381 };
4382
4383 /* ID3D10EffectVariable methods */
4384
4385 static BOOL STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_IsValid(ID3D10EffectShaderResourceVariable *iface)
4386 {
4387     TRACE("iface %p\n", iface);
4388
4389     return (struct d3d10_effect_variable *)iface != &null_shader_resource_variable;
4390 }
4391
4392 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetType(
4393         ID3D10EffectShaderResourceVariable *iface)
4394 {
4395     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4396 }
4397
4398 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetDesc(
4399         ID3D10EffectShaderResourceVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
4400 {
4401     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4402 }
4403
4404 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetAnnotationByIndex(
4405         ID3D10EffectShaderResourceVariable *iface, UINT index)
4406 {
4407     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4408 }
4409
4410 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetAnnotationByName(
4411         ID3D10EffectShaderResourceVariable *iface, LPCSTR name)
4412 {
4413     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4414 }
4415
4416 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberByIndex(
4417         ID3D10EffectShaderResourceVariable *iface, UINT index)
4418 {
4419     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4420 }
4421
4422 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberByName(
4423         ID3D10EffectShaderResourceVariable *iface, LPCSTR name)
4424 {
4425     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4426 }
4427
4428 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberBySemantic(
4429         ID3D10EffectShaderResourceVariable *iface, LPCSTR semantic)
4430 {
4431     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4432 }
4433
4434 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetElement(
4435         ID3D10EffectShaderResourceVariable *iface, UINT index)
4436 {
4437     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4438 }
4439
4440 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetParentConstantBuffer(
4441         ID3D10EffectShaderResourceVariable *iface)
4442 {
4443     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4444 }
4445
4446 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsScalar(
4447         ID3D10EffectShaderResourceVariable *iface)
4448 {
4449     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4450 }
4451
4452 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsVector(
4453         ID3D10EffectShaderResourceVariable *iface)
4454 {
4455     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4456 }
4457
4458 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsMatrix(
4459         ID3D10EffectShaderResourceVariable *iface)
4460 {
4461     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4462 }
4463
4464 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsString(
4465         ID3D10EffectShaderResourceVariable *iface)
4466 {
4467     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4468 }
4469
4470 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsShaderResource(
4471         ID3D10EffectShaderResourceVariable *iface)
4472 {
4473     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4474 }
4475
4476 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsRenderTargetView(
4477         ID3D10EffectShaderResourceVariable *iface)
4478 {
4479     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4480 }
4481
4482 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsDepthStencilView(
4483         ID3D10EffectShaderResourceVariable *iface)
4484 {
4485     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4486 }
4487
4488 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsConstantBuffer(
4489         ID3D10EffectShaderResourceVariable *iface)
4490 {
4491     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4492 }
4493
4494 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsShader(
4495         ID3D10EffectShaderResourceVariable *iface)
4496 {
4497     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4498 }
4499
4500 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsBlend(
4501         ID3D10EffectShaderResourceVariable *iface)
4502 {
4503     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4504 }
4505
4506 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsDepthStencil(
4507         ID3D10EffectShaderResourceVariable *iface)
4508 {
4509     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4510 }
4511
4512 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsRasterizer(
4513         ID3D10EffectShaderResourceVariable *iface)
4514 {
4515     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4516 }
4517
4518 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsSampler(
4519         ID3D10EffectShaderResourceVariable *iface)
4520 {
4521     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4522 }
4523
4524 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetRawValue(
4525         ID3D10EffectShaderResourceVariable *iface, void *data, UINT offset, UINT count)
4526 {
4527     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4528 }
4529
4530 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetRawValue(
4531         ID3D10EffectShaderResourceVariable *iface, void *data, UINT offset, UINT count)
4532 {
4533     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4534 }
4535
4536 /* ID3D10EffectShaderResourceVariable methods */
4537
4538 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetResource(
4539         ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView *resource)
4540 {
4541     FIXME("iface %p, resource %p stub!\n", iface, resource);
4542
4543     return E_NOTIMPL;
4544 }
4545
4546 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetResource(
4547         ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resource)
4548 {
4549     FIXME("iface %p, resource %p stub!\n", iface, resource);
4550
4551     return E_NOTIMPL;
4552 }
4553
4554 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetResourceArray(
4555         ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resources, UINT offset, UINT count)
4556 {
4557     FIXME("iface %p, resources %p, offset %u, count %u stub!\n", iface, resources, offset, count);
4558
4559     return E_NOTIMPL;
4560 }
4561
4562 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetResourceArray(
4563         ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resources, UINT offset, UINT count)
4564 {
4565     FIXME("iface %p, resources %p, offset %u, count %u stub!\n", iface, resources, offset, count);
4566
4567     return E_NOTIMPL;
4568 }
4569
4570
4571 static const struct ID3D10EffectShaderResourceVariableVtbl d3d10_effect_shader_resource_variable_vtbl =
4572 {
4573     /* ID3D10EffectVariable methods */
4574     d3d10_effect_shader_resource_variable_IsValid,
4575     d3d10_effect_shader_resource_variable_GetType,
4576     d3d10_effect_shader_resource_variable_GetDesc,
4577     d3d10_effect_shader_resource_variable_GetAnnotationByIndex,
4578     d3d10_effect_shader_resource_variable_GetAnnotationByName,
4579     d3d10_effect_shader_resource_variable_GetMemberByIndex,
4580     d3d10_effect_shader_resource_variable_GetMemberByName,
4581     d3d10_effect_shader_resource_variable_GetMemberBySemantic,
4582     d3d10_effect_shader_resource_variable_GetElement,
4583     d3d10_effect_shader_resource_variable_GetParentConstantBuffer,
4584     d3d10_effect_shader_resource_variable_AsScalar,
4585     d3d10_effect_shader_resource_variable_AsVector,
4586     d3d10_effect_shader_resource_variable_AsMatrix,
4587     d3d10_effect_shader_resource_variable_AsString,
4588     d3d10_effect_shader_resource_variable_AsShaderResource,
4589     d3d10_effect_shader_resource_variable_AsRenderTargetView,
4590     d3d10_effect_shader_resource_variable_AsDepthStencilView,
4591     d3d10_effect_shader_resource_variable_AsConstantBuffer,
4592     d3d10_effect_shader_resource_variable_AsShader,
4593     d3d10_effect_shader_resource_variable_AsBlend,
4594     d3d10_effect_shader_resource_variable_AsDepthStencil,
4595     d3d10_effect_shader_resource_variable_AsRasterizer,
4596     d3d10_effect_shader_resource_variable_AsSampler,
4597     d3d10_effect_shader_resource_variable_SetRawValue,
4598     d3d10_effect_shader_resource_variable_GetRawValue,
4599     /* ID3D10EffectShaderResourceVariable methods */
4600     d3d10_effect_shader_resource_variable_SetResource,
4601     d3d10_effect_shader_resource_variable_GetResource,
4602     d3d10_effect_shader_resource_variable_SetResourceArray,
4603     d3d10_effect_shader_resource_variable_GetResourceArray,
4604 };
4605
4606 /* ID3D10EffectVariable methods */
4607
4608 static BOOL STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_IsValid(
4609         ID3D10EffectRenderTargetViewVariable *iface)
4610 {
4611     TRACE("iface %p\n", iface);
4612
4613     return (struct d3d10_effect_variable *)iface != &null_render_target_view_variable;
4614 }
4615
4616 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetType(
4617         ID3D10EffectRenderTargetViewVariable *iface)
4618 {
4619     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4620 }
4621
4622 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetDesc(
4623         ID3D10EffectRenderTargetViewVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
4624 {
4625     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4626 }
4627
4628 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetAnnotationByIndex(
4629         ID3D10EffectRenderTargetViewVariable *iface, UINT index)
4630 {
4631     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4632 }
4633
4634 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetAnnotationByName(
4635         ID3D10EffectRenderTargetViewVariable *iface, LPCSTR name)
4636 {
4637     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4638 }
4639
4640 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberByIndex(
4641         ID3D10EffectRenderTargetViewVariable *iface, UINT index)
4642 {
4643     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4644 }
4645
4646 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberByName(
4647         ID3D10EffectRenderTargetViewVariable *iface, LPCSTR name)
4648 {
4649     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4650 }
4651
4652 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberBySemantic(
4653         ID3D10EffectRenderTargetViewVariable *iface, LPCSTR semantic)
4654 {
4655     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4656 }
4657
4658 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetElement(
4659         ID3D10EffectRenderTargetViewVariable *iface, UINT index)
4660 {
4661     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4662 }
4663
4664 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetParentConstantBuffer(
4665         ID3D10EffectRenderTargetViewVariable *iface)
4666 {
4667     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4668 }
4669
4670 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsScalar(
4671         ID3D10EffectRenderTargetViewVariable *iface)
4672 {
4673     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4674 }
4675
4676 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsVector(
4677         ID3D10EffectRenderTargetViewVariable *iface)
4678 {
4679     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4680 }
4681
4682 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsMatrix(
4683         ID3D10EffectRenderTargetViewVariable *iface)
4684 {
4685     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4686 }
4687
4688 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsString(
4689         ID3D10EffectRenderTargetViewVariable *iface)
4690 {
4691     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4692 }
4693
4694 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsShaderResource(
4695         ID3D10EffectRenderTargetViewVariable *iface)
4696 {
4697     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4698 }
4699
4700 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsRenderTargetView(
4701         ID3D10EffectRenderTargetViewVariable *iface)
4702 {
4703     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4704 }
4705
4706 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsDepthStencilView(
4707         ID3D10EffectRenderTargetViewVariable *iface)
4708 {
4709     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4710 }
4711
4712 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsConstantBuffer(
4713         ID3D10EffectRenderTargetViewVariable *iface)
4714 {
4715     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4716 }
4717
4718 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsShader(
4719         ID3D10EffectRenderTargetViewVariable *iface)
4720 {
4721     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4722 }
4723
4724 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsBlend(
4725         ID3D10EffectRenderTargetViewVariable *iface)
4726 {
4727     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4728 }
4729
4730 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsDepthStencil(
4731         ID3D10EffectRenderTargetViewVariable *iface)
4732 {
4733     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4734 }
4735
4736 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsRasterizer(
4737         ID3D10EffectRenderTargetViewVariable *iface)
4738 {
4739     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4740 }
4741
4742 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsSampler(
4743         ID3D10EffectRenderTargetViewVariable *iface)
4744 {
4745     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4746 }
4747
4748 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRawValue(
4749         ID3D10EffectRenderTargetViewVariable *iface, void *data, UINT offset, UINT count)
4750 {
4751     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4752 }
4753
4754 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRawValue(
4755         ID3D10EffectRenderTargetViewVariable *iface, void *data, UINT offset, UINT count)
4756 {
4757     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4758 }
4759
4760 /* ID3D10EffectRenderTargetViewVariable methods */
4761
4762 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRenderTarget(
4763         ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView *view)
4764 {
4765     FIXME("iface %p, view %p stub!\n", iface, view);
4766
4767     return E_NOTIMPL;
4768 }
4769
4770 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRenderTarget(
4771         ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **view)
4772 {
4773     FIXME("iface %p, view %p stub!\n", iface, view);
4774
4775     return E_NOTIMPL;
4776 }
4777
4778 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRenderTargetArray(
4779         ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **views, UINT offset, UINT count)
4780 {
4781     FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
4782
4783     return E_NOTIMPL;
4784 }
4785
4786 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRenderTargetArray(
4787         ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **views, UINT offset, UINT count)
4788 {
4789     FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
4790
4791     return E_NOTIMPL;
4792 }
4793
4794
4795 static const struct ID3D10EffectRenderTargetViewVariableVtbl d3d10_effect_render_target_view_variable_vtbl =
4796 {
4797     /* ID3D10EffectVariable methods */
4798     d3d10_effect_render_target_view_variable_IsValid,
4799     d3d10_effect_render_target_view_variable_GetType,
4800     d3d10_effect_render_target_view_variable_GetDesc,
4801     d3d10_effect_render_target_view_variable_GetAnnotationByIndex,
4802     d3d10_effect_render_target_view_variable_GetAnnotationByName,
4803     d3d10_effect_render_target_view_variable_GetMemberByIndex,
4804     d3d10_effect_render_target_view_variable_GetMemberByName,
4805     d3d10_effect_render_target_view_variable_GetMemberBySemantic,
4806     d3d10_effect_render_target_view_variable_GetElement,
4807     d3d10_effect_render_target_view_variable_GetParentConstantBuffer,
4808     d3d10_effect_render_target_view_variable_AsScalar,
4809     d3d10_effect_render_target_view_variable_AsVector,
4810     d3d10_effect_render_target_view_variable_AsMatrix,
4811     d3d10_effect_render_target_view_variable_AsString,
4812     d3d10_effect_render_target_view_variable_AsShaderResource,
4813     d3d10_effect_render_target_view_variable_AsRenderTargetView,
4814     d3d10_effect_render_target_view_variable_AsDepthStencilView,
4815     d3d10_effect_render_target_view_variable_AsConstantBuffer,
4816     d3d10_effect_render_target_view_variable_AsShader,
4817     d3d10_effect_render_target_view_variable_AsBlend,
4818     d3d10_effect_render_target_view_variable_AsDepthStencil,
4819     d3d10_effect_render_target_view_variable_AsRasterizer,
4820     d3d10_effect_render_target_view_variable_AsSampler,
4821     d3d10_effect_render_target_view_variable_SetRawValue,
4822     d3d10_effect_render_target_view_variable_GetRawValue,
4823     /* ID3D10EffectRenderTargetViewVariable methods */
4824     d3d10_effect_render_target_view_variable_SetRenderTarget,
4825     d3d10_effect_render_target_view_variable_GetRenderTarget,
4826     d3d10_effect_render_target_view_variable_SetRenderTargetArray,
4827     d3d10_effect_render_target_view_variable_GetRenderTargetArray,
4828 };
4829
4830 /* ID3D10EffectVariable methods */
4831
4832 static BOOL STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_IsValid(
4833         ID3D10EffectDepthStencilViewVariable *iface)
4834 {
4835     TRACE("iface %p\n", iface);
4836
4837     return (struct d3d10_effect_variable *)iface != &null_depth_stencil_view_variable;
4838 }
4839
4840 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetType(
4841         ID3D10EffectDepthStencilViewVariable *iface)
4842 {
4843     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4844 }
4845
4846 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDesc(
4847         ID3D10EffectDepthStencilViewVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
4848 {
4849     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4850 }
4851
4852 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetAnnotationByIndex(
4853         ID3D10EffectDepthStencilViewVariable *iface, UINT index)
4854 {
4855     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4856 }
4857
4858 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetAnnotationByName(
4859         ID3D10EffectDepthStencilViewVariable *iface, LPCSTR name)
4860 {
4861     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4862 }
4863
4864 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberByIndex(
4865         ID3D10EffectDepthStencilViewVariable *iface, UINT index)
4866 {
4867     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4868 }
4869
4870 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberByName(
4871         ID3D10EffectDepthStencilViewVariable *iface, LPCSTR name)
4872 {
4873     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4874 }
4875
4876 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberBySemantic(
4877         ID3D10EffectDepthStencilViewVariable *iface, LPCSTR semantic)
4878 {
4879     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4880 }
4881
4882 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetElement(
4883         ID3D10EffectDepthStencilViewVariable *iface, UINT index)
4884 {
4885     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4886 }
4887
4888 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetParentConstantBuffer(
4889         ID3D10EffectDepthStencilViewVariable *iface)
4890 {
4891     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4892 }
4893
4894 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsScalar(
4895         ID3D10EffectDepthStencilViewVariable *iface)
4896 {
4897     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4898 }
4899
4900 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsVector(
4901         ID3D10EffectDepthStencilViewVariable *iface)
4902 {
4903     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4904 }
4905
4906 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsMatrix(
4907         ID3D10EffectDepthStencilViewVariable *iface)
4908 {
4909     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4910 }
4911
4912 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsString(
4913         ID3D10EffectDepthStencilViewVariable *iface)
4914 {
4915     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4916 }
4917
4918 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsShaderResource(
4919         ID3D10EffectDepthStencilViewVariable *iface)
4920 {
4921     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4922 }
4923
4924 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsRenderTargetView(
4925         ID3D10EffectDepthStencilViewVariable *iface)
4926 {
4927     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4928 }
4929
4930 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsDepthStencilView(
4931         ID3D10EffectDepthStencilViewVariable *iface)
4932 {
4933     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4934 }
4935
4936 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsConstantBuffer(
4937         ID3D10EffectDepthStencilViewVariable *iface)
4938 {
4939     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4940 }
4941
4942 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsShader(
4943         ID3D10EffectDepthStencilViewVariable *iface)
4944 {
4945     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4946 }
4947
4948 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsBlend(
4949         ID3D10EffectDepthStencilViewVariable *iface)
4950 {
4951     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4952 }
4953
4954 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsDepthStencil(
4955         ID3D10EffectDepthStencilViewVariable *iface)
4956 {
4957     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4958 }
4959
4960 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsRasterizer(
4961         ID3D10EffectDepthStencilViewVariable *iface)
4962 {
4963     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4964 }
4965
4966 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsSampler(
4967         ID3D10EffectDepthStencilViewVariable *iface)
4968 {
4969     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4970 }
4971
4972 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetRawValue(
4973         ID3D10EffectDepthStencilViewVariable *iface, void *data, UINT offset, UINT count)
4974 {
4975     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4976 }
4977
4978 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetRawValue(
4979         ID3D10EffectDepthStencilViewVariable *iface, void *data, UINT offset, UINT count)
4980 {
4981     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4982 }
4983
4984 /* ID3D10EffectDepthStencilViewVariable methods */
4985
4986 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetDepthStencil(
4987         ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView *view)
4988 {
4989     FIXME("iface %p, view %p stub!\n", iface, view);
4990
4991     return E_NOTIMPL;
4992 }
4993
4994 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDepthStencil(
4995         ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **view)
4996 {
4997     FIXME("iface %p, view %p stub!\n", iface, view);
4998
4999     return E_NOTIMPL;
5000 }
5001
5002 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetDepthStencilArray(
5003         ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **views, UINT offset, UINT count)
5004 {
5005     FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5006
5007     return E_NOTIMPL;
5008 }
5009
5010 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDepthStencilArray(
5011         ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **views, UINT offset, UINT count)
5012 {
5013     FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5014
5015     return E_NOTIMPL;
5016 }
5017
5018
5019 static const struct ID3D10EffectDepthStencilViewVariableVtbl d3d10_effect_depth_stencil_view_variable_vtbl =
5020 {
5021     /* ID3D10EffectVariable methods */
5022     d3d10_effect_depth_stencil_view_variable_IsValid,
5023     d3d10_effect_depth_stencil_view_variable_GetType,
5024     d3d10_effect_depth_stencil_view_variable_GetDesc,
5025     d3d10_effect_depth_stencil_view_variable_GetAnnotationByIndex,
5026     d3d10_effect_depth_stencil_view_variable_GetAnnotationByName,
5027     d3d10_effect_depth_stencil_view_variable_GetMemberByIndex,
5028     d3d10_effect_depth_stencil_view_variable_GetMemberByName,
5029     d3d10_effect_depth_stencil_view_variable_GetMemberBySemantic,
5030     d3d10_effect_depth_stencil_view_variable_GetElement,
5031     d3d10_effect_depth_stencil_view_variable_GetParentConstantBuffer,
5032     d3d10_effect_depth_stencil_view_variable_AsScalar,
5033     d3d10_effect_depth_stencil_view_variable_AsVector,
5034     d3d10_effect_depth_stencil_view_variable_AsMatrix,
5035     d3d10_effect_depth_stencil_view_variable_AsString,
5036     d3d10_effect_depth_stencil_view_variable_AsShaderResource,
5037     d3d10_effect_depth_stencil_view_variable_AsRenderTargetView,
5038     d3d10_effect_depth_stencil_view_variable_AsDepthStencilView,
5039     d3d10_effect_depth_stencil_view_variable_AsConstantBuffer,
5040     d3d10_effect_depth_stencil_view_variable_AsShader,
5041     d3d10_effect_depth_stencil_view_variable_AsBlend,
5042     d3d10_effect_depth_stencil_view_variable_AsDepthStencil,
5043     d3d10_effect_depth_stencil_view_variable_AsRasterizer,
5044     d3d10_effect_depth_stencil_view_variable_AsSampler,
5045     d3d10_effect_depth_stencil_view_variable_SetRawValue,
5046     d3d10_effect_depth_stencil_view_variable_GetRawValue,
5047     /* ID3D10EffectDepthStencilViewVariable methods */
5048     d3d10_effect_depth_stencil_view_variable_SetDepthStencil,
5049     d3d10_effect_depth_stencil_view_variable_GetDepthStencil,
5050     d3d10_effect_depth_stencil_view_variable_SetDepthStencilArray,
5051     d3d10_effect_depth_stencil_view_variable_GetDepthStencilArray,
5052 };
5053
5054 /* ID3D10EffectVariable methods */
5055
5056 static BOOL STDMETHODCALLTYPE d3d10_effect_shader_variable_IsValid(ID3D10EffectShaderVariable *iface)
5057 {
5058     TRACE("iface %p\n", iface);
5059
5060     return (struct d3d10_effect_variable *)iface != &null_shader_variable;
5061 }
5062
5063 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetType(
5064         ID3D10EffectShaderVariable *iface)
5065 {
5066     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5067 }
5068
5069 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetDesc(ID3D10EffectShaderVariable *iface,
5070         D3D10_EFFECT_VARIABLE_DESC *desc)
5071 {
5072     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5073 }
5074
5075 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetAnnotationByIndex(
5076         ID3D10EffectShaderVariable *iface, UINT index)
5077 {
5078     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5079 }
5080
5081 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetAnnotationByName(
5082         ID3D10EffectShaderVariable *iface, LPCSTR name)
5083 {
5084     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5085 }
5086
5087 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberByIndex(
5088         ID3D10EffectShaderVariable *iface, UINT index)
5089 {
5090     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5091 }
5092
5093 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberByName(
5094         ID3D10EffectShaderVariable *iface, LPCSTR name)
5095 {
5096     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5097 }
5098
5099 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberBySemantic(
5100         ID3D10EffectShaderVariable *iface, LPCSTR semantic)
5101 {
5102     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5103 }
5104
5105 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetElement(
5106         ID3D10EffectShaderVariable *iface, UINT index)
5107 {
5108     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5109 }
5110
5111 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetParentConstantBuffer(
5112         ID3D10EffectShaderVariable *iface)
5113 {
5114     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5115 }
5116
5117 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsScalar(
5118         ID3D10EffectShaderVariable *iface)
5119 {
5120     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5121 }
5122
5123 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsVector(
5124         ID3D10EffectShaderVariable *iface)
5125 {
5126     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5127 }
5128
5129 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsMatrix(
5130         ID3D10EffectShaderVariable *iface)
5131 {
5132     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5133 }
5134
5135 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsString(
5136         ID3D10EffectShaderVariable *iface)
5137 {
5138     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5139 }
5140
5141 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsShaderResource(
5142         ID3D10EffectShaderVariable *iface)
5143 {
5144     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5145 }
5146
5147 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsRenderTargetView(
5148         ID3D10EffectShaderVariable *iface)
5149 {
5150     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5151 }
5152
5153 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsDepthStencilView(
5154         ID3D10EffectShaderVariable *iface)
5155 {
5156     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5157 }
5158
5159 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsConstantBuffer(
5160         ID3D10EffectShaderVariable *iface)
5161 {
5162     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5163 }
5164
5165 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsShader(
5166         ID3D10EffectShaderVariable *iface)
5167 {
5168     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5169 }
5170
5171 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsBlend(
5172         ID3D10EffectShaderVariable *iface)
5173 {
5174     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5175 }
5176
5177 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsDepthStencil(
5178         ID3D10EffectShaderVariable *iface)
5179 {
5180     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5181 }
5182
5183 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsRasterizer(
5184         ID3D10EffectShaderVariable *iface)
5185 {
5186     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5187 }
5188
5189 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsSampler(
5190         ID3D10EffectShaderVariable *iface)
5191 {
5192     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5193 }
5194
5195 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_SetRawValue(
5196         ID3D10EffectShaderVariable *iface, void *data, UINT offset, UINT count)
5197 {
5198     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5199 }
5200
5201 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetRawValue(
5202         ID3D10EffectShaderVariable *iface, void *data, UINT offset, UINT count)
5203 {
5204     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5205 }
5206
5207 /* ID3D10EffectShaderVariable methods */
5208
5209 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetShaderDesc(
5210         ID3D10EffectShaderVariable *iface, UINT index, D3D10_EFFECT_SHADER_DESC *desc)
5211 {
5212     FIXME("iface %p, index %u, desc %p stub!\n", iface, index, desc);
5213
5214     return E_NOTIMPL;
5215 }
5216
5217 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetVertexShader(
5218         ID3D10EffectShaderVariable *iface, UINT index, ID3D10VertexShader **shader)
5219 {
5220     FIXME("iface %p, index %u, shader %p stub!\n", iface, index, shader);
5221
5222     return E_NOTIMPL;
5223 }
5224
5225 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetGeometryShader(
5226         ID3D10EffectShaderVariable *iface, UINT index, ID3D10GeometryShader **shader)
5227 {
5228     FIXME("iface %p, index %u, shader %p stub!\n", iface, index, shader);
5229
5230     return E_NOTIMPL;
5231 }
5232
5233 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetPixelShader(
5234         ID3D10EffectShaderVariable *iface, UINT index, ID3D10PixelShader **shader)
5235 {
5236     FIXME("iface %p, index %u, shader %p stub!\n", iface, index, shader);
5237
5238     return E_NOTIMPL;
5239 }
5240
5241 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetInputSignatureElementDesc(
5242         ID3D10EffectShaderVariable *iface, UINT shader_index, UINT element_index,
5243         D3D10_SIGNATURE_PARAMETER_DESC *desc)
5244 {
5245     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
5246     struct d3d10_effect_shader_variable *s;
5247     D3D10_SIGNATURE_PARAMETER_DESC *d;
5248
5249     TRACE("iface %p, shader_index %u, element_index %u, desc %p\n",
5250             iface, shader_index, element_index, desc);
5251
5252     if (!iface->lpVtbl->IsValid(iface))
5253     {
5254         WARN("Null variable specified\n");
5255         return E_FAIL;
5256     }
5257
5258     /* Check shader_index, this crashes on W7/DX10 */
5259     if (shader_index >= This->effect->used_shader_count)
5260     {
5261         WARN("This should crash on W7/DX10!\n");
5262         return E_FAIL;
5263     }
5264
5265     s = This->effect->used_shaders[shader_index]->data;
5266     if (!s->input_signature.signature)
5267     {
5268         WARN("No shader signature\n");
5269         return D3DERR_INVALIDCALL;
5270     }
5271
5272     /* Check desc for NULL, this crashes on W7/DX10 */
5273     if (!desc)
5274     {
5275         WARN("This should crash on W7/DX10!\n");
5276         return E_FAIL;
5277     }
5278
5279     if (element_index >= s->input_signature.element_count)
5280     {
5281         WARN("Invalid element index specified\n");
5282         return E_INVALIDARG;
5283     }
5284
5285     d = &s->input_signature.elements[element_index];
5286     desc->SemanticName = d->SemanticName;
5287     desc->SemanticIndex  =  d->SemanticIndex;
5288     desc->SystemValueType =  d->SystemValueType;
5289     desc->ComponentType =  d->ComponentType;
5290     desc->Register =  d->Register;
5291     desc->ReadWriteMask  =  d->ReadWriteMask;
5292     desc->Mask =  d->Mask;
5293
5294     return S_OK;
5295 }
5296
5297 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetOutputSignatureElementDesc(
5298         ID3D10EffectShaderVariable *iface, UINT shader_index, UINT element_index,
5299         D3D10_SIGNATURE_PARAMETER_DESC *desc)
5300 {
5301     struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
5302     struct d3d10_effect_shader_variable *s;
5303     D3D10_SIGNATURE_PARAMETER_DESC *d;
5304
5305     TRACE("iface %p, shader_index %u, element_index %u, desc %p\n",
5306             iface, shader_index, element_index, desc);
5307
5308     if (!iface->lpVtbl->IsValid(iface))
5309     {
5310         WARN("Null variable specified\n");
5311         return E_FAIL;
5312     }
5313
5314     /* Check shader_index, this crashes on W7/DX10 */
5315     if (shader_index >= This->effect->used_shader_count)
5316     {
5317         WARN("This should crash on W7/DX10!\n");
5318         return E_FAIL;
5319     }
5320
5321     s = This->effect->used_shaders[shader_index]->data;
5322     if (!s->output_signature.signature)
5323     {
5324         WARN("No shader signature\n");
5325         return D3DERR_INVALIDCALL;
5326     }
5327
5328     /* Check desc for NULL, this crashes on W7/DX10 */
5329     if (!desc)
5330     {
5331         WARN("This should crash on W7/DX10!\n");
5332         return E_FAIL;
5333     }
5334
5335     if (element_index >= s->output_signature.element_count)
5336     {
5337         WARN("Invalid element index specified\n");
5338         return E_INVALIDARG;
5339     }
5340
5341     d = &s->output_signature.elements[element_index];
5342     desc->SemanticName = d->SemanticName;
5343     desc->SemanticIndex  =  d->SemanticIndex;
5344     desc->SystemValueType =  d->SystemValueType;
5345     desc->ComponentType =  d->ComponentType;
5346     desc->Register =  d->Register;
5347     desc->ReadWriteMask  =  d->ReadWriteMask;
5348     desc->Mask =  d->Mask;
5349
5350     return S_OK;
5351 }
5352
5353
5354 static const struct ID3D10EffectShaderVariableVtbl d3d10_effect_shader_variable_vtbl =
5355 {
5356     /* ID3D10EffectVariable methods */
5357     d3d10_effect_shader_variable_IsValid,
5358     d3d10_effect_shader_variable_GetType,
5359     d3d10_effect_shader_variable_GetDesc,
5360     d3d10_effect_shader_variable_GetAnnotationByIndex,
5361     d3d10_effect_shader_variable_GetAnnotationByName,
5362     d3d10_effect_shader_variable_GetMemberByIndex,
5363     d3d10_effect_shader_variable_GetMemberByName,
5364     d3d10_effect_shader_variable_GetMemberBySemantic,
5365     d3d10_effect_shader_variable_GetElement,
5366     d3d10_effect_shader_variable_GetParentConstantBuffer,
5367     d3d10_effect_shader_variable_AsScalar,
5368     d3d10_effect_shader_variable_AsVector,
5369     d3d10_effect_shader_variable_AsMatrix,
5370     d3d10_effect_shader_variable_AsString,
5371     d3d10_effect_shader_variable_AsShaderResource,
5372     d3d10_effect_shader_variable_AsRenderTargetView,
5373     d3d10_effect_shader_variable_AsDepthStencilView,
5374     d3d10_effect_shader_variable_AsConstantBuffer,
5375     d3d10_effect_shader_variable_AsShader,
5376     d3d10_effect_shader_variable_AsBlend,
5377     d3d10_effect_shader_variable_AsDepthStencil,
5378     d3d10_effect_shader_variable_AsRasterizer,
5379     d3d10_effect_shader_variable_AsSampler,
5380     d3d10_effect_shader_variable_SetRawValue,
5381     d3d10_effect_shader_variable_GetRawValue,
5382     /* ID3D10EffectShaderVariable methods */
5383     d3d10_effect_shader_variable_GetShaderDesc,
5384     d3d10_effect_shader_variable_GetVertexShader,
5385     d3d10_effect_shader_variable_GetGeometryShader,
5386     d3d10_effect_shader_variable_GetPixelShader,
5387     d3d10_effect_shader_variable_GetInputSignatureElementDesc,
5388     d3d10_effect_shader_variable_GetOutputSignatureElementDesc,
5389 };
5390
5391 /* ID3D10EffectVariable methods */
5392
5393 static BOOL STDMETHODCALLTYPE d3d10_effect_blend_variable_IsValid(ID3D10EffectBlendVariable *iface)
5394 {
5395     TRACE("iface %p\n", iface);
5396
5397     return (struct d3d10_effect_variable *)iface != &null_blend_variable;
5398 }
5399
5400 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetType(
5401         ID3D10EffectBlendVariable *iface)
5402 {
5403     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5404 }
5405
5406 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetDesc(ID3D10EffectBlendVariable *iface,
5407         D3D10_EFFECT_VARIABLE_DESC *desc)
5408 {
5409     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5410 }
5411
5412 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetAnnotationByIndex(
5413         ID3D10EffectBlendVariable *iface, UINT index)
5414 {
5415     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5416 }
5417
5418 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetAnnotationByName(
5419         ID3D10EffectBlendVariable *iface, LPCSTR name)
5420 {
5421     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5422 }
5423
5424 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberByIndex(
5425         ID3D10EffectBlendVariable *iface, UINT index)
5426 {
5427     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5428 }
5429
5430 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberByName(
5431         ID3D10EffectBlendVariable *iface, LPCSTR name)
5432 {
5433     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5434 }
5435
5436 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberBySemantic(
5437         ID3D10EffectBlendVariable *iface, LPCSTR semantic)
5438 {
5439     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5440 }
5441
5442 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetElement(
5443         ID3D10EffectBlendVariable *iface, UINT index)
5444 {
5445     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5446 }
5447
5448 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetParentConstantBuffer(
5449         ID3D10EffectBlendVariable *iface)
5450 {
5451     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5452 }
5453
5454 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsScalar(
5455         ID3D10EffectBlendVariable *iface)
5456 {
5457     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5458 }
5459
5460 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsVector(
5461         ID3D10EffectBlendVariable *iface)
5462 {
5463     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5464 }
5465
5466 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsMatrix(
5467         ID3D10EffectBlendVariable *iface)
5468 {
5469     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5470 }
5471
5472 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsString(
5473         ID3D10EffectBlendVariable *iface)
5474 {
5475     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5476 }
5477
5478 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsShaderResource(
5479         ID3D10EffectBlendVariable *iface)
5480 {
5481     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5482 }
5483
5484 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsRenderTargetView(
5485         ID3D10EffectBlendVariable *iface)
5486 {
5487     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5488 }
5489
5490 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsDepthStencilView(
5491         ID3D10EffectBlendVariable *iface)
5492 {
5493     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5494 }
5495
5496 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsConstantBuffer(
5497         ID3D10EffectBlendVariable *iface)
5498 {
5499     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5500 }
5501
5502 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsShader(
5503         ID3D10EffectBlendVariable *iface)
5504 {
5505     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5506 }
5507
5508 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsBlend(
5509         ID3D10EffectBlendVariable *iface)
5510 {
5511     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5512 }
5513
5514 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsDepthStencil(
5515         ID3D10EffectBlendVariable *iface)
5516 {
5517     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5518 }
5519
5520 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsRasterizer(
5521         ID3D10EffectBlendVariable *iface)
5522 {
5523     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5524 }
5525
5526 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsSampler(
5527         ID3D10EffectBlendVariable *iface)
5528 {
5529     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5530 }
5531
5532 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_SetRawValue(ID3D10EffectBlendVariable *iface,
5533         void *data, UINT offset, UINT count)
5534 {
5535     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5536 }
5537
5538 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetRawValue(ID3D10EffectBlendVariable *iface,
5539         void *data, UINT offset, UINT count)
5540 {
5541     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5542 }
5543
5544 /* ID3D10EffectBlendVariable methods */
5545
5546 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetBlendState(ID3D10EffectBlendVariable *iface,
5547         UINT index, ID3D10BlendState **blend_state)
5548 {
5549     FIXME("iface %p, index %u, blend_state %p stub!\n", iface, index, blend_state);
5550
5551     return E_NOTIMPL;
5552 }
5553
5554 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetBackingStore(ID3D10EffectBlendVariable *iface,
5555         UINT index, D3D10_BLEND_DESC *desc)
5556 {
5557     FIXME("iface %p, index %u, desc %p stub!\n", iface, index, desc);
5558
5559     return E_NOTIMPL;
5560 }
5561
5562
5563 static const struct ID3D10EffectBlendVariableVtbl d3d10_effect_blend_variable_vtbl =
5564 {
5565     /* ID3D10EffectVariable methods */
5566     d3d10_effect_blend_variable_IsValid,
5567     d3d10_effect_blend_variable_GetType,
5568     d3d10_effect_blend_variable_GetDesc,
5569     d3d10_effect_blend_variable_GetAnnotationByIndex,
5570     d3d10_effect_blend_variable_GetAnnotationByName,
5571     d3d10_effect_blend_variable_GetMemberByIndex,
5572     d3d10_effect_blend_variable_GetMemberByName,
5573     d3d10_effect_blend_variable_GetMemberBySemantic,
5574     d3d10_effect_blend_variable_GetElement,
5575     d3d10_effect_blend_variable_GetParentConstantBuffer,
5576     d3d10_effect_blend_variable_AsScalar,
5577     d3d10_effect_blend_variable_AsVector,
5578     d3d10_effect_blend_variable_AsMatrix,
5579     d3d10_effect_blend_variable_AsString,
5580     d3d10_effect_blend_variable_AsShaderResource,
5581     d3d10_effect_blend_variable_AsRenderTargetView,
5582     d3d10_effect_blend_variable_AsDepthStencilView,
5583     d3d10_effect_blend_variable_AsConstantBuffer,
5584     d3d10_effect_blend_variable_AsShader,
5585     d3d10_effect_blend_variable_AsBlend,
5586     d3d10_effect_blend_variable_AsDepthStencil,
5587     d3d10_effect_blend_variable_AsRasterizer,
5588     d3d10_effect_blend_variable_AsSampler,
5589     d3d10_effect_blend_variable_SetRawValue,
5590     d3d10_effect_blend_variable_GetRawValue,
5591     /* ID3D10EffectBlendVariable methods */
5592     d3d10_effect_blend_variable_GetBlendState,
5593     d3d10_effect_blend_variable_GetBackingStore,
5594 };
5595
5596 /* ID3D10EffectVariable methods */
5597
5598 static BOOL STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_IsValid(ID3D10EffectDepthStencilVariable *iface)
5599 {
5600     TRACE("iface %p\n", iface);
5601
5602     return (struct d3d10_effect_variable *)iface != &null_depth_stencil_variable;
5603 }
5604
5605 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetType(
5606         ID3D10EffectDepthStencilVariable *iface)
5607 {
5608     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5609 }
5610
5611 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetDesc(ID3D10EffectDepthStencilVariable *iface,
5612         D3D10_EFFECT_VARIABLE_DESC *desc)
5613 {
5614     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5615 }
5616
5617 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetAnnotationByIndex(
5618         ID3D10EffectDepthStencilVariable *iface, UINT index)
5619 {
5620     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5621 }
5622
5623 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetAnnotationByName(
5624         ID3D10EffectDepthStencilVariable *iface, LPCSTR name)
5625 {
5626     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5627 }
5628
5629 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberByIndex(
5630         ID3D10EffectDepthStencilVariable *iface, UINT index)
5631 {
5632     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5633 }
5634
5635 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberByName(
5636         ID3D10EffectDepthStencilVariable *iface, LPCSTR name)
5637 {
5638     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5639 }
5640
5641 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberBySemantic(
5642         ID3D10EffectDepthStencilVariable *iface, LPCSTR semantic)
5643 {
5644     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5645 }
5646
5647 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetElement(
5648         ID3D10EffectDepthStencilVariable *iface, UINT index)
5649 {
5650     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5651 }
5652
5653 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetParentConstantBuffer(
5654         ID3D10EffectDepthStencilVariable *iface)
5655 {
5656     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5657 }
5658
5659 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsScalar(
5660         ID3D10EffectDepthStencilVariable *iface)
5661 {
5662     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5663 }
5664
5665 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsVector(
5666         ID3D10EffectDepthStencilVariable *iface)
5667 {
5668     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5669 }
5670
5671 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsMatrix(
5672         ID3D10EffectDepthStencilVariable *iface)
5673 {
5674     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5675 }
5676
5677 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsString(
5678         ID3D10EffectDepthStencilVariable *iface)
5679 {
5680     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5681 }
5682
5683 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsShaderResource(
5684         ID3D10EffectDepthStencilVariable *iface)
5685 {
5686     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5687 }
5688
5689 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsRenderTargetView(
5690         ID3D10EffectDepthStencilVariable *iface)
5691 {
5692     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5693 }
5694
5695 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsDepthStencilView(
5696         ID3D10EffectDepthStencilVariable *iface)
5697 {
5698     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5699 }
5700
5701 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsConstantBuffer(
5702         ID3D10EffectDepthStencilVariable *iface)
5703 {
5704     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5705 }
5706
5707 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsShader(
5708         ID3D10EffectDepthStencilVariable *iface)
5709 {
5710     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5711 }
5712
5713 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsBlend(
5714         ID3D10EffectDepthStencilVariable *iface)
5715 {
5716     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5717 }
5718
5719 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsDepthStencil(
5720         ID3D10EffectDepthStencilVariable *iface)
5721 {
5722     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5723 }
5724
5725 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsRasterizer(
5726         ID3D10EffectDepthStencilVariable *iface)
5727 {
5728     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5729 }
5730
5731 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsSampler(
5732         ID3D10EffectDepthStencilVariable *iface)
5733 {
5734     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5735 }
5736
5737 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_SetRawValue(ID3D10EffectDepthStencilVariable *iface,
5738         void *data, UINT offset, UINT count)
5739 {
5740     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5741 }
5742
5743 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetRawValue(ID3D10EffectDepthStencilVariable *iface,
5744         void *data, UINT offset, UINT count)
5745 {
5746     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5747 }
5748
5749 /* ID3D10EffectDepthStencilVariable methods */
5750
5751 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetDepthStencilState(ID3D10EffectDepthStencilVariable *iface,
5752         UINT index, ID3D10DepthStencilState **depth_stencil_state)
5753 {
5754     FIXME("iface %p, index %u, depth_stencil_state %p stub!\n", iface, index, depth_stencil_state);
5755
5756     return E_NOTIMPL;
5757 }
5758
5759 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetBackingStore(ID3D10EffectDepthStencilVariable *iface,
5760         UINT index, D3D10_DEPTH_STENCIL_DESC *desc)
5761 {
5762     FIXME("iface %p, index %u, desc %p stub!\n", iface, index, desc);
5763
5764     return E_NOTIMPL;
5765 }
5766
5767
5768 static const struct ID3D10EffectDepthStencilVariableVtbl d3d10_effect_depth_stencil_variable_vtbl =
5769 {
5770     /* ID3D10EffectVariable methods */
5771     d3d10_effect_depth_stencil_variable_IsValid,
5772     d3d10_effect_depth_stencil_variable_GetType,
5773     d3d10_effect_depth_stencil_variable_GetDesc,
5774     d3d10_effect_depth_stencil_variable_GetAnnotationByIndex,
5775     d3d10_effect_depth_stencil_variable_GetAnnotationByName,
5776     d3d10_effect_depth_stencil_variable_GetMemberByIndex,
5777     d3d10_effect_depth_stencil_variable_GetMemberByName,
5778     d3d10_effect_depth_stencil_variable_GetMemberBySemantic,
5779     d3d10_effect_depth_stencil_variable_GetElement,
5780     d3d10_effect_depth_stencil_variable_GetParentConstantBuffer,
5781     d3d10_effect_depth_stencil_variable_AsScalar,
5782     d3d10_effect_depth_stencil_variable_AsVector,
5783     d3d10_effect_depth_stencil_variable_AsMatrix,
5784     d3d10_effect_depth_stencil_variable_AsString,
5785     d3d10_effect_depth_stencil_variable_AsShaderResource,
5786     d3d10_effect_depth_stencil_variable_AsRenderTargetView,
5787     d3d10_effect_depth_stencil_variable_AsDepthStencilView,
5788     d3d10_effect_depth_stencil_variable_AsConstantBuffer,
5789     d3d10_effect_depth_stencil_variable_AsShader,
5790     d3d10_effect_depth_stencil_variable_AsBlend,
5791     d3d10_effect_depth_stencil_variable_AsDepthStencil,
5792     d3d10_effect_depth_stencil_variable_AsRasterizer,
5793     d3d10_effect_depth_stencil_variable_AsSampler,
5794     d3d10_effect_depth_stencil_variable_SetRawValue,
5795     d3d10_effect_depth_stencil_variable_GetRawValue,
5796     /* ID3D10EffectDepthStencilVariable methods */
5797     d3d10_effect_depth_stencil_variable_GetDepthStencilState,
5798     d3d10_effect_depth_stencil_variable_GetBackingStore,
5799 };
5800
5801 /* ID3D10EffectVariable methods */
5802
5803 static BOOL STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_IsValid(ID3D10EffectRasterizerVariable *iface)
5804 {
5805     TRACE("iface %p\n", iface);
5806
5807     return (struct d3d10_effect_variable *)iface != &null_rasterizer_variable;
5808 }
5809
5810 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetType(
5811         ID3D10EffectRasterizerVariable *iface)
5812 {
5813     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5814 }
5815
5816 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetDesc(ID3D10EffectRasterizerVariable *iface,
5817         D3D10_EFFECT_VARIABLE_DESC *desc)
5818 {
5819     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5820 }
5821
5822 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetAnnotationByIndex(
5823         ID3D10EffectRasterizerVariable *iface, UINT index)
5824 {
5825     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5826 }
5827
5828 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetAnnotationByName(
5829         ID3D10EffectRasterizerVariable *iface, LPCSTR name)
5830 {
5831     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5832 }
5833
5834 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberByIndex(
5835         ID3D10EffectRasterizerVariable *iface, UINT index)
5836 {
5837     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5838 }
5839
5840 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberByName(
5841         ID3D10EffectRasterizerVariable *iface, LPCSTR name)
5842 {
5843     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5844 }
5845
5846 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberBySemantic(
5847         ID3D10EffectRasterizerVariable *iface, LPCSTR semantic)
5848 {
5849     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5850 }
5851
5852 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetElement(
5853         ID3D10EffectRasterizerVariable *iface, UINT index)
5854 {
5855     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5856 }
5857
5858 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetParentConstantBuffer(
5859         ID3D10EffectRasterizerVariable *iface)
5860 {
5861     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5862 }
5863
5864 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsScalar(
5865         ID3D10EffectRasterizerVariable *iface)
5866 {
5867     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5868 }
5869
5870 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsVector(
5871         ID3D10EffectRasterizerVariable *iface)
5872 {
5873     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5874 }
5875
5876 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsMatrix(
5877         ID3D10EffectRasterizerVariable *iface)
5878 {
5879     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5880 }
5881
5882 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsString(
5883         ID3D10EffectRasterizerVariable *iface)
5884 {
5885     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5886 }
5887
5888 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsShaderResource(
5889         ID3D10EffectRasterizerVariable *iface)
5890 {
5891     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5892 }
5893
5894 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsRenderTargetView(
5895         ID3D10EffectRasterizerVariable *iface)
5896 {
5897     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5898 }
5899
5900 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsDepthStencilView(
5901         ID3D10EffectRasterizerVariable *iface)
5902 {
5903     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5904 }
5905
5906 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsConstantBuffer(
5907         ID3D10EffectRasterizerVariable *iface)
5908 {
5909     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5910 }
5911
5912 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsShader(
5913         ID3D10EffectRasterizerVariable *iface)
5914 {
5915     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5916 }
5917
5918 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsBlend(
5919         ID3D10EffectRasterizerVariable *iface)
5920 {
5921     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5922 }
5923
5924 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsDepthStencil(
5925         ID3D10EffectRasterizerVariable *iface)
5926 {
5927     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5928 }
5929
5930 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsRasterizer(
5931         ID3D10EffectRasterizerVariable *iface)
5932 {
5933     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5934 }
5935
5936 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsSampler(
5937         ID3D10EffectRasterizerVariable *iface)
5938 {
5939     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5940 }
5941
5942 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_SetRawValue(ID3D10EffectRasterizerVariable *iface,
5943         void *data, UINT offset, UINT count)
5944 {
5945     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5946 }
5947
5948 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetRawValue(ID3D10EffectRasterizerVariable *iface,
5949         void *data, UINT offset, UINT count)
5950 {
5951     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5952 }
5953
5954 /* ID3D10EffectRasterizerVariable methods */
5955
5956 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetRasterizerState(ID3D10EffectRasterizerVariable *iface,
5957         UINT index, ID3D10RasterizerState **rasterizer_state)
5958 {
5959     FIXME("iface %p, index %u, rasterizer_state %p stub!\n", iface, index, rasterizer_state);
5960
5961     return E_NOTIMPL;
5962 }
5963
5964 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetBackingStore(ID3D10EffectRasterizerVariable *iface,
5965         UINT index, D3D10_RASTERIZER_DESC *desc)
5966 {
5967     FIXME("iface %p, index %u, desc %p stub!\n", iface, index, desc);
5968
5969     return E_NOTIMPL;
5970 }
5971
5972
5973 static const struct ID3D10EffectRasterizerVariableVtbl d3d10_effect_rasterizer_variable_vtbl =
5974 {
5975     /* ID3D10EffectVariable methods */
5976     d3d10_effect_rasterizer_variable_IsValid,
5977     d3d10_effect_rasterizer_variable_GetType,
5978     d3d10_effect_rasterizer_variable_GetDesc,
5979     d3d10_effect_rasterizer_variable_GetAnnotationByIndex,
5980     d3d10_effect_rasterizer_variable_GetAnnotationByName,
5981     d3d10_effect_rasterizer_variable_GetMemberByIndex,
5982     d3d10_effect_rasterizer_variable_GetMemberByName,
5983     d3d10_effect_rasterizer_variable_GetMemberBySemantic,
5984     d3d10_effect_rasterizer_variable_GetElement,
5985     d3d10_effect_rasterizer_variable_GetParentConstantBuffer,
5986     d3d10_effect_rasterizer_variable_AsScalar,
5987     d3d10_effect_rasterizer_variable_AsVector,
5988     d3d10_effect_rasterizer_variable_AsMatrix,
5989     d3d10_effect_rasterizer_variable_AsString,
5990     d3d10_effect_rasterizer_variable_AsShaderResource,
5991     d3d10_effect_rasterizer_variable_AsRenderTargetView,
5992     d3d10_effect_rasterizer_variable_AsDepthStencilView,
5993     d3d10_effect_rasterizer_variable_AsConstantBuffer,
5994     d3d10_effect_rasterizer_variable_AsShader,
5995     d3d10_effect_rasterizer_variable_AsBlend,
5996     d3d10_effect_rasterizer_variable_AsDepthStencil,
5997     d3d10_effect_rasterizer_variable_AsRasterizer,
5998     d3d10_effect_rasterizer_variable_AsSampler,
5999     d3d10_effect_rasterizer_variable_SetRawValue,
6000     d3d10_effect_rasterizer_variable_GetRawValue,
6001     /* ID3D10EffectRasterizerVariable methods */
6002     d3d10_effect_rasterizer_variable_GetRasterizerState,
6003     d3d10_effect_rasterizer_variable_GetBackingStore,
6004 };
6005
6006 /* ID3D10EffectVariable methods */
6007
6008 static BOOL STDMETHODCALLTYPE d3d10_effect_sampler_variable_IsValid(ID3D10EffectSamplerVariable *iface)
6009 {
6010     TRACE("iface %p\n", iface);
6011
6012     return (struct d3d10_effect_variable *)iface != &null_sampler_variable;
6013 }
6014
6015 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetType(
6016         ID3D10EffectSamplerVariable *iface)
6017 {
6018     return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
6019 }
6020
6021 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetDesc(ID3D10EffectSamplerVariable *iface,
6022         D3D10_EFFECT_VARIABLE_DESC *desc)
6023 {
6024     return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
6025 }
6026
6027 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetAnnotationByIndex(
6028         ID3D10EffectSamplerVariable *iface, UINT index)
6029 {
6030     return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6031 }
6032
6033 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetAnnotationByName(
6034         ID3D10EffectSamplerVariable *iface, LPCSTR name)
6035 {
6036     return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6037 }
6038
6039 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberByIndex(
6040         ID3D10EffectSamplerVariable *iface, UINT index)
6041 {
6042     return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6043 }
6044
6045 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberByName(
6046         ID3D10EffectSamplerVariable *iface, LPCSTR name)
6047 {
6048     return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6049 }
6050
6051 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberBySemantic(
6052         ID3D10EffectSamplerVariable *iface, LPCSTR semantic)
6053 {
6054     return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6055 }
6056
6057 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetElement(
6058         ID3D10EffectSamplerVariable *iface, UINT index)
6059 {
6060     return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6061 }
6062
6063 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetParentConstantBuffer(
6064         ID3D10EffectSamplerVariable *iface)
6065 {
6066     return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6067 }
6068
6069 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsScalar(
6070         ID3D10EffectSamplerVariable *iface)
6071 {
6072     return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6073 }
6074
6075 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsVector(
6076         ID3D10EffectSamplerVariable *iface)
6077 {
6078     return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6079 }
6080
6081 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsMatrix(
6082         ID3D10EffectSamplerVariable *iface)
6083 {
6084     return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6085 }
6086
6087 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsString(
6088         ID3D10EffectSamplerVariable *iface)
6089 {
6090     return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6091 }
6092
6093 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsShaderResource(
6094         ID3D10EffectSamplerVariable *iface)
6095 {
6096     return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6097 }
6098
6099 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsRenderTargetView(
6100         ID3D10EffectSamplerVariable *iface)
6101 {
6102     return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6103 }
6104
6105 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsDepthStencilView(
6106         ID3D10EffectSamplerVariable *iface)
6107 {
6108     return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6109 }
6110
6111 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsConstantBuffer(
6112         ID3D10EffectSamplerVariable *iface)
6113 {
6114     return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6115 }
6116
6117 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsShader(
6118         ID3D10EffectSamplerVariable *iface)
6119 {
6120     return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6121 }
6122
6123 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsBlend(
6124         ID3D10EffectSamplerVariable *iface)
6125 {
6126     return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6127 }
6128
6129 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsDepthStencil(
6130         ID3D10EffectSamplerVariable *iface)
6131 {
6132     return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6133 }
6134
6135 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsRasterizer(
6136         ID3D10EffectSamplerVariable *iface)
6137 {
6138     return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6139 }
6140
6141 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsSampler(
6142         ID3D10EffectSamplerVariable *iface)
6143 {
6144     return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6145 }
6146
6147 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_SetRawValue(ID3D10EffectSamplerVariable *iface,
6148         void *data, UINT offset, UINT count)
6149 {
6150     return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6151 }
6152
6153 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetRawValue(ID3D10EffectSamplerVariable *iface,
6154         void *data, UINT offset, UINT count)
6155 {
6156     return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6157 }
6158
6159 /* ID3D10EffectSamplerVariable methods */
6160
6161 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetSampler(ID3D10EffectSamplerVariable *iface,
6162         UINT index, ID3D10SamplerState **sampler)
6163 {
6164     FIXME("iface %p, index %u, sampler %p stub!\n", iface, index, sampler);
6165
6166     return E_NOTIMPL;
6167 }
6168
6169 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetBackingStore(ID3D10EffectSamplerVariable *iface,
6170         UINT index, D3D10_SAMPLER_DESC *desc)
6171 {
6172     FIXME("iface %p, index %u, desc %p stub!\n", iface, index, desc);
6173
6174     return E_NOTIMPL;
6175 }
6176
6177
6178 static const struct ID3D10EffectSamplerVariableVtbl d3d10_effect_sampler_variable_vtbl =
6179 {
6180     /* ID3D10EffectVariable methods */
6181     d3d10_effect_sampler_variable_IsValid,
6182     d3d10_effect_sampler_variable_GetType,
6183     d3d10_effect_sampler_variable_GetDesc,
6184     d3d10_effect_sampler_variable_GetAnnotationByIndex,
6185     d3d10_effect_sampler_variable_GetAnnotationByName,
6186     d3d10_effect_sampler_variable_GetMemberByIndex,
6187     d3d10_effect_sampler_variable_GetMemberByName,
6188     d3d10_effect_sampler_variable_GetMemberBySemantic,
6189     d3d10_effect_sampler_variable_GetElement,
6190     d3d10_effect_sampler_variable_GetParentConstantBuffer,
6191     d3d10_effect_sampler_variable_AsScalar,
6192     d3d10_effect_sampler_variable_AsVector,
6193     d3d10_effect_sampler_variable_AsMatrix,
6194     d3d10_effect_sampler_variable_AsString,
6195     d3d10_effect_sampler_variable_AsShaderResource,
6196     d3d10_effect_sampler_variable_AsRenderTargetView,
6197     d3d10_effect_sampler_variable_AsDepthStencilView,
6198     d3d10_effect_sampler_variable_AsConstantBuffer,
6199     d3d10_effect_sampler_variable_AsShader,
6200     d3d10_effect_sampler_variable_AsBlend,
6201     d3d10_effect_sampler_variable_AsDepthStencil,
6202     d3d10_effect_sampler_variable_AsRasterizer,
6203     d3d10_effect_sampler_variable_AsSampler,
6204     d3d10_effect_sampler_variable_SetRawValue,
6205     d3d10_effect_sampler_variable_GetRawValue,
6206     /* ID3D10EffectSamplerVariable methods */
6207     d3d10_effect_sampler_variable_GetSampler,
6208     d3d10_effect_sampler_variable_GetBackingStore,
6209 };
6210
6211 /* ID3D10EffectType methods */
6212
6213 static inline struct d3d10_effect_type *impl_from_ID3D10EffectType(ID3D10EffectType *iface)
6214 {
6215     return CONTAINING_RECORD(iface, struct d3d10_effect_type, ID3D10EffectType_iface);
6216 }
6217
6218 static BOOL STDMETHODCALLTYPE d3d10_effect_type_IsValid(ID3D10EffectType *iface)
6219 {
6220     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6221
6222     TRACE("iface %p\n", iface);
6223
6224     return This != &null_type;
6225 }
6226
6227 static HRESULT STDMETHODCALLTYPE d3d10_effect_type_GetDesc(ID3D10EffectType *iface, D3D10_EFFECT_TYPE_DESC *desc)
6228 {
6229     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6230
6231     TRACE("iface %p, desc %p\n", iface, desc);
6232
6233     if (This == &null_type)
6234     {
6235         WARN("Null type specified\n");
6236         return E_FAIL;
6237     }
6238
6239     if (!desc)
6240     {
6241         WARN("Invalid argument specified\n");
6242         return E_INVALIDARG;
6243     }
6244
6245     desc->TypeName = This->name;
6246     desc->Class = This->type_class;
6247     desc->Type = This->basetype;
6248     desc->Elements = This->element_count;
6249     desc->Members = This->member_count;
6250     desc->Rows = This->row_count;
6251     desc->Columns = This->column_count;
6252     desc->PackedSize = This->size_packed;
6253     desc->UnpackedSize = This->size_unpacked;
6254     desc->Stride = This->stride;
6255
6256     return S_OK;
6257 }
6258
6259 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByIndex(ID3D10EffectType *iface,
6260         UINT index)
6261 {
6262     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6263     struct d3d10_effect_type *t;
6264
6265     TRACE("iface %p, index %u\n", iface, index);
6266
6267     if (index >= This->member_count)
6268     {
6269         WARN("Invalid index specified\n");
6270         return &null_type.ID3D10EffectType_iface;
6271     }
6272
6273     t = (&This->members[index])->type;
6274
6275     TRACE("Returning member %p, %s\n", t, debugstr_a(t->name));
6276
6277     return &t->ID3D10EffectType_iface;
6278 }
6279
6280 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByName(ID3D10EffectType *iface,
6281         LPCSTR name)
6282 {
6283     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6284     unsigned int i;
6285
6286     TRACE("iface %p, name %s\n", iface, debugstr_a(name));
6287
6288     if (!name)
6289     {
6290         WARN("Invalid name specified\n");
6291         return &null_type.ID3D10EffectType_iface;
6292     }
6293
6294     for (i = 0; i < This->member_count; ++i)
6295     {
6296         struct d3d10_effect_type_member *typem = &This->members[i];
6297
6298         if (typem->name)
6299         {
6300             if (!strcmp(typem->name, name))
6301             {
6302                 TRACE("Returning type %p.\n", typem->type);
6303                 return &typem->type->ID3D10EffectType_iface;
6304             }
6305         }
6306     }
6307
6308     WARN("Invalid name specified\n");
6309
6310     return &null_type.ID3D10EffectType_iface;
6311 }
6312
6313 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeBySemantic(ID3D10EffectType *iface,
6314         LPCSTR semantic)
6315 {
6316     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6317     unsigned int i;
6318
6319     TRACE("iface %p, semantic %s\n", iface, debugstr_a(semantic));
6320
6321     if (!semantic)
6322     {
6323         WARN("Invalid semantic specified\n");
6324         return &null_type.ID3D10EffectType_iface;
6325     }
6326
6327     for (i = 0; i < This->member_count; ++i)
6328     {
6329         struct d3d10_effect_type_member *typem = &This->members[i];
6330
6331         if (typem->semantic)
6332         {
6333             if (!strcmp(typem->semantic, semantic))
6334             {
6335                 TRACE("Returning type %p.\n", typem->type);
6336                 return &typem->type->ID3D10EffectType_iface;
6337             }
6338         }
6339     }
6340
6341     WARN("Invalid semantic specified\n");
6342
6343     return &null_type.ID3D10EffectType_iface;
6344 }
6345
6346 static LPCSTR STDMETHODCALLTYPE d3d10_effect_type_GetMemberName(ID3D10EffectType *iface, UINT index)
6347 {
6348     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6349     struct d3d10_effect_type_member *typem;
6350
6351     TRACE("iface %p, index %u\n", iface, index);
6352
6353     if (index >= This->member_count)
6354     {
6355         WARN("Invalid index specified\n");
6356         return NULL;
6357     }
6358
6359     typem = &This->members[index];
6360
6361     TRACE("Returning name %s\n", debugstr_a(typem->name));
6362
6363     return typem->name;
6364 }
6365
6366 static LPCSTR STDMETHODCALLTYPE d3d10_effect_type_GetMemberSemantic(ID3D10EffectType *iface, UINT index)
6367 {
6368     struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6369     struct d3d10_effect_type_member *typem;
6370
6371     TRACE("iface %p, index %u\n", iface, index);
6372
6373     if (index >= This->member_count)
6374     {
6375         WARN("Invalid index specified\n");
6376         return NULL;
6377     }
6378
6379     typem = &This->members[index];
6380
6381     TRACE("Returning semantic %s\n", debugstr_a(typem->semantic));
6382
6383     return typem->semantic;
6384 }
6385
6386 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl =
6387 {
6388     /* ID3D10EffectType */
6389     d3d10_effect_type_IsValid,
6390     d3d10_effect_type_GetDesc,
6391     d3d10_effect_type_GetMemberTypeByIndex,
6392     d3d10_effect_type_GetMemberTypeByName,
6393     d3d10_effect_type_GetMemberTypeBySemantic,
6394     d3d10_effect_type_GetMemberName,
6395     d3d10_effect_type_GetMemberSemantic,
6396 };