?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dinput/tests: Add EnumObjects callback return value test.
[wine.git] / dlls / d3d10 / effect.c
blob61c76416273334cd777b923884744477bdcaf9af
1 /*
2 * Copyright 2009 Henri Verbeet for CodeWeavers
3 * Copyright 2009 Rico Schüller
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 *
19 */
20
21 #include "d3d10_private.h"
22
23 #include <float.h>
24 #include <stdint.h>
25
26 WINE_DEFAULT_DEBUG_CHANNEL(d3d10);
27
28 #define MAKE_TAG(ch0, ch1, ch2, ch3) \
29 ((DWORD)(ch0) | ((DWORD)(ch1) << 8) | \
30 ((DWORD)(ch2) << 16) | ((DWORD)(ch3) << 24 ))
31 #define TAG_DXBC MAKE_TAG('D', 'X', 'B', 'C')
32 #define TAG_FX10 MAKE_TAG('F', 'X', '1', '0')
33 #define TAG_FXLC MAKE_TAG('F', 'X', 'L', 'C')
34 #define TAG_CLI4 MAKE_TAG('C', 'L', 'I', '4')
35 #define TAG_CTAB MAKE_TAG('C', 'T', 'A', 'B')
36
37 #define D3D10_FX10_TYPE_COLUMN_SHIFT 11
38 #define D3D10_FX10_TYPE_COLUMN_MASK (0x7 << D3D10_FX10_TYPE_COLUMN_SHIFT)
39
40 #define D3D10_FX10_TYPE_ROW_SHIFT 8
41 #define D3D10_FX10_TYPE_ROW_MASK (0x7 << D3D10_FX10_TYPE_ROW_SHIFT)
42
43 #define D3D10_FX10_TYPE_BASETYPE_SHIFT 3
44 #define D3D10_FX10_TYPE_BASETYPE_MASK (0x1f << D3D10_FX10_TYPE_BASETYPE_SHIFT)
45
46 #define D3D10_FX10_TYPE_CLASS_SHIFT 0
47 #define D3D10_FX10_TYPE_CLASS_MASK (0x7 << D3D10_FX10_TYPE_CLASS_SHIFT)
48
49 #define D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK 0x4000
50
51 static inline struct d3d10_effect *impl_from_ID3D10EffectPool(ID3D10EffectPool *iface)
52 {
53 return CONTAINING_RECORD(iface, struct d3d10_effect, ID3D10EffectPool_iface);
54 }
55
56 const struct ID3D10EffectPoolVtbl d3d10_effect_pool_vtbl;
57 static inline struct d3d10_effect *unsafe_impl_from_ID3D10EffectPool(ID3D10EffectPool *iface)
58 {
59 if (!iface || iface->lpVtbl != &d3d10_effect_pool_vtbl)
60 return NULL;
61 return CONTAINING_RECORD(iface, struct d3d10_effect, ID3D10EffectPool_iface);
62 }
63
64 static const struct ID3D10EffectVtbl d3d10_effect_pool_effect_vtbl;
65 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable *v);
66
67 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl;
68 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl;
69 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl;
70 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl;
71 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl;
72 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl;
73 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl;
74 static const struct ID3D10EffectStringVariableVtbl d3d10_effect_string_variable_vtbl;
75 static const struct ID3D10EffectShaderResourceVariableVtbl d3d10_effect_shader_resource_variable_vtbl;
76 static const struct ID3D10EffectRenderTargetViewVariableVtbl d3d10_effect_render_target_view_variable_vtbl;
77 static const struct ID3D10EffectDepthStencilViewVariableVtbl d3d10_effect_depth_stencil_view_variable_vtbl;
78 static const struct ID3D10EffectShaderVariableVtbl d3d10_effect_shader_variable_vtbl;
79 static const struct ID3D10EffectBlendVariableVtbl d3d10_effect_blend_variable_vtbl;
80 static const struct ID3D10EffectDepthStencilVariableVtbl d3d10_effect_depth_stencil_variable_vtbl;
81 static const struct ID3D10EffectRasterizerVariableVtbl d3d10_effect_rasterizer_variable_vtbl;
82 static const struct ID3D10EffectSamplerVariableVtbl d3d10_effect_sampler_variable_vtbl;
83 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl;
84
85 /* null objects - needed for invalid calls */
86 static struct d3d10_effect_technique null_technique = {{&d3d10_effect_technique_vtbl}};
87 static struct d3d10_effect_pass null_pass = {{&d3d10_effect_pass_vtbl}};
88 static struct d3d10_effect_type null_type = {{&d3d10_effect_type_vtbl}};
89 static struct d3d10_effect_variable null_local_buffer = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl},
90 &null_local_buffer, &null_type};
91 static struct d3d10_effect_variable null_variable = {{&d3d10_effect_variable_vtbl},
92 &null_local_buffer, &null_type};
93 static struct d3d10_effect_variable null_scalar_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl},
94 &null_local_buffer, &null_type};
95 static struct d3d10_effect_variable null_vector_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl},
96 &null_local_buffer, &null_type};
97 static struct d3d10_effect_variable null_matrix_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl},
98 &null_local_buffer, &null_type};
99 static struct d3d10_effect_variable null_string_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl},
100 &null_local_buffer, &null_type};
101 static struct d3d10_effect_variable null_render_target_view_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl},
102 &null_local_buffer, &null_type};
103 static struct d3d10_effect_variable null_depth_stencil_view_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl},
104 &null_local_buffer, &null_type};
105 static struct d3d10_effect_variable null_shader_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
106 &null_local_buffer, &null_type};
107 static struct d3d10_effect_variable null_blend_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl},
108 &null_local_buffer, &null_type};
109 static struct d3d10_effect_variable null_depth_stencil_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl},
110 &null_local_buffer, &null_type};
111 static struct d3d10_effect_variable null_rasterizer_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl},
112 &null_local_buffer, &null_type};
113 static struct d3d10_effect_variable null_sampler_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl},
114 &null_local_buffer, &null_type};
115
116 static ID3D10ShaderResourceView *null_srvs[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT];
117
118 static struct d3d10_effect_variable null_shader_resource_variable =
119 {
120 .ID3D10EffectVariable_iface.lpVtbl = (ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl,
121 .buffer = &null_local_buffer,
122 .type = &null_type,
123 .u.resource.srv = null_srvs,
124 };
125
126 /* anonymous_shader_type and anonymous_shader */
127 static char anonymous_name[] = "$Anonymous";
128 static char anonymous_vertexshader_name[] = "vertexshader";
129 static char anonymous_pixelshader_name[] = "pixelshader";
130 static char anonymous_geometryshader_name[] = "geometryshader";
131 static struct d3d10_effect_type anonymous_vs_type = {{&d3d10_effect_type_vtbl},
132 anonymous_vertexshader_name, D3D10_SVT_VERTEXSHADER, D3D10_SVC_OBJECT};
133 static struct d3d10_effect_type anonymous_ps_type = {{&d3d10_effect_type_vtbl},
134 anonymous_pixelshader_name, D3D10_SVT_PIXELSHADER, D3D10_SVC_OBJECT};
135 static struct d3d10_effect_type anonymous_gs_type = {{&d3d10_effect_type_vtbl},
136 anonymous_geometryshader_name, D3D10_SVT_GEOMETRYSHADER, D3D10_SVC_OBJECT};
137 static struct d3d10_effect_variable anonymous_vs = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
138 &null_local_buffer, &anonymous_vs_type, anonymous_name};
139 static struct d3d10_effect_variable anonymous_ps = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
140 &null_local_buffer, &anonymous_ps_type, anonymous_name};
141 static struct d3d10_effect_variable anonymous_gs = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
142 &null_local_buffer, &anonymous_gs_type, anonymous_name};
143
144 static struct d3d10_effect_type *get_fx10_type(struct d3d10_effect *effect,
145 const char *data, size_t data_size, uint32_t offset);
146
147 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectVariable(ID3D10EffectVariable *iface)
148 {
149 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
150 }
151
152 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectShaderVariable(ID3D10EffectShaderVariable *iface)
153 {
154 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
155 }
156
157 static struct d3d10_effect_variable * d3d10_array_get_element(struct d3d10_effect_variable *v,
158 unsigned int index)
159 {
160 if (!v->type->element_count) return v;
161 return &v->elements[index];
162 }
163
164 static struct d3d10_effect_variable * d3d10_get_state_variable(struct d3d10_effect_variable *v,
165 unsigned int index, const struct d3d10_effect_var_array *array)
166 {
167 v = d3d10_array_get_element(v, 0);
168
169 if (v->u.state.index + index >= array->count)
170 {
171 WARN("Invalid index %u.\n", index);
172 return NULL;
173 }
174
175 return array->v[v->u.state.index + index];
176 }
177
178 enum d3d10_effect_container_type
179 {
180 D3D10_C_NONE,
181 D3D10_C_PASS,
182 D3D10_C_RASTERIZER,
183 D3D10_C_DEPTHSTENCIL,
184 D3D10_C_BLEND,
185 D3D10_C_SAMPLER,
186 };
187
188 static enum d3d10_effect_container_type get_var_container_type(const struct d3d10_effect_variable *v)
189 {
190 switch (v->type->basetype)
191 {
192 case D3D10_SVT_DEPTHSTENCIL: return D3D10_C_DEPTHSTENCIL;
193 case D3D10_SVT_BLEND: return D3D10_C_BLEND;
194 case D3D10_SVT_RASTERIZER: return D3D10_C_RASTERIZER;
195 case D3D10_SVT_SAMPLER: return D3D10_C_SAMPLER;
196 default: return D3D10_C_NONE;
197 }
198 }
199
200 struct preshader_instr
201 {
202 unsigned int comp_count : 16;
203 unsigned int reserved : 4;
204 unsigned int opcode : 11;
205 unsigned int scalar : 1;
206 };
207
208 typedef void (*pres_op_func)(float **args, unsigned int n, const struct preshader_instr *instr);
209
210 static void pres_neg(float **args, unsigned int n, const struct preshader_instr *instr)
211 {
212 float *retval = args[1];
213 unsigned int i;
214
215 for (i = 0; i < instr->comp_count; ++i)
216 retval[i] = -args[0][i];
217 }
218
219 static void pres_rcp(float **args, unsigned int n, const struct preshader_instr *instr)
220 {
221 float *retval = args[1];
222 unsigned int i;
223
224 for (i = 0; i < instr->comp_count; ++i)
225 retval[i] = 1.0f / args[0][i];
226 }
227
228 static void pres_frc(float **args, unsigned int n, const struct preshader_instr *instr)
229 {
230 float *retval = args[1];
231 unsigned int i;
232
233 for (i = 0; i < instr->comp_count; ++i)
234 retval[i] = args[0][i] - floor(args[0][i]);
235 }
236
237 static void pres_sin(float **args, unsigned int n, const struct preshader_instr *instr)
238 {
239 float *retval = args[1];
240 unsigned int i;
241
242 for (i = 0; i < instr->comp_count; ++i)
243 retval[i] = sin(args[0][i]);
244 }
245
246 static void pres_cos(float **args, unsigned int n, const struct preshader_instr *instr)
247 {
248 float *retval = args[1];
249 unsigned int i;
250
251 for (i = 0; i < instr->comp_count; ++i)
252 retval[i] = cos(args[0][i]);
253 }
254
255 static void pres_asin(float **args, unsigned int n, const struct preshader_instr *instr)
256 {
257 float *retval = args[1];
258 unsigned int i;
259
260 for (i = 0; i < instr->comp_count; ++i)
261 retval[i] = asinf(args[0][i]);
262 }
263
264 static void pres_acos(float **args, unsigned int n, const struct preshader_instr *instr)
265 {
266 float *retval = args[1];
267 unsigned int i;
268
269 for (i = 0; i < instr->comp_count; ++i)
270 retval[i] = acosf(args[0][i]);
271 }
272
273 static void pres_atan(float **args, unsigned int n, const struct preshader_instr *instr)
274 {
275 float *retval = args[1];
276 unsigned int i;
277
278 for (i = 0; i < instr->comp_count; ++i)
279 retval[i] = atanf(args[0][i]);
280 }
281
282 static void pres_ineg(float **args, unsigned int n, const struct preshader_instr *instr)
283 {
284 int *arg1 = (int *)args[0];
285 float *retval = args[1];
286 unsigned int i;
287
288 for (i = 0; i < instr->comp_count; ++i)
289 {
290 int v = -arg1[i];
291 retval[i] = *(float *)&v;
292 }
293 }
294
295 static void pres_itof(float **args, unsigned int n, const struct preshader_instr *instr)
296 {
297 float *retval = args[1];
298 unsigned int i;
299
300 for (i = 0; i < instr->comp_count; ++i)
301 retval[i] = *(int *)&args[0][i];
302 }
303
304 static void pres_utof(float **args, unsigned int n, const struct preshader_instr *instr)
305 {
306 float *retval = args[1];
307 unsigned int i;
308
309 for (i = 0; i < instr->comp_count; ++i)
310 retval[i] = *(unsigned int *)&args[0][i];
311 }
312
313 static void pres_ftou(float **args, unsigned int n, const struct preshader_instr *instr)
314 {
315 float *retval = args[1];
316 unsigned int i;
317
318 for (i = 0; i < instr->comp_count; ++i)
319 {
320 unsigned int u = args[0][i];
321 retval[i] = *(float *)&u;
322 }
323 }
324
325 static void pres_ftob(float **args, unsigned int n, const struct preshader_instr *instr)
326 {
327 float *retval = args[1];
328 unsigned int i;
329
330 for (i = 0; i < instr->comp_count; ++i)
331 {
332 unsigned int u = args[0][i] == 0.0f ? 0 : ~0u;
333 retval[i] = *(float *)&u;
334 }
335 }
336
337 static void pres_min(float **args, unsigned int n, const struct preshader_instr *instr)
338 {
339 float *retval = args[2];
340 unsigned int i;
341
342 for (i = 0; i < instr->comp_count; ++i)
343 retval[i] = min(args[0][instr->scalar ? 0 : i], args[1][i]);
344 }
345
346 static void pres_max(float **args, unsigned int n, const struct preshader_instr *instr)
347 {
348 float *retval = args[2];
349 unsigned int i;
350
351 for (i = 0; i < instr->comp_count; ++i)
352 retval[i] = max(args[0][instr->scalar ? 0 : i], args[1][i]);
353 }
354
355 static void pres_add(float **args, unsigned int n, const struct preshader_instr *instr)
356 {
357 float *retval = args[2];
358 unsigned int i;
359
360 for (i = 0; i < instr->comp_count; ++i)
361 retval[i] = args[0][instr->scalar ? 0 : i] + args[1][i];
362 }
363
364 static void pres_mul(float **args, unsigned int n, const struct preshader_instr *instr)
365 {
366 float *retval = args[2];
367 unsigned int i;
368
369 for (i = 0; i < instr->comp_count; ++i)
370 retval[i] = args[0][instr->scalar ? 0 : i] * args[1][i];
371 }
372
373 static void pres_atan2(float **args, unsigned int n, const struct preshader_instr *instr)
374 {
375 float *retval = args[2];
376 unsigned int i;
377
378 for (i = 0; i < instr->comp_count; ++i)
379 retval[i] = atan2f(args[0][instr->scalar ? 0 : i], args[1][i]);
380 }
381
382 static void pres_div(float **args, unsigned int n, const struct preshader_instr *instr)
383 {
384 float *retval = args[2];
385 unsigned int i;
386
387 for (i = 0; i < instr->comp_count; ++i)
388 retval[i] = args[0][instr->scalar ? 0 : i] / args[1][i];
389 }
390
391 static void pres_iadd(float **args, unsigned int n, const struct preshader_instr *instr)
392 {
393 int *arg1 = (int *)args[0];
394 int *arg2 = (int *)args[1];
395 float *retval = args[2];
396 unsigned int i;
397
398 for (i = 0; i < instr->comp_count; ++i)
399 {
400 int v = arg1[instr->scalar ? 0 : i] + arg2[i];
401 retval[i] = *(float *)&v;
402 }
403 }
404
405 static void pres_udiv(float **args, unsigned int n, const struct preshader_instr *instr)
406 {
407 unsigned int *arg1 = (unsigned int *)args[0];
408 unsigned int *arg2 = (unsigned int *)args[1];
409 float *retval = args[2];
410 unsigned int i;
411
412 for (i = 0; i < instr->comp_count; ++i)
413 {
414 unsigned int v = arg2[i] ? arg1[instr->scalar ? 0 : i] / arg2[i] : UINT_MAX;
415 retval[i] = *(float *)&v;
416 }
417 }
418
419 static void pres_imin(float **args, unsigned int n, const struct preshader_instr *instr)
420 {
421 int *arg1 = (int *)args[0], *arg2 = (int *)args[1];
422 float *retval = args[2];
423 unsigned int i;
424
425 for (i = 0; i < instr->comp_count; ++i)
426 {
427 int v = min(arg1[instr->scalar ? 0 : i], arg2[i]);
428 retval[i] = *(float *)&v;
429 }
430 }
431
432 static void pres_imax(float **args, unsigned int n, const struct preshader_instr *instr)
433 {
434 int *arg1 = (int *)args[0], *arg2 = (int *)args[1];
435 float *retval = args[2];
436 unsigned int i;
437
438 for (i = 0; i < instr->comp_count; ++i)
439 {
440 int v = max(arg1[instr->scalar ? 0 : i], arg2[i]);
441 retval[i] = *(float *)&v;
442 }
443 }
444
445 static void pres_umin(float **args, unsigned int n, const struct preshader_instr *instr)
446 {
447 unsigned int *arg1 = (unsigned int *)args[0], *arg2 = (unsigned int *)args[1];
448 float *retval = args[2];
449 unsigned int i;
450
451 for (i = 0; i < instr->comp_count; ++i)
452 {
453 unsigned int v = min(arg1[instr->scalar ? 0 : i], arg2[i]);
454 retval[i] = *(float *)&v;
455 }
456 }
457
458 static void pres_umax(float **args, unsigned int n, const struct preshader_instr *instr)
459 {
460 unsigned int *arg1 = (unsigned int *)args[0], *arg2 = (unsigned int *)args[1];
461 float *retval = args[2];
462 unsigned int i;
463
464 for (i = 0; i < instr->comp_count; ++i)
465 {
466 unsigned int v = max(arg1[instr->scalar ? 0 : i], arg2[i]);
467 retval[i] = *(float *)&v;
468 }
469 }
470
471 static void pres_movc(float **args, unsigned int n, const struct preshader_instr *instr)
472 {
473 float *arg1 = args[0], *arg2 = args[1], *arg3 = args[2];
474 float *retval = args[3];
475 unsigned int i;
476
477 for (i = 0; i < instr->comp_count; ++i)
478 retval[i] = arg1[i] ? arg2[i] : arg3[i];
479 }
480
481 struct preshader_op_info
482 {
483 int opcode;
484 char name[8];
485 pres_op_func func;
486 };
487
488 static const struct preshader_op_info preshader_ops[] =
489 {
490 { 0x101, "neg", pres_neg },
491 { 0x103, "rcp", pres_rcp },
492 { 0x104, "frc", pres_frc },
493 { 0x108, "sin", pres_sin },
494 { 0x109, "cos", pres_cos },
495 { 0x10a, "asin", pres_asin },
496 { 0x10b, "acos", pres_acos },
497 { 0x10c, "atan", pres_atan },
498 { 0x120, "ineg", pres_ineg },
499 { 0x130, "itof", pres_itof },
500 { 0x131, "utof", pres_utof },
501 { 0x133, "ftou", pres_ftou },
502 { 0x137, "ftob", pres_ftob },
503 { 0x200, "min", pres_min },
504 { 0x201, "max", pres_max },
505 { 0x204, "add", pres_add },
506 { 0x205, "mul", pres_mul },
507 { 0x206, "atan2",pres_atan2},
508 { 0x208, "div", pres_div },
509 { 0x216, "iadd", pres_iadd },
510 { 0x21a, "udiv", pres_udiv },
511 { 0x21d, "imin", pres_imin },
512 { 0x21e, "imax", pres_imax },
513 { 0x21f, "umin", pres_umin },
514 { 0x220, "umax", pres_umax },
515 { 0x301, "movc", pres_movc },
516 };
517
518 static int __cdecl preshader_op_compare(const void *a, const void *b)
519 {
520 int opcode = *(int *)a;
521 const struct preshader_op_info *op_info = b;
522 return opcode - op_info->opcode;
523 }
524
525 static const struct preshader_op_info * d3d10_effect_get_op_info(int opcode)
526 {
527 return bsearch(&opcode, preshader_ops, ARRAY_SIZE(preshader_ops), sizeof(*preshader_ops),
528 preshader_op_compare);
529 }
530
531 struct d3d10_ctab_var
532 {
533 struct d3d10_effect_variable *v;
534 unsigned int offset;
535 unsigned int length;
536 };
537
538 struct d3d10_reg_table
539 {
540 union
541 {
542 float *f;
543 DWORD *dword;
544 };
545 unsigned int count;
546 };
547
548 enum d3d10_reg_table_type
549 {
550 D3D10_REG_TABLE_CONSTANTS = 1,
551 D3D10_REG_TABLE_CB = 2,
552 D3D10_REG_TABLE_RESULT = 4,
553 D3D10_REG_TABLE_TEMP = 7,
554 D3D10_REG_TABLE_COUNT,
555 };
556
557 struct d3d10_effect_preshader
558 {
559 struct d3d10_reg_table reg_tables[D3D10_REG_TABLE_COUNT];
560 ID3D10Blob *code;
561
562 struct d3d10_ctab_var *vars;
563 unsigned int vars_count;
564 };
565
566 struct d3d10_preshader_parse_context
567 {
568 struct d3d10_effect_preshader *preshader;
569 struct d3d10_effect *effect;
570 unsigned int table_sizes[D3D10_REG_TABLE_COUNT];
571 };
572
573 struct d3d10_effect_prop_dependency
574 {
575 unsigned int id;
576 unsigned int idx;
577 unsigned int operation;
578 union
579 {
580 struct
581 {
582 struct d3d10_effect_variable *v;
583 unsigned int offset;
584 } var;
585 struct
586 {
587 struct d3d10_effect_variable *v;
588 struct d3d10_effect_preshader index;
589 } index_expr;
590 struct
591 {
592 struct d3d10_effect_preshader value;
593 } value_expr;
594 };
595 };
596
597 static HRESULT d3d10_reg_table_allocate(struct d3d10_reg_table *table, unsigned int count)
598 {
599 if (!(table->f = calloc(count, sizeof(*table->f))))
600 return E_OUTOFMEMORY;
601 table->count = count;
602 return S_OK;
603 }
604
605 static void d3d10_effect_preshader_clear(struct d3d10_effect_preshader *p)
606 {
607 unsigned int i;
608
609 for (i = 0; i < ARRAY_SIZE(p->reg_tables); ++i)
610 free(p->reg_tables[i].f);
611 if (p->code)
612 ID3D10Blob_Release(p->code);
613 free(p->vars);
614 memset(p, 0, sizeof(*p));
615 }
616
617 static float * d3d10_effect_preshader_get_reg_ptr(const struct d3d10_effect_preshader *p,
618 enum d3d10_reg_table_type regt, unsigned int offset)
619 {
620 switch (regt)
621 {
622 case D3D10_REG_TABLE_CONSTANTS:
623 case D3D10_REG_TABLE_CB:
624 case D3D10_REG_TABLE_RESULT:
625 case D3D10_REG_TABLE_TEMP:
626 return p->reg_tables[regt].f + offset;
627 default:
628 return NULL;
629 }
630 }
631
632 static HRESULT d3d10_effect_preshader_eval(struct d3d10_effect_preshader *p)
633 {
634 unsigned int i, j, regt, offset, instr_count, arg_count;
635 const DWORD *ip = ID3D10Blob_GetBufferPointer(p->code);
636 struct preshader_instr ins;
637 float *dst, *args[4];
638
639 dst = d3d10_effect_preshader_get_reg_ptr(p, D3D10_REG_TABLE_RESULT, 0);
640 memset(dst, 0, sizeof(float) * p->reg_tables[D3D10_REG_TABLE_RESULT].count);
641
642 /* Update constant buffer */
643 dst = d3d10_effect_preshader_get_reg_ptr(p, D3D10_REG_TABLE_CB, 0);
644 for (i = 0; i < p->vars_count; ++i)
645 {
646 struct d3d10_ctab_var *v = &p->vars[i];
647 memcpy(dst + v->offset, v->v->buffer->u.buffer.local_buffer + v->v->buffer_offset,
648 v->length * sizeof(*dst));
649 }
650
651 instr_count = *ip++;
652
653 for (i = 0; i < instr_count; ++i)
654 {
655 *(DWORD *)&ins = *ip++;
656 arg_count = 1 + *ip++;
657
658 if (arg_count > ARRAY_SIZE(args))
659 {
660 FIXME("Unexpected argument count %u.\n", arg_count);
661 return E_FAIL;
662 }
663
664 /* Arguments are followed by the return value. */
665 for (j = 0; j < arg_count; ++j)
666 {
667 ip++; /* TODO: argument register flags are currently ignored */
668 regt = *ip++;
669 offset = *ip++;
670
671 args[j] = d3d10_effect_preshader_get_reg_ptr(p, regt, offset);
672 }
673
674 d3d10_effect_get_op_info(ins.opcode)->func(args, arg_count, &ins);
675 }
676
677 return S_OK;
678 }
679
680 static void d3d10_effect_clear_prop_dependencies(struct d3d10_effect_prop_dependencies *d)
681 {
682 unsigned int i;
683
684 for (i = 0; i < d->count; ++i)
685 {
686 struct d3d10_effect_prop_dependency *dep = &d->entries[i];
687 switch (dep->operation)
688 {
689 case D3D10_EOO_INDEX_EXPRESSION:
690 d3d10_effect_preshader_clear(&dep->index_expr.index);
691 break;
692 case D3D10_EOO_VALUE_EXPRESSION:
693 d3d10_effect_preshader_clear(&dep->value_expr.value);
694 break;
695 }
696 }
697 free(d->entries);
698 memset(d, 0, sizeof(*d));
699 }
700
701 struct d3d10_effect_state_property_info
702 {
703 const char *name;
704 D3D_SHADER_VARIABLE_TYPE type;
705 UINT size;
706 UINT count;
707 enum d3d10_effect_container_type container_type;
708 LONG offset;
709 LONG index_offset;
710 };
711
712 static const struct d3d10_effect_state_property_info property_infos[] =
713 {
714 { "Pass.RasterizerState", D3D10_SVT_RASTERIZER, 1, 1, D3D10_C_PASS, FIELD_OFFSET(struct d3d10_effect_pass, rasterizer) },
715 { "Pass.DepthStencilState", D3D10_SVT_DEPTHSTENCIL, 1, 1, D3D10_C_PASS, FIELD_OFFSET(struct d3d10_effect_pass, depth_stencil) },
716 { "Pass.BlendState", D3D10_SVT_BLEND, 1, 1, D3D10_C_PASS, FIELD_OFFSET(struct d3d10_effect_pass, blend) },
717 { "Pass.RenderTargets", D3D10_SVT_RENDERTARGETVIEW, 1, 8, D3D10_C_PASS, ~0u },
718 { "Pass.DepthStencilView", D3D10_SVT_DEPTHSTENCILVIEW, 1, 1, D3D10_C_PASS, ~0u },
719 { "Pass.Unknown5", D3D10_SVT_VOID, 0, 0, D3D10_C_PASS, ~0u },
720 { "Pass.VertexShader", D3D10_SVT_VERTEXSHADER, 1, 1, D3D10_C_PASS, FIELD_OFFSET(struct d3d10_effect_pass, vs.shader),
721 FIELD_OFFSET(struct d3d10_effect_pass, vs.index) },
722 { "Pass.PixelShader", D3D10_SVT_PIXELSHADER, 1, 1, D3D10_C_PASS, FIELD_OFFSET(struct d3d10_effect_pass, ps.shader),
723 FIELD_OFFSET(struct d3d10_effect_pass, ps.index) },
724 { "Pass.GeometryShader", D3D10_SVT_GEOMETRYSHADER, 1, 1, D3D10_C_PASS, FIELD_OFFSET(struct d3d10_effect_pass, gs.shader),
725 FIELD_OFFSET(struct d3d10_effect_pass, gs.index) },
726 { "Pass.StencilRef", D3D10_SVT_UINT, 1, 1, D3D10_C_PASS, FIELD_OFFSET(struct d3d10_effect_pass, stencil_ref) },
727 { "Pass.BlendFactor", D3D10_SVT_FLOAT, 4, 1, D3D10_C_PASS, FIELD_OFFSET(struct d3d10_effect_pass, blend_factor) },
728 { "Pass.SampleMask", D3D10_SVT_UINT, 1, 1, D3D10_C_PASS, FIELD_OFFSET(struct d3d10_effect_pass, sample_mask) },
729
730 { "RasterizerState.FillMode", D3D10_SVT_INT, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, FillMode) },
731 { "RasterizerState.CullMode", D3D10_SVT_INT, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, CullMode) },
732 { "RasterizerState.FrontCounterClockwise", D3D10_SVT_BOOL, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, FrontCounterClockwise) },
733 { "RasterizerState.DepthBias", D3D10_SVT_INT, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, DepthBias) },
734 { "RasterizerState.DepthBiasClamp", D3D10_SVT_FLOAT, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, DepthBiasClamp) },
735 { "RasterizerState.SlopeScaledDepthBias", D3D10_SVT_FLOAT, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, SlopeScaledDepthBias) },
736 { "RasterizerState.DepthClipEnable", D3D10_SVT_BOOL, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, DepthClipEnable) },
737 { "RasterizerState.ScissorEnable", D3D10_SVT_BOOL, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, ScissorEnable) },
738 { "RasterizerState.MultisampleEnable", D3D10_SVT_BOOL, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, MultisampleEnable) },
739 { "RasterizerState.AntialiasedLineEnable", D3D10_SVT_BOOL, 1, 1, D3D10_C_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, AntialiasedLineEnable) },
740
741 { "DepthStencilState.DepthEnable", D3D10_SVT_BOOL, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, DepthEnable) },
742 { "DepthStencilState.DepthWriteMask", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, DepthWriteMask) },
743 { "DepthStencilState.DepthFunc", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, DepthFunc) },
744 { "DepthStencilState.StencilEnable", D3D10_SVT_BOOL, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, StencilEnable) },
745 { "DepthStencilState.StencilReadMask", D3D10_SVT_UINT8, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, StencilReadMask) },
746 { "DepthStencilState.StencilWriteMask", D3D10_SVT_UINT8, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, StencilWriteMask) },
747 { "DepthStencilState.FrontFaceStencilFail", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilFailOp) },
748 { "DepthStencilState.FrontFaceStencilDepthFail", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilDepthFailOp)},
749 { "DepthStencilState.FrontFaceStencilPass", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilPassOp) },
750 { "DepthStencilState.FrontFaceStencilFunc", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilFunc) },
751 { "DepthStencilState.BackFaceStencilFail", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilFailOp) },
752 { "DepthStencilState.BackFaceStencilDepthFail", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilDepthFailOp) },
753 { "DepthStencilState.BackFaceStencilPass", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilPassOp) },
754 { "DepthStencilState.BackFaceStencilFunc", D3D10_SVT_INT, 1, 1, D3D10_C_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilFunc) },
755
756 { "BlendState.AlphaToCoverageEnable", D3D10_SVT_BOOL, 1, 1, D3D10_C_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, AlphaToCoverageEnable) },
757 { "BlendState.BlendEnable", D3D10_SVT_BOOL, 1, 8, D3D10_C_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, BlendEnable) },
758 { "BlendState.SrcBlend", D3D10_SVT_INT, 1, 1, D3D10_C_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, SrcBlend) },
759 { "BlendState.DestBlend", D3D10_SVT_INT, 1, 1, D3D10_C_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, DestBlend) },
760 { "BlendState.BlendOp", D3D10_SVT_INT, 1, 1, D3D10_C_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, BlendOp) },
761 { "BlendState.SrcBlendAlpha", D3D10_SVT_INT, 1, 1, D3D10_C_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, SrcBlendAlpha) },
762 { "BlendState.DestBlendAlpha", D3D10_SVT_INT, 1, 1, D3D10_C_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, DestBlendAlpha) },
763 { "BlendState.BlendOpAlpha", D3D10_SVT_INT, 1, 1, D3D10_C_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, BlendOpAlpha) },
764 { "BlendState.RenderTargetWriteMask", D3D10_SVT_UINT8, 1, 8, D3D10_C_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, RenderTargetWriteMask) },
765
766 { "SamplerState.Filter", D3D10_SVT_INT, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.Filter) },
767 { "SamplerState.AddressU", D3D10_SVT_INT, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.AddressU) },
768 { "SamplerState.AddressV", D3D10_SVT_INT, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.AddressV) },
769 { "SamplerState.AddressW", D3D10_SVT_INT, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.AddressW) },
770 { "SamplerState.MipLODBias", D3D10_SVT_FLOAT, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.MipLODBias) },
771 { "SamplerState.MaxAnisotropy", D3D10_SVT_UINT, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.MaxAnisotropy) },
772 { "SamplerState.ComparisonFunc", D3D10_SVT_INT, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.ComparisonFunc) },
773 { "SamplerState.BorderColor", D3D10_SVT_FLOAT, 4, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.BorderColor) },
774 { "SamplerState.MinLOD", D3D10_SVT_FLOAT, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.MinLOD) },
775 { "SamplerState.MaxLOD", D3D10_SVT_FLOAT, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, desc.MaxLOD) },
776 { "SamplerState.Texture", D3D10_SVT_TEXTURE, 1, 1, D3D10_C_SAMPLER, FIELD_OFFSET(struct d3d10_effect_sampler_desc, texture) },
777 };
778
779 static const D3D10_RASTERIZER_DESC default_rasterizer_desc =
780 {
781 D3D10_FILL_SOLID,
782 D3D10_CULL_BACK,
783 FALSE,
784 0,
785 0.0f,
786 0.0f,
787 TRUE,
788 FALSE,
789 FALSE,
790 FALSE,
791 };
792
793 static const D3D10_DEPTH_STENCIL_DESC default_depth_stencil_desc =
794 {
795 TRUE,
796 D3D10_DEPTH_WRITE_MASK_ALL,
797 D3D10_COMPARISON_LESS,
798 FALSE,
799 D3D10_DEFAULT_STENCIL_READ_MASK,
800 D3D10_DEFAULT_STENCIL_WRITE_MASK,
801 {D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_COMPARISON_ALWAYS},
802 {D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_COMPARISON_ALWAYS},
803 };
804
805 static const D3D10_BLEND_DESC default_blend_desc =
806 {
807 FALSE,
808 {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE},
809 D3D10_BLEND_SRC_ALPHA,
810 D3D10_BLEND_INV_SRC_ALPHA,
811 D3D10_BLEND_OP_ADD,
812 D3D10_BLEND_SRC_ALPHA,
813 D3D10_BLEND_INV_SRC_ALPHA,
814 D3D10_BLEND_OP_ADD,
815 {0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf},
816 };
817
818 static const D3D10_SAMPLER_DESC default_sampler_desc =
819 {
820 D3D10_FILTER_MIN_MAG_MIP_POINT,
821 D3D10_TEXTURE_ADDRESS_WRAP,
822 D3D10_TEXTURE_ADDRESS_WRAP,
823 D3D10_TEXTURE_ADDRESS_WRAP,
824 0.0f,
825 16,
826 D3D10_COMPARISON_NEVER,
827 {0.0f, 0.0f, 0.0f, 0.0f},
828 0.0f,
829 FLT_MAX,
830 };
831
832 struct d3d10_effect_state_storage_info
833 {
834 D3D_SHADER_VARIABLE_TYPE id;
835 SIZE_T size;
836 const void *default_state;
837 };
838
839 static const struct d3d10_effect_state_storage_info d3d10_effect_state_storage_info[] =
840 {
841 {D3D10_SVT_RASTERIZER, sizeof(default_rasterizer_desc), &default_rasterizer_desc },
842 {D3D10_SVT_DEPTHSTENCIL, sizeof(default_depth_stencil_desc), &default_depth_stencil_desc},
843 {D3D10_SVT_BLEND, sizeof(default_blend_desc), &default_blend_desc },
844 {D3D10_SVT_SAMPLER, sizeof(default_sampler_desc), &default_sampler_desc },
845 };
846
847 #define WINE_D3D10_TO_STR(x) case x: return #x
848
849 static const char *debug_d3d10_shader_variable_class(D3D10_SHADER_VARIABLE_CLASS c)
850 {
851 switch (c)
852 {
853 WINE_D3D10_TO_STR(D3D10_SVC_SCALAR);
854 WINE_D3D10_TO_STR(D3D10_SVC_VECTOR);
855 WINE_D3D10_TO_STR(D3D10_SVC_MATRIX_ROWS);
856 WINE_D3D10_TO_STR(D3D10_SVC_MATRIX_COLUMNS);
857 WINE_D3D10_TO_STR(D3D10_SVC_OBJECT);
858 WINE_D3D10_TO_STR(D3D10_SVC_STRUCT);
859 default:
860 FIXME("Unrecognised D3D10_SHADER_VARIABLE_CLASS %#x.\n", c);
861 return "unrecognised";
862 }
863 }
864
865 static const char *debug_d3d10_shader_variable_type(D3D10_SHADER_VARIABLE_TYPE t)
866 {
867 switch (t)
868 {
869 WINE_D3D10_TO_STR(D3D10_SVT_VOID);
870 WINE_D3D10_TO_STR(D3D10_SVT_BOOL);
871 WINE_D3D10_TO_STR(D3D10_SVT_INT);
872 WINE_D3D10_TO_STR(D3D10_SVT_FLOAT);
873 WINE_D3D10_TO_STR(D3D10_SVT_STRING);
874 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURE);
875 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURE1D);
876 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURE2D);
877 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURE3D);
878 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURECUBE);
879 WINE_D3D10_TO_STR(D3D10_SVT_SAMPLER);
880 WINE_D3D10_TO_STR(D3D10_SVT_PIXELSHADER);
881 WINE_D3D10_TO_STR(D3D10_SVT_VERTEXSHADER);
882 WINE_D3D10_TO_STR(D3D10_SVT_UINT);
883 WINE_D3D10_TO_STR(D3D10_SVT_UINT8);
884 WINE_D3D10_TO_STR(D3D10_SVT_GEOMETRYSHADER);
885 WINE_D3D10_TO_STR(D3D10_SVT_RASTERIZER);
886 WINE_D3D10_TO_STR(D3D10_SVT_DEPTHSTENCIL);
887 WINE_D3D10_TO_STR(D3D10_SVT_BLEND);
888 WINE_D3D10_TO_STR(D3D10_SVT_BUFFER);
889 WINE_D3D10_TO_STR(D3D10_SVT_CBUFFER);
890 WINE_D3D10_TO_STR(D3D10_SVT_TBUFFER);
891 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURE1DARRAY);
892 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURE2DARRAY);
893 WINE_D3D10_TO_STR(D3D10_SVT_RENDERTARGETVIEW);
894 WINE_D3D10_TO_STR(D3D10_SVT_DEPTHSTENCILVIEW);
895 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURE2DMS);
896 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURE2DMSARRAY);
897 WINE_D3D10_TO_STR(D3D10_SVT_TEXTURECUBEARRAY);
898 default:
899 FIXME("Unrecognised D3D10_SHADER_VARIABLE_TYPE %#x.\n", t);
900 return "unrecognised";
901 }
902 }
903
904 #undef WINE_D3D10_TO_STR
905
906 static HRESULT d3d10_effect_variable_get_raw_value(struct d3d10_effect_variable *v,
907 void *data, unsigned int offset, unsigned int count)
908 {
909 BOOL is_buffer;
910
911 is_buffer = v->type->basetype == D3D10_SVT_CBUFFER || v->type->basetype == D3D10_SVT_TBUFFER;
912
913 if (v->type->type_class == D3D10_SVC_OBJECT && !is_buffer)
914 {
915 WARN("Not supported on object variables of type %s.\n",
916 debug_d3d10_shader_variable_type(v->type->basetype));
917 return D3DERR_INVALIDCALL;
918 }
919
920 if (!is_buffer)
921 {
922 offset += v->buffer_offset;
923 v = v->buffer;
924 }
925
926 memcpy(data, v->u.buffer.local_buffer + offset, count);
927
928 return S_OK;
929 }
930
931 static BOOL read_float_value(uint32_t value, D3D_SHADER_VARIABLE_TYPE in_type,
932 float *out_data, unsigned int out_idx)
933 {
934 switch (in_type)
935 {
936 case D3D10_SVT_FLOAT:
937 out_data[out_idx] = *(float *)&value;
938 return TRUE;
939
940 case D3D10_SVT_INT:
941 out_data[out_idx] = (INT)value;
942 return TRUE;
943
944 case D3D10_SVT_UINT:
945 out_data[out_idx] = value;
946 return TRUE;
947
948 default:
949 FIXME("Unhandled in_type %#x.\n", in_type);
950 return FALSE;
951 }
952 }
953
954 static BOOL read_int32_value(uint32_t value, D3D_SHADER_VARIABLE_TYPE in_type,
955 int *out_data, unsigned int out_idx)
956 {
957 switch (in_type)
958 {
959 case D3D10_SVT_FLOAT:
960 out_data[out_idx] = *(float *)&value;
961 return TRUE;
962
963 case D3D10_SVT_INT:
964 case D3D10_SVT_UINT:
965 case D3D10_SVT_BOOL:
966 out_data[out_idx] = value;
967 return TRUE;
968
969 default:
970 FIXME("Unhandled in_type %#x.\n", in_type);
971 return FALSE;
972 }
973 }
974
975 static BOOL read_int8_value(uint32_t value, D3D_SHADER_VARIABLE_TYPE in_type,
976 INT8 *out_data, unsigned int out_idx)
977 {
978 switch (in_type)
979 {
980 case D3D10_SVT_INT:
981 case D3D10_SVT_UINT:
982 out_data[out_idx] = value;
983 return TRUE;
984
985 default:
986 FIXME("Unhandled in_type %#x.\n", in_type);
987 return FALSE;
988 }
989 }
990
991 static BOOL d3d10_effect_read_numeric_value(uint32_t value, D3D_SHADER_VARIABLE_TYPE in_type,
992 D3D_SHADER_VARIABLE_TYPE out_type, void *out_data, unsigned int out_idx)
993 {
994 switch (out_type)
995 {
996 case D3D10_SVT_FLOAT:
997 return read_float_value(value, in_type, out_data, out_idx);
998 case D3D10_SVT_INT:
999 case D3D10_SVT_UINT:
1000 case D3D10_SVT_BOOL:
1001 return read_int32_value(value, in_type, out_data, out_idx);
1002 case D3D10_SVT_UINT8:
1003 return read_int8_value(value, in_type, out_data, out_idx);
1004 default:
1005 FIXME("Unsupported property type %u.\n", out_type);
1006 return FALSE;
1007 }
1008 }
1009
1010 static void d3d10_effect_update_dependent_props(struct d3d10_effect_prop_dependencies *deps,
1011 void *container)
1012 {
1013 const struct d3d10_effect_state_property_info *property_info;
1014 struct d3d10_effect_prop_dependency *d;
1015 unsigned int i, j, count, variable_idx;
1016 struct d3d10_effect_variable *v;
1017 struct d3d10_reg_table *table;
1018 unsigned int *dst_index;
1019 uint32_t value;
1020 HRESULT hr;
1021 void *dst;
1022
1023 for (i = 0; i < deps->count; ++i)
1024 {
1025 d = &deps->entries[i];
1026
1027 property_info = &property_infos[d->id];
1028
1029 dst = (char *)container + property_info->offset;
1030 dst_index = (unsigned int *)((char *)container + property_info->index_offset);
1031
1032 switch (d->operation)
1033 {
1034 case D3D10_EOO_VAR:
1035 case D3D10_EOO_CONST_INDEX:
1036
1037 v = d->var.v;
1038
1039 count = v->type->type_class == D3D10_SVC_VECTOR ? 4 : 1;
1040
1041 for (j = 0; j < count; ++j)
1042 {
1043 d3d10_effect_variable_get_raw_value(v, &value, d->var.offset + j * sizeof(value), sizeof(value));
1044 d3d10_effect_read_numeric_value(value, v->type->basetype, property_info->type, dst, j);
1045 }
1046
1047 break;
1048
1049 case D3D10_EOO_INDEX_EXPRESSION:
1050
1051 v = d->index_expr.v;
1052
1053 if (FAILED(hr = d3d10_effect_preshader_eval(&d->index_expr.index)))
1054 {
1055 WARN("Failed to evaluate index expression, hr %#lx.\n", hr);
1056 return;
1057 }
1058
1059 variable_idx = *d->index_expr.index.reg_tables[D3D10_REG_TABLE_RESULT].dword;
1060
1061 if (variable_idx >= v->type->element_count)
1062 {
1063 WARN("Expression evaluated to invalid index value %u, array %s of size %u.\n",
1064 variable_idx, debugstr_a(v->name), v->type->element_count);
1065 variable_idx = 0;
1066 }
1067
1068 /* Ignoring destination index here, there are no object typed array properties. */
1069 switch (property_info->type)
1070 {
1071 case D3D10_SVT_VERTEXSHADER:
1072 case D3D10_SVT_PIXELSHADER:
1073 case D3D10_SVT_GEOMETRYSHADER:
1074 *(void **)dst = v;
1075 *dst_index = variable_idx;
1076 break;
1077 default:
1078 *(void **)dst = &v->elements[variable_idx];
1079 }
1080 break;
1081
1082 case D3D10_EOO_VALUE_EXPRESSION:
1083
1084 if ((property_info->type != D3D10_SVT_UINT)
1085 && (property_info->type != D3D10_SVT_FLOAT)
1086 && (property_info->type != D3D10_SVT_BOOL))
1087 {
1088 FIXME("Unimplemented for property %s.\n", property_info->name);
1089 return;
1090 }
1091
1092 if (FAILED(hr = d3d10_effect_preshader_eval(&d->value_expr.value)))
1093 {
1094 WARN("Failed to evaluate value expression, hr %#lx.\n", hr);
1095 return;
1096 }
1097
1098 table = &d->value_expr.value.reg_tables[D3D10_REG_TABLE_RESULT];
1099
1100 if (property_info->size != table->count)
1101 {
1102 WARN("Unexpected value expression output size %u, property size %u.\n",
1103 table->count, property_info->size);
1104 return;
1105 }
1106
1107 memcpy(dst, table->f, property_info->size * sizeof(float));
1108
1109 break;
1110
1111 default:
1112 FIXME("Unsupported property update for %u.\n", d->operation);
1113 }
1114 }
1115 }
1116
1117 static BOOL d3d_array_reserve(void **elements, SIZE_T *capacity, SIZE_T count, SIZE_T size)
1118 {
1119 SIZE_T max_capacity, new_capacity;
1120 void *new_elements;
1121
1122 if (count <= *capacity)
1123 return TRUE;
1124
1125 max_capacity = ~(SIZE_T)0 / size;
1126 if (count > max_capacity)
1127 return FALSE;
1128
1129 new_capacity = max(1, *capacity);
1130 while (new_capacity < count && new_capacity <= max_capacity / 2)
1131 new_capacity *= 2;
1132 if (new_capacity < count)
1133 new_capacity = count;
1134
1135 if (!(new_elements = realloc(*elements, new_capacity * size)))
1136 return FALSE;
1137
1138 *elements = new_elements;
1139 *capacity = new_capacity;
1140 return TRUE;
1141 }
1142
1143 static BOOL require_space(size_t offset, size_t count, size_t size, size_t data_size)
1144 {
1145 return !count || (data_size - offset) / count >= size;
1146 }
1147
1148 static HRESULT parse_dxbc(const char *data, SIZE_T data_size,
1149 HRESULT (*chunk_handler)(const char *data, size_t data_size, uint32_t tag, void *ctx), void *ctx)
1150 {
1151 const char *ptr = data;
1152 uint32_t chunk_count;
1153 uint32_t total_size;
1154 HRESULT hr = S_OK;
1155 uint32_t version;
1156 unsigned int i;
1157 uint32_t tag;
1158
1159 if (!data)
1160 {
1161 WARN("No data supplied.\n");
1162 return E_FAIL;
1163 }
1164
1165 tag = read_u32(&ptr);
1166 TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
1167
1168 if (tag != TAG_DXBC)
1169 {
1170 WARN("Wrong tag.\n");
1171 return E_FAIL;
1172 }
1173
1174 FIXME("Skipping DXBC checksum.\n");
1175 skip_u32_unknown(&ptr, 4);
1176
1177 version = read_u32(&ptr);
1178 TRACE("version: %#x.\n", version);
1179 if (version != 0x00000001)
1180 {
1181 WARN("Got unexpected DXBC version %#x.\n", version);
1182 return E_FAIL;
1183 }
1184
1185 total_size = read_u32(&ptr);
1186 TRACE("Total size: %#x.\n", total_size);
1187
1188 if (data_size != total_size)
1189 {
1190 WARN("Wrong size supplied.\n");
1191 return E_FAIL;
1192 }
1193
1194 chunk_count = read_u32(&ptr);
1195 TRACE("Chunk count: %#x.\n", chunk_count);
1196
1197 for (i = 0; i < chunk_count; ++i)
1198 {
1199 uint32_t chunk_tag, chunk_size;
1200 const char *chunk_ptr;
1201 uint32_t chunk_offset;
1202
1203 chunk_offset = read_u32(&ptr);
1204 TRACE("Chunk %u at offset %#x.\n", i, chunk_offset);
1205
1206 if (chunk_offset >= data_size || !require_space(chunk_offset, 2, sizeof(uint32_t), data_size))
1207 {
1208 WARN("Invalid chunk offset %#x (data size %#Ix).\n", chunk_offset, data_size);
1209 return E_FAIL;
1210 }
1211
1212 chunk_ptr = data + chunk_offset;
1213
1214 chunk_tag = read_u32(&chunk_ptr);
1215 chunk_size = read_u32(&chunk_ptr);
1216
1217 if (!require_space(chunk_ptr - data, 1, chunk_size, data_size))
1218 {
1219 WARN("Invalid chunk size %#x (data size %#Ix, chunk offset %#x).\n",
1220 chunk_size, data_size, chunk_offset);
1221 return E_FAIL;
1222 }
1223
1224 if (FAILED(hr = chunk_handler(chunk_ptr, chunk_size, chunk_tag, ctx)))
1225 break;
1226 }
1227
1228 return hr;
1229 }
1230
1231 static BOOL fx10_get_string(const char *data, size_t data_size, uint32_t offset, const char **s, size_t *l)
1232 {
1233 size_t len, max_len;
1234
1235 if (offset >= data_size)
1236 {
1237 WARN("Invalid offset %#x (data size %#Ix).\n", offset, data_size);
1238 return FALSE;
1239 }
1240
1241 max_len = data_size - offset;
1242 if (!(len = strnlen(data + offset, max_len)))
1243 {
1244 *s = NULL;
1245 *l = 0;
1246 return TRUE;
1247 }
1248
1249 if (len == max_len)
1250 return FALSE;
1251
1252 *s = data + offset;
1253 *l = ++len;
1254
1255 return TRUE;
1256 }
1257
1258 static BOOL fx10_copy_string(const char *data, size_t data_size, DWORD offset, char **s)
1259 {
1260 const char *p;
1261 size_t len;
1262
1263 if (!fx10_get_string(data, data_size, offset, &p, &len))
1264 return FALSE;
1265
1266 if (!p)
1267 {
1268 *s = NULL;
1269 return TRUE;
1270 }
1271
1272 if (!(*s = malloc(len)))
1273 {
1274 ERR("Failed to allocate string memory.\n");
1275 return FALSE;
1276 }
1277
1278 memcpy(*s, p, len);
1279
1280 return TRUE;
1281 }
1282
1283 static BOOL copy_name(const char *ptr, char **name)
1284 {
1285 if (!ptr || !*ptr) return TRUE;
1286
1287 if (!(*name = strdup(ptr)))
1288 {
1289 ERR("Failed to allocate name memory.\n");
1290 return FALSE;
1291 }
1292
1293 return TRUE;
1294 }
1295
1296 static struct d3d10_effect_variable * d3d10_effect_get_buffer_by_name(struct d3d10_effect *effect,
1297 const char *name)
1298 {
1299 unsigned int i;
1300
1301 for (i = 0; i < effect->local_buffer_count; ++i)
1302 {
1303 struct d3d10_effect_variable *l = &effect->local_buffers[i];
1304 if (l->name && !strcmp(l->name, name))
1305 return l;
1306 }
1307
1308 return effect->pool ? d3d10_effect_get_buffer_by_name(effect->pool, name) : NULL;
1309 }
1310
1311 static struct d3d10_effect_variable * d3d10_effect_get_variable_by_name(
1312 const struct d3d10_effect *effect, const char *name)
1313 {
1314 struct d3d10_effect_variable *v;
1315 unsigned int i, j;
1316
1317 for (i = 0; i < effect->local_buffer_count; ++i)
1318 {
1319 for (j = 0; j < effect->local_buffers[i].type->member_count; ++j)
1320 {
1321 v = &effect->local_buffers[i].members[j];
1322 if (v->name && !strcmp(v->name, name))
1323 return v;
1324 }
1325 }
1326
1327 for (i = 0; i < effect->local_variable_count; ++i)
1328 {
1329 struct d3d10_effect_variable *v = &effect->local_variables[i];
1330 if (v->name && !strcmp(v->name, name))
1331 return v;
1332 }
1333
1334 return effect->pool ? d3d10_effect_get_variable_by_name(effect->pool, name) : NULL;
1335 }
1336
1337 static HRESULT get_fx10_shader_resources(struct d3d10_effect_variable *v)
1338 {
1339 struct d3d10_effect_shader_variable *sv = &v->u.shader;
1340 struct d3d10_effect_shader_resource *sr;
1341 D3D10_SHADER_INPUT_BIND_DESC bind_desc;
1342 D3D10_SHADER_DESC desc;
1343 unsigned int i;
1344
1345 sv->reflection->lpVtbl->GetDesc(sv->reflection, &desc);
1346 sv->resource_count = desc.BoundResources;
1347
1348 if (!(sv->resources = calloc(sv->resource_count, sizeof(*sv->resources))))
1349 {
1350 ERR("Failed to allocate shader resource binding information memory.\n");
1351 return E_OUTOFMEMORY;
1352 }
1353
1354 for (i = 0; i < desc.BoundResources; ++i)
1355 {
1356 sv->reflection->lpVtbl->GetResourceBindingDesc(sv->reflection, i, &bind_desc);
1357 sr = &sv->resources[i];
1358
1359 sr->in_type = bind_desc.Type;
1360 sr->bind_point = bind_desc.BindPoint;
1361 sr->bind_count = bind_desc.BindCount;
1362
1363 switch (bind_desc.Type)
1364 {
1365 case D3D10_SIT_CBUFFER:
1366 case D3D10_SIT_TBUFFER:
1367 if (sr->bind_count != 1)
1368 {
1369 WARN("Unexpected bind count %u for a buffer %s.\n", bind_desc.BindCount,
1370 debugstr_a(bind_desc.Name));
1371 return E_UNEXPECTED;
1372 }
1373 sr->variable = d3d10_effect_get_buffer_by_name(v->effect, bind_desc.Name);
1374 break;
1375
1376 case D3D10_SIT_SAMPLER:
1377 case D3D10_SIT_TEXTURE:
1378 sr->variable = d3d10_effect_get_variable_by_name(v->effect, bind_desc.Name);
1379 break;
1380
1381 default:
1382 break;
1383 }
1384
1385 if (!sr->variable)
1386 {
1387 WARN("Failed to find shader resource.\n");
1388 return E_FAIL;
1389 }
1390 }
1391
1392 return S_OK;
1393 }
1394
1395 struct d3d10_effect_so_decl
1396 {
1397 D3D10_SO_DECLARATION_ENTRY *entries;
1398 SIZE_T capacity;
1399 SIZE_T count;
1400 unsigned int stride;
1401 char *decl;
1402 };
1403
1404 static void d3d10_effect_cleanup_so_decl(struct d3d10_effect_so_decl *so_decl)
1405 {
1406 free(so_decl->entries);
1407 free(so_decl->decl);
1408 memset(so_decl, 0, sizeof(*so_decl));
1409 }
1410
1411 static HRESULT d3d10_effect_parse_stream_output_declaration(const char *decl,
1412 struct d3d10_effect_so_decl *so_decl)
1413 {
1414 static const char * xyzw = "xyzw";
1415 static const char * rgba = "rgba";
1416 char *p, *ptr, *end, *next, *mask, *m, *slot;
1417 D3D10_SO_DECLARATION_ENTRY e;
1418 unsigned int len;
1419
1420 memset(so_decl, 0, sizeof(*so_decl));
1421
1422 if (!(so_decl->decl = strdup(decl)))
1423 return E_OUTOFMEMORY;
1424
1425 p = so_decl->decl;
1426
1427 while (p && *p)
1428 {
1429 memset(&e, 0, sizeof(e));
1430
1431 end = strchr(p, ';');
1432 next = end ? end + 1 : p + strlen(p);
1433
1434 len = next - p;
1435 if (end) len--;
1436
1437 /* Remove leading and trailing spaces. */
1438 while (len && isspace(*p)) { len--; p++; }
1439 while (len && isspace(p[len - 1])) len--;
1440
1441 p[len] = 0;
1442
1443 /* Output slot */
1444 if ((slot = strchr(p, ':')))
1445 {
1446 *slot = 0;
1447
1448 ptr = p;
1449 while (*ptr)
1450 {
1451 if (!isdigit(*ptr))
1452 {
1453 WARN("Invalid output slot %s.\n", debugstr_a(p));
1454 goto failed;
1455 }
1456 ptr++;
1457 }
1458
1459 e.OutputSlot = atoi(p);
1460 p = slot + 1;
1461 }
1462
1463 /* Mask */
1464 if ((mask = strchr(p, '.')))
1465 {
1466 *mask = 0; mask++;
1467
1468 if ((m = strstr(xyzw, mask)))
1469 e.StartComponent = m - xyzw;
1470 else if ((m = strstr(rgba, mask)))
1471 e.StartComponent = m - rgba;
1472 else
1473 {
1474 WARN("Invalid component mask %s.\n", debugstr_a(mask));
1475 goto failed;
1476 }
1477
1478 e.ComponentCount = strlen(mask);
1479 }
1480 else
1481 {
1482 e.StartComponent = 0;
1483 e.ComponentCount = 4;
1484 }
1485
1486 /* Semantic index and name */
1487 len = strlen(p);
1488 while (isdigit(p[len - 1]))
1489 len--;
1490
1491 if (p[len])
1492 {
1493 e.SemanticIndex = atoi(&p[len]);
1494 p[len] = 0;
1495 }
1496
1497 e.SemanticName = stricmp(p, "$SKIP") ? p : NULL;
1498
1499 if (!d3d_array_reserve((void **)&so_decl->entries, &so_decl->capacity, so_decl->count + 1,
1500 sizeof(*so_decl->entries)))
1501 goto failed;
1502
1503 so_decl->entries[so_decl->count++] = e;
1504
1505 if (e.OutputSlot == 0)
1506 so_decl->stride += e.ComponentCount * sizeof(float);
1507
1508 p = next;
1509 }
1510
1511 return S_OK;
1512
1513 failed:
1514 d3d10_effect_cleanup_so_decl(so_decl);
1515
1516 return E_FAIL;
1517 }
1518
1519 static HRESULT parse_fx10_shader(const char *data, size_t data_size, uint32_t offset, struct d3d10_effect_variable *v)
1520 {
1521 ID3D10Device *device = v->effect->device;
1522 uint32_t dxbc_size;
1523 const char *ptr;
1524 HRESULT hr;
1525
1526 if (v->effect->shaders.current >= v->effect->shaders.count)
1527 {
1528 WARN("Invalid effect? Used shader current(%u) >= used shader count(%u)\n",
1529 v->effect->shaders.current, v->effect->shaders.count);
1530 return E_FAIL;
1531 }
1532
1533 v->effect->shaders.v[v->effect->shaders.current++] = v;
1534
1535 if (offset >= data_size || !require_space(offset, 1, sizeof(dxbc_size), data_size))
1536 {
1537 WARN("Invalid offset %#x (data size %#Ix).\n", offset, data_size);
1538 return E_FAIL;
1539 }
1540
1541 ptr = data + offset;
1542 dxbc_size = read_u32(&ptr);
1543 TRACE("DXBC size: %#x.\n", dxbc_size);
1544
1545 if (!require_space(ptr - data, 1, dxbc_size, data_size))
1546 {
1547 WARN("Invalid dxbc size %#x (data size %#Ix, offset %#x).\n", offset, data_size, offset);
1548 return E_FAIL;
1549 }
1550
1551 if (!dxbc_size)
1552 return S_OK;
1553
1554 if (FAILED(hr = D3D10ReflectShader(ptr, dxbc_size, &v->u.shader.reflection)))
1555 return hr;
1556
1557 D3DGetInputSignatureBlob(ptr, dxbc_size, &v->u.shader.input_signature);
1558
1559 if (FAILED(hr = D3DCreateBlob(dxbc_size, &v->u.shader.bytecode)))
1560 return hr;
1561
1562 memcpy(ID3D10Blob_GetBufferPointer(v->u.shader.bytecode), ptr, dxbc_size);
1563
1564 if (FAILED(hr = get_fx10_shader_resources(v)))
1565 return hr;
1566
1567 switch (v->type->basetype)
1568 {
1569 case D3D10_SVT_VERTEXSHADER:
1570 hr = ID3D10Device_CreateVertexShader(device, ptr, dxbc_size, &v->u.shader.shader.vs);
1571 break;
1572
1573 case D3D10_SVT_PIXELSHADER:
1574 hr = ID3D10Device_CreatePixelShader(device, ptr, dxbc_size, &v->u.shader.shader.ps);
1575 break;
1576
1577 case D3D10_SVT_GEOMETRYSHADER:
1578 if (v->u.shader.stream_output_declaration)
1579 {
1580 struct d3d10_effect_so_decl so_decl;
1581
1582 if (FAILED(hr = d3d10_effect_parse_stream_output_declaration(v->u.shader.stream_output_declaration, &so_decl)))
1583 {
1584 WARN("Failed to parse stream output declaration, hr %#lx.\n", hr);
1585 break;
1586 }
1587
1588 hr = ID3D10Device_CreateGeometryShaderWithStreamOutput(device, ptr, dxbc_size,
1589 so_decl.entries, so_decl.count, so_decl.stride, &v->u.shader.shader.gs);
1590
1591 d3d10_effect_cleanup_so_decl(&so_decl);
1592 }
1593 else
1594 hr = ID3D10Device_CreateGeometryShader(device, ptr, dxbc_size, &v->u.shader.shader.gs);
1595 break;
1596
1597 default:
1598 ERR("This should not happen!\n");
1599 return E_FAIL;
1600 }
1601
1602 return hr;
1603 }
1604
1605 static D3D10_SHADER_VARIABLE_CLASS d3d10_variable_class(uint32_t c, BOOL is_column_major)
1606 {
1607 switch (c)
1608 {
1609 case 1: return D3D10_SVC_SCALAR;
1610 case 2: return D3D10_SVC_VECTOR;
1611 case 3: if (is_column_major) return D3D10_SVC_MATRIX_COLUMNS;
1612 else return D3D10_SVC_MATRIX_ROWS;
1613 default:
1614 FIXME("Unknown variable class %#x.\n", c);
1615 return 0;
1616 }
1617 }
1618
1619 static D3D10_SHADER_VARIABLE_TYPE d3d10_variable_type(uint32_t t, BOOL is_object,
1620 uint32_t *flags)
1621 {
1622 *flags = 0;
1623
1624 if(is_object)
1625 {
1626 switch (t)
1627 {
1628 case 1: return D3D10_SVT_STRING;
1629 case 2: return D3D10_SVT_BLEND;
1630 case 3: return D3D10_SVT_DEPTHSTENCIL;
1631 case 4: return D3D10_SVT_RASTERIZER;
1632 case 5: return D3D10_SVT_PIXELSHADER;
1633 case 6: return D3D10_SVT_VERTEXSHADER;
1634 case 7: return D3D10_SVT_GEOMETRYSHADER;
1635 case 8:
1636 *flags = D3D10_EOT_FLAG_GS_SO;
1637 return D3D10_SVT_GEOMETRYSHADER;
1638
1639 case 9: return D3D10_SVT_TEXTURE;
1640 case 10: return D3D10_SVT_TEXTURE1D;
1641 case 11: return D3D10_SVT_TEXTURE1DARRAY;
1642 case 12: return D3D10_SVT_TEXTURE2D;
1643 case 13: return D3D10_SVT_TEXTURE2DARRAY;
1644 case 14: return D3D10_SVT_TEXTURE2DMS;
1645 case 15: return D3D10_SVT_TEXTURE2DMSARRAY;
1646 case 16: return D3D10_SVT_TEXTURE3D;
1647 case 17: return D3D10_SVT_TEXTURECUBE;
1648
1649 case 19: return D3D10_SVT_RENDERTARGETVIEW;
1650 case 20: return D3D10_SVT_DEPTHSTENCILVIEW;
1651 case 21: return D3D10_SVT_SAMPLER;
1652 case 22: return D3D10_SVT_BUFFER;
1653 default:
1654 FIXME("Unknown variable type %#x.\n", t);
1655 return D3D10_SVT_VOID;
1656 }
1657 }
1658 else
1659 {
1660 switch (t)
1661 {
1662 case 1: return D3D10_SVT_FLOAT;
1663 case 2: return D3D10_SVT_INT;
1664 case 3: return D3D10_SVT_UINT;
1665 case 4: return D3D10_SVT_BOOL;
1666 default:
1667 FIXME("Unknown variable type %#x.\n", t);
1668 return D3D10_SVT_VOID;
1669 }
1670 }
1671 }
1672
1673 static HRESULT parse_fx10_type(const char *data, size_t data_size, uint32_t offset, struct d3d10_effect_type *t)
1674 {
1675 uint32_t typeinfo, type_flags, type_kind;
1676 const char *ptr;
1677 unsigned int i;
1678
1679 if (offset >= data_size || !require_space(offset, 6, sizeof(DWORD), data_size))
1680 {
1681 WARN("Invalid offset %#x (data size %#Ix).\n", offset, data_size);
1682 return E_FAIL;
1683 }
1684
1685 ptr = data + offset;
1686 offset = read_u32(&ptr);
1687 TRACE("Type name at offset %#x.\n", offset);
1688
1689 if (!fx10_copy_string(data, data_size, offset, &t->name))
1690 {
1691 ERR("Failed to copy name.\n");
1692 return E_OUTOFMEMORY;
1693 }
1694 TRACE("Type name: %s.\n", debugstr_a(t->name));
1695
1696 type_kind = read_u32(&ptr);
1697 TRACE("Kind: %u.\n", type_kind);
1698
1699 t->element_count = read_u32(&ptr);
1700 TRACE("Element count: %u.\n", t->element_count);
1701
1702 t->size_unpacked = read_u32(&ptr);
1703 TRACE("Unpacked size: %#x.\n", t->size_unpacked);
1704
1705 t->stride = read_u32(&ptr);
1706 TRACE("Stride: %#x.\n", t->stride);
1707
1708 t->size_packed = read_u32(&ptr);
1709 TRACE("Packed size %#x.\n", t->size_packed);
1710
1711 switch (type_kind)
1712 {
1713 case 1:
1714 TRACE("Type is numeric.\n");
1715
1716 if (!require_space(ptr - data, 1, sizeof(typeinfo), data_size))
1717 {
1718 WARN("Invalid offset %#x (data size %#Ix).\n", offset, data_size);
1719 return E_FAIL;
1720 }
1721
1722 typeinfo = read_u32(&ptr);
1723 t->member_count = 0;
1724 t->column_count = (typeinfo & D3D10_FX10_TYPE_COLUMN_MASK) >> D3D10_FX10_TYPE_COLUMN_SHIFT;
1725 t->row_count = (typeinfo & D3D10_FX10_TYPE_ROW_MASK) >> D3D10_FX10_TYPE_ROW_SHIFT;
1726 t->basetype = d3d10_variable_type((typeinfo & D3D10_FX10_TYPE_BASETYPE_MASK)
1727 >> D3D10_FX10_TYPE_BASETYPE_SHIFT, FALSE, &type_flags);
1728 t->type_class = d3d10_variable_class((typeinfo & D3D10_FX10_TYPE_CLASS_MASK)
1729 >> D3D10_FX10_TYPE_CLASS_SHIFT, typeinfo & D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK);
1730
1731 TRACE("Type description: %#x.\n", typeinfo);
1732 TRACE("\tcolumns: %u.\n", t->column_count);
1733 TRACE("\trows: %u.\n", t->row_count);
1734 TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t->basetype));
1735 TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t->type_class));
1736 TRACE("\tunknown bits: %#x.\n", typeinfo & ~(D3D10_FX10_TYPE_COLUMN_MASK | D3D10_FX10_TYPE_ROW_MASK
1737 | D3D10_FX10_TYPE_BASETYPE_MASK | D3D10_FX10_TYPE_CLASS_MASK | D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK));
1738 break;
1739
1740 case 2:
1741 TRACE("Type is an object.\n");
1742
1743 if (!require_space(ptr - data, 1, sizeof(typeinfo), data_size))
1744 {
1745 WARN("Invalid offset %#x (data size %#Ix).\n", offset, data_size);
1746 return E_FAIL;
1747 }
1748
1749 typeinfo = read_u32(&ptr);
1750 t->member_count = 0;
1751 t->column_count = 0;
1752 t->row_count = 0;
1753 t->basetype = d3d10_variable_type(typeinfo, TRUE, &type_flags);
1754 t->type_class = D3D10_SVC_OBJECT;
1755 t->flags = type_flags;
1756
1757 TRACE("Type description: %#x.\n", typeinfo);
1758 TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t->basetype));
1759 TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t->type_class));
1760 TRACE("\tflags: %#x.\n", t->flags);
1761 break;
1762
1763 case 3:
1764 TRACE("Type is a structure.\n");
1765
1766 if (!require_space(ptr - data, 1, sizeof(t->member_count), data_size))
1767 {
1768 WARN("Invalid offset %#x (data size %#Ix).\n", offset, data_size);
1769 return E_FAIL;
1770 }
1771
1772 t->member_count = read_u32(&ptr);
1773 TRACE("Member count: %u.\n", t->member_count);
1774
1775 t->column_count = 0;
1776 t->row_count = 0;
1777 t->basetype = 0;
1778 t->type_class = D3D10_SVC_STRUCT;
1779
1780 if (!(t->members = calloc(t->member_count, sizeof(*t->members))))
1781 {
1782 ERR("Failed to allocate members memory.\n");
1783 return E_OUTOFMEMORY;
1784 }
1785
1786 if (!require_space(ptr - data, t->member_count, 4 * sizeof(DWORD), data_size))
1787 {
1788 WARN("Invalid member count %#x (data size %#Ix, offset %#x).\n",
1789 t->member_count, data_size, offset);
1790 return E_FAIL;
1791 }
1792
1793 for (i = 0; i < t->member_count; ++i)
1794 {
1795 struct d3d10_effect_type_member *typem = &t->members[i];
1796
1797 offset = read_u32(&ptr);
1798 TRACE("Member name at offset %#x.\n", offset);
1799
1800 if (!fx10_copy_string(data, data_size, offset, &typem->name))
1801 {
1802 ERR("Failed to copy name.\n");
1803 return E_OUTOFMEMORY;
1804 }
1805 TRACE("Member name: %s.\n", debugstr_a(typem->name));
1806
1807 offset = read_u32(&ptr);
1808 TRACE("Member semantic at offset %#x.\n", offset);
1809
1810 if (!fx10_copy_string(data, data_size, offset, &typem->semantic))
1811 {
1812 ERR("Failed to copy semantic.\n");
1813 return E_OUTOFMEMORY;
1814 }
1815 TRACE("Member semantic: %s.\n", debugstr_a(typem->semantic));
1816
1817 typem->buffer_offset = read_u32(&ptr);
1818 TRACE("Member offset in struct: %#x.\n", typem->buffer_offset);
1819
1820 offset = read_u32(&ptr);
1821 TRACE("Member type info at offset %#x.\n", offset);
1822
1823 if (!(typem->type = get_fx10_type(t->effect, data, data_size, offset)))
1824 {
1825 ERR("Failed to get variable type.\n");
1826 return E_FAIL;
1827 }
1828 }
1829 break;
1830
1831 default:
1832 FIXME("Unhandled type kind %#x.\n", type_kind);
1833 return E_FAIL;
1834 }
1835
1836 if (t->element_count)
1837 {
1838 TRACE("Elementtype for type at offset: %#lx\n", t->id);
1839
1840 /* allocate elementtype - we need only one, because all elements have the same type */
1841 if (!(t->elementtype = calloc(1, sizeof(*t->elementtype))))
1842 {
1843 ERR("Failed to allocate members memory.\n");
1844 return E_OUTOFMEMORY;
1845 }
1846
1847 /* create a copy of the original type with some minor changes */
1848 t->elementtype->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
1849 t->elementtype->effect = t->effect;
1850
1851 if (!copy_name(t->name, &t->elementtype->name))
1852 {
1853 ERR("Failed to copy name.\n");
1854 return E_OUTOFMEMORY;
1855 }
1856 TRACE("\tType name: %s.\n", debugstr_a(t->elementtype->name));
1857
1858 t->elementtype->element_count = 0;
1859 TRACE("\tElement count: %u.\n", t->elementtype->element_count);
1860
1861 /*
1862 * Not sure if this calculation is 100% correct, but a test
1863 * shows that these values work.
1864 */
1865 t->elementtype->size_unpacked = t->size_packed / t->element_count;
1866 TRACE("\tUnpacked size: %#x.\n", t->elementtype->size_unpacked);
1867
1868 t->elementtype->stride = t->stride;
1869 TRACE("\tStride: %#x.\n", t->elementtype->stride);
1870
1871 t->elementtype->size_packed = t->size_packed / t->element_count;
1872 TRACE("\tPacked size: %#x.\n", t->elementtype->size_packed);
1873
1874 t->elementtype->member_count = t->member_count;
1875 TRACE("\tMember count: %u.\n", t->elementtype->member_count);
1876
1877 t->elementtype->column_count = t->column_count;
1878 TRACE("\tColumns: %u.\n", t->elementtype->column_count);
1879
1880 t->elementtype->row_count = t->row_count;
1881 TRACE("\tRows: %u.\n", t->elementtype->row_count);
1882
1883 t->elementtype->basetype = t->basetype;
1884 TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(t->elementtype->basetype));
1885
1886 t->elementtype->type_class = t->type_class;
1887 TRACE("\tClass: %s.\n", debug_d3d10_shader_variable_class(t->elementtype->type_class));
1888
1889 t->elementtype->members = t->members;
1890 }
1891
1892 return S_OK;
1893 }
1894
1895 static struct d3d10_effect_type *get_fx10_type(struct d3d10_effect *effect, const char *data,
1896 size_t data_size, uint32_t offset)
1897 {
1898 struct d3d10_effect_type *type;
1899 struct wine_rb_entry *entry;
1900 HRESULT hr;
1901
1902 entry = wine_rb_get(&effect->types, &offset);
1903 if (entry)
1904 {
1905 TRACE("Returning existing type.\n");
1906 return WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
1907 }
1908
1909 if (!(type = calloc(1, sizeof(*type))))
1910 {
1911 ERR("Failed to allocate type memory.\n");
1912 return NULL;
1913 }
1914
1915 type->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
1916 type->id = offset;
1917 type->effect = effect;
1918 if (FAILED(hr = parse_fx10_type(data, data_size, offset, type)))
1919 {
1920 ERR("Failed to parse type info, hr %#lx.\n", hr);
1921 free(type);
1922 return NULL;
1923 }
1924
1925 if (wine_rb_put(&effect->types, &offset, &type->entry) == -1)
1926 {
1927 ERR("Failed to insert type entry.\n");
1928 free(type);
1929 return NULL;
1930 }
1931
1932 return type;
1933 }
1934
1935 static void set_variable_vtbl(struct d3d10_effect_variable *v)
1936 {
1937 const ID3D10EffectVariableVtbl **vtbl = &v->ID3D10EffectVariable_iface.lpVtbl;
1938
1939 switch (v->type->type_class)
1940 {
1941 case D3D10_SVC_SCALAR:
1942 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl;
1943 break;
1944
1945 case D3D10_SVC_VECTOR:
1946 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl;
1947 break;
1948
1949 case D3D10_SVC_MATRIX_ROWS:
1950 case D3D10_SVC_MATRIX_COLUMNS:
1951 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl;
1952 break;
1953
1954 case D3D10_SVC_STRUCT:
1955 *vtbl = &d3d10_effect_variable_vtbl;
1956 break;
1957
1958 case D3D10_SVC_OBJECT:
1959 switch(v->type->basetype)
1960 {
1961 case D3D10_SVT_STRING:
1962 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl;
1963 break;
1964
1965 case D3D10_SVT_TEXTURE:
1966 case D3D10_SVT_TEXTURE1D:
1967 case D3D10_SVT_TEXTURE1DARRAY:
1968 case D3D10_SVT_TEXTURE2D:
1969 case D3D10_SVT_TEXTURE2DARRAY:
1970 case D3D10_SVT_TEXTURE2DMS:
1971 case D3D10_SVT_TEXTURE2DMSARRAY:
1972 case D3D10_SVT_TEXTURE3D:
1973 case D3D10_SVT_TEXTURECUBE:
1974 case D3D10_SVT_BUFFER: /* Either resource or constant buffer. */
1975 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl;
1976 break;
1977
1978 case D3D10_SVT_RENDERTARGETVIEW:
1979 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl;
1980 break;
1981
1982 case D3D10_SVT_DEPTHSTENCILVIEW:
1983 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl;
1984 break;
1985
1986 case D3D10_SVT_DEPTHSTENCIL:
1987 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl;
1988 break;
1989
1990 case D3D10_SVT_VERTEXSHADER:
1991 case D3D10_SVT_GEOMETRYSHADER:
1992 case D3D10_SVT_PIXELSHADER:
1993 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl;
1994 break;
1995
1996 case D3D10_SVT_BLEND:
1997 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl;
1998 break;
1999
2000 case D3D10_SVT_RASTERIZER:
2001 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl;
2002 break;
2003
2004 case D3D10_SVT_SAMPLER:
2005 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl;
2006 break;
2007
2008 default:
2009 FIXME("Unhandled basetype %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
2010 *vtbl = &d3d10_effect_variable_vtbl;
2011 break;
2012 }
2013 break;
2014
2015 default:
2016 FIXME("Unhandled type class %s.\n", debug_d3d10_shader_variable_class(v->type->type_class));
2017 *vtbl = &d3d10_effect_variable_vtbl;
2018 break;
2019 }
2020 }
2021
2022 static HRESULT copy_variableinfo_from_type(struct d3d10_effect_variable *v)
2023 {
2024 unsigned int i;
2025 HRESULT hr;
2026
2027 if (v->type->member_count)
2028 {
2029 if (!(v->members = calloc(v->type->member_count, sizeof(*v->members))))
2030 {
2031 ERR("Failed to allocate members memory.\n");
2032 return E_OUTOFMEMORY;
2033 }
2034
2035 for (i = 0; i < v->type->member_count; ++i)
2036 {
2037 struct d3d10_effect_variable *var = &v->members[i];
2038 struct d3d10_effect_type_member *typem = &v->type->members[i];
2039
2040 var->buffer = v->buffer;
2041 var->effect = v->effect;
2042 var->type = typem->type;
2043 set_variable_vtbl(var);
2044
2045 if (!copy_name(typem->name, &var->name))
2046 {
2047 ERR("Failed to copy name.\n");
2048 return E_OUTOFMEMORY;
2049 }
2050 TRACE("Variable name: %s.\n", debugstr_a(var->name));
2051
2052 if (!copy_name(typem->semantic, &var->semantic))
2053 {
2054 ERR("Failed to copy name.\n");
2055 return E_OUTOFMEMORY;
2056 }
2057 TRACE("Variable semantic: %s.\n", debugstr_a(var->semantic));
2058
2059 var->buffer_offset = v->buffer_offset + typem->buffer_offset;
2060 TRACE("Variable buffer offset: %u.\n", var->buffer_offset);
2061
2062 hr = copy_variableinfo_from_type(var);
2063 if (FAILED(hr)) return hr;
2064 }
2065 }
2066
2067 if (v->type->element_count)
2068 {
2069 unsigned int bufferoffset = v->buffer_offset;
2070
2071 if (!(v->elements = calloc(v->type->element_count, sizeof(*v->elements))))
2072 {
2073 ERR("Failed to allocate elements memory.\n");
2074 return E_OUTOFMEMORY;
2075 }
2076
2077 for (i = 0; i < v->type->element_count; ++i)
2078 {
2079 struct d3d10_effect_variable *var = &v->elements[i];
2080
2081 var->buffer = v->buffer;
2082 var->effect = v->effect;
2083 var->type = v->type->elementtype;
2084 set_variable_vtbl(var);
2085
2086 if (!copy_name(v->name, &var->name))
2087 {
2088 ERR("Failed to copy name.\n");
2089 return E_OUTOFMEMORY;
2090 }
2091 TRACE("Variable name: %s.\n", debugstr_a(var->name));
2092
2093 if (!copy_name(v->semantic, &var->semantic))
2094 {
2095 ERR("Failed to copy name.\n");
2096 return E_OUTOFMEMORY;
2097 }
2098 TRACE("Variable semantic: %s.\n", debugstr_a(var->semantic));
2099
2100 if (i != 0)
2101 {
2102 bufferoffset += v->type->stride;
2103 }
2104 var->buffer_offset = bufferoffset;
2105 TRACE("Variable buffer offset: %u.\n", var->buffer_offset);
2106
2107 hr = copy_variableinfo_from_type(var);
2108 if (FAILED(hr)) return hr;
2109 }
2110 }
2111
2112 return S_OK;
2113 }
2114
2115 static HRESULT parse_fx10_variable_head(const char *data, size_t data_size,
2116 const char **ptr, struct d3d10_effect_variable *v)
2117 {
2118 uint32_t offset;
2119
2120 offset = read_u32(ptr);
2121 TRACE("Variable name at offset %#x.\n", offset);
2122
2123 if (!fx10_copy_string(data, data_size, offset, &v->name))
2124 {
2125 ERR("Failed to copy name.\n");
2126 return E_OUTOFMEMORY;
2127 }
2128 TRACE("Variable name: %s.\n", debugstr_a(v->name));
2129
2130 offset = read_u32(ptr);
2131 TRACE("Variable type info at offset %#x.\n", offset);
2132
2133 if (!(v->type = get_fx10_type(v->effect, data, data_size, offset)))
2134 {
2135 ERR("Failed to get variable type.\n");
2136 return E_FAIL;
2137 }
2138 set_variable_vtbl(v);
2139
2140 v->explicit_bind_point = ~0u;
2141
2142 if (v->effect->flags & D3D10_EFFECT_IS_POOL)
2143 v->flag |= D3D10_EFFECT_VARIABLE_POOLED;
2144
2145 return copy_variableinfo_from_type(v);
2146 }
2147
2148 static HRESULT parse_fx10_annotation(const char *data, size_t data_size,
2149 const char **ptr, struct d3d10_effect_variable *a)
2150 {
2151 uint32_t offset;
2152 HRESULT hr;
2153
2154 if (FAILED(hr = parse_fx10_variable_head(data, data_size, ptr, a)))
2155 return hr;
2156
2157 offset = read_u32(ptr);
2158 TRACE("Annotation value is at offset %#x.\n", offset);
2159
2160 switch (a->type->basetype)
2161 {
2162 case D3D10_SVT_STRING:
2163 if (!fx10_copy_string(data, data_size, offset, (char **)&a->u.buffer.local_buffer))
2164 {
2165 ERR("Failed to copy name.\n");
2166 return E_OUTOFMEMORY;
2167 }
2168 break;
2169
2170 default:
2171 FIXME("Unhandled object type %#x.\n", a->type->basetype);
2172 }
2173
2174 /* mark the variable as annotation */
2175 a->flag |= D3D10_EFFECT_VARIABLE_ANNOTATION;
2176
2177 return S_OK;
2178 }
2179
2180 static HRESULT parse_fx10_annotations(const char *data, size_t data_size, const char **ptr,
2181 struct d3d10_effect *effect, struct d3d10_effect_annotations *annotations)
2182 {
2183 unsigned int i;
2184 HRESULT hr;
2185
2186 if (!(annotations->elements = calloc(annotations->count, sizeof(*annotations->elements))))
2187 {
2188 ERR("Failed to allocate annotations memory.\n");
2189 return E_OUTOFMEMORY;
2190 }
2191
2192 for (i = 0; i < annotations->count; ++i)
2193 {
2194 struct d3d10_effect_variable *a = &annotations->elements[i];
2195
2196 a->effect = effect;
2197 a->buffer = &null_local_buffer;
2198
2199 if (FAILED(hr = parse_fx10_annotation(data, data_size, ptr, a)))
2200 return hr;
2201 }
2202
2203 return hr;
2204 }
2205
2206 static HRESULT parse_fx10_anonymous_shader(struct d3d10_effect *e, D3D_SHADER_VARIABLE_TYPE basetype,
2207 struct d3d10_effect_anonymous_shader *s)
2208 {
2209 struct d3d10_effect_variable *v = &s->shader;
2210 struct d3d10_effect_type *t = &s->type;
2211 const char *name = NULL;
2212
2213 switch (basetype)
2214 {
2215 case D3D10_SVT_VERTEXSHADER:
2216 name = "vertexshader";
2217 break;
2218
2219 case D3D10_SVT_PIXELSHADER:
2220 name = "pixelshader";
2221 break;
2222
2223 case D3D10_SVT_GEOMETRYSHADER:
2224 name = "geometryshader";
2225 break;
2226
2227 default:
2228 WARN("Unhandled shader type %#x.\n", basetype);
2229 return E_FAIL;
2230 }
2231 t->basetype = basetype;
2232
2233 if (!copy_name(name, &t->name))
2234 {
2235 ERR("Failed to copy name.\n");
2236 return E_OUTOFMEMORY;
2237 }
2238 TRACE("Type name: %s.\n", debugstr_a(t->name));
2239
2240 t->type_class = D3D10_SVC_OBJECT;
2241
2242 t->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
2243
2244 v->type = t;
2245 v->effect = e;
2246 v->u.shader.isinline = 1;
2247 set_variable_vtbl(v);
2248
2249 if (!copy_name("$Anonymous", &v->name))
2250 {
2251 ERR("Failed to copy semantic.\n");
2252 return E_OUTOFMEMORY;
2253 }
2254 TRACE("Variable name: %s.\n", debugstr_a(v->name));
2255
2256 return S_OK;
2257 }
2258
2259 static const struct d3d10_effect_state_storage_info *get_storage_info(D3D_SHADER_VARIABLE_TYPE id)
2260 {
2261 unsigned int i;
2262
2263 for (i = 0; i < ARRAY_SIZE(d3d10_effect_state_storage_info); ++i)
2264 {
2265 if (d3d10_effect_state_storage_info[i].id == id)
2266 return &d3d10_effect_state_storage_info[i];
2267 }
2268
2269 return NULL;
2270 }
2271
2272 static BOOL read_value_list(const char *data, size_t data_size, uint32_t offset,
2273 D3D_SHADER_VARIABLE_TYPE out_type, unsigned int out_base, unsigned int out_size,
2274 void *out_data)
2275 {
2276 uint32_t t, value, count, type_flags;
2277 D3D_SHADER_VARIABLE_TYPE in_type;
2278 const char *ptr;
2279 unsigned int i;
2280
2281 if (offset >= data_size || !require_space(offset, 1, sizeof(count), data_size))
2282 {
2283 WARN("Invalid offset %#x (data size %#Ix).\n", offset, data_size);
2284 return FALSE;
2285 }
2286
2287 ptr = data + offset;
2288 count = read_u32(&ptr);
2289 if (count != out_size)
2290 return FALSE;
2291
2292 if (!require_space(ptr - data, count, 2 * sizeof(DWORD), data_size))
2293 {
2294 WARN("Invalid value count %#x (offset %#x, data size %#Ix).\n", count, offset, data_size);
2295 return FALSE;
2296 }
2297
2298 TRACE("%u values:\n", count);
2299 for (i = 0; i < count; ++i)
2300 {
2301 unsigned int out_idx = out_base * out_size + i;
2302
2303 t = read_u32(&ptr);
2304 value = read_u32(&ptr);
2305
2306 in_type = d3d10_variable_type(t, FALSE, &type_flags);
2307 TRACE("\t%s: %#x.\n", debug_d3d10_shader_variable_type(in_type), value);
2308
2309 switch (out_type)
2310 {
2311 case D3D10_SVT_FLOAT:
2312 case D3D10_SVT_INT:
2313 case D3D10_SVT_UINT:
2314 case D3D10_SVT_UINT8:
2315 case D3D10_SVT_BOOL:
2316 if (!d3d10_effect_read_numeric_value(value, in_type, out_type, out_data, out_idx))
2317 return FALSE;
2318 break;
2319
2320 case D3D10_SVT_VERTEXSHADER:
2321 *(void **)out_data = &anonymous_vs;
2322 break;
2323
2324 case D3D10_SVT_PIXELSHADER:
2325 *(void **)out_data = &anonymous_ps;
2326 break;
2327
2328 case D3D10_SVT_GEOMETRYSHADER:
2329 *(void **)out_data = &anonymous_gs;
2330 break;
2331
2332 case D3D10_SVT_TEXTURE:
2333 *(void **)out_data = &null_shader_resource_variable;
2334 break;
2335
2336 case D3D10_SVT_DEPTHSTENCIL:
2337 *(void **)out_data = &null_depth_stencil_variable;
2338 break;
2339
2340 case D3D10_SVT_BLEND:
2341 *(void **)out_data = &null_blend_variable;
2342 break;
2343
2344 default:
2345 FIXME("Unhandled out_type %#x.\n", out_type);
2346 return FALSE;
2347 }
2348 }
2349
2350 return TRUE;
2351 }
2352
2353 static BOOL is_object_property(const struct d3d10_effect_state_property_info *property_info)
2354 {
2355 switch (property_info->type)
2356 {
2357 case D3D10_SVT_RASTERIZER:
2358 case D3D10_SVT_DEPTHSTENCIL:
2359 case D3D10_SVT_BLEND:
2360 case D3D10_SVT_RENDERTARGETVIEW:
2361 case D3D10_SVT_DEPTHSTENCILVIEW:
2362 case D3D10_SVT_VERTEXSHADER:
2363 case D3D10_SVT_PIXELSHADER:
2364 case D3D10_SVT_GEOMETRYSHADER:
2365 case D3D10_SVT_TEXTURE:
2366 return TRUE;
2367 default:
2368 return FALSE;
2369 }
2370 }
2371
2372 static BOOL is_object_property_type_matching(const struct d3d10_effect_state_property_info *property_info,
2373 const struct d3d10_effect_variable *v)
2374 {
2375 if (property_info->type == v->type->basetype) return TRUE;
2376
2377 switch (v->type->basetype)
2378 {
2379 case D3D10_SVT_TEXTURE1D:
2380 case D3D10_SVT_TEXTURE1DARRAY:
2381 case D3D10_SVT_TEXTURE2D:
2382 case D3D10_SVT_TEXTURE2DARRAY:
2383 case D3D10_SVT_TEXTURE2DMS:
2384 case D3D10_SVT_TEXTURE2DMSARRAY:
2385 case D3D10_SVT_TEXTURE3D:
2386 case D3D10_SVT_TEXTURECUBE:
2387 if (property_info->type == D3D10_SVT_TEXTURE) return TRUE;
2388 /* fallthrough */
2389 default:
2390 return FALSE;
2391 }
2392 }
2393
2394 static HRESULT parse_fx10_preshader_instr(struct d3d10_preshader_parse_context *context,
2395 unsigned int *offset, const char **ptr, unsigned int data_size)
2396 {
2397 const struct preshader_op_info *op_info;
2398 unsigned int i, param_count, size;
2399 struct preshader_instr ins;
2400 uint32_t input_count;
2401
2402 if (!require_space(*offset, 2, sizeof(uint32_t), data_size))
2403 {
2404 WARN("Malformed FXLC table, size %u.\n", data_size);
2405 return E_FAIL;
2406 }
2407
2408 *(uint32_t *)&ins = read_u32(ptr);
2409 input_count = read_u32(ptr);
2410 *offset += 2 * sizeof(uint32_t);
2411
2412 if (!(op_info = d3d10_effect_get_op_info(ins.opcode)))
2413 {
2414 FIXME("Unrecognized opcode %#x.\n", ins.opcode);
2415 return E_FAIL;
2416 }
2417
2418 TRACE("Opcode %#x (%s) (%u,%u), input count %u.\n", ins.opcode, op_info->name,
2419 ins.comp_count, ins.scalar, input_count);
2420
2421 /* Inputs + one output */
2422 param_count = input_count + 1;
2423
2424 if (!require_space(*offset, 3 * param_count, sizeof(uint32_t), data_size))
2425 {
2426 WARN("Malformed FXLC table, opcode %#x.\n", ins.opcode);
2427 return E_FAIL;
2428 }
2429 *offset += 3 * param_count * sizeof(uint32_t);
2430
2431 for (i = 0; i < param_count; ++i)
2432 {
2433 uint32_t flags, regt, param_offset;
2434
2435 flags = read_u32(ptr);
2436 if (flags)
2437 {
2438 FIXME("Argument flags are not supported %#x.\n", flags);
2439 return E_UNEXPECTED;
2440 }
2441
2442 regt = read_u32(ptr);
2443 param_offset = read_u32(ptr);
2444
2445 switch (regt)
2446 {
2447 case D3D10_REG_TABLE_CONSTANTS:
2448 case D3D10_REG_TABLE_CB:
2449 case D3D10_REG_TABLE_RESULT:
2450 case D3D10_REG_TABLE_TEMP:
2451 size = param_offset + (ins.scalar && i == 0 ? 1 : ins.comp_count);
2452 context->table_sizes[regt] = max(context->table_sizes[regt], size);
2453 break;
2454 default:
2455 FIXME("Unexpected register table index %u.\n", regt);
2456 break;
2457 }
2458 }
2459
2460 return S_OK;
2461 }
2462
2463 static HRESULT parse_fx10_fxlc(void *ctx, const char *data, unsigned int data_size)
2464 {
2465 struct d3d10_preshader_parse_context *context = ctx;
2466 struct d3d10_effect_preshader *p = context->preshader;
2467 unsigned int i, offset = 4;
2468 uint32_t ins_count;
2469 const char *ptr;
2470 HRESULT hr;
2471
2472 if (data_size % sizeof(uint32_t))
2473 {
2474 WARN("FXLC size misaligned %u.\n", data_size);
2475 return E_FAIL;
2476 }
2477
2478 if (FAILED(hr = D3DCreateBlob(data_size, &p->code)))
2479 return hr;
2480 memcpy(ID3D10Blob_GetBufferPointer(p->code), data, data_size);
2481
2482 ptr = data;
2483 ins_count = read_u32(&ptr);
2484 TRACE("%u instructions.\n", ins_count);
2485
2486 for (i = 0; i < ins_count; ++i)
2487 {
2488 if (FAILED(hr = parse_fx10_preshader_instr(context, &offset, &ptr, data_size)))
2489 {
2490 WARN("Failed to parse instruction %u.\n", i);
2491 return hr;
2492 }
2493 }
2494
2495 if (FAILED(hr = d3d10_reg_table_allocate(&p->reg_tables[D3D10_REG_TABLE_RESULT],
2496 context->table_sizes[D3D10_REG_TABLE_RESULT]))) return hr;
2497 if (FAILED(hr = d3d10_reg_table_allocate(&p->reg_tables[D3D10_REG_TABLE_TEMP],
2498 context->table_sizes[D3D10_REG_TABLE_TEMP]))) return hr;
2499
2500 return S_OK;
2501 }
2502
2503 static HRESULT parse_fx10_cli4(void *ctx, const char *data, unsigned int data_size)
2504 {
2505 struct d3d10_preshader_parse_context *context = ctx;
2506 struct d3d10_effect_preshader *p = context->preshader;
2507 struct d3d10_reg_table *table = &p->reg_tables[D3D10_REG_TABLE_CONSTANTS];
2508 const char *ptr = data;
2509 uint32_t count;
2510 HRESULT hr;
2511
2512 if (data_size < sizeof(DWORD))
2513 {
2514 WARN("Invalid CLI4 chunk size %u.\n", data_size);
2515 return E_FAIL;
2516 }
2517
2518 count = read_u32(&ptr);
2519
2520 TRACE("%u literal constants.\n", count);
2521
2522 if (!require_space(4, count, sizeof(float), data_size))
2523 {
2524 WARN("Invalid constant table size %u.\n", data_size);
2525 return E_FAIL;
2526 }
2527
2528 if (FAILED(hr = d3d10_reg_table_allocate(table, count)))
2529 return hr;
2530
2531 memcpy(table->f, ptr, table->count * sizeof(*table->f));
2532
2533 return S_OK;
2534 }
2535
2536 static HRESULT parse_fx10_ctab(void *ctx, const char *data, unsigned int data_size)
2537 {
2538 struct d3d10_preshader_parse_context *context = ctx;
2539 struct d3d10_effect_preshader *p = context->preshader;
2540 struct ctab_header
2541 {
2542 uint32_t size;
2543 uint32_t creator;
2544 uint32_t version;
2545 uint32_t constants;
2546 uint32_t constantinfo;
2547 uint32_t flags;
2548 uint32_t target;
2549 } header;
2550 struct ctab_const_info
2551 {
2552 uint32_t name;
2553 WORD register_set;
2554 WORD register_index;
2555 WORD register_count;
2556 WORD reserved;
2557 uint32_t typeinfo;
2558 uint32_t default_value;
2559 } *info;
2560 unsigned int i, cb_reg_count = 0;
2561 const char *ptr = data;
2562 const char *name;
2563 size_t name_len;
2564 HRESULT hr;
2565
2566 if (data_size < sizeof(header))
2567 {
2568 WARN("Invalid constant table size %u.\n", data_size);
2569 return E_FAIL;
2570 }
2571
2572 header.size = read_u32(&ptr);
2573 header.creator = read_u32(&ptr);
2574 header.version = read_u32(&ptr);
2575 header.constants = read_u32(&ptr);
2576 header.constantinfo = read_u32(&ptr);
2577 header.flags = read_u32(&ptr);
2578 header.target = read_u32(&ptr);
2579
2580 if (!require_space(header.constantinfo, header.constants, sizeof(*info), data_size))
2581 {
2582 WARN("Invalid constant info section offset %#x.\n", header.constantinfo);
2583 return E_FAIL;
2584 }
2585
2586 p->vars_count = header.constants;
2587
2588 TRACE("Variable count %u.\n", p->vars_count);
2589
2590 if (!(p->vars = calloc(p->vars_count, sizeof(*p->vars))))
2591 return E_OUTOFMEMORY;
2592
2593 info = (struct ctab_const_info *)(data + header.constantinfo);
2594 for (i = 0; i < p->vars_count; ++i, ++info)
2595 {
2596 if (!fx10_get_string(data, data_size, info->name, &name, &name_len))
2597 return E_FAIL;
2598
2599 if (!(p->vars[i].v = d3d10_effect_get_variable_by_name(context->effect, name)))
2600 {
2601 WARN("Couldn't find variable %s.\n", debugstr_a(name));
2602 return E_FAIL;
2603 }
2604
2605 /* 4 components per register */
2606 p->vars[i].offset = info->register_index * 4;
2607 p->vars[i].length = info->register_count * 4;
2608
2609 cb_reg_count = max(cb_reg_count, info->register_index + info->register_count);
2610 }
2611
2612 /* Allocate contiguous "constant buffer" for all referenced variables. */
2613 if (FAILED(hr = d3d10_reg_table_allocate(&p->reg_tables[D3D10_REG_TABLE_CB], cb_reg_count * 4)))
2614 {
2615 WARN("Failed to allocate variables buffer.\n");
2616 return hr;
2617 }
2618
2619 return S_OK;
2620 }
2621
2622 static HRESULT fxlvm_chunk_handler(const char *data, size_t data_size, uint32_t tag, void *ctx)
2623 {
2624 TRACE("Chunk tag: %s, size: %Iu.\n", debugstr_an((const char *)&tag, 4), data_size);
2625
2626 switch (tag)
2627 {
2628 case TAG_FXLC:
2629 return parse_fx10_fxlc(ctx, data, data_size);
2630
2631 case TAG_CLI4:
2632 return parse_fx10_cli4(ctx, data, data_size);
2633
2634 case TAG_CTAB:
2635 return parse_fx10_ctab(ctx, data, data_size);
2636
2637 default:
2638 FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
2639 return S_OK;
2640 }
2641 }
2642
2643 static HRESULT parse_fx10_preshader(const char *data, size_t data_size,
2644 struct d3d10_effect *effect, struct d3d10_effect_preshader *preshader)
2645 {
2646 struct d3d10_preshader_parse_context context;
2647 HRESULT hr;
2648
2649 memset(preshader, 0, sizeof(*preshader));
2650 memset(&context, 0, sizeof(context));
2651 context.preshader = preshader;
2652 context.effect = effect;
2653
2654 if (FAILED(hr = parse_dxbc(data, data_size, fxlvm_chunk_handler, &context)))
2655 return hr;
2656
2657 /* Constant buffer and literal constants are preallocated, validate here that expression
2658 has no invalid accesses for those. */
2659
2660 if (context.table_sizes[D3D10_REG_TABLE_CONSTANTS] >
2661 preshader->reg_tables[D3D10_REG_TABLE_CONSTANTS].count)
2662 {
2663 WARN("Expression references out of bounds literal constant.\n");
2664 return E_FAIL;
2665 }
2666
2667 if (context.table_sizes[D3D10_REG_TABLE_CB] > preshader->reg_tables[D3D10_REG_TABLE_CB].count)
2668 {
2669 WARN("Expression references out of bounds variable.\n");
2670 return E_FAIL;
2671 }
2672
2673 return S_OK;
2674 }
2675
2676 static HRESULT d3d10_effect_add_prop_dependency(struct d3d10_effect_prop_dependencies *d,
2677 const struct d3d10_effect_prop_dependency *dep)
2678 {
2679 if (!d3d_array_reserve((void **)&d->entries, &d->capacity, d->count + 1, sizeof(*d->entries)))
2680 return E_OUTOFMEMORY;
2681
2682 d->entries[d->count++] = *dep;
2683
2684 return S_OK;
2685 }
2686
2687 static HRESULT parse_fx10_property_assignment(const char *data, size_t data_size,
2688 const char **ptr, enum d3d10_effect_container_type container_type,
2689 struct d3d10_effect *effect, void *container, struct d3d10_effect_prop_dependencies *d)
2690 {
2691 uint32_t id, idx, variable_idx, operation, value_offset, sodecl_offset;
2692 const struct d3d10_effect_state_property_info *property_info;
2693 struct d3d10_effect_prop_dependency dep;
2694 struct d3d10_effect_variable *variable;
2695 uint32_t code_offset, blob_size;
2696 const char *data_ptr, *name;
2697 unsigned int *dst_index;
2698 size_t name_len;
2699 HRESULT hr;
2700 void *dst;
2701
2702 id = read_u32(ptr);
2703 idx = read_u32(ptr);
2704 operation = read_u32(ptr);
2705 value_offset = read_u32(ptr);
2706
2707 if (id >= ARRAY_SIZE(property_infos))
2708 {
2709 FIXME("Unknown property id %#x.\n", id);
2710 return E_FAIL;
2711 }
2712 property_info = &property_infos[id];
2713
2714 TRACE("Property %s[%#x] = value list @ offset %#x.\n", property_info->name, idx, value_offset);
2715
2716 if (property_info->container_type != container_type)
2717 {
2718 ERR("Invalid container type %#x for property %#x.\n", container_type, id);
2719 return E_FAIL;
2720 }
2721
2722 if (idx >= property_info->count)
2723 {
2724 ERR("Invalid index %#x for property %#x.\n", idx, id);
2725 return E_FAIL;
2726 }
2727
2728 if (property_info->offset == ~0u)
2729 {
2730 ERR("Unsupported property %#x.\n", id);
2731 return E_NOTIMPL;
2732 }
2733
2734 dst = (char *)container + property_info->offset;
2735 dst_index = (unsigned int *)((char *)container + property_info->index_offset);
2736
2737 switch (operation)
2738 {
2739 case D3D10_EOO_CONST:
2740
2741 /* Constant values output directly to backing store. */
2742 if (!read_value_list(data, data_size, value_offset, property_info->type, idx,
2743 property_info->size, dst))
2744 {
2745 ERR("Failed to read values for property %#x.\n", id);
2746 return E_FAIL;
2747 }
2748 break;
2749
2750 case D3D10_EOO_VAR:
2751
2752 /* Variable. */
2753 if (!fx10_get_string(data, data_size, value_offset, &name, &name_len))
2754 {
2755 WARN("Failed to get variable name.\n");
2756 return E_FAIL;
2757 }
2758 TRACE("Variable name %s.\n", debugstr_a(name));
2759
2760 if (!(variable = d3d10_effect_get_variable_by_name(effect, name)))
2761 {
2762 WARN("Couldn't find variable %s.\n", debugstr_a(name));
2763 return E_FAIL;
2764 }
2765
2766 if (is_object_property(property_info))
2767 {
2768 if (variable->type->element_count)
2769 {
2770 WARN("Unexpected array variable value %s.\n", debugstr_a(name));
2771 return E_FAIL;
2772 }
2773
2774 if (!is_object_property_type_matching(property_info, variable))
2775 {
2776 WARN("Object type mismatch. Variable type %#x, property type %#x.\n",
2777 variable->type->basetype, property_info->type);
2778 return E_FAIL;
2779 }
2780
2781 ((void **)dst)[idx] = variable;
2782 }
2783 else
2784 {
2785 if (property_info->size * sizeof(float) > variable->type->size_unpacked)
2786 {
2787 WARN("Mismatching variable size %u, property size %u.\n",
2788 variable->type->size_unpacked, property_info->size);
2789 return E_FAIL;
2790 }
2791
2792 dep.id = id;
2793 dep.idx = idx;
2794 dep.operation = operation;
2795 dep.var.v = variable;
2796 dep.var.offset = 0;
2797
2798 return d3d10_effect_add_prop_dependency(d, &dep);
2799 }
2800
2801 break;
2802
2803 case D3D10_EOO_CONST_INDEX:
2804
2805 /* Array variable, constant index. */
2806 if (value_offset >= data_size || !require_space(value_offset, 2, sizeof(DWORD), data_size))
2807 {
2808 WARN("Invalid offset %#x (data size %#Ix).\n", value_offset, data_size);
2809 return E_FAIL;
2810 }
2811 data_ptr = data + value_offset;
2812 value_offset = read_u32(&data_ptr);
2813 variable_idx = read_u32(&data_ptr);
2814
2815 if (!fx10_get_string(data, data_size, value_offset, &name, &name_len))
2816 {
2817 WARN("Failed to get variable name.\n");
2818 return E_FAIL;
2819 }
2820
2821 TRACE("Variable name %s[%s%u].\n", debugstr_a(name), is_object_property(property_info) ?
2822 "" : "offset ", variable_idx);
2823
2824 if (!(variable = d3d10_effect_get_variable_by_name(effect, name)))
2825 {
2826 WARN("Couldn't find variable %s.\n", debugstr_a(name));
2827 return E_FAIL;
2828 }
2829
2830 if (is_object_property(property_info))
2831 {
2832 if (!variable->type->element_count || variable_idx >= variable->type->element_count)
2833 {
2834 WARN("Invalid array size %u.\n", variable->type->element_count);
2835 return E_FAIL;
2836 }
2837
2838 if (!is_object_property_type_matching(property_info, variable))
2839 {
2840 WARN("Object type mismatch. Variable type %#x, property type %#x.\n",
2841 variable->type->basetype, property_info->type);
2842 return E_FAIL;
2843 }
2844
2845 /* Shader variables are special, they are referenced via array, with index stored separately. */
2846 switch (property_info->type)
2847 {
2848 case D3D10_SVT_VERTEXSHADER:
2849 case D3D10_SVT_PIXELSHADER:
2850 case D3D10_SVT_GEOMETRYSHADER:
2851 ((void **)dst)[idx] = variable;
2852 *dst_index = variable_idx;
2853 break;
2854 default:
2855 ((void **)dst)[idx] = &variable->elements[variable_idx];
2856 }
2857 }
2858 else
2859 {
2860 unsigned int offset = variable_idx * sizeof(float);
2861
2862 if (offset >= variable->type->size_unpacked ||
2863 variable->type->size_unpacked - offset < property_info->size * sizeof(float))
2864 {
2865 WARN("Invalid numeric variable data offset %u.\n", variable_idx);
2866 return E_FAIL;
2867 }
2868
2869 dep.id = id;
2870 dep.idx = idx;
2871 dep.operation = operation;
2872 dep.var.v = variable;
2873 dep.var.offset = offset;
2874
2875 return d3d10_effect_add_prop_dependency(d, &dep);
2876 }
2877
2878 break;
2879
2880 case D3D10_EOO_INDEX_EXPRESSION:
2881
2882 /* Variable, and an expression for its index. */
2883 if (value_offset >= data_size || !require_space(value_offset, 2, sizeof(DWORD), data_size))
2884 {
2885 WARN("Invalid offset %#x (data size %#Ix).\n", value_offset, data_size);
2886 return E_FAIL;
2887 }
2888
2889 data_ptr = data + value_offset;
2890 value_offset = read_u32(&data_ptr);
2891 code_offset = read_u32(&data_ptr);
2892
2893 if (!fx10_get_string(data, data_size, value_offset, &name, &name_len))
2894 {
2895 WARN("Failed to get variable name.\n");
2896 return E_FAIL;
2897 }
2898
2899 TRACE("Variable name %s[<expr>].\n", debugstr_a(name));
2900
2901 if (!(variable = d3d10_effect_get_variable_by_name(effect, name)))
2902 {
2903 WARN("Couldn't find variable %s.\n", debugstr_a(name));
2904 return E_FAIL;
2905 }
2906
2907 if (!variable->type->element_count)
2908 {
2909 WARN("Expected array variable.\n");
2910 return E_FAIL;
2911 }
2912
2913 if (!is_object_property(property_info))
2914 {
2915 WARN("Expected object type property used with indexed expression.\n");
2916 return E_FAIL;
2917 }
2918
2919 if (code_offset >= data_size || !require_space(code_offset, 1, sizeof(DWORD), data_size))
2920 {
2921 WARN("Invalid offset %#x (data size %#Ix).\n", value_offset, data_size);
2922 return E_FAIL;
2923 }
2924
2925 data_ptr = data + code_offset;
2926 blob_size = read_u32(&data_ptr);
2927
2928 if (!require_space(code_offset, 1, sizeof(uint32_t) + blob_size, data_size))
2929 {
2930 WARN("Invalid offset %#x (data size %#Ix).\n", code_offset, data_size);
2931 return E_FAIL;
2932 }
2933
2934 dep.id = id;
2935 dep.idx = idx;
2936 dep.operation = operation;
2937 dep.index_expr.v = variable;
2938 if (FAILED(hr = parse_fx10_preshader(data_ptr, blob_size, effect, &dep.index_expr.index)))
2939 {
2940 WARN("Failed to parse preshader, hr %#lx.\n", hr);
2941 return hr;
2942 }
2943
2944 return d3d10_effect_add_prop_dependency(d, &dep);
2945
2946 case D3D10_EOO_VALUE_EXPRESSION:
2947
2948 if (value_offset >= data_size || !require_space(value_offset, 1, sizeof(uint32_t), data_size))
2949 {
2950 WARN("Invalid offset %#x (data size %#Ix).\n", value_offset, data_size);
2951 return E_FAIL;
2952 }
2953
2954 data_ptr = data + value_offset;
2955 blob_size = read_u32(&data_ptr);
2956
2957 if (!require_space(value_offset, 1, sizeof(uint32_t) + blob_size, data_size))
2958 {
2959 WARN("Invalid offset %#x (data size %#Ix).\n", value_offset, data_size);
2960 return E_FAIL;
2961 }
2962
2963 dep.id = id;
2964 dep.idx = idx;
2965 dep.operation = operation;
2966 if (FAILED(hr = parse_fx10_preshader(data_ptr, blob_size, effect, &dep.value_expr.value)))
2967 {
2968 WARN("Failed to parse preshader, hr %#lx.\n", hr);
2969 return hr;
2970 }
2971
2972 return d3d10_effect_add_prop_dependency(d, &dep);
2973
2974 case D3D10_EOO_ANONYMOUS_SHADER:
2975
2976 /* Anonymous shader */
2977 if (effect->anonymous_shader_current >= effect->anonymous_shader_count)
2978 {
2979 ERR("Anonymous shader count is wrong!\n");
2980 return E_FAIL;
2981 }
2982
2983 if (value_offset >= data_size || !require_space(value_offset, 2, sizeof(DWORD), data_size))
2984 {
2985 WARN("Invalid offset %#x (data size %#Ix).\n", value_offset, data_size);
2986 return E_FAIL;
2987 }
2988 data_ptr = data + value_offset;
2989 value_offset = read_u32(&data_ptr);
2990 sodecl_offset = read_u32(&data_ptr);
2991
2992 TRACE("Effect object starts at offset %#x.\n", value_offset);
2993
2994 if (FAILED(hr = parse_fx10_anonymous_shader(effect, property_info->type,
2995 &effect->anonymous_shaders[effect->anonymous_shader_current])))
2996 return hr;
2997
2998 variable = &effect->anonymous_shaders[effect->anonymous_shader_current].shader;
2999 ++effect->anonymous_shader_current;
3000
3001 if (sodecl_offset)
3002 {
3003 TRACE("Anonymous shader stream output declaration at offset %#x.\n", sodecl_offset);
3004 if (!fx10_copy_string(data, data_size, sodecl_offset,
3005 &variable->u.shader.stream_output_declaration))
3006 {
3007 ERR("Failed to copy stream output declaration.\n");
3008 return E_FAIL;
3009 }
3010
3011 TRACE("Stream output declaration: %s.\n", debugstr_a(variable->u.shader.stream_output_declaration));
3012 }
3013
3014 switch (property_info->type)
3015 {
3016 case D3D10_SVT_VERTEXSHADER:
3017 case D3D10_SVT_PIXELSHADER:
3018 case D3D10_SVT_GEOMETRYSHADER:
3019 if (FAILED(hr = parse_fx10_shader(data, data_size, value_offset, variable)))
3020 return hr;
3021 break;
3022
3023 default:
3024 WARN("Unexpected shader type %#x.\n", property_info->type);
3025 return E_FAIL;
3026 }
3027
3028 ((void **)dst)[idx] = variable;
3029
3030 break;
3031
3032 default:
3033 FIXME("Unhandled operation %#x.\n", operation);
3034 return E_FAIL;
3035 }
3036
3037 return S_OK;
3038 }
3039
3040 static HRESULT parse_fx10_pass(const char *data, size_t data_size,
3041 const char **ptr, struct d3d10_effect_pass *p)
3042 {
3043 uint32_t offset, object_count;
3044 unsigned int i;
3045 HRESULT hr;
3046
3047 offset = read_u32(ptr);
3048 TRACE("Pass name at offset %#x.\n", offset);
3049
3050 if (!fx10_copy_string(data, data_size, offset, &p->name))
3051 {
3052 ERR("Failed to copy name.\n");
3053 return E_OUTOFMEMORY;
3054 }
3055 TRACE("Pass name: %s.\n", debugstr_a(p->name));
3056
3057 object_count = read_u32(ptr);
3058 TRACE("Pass has %u effect objects.\n", object_count);
3059
3060 p->annotations.count = read_u32(ptr);
3061 TRACE("Pass has %u annotations.\n", p->annotations.count);
3062
3063 if (FAILED(hr = parse_fx10_annotations(data, data_size, ptr, p->technique->effect,
3064 &p->annotations)))
3065 {
3066 ERR("Failed to parse pass annotations, hr %#lx.\n", hr);
3067 return hr;
3068 }
3069
3070 p->vs.shader = &null_shader_variable;
3071 p->ps.shader = &null_shader_variable;
3072 p->gs.shader = &null_shader_variable;
3073
3074 for (i = 0; i < object_count; ++i)
3075 {
3076 if (FAILED(hr = parse_fx10_property_assignment(data, data_size, ptr,
3077 D3D10_C_PASS, p->technique->effect, p, &p->dependencies)))
3078 {
3079 WARN("Failed to parse pass assignment %u, hr %#lx.\n", i, hr);
3080 return hr;
3081 }
3082 }
3083
3084 return hr;
3085 }
3086
3087 static HRESULT parse_fx10_technique(const char *data, size_t data_size,
3088 const char **ptr, struct d3d10_effect_technique *t)
3089 {
3090 unsigned int i;
3091 uint32_t offset;
3092 HRESULT hr;
3093
3094 offset = read_u32(ptr);
3095 TRACE("Technique name at offset %#x.\n", offset);
3096
3097 if (!fx10_copy_string(data, data_size, offset, &t->name))
3098 {
3099 ERR("Failed to copy name.\n");
3100 return E_OUTOFMEMORY;
3101 }
3102 TRACE("Technique name: %s.\n", debugstr_a(t->name));
3103
3104 t->pass_count = read_u32(ptr);
3105 TRACE("Technique has %u passes.\n", t->pass_count);
3106
3107 t->annotations.count = read_u32(ptr);
3108 TRACE("Technique has %u annotations.\n", t->annotations.count);
3109
3110 if (FAILED(hr = parse_fx10_annotations(data, data_size, ptr, t->effect,
3111 &t->annotations)))
3112 {
3113 ERR("Failed to parse technique annotations, hr %#lx.\n", hr);
3114 return hr;
3115 }
3116
3117 if (!(t->passes = calloc(t->pass_count, sizeof(*t->passes))))
3118 {
3119 ERR("Failed to allocate passes memory\n");
3120 return E_OUTOFMEMORY;
3121 }
3122
3123 for (i = 0; i < t->pass_count; ++i)
3124 {
3125 struct d3d10_effect_pass *p = &t->passes[i];
3126
3127 p->ID3D10EffectPass_iface.lpVtbl = &d3d10_effect_pass_vtbl;
3128 p->technique = t;
3129
3130 if (FAILED(hr = parse_fx10_pass(data, data_size, ptr, p)))
3131 return hr;
3132 }
3133
3134 return S_OK;
3135 }
3136
3137 static void parse_fx10_set_default_numeric_value(const char **ptr, struct d3d10_effect_variable *v)
3138 {
3139 float *dst = (float *)(v->buffer->u.buffer.local_buffer + v->buffer_offset), *src;
3140 BOOL col_major = v->type->type_class == D3D10_SVC_MATRIX_COLUMNS;
3141 unsigned int col_count = v->type->column_count, col;
3142 unsigned int row_count = v->type->row_count, row;
3143
3144 src = (float *)*ptr;
3145
3146 if (col_major)
3147 {
3148 for (col = 0; col < col_count; ++col)
3149 {
3150 for (row = 0; row < row_count; ++row)
3151 dst[row] = src[row * col_count + col];
3152 dst += 4;
3153 }
3154 }
3155 else
3156 {
3157 for (row = 0; row < row_count; ++row)
3158 {
3159 memcpy(dst, src, col_count * sizeof(float));
3160 src += col_count;
3161 dst += 4;
3162 }
3163 }
3164
3165 *ptr += col_count * row_count * sizeof(float);
3166 }
3167
3168 static void parse_fx10_default_value(const char **ptr, struct d3d10_effect_variable *var)
3169 {
3170 unsigned int element_count = max(var->type->element_count, 1), i, m;
3171 struct d3d10_effect_variable *v;
3172
3173 for (i = 0; i < element_count; ++i)
3174 {
3175 v = d3d10_array_get_element(var, i);
3176
3177 switch (v->type->type_class)
3178 {
3179 case D3D10_SVC_STRUCT:
3180 for (m = 0; m < v->type->member_count; ++m)
3181 parse_fx10_default_value(ptr, &v->members[m]);
3182 break;
3183 case D3D10_SVC_SCALAR:
3184 case D3D10_SVC_VECTOR:
3185 case D3D10_SVC_MATRIX_COLUMNS:
3186 case D3D10_SVC_MATRIX_ROWS:
3187 parse_fx10_set_default_numeric_value(ptr, v);
3188 break;
3189 default:
3190 FIXME("Unexpected initial value for type %#x.\n", v->type->basetype);
3191 return;
3192 }
3193 }
3194 }
3195
3196 static void d3d10_effect_variable_update_buffer_offsets(struct d3d10_effect_variable *v,
3197 unsigned int offset)
3198 {
3199 unsigned int i;
3200
3201 for (i = 0; i < v->type->member_count; ++i)
3202 d3d10_effect_variable_update_buffer_offsets(&v->members[i], offset);
3203
3204 for (i = 0; i < v->type->element_count; ++i)
3205 d3d10_effect_variable_update_buffer_offsets(&v->elements[i], offset);
3206
3207 v->buffer_offset += offset;
3208 }
3209
3210 static HRESULT parse_fx10_numeric_variable(const char *data, size_t data_size,
3211 const char **ptr, BOOL local, struct d3d10_effect_variable *v)
3212 {
3213 uint32_t offset, flags, default_value_offset, buffer_offset;
3214 const char *data_ptr;
3215 HRESULT hr;
3216
3217 if (FAILED(hr = parse_fx10_variable_head(data, data_size, ptr, v)))
3218 return hr;
3219
3220 offset = read_u32(ptr);
3221 TRACE("Variable semantic at offset %#x.\n", offset);
3222
3223 if (!fx10_copy_string(data, data_size, offset, &v->semantic))
3224 {
3225 ERR("Failed to copy semantic.\n");
3226 return E_OUTOFMEMORY;
3227 }
3228 TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
3229
3230 buffer_offset = read_u32(ptr);
3231 TRACE("Variable offset in buffer: %#x.\n", buffer_offset);
3232
3233 default_value_offset = read_u32(ptr);
3234 TRACE("Variable default value offset: %#x.\n", default_value_offset);
3235
3236 flags = read_u32(ptr);
3237 TRACE("Variable flags: %#x.\n", flags);
3238
3239 v->flag |= flags;
3240
3241 /* At this point storage offsets for members and array elements are relative to containing
3242 variable. Update them by moving to correct offset within a buffer. */
3243 d3d10_effect_variable_update_buffer_offsets(v, buffer_offset);
3244
3245 if (local)
3246 {
3247 if (default_value_offset)
3248 {
3249 if (!require_space(default_value_offset, 1, v->type->size_packed, data_size))
3250 {
3251 WARN("Invalid default value offset %#x, variable packed size %u.\n", default_value_offset,
3252 v->type->size_packed);
3253 return E_FAIL;
3254 }
3255
3256 data_ptr = data + default_value_offset;
3257 parse_fx10_default_value(&data_ptr, v);
3258 }
3259
3260 v->annotations.count = read_u32(ptr);
3261 TRACE("Variable has %u annotations.\n", v->annotations.count);
3262
3263 if (FAILED(hr = parse_fx10_annotations(data, data_size, ptr, v->effect,
3264 &v->annotations)))
3265 {
3266 ERR("Failed to parse variable annotations, hr %#lx.\n", hr);
3267 return hr;
3268 }
3269 }
3270
3271 if (v->flag & D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
3272 v->explicit_bind_point = v->buffer_offset;
3273
3274 return S_OK;
3275 }
3276
3277 static HRESULT create_state_object(struct d3d10_effect_variable *v)
3278 {
3279 ID3D10Device *device = v->effect->device;
3280 HRESULT hr;
3281
3282 switch (v->type->basetype)
3283 {
3284 case D3D10_SVT_DEPTHSTENCIL:
3285 if (FAILED(hr = ID3D10Device_CreateDepthStencilState(device,
3286 &v->u.state.desc.depth_stencil, &v->u.state.object.depth_stencil)))
3287 return hr;
3288 break;
3289
3290 case D3D10_SVT_BLEND:
3291 if (FAILED(hr = ID3D10Device_CreateBlendState(device,
3292 &v->u.state.desc.blend, &v->u.state.object.blend)))
3293 return hr;
3294 break;
3295
3296 case D3D10_SVT_RASTERIZER:
3297 if (FAILED(hr = ID3D10Device_CreateRasterizerState(device,
3298 &v->u.state.desc.rasterizer, &v->u.state.object.rasterizer)))
3299 return hr;
3300 break;
3301
3302 case D3D10_SVT_SAMPLER:
3303 if (FAILED(hr = ID3D10Device_CreateSamplerState(device,
3304 &v->u.state.desc.sampler.desc, &v->u.state.object.sampler)))
3305 return hr;
3306 break;
3307
3308 default:
3309 ERR("Unhandled variable type %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
3310 return E_FAIL;
3311 }
3312
3313 return S_OK;
3314 }
3315
3316 static HRESULT parse_fx10_object_variable(const char *data, size_t data_size,
3317 const char **ptr, BOOL shared_type_desc, struct d3d10_effect_variable *v)
3318 {
3319 struct d3d10_effect_var_array *vars;
3320 struct d3d10_effect_variable *var;
3321 unsigned int i, j, element_count;
3322 HRESULT hr;
3323 uint32_t offset;
3324
3325 if (FAILED(hr = parse_fx10_variable_head(data, data_size, ptr, v)))
3326 return hr;
3327
3328 offset = read_u32(ptr);
3329 TRACE("Variable semantic at offset %#x.\n", offset);
3330
3331 if (!fx10_copy_string(data, data_size, offset, &v->semantic))
3332 {
3333 ERR("Failed to copy semantic.\n");
3334 return E_OUTOFMEMORY;
3335 }
3336 TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
3337
3338 v->explicit_bind_point = read_u32(ptr);
3339 TRACE("Variable explicit bind point %#x.\n", v->explicit_bind_point);
3340
3341 /* Shared variable description contains only type information. */
3342 if (shared_type_desc) return S_OK;
3343
3344 element_count = max(v->type->element_count, 1);
3345
3346 switch (v->type->basetype)
3347 {
3348 case D3D10_SVT_TEXTURE:
3349 case D3D10_SVT_TEXTURE1D:
3350 case D3D10_SVT_TEXTURE1DARRAY:
3351 case D3D10_SVT_TEXTURE2D:
3352 case D3D10_SVT_TEXTURE2DARRAY:
3353 case D3D10_SVT_TEXTURE2DMS:
3354 case D3D10_SVT_TEXTURE2DMSARRAY:
3355 case D3D10_SVT_TEXTURE3D:
3356 case D3D10_SVT_TEXTURECUBE:
3357 if (!(v->u.resource.srv = calloc(element_count, sizeof(*v->u.resource.srv))))
3358 {
3359 ERR("Failed to allocate shader resource view array memory.\n");
3360 return E_OUTOFMEMORY;
3361 }
3362 v->u.resource.parent = TRUE;
3363
3364 if (v->elements)
3365 {
3366 for (i = 0; i < v->type->element_count; ++i)
3367 {
3368 v->elements[i].u.resource.srv = &v->u.resource.srv[i];
3369 v->elements[i].u.resource.parent = FALSE;
3370 }
3371 }
3372 break;
3373
3374 case D3D10_SVT_RENDERTARGETVIEW:
3375 case D3D10_SVT_DEPTHSTENCILVIEW:
3376 case D3D10_SVT_BUFFER:
3377 TRACE("SVT could not have elements.\n");
3378 break;
3379
3380 case D3D10_SVT_VERTEXSHADER:
3381 case D3D10_SVT_PIXELSHADER:
3382 case D3D10_SVT_GEOMETRYSHADER:
3383 TRACE("Shader type is %s\n", debug_d3d10_shader_variable_type(v->type->basetype));
3384 for (i = 0; i < element_count; ++i)
3385 {
3386 uint32_t shader_offset, sodecl_offset;
3387
3388 var = d3d10_array_get_element(v, i);
3389
3390 shader_offset = read_u32(ptr);
3391 TRACE("Shader offset: %#x.\n", shader_offset);
3392
3393 if (v->type->flags & D3D10_EOT_FLAG_GS_SO)
3394 {
3395 sodecl_offset = read_u32(ptr);
3396 TRACE("Stream output declaration at offset %#x.\n", sodecl_offset);
3397
3398 if (!fx10_copy_string(data, data_size, sodecl_offset,
3399 &var->u.shader.stream_output_declaration))
3400 {
3401 ERR("Failed to copy stream output declaration.\n");
3402 return E_OUTOFMEMORY;
3403 }
3404
3405 TRACE("Stream output declaration: %s.\n", debugstr_a(var->u.shader.stream_output_declaration));
3406 }
3407
3408 if (FAILED(hr = parse_fx10_shader(data, data_size, shader_offset, var)))
3409 return hr;
3410 }
3411 break;
3412
3413 case D3D10_SVT_DEPTHSTENCIL:
3414 case D3D10_SVT_BLEND:
3415 case D3D10_SVT_RASTERIZER:
3416 case D3D10_SVT_SAMPLER:
3417 {
3418 const struct d3d10_effect_state_storage_info *storage_info;
3419
3420 if (!(storage_info = get_storage_info(v->type->basetype)))
3421 {
3422 FIXME("Failed to get backing store info for type %s.\n",
3423 debug_d3d10_shader_variable_type(v->type->basetype));
3424 return E_FAIL;
3425 }
3426
3427 if (storage_info->size > sizeof(v->u.state.desc))
3428 {
3429 ERR("Invalid storage size %#Ix.\n", storage_info->size);
3430 return E_FAIL;
3431 }
3432
3433 switch (v->type->basetype)
3434 {
3435 case D3D10_SVT_DEPTHSTENCIL:
3436 vars = &v->effect->ds_states;
3437 break;
3438 case D3D10_SVT_BLEND:
3439 vars = &v->effect->blend_states;
3440 break;
3441 case D3D10_SVT_RASTERIZER:
3442 vars = &v->effect->rs_states;
3443 break;
3444 case D3D10_SVT_SAMPLER:
3445 vars = &v->effect->samplers;
3446 break;
3447 default:
3448 ;
3449 }
3450
3451 for (i = 0; i < element_count; ++i)
3452 {
3453 unsigned int prop_count;
3454
3455 var = d3d10_array_get_element(v, i);
3456
3457 if (vars->current >= vars->count)
3458 {
3459 WARN("Wrong variable array size for %#x.\n", v->type->basetype);
3460 return E_FAIL;
3461 }
3462 var->u.state.index = vars->current;
3463 vars->v[vars->current++] = var;
3464
3465 prop_count = read_u32(ptr);
3466 TRACE("State object property count: %#x.\n", prop_count);
3467
3468 memcpy(&var->u.state.desc, storage_info->default_state, storage_info->size);
3469
3470 for (j = 0; j < prop_count; ++j)
3471 {
3472 if (FAILED(hr = parse_fx10_property_assignment(data, data_size, ptr,
3473 get_var_container_type(var), var->effect, &var->u.state.desc,
3474 &var->u.state.dependencies)))
3475 {
3476 ERR("Failed to read property list.\n");
3477 return hr;
3478 }
3479 }
3480
3481 if (FAILED(hr = create_state_object(var)))
3482 return hr;
3483 }
3484 }
3485 break;
3486
3487 default:
3488 FIXME("Unhandled case %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
3489 return E_FAIL;
3490 }
3491
3492 v->annotations.count = read_u32(ptr);
3493 TRACE("Variable has %u annotations.\n", v->annotations.count);
3494
3495 if (FAILED(hr = parse_fx10_annotations(data, data_size, ptr, v->effect,
3496 &v->annotations)))
3497 {
3498 ERR("Failed to parse variable annotations, hr %#lx.\n", hr);
3499 return hr;
3500 }
3501
3502 return S_OK;
3503 }
3504
3505 static HRESULT create_buffer_object(struct d3d10_effect_variable *v)
3506 {
3507 D3D10_BUFFER_DESC buffer_desc;
3508 D3D10_SUBRESOURCE_DATA subresource_data;
3509 D3D10_SHADER_RESOURCE_VIEW_DESC srv_desc;
3510 ID3D10Device *device = v->effect->device;
3511 HRESULT hr;
3512
3513 buffer_desc.ByteWidth = v->data_size;
3514 buffer_desc.Usage = D3D10_USAGE_DEFAULT;
3515 buffer_desc.CPUAccessFlags = 0;
3516 buffer_desc.MiscFlags = 0;
3517 if (v->type->basetype == D3D10_SVT_CBUFFER)
3518 buffer_desc.BindFlags = D3D10_BIND_CONSTANT_BUFFER;
3519 else
3520 buffer_desc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
3521
3522 subresource_data.pSysMem = v->u.buffer.local_buffer;
3523 subresource_data.SysMemPitch = 0;
3524 subresource_data.SysMemSlicePitch = 0;
3525
3526 if (FAILED(hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &subresource_data, &v->u.buffer.buffer)))
3527 return hr;
3528
3529 if (v->type->basetype == D3D10_SVT_TBUFFER)
3530 {
3531 srv_desc.Format = DXGI_FORMAT_R32G32B32A32_UINT;
3532 srv_desc.ViewDimension = D3D_SRV_DIMENSION_BUFFER;
3533 srv_desc.Buffer.ElementOffset = 0;
3534 srv_desc.Buffer.ElementWidth = v->type->size_unpacked / 16;
3535 if (v->type->size_unpacked % 16)
3536 WARN("Unexpected texture buffer size not a multiple of 16.\n");
3537
3538 if (FAILED(hr = ID3D10Device_CreateShaderResourceView(device, (ID3D10Resource *)v->u.buffer.buffer,
3539 &srv_desc, &v->u.buffer.resource_view)))
3540 return hr;
3541 }
3542 else
3543 v->u.buffer.resource_view = NULL;
3544
3545 return S_OK;
3546 }
3547
3548 static HRESULT parse_fx10_buffer(const char *data, size_t data_size, const char **ptr,
3549 BOOL local, struct d3d10_effect_variable *l)
3550 {
3551 const char *prefix = local ? "Local" : "Shared";
3552 unsigned int i;
3553 uint32_t offset;
3554 D3D10_CBUFFER_TYPE d3d10_cbuffer_type;
3555 HRESULT hr;
3556 unsigned int stride = 0;
3557
3558 /* Generate our own type, it isn't in the fx blob. */
3559 if (!(l->type = calloc(1, sizeof(*l->type))))
3560 {
3561 ERR("Failed to allocate local buffer type memory.\n");
3562 return E_OUTOFMEMORY;
3563 }
3564 l->type->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
3565 l->type->type_class = D3D10_SVC_OBJECT;
3566 l->type->effect = l->effect;
3567
3568 offset = read_u32(ptr);
3569 TRACE("%s buffer name at offset %#x.\n", prefix, offset);
3570
3571 if (!fx10_copy_string(data, data_size, offset, &l->name))
3572 {
3573 ERR("Failed to copy name.\n");
3574 return E_OUTOFMEMORY;
3575 }
3576 TRACE("%s buffer name: %s.\n", prefix, debugstr_a(l->name));
3577
3578 l->data_size = read_u32(ptr);
3579 TRACE("%s buffer data size: %#x.\n", prefix, l->data_size);
3580
3581 d3d10_cbuffer_type = read_u32(ptr);
3582 TRACE("%s buffer type: %#x.\n", prefix, d3d10_cbuffer_type);
3583
3584 switch(d3d10_cbuffer_type)
3585 {
3586 case D3D10_CT_CBUFFER:
3587 l->type->basetype = D3D10_SVT_CBUFFER;
3588 if (!copy_name("cbuffer", &l->type->name))
3589 {
3590 ERR("Failed to copy name.\n");
3591 return E_OUTOFMEMORY;
3592 }
3593 break;
3594
3595 case D3D10_CT_TBUFFER:
3596 l->type->basetype = D3D10_SVT_TBUFFER;
3597 if (!copy_name("tbuffer", &l->type->name))
3598 {
3599 ERR("Failed to copy name.\n");
3600 return E_OUTOFMEMORY;
3601 }
3602 break;
3603
3604 default:
3605 ERR("Unexpected D3D10_CBUFFER_TYPE %#x!\n", d3d10_cbuffer_type);
3606 return E_FAIL;
3607 }
3608
3609 l->type->member_count = read_u32(ptr);
3610 TRACE("%s buffer member count: %#x.\n", prefix, l->type->member_count);
3611
3612 l->explicit_bind_point = read_u32(ptr);
3613 TRACE("%s buffer explicit bind point: %#x.\n", prefix, l->explicit_bind_point);
3614
3615 if (l->effect->flags & D3D10_EFFECT_IS_POOL)
3616 l->flag |= D3D10_EFFECT_VARIABLE_POOLED;
3617
3618 if (local)
3619 {
3620 l->annotations.count = read_u32(ptr);
3621 TRACE("Local buffer has %u annotations.\n", l->annotations.count);
3622
3623 if (FAILED(hr = parse_fx10_annotations(data, data_size, ptr, l->effect,
3624 &l->annotations)))
3625 {
3626 ERR("Failed to parse buffer annotations, hr %#lx.\n", hr);
3627 return hr;
3628 }
3629 }
3630
3631 if (!(l->members = calloc(l->type->member_count, sizeof(*l->members))))
3632 {
3633 ERR("Failed to allocate members memory.\n");
3634 return E_OUTOFMEMORY;
3635 }
3636
3637 if (!(l->type->members = calloc(l->type->member_count, sizeof(*l->type->members))))
3638 {
3639 ERR("Failed to allocate type members memory.\n");
3640 return E_OUTOFMEMORY;
3641 }
3642
3643 if (local && !(l->u.buffer.local_buffer = calloc(1, l->data_size)))
3644 {
3645 ERR("Failed to allocate local constant buffer memory.\n");
3646 return E_OUTOFMEMORY;
3647 }
3648
3649 for (i = 0; i < l->type->member_count; ++i)
3650 {
3651 struct d3d10_effect_variable *v = &l->members[i];
3652 struct d3d10_effect_type_member *typem = &l->type->members[i];
3653
3654 v->buffer = l;
3655 v->effect = l->effect;
3656
3657 if (FAILED(hr = parse_fx10_numeric_variable(data, data_size, ptr, local, v)))
3658 return hr;
3659
3660 /*
3661 * Copy the values from the variable type to the constant buffers type
3662 * members structure, because it is our own generated type.
3663 */
3664 typem->type = v->type;
3665
3666 if (!copy_name(v->name, &typem->name))
3667 {
3668 ERR("Failed to copy name.\n");
3669 return E_OUTOFMEMORY;
3670 }
3671 TRACE("Variable name: %s.\n", debugstr_a(typem->name));
3672
3673 if (!copy_name(v->semantic, &typem->semantic))
3674 {
3675 ERR("Failed to copy name.\n");
3676 return E_OUTOFMEMORY;
3677 }
3678 TRACE("Variable semantic: %s.\n", debugstr_a(typem->semantic));
3679
3680 typem->buffer_offset = v->buffer_offset;
3681 TRACE("Variable buffer offset: %u.\n", typem->buffer_offset);
3682
3683 l->type->size_packed += v->type->size_packed;
3684
3685 /*
3686 * For the complete constantbuffer the size_unpacked = stride,
3687 * the stride is calculated like this:
3688 *
3689 * 1) if the constant buffer variables are packed with packoffset
3690 * - stride = the highest used constant
3691 * - the complete stride has to be a multiple of 0x10
3692 *
3693 * 2) if the constant buffer variables are NOT packed with packoffset
3694 * - sum of unpacked size for all variables which fit in a 0x10 part
3695 * - if the size exceeds a 0x10 part, the rest of the old part is skipped
3696 * and a new part is started
3697 * - if the variable is a struct it is always used a new part
3698 * - the complete stride has to be a multiple of 0x10
3699 *
3700 * e.g.:
3701 * 0x4, 0x4, 0x4, 0x8, 0x4, 0x14, 0x4
3702 * part 0x10 0x10 0x20 -> 0x40
3703 */
3704 if (v->flag & D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
3705 {
3706 if ((v->type->size_unpacked + v->buffer_offset) > stride)
3707 {
3708 stride = v->type->size_unpacked + v->buffer_offset;
3709 }
3710 }
3711 else
3712 {
3713 if (v->type->type_class == D3D10_SVC_STRUCT)
3714 {
3715 stride = (stride + 0xf) & ~0xf;
3716 }
3717
3718 if ( ((stride & 0xf) + v->type->size_unpacked) > 0x10)
3719 {
3720 stride = (stride + 0xf) & ~0xf;
3721 }
3722
3723 stride += v->type->size_unpacked;
3724 }
3725 }
3726 l->type->stride = l->type->size_unpacked = (stride + 0xf) & ~0xf;
3727
3728 TRACE("%s constant buffer:\n", prefix);
3729 TRACE("\tType name: %s.\n", debugstr_a(l->type->name));
3730 TRACE("\tElement count: %u.\n", l->type->element_count);
3731 TRACE("\tMember count: %u.\n", l->type->member_count);
3732 TRACE("\tUnpacked size: %#x.\n", l->type->size_unpacked);
3733 TRACE("\tStride: %#x.\n", l->type->stride);
3734 TRACE("\tPacked size %#x.\n", l->type->size_packed);
3735 TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(l->type->basetype));
3736 TRACE("\tTypeclass: %s.\n", debug_d3d10_shader_variable_class(l->type->type_class));
3737
3738 if (local && l->data_size)
3739 {
3740 if (FAILED(hr = create_buffer_object(l)))
3741 {
3742 WARN("Failed to create a buffer object, hr %#lx.\n", hr);
3743 return hr;
3744 }
3745 }
3746
3747 if (l->explicit_bind_point != ~0u)
3748 l->flag |= D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT;
3749
3750 return S_OK;
3751 }
3752
3753 static void d3d10_effect_type_member_destroy(struct d3d10_effect_type_member *typem)
3754 {
3755 TRACE("effect type member %p.\n", typem);
3756
3757 /* Do not release typem->type, it will be covered by d3d10_effect_type_destroy(). */
3758 free(typem->semantic);
3759 free(typem->name);
3760 }
3761
3762 static void d3d10_effect_type_destroy(struct wine_rb_entry *entry, void *context)
3763 {
3764 struct d3d10_effect_type *t = WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
3765
3766 TRACE("effect type %p.\n", t);
3767
3768 if (t->elementtype)
3769 {
3770 free(t->elementtype->name);
3771 free(t->elementtype);
3772 }
3773
3774 if (t->members)
3775 {
3776 unsigned int i;
3777
3778 for (i = 0; i < t->member_count; ++i)
3779 {
3780 d3d10_effect_type_member_destroy(&t->members[i]);
3781 }
3782 free(t->members);
3783 }
3784
3785 free(t->name);
3786 free(t);
3787 }
3788
3789 static BOOL d3d10_effect_types_match(const struct d3d10_effect_type *t1,
3790 const struct d3d10_effect_type *t2)
3791 {
3792 unsigned int i;
3793
3794 if (strcmp(t1->name, t2->name)) return FALSE;
3795 if (t1->basetype != t2->basetype) return FALSE;
3796 if (t1->type_class != t2->type_class) return FALSE;
3797 if (t1->element_count != t2->element_count) return FALSE;
3798 if (t1->element_count) return d3d10_effect_types_match(t1->elementtype, t2->elementtype);
3799 if (t1->member_count != t2->member_count) return FALSE;
3800 if (t1->column_count != t2->column_count) return FALSE;
3801 if (t1->row_count != t2->row_count) return FALSE;
3802
3803 for (i = 0; i < t1->member_count; ++i)
3804 {
3805 if (strcmp(t1->members[i].name, t2->members[i].name)) return FALSE;
3806 if (t1->members[i].buffer_offset != t2->members[i].buffer_offset) return FALSE;
3807 if (!d3d10_effect_types_match(t1->members[i].type, t2->members[i].type)) return FALSE;
3808 }
3809
3810 return TRUE;
3811 }
3812
3813 static HRESULT d3d10_effect_validate_shared_variable(const struct d3d10_effect *effect,
3814 const struct d3d10_effect_variable *v)
3815 {
3816 struct d3d10_effect_variable *sv;
3817
3818 switch (v->type->basetype)
3819 {
3820 case D3D10_SVT_CBUFFER:
3821 case D3D10_SVT_TBUFFER:
3822 sv = d3d10_effect_get_buffer_by_name(effect->pool, v->name);
3823 break;
3824 default:
3825 sv = d3d10_effect_get_variable_by_name(effect->pool, v->name);
3826 }
3827
3828 if (!sv)
3829 {
3830 WARN("Variable %s wasn't found in the pool.\n", debugstr_a(v->name));
3831 return E_INVALIDARG;
3832 }
3833
3834 if (!d3d10_effect_types_match(sv->type, v->type))
3835 {
3836 WARN("Variable %s type does not match pool type.\n", debugstr_a(v->name));
3837 return E_INVALIDARG;
3838 }
3839
3840 return S_OK;
3841 }
3842
3843 static HRESULT parse_fx10_body(struct d3d10_effect *e, const char *data, size_t data_size)
3844 {
3845 const char *ptr;
3846 unsigned int i;
3847 HRESULT hr;
3848
3849 if (e->index_offset >= data_size)
3850 {
3851 WARN("Invalid index offset %#x (data size %#Ix).\n", e->index_offset, data_size);
3852 return E_FAIL;
3853 }
3854 ptr = data + e->index_offset;
3855
3856 if (!(e->local_buffers = calloc(e->local_buffer_count, sizeof(*e->local_buffers))))
3857 {
3858 ERR("Failed to allocate local buffer memory.\n");
3859 return E_OUTOFMEMORY;
3860 }
3861
3862 if (!(e->local_variables = calloc(e->local_variable_count, sizeof(*e->local_variables))))
3863 {
3864 ERR("Failed to allocate local variable memory.\n");
3865 return E_OUTOFMEMORY;
3866 }
3867
3868 if (!(e->anonymous_shaders = calloc(e->anonymous_shader_count, sizeof(*e->anonymous_shaders))))
3869 {
3870 ERR("Failed to allocate anonymous shaders memory\n");
3871 return E_OUTOFMEMORY;
3872 }
3873
3874 if (!(e->shaders.v = calloc(e->shaders.count, sizeof(*e->shaders.v))))
3875 {
3876 ERR("Failed to allocate used shaders memory\n");
3877 return E_OUTOFMEMORY;
3878 }
3879
3880 if (!(e->samplers.v = calloc(e->samplers.count, sizeof(*e->samplers.v))))
3881 {
3882 ERR("Failed to allocate samplers array.\n");
3883 return E_OUTOFMEMORY;
3884 }
3885
3886 if (!(e->blend_states.v = calloc(e->blend_states.count, sizeof(*e->blend_states.v))))
3887 {
3888 ERR("Failed to allocate blend states array.\n");
3889 return E_OUTOFMEMORY;
3890 }
3891
3892 if (!(e->ds_states.v = calloc(e->ds_states.count, sizeof(*e->ds_states.v))))
3893 {
3894 ERR("Failed to allocate depth stencil states array.\n");
3895 return E_OUTOFMEMORY;
3896 }
3897
3898 if (!(e->rs_states.v = calloc(e->rs_states.count, sizeof(*e->rs_states.v))))
3899 {
3900 ERR("Failed to allocate rasterizer states array.\n");
3901 return E_OUTOFMEMORY;
3902 }
3903
3904 if (!(e->techniques = calloc(e->technique_count, sizeof(*e->techniques))))
3905 {
3906 ERR("Failed to allocate techniques memory\n");
3907 return E_OUTOFMEMORY;
3908 }
3909
3910 for (i = 0; i < e->local_buffer_count; ++i)
3911 {
3912 struct d3d10_effect_variable *l = &e->local_buffers[i];
3913 l->ID3D10EffectVariable_iface.lpVtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl;
3914 l->effect = e;
3915 l->buffer = &null_local_buffer;
3916
3917 if (FAILED(hr = parse_fx10_buffer(data, data_size, &ptr, TRUE, l)))
3918 return hr;
3919 }
3920
3921 for (i = 0; i < e->local_variable_count; ++i)
3922 {
3923 struct d3d10_effect_variable *v = &e->local_variables[i];
3924
3925 v->effect = e;
3926 v->ID3D10EffectVariable_iface.lpVtbl = &d3d10_effect_variable_vtbl;
3927 v->buffer = &null_local_buffer;
3928
3929 if (FAILED(hr = parse_fx10_object_variable(data, data_size, &ptr, FALSE, v)))
3930 return hr;
3931 }
3932
3933 for (i = 0; i < e->shared_buffer_count; ++i)
3934 {
3935 struct d3d10_effect_variable b = {{ 0 }};
3936
3937 b.effect = e;
3938
3939 if (FAILED(hr = parse_fx10_buffer(data, data_size, &ptr, FALSE, &b)))
3940 {
3941 d3d10_effect_variable_destroy(&b);
3942 return hr;
3943 }
3944
3945 hr = d3d10_effect_validate_shared_variable(e, &b);
3946 d3d10_effect_variable_destroy(&b);
3947 if (FAILED(hr)) return hr;
3948 }
3949
3950 for (i = 0; i < e->shared_object_count; ++i)
3951 {
3952 struct d3d10_effect_variable o = {{ 0 }};
3953
3954 o.effect = e;
3955
3956 if (FAILED(hr = parse_fx10_object_variable(data, data_size, &ptr, TRUE, &o)))
3957 {
3958 d3d10_effect_variable_destroy(&o);
3959 return hr;
3960 }
3961
3962 hr = d3d10_effect_validate_shared_variable(e, &o);
3963 d3d10_effect_variable_destroy(&o);
3964 if (FAILED(hr)) return hr;
3965 }
3966
3967 for (i = 0; i < e->technique_count; ++i)
3968 {
3969 struct d3d10_effect_technique *t = &e->techniques[i];
3970
3971 t->ID3D10EffectTechnique_iface.lpVtbl = &d3d10_effect_technique_vtbl;
3972 t->effect = e;
3973
3974 if (FAILED(hr = parse_fx10_technique(data, data_size, &ptr, t)))
3975 return hr;
3976 }
3977
3978 return S_OK;
3979 }
3980
3981 static HRESULT parse_fx10(struct d3d10_effect *e, const char *data, size_t data_size)
3982 {
3983 const char *ptr = data;
3984 uint32_t unused;
3985
3986 if (!require_space(0, 19, sizeof(uint32_t), data_size))
3987 {
3988 WARN("Invalid data size %#Ix.\n", data_size);
3989 return E_INVALIDARG;
3990 }
3991
3992 /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
3993 e->version = read_u32(&ptr);
3994 TRACE("Target: %#x.\n", e->version);
3995
3996 e->local_buffer_count = read_u32(&ptr);
3997 TRACE("Local buffer count: %u.\n", e->local_buffer_count);
3998
3999 e->variable_count = read_u32(&ptr);
4000 TRACE("Variable count: %u.\n", e->variable_count);
4001
4002 e->local_variable_count = read_u32(&ptr);
4003 TRACE("Object count: %u.\n", e->local_variable_count);
4004
4005 e->shared_buffer_count = read_u32(&ptr);
4006 TRACE("Pool buffer count: %u.\n", e->shared_buffer_count);
4007
4008 unused = read_u32(&ptr);
4009 TRACE("Pool variable count: %u.\n", unused);
4010
4011 e->shared_object_count = read_u32(&ptr);
4012 TRACE("Pool objects count: %u.\n", e->shared_object_count);
4013
4014 e->technique_count = read_u32(&ptr);
4015 TRACE("Technique count: %u.\n", e->technique_count);
4016
4017 e->index_offset = read_u32(&ptr);
4018 TRACE("Index offset: %#x.\n", e->index_offset);
4019
4020 unused = read_u32(&ptr);
4021 TRACE("String count: %u.\n", unused);
4022
4023 e->texture_count = read_u32(&ptr);
4024 TRACE("Texture count: %u.\n", e->texture_count);
4025
4026 e->ds_states.count = read_u32(&ptr);
4027 TRACE("Depthstencilstate count: %u.\n", e->ds_states.count);
4028
4029 e->blend_states.count = read_u32(&ptr);
4030 TRACE("Blendstate count: %u.\n", e->blend_states.count);
4031
4032 e->rs_states.count = read_u32(&ptr);
4033 TRACE("Rasterizerstate count: %u.\n", e->rs_states.count);
4034
4035 e->samplers.count = read_u32(&ptr);
4036 TRACE("Samplerstate count: %u.\n", e->samplers.count);
4037
4038 e->rtvs.count = read_u32(&ptr);
4039 TRACE("Rendertargetview count: %u.\n", e->rtvs.count);
4040
4041 e->dsvs.count = read_u32(&ptr);
4042 TRACE("Depthstencilview count: %u.\n", e->dsvs.count);
4043
4044 e->shaders.count = read_u32(&ptr);
4045 TRACE("Used shader count: %u.\n", e->shaders.count);
4046
4047 e->anonymous_shader_count = read_u32(&ptr);
4048 TRACE("Anonymous shader count: %u.\n", e->anonymous_shader_count);
4049
4050 if (!e->pool && (e->shared_object_count || e->shared_buffer_count))
4051 {
4052 WARN("Effect requires a pool to load.\n");
4053 return E_FAIL;
4054 }
4055
4056 return parse_fx10_body(e, ptr, data_size - (ptr - data));
4057 }
4058
4059 static HRESULT fx10_chunk_handler(const char *data, size_t data_size, uint32_t tag, void *ctx)
4060 {
4061 struct d3d10_effect *e = ctx;
4062
4063 TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
4064
4065 TRACE("Chunk size: %#Ix.\n", data_size);
4066
4067 switch(tag)
4068 {
4069 case TAG_FX10:
4070 return parse_fx10(e, data, data_size);
4071
4072 default:
4073 FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
4074 return S_OK;
4075 }
4076 }
4077
4078 HRESULT d3d10_effect_parse(struct d3d10_effect *effect, const void *data, SIZE_T data_size)
4079 {
4080 return parse_dxbc(data, data_size, fx10_chunk_handler, effect);
4081 }
4082
4083 static void d3d10_effect_shader_variable_destroy(struct d3d10_effect_shader_variable *s,
4084 D3D10_SHADER_VARIABLE_TYPE type)
4085 {
4086 if (s->reflection)
4087 s->reflection->lpVtbl->Release(s->reflection);
4088 if (s->input_signature)
4089 ID3D10Blob_Release(s->input_signature);
4090 if (s->bytecode)
4091 ID3D10Blob_Release(s->bytecode);
4092
4093 switch (type)
4094 {
4095 case D3D10_SVT_VERTEXSHADER:
4096 case D3D10_SVT_PIXELSHADER:
4097 case D3D10_SVT_GEOMETRYSHADER:
4098 if (s->shader.object)
4099 IUnknown_Release(s->shader.object);
4100 break;
4101
4102 default:
4103 FIXME("Unhandled shader type %s.\n", debug_d3d10_shader_variable_type(type));
4104 break;
4105 }
4106
4107 if (s->resource_count)
4108 free(s->resources);
4109 }
4110
4111 static void d3d10_effect_annotations_destroy(struct d3d10_effect_annotations *a)
4112 {
4113 unsigned int i;
4114
4115 if (!a->elements) return;
4116
4117 for (i = 0; i < a->count; ++i)
4118 d3d10_effect_variable_destroy(&a->elements[i]);
4119 free(a->elements);
4120 a->elements = NULL;
4121 a->count = 0;
4122 }
4123
4124 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable *v)
4125 {
4126 unsigned int i, elem_count;
4127
4128 TRACE("variable %p.\n", v);
4129
4130 free(v->name);
4131 free(v->semantic);
4132 d3d10_effect_annotations_destroy(&v->annotations);
4133
4134 if (v->members)
4135 {
4136 for (i = 0; i < v->type->member_count; ++i)
4137 {
4138 d3d10_effect_variable_destroy(&v->members[i]);
4139 }
4140 free(v->members);
4141 }
4142
4143 if (v->elements)
4144 {
4145 for (i = 0; i < v->type->element_count; ++i)
4146 {
4147 d3d10_effect_variable_destroy(&v->elements[i]);
4148 }
4149 free(v->elements);
4150 }
4151
4152 if (v->type)
4153 {
4154 switch (v->type->basetype)
4155 {
4156 case D3D10_SVT_VERTEXSHADER:
4157 case D3D10_SVT_PIXELSHADER:
4158 case D3D10_SVT_GEOMETRYSHADER:
4159 d3d10_effect_shader_variable_destroy(&v->u.shader, v->type->basetype);
4160 break;
4161
4162 case D3D10_SVT_DEPTHSTENCIL:
4163 case D3D10_SVT_BLEND:
4164 case D3D10_SVT_RASTERIZER:
4165 case D3D10_SVT_SAMPLER:
4166 if (v->u.state.object.object)
4167 IUnknown_Release(v->u.state.object.object);
4168 d3d10_effect_clear_prop_dependencies(&v->u.state.dependencies);
4169 break;
4170
4171 case D3D10_SVT_TEXTURE1D:
4172 case D3D10_SVT_TEXTURE1DARRAY:
4173 case D3D10_SVT_TEXTURE2D:
4174 case D3D10_SVT_TEXTURE2DARRAY:
4175 case D3D10_SVT_TEXTURE2DMS:
4176 case D3D10_SVT_TEXTURE2DMSARRAY:
4177 case D3D10_SVT_TEXTURE3D:
4178 case D3D10_SVT_TEXTURECUBE:
4179 if (!v->u.resource.parent)
4180 break;
4181
4182 if (!v->type->element_count)
4183 elem_count = 1;
4184 else
4185 elem_count = v->type->element_count;
4186
4187 for (i = 0; i < elem_count; ++i)
4188 {
4189 if (v->u.resource.srv[i])
4190 ID3D10ShaderResourceView_Release(v->u.resource.srv[i]);
4191 }
4192
4193 free(v->u.resource.srv);
4194 break;
4195
4196 case D3D10_SVT_STRING:
4197 free(v->u.buffer.local_buffer);
4198 break;
4199
4200 default:
4201 break;
4202 }
4203 }
4204 }
4205
4206 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass *p)
4207 {
4208 TRACE("pass %p\n", p);
4209
4210 free(p->name);
4211 d3d10_effect_annotations_destroy(&p->annotations);
4212 d3d10_effect_clear_prop_dependencies(&p->dependencies);
4213 }
4214
4215 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique *t)
4216 {
4217 unsigned int i;
4218
4219 TRACE("technique %p\n", t);
4220
4221 free(t->name);
4222 if (t->passes)
4223 {
4224 for (i = 0; i < t->pass_count; ++i)
4225 {
4226 d3d10_effect_pass_destroy(&t->passes[i]);
4227 }
4228 free(t->passes);
4229 }
4230
4231 d3d10_effect_annotations_destroy(&t->annotations);
4232 }
4233
4234 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_variable *l)
4235 {
4236 unsigned int i;
4237
4238 TRACE("local buffer %p.\n", l);
4239
4240 free(l->name);
4241 if (l->members)
4242 {
4243 for (i = 0; i < l->type->member_count; ++i)
4244 {
4245 d3d10_effect_variable_destroy(&l->members[i]);
4246 }
4247 free(l->members);
4248 }
4249
4250 if (l->type)
4251 d3d10_effect_type_destroy(&l->type->entry, NULL);
4252
4253 d3d10_effect_annotations_destroy(&l->annotations);
4254 free(l->u.buffer.local_buffer);
4255
4256 if (l->u.buffer.buffer)
4257 ID3D10Buffer_Release(l->u.buffer.buffer);
4258 if (l->u.buffer.resource_view)
4259 ID3D10ShaderResourceView_Release(l->u.buffer.resource_view);
4260 }
4261
4262 /* IUnknown methods */
4263
4264 static inline struct d3d10_effect *impl_from_ID3D10Effect(ID3D10Effect *iface)
4265 {
4266 return CONTAINING_RECORD(iface, struct d3d10_effect, ID3D10Effect_iface);
4267 }
4268
4269 static HRESULT STDMETHODCALLTYPE d3d10_effect_QueryInterface(ID3D10Effect *iface, REFIID riid, void **object)
4270 {
4271 TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
4272
4273 if (IsEqualGUID(riid, &IID_ID3D10Effect)
4274 || IsEqualGUID(riid, &IID_IUnknown))
4275 {
4276 IUnknown_AddRef(iface);
4277 *object = iface;
4278 return S_OK;
4279 }
4280
4281 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
4282
4283 *object = NULL;
4284 return E_NOINTERFACE;
4285 }
4286
4287 static ULONG STDMETHODCALLTYPE d3d10_effect_AddRef(ID3D10Effect *iface)
4288 {
4289 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
4290 ULONG refcount = InterlockedIncrement(&This->refcount);
4291
4292 TRACE("%p increasing refcount to %lu.\n", This, refcount);
4293
4294 return refcount;
4295 }
4296
4297 static ULONG STDMETHODCALLTYPE d3d10_effect_Release(ID3D10Effect *iface)
4298 {
4299 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4300 ULONG refcount = InterlockedDecrement(&effect->refcount);
4301
4302 TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
4303
4304 if (!refcount)
4305 {
4306 unsigned int i;
4307
4308 if (effect->techniques)
4309 {
4310 for (i = 0; i < effect->technique_count; ++i)
4311 {
4312 d3d10_effect_technique_destroy(&effect->techniques[i]);
4313 }
4314 free(effect->techniques);
4315 }
4316
4317 if (effect->local_variables)
4318 {
4319 for (i = 0; i < effect->local_variable_count; ++i)
4320 {
4321 d3d10_effect_variable_destroy(&effect->local_variables[i]);
4322 }
4323 free(effect->local_variables);
4324 }
4325
4326 if (effect->local_buffers)
4327 {
4328 for (i = 0; i < effect->local_buffer_count; ++i)
4329 {
4330 d3d10_effect_local_buffer_destroy(&effect->local_buffers[i]);
4331 }
4332 free(effect->local_buffers);
4333 }
4334
4335 if (effect->anonymous_shaders)
4336 {
4337 for (i = 0; i < effect->anonymous_shader_count; ++i)
4338 {
4339 d3d10_effect_variable_destroy(&effect->anonymous_shaders[i].shader);
4340 free(effect->anonymous_shaders[i].type.name);
4341 }
4342 free(effect->anonymous_shaders);
4343 }
4344
4345 free(effect->shaders.v);
4346 free(effect->samplers.v);
4347 free(effect->rtvs.v);
4348 free(effect->dsvs.v);
4349 free(effect->blend_states.v);
4350 free(effect->ds_states.v);
4351 free(effect->rs_states.v);
4352
4353 wine_rb_destroy(&effect->types, d3d10_effect_type_destroy, NULL);
4354
4355 if (effect->pool)
4356 IUnknown_Release(&effect->pool->ID3D10Effect_iface);
4357 ID3D10Device_Release(effect->device);
4358 free(effect);
4359 }
4360
4361 return refcount;
4362 }
4363
4364 /* ID3D10Effect methods */
4365
4366 static BOOL STDMETHODCALLTYPE d3d10_effect_IsValid(ID3D10Effect *iface)
4367 {
4368 FIXME("iface %p stub!\n", iface);
4369
4370 return FALSE;
4371 }
4372
4373 static BOOL STDMETHODCALLTYPE d3d10_effect_IsPool(ID3D10Effect *iface)
4374 {
4375 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4376
4377 TRACE("iface %p.\n", iface);
4378
4379 return effect->ID3D10Effect_iface.lpVtbl == &d3d10_effect_pool_effect_vtbl;
4380 }
4381
4382 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDevice(ID3D10Effect *iface, ID3D10Device **device)
4383 {
4384 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
4385
4386 TRACE("iface %p, device %p\n", iface, device);
4387
4388 ID3D10Device_AddRef(This->device);
4389 *device = This->device;
4390
4391 return S_OK;
4392 }
4393
4394 static void d3d10_effect_get_desc(const struct d3d10_effect *effect, D3D10_EFFECT_DESC *desc)
4395 {
4396 unsigned int i;
4397
4398 desc->IsChildEffect = !!effect->pool;
4399 desc->ConstantBuffers = effect->local_buffer_count;
4400 desc->SharedConstantBuffers = 0;
4401 desc->GlobalVariables = effect->local_variable_count;
4402 for (i = 0; i < effect->local_buffer_count; ++i)
4403 {
4404 desc->GlobalVariables += effect->local_buffers[i].type->member_count;
4405 }
4406 desc->SharedGlobalVariables = 0;
4407 desc->Techniques = effect->technique_count;
4408 }
4409
4410 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDesc(ID3D10Effect *iface, D3D10_EFFECT_DESC *desc)
4411 {
4412 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4413 D3D10_EFFECT_DESC pool_desc = { 0 };
4414
4415 TRACE("iface %p, desc %p.\n", iface, desc);
4416
4417 if (!desc)
4418 return E_INVALIDARG;
4419
4420 if (effect->pool)
4421 d3d10_effect_get_desc(effect->pool, &pool_desc);
4422
4423 d3d10_effect_get_desc(effect, desc);
4424
4425 desc->SharedConstantBuffers = pool_desc.ConstantBuffers;
4426 desc->SharedGlobalVariables = pool_desc.GlobalVariables;
4427
4428 return S_OK;
4429 }
4430
4431 static struct d3d10_effect_variable * d3d10_effect_get_buffer_by_index(struct d3d10_effect *effect,
4432 unsigned int index)
4433 {
4434 if (index < effect->local_buffer_count)
4435 return &effect->local_buffers[index];
4436 index -= effect->local_buffer_count;
4437
4438 return effect->pool ? d3d10_effect_get_buffer_by_index(effect->pool, index) : NULL;
4439 }
4440
4441 static BOOL is_var_shared(const struct d3d10_effect_variable *v)
4442 {
4443 return !!(v->flag & D3D10_EFFECT_VARIABLE_POOLED);
4444 }
4445
4446 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByIndex(ID3D10Effect *iface,
4447 UINT index)
4448 {
4449 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4450 struct d3d10_effect_variable *v;
4451
4452 TRACE("iface %p, index %u\n", iface, index);
4453
4454 if ((v = d3d10_effect_get_buffer_by_index(effect, index)))
4455 {
4456 TRACE("Returning %sbuffer %p, name %s.\n", is_var_shared(v) ? "shared " : "", v,
4457 debugstr_a(v->name));
4458 return (ID3D10EffectConstantBuffer *)&v->ID3D10EffectVariable_iface;
4459 }
4460
4461 WARN("Invalid index specified\n");
4462
4463 return (ID3D10EffectConstantBuffer *)&null_local_buffer.ID3D10EffectVariable_iface;
4464 }
4465
4466 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByName(ID3D10Effect *iface,
4467 const char *name)
4468 {
4469 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4470 struct d3d10_effect_variable *v;
4471
4472 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
4473
4474 if ((v = d3d10_effect_get_buffer_by_name(effect, name)))
4475 {
4476 TRACE("Returning %sbuffer %p.\n", is_var_shared(v) ? "shared " : "", v);
4477 return (ID3D10EffectConstantBuffer *)&v->ID3D10EffectVariable_iface;
4478 }
4479
4480 WARN("Invalid name specified\n");
4481
4482 return (ID3D10EffectConstantBuffer *)&null_local_buffer.ID3D10EffectVariable_iface;
4483 }
4484
4485 static struct d3d10_effect_variable * d3d10_effect_get_variable_by_index(
4486 const struct d3d10_effect *effect, unsigned int index)
4487 {
4488 unsigned int i;
4489
4490 for (i = 0; i < effect->local_buffer_count; ++i)
4491 {
4492 struct d3d10_effect_variable *v = &effect->local_buffers[i];
4493 if (index < v->type->member_count)
4494 return &v->members[index];
4495 index -= v->type->member_count;
4496 }
4497
4498 if (index < effect->local_variable_count)
4499 return &effect->local_variables[index];
4500 index -= effect->local_variable_count;
4501
4502 return effect->pool ? d3d10_effect_get_variable_by_index(effect->pool, index) : NULL;
4503 }
4504
4505 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByIndex(ID3D10Effect *iface, UINT index)
4506 {
4507 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4508 struct d3d10_effect_variable *v;
4509
4510 TRACE("iface %p, index %u\n", iface, index);
4511
4512 if ((v = d3d10_effect_get_variable_by_index(effect, index)))
4513 {
4514 TRACE("Returning %svariable %s.\n", is_var_shared(v) ? "shared " : "", debugstr_a(v->name));
4515 return &v->ID3D10EffectVariable_iface;
4516 }
4517
4518 WARN("Invalid index specified\n");
4519
4520 return &null_variable.ID3D10EffectVariable_iface;
4521 }
4522
4523 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByName(ID3D10Effect *iface,
4524 const char *name)
4525 {
4526 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4527 struct d3d10_effect_variable *v;
4528
4529 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
4530
4531 if (!name)
4532 {
4533 WARN("Invalid name specified\n");
4534 return &null_variable.ID3D10EffectVariable_iface;
4535 }
4536
4537 if ((v = d3d10_effect_get_variable_by_name(effect, name)))
4538 {
4539 TRACE("Returning %svariable %p.\n", is_var_shared(v) ? "shared " : "", v);
4540 return &v->ID3D10EffectVariable_iface;
4541 }
4542
4543 WARN("Invalid name specified\n");
4544
4545 return &null_variable.ID3D10EffectVariable_iface;
4546 }
4547
4548 static struct d3d10_effect_variable * d3d10_effect_get_variable_by_semantic(
4549 const struct d3d10_effect *effect, const char *semantic)
4550 {
4551 unsigned int i;
4552
4553 for (i = 0; i < effect->local_buffer_count; ++i)
4554 {
4555 struct d3d10_effect_variable *l = &effect->local_buffers[i];
4556 unsigned int j;
4557
4558 for (j = 0; j < l->type->member_count; ++j)
4559 {
4560 struct d3d10_effect_variable *v = &l->members[j];
4561
4562 if (v->semantic && !stricmp(v->semantic, semantic))
4563 return v;
4564 }
4565 }
4566
4567 for (i = 0; i < effect->local_variable_count; ++i)
4568 {
4569 struct d3d10_effect_variable *v = &effect->local_variables[i];
4570
4571 if (v->semantic && !stricmp(v->semantic, semantic))
4572 return v;
4573 }
4574
4575 return effect->pool ? d3d10_effect_get_variable_by_semantic(effect->pool, semantic) : NULL;
4576 }
4577
4578 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableBySemantic(ID3D10Effect *iface,
4579 const char *semantic)
4580 {
4581 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4582 struct d3d10_effect_variable *v;
4583
4584 TRACE("iface %p, semantic %s\n", iface, debugstr_a(semantic));
4585
4586 if (!semantic)
4587 {
4588 WARN("Invalid semantic specified\n");
4589 return &null_variable.ID3D10EffectVariable_iface;
4590 }
4591
4592 if ((v = d3d10_effect_get_variable_by_semantic(effect, semantic)))
4593 {
4594 TRACE("Returning %svariable %s.\n", is_var_shared(v) ? "shared " : "", debugstr_a(v->name));
4595 return &v->ID3D10EffectVariable_iface;
4596 }
4597
4598 WARN("Invalid semantic specified\n");
4599
4600 return &null_variable.ID3D10EffectVariable_iface;
4601 }
4602
4603 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByIndex(ID3D10Effect *iface,
4604 UINT index)
4605 {
4606 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
4607 struct d3d10_effect_technique *t;
4608
4609 TRACE("iface %p, index %u\n", iface, index);
4610
4611 if (index >= This->technique_count)
4612 {
4613 WARN("Invalid index specified\n");
4614 return &null_technique.ID3D10EffectTechnique_iface;
4615 }
4616
4617 t = &This->techniques[index];
4618
4619 TRACE("Returning technique %p, %s.\n", t, debugstr_a(t->name));
4620
4621 return &t->ID3D10EffectTechnique_iface;
4622 }
4623
4624 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByName(ID3D10Effect *iface,
4625 const char *name)
4626 {
4627 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
4628 unsigned int i;
4629
4630 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
4631
4632 if (!name)
4633 {
4634 WARN("Invalid name specified\n");
4635 return &null_technique.ID3D10EffectTechnique_iface;
4636 }
4637
4638 for (i = 0; i < This->technique_count; ++i)
4639 {
4640 struct d3d10_effect_technique *t = &This->techniques[i];
4641 if (t->name && !strcmp(t->name, name))
4642 {
4643 TRACE("Returning technique %p\n", t);
4644 return &t->ID3D10EffectTechnique_iface;
4645 }
4646 }
4647
4648 WARN("Invalid name specified\n");
4649
4650 return &null_technique.ID3D10EffectTechnique_iface;
4651 }
4652
4653 static HRESULT STDMETHODCALLTYPE d3d10_effect_Optimize(ID3D10Effect *iface)
4654 {
4655 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4656 struct d3d10_effect_variable *v;
4657 unsigned int i, j;
4658
4659 FIXME("iface %p semi-stub!\n", iface);
4660
4661 if (effect->flags & D3D10_EFFECT_OPTIMIZED)
4662 return S_OK;
4663
4664 for (i = 0; i < effect->shaders.count; ++i)
4665 {
4666 v = effect->shaders.v[i];
4667
4668 if (v->u.shader.reflection)
4669 {
4670 v->u.shader.reflection->lpVtbl->Release(v->u.shader.reflection);
4671 v->u.shader.reflection = NULL;
4672 }
4673 if (v->u.shader.bytecode)
4674 {
4675 ID3D10Blob_Release(v->u.shader.bytecode);
4676 v->u.shader.bytecode = NULL;
4677 }
4678 free(v->u.shader.stream_output_declaration);
4679 v->u.shader.stream_output_declaration = NULL;
4680 }
4681
4682 for (i = 0; i < effect->technique_count; ++i)
4683 {
4684 for (j = 0; j < effect->techniques[i].pass_count; ++j)
4685 {
4686 free(effect->techniques[i].passes[j].name);
4687 effect->techniques[i].passes[j].name = NULL;
4688 }
4689
4690 free(effect->techniques[i].name);
4691 effect->techniques[i].name = NULL;
4692 }
4693
4694 effect->flags |= D3D10_EFFECT_OPTIMIZED;
4695
4696 return S_OK;
4697 }
4698
4699 static BOOL STDMETHODCALLTYPE d3d10_effect_IsOptimized(ID3D10Effect *iface)
4700 {
4701 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
4702
4703 TRACE("iface %p.\n", iface);
4704
4705 return !!(effect->flags & D3D10_EFFECT_OPTIMIZED);
4706 }
4707
4708 static const struct ID3D10EffectVtbl d3d10_effect_vtbl =
4709 {
4710 /* IUnknown methods */
4711 d3d10_effect_QueryInterface,
4712 d3d10_effect_AddRef,
4713 d3d10_effect_Release,
4714 /* ID3D10Effect methods */
4715 d3d10_effect_IsValid,
4716 d3d10_effect_IsPool,
4717 d3d10_effect_GetDevice,
4718 d3d10_effect_GetDesc,
4719 d3d10_effect_GetConstantBufferByIndex,
4720 d3d10_effect_GetConstantBufferByName,
4721 d3d10_effect_GetVariableByIndex,
4722 d3d10_effect_GetVariableByName,
4723 d3d10_effect_GetVariableBySemantic,
4724 d3d10_effect_GetTechniqueByIndex,
4725 d3d10_effect_GetTechniqueByName,
4726 d3d10_effect_Optimize,
4727 d3d10_effect_IsOptimized,
4728 };
4729
4730 /* ID3D10EffectTechnique methods */
4731
4732 static inline struct d3d10_effect_technique *impl_from_ID3D10EffectTechnique(ID3D10EffectTechnique *iface)
4733 {
4734 return CONTAINING_RECORD(iface, struct d3d10_effect_technique, ID3D10EffectTechnique_iface);
4735 }
4736
4737 static BOOL STDMETHODCALLTYPE d3d10_effect_technique_IsValid(ID3D10EffectTechnique *iface)
4738 {
4739 struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
4740
4741 TRACE("iface %p\n", iface);
4742
4743 return This != &null_technique;
4744 }
4745
4746 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_GetDesc(ID3D10EffectTechnique *iface,
4747 D3D10_TECHNIQUE_DESC *desc)
4748 {
4749 struct d3d10_effect_technique *tech = impl_from_ID3D10EffectTechnique(iface);
4750
4751 TRACE("iface %p, desc %p\n", iface, desc);
4752
4753 if (tech == &null_technique)
4754 {
4755 WARN("Null technique specified\n");
4756 return E_FAIL;
4757 }
4758
4759 if (!desc)
4760 {
4761 WARN("Invalid argument specified\n");
4762 return E_INVALIDARG;
4763 }
4764
4765 desc->Name = tech->name;
4766 desc->Passes = tech->pass_count;
4767 desc->Annotations = tech->annotations.count;
4768
4769 return S_OK;
4770 }
4771
4772 static ID3D10EffectVariable * d3d10_annotation_get_by_index(const struct d3d10_effect_annotations *annotations,
4773 unsigned int index)
4774 {
4775 struct d3d10_effect_variable *a;
4776
4777 if (index >= annotations->count)
4778 {
4779 WARN("Invalid index specified\n");
4780 return &null_variable.ID3D10EffectVariable_iface;
4781 }
4782
4783 a = &annotations->elements[index];
4784
4785 TRACE("Returning annotation %p, name %s.\n", a, debugstr_a(a->name));
4786
4787 return &a->ID3D10EffectVariable_iface;
4788 }
4789
4790 static ID3D10EffectVariable * d3d10_annotation_get_by_name(const struct d3d10_effect_annotations *annotations,
4791 const char *name)
4792 {
4793 unsigned int i;
4794
4795 for (i = 0; i < annotations->count; ++i)
4796 {
4797 struct d3d10_effect_variable *a = &annotations->elements[i];
4798 if (a->name && !strcmp(a->name, name))
4799 {
4800 TRACE("Returning annotation %p.\n", a);
4801 return &a->ID3D10EffectVariable_iface;
4802 }
4803 }
4804
4805 WARN("Invalid name specified.\n");
4806
4807 return &null_variable.ID3D10EffectVariable_iface;
4808 }
4809
4810 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByIndex(
4811 ID3D10EffectTechnique *iface, UINT index)
4812 {
4813 struct d3d10_effect_technique *tech = impl_from_ID3D10EffectTechnique(iface);
4814
4815 TRACE("iface %p, index %u\n", iface, index);
4816
4817 return d3d10_annotation_get_by_index(&tech->annotations, index);
4818 }
4819
4820 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByName(
4821 ID3D10EffectTechnique *iface, const char *name)
4822 {
4823 struct d3d10_effect_technique *tech = impl_from_ID3D10EffectTechnique(iface);
4824
4825 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
4826
4827 return d3d10_annotation_get_by_name(&tech->annotations, name);
4828 }
4829
4830 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique *iface,
4831 UINT index)
4832 {
4833 struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
4834 struct d3d10_effect_pass *p;
4835
4836 TRACE("iface %p, index %u\n", iface, index);
4837
4838 if (index >= This->pass_count)
4839 {
4840 WARN("Invalid index specified\n");
4841 return &null_pass.ID3D10EffectPass_iface;
4842 }
4843
4844 p = &This->passes[index];
4845
4846 TRACE("Returning pass %p, %s.\n", p, debugstr_a(p->name));
4847
4848 return &p->ID3D10EffectPass_iface;
4849 }
4850
4851 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique *iface,
4852 const char *name)
4853 {
4854 struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
4855 unsigned int i;
4856
4857 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
4858
4859 /* Do not check for name==NULL, W7/DX10 crashes in that case. */
4860
4861 for (i = 0; i < This->pass_count; ++i)
4862 {
4863 struct d3d10_effect_pass *p = &This->passes[i];
4864 if (p->name && !strcmp(p->name, name))
4865 {
4866 TRACE("Returning pass %p\n", p);
4867 return &p->ID3D10EffectPass_iface;
4868 }
4869 }
4870
4871 WARN("Invalid name specified\n");
4872
4873 return &null_pass.ID3D10EffectPass_iface;
4874 }
4875
4876 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique *iface,
4877 D3D10_STATE_BLOCK_MASK *mask)
4878 {
4879 FIXME("iface %p,mask %p stub!\n", iface, mask);
4880
4881 return E_NOTIMPL;
4882 }
4883
4884 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl =
4885 {
4886 /* ID3D10EffectTechnique methods */
4887 d3d10_effect_technique_IsValid,
4888 d3d10_effect_technique_GetDesc,
4889 d3d10_effect_technique_GetAnnotationByIndex,
4890 d3d10_effect_technique_GetAnnotationByName,
4891 d3d10_effect_technique_GetPassByIndex,
4892 d3d10_effect_technique_GetPassByName,
4893 d3d10_effect_technique_ComputeStateBlockMask,
4894 };
4895
4896 /* ID3D10EffectPass methods */
4897
4898 static inline struct d3d10_effect_pass *impl_from_ID3D10EffectPass(ID3D10EffectPass *iface)
4899 {
4900 return CONTAINING_RECORD(iface, struct d3d10_effect_pass, ID3D10EffectPass_iface);
4901 }
4902
4903 static BOOL STDMETHODCALLTYPE d3d10_effect_pass_IsValid(ID3D10EffectPass *iface)
4904 {
4905 struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
4906
4907 TRACE("iface %p\n", iface);
4908
4909 return This != &null_pass;
4910 }
4911
4912 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetDesc(ID3D10EffectPass *iface,
4913 D3D10_PASS_DESC *desc)
4914 {
4915 struct d3d10_effect_pass *pass = impl_from_ID3D10EffectPass(iface);
4916 struct d3d10_effect_variable *vs;
4917 ID3D10Blob *input_signature;
4918
4919 TRACE("iface %p, desc %p.\n", iface, desc);
4920
4921 if (pass == &null_pass)
4922 {
4923 WARN("Null pass specified\n");
4924 return E_FAIL;
4925 }
4926
4927 if (!desc)
4928 {
4929 WARN("Invalid argument specified\n");
4930 return E_INVALIDARG;
4931 }
4932
4933 d3d10_effect_update_dependent_props(&pass->dependencies, pass);
4934
4935 vs = d3d10_array_get_element(pass->vs.shader, pass->vs.index);
4936 input_signature = vs->u.shader.input_signature;
4937
4938 desc->Name = pass->name;
4939 desc->Annotations = pass->annotations.count;
4940 if (input_signature)
4941 {
4942 desc->pIAInputSignature = ID3D10Blob_GetBufferPointer(input_signature);
4943 desc->IAInputSignatureSize = ID3D10Blob_GetBufferSize(input_signature);
4944 }
4945 else
4946 {
4947 desc->pIAInputSignature = NULL;
4948 desc->IAInputSignatureSize = 0;
4949 }
4950 desc->StencilRef = pass->stencil_ref;
4951 desc->SampleMask = pass->sample_mask;
4952 memcpy(desc->BlendFactor, pass->blend_factor, 4 * sizeof(float));
4953
4954 return S_OK;
4955 }
4956
4957 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass *iface,
4958 D3D10_PASS_SHADER_DESC *desc)
4959 {
4960 struct d3d10_effect_pass *pass = impl_from_ID3D10EffectPass(iface);
4961
4962 TRACE("iface %p, desc %p.\n", iface, desc);
4963
4964 if (pass == &null_pass)
4965 {
4966 WARN("Null pass specified.\n");
4967 return E_FAIL;
4968 }
4969
4970 if (!desc)
4971 {
4972 WARN("Invalid argument specified.\n");
4973 return E_INVALIDARG;
4974 }
4975
4976 d3d10_effect_update_dependent_props(&pass->dependencies, pass);
4977
4978 desc->pShaderVariable = (ID3D10EffectShaderVariable *)&pass->vs.shader->ID3D10EffectVariable_iface;
4979 desc->ShaderIndex = pass->vs.index;
4980
4981 return S_OK;
4982 }
4983
4984 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass *iface,
4985 D3D10_PASS_SHADER_DESC *desc)
4986 {
4987 struct d3d10_effect_pass *pass = impl_from_ID3D10EffectPass(iface);
4988
4989 TRACE("iface %p, desc %p.\n", iface, desc);
4990
4991 if (pass == &null_pass)
4992 {
4993 WARN("Null pass specified.\n");
4994 return E_FAIL;
4995 }
4996
4997 if (!desc)
4998 {
4999 WARN("Invalid argument specified.\n");
5000 return E_INVALIDARG;
5001 }
5002
5003 d3d10_effect_update_dependent_props(&pass->dependencies, pass);
5004
5005 desc->pShaderVariable = (ID3D10EffectShaderVariable *)&pass->gs.shader->ID3D10EffectVariable_iface;
5006 desc->ShaderIndex = pass->gs.index;
5007
5008 return S_OK;
5009 }
5010
5011 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass *iface,
5012 D3D10_PASS_SHADER_DESC *desc)
5013 {
5014 struct d3d10_effect_pass *pass = impl_from_ID3D10EffectPass(iface);
5015
5016 TRACE("iface %p, desc %p.\n", iface, desc);
5017
5018 if (pass == &null_pass)
5019 {
5020 WARN("Null pass specified.\n");
5021 return E_FAIL;
5022 }
5023
5024 if (!desc)
5025 {
5026 WARN("Invalid argument specified.\n");
5027 return E_INVALIDARG;
5028 }
5029
5030 d3d10_effect_update_dependent_props(&pass->dependencies, pass);
5031
5032 desc->pShaderVariable = (ID3D10EffectShaderVariable *)&pass->ps.shader->ID3D10EffectVariable_iface;
5033 desc->ShaderIndex = pass->ps.index;
5034
5035 return S_OK;
5036 }
5037
5038 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass *iface,
5039 UINT index)
5040 {
5041 struct d3d10_effect_pass *pass = impl_from_ID3D10EffectPass(iface);
5042
5043 TRACE("iface %p, index %u\n", iface, index);
5044
5045 return d3d10_annotation_get_by_index(&pass->annotations, index);
5046 }
5047
5048 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass *iface,
5049 const char *name)
5050 {
5051 struct d3d10_effect_pass *pass = impl_from_ID3D10EffectPass(iface);
5052
5053 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
5054
5055 return d3d10_annotation_get_by_name(&pass->annotations, name);
5056 }
5057
5058 static void update_buffer(ID3D10Device *device, struct d3d10_effect_variable *v)
5059 {
5060 struct d3d10_effect_buffer_variable *b = &v->u.buffer;
5061
5062 if (!b->changed)
5063 return;
5064
5065 ID3D10Device_UpdateSubresource(device, (ID3D10Resource *)b->buffer, 0, NULL,
5066 b->local_buffer, v->data_size, 0);
5067
5068 b->changed = FALSE;
5069 }
5070
5071 static void set_sampler(ID3D10Device *device, D3D10_SHADER_VARIABLE_TYPE shader_type,
5072 struct d3d10_effect_variable *v, unsigned int bind_point)
5073 {
5074 switch (shader_type)
5075 {
5076 case D3D10_SVT_VERTEXSHADER:
5077 ID3D10Device_VSSetSamplers(device, bind_point, 1, &v->u.state.object.sampler);
5078 break;
5079
5080 case D3D10_SVT_PIXELSHADER:
5081 ID3D10Device_PSSetSamplers(device, bind_point, 1, &v->u.state.object.sampler);
5082 break;
5083
5084 case D3D10_SVT_GEOMETRYSHADER:
5085 ID3D10Device_GSSetSamplers(device, bind_point, 1, &v->u.state.object.sampler);
5086 break;
5087
5088 default:
5089 WARN("Incorrect shader type to bind sampler.\n");
5090 break;
5091 }
5092 }
5093
5094 static void apply_shader_resources(ID3D10Device *device, struct d3d10_effect_variable *v)
5095 {
5096 struct d3d10_effect_shader_variable *sv = &v->u.shader;
5097 struct d3d10_effect_shader_resource *sr;
5098 struct d3d10_effect_variable *rsrc_v;
5099 ID3D10ShaderResourceView **srv;
5100 unsigned int i, j;
5101
5102 for (i = 0; i < sv->resource_count; ++i)
5103 {
5104 sr = &sv->resources[i];
5105 rsrc_v = sr->variable;
5106
5107 switch (sr->in_type)
5108 {
5109 case D3D10_SIT_CBUFFER:
5110 update_buffer(device, rsrc_v);
5111 switch (v->type->basetype)
5112 {
5113 case D3D10_SVT_VERTEXSHADER:
5114 ID3D10Device_VSSetConstantBuffers(device, sr->bind_point, 1,
5115 &rsrc_v->u.buffer.buffer);
5116 break;
5117
5118 case D3D10_SVT_PIXELSHADER:
5119 ID3D10Device_PSSetConstantBuffers(device, sr->bind_point, 1,
5120 &rsrc_v->u.buffer.buffer);
5121 break;
5122
5123 case D3D10_SVT_GEOMETRYSHADER:
5124 ID3D10Device_GSSetConstantBuffers(device, sr->bind_point, 1,
5125 &rsrc_v->u.buffer.buffer);
5126 break;
5127
5128 default:
5129 WARN("Incorrect shader type to bind constant buffer.\n");
5130 break;
5131 }
5132 break;
5133
5134 case D3D10_SIT_TEXTURE:
5135
5136 if (rsrc_v->type->basetype == D3D10_SVT_SAMPLER)
5137 {
5138 TRACE("Using texture associated with sampler %s.\n", debugstr_a(rsrc_v->name));
5139 rsrc_v = rsrc_v->u.state.desc.sampler.texture;
5140 }
5141
5142 /* fallthrough */
5143 case D3D10_SIT_TBUFFER:
5144
5145 if (sr->in_type == D3D10_SIT_TBUFFER)
5146 {
5147 update_buffer(device, rsrc_v);
5148 srv = &rsrc_v->u.buffer.resource_view;
5149 }
5150 else
5151 srv = rsrc_v->u.resource.srv;
5152
5153 switch (v->type->basetype)
5154 {
5155 case D3D10_SVT_VERTEXSHADER:
5156 ID3D10Device_VSSetShaderResources(device, sr->bind_point, sr->bind_count, srv);
5157 break;
5158
5159 case D3D10_SVT_PIXELSHADER:
5160 ID3D10Device_PSSetShaderResources(device, sr->bind_point, sr->bind_count, srv);
5161 break;
5162
5163 case D3D10_SVT_GEOMETRYSHADER:
5164 ID3D10Device_GSSetShaderResources(device, sr->bind_point, sr->bind_count, srv);
5165 break;
5166
5167 default:
5168 WARN("Incorrect shader type to bind shader resource view.\n");
5169 break;
5170 }
5171 break;
5172
5173 case D3D10_SIT_SAMPLER:
5174 if (!rsrc_v->type->element_count)
5175 {
5176 set_sampler(device, v->type->basetype, rsrc_v, sr->bind_point);
5177 break;
5178 }
5179
5180 for (j = 0; j < sr->bind_count; ++j)
5181 set_sampler(device, v->type->basetype, &rsrc_v->elements[j], sr->bind_point + j);
5182 break;
5183
5184 default:
5185 WARN("Unhandled shader resource %#x.\n", sr->in_type);
5186 break;
5187 }
5188 }
5189 }
5190
5191 static void d3d10_effect_pass_set_shader(struct d3d10_effect_pass *pass,
5192 const struct d3d10_effect_pass_shader_desc *shader_desc)
5193 {
5194 ID3D10Device *device = pass->technique->effect->device;
5195 struct d3d10_effect_variable *v;
5196
5197 v = d3d10_array_get_element(shader_desc->shader, shader_desc->index);
5198
5199 switch (v->type->basetype)
5200 {
5201 case D3D10_SVT_VERTEXSHADER:
5202 ID3D10Device_VSSetShader(device, v->u.shader.shader.vs);
5203 break;
5204 case D3D10_SVT_PIXELSHADER:
5205 ID3D10Device_PSSetShader(device, v->u.shader.shader.ps);
5206 break;
5207 case D3D10_SVT_GEOMETRYSHADER:
5208 ID3D10Device_GSSetShader(device, v->u.shader.shader.gs);
5209 break;
5210 default:
5211 WARN("Unexpected shader type %u.\n", v->type->basetype);
5212 }
5213
5214 apply_shader_resources(device, v);
5215 }
5216
5217 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_Apply(ID3D10EffectPass *iface, UINT flags)
5218 {
5219 struct d3d10_effect_pass *pass = impl_from_ID3D10EffectPass(iface);
5220 ID3D10Device *device = pass->technique->effect->device;
5221
5222 TRACE("iface %p, flags %#x\n", iface, flags);
5223
5224 if (flags) FIXME("Ignoring flags (%#x)\n", flags);
5225
5226 d3d10_effect_update_dependent_props(&pass->dependencies, pass);
5227
5228 if (pass->vs.shader != &null_shader_variable)
5229 d3d10_effect_pass_set_shader(pass, &pass->vs);
5230 if (pass->gs.shader != &null_shader_variable)
5231 d3d10_effect_pass_set_shader(pass, &pass->gs);
5232 if (pass->ps.shader != &null_shader_variable)
5233 d3d10_effect_pass_set_shader(pass, &pass->ps);
5234 if (pass->rasterizer)
5235 ID3D10Device_RSSetState(device, pass->rasterizer->u.state.object.rasterizer);
5236 if (pass->depth_stencil)
5237 ID3D10Device_OMSetDepthStencilState(device, pass->depth_stencil->u.state.object.depth_stencil,
5238 pass->stencil_ref);
5239 if (pass->blend)
5240 ID3D10Device_OMSetBlendState(device, pass->blend->u.state.object.blend,
5241 pass->blend_factor, pass->sample_mask);
5242
5243 return S_OK;
5244 }
5245
5246 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass *iface,
5247 D3D10_STATE_BLOCK_MASK *mask)
5248 {
5249 struct d3d10_effect_pass *pass = impl_from_ID3D10EffectPass(iface);
5250
5251 FIXME("iface %p, mask %p semi-stub!\n", iface, mask);
5252
5253 if (pass->vs.shader != &null_shader_variable)
5254 D3D10StateBlockMaskEnableCapture(mask, D3D10_DST_VS, 0, 1);
5255 if (pass->ps.shader != &null_shader_variable)
5256 D3D10StateBlockMaskEnableCapture(mask, D3D10_DST_PS, 0, 1);
5257 if (pass->gs.shader != &null_shader_variable)
5258 D3D10StateBlockMaskEnableCapture(mask, D3D10_DST_GS, 0, 1);
5259 if (pass->rasterizer)
5260 D3D10StateBlockMaskEnableCapture(mask, D3D10_DST_RS_RASTERIZER_STATE, 0, 1);
5261 if (pass->depth_stencil)
5262 D3D10StateBlockMaskEnableCapture(mask, D3D10_DST_OM_DEPTH_STENCIL_STATE, 0, 1);
5263 if (pass->blend)
5264 D3D10StateBlockMaskEnableCapture(mask, D3D10_DST_OM_BLEND_STATE, 0, 1);
5265
5266 return S_OK;
5267 }
5268
5269 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl =
5270 {
5271 /* ID3D10EffectPass methods */
5272 d3d10_effect_pass_IsValid,
5273 d3d10_effect_pass_GetDesc,
5274 d3d10_effect_pass_GetVertexShaderDesc,
5275 d3d10_effect_pass_GetGeometryShaderDesc,
5276 d3d10_effect_pass_GetPixelShaderDesc,
5277 d3d10_effect_pass_GetAnnotationByIndex,
5278 d3d10_effect_pass_GetAnnotationByName,
5279 d3d10_effect_pass_Apply,
5280 d3d10_effect_pass_ComputeStateBlockMask,
5281 };
5282
5283 /* ID3D10EffectVariable methods */
5284
5285 static BOOL STDMETHODCALLTYPE d3d10_effect_variable_IsValid(ID3D10EffectVariable *iface)
5286 {
5287 TRACE("iface %p\n", iface);
5288
5289 return impl_from_ID3D10EffectVariable(iface) != &null_variable;
5290 }
5291
5292 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_variable_GetType(ID3D10EffectVariable *iface)
5293 {
5294 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5295
5296 TRACE("iface %p\n", iface);
5297
5298 return &This->type->ID3D10EffectType_iface;
5299 }
5300
5301 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetDesc(ID3D10EffectVariable *iface,
5302 D3D10_EFFECT_VARIABLE_DESC *desc)
5303 {
5304 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable(iface);
5305
5306 TRACE("iface %p, desc %p\n", iface, desc);
5307
5308 if (!iface->lpVtbl->IsValid(iface))
5309 {
5310 WARN("Null variable specified\n");
5311 return E_FAIL;
5312 }
5313
5314 if (!desc)
5315 {
5316 WARN("Invalid argument specified\n");
5317 return E_INVALIDARG;
5318 }
5319
5320 /* FIXME: This isn't correct. Anonymous shaders let desc->ExplicitBindPoint untouched, but normal shaders set it! */
5321 memset(desc, 0, sizeof(*desc));
5322 desc->Name = v->name;
5323 desc->Semantic = v->semantic;
5324 desc->Flags = v->flag;
5325 desc->Annotations = v->annotations.count;
5326 desc->BufferOffset = v->buffer_offset;
5327
5328 if (v->flag & D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
5329 desc->ExplicitBindPoint = v->explicit_bind_point;
5330
5331 return S_OK;
5332 }
5333
5334 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByIndex(
5335 ID3D10EffectVariable *iface, UINT index)
5336 {
5337 struct d3d10_effect_variable *var = impl_from_ID3D10EffectVariable(iface);
5338
5339 TRACE("iface %p, index %u\n", iface, index);
5340
5341 return d3d10_annotation_get_by_index(&var->annotations, index);
5342 }
5343
5344 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByName(
5345 ID3D10EffectVariable *iface, const char *name)
5346 {
5347 struct d3d10_effect_variable *var = impl_from_ID3D10EffectVariable(iface);
5348
5349 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
5350
5351 return d3d10_annotation_get_by_name(&var->annotations, name);
5352 }
5353
5354 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByIndex(
5355 ID3D10EffectVariable *iface, UINT index)
5356 {
5357 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5358 struct d3d10_effect_variable *m;
5359
5360 TRACE("iface %p, index %u\n", iface, index);
5361
5362 if (index >= This->type->member_count)
5363 {
5364 WARN("Invalid index specified\n");
5365 return &null_variable.ID3D10EffectVariable_iface;
5366 }
5367
5368 m = &This->members[index];
5369
5370 TRACE("Returning member %p, %s\n", m, debugstr_a(m->name));
5371
5372 return &m->ID3D10EffectVariable_iface;
5373 }
5374
5375 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByName(
5376 ID3D10EffectVariable *iface, const char *name)
5377 {
5378 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5379 unsigned int i;
5380
5381 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
5382
5383 if (!name)
5384 {
5385 WARN("Invalid name specified\n");
5386 return &null_variable.ID3D10EffectVariable_iface;
5387 }
5388
5389 for (i = 0; i < This->type->member_count; ++i)
5390 {
5391 struct d3d10_effect_variable *m = &This->members[i];
5392
5393 if (m->name && !strcmp(m->name, name))
5394 {
5395 TRACE("Returning member %p\n", m);
5396 return &m->ID3D10EffectVariable_iface;
5397 }
5398 }
5399
5400 WARN("Invalid name specified\n");
5401
5402 return &null_variable.ID3D10EffectVariable_iface;
5403 }
5404
5405 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberBySemantic(
5406 ID3D10EffectVariable *iface, const char *semantic)
5407 {
5408 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5409 unsigned int i;
5410
5411 TRACE("iface %p, semantic %s.\n", iface, debugstr_a(semantic));
5412
5413 if (!semantic)
5414 {
5415 WARN("Invalid semantic specified\n");
5416 return &null_variable.ID3D10EffectVariable_iface;
5417 }
5418
5419 for (i = 0; i < This->type->member_count; ++i)
5420 {
5421 struct d3d10_effect_variable *m = &This->members[i];
5422
5423 if (m->semantic && !stricmp(m->semantic, semantic))
5424 {
5425 TRACE("Returning member %p\n", m);
5426 return &m->ID3D10EffectVariable_iface;
5427 }
5428 }
5429
5430 WARN("Invalid semantic specified\n");
5431
5432 return &null_variable.ID3D10EffectVariable_iface;
5433 }
5434
5435 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetElement(
5436 ID3D10EffectVariable *iface, UINT index)
5437 {
5438 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5439 struct d3d10_effect_variable *v;
5440
5441 TRACE("iface %p, index %u\n", iface, index);
5442
5443 if (index >= This->type->element_count)
5444 {
5445 WARN("Invalid index specified\n");
5446 return &null_variable.ID3D10EffectVariable_iface;
5447 }
5448
5449 v = &This->elements[index];
5450
5451 TRACE("Returning element %p, %s\n", v, debugstr_a(v->name));
5452
5453 return &v->ID3D10EffectVariable_iface;
5454 }
5455
5456 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_GetParentConstantBuffer(
5457 ID3D10EffectVariable *iface)
5458 {
5459 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5460
5461 TRACE("iface %p\n", iface);
5462
5463 return (ID3D10EffectConstantBuffer *)&This->buffer->ID3D10EffectVariable_iface;
5464 }
5465
5466 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsScalar(
5467 ID3D10EffectVariable *iface)
5468 {
5469 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5470
5471 TRACE("iface %p\n", iface);
5472
5473 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl)
5474 return (ID3D10EffectScalarVariable *)&This->ID3D10EffectVariable_iface;
5475
5476 return (ID3D10EffectScalarVariable *)&null_scalar_variable.ID3D10EffectVariable_iface;
5477 }
5478
5479 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsVector(
5480 ID3D10EffectVariable *iface)
5481 {
5482 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5483
5484 TRACE("iface %p\n", iface);
5485
5486 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl)
5487 return (ID3D10EffectVectorVariable *)&This->ID3D10EffectVariable_iface;
5488
5489 return (ID3D10EffectVectorVariable *)&null_vector_variable.ID3D10EffectVariable_iface;
5490 }
5491
5492 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsMatrix(
5493 ID3D10EffectVariable *iface)
5494 {
5495 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5496
5497 TRACE("iface %p\n", iface);
5498
5499 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl)
5500 return (ID3D10EffectMatrixVariable *)&This->ID3D10EffectVariable_iface;
5501
5502 return (ID3D10EffectMatrixVariable *)&null_matrix_variable.ID3D10EffectVariable_iface;
5503 }
5504
5505 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsString(
5506 ID3D10EffectVariable *iface)
5507 {
5508 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5509
5510 TRACE("iface %p\n", iface);
5511
5512 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl)
5513 return (ID3D10EffectStringVariable *)&This->ID3D10EffectVariable_iface;
5514
5515 return (ID3D10EffectStringVariable *)&null_string_variable.ID3D10EffectVariable_iface;
5516 }
5517
5518 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShaderResource(
5519 ID3D10EffectVariable *iface)
5520 {
5521 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5522
5523 TRACE("iface %p\n", iface);
5524
5525 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl)
5526 return (ID3D10EffectShaderResourceVariable *)&This->ID3D10EffectVariable_iface;
5527
5528 return (ID3D10EffectShaderResourceVariable *)&null_shader_resource_variable.ID3D10EffectVariable_iface;
5529 }
5530
5531 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRenderTargetView(
5532 ID3D10EffectVariable *iface)
5533 {
5534 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5535
5536 TRACE("iface %p\n", iface);
5537
5538 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl)
5539 return (ID3D10EffectRenderTargetViewVariable *)&This->ID3D10EffectVariable_iface;
5540
5541 return (ID3D10EffectRenderTargetViewVariable *)&null_render_target_view_variable.ID3D10EffectVariable_iface;
5542 }
5543
5544 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencilView(
5545 ID3D10EffectVariable *iface)
5546 {
5547 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5548
5549 TRACE("iface %p\n", iface);
5550
5551 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl)
5552 return (ID3D10EffectDepthStencilViewVariable *)&This->ID3D10EffectVariable_iface;
5553
5554 return (ID3D10EffectDepthStencilViewVariable *)&null_depth_stencil_view_variable.ID3D10EffectVariable_iface;
5555 }
5556
5557 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_AsConstantBuffer(
5558 ID3D10EffectVariable *iface)
5559 {
5560 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5561
5562 TRACE("iface %p\n", iface);
5563
5564 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl)
5565 return (ID3D10EffectConstantBuffer *)&This->ID3D10EffectVariable_iface;
5566
5567 return (ID3D10EffectConstantBuffer *)&null_local_buffer.ID3D10EffectVariable_iface;
5568 }
5569
5570 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShader(
5571 ID3D10EffectVariable *iface)
5572 {
5573 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5574
5575 TRACE("iface %p\n", iface);
5576
5577 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl)
5578 return (ID3D10EffectShaderVariable *)&This->ID3D10EffectVariable_iface;
5579
5580 return (ID3D10EffectShaderVariable *)&null_shader_variable.ID3D10EffectVariable_iface;
5581 }
5582
5583 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsBlend(ID3D10EffectVariable *iface)
5584 {
5585 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5586
5587 TRACE("iface %p\n", iface);
5588
5589 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl)
5590 return (ID3D10EffectBlendVariable *)&This->ID3D10EffectVariable_iface;
5591
5592 return (ID3D10EffectBlendVariable *)&null_blend_variable.ID3D10EffectVariable_iface;
5593 }
5594
5595 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencil(
5596 ID3D10EffectVariable *iface)
5597 {
5598 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5599
5600 TRACE("iface %p\n", iface);
5601
5602 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl)
5603 return (ID3D10EffectDepthStencilVariable *)&This->ID3D10EffectVariable_iface;
5604
5605 return (ID3D10EffectDepthStencilVariable *)&null_depth_stencil_variable.ID3D10EffectVariable_iface;
5606 }
5607
5608 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRasterizer(
5609 ID3D10EffectVariable *iface)
5610 {
5611 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5612
5613 TRACE("iface %p\n", iface);
5614
5615 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl)
5616 return (ID3D10EffectRasterizerVariable *)&This->ID3D10EffectVariable_iface;
5617
5618 return (ID3D10EffectRasterizerVariable *)&null_rasterizer_variable.ID3D10EffectVariable_iface;
5619 }
5620
5621 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsSampler(
5622 ID3D10EffectVariable *iface)
5623 {
5624 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
5625
5626 TRACE("iface %p\n", iface);
5627
5628 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl)
5629 return (ID3D10EffectSamplerVariable *)&This->ID3D10EffectVariable_iface;
5630
5631 return (ID3D10EffectSamplerVariable *)&null_sampler_variable.ID3D10EffectVariable_iface;
5632 }
5633
5634 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_SetRawValue(ID3D10EffectVariable *iface,
5635 void *data, UINT offset, UINT count)
5636 {
5637 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable(iface);
5638 BOOL is_buffer;
5639
5640 TRACE("iface %p, data %p, offset %u, count %u.\n", iface, data, offset, count);
5641
5642 if (!iface->lpVtbl->IsValid(iface))
5643 {
5644 WARN("Invalid variable.\n");
5645 return E_FAIL;
5646 }
5647
5648 is_buffer = v->type->basetype == D3D10_SVT_CBUFFER || v->type->basetype == D3D10_SVT_TBUFFER;
5649
5650 if (v->type->type_class == D3D10_SVC_OBJECT && !is_buffer)
5651 {
5652 WARN("Not supported on object variables of type %s.\n",
5653 debug_d3d10_shader_variable_type(v->type->basetype));
5654 return D3DERR_INVALIDCALL;
5655 }
5656
5657 if (!is_buffer)
5658 {
5659 offset += v->buffer_offset;
5660 v = v->buffer;
5661 }
5662
5663 memcpy(v->u.buffer.local_buffer + offset, data, count);
5664 v->u.buffer.changed = TRUE;
5665
5666 return S_OK;
5667 }
5668
5669 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetRawValue(ID3D10EffectVariable *iface,
5670 void *data, UINT offset, UINT count)
5671 {
5672 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable(iface);
5673
5674 TRACE("iface %p, data %p, offset %u, count %u.\n", iface, data, offset, count);
5675
5676 if (!iface->lpVtbl->IsValid(iface))
5677 {
5678 WARN("Invalid variable.\n");
5679 return E_FAIL;
5680 }
5681
5682 return d3d10_effect_variable_get_raw_value(v, data, offset, count);
5683 }
5684
5685 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl =
5686 {
5687 /* ID3D10EffectVariable methods */
5688 d3d10_effect_variable_IsValid,
5689 d3d10_effect_variable_GetType,
5690 d3d10_effect_variable_GetDesc,
5691 d3d10_effect_variable_GetAnnotationByIndex,
5692 d3d10_effect_variable_GetAnnotationByName,
5693 d3d10_effect_variable_GetMemberByIndex,
5694 d3d10_effect_variable_GetMemberByName,
5695 d3d10_effect_variable_GetMemberBySemantic,
5696 d3d10_effect_variable_GetElement,
5697 d3d10_effect_variable_GetParentConstantBuffer,
5698 d3d10_effect_variable_AsScalar,
5699 d3d10_effect_variable_AsVector,
5700 d3d10_effect_variable_AsMatrix,
5701 d3d10_effect_variable_AsString,
5702 d3d10_effect_variable_AsShaderResource,
5703 d3d10_effect_variable_AsRenderTargetView,
5704 d3d10_effect_variable_AsDepthStencilView,
5705 d3d10_effect_variable_AsConstantBuffer,
5706 d3d10_effect_variable_AsShader,
5707 d3d10_effect_variable_AsBlend,
5708 d3d10_effect_variable_AsDepthStencil,
5709 d3d10_effect_variable_AsRasterizer,
5710 d3d10_effect_variable_AsSampler,
5711 d3d10_effect_variable_SetRawValue,
5712 d3d10_effect_variable_GetRawValue,
5713 };
5714
5715 /* ID3D10EffectVariable methods */
5716 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectConstantBuffer(ID3D10EffectConstantBuffer *iface)
5717 {
5718 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
5719 }
5720
5721 static BOOL STDMETHODCALLTYPE d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer *iface)
5722 {
5723 struct d3d10_effect_variable *v = impl_from_ID3D10EffectConstantBuffer(iface);
5724
5725 TRACE("iface %p.\n", iface);
5726
5727 return v != &null_local_buffer;
5728 }
5729
5730 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer *iface)
5731 {
5732 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5733 }
5734
5735 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer *iface,
5736 D3D10_EFFECT_VARIABLE_DESC *desc)
5737 {
5738 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5739 }
5740
5741 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByIndex(
5742 ID3D10EffectConstantBuffer *iface, UINT index)
5743 {
5744 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5745 }
5746
5747 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByName(
5748 ID3D10EffectConstantBuffer *iface, const char *name)
5749 {
5750 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5751 }
5752
5753 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByIndex(
5754 ID3D10EffectConstantBuffer *iface, UINT index)
5755 {
5756 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5757 }
5758
5759 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByName(
5760 ID3D10EffectConstantBuffer *iface, const char *name)
5761 {
5762 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5763 }
5764
5765 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberBySemantic(
5766 ID3D10EffectConstantBuffer *iface, const char *semantic)
5767 {
5768 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5769 }
5770
5771 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetElement(
5772 ID3D10EffectConstantBuffer *iface, UINT index)
5773 {
5774 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5775 }
5776
5777 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetParentConstantBuffer(
5778 ID3D10EffectConstantBuffer *iface)
5779 {
5780 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5781 }
5782
5783 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsScalar(
5784 ID3D10EffectConstantBuffer *iface)
5785 {
5786 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5787 }
5788
5789 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsVector(
5790 ID3D10EffectConstantBuffer *iface)
5791 {
5792 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5793 }
5794
5795 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsMatrix(
5796 ID3D10EffectConstantBuffer *iface)
5797 {
5798 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5799 }
5800
5801 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsString(
5802 ID3D10EffectConstantBuffer *iface)
5803 {
5804 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5805 }
5806
5807 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShaderResource(
5808 ID3D10EffectConstantBuffer *iface)
5809 {
5810 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5811 }
5812
5813 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRenderTargetView(
5814 ID3D10EffectConstantBuffer *iface)
5815 {
5816 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5817 }
5818
5819 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencilView(
5820 ID3D10EffectConstantBuffer *iface)
5821 {
5822 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5823 }
5824
5825 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsConstantBuffer(
5826 ID3D10EffectConstantBuffer *iface)
5827 {
5828 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5829 }
5830
5831 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShader(
5832 ID3D10EffectConstantBuffer *iface)
5833 {
5834 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5835 }
5836
5837 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer *iface)
5838 {
5839 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5840 }
5841
5842 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencil(
5843 ID3D10EffectConstantBuffer *iface)
5844 {
5845 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5846 }
5847
5848 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRasterizer(
5849 ID3D10EffectConstantBuffer *iface)
5850 {
5851 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5852 }
5853
5854 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsSampler(
5855 ID3D10EffectConstantBuffer *iface)
5856 {
5857 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5858 }
5859
5860 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer *iface,
5861 void *data, UINT offset, UINT count)
5862 {
5863 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5864 }
5865
5866 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer *iface,
5867 void *data, UINT offset, UINT count)
5868 {
5869 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5870 }
5871
5872 /* ID3D10EffectConstantBuffer methods */
5873 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer *iface,
5874 ID3D10Buffer *buffer)
5875 {
5876 FIXME("iface %p, buffer %p stub!\n", iface, buffer);
5877
5878 return E_NOTIMPL;
5879 }
5880
5881 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer *iface,
5882 ID3D10Buffer **buffer)
5883 {
5884 struct d3d10_effect_variable *v = impl_from_ID3D10EffectConstantBuffer(iface);
5885
5886 TRACE("iface %p, buffer %p.\n", iface, buffer);
5887
5888 if (!iface->lpVtbl->IsValid(iface))
5889 {
5890 WARN("Null variable specified.\n");
5891 return E_FAIL;
5892 }
5893
5894 if (v->type->basetype != D3D10_SVT_CBUFFER)
5895 {
5896 WARN("Wrong variable type %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
5897 return D3DERR_INVALIDCALL;
5898 }
5899
5900 *buffer = v->u.buffer.buffer;
5901 ID3D10Buffer_AddRef(*buffer);
5902
5903 return S_OK;
5904 }
5905
5906 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer *iface,
5907 ID3D10ShaderResourceView *view)
5908 {
5909 FIXME("iface %p, view %p stub!\n", iface, view);
5910
5911 return E_NOTIMPL;
5912 }
5913
5914 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer *iface,
5915 ID3D10ShaderResourceView **view)
5916 {
5917 struct d3d10_effect_variable *v = impl_from_ID3D10EffectConstantBuffer(iface);
5918
5919 FIXME("iface %p, view %p stub!\n", iface, view);
5920
5921 if (!iface->lpVtbl->IsValid(iface))
5922 {
5923 WARN("Null variable specified.\n");
5924 return E_FAIL;
5925 }
5926
5927 if (v->type->basetype != D3D10_SVT_TBUFFER)
5928 {
5929 WARN("Wrong variable type %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
5930 return D3DERR_INVALIDCALL;
5931 }
5932
5933 return E_NOTIMPL;
5934 }
5935
5936 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl =
5937 {
5938 /* ID3D10EffectVariable methods */
5939 d3d10_effect_constant_buffer_IsValid,
5940 d3d10_effect_constant_buffer_GetType,
5941 d3d10_effect_constant_buffer_GetDesc,
5942 d3d10_effect_constant_buffer_GetAnnotationByIndex,
5943 d3d10_effect_constant_buffer_GetAnnotationByName,
5944 d3d10_effect_constant_buffer_GetMemberByIndex,
5945 d3d10_effect_constant_buffer_GetMemberByName,
5946 d3d10_effect_constant_buffer_GetMemberBySemantic,
5947 d3d10_effect_constant_buffer_GetElement,
5948 d3d10_effect_constant_buffer_GetParentConstantBuffer,
5949 d3d10_effect_constant_buffer_AsScalar,
5950 d3d10_effect_constant_buffer_AsVector,
5951 d3d10_effect_constant_buffer_AsMatrix,
5952 d3d10_effect_constant_buffer_AsString,
5953 d3d10_effect_constant_buffer_AsShaderResource,
5954 d3d10_effect_constant_buffer_AsRenderTargetView,
5955 d3d10_effect_constant_buffer_AsDepthStencilView,
5956 d3d10_effect_constant_buffer_AsConstantBuffer,
5957 d3d10_effect_constant_buffer_AsShader,
5958 d3d10_effect_constant_buffer_AsBlend,
5959 d3d10_effect_constant_buffer_AsDepthStencil,
5960 d3d10_effect_constant_buffer_AsRasterizer,
5961 d3d10_effect_constant_buffer_AsSampler,
5962 d3d10_effect_constant_buffer_SetRawValue,
5963 d3d10_effect_constant_buffer_GetRawValue,
5964 /* ID3D10EffectConstantBuffer methods */
5965 d3d10_effect_constant_buffer_SetConstantBuffer,
5966 d3d10_effect_constant_buffer_GetConstantBuffer,
5967 d3d10_effect_constant_buffer_SetTextureBuffer,
5968 d3d10_effect_constant_buffer_GetTextureBuffer,
5969 };
5970
5971
5972 static BOOL get_value_as_bool(void *src_data, D3D10_SHADER_VARIABLE_TYPE src_type)
5973 {
5974 switch (src_type)
5975 {
5976 case D3D10_SVT_FLOAT:
5977 case D3D10_SVT_INT:
5978 case D3D10_SVT_UINT:
5979 case D3D10_SVT_BOOL:
5980 if (*(DWORD *)src_data)
5981 return -1;
5982 break;
5983
5984 default:
5985 break;
5986 }
5987
5988 return 0;
5989 }
5990
5991 static int get_value_as_int(void *src_data, D3D10_SHADER_VARIABLE_TYPE src_type)
5992 {
5993 switch (src_type)
5994 {
5995 case D3D10_SVT_FLOAT:
5996 return (int)(*(float *)src_data);
5997
5998 case D3D10_SVT_INT:
5999 case D3D10_SVT_UINT:
6000 return *(int *)src_data;
6001
6002 case D3D10_SVT_BOOL:
6003 return get_value_as_bool(src_data, src_type);
6004
6005 default:
6006 return 0;
6007 }
6008 }
6009
6010 static float get_value_as_float(void *src_data, D3D10_SHADER_VARIABLE_TYPE src_type)
6011 {
6012 switch (src_type)
6013 {
6014 case D3D10_SVT_FLOAT:
6015 return *(float *)src_data;
6016
6017 case D3D10_SVT_INT:
6018 case D3D10_SVT_UINT:
6019 return (float)(*(int *)src_data);
6020
6021 case D3D10_SVT_BOOL:
6022 return (float)get_value_as_bool(src_data, src_type);
6023
6024 default:
6025 return 0.0f;
6026 }
6027 }
6028
6029 static void get_vector_as_type(BYTE *dst_data, D3D_SHADER_VARIABLE_TYPE dst_type,
6030 BYTE *src_data, D3D_SHADER_VARIABLE_TYPE src_type, unsigned int count)
6031 {
6032 DWORD *src_data_dword = (DWORD *)src_data;
6033 DWORD *dst_data_dword = (DWORD *)dst_data;
6034 unsigned int i;
6035
6036 for (i = 0; i < count; ++i, ++dst_data_dword, ++src_data_dword)
6037 {
6038 if (dst_type == src_type)
6039 *dst_data_dword = *src_data_dword;
6040 else
6041 {
6042 switch (dst_type)
6043 {
6044 case D3D10_SVT_FLOAT:
6045 *(float *)dst_data_dword = get_value_as_float(src_data_dword, src_type);
6046 break;
6047
6048 case D3D10_SVT_INT:
6049 case D3D10_SVT_UINT:
6050 *(int *)dst_data_dword = get_value_as_int(src_data_dword, src_type);
6051 break;
6052
6053 case D3D10_SVT_BOOL:
6054 *(BOOL *)dst_data_dword = get_value_as_bool(src_data_dword, src_type);
6055 break;
6056
6057 default:
6058 *dst_data_dword = 0;
6059 break;
6060 }
6061 }
6062 }
6063 }
6064
6065 static void write_variable_to_buffer(struct d3d10_effect_variable *variable, void *src,
6066 D3D_SHADER_VARIABLE_TYPE src_type)
6067 {
6068 BYTE *dst = variable->buffer->u.buffer.local_buffer + variable->buffer_offset;
6069 D3D_SHADER_VARIABLE_TYPE dst_type = variable->type->basetype;
6070
6071 get_vector_as_type(dst, dst_type, src, src_type, variable->type->column_count);
6072
6073 variable->buffer->u.buffer.changed = TRUE;
6074 }
6075
6076 static void write_variable_array_to_buffer(struct d3d10_effect_variable *variable, void *src,
6077 D3D_SHADER_VARIABLE_TYPE src_type, unsigned int offset, unsigned int count)
6078 {
6079 BYTE *dst = variable->buffer->u.buffer.local_buffer + variable->buffer_offset;
6080 D3D_SHADER_VARIABLE_TYPE dst_type = variable->type->basetype;
6081 unsigned int element_size, i;
6082 BYTE *cur_element = src;
6083
6084 if (!variable->type->element_count)
6085 {
6086 write_variable_to_buffer(variable, src, src_type);
6087 return;
6088 }
6089
6090 if (offset >= variable->type->element_count)
6091 {
6092 WARN("Offset %u larger than element count %u, ignoring.\n", offset, variable->type->element_count);
6093 return;
6094 }
6095
6096 if (count > variable->type->element_count - offset)
6097 {
6098 WARN("Offset %u, count %u overruns the variable (element count %u), fixing up.\n",
6099 offset, count, variable->type->element_count);
6100 count = variable->type->element_count - offset;
6101 }
6102
6103 element_size = variable->type->elementtype->size_packed;
6104 dst += variable->type->stride * offset;
6105
6106 for (i = 0; i < count; ++i)
6107 {
6108 get_vector_as_type(dst, dst_type, cur_element, src_type, variable->type->column_count);
6109
6110 cur_element += element_size;
6111 dst += variable->type->stride;
6112 }
6113
6114 variable->buffer->u.buffer.changed = TRUE;
6115 }
6116
6117 static void read_variable_from_buffer(struct d3d10_effect_variable *variable, void *dst,
6118 D3D_SHADER_VARIABLE_TYPE dst_type)
6119 {
6120 BYTE *src = variable->buffer->u.buffer.local_buffer + variable->buffer_offset;
6121 D3D_SHADER_VARIABLE_TYPE src_type = variable->type->basetype;
6122
6123 get_vector_as_type(dst, dst_type, src, src_type, variable->type->column_count);
6124 }
6125
6126 static void read_variable_array_from_buffer(struct d3d10_effect_variable *variable, void *dst,
6127 D3D_SHADER_VARIABLE_TYPE dst_type, unsigned int offset, unsigned int count)
6128 {
6129 BYTE *src = variable->buffer->u.buffer.local_buffer + variable->buffer_offset;
6130 D3D_SHADER_VARIABLE_TYPE src_type = variable->type->basetype;
6131 unsigned int element_size, i;
6132 BYTE *cur_element = dst;
6133
6134 if (!variable->type->element_count)
6135 {
6136 read_variable_from_buffer(variable, dst, dst_type);
6137 return;
6138 }
6139
6140 if (offset >= variable->type->element_count)
6141 {
6142 WARN("Offset %u larger than element count %u, ignoring.\n", offset, variable->type->element_count);
6143 return;
6144 }
6145
6146 if (count > variable->type->element_count - offset)
6147 {
6148 WARN("Offset %u, count %u overruns the variable (element count %u), fixing up.\n",
6149 offset, count, variable->type->element_count);
6150 count = variable->type->element_count - offset;
6151 }
6152
6153 element_size = variable->type->elementtype->size_packed;
6154 src += variable->type->stride * offset;
6155
6156 for (i = 0; i < count; ++i)
6157 {
6158 get_vector_as_type(cur_element, dst_type, src, src_type, variable->type->column_count);
6159
6160 cur_element += element_size;
6161 src += variable->type->stride;
6162 }
6163 }
6164
6165 /* ID3D10EffectVariable methods */
6166
6167 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectScalarVariable(ID3D10EffectScalarVariable *iface)
6168 {
6169 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
6170 }
6171
6172 static BOOL STDMETHODCALLTYPE d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable *iface)
6173 {
6174 struct d3d10_effect_variable *v = impl_from_ID3D10EffectScalarVariable(iface);
6175
6176 TRACE("iface %p\n", iface);
6177
6178 return v != &null_scalar_variable;
6179 }
6180
6181 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetType(
6182 ID3D10EffectScalarVariable *iface)
6183 {
6184 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
6185 }
6186
6187 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetDesc(ID3D10EffectScalarVariable *iface,
6188 D3D10_EFFECT_VARIABLE_DESC *desc)
6189 {
6190 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
6191 }
6192
6193 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByIndex(
6194 ID3D10EffectScalarVariable *iface, UINT index)
6195 {
6196 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6197 }
6198
6199 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByName(
6200 ID3D10EffectScalarVariable *iface, const char *name)
6201 {
6202 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6203 }
6204
6205 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByIndex(
6206 ID3D10EffectScalarVariable *iface, UINT index)
6207 {
6208 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6209 }
6210
6211 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByName(
6212 ID3D10EffectScalarVariable *iface, const char *name)
6213 {
6214 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6215 }
6216
6217 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberBySemantic(
6218 ID3D10EffectScalarVariable *iface, const char *semantic)
6219 {
6220 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6221 }
6222
6223 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetElement(
6224 ID3D10EffectScalarVariable *iface, UINT index)
6225 {
6226 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6227 }
6228
6229 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetParentConstantBuffer(
6230 ID3D10EffectScalarVariable *iface)
6231 {
6232 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6233 }
6234
6235 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsScalar(
6236 ID3D10EffectScalarVariable *iface)
6237 {
6238 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6239 }
6240
6241 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsVector(
6242 ID3D10EffectScalarVariable *iface)
6243 {
6244 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6245 }
6246
6247 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsMatrix(
6248 ID3D10EffectScalarVariable *iface)
6249 {
6250 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6251 }
6252
6253 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsString(
6254 ID3D10EffectScalarVariable *iface)
6255 {
6256 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6257 }
6258
6259 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShaderResource(
6260 ID3D10EffectScalarVariable *iface)
6261 {
6262 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6263 }
6264
6265 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRenderTargetView(
6266 ID3D10EffectScalarVariable *iface)
6267 {
6268 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6269 }
6270
6271 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencilView(
6272 ID3D10EffectScalarVariable *iface)
6273 {
6274 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6275 }
6276
6277 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsConstantBuffer(
6278 ID3D10EffectScalarVariable *iface)
6279 {
6280 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6281 }
6282
6283 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShader(
6284 ID3D10EffectScalarVariable *iface)
6285 {
6286 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6287 }
6288
6289 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsBlend(
6290 ID3D10EffectScalarVariable *iface)
6291 {
6292 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6293 }
6294
6295 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencil(
6296 ID3D10EffectScalarVariable *iface)
6297 {
6298 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6299 }
6300
6301 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRasterizer(
6302 ID3D10EffectScalarVariable *iface)
6303 {
6304 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6305 }
6306
6307 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsSampler(
6308 ID3D10EffectScalarVariable *iface)
6309 {
6310 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6311 }
6312
6313 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetRawValue(ID3D10EffectScalarVariable *iface,
6314 void *data, UINT offset, UINT count)
6315 {
6316 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6317 }
6318
6319 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetRawValue(ID3D10EffectScalarVariable *iface,
6320 void *data, UINT offset, UINT count)
6321 {
6322 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6323 }
6324
6325 /* ID3D10EffectScalarVariable methods */
6326
6327 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable *iface,
6328 float value)
6329 {
6330 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6331
6332 TRACE("iface %p, value %.8e.\n", iface, value);
6333 write_variable_to_buffer(effect_var, &value, D3D10_SVT_FLOAT);
6334
6335 return S_OK;
6336 }
6337
6338 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable *iface,
6339 float *value)
6340 {
6341 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6342
6343 TRACE("iface %p, value %p.\n", iface, value);
6344 read_variable_from_buffer(effect_var, value, D3D10_SVT_FLOAT);
6345
6346 return S_OK;
6347 }
6348
6349 /* Tests show that offset is ignored for scalar variables. */
6350 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable *iface,
6351 float *values, UINT offset, UINT count)
6352 {
6353 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6354
6355 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6356 write_variable_array_to_buffer(effect_var, values, D3D10_SVT_FLOAT, 0, count);
6357
6358 return S_OK;
6359 }
6360
6361 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable *iface,
6362 float *values, UINT offset, UINT count)
6363 {
6364 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6365
6366 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6367 read_variable_array_from_buffer(effect_var, values, D3D10_SVT_FLOAT, 0, count);
6368
6369 return S_OK;
6370 }
6371
6372 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable *iface,
6373 int value)
6374 {
6375 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6376
6377 TRACE("iface %p, value %d.\n", iface, value);
6378 write_variable_to_buffer(effect_var, &value, D3D10_SVT_INT);
6379
6380 return S_OK;
6381 }
6382
6383 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable *iface,
6384 int *value)
6385 {
6386 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6387
6388 TRACE("iface %p, value %p.\n", iface, value);
6389 read_variable_from_buffer(effect_var, value, D3D10_SVT_INT);
6390
6391 return S_OK;
6392 }
6393
6394 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable *iface,
6395 int *values, UINT offset, UINT count)
6396 {
6397 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6398
6399 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6400 write_variable_array_to_buffer(effect_var, values, D3D10_SVT_INT, 0, count);
6401
6402 return S_OK;
6403 }
6404
6405 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable *iface,
6406 int *values, UINT offset, UINT count)
6407 {
6408 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6409
6410 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6411 read_variable_array_from_buffer(effect_var, values, D3D10_SVT_INT, 0, count);
6412
6413 return S_OK;
6414 }
6415
6416 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable *iface,
6417 BOOL value)
6418 {
6419 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6420
6421 TRACE("iface %p, value %d.\n", iface, value);
6422 write_variable_to_buffer(effect_var, &value, D3D10_SVT_BOOL);
6423
6424 return S_OK;
6425 }
6426
6427 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable *iface,
6428 BOOL *value)
6429 {
6430 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6431
6432 TRACE("iface %p, value %p.\n", iface, value);
6433 read_variable_from_buffer(effect_var, value, D3D10_SVT_BOOL);
6434
6435 return S_OK;
6436 }
6437
6438 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable *iface,
6439 BOOL *values, UINT offset, UINT count)
6440 {
6441 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6442
6443 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6444 write_variable_array_to_buffer(effect_var, values, D3D10_SVT_BOOL, 0, count);
6445
6446 return S_OK;
6447 }
6448
6449 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable *iface,
6450 BOOL *values, UINT offset, UINT count)
6451 {
6452 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectScalarVariable(iface);
6453
6454 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6455 read_variable_array_from_buffer(effect_var, values, D3D10_SVT_BOOL, 0, count);
6456
6457 return S_OK;
6458 }
6459
6460 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl =
6461 {
6462 /* ID3D10EffectVariable methods */
6463 d3d10_effect_scalar_variable_IsValid,
6464 d3d10_effect_scalar_variable_GetType,
6465 d3d10_effect_scalar_variable_GetDesc,
6466 d3d10_effect_scalar_variable_GetAnnotationByIndex,
6467 d3d10_effect_scalar_variable_GetAnnotationByName,
6468 d3d10_effect_scalar_variable_GetMemberByIndex,
6469 d3d10_effect_scalar_variable_GetMemberByName,
6470 d3d10_effect_scalar_variable_GetMemberBySemantic,
6471 d3d10_effect_scalar_variable_GetElement,
6472 d3d10_effect_scalar_variable_GetParentConstantBuffer,
6473 d3d10_effect_scalar_variable_AsScalar,
6474 d3d10_effect_scalar_variable_AsVector,
6475 d3d10_effect_scalar_variable_AsMatrix,
6476 d3d10_effect_scalar_variable_AsString,
6477 d3d10_effect_scalar_variable_AsShaderResource,
6478 d3d10_effect_scalar_variable_AsRenderTargetView,
6479 d3d10_effect_scalar_variable_AsDepthStencilView,
6480 d3d10_effect_scalar_variable_AsConstantBuffer,
6481 d3d10_effect_scalar_variable_AsShader,
6482 d3d10_effect_scalar_variable_AsBlend,
6483 d3d10_effect_scalar_variable_AsDepthStencil,
6484 d3d10_effect_scalar_variable_AsRasterizer,
6485 d3d10_effect_scalar_variable_AsSampler,
6486 d3d10_effect_scalar_variable_SetRawValue,
6487 d3d10_effect_scalar_variable_GetRawValue,
6488 /* ID3D10EffectScalarVariable methods */
6489 d3d10_effect_scalar_variable_SetFloat,
6490 d3d10_effect_scalar_variable_GetFloat,
6491 d3d10_effect_scalar_variable_SetFloatArray,
6492 d3d10_effect_scalar_variable_GetFloatArray,
6493 d3d10_effect_scalar_variable_SetInt,
6494 d3d10_effect_scalar_variable_GetInt,
6495 d3d10_effect_scalar_variable_SetIntArray,
6496 d3d10_effect_scalar_variable_GetIntArray,
6497 d3d10_effect_scalar_variable_SetBool,
6498 d3d10_effect_scalar_variable_GetBool,
6499 d3d10_effect_scalar_variable_SetBoolArray,
6500 d3d10_effect_scalar_variable_GetBoolArray,
6501 };
6502
6503 /* ID3D10EffectVariable methods */
6504
6505 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectVectorVariable(ID3D10EffectVectorVariable *iface)
6506 {
6507 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
6508 }
6509
6510 static BOOL STDMETHODCALLTYPE d3d10_effect_vector_variable_IsValid(ID3D10EffectVectorVariable *iface)
6511 {
6512 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVectorVariable(iface);
6513
6514 TRACE("iface %p\n", iface);
6515
6516 return v != &null_vector_variable;
6517 }
6518
6519 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetType(
6520 ID3D10EffectVectorVariable *iface)
6521 {
6522 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
6523 }
6524
6525 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetDesc(ID3D10EffectVectorVariable *iface,
6526 D3D10_EFFECT_VARIABLE_DESC *desc)
6527 {
6528 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
6529 }
6530
6531 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByIndex(
6532 ID3D10EffectVectorVariable *iface, UINT index)
6533 {
6534 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6535 }
6536
6537 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByName(
6538 ID3D10EffectVectorVariable *iface, const char *name)
6539 {
6540 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6541 }
6542
6543 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByIndex(
6544 ID3D10EffectVectorVariable *iface, UINT index)
6545 {
6546 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6547 }
6548
6549 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByName(
6550 ID3D10EffectVectorVariable *iface, const char *name)
6551 {
6552 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6553 }
6554
6555 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberBySemantic(
6556 ID3D10EffectVectorVariable *iface, const char *semantic)
6557 {
6558 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6559 }
6560
6561 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetElement(
6562 ID3D10EffectVectorVariable *iface, UINT index)
6563 {
6564 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6565 }
6566
6567 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetParentConstantBuffer(
6568 ID3D10EffectVectorVariable *iface)
6569 {
6570 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6571 }
6572
6573 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsScalar(
6574 ID3D10EffectVectorVariable *iface)
6575 {
6576 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6577 }
6578
6579 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsVector(
6580 ID3D10EffectVectorVariable *iface)
6581 {
6582 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6583 }
6584
6585 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsMatrix(
6586 ID3D10EffectVectorVariable *iface)
6587 {
6588 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6589 }
6590
6591 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsString(
6592 ID3D10EffectVectorVariable *iface)
6593 {
6594 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6595 }
6596
6597 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShaderResource(
6598 ID3D10EffectVectorVariable *iface)
6599 {
6600 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6601 }
6602
6603 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRenderTargetView(
6604 ID3D10EffectVectorVariable *iface)
6605 {
6606 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6607 }
6608
6609 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencilView(
6610 ID3D10EffectVectorVariable *iface)
6611 {
6612 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6613 }
6614
6615 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsConstantBuffer(
6616 ID3D10EffectVectorVariable *iface)
6617 {
6618 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6619 }
6620
6621 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShader(
6622 ID3D10EffectVectorVariable *iface)
6623 {
6624 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6625 }
6626
6627 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsBlend(
6628 ID3D10EffectVectorVariable *iface)
6629 {
6630 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6631 }
6632
6633 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencil(
6634 ID3D10EffectVectorVariable *iface)
6635 {
6636 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6637 }
6638
6639 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRasterizer(
6640 ID3D10EffectVectorVariable *iface)
6641 {
6642 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6643 }
6644
6645 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsSampler(
6646 ID3D10EffectVectorVariable *iface)
6647 {
6648 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6649 }
6650
6651 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetRawValue(ID3D10EffectVectorVariable *iface,
6652 void *data, UINT offset, UINT count)
6653 {
6654 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6655 }
6656
6657 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetRawValue(ID3D10EffectVectorVariable *iface,
6658 void *data, UINT offset, UINT count)
6659 {
6660 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6661 }
6662
6663 /* ID3D10EffectVectorVariable methods */
6664
6665 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVector(ID3D10EffectVectorVariable *iface,
6666 BOOL *value)
6667 {
6668 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6669
6670 TRACE("iface %p, value %p.\n", iface, value);
6671 write_variable_to_buffer(effect_var, value, D3D10_SVT_BOOL);
6672
6673 return S_OK;
6674 }
6675
6676 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVector(ID3D10EffectVectorVariable *iface,
6677 int *value)
6678 {
6679 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6680
6681 TRACE("iface %p, value %p.\n", iface, value);
6682 write_variable_to_buffer(effect_var, value, D3D10_SVT_INT);
6683
6684 return S_OK;
6685 }
6686
6687 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVector(ID3D10EffectVectorVariable *iface,
6688 float *value)
6689 {
6690 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6691
6692 TRACE("iface %p, value %p.\n", iface, value);
6693 write_variable_to_buffer(effect_var, value, D3D10_SVT_FLOAT);
6694
6695 return S_OK;
6696 }
6697
6698 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVector(ID3D10EffectVectorVariable *iface,
6699 BOOL *value)
6700 {
6701 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6702
6703 TRACE("iface %p, value %p.\n", iface, value);
6704 read_variable_from_buffer(effect_var, value, D3D10_SVT_BOOL);
6705
6706 return S_OK;
6707 }
6708
6709 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVector(ID3D10EffectVectorVariable *iface,
6710 int *value)
6711 {
6712 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6713
6714 TRACE("iface %p, value %p.\n", iface, value);
6715 read_variable_from_buffer(effect_var, value, D3D10_SVT_INT);
6716
6717 return S_OK;
6718 }
6719
6720 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVector(ID3D10EffectVectorVariable *iface,
6721 float *value)
6722 {
6723 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6724
6725 TRACE("iface %p, value %p.\n", iface, value);
6726 read_variable_from_buffer(effect_var, value, D3D10_SVT_FLOAT);
6727
6728 return S_OK;
6729 }
6730
6731 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVectorArray(ID3D10EffectVectorVariable *iface,
6732 BOOL *values, UINT offset, UINT count)
6733 {
6734 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6735
6736 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6737 write_variable_array_to_buffer(effect_var, values, D3D10_SVT_BOOL, offset, count);
6738
6739 return S_OK;
6740 }
6741
6742 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVectorArray(ID3D10EffectVectorVariable *iface,
6743 int *values, UINT offset, UINT count)
6744 {
6745 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6746
6747 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6748 write_variable_array_to_buffer(effect_var, values, D3D10_SVT_INT, offset, count);
6749
6750 return S_OK;
6751 }
6752
6753 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVectorArray(ID3D10EffectVectorVariable *iface,
6754 float *values, UINT offset, UINT count)
6755 {
6756 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6757
6758 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6759 write_variable_array_to_buffer(effect_var, values, D3D10_SVT_FLOAT, offset, count);
6760
6761 return S_OK;
6762 }
6763
6764 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVectorArray(ID3D10EffectVectorVariable *iface,
6765 BOOL *values, UINT offset, UINT count)
6766 {
6767 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6768
6769 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6770 read_variable_array_from_buffer(effect_var, values, D3D10_SVT_BOOL, offset, count);
6771
6772 return S_OK;
6773 }
6774
6775 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVectorArray(ID3D10EffectVectorVariable *iface,
6776 int *values, UINT offset, UINT count)
6777 {
6778 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6779
6780 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6781 read_variable_array_from_buffer(effect_var, values, D3D10_SVT_INT, offset, count);
6782
6783 return S_OK;
6784 }
6785
6786 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVectorArray(ID3D10EffectVectorVariable *iface,
6787 float *values, UINT offset, UINT count)
6788 {
6789 struct d3d10_effect_variable *effect_var = impl_from_ID3D10EffectVectorVariable(iface);
6790
6791 TRACE("iface %p, values %p, offset %u, count %u.\n", iface, values, offset, count);
6792 read_variable_array_from_buffer(effect_var, values, D3D10_SVT_FLOAT, offset, count);
6793
6794 return S_OK;
6795 }
6796
6797 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl =
6798 {
6799 /* ID3D10EffectVariable methods */
6800 d3d10_effect_vector_variable_IsValid,
6801 d3d10_effect_vector_variable_GetType,
6802 d3d10_effect_vector_variable_GetDesc,
6803 d3d10_effect_vector_variable_GetAnnotationByIndex,
6804 d3d10_effect_vector_variable_GetAnnotationByName,
6805 d3d10_effect_vector_variable_GetMemberByIndex,
6806 d3d10_effect_vector_variable_GetMemberByName,
6807 d3d10_effect_vector_variable_GetMemberBySemantic,
6808 d3d10_effect_vector_variable_GetElement,
6809 d3d10_effect_vector_variable_GetParentConstantBuffer,
6810 d3d10_effect_vector_variable_AsScalar,
6811 d3d10_effect_vector_variable_AsVector,
6812 d3d10_effect_vector_variable_AsMatrix,
6813 d3d10_effect_vector_variable_AsString,
6814 d3d10_effect_vector_variable_AsShaderResource,
6815 d3d10_effect_vector_variable_AsRenderTargetView,
6816 d3d10_effect_vector_variable_AsDepthStencilView,
6817 d3d10_effect_vector_variable_AsConstantBuffer,
6818 d3d10_effect_vector_variable_AsShader,
6819 d3d10_effect_vector_variable_AsBlend,
6820 d3d10_effect_vector_variable_AsDepthStencil,
6821 d3d10_effect_vector_variable_AsRasterizer,
6822 d3d10_effect_vector_variable_AsSampler,
6823 d3d10_effect_vector_variable_SetRawValue,
6824 d3d10_effect_vector_variable_GetRawValue,
6825 /* ID3D10EffectVectorVariable methods */
6826 d3d10_effect_vector_variable_SetBoolVector,
6827 d3d10_effect_vector_variable_SetIntVector,
6828 d3d10_effect_vector_variable_SetFloatVector,
6829 d3d10_effect_vector_variable_GetBoolVector,
6830 d3d10_effect_vector_variable_GetIntVector,
6831 d3d10_effect_vector_variable_GetFloatVector,
6832 d3d10_effect_vector_variable_SetBoolVectorArray,
6833 d3d10_effect_vector_variable_SetIntVectorArray,
6834 d3d10_effect_vector_variable_SetFloatVectorArray,
6835 d3d10_effect_vector_variable_GetBoolVectorArray,
6836 d3d10_effect_vector_variable_GetIntVectorArray,
6837 d3d10_effect_vector_variable_GetFloatVectorArray,
6838 };
6839
6840 static void write_matrix_to_buffer(struct d3d10_effect_variable *variable, void *dst_void,
6841 struct d3d10_matrix *src, BOOL transpose)
6842 {
6843 unsigned int col_count = !transpose ? variable->type->column_count : variable->type->row_count;
6844 unsigned int row_count = !transpose ? variable->type->row_count : variable->type->column_count;
6845 BOOL major = variable->type->type_class == D3D10_SVC_MATRIX_COLUMNS;
6846 float *dst = dst_void;
6847 unsigned int row, col;
6848
6849 if (transpose)
6850 major = !major;
6851
6852 if (major)
6853 {
6854 for (col = 0; col < col_count; ++col)
6855 {
6856 for (row = 0; row < row_count; ++row)
6857 dst[(col * 4) + row] = src->m[row][col];
6858 }
6859 }
6860 else
6861 {
6862 for (row = 0; row < row_count; ++row)
6863 {
6864 for (col = 0; col < col_count; ++col)
6865 dst[(row * 4) + col] = src->m[row][col];
6866 }
6867 }
6868 }
6869
6870 static void write_matrix_variable_to_buffer(struct d3d10_effect_variable *variable, void *src_data, BOOL transpose)
6871 {
6872 BYTE *dst = variable->buffer->u.buffer.local_buffer + variable->buffer_offset;
6873
6874 write_matrix_to_buffer(variable, dst, src_data, transpose);
6875
6876 variable->buffer->u.buffer.changed = TRUE;
6877 }
6878
6879 static void write_matrix_variable_array_to_buffer(struct d3d10_effect_variable *variable, void *src_data,
6880 unsigned int offset, unsigned int count, BOOL transpose)
6881 {
6882 BYTE *dst = variable->buffer->u.buffer.local_buffer + variable->buffer_offset;
6883 struct d3d10_matrix *src = src_data;
6884 unsigned int i;
6885
6886 if (!variable->type->element_count)
6887 {
6888 write_matrix_variable_to_buffer(variable, src_data, transpose);
6889 return;
6890 }
6891
6892 if (offset >= variable->type->element_count)
6893 {
6894 WARN("Offset %u larger than element count %u, ignoring.\n", offset, variable->type->element_count);
6895 return;
6896 }
6897
6898 if (count > variable->type->element_count - offset)
6899 {
6900 WARN("Offset %u, count %u overruns the variable (element count %u), fixing up.\n",
6901 offset, count, variable->type->element_count);
6902 count = variable->type->element_count - offset;
6903 }
6904
6905 if (offset)
6906 dst += variable->type->stride * offset;
6907
6908 for (i = 0; i < count; ++i)
6909 {
6910 write_matrix_to_buffer(variable, dst, &src[i], transpose);
6911
6912 dst += variable->type->stride;
6913 }
6914
6915 variable->buffer->u.buffer.changed = TRUE;
6916 }
6917
6918 static void read_matrix_from_buffer(struct d3d10_effect_variable *variable, void *src_void,
6919 struct d3d10_matrix *dst, BOOL transpose)
6920 {
6921 unsigned int col_count = !transpose ? variable->type->column_count : variable->type->row_count;
6922 unsigned int row_count = !transpose ? variable->type->row_count : variable->type->column_count;
6923 BOOL major = variable->type->type_class == D3D10_SVC_MATRIX_COLUMNS;
6924 float *src = src_void;
6925 unsigned int row, col;
6926
6927 if (transpose)
6928 major = !major;
6929
6930 if (major)
6931 {
6932 for (col = 0; col < col_count; ++col)
6933 {
6934 for (row = 0; row < row_count; ++row)
6935 dst->m[row][col] = src[(col * 4) + row];
6936 }
6937 }
6938 else
6939 {
6940 for (row = 0; row < row_count; ++row)
6941 {
6942 for (col = 0; col < col_count; ++col)
6943 dst->m[row][col] = src[(row * 4) + col];
6944 }
6945 }
6946 }
6947
6948 static void read_matrix_variable_from_buffer(struct d3d10_effect_variable *variable, void *dst, BOOL transpose)
6949 {
6950 BYTE *src = variable->buffer->u.buffer.local_buffer + variable->buffer_offset;
6951
6952 read_matrix_from_buffer(variable, src, dst, transpose);
6953 }
6954
6955 static void read_matrix_variable_array_from_buffer(struct d3d10_effect_variable *variable, void *dst_data, UINT offset,
6956 UINT count, BOOL transpose)
6957 {
6958 BYTE *src = variable->buffer->u.buffer.local_buffer + variable->buffer_offset;
6959 struct d3d10_matrix *dst = dst_data;
6960 unsigned int i;
6961
6962 if (!variable->type->element_count)
6963 {
6964 read_matrix_variable_from_buffer(variable, dst_data, transpose);
6965 return;
6966 }
6967
6968 if (offset >= variable->type->element_count)
6969 {
6970 WARN("Offset %u larger than element count %u, ignoring.\n", offset, variable->type->element_count);
6971 return;
6972 }
6973
6974 if (count > variable->type->element_count - offset)
6975 {
6976 WARN("Offset %u, count %u overruns the variable (element count %u), fixing up.\n",
6977 offset, count, variable->type->element_count);
6978 count = variable->type->element_count - offset;
6979 }
6980
6981 if (offset)
6982 src += variable->type->stride * offset;
6983
6984 for (i = 0; i < count; ++i)
6985 {
6986 read_matrix_from_buffer(variable, src, &dst[i], transpose);
6987
6988 src += variable->type->stride;
6989 }
6990 }
6991
6992 /* ID3D10EffectVariable methods */
6993
6994 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectMatrixVariable(ID3D10EffectMatrixVariable *iface)
6995 {
6996 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
6997 }
6998
6999 static BOOL STDMETHODCALLTYPE d3d10_effect_matrix_variable_IsValid(ID3D10EffectMatrixVariable *iface)
7000 {
7001 struct d3d10_effect_variable *v = impl_from_ID3D10EffectMatrixVariable(iface);
7002
7003 TRACE("iface %p\n", iface);
7004
7005 return v != &null_matrix_variable;
7006 }
7007
7008 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetType(
7009 ID3D10EffectMatrixVariable *iface)
7010 {
7011 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
7012 }
7013
7014 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetDesc(ID3D10EffectMatrixVariable *iface,
7015 D3D10_EFFECT_VARIABLE_DESC *desc)
7016 {
7017 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
7018 }
7019
7020 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByIndex(
7021 ID3D10EffectMatrixVariable *iface, UINT index)
7022 {
7023 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
7024 }
7025
7026 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByName(
7027 ID3D10EffectMatrixVariable *iface, const char *name)
7028 {
7029 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
7030 }
7031
7032 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByIndex(
7033 ID3D10EffectMatrixVariable *iface, UINT index)
7034 {
7035 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
7036 }
7037
7038 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByName(
7039 ID3D10EffectMatrixVariable *iface, const char *name)
7040 {
7041 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
7042 }
7043
7044 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberBySemantic(
7045 ID3D10EffectMatrixVariable *iface, const char *semantic)
7046 {
7047 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
7048 }
7049
7050 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetElement(
7051 ID3D10EffectMatrixVariable *iface, UINT index)
7052 {
7053 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
7054 }
7055
7056 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetParentConstantBuffer(
7057 ID3D10EffectMatrixVariable *iface)
7058 {
7059 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
7060 }
7061
7062 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsScalar(
7063 ID3D10EffectMatrixVariable *iface)
7064 {
7065 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
7066 }
7067
7068 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsVector(
7069 ID3D10EffectMatrixVariable *iface)
7070 {
7071 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
7072 }
7073
7074 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsMatrix(
7075 ID3D10EffectMatrixVariable *iface)
7076 {
7077 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
7078 }
7079
7080 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsString(
7081 ID3D10EffectMatrixVariable *iface)
7082 {
7083 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
7084 }
7085
7086 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShaderResource(
7087 ID3D10EffectMatrixVariable *iface)
7088 {
7089 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
7090 }
7091
7092 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRenderTargetView(
7093 ID3D10EffectMatrixVariable *iface)
7094 {
7095 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
7096 }
7097
7098 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencilView(
7099 ID3D10EffectMatrixVariable *iface)
7100 {
7101 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
7102 }
7103
7104 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsConstantBuffer(
7105 ID3D10EffectMatrixVariable *iface)
7106 {
7107 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
7108 }
7109
7110 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShader(
7111 ID3D10EffectMatrixVariable *iface)
7112 {
7113 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
7114 }
7115
7116 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsBlend(
7117 ID3D10EffectMatrixVariable *iface)
7118 {
7119 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
7120 }
7121
7122 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencil(
7123 ID3D10EffectMatrixVariable *iface)
7124 {
7125 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
7126 }
7127
7128 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRasterizer(
7129 ID3D10EffectMatrixVariable *iface)
7130 {
7131 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
7132 }
7133
7134 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsSampler(
7135 ID3D10EffectMatrixVariable *iface)
7136 {
7137 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
7138 }
7139
7140 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetRawValue(ID3D10EffectMatrixVariable *iface,
7141 void *data, UINT offset, UINT count)
7142 {
7143 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
7144 }
7145
7146 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetRawValue(ID3D10EffectMatrixVariable *iface,
7147 void *data, UINT offset, UINT count)
7148 {
7149 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
7150 }
7151
7152 /* ID3D10EffectMatrixVariable methods */
7153
7154 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrix(ID3D10EffectMatrixVariable *iface,
7155 float *data)
7156 {
7157 struct d3d10_effect_variable *var = impl_from_ID3D10EffectMatrixVariable(iface);
7158
7159 TRACE("iface %p, data %p.\n", iface, data);
7160 write_matrix_variable_to_buffer(var, data, FALSE);
7161
7162 return S_OK;
7163 }
7164
7165 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrix(ID3D10EffectMatrixVariable *iface,
7166 float *data)
7167 {
7168 struct d3d10_effect_variable *var = impl_from_ID3D10EffectMatrixVariable(iface);
7169
7170 TRACE("iface %p, data %p.\n", iface, data);
7171 read_matrix_variable_from_buffer(var, data, FALSE);
7172
7173 return S_OK;
7174 }
7175
7176 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixArray(ID3D10EffectMatrixVariable *iface,
7177 float *data, UINT offset, UINT count)
7178 {
7179 struct d3d10_effect_variable *var = impl_from_ID3D10EffectMatrixVariable(iface);
7180
7181 TRACE("iface %p, data %p, offset %u, count %u.\n", iface, data, offset, count);
7182 write_matrix_variable_array_to_buffer(var, data, offset, count, FALSE);
7183
7184 return S_OK;
7185 }
7186
7187 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixArray(ID3D10EffectMatrixVariable *iface,
7188 float *data, UINT offset, UINT count)
7189 {
7190 struct d3d10_effect_variable *var = impl_from_ID3D10EffectMatrixVariable(iface);
7191
7192 TRACE("iface %p, data %p, offset %u, count %u.\n", iface, data, offset, count);
7193 read_matrix_variable_array_from_buffer(var, data, offset, count, FALSE);
7194
7195 return S_OK;
7196 }
7197
7198 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
7199 float *data)
7200 {
7201 struct d3d10_effect_variable *var = impl_from_ID3D10EffectMatrixVariable(iface);
7202
7203 TRACE("iface %p, data %p.\n", iface, data);
7204 write_matrix_variable_to_buffer(var, data, TRUE);
7205
7206 return S_OK;
7207 }
7208
7209 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
7210 float *data)
7211 {
7212 struct d3d10_effect_variable *var = impl_from_ID3D10EffectMatrixVariable(iface);
7213
7214 TRACE("iface %p, data %p.\n", iface, data);
7215 read_matrix_variable_from_buffer(var, data, TRUE);
7216
7217 return S_OK;
7218 }
7219
7220 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
7221 float *data, UINT offset, UINT count)
7222 {
7223 struct d3d10_effect_variable *var = impl_from_ID3D10EffectMatrixVariable(iface);
7224
7225 TRACE("iface %p, data %p, offset %u, count %u.\n", iface, data, offset, count);
7226 write_matrix_variable_array_to_buffer(var, data, offset, count, TRUE);
7227
7228 return S_OK;
7229 }
7230
7231 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
7232 float *data, UINT offset, UINT count)
7233 {
7234 struct d3d10_effect_variable *var = impl_from_ID3D10EffectMatrixVariable(iface);
7235
7236 TRACE("iface %p, data %p, offset %u, count %u.\n", iface, data, offset, count);
7237 read_matrix_variable_array_from_buffer(var, data, offset, count, TRUE);
7238
7239 return S_OK;
7240 }
7241
7242
7243 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl =
7244 {
7245 /* ID3D10EffectVariable methods */
7246 d3d10_effect_matrix_variable_IsValid,
7247 d3d10_effect_matrix_variable_GetType,
7248 d3d10_effect_matrix_variable_GetDesc,
7249 d3d10_effect_matrix_variable_GetAnnotationByIndex,
7250 d3d10_effect_matrix_variable_GetAnnotationByName,
7251 d3d10_effect_matrix_variable_GetMemberByIndex,
7252 d3d10_effect_matrix_variable_GetMemberByName,
7253 d3d10_effect_matrix_variable_GetMemberBySemantic,
7254 d3d10_effect_matrix_variable_GetElement,
7255 d3d10_effect_matrix_variable_GetParentConstantBuffer,
7256 d3d10_effect_matrix_variable_AsScalar,
7257 d3d10_effect_matrix_variable_AsVector,
7258 d3d10_effect_matrix_variable_AsMatrix,
7259 d3d10_effect_matrix_variable_AsString,
7260 d3d10_effect_matrix_variable_AsShaderResource,
7261 d3d10_effect_matrix_variable_AsRenderTargetView,
7262 d3d10_effect_matrix_variable_AsDepthStencilView,
7263 d3d10_effect_matrix_variable_AsConstantBuffer,
7264 d3d10_effect_matrix_variable_AsShader,
7265 d3d10_effect_matrix_variable_AsBlend,
7266 d3d10_effect_matrix_variable_AsDepthStencil,
7267 d3d10_effect_matrix_variable_AsRasterizer,
7268 d3d10_effect_matrix_variable_AsSampler,
7269 d3d10_effect_matrix_variable_SetRawValue,
7270 d3d10_effect_matrix_variable_GetRawValue,
7271 /* ID3D10EffectMatrixVariable methods */
7272 d3d10_effect_matrix_variable_SetMatrix,
7273 d3d10_effect_matrix_variable_GetMatrix,
7274 d3d10_effect_matrix_variable_SetMatrixArray,
7275 d3d10_effect_matrix_variable_GetMatrixArray,
7276 d3d10_effect_matrix_variable_SetMatrixTranspose,
7277 d3d10_effect_matrix_variable_GetMatrixTranspose,
7278 d3d10_effect_matrix_variable_SetMatrixTransposeArray,
7279 d3d10_effect_matrix_variable_GetMatrixTransposeArray,
7280 };
7281
7282 /* ID3D10EffectVariable methods */
7283
7284 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectStringVariable(ID3D10EffectStringVariable *iface)
7285 {
7286 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
7287 }
7288
7289 static BOOL STDMETHODCALLTYPE d3d10_effect_string_variable_IsValid(ID3D10EffectStringVariable *iface)
7290 {
7291 struct d3d10_effect_variable *v = impl_from_ID3D10EffectStringVariable(iface);
7292
7293 TRACE("iface %p\n", iface);
7294
7295 return v != &null_string_variable;
7296 }
7297
7298 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_string_variable_GetType(
7299 ID3D10EffectStringVariable *iface)
7300 {
7301 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
7302 }
7303
7304 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetDesc(ID3D10EffectStringVariable *iface,
7305 D3D10_EFFECT_VARIABLE_DESC *desc)
7306 {
7307 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
7308 }
7309
7310 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetAnnotationByIndex(
7311 ID3D10EffectStringVariable *iface, UINT index)
7312 {
7313 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
7314 }
7315
7316 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetAnnotationByName(
7317 ID3D10EffectStringVariable *iface, const char *name)
7318 {
7319 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
7320 }
7321
7322 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberByIndex(
7323 ID3D10EffectStringVariable *iface, UINT index)
7324 {
7325 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
7326 }
7327
7328 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberByName(
7329 ID3D10EffectStringVariable *iface, const char *name)
7330 {
7331 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
7332 }
7333
7334 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberBySemantic(
7335 ID3D10EffectStringVariable *iface, const char *semantic)
7336 {
7337 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
7338 }
7339
7340 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetElement(
7341 ID3D10EffectStringVariable *iface, UINT index)
7342 {
7343 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
7344 }
7345
7346 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_string_variable_GetParentConstantBuffer(
7347 ID3D10EffectStringVariable *iface)
7348 {
7349 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
7350 }
7351
7352 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsScalar(
7353 ID3D10EffectStringVariable *iface)
7354 {
7355 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
7356 }
7357
7358 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsVector(
7359 ID3D10EffectStringVariable *iface)
7360 {
7361 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
7362 }
7363
7364 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsMatrix(
7365 ID3D10EffectStringVariable *iface)
7366 {
7367 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
7368 }
7369
7370 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsString(
7371 ID3D10EffectStringVariable *iface)
7372 {
7373 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
7374 }
7375
7376 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsShaderResource(
7377 ID3D10EffectStringVariable *iface)
7378 {
7379 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
7380 }
7381
7382 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsRenderTargetView(
7383 ID3D10EffectStringVariable *iface)
7384 {
7385 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
7386 }
7387
7388 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsDepthStencilView(
7389 ID3D10EffectStringVariable *iface)
7390 {
7391 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
7392 }
7393
7394 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_string_variable_AsConstantBuffer(
7395 ID3D10EffectStringVariable *iface)
7396 {
7397 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
7398 }
7399
7400 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsShader(
7401 ID3D10EffectStringVariable *iface)
7402 {
7403 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
7404 }
7405
7406 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsBlend(
7407 ID3D10EffectStringVariable *iface)
7408 {
7409 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
7410 }
7411
7412 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsDepthStencil(
7413 ID3D10EffectStringVariable *iface)
7414 {
7415 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
7416 }
7417
7418 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsRasterizer(
7419 ID3D10EffectStringVariable *iface)
7420 {
7421 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
7422 }
7423
7424 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsSampler(
7425 ID3D10EffectStringVariable *iface)
7426 {
7427 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
7428 }
7429
7430 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_SetRawValue(ID3D10EffectStringVariable *iface,
7431 void *data, UINT offset, UINT count)
7432 {
7433 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
7434 }
7435
7436 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetRawValue(ID3D10EffectStringVariable *iface,
7437 void *data, UINT offset, UINT count)
7438 {
7439 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
7440 }
7441
7442 /* ID3D10EffectStringVariable methods */
7443
7444 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetString(ID3D10EffectStringVariable *iface,
7445 const char **str)
7446 {
7447 struct d3d10_effect_variable *var = impl_from_ID3D10EffectStringVariable(iface);
7448 char *value = (char *)var->u.buffer.local_buffer;
7449
7450 TRACE("iface %p, str %p.\n", iface, str);
7451
7452 if (!value)
7453 return E_FAIL;
7454
7455 if (!str)
7456 return E_INVALIDARG;
7457
7458 *str = value;
7459
7460 return S_OK;
7461 }
7462
7463 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetStringArray(ID3D10EffectStringVariable *iface,
7464 const char **strs, UINT offset, UINT count)
7465 {
7466 FIXME("iface %p, strs %p, offset %u, count %u stub!\n", iface, strs, offset, count);
7467
7468 return E_NOTIMPL;
7469 }
7470
7471
7472 static const struct ID3D10EffectStringVariableVtbl d3d10_effect_string_variable_vtbl =
7473 {
7474 /* ID3D10EffectVariable methods */
7475 d3d10_effect_string_variable_IsValid,
7476 d3d10_effect_string_variable_GetType,
7477 d3d10_effect_string_variable_GetDesc,
7478 d3d10_effect_string_variable_GetAnnotationByIndex,
7479 d3d10_effect_string_variable_GetAnnotationByName,
7480 d3d10_effect_string_variable_GetMemberByIndex,
7481 d3d10_effect_string_variable_GetMemberByName,
7482 d3d10_effect_string_variable_GetMemberBySemantic,
7483 d3d10_effect_string_variable_GetElement,
7484 d3d10_effect_string_variable_GetParentConstantBuffer,
7485 d3d10_effect_string_variable_AsScalar,
7486 d3d10_effect_string_variable_AsVector,
7487 d3d10_effect_string_variable_AsMatrix,
7488 d3d10_effect_string_variable_AsString,
7489 d3d10_effect_string_variable_AsShaderResource,
7490 d3d10_effect_string_variable_AsRenderTargetView,
7491 d3d10_effect_string_variable_AsDepthStencilView,
7492 d3d10_effect_string_variable_AsConstantBuffer,
7493 d3d10_effect_string_variable_AsShader,
7494 d3d10_effect_string_variable_AsBlend,
7495 d3d10_effect_string_variable_AsDepthStencil,
7496 d3d10_effect_string_variable_AsRasterizer,
7497 d3d10_effect_string_variable_AsSampler,
7498 d3d10_effect_string_variable_SetRawValue,
7499 d3d10_effect_string_variable_GetRawValue,
7500 /* ID3D10EffectStringVariable methods */
7501 d3d10_effect_string_variable_GetString,
7502 d3d10_effect_string_variable_GetStringArray,
7503 };
7504
7505 static void set_shader_resource_variable(ID3D10ShaderResourceView **src, ID3D10ShaderResourceView **dst)
7506 {
7507 if (*dst == *src)
7508 return;
7509
7510 if (*src)
7511 ID3D10ShaderResourceView_AddRef(*src);
7512 if (*dst)
7513 ID3D10ShaderResourceView_Release(*dst);
7514
7515 *dst = *src;
7516 }
7517
7518 /* ID3D10EffectVariable methods */
7519
7520 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectShaderResourceVariable(
7521 ID3D10EffectShaderResourceVariable *iface)
7522 {
7523 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
7524 }
7525
7526 static BOOL STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_IsValid(ID3D10EffectShaderResourceVariable *iface)
7527 {
7528 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderResourceVariable(iface);
7529
7530 TRACE("iface %p.\n", iface);
7531
7532 return v != &null_shader_resource_variable;
7533 }
7534
7535 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetType(
7536 ID3D10EffectShaderResourceVariable *iface)
7537 {
7538 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
7539 }
7540
7541 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetDesc(
7542 ID3D10EffectShaderResourceVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
7543 {
7544 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
7545 }
7546
7547 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetAnnotationByIndex(
7548 ID3D10EffectShaderResourceVariable *iface, UINT index)
7549 {
7550 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
7551 }
7552
7553 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetAnnotationByName(
7554 ID3D10EffectShaderResourceVariable *iface, const char *name)
7555 {
7556 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
7557 }
7558
7559 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberByIndex(
7560 ID3D10EffectShaderResourceVariable *iface, UINT index)
7561 {
7562 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
7563 }
7564
7565 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberByName(
7566 ID3D10EffectShaderResourceVariable *iface, const char *name)
7567 {
7568 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
7569 }
7570
7571 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberBySemantic(
7572 ID3D10EffectShaderResourceVariable *iface, const char *semantic)
7573 {
7574 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
7575 }
7576
7577 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetElement(
7578 ID3D10EffectShaderResourceVariable *iface, UINT index)
7579 {
7580 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
7581 }
7582
7583 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetParentConstantBuffer(
7584 ID3D10EffectShaderResourceVariable *iface)
7585 {
7586 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
7587 }
7588
7589 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsScalar(
7590 ID3D10EffectShaderResourceVariable *iface)
7591 {
7592 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
7593 }
7594
7595 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsVector(
7596 ID3D10EffectShaderResourceVariable *iface)
7597 {
7598 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
7599 }
7600
7601 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsMatrix(
7602 ID3D10EffectShaderResourceVariable *iface)
7603 {
7604 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
7605 }
7606
7607 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsString(
7608 ID3D10EffectShaderResourceVariable *iface)
7609 {
7610 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
7611 }
7612
7613 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsShaderResource(
7614 ID3D10EffectShaderResourceVariable *iface)
7615 {
7616 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
7617 }
7618
7619 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsRenderTargetView(
7620 ID3D10EffectShaderResourceVariable *iface)
7621 {
7622 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
7623 }
7624
7625 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsDepthStencilView(
7626 ID3D10EffectShaderResourceVariable *iface)
7627 {
7628 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
7629 }
7630
7631 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsConstantBuffer(
7632 ID3D10EffectShaderResourceVariable *iface)
7633 {
7634 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
7635 }
7636
7637 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsShader(
7638 ID3D10EffectShaderResourceVariable *iface)
7639 {
7640 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
7641 }
7642
7643 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsBlend(
7644 ID3D10EffectShaderResourceVariable *iface)
7645 {
7646 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
7647 }
7648
7649 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsDepthStencil(
7650 ID3D10EffectShaderResourceVariable *iface)
7651 {
7652 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
7653 }
7654
7655 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsRasterizer(
7656 ID3D10EffectShaderResourceVariable *iface)
7657 {
7658 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
7659 }
7660
7661 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsSampler(
7662 ID3D10EffectShaderResourceVariable *iface)
7663 {
7664 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
7665 }
7666
7667 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetRawValue(
7668 ID3D10EffectShaderResourceVariable *iface, void *data, UINT offset, UINT count)
7669 {
7670 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
7671 }
7672
7673 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetRawValue(
7674 ID3D10EffectShaderResourceVariable *iface, void *data, UINT offset, UINT count)
7675 {
7676 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
7677 }
7678
7679 /* ID3D10EffectShaderResourceVariable methods */
7680
7681 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetResource(
7682 ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView *resource)
7683 {
7684 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderResourceVariable(iface);
7685
7686 TRACE("iface %p, resource %p.\n", iface, resource);
7687
7688 if (!d3d10_effect_shader_resource_variable_IsValid(iface))
7689 return E_FAIL;
7690
7691 set_shader_resource_variable(&resource, v->u.resource.srv);
7692
7693 return S_OK;
7694 }
7695
7696 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetResource(
7697 ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resource)
7698 {
7699 FIXME("iface %p, resource %p stub!\n", iface, resource);
7700
7701 return E_NOTIMPL;
7702 }
7703
7704 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetResourceArray(
7705 ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resources, UINT offset, UINT count)
7706 {
7707 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderResourceVariable(iface);
7708 ID3D10ShaderResourceView **rsrc_view;
7709 unsigned int i;
7710
7711 TRACE("iface %p, resources %p, offset %u, count %u.\n", iface, resources, offset, count);
7712
7713 if (!v->type->element_count)
7714 return d3d10_effect_shader_resource_variable_SetResource(iface, *resources);
7715
7716 if (offset >= v->type->element_count)
7717 {
7718 WARN("Offset %u larger than element count %u, ignoring.\n", offset, v->type->element_count);
7719 return S_OK;
7720 }
7721
7722 if (count > v->type->element_count - offset)
7723 {
7724 WARN("Offset %u, count %u overruns the variable (element count %u), fixing up.\n",
7725 offset, count, v->type->element_count);
7726 count = v->type->element_count - offset;
7727 }
7728
7729 rsrc_view = &v->u.resource.srv[offset];
7730 for (i = 0; i < count; ++i)
7731 set_shader_resource_variable(&resources[i], &rsrc_view[i]);
7732
7733 return S_OK;
7734 }
7735
7736 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetResourceArray(
7737 ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resources, UINT offset, UINT count)
7738 {
7739 FIXME("iface %p, resources %p, offset %u, count %u stub!\n", iface, resources, offset, count);
7740
7741 return E_NOTIMPL;
7742 }
7743
7744
7745 static const struct ID3D10EffectShaderResourceVariableVtbl d3d10_effect_shader_resource_variable_vtbl =
7746 {
7747 /* ID3D10EffectVariable methods */
7748 d3d10_effect_shader_resource_variable_IsValid,
7749 d3d10_effect_shader_resource_variable_GetType,
7750 d3d10_effect_shader_resource_variable_GetDesc,
7751 d3d10_effect_shader_resource_variable_GetAnnotationByIndex,
7752 d3d10_effect_shader_resource_variable_GetAnnotationByName,
7753 d3d10_effect_shader_resource_variable_GetMemberByIndex,
7754 d3d10_effect_shader_resource_variable_GetMemberByName,
7755 d3d10_effect_shader_resource_variable_GetMemberBySemantic,
7756 d3d10_effect_shader_resource_variable_GetElement,
7757 d3d10_effect_shader_resource_variable_GetParentConstantBuffer,
7758 d3d10_effect_shader_resource_variable_AsScalar,
7759 d3d10_effect_shader_resource_variable_AsVector,
7760 d3d10_effect_shader_resource_variable_AsMatrix,
7761 d3d10_effect_shader_resource_variable_AsString,
7762 d3d10_effect_shader_resource_variable_AsShaderResource,
7763 d3d10_effect_shader_resource_variable_AsRenderTargetView,
7764 d3d10_effect_shader_resource_variable_AsDepthStencilView,
7765 d3d10_effect_shader_resource_variable_AsConstantBuffer,
7766 d3d10_effect_shader_resource_variable_AsShader,
7767 d3d10_effect_shader_resource_variable_AsBlend,
7768 d3d10_effect_shader_resource_variable_AsDepthStencil,
7769 d3d10_effect_shader_resource_variable_AsRasterizer,
7770 d3d10_effect_shader_resource_variable_AsSampler,
7771 d3d10_effect_shader_resource_variable_SetRawValue,
7772 d3d10_effect_shader_resource_variable_GetRawValue,
7773 /* ID3D10EffectShaderResourceVariable methods */
7774 d3d10_effect_shader_resource_variable_SetResource,
7775 d3d10_effect_shader_resource_variable_GetResource,
7776 d3d10_effect_shader_resource_variable_SetResourceArray,
7777 d3d10_effect_shader_resource_variable_GetResourceArray,
7778 };
7779
7780 /* ID3D10EffectVariable methods */
7781
7782 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectRenderTargetViewVariable(
7783 ID3D10EffectRenderTargetViewVariable *iface)
7784 {
7785 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
7786 }
7787
7788 static BOOL STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_IsValid(
7789 ID3D10EffectRenderTargetViewVariable *iface)
7790 {
7791 struct d3d10_effect_variable *v = impl_from_ID3D10EffectRenderTargetViewVariable(iface);
7792
7793 TRACE("iface %p\n", iface);
7794
7795 return v != &null_render_target_view_variable;
7796 }
7797
7798 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetType(
7799 ID3D10EffectRenderTargetViewVariable *iface)
7800 {
7801 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
7802 }
7803
7804 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetDesc(
7805 ID3D10EffectRenderTargetViewVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
7806 {
7807 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
7808 }
7809
7810 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetAnnotationByIndex(
7811 ID3D10EffectRenderTargetViewVariable *iface, UINT index)
7812 {
7813 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
7814 }
7815
7816 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetAnnotationByName(
7817 ID3D10EffectRenderTargetViewVariable *iface, const char *name)
7818 {
7819 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
7820 }
7821
7822 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberByIndex(
7823 ID3D10EffectRenderTargetViewVariable *iface, UINT index)
7824 {
7825 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
7826 }
7827
7828 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberByName(
7829 ID3D10EffectRenderTargetViewVariable *iface, const char *name)
7830 {
7831 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
7832 }
7833
7834 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberBySemantic(
7835 ID3D10EffectRenderTargetViewVariable *iface, const char *semantic)
7836 {
7837 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
7838 }
7839
7840 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetElement(
7841 ID3D10EffectRenderTargetViewVariable *iface, UINT index)
7842 {
7843 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
7844 }
7845
7846 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetParentConstantBuffer(
7847 ID3D10EffectRenderTargetViewVariable *iface)
7848 {
7849 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
7850 }
7851
7852 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsScalar(
7853 ID3D10EffectRenderTargetViewVariable *iface)
7854 {
7855 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
7856 }
7857
7858 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsVector(
7859 ID3D10EffectRenderTargetViewVariable *iface)
7860 {
7861 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
7862 }
7863
7864 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsMatrix(
7865 ID3D10EffectRenderTargetViewVariable *iface)
7866 {
7867 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
7868 }
7869
7870 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsString(
7871 ID3D10EffectRenderTargetViewVariable *iface)
7872 {
7873 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
7874 }
7875
7876 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsShaderResource(
7877 ID3D10EffectRenderTargetViewVariable *iface)
7878 {
7879 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
7880 }
7881
7882 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsRenderTargetView(
7883 ID3D10EffectRenderTargetViewVariable *iface)
7884 {
7885 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
7886 }
7887
7888 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsDepthStencilView(
7889 ID3D10EffectRenderTargetViewVariable *iface)
7890 {
7891 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
7892 }
7893
7894 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsConstantBuffer(
7895 ID3D10EffectRenderTargetViewVariable *iface)
7896 {
7897 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
7898 }
7899
7900 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsShader(
7901 ID3D10EffectRenderTargetViewVariable *iface)
7902 {
7903 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
7904 }
7905
7906 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsBlend(
7907 ID3D10EffectRenderTargetViewVariable *iface)
7908 {
7909 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
7910 }
7911
7912 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsDepthStencil(
7913 ID3D10EffectRenderTargetViewVariable *iface)
7914 {
7915 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
7916 }
7917
7918 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsRasterizer(
7919 ID3D10EffectRenderTargetViewVariable *iface)
7920 {
7921 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
7922 }
7923
7924 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsSampler(
7925 ID3D10EffectRenderTargetViewVariable *iface)
7926 {
7927 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
7928 }
7929
7930 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRawValue(
7931 ID3D10EffectRenderTargetViewVariable *iface, void *data, UINT offset, UINT count)
7932 {
7933 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
7934 }
7935
7936 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRawValue(
7937 ID3D10EffectRenderTargetViewVariable *iface, void *data, UINT offset, UINT count)
7938 {
7939 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
7940 }
7941
7942 /* ID3D10EffectRenderTargetViewVariable methods */
7943
7944 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRenderTarget(
7945 ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView *view)
7946 {
7947 FIXME("iface %p, view %p stub!\n", iface, view);
7948
7949 return E_NOTIMPL;
7950 }
7951
7952 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRenderTarget(
7953 ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **view)
7954 {
7955 FIXME("iface %p, view %p stub!\n", iface, view);
7956
7957 return E_NOTIMPL;
7958 }
7959
7960 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRenderTargetArray(
7961 ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **views, UINT offset, UINT count)
7962 {
7963 FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
7964
7965 return E_NOTIMPL;
7966 }
7967
7968 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRenderTargetArray(
7969 ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **views, UINT offset, UINT count)
7970 {
7971 FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
7972
7973 return E_NOTIMPL;
7974 }
7975
7976
7977 static const struct ID3D10EffectRenderTargetViewVariableVtbl d3d10_effect_render_target_view_variable_vtbl =
7978 {
7979 /* ID3D10EffectVariable methods */
7980 d3d10_effect_render_target_view_variable_IsValid,
7981 d3d10_effect_render_target_view_variable_GetType,
7982 d3d10_effect_render_target_view_variable_GetDesc,
7983 d3d10_effect_render_target_view_variable_GetAnnotationByIndex,
7984 d3d10_effect_render_target_view_variable_GetAnnotationByName,
7985 d3d10_effect_render_target_view_variable_GetMemberByIndex,
7986 d3d10_effect_render_target_view_variable_GetMemberByName,
7987 d3d10_effect_render_target_view_variable_GetMemberBySemantic,
7988 d3d10_effect_render_target_view_variable_GetElement,
7989 d3d10_effect_render_target_view_variable_GetParentConstantBuffer,
7990 d3d10_effect_render_target_view_variable_AsScalar,
7991 d3d10_effect_render_target_view_variable_AsVector,
7992 d3d10_effect_render_target_view_variable_AsMatrix,
7993 d3d10_effect_render_target_view_variable_AsString,
7994 d3d10_effect_render_target_view_variable_AsShaderResource,
7995 d3d10_effect_render_target_view_variable_AsRenderTargetView,
7996 d3d10_effect_render_target_view_variable_AsDepthStencilView,
7997 d3d10_effect_render_target_view_variable_AsConstantBuffer,
7998 d3d10_effect_render_target_view_variable_AsShader,
7999 d3d10_effect_render_target_view_variable_AsBlend,
8000 d3d10_effect_render_target_view_variable_AsDepthStencil,
8001 d3d10_effect_render_target_view_variable_AsRasterizer,
8002 d3d10_effect_render_target_view_variable_AsSampler,
8003 d3d10_effect_render_target_view_variable_SetRawValue,
8004 d3d10_effect_render_target_view_variable_GetRawValue,
8005 /* ID3D10EffectRenderTargetViewVariable methods */
8006 d3d10_effect_render_target_view_variable_SetRenderTarget,
8007 d3d10_effect_render_target_view_variable_GetRenderTarget,
8008 d3d10_effect_render_target_view_variable_SetRenderTargetArray,
8009 d3d10_effect_render_target_view_variable_GetRenderTargetArray,
8010 };
8011
8012 /* ID3D10EffectVariable methods */
8013
8014 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectDepthStencilViewVariable(
8015 ID3D10EffectDepthStencilViewVariable *iface)
8016 {
8017 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
8018 }
8019
8020 static BOOL STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_IsValid(
8021 ID3D10EffectDepthStencilViewVariable *iface)
8022 {
8023 struct d3d10_effect_variable *v = impl_from_ID3D10EffectDepthStencilViewVariable(iface);
8024
8025 TRACE("iface %p\n", iface);
8026
8027 return v != &null_depth_stencil_view_variable;
8028 }
8029
8030 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetType(
8031 ID3D10EffectDepthStencilViewVariable *iface)
8032 {
8033 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
8034 }
8035
8036 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDesc(
8037 ID3D10EffectDepthStencilViewVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
8038 {
8039 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
8040 }
8041
8042 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetAnnotationByIndex(
8043 ID3D10EffectDepthStencilViewVariable *iface, UINT index)
8044 {
8045 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
8046 }
8047
8048 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetAnnotationByName(
8049 ID3D10EffectDepthStencilViewVariable *iface, const char *name)
8050 {
8051 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
8052 }
8053
8054 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberByIndex(
8055 ID3D10EffectDepthStencilViewVariable *iface, UINT index)
8056 {
8057 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
8058 }
8059
8060 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberByName(
8061 ID3D10EffectDepthStencilViewVariable *iface, const char *name)
8062 {
8063 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
8064 }
8065
8066 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberBySemantic(
8067 ID3D10EffectDepthStencilViewVariable *iface, const char *semantic)
8068 {
8069 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
8070 }
8071
8072 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetElement(
8073 ID3D10EffectDepthStencilViewVariable *iface, UINT index)
8074 {
8075 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
8076 }
8077
8078 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetParentConstantBuffer(
8079 ID3D10EffectDepthStencilViewVariable *iface)
8080 {
8081 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
8082 }
8083
8084 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsScalar(
8085 ID3D10EffectDepthStencilViewVariable *iface)
8086 {
8087 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
8088 }
8089
8090 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsVector(
8091 ID3D10EffectDepthStencilViewVariable *iface)
8092 {
8093 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
8094 }
8095
8096 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsMatrix(
8097 ID3D10EffectDepthStencilViewVariable *iface)
8098 {
8099 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
8100 }
8101
8102 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsString(
8103 ID3D10EffectDepthStencilViewVariable *iface)
8104 {
8105 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
8106 }
8107
8108 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsShaderResource(
8109 ID3D10EffectDepthStencilViewVariable *iface)
8110 {
8111 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
8112 }
8113
8114 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsRenderTargetView(
8115 ID3D10EffectDepthStencilViewVariable *iface)
8116 {
8117 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
8118 }
8119
8120 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsDepthStencilView(
8121 ID3D10EffectDepthStencilViewVariable *iface)
8122 {
8123 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
8124 }
8125
8126 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsConstantBuffer(
8127 ID3D10EffectDepthStencilViewVariable *iface)
8128 {
8129 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
8130 }
8131
8132 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsShader(
8133 ID3D10EffectDepthStencilViewVariable *iface)
8134 {
8135 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
8136 }
8137
8138 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsBlend(
8139 ID3D10EffectDepthStencilViewVariable *iface)
8140 {
8141 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
8142 }
8143
8144 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsDepthStencil(
8145 ID3D10EffectDepthStencilViewVariable *iface)
8146 {
8147 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
8148 }
8149
8150 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsRasterizer(
8151 ID3D10EffectDepthStencilViewVariable *iface)
8152 {
8153 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
8154 }
8155
8156 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsSampler(
8157 ID3D10EffectDepthStencilViewVariable *iface)
8158 {
8159 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
8160 }
8161
8162 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetRawValue(
8163 ID3D10EffectDepthStencilViewVariable *iface, void *data, UINT offset, UINT count)
8164 {
8165 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
8166 }
8167
8168 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetRawValue(
8169 ID3D10EffectDepthStencilViewVariable *iface, void *data, UINT offset, UINT count)
8170 {
8171 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
8172 }
8173
8174 /* ID3D10EffectDepthStencilViewVariable methods */
8175
8176 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetDepthStencil(
8177 ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView *view)
8178 {
8179 FIXME("iface %p, view %p stub!\n", iface, view);
8180
8181 return E_NOTIMPL;
8182 }
8183
8184 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDepthStencil(
8185 ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **view)
8186 {
8187 FIXME("iface %p, view %p stub!\n", iface, view);
8188
8189 return E_NOTIMPL;
8190 }
8191
8192 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetDepthStencilArray(
8193 ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **views, UINT offset, UINT count)
8194 {
8195 FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
8196
8197 return E_NOTIMPL;
8198 }
8199
8200 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDepthStencilArray(
8201 ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **views, UINT offset, UINT count)
8202 {
8203 FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
8204
8205 return E_NOTIMPL;
8206 }
8207
8208
8209 static const struct ID3D10EffectDepthStencilViewVariableVtbl d3d10_effect_depth_stencil_view_variable_vtbl =
8210 {
8211 /* ID3D10EffectVariable methods */
8212 d3d10_effect_depth_stencil_view_variable_IsValid,
8213 d3d10_effect_depth_stencil_view_variable_GetType,
8214 d3d10_effect_depth_stencil_view_variable_GetDesc,
8215 d3d10_effect_depth_stencil_view_variable_GetAnnotationByIndex,
8216 d3d10_effect_depth_stencil_view_variable_GetAnnotationByName,
8217 d3d10_effect_depth_stencil_view_variable_GetMemberByIndex,
8218 d3d10_effect_depth_stencil_view_variable_GetMemberByName,
8219 d3d10_effect_depth_stencil_view_variable_GetMemberBySemantic,
8220 d3d10_effect_depth_stencil_view_variable_GetElement,
8221 d3d10_effect_depth_stencil_view_variable_GetParentConstantBuffer,
8222 d3d10_effect_depth_stencil_view_variable_AsScalar,
8223 d3d10_effect_depth_stencil_view_variable_AsVector,
8224 d3d10_effect_depth_stencil_view_variable_AsMatrix,
8225 d3d10_effect_depth_stencil_view_variable_AsString,
8226 d3d10_effect_depth_stencil_view_variable_AsShaderResource,
8227 d3d10_effect_depth_stencil_view_variable_AsRenderTargetView,
8228 d3d10_effect_depth_stencil_view_variable_AsDepthStencilView,
8229 d3d10_effect_depth_stencil_view_variable_AsConstantBuffer,
8230 d3d10_effect_depth_stencil_view_variable_AsShader,
8231 d3d10_effect_depth_stencil_view_variable_AsBlend,
8232 d3d10_effect_depth_stencil_view_variable_AsDepthStencil,
8233 d3d10_effect_depth_stencil_view_variable_AsRasterizer,
8234 d3d10_effect_depth_stencil_view_variable_AsSampler,
8235 d3d10_effect_depth_stencil_view_variable_SetRawValue,
8236 d3d10_effect_depth_stencil_view_variable_GetRawValue,
8237 /* ID3D10EffectDepthStencilViewVariable methods */
8238 d3d10_effect_depth_stencil_view_variable_SetDepthStencil,
8239 d3d10_effect_depth_stencil_view_variable_GetDepthStencil,
8240 d3d10_effect_depth_stencil_view_variable_SetDepthStencilArray,
8241 d3d10_effect_depth_stencil_view_variable_GetDepthStencilArray,
8242 };
8243
8244 /* ID3D10EffectVariable methods */
8245
8246 static BOOL STDMETHODCALLTYPE d3d10_effect_shader_variable_IsValid(ID3D10EffectShaderVariable *iface)
8247 {
8248 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderVariable(iface);
8249
8250 TRACE("iface %p\n", iface);
8251
8252 return v != &null_shader_variable;
8253 }
8254
8255 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetType(
8256 ID3D10EffectShaderVariable *iface)
8257 {
8258 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
8259 }
8260
8261 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetDesc(ID3D10EffectShaderVariable *iface,
8262 D3D10_EFFECT_VARIABLE_DESC *desc)
8263 {
8264 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
8265 }
8266
8267 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetAnnotationByIndex(
8268 ID3D10EffectShaderVariable *iface, UINT index)
8269 {
8270 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
8271 }
8272
8273 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetAnnotationByName(
8274 ID3D10EffectShaderVariable *iface, const char *name)
8275 {
8276 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
8277 }
8278
8279 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberByIndex(
8280 ID3D10EffectShaderVariable *iface, UINT index)
8281 {
8282 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
8283 }
8284
8285 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberByName(
8286 ID3D10EffectShaderVariable *iface, const char *name)
8287 {
8288 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
8289 }
8290
8291 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberBySemantic(
8292 ID3D10EffectShaderVariable *iface, const char *semantic)
8293 {
8294 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
8295 }
8296
8297 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetElement(
8298 ID3D10EffectShaderVariable *iface, UINT index)
8299 {
8300 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
8301 }
8302
8303 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetParentConstantBuffer(
8304 ID3D10EffectShaderVariable *iface)
8305 {
8306 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
8307 }
8308
8309 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsScalar(
8310 ID3D10EffectShaderVariable *iface)
8311 {
8312 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
8313 }
8314
8315 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsVector(
8316 ID3D10EffectShaderVariable *iface)
8317 {
8318 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
8319 }
8320
8321 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsMatrix(
8322 ID3D10EffectShaderVariable *iface)
8323 {
8324 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
8325 }
8326
8327 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsString(
8328 ID3D10EffectShaderVariable *iface)
8329 {
8330 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
8331 }
8332
8333 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsShaderResource(
8334 ID3D10EffectShaderVariable *iface)
8335 {
8336 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
8337 }
8338
8339 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsRenderTargetView(
8340 ID3D10EffectShaderVariable *iface)
8341 {
8342 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
8343 }
8344
8345 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsDepthStencilView(
8346 ID3D10EffectShaderVariable *iface)
8347 {
8348 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
8349 }
8350
8351 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsConstantBuffer(
8352 ID3D10EffectShaderVariable *iface)
8353 {
8354 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
8355 }
8356
8357 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsShader(
8358 ID3D10EffectShaderVariable *iface)
8359 {
8360 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
8361 }
8362
8363 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsBlend(
8364 ID3D10EffectShaderVariable *iface)
8365 {
8366 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
8367 }
8368
8369 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsDepthStencil(
8370 ID3D10EffectShaderVariable *iface)
8371 {
8372 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
8373 }
8374
8375 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsRasterizer(
8376 ID3D10EffectShaderVariable *iface)
8377 {
8378 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
8379 }
8380
8381 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsSampler(
8382 ID3D10EffectShaderVariable *iface)
8383 {
8384 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
8385 }
8386
8387 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_SetRawValue(
8388 ID3D10EffectShaderVariable *iface, void *data, UINT offset, UINT count)
8389 {
8390 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
8391 }
8392
8393 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetRawValue(
8394 ID3D10EffectShaderVariable *iface, void *data, UINT offset, UINT count)
8395 {
8396 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
8397 }
8398
8399 /* ID3D10EffectShaderVariable methods */
8400
8401 static HRESULT d3d10_get_shader_variable(struct d3d10_effect_variable *v, UINT shader_index,
8402 struct d3d10_effect_shader_variable **s, D3D10_SHADER_VARIABLE_TYPE *basetype)
8403 {
8404 unsigned int i;
8405
8406 v = d3d10_array_get_element(v, 0);
8407
8408 if (!shader_index)
8409 {
8410 *s = &v->u.shader;
8411 if (basetype) *basetype = v->type->basetype;
8412 return S_OK;
8413 }
8414
8415 /* Index is used as an offset from this variable. */
8416
8417 for (i = 0; i < v->effect->shaders.count; ++i)
8418 {
8419 if (v == v->effect->shaders.v[i]) break;
8420 }
8421
8422 if (i + shader_index >= v->effect->shaders.count)
8423 {
8424 WARN("Invalid shader index %u.\n", shader_index);
8425 return E_FAIL;
8426 }
8427
8428 *s = &v->effect->shaders.v[i + shader_index]->u.shader;
8429 if (basetype) *basetype = v->effect->shaders.v[i + shader_index]->type->basetype;
8430
8431 return S_OK;
8432 }
8433
8434 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetShaderDesc(
8435 ID3D10EffectShaderVariable *iface, UINT index, D3D10_EFFECT_SHADER_DESC *desc)
8436 {
8437 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderVariable(iface);
8438 struct d3d10_effect_shader_variable *s;
8439 D3D10_SHADER_DESC shader_desc;
8440 HRESULT hr;
8441
8442 TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
8443
8444 if (FAILED(hr = d3d10_get_shader_variable(v, index, &s, NULL)))
8445 return hr;
8446
8447 memset(desc, 0, sizeof(*desc));
8448 if (s->input_signature)
8449 desc->pInputSignature = ID3D10Blob_GetBufferPointer(s->input_signature);
8450 desc->SODecl = s->stream_output_declaration;
8451 desc->IsInline = s->isinline;
8452 if (s->bytecode)
8453 {
8454 desc->pBytecode = ID3D10Blob_GetBufferPointer(s->bytecode);
8455 desc->BytecodeLength = ID3D10Blob_GetBufferSize(s->bytecode);
8456 }
8457 if (s->reflection)
8458 {
8459 if (SUCCEEDED(hr = s->reflection->lpVtbl->GetDesc(s->reflection, &shader_desc)))
8460 {
8461 desc->NumInputSignatureEntries = shader_desc.InputParameters;
8462 desc->NumOutputSignatureEntries = shader_desc.OutputParameters;
8463 }
8464 }
8465
8466 return hr;
8467 }
8468
8469 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetVertexShader(
8470 ID3D10EffectShaderVariable *iface, UINT index, ID3D10VertexShader **shader)
8471 {
8472 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderVariable(iface);
8473 struct d3d10_effect_shader_variable *s;
8474 D3D10_SHADER_VARIABLE_TYPE basetype;
8475 HRESULT hr;
8476
8477 TRACE("iface %p, index %u, shader %p.\n", iface, index, shader);
8478
8479 *shader = NULL;
8480
8481 if (FAILED(hr = d3d10_get_shader_variable(v, index, &s, &basetype)))
8482 return hr;
8483
8484 if (basetype != D3D10_SVT_VERTEXSHADER)
8485 {
8486 WARN("Shader is not a vertex shader.\n");
8487 return D3DERR_INVALIDCALL;
8488 }
8489
8490 if ((*shader = s->shader.vs))
8491 ID3D10VertexShader_AddRef(*shader);
8492
8493 return S_OK;
8494 }
8495
8496 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetGeometryShader(
8497 ID3D10EffectShaderVariable *iface, UINT index, ID3D10GeometryShader **shader)
8498 {
8499 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderVariable(iface);
8500 struct d3d10_effect_shader_variable *s;
8501 D3D10_SHADER_VARIABLE_TYPE basetype;
8502 HRESULT hr;
8503
8504 TRACE("iface %p, index %u, shader %p.\n", iface, index, shader);
8505
8506 *shader = NULL;
8507
8508 if (FAILED(hr = d3d10_get_shader_variable(v, index, &s, &basetype)))
8509 return hr;
8510
8511 if (basetype != D3D10_SVT_GEOMETRYSHADER)
8512 {
8513 WARN("Shader is not a geometry shader.\n");
8514 return D3DERR_INVALIDCALL;
8515 }
8516
8517 if ((*shader = s->shader.gs))
8518 ID3D10GeometryShader_AddRef(*shader);
8519
8520 return S_OK;
8521 }
8522
8523 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetPixelShader(
8524 ID3D10EffectShaderVariable *iface, UINT index, ID3D10PixelShader **shader)
8525 {
8526 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderVariable(iface);
8527 struct d3d10_effect_shader_variable *s;
8528 D3D10_SHADER_VARIABLE_TYPE basetype;
8529 HRESULT hr;
8530
8531 TRACE("iface %p, index %u, shader %p.\n", iface, index, shader);
8532
8533 *shader = NULL;
8534
8535 if (FAILED(hr = d3d10_get_shader_variable(v, index, &s, &basetype)))
8536 return hr;
8537
8538 if (basetype != D3D10_SVT_PIXELSHADER)
8539 {
8540 WARN("Shader is not a pixel shader.\n");
8541 return D3DERR_INVALIDCALL;
8542 }
8543
8544 if ((*shader = s->shader.ps))
8545 ID3D10PixelShader_AddRef(*shader);
8546
8547 return S_OK;
8548 }
8549
8550 static HRESULT d3d10_get_shader_variable_signature(struct d3d10_effect_variable *v,
8551 UINT shader_index, UINT element_index, BOOL output, D3D10_SIGNATURE_PARAMETER_DESC *desc)
8552 {
8553 struct d3d10_effect_shader_variable *s;
8554 HRESULT hr;
8555
8556 if (FAILED(hr = d3d10_get_shader_variable(v, shader_index, &s, NULL)))
8557 return hr;
8558
8559 if (!s->reflection)
8560 return D3DERR_INVALIDCALL;
8561
8562 if (output)
8563 return s->reflection->lpVtbl->GetOutputParameterDesc(s->reflection, element_index, desc);
8564 else
8565 return s->reflection->lpVtbl->GetInputParameterDesc(s->reflection, element_index, desc);
8566 }
8567
8568 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetInputSignatureElementDesc(
8569 ID3D10EffectShaderVariable *iface, UINT shader_index, UINT element_index,
8570 D3D10_SIGNATURE_PARAMETER_DESC *desc)
8571 {
8572 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderVariable(iface);
8573
8574 TRACE("iface %p, shader_index %u, element_index %u, desc %p\n",
8575 iface, shader_index, element_index, desc);
8576
8577 if (!iface->lpVtbl->IsValid(iface))
8578 {
8579 WARN("Null variable specified\n");
8580 return E_FAIL;
8581 }
8582
8583 return d3d10_get_shader_variable_signature(v, shader_index, element_index, FALSE, desc);
8584 }
8585
8586 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetOutputSignatureElementDesc(
8587 ID3D10EffectShaderVariable *iface, UINT shader_index, UINT element_index,
8588 D3D10_SIGNATURE_PARAMETER_DESC *desc)
8589 {
8590 struct d3d10_effect_variable *v = impl_from_ID3D10EffectShaderVariable(iface);
8591
8592 TRACE("iface %p, shader_index %u, element_index %u, desc %p\n",
8593 iface, shader_index, element_index, desc);
8594
8595 if (!iface->lpVtbl->IsValid(iface))
8596 {
8597 WARN("Null variable specified\n");
8598 return E_FAIL;
8599 }
8600
8601 return d3d10_get_shader_variable_signature(v, shader_index, element_index, TRUE, desc);
8602 }
8603
8604
8605 static const struct ID3D10EffectShaderVariableVtbl d3d10_effect_shader_variable_vtbl =
8606 {
8607 /* ID3D10EffectVariable methods */
8608 d3d10_effect_shader_variable_IsValid,
8609 d3d10_effect_shader_variable_GetType,
8610 d3d10_effect_shader_variable_GetDesc,
8611 d3d10_effect_shader_variable_GetAnnotationByIndex,
8612 d3d10_effect_shader_variable_GetAnnotationByName,
8613 d3d10_effect_shader_variable_GetMemberByIndex,
8614 d3d10_effect_shader_variable_GetMemberByName,
8615 d3d10_effect_shader_variable_GetMemberBySemantic,
8616 d3d10_effect_shader_variable_GetElement,
8617 d3d10_effect_shader_variable_GetParentConstantBuffer,
8618 d3d10_effect_shader_variable_AsScalar,
8619 d3d10_effect_shader_variable_AsVector,
8620 d3d10_effect_shader_variable_AsMatrix,
8621 d3d10_effect_shader_variable_AsString,
8622 d3d10_effect_shader_variable_AsShaderResource,
8623 d3d10_effect_shader_variable_AsRenderTargetView,
8624 d3d10_effect_shader_variable_AsDepthStencilView,
8625 d3d10_effect_shader_variable_AsConstantBuffer,
8626 d3d10_effect_shader_variable_AsShader,
8627 d3d10_effect_shader_variable_AsBlend,
8628 d3d10_effect_shader_variable_AsDepthStencil,
8629 d3d10_effect_shader_variable_AsRasterizer,
8630 d3d10_effect_shader_variable_AsSampler,
8631 d3d10_effect_shader_variable_SetRawValue,
8632 d3d10_effect_shader_variable_GetRawValue,
8633 /* ID3D10EffectShaderVariable methods */
8634 d3d10_effect_shader_variable_GetShaderDesc,
8635 d3d10_effect_shader_variable_GetVertexShader,
8636 d3d10_effect_shader_variable_GetGeometryShader,
8637 d3d10_effect_shader_variable_GetPixelShader,
8638 d3d10_effect_shader_variable_GetInputSignatureElementDesc,
8639 d3d10_effect_shader_variable_GetOutputSignatureElementDesc,
8640 };
8641
8642 /* ID3D10EffectVariable methods */
8643
8644 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectBlendVariable(
8645 ID3D10EffectBlendVariable *iface)
8646 {
8647 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
8648 }
8649
8650 static BOOL STDMETHODCALLTYPE d3d10_effect_blend_variable_IsValid(ID3D10EffectBlendVariable *iface)
8651 {
8652 struct d3d10_effect_variable *v = impl_from_ID3D10EffectBlendVariable(iface);
8653
8654 TRACE("iface %p\n", iface);
8655
8656 return v != &null_blend_variable;
8657 }
8658
8659 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetType(
8660 ID3D10EffectBlendVariable *iface)
8661 {
8662 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
8663 }
8664
8665 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetDesc(ID3D10EffectBlendVariable *iface,
8666 D3D10_EFFECT_VARIABLE_DESC *desc)
8667 {
8668 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
8669 }
8670
8671 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetAnnotationByIndex(
8672 ID3D10EffectBlendVariable *iface, UINT index)
8673 {
8674 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
8675 }
8676
8677 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetAnnotationByName(
8678 ID3D10EffectBlendVariable *iface, const char *name)
8679 {
8680 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
8681 }
8682
8683 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberByIndex(
8684 ID3D10EffectBlendVariable *iface, UINT index)
8685 {
8686 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
8687 }
8688
8689 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberByName(
8690 ID3D10EffectBlendVariable *iface, const char *name)
8691 {
8692 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
8693 }
8694
8695 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberBySemantic(
8696 ID3D10EffectBlendVariable *iface, const char *semantic)
8697 {
8698 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
8699 }
8700
8701 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetElement(
8702 ID3D10EffectBlendVariable *iface, UINT index)
8703 {
8704 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
8705 }
8706
8707 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetParentConstantBuffer(
8708 ID3D10EffectBlendVariable *iface)
8709 {
8710 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
8711 }
8712
8713 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsScalar(
8714 ID3D10EffectBlendVariable *iface)
8715 {
8716 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
8717 }
8718
8719 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsVector(
8720 ID3D10EffectBlendVariable *iface)
8721 {
8722 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
8723 }
8724
8725 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsMatrix(
8726 ID3D10EffectBlendVariable *iface)
8727 {
8728 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
8729 }
8730
8731 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsString(
8732 ID3D10EffectBlendVariable *iface)
8733 {
8734 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
8735 }
8736
8737 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsShaderResource(
8738 ID3D10EffectBlendVariable *iface)
8739 {
8740 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
8741 }
8742
8743 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsRenderTargetView(
8744 ID3D10EffectBlendVariable *iface)
8745 {
8746 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
8747 }
8748
8749 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsDepthStencilView(
8750 ID3D10EffectBlendVariable *iface)
8751 {
8752 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
8753 }
8754
8755 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsConstantBuffer(
8756 ID3D10EffectBlendVariable *iface)
8757 {
8758 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
8759 }
8760
8761 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsShader(
8762 ID3D10EffectBlendVariable *iface)
8763 {
8764 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
8765 }
8766
8767 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsBlend(
8768 ID3D10EffectBlendVariable *iface)
8769 {
8770 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
8771 }
8772
8773 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsDepthStencil(
8774 ID3D10EffectBlendVariable *iface)
8775 {
8776 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
8777 }
8778
8779 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsRasterizer(
8780 ID3D10EffectBlendVariable *iface)
8781 {
8782 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
8783 }
8784
8785 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsSampler(
8786 ID3D10EffectBlendVariable *iface)
8787 {
8788 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
8789 }
8790
8791 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_SetRawValue(ID3D10EffectBlendVariable *iface,
8792 void *data, UINT offset, UINT count)
8793 {
8794 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
8795 }
8796
8797 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetRawValue(ID3D10EffectBlendVariable *iface,
8798 void *data, UINT offset, UINT count)
8799 {
8800 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
8801 }
8802
8803 /* ID3D10EffectBlendVariable methods */
8804
8805 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetBlendState(ID3D10EffectBlendVariable *iface,
8806 UINT index, ID3D10BlendState **blend_state)
8807 {
8808 struct d3d10_effect_variable *v = impl_from_ID3D10EffectBlendVariable(iface);
8809
8810 TRACE("iface %p, index %u, blend_state %p.\n", iface, index, blend_state);
8811
8812 if (!iface->lpVtbl->IsValid(iface))
8813 {
8814 WARN("Invalid variable.\n");
8815 return E_FAIL;
8816 }
8817
8818 if (!(v = d3d10_get_state_variable(v, index, &v->effect->blend_states)))
8819 return E_FAIL;
8820
8821 if ((*blend_state = v->u.state.object.blend))
8822 ID3D10BlendState_AddRef(*blend_state);
8823
8824 return S_OK;
8825 }
8826
8827 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetBackingStore(ID3D10EffectBlendVariable *iface,
8828 UINT index, D3D10_BLEND_DESC *desc)
8829 {
8830 struct d3d10_effect_variable *v = impl_from_ID3D10EffectBlendVariable(iface);
8831
8832 TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
8833
8834 if (!iface->lpVtbl->IsValid(iface))
8835 {
8836 WARN("Invalid variable.\n");
8837 return E_FAIL;
8838 }
8839
8840 if (!(v = d3d10_get_state_variable(v, index, &v->effect->blend_states)))
8841 return E_FAIL;
8842
8843 *desc = v->u.state.desc.blend;
8844
8845 return S_OK;
8846 }
8847
8848 static const struct ID3D10EffectBlendVariableVtbl d3d10_effect_blend_variable_vtbl =
8849 {
8850 /* ID3D10EffectVariable methods */
8851 d3d10_effect_blend_variable_IsValid,
8852 d3d10_effect_blend_variable_GetType,
8853 d3d10_effect_blend_variable_GetDesc,
8854 d3d10_effect_blend_variable_GetAnnotationByIndex,
8855 d3d10_effect_blend_variable_GetAnnotationByName,
8856 d3d10_effect_blend_variable_GetMemberByIndex,
8857 d3d10_effect_blend_variable_GetMemberByName,
8858 d3d10_effect_blend_variable_GetMemberBySemantic,
8859 d3d10_effect_blend_variable_GetElement,
8860 d3d10_effect_blend_variable_GetParentConstantBuffer,
8861 d3d10_effect_blend_variable_AsScalar,
8862 d3d10_effect_blend_variable_AsVector,
8863 d3d10_effect_blend_variable_AsMatrix,
8864 d3d10_effect_blend_variable_AsString,
8865 d3d10_effect_blend_variable_AsShaderResource,
8866 d3d10_effect_blend_variable_AsRenderTargetView,
8867 d3d10_effect_blend_variable_AsDepthStencilView,
8868 d3d10_effect_blend_variable_AsConstantBuffer,
8869 d3d10_effect_blend_variable_AsShader,
8870 d3d10_effect_blend_variable_AsBlend,
8871 d3d10_effect_blend_variable_AsDepthStencil,
8872 d3d10_effect_blend_variable_AsRasterizer,
8873 d3d10_effect_blend_variable_AsSampler,
8874 d3d10_effect_blend_variable_SetRawValue,
8875 d3d10_effect_blend_variable_GetRawValue,
8876 /* ID3D10EffectBlendVariable methods */
8877 d3d10_effect_blend_variable_GetBlendState,
8878 d3d10_effect_blend_variable_GetBackingStore,
8879 };
8880
8881 /* ID3D10EffectVariable methods */
8882
8883 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectDepthStencilVariable(
8884 ID3D10EffectDepthStencilVariable *iface)
8885 {
8886 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
8887 }
8888
8889 static BOOL STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_IsValid(ID3D10EffectDepthStencilVariable *iface)
8890 {
8891 struct d3d10_effect_variable *v = impl_from_ID3D10EffectDepthStencilVariable(iface);
8892
8893 TRACE("iface %p\n", iface);
8894
8895 return v != &null_depth_stencil_variable;
8896 }
8897
8898 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetType(
8899 ID3D10EffectDepthStencilVariable *iface)
8900 {
8901 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
8902 }
8903
8904 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetDesc(ID3D10EffectDepthStencilVariable *iface,
8905 D3D10_EFFECT_VARIABLE_DESC *desc)
8906 {
8907 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
8908 }
8909
8910 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetAnnotationByIndex(
8911 ID3D10EffectDepthStencilVariable *iface, UINT index)
8912 {
8913 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
8914 }
8915
8916 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetAnnotationByName(
8917 ID3D10EffectDepthStencilVariable *iface, const char *name)
8918 {
8919 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
8920 }
8921
8922 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberByIndex(
8923 ID3D10EffectDepthStencilVariable *iface, UINT index)
8924 {
8925 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
8926 }
8927
8928 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberByName(
8929 ID3D10EffectDepthStencilVariable *iface, const char *name)
8930 {
8931 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
8932 }
8933
8934 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberBySemantic(
8935 ID3D10EffectDepthStencilVariable *iface, const char *semantic)
8936 {
8937 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
8938 }
8939
8940 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetElement(
8941 ID3D10EffectDepthStencilVariable *iface, UINT index)
8942 {
8943 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
8944 }
8945
8946 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetParentConstantBuffer(
8947 ID3D10EffectDepthStencilVariable *iface)
8948 {
8949 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
8950 }
8951
8952 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsScalar(
8953 ID3D10EffectDepthStencilVariable *iface)
8954 {
8955 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
8956 }
8957
8958 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsVector(
8959 ID3D10EffectDepthStencilVariable *iface)
8960 {
8961 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
8962 }
8963
8964 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsMatrix(
8965 ID3D10EffectDepthStencilVariable *iface)
8966 {
8967 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
8968 }
8969
8970 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsString(
8971 ID3D10EffectDepthStencilVariable *iface)
8972 {
8973 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
8974 }
8975
8976 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsShaderResource(
8977 ID3D10EffectDepthStencilVariable *iface)
8978 {
8979 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
8980 }
8981
8982 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsRenderTargetView(
8983 ID3D10EffectDepthStencilVariable *iface)
8984 {
8985 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
8986 }
8987
8988 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsDepthStencilView(
8989 ID3D10EffectDepthStencilVariable *iface)
8990 {
8991 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
8992 }
8993
8994 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsConstantBuffer(
8995 ID3D10EffectDepthStencilVariable *iface)
8996 {
8997 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
8998 }
8999
9000 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsShader(
9001 ID3D10EffectDepthStencilVariable *iface)
9002 {
9003 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
9004 }
9005
9006 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsBlend(
9007 ID3D10EffectDepthStencilVariable *iface)
9008 {
9009 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
9010 }
9011
9012 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsDepthStencil(
9013 ID3D10EffectDepthStencilVariable *iface)
9014 {
9015 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
9016 }
9017
9018 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsRasterizer(
9019 ID3D10EffectDepthStencilVariable *iface)
9020 {
9021 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
9022 }
9023
9024 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsSampler(
9025 ID3D10EffectDepthStencilVariable *iface)
9026 {
9027 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
9028 }
9029
9030 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_SetRawValue(ID3D10EffectDepthStencilVariable *iface,
9031 void *data, UINT offset, UINT count)
9032 {
9033 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
9034 }
9035
9036 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetRawValue(ID3D10EffectDepthStencilVariable *iface,
9037 void *data, UINT offset, UINT count)
9038 {
9039 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
9040 }
9041
9042 /* ID3D10EffectDepthStencilVariable methods */
9043
9044 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetDepthStencilState(ID3D10EffectDepthStencilVariable *iface,
9045 UINT index, ID3D10DepthStencilState **depth_stencil_state)
9046 {
9047 struct d3d10_effect_variable *v = impl_from_ID3D10EffectDepthStencilVariable(iface);
9048
9049 TRACE("iface %p, index %u, depth_stencil_state %p.\n", iface, index, depth_stencil_state);
9050
9051 if (!iface->lpVtbl->IsValid(iface))
9052 {
9053 WARN("Invalid variable.\n");
9054 return E_FAIL;
9055 }
9056
9057 if (!(v = d3d10_get_state_variable(v, index, &v->effect->ds_states)))
9058 return E_FAIL;
9059
9060 if ((*depth_stencil_state = v->u.state.object.depth_stencil))
9061 ID3D10DepthStencilState_AddRef(*depth_stencil_state);
9062
9063 return S_OK;
9064 }
9065
9066 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetBackingStore(ID3D10EffectDepthStencilVariable *iface,
9067 UINT index, D3D10_DEPTH_STENCIL_DESC *desc)
9068 {
9069 struct d3d10_effect_variable *v = impl_from_ID3D10EffectDepthStencilVariable(iface);
9070
9071 TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
9072
9073 if (!iface->lpVtbl->IsValid(iface))
9074 {
9075 WARN("Invalid variable.\n");
9076 return E_FAIL;
9077 }
9078
9079 if (!(v = d3d10_get_state_variable(v, index, &v->effect->ds_states)))
9080 return E_FAIL;
9081
9082 d3d10_effect_update_dependent_props(&v->u.state.dependencies, &v->u.state.desc);
9083
9084 *desc = v->u.state.desc.depth_stencil;
9085
9086 return S_OK;
9087 }
9088
9089 static const struct ID3D10EffectDepthStencilVariableVtbl d3d10_effect_depth_stencil_variable_vtbl =
9090 {
9091 /* ID3D10EffectVariable methods */
9092 d3d10_effect_depth_stencil_variable_IsValid,
9093 d3d10_effect_depth_stencil_variable_GetType,
9094 d3d10_effect_depth_stencil_variable_GetDesc,
9095 d3d10_effect_depth_stencil_variable_GetAnnotationByIndex,
9096 d3d10_effect_depth_stencil_variable_GetAnnotationByName,
9097 d3d10_effect_depth_stencil_variable_GetMemberByIndex,
9098 d3d10_effect_depth_stencil_variable_GetMemberByName,
9099 d3d10_effect_depth_stencil_variable_GetMemberBySemantic,
9100 d3d10_effect_depth_stencil_variable_GetElement,
9101 d3d10_effect_depth_stencil_variable_GetParentConstantBuffer,
9102 d3d10_effect_depth_stencil_variable_AsScalar,
9103 d3d10_effect_depth_stencil_variable_AsVector,
9104 d3d10_effect_depth_stencil_variable_AsMatrix,
9105 d3d10_effect_depth_stencil_variable_AsString,
9106 d3d10_effect_depth_stencil_variable_AsShaderResource,
9107 d3d10_effect_depth_stencil_variable_AsRenderTargetView,
9108 d3d10_effect_depth_stencil_variable_AsDepthStencilView,
9109 d3d10_effect_depth_stencil_variable_AsConstantBuffer,
9110 d3d10_effect_depth_stencil_variable_AsShader,
9111 d3d10_effect_depth_stencil_variable_AsBlend,
9112 d3d10_effect_depth_stencil_variable_AsDepthStencil,
9113 d3d10_effect_depth_stencil_variable_AsRasterizer,
9114 d3d10_effect_depth_stencil_variable_AsSampler,
9115 d3d10_effect_depth_stencil_variable_SetRawValue,
9116 d3d10_effect_depth_stencil_variable_GetRawValue,
9117 /* ID3D10EffectDepthStencilVariable methods */
9118 d3d10_effect_depth_stencil_variable_GetDepthStencilState,
9119 d3d10_effect_depth_stencil_variable_GetBackingStore,
9120 };
9121
9122 /* ID3D10EffectVariable methods */
9123
9124 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectRasterizerVariable(
9125 ID3D10EffectRasterizerVariable *iface)
9126 {
9127 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
9128 }
9129
9130 static BOOL STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_IsValid(ID3D10EffectRasterizerVariable *iface)
9131 {
9132 struct d3d10_effect_variable *v = impl_from_ID3D10EffectRasterizerVariable(iface);
9133
9134 TRACE("iface %p\n", iface);
9135
9136 return v != &null_rasterizer_variable;
9137 }
9138
9139 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetType(
9140 ID3D10EffectRasterizerVariable *iface)
9141 {
9142 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
9143 }
9144
9145 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetDesc(ID3D10EffectRasterizerVariable *iface,
9146 D3D10_EFFECT_VARIABLE_DESC *desc)
9147 {
9148 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
9149 }
9150
9151 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetAnnotationByIndex(
9152 ID3D10EffectRasterizerVariable *iface, UINT index)
9153 {
9154 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
9155 }
9156
9157 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetAnnotationByName(
9158 ID3D10EffectRasterizerVariable *iface, const char *name)
9159 {
9160 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
9161 }
9162
9163 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberByIndex(
9164 ID3D10EffectRasterizerVariable *iface, UINT index)
9165 {
9166 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
9167 }
9168
9169 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberByName(
9170 ID3D10EffectRasterizerVariable *iface, const char *name)
9171 {
9172 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
9173 }
9174
9175 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberBySemantic(
9176 ID3D10EffectRasterizerVariable *iface, const char *semantic)
9177 {
9178 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
9179 }
9180
9181 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetElement(
9182 ID3D10EffectRasterizerVariable *iface, UINT index)
9183 {
9184 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
9185 }
9186
9187 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetParentConstantBuffer(
9188 ID3D10EffectRasterizerVariable *iface)
9189 {
9190 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
9191 }
9192
9193 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsScalar(
9194 ID3D10EffectRasterizerVariable *iface)
9195 {
9196 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
9197 }
9198
9199 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsVector(
9200 ID3D10EffectRasterizerVariable *iface)
9201 {
9202 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
9203 }
9204
9205 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsMatrix(
9206 ID3D10EffectRasterizerVariable *iface)
9207 {
9208 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
9209 }
9210
9211 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsString(
9212 ID3D10EffectRasterizerVariable *iface)
9213 {
9214 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
9215 }
9216
9217 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsShaderResource(
9218 ID3D10EffectRasterizerVariable *iface)
9219 {
9220 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
9221 }
9222
9223 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsRenderTargetView(
9224 ID3D10EffectRasterizerVariable *iface)
9225 {
9226 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
9227 }
9228
9229 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsDepthStencilView(
9230 ID3D10EffectRasterizerVariable *iface)
9231 {
9232 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
9233 }
9234
9235 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsConstantBuffer(
9236 ID3D10EffectRasterizerVariable *iface)
9237 {
9238 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
9239 }
9240
9241 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsShader(
9242 ID3D10EffectRasterizerVariable *iface)
9243 {
9244 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
9245 }
9246
9247 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsBlend(
9248 ID3D10EffectRasterizerVariable *iface)
9249 {
9250 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
9251 }
9252
9253 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsDepthStencil(
9254 ID3D10EffectRasterizerVariable *iface)
9255 {
9256 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
9257 }
9258
9259 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsRasterizer(
9260 ID3D10EffectRasterizerVariable *iface)
9261 {
9262 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
9263 }
9264
9265 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsSampler(
9266 ID3D10EffectRasterizerVariable *iface)
9267 {
9268 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
9269 }
9270
9271 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_SetRawValue(ID3D10EffectRasterizerVariable *iface,
9272 void *data, UINT offset, UINT count)
9273 {
9274 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
9275 }
9276
9277 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetRawValue(ID3D10EffectRasterizerVariable *iface,
9278 void *data, UINT offset, UINT count)
9279 {
9280 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
9281 }
9282
9283 /* ID3D10EffectRasterizerVariable methods */
9284
9285 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetRasterizerState(ID3D10EffectRasterizerVariable *iface,
9286 UINT index, ID3D10RasterizerState **rasterizer_state)
9287 {
9288 struct d3d10_effect_variable *v = impl_from_ID3D10EffectRasterizerVariable(iface);
9289
9290 TRACE("iface %p, index %u, rasterizer_state %p.\n", iface, index, rasterizer_state);
9291
9292 if (!iface->lpVtbl->IsValid(iface))
9293 {
9294 WARN("Invalid variable.\n");
9295 return E_FAIL;
9296 }
9297
9298 if (!(v = d3d10_get_state_variable(v, index, &v->effect->rs_states)))
9299 return E_FAIL;
9300
9301 if ((*rasterizer_state = v->u.state.object.rasterizer))
9302 ID3D10RasterizerState_AddRef(*rasterizer_state);
9303
9304 return S_OK;
9305 }
9306
9307 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetBackingStore(ID3D10EffectRasterizerVariable *iface,
9308 UINT index, D3D10_RASTERIZER_DESC *desc)
9309 {
9310 struct d3d10_effect_variable *v = impl_from_ID3D10EffectRasterizerVariable(iface);
9311
9312 TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
9313
9314 if (!iface->lpVtbl->IsValid(iface))
9315 {
9316 WARN("Invalid variable.\n");
9317 return E_FAIL;
9318 }
9319
9320 if (!(v = d3d10_get_state_variable(v, index, &v->effect->rs_states)))
9321 return E_FAIL;
9322
9323 *desc = v->u.state.desc.rasterizer;
9324
9325 return S_OK;
9326 }
9327
9328 static const struct ID3D10EffectRasterizerVariableVtbl d3d10_effect_rasterizer_variable_vtbl =
9329 {
9330 /* ID3D10EffectVariable methods */
9331 d3d10_effect_rasterizer_variable_IsValid,
9332 d3d10_effect_rasterizer_variable_GetType,
9333 d3d10_effect_rasterizer_variable_GetDesc,
9334 d3d10_effect_rasterizer_variable_GetAnnotationByIndex,
9335 d3d10_effect_rasterizer_variable_GetAnnotationByName,
9336 d3d10_effect_rasterizer_variable_GetMemberByIndex,
9337 d3d10_effect_rasterizer_variable_GetMemberByName,
9338 d3d10_effect_rasterizer_variable_GetMemberBySemantic,
9339 d3d10_effect_rasterizer_variable_GetElement,
9340 d3d10_effect_rasterizer_variable_GetParentConstantBuffer,
9341 d3d10_effect_rasterizer_variable_AsScalar,
9342 d3d10_effect_rasterizer_variable_AsVector,
9343 d3d10_effect_rasterizer_variable_AsMatrix,
9344 d3d10_effect_rasterizer_variable_AsString,
9345 d3d10_effect_rasterizer_variable_AsShaderResource,
9346 d3d10_effect_rasterizer_variable_AsRenderTargetView,
9347 d3d10_effect_rasterizer_variable_AsDepthStencilView,
9348 d3d10_effect_rasterizer_variable_AsConstantBuffer,
9349 d3d10_effect_rasterizer_variable_AsShader,
9350 d3d10_effect_rasterizer_variable_AsBlend,
9351 d3d10_effect_rasterizer_variable_AsDepthStencil,
9352 d3d10_effect_rasterizer_variable_AsRasterizer,
9353 d3d10_effect_rasterizer_variable_AsSampler,
9354 d3d10_effect_rasterizer_variable_SetRawValue,
9355 d3d10_effect_rasterizer_variable_GetRawValue,
9356 /* ID3D10EffectRasterizerVariable methods */
9357 d3d10_effect_rasterizer_variable_GetRasterizerState,
9358 d3d10_effect_rasterizer_variable_GetBackingStore,
9359 };
9360
9361 /* ID3D10EffectVariable methods */
9362
9363 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectSamplerVariable(
9364 ID3D10EffectSamplerVariable *iface)
9365 {
9366 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
9367 }
9368
9369 static BOOL STDMETHODCALLTYPE d3d10_effect_sampler_variable_IsValid(ID3D10EffectSamplerVariable *iface)
9370 {
9371 struct d3d10_effect_variable *v = impl_from_ID3D10EffectSamplerVariable(iface);
9372
9373 TRACE("iface %p\n", iface);
9374
9375 return v != &null_sampler_variable;
9376 }
9377
9378 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetType(
9379 ID3D10EffectSamplerVariable *iface)
9380 {
9381 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
9382 }
9383
9384 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetDesc(ID3D10EffectSamplerVariable *iface,
9385 D3D10_EFFECT_VARIABLE_DESC *desc)
9386 {
9387 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
9388 }
9389
9390 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetAnnotationByIndex(
9391 ID3D10EffectSamplerVariable *iface, UINT index)
9392 {
9393 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
9394 }
9395
9396 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetAnnotationByName(
9397 ID3D10EffectSamplerVariable *iface, const char *name)
9398 {
9399 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
9400 }
9401
9402 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberByIndex(
9403 ID3D10EffectSamplerVariable *iface, UINT index)
9404 {
9405 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
9406 }
9407
9408 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberByName(
9409 ID3D10EffectSamplerVariable *iface, const char *name)
9410 {
9411 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
9412 }
9413
9414 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberBySemantic(
9415 ID3D10EffectSamplerVariable *iface, const char *semantic)
9416 {
9417 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
9418 }
9419
9420 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetElement(
9421 ID3D10EffectSamplerVariable *iface, UINT index)
9422 {
9423 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
9424 }
9425
9426 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetParentConstantBuffer(
9427 ID3D10EffectSamplerVariable *iface)
9428 {
9429 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
9430 }
9431
9432 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsScalar(
9433 ID3D10EffectSamplerVariable *iface)
9434 {
9435 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
9436 }
9437
9438 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsVector(
9439 ID3D10EffectSamplerVariable *iface)
9440 {
9441 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
9442 }
9443
9444 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsMatrix(
9445 ID3D10EffectSamplerVariable *iface)
9446 {
9447 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
9448 }
9449
9450 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsString(
9451 ID3D10EffectSamplerVariable *iface)
9452 {
9453 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
9454 }
9455
9456 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsShaderResource(
9457 ID3D10EffectSamplerVariable *iface)
9458 {
9459 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
9460 }
9461
9462 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsRenderTargetView(
9463 ID3D10EffectSamplerVariable *iface)
9464 {
9465 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
9466 }
9467
9468 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsDepthStencilView(
9469 ID3D10EffectSamplerVariable *iface)
9470 {
9471 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
9472 }
9473
9474 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsConstantBuffer(
9475 ID3D10EffectSamplerVariable *iface)
9476 {
9477 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
9478 }
9479
9480 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsShader(
9481 ID3D10EffectSamplerVariable *iface)
9482 {
9483 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
9484 }
9485
9486 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsBlend(
9487 ID3D10EffectSamplerVariable *iface)
9488 {
9489 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
9490 }
9491
9492 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsDepthStencil(
9493 ID3D10EffectSamplerVariable *iface)
9494 {
9495 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
9496 }
9497
9498 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsRasterizer(
9499 ID3D10EffectSamplerVariable *iface)
9500 {
9501 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
9502 }
9503
9504 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsSampler(
9505 ID3D10EffectSamplerVariable *iface)
9506 {
9507 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
9508 }
9509
9510 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_SetRawValue(ID3D10EffectSamplerVariable *iface,
9511 void *data, UINT offset, UINT count)
9512 {
9513 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
9514 }
9515
9516 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetRawValue(ID3D10EffectSamplerVariable *iface,
9517 void *data, UINT offset, UINT count)
9518 {
9519 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
9520 }
9521
9522 /* ID3D10EffectSamplerVariable methods */
9523
9524 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetSampler(ID3D10EffectSamplerVariable *iface,
9525 UINT index, ID3D10SamplerState **sampler)
9526 {
9527 struct d3d10_effect_variable *v = impl_from_ID3D10EffectSamplerVariable(iface);
9528
9529 TRACE("iface %p, index %u, sampler %p.\n", iface, index, sampler);
9530
9531 if (!iface->lpVtbl->IsValid(iface))
9532 {
9533 WARN("Invalid variable.\n");
9534 return E_FAIL;
9535 }
9536
9537 if (!(v = d3d10_get_state_variable(v, index, &v->effect->samplers)))
9538 return E_FAIL;
9539
9540 if ((*sampler = v->u.state.object.sampler))
9541 ID3D10SamplerState_AddRef(*sampler);
9542
9543 return S_OK;
9544 }
9545
9546 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetBackingStore(ID3D10EffectSamplerVariable *iface,
9547 UINT index, D3D10_SAMPLER_DESC *desc)
9548 {
9549 struct d3d10_effect_variable *v = impl_from_ID3D10EffectSamplerVariable(iface);
9550
9551 TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
9552
9553 if (!iface->lpVtbl->IsValid(iface))
9554 {
9555 WARN("Invalid variable.\n");
9556 return E_FAIL;
9557 }
9558
9559 if (!(v = d3d10_get_state_variable(v, index, &v->effect->samplers)))
9560 return E_FAIL;
9561
9562 *desc = v->u.state.desc.sampler.desc;
9563
9564 return S_OK;
9565 }
9566
9567 static const struct ID3D10EffectSamplerVariableVtbl d3d10_effect_sampler_variable_vtbl =
9568 {
9569 /* ID3D10EffectVariable methods */
9570 d3d10_effect_sampler_variable_IsValid,
9571 d3d10_effect_sampler_variable_GetType,
9572 d3d10_effect_sampler_variable_GetDesc,
9573 d3d10_effect_sampler_variable_GetAnnotationByIndex,
9574 d3d10_effect_sampler_variable_GetAnnotationByName,
9575 d3d10_effect_sampler_variable_GetMemberByIndex,
9576 d3d10_effect_sampler_variable_GetMemberByName,
9577 d3d10_effect_sampler_variable_GetMemberBySemantic,
9578 d3d10_effect_sampler_variable_GetElement,
9579 d3d10_effect_sampler_variable_GetParentConstantBuffer,
9580 d3d10_effect_sampler_variable_AsScalar,
9581 d3d10_effect_sampler_variable_AsVector,
9582 d3d10_effect_sampler_variable_AsMatrix,
9583 d3d10_effect_sampler_variable_AsString,
9584 d3d10_effect_sampler_variable_AsShaderResource,
9585 d3d10_effect_sampler_variable_AsRenderTargetView,
9586 d3d10_effect_sampler_variable_AsDepthStencilView,
9587 d3d10_effect_sampler_variable_AsConstantBuffer,
9588 d3d10_effect_sampler_variable_AsShader,
9589 d3d10_effect_sampler_variable_AsBlend,
9590 d3d10_effect_sampler_variable_AsDepthStencil,
9591 d3d10_effect_sampler_variable_AsRasterizer,
9592 d3d10_effect_sampler_variable_AsSampler,
9593 d3d10_effect_sampler_variable_SetRawValue,
9594 d3d10_effect_sampler_variable_GetRawValue,
9595 /* ID3D10EffectSamplerVariable methods */
9596 d3d10_effect_sampler_variable_GetSampler,
9597 d3d10_effect_sampler_variable_GetBackingStore,
9598 };
9599
9600 /* ID3D10EffectType methods */
9601
9602 static inline struct d3d10_effect_type *impl_from_ID3D10EffectType(ID3D10EffectType *iface)
9603 {
9604 return CONTAINING_RECORD(iface, struct d3d10_effect_type, ID3D10EffectType_iface);
9605 }
9606
9607 static BOOL STDMETHODCALLTYPE d3d10_effect_type_IsValid(ID3D10EffectType *iface)
9608 {
9609 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
9610
9611 TRACE("iface %p\n", iface);
9612
9613 return This != &null_type;
9614 }
9615
9616 static HRESULT STDMETHODCALLTYPE d3d10_effect_type_GetDesc(ID3D10EffectType *iface, D3D10_EFFECT_TYPE_DESC *desc)
9617 {
9618 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
9619
9620 TRACE("iface %p, desc %p\n", iface, desc);
9621
9622 if (This == &null_type)
9623 {
9624 WARN("Null type specified\n");
9625 return E_FAIL;
9626 }
9627
9628 if (!desc)
9629 {
9630 WARN("Invalid argument specified\n");
9631 return E_INVALIDARG;
9632 }
9633
9634 desc->TypeName = This->name;
9635 desc->Class = This->type_class;
9636 desc->Type = This->basetype;
9637 desc->Elements = This->element_count;
9638 desc->Members = This->member_count;
9639 desc->Rows = This->row_count;
9640 desc->Columns = This->column_count;
9641 desc->PackedSize = This->size_packed;
9642 desc->UnpackedSize = This->size_unpacked;
9643 desc->Stride = This->stride;
9644
9645 return S_OK;
9646 }
9647
9648 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByIndex(ID3D10EffectType *iface,
9649 UINT index)
9650 {
9651 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
9652 struct d3d10_effect_type *t;
9653
9654 TRACE("iface %p, index %u\n", iface, index);
9655
9656 if (index >= This->member_count)
9657 {
9658 WARN("Invalid index specified\n");
9659 return &null_type.ID3D10EffectType_iface;
9660 }
9661
9662 t = (&This->members[index])->type;
9663
9664 TRACE("Returning member %p, %s\n", t, debugstr_a(t->name));
9665
9666 return &t->ID3D10EffectType_iface;
9667 }
9668
9669 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByName(ID3D10EffectType *iface,
9670 const char *name)
9671 {
9672 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
9673 unsigned int i;
9674
9675 TRACE("iface %p, name %s\n", iface, debugstr_a(name));
9676
9677 if (!name)
9678 {
9679 WARN("Invalid name specified\n");
9680 return &null_type.ID3D10EffectType_iface;
9681 }
9682
9683 for (i = 0; i < This->member_count; ++i)
9684 {
9685 struct d3d10_effect_type_member *typem = &This->members[i];
9686
9687 if (typem->name && !strcmp(typem->name, name))
9688 {
9689 TRACE("Returning type %p.\n", typem->type);
9690 return &typem->type->ID3D10EffectType_iface;
9691 }
9692 }
9693
9694 WARN("Invalid name specified\n");
9695
9696 return &null_type.ID3D10EffectType_iface;
9697 }
9698
9699 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeBySemantic(ID3D10EffectType *iface,
9700 const char *semantic)
9701 {
9702 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
9703 unsigned int i;
9704
9705 TRACE("iface %p, semantic %s\n", iface, debugstr_a(semantic));
9706
9707 if (!semantic)
9708 {
9709 WARN("Invalid semantic specified\n");
9710 return &null_type.ID3D10EffectType_iface;
9711 }
9712
9713 for (i = 0; i < This->member_count; ++i)
9714 {
9715 struct d3d10_effect_type_member *typem = &This->members[i];
9716
9717 if (typem->semantic && !stricmp(typem->semantic, semantic))
9718 {
9719 TRACE("Returning type %p.\n", typem->type);
9720 return &typem->type->ID3D10EffectType_iface;
9721 }
9722 }
9723
9724 WARN("Invalid semantic specified\n");
9725
9726 return &null_type.ID3D10EffectType_iface;
9727 }
9728
9729 static const char * STDMETHODCALLTYPE d3d10_effect_type_GetMemberName(ID3D10EffectType *iface, UINT index)
9730 {
9731 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
9732 struct d3d10_effect_type_member *typem;
9733
9734 TRACE("iface %p, index %u\n", iface, index);
9735
9736 if (index >= This->member_count)
9737 {
9738 WARN("Invalid index specified\n");
9739 return NULL;
9740 }
9741
9742 typem = &This->members[index];
9743
9744 TRACE("Returning name %s\n", debugstr_a(typem->name));
9745
9746 return typem->name;
9747 }
9748
9749 static const char * STDMETHODCALLTYPE d3d10_effect_type_GetMemberSemantic(ID3D10EffectType *iface, UINT index)
9750 {
9751 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
9752 struct d3d10_effect_type_member *typem;
9753
9754 TRACE("iface %p, index %u\n", iface, index);
9755
9756 if (index >= This->member_count)
9757 {
9758 WARN("Invalid index specified\n");
9759 return NULL;
9760 }
9761
9762 typem = &This->members[index];
9763
9764 TRACE("Returning semantic %s\n", debugstr_a(typem->semantic));
9765
9766 return typem->semantic;
9767 }
9768
9769 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl =
9770 {
9771 /* ID3D10EffectType */
9772 d3d10_effect_type_IsValid,
9773 d3d10_effect_type_GetDesc,
9774 d3d10_effect_type_GetMemberTypeByIndex,
9775 d3d10_effect_type_GetMemberTypeByName,
9776 d3d10_effect_type_GetMemberTypeBySemantic,
9777 d3d10_effect_type_GetMemberName,
9778 d3d10_effect_type_GetMemberSemantic,
9779 };
9780
9781 static HRESULT STDMETHODCALLTYPE d3d10_effect_pool_QueryInterface(ID3D10EffectPool *iface,
9782 REFIID riid, void **object)
9783 {
9784 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
9785
9786 if (IsEqualGUID(riid, &IID_ID3D10EffectPool) ||
9787 IsEqualGUID(riid, &IID_IUnknown))
9788 {
9789 IUnknown_AddRef(iface);
9790 *object = iface;
9791 return S_OK;
9792 }
9793
9794 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
9795
9796 *object = NULL;
9797 return E_NOINTERFACE;
9798 }
9799
9800 static ULONG STDMETHODCALLTYPE d3d10_effect_pool_AddRef(ID3D10EffectPool *iface)
9801 {
9802 struct d3d10_effect *effect = impl_from_ID3D10EffectPool(iface);
9803 return d3d10_effect_AddRef(&effect->ID3D10Effect_iface);
9804 }
9805
9806 static ULONG STDMETHODCALLTYPE d3d10_effect_pool_Release(ID3D10EffectPool *iface)
9807 {
9808 struct d3d10_effect *effect = impl_from_ID3D10EffectPool(iface);
9809 return d3d10_effect_Release(&effect->ID3D10Effect_iface);
9810 }
9811
9812 static ID3D10Effect * STDMETHODCALLTYPE d3d10_effect_pool_AsEffect(ID3D10EffectPool *iface)
9813 {
9814 struct d3d10_effect *effect = impl_from_ID3D10EffectPool(iface);
9815
9816 TRACE("%p.\n", iface);
9817
9818 return &effect->ID3D10Effect_iface;
9819 }
9820
9821 const struct ID3D10EffectPoolVtbl d3d10_effect_pool_vtbl =
9822 {
9823 /* IUnknown methods */
9824 d3d10_effect_pool_QueryInterface,
9825 d3d10_effect_pool_AddRef,
9826 d3d10_effect_pool_Release,
9827 /* ID3D10EffectPool methods */
9828 d3d10_effect_pool_AsEffect,
9829 };
9830
9831
9832 static int d3d10_effect_type_compare(const void *key, const struct wine_rb_entry *entry)
9833 {
9834 const struct d3d10_effect_type *t = WINE_RB_ENTRY_VALUE(entry, const struct d3d10_effect_type, entry);
9835 const DWORD *id = key;
9836
9837 return *id - t->id;
9838 }
9839
9840 static HRESULT d3d10_create_effect(void *data, SIZE_T data_size, ID3D10Device *device,
9841 struct d3d10_effect *pool, unsigned int flags, struct d3d10_effect **effect)
9842 {
9843 struct d3d10_effect *object;
9844 HRESULT hr;
9845
9846 if (!device)
9847 return D3DERR_INVALIDCALL;
9848
9849 if (!(object = calloc(1, sizeof(*object))))
9850 return E_OUTOFMEMORY;
9851
9852 wine_rb_init(&object->types, d3d10_effect_type_compare);
9853 object->ID3D10Effect_iface.lpVtbl = flags & D3D10_EFFECT_IS_POOL ?
9854 &d3d10_effect_pool_effect_vtbl : &d3d10_effect_vtbl;
9855 object->ID3D10EffectPool_iface.lpVtbl = &d3d10_effect_pool_vtbl;
9856 object->refcount = 1;
9857 ID3D10Device_AddRef(device);
9858 object->device = device;
9859 object->pool = pool;
9860 object->flags = flags;
9861 if (pool) IUnknown_AddRef(&pool->ID3D10Effect_iface);
9862
9863 hr = d3d10_effect_parse(object, data, data_size);
9864 if (FAILED(hr))
9865 {
9866 ERR("Failed to parse effect\n");
9867 IUnknown_Release(&object->ID3D10Effect_iface);
9868 return hr;
9869 }
9870
9871 *effect = object;
9872
9873 return S_OK;
9874 }
9875
9876 HRESULT WINAPI D3D10CreateEffectFromMemory(void *data, SIZE_T data_size, UINT flags,
9877 ID3D10Device *device, ID3D10EffectPool *effect_pool, ID3D10Effect **effect)
9878 {
9879 struct d3d10_effect *object, *pool = NULL;
9880 HRESULT hr;
9881
9882 TRACE("data %p, data_size %Iu, flags %#x, device %p, effect_pool %p, effect %p.\n",
9883 data, data_size, flags, device, effect_pool, effect);
9884
9885 if (!(flags & D3D10_EFFECT_COMPILE_CHILD_EFFECT) != !effect_pool)
9886 return E_INVALIDARG;
9887
9888 if (effect_pool && !(pool = unsafe_impl_from_ID3D10EffectPool(effect_pool)))
9889 {
9890 WARN("External pool implementations are not supported.\n");
9891 return E_INVALIDARG;
9892 }
9893
9894 if (FAILED(hr = d3d10_create_effect(data, data_size, device, pool, 0, &object)))
9895 {
9896 WARN("Failed to create an effect, hr %#lx.\n", hr);
9897 return hr;
9898 }
9899
9900 *effect = &object->ID3D10Effect_iface;
9901
9902 TRACE("Created effect %p\n", object);
9903
9904 return hr;
9905 }
9906
9907 static HRESULT STDMETHODCALLTYPE d3d10_effect_pool_effect_QueryInterface(ID3D10Effect *iface,
9908 REFIID riid, void **object)
9909 {
9910 struct d3d10_effect *effect = impl_from_ID3D10Effect(iface);
9911
9912 TRACE("iface %p, riid %s, obj %p.\n", iface, debugstr_guid(riid), object);
9913
9914 return IUnknown_QueryInterface(&effect->ID3D10EffectPool_iface, riid, object);
9915 }
9916
9917 static const struct ID3D10EffectVtbl d3d10_effect_pool_effect_vtbl =
9918 {
9919 /* IUnknown methods */
9920 d3d10_effect_pool_effect_QueryInterface,
9921 d3d10_effect_AddRef,
9922 d3d10_effect_Release,
9923 /* ID3D10Effect methods */
9924 d3d10_effect_IsValid,
9925 d3d10_effect_IsPool,
9926 d3d10_effect_GetDevice,
9927 d3d10_effect_GetDesc,
9928 d3d10_effect_GetConstantBufferByIndex,
9929 d3d10_effect_GetConstantBufferByName,
9930 d3d10_effect_GetVariableByIndex,
9931 d3d10_effect_GetVariableByName,
9932 d3d10_effect_GetVariableBySemantic,
9933 d3d10_effect_GetTechniqueByIndex,
9934 d3d10_effect_GetTechniqueByName,
9935 d3d10_effect_Optimize,
9936 d3d10_effect_IsOptimized,
9937 };
9938
9939 HRESULT WINAPI D3D10CreateEffectPoolFromMemory(void *data, SIZE_T data_size, UINT fx_flags,
9940 ID3D10Device *device, ID3D10EffectPool **effect_pool)
9941 {
9942 struct d3d10_effect *object;
9943 HRESULT hr;
9944
9945 TRACE("data %p, data_size %Iu, fx_flags %#x, device %p, effect_pool %p.\n",
9946 data, data_size, fx_flags, device, effect_pool);
9947
9948 if (!data)
9949 return E_INVALIDARG;
9950
9951 if (FAILED(hr = d3d10_create_effect(data, data_size, device, NULL,
9952 D3D10_EFFECT_IS_POOL, &object)))
9953 {
9954 WARN("Failed to create an effect, hr %#lx.\n", hr);
9955 return hr;
9956 }
9957
9958 *effect_pool = &object->ID3D10EffectPool_iface;
9959
9960 TRACE("Created effect pool %p.\n", object);
9961
9962 return hr;
9963 }
Windows API implementation