2 * Copyright 2009 Henri Verbeet for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include "wine/port.h"
23 #include "d3d10_private.h"
25 WINE_DEFAULT_DEBUG_CHANNEL(d3d10
);
27 #define MAKE_TAG(ch0, ch1, ch2, ch3) \
28 ((DWORD)(ch0) | ((DWORD)(ch1) << 8) | \
29 ((DWORD)(ch2) << 16) | ((DWORD)(ch3) << 24 ))
30 #define TAG_DXBC MAKE_TAG('D', 'X', 'B', 'C')
31 #define TAG_FX10 MAKE_TAG('F', 'X', '1', '0')
32 #define TAG_ISGN MAKE_TAG('I', 'S', 'G', 'N')
34 #define D3D10_FX10_TYPE_COLUMN_SHIFT 11
35 #define D3D10_FX10_TYPE_COLUMN_MASK (0x7 << D3D10_FX10_TYPE_COLUMN_SHIFT)
37 #define D3D10_FX10_TYPE_ROW_SHIFT 8
38 #define D3D10_FX10_TYPE_ROW_MASK (0x7 << D3D10_FX10_TYPE_ROW_SHIFT)
40 #define D3D10_FX10_TYPE_BASETYPE_SHIFT 3
41 #define D3D10_FX10_TYPE_BASETYPE_MASK (0x1f << D3D10_FX10_TYPE_BASETYPE_SHIFT)
43 #define D3D10_FX10_TYPE_CLASS_SHIFT 0
44 #define D3D10_FX10_TYPE_CLASS_MASK (0x7 << D3D10_FX10_TYPE_CLASS_SHIFT)
46 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl
;
47 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl
;
48 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl
;
49 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl
;
50 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl
;
51 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl
;
52 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl
;
53 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl
;
55 /* null objects - needed for invalid calls */
56 static struct d3d10_effect_technique null_technique
=
57 {&d3d10_effect_technique_vtbl
, NULL
, NULL
, 0, 0, NULL
, NULL
};
58 static struct d3d10_effect_pass null_pass
=
59 {&d3d10_effect_pass_vtbl
, NULL
, NULL
, 0, 0, 0, NULL
, NULL
};
60 static struct d3d10_effect_type null_type
=
61 {&d3d10_effect_type_vtbl
, 0, {NULL
, NULL
, 0}, NULL
, NULL
, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
};
62 static struct d3d10_effect_variable null_local_buffer
=
63 {(ID3D10EffectVariableVtbl
*)&d3d10_effect_constant_buffer_vtbl
,
64 NULL
, NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
};
65 static struct d3d10_effect_variable null_variable
=
66 {&d3d10_effect_variable_vtbl
, NULL
, NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
};
67 static struct d3d10_effect_variable null_scalar_variable
=
68 {(ID3D10EffectVariableVtbl
*)&d3d10_effect_scalar_variable_vtbl
,
69 NULL
, NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
};
70 static struct d3d10_effect_variable null_vector_variable
=
71 {(ID3D10EffectVariableVtbl
*)&d3d10_effect_vector_variable_vtbl
,
72 NULL
, NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
};
73 static struct d3d10_effect_variable null_matrix_variable
=
74 {(ID3D10EffectVariableVtbl
*)&d3d10_effect_matrix_variable_vtbl
,
75 NULL
, NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
};
77 static struct d3d10_effect_type
*get_fx10_type(struct d3d10_effect
*effect
, const char *data
, DWORD offset
);
79 static inline void read_dword(const char **ptr
, DWORD
*d
)
81 memcpy(d
, *ptr
, sizeof(*d
));
85 static inline void skip_dword_unknown(const char **ptr
, unsigned int count
)
90 FIXME("Skipping %u unknown DWORDs:\n", count
);
91 for (i
= 0; i
< count
; ++i
)
94 FIXME("\t0x%08x\n", d
);
98 static inline void write_dword(char **ptr
, DWORD d
)
100 memcpy(*ptr
, &d
, sizeof(d
));
104 static inline void write_dword_unknown(char **ptr
, DWORD d
)
106 FIXME("Writing unknown DWORD 0x%08x\n", d
);
110 static HRESULT
parse_dxbc(const char *data
, SIZE_T data_size
,
111 HRESULT (*chunk_handler
)(const char *data
, DWORD data_size
, DWORD tag
, void *ctx
), void *ctx
)
113 const char *ptr
= data
;
120 read_dword(&ptr
, &tag
);
121 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
125 WARN("Wrong tag.\n");
130 skip_dword_unknown(&ptr
, 4);
132 skip_dword_unknown(&ptr
, 1);
134 read_dword(&ptr
, &total_size
);
135 TRACE("total size: %#x\n", total_size
);
137 read_dword(&ptr
, &chunk_count
);
138 TRACE("chunk count: %#x\n", chunk_count
);
140 for (i
= 0; i
< chunk_count
; ++i
)
142 DWORD chunk_tag
, chunk_size
;
143 const char *chunk_ptr
;
146 read_dword(&ptr
, &chunk_offset
);
147 TRACE("chunk %u at offset %#x\n", i
, chunk_offset
);
149 chunk_ptr
= data
+ chunk_offset
;
151 read_dword(&chunk_ptr
, &chunk_tag
);
152 read_dword(&chunk_ptr
, &chunk_size
);
154 hr
= chunk_handler(chunk_ptr
, chunk_size
, chunk_tag
, ctx
);
155 if (FAILED(hr
)) break;
161 static BOOL
copy_name(const char *ptr
, char **name
)
165 if (!ptr
) return TRUE
;
167 name_len
= strlen(ptr
) + 1;
173 *name
= HeapAlloc(GetProcessHeap(), 0, name_len
);
176 ERR("Failed to allocate name memory.\n");
180 memcpy(*name
, ptr
, name_len
);
185 static HRESULT
shader_chunk_handler(const char *data
, DWORD data_size
, DWORD tag
, void *ctx
)
187 struct d3d10_effect_shader_variable
*s
= ctx
;
189 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
191 TRACE("chunk size: %#x\n", data_size
);
197 /* 32 (DXBC header) + 1 * 4 (chunk index) + 2 * 4 (chunk header) + data_size (chunk data) */
198 UINT size
= 44 + data_size
;
201 s
->input_signature
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
202 if (!s
->input_signature
)
204 ERR("Failed to allocate input signature data\n");
205 return E_OUTOFMEMORY
;
207 s
->input_signature_size
= size
;
209 ptr
= s
->input_signature
;
211 write_dword(&ptr
, TAG_DXBC
);
214 write_dword_unknown(&ptr
, 0);
215 write_dword_unknown(&ptr
, 0);
216 write_dword_unknown(&ptr
, 0);
217 write_dword_unknown(&ptr
, 0);
219 /* seems to be always 1 */
220 write_dword_unknown(&ptr
, 1);
223 write_dword(&ptr
, size
);
226 write_dword(&ptr
, 1);
229 write_dword(&ptr
, (ptr
- s
->input_signature
) + 4);
232 write_dword(&ptr
, TAG_ISGN
);
233 write_dword(&ptr
, data_size
);
234 memcpy(ptr
, data
, data_size
);
239 FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag
, 4));
246 static HRESULT
parse_shader(struct d3d10_effect_object
*o
, const char *data
)
248 ID3D10Device
*device
= o
->pass
->technique
->effect
->device
;
249 struct d3d10_effect_shader_variable
*s
;
250 const char *ptr
= data
;
254 o
->data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(struct d3d10_effect_shader_variable
));
257 ERR("Failed to allocate shader variable memory\n");
258 return E_OUTOFMEMORY
;
261 if (!ptr
) return S_OK
;
265 read_dword(&ptr
, &dxbc_size
);
266 TRACE("dxbc size: %#x\n", dxbc_size
);
270 case D3D10_EOT_VERTEXSHADER
:
271 hr
= ID3D10Device_CreateVertexShader(device
, ptr
, dxbc_size
, &s
->shader
.vs
);
272 if (FAILED(hr
)) return hr
;
275 case D3D10_EOT_PIXELSHADER
:
276 hr
= ID3D10Device_CreatePixelShader(device
, ptr
, dxbc_size
, &s
->shader
.ps
);
277 if (FAILED(hr
)) return hr
;
279 case D3D10_EOT_GEOMETRYSHADER
:
280 hr
= ID3D10Device_CreateGeometryShader(device
, ptr
, dxbc_size
, &s
->shader
.gs
);
281 if (FAILED(hr
)) return hr
;
285 return parse_dxbc(ptr
, dxbc_size
, shader_chunk_handler
, s
);
288 static D3D10_SHADER_VARIABLE_CLASS
d3d10_variable_class(DWORD c
)
292 case 1: return D3D10_SVC_SCALAR
;
293 case 2: return D3D10_SVC_VECTOR
;
294 case 3: return D3D10_SVC_MATRIX_ROWS
;
296 FIXME("Unknown variable class %#x.\n", c
);
301 static D3D10_SHADER_VARIABLE_TYPE
d3d10_variable_type(DWORD t
)
305 case 1: return D3D10_SVT_FLOAT
;
306 case 2: return D3D10_SVT_INT
;
307 case 3: return D3D10_SVT_UINT
;
308 case 4: return D3D10_SVT_BOOL
;
310 FIXME("Unknown variable type %#x.\n", t
);
315 static HRESULT
parse_fx10_type(struct d3d10_effect_type
*t
, const char *ptr
, const char *data
)
320 read_dword(&ptr
, &offset
);
321 TRACE("Type name at offset %#x.\n", offset
);
323 if (!copy_name(data
+ offset
, &t
->name
))
325 ERR("Failed to copy name.\n");
326 return E_OUTOFMEMORY
;
328 TRACE("Type name: %s.\n", debugstr_a(t
->name
));
330 read_dword(&ptr
, &unknown0
);
331 TRACE("Unknown 0: %u.\n", unknown0
);
333 read_dword(&ptr
, &t
->element_count
);
334 TRACE("Element count: %u.\n", t
->element_count
);
336 read_dword(&ptr
, &t
->size_unpacked
);
337 TRACE("Unpacked size: %#x.\n", t
->size_unpacked
);
339 read_dword(&ptr
, &t
->stride
);
340 TRACE("Stride: %#x.\n", t
->stride
);
342 read_dword(&ptr
, &t
->size_packed
);
343 TRACE("Packed size %#x.\n", t
->size_packed
);
351 read_dword(&ptr
, &tmp
);
352 t
->column_count
= (tmp
& D3D10_FX10_TYPE_COLUMN_MASK
) >> D3D10_FX10_TYPE_COLUMN_SHIFT
;
353 t
->row_count
= (tmp
& D3D10_FX10_TYPE_ROW_MASK
) >> D3D10_FX10_TYPE_ROW_SHIFT
;
354 t
->basetype
= d3d10_variable_type((tmp
& D3D10_FX10_TYPE_BASETYPE_MASK
) >> D3D10_FX10_TYPE_BASETYPE_SHIFT
);
355 t
->type_class
= d3d10_variable_class((tmp
& D3D10_FX10_TYPE_CLASS_MASK
) >> D3D10_FX10_TYPE_CLASS_SHIFT
);
357 TRACE("Type description: %#x.\n", tmp
);
358 TRACE("\tcolumns: %u.\n", t
->column_count
);
359 TRACE("\trows: %u.\n", t
->row_count
);
360 TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t
->basetype
));
361 TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t
->type_class
));
362 TRACE("\tunknown bits: %#x.\n", tmp
& ~(D3D10_FX10_TYPE_COLUMN_MASK
| D3D10_FX10_TYPE_ROW_MASK
363 | D3D10_FX10_TYPE_BASETYPE_MASK
| D3D10_FX10_TYPE_CLASS_MASK
));
365 else if (unknown0
== 3)
369 TRACE("Type is a structure.\n");
371 read_dword(&ptr
, &t
->member_count
);
372 TRACE("Member count: %u.\n", t
->member_count
);
377 t
->type_class
= D3D10_SVC_STRUCT
;
379 t
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, t
->member_count
* sizeof(*t
->members
));
382 ERR("Failed to allocate members memory.\n");
383 return E_OUTOFMEMORY
;
386 for (i
= 0; i
< t
->member_count
; ++i
)
388 struct d3d10_effect_type_member
*typem
= &t
->members
[i
];
390 read_dword(&ptr
, &offset
);
391 TRACE("Member name at offset %#x.\n", offset
);
393 if (!copy_name(data
+ offset
, &typem
->name
))
395 ERR("Failed to copy name.\n");
396 return E_OUTOFMEMORY
;
398 TRACE("Member name: %s.\n", debugstr_a(typem
->name
));
400 read_dword(&ptr
, &offset
);
401 TRACE("Member semantic at offset %#x.\n", offset
);
403 if (!copy_name(data
+ offset
, &typem
->semantic
))
405 ERR("Failed to copy semantic.\n");
406 return E_OUTOFMEMORY
;
408 TRACE("Member semantic: %s.\n", debugstr_a(typem
->semantic
));
410 read_dword(&ptr
, &typem
->buffer_offset
);
411 TRACE("Member offset in struct: %#x.\n", typem
->buffer_offset
);
413 read_dword(&ptr
, &offset
);
414 TRACE("Member type info at offset %#x.\n", offset
);
416 typem
->type
= get_fx10_type(t
->effect
, data
, offset
);
419 ERR("Failed to get variable type.\n");
428 static struct d3d10_effect_type
*get_fx10_type(struct d3d10_effect
*effect
, const char *data
, DWORD offset
)
430 struct d3d10_effect_type
*type
;
431 struct wine_rb_entry
*entry
;
434 entry
= wine_rb_get(&effect
->types
, &offset
);
437 TRACE("Returning existing type.\n");
438 return WINE_RB_ENTRY_VALUE(entry
, struct d3d10_effect_type
, entry
);
441 type
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*type
));
444 ERR("Failed to allocate type memory.\n");
448 type
->vtbl
= &d3d10_effect_type_vtbl
;
450 type
->effect
= effect
;
451 hr
= parse_fx10_type(type
, data
+ offset
, data
);
454 ERR("Failed to parse type info, hr %#x.\n", hr
);
455 HeapFree(GetProcessHeap(), 0, type
);
459 if (wine_rb_put(&effect
->types
, &offset
, &type
->entry
) == -1)
461 ERR("Failed to insert type entry.\n");
462 HeapFree(GetProcessHeap(), 0, type
);
469 static void set_variable_vtbl(struct d3d10_effect_variable
*v
)
471 switch (v
->type
->type_class
)
473 case D3D10_SVC_SCALAR
:
474 v
->vtbl
= (ID3D10EffectVariableVtbl
*)&d3d10_effect_scalar_variable_vtbl
;
477 case D3D10_SVC_VECTOR
:
478 v
->vtbl
= (ID3D10EffectVariableVtbl
*)&d3d10_effect_vector_variable_vtbl
;
481 case D3D10_SVC_MATRIX_ROWS
:
482 case D3D10_SVC_MATRIX_COLUMNS
:
483 v
->vtbl
= (ID3D10EffectVariableVtbl
*)&d3d10_effect_matrix_variable_vtbl
;
487 FIXME("Unhandled type class %s.\n", debug_d3d10_shader_variable_class(v
->type
->type_class
));
488 v
->vtbl
= &d3d10_effect_variable_vtbl
;
493 static HRESULT
copy_variableinfo_from_type(struct d3d10_effect_variable
*v
)
497 if (v
->type
->member_count
== 0) return S_OK
;
499 v
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, v
->type
->member_count
* sizeof(*v
->members
));
502 ERR("Failed to allocate members memory.\n");
503 return E_OUTOFMEMORY
;
506 for (i
= 0; i
< v
->type
->member_count
; ++i
)
508 struct d3d10_effect_variable
*var
= &v
->members
[i
];
509 struct d3d10_effect_type_member
*typem
= &v
->type
->members
[i
];
513 var
->effect
= v
->effect
;
514 var
->type
= typem
->type
;
515 set_variable_vtbl(var
);
517 if (!copy_name(typem
->name
, &var
->name
))
519 ERR("Failed to copy name.\n");
520 return E_OUTOFMEMORY
;
522 TRACE("Variable name: %s.\n", debugstr_a(var
->name
));
524 if (!copy_name(typem
->semantic
, &var
->semantic
))
526 ERR("Failed to copy name.\n");
527 return E_OUTOFMEMORY
;
529 TRACE("Variable semantic: %s.\n", debugstr_a(var
->semantic
));
531 var
->buffer_offset
= typem
->buffer_offset
;
532 TRACE("Variable buffer offset: %u.\n", var
->buffer_offset
);
534 hr
= copy_variableinfo_from_type(var
);
535 if (FAILED(hr
)) return hr
;
541 static HRESULT
parse_fx10_variable_head(struct d3d10_effect_variable
*v
, const char **ptr
, const char *data
)
545 read_dword(ptr
, &offset
);
546 TRACE("Variable name at offset %#x.\n", offset
);
548 if (!copy_name(data
+ offset
, &v
->name
))
550 ERR("Failed to copy name.\n");
551 return E_OUTOFMEMORY
;
553 TRACE("Variable name: %s.\n", debugstr_a(v
->name
));
555 read_dword(ptr
, &offset
);
556 TRACE("Variable type info at offset %#x.\n", offset
);
558 v
->type
= get_fx10_type(v
->effect
, data
, offset
);
561 ERR("Failed to get variable type.\n");
564 set_variable_vtbl(v
);
566 return copy_variableinfo_from_type(v
);
569 static HRESULT
parse_fx10_annotation(struct d3d10_effect_variable
*a
, const char **ptr
, const char *data
)
573 hr
= parse_fx10_variable_head(a
, ptr
, data
);
574 if (FAILED(hr
)) return hr
;
576 skip_dword_unknown(ptr
, 1);
581 static HRESULT
parse_fx10_object(struct d3d10_effect_object
*o
, const char **ptr
, const char *data
)
583 const char *data_ptr
;
587 read_dword(ptr
, &o
->type
);
588 TRACE("Effect object is of type %#x.\n", o
->type
);
590 skip_dword_unknown(ptr
, 2);
592 read_dword(ptr
, &offset
);
593 TRACE("Effect object idx is at offset %#x.\n", offset
);
595 data_ptr
= data
+ offset
;
596 read_dword(&data_ptr
, &offset
);
598 TRACE("Effect object starts at offset %#x.\n", offset
);
600 /* FIXME: This probably isn't completely correct. */
603 WARN("Skipping effect object.\n");
608 data_ptr
= data
+ offset
;
613 case D3D10_EOT_VERTEXSHADER
:
614 TRACE("Vertex shader\n");
615 hr
= parse_shader(o
, data_ptr
);
618 case D3D10_EOT_PIXELSHADER
:
619 TRACE("Pixel shader\n");
620 hr
= parse_shader(o
, data_ptr
);
623 case D3D10_EOT_GEOMETRYSHADER
:
624 TRACE("Geometry shader\n");
625 hr
= parse_shader(o
, data_ptr
);
629 FIXME("Unhandled object type %#x\n", o
->type
);
637 static HRESULT
parse_fx10_pass(struct d3d10_effect_pass
*p
, const char **ptr
, const char *data
)
643 read_dword(ptr
, &offset
);
644 TRACE("Pass name at offset %#x.\n", offset
);
646 if (!copy_name(data
+ offset
, &p
->name
))
648 ERR("Failed to copy name.\n");
649 return E_OUTOFMEMORY
;
651 TRACE("Pass name: %s.\n", debugstr_a(p
->name
));
653 read_dword(ptr
, &p
->object_count
);
654 TRACE("Pass has %u effect objects.\n", p
->object_count
);
656 read_dword(ptr
, &p
->annotation_count
);
657 TRACE("Pass has %u annotations.\n", p
->annotation_count
);
659 p
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, p
->annotation_count
* sizeof(*p
->annotations
));
662 ERR("Failed to allocate pass annotations memory.\n");
663 return E_OUTOFMEMORY
;
666 for(i
= 0; i
< p
->annotation_count
; ++i
)
668 struct d3d10_effect_variable
*a
= &p
->annotations
[i
];
670 a
->effect
= p
->technique
->effect
;
672 hr
= parse_fx10_annotation(a
, ptr
, data
);
673 if (FAILED(hr
)) return hr
;
676 p
->objects
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, p
->object_count
* sizeof(*p
->objects
));
679 ERR("Failed to allocate effect objects memory.\n");
680 return E_OUTOFMEMORY
;
683 for (i
= 0; i
< p
->object_count
; ++i
)
685 struct d3d10_effect_object
*o
= &p
->objects
[i
];
689 hr
= parse_fx10_object(o
, ptr
, data
);
690 if (FAILED(hr
)) return hr
;
696 static HRESULT
parse_fx10_technique(struct d3d10_effect_technique
*t
, const char **ptr
, const char *data
)
702 read_dword(ptr
, &offset
);
703 TRACE("Technique name at offset %#x.\n", offset
);
705 if (!copy_name(data
+ offset
, &t
->name
))
707 ERR("Failed to copy name.\n");
708 return E_OUTOFMEMORY
;
710 TRACE("Technique name: %s.\n", debugstr_a(t
->name
));
712 read_dword(ptr
, &t
->pass_count
);
713 TRACE("Technique has %u passes\n", t
->pass_count
);
715 read_dword(ptr
, &t
->annotation_count
);
716 TRACE("Technique has %u annotations.\n", t
->annotation_count
);
718 t
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, t
->annotation_count
* sizeof(*t
->annotations
));
721 ERR("Failed to allocate technique annotations memory.\n");
722 return E_OUTOFMEMORY
;
725 for(i
= 0; i
< t
->annotation_count
; ++i
)
727 struct d3d10_effect_variable
*a
= &t
->annotations
[i
];
729 a
->effect
= t
->effect
;
731 hr
= parse_fx10_annotation(a
, ptr
, data
);
732 if (FAILED(hr
)) return hr
;
735 t
->passes
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, t
->pass_count
* sizeof(*t
->passes
));
738 ERR("Failed to allocate passes memory\n");
739 return E_OUTOFMEMORY
;
742 for (i
= 0; i
< t
->pass_count
; ++i
)
744 struct d3d10_effect_pass
*p
= &t
->passes
[i
];
746 p
->vtbl
= &d3d10_effect_pass_vtbl
;
749 hr
= parse_fx10_pass(p
, ptr
, data
);
750 if (FAILED(hr
)) return hr
;
756 static HRESULT
parse_fx10_variable(struct d3d10_effect_variable
*v
, const char **ptr
, const char *data
)
762 hr
= parse_fx10_variable_head(v
, ptr
, data
);
763 if (FAILED(hr
)) return hr
;
765 read_dword(ptr
, &offset
);
766 TRACE("Variable semantic at offset %#x.\n", offset
);
768 if (!copy_name(data
+ offset
, &v
->semantic
))
770 ERR("Failed to copy semantic.\n");
771 return E_OUTOFMEMORY
;
773 TRACE("Variable semantic: %s.\n", debugstr_a(v
->semantic
));
775 read_dword(ptr
, &v
->buffer_offset
);
776 TRACE("Variable offset in buffer: %#x.\n", v
->buffer_offset
);
778 skip_dword_unknown(ptr
, 1);
780 read_dword(ptr
, &v
->flag
);
781 TRACE("Variable flag: %#x.\n", v
->flag
);
783 read_dword(ptr
, &v
->annotation_count
);
784 TRACE("Variable has %u annotations.\n", v
->annotation_count
);
786 v
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, v
->annotation_count
* sizeof(*v
->annotations
));
789 ERR("Failed to allocate variable annotations memory.\n");
790 return E_OUTOFMEMORY
;
793 for (i
= 0; i
< v
->annotation_count
; ++i
)
795 struct d3d10_effect_variable
*a
= &v
->annotations
[i
];
797 a
->effect
= v
->effect
;
799 hr
= parse_fx10_annotation(a
, ptr
, data
);
800 if (FAILED(hr
)) return hr
;
806 static HRESULT
parse_fx10_local_buffer(struct d3d10_effect_variable
*l
, const char **ptr
, const char *data
)
810 D3D10_CBUFFER_TYPE d3d10_cbuffer_type
;
813 /* Generate our own type, it isn't in the fx blob. */
814 l
->type
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*l
->type
));
817 ERR("Failed to allocate local buffer type memory.\n");
818 return E_OUTOFMEMORY
;
820 l
->type
->vtbl
= &d3d10_effect_type_vtbl
;
821 l
->type
->type_class
= D3D10_SVC_OBJECT
;
822 l
->type
->effect
= l
->effect
;
824 read_dword(ptr
, &offset
);
825 TRACE("Local buffer name at offset %#x.\n", offset
);
827 if (!copy_name(data
+ offset
, &l
->name
))
829 ERR("Failed to copy name.\n");
830 return E_OUTOFMEMORY
;
832 TRACE("Local buffer name: %s.\n", debugstr_a(l
->name
));
834 read_dword(ptr
, &l
->data_size
);
835 TRACE("Local buffer data size: %#x.\n", l
->data_size
);
837 read_dword(ptr
, &d3d10_cbuffer_type
);
838 TRACE("Local buffer type: %#x.\n", d3d10_cbuffer_type
);
840 switch(d3d10_cbuffer_type
)
842 case D3D10_CT_CBUFFER
:
843 l
->type
->basetype
= D3D10_SVT_CBUFFER
;
844 if (!copy_name("cbuffer", &l
->type
->name
))
846 ERR("Failed to copy name.\n");
847 return E_OUTOFMEMORY
;
851 case D3D10_CT_TBUFFER
:
852 l
->type
->basetype
= D3D10_SVT_TBUFFER
;
853 if (!copy_name("tbuffer", &l
->type
->name
))
855 ERR("Failed to copy name.\n");
856 return E_OUTOFMEMORY
;
861 ERR("Unexpected D3D10_CBUFFER_TYPE %#x!\n", d3d10_cbuffer_type
);
865 read_dword(ptr
, &l
->type
->member_count
);
866 TRACE("Local buffer member count: %#x.\n", l
->type
->member_count
);
868 skip_dword_unknown(ptr
, 1);
870 read_dword(ptr
, &l
->annotation_count
);
871 TRACE("Local buffer has %u annotations.\n", l
->annotation_count
);
873 l
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, l
->annotation_count
* sizeof(*l
->annotations
));
876 ERR("Failed to allocate local buffer annotations memory.\n");
877 return E_OUTOFMEMORY
;
880 for(i
= 0; i
< l
->annotation_count
; ++i
)
882 struct d3d10_effect_variable
*a
= &l
->annotations
[i
];
884 a
->effect
= l
->effect
;
886 hr
= parse_fx10_annotation(a
, ptr
, data
);
887 if (FAILED(hr
)) return hr
;
890 l
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, l
->type
->member_count
* sizeof(*l
->members
));
893 ERR("Failed to allocate members memory.\n");
894 return E_OUTOFMEMORY
;
897 l
->type
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, l
->type
->member_count
* sizeof(*l
->type
->members
));
898 if (!l
->type
->members
)
900 ERR("Failed to allocate type members memory.\n");
901 return E_OUTOFMEMORY
;
904 for (i
= 0; i
< l
->type
->member_count
; ++i
)
906 struct d3d10_effect_variable
*v
= &l
->members
[i
];
907 struct d3d10_effect_type_member
*typem
= &l
->type
->members
[i
];
910 v
->effect
= l
->effect
;
912 hr
= parse_fx10_variable(v
, ptr
, data
);
913 if (FAILED(hr
)) return hr
;
916 * Copy the values from the variable type to the constant buffers type
917 * members structure, because it is our own generated type.
919 typem
->type
= v
->type
;
921 if (!copy_name(v
->name
, &typem
->name
))
923 ERR("Failed to copy name.\n");
924 return E_OUTOFMEMORY
;
926 TRACE("Variable name: %s.\n", debugstr_a(typem
->name
));
928 if (!copy_name(v
->semantic
, &typem
->semantic
))
930 ERR("Failed to copy name.\n");
931 return E_OUTOFMEMORY
;
933 TRACE("Variable semantic: %s.\n", debugstr_a(typem
->semantic
));
935 typem
->buffer_offset
= v
->buffer_offset
;
936 TRACE("Variable buffer offset: %u.\n", typem
->buffer_offset
);
938 l
->type
->size_packed
+= v
->type
->size_packed
;
939 l
->type
->size_unpacked
+= v
->type
->size_unpacked
;
941 l
->type
->stride
= l
->type
->size_unpacked
= (l
->type
->size_unpacked
+ 0xf) & ~0xf;
943 TRACE("Constant buffer:\n");
944 TRACE("\tType name: %s.\n", debugstr_a(l
->type
->name
));
945 TRACE("\tElement count: %u.\n", l
->type
->element_count
);
946 TRACE("\tMember count: %u.\n", l
->type
->member_count
);
947 TRACE("\tUnpacked size: %#x.\n", l
->type
->size_unpacked
);
948 TRACE("\tStride: %#x.\n", l
->type
->stride
);
949 TRACE("\tPacked size %#x.\n", l
->type
->size_packed
);
950 TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(l
->type
->basetype
));
951 TRACE("\tTypeclass: %s.\n", debug_d3d10_shader_variable_class(l
->type
->type_class
));
956 static int d3d10_effect_type_compare(const void *key
, const struct wine_rb_entry
*entry
)
958 const struct d3d10_effect_type
*t
= WINE_RB_ENTRY_VALUE(entry
, const struct d3d10_effect_type
, entry
);
959 const DWORD
*id
= key
;
964 static void d3d10_effect_type_member_destroy(struct d3d10_effect_type_member
*typem
)
966 TRACE("effect type member %p.\n", typem
);
968 /* Do not release typem->type, it will be covered by d3d10_effect_type_destroy(). */
969 HeapFree(GetProcessHeap(), 0, typem
->semantic
);
970 HeapFree(GetProcessHeap(), 0, typem
->name
);
973 static void d3d10_effect_type_destroy(struct wine_rb_entry
*entry
, void *context
)
975 struct d3d10_effect_type
*t
= WINE_RB_ENTRY_VALUE(entry
, struct d3d10_effect_type
, entry
);
977 TRACE("effect type %p.\n", t
);
983 for (i
= 0; i
< t
->member_count
; ++i
)
985 d3d10_effect_type_member_destroy(&t
->members
[i
]);
987 HeapFree(GetProcessHeap(), 0, t
->members
);
990 HeapFree(GetProcessHeap(), 0, t
->name
);
991 HeapFree(GetProcessHeap(), 0, t
);
994 static const struct wine_rb_functions d3d10_effect_type_rb_functions
=
999 d3d10_effect_type_compare
,
1002 static HRESULT
parse_fx10_body(struct d3d10_effect
*e
, const char *data
, DWORD data_size
)
1004 const char *ptr
= data
+ e
->index_offset
;
1008 if (wine_rb_init(&e
->types
, &d3d10_effect_type_rb_functions
) == -1)
1010 ERR("Failed to initialize type rbtree.\n");
1014 e
->local_buffers
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, e
->local_buffer_count
* sizeof(*e
->local_buffers
));
1015 if (!e
->local_buffers
)
1017 ERR("Failed to allocate local buffer memory.\n");
1018 return E_OUTOFMEMORY
;
1021 e
->techniques
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, e
->technique_count
* sizeof(*e
->techniques
));
1024 ERR("Failed to allocate techniques memory\n");
1025 return E_OUTOFMEMORY
;
1028 for (i
= 0; i
< e
->local_buffer_count
; ++i
)
1030 struct d3d10_effect_variable
*l
= &e
->local_buffers
[i
];
1031 l
->vtbl
= (ID3D10EffectVariableVtbl
*)&d3d10_effect_constant_buffer_vtbl
;
1034 hr
= parse_fx10_local_buffer(l
, &ptr
, data
);
1035 if (FAILED(hr
)) return hr
;
1038 for (i
= 0; i
< e
->technique_count
; ++i
)
1040 struct d3d10_effect_technique
*t
= &e
->techniques
[i
];
1042 t
->vtbl
= &d3d10_effect_technique_vtbl
;
1045 hr
= parse_fx10_technique(t
, &ptr
, data
);
1046 if (FAILED(hr
)) return hr
;
1052 static HRESULT
parse_fx10(struct d3d10_effect
*e
, const char *data
, DWORD data_size
)
1054 const char *ptr
= data
;
1057 /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
1058 read_dword(&ptr
, &e
->version
);
1059 TRACE("Target: %#x\n", e
->version
);
1061 read_dword(&ptr
, &e
->local_buffer_count
);
1062 TRACE("Local buffer count: %u.\n", e
->local_buffer_count
);
1064 read_dword(&ptr
, &e
->variable_count
);
1065 TRACE("Variable count: %u\n", e
->variable_count
);
1067 read_dword(&ptr
, &e
->object_count
);
1068 TRACE("Object count: %u\n", e
->object_count
);
1070 read_dword(&ptr
, &e
->sharedbuffers_count
);
1071 TRACE("Sharedbuffers count: %u\n", e
->sharedbuffers_count
);
1073 /* Number of variables in shared buffers? */
1074 read_dword(&ptr
, &unknown
);
1075 FIXME("Unknown 0: %u\n", unknown
);
1077 read_dword(&ptr
, &e
->sharedobjects_count
);
1078 TRACE("Sharedobjects count: %u\n", e
->sharedobjects_count
);
1080 read_dword(&ptr
, &e
->technique_count
);
1081 TRACE("Technique count: %u\n", e
->technique_count
);
1083 read_dword(&ptr
, &e
->index_offset
);
1084 TRACE("Index offset: %#x\n", e
->index_offset
);
1086 read_dword(&ptr
, &unknown
);
1087 FIXME("Unknown 1: %u\n", unknown
);
1089 read_dword(&ptr
, &e
->texture_count
);
1090 TRACE("Texture count: %u\n", e
->texture_count
);
1092 read_dword(&ptr
, &e
->dephstencilstate_count
);
1093 TRACE("Depthstencilstate count: %u\n", e
->dephstencilstate_count
);
1095 read_dword(&ptr
, &e
->blendstate_count
);
1096 TRACE("Blendstate count: %u\n", e
->blendstate_count
);
1098 read_dword(&ptr
, &e
->rasterizerstate_count
);
1099 TRACE("Rasterizerstate count: %u\n", e
->rasterizerstate_count
);
1101 read_dword(&ptr
, &e
->samplerstate_count
);
1102 TRACE("Samplerstate count: %u\n", e
->samplerstate_count
);
1104 read_dword(&ptr
, &e
->rendertargetview_count
);
1105 TRACE("Rendertargetview count: %u\n", e
->rendertargetview_count
);
1107 read_dword(&ptr
, &e
->depthstencilview_count
);
1108 TRACE("Depthstencilview count: %u\n", e
->depthstencilview_count
);
1110 read_dword(&ptr
, &e
->shader_call_count
);
1111 TRACE("Shader call count: %u\n", e
->shader_call_count
);
1113 read_dword(&ptr
, &e
->shader_compile_count
);
1114 TRACE("Shader compile count: %u\n", e
->shader_compile_count
);
1116 return parse_fx10_body(e
, ptr
, data_size
- (ptr
- data
));
1119 static HRESULT
fx10_chunk_handler(const char *data
, DWORD data_size
, DWORD tag
, void *ctx
)
1121 struct d3d10_effect
*e
= ctx
;
1123 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
1125 TRACE("chunk size: %#x\n", data_size
);
1130 return parse_fx10(e
, data
, data_size
);
1133 FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag
, 4));
1138 HRESULT
d3d10_effect_parse(struct d3d10_effect
*This
, const void *data
, SIZE_T data_size
)
1140 return parse_dxbc(data
, data_size
, fx10_chunk_handler
, This
);
1143 static void d3d10_effect_object_destroy(struct d3d10_effect_object
*o
)
1145 TRACE("effect object %p.\n", o
);
1149 case D3D10_EOT_VERTEXSHADER
:
1150 case D3D10_EOT_PIXELSHADER
:
1151 case D3D10_EOT_GEOMETRYSHADER
:
1152 HeapFree(GetProcessHeap(), 0, ((struct d3d10_effect_shader_variable
*)o
->data
)->input_signature
);
1158 HeapFree(GetProcessHeap(), 0, o
->data
);
1161 static HRESULT
d3d10_effect_object_apply(struct d3d10_effect_object
*o
)
1163 ID3D10Device
*device
= o
->pass
->technique
->effect
->device
;
1165 TRACE("effect object %p, type %#x.\n", o
, o
->type
);
1169 case D3D10_EOT_VERTEXSHADER
:
1170 ID3D10Device_VSSetShader(device
, ((struct d3d10_effect_shader_variable
*)o
->data
)->shader
.vs
);
1173 case D3D10_EOT_PIXELSHADER
:
1174 ID3D10Device_PSSetShader(device
, ((struct d3d10_effect_shader_variable
*)o
->data
)->shader
.ps
);
1177 case D3D10_EOT_GEOMETRYSHADER
:
1178 ID3D10Device_GSSetShader(device
, ((struct d3d10_effect_shader_variable
*)o
->data
)->shader
.gs
);
1182 FIXME("Unhandled effect object type %#x.\n", o
->type
);
1187 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable
*v
)
1191 TRACE("variable %p.\n", v
);
1193 HeapFree(GetProcessHeap(), 0, v
->name
);
1194 HeapFree(GetProcessHeap(), 0, v
->semantic
);
1197 for (i
= 0; i
< v
->annotation_count
; ++i
)
1199 d3d10_effect_variable_destroy(&v
->annotations
[i
]);
1201 HeapFree(GetProcessHeap(), 0, v
->annotations
);
1206 for (i
= 0; i
< v
->type
->member_count
; ++i
)
1208 d3d10_effect_variable_destroy(&v
->members
[i
]);
1210 HeapFree(GetProcessHeap(), 0, v
->members
);
1214 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass
*p
)
1218 TRACE("pass %p\n", p
);
1220 HeapFree(GetProcessHeap(), 0, p
->name
);
1223 for (i
= 0; i
< p
->object_count
; ++i
)
1225 d3d10_effect_object_destroy(&p
->objects
[i
]);
1227 HeapFree(GetProcessHeap(), 0, p
->objects
);
1232 for (i
= 0; i
< p
->annotation_count
; ++i
)
1234 d3d10_effect_variable_destroy(&p
->annotations
[i
]);
1236 HeapFree(GetProcessHeap(), 0, p
->annotations
);
1241 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique
*t
)
1245 TRACE("technique %p\n", t
);
1247 HeapFree(GetProcessHeap(), 0, t
->name
);
1250 for (i
= 0; i
< t
->pass_count
; ++i
)
1252 d3d10_effect_pass_destroy(&t
->passes
[i
]);
1254 HeapFree(GetProcessHeap(), 0, t
->passes
);
1259 for (i
= 0; i
< t
->annotation_count
; ++i
)
1261 d3d10_effect_variable_destroy(&t
->annotations
[i
]);
1263 HeapFree(GetProcessHeap(), 0, t
->annotations
);
1267 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_variable
*l
)
1271 TRACE("local buffer %p.\n", l
);
1273 HeapFree(GetProcessHeap(), 0, l
->name
);
1276 for (i
= 0; i
< l
->type
->member_count
; ++i
)
1278 d3d10_effect_variable_destroy(&l
->members
[i
]);
1280 HeapFree(GetProcessHeap(), 0, l
->members
);
1283 if (l
->type
->members
)
1285 for (i
= 0; i
< l
->type
->member_count
; ++i
)
1287 /* Do not release l->type->members[i].type, it will be covered by d3d10_effect_type_destroy(). */
1288 HeapFree(GetProcessHeap(), 0, l
->type
->members
[i
].semantic
);
1289 HeapFree(GetProcessHeap(), 0, l
->type
->members
[i
].name
);
1291 HeapFree(GetProcessHeap(), 0, l
->type
->members
);
1293 HeapFree(GetProcessHeap(), 0, l
->type
->name
);
1294 HeapFree(GetProcessHeap(), 0, l
->type
);
1298 for (i
= 0; i
< l
->annotation_count
; ++i
)
1300 d3d10_effect_variable_destroy(&l
->annotations
[i
]);
1302 HeapFree(GetProcessHeap(), 0, l
->annotations
);
1306 /* IUnknown methods */
1308 static HRESULT STDMETHODCALLTYPE
d3d10_effect_QueryInterface(ID3D10Effect
*iface
, REFIID riid
, void **object
)
1310 TRACE("iface %p, riid %s, object %p\n", iface
, debugstr_guid(riid
), object
);
1312 if (IsEqualGUID(riid
, &IID_ID3D10Effect
)
1313 || IsEqualGUID(riid
, &IID_IUnknown
))
1315 IUnknown_AddRef(iface
);
1320 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
1323 return E_NOINTERFACE
;
1326 static ULONG STDMETHODCALLTYPE
d3d10_effect_AddRef(ID3D10Effect
*iface
)
1328 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1329 ULONG refcount
= InterlockedIncrement(&This
->refcount
);
1331 TRACE("%p increasing refcount to %u\n", This
, refcount
);
1336 static ULONG STDMETHODCALLTYPE
d3d10_effect_Release(ID3D10Effect
*iface
)
1338 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1339 ULONG refcount
= InterlockedDecrement(&This
->refcount
);
1341 TRACE("%p decreasing refcount to %u\n", This
, refcount
);
1347 if (This
->techniques
)
1349 for (i
= 0; i
< This
->technique_count
; ++i
)
1351 d3d10_effect_technique_destroy(&This
->techniques
[i
]);
1353 HeapFree(GetProcessHeap(), 0, This
->techniques
);
1356 if (This
->local_buffers
)
1358 for (i
= 0; i
< This
->local_buffer_count
; ++i
)
1360 d3d10_effect_local_buffer_destroy(&This
->local_buffers
[i
]);
1362 HeapFree(GetProcessHeap(), 0, This
->local_buffers
);
1365 wine_rb_destroy(&This
->types
, d3d10_effect_type_destroy
, NULL
);
1367 ID3D10Device_Release(This
->device
);
1368 HeapFree(GetProcessHeap(), 0, This
);
1374 /* ID3D10Effect methods */
1376 static BOOL STDMETHODCALLTYPE
d3d10_effect_IsValid(ID3D10Effect
*iface
)
1378 FIXME("iface %p stub!\n", iface
);
1383 static BOOL STDMETHODCALLTYPE
d3d10_effect_IsPool(ID3D10Effect
*iface
)
1385 FIXME("iface %p stub!\n", iface
);
1390 static HRESULT STDMETHODCALLTYPE
d3d10_effect_GetDevice(ID3D10Effect
*iface
, ID3D10Device
**device
)
1392 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1394 TRACE("iface %p, device %p\n", iface
, device
);
1396 ID3D10Device_AddRef(This
->device
);
1397 *device
= This
->device
;
1402 static HRESULT STDMETHODCALLTYPE
d3d10_effect_GetDesc(ID3D10Effect
*iface
, D3D10_EFFECT_DESC
*desc
)
1404 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
1409 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_GetConstantBufferByIndex(ID3D10Effect
*iface
,
1412 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1413 struct d3d10_effect_variable
*l
;
1415 TRACE("iface %p, index %u\n", iface
, index
);
1417 if (index
>= This
->local_buffer_count
)
1419 WARN("Invalid index specified\n");
1420 return (ID3D10EffectConstantBuffer
*)&null_local_buffer
;
1423 l
= &This
->local_buffers
[index
];
1425 TRACE("Returning buffer %p, %s.\n", l
, debugstr_a(l
->name
));
1427 return (ID3D10EffectConstantBuffer
*)l
;
1430 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_GetConstantBufferByName(ID3D10Effect
*iface
,
1433 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1436 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1438 for (i
= 0; i
< This
->local_buffer_count
; ++i
)
1440 struct d3d10_effect_variable
*l
= &This
->local_buffers
[i
];
1442 if (!strcmp(l
->name
, name
))
1444 TRACE("Returning buffer %p.\n", l
);
1445 return (ID3D10EffectConstantBuffer
*)l
;
1449 WARN("Invalid name specified\n");
1451 return (ID3D10EffectConstantBuffer
*)&null_local_buffer
;
1454 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_GetVariableByIndex(ID3D10Effect
*iface
, UINT index
)
1456 FIXME("iface %p, index %u stub!\n", iface
, index
);
1461 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_GetVariableByName(ID3D10Effect
*iface
, LPCSTR name
)
1463 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1466 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1468 for (i
= 0; i
< This
->local_buffer_count
; ++i
)
1470 struct d3d10_effect_variable
*l
= &This
->local_buffers
[i
];
1473 for (j
= 0; j
< l
->type
->member_count
; ++j
)
1475 struct d3d10_effect_variable
*v
= &l
->members
[j
];
1477 if (!strcmp(v
->name
, name
))
1479 TRACE("Returning variable %p.\n", v
);
1480 return (ID3D10EffectVariable
*)v
;
1485 WARN("Invalid name specified\n");
1487 return (ID3D10EffectVariable
*)&null_variable
;
1490 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_GetVariableBySemantic(ID3D10Effect
*iface
,
1493 FIXME("iface %p, semantic %s stub!\n", iface
, debugstr_a(semantic
));
1498 static struct ID3D10EffectTechnique
* STDMETHODCALLTYPE
d3d10_effect_GetTechniqueByIndex(ID3D10Effect
*iface
,
1501 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1502 struct d3d10_effect_technique
*t
;
1504 TRACE("iface %p, index %u\n", iface
, index
);
1506 if (index
>= This
->technique_count
)
1508 WARN("Invalid index specified\n");
1509 return (ID3D10EffectTechnique
*)&null_technique
;
1512 t
= &This
->techniques
[index
];
1514 TRACE("Returning technique %p, %s.\n", t
, debugstr_a(t
->name
));
1516 return (ID3D10EffectTechnique
*)t
;
1519 static struct ID3D10EffectTechnique
* STDMETHODCALLTYPE
d3d10_effect_GetTechniqueByName(ID3D10Effect
*iface
,
1522 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1525 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1527 for (i
= 0; i
< This
->technique_count
; ++i
)
1529 struct d3d10_effect_technique
*t
= &This
->techniques
[i
];
1530 if (!strcmp(t
->name
, name
))
1532 TRACE("Returning technique %p\n", t
);
1533 return (ID3D10EffectTechnique
*)t
;
1537 WARN("Invalid name specified\n");
1539 return (ID3D10EffectTechnique
*)&null_technique
;
1542 static HRESULT STDMETHODCALLTYPE
d3d10_effect_Optimize(ID3D10Effect
*iface
)
1544 FIXME("iface %p stub!\n", iface
);
1549 static BOOL STDMETHODCALLTYPE
d3d10_effect_IsOptimized(ID3D10Effect
*iface
)
1551 FIXME("iface %p stub!\n", iface
);
1556 const struct ID3D10EffectVtbl d3d10_effect_vtbl
=
1558 /* IUnknown methods */
1559 d3d10_effect_QueryInterface
,
1560 d3d10_effect_AddRef
,
1561 d3d10_effect_Release
,
1562 /* ID3D10Effect methods */
1563 d3d10_effect_IsValid
,
1564 d3d10_effect_IsPool
,
1565 d3d10_effect_GetDevice
,
1566 d3d10_effect_GetDesc
,
1567 d3d10_effect_GetConstantBufferByIndex
,
1568 d3d10_effect_GetConstantBufferByName
,
1569 d3d10_effect_GetVariableByIndex
,
1570 d3d10_effect_GetVariableByName
,
1571 d3d10_effect_GetVariableBySemantic
,
1572 d3d10_effect_GetTechniqueByIndex
,
1573 d3d10_effect_GetTechniqueByName
,
1574 d3d10_effect_Optimize
,
1575 d3d10_effect_IsOptimized
,
1578 /* ID3D10EffectTechnique methods */
1580 static BOOL STDMETHODCALLTYPE
d3d10_effect_technique_IsValid(ID3D10EffectTechnique
*iface
)
1582 TRACE("iface %p\n", iface
);
1584 return (struct d3d10_effect_technique
*)iface
!= &null_technique
;
1587 static HRESULT STDMETHODCALLTYPE
d3d10_effect_technique_GetDesc(ID3D10EffectTechnique
*iface
,
1588 D3D10_TECHNIQUE_DESC
*desc
)
1590 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1592 TRACE("iface %p, desc %p\n", iface
, desc
);
1594 if(This
== &null_technique
)
1596 WARN("Null technique specified\n");
1602 WARN("Invalid argument specified\n");
1603 return E_INVALIDARG
;
1606 desc
->Name
= This
->name
;
1607 desc
->Passes
= This
->pass_count
;
1608 desc
->Annotations
= This
->annotation_count
;
1613 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_technique_GetAnnotationByIndex(
1614 ID3D10EffectTechnique
*iface
, UINT index
)
1616 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1617 struct d3d10_effect_variable
*a
;
1619 TRACE("iface %p, index %u\n", iface
, index
);
1621 if (index
>= This
->annotation_count
)
1623 WARN("Invalid index specified\n");
1624 return (ID3D10EffectVariable
*)&null_variable
;
1627 a
= &This
->annotations
[index
];
1629 TRACE("Returning annotation %p, %s\n", a
, debugstr_a(a
->name
));
1631 return (ID3D10EffectVariable
*)a
;
1634 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_technique_GetAnnotationByName(
1635 ID3D10EffectTechnique
*iface
, LPCSTR name
)
1637 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1640 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1642 for (i
= 0; i
< This
->annotation_count
; ++i
)
1644 struct d3d10_effect_variable
*a
= &This
->annotations
[i
];
1645 if (!strcmp(a
->name
, name
))
1647 TRACE("Returning annotation %p\n", a
);
1648 return (ID3D10EffectVariable
*)a
;
1652 WARN("Invalid name specified\n");
1654 return (ID3D10EffectVariable
*)&null_variable
;
1657 static struct ID3D10EffectPass
* STDMETHODCALLTYPE
d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique
*iface
,
1660 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1661 struct d3d10_effect_pass
*p
;
1663 TRACE("iface %p, index %u\n", iface
, index
);
1665 if (index
>= This
->pass_count
)
1667 WARN("Invalid index specified\n");
1668 return (ID3D10EffectPass
*)&null_pass
;
1671 p
= &This
->passes
[index
];
1673 TRACE("Returning pass %p, %s.\n", p
, debugstr_a(p
->name
));
1675 return (ID3D10EffectPass
*)p
;
1678 static struct ID3D10EffectPass
* STDMETHODCALLTYPE
d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique
*iface
,
1681 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1684 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1686 for (i
= 0; i
< This
->pass_count
; ++i
)
1688 struct d3d10_effect_pass
*p
= &This
->passes
[i
];
1689 if (!strcmp(p
->name
, name
))
1691 TRACE("Returning pass %p\n", p
);
1692 return (ID3D10EffectPass
*)p
;
1696 WARN("Invalid name specified\n");
1698 return (ID3D10EffectPass
*)&null_pass
;
1701 static HRESULT STDMETHODCALLTYPE
d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique
*iface
,
1702 D3D10_STATE_BLOCK_MASK
*mask
)
1704 FIXME("iface %p,mask %p stub!\n", iface
, mask
);
1709 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl
=
1711 /* ID3D10EffectTechnique methods */
1712 d3d10_effect_technique_IsValid
,
1713 d3d10_effect_technique_GetDesc
,
1714 d3d10_effect_technique_GetAnnotationByIndex
,
1715 d3d10_effect_technique_GetAnnotationByName
,
1716 d3d10_effect_technique_GetPassByIndex
,
1717 d3d10_effect_technique_GetPassByName
,
1718 d3d10_effect_technique_ComputeStateBlockMask
,
1721 /* ID3D10EffectPass methods */
1723 static BOOL STDMETHODCALLTYPE
d3d10_effect_pass_IsValid(ID3D10EffectPass
*iface
)
1725 TRACE("iface %p\n", iface
);
1727 return (struct d3d10_effect_pass
*)iface
!= &null_pass
;
1730 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetDesc(ID3D10EffectPass
*iface
, D3D10_PASS_DESC
*desc
)
1732 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
1735 FIXME("iface %p, desc %p partial stub!\n", iface
, desc
);
1737 if(This
== &null_pass
)
1739 WARN("Null pass specified\n");
1745 WARN("Invalid argument specified\n");
1746 return E_INVALIDARG
;
1749 memset(desc
, 0, sizeof(*desc
));
1750 desc
->Name
= This
->name
;
1751 for (i
= 0; i
< This
->object_count
; ++i
)
1753 struct d3d10_effect_object
*o
= &This
->objects
[i
];
1754 if (o
->type
== D3D10_EOT_VERTEXSHADER
)
1756 struct d3d10_effect_shader_variable
*s
= o
->data
;
1757 desc
->pIAInputSignature
= (BYTE
*)s
->input_signature
;
1758 desc
->IAInputSignatureSize
= s
->input_signature_size
;
1766 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass
*iface
,
1767 D3D10_PASS_SHADER_DESC
*desc
)
1769 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
1774 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass
*iface
,
1775 D3D10_PASS_SHADER_DESC
*desc
)
1777 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
1782 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass
*iface
,
1783 D3D10_PASS_SHADER_DESC
*desc
)
1785 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
1790 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass
*iface
,
1793 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
1794 struct d3d10_effect_variable
*a
;
1796 TRACE("iface %p, index %u\n", iface
, index
);
1798 if (index
>= This
->annotation_count
)
1800 WARN("Invalid index specified\n");
1801 return (ID3D10EffectVariable
*)&null_variable
;
1804 a
= &This
->annotations
[index
];
1806 TRACE("Returning annotation %p, %s\n", a
, debugstr_a(a
->name
));
1808 return (ID3D10EffectVariable
*)a
;
1811 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass
*iface
,
1814 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
1817 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1819 for (i
= 0; i
< This
->annotation_count
; ++i
)
1821 struct d3d10_effect_variable
*a
= &This
->annotations
[i
];
1822 if (!strcmp(a
->name
, name
))
1824 TRACE("Returning annotation %p\n", a
);
1825 return (ID3D10EffectVariable
*)a
;
1829 WARN("Invalid name specified\n");
1831 return (ID3D10EffectVariable
*)&null_variable
;
1834 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_Apply(ID3D10EffectPass
*iface
, UINT flags
)
1836 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
1840 TRACE("iface %p, flags %#x\n", iface
, flags
);
1842 if (flags
) FIXME("Ignoring flags (%#x)\n", flags
);
1844 for (i
= 0; i
< This
->object_count
; ++i
)
1846 hr
= d3d10_effect_object_apply(&This
->objects
[i
]);
1847 if (FAILED(hr
)) break;
1853 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass
*iface
,
1854 D3D10_STATE_BLOCK_MASK
*mask
)
1856 FIXME("iface %p, mask %p stub!\n", iface
, mask
);
1861 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl
=
1863 /* ID3D10EffectPass methods */
1864 d3d10_effect_pass_IsValid
,
1865 d3d10_effect_pass_GetDesc
,
1866 d3d10_effect_pass_GetVertexShaderDesc
,
1867 d3d10_effect_pass_GetGeometryShaderDesc
,
1868 d3d10_effect_pass_GetPixelShaderDesc
,
1869 d3d10_effect_pass_GetAnnotationByIndex
,
1870 d3d10_effect_pass_GetAnnotationByName
,
1871 d3d10_effect_pass_Apply
,
1872 d3d10_effect_pass_ComputeStateBlockMask
,
1875 /* ID3D10EffectVariable methods */
1877 static BOOL STDMETHODCALLTYPE
d3d10_effect_variable_IsValid(ID3D10EffectVariable
*iface
)
1879 TRACE("iface %p\n", iface
);
1881 return (struct d3d10_effect_variable
*)iface
!= &null_variable
;
1884 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_variable_GetType(ID3D10EffectVariable
*iface
)
1886 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1888 TRACE("iface %p\n", iface
);
1890 return (ID3D10EffectType
*)This
->type
;
1893 static HRESULT STDMETHODCALLTYPE
d3d10_effect_variable_GetDesc(ID3D10EffectVariable
*iface
,
1894 D3D10_EFFECT_VARIABLE_DESC
*desc
)
1896 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1898 TRACE("iface %p, desc %p\n", iface
, desc
);
1900 if(This
== &null_variable
)
1902 WARN("Null variable specified\n");
1908 WARN("Invalid argument specified\n");
1909 return E_INVALIDARG
;
1912 memset(desc
, 0, sizeof(*desc
));
1913 desc
->Name
= This
->name
;
1914 desc
->Semantic
= This
->semantic
;
1915 desc
->Flags
= This
->flag
;
1916 desc
->Annotations
= This
->annotation_count
;
1917 desc
->BufferOffset
= This
->buffer_offset
;
1919 if( This
->flag
== D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT
)
1921 desc
->ExplicitBindPoint
= This
->buffer_offset
;
1925 FIXME("Unhandled flag %#x!\n", This
->flag
);
1931 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetAnnotationByIndex(
1932 ID3D10EffectVariable
*iface
, UINT index
)
1934 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1935 struct d3d10_effect_variable
*a
;
1937 TRACE("iface %p, index %u\n", iface
, index
);
1939 if (index
>= This
->annotation_count
)
1941 WARN("Invalid index specified\n");
1942 return (ID3D10EffectVariable
*)&null_variable
;
1945 a
= &This
->annotations
[index
];
1947 TRACE("Returning annotation %p, %s\n", a
, debugstr_a(a
->name
));
1949 return (ID3D10EffectVariable
*)a
;
1952 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetAnnotationByName(
1953 ID3D10EffectVariable
*iface
, LPCSTR name
)
1955 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1958 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1960 for (i
= 0; i
< This
->annotation_count
; ++i
)
1962 struct d3d10_effect_variable
*a
= &This
->annotations
[i
];
1963 if (!strcmp(a
->name
, name
))
1965 TRACE("Returning annotation %p\n", a
);
1966 return (ID3D10EffectVariable
*)a
;
1970 WARN("Invalid name specified\n");
1972 return (ID3D10EffectVariable
*)&null_variable
;
1975 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetMemberByIndex(
1976 ID3D10EffectVariable
*iface
, UINT index
)
1978 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1979 struct d3d10_effect_variable
*m
;
1981 TRACE("iface %p, index %u\n", iface
, index
);
1983 if (index
>= This
->type
->member_count
)
1985 WARN("Invalid index specified\n");
1986 return (ID3D10EffectVariable
*)&null_variable
;
1989 m
= &This
->members
[index
];
1991 TRACE("Returning member %p, %s\n", m
, debugstr_a(m
->name
));
1993 return (ID3D10EffectVariable
*)m
;
1996 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetMemberByName(
1997 ID3D10EffectVariable
*iface
, LPCSTR name
)
1999 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2002 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
2006 WARN("Invalid name specified\n");
2007 return (ID3D10EffectVariable
*)&null_variable
;
2010 for (i
= 0; i
< This
->type
->member_count
; ++i
)
2012 struct d3d10_effect_variable
*m
= &This
->members
[i
];
2016 if (!strcmp(m
->name
, name
))
2018 TRACE("Returning member %p\n", m
);
2019 return (ID3D10EffectVariable
*)m
;
2024 WARN("Invalid name specified\n");
2026 return (ID3D10EffectVariable
*)&null_variable
;
2029 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetMemberBySemantic(
2030 ID3D10EffectVariable
*iface
, LPCSTR semantic
)
2032 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2035 TRACE("iface %p, semantic %s.\n", iface
, debugstr_a(semantic
));
2039 WARN("Invalid semantic specified\n");
2040 return (ID3D10EffectVariable
*)&null_variable
;
2043 for (i
= 0; i
< This
->type
->member_count
; ++i
)
2045 struct d3d10_effect_variable
*m
= &This
->members
[i
];
2049 if (!strcmp(m
->semantic
, semantic
))
2051 TRACE("Returning member %p\n", m
);
2052 return (ID3D10EffectVariable
*)m
;
2057 WARN("Invalid semantic specified\n");
2059 return (ID3D10EffectVariable
*)&null_variable
;
2062 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetElement(
2063 ID3D10EffectVariable
*iface
, UINT index
)
2065 FIXME("iface %p, index %u stub!\n", iface
, index
);
2070 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_variable_GetParentConstantBuffer(
2071 ID3D10EffectVariable
*iface
)
2073 FIXME("iface %p stub!\n", iface
);
2078 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsScalar(
2079 ID3D10EffectVariable
*iface
)
2081 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2083 TRACE("iface %p\n", iface
);
2085 if (This
->vtbl
== (ID3D10EffectVariableVtbl
*)&d3d10_effect_scalar_variable_vtbl
)
2086 return (ID3D10EffectScalarVariable
*)This
;
2088 return (ID3D10EffectScalarVariable
*)&null_scalar_variable
;
2091 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsVector(
2092 ID3D10EffectVariable
*iface
)
2094 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2096 TRACE("iface %p\n", iface
);
2098 if (This
->vtbl
== (ID3D10EffectVariableVtbl
*)&d3d10_effect_vector_variable_vtbl
)
2099 return (ID3D10EffectVectorVariable
*)This
;
2101 return (ID3D10EffectVectorVariable
*)&null_vector_variable
;
2104 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsMatrix(
2105 ID3D10EffectVariable
*iface
)
2107 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2109 TRACE("iface %p\n", iface
);
2111 if (This
->vtbl
== (ID3D10EffectVariableVtbl
*)&d3d10_effect_matrix_variable_vtbl
)
2112 return (ID3D10EffectMatrixVariable
*)This
;
2114 return (ID3D10EffectMatrixVariable
*)&null_matrix_variable
;
2117 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsString(
2118 ID3D10EffectVariable
*iface
)
2120 FIXME("iface %p stub!\n", iface
);
2125 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsShaderResource(
2126 ID3D10EffectVariable
*iface
)
2128 FIXME("iface %p stub!\n", iface
);
2133 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsRenderTargetView(
2134 ID3D10EffectVariable
*iface
)
2136 FIXME("iface %p stub!\n", iface
);
2141 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsDepthStencilView(
2142 ID3D10EffectVariable
*iface
)
2144 FIXME("iface %p stub!\n", iface
);
2149 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_variable_AsConstantBuffer(
2150 ID3D10EffectVariable
*iface
)
2152 FIXME("iface %p stub!\n", iface
);
2157 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsShader(
2158 ID3D10EffectVariable
*iface
)
2160 FIXME("iface %p stub!\n", iface
);
2165 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsBlend(ID3D10EffectVariable
*iface
)
2167 FIXME("iface %p stub!\n", iface
);
2172 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsDepthStencil(
2173 ID3D10EffectVariable
*iface
)
2175 FIXME("iface %p stub!\n", iface
);
2180 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsRasterizer(
2181 ID3D10EffectVariable
*iface
)
2183 FIXME("iface %p stub!\n", iface
);
2188 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsSampler(
2189 ID3D10EffectVariable
*iface
)
2191 FIXME("iface %p stub!\n", iface
);
2196 static HRESULT STDMETHODCALLTYPE
d3d10_effect_variable_SetRawValue(ID3D10EffectVariable
*iface
,
2197 void *data
, UINT offset
, UINT count
)
2199 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
2204 static HRESULT STDMETHODCALLTYPE
d3d10_effect_variable_GetRawValue(ID3D10EffectVariable
*iface
,
2205 void *data
, UINT offset
, UINT count
)
2207 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
2212 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl
=
2214 /* ID3D10EffectVariable methods */
2215 d3d10_effect_variable_IsValid
,
2216 d3d10_effect_variable_GetType
,
2217 d3d10_effect_variable_GetDesc
,
2218 d3d10_effect_variable_GetAnnotationByIndex
,
2219 d3d10_effect_variable_GetAnnotationByName
,
2220 d3d10_effect_variable_GetMemberByIndex
,
2221 d3d10_effect_variable_GetMemberByName
,
2222 d3d10_effect_variable_GetMemberBySemantic
,
2223 d3d10_effect_variable_GetElement
,
2224 d3d10_effect_variable_GetParentConstantBuffer
,
2225 d3d10_effect_variable_AsScalar
,
2226 d3d10_effect_variable_AsVector
,
2227 d3d10_effect_variable_AsMatrix
,
2228 d3d10_effect_variable_AsString
,
2229 d3d10_effect_variable_AsShaderResource
,
2230 d3d10_effect_variable_AsRenderTargetView
,
2231 d3d10_effect_variable_AsDepthStencilView
,
2232 d3d10_effect_variable_AsConstantBuffer
,
2233 d3d10_effect_variable_AsShader
,
2234 d3d10_effect_variable_AsBlend
,
2235 d3d10_effect_variable_AsDepthStencil
,
2236 d3d10_effect_variable_AsRasterizer
,
2237 d3d10_effect_variable_AsSampler
,
2238 d3d10_effect_variable_SetRawValue
,
2239 d3d10_effect_variable_GetRawValue
,
2242 /* ID3D10EffectVariable methods */
2243 static BOOL STDMETHODCALLTYPE
d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer
*iface
)
2245 TRACE("iface %p\n", iface
);
2247 return (struct d3d10_effect_variable
*)iface
!= &null_local_buffer
;
2250 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer
*iface
)
2252 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
2255 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer
*iface
,
2256 D3D10_EFFECT_VARIABLE_DESC
*desc
)
2258 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
2261 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetAnnotationByIndex(
2262 ID3D10EffectConstantBuffer
*iface
, UINT index
)
2264 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
2267 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetAnnotationByName(
2268 ID3D10EffectConstantBuffer
*iface
, LPCSTR name
)
2270 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
2273 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetMemberByIndex(
2274 ID3D10EffectConstantBuffer
*iface
, UINT index
)
2276 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
2279 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetMemberByName(
2280 ID3D10EffectConstantBuffer
*iface
, LPCSTR name
)
2282 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
2285 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetMemberBySemantic(
2286 ID3D10EffectConstantBuffer
*iface
, LPCSTR semantic
)
2288 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
2291 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetElement(
2292 ID3D10EffectConstantBuffer
*iface
, UINT index
)
2294 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
2297 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetParentConstantBuffer(
2298 ID3D10EffectConstantBuffer
*iface
)
2300 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
2303 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsScalar(
2304 ID3D10EffectConstantBuffer
*iface
)
2306 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
2309 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsVector(
2310 ID3D10EffectConstantBuffer
*iface
)
2312 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
2315 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsMatrix(
2316 ID3D10EffectConstantBuffer
*iface
)
2318 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
2321 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsString(
2322 ID3D10EffectConstantBuffer
*iface
)
2324 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
2327 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsShaderResource(
2328 ID3D10EffectConstantBuffer
*iface
)
2330 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
2333 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsRenderTargetView(
2334 ID3D10EffectConstantBuffer
*iface
)
2336 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
2339 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsDepthStencilView(
2340 ID3D10EffectConstantBuffer
*iface
)
2342 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
2345 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsConstantBuffer(
2346 ID3D10EffectConstantBuffer
*iface
)
2348 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
2351 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsShader(
2352 ID3D10EffectConstantBuffer
*iface
)
2354 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
2357 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer
*iface
)
2359 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
2362 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsDepthStencil(
2363 ID3D10EffectConstantBuffer
*iface
)
2365 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
2368 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsRasterizer(
2369 ID3D10EffectConstantBuffer
*iface
)
2371 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
2374 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsSampler(
2375 ID3D10EffectConstantBuffer
*iface
)
2377 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
2380 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer
*iface
,
2381 void *data
, UINT offset
, UINT count
)
2383 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2386 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer
*iface
,
2387 void *data
, UINT offset
, UINT count
)
2389 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2392 /* ID3D10EffectConstantBuffer methods */
2393 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer
*iface
,
2394 ID3D10Buffer
*buffer
)
2396 FIXME("iface %p, buffer %p stub!\n", iface
, buffer
);
2401 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer
*iface
,
2402 ID3D10Buffer
**buffer
)
2404 FIXME("iface %p, buffer %p stub!\n", iface
, buffer
);
2409 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer
*iface
,
2410 ID3D10ShaderResourceView
*view
)
2412 FIXME("iface %p, view %p stub!\n", iface
, view
);
2417 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer
*iface
,
2418 ID3D10ShaderResourceView
**view
)
2420 FIXME("iface %p, view %p stub!\n", iface
, view
);
2425 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl
=
2427 /* ID3D10EffectVariable methods */
2428 d3d10_effect_constant_buffer_IsValid
,
2429 d3d10_effect_constant_buffer_GetType
,
2430 d3d10_effect_constant_buffer_GetDesc
,
2431 d3d10_effect_constant_buffer_GetAnnotationByIndex
,
2432 d3d10_effect_constant_buffer_GetAnnotationByName
,
2433 d3d10_effect_constant_buffer_GetMemberByIndex
,
2434 d3d10_effect_constant_buffer_GetMemberByName
,
2435 d3d10_effect_constant_buffer_GetMemberBySemantic
,
2436 d3d10_effect_constant_buffer_GetElement
,
2437 d3d10_effect_constant_buffer_GetParentConstantBuffer
,
2438 d3d10_effect_constant_buffer_AsScalar
,
2439 d3d10_effect_constant_buffer_AsVector
,
2440 d3d10_effect_constant_buffer_AsMatrix
,
2441 d3d10_effect_constant_buffer_AsString
,
2442 d3d10_effect_constant_buffer_AsShaderResource
,
2443 d3d10_effect_constant_buffer_AsRenderTargetView
,
2444 d3d10_effect_constant_buffer_AsDepthStencilView
,
2445 d3d10_effect_constant_buffer_AsConstantBuffer
,
2446 d3d10_effect_constant_buffer_AsShader
,
2447 d3d10_effect_constant_buffer_AsBlend
,
2448 d3d10_effect_constant_buffer_AsDepthStencil
,
2449 d3d10_effect_constant_buffer_AsRasterizer
,
2450 d3d10_effect_constant_buffer_AsSampler
,
2451 d3d10_effect_constant_buffer_SetRawValue
,
2452 d3d10_effect_constant_buffer_GetRawValue
,
2453 /* ID3D10EffectConstantBuffer methods */
2454 d3d10_effect_constant_buffer_SetConstantBuffer
,
2455 d3d10_effect_constant_buffer_GetConstantBuffer
,
2456 d3d10_effect_constant_buffer_SetTextureBuffer
,
2457 d3d10_effect_constant_buffer_GetTextureBuffer
,
2460 /* ID3D10EffectVariable methods */
2462 static BOOL STDMETHODCALLTYPE
d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable
*iface
)
2464 TRACE("iface %p\n", iface
);
2466 return (struct d3d10_effect_variable
*)iface
!= &null_scalar_variable
;
2469 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetType(
2470 ID3D10EffectScalarVariable
*iface
)
2472 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
2475 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetDesc(ID3D10EffectScalarVariable
*iface
,
2476 D3D10_EFFECT_VARIABLE_DESC
*desc
)
2478 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
2481 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetAnnotationByIndex(
2482 ID3D10EffectScalarVariable
*iface
, UINT index
)
2484 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
2487 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetAnnotationByName(
2488 ID3D10EffectScalarVariable
*iface
, LPCSTR name
)
2490 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
2493 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetMemberByIndex(
2494 ID3D10EffectScalarVariable
*iface
, UINT index
)
2496 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
2499 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetMemberByName(
2500 ID3D10EffectScalarVariable
*iface
, LPCSTR name
)
2502 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
2505 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetMemberBySemantic(
2506 ID3D10EffectScalarVariable
*iface
, LPCSTR semantic
)
2508 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
2511 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetElement(
2512 ID3D10EffectScalarVariable
*iface
, UINT index
)
2514 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
2517 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetParentConstantBuffer(
2518 ID3D10EffectScalarVariable
*iface
)
2520 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
2523 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsScalar(
2524 ID3D10EffectScalarVariable
*iface
)
2526 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
2529 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsVector(
2530 ID3D10EffectScalarVariable
*iface
)
2532 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
2535 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsMatrix(
2536 ID3D10EffectScalarVariable
*iface
)
2538 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
2541 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsString(
2542 ID3D10EffectScalarVariable
*iface
)
2544 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
2547 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsShaderResource(
2548 ID3D10EffectScalarVariable
*iface
)
2550 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
2553 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsRenderTargetView(
2554 ID3D10EffectScalarVariable
*iface
)
2556 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
2559 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsDepthStencilView(
2560 ID3D10EffectScalarVariable
*iface
)
2562 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
2565 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsConstantBuffer(
2566 ID3D10EffectScalarVariable
*iface
)
2568 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
2571 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsShader(
2572 ID3D10EffectScalarVariable
*iface
)
2574 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
2577 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsBlend(
2578 ID3D10EffectScalarVariable
*iface
)
2580 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
2583 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsDepthStencil(
2584 ID3D10EffectScalarVariable
*iface
)
2586 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
2589 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsRasterizer(
2590 ID3D10EffectScalarVariable
*iface
)
2592 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
2595 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsSampler(
2596 ID3D10EffectScalarVariable
*iface
)
2598 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
2601 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetRawValue(ID3D10EffectScalarVariable
*iface
,
2602 void *data
, UINT offset
, UINT count
)
2604 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2607 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetRawValue(ID3D10EffectScalarVariable
*iface
,
2608 void *data
, UINT offset
, UINT count
)
2610 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2613 /* ID3D10EffectScalarVariable methods */
2615 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable
*iface
,
2618 FIXME("iface %p, value %.8e stub!\n", iface
, value
);
2623 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable
*iface
,
2626 FIXME("iface %p, value %p stub!\n", iface
, value
);
2631 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable
*iface
,
2632 float *values
, UINT offset
, UINT count
)
2634 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2639 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable
*iface
,
2640 float *values
, UINT offset
, UINT count
)
2642 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2647 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable
*iface
,
2650 FIXME("iface %p, value %d stub!\n", iface
, value
);
2655 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable
*iface
,
2658 FIXME("iface %p, value %p stub!\n", iface
, value
);
2663 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable
*iface
,
2664 int *values
, UINT offset
, UINT count
)
2666 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2671 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable
*iface
,
2672 int *values
, UINT offset
, UINT count
)
2674 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2679 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable
*iface
,
2682 FIXME("iface %p, value %d stub!\n", iface
, value
);
2687 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable
*iface
,
2690 FIXME("iface %p, value %p stub!\n", iface
, value
);
2695 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable
*iface
,
2696 BOOL
*values
, UINT offset
, UINT count
)
2698 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2703 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable
*iface
,
2704 BOOL
*values
, UINT offset
, UINT count
)
2706 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2711 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl
=
2713 /* ID3D10EffectVariable methods */
2714 d3d10_effect_scalar_variable_IsValid
,
2715 d3d10_effect_scalar_variable_GetType
,
2716 d3d10_effect_scalar_variable_GetDesc
,
2717 d3d10_effect_scalar_variable_GetAnnotationByIndex
,
2718 d3d10_effect_scalar_variable_GetAnnotationByName
,
2719 d3d10_effect_scalar_variable_GetMemberByIndex
,
2720 d3d10_effect_scalar_variable_GetMemberByName
,
2721 d3d10_effect_scalar_variable_GetMemberBySemantic
,
2722 d3d10_effect_scalar_variable_GetElement
,
2723 d3d10_effect_scalar_variable_GetParentConstantBuffer
,
2724 d3d10_effect_scalar_variable_AsScalar
,
2725 d3d10_effect_scalar_variable_AsVector
,
2726 d3d10_effect_scalar_variable_AsMatrix
,
2727 d3d10_effect_scalar_variable_AsString
,
2728 d3d10_effect_scalar_variable_AsShaderResource
,
2729 d3d10_effect_scalar_variable_AsRenderTargetView
,
2730 d3d10_effect_scalar_variable_AsDepthStencilView
,
2731 d3d10_effect_scalar_variable_AsConstantBuffer
,
2732 d3d10_effect_scalar_variable_AsShader
,
2733 d3d10_effect_scalar_variable_AsBlend
,
2734 d3d10_effect_scalar_variable_AsDepthStencil
,
2735 d3d10_effect_scalar_variable_AsRasterizer
,
2736 d3d10_effect_scalar_variable_AsSampler
,
2737 d3d10_effect_scalar_variable_SetRawValue
,
2738 d3d10_effect_scalar_variable_GetRawValue
,
2739 /* ID3D10EffectScalarVariable methods */
2740 d3d10_effect_scalar_variable_SetFloat
,
2741 d3d10_effect_scalar_variable_GetFloat
,
2742 d3d10_effect_scalar_variable_SetFloatArray
,
2743 d3d10_effect_scalar_variable_GetFloatArray
,
2744 d3d10_effect_scalar_variable_SetInt
,
2745 d3d10_effect_scalar_variable_GetInt
,
2746 d3d10_effect_scalar_variable_SetIntArray
,
2747 d3d10_effect_scalar_variable_GetIntArray
,
2748 d3d10_effect_scalar_variable_SetBool
,
2749 d3d10_effect_scalar_variable_GetBool
,
2750 d3d10_effect_scalar_variable_SetBoolArray
,
2751 d3d10_effect_scalar_variable_GetBoolArray
,
2754 /* ID3D10EffectVariable methods */
2756 static BOOL STDMETHODCALLTYPE
d3d10_effect_vector_variable_IsValid(ID3D10EffectVectorVariable
*iface
)
2758 TRACE("iface %p\n", iface
);
2760 return (struct d3d10_effect_variable
*)iface
!= &null_vector_variable
;
2763 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetType(
2764 ID3D10EffectVectorVariable
*iface
)
2766 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
2769 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetDesc(ID3D10EffectVectorVariable
*iface
,
2770 D3D10_EFFECT_VARIABLE_DESC
*desc
)
2772 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
2775 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetAnnotationByIndex(
2776 ID3D10EffectVectorVariable
*iface
, UINT index
)
2778 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
2781 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetAnnotationByName(
2782 ID3D10EffectVectorVariable
*iface
, LPCSTR name
)
2784 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
2787 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetMemberByIndex(
2788 ID3D10EffectVectorVariable
*iface
, UINT index
)
2790 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
2793 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetMemberByName(
2794 ID3D10EffectVectorVariable
*iface
, LPCSTR name
)
2796 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
2799 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetMemberBySemantic(
2800 ID3D10EffectVectorVariable
*iface
, LPCSTR semantic
)
2802 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
2805 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetElement(
2806 ID3D10EffectVectorVariable
*iface
, UINT index
)
2808 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
2811 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetParentConstantBuffer(
2812 ID3D10EffectVectorVariable
*iface
)
2814 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
2817 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsScalar(
2818 ID3D10EffectVectorVariable
*iface
)
2820 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
2823 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsVector(
2824 ID3D10EffectVectorVariable
*iface
)
2826 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
2829 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsMatrix(
2830 ID3D10EffectVectorVariable
*iface
)
2832 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
2835 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsString(
2836 ID3D10EffectVectorVariable
*iface
)
2838 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
2841 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsShaderResource(
2842 ID3D10EffectVectorVariable
*iface
)
2844 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
2847 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsRenderTargetView(
2848 ID3D10EffectVectorVariable
*iface
)
2850 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
2853 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsDepthStencilView(
2854 ID3D10EffectVectorVariable
*iface
)
2856 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
2859 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsConstantBuffer(
2860 ID3D10EffectVectorVariable
*iface
)
2862 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
2865 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsShader(
2866 ID3D10EffectVectorVariable
*iface
)
2868 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
2871 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsBlend(
2872 ID3D10EffectVectorVariable
*iface
)
2874 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
2877 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsDepthStencil(
2878 ID3D10EffectVectorVariable
*iface
)
2880 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
2883 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsRasterizer(
2884 ID3D10EffectVectorVariable
*iface
)
2886 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
2889 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsSampler(
2890 ID3D10EffectVectorVariable
*iface
)
2892 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
2895 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetRawValue(ID3D10EffectVectorVariable
*iface
,
2896 void *data
, UINT offset
, UINT count
)
2898 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2901 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetRawValue(ID3D10EffectVectorVariable
*iface
,
2902 void *data
, UINT offset
, UINT count
)
2904 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2907 /* ID3D10EffectVectorVariable methods */
2909 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetBoolVector(ID3D10EffectVectorVariable
*iface
,
2912 FIXME("iface %p, value %p stub!\n", iface
, value
);
2917 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetIntVector(ID3D10EffectVectorVariable
*iface
,
2920 FIXME("iface %p, value %p stub!\n", iface
, value
);
2925 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetFloatVector(ID3D10EffectVectorVariable
*iface
,
2928 FIXME("iface %p, value %p stub!\n", iface
, value
);
2933 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetBoolVector(ID3D10EffectVectorVariable
*iface
,
2936 FIXME("iface %p, value %p stub!\n", iface
, value
);
2941 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetIntVector(ID3D10EffectVectorVariable
*iface
,
2944 FIXME("iface %p, value %p stub!\n", iface
, value
);
2949 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetFloatVector(ID3D10EffectVectorVariable
*iface
,
2952 FIXME("iface %p, value %p stub!\n", iface
, value
);
2957 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetBoolVectorArray(ID3D10EffectVectorVariable
*iface
,
2958 BOOL
*values
, UINT offset
, UINT count
)
2960 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2965 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetIntVectorArray(ID3D10EffectVectorVariable
*iface
,
2966 int *values
, UINT offset
, UINT count
)
2968 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2973 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetFloatVectorArray(ID3D10EffectVectorVariable
*iface
,
2974 float *values
, UINT offset
, UINT count
)
2976 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2981 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetBoolVectorArray(ID3D10EffectVectorVariable
*iface
,
2982 BOOL
*values
, UINT offset
, UINT count
)
2984 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2989 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetIntVectorArray(ID3D10EffectVectorVariable
*iface
,
2990 int *values
, UINT offset
, UINT count
)
2992 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2997 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetFloatVectorArray(ID3D10EffectVectorVariable
*iface
,
2998 float *values
, UINT offset
, UINT count
)
3000 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3005 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl
=
3007 /* ID3D10EffectVariable methods */
3008 d3d10_effect_vector_variable_IsValid
,
3009 d3d10_effect_vector_variable_GetType
,
3010 d3d10_effect_vector_variable_GetDesc
,
3011 d3d10_effect_vector_variable_GetAnnotationByIndex
,
3012 d3d10_effect_vector_variable_GetAnnotationByName
,
3013 d3d10_effect_vector_variable_GetMemberByIndex
,
3014 d3d10_effect_vector_variable_GetMemberByName
,
3015 d3d10_effect_vector_variable_GetMemberBySemantic
,
3016 d3d10_effect_vector_variable_GetElement
,
3017 d3d10_effect_vector_variable_GetParentConstantBuffer
,
3018 d3d10_effect_vector_variable_AsScalar
,
3019 d3d10_effect_vector_variable_AsVector
,
3020 d3d10_effect_vector_variable_AsMatrix
,
3021 d3d10_effect_vector_variable_AsString
,
3022 d3d10_effect_vector_variable_AsShaderResource
,
3023 d3d10_effect_vector_variable_AsRenderTargetView
,
3024 d3d10_effect_vector_variable_AsDepthStencilView
,
3025 d3d10_effect_vector_variable_AsConstantBuffer
,
3026 d3d10_effect_vector_variable_AsShader
,
3027 d3d10_effect_vector_variable_AsBlend
,
3028 d3d10_effect_vector_variable_AsDepthStencil
,
3029 d3d10_effect_vector_variable_AsRasterizer
,
3030 d3d10_effect_vector_variable_AsSampler
,
3031 d3d10_effect_vector_variable_SetRawValue
,
3032 d3d10_effect_vector_variable_GetRawValue
,
3033 /* ID3D10EffectVectorVariable methods */
3034 d3d10_effect_vector_variable_SetBoolVector
,
3035 d3d10_effect_vector_variable_SetIntVector
,
3036 d3d10_effect_vector_variable_SetFloatVector
,
3037 d3d10_effect_vector_variable_GetBoolVector
,
3038 d3d10_effect_vector_variable_GetIntVector
,
3039 d3d10_effect_vector_variable_GetFloatVector
,
3040 d3d10_effect_vector_variable_SetBoolVectorArray
,
3041 d3d10_effect_vector_variable_SetIntVectorArray
,
3042 d3d10_effect_vector_variable_SetFloatVectorArray
,
3043 d3d10_effect_vector_variable_GetBoolVectorArray
,
3044 d3d10_effect_vector_variable_GetIntVectorArray
,
3045 d3d10_effect_vector_variable_GetFloatVectorArray
,
3048 /* ID3D10EffectVariable methods */
3050 static BOOL STDMETHODCALLTYPE
d3d10_effect_matrix_variable_IsValid(ID3D10EffectMatrixVariable
*iface
)
3052 TRACE("iface %p\n", iface
);
3054 return (struct d3d10_effect_variable
*)iface
!= &null_matrix_variable
;
3057 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetType(
3058 ID3D10EffectMatrixVariable
*iface
)
3060 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
3063 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetDesc(ID3D10EffectMatrixVariable
*iface
,
3064 D3D10_EFFECT_VARIABLE_DESC
*desc
)
3066 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
3069 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetAnnotationByIndex(
3070 ID3D10EffectMatrixVariable
*iface
, UINT index
)
3072 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
3075 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetAnnotationByName(
3076 ID3D10EffectMatrixVariable
*iface
, LPCSTR name
)
3078 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
3081 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMemberByIndex(
3082 ID3D10EffectMatrixVariable
*iface
, UINT index
)
3084 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
3087 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMemberByName(
3088 ID3D10EffectMatrixVariable
*iface
, LPCSTR name
)
3090 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
3093 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMemberBySemantic(
3094 ID3D10EffectMatrixVariable
*iface
, LPCSTR semantic
)
3096 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
3099 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetElement(
3100 ID3D10EffectMatrixVariable
*iface
, UINT index
)
3102 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
3105 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetParentConstantBuffer(
3106 ID3D10EffectMatrixVariable
*iface
)
3108 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
3111 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsScalar(
3112 ID3D10EffectMatrixVariable
*iface
)
3114 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
3117 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsVector(
3118 ID3D10EffectMatrixVariable
*iface
)
3120 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
3123 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsMatrix(
3124 ID3D10EffectMatrixVariable
*iface
)
3126 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
3129 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsString(
3130 ID3D10EffectMatrixVariable
*iface
)
3132 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
3135 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsShaderResource(
3136 ID3D10EffectMatrixVariable
*iface
)
3138 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
3141 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsRenderTargetView(
3142 ID3D10EffectMatrixVariable
*iface
)
3144 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
3147 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsDepthStencilView(
3148 ID3D10EffectMatrixVariable
*iface
)
3150 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
3153 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsConstantBuffer(
3154 ID3D10EffectMatrixVariable
*iface
)
3156 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
3159 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsShader(
3160 ID3D10EffectMatrixVariable
*iface
)
3162 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
3165 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsBlend(
3166 ID3D10EffectMatrixVariable
*iface
)
3168 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
3171 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsDepthStencil(
3172 ID3D10EffectMatrixVariable
*iface
)
3174 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
3177 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsRasterizer(
3178 ID3D10EffectMatrixVariable
*iface
)
3180 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
3183 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsSampler(
3184 ID3D10EffectMatrixVariable
*iface
)
3186 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
3189 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetRawValue(ID3D10EffectMatrixVariable
*iface
,
3190 void *data
, UINT offset
, UINT count
)
3192 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
3195 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetRawValue(ID3D10EffectMatrixVariable
*iface
,
3196 void *data
, UINT offset
, UINT count
)
3198 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
3201 /* ID3D10EffectMatrixVariable methods */
3203 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrix(ID3D10EffectMatrixVariable
*iface
,
3206 FIXME("iface %p, data %p stub!\n", iface
, data
);
3211 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrix(ID3D10EffectMatrixVariable
*iface
,
3214 FIXME("iface %p, data %p stub!\n", iface
, data
);
3219 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrixArray(ID3D10EffectMatrixVariable
*iface
,
3220 float *data
, UINT offset
, UINT count
)
3222 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3227 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrixArray(ID3D10EffectMatrixVariable
*iface
,
3228 float *data
, UINT offset
, UINT count
)
3230 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3235 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrixTranspose(ID3D10EffectMatrixVariable
*iface
,
3238 FIXME("iface %p, data %p stub!\n", iface
, data
);
3243 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrixTranspose(ID3D10EffectMatrixVariable
*iface
,
3246 FIXME("iface %p, data %p stub!\n", iface
, data
);
3251 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrixTransposeArray(ID3D10EffectMatrixVariable
*iface
,
3252 float *data
, UINT offset
, UINT count
)
3254 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3259 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrixTransposeArray(ID3D10EffectMatrixVariable
*iface
,
3260 float *data
, UINT offset
, UINT count
)
3262 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3268 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl
=
3270 /* ID3D10EffectVariable methods */
3271 d3d10_effect_matrix_variable_IsValid
,
3272 d3d10_effect_matrix_variable_GetType
,
3273 d3d10_effect_matrix_variable_GetDesc
,
3274 d3d10_effect_matrix_variable_GetAnnotationByIndex
,
3275 d3d10_effect_matrix_variable_GetAnnotationByName
,
3276 d3d10_effect_matrix_variable_GetMemberByIndex
,
3277 d3d10_effect_matrix_variable_GetMemberByName
,
3278 d3d10_effect_matrix_variable_GetMemberBySemantic
,
3279 d3d10_effect_matrix_variable_GetElement
,
3280 d3d10_effect_matrix_variable_GetParentConstantBuffer
,
3281 d3d10_effect_matrix_variable_AsScalar
,
3282 d3d10_effect_matrix_variable_AsVector
,
3283 d3d10_effect_matrix_variable_AsMatrix
,
3284 d3d10_effect_matrix_variable_AsString
,
3285 d3d10_effect_matrix_variable_AsShaderResource
,
3286 d3d10_effect_matrix_variable_AsRenderTargetView
,
3287 d3d10_effect_matrix_variable_AsDepthStencilView
,
3288 d3d10_effect_matrix_variable_AsConstantBuffer
,
3289 d3d10_effect_matrix_variable_AsShader
,
3290 d3d10_effect_matrix_variable_AsBlend
,
3291 d3d10_effect_matrix_variable_AsDepthStencil
,
3292 d3d10_effect_matrix_variable_AsRasterizer
,
3293 d3d10_effect_matrix_variable_AsSampler
,
3294 d3d10_effect_matrix_variable_SetRawValue
,
3295 d3d10_effect_matrix_variable_GetRawValue
,
3296 /* ID3D10EffectMatrixVariable methods */
3297 d3d10_effect_matrix_variable_SetMatrix
,
3298 d3d10_effect_matrix_variable_GetMatrix
,
3299 d3d10_effect_matrix_variable_SetMatrixArray
,
3300 d3d10_effect_matrix_variable_GetMatrixArray
,
3301 d3d10_effect_matrix_variable_SetMatrixTranspose
,
3302 d3d10_effect_matrix_variable_GetMatrixTranspose
,
3303 d3d10_effect_matrix_variable_SetMatrixTransposeArray
,
3304 d3d10_effect_matrix_variable_GetMatrixTransposeArray
,
3307 static BOOL STDMETHODCALLTYPE
d3d10_effect_type_IsValid(ID3D10EffectType
*iface
)
3309 FIXME("iface %p stub!\n", iface
);
3314 static HRESULT STDMETHODCALLTYPE
d3d10_effect_type_GetDesc(ID3D10EffectType
*iface
, D3D10_EFFECT_TYPE_DESC
*desc
)
3316 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3318 TRACE("iface %p, desc %p\n", iface
, desc
);
3320 if (This
== &null_type
)
3322 WARN("Null type specified\n");
3328 WARN("Invalid argument specified\n");
3329 return E_INVALIDARG
;
3332 desc
->TypeName
= This
->name
;
3333 desc
->Class
= This
->type_class
;
3334 desc
->Type
= This
->basetype
;
3335 desc
->Elements
= This
->element_count
;
3336 desc
->Members
= This
->member_count
;
3337 desc
->Rows
= This
->row_count
;
3338 desc
->Columns
= This
->column_count
;
3339 desc
->PackedSize
= This
->size_packed
;
3340 desc
->UnpackedSize
= This
->size_unpacked
;
3341 desc
->Stride
= This
->stride
;
3346 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_type_GetMemberTypeByIndex(ID3D10EffectType
*iface
,
3349 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3350 struct d3d10_effect_type
*t
;
3352 TRACE("iface %p, index %u\n", iface
, index
);
3354 if (index
>= This
->member_count
)
3356 WARN("Invalid index specified\n");
3357 return (ID3D10EffectType
*)&null_type
;
3360 t
= (&This
->members
[index
])->type
;
3362 TRACE("Returning member %p, %s\n", t
, debugstr_a(t
->name
));
3364 return (ID3D10EffectType
*)t
;
3367 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_type_GetMemberTypeByName(ID3D10EffectType
*iface
,
3370 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3373 TRACE("iface %p, name %s\n", iface
, debugstr_a(name
));
3377 WARN("Invalid name specified\n");
3378 return (ID3D10EffectType
*)&null_type
;
3381 for (i
= 0; i
< This
->member_count
; ++i
)
3383 struct d3d10_effect_type_member
*typem
= &This
->members
[i
];
3387 if (!strcmp(typem
->name
, name
))
3389 TRACE("Returning type %p.\n", typem
->type
);
3390 return (ID3D10EffectType
*)typem
->type
;
3395 WARN("Invalid name specified\n");
3397 return (ID3D10EffectType
*)&null_type
;
3400 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_type_GetMemberTypeBySemantic(ID3D10EffectType
*iface
,
3403 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3406 TRACE("iface %p, semantic %s\n", iface
, debugstr_a(semantic
));
3410 WARN("Invalid semantic specified\n");
3411 return (ID3D10EffectType
*)&null_type
;
3414 for (i
= 0; i
< This
->member_count
; ++i
)
3416 struct d3d10_effect_type_member
*typem
= &This
->members
[i
];
3418 if (typem
->semantic
)
3420 if (!strcmp(typem
->semantic
, semantic
))
3422 TRACE("Returning type %p.\n", typem
->type
);
3423 return (ID3D10EffectType
*)typem
->type
;
3428 WARN("Invalid semantic specified\n");
3430 return (ID3D10EffectType
*)&null_type
;
3433 static LPCSTR STDMETHODCALLTYPE
d3d10_effect_type_GetMemberName(ID3D10EffectType
*iface
, UINT index
)
3435 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3436 struct d3d10_effect_type_member
*typem
;
3438 TRACE("iface %p, index %u\n", iface
, index
);
3440 if (index
>= This
->member_count
)
3442 WARN("Invalid index specified\n");
3446 typem
= &This
->members
[index
];
3448 TRACE("Returning name %s\n", debugstr_a(typem
->name
));
3453 static LPCSTR STDMETHODCALLTYPE
d3d10_effect_type_GetMemberSemantic(ID3D10EffectType
*iface
, UINT index
)
3455 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3456 struct d3d10_effect_type_member
*typem
;
3458 TRACE("iface %p, index %u\n", iface
, index
);
3460 if (index
>= This
->member_count
)
3462 WARN("Invalid index specified\n");
3466 typem
= &This
->members
[index
];
3468 TRACE("Returning semantic %s\n", debugstr_a(typem
->semantic
));
3470 return typem
->semantic
;
3473 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl
=
3475 /* ID3D10EffectType */
3476 d3d10_effect_type_IsValid
,
3477 d3d10_effect_type_GetDesc
,
3478 d3d10_effect_type_GetMemberTypeByIndex
,
3479 d3d10_effect_type_GetMemberTypeByName
,
3480 d3d10_effect_type_GetMemberTypeBySemantic
,
3481 d3d10_effect_type_GetMemberName
,
3482 d3d10_effect_type_GetMemberSemantic
,