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
;
486 case D3D10_SVC_STRUCT
:
487 v
->vtbl
= &d3d10_effect_variable_vtbl
;
491 FIXME("Unhandled type class %s.\n", debug_d3d10_shader_variable_class(v
->type
->type_class
));
492 v
->vtbl
= &d3d10_effect_variable_vtbl
;
497 static HRESULT
copy_variableinfo_from_type(struct d3d10_effect_variable
*v
)
501 if (v
->type
->member_count
== 0) return S_OK
;
503 v
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, v
->type
->member_count
* sizeof(*v
->members
));
506 ERR("Failed to allocate members memory.\n");
507 return E_OUTOFMEMORY
;
510 for (i
= 0; i
< v
->type
->member_count
; ++i
)
512 struct d3d10_effect_variable
*var
= &v
->members
[i
];
513 struct d3d10_effect_type_member
*typem
= &v
->type
->members
[i
];
517 var
->effect
= v
->effect
;
518 var
->type
= typem
->type
;
519 set_variable_vtbl(var
);
521 if (!copy_name(typem
->name
, &var
->name
))
523 ERR("Failed to copy name.\n");
524 return E_OUTOFMEMORY
;
526 TRACE("Variable name: %s.\n", debugstr_a(var
->name
));
528 if (!copy_name(typem
->semantic
, &var
->semantic
))
530 ERR("Failed to copy name.\n");
531 return E_OUTOFMEMORY
;
533 TRACE("Variable semantic: %s.\n", debugstr_a(var
->semantic
));
535 var
->buffer_offset
= typem
->buffer_offset
;
536 TRACE("Variable buffer offset: %u.\n", var
->buffer_offset
);
538 hr
= copy_variableinfo_from_type(var
);
539 if (FAILED(hr
)) return hr
;
545 static HRESULT
parse_fx10_variable_head(struct d3d10_effect_variable
*v
, const char **ptr
, const char *data
)
549 read_dword(ptr
, &offset
);
550 TRACE("Variable name at offset %#x.\n", offset
);
552 if (!copy_name(data
+ offset
, &v
->name
))
554 ERR("Failed to copy name.\n");
555 return E_OUTOFMEMORY
;
557 TRACE("Variable name: %s.\n", debugstr_a(v
->name
));
559 read_dword(ptr
, &offset
);
560 TRACE("Variable type info at offset %#x.\n", offset
);
562 v
->type
= get_fx10_type(v
->effect
, data
, offset
);
565 ERR("Failed to get variable type.\n");
568 set_variable_vtbl(v
);
570 return copy_variableinfo_from_type(v
);
573 static HRESULT
parse_fx10_annotation(struct d3d10_effect_variable
*a
, const char **ptr
, const char *data
)
577 hr
= parse_fx10_variable_head(a
, ptr
, data
);
578 if (FAILED(hr
)) return hr
;
580 skip_dword_unknown(ptr
, 1);
585 static HRESULT
parse_fx10_object(struct d3d10_effect_object
*o
, const char **ptr
, const char *data
)
587 const char *data_ptr
;
591 read_dword(ptr
, &o
->type
);
592 TRACE("Effect object is of type %#x.\n", o
->type
);
594 skip_dword_unknown(ptr
, 2);
596 read_dword(ptr
, &offset
);
597 TRACE("Effect object idx is at offset %#x.\n", offset
);
599 data_ptr
= data
+ offset
;
600 read_dword(&data_ptr
, &offset
);
602 TRACE("Effect object starts at offset %#x.\n", offset
);
604 /* FIXME: This probably isn't completely correct. */
607 WARN("Skipping effect object.\n");
612 data_ptr
= data
+ offset
;
617 case D3D10_EOT_VERTEXSHADER
:
618 TRACE("Vertex shader\n");
619 hr
= parse_shader(o
, data_ptr
);
622 case D3D10_EOT_PIXELSHADER
:
623 TRACE("Pixel shader\n");
624 hr
= parse_shader(o
, data_ptr
);
627 case D3D10_EOT_GEOMETRYSHADER
:
628 TRACE("Geometry shader\n");
629 hr
= parse_shader(o
, data_ptr
);
633 FIXME("Unhandled object type %#x\n", o
->type
);
641 static HRESULT
parse_fx10_pass(struct d3d10_effect_pass
*p
, const char **ptr
, const char *data
)
647 read_dword(ptr
, &offset
);
648 TRACE("Pass name at offset %#x.\n", offset
);
650 if (!copy_name(data
+ offset
, &p
->name
))
652 ERR("Failed to copy name.\n");
653 return E_OUTOFMEMORY
;
655 TRACE("Pass name: %s.\n", debugstr_a(p
->name
));
657 read_dword(ptr
, &p
->object_count
);
658 TRACE("Pass has %u effect objects.\n", p
->object_count
);
660 read_dword(ptr
, &p
->annotation_count
);
661 TRACE("Pass has %u annotations.\n", p
->annotation_count
);
663 p
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, p
->annotation_count
* sizeof(*p
->annotations
));
666 ERR("Failed to allocate pass annotations memory.\n");
667 return E_OUTOFMEMORY
;
670 for(i
= 0; i
< p
->annotation_count
; ++i
)
672 struct d3d10_effect_variable
*a
= &p
->annotations
[i
];
674 a
->effect
= p
->technique
->effect
;
676 hr
= parse_fx10_annotation(a
, ptr
, data
);
677 if (FAILED(hr
)) return hr
;
680 p
->objects
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, p
->object_count
* sizeof(*p
->objects
));
683 ERR("Failed to allocate effect objects memory.\n");
684 return E_OUTOFMEMORY
;
687 for (i
= 0; i
< p
->object_count
; ++i
)
689 struct d3d10_effect_object
*o
= &p
->objects
[i
];
693 hr
= parse_fx10_object(o
, ptr
, data
);
694 if (FAILED(hr
)) return hr
;
700 static HRESULT
parse_fx10_technique(struct d3d10_effect_technique
*t
, const char **ptr
, const char *data
)
706 read_dword(ptr
, &offset
);
707 TRACE("Technique name at offset %#x.\n", offset
);
709 if (!copy_name(data
+ offset
, &t
->name
))
711 ERR("Failed to copy name.\n");
712 return E_OUTOFMEMORY
;
714 TRACE("Technique name: %s.\n", debugstr_a(t
->name
));
716 read_dword(ptr
, &t
->pass_count
);
717 TRACE("Technique has %u passes\n", t
->pass_count
);
719 read_dword(ptr
, &t
->annotation_count
);
720 TRACE("Technique has %u annotations.\n", t
->annotation_count
);
722 t
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, t
->annotation_count
* sizeof(*t
->annotations
));
725 ERR("Failed to allocate technique annotations memory.\n");
726 return E_OUTOFMEMORY
;
729 for(i
= 0; i
< t
->annotation_count
; ++i
)
731 struct d3d10_effect_variable
*a
= &t
->annotations
[i
];
733 a
->effect
= t
->effect
;
735 hr
= parse_fx10_annotation(a
, ptr
, data
);
736 if (FAILED(hr
)) return hr
;
739 t
->passes
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, t
->pass_count
* sizeof(*t
->passes
));
742 ERR("Failed to allocate passes memory\n");
743 return E_OUTOFMEMORY
;
746 for (i
= 0; i
< t
->pass_count
; ++i
)
748 struct d3d10_effect_pass
*p
= &t
->passes
[i
];
750 p
->vtbl
= &d3d10_effect_pass_vtbl
;
753 hr
= parse_fx10_pass(p
, ptr
, data
);
754 if (FAILED(hr
)) return hr
;
760 static HRESULT
parse_fx10_variable(struct d3d10_effect_variable
*v
, const char **ptr
, const char *data
)
766 hr
= parse_fx10_variable_head(v
, ptr
, data
);
767 if (FAILED(hr
)) return hr
;
769 read_dword(ptr
, &offset
);
770 TRACE("Variable semantic at offset %#x.\n", offset
);
772 if (!copy_name(data
+ offset
, &v
->semantic
))
774 ERR("Failed to copy semantic.\n");
775 return E_OUTOFMEMORY
;
777 TRACE("Variable semantic: %s.\n", debugstr_a(v
->semantic
));
779 read_dword(ptr
, &v
->buffer_offset
);
780 TRACE("Variable offset in buffer: %#x.\n", v
->buffer_offset
);
782 skip_dword_unknown(ptr
, 1);
784 read_dword(ptr
, &v
->flag
);
785 TRACE("Variable flag: %#x.\n", v
->flag
);
787 read_dword(ptr
, &v
->annotation_count
);
788 TRACE("Variable has %u annotations.\n", v
->annotation_count
);
790 v
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, v
->annotation_count
* sizeof(*v
->annotations
));
793 ERR("Failed to allocate variable annotations memory.\n");
794 return E_OUTOFMEMORY
;
797 for (i
= 0; i
< v
->annotation_count
; ++i
)
799 struct d3d10_effect_variable
*a
= &v
->annotations
[i
];
801 a
->effect
= v
->effect
;
803 hr
= parse_fx10_annotation(a
, ptr
, data
);
804 if (FAILED(hr
)) return hr
;
810 static HRESULT
parse_fx10_local_buffer(struct d3d10_effect_variable
*l
, const char **ptr
, const char *data
)
814 D3D10_CBUFFER_TYPE d3d10_cbuffer_type
;
817 /* Generate our own type, it isn't in the fx blob. */
818 l
->type
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*l
->type
));
821 ERR("Failed to allocate local buffer type memory.\n");
822 return E_OUTOFMEMORY
;
824 l
->type
->vtbl
= &d3d10_effect_type_vtbl
;
825 l
->type
->type_class
= D3D10_SVC_OBJECT
;
826 l
->type
->effect
= l
->effect
;
828 read_dword(ptr
, &offset
);
829 TRACE("Local buffer name at offset %#x.\n", offset
);
831 if (!copy_name(data
+ offset
, &l
->name
))
833 ERR("Failed to copy name.\n");
834 return E_OUTOFMEMORY
;
836 TRACE("Local buffer name: %s.\n", debugstr_a(l
->name
));
838 read_dword(ptr
, &l
->data_size
);
839 TRACE("Local buffer data size: %#x.\n", l
->data_size
);
841 read_dword(ptr
, &d3d10_cbuffer_type
);
842 TRACE("Local buffer type: %#x.\n", d3d10_cbuffer_type
);
844 switch(d3d10_cbuffer_type
)
846 case D3D10_CT_CBUFFER
:
847 l
->type
->basetype
= D3D10_SVT_CBUFFER
;
848 if (!copy_name("cbuffer", &l
->type
->name
))
850 ERR("Failed to copy name.\n");
851 return E_OUTOFMEMORY
;
855 case D3D10_CT_TBUFFER
:
856 l
->type
->basetype
= D3D10_SVT_TBUFFER
;
857 if (!copy_name("tbuffer", &l
->type
->name
))
859 ERR("Failed to copy name.\n");
860 return E_OUTOFMEMORY
;
865 ERR("Unexpected D3D10_CBUFFER_TYPE %#x!\n", d3d10_cbuffer_type
);
869 read_dword(ptr
, &l
->type
->member_count
);
870 TRACE("Local buffer member count: %#x.\n", l
->type
->member_count
);
872 skip_dword_unknown(ptr
, 1);
874 read_dword(ptr
, &l
->annotation_count
);
875 TRACE("Local buffer has %u annotations.\n", l
->annotation_count
);
877 l
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, l
->annotation_count
* sizeof(*l
->annotations
));
880 ERR("Failed to allocate local buffer annotations memory.\n");
881 return E_OUTOFMEMORY
;
884 for(i
= 0; i
< l
->annotation_count
; ++i
)
886 struct d3d10_effect_variable
*a
= &l
->annotations
[i
];
888 a
->effect
= l
->effect
;
890 hr
= parse_fx10_annotation(a
, ptr
, data
);
891 if (FAILED(hr
)) return hr
;
894 l
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, l
->type
->member_count
* sizeof(*l
->members
));
897 ERR("Failed to allocate members memory.\n");
898 return E_OUTOFMEMORY
;
901 l
->type
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, l
->type
->member_count
* sizeof(*l
->type
->members
));
902 if (!l
->type
->members
)
904 ERR("Failed to allocate type members memory.\n");
905 return E_OUTOFMEMORY
;
908 for (i
= 0; i
< l
->type
->member_count
; ++i
)
910 struct d3d10_effect_variable
*v
= &l
->members
[i
];
911 struct d3d10_effect_type_member
*typem
= &l
->type
->members
[i
];
914 v
->effect
= l
->effect
;
916 hr
= parse_fx10_variable(v
, ptr
, data
);
917 if (FAILED(hr
)) return hr
;
920 * Copy the values from the variable type to the constant buffers type
921 * members structure, because it is our own generated type.
923 typem
->type
= v
->type
;
925 if (!copy_name(v
->name
, &typem
->name
))
927 ERR("Failed to copy name.\n");
928 return E_OUTOFMEMORY
;
930 TRACE("Variable name: %s.\n", debugstr_a(typem
->name
));
932 if (!copy_name(v
->semantic
, &typem
->semantic
))
934 ERR("Failed to copy name.\n");
935 return E_OUTOFMEMORY
;
937 TRACE("Variable semantic: %s.\n", debugstr_a(typem
->semantic
));
939 typem
->buffer_offset
= v
->buffer_offset
;
940 TRACE("Variable buffer offset: %u.\n", typem
->buffer_offset
);
942 l
->type
->size_packed
+= v
->type
->size_packed
;
943 l
->type
->size_unpacked
+= v
->type
->size_unpacked
;
945 l
->type
->stride
= l
->type
->size_unpacked
= (l
->type
->size_unpacked
+ 0xf) & ~0xf;
947 TRACE("Constant buffer:\n");
948 TRACE("\tType name: %s.\n", debugstr_a(l
->type
->name
));
949 TRACE("\tElement count: %u.\n", l
->type
->element_count
);
950 TRACE("\tMember count: %u.\n", l
->type
->member_count
);
951 TRACE("\tUnpacked size: %#x.\n", l
->type
->size_unpacked
);
952 TRACE("\tStride: %#x.\n", l
->type
->stride
);
953 TRACE("\tPacked size %#x.\n", l
->type
->size_packed
);
954 TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(l
->type
->basetype
));
955 TRACE("\tTypeclass: %s.\n", debug_d3d10_shader_variable_class(l
->type
->type_class
));
960 static int d3d10_effect_type_compare(const void *key
, const struct wine_rb_entry
*entry
)
962 const struct d3d10_effect_type
*t
= WINE_RB_ENTRY_VALUE(entry
, const struct d3d10_effect_type
, entry
);
963 const DWORD
*id
= key
;
968 static void d3d10_effect_type_member_destroy(struct d3d10_effect_type_member
*typem
)
970 TRACE("effect type member %p.\n", typem
);
972 /* Do not release typem->type, it will be covered by d3d10_effect_type_destroy(). */
973 HeapFree(GetProcessHeap(), 0, typem
->semantic
);
974 HeapFree(GetProcessHeap(), 0, typem
->name
);
977 static void d3d10_effect_type_destroy(struct wine_rb_entry
*entry
, void *context
)
979 struct d3d10_effect_type
*t
= WINE_RB_ENTRY_VALUE(entry
, struct d3d10_effect_type
, entry
);
981 TRACE("effect type %p.\n", t
);
987 for (i
= 0; i
< t
->member_count
; ++i
)
989 d3d10_effect_type_member_destroy(&t
->members
[i
]);
991 HeapFree(GetProcessHeap(), 0, t
->members
);
994 HeapFree(GetProcessHeap(), 0, t
->name
);
995 HeapFree(GetProcessHeap(), 0, t
);
998 static const struct wine_rb_functions d3d10_effect_type_rb_functions
=
1003 d3d10_effect_type_compare
,
1006 static HRESULT
parse_fx10_body(struct d3d10_effect
*e
, const char *data
, DWORD data_size
)
1008 const char *ptr
= data
+ e
->index_offset
;
1012 if (wine_rb_init(&e
->types
, &d3d10_effect_type_rb_functions
) == -1)
1014 ERR("Failed to initialize type rbtree.\n");
1018 e
->local_buffers
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, e
->local_buffer_count
* sizeof(*e
->local_buffers
));
1019 if (!e
->local_buffers
)
1021 ERR("Failed to allocate local buffer memory.\n");
1022 return E_OUTOFMEMORY
;
1025 e
->techniques
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, e
->technique_count
* sizeof(*e
->techniques
));
1028 ERR("Failed to allocate techniques memory\n");
1029 return E_OUTOFMEMORY
;
1032 for (i
= 0; i
< e
->local_buffer_count
; ++i
)
1034 struct d3d10_effect_variable
*l
= &e
->local_buffers
[i
];
1035 l
->vtbl
= (ID3D10EffectVariableVtbl
*)&d3d10_effect_constant_buffer_vtbl
;
1038 hr
= parse_fx10_local_buffer(l
, &ptr
, data
);
1039 if (FAILED(hr
)) return hr
;
1042 for (i
= 0; i
< e
->technique_count
; ++i
)
1044 struct d3d10_effect_technique
*t
= &e
->techniques
[i
];
1046 t
->vtbl
= &d3d10_effect_technique_vtbl
;
1049 hr
= parse_fx10_technique(t
, &ptr
, data
);
1050 if (FAILED(hr
)) return hr
;
1056 static HRESULT
parse_fx10(struct d3d10_effect
*e
, const char *data
, DWORD data_size
)
1058 const char *ptr
= data
;
1061 /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
1062 read_dword(&ptr
, &e
->version
);
1063 TRACE("Target: %#x\n", e
->version
);
1065 read_dword(&ptr
, &e
->local_buffer_count
);
1066 TRACE("Local buffer count: %u.\n", e
->local_buffer_count
);
1068 read_dword(&ptr
, &e
->variable_count
);
1069 TRACE("Variable count: %u\n", e
->variable_count
);
1071 read_dword(&ptr
, &e
->object_count
);
1072 TRACE("Object count: %u\n", e
->object_count
);
1074 read_dword(&ptr
, &e
->sharedbuffers_count
);
1075 TRACE("Sharedbuffers count: %u\n", e
->sharedbuffers_count
);
1077 /* Number of variables in shared buffers? */
1078 read_dword(&ptr
, &unknown
);
1079 FIXME("Unknown 0: %u\n", unknown
);
1081 read_dword(&ptr
, &e
->sharedobjects_count
);
1082 TRACE("Sharedobjects count: %u\n", e
->sharedobjects_count
);
1084 read_dword(&ptr
, &e
->technique_count
);
1085 TRACE("Technique count: %u\n", e
->technique_count
);
1087 read_dword(&ptr
, &e
->index_offset
);
1088 TRACE("Index offset: %#x\n", e
->index_offset
);
1090 read_dword(&ptr
, &unknown
);
1091 FIXME("Unknown 1: %u\n", unknown
);
1093 read_dword(&ptr
, &e
->texture_count
);
1094 TRACE("Texture count: %u\n", e
->texture_count
);
1096 read_dword(&ptr
, &e
->dephstencilstate_count
);
1097 TRACE("Depthstencilstate count: %u\n", e
->dephstencilstate_count
);
1099 read_dword(&ptr
, &e
->blendstate_count
);
1100 TRACE("Blendstate count: %u\n", e
->blendstate_count
);
1102 read_dword(&ptr
, &e
->rasterizerstate_count
);
1103 TRACE("Rasterizerstate count: %u\n", e
->rasterizerstate_count
);
1105 read_dword(&ptr
, &e
->samplerstate_count
);
1106 TRACE("Samplerstate count: %u\n", e
->samplerstate_count
);
1108 read_dword(&ptr
, &e
->rendertargetview_count
);
1109 TRACE("Rendertargetview count: %u\n", e
->rendertargetview_count
);
1111 read_dword(&ptr
, &e
->depthstencilview_count
);
1112 TRACE("Depthstencilview count: %u\n", e
->depthstencilview_count
);
1114 read_dword(&ptr
, &e
->shader_call_count
);
1115 TRACE("Shader call count: %u\n", e
->shader_call_count
);
1117 read_dword(&ptr
, &e
->shader_compile_count
);
1118 TRACE("Shader compile count: %u\n", e
->shader_compile_count
);
1120 return parse_fx10_body(e
, ptr
, data_size
- (ptr
- data
));
1123 static HRESULT
fx10_chunk_handler(const char *data
, DWORD data_size
, DWORD tag
, void *ctx
)
1125 struct d3d10_effect
*e
= ctx
;
1127 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
1129 TRACE("chunk size: %#x\n", data_size
);
1134 return parse_fx10(e
, data
, data_size
);
1137 FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag
, 4));
1142 HRESULT
d3d10_effect_parse(struct d3d10_effect
*This
, const void *data
, SIZE_T data_size
)
1144 return parse_dxbc(data
, data_size
, fx10_chunk_handler
, This
);
1147 static void d3d10_effect_object_destroy(struct d3d10_effect_object
*o
)
1149 TRACE("effect object %p.\n", o
);
1153 case D3D10_EOT_VERTEXSHADER
:
1154 case D3D10_EOT_PIXELSHADER
:
1155 case D3D10_EOT_GEOMETRYSHADER
:
1156 HeapFree(GetProcessHeap(), 0, ((struct d3d10_effect_shader_variable
*)o
->data
)->input_signature
);
1162 HeapFree(GetProcessHeap(), 0, o
->data
);
1165 static HRESULT
d3d10_effect_object_apply(struct d3d10_effect_object
*o
)
1167 ID3D10Device
*device
= o
->pass
->technique
->effect
->device
;
1169 TRACE("effect object %p, type %#x.\n", o
, o
->type
);
1173 case D3D10_EOT_VERTEXSHADER
:
1174 ID3D10Device_VSSetShader(device
, ((struct d3d10_effect_shader_variable
*)o
->data
)->shader
.vs
);
1177 case D3D10_EOT_PIXELSHADER
:
1178 ID3D10Device_PSSetShader(device
, ((struct d3d10_effect_shader_variable
*)o
->data
)->shader
.ps
);
1181 case D3D10_EOT_GEOMETRYSHADER
:
1182 ID3D10Device_GSSetShader(device
, ((struct d3d10_effect_shader_variable
*)o
->data
)->shader
.gs
);
1186 FIXME("Unhandled effect object type %#x.\n", o
->type
);
1191 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable
*v
)
1195 TRACE("variable %p.\n", v
);
1197 HeapFree(GetProcessHeap(), 0, v
->name
);
1198 HeapFree(GetProcessHeap(), 0, v
->semantic
);
1201 for (i
= 0; i
< v
->annotation_count
; ++i
)
1203 d3d10_effect_variable_destroy(&v
->annotations
[i
]);
1205 HeapFree(GetProcessHeap(), 0, v
->annotations
);
1210 for (i
= 0; i
< v
->type
->member_count
; ++i
)
1212 d3d10_effect_variable_destroy(&v
->members
[i
]);
1214 HeapFree(GetProcessHeap(), 0, v
->members
);
1218 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass
*p
)
1222 TRACE("pass %p\n", p
);
1224 HeapFree(GetProcessHeap(), 0, p
->name
);
1227 for (i
= 0; i
< p
->object_count
; ++i
)
1229 d3d10_effect_object_destroy(&p
->objects
[i
]);
1231 HeapFree(GetProcessHeap(), 0, p
->objects
);
1236 for (i
= 0; i
< p
->annotation_count
; ++i
)
1238 d3d10_effect_variable_destroy(&p
->annotations
[i
]);
1240 HeapFree(GetProcessHeap(), 0, p
->annotations
);
1245 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique
*t
)
1249 TRACE("technique %p\n", t
);
1251 HeapFree(GetProcessHeap(), 0, t
->name
);
1254 for (i
= 0; i
< t
->pass_count
; ++i
)
1256 d3d10_effect_pass_destroy(&t
->passes
[i
]);
1258 HeapFree(GetProcessHeap(), 0, t
->passes
);
1263 for (i
= 0; i
< t
->annotation_count
; ++i
)
1265 d3d10_effect_variable_destroy(&t
->annotations
[i
]);
1267 HeapFree(GetProcessHeap(), 0, t
->annotations
);
1271 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_variable
*l
)
1275 TRACE("local buffer %p.\n", l
);
1277 HeapFree(GetProcessHeap(), 0, l
->name
);
1280 for (i
= 0; i
< l
->type
->member_count
; ++i
)
1282 d3d10_effect_variable_destroy(&l
->members
[i
]);
1284 HeapFree(GetProcessHeap(), 0, l
->members
);
1287 if (l
->type
->members
)
1289 for (i
= 0; i
< l
->type
->member_count
; ++i
)
1291 /* Do not release l->type->members[i].type, it will be covered by d3d10_effect_type_destroy(). */
1292 HeapFree(GetProcessHeap(), 0, l
->type
->members
[i
].semantic
);
1293 HeapFree(GetProcessHeap(), 0, l
->type
->members
[i
].name
);
1295 HeapFree(GetProcessHeap(), 0, l
->type
->members
);
1297 HeapFree(GetProcessHeap(), 0, l
->type
->name
);
1298 HeapFree(GetProcessHeap(), 0, l
->type
);
1302 for (i
= 0; i
< l
->annotation_count
; ++i
)
1304 d3d10_effect_variable_destroy(&l
->annotations
[i
]);
1306 HeapFree(GetProcessHeap(), 0, l
->annotations
);
1310 /* IUnknown methods */
1312 static HRESULT STDMETHODCALLTYPE
d3d10_effect_QueryInterface(ID3D10Effect
*iface
, REFIID riid
, void **object
)
1314 TRACE("iface %p, riid %s, object %p\n", iface
, debugstr_guid(riid
), object
);
1316 if (IsEqualGUID(riid
, &IID_ID3D10Effect
)
1317 || IsEqualGUID(riid
, &IID_IUnknown
))
1319 IUnknown_AddRef(iface
);
1324 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
1327 return E_NOINTERFACE
;
1330 static ULONG STDMETHODCALLTYPE
d3d10_effect_AddRef(ID3D10Effect
*iface
)
1332 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1333 ULONG refcount
= InterlockedIncrement(&This
->refcount
);
1335 TRACE("%p increasing refcount to %u\n", This
, refcount
);
1340 static ULONG STDMETHODCALLTYPE
d3d10_effect_Release(ID3D10Effect
*iface
)
1342 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1343 ULONG refcount
= InterlockedDecrement(&This
->refcount
);
1345 TRACE("%p decreasing refcount to %u\n", This
, refcount
);
1351 if (This
->techniques
)
1353 for (i
= 0; i
< This
->technique_count
; ++i
)
1355 d3d10_effect_technique_destroy(&This
->techniques
[i
]);
1357 HeapFree(GetProcessHeap(), 0, This
->techniques
);
1360 if (This
->local_buffers
)
1362 for (i
= 0; i
< This
->local_buffer_count
; ++i
)
1364 d3d10_effect_local_buffer_destroy(&This
->local_buffers
[i
]);
1366 HeapFree(GetProcessHeap(), 0, This
->local_buffers
);
1369 wine_rb_destroy(&This
->types
, d3d10_effect_type_destroy
, NULL
);
1371 ID3D10Device_Release(This
->device
);
1372 HeapFree(GetProcessHeap(), 0, This
);
1378 /* ID3D10Effect methods */
1380 static BOOL STDMETHODCALLTYPE
d3d10_effect_IsValid(ID3D10Effect
*iface
)
1382 FIXME("iface %p stub!\n", iface
);
1387 static BOOL STDMETHODCALLTYPE
d3d10_effect_IsPool(ID3D10Effect
*iface
)
1389 FIXME("iface %p stub!\n", iface
);
1394 static HRESULT STDMETHODCALLTYPE
d3d10_effect_GetDevice(ID3D10Effect
*iface
, ID3D10Device
**device
)
1396 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1398 TRACE("iface %p, device %p\n", iface
, device
);
1400 ID3D10Device_AddRef(This
->device
);
1401 *device
= This
->device
;
1406 static HRESULT STDMETHODCALLTYPE
d3d10_effect_GetDesc(ID3D10Effect
*iface
, D3D10_EFFECT_DESC
*desc
)
1408 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
1413 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_GetConstantBufferByIndex(ID3D10Effect
*iface
,
1416 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1417 struct d3d10_effect_variable
*l
;
1419 TRACE("iface %p, index %u\n", iface
, index
);
1421 if (index
>= This
->local_buffer_count
)
1423 WARN("Invalid index specified\n");
1424 return (ID3D10EffectConstantBuffer
*)&null_local_buffer
;
1427 l
= &This
->local_buffers
[index
];
1429 TRACE("Returning buffer %p, %s.\n", l
, debugstr_a(l
->name
));
1431 return (ID3D10EffectConstantBuffer
*)l
;
1434 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_GetConstantBufferByName(ID3D10Effect
*iface
,
1437 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1440 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1442 for (i
= 0; i
< This
->local_buffer_count
; ++i
)
1444 struct d3d10_effect_variable
*l
= &This
->local_buffers
[i
];
1446 if (!strcmp(l
->name
, name
))
1448 TRACE("Returning buffer %p.\n", l
);
1449 return (ID3D10EffectConstantBuffer
*)l
;
1453 WARN("Invalid name specified\n");
1455 return (ID3D10EffectConstantBuffer
*)&null_local_buffer
;
1458 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_GetVariableByIndex(ID3D10Effect
*iface
, UINT index
)
1460 FIXME("iface %p, index %u stub!\n", iface
, index
);
1465 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_GetVariableByName(ID3D10Effect
*iface
, LPCSTR name
)
1467 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1470 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1472 for (i
= 0; i
< This
->local_buffer_count
; ++i
)
1474 struct d3d10_effect_variable
*l
= &This
->local_buffers
[i
];
1477 for (j
= 0; j
< l
->type
->member_count
; ++j
)
1479 struct d3d10_effect_variable
*v
= &l
->members
[j
];
1481 if (!strcmp(v
->name
, name
))
1483 TRACE("Returning variable %p.\n", v
);
1484 return (ID3D10EffectVariable
*)v
;
1489 WARN("Invalid name specified\n");
1491 return (ID3D10EffectVariable
*)&null_variable
;
1494 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_GetVariableBySemantic(ID3D10Effect
*iface
,
1497 FIXME("iface %p, semantic %s stub!\n", iface
, debugstr_a(semantic
));
1502 static struct ID3D10EffectTechnique
* STDMETHODCALLTYPE
d3d10_effect_GetTechniqueByIndex(ID3D10Effect
*iface
,
1505 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1506 struct d3d10_effect_technique
*t
;
1508 TRACE("iface %p, index %u\n", iface
, index
);
1510 if (index
>= This
->technique_count
)
1512 WARN("Invalid index specified\n");
1513 return (ID3D10EffectTechnique
*)&null_technique
;
1516 t
= &This
->techniques
[index
];
1518 TRACE("Returning technique %p, %s.\n", t
, debugstr_a(t
->name
));
1520 return (ID3D10EffectTechnique
*)t
;
1523 static struct ID3D10EffectTechnique
* STDMETHODCALLTYPE
d3d10_effect_GetTechniqueByName(ID3D10Effect
*iface
,
1526 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1529 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1531 for (i
= 0; i
< This
->technique_count
; ++i
)
1533 struct d3d10_effect_technique
*t
= &This
->techniques
[i
];
1534 if (!strcmp(t
->name
, name
))
1536 TRACE("Returning technique %p\n", t
);
1537 return (ID3D10EffectTechnique
*)t
;
1541 WARN("Invalid name specified\n");
1543 return (ID3D10EffectTechnique
*)&null_technique
;
1546 static HRESULT STDMETHODCALLTYPE
d3d10_effect_Optimize(ID3D10Effect
*iface
)
1548 FIXME("iface %p stub!\n", iface
);
1553 static BOOL STDMETHODCALLTYPE
d3d10_effect_IsOptimized(ID3D10Effect
*iface
)
1555 FIXME("iface %p stub!\n", iface
);
1560 const struct ID3D10EffectVtbl d3d10_effect_vtbl
=
1562 /* IUnknown methods */
1563 d3d10_effect_QueryInterface
,
1564 d3d10_effect_AddRef
,
1565 d3d10_effect_Release
,
1566 /* ID3D10Effect methods */
1567 d3d10_effect_IsValid
,
1568 d3d10_effect_IsPool
,
1569 d3d10_effect_GetDevice
,
1570 d3d10_effect_GetDesc
,
1571 d3d10_effect_GetConstantBufferByIndex
,
1572 d3d10_effect_GetConstantBufferByName
,
1573 d3d10_effect_GetVariableByIndex
,
1574 d3d10_effect_GetVariableByName
,
1575 d3d10_effect_GetVariableBySemantic
,
1576 d3d10_effect_GetTechniqueByIndex
,
1577 d3d10_effect_GetTechniqueByName
,
1578 d3d10_effect_Optimize
,
1579 d3d10_effect_IsOptimized
,
1582 /* ID3D10EffectTechnique methods */
1584 static BOOL STDMETHODCALLTYPE
d3d10_effect_technique_IsValid(ID3D10EffectTechnique
*iface
)
1586 TRACE("iface %p\n", iface
);
1588 return (struct d3d10_effect_technique
*)iface
!= &null_technique
;
1591 static HRESULT STDMETHODCALLTYPE
d3d10_effect_technique_GetDesc(ID3D10EffectTechnique
*iface
,
1592 D3D10_TECHNIQUE_DESC
*desc
)
1594 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1596 TRACE("iface %p, desc %p\n", iface
, desc
);
1598 if(This
== &null_technique
)
1600 WARN("Null technique specified\n");
1606 WARN("Invalid argument specified\n");
1607 return E_INVALIDARG
;
1610 desc
->Name
= This
->name
;
1611 desc
->Passes
= This
->pass_count
;
1612 desc
->Annotations
= This
->annotation_count
;
1617 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_technique_GetAnnotationByIndex(
1618 ID3D10EffectTechnique
*iface
, UINT index
)
1620 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1621 struct d3d10_effect_variable
*a
;
1623 TRACE("iface %p, index %u\n", iface
, index
);
1625 if (index
>= This
->annotation_count
)
1627 WARN("Invalid index specified\n");
1628 return (ID3D10EffectVariable
*)&null_variable
;
1631 a
= &This
->annotations
[index
];
1633 TRACE("Returning annotation %p, %s\n", a
, debugstr_a(a
->name
));
1635 return (ID3D10EffectVariable
*)a
;
1638 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_technique_GetAnnotationByName(
1639 ID3D10EffectTechnique
*iface
, LPCSTR name
)
1641 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1644 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1646 for (i
= 0; i
< This
->annotation_count
; ++i
)
1648 struct d3d10_effect_variable
*a
= &This
->annotations
[i
];
1649 if (!strcmp(a
->name
, name
))
1651 TRACE("Returning annotation %p\n", a
);
1652 return (ID3D10EffectVariable
*)a
;
1656 WARN("Invalid name specified\n");
1658 return (ID3D10EffectVariable
*)&null_variable
;
1661 static struct ID3D10EffectPass
* STDMETHODCALLTYPE
d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique
*iface
,
1664 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1665 struct d3d10_effect_pass
*p
;
1667 TRACE("iface %p, index %u\n", iface
, index
);
1669 if (index
>= This
->pass_count
)
1671 WARN("Invalid index specified\n");
1672 return (ID3D10EffectPass
*)&null_pass
;
1675 p
= &This
->passes
[index
];
1677 TRACE("Returning pass %p, %s.\n", p
, debugstr_a(p
->name
));
1679 return (ID3D10EffectPass
*)p
;
1682 static struct ID3D10EffectPass
* STDMETHODCALLTYPE
d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique
*iface
,
1685 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1688 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1690 for (i
= 0; i
< This
->pass_count
; ++i
)
1692 struct d3d10_effect_pass
*p
= &This
->passes
[i
];
1693 if (!strcmp(p
->name
, name
))
1695 TRACE("Returning pass %p\n", p
);
1696 return (ID3D10EffectPass
*)p
;
1700 WARN("Invalid name specified\n");
1702 return (ID3D10EffectPass
*)&null_pass
;
1705 static HRESULT STDMETHODCALLTYPE
d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique
*iface
,
1706 D3D10_STATE_BLOCK_MASK
*mask
)
1708 FIXME("iface %p,mask %p stub!\n", iface
, mask
);
1713 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl
=
1715 /* ID3D10EffectTechnique methods */
1716 d3d10_effect_technique_IsValid
,
1717 d3d10_effect_technique_GetDesc
,
1718 d3d10_effect_technique_GetAnnotationByIndex
,
1719 d3d10_effect_technique_GetAnnotationByName
,
1720 d3d10_effect_technique_GetPassByIndex
,
1721 d3d10_effect_technique_GetPassByName
,
1722 d3d10_effect_technique_ComputeStateBlockMask
,
1725 /* ID3D10EffectPass methods */
1727 static BOOL STDMETHODCALLTYPE
d3d10_effect_pass_IsValid(ID3D10EffectPass
*iface
)
1729 TRACE("iface %p\n", iface
);
1731 return (struct d3d10_effect_pass
*)iface
!= &null_pass
;
1734 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetDesc(ID3D10EffectPass
*iface
, D3D10_PASS_DESC
*desc
)
1736 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
1739 FIXME("iface %p, desc %p partial stub!\n", iface
, desc
);
1741 if(This
== &null_pass
)
1743 WARN("Null pass specified\n");
1749 WARN("Invalid argument specified\n");
1750 return E_INVALIDARG
;
1753 memset(desc
, 0, sizeof(*desc
));
1754 desc
->Name
= This
->name
;
1755 for (i
= 0; i
< This
->object_count
; ++i
)
1757 struct d3d10_effect_object
*o
= &This
->objects
[i
];
1758 if (o
->type
== D3D10_EOT_VERTEXSHADER
)
1760 struct d3d10_effect_shader_variable
*s
= o
->data
;
1761 desc
->pIAInputSignature
= (BYTE
*)s
->input_signature
;
1762 desc
->IAInputSignatureSize
= s
->input_signature_size
;
1770 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass
*iface
,
1771 D3D10_PASS_SHADER_DESC
*desc
)
1773 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
1778 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass
*iface
,
1779 D3D10_PASS_SHADER_DESC
*desc
)
1781 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
1786 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass
*iface
,
1787 D3D10_PASS_SHADER_DESC
*desc
)
1789 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
1794 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass
*iface
,
1797 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
1798 struct d3d10_effect_variable
*a
;
1800 TRACE("iface %p, index %u\n", iface
, index
);
1802 if (index
>= This
->annotation_count
)
1804 WARN("Invalid index specified\n");
1805 return (ID3D10EffectVariable
*)&null_variable
;
1808 a
= &This
->annotations
[index
];
1810 TRACE("Returning annotation %p, %s\n", a
, debugstr_a(a
->name
));
1812 return (ID3D10EffectVariable
*)a
;
1815 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass
*iface
,
1818 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
1821 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1823 for (i
= 0; i
< This
->annotation_count
; ++i
)
1825 struct d3d10_effect_variable
*a
= &This
->annotations
[i
];
1826 if (!strcmp(a
->name
, name
))
1828 TRACE("Returning annotation %p\n", a
);
1829 return (ID3D10EffectVariable
*)a
;
1833 WARN("Invalid name specified\n");
1835 return (ID3D10EffectVariable
*)&null_variable
;
1838 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_Apply(ID3D10EffectPass
*iface
, UINT flags
)
1840 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
1844 TRACE("iface %p, flags %#x\n", iface
, flags
);
1846 if (flags
) FIXME("Ignoring flags (%#x)\n", flags
);
1848 for (i
= 0; i
< This
->object_count
; ++i
)
1850 hr
= d3d10_effect_object_apply(&This
->objects
[i
]);
1851 if (FAILED(hr
)) break;
1857 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass
*iface
,
1858 D3D10_STATE_BLOCK_MASK
*mask
)
1860 FIXME("iface %p, mask %p stub!\n", iface
, mask
);
1865 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl
=
1867 /* ID3D10EffectPass methods */
1868 d3d10_effect_pass_IsValid
,
1869 d3d10_effect_pass_GetDesc
,
1870 d3d10_effect_pass_GetVertexShaderDesc
,
1871 d3d10_effect_pass_GetGeometryShaderDesc
,
1872 d3d10_effect_pass_GetPixelShaderDesc
,
1873 d3d10_effect_pass_GetAnnotationByIndex
,
1874 d3d10_effect_pass_GetAnnotationByName
,
1875 d3d10_effect_pass_Apply
,
1876 d3d10_effect_pass_ComputeStateBlockMask
,
1879 /* ID3D10EffectVariable methods */
1881 static BOOL STDMETHODCALLTYPE
d3d10_effect_variable_IsValid(ID3D10EffectVariable
*iface
)
1883 TRACE("iface %p\n", iface
);
1885 return (struct d3d10_effect_variable
*)iface
!= &null_variable
;
1888 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_variable_GetType(ID3D10EffectVariable
*iface
)
1890 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1892 TRACE("iface %p\n", iface
);
1894 return (ID3D10EffectType
*)This
->type
;
1897 static HRESULT STDMETHODCALLTYPE
d3d10_effect_variable_GetDesc(ID3D10EffectVariable
*iface
,
1898 D3D10_EFFECT_VARIABLE_DESC
*desc
)
1900 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1902 TRACE("iface %p, desc %p\n", iface
, desc
);
1904 if(This
== &null_variable
)
1906 WARN("Null variable specified\n");
1912 WARN("Invalid argument specified\n");
1913 return E_INVALIDARG
;
1916 memset(desc
, 0, sizeof(*desc
));
1917 desc
->Name
= This
->name
;
1918 desc
->Semantic
= This
->semantic
;
1919 desc
->Flags
= This
->flag
;
1920 desc
->Annotations
= This
->annotation_count
;
1921 desc
->BufferOffset
= This
->buffer_offset
;
1923 if( This
->flag
== D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT
)
1925 desc
->ExplicitBindPoint
= This
->buffer_offset
;
1929 FIXME("Unhandled flag %#x!\n", This
->flag
);
1935 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetAnnotationByIndex(
1936 ID3D10EffectVariable
*iface
, UINT index
)
1938 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1939 struct d3d10_effect_variable
*a
;
1941 TRACE("iface %p, index %u\n", iface
, index
);
1943 if (index
>= This
->annotation_count
)
1945 WARN("Invalid index specified\n");
1946 return (ID3D10EffectVariable
*)&null_variable
;
1949 a
= &This
->annotations
[index
];
1951 TRACE("Returning annotation %p, %s\n", a
, debugstr_a(a
->name
));
1953 return (ID3D10EffectVariable
*)a
;
1956 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetAnnotationByName(
1957 ID3D10EffectVariable
*iface
, LPCSTR name
)
1959 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1962 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1964 for (i
= 0; i
< This
->annotation_count
; ++i
)
1966 struct d3d10_effect_variable
*a
= &This
->annotations
[i
];
1967 if (!strcmp(a
->name
, name
))
1969 TRACE("Returning annotation %p\n", a
);
1970 return (ID3D10EffectVariable
*)a
;
1974 WARN("Invalid name specified\n");
1976 return (ID3D10EffectVariable
*)&null_variable
;
1979 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetMemberByIndex(
1980 ID3D10EffectVariable
*iface
, UINT index
)
1982 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
1983 struct d3d10_effect_variable
*m
;
1985 TRACE("iface %p, index %u\n", iface
, index
);
1987 if (index
>= This
->type
->member_count
)
1989 WARN("Invalid index specified\n");
1990 return (ID3D10EffectVariable
*)&null_variable
;
1993 m
= &This
->members
[index
];
1995 TRACE("Returning member %p, %s\n", m
, debugstr_a(m
->name
));
1997 return (ID3D10EffectVariable
*)m
;
2000 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetMemberByName(
2001 ID3D10EffectVariable
*iface
, LPCSTR name
)
2003 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2006 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
2010 WARN("Invalid name specified\n");
2011 return (ID3D10EffectVariable
*)&null_variable
;
2014 for (i
= 0; i
< This
->type
->member_count
; ++i
)
2016 struct d3d10_effect_variable
*m
= &This
->members
[i
];
2020 if (!strcmp(m
->name
, name
))
2022 TRACE("Returning member %p\n", m
);
2023 return (ID3D10EffectVariable
*)m
;
2028 WARN("Invalid name specified\n");
2030 return (ID3D10EffectVariable
*)&null_variable
;
2033 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetMemberBySemantic(
2034 ID3D10EffectVariable
*iface
, LPCSTR semantic
)
2036 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2039 TRACE("iface %p, semantic %s.\n", iface
, debugstr_a(semantic
));
2043 WARN("Invalid semantic specified\n");
2044 return (ID3D10EffectVariable
*)&null_variable
;
2047 for (i
= 0; i
< This
->type
->member_count
; ++i
)
2049 struct d3d10_effect_variable
*m
= &This
->members
[i
];
2053 if (!strcmp(m
->semantic
, semantic
))
2055 TRACE("Returning member %p\n", m
);
2056 return (ID3D10EffectVariable
*)m
;
2061 WARN("Invalid semantic specified\n");
2063 return (ID3D10EffectVariable
*)&null_variable
;
2066 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetElement(
2067 ID3D10EffectVariable
*iface
, UINT index
)
2069 FIXME("iface %p, index %u stub!\n", iface
, index
);
2074 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_variable_GetParentConstantBuffer(
2075 ID3D10EffectVariable
*iface
)
2077 FIXME("iface %p stub!\n", iface
);
2082 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsScalar(
2083 ID3D10EffectVariable
*iface
)
2085 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2087 TRACE("iface %p\n", iface
);
2089 if (This
->vtbl
== (ID3D10EffectVariableVtbl
*)&d3d10_effect_scalar_variable_vtbl
)
2090 return (ID3D10EffectScalarVariable
*)This
;
2092 return (ID3D10EffectScalarVariable
*)&null_scalar_variable
;
2095 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsVector(
2096 ID3D10EffectVariable
*iface
)
2098 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2100 TRACE("iface %p\n", iface
);
2102 if (This
->vtbl
== (ID3D10EffectVariableVtbl
*)&d3d10_effect_vector_variable_vtbl
)
2103 return (ID3D10EffectVectorVariable
*)This
;
2105 return (ID3D10EffectVectorVariable
*)&null_vector_variable
;
2108 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsMatrix(
2109 ID3D10EffectVariable
*iface
)
2111 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2113 TRACE("iface %p\n", iface
);
2115 if (This
->vtbl
== (ID3D10EffectVariableVtbl
*)&d3d10_effect_matrix_variable_vtbl
)
2116 return (ID3D10EffectMatrixVariable
*)This
;
2118 return (ID3D10EffectMatrixVariable
*)&null_matrix_variable
;
2121 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsString(
2122 ID3D10EffectVariable
*iface
)
2124 FIXME("iface %p stub!\n", iface
);
2129 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsShaderResource(
2130 ID3D10EffectVariable
*iface
)
2132 FIXME("iface %p stub!\n", iface
);
2137 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsRenderTargetView(
2138 ID3D10EffectVariable
*iface
)
2140 FIXME("iface %p stub!\n", iface
);
2145 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsDepthStencilView(
2146 ID3D10EffectVariable
*iface
)
2148 FIXME("iface %p stub!\n", iface
);
2153 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_variable_AsConstantBuffer(
2154 ID3D10EffectVariable
*iface
)
2156 FIXME("iface %p stub!\n", iface
);
2161 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsShader(
2162 ID3D10EffectVariable
*iface
)
2164 FIXME("iface %p stub!\n", iface
);
2169 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsBlend(ID3D10EffectVariable
*iface
)
2171 FIXME("iface %p stub!\n", iface
);
2176 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsDepthStencil(
2177 ID3D10EffectVariable
*iface
)
2179 FIXME("iface %p stub!\n", iface
);
2184 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsRasterizer(
2185 ID3D10EffectVariable
*iface
)
2187 FIXME("iface %p stub!\n", iface
);
2192 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsSampler(
2193 ID3D10EffectVariable
*iface
)
2195 FIXME("iface %p stub!\n", iface
);
2200 static HRESULT STDMETHODCALLTYPE
d3d10_effect_variable_SetRawValue(ID3D10EffectVariable
*iface
,
2201 void *data
, UINT offset
, UINT count
)
2203 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
2208 static HRESULT STDMETHODCALLTYPE
d3d10_effect_variable_GetRawValue(ID3D10EffectVariable
*iface
,
2209 void *data
, UINT offset
, UINT count
)
2211 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
2216 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl
=
2218 /* ID3D10EffectVariable methods */
2219 d3d10_effect_variable_IsValid
,
2220 d3d10_effect_variable_GetType
,
2221 d3d10_effect_variable_GetDesc
,
2222 d3d10_effect_variable_GetAnnotationByIndex
,
2223 d3d10_effect_variable_GetAnnotationByName
,
2224 d3d10_effect_variable_GetMemberByIndex
,
2225 d3d10_effect_variable_GetMemberByName
,
2226 d3d10_effect_variable_GetMemberBySemantic
,
2227 d3d10_effect_variable_GetElement
,
2228 d3d10_effect_variable_GetParentConstantBuffer
,
2229 d3d10_effect_variable_AsScalar
,
2230 d3d10_effect_variable_AsVector
,
2231 d3d10_effect_variable_AsMatrix
,
2232 d3d10_effect_variable_AsString
,
2233 d3d10_effect_variable_AsShaderResource
,
2234 d3d10_effect_variable_AsRenderTargetView
,
2235 d3d10_effect_variable_AsDepthStencilView
,
2236 d3d10_effect_variable_AsConstantBuffer
,
2237 d3d10_effect_variable_AsShader
,
2238 d3d10_effect_variable_AsBlend
,
2239 d3d10_effect_variable_AsDepthStencil
,
2240 d3d10_effect_variable_AsRasterizer
,
2241 d3d10_effect_variable_AsSampler
,
2242 d3d10_effect_variable_SetRawValue
,
2243 d3d10_effect_variable_GetRawValue
,
2246 /* ID3D10EffectVariable methods */
2247 static BOOL STDMETHODCALLTYPE
d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer
*iface
)
2249 TRACE("iface %p\n", iface
);
2251 return (struct d3d10_effect_variable
*)iface
!= &null_local_buffer
;
2254 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer
*iface
)
2256 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
2259 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer
*iface
,
2260 D3D10_EFFECT_VARIABLE_DESC
*desc
)
2262 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
2265 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetAnnotationByIndex(
2266 ID3D10EffectConstantBuffer
*iface
, UINT index
)
2268 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
2271 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetAnnotationByName(
2272 ID3D10EffectConstantBuffer
*iface
, LPCSTR name
)
2274 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
2277 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetMemberByIndex(
2278 ID3D10EffectConstantBuffer
*iface
, UINT index
)
2280 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
2283 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetMemberByName(
2284 ID3D10EffectConstantBuffer
*iface
, LPCSTR name
)
2286 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
2289 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetMemberBySemantic(
2290 ID3D10EffectConstantBuffer
*iface
, LPCSTR semantic
)
2292 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
2295 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetElement(
2296 ID3D10EffectConstantBuffer
*iface
, UINT index
)
2298 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
2301 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetParentConstantBuffer(
2302 ID3D10EffectConstantBuffer
*iface
)
2304 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
2307 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsScalar(
2308 ID3D10EffectConstantBuffer
*iface
)
2310 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
2313 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsVector(
2314 ID3D10EffectConstantBuffer
*iface
)
2316 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
2319 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsMatrix(
2320 ID3D10EffectConstantBuffer
*iface
)
2322 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
2325 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsString(
2326 ID3D10EffectConstantBuffer
*iface
)
2328 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
2331 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsShaderResource(
2332 ID3D10EffectConstantBuffer
*iface
)
2334 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
2337 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsRenderTargetView(
2338 ID3D10EffectConstantBuffer
*iface
)
2340 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
2343 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsDepthStencilView(
2344 ID3D10EffectConstantBuffer
*iface
)
2346 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
2349 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsConstantBuffer(
2350 ID3D10EffectConstantBuffer
*iface
)
2352 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
2355 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsShader(
2356 ID3D10EffectConstantBuffer
*iface
)
2358 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
2361 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer
*iface
)
2363 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
2366 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsDepthStencil(
2367 ID3D10EffectConstantBuffer
*iface
)
2369 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
2372 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsRasterizer(
2373 ID3D10EffectConstantBuffer
*iface
)
2375 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
2378 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsSampler(
2379 ID3D10EffectConstantBuffer
*iface
)
2381 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
2384 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer
*iface
,
2385 void *data
, UINT offset
, UINT count
)
2387 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2390 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer
*iface
,
2391 void *data
, UINT offset
, UINT count
)
2393 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2396 /* ID3D10EffectConstantBuffer methods */
2397 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer
*iface
,
2398 ID3D10Buffer
*buffer
)
2400 FIXME("iface %p, buffer %p stub!\n", iface
, buffer
);
2405 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer
*iface
,
2406 ID3D10Buffer
**buffer
)
2408 FIXME("iface %p, buffer %p stub!\n", iface
, buffer
);
2413 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer
*iface
,
2414 ID3D10ShaderResourceView
*view
)
2416 FIXME("iface %p, view %p stub!\n", iface
, view
);
2421 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer
*iface
,
2422 ID3D10ShaderResourceView
**view
)
2424 FIXME("iface %p, view %p stub!\n", iface
, view
);
2429 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl
=
2431 /* ID3D10EffectVariable methods */
2432 d3d10_effect_constant_buffer_IsValid
,
2433 d3d10_effect_constant_buffer_GetType
,
2434 d3d10_effect_constant_buffer_GetDesc
,
2435 d3d10_effect_constant_buffer_GetAnnotationByIndex
,
2436 d3d10_effect_constant_buffer_GetAnnotationByName
,
2437 d3d10_effect_constant_buffer_GetMemberByIndex
,
2438 d3d10_effect_constant_buffer_GetMemberByName
,
2439 d3d10_effect_constant_buffer_GetMemberBySemantic
,
2440 d3d10_effect_constant_buffer_GetElement
,
2441 d3d10_effect_constant_buffer_GetParentConstantBuffer
,
2442 d3d10_effect_constant_buffer_AsScalar
,
2443 d3d10_effect_constant_buffer_AsVector
,
2444 d3d10_effect_constant_buffer_AsMatrix
,
2445 d3d10_effect_constant_buffer_AsString
,
2446 d3d10_effect_constant_buffer_AsShaderResource
,
2447 d3d10_effect_constant_buffer_AsRenderTargetView
,
2448 d3d10_effect_constant_buffer_AsDepthStencilView
,
2449 d3d10_effect_constant_buffer_AsConstantBuffer
,
2450 d3d10_effect_constant_buffer_AsShader
,
2451 d3d10_effect_constant_buffer_AsBlend
,
2452 d3d10_effect_constant_buffer_AsDepthStencil
,
2453 d3d10_effect_constant_buffer_AsRasterizer
,
2454 d3d10_effect_constant_buffer_AsSampler
,
2455 d3d10_effect_constant_buffer_SetRawValue
,
2456 d3d10_effect_constant_buffer_GetRawValue
,
2457 /* ID3D10EffectConstantBuffer methods */
2458 d3d10_effect_constant_buffer_SetConstantBuffer
,
2459 d3d10_effect_constant_buffer_GetConstantBuffer
,
2460 d3d10_effect_constant_buffer_SetTextureBuffer
,
2461 d3d10_effect_constant_buffer_GetTextureBuffer
,
2464 /* ID3D10EffectVariable methods */
2466 static BOOL STDMETHODCALLTYPE
d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable
*iface
)
2468 TRACE("iface %p\n", iface
);
2470 return (struct d3d10_effect_variable
*)iface
!= &null_scalar_variable
;
2473 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetType(
2474 ID3D10EffectScalarVariable
*iface
)
2476 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
2479 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetDesc(ID3D10EffectScalarVariable
*iface
,
2480 D3D10_EFFECT_VARIABLE_DESC
*desc
)
2482 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
2485 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetAnnotationByIndex(
2486 ID3D10EffectScalarVariable
*iface
, UINT index
)
2488 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
2491 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetAnnotationByName(
2492 ID3D10EffectScalarVariable
*iface
, LPCSTR name
)
2494 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
2497 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetMemberByIndex(
2498 ID3D10EffectScalarVariable
*iface
, UINT index
)
2500 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
2503 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetMemberByName(
2504 ID3D10EffectScalarVariable
*iface
, LPCSTR name
)
2506 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
2509 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetMemberBySemantic(
2510 ID3D10EffectScalarVariable
*iface
, LPCSTR semantic
)
2512 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
2515 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetElement(
2516 ID3D10EffectScalarVariable
*iface
, UINT index
)
2518 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
2521 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetParentConstantBuffer(
2522 ID3D10EffectScalarVariable
*iface
)
2524 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
2527 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsScalar(
2528 ID3D10EffectScalarVariable
*iface
)
2530 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
2533 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsVector(
2534 ID3D10EffectScalarVariable
*iface
)
2536 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
2539 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsMatrix(
2540 ID3D10EffectScalarVariable
*iface
)
2542 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
2545 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsString(
2546 ID3D10EffectScalarVariable
*iface
)
2548 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
2551 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsShaderResource(
2552 ID3D10EffectScalarVariable
*iface
)
2554 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
2557 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsRenderTargetView(
2558 ID3D10EffectScalarVariable
*iface
)
2560 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
2563 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsDepthStencilView(
2564 ID3D10EffectScalarVariable
*iface
)
2566 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
2569 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsConstantBuffer(
2570 ID3D10EffectScalarVariable
*iface
)
2572 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
2575 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsShader(
2576 ID3D10EffectScalarVariable
*iface
)
2578 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
2581 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsBlend(
2582 ID3D10EffectScalarVariable
*iface
)
2584 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
2587 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsDepthStencil(
2588 ID3D10EffectScalarVariable
*iface
)
2590 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
2593 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsRasterizer(
2594 ID3D10EffectScalarVariable
*iface
)
2596 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
2599 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsSampler(
2600 ID3D10EffectScalarVariable
*iface
)
2602 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
2605 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetRawValue(ID3D10EffectScalarVariable
*iface
,
2606 void *data
, UINT offset
, UINT count
)
2608 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2611 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetRawValue(ID3D10EffectScalarVariable
*iface
,
2612 void *data
, UINT offset
, UINT count
)
2614 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2617 /* ID3D10EffectScalarVariable methods */
2619 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable
*iface
,
2622 FIXME("iface %p, value %.8e stub!\n", iface
, value
);
2627 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable
*iface
,
2630 FIXME("iface %p, value %p stub!\n", iface
, value
);
2635 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable
*iface
,
2636 float *values
, UINT offset
, UINT count
)
2638 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2643 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable
*iface
,
2644 float *values
, UINT offset
, UINT count
)
2646 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2651 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable
*iface
,
2654 FIXME("iface %p, value %d stub!\n", iface
, value
);
2659 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable
*iface
,
2662 FIXME("iface %p, value %p stub!\n", iface
, value
);
2667 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable
*iface
,
2668 int *values
, UINT offset
, UINT count
)
2670 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2675 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable
*iface
,
2676 int *values
, UINT offset
, UINT count
)
2678 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2683 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable
*iface
,
2686 FIXME("iface %p, value %d stub!\n", iface
, value
);
2691 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable
*iface
,
2694 FIXME("iface %p, value %p stub!\n", iface
, value
);
2699 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable
*iface
,
2700 BOOL
*values
, UINT offset
, UINT count
)
2702 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2707 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable
*iface
,
2708 BOOL
*values
, UINT offset
, UINT count
)
2710 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2715 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl
=
2717 /* ID3D10EffectVariable methods */
2718 d3d10_effect_scalar_variable_IsValid
,
2719 d3d10_effect_scalar_variable_GetType
,
2720 d3d10_effect_scalar_variable_GetDesc
,
2721 d3d10_effect_scalar_variable_GetAnnotationByIndex
,
2722 d3d10_effect_scalar_variable_GetAnnotationByName
,
2723 d3d10_effect_scalar_variable_GetMemberByIndex
,
2724 d3d10_effect_scalar_variable_GetMemberByName
,
2725 d3d10_effect_scalar_variable_GetMemberBySemantic
,
2726 d3d10_effect_scalar_variable_GetElement
,
2727 d3d10_effect_scalar_variable_GetParentConstantBuffer
,
2728 d3d10_effect_scalar_variable_AsScalar
,
2729 d3d10_effect_scalar_variable_AsVector
,
2730 d3d10_effect_scalar_variable_AsMatrix
,
2731 d3d10_effect_scalar_variable_AsString
,
2732 d3d10_effect_scalar_variable_AsShaderResource
,
2733 d3d10_effect_scalar_variable_AsRenderTargetView
,
2734 d3d10_effect_scalar_variable_AsDepthStencilView
,
2735 d3d10_effect_scalar_variable_AsConstantBuffer
,
2736 d3d10_effect_scalar_variable_AsShader
,
2737 d3d10_effect_scalar_variable_AsBlend
,
2738 d3d10_effect_scalar_variable_AsDepthStencil
,
2739 d3d10_effect_scalar_variable_AsRasterizer
,
2740 d3d10_effect_scalar_variable_AsSampler
,
2741 d3d10_effect_scalar_variable_SetRawValue
,
2742 d3d10_effect_scalar_variable_GetRawValue
,
2743 /* ID3D10EffectScalarVariable methods */
2744 d3d10_effect_scalar_variable_SetFloat
,
2745 d3d10_effect_scalar_variable_GetFloat
,
2746 d3d10_effect_scalar_variable_SetFloatArray
,
2747 d3d10_effect_scalar_variable_GetFloatArray
,
2748 d3d10_effect_scalar_variable_SetInt
,
2749 d3d10_effect_scalar_variable_GetInt
,
2750 d3d10_effect_scalar_variable_SetIntArray
,
2751 d3d10_effect_scalar_variable_GetIntArray
,
2752 d3d10_effect_scalar_variable_SetBool
,
2753 d3d10_effect_scalar_variable_GetBool
,
2754 d3d10_effect_scalar_variable_SetBoolArray
,
2755 d3d10_effect_scalar_variable_GetBoolArray
,
2758 /* ID3D10EffectVariable methods */
2760 static BOOL STDMETHODCALLTYPE
d3d10_effect_vector_variable_IsValid(ID3D10EffectVectorVariable
*iface
)
2762 TRACE("iface %p\n", iface
);
2764 return (struct d3d10_effect_variable
*)iface
!= &null_vector_variable
;
2767 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetType(
2768 ID3D10EffectVectorVariable
*iface
)
2770 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
2773 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetDesc(ID3D10EffectVectorVariable
*iface
,
2774 D3D10_EFFECT_VARIABLE_DESC
*desc
)
2776 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
2779 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetAnnotationByIndex(
2780 ID3D10EffectVectorVariable
*iface
, UINT index
)
2782 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
2785 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetAnnotationByName(
2786 ID3D10EffectVectorVariable
*iface
, LPCSTR name
)
2788 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
2791 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetMemberByIndex(
2792 ID3D10EffectVectorVariable
*iface
, UINT index
)
2794 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
2797 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetMemberByName(
2798 ID3D10EffectVectorVariable
*iface
, LPCSTR name
)
2800 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
2803 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetMemberBySemantic(
2804 ID3D10EffectVectorVariable
*iface
, LPCSTR semantic
)
2806 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
2809 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetElement(
2810 ID3D10EffectVectorVariable
*iface
, UINT index
)
2812 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
2815 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetParentConstantBuffer(
2816 ID3D10EffectVectorVariable
*iface
)
2818 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
2821 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsScalar(
2822 ID3D10EffectVectorVariable
*iface
)
2824 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
2827 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsVector(
2828 ID3D10EffectVectorVariable
*iface
)
2830 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
2833 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsMatrix(
2834 ID3D10EffectVectorVariable
*iface
)
2836 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
2839 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsString(
2840 ID3D10EffectVectorVariable
*iface
)
2842 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
2845 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsShaderResource(
2846 ID3D10EffectVectorVariable
*iface
)
2848 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
2851 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsRenderTargetView(
2852 ID3D10EffectVectorVariable
*iface
)
2854 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
2857 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsDepthStencilView(
2858 ID3D10EffectVectorVariable
*iface
)
2860 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
2863 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsConstantBuffer(
2864 ID3D10EffectVectorVariable
*iface
)
2866 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
2869 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsShader(
2870 ID3D10EffectVectorVariable
*iface
)
2872 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
2875 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsBlend(
2876 ID3D10EffectVectorVariable
*iface
)
2878 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
2881 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsDepthStencil(
2882 ID3D10EffectVectorVariable
*iface
)
2884 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
2887 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsRasterizer(
2888 ID3D10EffectVectorVariable
*iface
)
2890 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
2893 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsSampler(
2894 ID3D10EffectVectorVariable
*iface
)
2896 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
2899 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetRawValue(ID3D10EffectVectorVariable
*iface
,
2900 void *data
, UINT offset
, UINT count
)
2902 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2905 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetRawValue(ID3D10EffectVectorVariable
*iface
,
2906 void *data
, UINT offset
, UINT count
)
2908 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2911 /* ID3D10EffectVectorVariable methods */
2913 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetBoolVector(ID3D10EffectVectorVariable
*iface
,
2916 FIXME("iface %p, value %p stub!\n", iface
, value
);
2921 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetIntVector(ID3D10EffectVectorVariable
*iface
,
2924 FIXME("iface %p, value %p stub!\n", iface
, value
);
2929 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetFloatVector(ID3D10EffectVectorVariable
*iface
,
2932 FIXME("iface %p, value %p stub!\n", iface
, value
);
2937 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetBoolVector(ID3D10EffectVectorVariable
*iface
,
2940 FIXME("iface %p, value %p stub!\n", iface
, value
);
2945 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetIntVector(ID3D10EffectVectorVariable
*iface
,
2948 FIXME("iface %p, value %p stub!\n", iface
, value
);
2953 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetFloatVector(ID3D10EffectVectorVariable
*iface
,
2956 FIXME("iface %p, value %p stub!\n", iface
, value
);
2961 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetBoolVectorArray(ID3D10EffectVectorVariable
*iface
,
2962 BOOL
*values
, UINT offset
, UINT count
)
2964 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2969 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetIntVectorArray(ID3D10EffectVectorVariable
*iface
,
2970 int *values
, UINT offset
, UINT count
)
2972 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2977 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetFloatVectorArray(ID3D10EffectVectorVariable
*iface
,
2978 float *values
, UINT offset
, UINT count
)
2980 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2985 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetBoolVectorArray(ID3D10EffectVectorVariable
*iface
,
2986 BOOL
*values
, UINT offset
, UINT count
)
2988 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2993 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetIntVectorArray(ID3D10EffectVectorVariable
*iface
,
2994 int *values
, UINT offset
, UINT count
)
2996 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3001 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetFloatVectorArray(ID3D10EffectVectorVariable
*iface
,
3002 float *values
, UINT offset
, UINT count
)
3004 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3009 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl
=
3011 /* ID3D10EffectVariable methods */
3012 d3d10_effect_vector_variable_IsValid
,
3013 d3d10_effect_vector_variable_GetType
,
3014 d3d10_effect_vector_variable_GetDesc
,
3015 d3d10_effect_vector_variable_GetAnnotationByIndex
,
3016 d3d10_effect_vector_variable_GetAnnotationByName
,
3017 d3d10_effect_vector_variable_GetMemberByIndex
,
3018 d3d10_effect_vector_variable_GetMemberByName
,
3019 d3d10_effect_vector_variable_GetMemberBySemantic
,
3020 d3d10_effect_vector_variable_GetElement
,
3021 d3d10_effect_vector_variable_GetParentConstantBuffer
,
3022 d3d10_effect_vector_variable_AsScalar
,
3023 d3d10_effect_vector_variable_AsVector
,
3024 d3d10_effect_vector_variable_AsMatrix
,
3025 d3d10_effect_vector_variable_AsString
,
3026 d3d10_effect_vector_variable_AsShaderResource
,
3027 d3d10_effect_vector_variable_AsRenderTargetView
,
3028 d3d10_effect_vector_variable_AsDepthStencilView
,
3029 d3d10_effect_vector_variable_AsConstantBuffer
,
3030 d3d10_effect_vector_variable_AsShader
,
3031 d3d10_effect_vector_variable_AsBlend
,
3032 d3d10_effect_vector_variable_AsDepthStencil
,
3033 d3d10_effect_vector_variable_AsRasterizer
,
3034 d3d10_effect_vector_variable_AsSampler
,
3035 d3d10_effect_vector_variable_SetRawValue
,
3036 d3d10_effect_vector_variable_GetRawValue
,
3037 /* ID3D10EffectVectorVariable methods */
3038 d3d10_effect_vector_variable_SetBoolVector
,
3039 d3d10_effect_vector_variable_SetIntVector
,
3040 d3d10_effect_vector_variable_SetFloatVector
,
3041 d3d10_effect_vector_variable_GetBoolVector
,
3042 d3d10_effect_vector_variable_GetIntVector
,
3043 d3d10_effect_vector_variable_GetFloatVector
,
3044 d3d10_effect_vector_variable_SetBoolVectorArray
,
3045 d3d10_effect_vector_variable_SetIntVectorArray
,
3046 d3d10_effect_vector_variable_SetFloatVectorArray
,
3047 d3d10_effect_vector_variable_GetBoolVectorArray
,
3048 d3d10_effect_vector_variable_GetIntVectorArray
,
3049 d3d10_effect_vector_variable_GetFloatVectorArray
,
3052 /* ID3D10EffectVariable methods */
3054 static BOOL STDMETHODCALLTYPE
d3d10_effect_matrix_variable_IsValid(ID3D10EffectMatrixVariable
*iface
)
3056 TRACE("iface %p\n", iface
);
3058 return (struct d3d10_effect_variable
*)iface
!= &null_matrix_variable
;
3061 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetType(
3062 ID3D10EffectMatrixVariable
*iface
)
3064 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
3067 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetDesc(ID3D10EffectMatrixVariable
*iface
,
3068 D3D10_EFFECT_VARIABLE_DESC
*desc
)
3070 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
3073 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetAnnotationByIndex(
3074 ID3D10EffectMatrixVariable
*iface
, UINT index
)
3076 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
3079 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetAnnotationByName(
3080 ID3D10EffectMatrixVariable
*iface
, LPCSTR name
)
3082 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
3085 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMemberByIndex(
3086 ID3D10EffectMatrixVariable
*iface
, UINT index
)
3088 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
3091 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMemberByName(
3092 ID3D10EffectMatrixVariable
*iface
, LPCSTR name
)
3094 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
3097 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMemberBySemantic(
3098 ID3D10EffectMatrixVariable
*iface
, LPCSTR semantic
)
3100 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
3103 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetElement(
3104 ID3D10EffectMatrixVariable
*iface
, UINT index
)
3106 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
3109 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetParentConstantBuffer(
3110 ID3D10EffectMatrixVariable
*iface
)
3112 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
3115 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsScalar(
3116 ID3D10EffectMatrixVariable
*iface
)
3118 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
3121 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsVector(
3122 ID3D10EffectMatrixVariable
*iface
)
3124 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
3127 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsMatrix(
3128 ID3D10EffectMatrixVariable
*iface
)
3130 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
3133 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsString(
3134 ID3D10EffectMatrixVariable
*iface
)
3136 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
3139 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsShaderResource(
3140 ID3D10EffectMatrixVariable
*iface
)
3142 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
3145 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsRenderTargetView(
3146 ID3D10EffectMatrixVariable
*iface
)
3148 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
3151 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsDepthStencilView(
3152 ID3D10EffectMatrixVariable
*iface
)
3154 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
3157 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsConstantBuffer(
3158 ID3D10EffectMatrixVariable
*iface
)
3160 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
3163 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsShader(
3164 ID3D10EffectMatrixVariable
*iface
)
3166 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
3169 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsBlend(
3170 ID3D10EffectMatrixVariable
*iface
)
3172 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
3175 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsDepthStencil(
3176 ID3D10EffectMatrixVariable
*iface
)
3178 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
3181 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsRasterizer(
3182 ID3D10EffectMatrixVariable
*iface
)
3184 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
3187 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsSampler(
3188 ID3D10EffectMatrixVariable
*iface
)
3190 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
3193 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetRawValue(ID3D10EffectMatrixVariable
*iface
,
3194 void *data
, UINT offset
, UINT count
)
3196 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
3199 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetRawValue(ID3D10EffectMatrixVariable
*iface
,
3200 void *data
, UINT offset
, UINT count
)
3202 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
3205 /* ID3D10EffectMatrixVariable methods */
3207 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrix(ID3D10EffectMatrixVariable
*iface
,
3210 FIXME("iface %p, data %p stub!\n", iface
, data
);
3215 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrix(ID3D10EffectMatrixVariable
*iface
,
3218 FIXME("iface %p, data %p stub!\n", iface
, data
);
3223 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrixArray(ID3D10EffectMatrixVariable
*iface
,
3224 float *data
, UINT offset
, UINT count
)
3226 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3231 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrixArray(ID3D10EffectMatrixVariable
*iface
,
3232 float *data
, UINT offset
, UINT count
)
3234 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3239 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrixTranspose(ID3D10EffectMatrixVariable
*iface
,
3242 FIXME("iface %p, data %p stub!\n", iface
, data
);
3247 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrixTranspose(ID3D10EffectMatrixVariable
*iface
,
3250 FIXME("iface %p, data %p stub!\n", iface
, data
);
3255 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrixTransposeArray(ID3D10EffectMatrixVariable
*iface
,
3256 float *data
, UINT offset
, UINT count
)
3258 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3263 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrixTransposeArray(ID3D10EffectMatrixVariable
*iface
,
3264 float *data
, UINT offset
, UINT count
)
3266 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3272 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl
=
3274 /* ID3D10EffectVariable methods */
3275 d3d10_effect_matrix_variable_IsValid
,
3276 d3d10_effect_matrix_variable_GetType
,
3277 d3d10_effect_matrix_variable_GetDesc
,
3278 d3d10_effect_matrix_variable_GetAnnotationByIndex
,
3279 d3d10_effect_matrix_variable_GetAnnotationByName
,
3280 d3d10_effect_matrix_variable_GetMemberByIndex
,
3281 d3d10_effect_matrix_variable_GetMemberByName
,
3282 d3d10_effect_matrix_variable_GetMemberBySemantic
,
3283 d3d10_effect_matrix_variable_GetElement
,
3284 d3d10_effect_matrix_variable_GetParentConstantBuffer
,
3285 d3d10_effect_matrix_variable_AsScalar
,
3286 d3d10_effect_matrix_variable_AsVector
,
3287 d3d10_effect_matrix_variable_AsMatrix
,
3288 d3d10_effect_matrix_variable_AsString
,
3289 d3d10_effect_matrix_variable_AsShaderResource
,
3290 d3d10_effect_matrix_variable_AsRenderTargetView
,
3291 d3d10_effect_matrix_variable_AsDepthStencilView
,
3292 d3d10_effect_matrix_variable_AsConstantBuffer
,
3293 d3d10_effect_matrix_variable_AsShader
,
3294 d3d10_effect_matrix_variable_AsBlend
,
3295 d3d10_effect_matrix_variable_AsDepthStencil
,
3296 d3d10_effect_matrix_variable_AsRasterizer
,
3297 d3d10_effect_matrix_variable_AsSampler
,
3298 d3d10_effect_matrix_variable_SetRawValue
,
3299 d3d10_effect_matrix_variable_GetRawValue
,
3300 /* ID3D10EffectMatrixVariable methods */
3301 d3d10_effect_matrix_variable_SetMatrix
,
3302 d3d10_effect_matrix_variable_GetMatrix
,
3303 d3d10_effect_matrix_variable_SetMatrixArray
,
3304 d3d10_effect_matrix_variable_GetMatrixArray
,
3305 d3d10_effect_matrix_variable_SetMatrixTranspose
,
3306 d3d10_effect_matrix_variable_GetMatrixTranspose
,
3307 d3d10_effect_matrix_variable_SetMatrixTransposeArray
,
3308 d3d10_effect_matrix_variable_GetMatrixTransposeArray
,
3311 static BOOL STDMETHODCALLTYPE
d3d10_effect_type_IsValid(ID3D10EffectType
*iface
)
3313 FIXME("iface %p stub!\n", iface
);
3318 static HRESULT STDMETHODCALLTYPE
d3d10_effect_type_GetDesc(ID3D10EffectType
*iface
, D3D10_EFFECT_TYPE_DESC
*desc
)
3320 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3322 TRACE("iface %p, desc %p\n", iface
, desc
);
3324 if (This
== &null_type
)
3326 WARN("Null type specified\n");
3332 WARN("Invalid argument specified\n");
3333 return E_INVALIDARG
;
3336 desc
->TypeName
= This
->name
;
3337 desc
->Class
= This
->type_class
;
3338 desc
->Type
= This
->basetype
;
3339 desc
->Elements
= This
->element_count
;
3340 desc
->Members
= This
->member_count
;
3341 desc
->Rows
= This
->row_count
;
3342 desc
->Columns
= This
->column_count
;
3343 desc
->PackedSize
= This
->size_packed
;
3344 desc
->UnpackedSize
= This
->size_unpacked
;
3345 desc
->Stride
= This
->stride
;
3350 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_type_GetMemberTypeByIndex(ID3D10EffectType
*iface
,
3353 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3354 struct d3d10_effect_type
*t
;
3356 TRACE("iface %p, index %u\n", iface
, index
);
3358 if (index
>= This
->member_count
)
3360 WARN("Invalid index specified\n");
3361 return (ID3D10EffectType
*)&null_type
;
3364 t
= (&This
->members
[index
])->type
;
3366 TRACE("Returning member %p, %s\n", t
, debugstr_a(t
->name
));
3368 return (ID3D10EffectType
*)t
;
3371 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_type_GetMemberTypeByName(ID3D10EffectType
*iface
,
3374 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3377 TRACE("iface %p, name %s\n", iface
, debugstr_a(name
));
3381 WARN("Invalid name specified\n");
3382 return (ID3D10EffectType
*)&null_type
;
3385 for (i
= 0; i
< This
->member_count
; ++i
)
3387 struct d3d10_effect_type_member
*typem
= &This
->members
[i
];
3391 if (!strcmp(typem
->name
, name
))
3393 TRACE("Returning type %p.\n", typem
->type
);
3394 return (ID3D10EffectType
*)typem
->type
;
3399 WARN("Invalid name specified\n");
3401 return (ID3D10EffectType
*)&null_type
;
3404 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_type_GetMemberTypeBySemantic(ID3D10EffectType
*iface
,
3407 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3410 TRACE("iface %p, semantic %s\n", iface
, debugstr_a(semantic
));
3414 WARN("Invalid semantic specified\n");
3415 return (ID3D10EffectType
*)&null_type
;
3418 for (i
= 0; i
< This
->member_count
; ++i
)
3420 struct d3d10_effect_type_member
*typem
= &This
->members
[i
];
3422 if (typem
->semantic
)
3424 if (!strcmp(typem
->semantic
, semantic
))
3426 TRACE("Returning type %p.\n", typem
->type
);
3427 return (ID3D10EffectType
*)typem
->type
;
3432 WARN("Invalid semantic specified\n");
3434 return (ID3D10EffectType
*)&null_type
;
3437 static LPCSTR STDMETHODCALLTYPE
d3d10_effect_type_GetMemberName(ID3D10EffectType
*iface
, UINT index
)
3439 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3440 struct d3d10_effect_type_member
*typem
;
3442 TRACE("iface %p, index %u\n", iface
, index
);
3444 if (index
>= This
->member_count
)
3446 WARN("Invalid index specified\n");
3450 typem
= &This
->members
[index
];
3452 TRACE("Returning name %s\n", debugstr_a(typem
->name
));
3457 static LPCSTR STDMETHODCALLTYPE
d3d10_effect_type_GetMemberSemantic(ID3D10EffectType
*iface
, UINT index
)
3459 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3460 struct d3d10_effect_type_member
*typem
;
3462 TRACE("iface %p, index %u\n", iface
, index
);
3464 if (index
>= This
->member_count
)
3466 WARN("Invalid index specified\n");
3470 typem
= &This
->members
[index
];
3472 TRACE("Returning semantic %s\n", debugstr_a(typem
->semantic
));
3474 return typem
->semantic
;
3477 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl
=
3479 /* ID3D10EffectType */
3480 d3d10_effect_type_IsValid
,
3481 d3d10_effect_type_GetDesc
,
3482 d3d10_effect_type_GetMemberTypeByIndex
,
3483 d3d10_effect_type_GetMemberTypeByName
,
3484 d3d10_effect_type_GetMemberTypeBySemantic
,
3485 d3d10_effect_type_GetMemberName
,
3486 d3d10_effect_type_GetMemberSemantic
,