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 #define D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK 0x4000
48 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl
;
49 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl
;
50 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl
;
51 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl
;
52 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl
;
53 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl
;
54 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl
;
55 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl
;
57 /* null objects - needed for invalid calls */
58 static struct d3d10_effect_technique null_technique
=
59 {&d3d10_effect_technique_vtbl
, NULL
, NULL
, 0, 0, NULL
, NULL
};
60 static struct d3d10_effect_pass null_pass
=
61 {&d3d10_effect_pass_vtbl
, NULL
, NULL
, 0, 0, 0, NULL
, NULL
};
62 static struct d3d10_effect_type null_type
=
63 {&d3d10_effect_type_vtbl
, 0, {NULL
, NULL
, 0}, NULL
, NULL
, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
, NULL
};
64 static struct d3d10_effect_variable null_local_buffer
=
65 {(ID3D10EffectVariableVtbl
*)&d3d10_effect_constant_buffer_vtbl
, &null_local_buffer
,
66 NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
, NULL
};
67 static struct d3d10_effect_variable null_variable
=
68 {&d3d10_effect_variable_vtbl
, &null_local_buffer
,
69 NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
, NULL
};
70 static struct d3d10_effect_variable null_scalar_variable
=
71 {(ID3D10EffectVariableVtbl
*)&d3d10_effect_scalar_variable_vtbl
, &null_local_buffer
,
72 NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
, NULL
};
73 static struct d3d10_effect_variable null_vector_variable
=
74 {(ID3D10EffectVariableVtbl
*)&d3d10_effect_vector_variable_vtbl
, &null_local_buffer
,
75 NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
, NULL
};
76 static struct d3d10_effect_variable null_matrix_variable
=
77 {(ID3D10EffectVariableVtbl
*)&d3d10_effect_matrix_variable_vtbl
, &null_local_buffer
,
78 NULL
, NULL
, NULL
, 0, 0, 0, 0, &null_type
, NULL
, NULL
, NULL
};
80 static struct d3d10_effect_type
*get_fx10_type(struct d3d10_effect
*effect
, const char *data
, DWORD offset
);
82 static inline void read_dword(const char **ptr
, DWORD
*d
)
84 memcpy(d
, *ptr
, sizeof(*d
));
88 static inline void skip_dword_unknown(const char **ptr
, unsigned int count
)
93 FIXME("Skipping %u unknown DWORDs:\n", count
);
94 for (i
= 0; i
< count
; ++i
)
97 FIXME("\t0x%08x\n", d
);
101 static inline void write_dword(char **ptr
, DWORD d
)
103 memcpy(*ptr
, &d
, sizeof(d
));
107 static inline void write_dword_unknown(char **ptr
, DWORD d
)
109 FIXME("Writing unknown DWORD 0x%08x\n", d
);
113 static HRESULT
parse_dxbc(const char *data
, SIZE_T data_size
,
114 HRESULT (*chunk_handler
)(const char *data
, DWORD data_size
, DWORD tag
, void *ctx
), void *ctx
)
116 const char *ptr
= data
;
123 read_dword(&ptr
, &tag
);
124 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
128 WARN("Wrong tag.\n");
133 skip_dword_unknown(&ptr
, 4);
135 skip_dword_unknown(&ptr
, 1);
137 read_dword(&ptr
, &total_size
);
138 TRACE("total size: %#x\n", total_size
);
140 read_dword(&ptr
, &chunk_count
);
141 TRACE("chunk count: %#x\n", chunk_count
);
143 for (i
= 0; i
< chunk_count
; ++i
)
145 DWORD chunk_tag
, chunk_size
;
146 const char *chunk_ptr
;
149 read_dword(&ptr
, &chunk_offset
);
150 TRACE("chunk %u at offset %#x\n", i
, chunk_offset
);
152 chunk_ptr
= data
+ chunk_offset
;
154 read_dword(&chunk_ptr
, &chunk_tag
);
155 read_dword(&chunk_ptr
, &chunk_size
);
157 hr
= chunk_handler(chunk_ptr
, chunk_size
, chunk_tag
, ctx
);
158 if (FAILED(hr
)) break;
164 static BOOL
copy_name(const char *ptr
, char **name
)
168 if (!ptr
) return TRUE
;
170 name_len
= strlen(ptr
) + 1;
176 *name
= HeapAlloc(GetProcessHeap(), 0, name_len
);
179 ERR("Failed to allocate name memory.\n");
183 memcpy(*name
, ptr
, name_len
);
188 static HRESULT
shader_chunk_handler(const char *data
, DWORD data_size
, DWORD tag
, void *ctx
)
190 struct d3d10_effect_shader_variable
*s
= ctx
;
192 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
194 TRACE("chunk size: %#x\n", data_size
);
200 /* 32 (DXBC header) + 1 * 4 (chunk index) + 2 * 4 (chunk header) + data_size (chunk data) */
201 UINT size
= 44 + data_size
;
204 s
->input_signature
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
205 if (!s
->input_signature
)
207 ERR("Failed to allocate input signature data\n");
208 return E_OUTOFMEMORY
;
210 s
->input_signature_size
= size
;
212 ptr
= s
->input_signature
;
214 write_dword(&ptr
, TAG_DXBC
);
217 write_dword_unknown(&ptr
, 0);
218 write_dword_unknown(&ptr
, 0);
219 write_dword_unknown(&ptr
, 0);
220 write_dword_unknown(&ptr
, 0);
222 /* seems to be always 1 */
223 write_dword_unknown(&ptr
, 1);
226 write_dword(&ptr
, size
);
229 write_dword(&ptr
, 1);
232 write_dword(&ptr
, (ptr
- s
->input_signature
) + 4);
235 write_dword(&ptr
, TAG_ISGN
);
236 write_dword(&ptr
, data_size
);
237 memcpy(ptr
, data
, data_size
);
242 FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag
, 4));
249 static HRESULT
parse_shader(struct d3d10_effect_object
*o
, const char *data
)
251 ID3D10Device
*device
= o
->pass
->technique
->effect
->device
;
252 struct d3d10_effect_shader_variable
*s
;
253 const char *ptr
= data
;
257 o
->data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(struct d3d10_effect_shader_variable
));
260 ERR("Failed to allocate shader variable memory\n");
261 return E_OUTOFMEMORY
;
264 if (!ptr
) return S_OK
;
268 read_dword(&ptr
, &dxbc_size
);
269 TRACE("dxbc size: %#x\n", dxbc_size
);
273 case D3D10_EOT_VERTEXSHADER
:
274 hr
= ID3D10Device_CreateVertexShader(device
, ptr
, dxbc_size
, &s
->shader
.vs
);
275 if (FAILED(hr
)) return hr
;
278 case D3D10_EOT_PIXELSHADER
:
279 hr
= ID3D10Device_CreatePixelShader(device
, ptr
, dxbc_size
, &s
->shader
.ps
);
280 if (FAILED(hr
)) return hr
;
282 case D3D10_EOT_GEOMETRYSHADER
:
283 hr
= ID3D10Device_CreateGeometryShader(device
, ptr
, dxbc_size
, &s
->shader
.gs
);
284 if (FAILED(hr
)) return hr
;
288 return parse_dxbc(ptr
, dxbc_size
, shader_chunk_handler
, s
);
291 static D3D10_SHADER_VARIABLE_CLASS
d3d10_variable_class(DWORD c
, BOOL is_column_major
)
295 case 1: return D3D10_SVC_SCALAR
;
296 case 2: return D3D10_SVC_VECTOR
;
297 case 3: if (is_column_major
) return D3D10_SVC_MATRIX_COLUMNS
;
298 else return D3D10_SVC_MATRIX_ROWS
;
300 FIXME("Unknown variable class %#x.\n", c
);
305 static D3D10_SHADER_VARIABLE_TYPE
d3d10_variable_type(DWORD t
, BOOL is_object
)
311 case 1: return D3D10_SVT_STRING
;
312 case 2: return D3D10_SVT_BLEND
;
313 case 3: return D3D10_SVT_DEPTHSTENCIL
;
314 case 4: return D3D10_SVT_RASTERIZER
;
315 case 5: return D3D10_SVT_PIXELSHADER
;
316 case 6: return D3D10_SVT_VERTEXSHADER
;
317 case 7: return D3D10_SVT_GEOMETRYSHADER
;
319 case 10: return D3D10_SVT_TEXTURE1D
;
320 case 11: return D3D10_SVT_TEXTURE1DARRAY
;
321 case 12: return D3D10_SVT_TEXTURE2D
;
322 case 13: return D3D10_SVT_TEXTURE2DARRAY
;
323 case 14: return D3D10_SVT_TEXTURE2DMS
;
324 case 15: return D3D10_SVT_TEXTURE2DMSARRAY
;
325 case 16: return D3D10_SVT_TEXTURE3D
;
326 case 17: return D3D10_SVT_TEXTURECUBE
;
328 case 19: return D3D10_SVT_RENDERTARGETVIEW
;
329 case 20: return D3D10_SVT_DEPTHSTENCILVIEW
;
330 case 21: return D3D10_SVT_SAMPLER
;
332 FIXME("Unknown variable type %#x.\n", t
);
340 case 1: return D3D10_SVT_FLOAT
;
341 case 2: return D3D10_SVT_INT
;
342 case 3: return D3D10_SVT_UINT
;
343 case 4: return D3D10_SVT_BOOL
;
345 FIXME("Unknown variable type %#x.\n", t
);
351 static HRESULT
parse_fx10_type(struct d3d10_effect_type
*t
, const char *ptr
, const char *data
)
358 read_dword(&ptr
, &offset
);
359 TRACE("Type name at offset %#x.\n", offset
);
361 if (!copy_name(data
+ offset
, &t
->name
))
363 ERR("Failed to copy name.\n");
364 return E_OUTOFMEMORY
;
366 TRACE("Type name: %s.\n", debugstr_a(t
->name
));
368 read_dword(&ptr
, &unknown0
);
369 TRACE("Unknown 0: %u.\n", unknown0
);
371 read_dword(&ptr
, &t
->element_count
);
372 TRACE("Element count: %u.\n", t
->element_count
);
374 read_dword(&ptr
, &t
->size_unpacked
);
375 TRACE("Unpacked size: %#x.\n", t
->size_unpacked
);
377 read_dword(&ptr
, &t
->stride
);
378 TRACE("Stride: %#x.\n", t
->stride
);
380 read_dword(&ptr
, &t
->size_packed
);
381 TRACE("Packed size %#x.\n", t
->size_packed
);
388 read_dword(&ptr
, &typeinfo
);
389 t
->column_count
= (typeinfo
& D3D10_FX10_TYPE_COLUMN_MASK
) >> D3D10_FX10_TYPE_COLUMN_SHIFT
;
390 t
->row_count
= (typeinfo
& D3D10_FX10_TYPE_ROW_MASK
) >> D3D10_FX10_TYPE_ROW_SHIFT
;
391 t
->basetype
= d3d10_variable_type((typeinfo
& D3D10_FX10_TYPE_BASETYPE_MASK
) >> D3D10_FX10_TYPE_BASETYPE_SHIFT
, FALSE
);
392 t
->type_class
= d3d10_variable_class((typeinfo
& D3D10_FX10_TYPE_CLASS_MASK
) >> D3D10_FX10_TYPE_CLASS_SHIFT
, typeinfo
& D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK
);
394 TRACE("Type description: %#x.\n", typeinfo
);
395 TRACE("\tcolumns: %u.\n", t
->column_count
);
396 TRACE("\trows: %u.\n", t
->row_count
);
397 TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t
->basetype
));
398 TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t
->type_class
));
399 TRACE("\tunknown bits: %#x.\n", typeinfo
& ~(D3D10_FX10_TYPE_COLUMN_MASK
| D3D10_FX10_TYPE_ROW_MASK
400 | D3D10_FX10_TYPE_BASETYPE_MASK
| D3D10_FX10_TYPE_CLASS_MASK
| D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK
));
404 TRACE("Type is an object.\n");
409 t
->type_class
= D3D10_SVC_OBJECT
;
411 read_dword(&ptr
, &typeinfo
);
412 t
->basetype
= d3d10_variable_type(typeinfo
, TRUE
);
414 TRACE("Type description: %#x.\n", typeinfo
);
415 TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t
->basetype
));
416 TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t
->type_class
));
420 TRACE("Type is a structure.\n");
422 read_dword(&ptr
, &t
->member_count
);
423 TRACE("Member count: %u.\n", t
->member_count
);
428 t
->type_class
= D3D10_SVC_STRUCT
;
430 t
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, t
->member_count
* sizeof(*t
->members
));
433 ERR("Failed to allocate members memory.\n");
434 return E_OUTOFMEMORY
;
437 for (i
= 0; i
< t
->member_count
; ++i
)
439 struct d3d10_effect_type_member
*typem
= &t
->members
[i
];
441 read_dword(&ptr
, &offset
);
442 TRACE("Member name at offset %#x.\n", offset
);
444 if (!copy_name(data
+ offset
, &typem
->name
))
446 ERR("Failed to copy name.\n");
447 return E_OUTOFMEMORY
;
449 TRACE("Member name: %s.\n", debugstr_a(typem
->name
));
451 read_dword(&ptr
, &offset
);
452 TRACE("Member semantic at offset %#x.\n", offset
);
454 if (!copy_name(data
+ offset
, &typem
->semantic
))
456 ERR("Failed to copy semantic.\n");
457 return E_OUTOFMEMORY
;
459 TRACE("Member semantic: %s.\n", debugstr_a(typem
->semantic
));
461 read_dword(&ptr
, &typem
->buffer_offset
);
462 TRACE("Member offset in struct: %#x.\n", typem
->buffer_offset
);
464 read_dword(&ptr
, &offset
);
465 TRACE("Member type info at offset %#x.\n", offset
);
467 typem
->type
= get_fx10_type(t
->effect
, data
, offset
);
470 ERR("Failed to get variable type.\n");
477 FIXME("Unhandled case %#x.\n", unknown0
);
481 if (t
->element_count
)
483 TRACE("Elementtype for type at offset: %#x\n", t
->id
);
485 /* allocate elementtype - we need only one, because all elements have the same type */
486 t
->elementtype
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*t
->elementtype
));
489 ERR("Failed to allocate members memory.\n");
490 return E_OUTOFMEMORY
;
493 /* create a copy of the original type with some minor changes */
494 t
->elementtype
->vtbl
= &d3d10_effect_type_vtbl
;
495 t
->elementtype
->effect
= t
->effect
;
497 if (!copy_name(t
->name
, &t
->elementtype
->name
))
499 ERR("Failed to copy name.\n");
500 return E_OUTOFMEMORY
;
502 TRACE("\tType name: %s.\n", debugstr_a(t
->elementtype
->name
));
504 t
->elementtype
->element_count
= 0;
505 TRACE("\tElement count: %u.\n", t
->elementtype
->element_count
);
508 * Not sure if this calculation is 100% correct, but a test
509 * show's that these values work.
511 t
->elementtype
->size_unpacked
= t
->size_packed
/ t
->element_count
;
512 TRACE("\tUnpacked size: %#x.\n", t
->elementtype
->size_unpacked
);
514 t
->elementtype
->stride
= t
->stride
;
515 TRACE("\tStride: %#x.\n", t
->elementtype
->stride
);
517 t
->elementtype
->size_packed
= t
->size_packed
/ t
->element_count
;
518 TRACE("\tPacked size: %#x.\n", t
->elementtype
->size_packed
);
520 t
->elementtype
->member_count
= t
->member_count
;
521 TRACE("\tMember count: %u.\n", t
->elementtype
->member_count
);
523 t
->elementtype
->column_count
= t
->column_count
;
524 TRACE("\tColumns: %u.\n", t
->elementtype
->column_count
);
526 t
->elementtype
->row_count
= t
->row_count
;
527 TRACE("\tRows: %u.\n", t
->elementtype
->row_count
);
529 t
->elementtype
->basetype
= t
->basetype
;
530 TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(t
->elementtype
->basetype
));
532 t
->elementtype
->type_class
= t
->type_class
;
533 TRACE("\tClass: %s.\n", debug_d3d10_shader_variable_class(t
->elementtype
->type_class
));
535 t
->elementtype
->members
= t
->members
;
541 static struct d3d10_effect_type
*get_fx10_type(struct d3d10_effect
*effect
, const char *data
, DWORD offset
)
543 struct d3d10_effect_type
*type
;
544 struct wine_rb_entry
*entry
;
547 entry
= wine_rb_get(&effect
->types
, &offset
);
550 TRACE("Returning existing type.\n");
551 return WINE_RB_ENTRY_VALUE(entry
, struct d3d10_effect_type
, entry
);
554 type
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*type
));
557 ERR("Failed to allocate type memory.\n");
561 type
->vtbl
= &d3d10_effect_type_vtbl
;
563 type
->effect
= effect
;
564 hr
= parse_fx10_type(type
, data
+ offset
, data
);
567 ERR("Failed to parse type info, hr %#x.\n", hr
);
568 HeapFree(GetProcessHeap(), 0, type
);
572 if (wine_rb_put(&effect
->types
, &offset
, &type
->entry
) == -1)
574 ERR("Failed to insert type entry.\n");
575 HeapFree(GetProcessHeap(), 0, type
);
582 static void set_variable_vtbl(struct d3d10_effect_variable
*v
)
584 switch (v
->type
->type_class
)
586 case D3D10_SVC_SCALAR
:
587 v
->vtbl
= (ID3D10EffectVariableVtbl
*)&d3d10_effect_scalar_variable_vtbl
;
590 case D3D10_SVC_VECTOR
:
591 v
->vtbl
= (ID3D10EffectVariableVtbl
*)&d3d10_effect_vector_variable_vtbl
;
594 case D3D10_SVC_MATRIX_ROWS
:
595 case D3D10_SVC_MATRIX_COLUMNS
:
596 v
->vtbl
= (ID3D10EffectVariableVtbl
*)&d3d10_effect_matrix_variable_vtbl
;
599 case D3D10_SVC_STRUCT
:
600 v
->vtbl
= &d3d10_effect_variable_vtbl
;
604 FIXME("Unhandled type class %s.\n", debug_d3d10_shader_variable_class(v
->type
->type_class
));
605 v
->vtbl
= &d3d10_effect_variable_vtbl
;
610 static HRESULT
copy_variableinfo_from_type(struct d3d10_effect_variable
*v
)
615 if (v
->type
->member_count
)
617 v
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, v
->type
->member_count
* sizeof(*v
->members
));
620 ERR("Failed to allocate members memory.\n");
621 return E_OUTOFMEMORY
;
624 for (i
= 0; i
< v
->type
->member_count
; ++i
)
626 struct d3d10_effect_variable
*var
= &v
->members
[i
];
627 struct d3d10_effect_type_member
*typem
= &v
->type
->members
[i
];
629 var
->buffer
= v
->buffer
;
630 var
->effect
= v
->effect
;
631 var
->type
= typem
->type
;
632 set_variable_vtbl(var
);
634 if (!copy_name(typem
->name
, &var
->name
))
636 ERR("Failed to copy name.\n");
637 return E_OUTOFMEMORY
;
639 TRACE("Variable name: %s.\n", debugstr_a(var
->name
));
641 if (!copy_name(typem
->semantic
, &var
->semantic
))
643 ERR("Failed to copy name.\n");
644 return E_OUTOFMEMORY
;
646 TRACE("Variable semantic: %s.\n", debugstr_a(var
->semantic
));
648 var
->buffer_offset
= v
->buffer_offset
+ typem
->buffer_offset
;
649 TRACE("Variable buffer offset: %u.\n", var
->buffer_offset
);
651 hr
= copy_variableinfo_from_type(var
);
652 if (FAILED(hr
)) return hr
;
656 if (v
->type
->element_count
)
658 unsigned int bufferoffset
= v
->buffer_offset
;
660 v
->elements
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, v
->type
->element_count
* sizeof(*v
->elements
));
663 ERR("Failed to allocate elements memory.\n");
664 return E_OUTOFMEMORY
;
667 for (i
= 0; i
< v
->type
->element_count
; ++i
)
669 struct d3d10_effect_variable
*var
= &v
->elements
[i
];
671 var
->buffer
= v
->buffer
;
672 var
->effect
= v
->effect
;
673 var
->type
= v
->type
->elementtype
;
674 set_variable_vtbl(var
);
676 if (!copy_name(v
->name
, &var
->name
))
678 ERR("Failed to copy name.\n");
679 return E_OUTOFMEMORY
;
681 TRACE("Variable name: %s.\n", debugstr_a(var
->name
));
683 if (!copy_name(v
->semantic
, &var
->semantic
))
685 ERR("Failed to copy name.\n");
686 return E_OUTOFMEMORY
;
688 TRACE("Variable semantic: %s.\n", debugstr_a(var
->semantic
));
692 bufferoffset
+= v
->type
->stride
;
694 var
->buffer_offset
= bufferoffset
;
695 TRACE("Variable buffer offset: %u.\n", var
->buffer_offset
);
697 hr
= copy_variableinfo_from_type(var
);
698 if (FAILED(hr
)) return hr
;
705 static HRESULT
parse_fx10_variable_head(struct d3d10_effect_variable
*v
, const char **ptr
, const char *data
)
709 read_dword(ptr
, &offset
);
710 TRACE("Variable name at offset %#x.\n", offset
);
712 if (!copy_name(data
+ offset
, &v
->name
))
714 ERR("Failed to copy name.\n");
715 return E_OUTOFMEMORY
;
717 TRACE("Variable name: %s.\n", debugstr_a(v
->name
));
719 read_dword(ptr
, &offset
);
720 TRACE("Variable type info at offset %#x.\n", offset
);
722 v
->type
= get_fx10_type(v
->effect
, data
, offset
);
725 ERR("Failed to get variable type.\n");
728 set_variable_vtbl(v
);
730 return copy_variableinfo_from_type(v
);
733 static HRESULT
parse_fx10_annotation(struct d3d10_effect_variable
*a
, const char **ptr
, const char *data
)
737 hr
= parse_fx10_variable_head(a
, ptr
, data
);
738 if (FAILED(hr
)) return hr
;
740 skip_dword_unknown(ptr
, 1);
745 static HRESULT
parse_fx10_object(struct d3d10_effect_object
*o
, const char **ptr
, const char *data
)
747 const char *data_ptr
;
751 read_dword(ptr
, &o
->type
);
752 TRACE("Effect object is of type %#x.\n", o
->type
);
754 skip_dword_unknown(ptr
, 2);
756 read_dword(ptr
, &offset
);
757 TRACE("Effect object idx is at offset %#x.\n", offset
);
759 data_ptr
= data
+ offset
;
760 read_dword(&data_ptr
, &offset
);
762 TRACE("Effect object starts at offset %#x.\n", offset
);
764 /* FIXME: This probably isn't completely correct. */
767 WARN("Skipping effect object.\n");
772 data_ptr
= data
+ offset
;
777 case D3D10_EOT_VERTEXSHADER
:
778 TRACE("Vertex shader\n");
779 hr
= parse_shader(o
, data_ptr
);
782 case D3D10_EOT_PIXELSHADER
:
783 TRACE("Pixel shader\n");
784 hr
= parse_shader(o
, data_ptr
);
787 case D3D10_EOT_GEOMETRYSHADER
:
788 TRACE("Geometry shader\n");
789 hr
= parse_shader(o
, data_ptr
);
793 FIXME("Unhandled object type %#x\n", o
->type
);
801 static HRESULT
parse_fx10_pass(struct d3d10_effect_pass
*p
, const char **ptr
, const char *data
)
807 read_dword(ptr
, &offset
);
808 TRACE("Pass name at offset %#x.\n", offset
);
810 if (!copy_name(data
+ offset
, &p
->name
))
812 ERR("Failed to copy name.\n");
813 return E_OUTOFMEMORY
;
815 TRACE("Pass name: %s.\n", debugstr_a(p
->name
));
817 read_dword(ptr
, &p
->object_count
);
818 TRACE("Pass has %u effect objects.\n", p
->object_count
);
820 read_dword(ptr
, &p
->annotation_count
);
821 TRACE("Pass has %u annotations.\n", p
->annotation_count
);
823 p
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, p
->annotation_count
* sizeof(*p
->annotations
));
826 ERR("Failed to allocate pass annotations memory.\n");
827 return E_OUTOFMEMORY
;
830 for(i
= 0; i
< p
->annotation_count
; ++i
)
832 struct d3d10_effect_variable
*a
= &p
->annotations
[i
];
834 a
->effect
= p
->technique
->effect
;
836 hr
= parse_fx10_annotation(a
, ptr
, data
);
837 if (FAILED(hr
)) return hr
;
840 p
->objects
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, p
->object_count
* sizeof(*p
->objects
));
843 ERR("Failed to allocate effect objects memory.\n");
844 return E_OUTOFMEMORY
;
847 for (i
= 0; i
< p
->object_count
; ++i
)
849 struct d3d10_effect_object
*o
= &p
->objects
[i
];
853 hr
= parse_fx10_object(o
, ptr
, data
);
854 if (FAILED(hr
)) return hr
;
860 static HRESULT
parse_fx10_technique(struct d3d10_effect_technique
*t
, const char **ptr
, const char *data
)
866 read_dword(ptr
, &offset
);
867 TRACE("Technique name at offset %#x.\n", offset
);
869 if (!copy_name(data
+ offset
, &t
->name
))
871 ERR("Failed to copy name.\n");
872 return E_OUTOFMEMORY
;
874 TRACE("Technique name: %s.\n", debugstr_a(t
->name
));
876 read_dword(ptr
, &t
->pass_count
);
877 TRACE("Technique has %u passes\n", t
->pass_count
);
879 read_dword(ptr
, &t
->annotation_count
);
880 TRACE("Technique has %u annotations.\n", t
->annotation_count
);
882 t
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, t
->annotation_count
* sizeof(*t
->annotations
));
885 ERR("Failed to allocate technique annotations memory.\n");
886 return E_OUTOFMEMORY
;
889 for(i
= 0; i
< t
->annotation_count
; ++i
)
891 struct d3d10_effect_variable
*a
= &t
->annotations
[i
];
893 a
->effect
= t
->effect
;
895 hr
= parse_fx10_annotation(a
, ptr
, data
);
896 if (FAILED(hr
)) return hr
;
899 t
->passes
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, t
->pass_count
* sizeof(*t
->passes
));
902 ERR("Failed to allocate passes memory\n");
903 return E_OUTOFMEMORY
;
906 for (i
= 0; i
< t
->pass_count
; ++i
)
908 struct d3d10_effect_pass
*p
= &t
->passes
[i
];
910 p
->vtbl
= &d3d10_effect_pass_vtbl
;
913 hr
= parse_fx10_pass(p
, ptr
, data
);
914 if (FAILED(hr
)) return hr
;
920 static HRESULT
parse_fx10_variable(struct d3d10_effect_variable
*v
, const char **ptr
, const char *data
)
926 hr
= parse_fx10_variable_head(v
, ptr
, data
);
927 if (FAILED(hr
)) return hr
;
929 read_dword(ptr
, &offset
);
930 TRACE("Variable semantic at offset %#x.\n", offset
);
932 if (!copy_name(data
+ offset
, &v
->semantic
))
934 ERR("Failed to copy semantic.\n");
935 return E_OUTOFMEMORY
;
937 TRACE("Variable semantic: %s.\n", debugstr_a(v
->semantic
));
939 read_dword(ptr
, &v
->buffer_offset
);
940 TRACE("Variable offset in buffer: %#x.\n", v
->buffer_offset
);
942 skip_dword_unknown(ptr
, 1);
944 read_dword(ptr
, &v
->flag
);
945 TRACE("Variable flag: %#x.\n", v
->flag
);
947 read_dword(ptr
, &v
->annotation_count
);
948 TRACE("Variable has %u annotations.\n", v
->annotation_count
);
950 v
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, v
->annotation_count
* sizeof(*v
->annotations
));
953 ERR("Failed to allocate variable annotations memory.\n");
954 return E_OUTOFMEMORY
;
957 for (i
= 0; i
< v
->annotation_count
; ++i
)
959 struct d3d10_effect_variable
*a
= &v
->annotations
[i
];
961 a
->effect
= v
->effect
;
963 hr
= parse_fx10_annotation(a
, ptr
, data
);
964 if (FAILED(hr
)) return hr
;
970 static HRESULT
parse_fx10_local_variable(struct d3d10_effect_variable
*v
, const char **ptr
, const char *data
)
975 hr
= parse_fx10_variable_head(v
, ptr
, data
);
976 if (FAILED(hr
)) return hr
;
978 skip_dword_unknown(ptr
, 2);
980 switch (v
->type
->basetype
)
982 case D3D10_SVT_TEXTURE1D
:
983 case D3D10_SVT_TEXTURE1DARRAY
:
984 case D3D10_SVT_TEXTURE2D
:
985 case D3D10_SVT_TEXTURE2DARRAY
:
986 case D3D10_SVT_TEXTURE2DMS
:
987 case D3D10_SVT_TEXTURE2DMSARRAY
:
988 case D3D10_SVT_TEXTURE3D
:
989 case D3D10_SVT_TEXTURECUBE
:
990 case D3D10_SVT_RENDERTARGETVIEW
:
991 case D3D10_SVT_DEPTHSTENCILVIEW
:
992 TRACE("SVT could not have elements.\n");
995 case D3D10_SVT_VERTEXSHADER
:
996 case D3D10_SVT_PIXELSHADER
:
997 case D3D10_SVT_GEOMETRYSHADER
:
998 TRACE("SVT is a shader.\n");
999 for (i
= 0; i
< max(v
->type
->element_count
, 1); ++i
)
1001 DWORD shader_offset
;
1004 * TODO: Parse the shader
1006 read_dword(ptr
, &shader_offset
);
1007 FIXME("Shader offset: %#x.\n", shader_offset
);
1011 case D3D10_SVT_DEPTHSTENCIL
:
1012 case D3D10_SVT_BLEND
:
1013 case D3D10_SVT_RASTERIZER
:
1014 case D3D10_SVT_SAMPLER
:
1015 TRACE("SVT is a state.\n");
1016 for (i
= 0; i
< max(v
->type
->element_count
, 1); ++i
)
1021 read_dword(ptr
, &object_count
);
1022 TRACE("Object count: %#x.\n", object_count
);
1024 for (j
= 0; j
< object_count
; ++j
)
1026 skip_dword_unknown(ptr
, 4);
1032 FIXME("Unhandled case %s.\n", debug_d3d10_shader_variable_type(v
->type
->basetype
));
1036 read_dword(ptr
, &v
->annotation_count
);
1037 TRACE("Variable has %u annotations.\n", v
->annotation_count
);
1039 v
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, v
->annotation_count
* sizeof(*v
->annotations
));
1040 if (!v
->annotations
)
1042 ERR("Failed to allocate variable annotations memory.\n");
1043 return E_OUTOFMEMORY
;
1046 for (i
= 0; i
< v
->annotation_count
; ++i
)
1048 struct d3d10_effect_variable
*a
= &v
->annotations
[i
];
1050 a
->effect
= v
->effect
;
1052 hr
= parse_fx10_annotation(a
, ptr
, data
);
1053 if (FAILED(hr
)) return hr
;
1059 static HRESULT
parse_fx10_local_buffer(struct d3d10_effect_variable
*l
, const char **ptr
, const char *data
)
1063 D3D10_CBUFFER_TYPE d3d10_cbuffer_type
;
1066 /* Generate our own type, it isn't in the fx blob. */
1067 l
->type
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*l
->type
));
1070 ERR("Failed to allocate local buffer type memory.\n");
1071 return E_OUTOFMEMORY
;
1073 l
->type
->vtbl
= &d3d10_effect_type_vtbl
;
1074 l
->type
->type_class
= D3D10_SVC_OBJECT
;
1075 l
->type
->effect
= l
->effect
;
1077 read_dword(ptr
, &offset
);
1078 TRACE("Local buffer name at offset %#x.\n", offset
);
1080 if (!copy_name(data
+ offset
, &l
->name
))
1082 ERR("Failed to copy name.\n");
1083 return E_OUTOFMEMORY
;
1085 TRACE("Local buffer name: %s.\n", debugstr_a(l
->name
));
1087 read_dword(ptr
, &l
->data_size
);
1088 TRACE("Local buffer data size: %#x.\n", l
->data_size
);
1090 read_dword(ptr
, &d3d10_cbuffer_type
);
1091 TRACE("Local buffer type: %#x.\n", d3d10_cbuffer_type
);
1093 switch(d3d10_cbuffer_type
)
1095 case D3D10_CT_CBUFFER
:
1096 l
->type
->basetype
= D3D10_SVT_CBUFFER
;
1097 if (!copy_name("cbuffer", &l
->type
->name
))
1099 ERR("Failed to copy name.\n");
1100 return E_OUTOFMEMORY
;
1104 case D3D10_CT_TBUFFER
:
1105 l
->type
->basetype
= D3D10_SVT_TBUFFER
;
1106 if (!copy_name("tbuffer", &l
->type
->name
))
1108 ERR("Failed to copy name.\n");
1109 return E_OUTOFMEMORY
;
1114 ERR("Unexpected D3D10_CBUFFER_TYPE %#x!\n", d3d10_cbuffer_type
);
1118 read_dword(ptr
, &l
->type
->member_count
);
1119 TRACE("Local buffer member count: %#x.\n", l
->type
->member_count
);
1121 skip_dword_unknown(ptr
, 1);
1123 read_dword(ptr
, &l
->annotation_count
);
1124 TRACE("Local buffer has %u annotations.\n", l
->annotation_count
);
1126 l
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, l
->annotation_count
* sizeof(*l
->annotations
));
1127 if (!l
->annotations
)
1129 ERR("Failed to allocate local buffer annotations memory.\n");
1130 return E_OUTOFMEMORY
;
1133 for(i
= 0; i
< l
->annotation_count
; ++i
)
1135 struct d3d10_effect_variable
*a
= &l
->annotations
[i
];
1137 a
->effect
= l
->effect
;
1139 hr
= parse_fx10_annotation(a
, ptr
, data
);
1140 if (FAILED(hr
)) return hr
;
1143 l
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, l
->type
->member_count
* sizeof(*l
->members
));
1146 ERR("Failed to allocate members memory.\n");
1147 return E_OUTOFMEMORY
;
1150 l
->type
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, l
->type
->member_count
* sizeof(*l
->type
->members
));
1151 if (!l
->type
->members
)
1153 ERR("Failed to allocate type members memory.\n");
1154 return E_OUTOFMEMORY
;
1157 for (i
= 0; i
< l
->type
->member_count
; ++i
)
1159 struct d3d10_effect_variable
*v
= &l
->members
[i
];
1160 struct d3d10_effect_type_member
*typem
= &l
->type
->members
[i
];
1163 v
->effect
= l
->effect
;
1165 hr
= parse_fx10_variable(v
, ptr
, data
);
1166 if (FAILED(hr
)) return hr
;
1169 * Copy the values from the variable type to the constant buffers type
1170 * members structure, because it is our own generated type.
1172 typem
->type
= v
->type
;
1174 if (!copy_name(v
->name
, &typem
->name
))
1176 ERR("Failed to copy name.\n");
1177 return E_OUTOFMEMORY
;
1179 TRACE("Variable name: %s.\n", debugstr_a(typem
->name
));
1181 if (!copy_name(v
->semantic
, &typem
->semantic
))
1183 ERR("Failed to copy name.\n");
1184 return E_OUTOFMEMORY
;
1186 TRACE("Variable semantic: %s.\n", debugstr_a(typem
->semantic
));
1188 typem
->buffer_offset
= v
->buffer_offset
;
1189 TRACE("Variable buffer offset: %u.\n", typem
->buffer_offset
);
1191 l
->type
->size_packed
+= v
->type
->size_packed
;
1192 l
->type
->size_unpacked
+= v
->type
->size_unpacked
;
1194 l
->type
->stride
= l
->type
->size_unpacked
= (l
->type
->size_unpacked
+ 0xf) & ~0xf;
1196 TRACE("Constant buffer:\n");
1197 TRACE("\tType name: %s.\n", debugstr_a(l
->type
->name
));
1198 TRACE("\tElement count: %u.\n", l
->type
->element_count
);
1199 TRACE("\tMember count: %u.\n", l
->type
->member_count
);
1200 TRACE("\tUnpacked size: %#x.\n", l
->type
->size_unpacked
);
1201 TRACE("\tStride: %#x.\n", l
->type
->stride
);
1202 TRACE("\tPacked size %#x.\n", l
->type
->size_packed
);
1203 TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(l
->type
->basetype
));
1204 TRACE("\tTypeclass: %s.\n", debug_d3d10_shader_variable_class(l
->type
->type_class
));
1209 static int d3d10_effect_type_compare(const void *key
, const struct wine_rb_entry
*entry
)
1211 const struct d3d10_effect_type
*t
= WINE_RB_ENTRY_VALUE(entry
, const struct d3d10_effect_type
, entry
);
1212 const DWORD
*id
= key
;
1217 static void d3d10_effect_type_member_destroy(struct d3d10_effect_type_member
*typem
)
1219 TRACE("effect type member %p.\n", typem
);
1221 /* Do not release typem->type, it will be covered by d3d10_effect_type_destroy(). */
1222 HeapFree(GetProcessHeap(), 0, typem
->semantic
);
1223 HeapFree(GetProcessHeap(), 0, typem
->name
);
1226 static void d3d10_effect_type_destroy(struct wine_rb_entry
*entry
, void *context
)
1228 struct d3d10_effect_type
*t
= WINE_RB_ENTRY_VALUE(entry
, struct d3d10_effect_type
, entry
);
1230 TRACE("effect type %p.\n", t
);
1234 HeapFree(GetProcessHeap(), 0, t
->elementtype
->name
);
1235 HeapFree(GetProcessHeap(), 0, t
->elementtype
);
1242 for (i
= 0; i
< t
->member_count
; ++i
)
1244 d3d10_effect_type_member_destroy(&t
->members
[i
]);
1246 HeapFree(GetProcessHeap(), 0, t
->members
);
1249 HeapFree(GetProcessHeap(), 0, t
->name
);
1250 HeapFree(GetProcessHeap(), 0, t
);
1253 static const struct wine_rb_functions d3d10_effect_type_rb_functions
=
1258 d3d10_effect_type_compare
,
1261 static HRESULT
parse_fx10_body(struct d3d10_effect
*e
, const char *data
, DWORD data_size
)
1263 const char *ptr
= data
+ e
->index_offset
;
1267 if (wine_rb_init(&e
->types
, &d3d10_effect_type_rb_functions
) == -1)
1269 ERR("Failed to initialize type rbtree.\n");
1273 e
->local_buffers
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, e
->local_buffer_count
* sizeof(*e
->local_buffers
));
1274 if (!e
->local_buffers
)
1276 ERR("Failed to allocate local buffer memory.\n");
1277 return E_OUTOFMEMORY
;
1280 e
->local_variables
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, e
->local_variable_count
* sizeof(*e
->local_variables
));
1281 if (!e
->local_variables
)
1283 ERR("Failed to allocate local variable memory.\n");
1284 return E_OUTOFMEMORY
;
1287 e
->techniques
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, e
->technique_count
* sizeof(*e
->techniques
));
1290 ERR("Failed to allocate techniques memory\n");
1291 return E_OUTOFMEMORY
;
1294 for (i
= 0; i
< e
->local_buffer_count
; ++i
)
1296 struct d3d10_effect_variable
*l
= &e
->local_buffers
[i
];
1297 l
->vtbl
= (ID3D10EffectVariableVtbl
*)&d3d10_effect_constant_buffer_vtbl
;
1299 l
->buffer
= &null_local_buffer
;
1301 hr
= parse_fx10_local_buffer(l
, &ptr
, data
);
1302 if (FAILED(hr
)) return hr
;
1305 for (i
= 0; i
< e
->local_variable_count
; ++i
)
1307 struct d3d10_effect_variable
*v
= &e
->local_variables
[i
];
1310 v
->vtbl
= &d3d10_effect_variable_vtbl
;
1312 hr
= parse_fx10_local_variable(v
, &ptr
, data
);
1313 if (FAILED(hr
)) return hr
;
1316 for (i
= 0; i
< e
->technique_count
; ++i
)
1318 struct d3d10_effect_technique
*t
= &e
->techniques
[i
];
1320 t
->vtbl
= &d3d10_effect_technique_vtbl
;
1323 hr
= parse_fx10_technique(t
, &ptr
, data
);
1324 if (FAILED(hr
)) return hr
;
1330 static HRESULT
parse_fx10(struct d3d10_effect
*e
, const char *data
, DWORD data_size
)
1332 const char *ptr
= data
;
1335 /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
1336 read_dword(&ptr
, &e
->version
);
1337 TRACE("Target: %#x\n", e
->version
);
1339 read_dword(&ptr
, &e
->local_buffer_count
);
1340 TRACE("Local buffer count: %u.\n", e
->local_buffer_count
);
1342 read_dword(&ptr
, &e
->variable_count
);
1343 TRACE("Variable count: %u\n", e
->variable_count
);
1345 read_dword(&ptr
, &e
->local_variable_count
);
1346 TRACE("Object count: %u\n", e
->local_variable_count
);
1348 read_dword(&ptr
, &e
->sharedbuffers_count
);
1349 TRACE("Sharedbuffers count: %u\n", e
->sharedbuffers_count
);
1351 /* Number of variables in shared buffers? */
1352 read_dword(&ptr
, &unknown
);
1353 FIXME("Unknown 0: %u\n", unknown
);
1355 read_dword(&ptr
, &e
->sharedobjects_count
);
1356 TRACE("Sharedobjects count: %u\n", e
->sharedobjects_count
);
1358 read_dword(&ptr
, &e
->technique_count
);
1359 TRACE("Technique count: %u\n", e
->technique_count
);
1361 read_dword(&ptr
, &e
->index_offset
);
1362 TRACE("Index offset: %#x\n", e
->index_offset
);
1364 read_dword(&ptr
, &unknown
);
1365 FIXME("Unknown 1: %u\n", unknown
);
1367 read_dword(&ptr
, &e
->texture_count
);
1368 TRACE("Texture count: %u\n", e
->texture_count
);
1370 read_dword(&ptr
, &e
->dephstencilstate_count
);
1371 TRACE("Depthstencilstate count: %u\n", e
->dephstencilstate_count
);
1373 read_dword(&ptr
, &e
->blendstate_count
);
1374 TRACE("Blendstate count: %u\n", e
->blendstate_count
);
1376 read_dword(&ptr
, &e
->rasterizerstate_count
);
1377 TRACE("Rasterizerstate count: %u\n", e
->rasterizerstate_count
);
1379 read_dword(&ptr
, &e
->samplerstate_count
);
1380 TRACE("Samplerstate count: %u\n", e
->samplerstate_count
);
1382 read_dword(&ptr
, &e
->rendertargetview_count
);
1383 TRACE("Rendertargetview count: %u\n", e
->rendertargetview_count
);
1385 read_dword(&ptr
, &e
->depthstencilview_count
);
1386 TRACE("Depthstencilview count: %u\n", e
->depthstencilview_count
);
1388 read_dword(&ptr
, &e
->shader_call_count
);
1389 TRACE("Shader call count: %u\n", e
->shader_call_count
);
1391 read_dword(&ptr
, &e
->shader_compile_count
);
1392 TRACE("Shader compile count: %u\n", e
->shader_compile_count
);
1394 return parse_fx10_body(e
, ptr
, data_size
- (ptr
- data
));
1397 static HRESULT
fx10_chunk_handler(const char *data
, DWORD data_size
, DWORD tag
, void *ctx
)
1399 struct d3d10_effect
*e
= ctx
;
1401 TRACE("tag: %s.\n", debugstr_an((const char *)&tag
, 4));
1403 TRACE("chunk size: %#x\n", data_size
);
1408 return parse_fx10(e
, data
, data_size
);
1411 FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag
, 4));
1416 HRESULT
d3d10_effect_parse(struct d3d10_effect
*This
, const void *data
, SIZE_T data_size
)
1418 return parse_dxbc(data
, data_size
, fx10_chunk_handler
, This
);
1421 static void d3d10_effect_object_destroy(struct d3d10_effect_object
*o
)
1423 TRACE("effect object %p.\n", o
);
1427 case D3D10_EOT_VERTEXSHADER
:
1428 case D3D10_EOT_PIXELSHADER
:
1429 case D3D10_EOT_GEOMETRYSHADER
:
1430 HeapFree(GetProcessHeap(), 0, ((struct d3d10_effect_shader_variable
*)o
->data
)->input_signature
);
1436 HeapFree(GetProcessHeap(), 0, o
->data
);
1439 static HRESULT
d3d10_effect_object_apply(struct d3d10_effect_object
*o
)
1441 ID3D10Device
*device
= o
->pass
->technique
->effect
->device
;
1443 TRACE("effect object %p, type %#x.\n", o
, o
->type
);
1447 case D3D10_EOT_VERTEXSHADER
:
1448 ID3D10Device_VSSetShader(device
, ((struct d3d10_effect_shader_variable
*)o
->data
)->shader
.vs
);
1451 case D3D10_EOT_PIXELSHADER
:
1452 ID3D10Device_PSSetShader(device
, ((struct d3d10_effect_shader_variable
*)o
->data
)->shader
.ps
);
1455 case D3D10_EOT_GEOMETRYSHADER
:
1456 ID3D10Device_GSSetShader(device
, ((struct d3d10_effect_shader_variable
*)o
->data
)->shader
.gs
);
1460 FIXME("Unhandled effect object type %#x.\n", o
->type
);
1465 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable
*v
)
1469 TRACE("variable %p.\n", v
);
1471 HeapFree(GetProcessHeap(), 0, v
->name
);
1472 HeapFree(GetProcessHeap(), 0, v
->semantic
);
1475 for (i
= 0; i
< v
->annotation_count
; ++i
)
1477 d3d10_effect_variable_destroy(&v
->annotations
[i
]);
1479 HeapFree(GetProcessHeap(), 0, v
->annotations
);
1484 for (i
= 0; i
< v
->type
->member_count
; ++i
)
1486 d3d10_effect_variable_destroy(&v
->members
[i
]);
1488 HeapFree(GetProcessHeap(), 0, v
->members
);
1493 for (i
= 0; i
< v
->type
->element_count
; ++i
)
1495 d3d10_effect_variable_destroy(&v
->elements
[i
]);
1497 HeapFree(GetProcessHeap(), 0, v
->elements
);
1501 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass
*p
)
1505 TRACE("pass %p\n", p
);
1507 HeapFree(GetProcessHeap(), 0, p
->name
);
1510 for (i
= 0; i
< p
->object_count
; ++i
)
1512 d3d10_effect_object_destroy(&p
->objects
[i
]);
1514 HeapFree(GetProcessHeap(), 0, p
->objects
);
1519 for (i
= 0; i
< p
->annotation_count
; ++i
)
1521 d3d10_effect_variable_destroy(&p
->annotations
[i
]);
1523 HeapFree(GetProcessHeap(), 0, p
->annotations
);
1528 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique
*t
)
1532 TRACE("technique %p\n", t
);
1534 HeapFree(GetProcessHeap(), 0, t
->name
);
1537 for (i
= 0; i
< t
->pass_count
; ++i
)
1539 d3d10_effect_pass_destroy(&t
->passes
[i
]);
1541 HeapFree(GetProcessHeap(), 0, t
->passes
);
1546 for (i
= 0; i
< t
->annotation_count
; ++i
)
1548 d3d10_effect_variable_destroy(&t
->annotations
[i
]);
1550 HeapFree(GetProcessHeap(), 0, t
->annotations
);
1554 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_variable
*l
)
1558 TRACE("local buffer %p.\n", l
);
1560 HeapFree(GetProcessHeap(), 0, l
->name
);
1563 for (i
= 0; i
< l
->type
->member_count
; ++i
)
1565 d3d10_effect_variable_destroy(&l
->members
[i
]);
1567 HeapFree(GetProcessHeap(), 0, l
->members
);
1570 if (l
->type
->members
)
1572 for (i
= 0; i
< l
->type
->member_count
; ++i
)
1574 /* Do not release l->type->members[i].type, it will be covered by d3d10_effect_type_destroy(). */
1575 HeapFree(GetProcessHeap(), 0, l
->type
->members
[i
].semantic
);
1576 HeapFree(GetProcessHeap(), 0, l
->type
->members
[i
].name
);
1578 HeapFree(GetProcessHeap(), 0, l
->type
->members
);
1580 HeapFree(GetProcessHeap(), 0, l
->type
->name
);
1581 HeapFree(GetProcessHeap(), 0, l
->type
);
1585 for (i
= 0; i
< l
->annotation_count
; ++i
)
1587 d3d10_effect_variable_destroy(&l
->annotations
[i
]);
1589 HeapFree(GetProcessHeap(), 0, l
->annotations
);
1593 /* IUnknown methods */
1595 static HRESULT STDMETHODCALLTYPE
d3d10_effect_QueryInterface(ID3D10Effect
*iface
, REFIID riid
, void **object
)
1597 TRACE("iface %p, riid %s, object %p\n", iface
, debugstr_guid(riid
), object
);
1599 if (IsEqualGUID(riid
, &IID_ID3D10Effect
)
1600 || IsEqualGUID(riid
, &IID_IUnknown
))
1602 IUnknown_AddRef(iface
);
1607 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
1610 return E_NOINTERFACE
;
1613 static ULONG STDMETHODCALLTYPE
d3d10_effect_AddRef(ID3D10Effect
*iface
)
1615 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1616 ULONG refcount
= InterlockedIncrement(&This
->refcount
);
1618 TRACE("%p increasing refcount to %u\n", This
, refcount
);
1623 static ULONG STDMETHODCALLTYPE
d3d10_effect_Release(ID3D10Effect
*iface
)
1625 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1626 ULONG refcount
= InterlockedDecrement(&This
->refcount
);
1628 TRACE("%p decreasing refcount to %u\n", This
, refcount
);
1634 if (This
->techniques
)
1636 for (i
= 0; i
< This
->technique_count
; ++i
)
1638 d3d10_effect_technique_destroy(&This
->techniques
[i
]);
1640 HeapFree(GetProcessHeap(), 0, This
->techniques
);
1643 if (This
->local_variables
)
1645 for (i
= 0; i
< This
->local_variable_count
; ++i
)
1647 d3d10_effect_variable_destroy(&This
->local_variables
[i
]);
1649 HeapFree(GetProcessHeap(), 0, &This
->local_variables
);
1652 if (This
->local_buffers
)
1654 for (i
= 0; i
< This
->local_buffer_count
; ++i
)
1656 d3d10_effect_local_buffer_destroy(&This
->local_buffers
[i
]);
1658 HeapFree(GetProcessHeap(), 0, This
->local_buffers
);
1661 wine_rb_destroy(&This
->types
, d3d10_effect_type_destroy
, NULL
);
1663 ID3D10Device_Release(This
->device
);
1664 HeapFree(GetProcessHeap(), 0, This
);
1670 /* ID3D10Effect methods */
1672 static BOOL STDMETHODCALLTYPE
d3d10_effect_IsValid(ID3D10Effect
*iface
)
1674 FIXME("iface %p stub!\n", iface
);
1679 static BOOL STDMETHODCALLTYPE
d3d10_effect_IsPool(ID3D10Effect
*iface
)
1681 FIXME("iface %p stub!\n", iface
);
1686 static HRESULT STDMETHODCALLTYPE
d3d10_effect_GetDevice(ID3D10Effect
*iface
, ID3D10Device
**device
)
1688 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1690 TRACE("iface %p, device %p\n", iface
, device
);
1692 ID3D10Device_AddRef(This
->device
);
1693 *device
= This
->device
;
1698 static HRESULT STDMETHODCALLTYPE
d3d10_effect_GetDesc(ID3D10Effect
*iface
, D3D10_EFFECT_DESC
*desc
)
1700 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
1705 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_GetConstantBufferByIndex(ID3D10Effect
*iface
,
1708 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1709 struct d3d10_effect_variable
*l
;
1711 TRACE("iface %p, index %u\n", iface
, index
);
1713 if (index
>= This
->local_buffer_count
)
1715 WARN("Invalid index specified\n");
1716 return (ID3D10EffectConstantBuffer
*)&null_local_buffer
;
1719 l
= &This
->local_buffers
[index
];
1721 TRACE("Returning buffer %p, %s.\n", l
, debugstr_a(l
->name
));
1723 return (ID3D10EffectConstantBuffer
*)l
;
1726 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_GetConstantBufferByName(ID3D10Effect
*iface
,
1729 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1732 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1734 for (i
= 0; i
< This
->local_buffer_count
; ++i
)
1736 struct d3d10_effect_variable
*l
= &This
->local_buffers
[i
];
1738 if (!strcmp(l
->name
, name
))
1740 TRACE("Returning buffer %p.\n", l
);
1741 return (ID3D10EffectConstantBuffer
*)l
;
1745 WARN("Invalid name specified\n");
1747 return (ID3D10EffectConstantBuffer
*)&null_local_buffer
;
1750 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_GetVariableByIndex(ID3D10Effect
*iface
, UINT index
)
1752 FIXME("iface %p, index %u stub!\n", iface
, index
);
1757 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_GetVariableByName(ID3D10Effect
*iface
, LPCSTR name
)
1759 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1762 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1764 for (i
= 0; i
< This
->local_buffer_count
; ++i
)
1766 struct d3d10_effect_variable
*l
= &This
->local_buffers
[i
];
1769 for (j
= 0; j
< l
->type
->member_count
; ++j
)
1771 struct d3d10_effect_variable
*v
= &l
->members
[j
];
1773 if (!strcmp(v
->name
, name
))
1775 TRACE("Returning variable %p.\n", v
);
1776 return (ID3D10EffectVariable
*)v
;
1781 WARN("Invalid name specified\n");
1783 return (ID3D10EffectVariable
*)&null_variable
;
1786 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_GetVariableBySemantic(ID3D10Effect
*iface
,
1789 FIXME("iface %p, semantic %s stub!\n", iface
, debugstr_a(semantic
));
1794 static struct ID3D10EffectTechnique
* STDMETHODCALLTYPE
d3d10_effect_GetTechniqueByIndex(ID3D10Effect
*iface
,
1797 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1798 struct d3d10_effect_technique
*t
;
1800 TRACE("iface %p, index %u\n", iface
, index
);
1802 if (index
>= This
->technique_count
)
1804 WARN("Invalid index specified\n");
1805 return (ID3D10EffectTechnique
*)&null_technique
;
1808 t
= &This
->techniques
[index
];
1810 TRACE("Returning technique %p, %s.\n", t
, debugstr_a(t
->name
));
1812 return (ID3D10EffectTechnique
*)t
;
1815 static struct ID3D10EffectTechnique
* STDMETHODCALLTYPE
d3d10_effect_GetTechniqueByName(ID3D10Effect
*iface
,
1818 struct d3d10_effect
*This
= (struct d3d10_effect
*)iface
;
1821 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1823 for (i
= 0; i
< This
->technique_count
; ++i
)
1825 struct d3d10_effect_technique
*t
= &This
->techniques
[i
];
1826 if (!strcmp(t
->name
, name
))
1828 TRACE("Returning technique %p\n", t
);
1829 return (ID3D10EffectTechnique
*)t
;
1833 WARN("Invalid name specified\n");
1835 return (ID3D10EffectTechnique
*)&null_technique
;
1838 static HRESULT STDMETHODCALLTYPE
d3d10_effect_Optimize(ID3D10Effect
*iface
)
1840 FIXME("iface %p stub!\n", iface
);
1845 static BOOL STDMETHODCALLTYPE
d3d10_effect_IsOptimized(ID3D10Effect
*iface
)
1847 FIXME("iface %p stub!\n", iface
);
1852 const struct ID3D10EffectVtbl d3d10_effect_vtbl
=
1854 /* IUnknown methods */
1855 d3d10_effect_QueryInterface
,
1856 d3d10_effect_AddRef
,
1857 d3d10_effect_Release
,
1858 /* ID3D10Effect methods */
1859 d3d10_effect_IsValid
,
1860 d3d10_effect_IsPool
,
1861 d3d10_effect_GetDevice
,
1862 d3d10_effect_GetDesc
,
1863 d3d10_effect_GetConstantBufferByIndex
,
1864 d3d10_effect_GetConstantBufferByName
,
1865 d3d10_effect_GetVariableByIndex
,
1866 d3d10_effect_GetVariableByName
,
1867 d3d10_effect_GetVariableBySemantic
,
1868 d3d10_effect_GetTechniqueByIndex
,
1869 d3d10_effect_GetTechniqueByName
,
1870 d3d10_effect_Optimize
,
1871 d3d10_effect_IsOptimized
,
1874 /* ID3D10EffectTechnique methods */
1876 static BOOL STDMETHODCALLTYPE
d3d10_effect_technique_IsValid(ID3D10EffectTechnique
*iface
)
1878 TRACE("iface %p\n", iface
);
1880 return (struct d3d10_effect_technique
*)iface
!= &null_technique
;
1883 static HRESULT STDMETHODCALLTYPE
d3d10_effect_technique_GetDesc(ID3D10EffectTechnique
*iface
,
1884 D3D10_TECHNIQUE_DESC
*desc
)
1886 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1888 TRACE("iface %p, desc %p\n", iface
, desc
);
1890 if(This
== &null_technique
)
1892 WARN("Null technique specified\n");
1898 WARN("Invalid argument specified\n");
1899 return E_INVALIDARG
;
1902 desc
->Name
= This
->name
;
1903 desc
->Passes
= This
->pass_count
;
1904 desc
->Annotations
= This
->annotation_count
;
1909 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_technique_GetAnnotationByIndex(
1910 ID3D10EffectTechnique
*iface
, UINT index
)
1912 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1913 struct d3d10_effect_variable
*a
;
1915 TRACE("iface %p, index %u\n", iface
, index
);
1917 if (index
>= This
->annotation_count
)
1919 WARN("Invalid index specified\n");
1920 return (ID3D10EffectVariable
*)&null_variable
;
1923 a
= &This
->annotations
[index
];
1925 TRACE("Returning annotation %p, %s\n", a
, debugstr_a(a
->name
));
1927 return (ID3D10EffectVariable
*)a
;
1930 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_technique_GetAnnotationByName(
1931 ID3D10EffectTechnique
*iface
, LPCSTR name
)
1933 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1936 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1938 for (i
= 0; i
< This
->annotation_count
; ++i
)
1940 struct d3d10_effect_variable
*a
= &This
->annotations
[i
];
1941 if (!strcmp(a
->name
, name
))
1943 TRACE("Returning annotation %p\n", a
);
1944 return (ID3D10EffectVariable
*)a
;
1948 WARN("Invalid name specified\n");
1950 return (ID3D10EffectVariable
*)&null_variable
;
1953 static struct ID3D10EffectPass
* STDMETHODCALLTYPE
d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique
*iface
,
1956 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1957 struct d3d10_effect_pass
*p
;
1959 TRACE("iface %p, index %u\n", iface
, index
);
1961 if (index
>= This
->pass_count
)
1963 WARN("Invalid index specified\n");
1964 return (ID3D10EffectPass
*)&null_pass
;
1967 p
= &This
->passes
[index
];
1969 TRACE("Returning pass %p, %s.\n", p
, debugstr_a(p
->name
));
1971 return (ID3D10EffectPass
*)p
;
1974 static struct ID3D10EffectPass
* STDMETHODCALLTYPE
d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique
*iface
,
1977 struct d3d10_effect_technique
*This
= (struct d3d10_effect_technique
*)iface
;
1980 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
1982 for (i
= 0; i
< This
->pass_count
; ++i
)
1984 struct d3d10_effect_pass
*p
= &This
->passes
[i
];
1985 if (!strcmp(p
->name
, name
))
1987 TRACE("Returning pass %p\n", p
);
1988 return (ID3D10EffectPass
*)p
;
1992 WARN("Invalid name specified\n");
1994 return (ID3D10EffectPass
*)&null_pass
;
1997 static HRESULT STDMETHODCALLTYPE
d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique
*iface
,
1998 D3D10_STATE_BLOCK_MASK
*mask
)
2000 FIXME("iface %p,mask %p stub!\n", iface
, mask
);
2005 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl
=
2007 /* ID3D10EffectTechnique methods */
2008 d3d10_effect_technique_IsValid
,
2009 d3d10_effect_technique_GetDesc
,
2010 d3d10_effect_technique_GetAnnotationByIndex
,
2011 d3d10_effect_technique_GetAnnotationByName
,
2012 d3d10_effect_technique_GetPassByIndex
,
2013 d3d10_effect_technique_GetPassByName
,
2014 d3d10_effect_technique_ComputeStateBlockMask
,
2017 /* ID3D10EffectPass methods */
2019 static BOOL STDMETHODCALLTYPE
d3d10_effect_pass_IsValid(ID3D10EffectPass
*iface
)
2021 TRACE("iface %p\n", iface
);
2023 return (struct d3d10_effect_pass
*)iface
!= &null_pass
;
2026 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetDesc(ID3D10EffectPass
*iface
, D3D10_PASS_DESC
*desc
)
2028 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
2031 FIXME("iface %p, desc %p partial stub!\n", iface
, desc
);
2033 if(This
== &null_pass
)
2035 WARN("Null pass specified\n");
2041 WARN("Invalid argument specified\n");
2042 return E_INVALIDARG
;
2045 memset(desc
, 0, sizeof(*desc
));
2046 desc
->Name
= This
->name
;
2047 for (i
= 0; i
< This
->object_count
; ++i
)
2049 struct d3d10_effect_object
*o
= &This
->objects
[i
];
2050 if (o
->type
== D3D10_EOT_VERTEXSHADER
)
2052 struct d3d10_effect_shader_variable
*s
= o
->data
;
2053 desc
->pIAInputSignature
= (BYTE
*)s
->input_signature
;
2054 desc
->IAInputSignatureSize
= s
->input_signature_size
;
2062 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass
*iface
,
2063 D3D10_PASS_SHADER_DESC
*desc
)
2065 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
2070 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass
*iface
,
2071 D3D10_PASS_SHADER_DESC
*desc
)
2073 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
2078 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass
*iface
,
2079 D3D10_PASS_SHADER_DESC
*desc
)
2081 FIXME("iface %p, desc %p stub!\n", iface
, desc
);
2086 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass
*iface
,
2089 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
2090 struct d3d10_effect_variable
*a
;
2092 TRACE("iface %p, index %u\n", iface
, index
);
2094 if (index
>= This
->annotation_count
)
2096 WARN("Invalid index specified\n");
2097 return (ID3D10EffectVariable
*)&null_variable
;
2100 a
= &This
->annotations
[index
];
2102 TRACE("Returning annotation %p, %s\n", a
, debugstr_a(a
->name
));
2104 return (ID3D10EffectVariable
*)a
;
2107 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass
*iface
,
2110 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
2113 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
2115 for (i
= 0; i
< This
->annotation_count
; ++i
)
2117 struct d3d10_effect_variable
*a
= &This
->annotations
[i
];
2118 if (!strcmp(a
->name
, name
))
2120 TRACE("Returning annotation %p\n", a
);
2121 return (ID3D10EffectVariable
*)a
;
2125 WARN("Invalid name specified\n");
2127 return (ID3D10EffectVariable
*)&null_variable
;
2130 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_Apply(ID3D10EffectPass
*iface
, UINT flags
)
2132 struct d3d10_effect_pass
*This
= (struct d3d10_effect_pass
*)iface
;
2136 TRACE("iface %p, flags %#x\n", iface
, flags
);
2138 if (flags
) FIXME("Ignoring flags (%#x)\n", flags
);
2140 for (i
= 0; i
< This
->object_count
; ++i
)
2142 hr
= d3d10_effect_object_apply(&This
->objects
[i
]);
2143 if (FAILED(hr
)) break;
2149 static HRESULT STDMETHODCALLTYPE
d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass
*iface
,
2150 D3D10_STATE_BLOCK_MASK
*mask
)
2152 FIXME("iface %p, mask %p stub!\n", iface
, mask
);
2157 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl
=
2159 /* ID3D10EffectPass methods */
2160 d3d10_effect_pass_IsValid
,
2161 d3d10_effect_pass_GetDesc
,
2162 d3d10_effect_pass_GetVertexShaderDesc
,
2163 d3d10_effect_pass_GetGeometryShaderDesc
,
2164 d3d10_effect_pass_GetPixelShaderDesc
,
2165 d3d10_effect_pass_GetAnnotationByIndex
,
2166 d3d10_effect_pass_GetAnnotationByName
,
2167 d3d10_effect_pass_Apply
,
2168 d3d10_effect_pass_ComputeStateBlockMask
,
2171 /* ID3D10EffectVariable methods */
2173 static BOOL STDMETHODCALLTYPE
d3d10_effect_variable_IsValid(ID3D10EffectVariable
*iface
)
2175 TRACE("iface %p\n", iface
);
2177 return (struct d3d10_effect_variable
*)iface
!= &null_variable
;
2180 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_variable_GetType(ID3D10EffectVariable
*iface
)
2182 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2184 TRACE("iface %p\n", iface
);
2186 return (ID3D10EffectType
*)This
->type
;
2189 static HRESULT STDMETHODCALLTYPE
d3d10_effect_variable_GetDesc(ID3D10EffectVariable
*iface
,
2190 D3D10_EFFECT_VARIABLE_DESC
*desc
)
2192 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2194 TRACE("iface %p, desc %p\n", iface
, desc
);
2196 if(This
== &null_variable
)
2198 WARN("Null variable specified\n");
2204 WARN("Invalid argument specified\n");
2205 return E_INVALIDARG
;
2208 memset(desc
, 0, sizeof(*desc
));
2209 desc
->Name
= This
->name
;
2210 desc
->Semantic
= This
->semantic
;
2211 desc
->Flags
= This
->flag
;
2212 desc
->Annotations
= This
->annotation_count
;
2213 desc
->BufferOffset
= This
->buffer_offset
;
2215 if( This
->flag
== D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT
)
2217 desc
->ExplicitBindPoint
= This
->buffer_offset
;
2221 FIXME("Unhandled flag %#x!\n", This
->flag
);
2227 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetAnnotationByIndex(
2228 ID3D10EffectVariable
*iface
, UINT index
)
2230 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2231 struct d3d10_effect_variable
*a
;
2233 TRACE("iface %p, index %u\n", iface
, index
);
2235 if (index
>= This
->annotation_count
)
2237 WARN("Invalid index specified\n");
2238 return (ID3D10EffectVariable
*)&null_variable
;
2241 a
= &This
->annotations
[index
];
2243 TRACE("Returning annotation %p, %s\n", a
, debugstr_a(a
->name
));
2245 return (ID3D10EffectVariable
*)a
;
2248 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetAnnotationByName(
2249 ID3D10EffectVariable
*iface
, LPCSTR name
)
2251 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2254 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
2256 for (i
= 0; i
< This
->annotation_count
; ++i
)
2258 struct d3d10_effect_variable
*a
= &This
->annotations
[i
];
2259 if (!strcmp(a
->name
, name
))
2261 TRACE("Returning annotation %p\n", a
);
2262 return (ID3D10EffectVariable
*)a
;
2266 WARN("Invalid name specified\n");
2268 return (ID3D10EffectVariable
*)&null_variable
;
2271 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetMemberByIndex(
2272 ID3D10EffectVariable
*iface
, UINT index
)
2274 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2275 struct d3d10_effect_variable
*m
;
2277 TRACE("iface %p, index %u\n", iface
, index
);
2279 if (index
>= This
->type
->member_count
)
2281 WARN("Invalid index specified\n");
2282 return (ID3D10EffectVariable
*)&null_variable
;
2285 m
= &This
->members
[index
];
2287 TRACE("Returning member %p, %s\n", m
, debugstr_a(m
->name
));
2289 return (ID3D10EffectVariable
*)m
;
2292 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetMemberByName(
2293 ID3D10EffectVariable
*iface
, LPCSTR name
)
2295 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2298 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
2302 WARN("Invalid name specified\n");
2303 return (ID3D10EffectVariable
*)&null_variable
;
2306 for (i
= 0; i
< This
->type
->member_count
; ++i
)
2308 struct d3d10_effect_variable
*m
= &This
->members
[i
];
2312 if (!strcmp(m
->name
, name
))
2314 TRACE("Returning member %p\n", m
);
2315 return (ID3D10EffectVariable
*)m
;
2320 WARN("Invalid name specified\n");
2322 return (ID3D10EffectVariable
*)&null_variable
;
2325 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetMemberBySemantic(
2326 ID3D10EffectVariable
*iface
, LPCSTR semantic
)
2328 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2331 TRACE("iface %p, semantic %s.\n", iface
, debugstr_a(semantic
));
2335 WARN("Invalid semantic specified\n");
2336 return (ID3D10EffectVariable
*)&null_variable
;
2339 for (i
= 0; i
< This
->type
->member_count
; ++i
)
2341 struct d3d10_effect_variable
*m
= &This
->members
[i
];
2345 if (!strcmp(m
->semantic
, semantic
))
2347 TRACE("Returning member %p\n", m
);
2348 return (ID3D10EffectVariable
*)m
;
2353 WARN("Invalid semantic specified\n");
2355 return (ID3D10EffectVariable
*)&null_variable
;
2358 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_GetElement(
2359 ID3D10EffectVariable
*iface
, UINT index
)
2361 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2362 struct d3d10_effect_variable
*v
;
2364 TRACE("iface %p, index %u\n", iface
, index
);
2366 if (index
>= This
->type
->element_count
)
2368 WARN("Invalid index specified\n");
2369 return (ID3D10EffectVariable
*)&null_variable
;
2372 v
= &This
->elements
[index
];
2374 TRACE("Returning element %p, %s\n", v
, debugstr_a(v
->name
));
2376 return (ID3D10EffectVariable
*)v
;
2379 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_variable_GetParentConstantBuffer(
2380 ID3D10EffectVariable
*iface
)
2382 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2384 TRACE("iface %p\n", iface
);
2386 return (ID3D10EffectConstantBuffer
*)This
->buffer
;
2389 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsScalar(
2390 ID3D10EffectVariable
*iface
)
2392 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2394 TRACE("iface %p\n", iface
);
2396 if (This
->vtbl
== (ID3D10EffectVariableVtbl
*)&d3d10_effect_scalar_variable_vtbl
)
2397 return (ID3D10EffectScalarVariable
*)This
;
2399 return (ID3D10EffectScalarVariable
*)&null_scalar_variable
;
2402 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsVector(
2403 ID3D10EffectVariable
*iface
)
2405 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2407 TRACE("iface %p\n", iface
);
2409 if (This
->vtbl
== (ID3D10EffectVariableVtbl
*)&d3d10_effect_vector_variable_vtbl
)
2410 return (ID3D10EffectVectorVariable
*)This
;
2412 return (ID3D10EffectVectorVariable
*)&null_vector_variable
;
2415 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsMatrix(
2416 ID3D10EffectVariable
*iface
)
2418 struct d3d10_effect_variable
*This
= (struct d3d10_effect_variable
*)iface
;
2420 TRACE("iface %p\n", iface
);
2422 if (This
->vtbl
== (ID3D10EffectVariableVtbl
*)&d3d10_effect_matrix_variable_vtbl
)
2423 return (ID3D10EffectMatrixVariable
*)This
;
2425 return (ID3D10EffectMatrixVariable
*)&null_matrix_variable
;
2428 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsString(
2429 ID3D10EffectVariable
*iface
)
2431 FIXME("iface %p stub!\n", iface
);
2436 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsShaderResource(
2437 ID3D10EffectVariable
*iface
)
2439 FIXME("iface %p stub!\n", iface
);
2444 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsRenderTargetView(
2445 ID3D10EffectVariable
*iface
)
2447 FIXME("iface %p stub!\n", iface
);
2452 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsDepthStencilView(
2453 ID3D10EffectVariable
*iface
)
2455 FIXME("iface %p stub!\n", iface
);
2460 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_variable_AsConstantBuffer(
2461 ID3D10EffectVariable
*iface
)
2463 FIXME("iface %p stub!\n", iface
);
2468 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsShader(
2469 ID3D10EffectVariable
*iface
)
2471 FIXME("iface %p stub!\n", iface
);
2476 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsBlend(ID3D10EffectVariable
*iface
)
2478 FIXME("iface %p stub!\n", iface
);
2483 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsDepthStencil(
2484 ID3D10EffectVariable
*iface
)
2486 FIXME("iface %p stub!\n", iface
);
2491 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsRasterizer(
2492 ID3D10EffectVariable
*iface
)
2494 FIXME("iface %p stub!\n", iface
);
2499 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_variable_AsSampler(
2500 ID3D10EffectVariable
*iface
)
2502 FIXME("iface %p stub!\n", iface
);
2507 static HRESULT STDMETHODCALLTYPE
d3d10_effect_variable_SetRawValue(ID3D10EffectVariable
*iface
,
2508 void *data
, UINT offset
, UINT count
)
2510 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
2515 static HRESULT STDMETHODCALLTYPE
d3d10_effect_variable_GetRawValue(ID3D10EffectVariable
*iface
,
2516 void *data
, UINT offset
, UINT count
)
2518 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
2523 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl
=
2525 /* ID3D10EffectVariable methods */
2526 d3d10_effect_variable_IsValid
,
2527 d3d10_effect_variable_GetType
,
2528 d3d10_effect_variable_GetDesc
,
2529 d3d10_effect_variable_GetAnnotationByIndex
,
2530 d3d10_effect_variable_GetAnnotationByName
,
2531 d3d10_effect_variable_GetMemberByIndex
,
2532 d3d10_effect_variable_GetMemberByName
,
2533 d3d10_effect_variable_GetMemberBySemantic
,
2534 d3d10_effect_variable_GetElement
,
2535 d3d10_effect_variable_GetParentConstantBuffer
,
2536 d3d10_effect_variable_AsScalar
,
2537 d3d10_effect_variable_AsVector
,
2538 d3d10_effect_variable_AsMatrix
,
2539 d3d10_effect_variable_AsString
,
2540 d3d10_effect_variable_AsShaderResource
,
2541 d3d10_effect_variable_AsRenderTargetView
,
2542 d3d10_effect_variable_AsDepthStencilView
,
2543 d3d10_effect_variable_AsConstantBuffer
,
2544 d3d10_effect_variable_AsShader
,
2545 d3d10_effect_variable_AsBlend
,
2546 d3d10_effect_variable_AsDepthStencil
,
2547 d3d10_effect_variable_AsRasterizer
,
2548 d3d10_effect_variable_AsSampler
,
2549 d3d10_effect_variable_SetRawValue
,
2550 d3d10_effect_variable_GetRawValue
,
2553 /* ID3D10EffectVariable methods */
2554 static BOOL STDMETHODCALLTYPE
d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer
*iface
)
2556 TRACE("iface %p\n", iface
);
2558 return (struct d3d10_effect_variable
*)iface
!= &null_local_buffer
;
2561 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer
*iface
)
2563 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
2566 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer
*iface
,
2567 D3D10_EFFECT_VARIABLE_DESC
*desc
)
2569 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
2572 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetAnnotationByIndex(
2573 ID3D10EffectConstantBuffer
*iface
, UINT index
)
2575 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
2578 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetAnnotationByName(
2579 ID3D10EffectConstantBuffer
*iface
, LPCSTR name
)
2581 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
2584 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetMemberByIndex(
2585 ID3D10EffectConstantBuffer
*iface
, UINT index
)
2587 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
2590 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetMemberByName(
2591 ID3D10EffectConstantBuffer
*iface
, LPCSTR name
)
2593 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
2596 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetMemberBySemantic(
2597 ID3D10EffectConstantBuffer
*iface
, LPCSTR semantic
)
2599 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
2602 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetElement(
2603 ID3D10EffectConstantBuffer
*iface
, UINT index
)
2605 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
2608 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetParentConstantBuffer(
2609 ID3D10EffectConstantBuffer
*iface
)
2611 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
2614 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsScalar(
2615 ID3D10EffectConstantBuffer
*iface
)
2617 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
2620 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsVector(
2621 ID3D10EffectConstantBuffer
*iface
)
2623 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
2626 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsMatrix(
2627 ID3D10EffectConstantBuffer
*iface
)
2629 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
2632 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsString(
2633 ID3D10EffectConstantBuffer
*iface
)
2635 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
2638 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsShaderResource(
2639 ID3D10EffectConstantBuffer
*iface
)
2641 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
2644 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsRenderTargetView(
2645 ID3D10EffectConstantBuffer
*iface
)
2647 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
2650 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsDepthStencilView(
2651 ID3D10EffectConstantBuffer
*iface
)
2653 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
2656 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsConstantBuffer(
2657 ID3D10EffectConstantBuffer
*iface
)
2659 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
2662 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsShader(
2663 ID3D10EffectConstantBuffer
*iface
)
2665 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
2668 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer
*iface
)
2670 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
2673 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsDepthStencil(
2674 ID3D10EffectConstantBuffer
*iface
)
2676 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
2679 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsRasterizer(
2680 ID3D10EffectConstantBuffer
*iface
)
2682 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
2685 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_constant_buffer_AsSampler(
2686 ID3D10EffectConstantBuffer
*iface
)
2688 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
2691 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer
*iface
,
2692 void *data
, UINT offset
, UINT count
)
2694 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2697 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer
*iface
,
2698 void *data
, UINT offset
, UINT count
)
2700 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2703 /* ID3D10EffectConstantBuffer methods */
2704 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer
*iface
,
2705 ID3D10Buffer
*buffer
)
2707 FIXME("iface %p, buffer %p stub!\n", iface
, buffer
);
2712 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer
*iface
,
2713 ID3D10Buffer
**buffer
)
2715 FIXME("iface %p, buffer %p stub!\n", iface
, buffer
);
2720 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer
*iface
,
2721 ID3D10ShaderResourceView
*view
)
2723 FIXME("iface %p, view %p stub!\n", iface
, view
);
2728 static HRESULT STDMETHODCALLTYPE
d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer
*iface
,
2729 ID3D10ShaderResourceView
**view
)
2731 FIXME("iface %p, view %p stub!\n", iface
, view
);
2736 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl
=
2738 /* ID3D10EffectVariable methods */
2739 d3d10_effect_constant_buffer_IsValid
,
2740 d3d10_effect_constant_buffer_GetType
,
2741 d3d10_effect_constant_buffer_GetDesc
,
2742 d3d10_effect_constant_buffer_GetAnnotationByIndex
,
2743 d3d10_effect_constant_buffer_GetAnnotationByName
,
2744 d3d10_effect_constant_buffer_GetMemberByIndex
,
2745 d3d10_effect_constant_buffer_GetMemberByName
,
2746 d3d10_effect_constant_buffer_GetMemberBySemantic
,
2747 d3d10_effect_constant_buffer_GetElement
,
2748 d3d10_effect_constant_buffer_GetParentConstantBuffer
,
2749 d3d10_effect_constant_buffer_AsScalar
,
2750 d3d10_effect_constant_buffer_AsVector
,
2751 d3d10_effect_constant_buffer_AsMatrix
,
2752 d3d10_effect_constant_buffer_AsString
,
2753 d3d10_effect_constant_buffer_AsShaderResource
,
2754 d3d10_effect_constant_buffer_AsRenderTargetView
,
2755 d3d10_effect_constant_buffer_AsDepthStencilView
,
2756 d3d10_effect_constant_buffer_AsConstantBuffer
,
2757 d3d10_effect_constant_buffer_AsShader
,
2758 d3d10_effect_constant_buffer_AsBlend
,
2759 d3d10_effect_constant_buffer_AsDepthStencil
,
2760 d3d10_effect_constant_buffer_AsRasterizer
,
2761 d3d10_effect_constant_buffer_AsSampler
,
2762 d3d10_effect_constant_buffer_SetRawValue
,
2763 d3d10_effect_constant_buffer_GetRawValue
,
2764 /* ID3D10EffectConstantBuffer methods */
2765 d3d10_effect_constant_buffer_SetConstantBuffer
,
2766 d3d10_effect_constant_buffer_GetConstantBuffer
,
2767 d3d10_effect_constant_buffer_SetTextureBuffer
,
2768 d3d10_effect_constant_buffer_GetTextureBuffer
,
2771 /* ID3D10EffectVariable methods */
2773 static BOOL STDMETHODCALLTYPE
d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable
*iface
)
2775 TRACE("iface %p\n", iface
);
2777 return (struct d3d10_effect_variable
*)iface
!= &null_scalar_variable
;
2780 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetType(
2781 ID3D10EffectScalarVariable
*iface
)
2783 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
2786 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetDesc(ID3D10EffectScalarVariable
*iface
,
2787 D3D10_EFFECT_VARIABLE_DESC
*desc
)
2789 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
2792 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetAnnotationByIndex(
2793 ID3D10EffectScalarVariable
*iface
, UINT index
)
2795 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
2798 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetAnnotationByName(
2799 ID3D10EffectScalarVariable
*iface
, LPCSTR name
)
2801 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
2804 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetMemberByIndex(
2805 ID3D10EffectScalarVariable
*iface
, UINT index
)
2807 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
2810 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetMemberByName(
2811 ID3D10EffectScalarVariable
*iface
, LPCSTR name
)
2813 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
2816 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetMemberBySemantic(
2817 ID3D10EffectScalarVariable
*iface
, LPCSTR semantic
)
2819 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
2822 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetElement(
2823 ID3D10EffectScalarVariable
*iface
, UINT index
)
2825 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
2828 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetParentConstantBuffer(
2829 ID3D10EffectScalarVariable
*iface
)
2831 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
2834 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsScalar(
2835 ID3D10EffectScalarVariable
*iface
)
2837 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
2840 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsVector(
2841 ID3D10EffectScalarVariable
*iface
)
2843 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
2846 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsMatrix(
2847 ID3D10EffectScalarVariable
*iface
)
2849 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
2852 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsString(
2853 ID3D10EffectScalarVariable
*iface
)
2855 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
2858 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsShaderResource(
2859 ID3D10EffectScalarVariable
*iface
)
2861 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
2864 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsRenderTargetView(
2865 ID3D10EffectScalarVariable
*iface
)
2867 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
2870 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsDepthStencilView(
2871 ID3D10EffectScalarVariable
*iface
)
2873 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
2876 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsConstantBuffer(
2877 ID3D10EffectScalarVariable
*iface
)
2879 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
2882 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsShader(
2883 ID3D10EffectScalarVariable
*iface
)
2885 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
2888 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsBlend(
2889 ID3D10EffectScalarVariable
*iface
)
2891 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
2894 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsDepthStencil(
2895 ID3D10EffectScalarVariable
*iface
)
2897 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
2900 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsRasterizer(
2901 ID3D10EffectScalarVariable
*iface
)
2903 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
2906 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_scalar_variable_AsSampler(
2907 ID3D10EffectScalarVariable
*iface
)
2909 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
2912 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetRawValue(ID3D10EffectScalarVariable
*iface
,
2913 void *data
, UINT offset
, UINT count
)
2915 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2918 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetRawValue(ID3D10EffectScalarVariable
*iface
,
2919 void *data
, UINT offset
, UINT count
)
2921 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
2924 /* ID3D10EffectScalarVariable methods */
2926 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable
*iface
,
2929 FIXME("iface %p, value %.8e stub!\n", iface
, value
);
2934 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable
*iface
,
2937 FIXME("iface %p, value %p stub!\n", iface
, value
);
2942 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable
*iface
,
2943 float *values
, UINT offset
, UINT count
)
2945 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2950 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable
*iface
,
2951 float *values
, UINT offset
, UINT count
)
2953 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2958 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable
*iface
,
2961 FIXME("iface %p, value %d stub!\n", iface
, value
);
2966 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable
*iface
,
2969 FIXME("iface %p, value %p stub!\n", iface
, value
);
2974 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable
*iface
,
2975 int *values
, UINT offset
, UINT count
)
2977 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2982 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable
*iface
,
2983 int *values
, UINT offset
, UINT count
)
2985 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
2990 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable
*iface
,
2993 FIXME("iface %p, value %d stub!\n", iface
, value
);
2998 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable
*iface
,
3001 FIXME("iface %p, value %p stub!\n", iface
, value
);
3006 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable
*iface
,
3007 BOOL
*values
, UINT offset
, UINT count
)
3009 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3014 static HRESULT STDMETHODCALLTYPE
d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable
*iface
,
3015 BOOL
*values
, UINT offset
, UINT count
)
3017 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3022 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl
=
3024 /* ID3D10EffectVariable methods */
3025 d3d10_effect_scalar_variable_IsValid
,
3026 d3d10_effect_scalar_variable_GetType
,
3027 d3d10_effect_scalar_variable_GetDesc
,
3028 d3d10_effect_scalar_variable_GetAnnotationByIndex
,
3029 d3d10_effect_scalar_variable_GetAnnotationByName
,
3030 d3d10_effect_scalar_variable_GetMemberByIndex
,
3031 d3d10_effect_scalar_variable_GetMemberByName
,
3032 d3d10_effect_scalar_variable_GetMemberBySemantic
,
3033 d3d10_effect_scalar_variable_GetElement
,
3034 d3d10_effect_scalar_variable_GetParentConstantBuffer
,
3035 d3d10_effect_scalar_variable_AsScalar
,
3036 d3d10_effect_scalar_variable_AsVector
,
3037 d3d10_effect_scalar_variable_AsMatrix
,
3038 d3d10_effect_scalar_variable_AsString
,
3039 d3d10_effect_scalar_variable_AsShaderResource
,
3040 d3d10_effect_scalar_variable_AsRenderTargetView
,
3041 d3d10_effect_scalar_variable_AsDepthStencilView
,
3042 d3d10_effect_scalar_variable_AsConstantBuffer
,
3043 d3d10_effect_scalar_variable_AsShader
,
3044 d3d10_effect_scalar_variable_AsBlend
,
3045 d3d10_effect_scalar_variable_AsDepthStencil
,
3046 d3d10_effect_scalar_variable_AsRasterizer
,
3047 d3d10_effect_scalar_variable_AsSampler
,
3048 d3d10_effect_scalar_variable_SetRawValue
,
3049 d3d10_effect_scalar_variable_GetRawValue
,
3050 /* ID3D10EffectScalarVariable methods */
3051 d3d10_effect_scalar_variable_SetFloat
,
3052 d3d10_effect_scalar_variable_GetFloat
,
3053 d3d10_effect_scalar_variable_SetFloatArray
,
3054 d3d10_effect_scalar_variable_GetFloatArray
,
3055 d3d10_effect_scalar_variable_SetInt
,
3056 d3d10_effect_scalar_variable_GetInt
,
3057 d3d10_effect_scalar_variable_SetIntArray
,
3058 d3d10_effect_scalar_variable_GetIntArray
,
3059 d3d10_effect_scalar_variable_SetBool
,
3060 d3d10_effect_scalar_variable_GetBool
,
3061 d3d10_effect_scalar_variable_SetBoolArray
,
3062 d3d10_effect_scalar_variable_GetBoolArray
,
3065 /* ID3D10EffectVariable methods */
3067 static BOOL STDMETHODCALLTYPE
d3d10_effect_vector_variable_IsValid(ID3D10EffectVectorVariable
*iface
)
3069 TRACE("iface %p\n", iface
);
3071 return (struct d3d10_effect_variable
*)iface
!= &null_vector_variable
;
3074 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetType(
3075 ID3D10EffectVectorVariable
*iface
)
3077 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
3080 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetDesc(ID3D10EffectVectorVariable
*iface
,
3081 D3D10_EFFECT_VARIABLE_DESC
*desc
)
3083 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
3086 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetAnnotationByIndex(
3087 ID3D10EffectVectorVariable
*iface
, UINT index
)
3089 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
3092 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetAnnotationByName(
3093 ID3D10EffectVectorVariable
*iface
, LPCSTR name
)
3095 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
3098 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetMemberByIndex(
3099 ID3D10EffectVectorVariable
*iface
, UINT index
)
3101 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
3104 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetMemberByName(
3105 ID3D10EffectVectorVariable
*iface
, LPCSTR name
)
3107 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
3110 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetMemberBySemantic(
3111 ID3D10EffectVectorVariable
*iface
, LPCSTR semantic
)
3113 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
3116 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetElement(
3117 ID3D10EffectVectorVariable
*iface
, UINT index
)
3119 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
3122 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetParentConstantBuffer(
3123 ID3D10EffectVectorVariable
*iface
)
3125 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
3128 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsScalar(
3129 ID3D10EffectVectorVariable
*iface
)
3131 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
3134 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsVector(
3135 ID3D10EffectVectorVariable
*iface
)
3137 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
3140 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsMatrix(
3141 ID3D10EffectVectorVariable
*iface
)
3143 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
3146 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsString(
3147 ID3D10EffectVectorVariable
*iface
)
3149 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
3152 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsShaderResource(
3153 ID3D10EffectVectorVariable
*iface
)
3155 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
3158 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsRenderTargetView(
3159 ID3D10EffectVectorVariable
*iface
)
3161 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
3164 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsDepthStencilView(
3165 ID3D10EffectVectorVariable
*iface
)
3167 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
3170 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsConstantBuffer(
3171 ID3D10EffectVectorVariable
*iface
)
3173 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
3176 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsShader(
3177 ID3D10EffectVectorVariable
*iface
)
3179 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
3182 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsBlend(
3183 ID3D10EffectVectorVariable
*iface
)
3185 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
3188 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsDepthStencil(
3189 ID3D10EffectVectorVariable
*iface
)
3191 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
3194 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsRasterizer(
3195 ID3D10EffectVectorVariable
*iface
)
3197 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
3200 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_vector_variable_AsSampler(
3201 ID3D10EffectVectorVariable
*iface
)
3203 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
3206 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetRawValue(ID3D10EffectVectorVariable
*iface
,
3207 void *data
, UINT offset
, UINT count
)
3209 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
3212 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetRawValue(ID3D10EffectVectorVariable
*iface
,
3213 void *data
, UINT offset
, UINT count
)
3215 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
3218 /* ID3D10EffectVectorVariable methods */
3220 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetBoolVector(ID3D10EffectVectorVariable
*iface
,
3223 FIXME("iface %p, value %p stub!\n", iface
, value
);
3228 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetIntVector(ID3D10EffectVectorVariable
*iface
,
3231 FIXME("iface %p, value %p stub!\n", iface
, value
);
3236 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetFloatVector(ID3D10EffectVectorVariable
*iface
,
3239 FIXME("iface %p, value %p stub!\n", iface
, value
);
3244 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetBoolVector(ID3D10EffectVectorVariable
*iface
,
3247 FIXME("iface %p, value %p stub!\n", iface
, value
);
3252 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetIntVector(ID3D10EffectVectorVariable
*iface
,
3255 FIXME("iface %p, value %p stub!\n", iface
, value
);
3260 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetFloatVector(ID3D10EffectVectorVariable
*iface
,
3263 FIXME("iface %p, value %p stub!\n", iface
, value
);
3268 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetBoolVectorArray(ID3D10EffectVectorVariable
*iface
,
3269 BOOL
*values
, UINT offset
, UINT count
)
3271 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3276 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetIntVectorArray(ID3D10EffectVectorVariable
*iface
,
3277 int *values
, UINT offset
, UINT count
)
3279 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3284 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_SetFloatVectorArray(ID3D10EffectVectorVariable
*iface
,
3285 float *values
, UINT offset
, UINT count
)
3287 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3292 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetBoolVectorArray(ID3D10EffectVectorVariable
*iface
,
3293 BOOL
*values
, UINT offset
, UINT count
)
3295 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3300 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetIntVectorArray(ID3D10EffectVectorVariable
*iface
,
3301 int *values
, UINT offset
, UINT count
)
3303 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3308 static HRESULT STDMETHODCALLTYPE
d3d10_effect_vector_variable_GetFloatVectorArray(ID3D10EffectVectorVariable
*iface
,
3309 float *values
, UINT offset
, UINT count
)
3311 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface
, values
, offset
, count
);
3316 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl
=
3318 /* ID3D10EffectVariable methods */
3319 d3d10_effect_vector_variable_IsValid
,
3320 d3d10_effect_vector_variable_GetType
,
3321 d3d10_effect_vector_variable_GetDesc
,
3322 d3d10_effect_vector_variable_GetAnnotationByIndex
,
3323 d3d10_effect_vector_variable_GetAnnotationByName
,
3324 d3d10_effect_vector_variable_GetMemberByIndex
,
3325 d3d10_effect_vector_variable_GetMemberByName
,
3326 d3d10_effect_vector_variable_GetMemberBySemantic
,
3327 d3d10_effect_vector_variable_GetElement
,
3328 d3d10_effect_vector_variable_GetParentConstantBuffer
,
3329 d3d10_effect_vector_variable_AsScalar
,
3330 d3d10_effect_vector_variable_AsVector
,
3331 d3d10_effect_vector_variable_AsMatrix
,
3332 d3d10_effect_vector_variable_AsString
,
3333 d3d10_effect_vector_variable_AsShaderResource
,
3334 d3d10_effect_vector_variable_AsRenderTargetView
,
3335 d3d10_effect_vector_variable_AsDepthStencilView
,
3336 d3d10_effect_vector_variable_AsConstantBuffer
,
3337 d3d10_effect_vector_variable_AsShader
,
3338 d3d10_effect_vector_variable_AsBlend
,
3339 d3d10_effect_vector_variable_AsDepthStencil
,
3340 d3d10_effect_vector_variable_AsRasterizer
,
3341 d3d10_effect_vector_variable_AsSampler
,
3342 d3d10_effect_vector_variable_SetRawValue
,
3343 d3d10_effect_vector_variable_GetRawValue
,
3344 /* ID3D10EffectVectorVariable methods */
3345 d3d10_effect_vector_variable_SetBoolVector
,
3346 d3d10_effect_vector_variable_SetIntVector
,
3347 d3d10_effect_vector_variable_SetFloatVector
,
3348 d3d10_effect_vector_variable_GetBoolVector
,
3349 d3d10_effect_vector_variable_GetIntVector
,
3350 d3d10_effect_vector_variable_GetFloatVector
,
3351 d3d10_effect_vector_variable_SetBoolVectorArray
,
3352 d3d10_effect_vector_variable_SetIntVectorArray
,
3353 d3d10_effect_vector_variable_SetFloatVectorArray
,
3354 d3d10_effect_vector_variable_GetBoolVectorArray
,
3355 d3d10_effect_vector_variable_GetIntVectorArray
,
3356 d3d10_effect_vector_variable_GetFloatVectorArray
,
3359 /* ID3D10EffectVariable methods */
3361 static BOOL STDMETHODCALLTYPE
d3d10_effect_matrix_variable_IsValid(ID3D10EffectMatrixVariable
*iface
)
3363 TRACE("iface %p\n", iface
);
3365 return (struct d3d10_effect_variable
*)iface
!= &null_matrix_variable
;
3368 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetType(
3369 ID3D10EffectMatrixVariable
*iface
)
3371 return d3d10_effect_variable_GetType((ID3D10EffectVariable
*)iface
);
3374 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetDesc(ID3D10EffectMatrixVariable
*iface
,
3375 D3D10_EFFECT_VARIABLE_DESC
*desc
)
3377 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable
*)iface
, desc
);
3380 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetAnnotationByIndex(
3381 ID3D10EffectMatrixVariable
*iface
, UINT index
)
3383 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable
*)iface
, index
);
3386 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetAnnotationByName(
3387 ID3D10EffectMatrixVariable
*iface
, LPCSTR name
)
3389 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable
*)iface
, name
);
3392 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMemberByIndex(
3393 ID3D10EffectMatrixVariable
*iface
, UINT index
)
3395 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable
*)iface
, index
);
3398 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMemberByName(
3399 ID3D10EffectMatrixVariable
*iface
, LPCSTR name
)
3401 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable
*)iface
, name
);
3404 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMemberBySemantic(
3405 ID3D10EffectMatrixVariable
*iface
, LPCSTR semantic
)
3407 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable
*)iface
, semantic
);
3410 static struct ID3D10EffectVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetElement(
3411 ID3D10EffectMatrixVariable
*iface
, UINT index
)
3413 return d3d10_effect_variable_GetElement((ID3D10EffectVariable
*)iface
, index
);
3416 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetParentConstantBuffer(
3417 ID3D10EffectMatrixVariable
*iface
)
3419 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable
*)iface
);
3422 static struct ID3D10EffectScalarVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsScalar(
3423 ID3D10EffectMatrixVariable
*iface
)
3425 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable
*)iface
);
3428 static struct ID3D10EffectVectorVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsVector(
3429 ID3D10EffectMatrixVariable
*iface
)
3431 return d3d10_effect_variable_AsVector((ID3D10EffectVariable
*)iface
);
3434 static struct ID3D10EffectMatrixVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsMatrix(
3435 ID3D10EffectMatrixVariable
*iface
)
3437 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable
*)iface
);
3440 static struct ID3D10EffectStringVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsString(
3441 ID3D10EffectMatrixVariable
*iface
)
3443 return d3d10_effect_variable_AsString((ID3D10EffectVariable
*)iface
);
3446 static struct ID3D10EffectShaderResourceVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsShaderResource(
3447 ID3D10EffectMatrixVariable
*iface
)
3449 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable
*)iface
);
3452 static struct ID3D10EffectRenderTargetViewVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsRenderTargetView(
3453 ID3D10EffectMatrixVariable
*iface
)
3455 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable
*)iface
);
3458 static struct ID3D10EffectDepthStencilViewVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsDepthStencilView(
3459 ID3D10EffectMatrixVariable
*iface
)
3461 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable
*)iface
);
3464 static struct ID3D10EffectConstantBuffer
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsConstantBuffer(
3465 ID3D10EffectMatrixVariable
*iface
)
3467 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable
*)iface
);
3470 static struct ID3D10EffectShaderVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsShader(
3471 ID3D10EffectMatrixVariable
*iface
)
3473 return d3d10_effect_variable_AsShader((ID3D10EffectVariable
*)iface
);
3476 static struct ID3D10EffectBlendVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsBlend(
3477 ID3D10EffectMatrixVariable
*iface
)
3479 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable
*)iface
);
3482 static struct ID3D10EffectDepthStencilVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsDepthStencil(
3483 ID3D10EffectMatrixVariable
*iface
)
3485 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable
*)iface
);
3488 static struct ID3D10EffectRasterizerVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsRasterizer(
3489 ID3D10EffectMatrixVariable
*iface
)
3491 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable
*)iface
);
3494 static struct ID3D10EffectSamplerVariable
* STDMETHODCALLTYPE
d3d10_effect_matrix_variable_AsSampler(
3495 ID3D10EffectMatrixVariable
*iface
)
3497 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable
*)iface
);
3500 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetRawValue(ID3D10EffectMatrixVariable
*iface
,
3501 void *data
, UINT offset
, UINT count
)
3503 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
3506 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetRawValue(ID3D10EffectMatrixVariable
*iface
,
3507 void *data
, UINT offset
, UINT count
)
3509 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable
*)iface
, data
, offset
, count
);
3512 /* ID3D10EffectMatrixVariable methods */
3514 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrix(ID3D10EffectMatrixVariable
*iface
,
3517 FIXME("iface %p, data %p stub!\n", iface
, data
);
3522 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrix(ID3D10EffectMatrixVariable
*iface
,
3525 FIXME("iface %p, data %p stub!\n", iface
, data
);
3530 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrixArray(ID3D10EffectMatrixVariable
*iface
,
3531 float *data
, UINT offset
, UINT count
)
3533 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3538 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrixArray(ID3D10EffectMatrixVariable
*iface
,
3539 float *data
, UINT offset
, UINT count
)
3541 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3546 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrixTranspose(ID3D10EffectMatrixVariable
*iface
,
3549 FIXME("iface %p, data %p stub!\n", iface
, data
);
3554 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrixTranspose(ID3D10EffectMatrixVariable
*iface
,
3557 FIXME("iface %p, data %p stub!\n", iface
, data
);
3562 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_SetMatrixTransposeArray(ID3D10EffectMatrixVariable
*iface
,
3563 float *data
, UINT offset
, UINT count
)
3565 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3570 static HRESULT STDMETHODCALLTYPE
d3d10_effect_matrix_variable_GetMatrixTransposeArray(ID3D10EffectMatrixVariable
*iface
,
3571 float *data
, UINT offset
, UINT count
)
3573 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface
, data
, offset
, count
);
3579 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl
=
3581 /* ID3D10EffectVariable methods */
3582 d3d10_effect_matrix_variable_IsValid
,
3583 d3d10_effect_matrix_variable_GetType
,
3584 d3d10_effect_matrix_variable_GetDesc
,
3585 d3d10_effect_matrix_variable_GetAnnotationByIndex
,
3586 d3d10_effect_matrix_variable_GetAnnotationByName
,
3587 d3d10_effect_matrix_variable_GetMemberByIndex
,
3588 d3d10_effect_matrix_variable_GetMemberByName
,
3589 d3d10_effect_matrix_variable_GetMemberBySemantic
,
3590 d3d10_effect_matrix_variable_GetElement
,
3591 d3d10_effect_matrix_variable_GetParentConstantBuffer
,
3592 d3d10_effect_matrix_variable_AsScalar
,
3593 d3d10_effect_matrix_variable_AsVector
,
3594 d3d10_effect_matrix_variable_AsMatrix
,
3595 d3d10_effect_matrix_variable_AsString
,
3596 d3d10_effect_matrix_variable_AsShaderResource
,
3597 d3d10_effect_matrix_variable_AsRenderTargetView
,
3598 d3d10_effect_matrix_variable_AsDepthStencilView
,
3599 d3d10_effect_matrix_variable_AsConstantBuffer
,
3600 d3d10_effect_matrix_variable_AsShader
,
3601 d3d10_effect_matrix_variable_AsBlend
,
3602 d3d10_effect_matrix_variable_AsDepthStencil
,
3603 d3d10_effect_matrix_variable_AsRasterizer
,
3604 d3d10_effect_matrix_variable_AsSampler
,
3605 d3d10_effect_matrix_variable_SetRawValue
,
3606 d3d10_effect_matrix_variable_GetRawValue
,
3607 /* ID3D10EffectMatrixVariable methods */
3608 d3d10_effect_matrix_variable_SetMatrix
,
3609 d3d10_effect_matrix_variable_GetMatrix
,
3610 d3d10_effect_matrix_variable_SetMatrixArray
,
3611 d3d10_effect_matrix_variable_GetMatrixArray
,
3612 d3d10_effect_matrix_variable_SetMatrixTranspose
,
3613 d3d10_effect_matrix_variable_GetMatrixTranspose
,
3614 d3d10_effect_matrix_variable_SetMatrixTransposeArray
,
3615 d3d10_effect_matrix_variable_GetMatrixTransposeArray
,
3618 static BOOL STDMETHODCALLTYPE
d3d10_effect_type_IsValid(ID3D10EffectType
*iface
)
3620 FIXME("iface %p stub!\n", iface
);
3625 static HRESULT STDMETHODCALLTYPE
d3d10_effect_type_GetDesc(ID3D10EffectType
*iface
, D3D10_EFFECT_TYPE_DESC
*desc
)
3627 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3629 TRACE("iface %p, desc %p\n", iface
, desc
);
3631 if (This
== &null_type
)
3633 WARN("Null type specified\n");
3639 WARN("Invalid argument specified\n");
3640 return E_INVALIDARG
;
3643 desc
->TypeName
= This
->name
;
3644 desc
->Class
= This
->type_class
;
3645 desc
->Type
= This
->basetype
;
3646 desc
->Elements
= This
->element_count
;
3647 desc
->Members
= This
->member_count
;
3648 desc
->Rows
= This
->row_count
;
3649 desc
->Columns
= This
->column_count
;
3650 desc
->PackedSize
= This
->size_packed
;
3651 desc
->UnpackedSize
= This
->size_unpacked
;
3652 desc
->Stride
= This
->stride
;
3657 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_type_GetMemberTypeByIndex(ID3D10EffectType
*iface
,
3660 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3661 struct d3d10_effect_type
*t
;
3663 TRACE("iface %p, index %u\n", iface
, index
);
3665 if (index
>= This
->member_count
)
3667 WARN("Invalid index specified\n");
3668 return (ID3D10EffectType
*)&null_type
;
3671 t
= (&This
->members
[index
])->type
;
3673 TRACE("Returning member %p, %s\n", t
, debugstr_a(t
->name
));
3675 return (ID3D10EffectType
*)t
;
3678 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_type_GetMemberTypeByName(ID3D10EffectType
*iface
,
3681 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3684 TRACE("iface %p, name %s\n", iface
, debugstr_a(name
));
3688 WARN("Invalid name specified\n");
3689 return (ID3D10EffectType
*)&null_type
;
3692 for (i
= 0; i
< This
->member_count
; ++i
)
3694 struct d3d10_effect_type_member
*typem
= &This
->members
[i
];
3698 if (!strcmp(typem
->name
, name
))
3700 TRACE("Returning type %p.\n", typem
->type
);
3701 return (ID3D10EffectType
*)typem
->type
;
3706 WARN("Invalid name specified\n");
3708 return (ID3D10EffectType
*)&null_type
;
3711 static struct ID3D10EffectType
* STDMETHODCALLTYPE
d3d10_effect_type_GetMemberTypeBySemantic(ID3D10EffectType
*iface
,
3714 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3717 TRACE("iface %p, semantic %s\n", iface
, debugstr_a(semantic
));
3721 WARN("Invalid semantic specified\n");
3722 return (ID3D10EffectType
*)&null_type
;
3725 for (i
= 0; i
< This
->member_count
; ++i
)
3727 struct d3d10_effect_type_member
*typem
= &This
->members
[i
];
3729 if (typem
->semantic
)
3731 if (!strcmp(typem
->semantic
, semantic
))
3733 TRACE("Returning type %p.\n", typem
->type
);
3734 return (ID3D10EffectType
*)typem
->type
;
3739 WARN("Invalid semantic specified\n");
3741 return (ID3D10EffectType
*)&null_type
;
3744 static LPCSTR STDMETHODCALLTYPE
d3d10_effect_type_GetMemberName(ID3D10EffectType
*iface
, UINT index
)
3746 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3747 struct d3d10_effect_type_member
*typem
;
3749 TRACE("iface %p, index %u\n", iface
, index
);
3751 if (index
>= This
->member_count
)
3753 WARN("Invalid index specified\n");
3757 typem
= &This
->members
[index
];
3759 TRACE("Returning name %s\n", debugstr_a(typem
->name
));
3764 static LPCSTR STDMETHODCALLTYPE
d3d10_effect_type_GetMemberSemantic(ID3D10EffectType
*iface
, UINT index
)
3766 struct d3d10_effect_type
*This
= (struct d3d10_effect_type
*)iface
;
3767 struct d3d10_effect_type_member
*typem
;
3769 TRACE("iface %p, index %u\n", iface
, index
);
3771 if (index
>= This
->member_count
)
3773 WARN("Invalid index specified\n");
3777 typem
= &This
->members
[index
];
3779 TRACE("Returning semantic %s\n", debugstr_a(typem
->semantic
));
3781 return typem
->semantic
;
3784 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl
=
3786 /* ID3D10EffectType */
3787 d3d10_effect_type_IsValid
,
3788 d3d10_effect_type_GetDesc
,
3789 d3d10_effect_type_GetMemberTypeByIndex
,
3790 d3d10_effect_type_GetMemberTypeByName
,
3791 d3d10_effect_type_GetMemberTypeBySemantic
,
3792 d3d10_effect_type_GetMemberName
,
3793 d3d10_effect_type_GetMemberSemantic
,