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