?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d10: Validate the data size in parse_fx10() (AFL).
[wine.git] / dlls / d3d10 / effect.c
blob2eb0680e55d4569b1abb677027fe6cd8483d1bff
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 "config.h"
22 #include "wine/port.h"
23
24 #include "d3d10_private.h"
25
26 #include <float.h>
27
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d10);
29
30 #define D3D10_FX10_TYPE_COLUMN_SHIFT 11
31 #define D3D10_FX10_TYPE_COLUMN_MASK (0x7 << D3D10_FX10_TYPE_COLUMN_SHIFT)
32
33 #define D3D10_FX10_TYPE_ROW_SHIFT 8
34 #define D3D10_FX10_TYPE_ROW_MASK (0x7 << D3D10_FX10_TYPE_ROW_SHIFT)
35
36 #define D3D10_FX10_TYPE_BASETYPE_SHIFT 3
37 #define D3D10_FX10_TYPE_BASETYPE_MASK (0x1f << D3D10_FX10_TYPE_BASETYPE_SHIFT)
38
39 #define D3D10_FX10_TYPE_CLASS_SHIFT 0
40 #define D3D10_FX10_TYPE_CLASS_MASK (0x7 << D3D10_FX10_TYPE_CLASS_SHIFT)
41
42 #define D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK 0x4000
43
44 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl;
45 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl;
46 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl;
47 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl;
48 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl;
49 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl;
50 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl;
51 static const struct ID3D10EffectStringVariableVtbl d3d10_effect_string_variable_vtbl;
52 static const struct ID3D10EffectShaderResourceVariableVtbl d3d10_effect_shader_resource_variable_vtbl;
53 static const struct ID3D10EffectRenderTargetViewVariableVtbl d3d10_effect_render_target_view_variable_vtbl;
54 static const struct ID3D10EffectDepthStencilViewVariableVtbl d3d10_effect_depth_stencil_view_variable_vtbl;
55 static const struct ID3D10EffectShaderVariableVtbl d3d10_effect_shader_variable_vtbl;
56 static const struct ID3D10EffectBlendVariableVtbl d3d10_effect_blend_variable_vtbl;
57 static const struct ID3D10EffectDepthStencilVariableVtbl d3d10_effect_depth_stencil_variable_vtbl;
58 static const struct ID3D10EffectRasterizerVariableVtbl d3d10_effect_rasterizer_variable_vtbl;
59 static const struct ID3D10EffectSamplerVariableVtbl d3d10_effect_sampler_variable_vtbl;
60 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl;
61
62 /* null objects - needed for invalid calls */
63 static struct d3d10_effect_technique null_technique = {{&d3d10_effect_technique_vtbl}};
64 static struct d3d10_effect_pass null_pass = {{&d3d10_effect_pass_vtbl}};
65 static struct d3d10_effect_type null_type = {{&d3d10_effect_type_vtbl}};
66 static struct d3d10_effect_variable null_local_buffer = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl},
67 &null_local_buffer, &null_type};
68 static struct d3d10_effect_variable null_variable = {{&d3d10_effect_variable_vtbl},
69 &null_local_buffer, &null_type};
70 static struct d3d10_effect_variable null_scalar_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl},
71 &null_local_buffer, &null_type};
72 static struct d3d10_effect_variable null_vector_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl},
73 &null_local_buffer, &null_type};
74 static struct d3d10_effect_variable null_matrix_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl},
75 &null_local_buffer, &null_type};
76 static struct d3d10_effect_variable null_string_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl},
77 &null_local_buffer, &null_type};
78 static struct d3d10_effect_variable null_shader_resource_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl},
79 &null_local_buffer, &null_type};
80 static struct d3d10_effect_variable null_render_target_view_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl},
81 &null_local_buffer, &null_type};
82 static struct d3d10_effect_variable null_depth_stencil_view_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl},
83 &null_local_buffer, &null_type};
84 static struct d3d10_effect_variable null_shader_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
85 &null_local_buffer, &null_type};
86 static struct d3d10_effect_variable null_blend_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl},
87 &null_local_buffer, &null_type};
88 static struct d3d10_effect_variable null_depth_stencil_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl},
89 &null_local_buffer, &null_type};
90 static struct d3d10_effect_variable null_rasterizer_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl},
91 &null_local_buffer, &null_type};
92 static struct d3d10_effect_variable null_sampler_variable = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl},
93 &null_local_buffer, &null_type};
94
95 /* anonymous_shader_type and anonymous_shader */
96 static char anonymous_name[] = "$Anonymous";
97 static char anonymous_vertexshader_name[] = "vertexshader";
98 static char anonymous_pixelshader_name[] = "pixelshader";
99 static char anonymous_geometryshader_name[] = "geometryshader";
100 static struct d3d10_effect_type anonymous_vs_type = {{&d3d10_effect_type_vtbl},
101 anonymous_vertexshader_name, D3D10_SVT_VERTEXSHADER, D3D10_SVC_OBJECT};
102 static struct d3d10_effect_type anonymous_ps_type = {{&d3d10_effect_type_vtbl},
103 anonymous_pixelshader_name, D3D10_SVT_PIXELSHADER, D3D10_SVC_OBJECT};
104 static struct d3d10_effect_type anonymous_gs_type = {{&d3d10_effect_type_vtbl},
105 anonymous_geometryshader_name, D3D10_SVT_GEOMETRYSHADER, D3D10_SVC_OBJECT};
106 static struct d3d10_effect_variable anonymous_vs = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
107 &null_local_buffer, &anonymous_vs_type, anonymous_name};
108 static struct d3d10_effect_variable anonymous_ps = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
109 &null_local_buffer, &anonymous_ps_type, anonymous_name};
110 static struct d3d10_effect_variable anonymous_gs = {{(const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl},
111 &null_local_buffer, &anonymous_gs_type, anonymous_name};
112
113 static struct d3d10_effect_type *get_fx10_type(struct d3d10_effect *effect,
114 const char *data, size_t data_size, DWORD offset);
115
116 static inline struct d3d10_effect_variable *impl_from_ID3D10EffectVariable(ID3D10EffectVariable *iface)
117 {
118 return CONTAINING_RECORD(iface, struct d3d10_effect_variable, ID3D10EffectVariable_iface);
119 }
120
121 struct d3d10_effect_state_property_info
122 {
123 UINT id;
124 const char *name;
125 D3D_SHADER_VARIABLE_TYPE type;
126 UINT size;
127 UINT count;
128 D3D_SHADER_VARIABLE_TYPE container_type;
129 LONG offset;
130 };
131
132 static const struct d3d10_effect_state_property_info property_info[] =
133 {
134 {0x0c, "RasterizerState.FillMode", D3D10_SVT_INT, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, FillMode) },
135 {0x0d, "RasterizerState.CullMode", D3D10_SVT_INT, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, CullMode) },
136 {0x0e, "RasterizerState.FrontCounterClockwise", D3D10_SVT_BOOL, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, FrontCounterClockwise) },
137 {0x0f, "RasterizerState.DepthBias", D3D10_SVT_INT, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, DepthBias) },
138 {0x10, "RasterizerState.DepthBiasClamp", D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, DepthBiasClamp) },
139 {0x11, "RasterizerState.SlopeScaledDepthBias", D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, SlopeScaledDepthBias) },
140 {0x12, "RasterizerState.DepthClipEnable", D3D10_SVT_BOOL, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, DepthClipEnable) },
141 {0x13, "RasterizerState.ScissorEnable", D3D10_SVT_BOOL, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, ScissorEnable) },
142 {0x14, "RasterizerState.MultisampleEnable", D3D10_SVT_BOOL, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, MultisampleEnable) },
143 {0x15, "RasterizerState.AntialiasedLineEnable", D3D10_SVT_BOOL, 1, 1, D3D10_SVT_RASTERIZER, FIELD_OFFSET(D3D10_RASTERIZER_DESC, AntialiasedLineEnable) },
144 {0x16, "DepthStencilState.DepthEnable", D3D10_SVT_BOOL, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, DepthEnable) },
145 {0x17, "DepthStencilState.DepthWriteMask", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, DepthWriteMask) },
146 {0x18, "DepthStencilState.DepthFunc", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, DepthFunc) },
147 {0x19, "DepthStencilState.StencilEnable", D3D10_SVT_BOOL, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, StencilEnable) },
148 {0x1a, "DepthStencilState.StencilReadMask", D3D10_SVT_UINT8, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, StencilReadMask) },
149 {0x1b, "DepthStencilState.StencilWriteMask", D3D10_SVT_UINT8, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, StencilWriteMask) },
150 {0x1c, "DepthStencilState.FrontFaceStencilFail", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilFailOp) },
151 {0x1d, "DepthStencilState.FrontFaceStencilDepthFail", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilDepthFailOp)},
152 {0x1e, "DepthStencilState.FrontFaceStencilPass", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilPassOp) },
153 {0x1f, "DepthStencilState.FrontFaceStencilFunc", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, FrontFace.StencilFunc) },
154 {0x20, "DepthStencilState.BackFaceStencilFail", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilFailOp) },
155 {0x21, "DepthStencilState.BackFaceStencilDepthFail", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilDepthFailOp) },
156 {0x22, "DepthStencilState.BackFaceStencilPass", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilPassOp) },
157 {0x23, "DepthStencilState.BackFaceStencilFunc", D3D10_SVT_INT, 1, 1, D3D10_SVT_DEPTHSTENCIL, FIELD_OFFSET(D3D10_DEPTH_STENCIL_DESC, BackFace.StencilFunc) },
158 {0x24, "BlendState.AlphaToCoverageEnable", D3D10_SVT_BOOL, 1, 1, D3D10_SVT_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, AlphaToCoverageEnable) },
159 {0x25, "BlendState.BlendEnable", D3D10_SVT_BOOL, 1, 8, D3D10_SVT_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, BlendEnable) },
160 {0x26, "BlendState.SrcBlend", D3D10_SVT_INT, 1, 1, D3D10_SVT_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, SrcBlend) },
161 {0x27, "BlendState.DestBlend", D3D10_SVT_INT, 1, 1, D3D10_SVT_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, DestBlend) },
162 {0x28, "BlendState.BlendOp", D3D10_SVT_INT, 1, 1, D3D10_SVT_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, BlendOp) },
163 {0x29, "BlendState.SrcBlendAlpha", D3D10_SVT_INT, 1, 1, D3D10_SVT_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, SrcBlendAlpha) },
164 {0x2a, "BlendState.DestBlendAlpha", D3D10_SVT_INT, 1, 1, D3D10_SVT_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, DestBlendAlpha) },
165 {0x2b, "BlendState.BlendOpAlpha", D3D10_SVT_INT, 1, 1, D3D10_SVT_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, BlendOpAlpha) },
166 {0x2c, "BlendState.RenderTargetWriteMask", D3D10_SVT_UINT8, 1, 8, D3D10_SVT_BLEND, FIELD_OFFSET(D3D10_BLEND_DESC, RenderTargetWriteMask) },
167 {0x2d, "SamplerState.Filter", D3D10_SVT_INT, 1, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, Filter) },
168 {0x2e, "SamplerState.AddressU", D3D10_SVT_INT, 1, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, AddressU) },
169 {0x2f, "SamplerState.AddressV", D3D10_SVT_INT, 1, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, AddressV) },
170 {0x30, "SamplerState.AddressW", D3D10_SVT_INT, 1, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, AddressW) },
171 {0x31, "SamplerState.MipMapLODBias", D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, MipLODBias) },
172 {0x32, "SamplerState.MaxAnisotropy", D3D10_SVT_UINT, 1, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, MaxAnisotropy) },
173 {0x33, "SamplerState.ComparisonFunc", D3D10_SVT_INT, 1, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, ComparisonFunc) },
174 {0x34, "SamplerState.BorderColor", D3D10_SVT_FLOAT, 4, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, BorderColor) },
175 {0x35, "SamplerState.MinLOD", D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, MinLOD) },
176 {0x36, "SamplerState.MaxLOD", D3D10_SVT_FLOAT, 1, 1, D3D10_SVT_SAMPLER, FIELD_OFFSET(D3D10_SAMPLER_DESC, MaxLOD) },
177 };
178
179 static const D3D10_RASTERIZER_DESC default_rasterizer_desc =
180 {
181 D3D10_FILL_SOLID,
182 D3D10_CULL_BACK,
183 FALSE,
184 0,
185 0.0f,
186 0.0f,
187 TRUE,
188 FALSE,
189 FALSE,
190 FALSE,
191 };
192
193 static const D3D10_DEPTH_STENCIL_DESC default_depth_stencil_desc =
194 {
195 TRUE,
196 D3D10_DEPTH_WRITE_MASK_ALL,
197 D3D10_COMPARISON_LESS,
198 FALSE,
199 D3D10_DEFAULT_STENCIL_READ_MASK,
200 D3D10_DEFAULT_STENCIL_WRITE_MASK,
201 {D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_COMPARISON_ALWAYS},
202 {D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_STENCIL_OP_KEEP, D3D10_COMPARISON_ALWAYS},
203 };
204
205 static const D3D10_BLEND_DESC default_blend_desc =
206 {
207 FALSE,
208 {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE},
209 D3D10_BLEND_SRC_ALPHA,
210 D3D10_BLEND_INV_SRC_ALPHA,
211 D3D10_BLEND_OP_ADD,
212 D3D10_BLEND_SRC_ALPHA,
213 D3D10_BLEND_INV_SRC_ALPHA,
214 D3D10_BLEND_OP_ADD,
215 {0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf},
216 };
217
218 static const D3D10_SAMPLER_DESC default_sampler_desc =
219 {
220 D3D10_FILTER_MIN_MAG_MIP_POINT,
221 D3D10_TEXTURE_ADDRESS_WRAP,
222 D3D10_TEXTURE_ADDRESS_WRAP,
223 D3D10_TEXTURE_ADDRESS_WRAP,
224 0.0f,
225 16,
226 D3D10_COMPARISON_NEVER,
227 {0.0f, 0.0f, 0.0f, 0.0f},
228 0.0f,
229 FLT_MAX,
230 };
231
232 struct d3d10_effect_state_storage_info
233 {
234 D3D_SHADER_VARIABLE_TYPE id;
235 SIZE_T size;
236 const void *default_state;
237 };
238
239 static const struct d3d10_effect_state_storage_info d3d10_effect_state_storage_info[] =
240 {
241 {D3D10_SVT_RASTERIZER, sizeof(default_rasterizer_desc), &default_rasterizer_desc },
242 {D3D10_SVT_DEPTHSTENCIL, sizeof(default_depth_stencil_desc), &default_depth_stencil_desc},
243 {D3D10_SVT_BLEND, sizeof(default_blend_desc), &default_blend_desc },
244 {D3D10_SVT_SAMPLER, sizeof(default_sampler_desc), &default_sampler_desc },
245 };
246
247 static BOOL fx10_get_string(const char *data, size_t data_size, DWORD offset, const char **s, size_t *l)
248 {
249 size_t len, max_len;
250
251 if (offset >= data_size)
252 {
253 WARN("Invalid offset %#x (data size %#lx).\n", offset, (long)data_size);
254 return FALSE;
255 }
256
257 max_len = data_size - offset;
258 if (!(len = strnlen(data + offset, max_len)))
259 {
260 *s = NULL;
261 *l = 0;
262 return TRUE;
263 }
264
265 if (len == max_len)
266 return FALSE;
267
268 *s = data + offset;
269 *l = ++len;
270
271 return TRUE;
272 }
273
274 static BOOL fx10_copy_string(const char *data, size_t data_size, DWORD offset, char **s)
275 {
276 const char *p;
277 size_t len;
278
279 if (!fx10_get_string(data, data_size, offset, &p, &len))
280 return FALSE;
281
282 if (!p)
283 {
284 *s = NULL;
285 return TRUE;
286 }
287
288 if (!(*s = HeapAlloc(GetProcessHeap(), 0, len)))
289 {
290 ERR("Failed to allocate string memory.\n");
291 return FALSE;
292 }
293
294 memcpy(*s, p, len);
295
296 return TRUE;
297 }
298
299 static BOOL copy_name(const char *ptr, char **name)
300 {
301 size_t name_len;
302
303 if (!ptr) return TRUE;
304
305 name_len = strlen(ptr) + 1;
306 if (name_len == 1)
307 {
308 return TRUE;
309 }
310
311 *name = HeapAlloc(GetProcessHeap(), 0, name_len);
312 if (!*name)
313 {
314 ERR("Failed to allocate name memory.\n");
315 return FALSE;
316 }
317
318 memcpy(*name, ptr, name_len);
319
320 return TRUE;
321 }
322
323 static const char *shader_get_string(const char *data, size_t data_size, DWORD offset)
324 {
325 const char *s;
326 size_t l;
327
328 if (!fx10_get_string(data, data_size, offset, &s, &l))
329 return NULL;
330
331 return l ? s : "";
332 }
333
334 static HRESULT shader_parse_signature(const char *data, DWORD data_size, struct d3d10_effect_shader_signature *s)
335 {
336 D3D10_SIGNATURE_PARAMETER_DESC *e;
337 const char *ptr = data;
338 unsigned int i;
339 DWORD count;
340
341 if (!require_space(0, 2, sizeof(DWORD), data_size))
342 {
343 WARN("Invalid data size %#x.\n", data_size);
344 return E_INVALIDARG;
345 }
346
347 read_dword(&ptr, &count);
348 TRACE("%u elements\n", count);
349
350 skip_dword_unknown("shader signature", &ptr, 1);
351
352 if (!require_space(ptr - data, count, 6 * sizeof(DWORD), data_size))
353 {
354 WARN("Invalid count %#x (data size %#x).\n", count, data_size);
355 return E_INVALIDARG;
356 }
357
358 if (!(e = d3d10_calloc(count, sizeof(*e))))
359 {
360 ERR("Failed to allocate signature memory.\n");
361 return E_OUTOFMEMORY;
362 }
363
364 for (i = 0; i < count; ++i)
365 {
366 UINT name_offset;
367 UINT mask;
368
369 read_dword(&ptr, &name_offset);
370 if (!(e[i].SemanticName = shader_get_string(data, data_size, name_offset)))
371 {
372 WARN("Invalid name offset %#x (data size %#x).\n", name_offset, data_size);
373 HeapFree(GetProcessHeap(), 0, e);
374 return E_INVALIDARG;
375 }
376 read_dword(&ptr, &e[i].SemanticIndex);
377 read_dword(&ptr, &e[i].SystemValueType);
378 read_dword(&ptr, &e[i].ComponentType);
379 read_dword(&ptr, &e[i].Register);
380 read_dword(&ptr, &mask);
381
382 e[i].ReadWriteMask = mask >> 8;
383 e[i].Mask = mask & 0xff;
384
385 TRACE("semantic: %s, semantic idx: %u, sysval_semantic %#x, "
386 "type %u, register idx: %u, use_mask %#x, input_mask %#x\n",
387 debugstr_a(e[i].SemanticName), e[i].SemanticIndex, e[i].SystemValueType,
388 e[i].ComponentType, e[i].Register, e[i].Mask, e[i].ReadWriteMask);
389 }
390
391 s->elements = e;
392 s->element_count = count;
393
394 return S_OK;
395 }
396
397 static void shader_free_signature(struct d3d10_effect_shader_signature *s)
398 {
399 HeapFree(GetProcessHeap(), 0, s->signature);
400 HeapFree(GetProcessHeap(), 0, s->elements);
401 }
402
403 static HRESULT shader_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
404 {
405 struct d3d10_effect_shader_variable *s = ctx;
406 HRESULT hr;
407
408 TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
409
410 TRACE("chunk size: %#x\n", data_size);
411
412 switch(tag)
413 {
414 case TAG_ISGN:
415 case TAG_OSGN:
416 {
417 /* 32 (DXBC header) + 1 * 4 (chunk index) + 2 * 4 (chunk header) + data_size (chunk data) */
418 UINT size = 44 + data_size;
419 struct d3d10_effect_shader_signature *sig;
420 char *ptr;
421
422 if (tag == TAG_ISGN) sig = &s->input_signature;
423 else sig = &s->output_signature;
424
425 sig->signature = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
426 if (!sig->signature)
427 {
428 ERR("Failed to allocate input signature data\n");
429 return E_OUTOFMEMORY;
430 }
431 sig->signature_size = size;
432
433 ptr = sig->signature;
434
435 write_dword(&ptr, TAG_DXBC);
436
437 /* signature(?) */
438 write_dword_unknown(&ptr, 0);
439 write_dword_unknown(&ptr, 0);
440 write_dword_unknown(&ptr, 0);
441 write_dword_unknown(&ptr, 0);
442
443 /* seems to be always 1 */
444 write_dword_unknown(&ptr, 1);
445
446 /* DXBC size */
447 write_dword(&ptr, size);
448
449 /* chunk count */
450 write_dword(&ptr, 1);
451
452 /* chunk index */
453 write_dword(&ptr, (ptr - sig->signature) + 4);
454
455 /* chunk */
456 write_dword(&ptr, tag);
457 write_dword(&ptr, data_size);
458 memcpy(ptr, data, data_size);
459
460 hr = shader_parse_signature(ptr, data_size, sig);
461 if (FAILED(hr))
462 {
463 ERR("Failed to parse shader, hr %#x\n", hr);
464 shader_free_signature(sig);
465 }
466
467 break;
468 }
469
470 default:
471 FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
472 break;
473 }
474
475 return S_OK;
476 }
477
478 static HRESULT parse_shader(ID3D10EffectVariable *variable, const char *data)
479 {
480 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable(variable);
481 ID3D10Device *device = v->effect->device;
482 const char *ptr = data;
483 DWORD dxbc_size;
484 HRESULT hr;
485
486 if (v->effect->used_shader_current >= v->effect->used_shader_count)
487 {
488 WARN("Invalid shader? Used shader current(%u) >= used shader count(%u)\n", v->effect->used_shader_current, v->effect->used_shader_count);
489 return E_FAIL;
490 }
491
492 v->effect->used_shaders[v->effect->used_shader_current] = v;
493 ++v->effect->used_shader_current;
494
495 if (!ptr) return S_OK;
496
497 read_dword(&ptr, &dxbc_size);
498 TRACE("dxbc size: %#x\n", dxbc_size);
499
500 /* We got a shader VertexShader vs = NULL, so it is fine to skip this. */
501 if (!dxbc_size) return S_OK;
502
503 switch (v->type->basetype)
504 {
505 case D3D10_SVT_VERTEXSHADER:
506 hr = ID3D10Device_CreateVertexShader(device, ptr, dxbc_size, &v->u.shader.shader.vs);
507 if (FAILED(hr)) return hr;
508 break;
509
510 case D3D10_SVT_PIXELSHADER:
511 hr = ID3D10Device_CreatePixelShader(device, ptr, dxbc_size, &v->u.shader.shader.ps);
512 if (FAILED(hr)) return hr;
513 break;
514
515 case D3D10_SVT_GEOMETRYSHADER:
516 hr = ID3D10Device_CreateGeometryShader(device, ptr, dxbc_size, &v->u.shader.shader.gs);
517 if (FAILED(hr)) return hr;
518 break;
519
520 default:
521 ERR("This should not happen!\n");
522 return E_FAIL;
523 }
524
525 return parse_dxbc(ptr, dxbc_size, shader_chunk_handler, &v->u.shader);
526 }
527
528 static D3D10_SHADER_VARIABLE_CLASS d3d10_variable_class(DWORD c, BOOL is_column_major)
529 {
530 switch (c)
531 {
532 case 1: return D3D10_SVC_SCALAR;
533 case 2: return D3D10_SVC_VECTOR;
534 case 3: if (is_column_major) return D3D10_SVC_MATRIX_COLUMNS;
535 else return D3D10_SVC_MATRIX_ROWS;
536 default:
537 FIXME("Unknown variable class %#x.\n", c);
538 return 0;
539 }
540 }
541
542 static D3D10_SHADER_VARIABLE_TYPE d3d10_variable_type(DWORD t, BOOL is_object)
543 {
544 if(is_object)
545 {
546 switch (t)
547 {
548 case 1: return D3D10_SVT_STRING;
549 case 2: return D3D10_SVT_BLEND;
550 case 3: return D3D10_SVT_DEPTHSTENCIL;
551 case 4: return D3D10_SVT_RASTERIZER;
552 case 5: return D3D10_SVT_PIXELSHADER;
553 case 6: return D3D10_SVT_VERTEXSHADER;
554 case 7: return D3D10_SVT_GEOMETRYSHADER;
555
556 case 10: return D3D10_SVT_TEXTURE1D;
557 case 11: return D3D10_SVT_TEXTURE1DARRAY;
558 case 12: return D3D10_SVT_TEXTURE2D;
559 case 13: return D3D10_SVT_TEXTURE2DARRAY;
560 case 14: return D3D10_SVT_TEXTURE2DMS;
561 case 15: return D3D10_SVT_TEXTURE2DMSARRAY;
562 case 16: return D3D10_SVT_TEXTURE3D;
563 case 17: return D3D10_SVT_TEXTURECUBE;
564
565 case 19: return D3D10_SVT_RENDERTARGETVIEW;
566 case 20: return D3D10_SVT_DEPTHSTENCILVIEW;
567 case 21: return D3D10_SVT_SAMPLER;
568 case 22: return D3D10_SVT_BUFFER;
569 default:
570 FIXME("Unknown variable type %#x.\n", t);
571 return D3D10_SVT_VOID;
572 }
573 }
574 else
575 {
576 switch (t)
577 {
578 case 1: return D3D10_SVT_FLOAT;
579 case 2: return D3D10_SVT_INT;
580 case 3: return D3D10_SVT_UINT;
581 case 4: return D3D10_SVT_BOOL;
582 default:
583 FIXME("Unknown variable type %#x.\n", t);
584 return D3D10_SVT_VOID;
585 }
586 }
587 }
588
589 static HRESULT parse_fx10_type(const char *data, size_t data_size, DWORD offset, struct d3d10_effect_type *t)
590 {
591 const char *ptr = data + offset;
592 DWORD unknown0;
593 DWORD typeinfo;
594 unsigned int i;
595
596 read_dword(&ptr, &offset);
597 TRACE("Type name at offset %#x.\n", offset);
598
599 if (!fx10_copy_string(data, data_size, offset, &t->name))
600 {
601 ERR("Failed to copy name.\n");
602 return E_OUTOFMEMORY;
603 }
604 TRACE("Type name: %s.\n", debugstr_a(t->name));
605
606 read_dword(&ptr, &unknown0);
607 TRACE("Unknown 0: %u.\n", unknown0);
608
609 read_dword(&ptr, &t->element_count);
610 TRACE("Element count: %u.\n", t->element_count);
611
612 read_dword(&ptr, &t->size_unpacked);
613 TRACE("Unpacked size: %#x.\n", t->size_unpacked);
614
615 read_dword(&ptr, &t->stride);
616 TRACE("Stride: %#x.\n", t->stride);
617
618 read_dword(&ptr, &t->size_packed);
619 TRACE("Packed size %#x.\n", t->size_packed);
620
621 switch (unknown0)
622 {
623 case 1:
624 t->member_count = 0;
625
626 read_dword(&ptr, &typeinfo);
627 t->column_count = (typeinfo & D3D10_FX10_TYPE_COLUMN_MASK) >> D3D10_FX10_TYPE_COLUMN_SHIFT;
628 t->row_count = (typeinfo & D3D10_FX10_TYPE_ROW_MASK) >> D3D10_FX10_TYPE_ROW_SHIFT;
629 t->basetype = d3d10_variable_type((typeinfo & D3D10_FX10_TYPE_BASETYPE_MASK) >> D3D10_FX10_TYPE_BASETYPE_SHIFT, FALSE);
630 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);
631
632 TRACE("Type description: %#x.\n", typeinfo);
633 TRACE("\tcolumns: %u.\n", t->column_count);
634 TRACE("\trows: %u.\n", t->row_count);
635 TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t->basetype));
636 TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t->type_class));
637 TRACE("\tunknown bits: %#x.\n", typeinfo & ~(D3D10_FX10_TYPE_COLUMN_MASK | D3D10_FX10_TYPE_ROW_MASK
638 | D3D10_FX10_TYPE_BASETYPE_MASK | D3D10_FX10_TYPE_CLASS_MASK | D3D10_FX10_TYPE_MATRIX_COLUMN_MAJOR_MASK));
639 break;
640
641 case 2:
642 TRACE("Type is an object.\n");
643
644 t->member_count = 0;
645 t->column_count = 0;
646 t->row_count = 0;
647 t->type_class = D3D10_SVC_OBJECT;
648
649 read_dword(&ptr, &typeinfo);
650 t->basetype = d3d10_variable_type(typeinfo, TRUE);
651
652 TRACE("Type description: %#x.\n", typeinfo);
653 TRACE("\tbasetype: %s.\n", debug_d3d10_shader_variable_type(t->basetype));
654 TRACE("\tclass: %s.\n", debug_d3d10_shader_variable_class(t->type_class));
655 break;
656
657 case 3:
658 TRACE("Type is a structure.\n");
659
660 read_dword(&ptr, &t->member_count);
661 TRACE("Member count: %u.\n", t->member_count);
662
663 t->column_count = 0;
664 t->row_count = 0;
665 t->basetype = 0;
666 t->type_class = D3D10_SVC_STRUCT;
667
668 if (!(t->members = d3d10_calloc(t->member_count, sizeof(*t->members))))
669 {
670 ERR("Failed to allocate members memory.\n");
671 return E_OUTOFMEMORY;
672 }
673
674 for (i = 0; i < t->member_count; ++i)
675 {
676 struct d3d10_effect_type_member *typem = &t->members[i];
677
678 read_dword(&ptr, &offset);
679 TRACE("Member name at offset %#x.\n", offset);
680
681 if (!fx10_copy_string(data, data_size, offset, &typem->name))
682 {
683 ERR("Failed to copy name.\n");
684 return E_OUTOFMEMORY;
685 }
686 TRACE("Member name: %s.\n", debugstr_a(typem->name));
687
688 read_dword(&ptr, &offset);
689 TRACE("Member semantic at offset %#x.\n", offset);
690
691 if (!fx10_copy_string(data, data_size, offset, &typem->semantic))
692 {
693 ERR("Failed to copy semantic.\n");
694 return E_OUTOFMEMORY;
695 }
696 TRACE("Member semantic: %s.\n", debugstr_a(typem->semantic));
697
698 read_dword(&ptr, &typem->buffer_offset);
699 TRACE("Member offset in struct: %#x.\n", typem->buffer_offset);
700
701 read_dword(&ptr, &offset);
702 TRACE("Member type info at offset %#x.\n", offset);
703
704 if (!(typem->type = get_fx10_type(t->effect, data, data_size, offset)))
705 {
706 ERR("Failed to get variable type.\n");
707 return E_FAIL;
708 }
709 }
710 break;
711
712 default:
713 FIXME("Unhandled case %#x.\n", unknown0);
714 return E_FAIL;
715 }
716
717 if (t->element_count)
718 {
719 TRACE("Elementtype for type at offset: %#x\n", t->id);
720
721 /* allocate elementtype - we need only one, because all elements have the same type */
722 t->elementtype = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*t->elementtype));
723 if (!t->elementtype)
724 {
725 ERR("Failed to allocate members memory.\n");
726 return E_OUTOFMEMORY;
727 }
728
729 /* create a copy of the original type with some minor changes */
730 t->elementtype->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
731 t->elementtype->effect = t->effect;
732
733 if (!copy_name(t->name, &t->elementtype->name))
734 {
735 ERR("Failed to copy name.\n");
736 return E_OUTOFMEMORY;
737 }
738 TRACE("\tType name: %s.\n", debugstr_a(t->elementtype->name));
739
740 t->elementtype->element_count = 0;
741 TRACE("\tElement count: %u.\n", t->elementtype->element_count);
742
743 /*
744 * Not sure if this calculation is 100% correct, but a test
745 * shows that these values work.
746 */
747 t->elementtype->size_unpacked = t->size_packed / t->element_count;
748 TRACE("\tUnpacked size: %#x.\n", t->elementtype->size_unpacked);
749
750 t->elementtype->stride = t->stride;
751 TRACE("\tStride: %#x.\n", t->elementtype->stride);
752
753 t->elementtype->size_packed = t->size_packed / t->element_count;
754 TRACE("\tPacked size: %#x.\n", t->elementtype->size_packed);
755
756 t->elementtype->member_count = t->member_count;
757 TRACE("\tMember count: %u.\n", t->elementtype->member_count);
758
759 t->elementtype->column_count = t->column_count;
760 TRACE("\tColumns: %u.\n", t->elementtype->column_count);
761
762 t->elementtype->row_count = t->row_count;
763 TRACE("\tRows: %u.\n", t->elementtype->row_count);
764
765 t->elementtype->basetype = t->basetype;
766 TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(t->elementtype->basetype));
767
768 t->elementtype->type_class = t->type_class;
769 TRACE("\tClass: %s.\n", debug_d3d10_shader_variable_class(t->elementtype->type_class));
770
771 t->elementtype->members = t->members;
772 }
773
774 return S_OK;
775 }
776
777 static struct d3d10_effect_type *get_fx10_type(struct d3d10_effect *effect,
778 const char *data, size_t data_size, DWORD offset)
779 {
780 struct d3d10_effect_type *type;
781 struct wine_rb_entry *entry;
782 HRESULT hr;
783
784 entry = wine_rb_get(&effect->types, &offset);
785 if (entry)
786 {
787 TRACE("Returning existing type.\n");
788 return WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
789 }
790
791 type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*type));
792 if (!type)
793 {
794 ERR("Failed to allocate type memory.\n");
795 return NULL;
796 }
797
798 type->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
799 type->id = offset;
800 type->effect = effect;
801 if (FAILED(hr = parse_fx10_type(data, data_size, offset, type)))
802 {
803 ERR("Failed to parse type info, hr %#x.\n", hr);
804 HeapFree(GetProcessHeap(), 0, type);
805 return NULL;
806 }
807
808 if (wine_rb_put(&effect->types, &offset, &type->entry) == -1)
809 {
810 ERR("Failed to insert type entry.\n");
811 HeapFree(GetProcessHeap(), 0, type);
812 return NULL;
813 }
814
815 return type;
816 }
817
818 static void set_variable_vtbl(struct d3d10_effect_variable *v)
819 {
820 const ID3D10EffectVariableVtbl **vtbl = &v->ID3D10EffectVariable_iface.lpVtbl;
821
822 switch (v->type->type_class)
823 {
824 case D3D10_SVC_SCALAR:
825 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl;
826 break;
827
828 case D3D10_SVC_VECTOR:
829 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl;
830 break;
831
832 case D3D10_SVC_MATRIX_ROWS:
833 case D3D10_SVC_MATRIX_COLUMNS:
834 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl;
835 break;
836
837 case D3D10_SVC_STRUCT:
838 *vtbl = &d3d10_effect_variable_vtbl;
839 break;
840
841 case D3D10_SVC_OBJECT:
842 switch(v->type->basetype)
843 {
844 case D3D10_SVT_STRING:
845 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl;
846 break;
847
848 case D3D10_SVT_TEXTURE1D:
849 case D3D10_SVT_TEXTURE1DARRAY:
850 case D3D10_SVT_TEXTURE2D:
851 case D3D10_SVT_TEXTURE2DARRAY:
852 case D3D10_SVT_TEXTURE2DMS:
853 case D3D10_SVT_TEXTURE2DMSARRAY:
854 case D3D10_SVT_TEXTURE3D:
855 case D3D10_SVT_TEXTURECUBE:
856 case D3D10_SVT_BUFFER: /* Either resource or constant buffer. */
857 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl;
858 break;
859
860 case D3D10_SVT_RENDERTARGETVIEW:
861 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl;
862 break;
863
864 case D3D10_SVT_DEPTHSTENCILVIEW:
865 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl;
866 break;
867
868 case D3D10_SVT_DEPTHSTENCIL:
869 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl;
870 break;
871
872 case D3D10_SVT_VERTEXSHADER:
873 case D3D10_SVT_GEOMETRYSHADER:
874 case D3D10_SVT_PIXELSHADER:
875 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl;
876 break;
877
878 case D3D10_SVT_BLEND:
879 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl;
880 break;
881
882 case D3D10_SVT_RASTERIZER:
883 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl;
884 break;
885
886 case D3D10_SVT_SAMPLER:
887 *vtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl;
888 break;
889
890 default:
891 FIXME("Unhandled basetype %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
892 *vtbl = &d3d10_effect_variable_vtbl;
893 break;
894 }
895 break;
896
897 default:
898 FIXME("Unhandled type class %s.\n", debug_d3d10_shader_variable_class(v->type->type_class));
899 *vtbl = &d3d10_effect_variable_vtbl;
900 break;
901 }
902 }
903
904 static HRESULT copy_variableinfo_from_type(struct d3d10_effect_variable *v)
905 {
906 unsigned int i;
907 HRESULT hr;
908
909 if (v->type->member_count)
910 {
911 if (!(v->members = d3d10_calloc(v->type->member_count, sizeof(*v->members))))
912 {
913 ERR("Failed to allocate members memory.\n");
914 return E_OUTOFMEMORY;
915 }
916
917 for (i = 0; i < v->type->member_count; ++i)
918 {
919 struct d3d10_effect_variable *var = &v->members[i];
920 struct d3d10_effect_type_member *typem = &v->type->members[i];
921
922 var->buffer = v->buffer;
923 var->effect = v->effect;
924 var->type = typem->type;
925 set_variable_vtbl(var);
926
927 if (!copy_name(typem->name, &var->name))
928 {
929 ERR("Failed to copy name.\n");
930 return E_OUTOFMEMORY;
931 }
932 TRACE("Variable name: %s.\n", debugstr_a(var->name));
933
934 if (!copy_name(typem->semantic, &var->semantic))
935 {
936 ERR("Failed to copy name.\n");
937 return E_OUTOFMEMORY;
938 }
939 TRACE("Variable semantic: %s.\n", debugstr_a(var->semantic));
940
941 var->buffer_offset = v->buffer_offset + typem->buffer_offset;
942 TRACE("Variable buffer offset: %u.\n", var->buffer_offset);
943
944 hr = copy_variableinfo_from_type(var);
945 if (FAILED(hr)) return hr;
946 }
947 }
948
949 if (v->type->element_count)
950 {
951 unsigned int bufferoffset = v->buffer_offset;
952
953 if (!(v->elements = d3d10_calloc(v->type->element_count, sizeof(*v->elements))))
954 {
955 ERR("Failed to allocate elements memory.\n");
956 return E_OUTOFMEMORY;
957 }
958
959 for (i = 0; i < v->type->element_count; ++i)
960 {
961 struct d3d10_effect_variable *var = &v->elements[i];
962
963 var->buffer = v->buffer;
964 var->effect = v->effect;
965 var->type = v->type->elementtype;
966 set_variable_vtbl(var);
967
968 if (!copy_name(v->name, &var->name))
969 {
970 ERR("Failed to copy name.\n");
971 return E_OUTOFMEMORY;
972 }
973 TRACE("Variable name: %s.\n", debugstr_a(var->name));
974
975 if (!copy_name(v->semantic, &var->semantic))
976 {
977 ERR("Failed to copy name.\n");
978 return E_OUTOFMEMORY;
979 }
980 TRACE("Variable semantic: %s.\n", debugstr_a(var->semantic));
981
982 if (i != 0)
983 {
984 bufferoffset += v->type->stride;
985 }
986 var->buffer_offset = bufferoffset;
987 TRACE("Variable buffer offset: %u.\n", var->buffer_offset);
988
989 hr = copy_variableinfo_from_type(var);
990 if (FAILED(hr)) return hr;
991 }
992 }
993
994 return S_OK;
995 }
996
997 static HRESULT parse_fx10_variable_head(const char *data, size_t data_size,
998 const char **ptr, struct d3d10_effect_variable *v)
999 {
1000 DWORD offset;
1001
1002 read_dword(ptr, &offset);
1003 TRACE("Variable name at offset %#x.\n", offset);
1004
1005 if (!fx10_copy_string(data, data_size, offset, &v->name))
1006 {
1007 ERR("Failed to copy name.\n");
1008 return E_OUTOFMEMORY;
1009 }
1010 TRACE("Variable name: %s.\n", debugstr_a(v->name));
1011
1012 read_dword(ptr, &offset);
1013 TRACE("Variable type info at offset %#x.\n", offset);
1014
1015 if (!(v->type = get_fx10_type(v->effect, data, data_size, offset)))
1016 {
1017 ERR("Failed to get variable type.\n");
1018 return E_FAIL;
1019 }
1020 set_variable_vtbl(v);
1021
1022 return copy_variableinfo_from_type(v);
1023 }
1024
1025 static HRESULT parse_fx10_annotation(const char *data, size_t data_size,
1026 const char **ptr, struct d3d10_effect_variable *a)
1027 {
1028 HRESULT hr;
1029
1030 if (FAILED(hr = parse_fx10_variable_head(data, data_size, ptr, a)))
1031 return hr;
1032
1033 skip_dword_unknown("annotation", ptr, 1);
1034
1035 /* mark the variable as annotation */
1036 a->flag = D3D10_EFFECT_VARIABLE_ANNOTATION;
1037
1038 return S_OK;
1039 }
1040
1041 static HRESULT parse_fx10_anonymous_shader(struct d3d10_effect *e, struct d3d10_effect_anonymous_shader *s,
1042 enum d3d10_effect_object_type otype)
1043 {
1044 struct d3d10_effect_variable *v = &s->shader;
1045 struct d3d10_effect_type *t = &s->type;
1046 const char *shader = NULL;
1047
1048 switch (otype)
1049 {
1050 case D3D10_EOT_VERTEXSHADER:
1051 shader = "vertexshader";
1052 t->basetype = D3D10_SVT_VERTEXSHADER;
1053 break;
1054
1055 case D3D10_EOT_PIXELSHADER:
1056 shader = "pixelshader";
1057 t->basetype = D3D10_SVT_PIXELSHADER;
1058 break;
1059
1060 case D3D10_EOT_GEOMETRYSHADER:
1061 shader = "geometryshader";
1062 t->basetype = D3D10_SVT_GEOMETRYSHADER;
1063 break;
1064
1065 default:
1066 FIXME("Unhandled object type %#x.\n", otype);
1067 return E_FAIL;
1068 }
1069
1070 if (!copy_name(shader, &t->name))
1071 {
1072 ERR("Failed to copy name.\n");
1073 return E_OUTOFMEMORY;
1074 }
1075 TRACE("Type name: %s.\n", debugstr_a(t->name));
1076
1077 t->type_class = D3D10_SVC_OBJECT;
1078
1079 t->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
1080
1081 v->type = t;
1082 v->effect = e;
1083 set_variable_vtbl(v);
1084
1085 if (!copy_name("$Anonymous", &v->name))
1086 {
1087 ERR("Failed to copy semantic.\n");
1088 return E_OUTOFMEMORY;
1089 }
1090 TRACE("Variable name: %s.\n", debugstr_a(v->name));
1091
1092 if (!copy_name(NULL, &v->semantic))
1093 {
1094 ERR("Failed to copy semantic.\n");
1095 return E_OUTOFMEMORY;
1096 }
1097 TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
1098
1099 return S_OK;
1100 }
1101
1102 static const struct d3d10_effect_state_property_info *get_property_info(UINT id)
1103 {
1104 unsigned int i;
1105
1106 for (i = 0; i < sizeof(property_info) / sizeof(*property_info); ++i)
1107 {
1108 if (property_info[i].id == id)
1109 return &property_info[i];
1110 }
1111
1112 return NULL;
1113 }
1114
1115 static const struct d3d10_effect_state_storage_info *get_storage_info(D3D_SHADER_VARIABLE_TYPE id)
1116 {
1117 unsigned int i;
1118
1119 for (i = 0; i < sizeof(d3d10_effect_state_storage_info) / sizeof(*d3d10_effect_state_storage_info); ++i)
1120 {
1121 if (d3d10_effect_state_storage_info[i].id == id)
1122 return &d3d10_effect_state_storage_info[i];
1123 }
1124
1125 return NULL;
1126 }
1127
1128 static BOOL read_float_value(DWORD value, D3D_SHADER_VARIABLE_TYPE in_type, float *out_data, UINT idx)
1129 {
1130 switch (in_type)
1131 {
1132 case D3D10_SVT_FLOAT:
1133 out_data[idx] = *(float *)&value;
1134 return TRUE;
1135
1136 case D3D10_SVT_INT:
1137 out_data[idx] = (INT)value;
1138 return TRUE;
1139
1140 default:
1141 FIXME("Unhandled in_type %#x.\n", in_type);
1142 return FALSE;
1143 }
1144 }
1145
1146 static BOOL read_int32_value(DWORD value, D3D_SHADER_VARIABLE_TYPE in_type, INT *out_data, UINT idx)
1147 {
1148 switch (in_type)
1149 {
1150 case D3D10_SVT_FLOAT:
1151 out_data[idx] = *(float *)&value;
1152 return TRUE;
1153
1154 case D3D10_SVT_INT:
1155 case D3D10_SVT_UINT:
1156 case D3D10_SVT_BOOL:
1157 out_data[idx] = value;
1158 return TRUE;
1159
1160 default:
1161 FIXME("Unhandled in_type %#x.\n", in_type);
1162 return FALSE;
1163 }
1164 }
1165
1166 static BOOL read_int8_value(DWORD value, D3D_SHADER_VARIABLE_TYPE in_type, INT8 *out_data, UINT idx)
1167 {
1168 switch (in_type)
1169 {
1170 case D3D10_SVT_INT:
1171 case D3D10_SVT_UINT:
1172 out_data[idx] = value;
1173 return TRUE;
1174
1175 default:
1176 FIXME("Unhandled in_type %#x.\n", in_type);
1177 return FALSE;
1178 }
1179 }
1180
1181 static BOOL read_value_list(const char *data, size_t data_size, DWORD offset,
1182 D3D_SHADER_VARIABLE_TYPE out_type, UINT out_base, UINT out_size, void *out_data)
1183 {
1184 D3D_SHADER_VARIABLE_TYPE in_type;
1185 const char *ptr;
1186 DWORD t, value;
1187 DWORD count, i;
1188
1189 if (offset >= data_size || !require_space(offset, 1, sizeof(count), data_size))
1190 {
1191 WARN("Invalid offset %#x (data size %#lx).\n", offset, (long)data_size);
1192 return FALSE;
1193 }
1194
1195 ptr = data + offset;
1196 read_dword(&ptr, &count);
1197 if (count != out_size)
1198 return FALSE;
1199
1200 if (!require_space(ptr - data, count, 2 * sizeof(DWORD), data_size))
1201 {
1202 WARN("Invalid value count %#x (offset %#x, data size %#lx).\n", count, offset, (long)data_size);
1203 return FALSE;
1204 }
1205
1206 TRACE("%u values:\n", count);
1207 for (i = 0; i < count; ++i)
1208 {
1209 UINT out_idx = out_base * out_size + i;
1210
1211 read_dword(&ptr, &t);
1212 read_dword(&ptr, &value);
1213
1214 in_type = d3d10_variable_type(t, FALSE);
1215 TRACE("\t%s: %#x.\n", debug_d3d10_shader_variable_type(in_type), value);
1216
1217 switch (out_type)
1218 {
1219 case D3D10_SVT_FLOAT:
1220 if (!read_float_value(value, in_type, out_data, out_idx))
1221 return FALSE;
1222 break;
1223
1224 case D3D10_SVT_INT:
1225 case D3D10_SVT_UINT:
1226 case D3D10_SVT_BOOL:
1227 if (!read_int32_value(value, in_type, out_data, out_idx))
1228 return FALSE;
1229 break;
1230
1231 case D3D10_SVT_UINT8:
1232 if (!read_int8_value(value, in_type, out_data, out_idx))
1233 return FALSE;
1234 break;
1235
1236 default:
1237 FIXME("Unhandled out_type %#x.\n", out_type);
1238 return FALSE;
1239 }
1240 }
1241
1242 return TRUE;
1243 }
1244
1245 static BOOL parse_fx10_state_group(const char *data, size_t data_size,
1246 const char **ptr, D3D_SHADER_VARIABLE_TYPE container_type, void *container)
1247 {
1248 const struct d3d10_effect_state_property_info *property_info;
1249 UINT value_offset;
1250 unsigned int i;
1251 DWORD count;
1252 UINT idx;
1253 UINT id;
1254
1255 read_dword(ptr, &count);
1256 TRACE("Property count: %#x.\n", count);
1257
1258 for (i = 0; i < count; ++i)
1259 {
1260 read_dword(ptr, &id);
1261 read_dword(ptr, &idx);
1262 skip_dword_unknown("read property", ptr, 1);
1263 read_dword(ptr, &value_offset);
1264
1265 if (!(property_info = get_property_info(id)))
1266 {
1267 FIXME("Failed to find property info for property %#x.\n", id);
1268 return FALSE;
1269 }
1270
1271 TRACE("Property %s[%#x] = value list @ offset %#x.\n",
1272 property_info->name, idx, value_offset);
1273
1274 if (property_info->container_type != container_type)
1275 {
1276 ERR("Invalid container type %#x for property %#x.\n", container_type, id);
1277 return FALSE;
1278 }
1279
1280 if (idx >= property_info->count)
1281 {
1282 ERR("Invalid index %#x for property %#x.\n", idx, id);
1283 return FALSE;
1284 }
1285
1286 if (!read_value_list(data, data_size, value_offset, property_info->type, idx,
1287 property_info->size, (char *)container + property_info->offset))
1288 {
1289 ERR("Failed to read values for property %#x.\n", id);
1290 return FALSE;
1291 }
1292 }
1293
1294 return TRUE;
1295 }
1296
1297 static HRESULT parse_fx10_object(const char *data, size_t data_size,
1298 const char **ptr, struct d3d10_effect_object *o)
1299 {
1300 ID3D10EffectVariable *variable = &null_variable.ID3D10EffectVariable_iface;
1301 const char *data_ptr = NULL;
1302 DWORD offset;
1303 enum d3d10_effect_object_operation operation;
1304 HRESULT hr;
1305 struct d3d10_effect *effect = o->pass->technique->effect;
1306 ID3D10Effect *e = &effect->ID3D10Effect_iface;
1307 DWORD tmp, variable_idx = 0;
1308 const char *name;
1309 size_t name_len;
1310
1311 if (!require_space(*ptr - data, 4, sizeof(DWORD), data_size))
1312 {
1313 WARN("Invalid offset %#lx (data size %#lx).\n", (long)(*ptr - data), (long)data_size);
1314 return E_FAIL;
1315 }
1316
1317 read_dword(ptr, &o->type);
1318 TRACE("Effect object is of type %#x.\n", o->type);
1319
1320 read_dword(ptr, &tmp);
1321 TRACE("Effect object index %#x.\n", tmp);
1322
1323 read_dword(ptr, &operation);
1324 TRACE("Effect object operation %#x.\n", operation);
1325
1326 read_dword(ptr, &offset);
1327 TRACE("Effect object idx is at offset %#x.\n", offset);
1328
1329 switch(operation)
1330 {
1331 case D3D10_EOO_VALUE:
1332 TRACE("Copy variable values\n");
1333
1334 switch (o->type)
1335 {
1336 case D3D10_EOT_VERTEXSHADER:
1337 TRACE("Vertex shader\n");
1338 variable = &anonymous_vs.ID3D10EffectVariable_iface;
1339 break;
1340
1341 case D3D10_EOT_PIXELSHADER:
1342 TRACE("Pixel shader\n");
1343 variable = &anonymous_ps.ID3D10EffectVariable_iface;
1344 break;
1345
1346 case D3D10_EOT_GEOMETRYSHADER:
1347 TRACE("Geometry shader\n");
1348 variable = &anonymous_gs.ID3D10EffectVariable_iface;
1349 break;
1350
1351 case D3D10_EOT_STENCIL_REF:
1352 if (!read_value_list(data, data_size, offset, D3D10_SVT_UINT, 0, 1, &o->pass->stencil_ref))
1353 {
1354 ERR("Failed to read stencil ref.\n");
1355 return E_FAIL;
1356 }
1357 break;
1358
1359 case D3D10_EOT_SAMPLE_MASK:
1360 if (!read_value_list(data, data_size, offset, D3D10_SVT_UINT, 0, 1, &o->pass->sample_mask))
1361 {
1362 FIXME("Failed to read sample mask.\n");
1363 return E_FAIL;
1364 }
1365 break;
1366
1367 case D3D10_EOT_BLEND_FACTOR:
1368 if (!read_value_list(data, data_size, offset, D3D10_SVT_FLOAT, 0, 4, &o->pass->blend_factor[0]))
1369 {
1370 FIXME("Failed to read blend factor.\n");
1371 return E_FAIL;
1372 }
1373 break;
1374
1375 default:
1376 FIXME("Unhandled object type %#x\n", o->type);
1377 return E_FAIL;
1378 }
1379 break;
1380
1381 case D3D10_EOO_PARSED_OBJECT:
1382 /* This is a local object, we've parsed in parse_fx10_local_object. */
1383 if (!fx10_get_string(data, data_size, offset, &name, &name_len))
1384 {
1385 WARN("Failed to get variable name.\n");
1386 return E_FAIL;
1387 }
1388 TRACE("Variable name %s.\n", debugstr_a(name));
1389
1390 variable = e->lpVtbl->GetVariableByName(e, name);
1391 break;
1392
1393 case D3D10_EOO_PARSED_OBJECT_INDEX:
1394 /* This is a local object, we've parsed in parse_fx10_local_object, which has an array index. */
1395 if (offset >= data_size || !require_space(offset, 2, sizeof(DWORD), data_size))
1396 {
1397 WARN("Invalid offset %#x (data size %#lx).\n", offset, (long)data_size);
1398 return E_FAIL;
1399 }
1400 data_ptr = data + offset;
1401 read_dword(&data_ptr, &offset);
1402 read_dword(&data_ptr, &variable_idx);
1403
1404 if (!fx10_get_string(data, data_size, offset, &name, &name_len))
1405 {
1406 WARN("Failed to get variable name.\n");
1407 return E_FAIL;
1408 }
1409
1410 TRACE("Variable name %s[%u].\n", debugstr_a(name), variable_idx);
1411
1412 variable = e->lpVtbl->GetVariableByName(e, name);
1413 break;
1414
1415 case D3D10_EOO_ANONYMOUS_SHADER:
1416 TRACE("Anonymous shader\n");
1417
1418 /* check anonymous_shader_current for validity */
1419 if (effect->anonymous_shader_current >= effect->anonymous_shader_count)
1420 {
1421 ERR("Anonymous shader count is wrong!\n");
1422 return E_FAIL;
1423 }
1424
1425 if (offset >= data_size || !require_space(offset, 1, sizeof(DWORD), data_size))
1426 {
1427 WARN("Invalid offset %#x (data size %#lx).\n", offset, (long)data_size);
1428 return E_FAIL;
1429 }
1430 data_ptr = data + offset;
1431 read_dword(&data_ptr, &offset);
1432 TRACE("Effect object starts at offset %#x.\n", offset);
1433
1434 data_ptr = data + offset;
1435
1436 hr = parse_fx10_anonymous_shader(effect, &effect->anonymous_shaders[effect->anonymous_shader_current], o->type);
1437 if (FAILED(hr)) return hr;
1438
1439 variable = &effect->anonymous_shaders[effect->anonymous_shader_current].shader.ID3D10EffectVariable_iface;
1440 ++effect->anonymous_shader_current;
1441
1442 switch (o->type)
1443 {
1444 case D3D10_EOT_VERTEXSHADER:
1445 case D3D10_EOT_PIXELSHADER:
1446 case D3D10_EOT_GEOMETRYSHADER:
1447 if (FAILED(hr = parse_shader(variable, data_ptr)))
1448 return hr;
1449 break;
1450
1451 default:
1452 FIXME("Unhandled object type %#x\n", o->type);
1453 return E_FAIL;
1454 }
1455 break;
1456
1457 default:
1458 FIXME("Unhandled operation %#x.\n", operation);
1459 return E_FAIL;
1460 }
1461
1462 switch (o->type)
1463 {
1464 case D3D10_EOT_RASTERIZER_STATE:
1465 {
1466 ID3D10EffectRasterizerVariable *rv = variable->lpVtbl->AsRasterizer(variable);
1467 if (FAILED(hr = rv->lpVtbl->GetRasterizerState(rv, variable_idx, &o->object.rs)))
1468 return hr;
1469 break;
1470 }
1471
1472 case D3D10_EOT_DEPTH_STENCIL_STATE:
1473 {
1474 ID3D10EffectDepthStencilVariable *dv = variable->lpVtbl->AsDepthStencil(variable);
1475 if (FAILED(hr = dv->lpVtbl->GetDepthStencilState(dv, variable_idx, &o->object.ds)))
1476 return hr;
1477 break;
1478 }
1479
1480 case D3D10_EOT_BLEND_STATE:
1481 {
1482 ID3D10EffectBlendVariable *bv = variable->lpVtbl->AsBlend(variable);
1483 if (FAILED(hr = bv->lpVtbl->GetBlendState(bv, variable_idx, &o->object.bs)))
1484 return hr;
1485 break;
1486 }
1487
1488 case D3D10_EOT_VERTEXSHADER:
1489 {
1490 ID3D10EffectShaderVariable *sv = variable->lpVtbl->AsShader(variable);
1491 if (FAILED(hr = sv->lpVtbl->GetVertexShader(sv, variable_idx, &o->object.vs)))
1492 return hr;
1493 o->pass->vs.pShaderVariable = sv;
1494 o->pass->vs.ShaderIndex = variable_idx;
1495 break;
1496 }
1497
1498 case D3D10_EOT_PIXELSHADER:
1499 {
1500 ID3D10EffectShaderVariable *sv = variable->lpVtbl->AsShader(variable);
1501 if (FAILED(hr = sv->lpVtbl->GetPixelShader(sv, variable_idx, &o->object.ps)))
1502 return hr;
1503 o->pass->ps.pShaderVariable = sv;
1504 o->pass->ps.ShaderIndex = variable_idx;
1505 break;
1506 }
1507
1508 case D3D10_EOT_GEOMETRYSHADER:
1509 {
1510 ID3D10EffectShaderVariable *sv = variable->lpVtbl->AsShader(variable);
1511 if (FAILED(hr = sv->lpVtbl->GetGeometryShader(sv, variable_idx, &o->object.gs)))
1512 return hr;
1513 o->pass->gs.pShaderVariable = sv;
1514 o->pass->gs.ShaderIndex = variable_idx;
1515 break;
1516 }
1517
1518 case D3D10_EOT_STENCIL_REF:
1519 case D3D10_EOT_BLEND_FACTOR:
1520 case D3D10_EOT_SAMPLE_MASK:
1521 break;
1522
1523 default:
1524 FIXME("Unhandled object type %#x.\n", o->type);
1525 return E_FAIL;
1526 }
1527
1528 return S_OK;
1529 }
1530
1531 static HRESULT parse_fx10_pass(const char *data, size_t data_size,
1532 const char **ptr, struct d3d10_effect_pass *p)
1533 {
1534 HRESULT hr = S_OK;
1535 unsigned int i;
1536 DWORD offset;
1537
1538 read_dword(ptr, &offset);
1539 TRACE("Pass name at offset %#x.\n", offset);
1540
1541 if (!fx10_copy_string(data, data_size, offset, &p->name))
1542 {
1543 ERR("Failed to copy name.\n");
1544 return E_OUTOFMEMORY;
1545 }
1546 TRACE("Pass name: %s.\n", debugstr_a(p->name));
1547
1548 read_dword(ptr, &p->object_count);
1549 TRACE("Pass has %u effect objects.\n", p->object_count);
1550
1551 read_dword(ptr, &p->annotation_count);
1552 TRACE("Pass has %u annotations.\n", p->annotation_count);
1553
1554 if (!(p->annotations = d3d10_calloc(p->annotation_count, sizeof(*p->annotations))))
1555 {
1556 ERR("Failed to allocate pass annotations memory.\n");
1557 return E_OUTOFMEMORY;
1558 }
1559
1560 for (i = 0; i < p->annotation_count; ++i)
1561 {
1562 struct d3d10_effect_variable *a = &p->annotations[i];
1563
1564 a->effect = p->technique->effect;
1565 a->buffer = &null_local_buffer;
1566
1567 if (FAILED(hr = parse_fx10_annotation(data, data_size, ptr, a)))
1568 return hr;
1569 }
1570
1571 if (!(p->objects = d3d10_calloc(p->object_count, sizeof(*p->objects))))
1572 {
1573 ERR("Failed to allocate effect objects memory.\n");
1574 return E_OUTOFMEMORY;
1575 }
1576
1577 p->vs.pShaderVariable = (ID3D10EffectShaderVariable *)&null_shader_variable.ID3D10EffectVariable_iface;
1578 p->ps.pShaderVariable = (ID3D10EffectShaderVariable *)&null_shader_variable.ID3D10EffectVariable_iface;
1579 p->gs.pShaderVariable = (ID3D10EffectShaderVariable *)&null_shader_variable.ID3D10EffectVariable_iface;
1580
1581 for (i = 0; i < p->object_count; ++i)
1582 {
1583 struct d3d10_effect_object *o = &p->objects[i];
1584
1585 o->pass = p;
1586
1587 if (FAILED(hr = parse_fx10_object(data, data_size, ptr, o)))
1588 return hr;
1589 }
1590
1591 return hr;
1592 }
1593
1594 static HRESULT parse_fx10_technique(const char *data, size_t data_size,
1595 const char **ptr, struct d3d10_effect_technique *t)
1596 {
1597 unsigned int i;
1598 DWORD offset;
1599 HRESULT hr;
1600
1601 read_dword(ptr, &offset);
1602 TRACE("Technique name at offset %#x.\n", offset);
1603
1604 if (!fx10_copy_string(data, data_size, offset, &t->name))
1605 {
1606 ERR("Failed to copy name.\n");
1607 return E_OUTOFMEMORY;
1608 }
1609 TRACE("Technique name: %s.\n", debugstr_a(t->name));
1610
1611 read_dword(ptr, &t->pass_count);
1612 TRACE("Technique has %u passes\n", t->pass_count);
1613
1614 read_dword(ptr, &t->annotation_count);
1615 TRACE("Technique has %u annotations.\n", t->annotation_count);
1616
1617 if (!(t->annotations = d3d10_calloc(t->annotation_count, sizeof(*t->annotations))))
1618 {
1619 ERR("Failed to allocate technique annotations memory.\n");
1620 return E_OUTOFMEMORY;
1621 }
1622
1623 for (i = 0; i < t->annotation_count; ++i)
1624 {
1625 struct d3d10_effect_variable *a = &t->annotations[i];
1626
1627 a->effect = t->effect;
1628 a->buffer = &null_local_buffer;
1629
1630 if (FAILED(hr = parse_fx10_annotation(data, data_size, ptr, a)))
1631 return hr;
1632 }
1633
1634 if (!(t->passes = d3d10_calloc(t->pass_count, sizeof(*t->passes))))
1635 {
1636 ERR("Failed to allocate passes memory\n");
1637 return E_OUTOFMEMORY;
1638 }
1639
1640 for (i = 0; i < t->pass_count; ++i)
1641 {
1642 struct d3d10_effect_pass *p = &t->passes[i];
1643
1644 p->ID3D10EffectPass_iface.lpVtbl = &d3d10_effect_pass_vtbl;
1645 p->technique = t;
1646
1647 if (FAILED(hr = parse_fx10_pass(data, data_size, ptr, p)))
1648 return hr;
1649 }
1650
1651 return S_OK;
1652 }
1653
1654 static HRESULT parse_fx10_variable(const char *data, size_t data_size,
1655 const char **ptr, struct d3d10_effect_variable *v)
1656 {
1657 DWORD offset;
1658 unsigned int i;
1659 HRESULT hr;
1660
1661 if (FAILED(hr = parse_fx10_variable_head(data, data_size, ptr, v)))
1662 return hr;
1663
1664 read_dword(ptr, &offset);
1665 TRACE("Variable semantic at offset %#x.\n", offset);
1666
1667 if (!fx10_copy_string(data, data_size, offset, &v->semantic))
1668 {
1669 ERR("Failed to copy semantic.\n");
1670 return E_OUTOFMEMORY;
1671 }
1672 TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
1673
1674 read_dword(ptr, &v->buffer_offset);
1675 TRACE("Variable offset in buffer: %#x.\n", v->buffer_offset);
1676
1677 skip_dword_unknown("variable", ptr, 1);
1678
1679 read_dword(ptr, &v->flag);
1680 TRACE("Variable flag: %#x.\n", v->flag);
1681
1682 read_dword(ptr, &v->annotation_count);
1683 TRACE("Variable has %u annotations.\n", v->annotation_count);
1684
1685 if (!(v->annotations = d3d10_calloc(v->annotation_count, sizeof(*v->annotations))))
1686 {
1687 ERR("Failed to allocate variable annotations memory.\n");
1688 return E_OUTOFMEMORY;
1689 }
1690
1691 for (i = 0; i < v->annotation_count; ++i)
1692 {
1693 struct d3d10_effect_variable *a = &v->annotations[i];
1694
1695 a->effect = v->effect;
1696 a->buffer = &null_local_buffer;
1697
1698 if (FAILED(hr = parse_fx10_annotation(data, data_size, ptr, a)))
1699 return hr;
1700 }
1701
1702 return S_OK;
1703 }
1704
1705 static HRESULT create_state_object(struct d3d10_effect_variable *v)
1706 {
1707 ID3D10Device *device = v->effect->device;
1708 HRESULT hr;
1709
1710 switch (v->type->basetype)
1711 {
1712 case D3D10_SVT_DEPTHSTENCIL:
1713 if (FAILED(hr = ID3D10Device_CreateDepthStencilState(device,
1714 &v->u.state.desc.depth_stencil, &v->u.state.object.depth_stencil)))
1715 return hr;
1716 break;
1717
1718 case D3D10_SVT_BLEND:
1719 if (FAILED(hr = ID3D10Device_CreateBlendState(device,
1720 &v->u.state.desc.blend, &v->u.state.object.blend)))
1721 return hr;
1722 break;
1723
1724 case D3D10_SVT_RASTERIZER:
1725 if (FAILED(hr = ID3D10Device_CreateRasterizerState(device,
1726 &v->u.state.desc.rasterizer, &v->u.state.object.rasterizer)))
1727 return hr;
1728 break;
1729
1730 case D3D10_SVT_SAMPLER:
1731 if (FAILED(hr = ID3D10Device_CreateSamplerState(device,
1732 &v->u.state.desc.sampler, &v->u.state.object.sampler)))
1733 return hr;
1734 break;
1735
1736 default:
1737 ERR("Unhandled variable type %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
1738 return E_FAIL;
1739 }
1740
1741 return S_OK;
1742 }
1743
1744 static HRESULT parse_fx10_local_variable(const char *data, size_t data_size,
1745 const char **ptr, struct d3d10_effect_variable *v)
1746 {
1747 unsigned int i;
1748 HRESULT hr;
1749 DWORD offset;
1750
1751 if (FAILED(hr = parse_fx10_variable_head(data, data_size, ptr, v)))
1752 return hr;
1753
1754 read_dword(ptr, &offset);
1755 TRACE("Variable semantic at offset %#x.\n", offset);
1756
1757 if (!fx10_copy_string(data, data_size, offset, &v->semantic))
1758 {
1759 ERR("Failed to copy semantic.\n");
1760 return E_OUTOFMEMORY;
1761 }
1762 TRACE("Variable semantic: %s.\n", debugstr_a(v->semantic));
1763
1764 skip_dword_unknown("local variable", ptr, 1);
1765
1766 switch (v->type->basetype)
1767 {
1768 case D3D10_SVT_TEXTURE1D:
1769 case D3D10_SVT_TEXTURE1DARRAY:
1770 case D3D10_SVT_TEXTURE2D:
1771 case D3D10_SVT_TEXTURE2DARRAY:
1772 case D3D10_SVT_TEXTURE2DMS:
1773 case D3D10_SVT_TEXTURE2DMSARRAY:
1774 case D3D10_SVT_TEXTURE3D:
1775 case D3D10_SVT_TEXTURECUBE:
1776 case D3D10_SVT_RENDERTARGETVIEW:
1777 case D3D10_SVT_DEPTHSTENCILVIEW:
1778 case D3D10_SVT_BUFFER:
1779 TRACE("SVT could not have elements.\n");
1780 break;
1781
1782 case D3D10_SVT_VERTEXSHADER:
1783 case D3D10_SVT_PIXELSHADER:
1784 case D3D10_SVT_GEOMETRYSHADER:
1785 TRACE("Shader type is %s\n", debug_d3d10_shader_variable_type(v->type->basetype));
1786 for (i = 0; i < max(v->type->element_count, 1); ++i)
1787 {
1788 DWORD shader_offset;
1789 struct d3d10_effect_variable *var;
1790
1791 if (!v->type->element_count)
1792 {
1793 var = v;
1794 }
1795 else
1796 {
1797 var = &v->elements[i];
1798 }
1799
1800 read_dword(ptr, &shader_offset);
1801 TRACE("Shader offset: %#x.\n", shader_offset);
1802
1803 hr = parse_shader(&var->ID3D10EffectVariable_iface, data + shader_offset);
1804 if (FAILED(hr)) return hr;
1805 }
1806 break;
1807
1808 case D3D10_SVT_DEPTHSTENCIL:
1809 case D3D10_SVT_BLEND:
1810 case D3D10_SVT_RASTERIZER:
1811 case D3D10_SVT_SAMPLER:
1812 {
1813 const struct d3d10_effect_state_storage_info *storage_info;
1814 unsigned int count = max(v->type->element_count, 1);
1815
1816 if (!(storage_info = get_storage_info(v->type->basetype)))
1817 {
1818 FIXME("Failed to get backing store info for type %s.\n",
1819 debug_d3d10_shader_variable_type(v->type->basetype));
1820 return E_FAIL;
1821 }
1822
1823 if (storage_info->size > sizeof(v->u.state.desc))
1824 {
1825 ERR("Invalid storage size %#lx.\n", storage_info->size);
1826 return E_FAIL;
1827 }
1828
1829 for (i = 0; i < count; ++i)
1830 {
1831 struct d3d10_effect_variable *var;
1832
1833 if (v->type->element_count)
1834 var = &v->elements[i];
1835 else
1836 var = v;
1837
1838 memcpy(&var->u.state.desc, storage_info->default_state, storage_info->size);
1839 if (!parse_fx10_state_group(data, data_size, ptr, var->type->basetype, &var->u.state.desc))
1840 {
1841 ERR("Failed to read property list.\n");
1842 return E_FAIL;
1843 }
1844
1845 if (FAILED(hr = create_state_object(v)))
1846 return hr;
1847 }
1848 }
1849 break;
1850
1851 default:
1852 FIXME("Unhandled case %s.\n", debug_d3d10_shader_variable_type(v->type->basetype));
1853 return E_FAIL;
1854 }
1855
1856 read_dword(ptr, &v->annotation_count);
1857 TRACE("Variable has %u annotations.\n", v->annotation_count);
1858
1859 if (!(v->annotations = d3d10_calloc(v->annotation_count, sizeof(*v->annotations))))
1860 {
1861 ERR("Failed to allocate variable annotations memory.\n");
1862 return E_OUTOFMEMORY;
1863 }
1864
1865 for (i = 0; i < v->annotation_count; ++i)
1866 {
1867 struct d3d10_effect_variable *a = &v->annotations[i];
1868
1869 a->effect = v->effect;
1870 a->buffer = &null_local_buffer;
1871
1872 if (FAILED(hr = parse_fx10_annotation(data, data_size, ptr, a)))
1873 return hr;
1874 }
1875
1876 return S_OK;
1877 }
1878
1879 static HRESULT parse_fx10_local_buffer(const char *data, size_t data_size,
1880 const char **ptr, struct d3d10_effect_variable *l)
1881 {
1882 unsigned int i;
1883 DWORD offset;
1884 D3D10_CBUFFER_TYPE d3d10_cbuffer_type;
1885 HRESULT hr;
1886 unsigned int stride = 0;
1887
1888 /* Generate our own type, it isn't in the fx blob. */
1889 l->type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*l->type));
1890 if (!l->type)
1891 {
1892 ERR("Failed to allocate local buffer type memory.\n");
1893 return E_OUTOFMEMORY;
1894 }
1895 l->type->ID3D10EffectType_iface.lpVtbl = &d3d10_effect_type_vtbl;
1896 l->type->type_class = D3D10_SVC_OBJECT;
1897 l->type->effect = l->effect;
1898
1899 read_dword(ptr, &offset);
1900 TRACE("Local buffer name at offset %#x.\n", offset);
1901
1902 if (!fx10_copy_string(data, data_size, offset, &l->name))
1903 {
1904 ERR("Failed to copy name.\n");
1905 return E_OUTOFMEMORY;
1906 }
1907 TRACE("Local buffer name: %s.\n", debugstr_a(l->name));
1908
1909 read_dword(ptr, &l->data_size);
1910 TRACE("Local buffer data size: %#x.\n", l->data_size);
1911
1912 read_dword(ptr, &d3d10_cbuffer_type);
1913 TRACE("Local buffer type: %#x.\n", d3d10_cbuffer_type);
1914
1915 switch(d3d10_cbuffer_type)
1916 {
1917 case D3D10_CT_CBUFFER:
1918 l->type->basetype = D3D10_SVT_CBUFFER;
1919 if (!copy_name("cbuffer", &l->type->name))
1920 {
1921 ERR("Failed to copy name.\n");
1922 return E_OUTOFMEMORY;
1923 }
1924 break;
1925
1926 case D3D10_CT_TBUFFER:
1927 l->type->basetype = D3D10_SVT_TBUFFER;
1928 if (!copy_name("tbuffer", &l->type->name))
1929 {
1930 ERR("Failed to copy name.\n");
1931 return E_OUTOFMEMORY;
1932 }
1933 break;
1934
1935 default:
1936 ERR("Unexpected D3D10_CBUFFER_TYPE %#x!\n", d3d10_cbuffer_type);
1937 return E_FAIL;
1938 }
1939
1940 read_dword(ptr, &l->type->member_count);
1941 TRACE("Local buffer member count: %#x.\n", l->type->member_count);
1942
1943 skip_dword_unknown("local buffer", ptr, 1);
1944
1945 read_dword(ptr, &l->annotation_count);
1946 TRACE("Local buffer has %u annotations.\n", l->annotation_count);
1947
1948 if (!(l->annotations = d3d10_calloc(l->annotation_count, sizeof(*l->annotations))))
1949 {
1950 ERR("Failed to allocate local buffer annotations memory.\n");
1951 return E_OUTOFMEMORY;
1952 }
1953
1954 for (i = 0; i < l->annotation_count; ++i)
1955 {
1956 struct d3d10_effect_variable *a = &l->annotations[i];
1957
1958 a->effect = l->effect;
1959 a->buffer = &null_local_buffer;
1960
1961 if (FAILED(hr = parse_fx10_annotation(data, data_size, ptr, a)))
1962 return hr;
1963 }
1964
1965 if (!(l->members = d3d10_calloc(l->type->member_count, sizeof(*l->members))))
1966 {
1967 ERR("Failed to allocate members memory.\n");
1968 return E_OUTOFMEMORY;
1969 }
1970
1971 if (!(l->type->members = d3d10_calloc(l->type->member_count, sizeof(*l->type->members))))
1972 {
1973 ERR("Failed to allocate type members memory.\n");
1974 return E_OUTOFMEMORY;
1975 }
1976
1977 for (i = 0; i < l->type->member_count; ++i)
1978 {
1979 struct d3d10_effect_variable *v = &l->members[i];
1980 struct d3d10_effect_type_member *typem = &l->type->members[i];
1981
1982 v->buffer = l;
1983 v->effect = l->effect;
1984
1985 if (FAILED(hr = parse_fx10_variable(data, data_size, ptr, v)))
1986 return hr;
1987
1988 /*
1989 * Copy the values from the variable type to the constant buffers type
1990 * members structure, because it is our own generated type.
1991 */
1992 typem->type = v->type;
1993
1994 if (!copy_name(v->name, &typem->name))
1995 {
1996 ERR("Failed to copy name.\n");
1997 return E_OUTOFMEMORY;
1998 }
1999 TRACE("Variable name: %s.\n", debugstr_a(typem->name));
2000
2001 if (!copy_name(v->semantic, &typem->semantic))
2002 {
2003 ERR("Failed to copy name.\n");
2004 return E_OUTOFMEMORY;
2005 }
2006 TRACE("Variable semantic: %s.\n", debugstr_a(typem->semantic));
2007
2008 typem->buffer_offset = v->buffer_offset;
2009 TRACE("Variable buffer offset: %u.\n", typem->buffer_offset);
2010
2011 l->type->size_packed += v->type->size_packed;
2012
2013 /*
2014 * For the complete constantbuffer the size_unpacked = stride,
2015 * the stride is calculated like this:
2016 *
2017 * 1) if the constant buffer variables are packed with packoffset
2018 * - stride = the highest used constant
2019 * - the complete stride has to be a multiple of 0x10
2020 *
2021 * 2) if the constant buffer variables are NOT packed with packoffset
2022 * - sum of unpacked size for all variables which fit in a 0x10 part
2023 * - if the size exceeds a 0x10 part, the rest of the old part is skipped
2024 * and a new part is started
2025 * - if the variable is a struct it is always used a new part
2026 * - the complete stride has to be a multiple of 0x10
2027 *
2028 * e.g.:
2029 * 0x4, 0x4, 0x4, 0x8, 0x4, 0x14, 0x4
2030 * part 0x10 0x10 0x20 -> 0x40
2031 */
2032 if (v->flag & D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
2033 {
2034 if ((v->type->size_unpacked + v->buffer_offset) > stride)
2035 {
2036 stride = v->type->size_unpacked + v->buffer_offset;
2037 }
2038 }
2039 else
2040 {
2041 if (v->type->type_class == D3D10_SVC_STRUCT)
2042 {
2043 stride = (stride + 0xf) & ~0xf;
2044 }
2045
2046 if ( ((stride & 0xf) + v->type->size_unpacked) > 0x10)
2047 {
2048 stride = (stride + 0xf) & ~0xf;
2049 }
2050
2051 stride += v->type->size_unpacked;
2052 }
2053 }
2054 l->type->stride = l->type->size_unpacked = (stride + 0xf) & ~0xf;
2055
2056 TRACE("Constant buffer:\n");
2057 TRACE("\tType name: %s.\n", debugstr_a(l->type->name));
2058 TRACE("\tElement count: %u.\n", l->type->element_count);
2059 TRACE("\tMember count: %u.\n", l->type->member_count);
2060 TRACE("\tUnpacked size: %#x.\n", l->type->size_unpacked);
2061 TRACE("\tStride: %#x.\n", l->type->stride);
2062 TRACE("\tPacked size %#x.\n", l->type->size_packed);
2063 TRACE("\tBasetype: %s.\n", debug_d3d10_shader_variable_type(l->type->basetype));
2064 TRACE("\tTypeclass: %s.\n", debug_d3d10_shader_variable_class(l->type->type_class));
2065
2066 return S_OK;
2067 }
2068
2069 static void d3d10_effect_type_member_destroy(struct d3d10_effect_type_member *typem)
2070 {
2071 TRACE("effect type member %p.\n", typem);
2072
2073 /* Do not release typem->type, it will be covered by d3d10_effect_type_destroy(). */
2074 HeapFree(GetProcessHeap(), 0, typem->semantic);
2075 HeapFree(GetProcessHeap(), 0, typem->name);
2076 }
2077
2078 static void d3d10_effect_type_destroy(struct wine_rb_entry *entry, void *context)
2079 {
2080 struct d3d10_effect_type *t = WINE_RB_ENTRY_VALUE(entry, struct d3d10_effect_type, entry);
2081
2082 TRACE("effect type %p.\n", t);
2083
2084 if (t->elementtype)
2085 {
2086 HeapFree(GetProcessHeap(), 0, t->elementtype->name);
2087 HeapFree(GetProcessHeap(), 0, t->elementtype);
2088 }
2089
2090 if (t->members)
2091 {
2092 unsigned int i;
2093
2094 for (i = 0; i < t->member_count; ++i)
2095 {
2096 d3d10_effect_type_member_destroy(&t->members[i]);
2097 }
2098 HeapFree(GetProcessHeap(), 0, t->members);
2099 }
2100
2101 HeapFree(GetProcessHeap(), 0, t->name);
2102 HeapFree(GetProcessHeap(), 0, t);
2103 }
2104
2105 static HRESULT parse_fx10_body(struct d3d10_effect *e, const char *data, DWORD data_size)
2106 {
2107 const char *ptr = data + e->index_offset;
2108 unsigned int i;
2109 HRESULT hr;
2110
2111 if (!(e->local_buffers = d3d10_calloc(e->local_buffer_count, sizeof(*e->local_buffers))))
2112 {
2113 ERR("Failed to allocate local buffer memory.\n");
2114 return E_OUTOFMEMORY;
2115 }
2116
2117 if (!(e->local_variables = d3d10_calloc(e->local_variable_count, sizeof(*e->local_variables))))
2118 {
2119 ERR("Failed to allocate local variable memory.\n");
2120 return E_OUTOFMEMORY;
2121 }
2122
2123 if (!(e->anonymous_shaders = d3d10_calloc(e->anonymous_shader_count, sizeof(*e->anonymous_shaders))))
2124 {
2125 ERR("Failed to allocate anonymous shaders memory\n");
2126 return E_OUTOFMEMORY;
2127 }
2128
2129 if (!(e->used_shaders = d3d10_calloc(e->used_shader_count, sizeof(*e->used_shaders))))
2130 {
2131 ERR("Failed to allocate used shaders memory\n");
2132 return E_OUTOFMEMORY;
2133 }
2134
2135 if (!(e->techniques = d3d10_calloc(e->technique_count, sizeof(*e->techniques))))
2136 {
2137 ERR("Failed to allocate techniques memory\n");
2138 return E_OUTOFMEMORY;
2139 }
2140
2141 for (i = 0; i < e->local_buffer_count; ++i)
2142 {
2143 struct d3d10_effect_variable *l = &e->local_buffers[i];
2144 l->ID3D10EffectVariable_iface.lpVtbl = (const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl;
2145 l->effect = e;
2146 l->buffer = &null_local_buffer;
2147
2148 if (FAILED(hr = parse_fx10_local_buffer(data, data_size, &ptr, l)))
2149 return hr;
2150 }
2151
2152 for (i = 0; i < e->local_variable_count; ++i)
2153 {
2154 struct d3d10_effect_variable *v = &e->local_variables[i];
2155
2156 v->effect = e;
2157 v->ID3D10EffectVariable_iface.lpVtbl = &d3d10_effect_variable_vtbl;
2158 v->buffer = &null_local_buffer;
2159
2160 if (FAILED(hr = parse_fx10_local_variable(data, data_size, &ptr, v)))
2161 return hr;
2162 }
2163
2164 for (i = 0; i < e->technique_count; ++i)
2165 {
2166 struct d3d10_effect_technique *t = &e->techniques[i];
2167
2168 t->ID3D10EffectTechnique_iface.lpVtbl = &d3d10_effect_technique_vtbl;
2169 t->effect = e;
2170
2171 if (FAILED(hr = parse_fx10_technique(data, data_size, &ptr, t)))
2172 return hr;
2173 }
2174
2175 return S_OK;
2176 }
2177
2178 static HRESULT parse_fx10(struct d3d10_effect *e, const char *data, DWORD data_size)
2179 {
2180 const char *ptr = data;
2181 DWORD unknown;
2182
2183 if (!require_space(0, 19, sizeof(DWORD), data_size))
2184 {
2185 WARN("Invalid data size %#x.\n", data_size);
2186 return E_INVALIDARG;
2187 }
2188
2189 /* Compiled target version (e.g. fx_4_0=0xfeff1001, fx_4_1=0xfeff1011). */
2190 read_dword(&ptr, &e->version);
2191 TRACE("Target: %#x\n", e->version);
2192
2193 read_dword(&ptr, &e->local_buffer_count);
2194 TRACE("Local buffer count: %u.\n", e->local_buffer_count);
2195
2196 read_dword(&ptr, &e->variable_count);
2197 TRACE("Variable count: %u\n", e->variable_count);
2198
2199 read_dword(&ptr, &e->local_variable_count);
2200 TRACE("Object count: %u\n", e->local_variable_count);
2201
2202 read_dword(&ptr, &e->sharedbuffers_count);
2203 TRACE("Sharedbuffers count: %u\n", e->sharedbuffers_count);
2204
2205 /* Number of variables in shared buffers? */
2206 read_dword(&ptr, &unknown);
2207 FIXME("Unknown 0: %u\n", unknown);
2208
2209 read_dword(&ptr, &e->sharedobjects_count);
2210 TRACE("Sharedobjects count: %u\n", e->sharedobjects_count);
2211
2212 read_dword(&ptr, &e->technique_count);
2213 TRACE("Technique count: %u\n", e->technique_count);
2214
2215 read_dword(&ptr, &e->index_offset);
2216 TRACE("Index offset: %#x\n", e->index_offset);
2217
2218 read_dword(&ptr, &unknown);
2219 FIXME("Unknown 1: %u\n", unknown);
2220
2221 read_dword(&ptr, &e->texture_count);
2222 TRACE("Texture count: %u\n", e->texture_count);
2223
2224 read_dword(&ptr, &e->dephstencilstate_count);
2225 TRACE("Depthstencilstate count: %u\n", e->dephstencilstate_count);
2226
2227 read_dword(&ptr, &e->blendstate_count);
2228 TRACE("Blendstate count: %u\n", e->blendstate_count);
2229
2230 read_dword(&ptr, &e->rasterizerstate_count);
2231 TRACE("Rasterizerstate count: %u\n", e->rasterizerstate_count);
2232
2233 read_dword(&ptr, &e->samplerstate_count);
2234 TRACE("Samplerstate count: %u\n", e->samplerstate_count);
2235
2236 read_dword(&ptr, &e->rendertargetview_count);
2237 TRACE("Rendertargetview count: %u\n", e->rendertargetview_count);
2238
2239 read_dword(&ptr, &e->depthstencilview_count);
2240 TRACE("Depthstencilview count: %u\n", e->depthstencilview_count);
2241
2242 read_dword(&ptr, &e->used_shader_count);
2243 TRACE("Used shader count: %u\n", e->used_shader_count);
2244
2245 read_dword(&ptr, &e->anonymous_shader_count);
2246 TRACE("Anonymous shader count: %u\n", e->anonymous_shader_count);
2247
2248 return parse_fx10_body(e, ptr, data_size - (ptr - data));
2249 }
2250
2251 static HRESULT fx10_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
2252 {
2253 struct d3d10_effect *e = ctx;
2254
2255 TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
2256
2257 TRACE("chunk size: %#x\n", data_size);
2258
2259 switch(tag)
2260 {
2261 case TAG_FX10:
2262 return parse_fx10(e, data, data_size);
2263
2264 default:
2265 FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
2266 return S_OK;
2267 }
2268 }
2269
2270 HRESULT d3d10_effect_parse(struct d3d10_effect *This, const void *data, SIZE_T data_size)
2271 {
2272 return parse_dxbc(data, data_size, fx10_chunk_handler, This);
2273 }
2274
2275 static HRESULT d3d10_effect_object_apply(struct d3d10_effect_object *o)
2276 {
2277 ID3D10Device *device = o->pass->technique->effect->device;
2278
2279 TRACE("effect object %p, type %#x.\n", o, o->type);
2280
2281 switch(o->type)
2282 {
2283 case D3D10_EOT_RASTERIZER_STATE:
2284 ID3D10Device_RSSetState(device, o->object.rs);
2285 return S_OK;
2286
2287 case D3D10_EOT_DEPTH_STENCIL_STATE:
2288 ID3D10Device_OMSetDepthStencilState(device, o->object.ds, o->pass->stencil_ref);
2289 return S_OK;
2290
2291 case D3D10_EOT_BLEND_STATE:
2292 ID3D10Device_OMSetBlendState(device, o->object.bs, o->pass->blend_factor, o->pass->sample_mask);
2293 return S_OK;
2294
2295 case D3D10_EOT_VERTEXSHADER:
2296 ID3D10Device_VSSetShader(device, o->object.vs);
2297 return S_OK;
2298
2299 case D3D10_EOT_PIXELSHADER:
2300 ID3D10Device_PSSetShader(device, o->object.ps);
2301 return S_OK;
2302
2303 case D3D10_EOT_GEOMETRYSHADER:
2304 ID3D10Device_GSSetShader(device, o->object.gs);
2305 return S_OK;
2306
2307 case D3D10_EOT_STENCIL_REF:
2308 case D3D10_EOT_BLEND_FACTOR:
2309 case D3D10_EOT_SAMPLE_MASK:
2310 return S_OK;
2311
2312 default:
2313 FIXME("Unhandled effect object type %#x.\n", o->type);
2314 return E_FAIL;
2315 }
2316 }
2317
2318 static void d3d10_effect_shader_variable_destroy(struct d3d10_effect_shader_variable *s,
2319 D3D10_SHADER_VARIABLE_TYPE type)
2320 {
2321 shader_free_signature(&s->input_signature);
2322 shader_free_signature(&s->output_signature);
2323
2324 switch (type)
2325 {
2326 case D3D10_SVT_VERTEXSHADER:
2327 if (s->shader.vs)
2328 ID3D10VertexShader_Release(s->shader.vs);
2329 break;
2330
2331 case D3D10_SVT_PIXELSHADER:
2332 if (s->shader.ps)
2333 ID3D10PixelShader_Release(s->shader.ps);
2334 break;
2335
2336 case D3D10_SVT_GEOMETRYSHADER:
2337 if (s->shader.gs)
2338 ID3D10GeometryShader_Release(s->shader.gs);
2339 break;
2340
2341 default:
2342 FIXME("Unhandled shader type %s.\n", debug_d3d10_shader_variable_type(type));
2343 break;
2344 }
2345 }
2346
2347 static void d3d10_effect_variable_destroy(struct d3d10_effect_variable *v)
2348 {
2349 unsigned int i;
2350
2351 TRACE("variable %p.\n", v);
2352
2353 HeapFree(GetProcessHeap(), 0, v->name);
2354 HeapFree(GetProcessHeap(), 0, v->semantic);
2355 if (v->annotations)
2356 {
2357 for (i = 0; i < v->annotation_count; ++i)
2358 {
2359 d3d10_effect_variable_destroy(&v->annotations[i]);
2360 }
2361 HeapFree(GetProcessHeap(), 0, v->annotations);
2362 }
2363
2364 if (v->members)
2365 {
2366 for (i = 0; i < v->type->member_count; ++i)
2367 {
2368 d3d10_effect_variable_destroy(&v->members[i]);
2369 }
2370 HeapFree(GetProcessHeap(), 0, v->members);
2371 }
2372
2373 if (v->elements)
2374 {
2375 for (i = 0; i < v->type->element_count; ++i)
2376 {
2377 d3d10_effect_variable_destroy(&v->elements[i]);
2378 }
2379 HeapFree(GetProcessHeap(), 0, v->elements);
2380 }
2381
2382 if (v->type)
2383 {
2384 switch (v->type->basetype)
2385 {
2386 case D3D10_SVT_VERTEXSHADER:
2387 case D3D10_SVT_PIXELSHADER:
2388 case D3D10_SVT_GEOMETRYSHADER:
2389 d3d10_effect_shader_variable_destroy(&v->u.shader, v->type->basetype);
2390 break;
2391
2392 case D3D10_SVT_DEPTHSTENCIL:
2393 if (v->u.state.object.depth_stencil)
2394 ID3D10DepthStencilState_Release(v->u.state.object.depth_stencil);
2395 break;
2396
2397 case D3D10_SVT_BLEND:
2398 if (v->u.state.object.blend)
2399 ID3D10BlendState_Release(v->u.state.object.blend);
2400 break;
2401
2402 case D3D10_SVT_RASTERIZER:
2403 if (v->u.state.object.rasterizer)
2404 ID3D10RasterizerState_Release(v->u.state.object.rasterizer);
2405 break;
2406
2407 case D3D10_SVT_SAMPLER:
2408 if (v->u.state.object.sampler)
2409 ID3D10SamplerState_Release(v->u.state.object.sampler);
2410 break;
2411
2412 default:
2413 break;
2414 }
2415 }
2416 }
2417
2418 static void d3d10_effect_object_destroy(struct d3d10_effect_object *o)
2419 {
2420 switch (o->type)
2421 {
2422 case D3D10_EOT_RASTERIZER_STATE:
2423 if (o->object.rs)
2424 ID3D10RasterizerState_Release(o->object.rs);
2425 break;
2426
2427 case D3D10_EOT_DEPTH_STENCIL_STATE:
2428 if (o->object.ds)
2429 ID3D10DepthStencilState_Release(o->object.ds);
2430 break;
2431
2432 case D3D10_EOT_BLEND_STATE:
2433 if (o->object.bs)
2434 ID3D10BlendState_Release(o->object.bs);
2435 break;
2436
2437 case D3D10_EOT_VERTEXSHADER:
2438 if (o->object.vs)
2439 ID3D10VertexShader_Release(o->object.vs);
2440 break;
2441
2442 case D3D10_EOT_PIXELSHADER:
2443 if (o->object.ps)
2444 ID3D10PixelShader_Release(o->object.ps);
2445 break;
2446
2447 case D3D10_EOT_GEOMETRYSHADER:
2448 if (o->object.gs)
2449 ID3D10GeometryShader_Release(o->object.gs);
2450 break;
2451
2452 default:
2453 break;
2454 }
2455 }
2456
2457 static void d3d10_effect_pass_destroy(struct d3d10_effect_pass *p)
2458 {
2459 unsigned int i;
2460
2461 TRACE("pass %p\n", p);
2462
2463 HeapFree(GetProcessHeap(), 0, p->name);
2464
2465 if (p->objects)
2466 {
2467 for (i = 0; i < p->object_count; ++i)
2468 {
2469 d3d10_effect_object_destroy(&p->objects[i]);
2470 }
2471 HeapFree(GetProcessHeap(), 0, p->objects);
2472 }
2473
2474 if (p->annotations)
2475 {
2476 for (i = 0; i < p->annotation_count; ++i)
2477 {
2478 d3d10_effect_variable_destroy(&p->annotations[i]);
2479 }
2480 HeapFree(GetProcessHeap(), 0, p->annotations);
2481 }
2482 }
2483
2484 static void d3d10_effect_technique_destroy(struct d3d10_effect_technique *t)
2485 {
2486 unsigned int i;
2487
2488 TRACE("technique %p\n", t);
2489
2490 HeapFree(GetProcessHeap(), 0, t->name);
2491 if (t->passes)
2492 {
2493 for (i = 0; i < t->pass_count; ++i)
2494 {
2495 d3d10_effect_pass_destroy(&t->passes[i]);
2496 }
2497 HeapFree(GetProcessHeap(), 0, t->passes);
2498 }
2499
2500 if (t->annotations)
2501 {
2502 for (i = 0; i < t->annotation_count; ++i)
2503 {
2504 d3d10_effect_variable_destroy(&t->annotations[i]);
2505 }
2506 HeapFree(GetProcessHeap(), 0, t->annotations);
2507 }
2508 }
2509
2510 static void d3d10_effect_local_buffer_destroy(struct d3d10_effect_variable *l)
2511 {
2512 unsigned int i;
2513
2514 TRACE("local buffer %p.\n", l);
2515
2516 HeapFree(GetProcessHeap(), 0, l->name);
2517 if (l->members)
2518 {
2519 for (i = 0; i < l->type->member_count; ++i)
2520 {
2521 d3d10_effect_variable_destroy(&l->members[i]);
2522 }
2523 HeapFree(GetProcessHeap(), 0, l->members);
2524 }
2525
2526 if (l->type)
2527 d3d10_effect_type_destroy(&l->type->entry, NULL);
2528
2529 if (l->annotations)
2530 {
2531 for (i = 0; i < l->annotation_count; ++i)
2532 {
2533 d3d10_effect_variable_destroy(&l->annotations[i]);
2534 }
2535 HeapFree(GetProcessHeap(), 0, l->annotations);
2536 }
2537 }
2538
2539 /* IUnknown methods */
2540
2541 static inline struct d3d10_effect *impl_from_ID3D10Effect(ID3D10Effect *iface)
2542 {
2543 return CONTAINING_RECORD(iface, struct d3d10_effect, ID3D10Effect_iface);
2544 }
2545
2546 static HRESULT STDMETHODCALLTYPE d3d10_effect_QueryInterface(ID3D10Effect *iface, REFIID riid, void **object)
2547 {
2548 TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
2549
2550 if (IsEqualGUID(riid, &IID_ID3D10Effect)
2551 || IsEqualGUID(riid, &IID_IUnknown))
2552 {
2553 IUnknown_AddRef(iface);
2554 *object = iface;
2555 return S_OK;
2556 }
2557
2558 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
2559
2560 *object = NULL;
2561 return E_NOINTERFACE;
2562 }
2563
2564 static ULONG STDMETHODCALLTYPE d3d10_effect_AddRef(ID3D10Effect *iface)
2565 {
2566 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2567 ULONG refcount = InterlockedIncrement(&This->refcount);
2568
2569 TRACE("%p increasing refcount to %u\n", This, refcount);
2570
2571 return refcount;
2572 }
2573
2574 static ULONG STDMETHODCALLTYPE d3d10_effect_Release(ID3D10Effect *iface)
2575 {
2576 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2577 ULONG refcount = InterlockedDecrement(&This->refcount);
2578
2579 TRACE("%p decreasing refcount to %u\n", This, refcount);
2580
2581 if (!refcount)
2582 {
2583 unsigned int i;
2584
2585 if (This->techniques)
2586 {
2587 for (i = 0; i < This->technique_count; ++i)
2588 {
2589 d3d10_effect_technique_destroy(&This->techniques[i]);
2590 }
2591 HeapFree(GetProcessHeap(), 0, This->techniques);
2592 }
2593
2594 if (This->local_variables)
2595 {
2596 for (i = 0; i < This->local_variable_count; ++i)
2597 {
2598 d3d10_effect_variable_destroy(&This->local_variables[i]);
2599 }
2600 HeapFree(GetProcessHeap(), 0, This->local_variables);
2601 }
2602
2603 if (This->local_buffers)
2604 {
2605 for (i = 0; i < This->local_buffer_count; ++i)
2606 {
2607 d3d10_effect_local_buffer_destroy(&This->local_buffers[i]);
2608 }
2609 HeapFree(GetProcessHeap(), 0, This->local_buffers);
2610 }
2611
2612 if (This->anonymous_shaders)
2613 {
2614 for (i = 0; i < This->anonymous_shader_count; ++i)
2615 {
2616 d3d10_effect_variable_destroy(&This->anonymous_shaders[i].shader);
2617 HeapFree(GetProcessHeap(), 0, This->anonymous_shaders[i].type.name);
2618 }
2619 HeapFree(GetProcessHeap(), 0, This->anonymous_shaders);
2620 }
2621
2622 HeapFree(GetProcessHeap(), 0, This->used_shaders);
2623
2624 wine_rb_destroy(&This->types, d3d10_effect_type_destroy, NULL);
2625
2626 ID3D10Device_Release(This->device);
2627 HeapFree(GetProcessHeap(), 0, This);
2628 }
2629
2630 return refcount;
2631 }
2632
2633 /* ID3D10Effect methods */
2634
2635 static BOOL STDMETHODCALLTYPE d3d10_effect_IsValid(ID3D10Effect *iface)
2636 {
2637 FIXME("iface %p stub!\n", iface);
2638
2639 return FALSE;
2640 }
2641
2642 static BOOL STDMETHODCALLTYPE d3d10_effect_IsPool(ID3D10Effect *iface)
2643 {
2644 FIXME("iface %p stub!\n", iface);
2645
2646 return FALSE;
2647 }
2648
2649 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDevice(ID3D10Effect *iface, ID3D10Device **device)
2650 {
2651 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2652
2653 TRACE("iface %p, device %p\n", iface, device);
2654
2655 ID3D10Device_AddRef(This->device);
2656 *device = This->device;
2657
2658 return S_OK;
2659 }
2660
2661 static HRESULT STDMETHODCALLTYPE d3d10_effect_GetDesc(ID3D10Effect *iface, D3D10_EFFECT_DESC *desc)
2662 {
2663 FIXME("iface %p, desc %p stub!\n", iface, desc);
2664
2665 return E_NOTIMPL;
2666 }
2667
2668 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByIndex(ID3D10Effect *iface,
2669 UINT index)
2670 {
2671 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2672 struct d3d10_effect_variable *l;
2673
2674 TRACE("iface %p, index %u\n", iface, index);
2675
2676 if (index >= This->local_buffer_count)
2677 {
2678 WARN("Invalid index specified\n");
2679 return (ID3D10EffectConstantBuffer *)&null_local_buffer;
2680 }
2681
2682 l = &This->local_buffers[index];
2683
2684 TRACE("Returning buffer %p, %s.\n", l, debugstr_a(l->name));
2685
2686 return (ID3D10EffectConstantBuffer *)l;
2687 }
2688
2689 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_GetConstantBufferByName(ID3D10Effect *iface,
2690 const char *name)
2691 {
2692 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2693 unsigned int i;
2694
2695 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2696
2697 for (i = 0; i < This->local_buffer_count; ++i)
2698 {
2699 struct d3d10_effect_variable *l = &This->local_buffers[i];
2700
2701 if (l->name && !strcmp(l->name, name))
2702 {
2703 TRACE("Returning buffer %p.\n", l);
2704 return (ID3D10EffectConstantBuffer *)l;
2705 }
2706 }
2707
2708 WARN("Invalid name specified\n");
2709
2710 return (ID3D10EffectConstantBuffer *)&null_local_buffer;
2711 }
2712
2713 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByIndex(ID3D10Effect *iface, UINT index)
2714 {
2715 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2716 unsigned int i;
2717
2718 TRACE("iface %p, index %u\n", iface, index);
2719
2720 for (i = 0; i < This->local_buffer_count; ++i)
2721 {
2722 struct d3d10_effect_variable *l = &This->local_buffers[i];
2723
2724 if (index < l->type->member_count)
2725 {
2726 struct d3d10_effect_variable *v = &l->members[index];
2727
2728 TRACE("Returning variable %p.\n", v);
2729 return &v->ID3D10EffectVariable_iface;
2730 }
2731 index -= l->type->member_count;
2732 }
2733
2734 if (index < This->local_variable_count)
2735 {
2736 struct d3d10_effect_variable *v = &This->local_variables[index];
2737
2738 TRACE("Returning variable %p.\n", v);
2739 return &v->ID3D10EffectVariable_iface;
2740 }
2741
2742 WARN("Invalid index specified\n");
2743
2744 return &null_variable.ID3D10EffectVariable_iface;
2745 }
2746
2747 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableByName(ID3D10Effect *iface,
2748 const char *name)
2749 {
2750 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2751 unsigned int i;
2752
2753 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2754
2755 if (!name)
2756 {
2757 WARN("Invalid name specified\n");
2758 return &null_variable.ID3D10EffectVariable_iface;
2759 }
2760
2761 for (i = 0; i < This->local_buffer_count; ++i)
2762 {
2763 struct d3d10_effect_variable *l = &This->local_buffers[i];
2764 unsigned int j;
2765
2766 for (j = 0; j < l->type->member_count; ++j)
2767 {
2768 struct d3d10_effect_variable *v = &l->members[j];
2769
2770 if (v->name && !strcmp(v->name, name))
2771 {
2772 TRACE("Returning variable %p.\n", v);
2773 return &v->ID3D10EffectVariable_iface;
2774 }
2775 }
2776 }
2777
2778 for (i = 0; i < This->local_variable_count; ++i)
2779 {
2780 struct d3d10_effect_variable *v = &This->local_variables[i];
2781
2782 if (v->name && !strcmp(v->name, name))
2783 {
2784 TRACE("Returning variable %p.\n", v);
2785 return &v->ID3D10EffectVariable_iface;
2786 }
2787 }
2788
2789 WARN("Invalid name specified\n");
2790
2791 return &null_variable.ID3D10EffectVariable_iface;
2792 }
2793
2794 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_GetVariableBySemantic(ID3D10Effect *iface,
2795 const char *semantic)
2796 {
2797 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2798 unsigned int i;
2799
2800 TRACE("iface %p, semantic %s\n", iface, debugstr_a(semantic));
2801
2802 if (!semantic)
2803 {
2804 WARN("Invalid semantic specified\n");
2805 return &null_variable.ID3D10EffectVariable_iface;
2806 }
2807
2808 for (i = 0; i < This->local_buffer_count; ++i)
2809 {
2810 struct d3d10_effect_variable *l = &This->local_buffers[i];
2811 unsigned int j;
2812
2813 for (j = 0; j < l->type->member_count; ++j)
2814 {
2815 struct d3d10_effect_variable *v = &l->members[j];
2816
2817 if (v->semantic && !strcmp(v->semantic, semantic))
2818 {
2819 TRACE("Returning variable %p.\n", v);
2820 return &v->ID3D10EffectVariable_iface;
2821 }
2822 }
2823 }
2824
2825 for (i = 0; i < This->local_variable_count; ++i)
2826 {
2827 struct d3d10_effect_variable *v = &This->local_variables[i];
2828
2829 if (v->semantic && !strcmp(v->semantic, semantic))
2830 {
2831 TRACE("Returning variable %p.\n", v);
2832 return &v->ID3D10EffectVariable_iface;
2833 }
2834 }
2835
2836 WARN("Invalid semantic specified\n");
2837
2838 return &null_variable.ID3D10EffectVariable_iface;
2839 }
2840
2841 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByIndex(ID3D10Effect *iface,
2842 UINT index)
2843 {
2844 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2845 struct d3d10_effect_technique *t;
2846
2847 TRACE("iface %p, index %u\n", iface, index);
2848
2849 if (index >= This->technique_count)
2850 {
2851 WARN("Invalid index specified\n");
2852 return &null_technique.ID3D10EffectTechnique_iface;
2853 }
2854
2855 t = &This->techniques[index];
2856
2857 TRACE("Returning technique %p, %s.\n", t, debugstr_a(t->name));
2858
2859 return &t->ID3D10EffectTechnique_iface;
2860 }
2861
2862 static struct ID3D10EffectTechnique * STDMETHODCALLTYPE d3d10_effect_GetTechniqueByName(ID3D10Effect *iface,
2863 const char *name)
2864 {
2865 struct d3d10_effect *This = impl_from_ID3D10Effect(iface);
2866 unsigned int i;
2867
2868 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2869
2870 if (!name)
2871 {
2872 WARN("Invalid name specified\n");
2873 return &null_technique.ID3D10EffectTechnique_iface;
2874 }
2875
2876 for (i = 0; i < This->technique_count; ++i)
2877 {
2878 struct d3d10_effect_technique *t = &This->techniques[i];
2879 if (t->name && !strcmp(t->name, name))
2880 {
2881 TRACE("Returning technique %p\n", t);
2882 return &t->ID3D10EffectTechnique_iface;
2883 }
2884 }
2885
2886 WARN("Invalid name specified\n");
2887
2888 return &null_technique.ID3D10EffectTechnique_iface;
2889 }
2890
2891 static HRESULT STDMETHODCALLTYPE d3d10_effect_Optimize(ID3D10Effect *iface)
2892 {
2893 FIXME("iface %p stub!\n", iface);
2894
2895 return E_NOTIMPL;
2896 }
2897
2898 static BOOL STDMETHODCALLTYPE d3d10_effect_IsOptimized(ID3D10Effect *iface)
2899 {
2900 FIXME("iface %p stub!\n", iface);
2901
2902 return FALSE;
2903 }
2904
2905 const struct ID3D10EffectVtbl d3d10_effect_vtbl =
2906 {
2907 /* IUnknown methods */
2908 d3d10_effect_QueryInterface,
2909 d3d10_effect_AddRef,
2910 d3d10_effect_Release,
2911 /* ID3D10Effect methods */
2912 d3d10_effect_IsValid,
2913 d3d10_effect_IsPool,
2914 d3d10_effect_GetDevice,
2915 d3d10_effect_GetDesc,
2916 d3d10_effect_GetConstantBufferByIndex,
2917 d3d10_effect_GetConstantBufferByName,
2918 d3d10_effect_GetVariableByIndex,
2919 d3d10_effect_GetVariableByName,
2920 d3d10_effect_GetVariableBySemantic,
2921 d3d10_effect_GetTechniqueByIndex,
2922 d3d10_effect_GetTechniqueByName,
2923 d3d10_effect_Optimize,
2924 d3d10_effect_IsOptimized,
2925 };
2926
2927 /* ID3D10EffectTechnique methods */
2928
2929 static inline struct d3d10_effect_technique *impl_from_ID3D10EffectTechnique(ID3D10EffectTechnique *iface)
2930 {
2931 return CONTAINING_RECORD(iface, struct d3d10_effect_technique, ID3D10EffectTechnique_iface);
2932 }
2933
2934 static BOOL STDMETHODCALLTYPE d3d10_effect_technique_IsValid(ID3D10EffectTechnique *iface)
2935 {
2936 struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2937
2938 TRACE("iface %p\n", iface);
2939
2940 return This != &null_technique;
2941 }
2942
2943 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_GetDesc(ID3D10EffectTechnique *iface,
2944 D3D10_TECHNIQUE_DESC *desc)
2945 {
2946 struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2947
2948 TRACE("iface %p, desc %p\n", iface, desc);
2949
2950 if(This == &null_technique)
2951 {
2952 WARN("Null technique specified\n");
2953 return E_FAIL;
2954 }
2955
2956 if(!desc)
2957 {
2958 WARN("Invalid argument specified\n");
2959 return E_INVALIDARG;
2960 }
2961
2962 desc->Name = This->name;
2963 desc->Passes = This->pass_count;
2964 desc->Annotations = This->annotation_count;
2965
2966 return S_OK;
2967 }
2968
2969 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByIndex(
2970 ID3D10EffectTechnique *iface, UINT index)
2971 {
2972 struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2973 struct d3d10_effect_variable *a;
2974
2975 TRACE("iface %p, index %u\n", iface, index);
2976
2977 if (index >= This->annotation_count)
2978 {
2979 WARN("Invalid index specified\n");
2980 return &null_variable.ID3D10EffectVariable_iface;
2981 }
2982
2983 a = &This->annotations[index];
2984
2985 TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
2986
2987 return &a->ID3D10EffectVariable_iface;
2988 }
2989
2990 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_technique_GetAnnotationByName(
2991 ID3D10EffectTechnique *iface, const char *name)
2992 {
2993 struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
2994 unsigned int i;
2995
2996 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2997
2998 for (i = 0; i < This->annotation_count; ++i)
2999 {
3000 struct d3d10_effect_variable *a = &This->annotations[i];
3001 if (a->name && !strcmp(a->name, name))
3002 {
3003 TRACE("Returning annotation %p\n", a);
3004 return &a->ID3D10EffectVariable_iface;
3005 }
3006 }
3007
3008 WARN("Invalid name specified\n");
3009
3010 return &null_variable.ID3D10EffectVariable_iface;
3011 }
3012
3013 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByIndex(ID3D10EffectTechnique *iface,
3014 UINT index)
3015 {
3016 struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
3017 struct d3d10_effect_pass *p;
3018
3019 TRACE("iface %p, index %u\n", iface, index);
3020
3021 if (index >= This->pass_count)
3022 {
3023 WARN("Invalid index specified\n");
3024 return &null_pass.ID3D10EffectPass_iface;
3025 }
3026
3027 p = &This->passes[index];
3028
3029 TRACE("Returning pass %p, %s.\n", p, debugstr_a(p->name));
3030
3031 return &p->ID3D10EffectPass_iface;
3032 }
3033
3034 static struct ID3D10EffectPass * STDMETHODCALLTYPE d3d10_effect_technique_GetPassByName(ID3D10EffectTechnique *iface,
3035 const char *name)
3036 {
3037 struct d3d10_effect_technique *This = impl_from_ID3D10EffectTechnique(iface);
3038 unsigned int i;
3039
3040 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3041
3042 /* Do not check for name==NULL, W7/DX10 crashes in that case. */
3043
3044 for (i = 0; i < This->pass_count; ++i)
3045 {
3046 struct d3d10_effect_pass *p = &This->passes[i];
3047 if (p->name && !strcmp(p->name, name))
3048 {
3049 TRACE("Returning pass %p\n", p);
3050 return &p->ID3D10EffectPass_iface;
3051 }
3052 }
3053
3054 WARN("Invalid name specified\n");
3055
3056 return &null_pass.ID3D10EffectPass_iface;
3057 }
3058
3059 static HRESULT STDMETHODCALLTYPE d3d10_effect_technique_ComputeStateBlockMask(ID3D10EffectTechnique *iface,
3060 D3D10_STATE_BLOCK_MASK *mask)
3061 {
3062 FIXME("iface %p,mask %p stub!\n", iface, mask);
3063
3064 return E_NOTIMPL;
3065 }
3066
3067 static const struct ID3D10EffectTechniqueVtbl d3d10_effect_technique_vtbl =
3068 {
3069 /* ID3D10EffectTechnique methods */
3070 d3d10_effect_technique_IsValid,
3071 d3d10_effect_technique_GetDesc,
3072 d3d10_effect_technique_GetAnnotationByIndex,
3073 d3d10_effect_technique_GetAnnotationByName,
3074 d3d10_effect_technique_GetPassByIndex,
3075 d3d10_effect_technique_GetPassByName,
3076 d3d10_effect_technique_ComputeStateBlockMask,
3077 };
3078
3079 /* ID3D10EffectPass methods */
3080
3081 static inline struct d3d10_effect_pass *impl_from_ID3D10EffectPass(ID3D10EffectPass *iface)
3082 {
3083 return CONTAINING_RECORD(iface, struct d3d10_effect_pass, ID3D10EffectPass_iface);
3084 }
3085
3086 static BOOL STDMETHODCALLTYPE d3d10_effect_pass_IsValid(ID3D10EffectPass *iface)
3087 {
3088 struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
3089
3090 TRACE("iface %p\n", iface);
3091
3092 return This != &null_pass;
3093 }
3094
3095 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetDesc(ID3D10EffectPass *iface,
3096 D3D10_PASS_DESC *desc)
3097 {
3098 struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
3099 struct d3d10_effect_shader_variable *s;
3100
3101 FIXME("iface %p, desc %p partial stub!\n", iface, desc);
3102
3103 if(This == &null_pass)
3104 {
3105 WARN("Null pass specified\n");
3106 return E_FAIL;
3107 }
3108
3109 if(!desc)
3110 {
3111 WARN("Invalid argument specified\n");
3112 return E_INVALIDARG;
3113 }
3114
3115 memset(desc, 0, sizeof(*desc));
3116 desc->Name = This->name;
3117
3118 s = &impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)This->vs.pShaderVariable)->u.shader;
3119 desc->pIAInputSignature = (BYTE *)s->input_signature.signature;
3120 desc->IAInputSignatureSize = s->input_signature.signature_size;
3121
3122 desc->StencilRef = This->stencil_ref;
3123 desc->SampleMask = This->sample_mask;
3124 memcpy(desc->BlendFactor, This->blend_factor, 4 * sizeof(float));
3125
3126 return S_OK;
3127 }
3128
3129 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetVertexShaderDesc(ID3D10EffectPass *iface,
3130 D3D10_PASS_SHADER_DESC *desc)
3131 {
3132 struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
3133
3134 TRACE("iface %p, desc %p\n", iface, desc);
3135
3136 if (This == &null_pass)
3137 {
3138 WARN("Null pass specified\n");
3139 return E_FAIL;
3140 }
3141
3142 if (!desc)
3143 {
3144 WARN("Invalid argument specified\n");
3145 return E_INVALIDARG;
3146 }
3147
3148 *desc = This->vs;
3149
3150 return S_OK;
3151 }
3152
3153 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetGeometryShaderDesc(ID3D10EffectPass *iface,
3154 D3D10_PASS_SHADER_DESC *desc)
3155 {
3156 struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
3157
3158 TRACE("iface %p, desc %p\n", iface, desc);
3159
3160 if (This == &null_pass)
3161 {
3162 WARN("Null pass specified\n");
3163 return E_FAIL;
3164 }
3165
3166 if (!desc)
3167 {
3168 WARN("Invalid argument specified\n");
3169 return E_INVALIDARG;
3170 }
3171
3172 *desc = This->gs;
3173
3174 return S_OK;
3175 }
3176
3177 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_GetPixelShaderDesc(ID3D10EffectPass *iface,
3178 D3D10_PASS_SHADER_DESC *desc)
3179 {
3180 struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
3181
3182 TRACE("iface %p, desc %p\n", iface, desc);
3183
3184 if (This == &null_pass)
3185 {
3186 WARN("Null pass specified\n");
3187 return E_FAIL;
3188 }
3189
3190 if (!desc)
3191 {
3192 WARN("Invalid argument specified\n");
3193 return E_INVALIDARG;
3194 }
3195
3196 *desc = This->ps;
3197
3198 return S_OK;
3199 }
3200
3201 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByIndex(ID3D10EffectPass *iface,
3202 UINT index)
3203 {
3204 struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
3205 struct d3d10_effect_variable *a;
3206
3207 TRACE("iface %p, index %u\n", iface, index);
3208
3209 if (index >= This->annotation_count)
3210 {
3211 WARN("Invalid index specified\n");
3212 return &null_variable.ID3D10EffectVariable_iface;
3213 }
3214
3215 a = &This->annotations[index];
3216
3217 TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
3218
3219 return &a->ID3D10EffectVariable_iface;
3220 }
3221
3222 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_pass_GetAnnotationByName(ID3D10EffectPass *iface,
3223 const char *name)
3224 {
3225 struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
3226 unsigned int i;
3227
3228 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3229
3230 for (i = 0; i < This->annotation_count; ++i)
3231 {
3232 struct d3d10_effect_variable *a = &This->annotations[i];
3233 if (a->name && !strcmp(a->name, name))
3234 {
3235 TRACE("Returning annotation %p\n", a);
3236 return &a->ID3D10EffectVariable_iface;
3237 }
3238 }
3239
3240 WARN("Invalid name specified\n");
3241
3242 return &null_variable.ID3D10EffectVariable_iface;
3243 }
3244
3245 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_Apply(ID3D10EffectPass *iface, UINT flags)
3246 {
3247 struct d3d10_effect_pass *This = impl_from_ID3D10EffectPass(iface);
3248 HRESULT hr = S_OK;
3249 unsigned int i;
3250
3251 TRACE("iface %p, flags %#x\n", iface, flags);
3252
3253 if (flags) FIXME("Ignoring flags (%#x)\n", flags);
3254
3255 for (i = 0; i < This->object_count; ++i)
3256 {
3257 hr = d3d10_effect_object_apply(&This->objects[i]);
3258 if (FAILED(hr)) break;
3259 }
3260
3261 return hr;
3262 }
3263
3264 static HRESULT STDMETHODCALLTYPE d3d10_effect_pass_ComputeStateBlockMask(ID3D10EffectPass *iface,
3265 D3D10_STATE_BLOCK_MASK *mask)
3266 {
3267 FIXME("iface %p, mask %p stub!\n", iface, mask);
3268
3269 return E_NOTIMPL;
3270 }
3271
3272 static const struct ID3D10EffectPassVtbl d3d10_effect_pass_vtbl =
3273 {
3274 /* ID3D10EffectPass methods */
3275 d3d10_effect_pass_IsValid,
3276 d3d10_effect_pass_GetDesc,
3277 d3d10_effect_pass_GetVertexShaderDesc,
3278 d3d10_effect_pass_GetGeometryShaderDesc,
3279 d3d10_effect_pass_GetPixelShaderDesc,
3280 d3d10_effect_pass_GetAnnotationByIndex,
3281 d3d10_effect_pass_GetAnnotationByName,
3282 d3d10_effect_pass_Apply,
3283 d3d10_effect_pass_ComputeStateBlockMask,
3284 };
3285
3286 /* ID3D10EffectVariable methods */
3287
3288 static BOOL STDMETHODCALLTYPE d3d10_effect_variable_IsValid(ID3D10EffectVariable *iface)
3289 {
3290 TRACE("iface %p\n", iface);
3291
3292 return impl_from_ID3D10EffectVariable(iface) != &null_variable;
3293 }
3294
3295 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_variable_GetType(ID3D10EffectVariable *iface)
3296 {
3297 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3298
3299 TRACE("iface %p\n", iface);
3300
3301 return &This->type->ID3D10EffectType_iface;
3302 }
3303
3304 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetDesc(ID3D10EffectVariable *iface,
3305 D3D10_EFFECT_VARIABLE_DESC *desc)
3306 {
3307 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3308
3309 TRACE("iface %p, desc %p\n", iface, desc);
3310
3311 if (!iface->lpVtbl->IsValid(iface))
3312 {
3313 WARN("Null variable specified\n");
3314 return E_FAIL;
3315 }
3316
3317 if (!desc)
3318 {
3319 WARN("Invalid argument specified\n");
3320 return E_INVALIDARG;
3321 }
3322
3323 /* FIXME: This isn't correct. Anonymous shaders let desc->ExplicitBindPoint untouched, but normal shaders set it! */
3324 memset(desc, 0, sizeof(*desc));
3325 desc->Name = This->name;
3326 desc->Semantic = This->semantic;
3327 desc->Flags = This->flag;
3328 desc->Annotations = This->annotation_count;
3329 desc->BufferOffset = This->buffer_offset;
3330
3331 if (This->flag & D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT)
3332 {
3333 desc->ExplicitBindPoint = This->buffer_offset;
3334 }
3335
3336 return S_OK;
3337 }
3338
3339 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByIndex(
3340 ID3D10EffectVariable *iface, UINT index)
3341 {
3342 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3343 struct d3d10_effect_variable *a;
3344
3345 TRACE("iface %p, index %u\n", iface, index);
3346
3347 if (index >= This->annotation_count)
3348 {
3349 WARN("Invalid index specified\n");
3350 return &null_variable.ID3D10EffectVariable_iface;
3351 }
3352
3353 a = &This->annotations[index];
3354
3355 TRACE("Returning annotation %p, %s\n", a, debugstr_a(a->name));
3356
3357 return &a->ID3D10EffectVariable_iface;
3358 }
3359
3360 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetAnnotationByName(
3361 ID3D10EffectVariable *iface, const char *name)
3362 {
3363 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3364 unsigned int i;
3365
3366 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3367
3368 for (i = 0; i < This->annotation_count; ++i)
3369 {
3370 struct d3d10_effect_variable *a = &This->annotations[i];
3371 if (a->name && !strcmp(a->name, name))
3372 {
3373 TRACE("Returning annotation %p\n", a);
3374 return &a->ID3D10EffectVariable_iface;
3375 }
3376 }
3377
3378 WARN("Invalid name specified\n");
3379
3380 return &null_variable.ID3D10EffectVariable_iface;
3381 }
3382
3383 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByIndex(
3384 ID3D10EffectVariable *iface, UINT index)
3385 {
3386 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3387 struct d3d10_effect_variable *m;
3388
3389 TRACE("iface %p, index %u\n", iface, index);
3390
3391 if (index >= This->type->member_count)
3392 {
3393 WARN("Invalid index specified\n");
3394 return &null_variable.ID3D10EffectVariable_iface;
3395 }
3396
3397 m = &This->members[index];
3398
3399 TRACE("Returning member %p, %s\n", m, debugstr_a(m->name));
3400
3401 return &m->ID3D10EffectVariable_iface;
3402 }
3403
3404 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberByName(
3405 ID3D10EffectVariable *iface, const char *name)
3406 {
3407 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3408 unsigned int i;
3409
3410 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3411
3412 if (!name)
3413 {
3414 WARN("Invalid name specified\n");
3415 return &null_variable.ID3D10EffectVariable_iface;
3416 }
3417
3418 for (i = 0; i < This->type->member_count; ++i)
3419 {
3420 struct d3d10_effect_variable *m = &This->members[i];
3421
3422 if (m->name && !strcmp(m->name, name))
3423 {
3424 TRACE("Returning member %p\n", m);
3425 return &m->ID3D10EffectVariable_iface;
3426 }
3427 }
3428
3429 WARN("Invalid name specified\n");
3430
3431 return &null_variable.ID3D10EffectVariable_iface;
3432 }
3433
3434 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetMemberBySemantic(
3435 ID3D10EffectVariable *iface, const char *semantic)
3436 {
3437 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3438 unsigned int i;
3439
3440 TRACE("iface %p, semantic %s.\n", iface, debugstr_a(semantic));
3441
3442 if (!semantic)
3443 {
3444 WARN("Invalid semantic specified\n");
3445 return &null_variable.ID3D10EffectVariable_iface;
3446 }
3447
3448 for (i = 0; i < This->type->member_count; ++i)
3449 {
3450 struct d3d10_effect_variable *m = &This->members[i];
3451
3452 if (m->semantic && !strcmp(m->semantic, semantic))
3453 {
3454 TRACE("Returning member %p\n", m);
3455 return &m->ID3D10EffectVariable_iface;
3456 }
3457 }
3458
3459 WARN("Invalid semantic specified\n");
3460
3461 return &null_variable.ID3D10EffectVariable_iface;
3462 }
3463
3464 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_variable_GetElement(
3465 ID3D10EffectVariable *iface, UINT index)
3466 {
3467 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3468 struct d3d10_effect_variable *v;
3469
3470 TRACE("iface %p, index %u\n", iface, index);
3471
3472 if (index >= This->type->element_count)
3473 {
3474 WARN("Invalid index specified\n");
3475 return &null_variable.ID3D10EffectVariable_iface;
3476 }
3477
3478 v = &This->elements[index];
3479
3480 TRACE("Returning element %p, %s\n", v, debugstr_a(v->name));
3481
3482 return &v->ID3D10EffectVariable_iface;
3483 }
3484
3485 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_GetParentConstantBuffer(
3486 ID3D10EffectVariable *iface)
3487 {
3488 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3489
3490 TRACE("iface %p\n", iface);
3491
3492 return (ID3D10EffectConstantBuffer *)This->buffer;
3493 }
3494
3495 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsScalar(
3496 ID3D10EffectVariable *iface)
3497 {
3498 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3499
3500 TRACE("iface %p\n", iface);
3501
3502 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_scalar_variable_vtbl)
3503 return (ID3D10EffectScalarVariable *)&This->ID3D10EffectVariable_iface;
3504
3505 return (ID3D10EffectScalarVariable *)&null_scalar_variable.ID3D10EffectVariable_iface;
3506 }
3507
3508 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsVector(
3509 ID3D10EffectVariable *iface)
3510 {
3511 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3512
3513 TRACE("iface %p\n", iface);
3514
3515 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_vector_variable_vtbl)
3516 return (ID3D10EffectVectorVariable *)&This->ID3D10EffectVariable_iface;
3517
3518 return (ID3D10EffectVectorVariable *)&null_vector_variable.ID3D10EffectVariable_iface;
3519 }
3520
3521 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsMatrix(
3522 ID3D10EffectVariable *iface)
3523 {
3524 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3525
3526 TRACE("iface %p\n", iface);
3527
3528 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_matrix_variable_vtbl)
3529 return (ID3D10EffectMatrixVariable *)&This->ID3D10EffectVariable_iface;
3530
3531 return (ID3D10EffectMatrixVariable *)&null_matrix_variable.ID3D10EffectVariable_iface;
3532 }
3533
3534 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsString(
3535 ID3D10EffectVariable *iface)
3536 {
3537 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3538
3539 TRACE("iface %p\n", iface);
3540
3541 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_string_variable_vtbl)
3542 return (ID3D10EffectStringVariable *)&This->ID3D10EffectVariable_iface;
3543
3544 return (ID3D10EffectStringVariable *)&null_string_variable.ID3D10EffectVariable_iface;
3545 }
3546
3547 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShaderResource(
3548 ID3D10EffectVariable *iface)
3549 {
3550 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3551
3552 TRACE("iface %p\n", iface);
3553
3554 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_resource_variable_vtbl)
3555 return (ID3D10EffectShaderResourceVariable *)&This->ID3D10EffectVariable_iface;
3556
3557 return (ID3D10EffectShaderResourceVariable *)&null_shader_resource_variable.ID3D10EffectVariable_iface;
3558 }
3559
3560 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRenderTargetView(
3561 ID3D10EffectVariable *iface)
3562 {
3563 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3564
3565 TRACE("iface %p\n", iface);
3566
3567 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_render_target_view_variable_vtbl)
3568 return (ID3D10EffectRenderTargetViewVariable *)&This->ID3D10EffectVariable_iface;
3569
3570 return (ID3D10EffectRenderTargetViewVariable *)&null_render_target_view_variable.ID3D10EffectVariable_iface;
3571 }
3572
3573 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencilView(
3574 ID3D10EffectVariable *iface)
3575 {
3576 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3577
3578 TRACE("iface %p\n", iface);
3579
3580 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_view_variable_vtbl)
3581 return (ID3D10EffectDepthStencilViewVariable *)&This->ID3D10EffectVariable_iface;
3582
3583 return (ID3D10EffectDepthStencilViewVariable *)&null_depth_stencil_view_variable.ID3D10EffectVariable_iface;
3584 }
3585
3586 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_variable_AsConstantBuffer(
3587 ID3D10EffectVariable *iface)
3588 {
3589 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3590
3591 TRACE("iface %p\n", iface);
3592
3593 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_constant_buffer_vtbl)
3594 return (ID3D10EffectConstantBuffer *)&This->ID3D10EffectVariable_iface;
3595
3596 return (ID3D10EffectConstantBuffer *)&null_local_buffer.ID3D10EffectVariable_iface;
3597 }
3598
3599 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsShader(
3600 ID3D10EffectVariable *iface)
3601 {
3602 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3603
3604 TRACE("iface %p\n", iface);
3605
3606 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_shader_variable_vtbl)
3607 return (ID3D10EffectShaderVariable *)&This->ID3D10EffectVariable_iface;
3608
3609 return (ID3D10EffectShaderVariable *)&null_shader_variable.ID3D10EffectVariable_iface;
3610 }
3611
3612 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsBlend(ID3D10EffectVariable *iface)
3613 {
3614 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3615
3616 TRACE("iface %p\n", iface);
3617
3618 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_blend_variable_vtbl)
3619 return (ID3D10EffectBlendVariable *)&This->ID3D10EffectVariable_iface;
3620
3621 return (ID3D10EffectBlendVariable *)&null_blend_variable.ID3D10EffectVariable_iface;
3622 }
3623
3624 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsDepthStencil(
3625 ID3D10EffectVariable *iface)
3626 {
3627 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3628
3629 TRACE("iface %p\n", iface);
3630
3631 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_depth_stencil_variable_vtbl)
3632 return (ID3D10EffectDepthStencilVariable *)&This->ID3D10EffectVariable_iface;
3633
3634 return (ID3D10EffectDepthStencilVariable *)&null_depth_stencil_variable.ID3D10EffectVariable_iface;
3635 }
3636
3637 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsRasterizer(
3638 ID3D10EffectVariable *iface)
3639 {
3640 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3641
3642 TRACE("iface %p\n", iface);
3643
3644 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_rasterizer_variable_vtbl)
3645 return (ID3D10EffectRasterizerVariable *)&This->ID3D10EffectVariable_iface;
3646
3647 return (ID3D10EffectRasterizerVariable *)&null_rasterizer_variable.ID3D10EffectVariable_iface;
3648 }
3649
3650 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_variable_AsSampler(
3651 ID3D10EffectVariable *iface)
3652 {
3653 struct d3d10_effect_variable *This = impl_from_ID3D10EffectVariable(iface);
3654
3655 TRACE("iface %p\n", iface);
3656
3657 if (This->ID3D10EffectVariable_iface.lpVtbl == (const ID3D10EffectVariableVtbl *)&d3d10_effect_sampler_variable_vtbl)
3658 return (ID3D10EffectSamplerVariable *)&This->ID3D10EffectVariable_iface;
3659
3660 return (ID3D10EffectSamplerVariable *)&null_sampler_variable.ID3D10EffectVariable_iface;
3661 }
3662
3663 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_SetRawValue(ID3D10EffectVariable *iface,
3664 void *data, UINT offset, UINT count)
3665 {
3666 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
3667
3668 return E_NOTIMPL;
3669 }
3670
3671 static HRESULT STDMETHODCALLTYPE d3d10_effect_variable_GetRawValue(ID3D10EffectVariable *iface,
3672 void *data, UINT offset, UINT count)
3673 {
3674 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
3675
3676 return E_NOTIMPL;
3677 }
3678
3679 static const struct ID3D10EffectVariableVtbl d3d10_effect_variable_vtbl =
3680 {
3681 /* ID3D10EffectVariable methods */
3682 d3d10_effect_variable_IsValid,
3683 d3d10_effect_variable_GetType,
3684 d3d10_effect_variable_GetDesc,
3685 d3d10_effect_variable_GetAnnotationByIndex,
3686 d3d10_effect_variable_GetAnnotationByName,
3687 d3d10_effect_variable_GetMemberByIndex,
3688 d3d10_effect_variable_GetMemberByName,
3689 d3d10_effect_variable_GetMemberBySemantic,
3690 d3d10_effect_variable_GetElement,
3691 d3d10_effect_variable_GetParentConstantBuffer,
3692 d3d10_effect_variable_AsScalar,
3693 d3d10_effect_variable_AsVector,
3694 d3d10_effect_variable_AsMatrix,
3695 d3d10_effect_variable_AsString,
3696 d3d10_effect_variable_AsShaderResource,
3697 d3d10_effect_variable_AsRenderTargetView,
3698 d3d10_effect_variable_AsDepthStencilView,
3699 d3d10_effect_variable_AsConstantBuffer,
3700 d3d10_effect_variable_AsShader,
3701 d3d10_effect_variable_AsBlend,
3702 d3d10_effect_variable_AsDepthStencil,
3703 d3d10_effect_variable_AsRasterizer,
3704 d3d10_effect_variable_AsSampler,
3705 d3d10_effect_variable_SetRawValue,
3706 d3d10_effect_variable_GetRawValue,
3707 };
3708
3709 /* ID3D10EffectVariable methods */
3710 static BOOL STDMETHODCALLTYPE d3d10_effect_constant_buffer_IsValid(ID3D10EffectConstantBuffer *iface)
3711 {
3712 TRACE("iface %p\n", iface);
3713
3714 return (struct d3d10_effect_variable *)iface != &null_local_buffer;
3715 }
3716
3717 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetType(ID3D10EffectConstantBuffer *iface)
3718 {
3719 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
3720 }
3721
3722 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetDesc(ID3D10EffectConstantBuffer *iface,
3723 D3D10_EFFECT_VARIABLE_DESC *desc)
3724 {
3725 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
3726 }
3727
3728 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByIndex(
3729 ID3D10EffectConstantBuffer *iface, UINT index)
3730 {
3731 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
3732 }
3733
3734 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetAnnotationByName(
3735 ID3D10EffectConstantBuffer *iface, const char *name)
3736 {
3737 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
3738 }
3739
3740 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByIndex(
3741 ID3D10EffectConstantBuffer *iface, UINT index)
3742 {
3743 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
3744 }
3745
3746 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberByName(
3747 ID3D10EffectConstantBuffer *iface, const char *name)
3748 {
3749 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
3750 }
3751
3752 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetMemberBySemantic(
3753 ID3D10EffectConstantBuffer *iface, const char *semantic)
3754 {
3755 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
3756 }
3757
3758 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetElement(
3759 ID3D10EffectConstantBuffer *iface, UINT index)
3760 {
3761 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
3762 }
3763
3764 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetParentConstantBuffer(
3765 ID3D10EffectConstantBuffer *iface)
3766 {
3767 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
3768 }
3769
3770 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsScalar(
3771 ID3D10EffectConstantBuffer *iface)
3772 {
3773 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
3774 }
3775
3776 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsVector(
3777 ID3D10EffectConstantBuffer *iface)
3778 {
3779 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
3780 }
3781
3782 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsMatrix(
3783 ID3D10EffectConstantBuffer *iface)
3784 {
3785 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
3786 }
3787
3788 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsString(
3789 ID3D10EffectConstantBuffer *iface)
3790 {
3791 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
3792 }
3793
3794 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShaderResource(
3795 ID3D10EffectConstantBuffer *iface)
3796 {
3797 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
3798 }
3799
3800 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRenderTargetView(
3801 ID3D10EffectConstantBuffer *iface)
3802 {
3803 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
3804 }
3805
3806 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencilView(
3807 ID3D10EffectConstantBuffer *iface)
3808 {
3809 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
3810 }
3811
3812 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsConstantBuffer(
3813 ID3D10EffectConstantBuffer *iface)
3814 {
3815 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
3816 }
3817
3818 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsShader(
3819 ID3D10EffectConstantBuffer *iface)
3820 {
3821 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
3822 }
3823
3824 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsBlend(ID3D10EffectConstantBuffer *iface)
3825 {
3826 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
3827 }
3828
3829 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsDepthStencil(
3830 ID3D10EffectConstantBuffer *iface)
3831 {
3832 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
3833 }
3834
3835 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsRasterizer(
3836 ID3D10EffectConstantBuffer *iface)
3837 {
3838 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
3839 }
3840
3841 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_constant_buffer_AsSampler(
3842 ID3D10EffectConstantBuffer *iface)
3843 {
3844 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
3845 }
3846
3847 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetRawValue(ID3D10EffectConstantBuffer *iface,
3848 void *data, UINT offset, UINT count)
3849 {
3850 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3851 }
3852
3853 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetRawValue(ID3D10EffectConstantBuffer *iface,
3854 void *data, UINT offset, UINT count)
3855 {
3856 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
3857 }
3858
3859 /* ID3D10EffectConstantBuffer methods */
3860 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetConstantBuffer(ID3D10EffectConstantBuffer *iface,
3861 ID3D10Buffer *buffer)
3862 {
3863 FIXME("iface %p, buffer %p stub!\n", iface, buffer);
3864
3865 return E_NOTIMPL;
3866 }
3867
3868 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetConstantBuffer(ID3D10EffectConstantBuffer *iface,
3869 ID3D10Buffer **buffer)
3870 {
3871 FIXME("iface %p, buffer %p stub!\n", iface, buffer);
3872
3873 return E_NOTIMPL;
3874 }
3875
3876 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_SetTextureBuffer(ID3D10EffectConstantBuffer *iface,
3877 ID3D10ShaderResourceView *view)
3878 {
3879 FIXME("iface %p, view %p stub!\n", iface, view);
3880
3881 return E_NOTIMPL;
3882 }
3883
3884 static HRESULT STDMETHODCALLTYPE d3d10_effect_constant_buffer_GetTextureBuffer(ID3D10EffectConstantBuffer *iface,
3885 ID3D10ShaderResourceView **view)
3886 {
3887 FIXME("iface %p, view %p stub!\n", iface, view);
3888
3889 return E_NOTIMPL;
3890 }
3891
3892 static const struct ID3D10EffectConstantBufferVtbl d3d10_effect_constant_buffer_vtbl =
3893 {
3894 /* ID3D10EffectVariable methods */
3895 d3d10_effect_constant_buffer_IsValid,
3896 d3d10_effect_constant_buffer_GetType,
3897 d3d10_effect_constant_buffer_GetDesc,
3898 d3d10_effect_constant_buffer_GetAnnotationByIndex,
3899 d3d10_effect_constant_buffer_GetAnnotationByName,
3900 d3d10_effect_constant_buffer_GetMemberByIndex,
3901 d3d10_effect_constant_buffer_GetMemberByName,
3902 d3d10_effect_constant_buffer_GetMemberBySemantic,
3903 d3d10_effect_constant_buffer_GetElement,
3904 d3d10_effect_constant_buffer_GetParentConstantBuffer,
3905 d3d10_effect_constant_buffer_AsScalar,
3906 d3d10_effect_constant_buffer_AsVector,
3907 d3d10_effect_constant_buffer_AsMatrix,
3908 d3d10_effect_constant_buffer_AsString,
3909 d3d10_effect_constant_buffer_AsShaderResource,
3910 d3d10_effect_constant_buffer_AsRenderTargetView,
3911 d3d10_effect_constant_buffer_AsDepthStencilView,
3912 d3d10_effect_constant_buffer_AsConstantBuffer,
3913 d3d10_effect_constant_buffer_AsShader,
3914 d3d10_effect_constant_buffer_AsBlend,
3915 d3d10_effect_constant_buffer_AsDepthStencil,
3916 d3d10_effect_constant_buffer_AsRasterizer,
3917 d3d10_effect_constant_buffer_AsSampler,
3918 d3d10_effect_constant_buffer_SetRawValue,
3919 d3d10_effect_constant_buffer_GetRawValue,
3920 /* ID3D10EffectConstantBuffer methods */
3921 d3d10_effect_constant_buffer_SetConstantBuffer,
3922 d3d10_effect_constant_buffer_GetConstantBuffer,
3923 d3d10_effect_constant_buffer_SetTextureBuffer,
3924 d3d10_effect_constant_buffer_GetTextureBuffer,
3925 };
3926
3927 /* ID3D10EffectVariable methods */
3928
3929 static BOOL STDMETHODCALLTYPE d3d10_effect_scalar_variable_IsValid(ID3D10EffectScalarVariable *iface)
3930 {
3931 TRACE("iface %p\n", iface);
3932
3933 return (struct d3d10_effect_variable *)iface != &null_scalar_variable;
3934 }
3935
3936 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetType(
3937 ID3D10EffectScalarVariable *iface)
3938 {
3939 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
3940 }
3941
3942 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetDesc(ID3D10EffectScalarVariable *iface,
3943 D3D10_EFFECT_VARIABLE_DESC *desc)
3944 {
3945 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
3946 }
3947
3948 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByIndex(
3949 ID3D10EffectScalarVariable *iface, UINT index)
3950 {
3951 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
3952 }
3953
3954 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetAnnotationByName(
3955 ID3D10EffectScalarVariable *iface, const char *name)
3956 {
3957 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
3958 }
3959
3960 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByIndex(
3961 ID3D10EffectScalarVariable *iface, UINT index)
3962 {
3963 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
3964 }
3965
3966 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberByName(
3967 ID3D10EffectScalarVariable *iface, const char *name)
3968 {
3969 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
3970 }
3971
3972 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetMemberBySemantic(
3973 ID3D10EffectScalarVariable *iface, const char *semantic)
3974 {
3975 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
3976 }
3977
3978 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetElement(
3979 ID3D10EffectScalarVariable *iface, UINT index)
3980 {
3981 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
3982 }
3983
3984 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetParentConstantBuffer(
3985 ID3D10EffectScalarVariable *iface)
3986 {
3987 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
3988 }
3989
3990 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsScalar(
3991 ID3D10EffectScalarVariable *iface)
3992 {
3993 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
3994 }
3995
3996 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsVector(
3997 ID3D10EffectScalarVariable *iface)
3998 {
3999 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4000 }
4001
4002 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsMatrix(
4003 ID3D10EffectScalarVariable *iface)
4004 {
4005 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4006 }
4007
4008 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsString(
4009 ID3D10EffectScalarVariable *iface)
4010 {
4011 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4012 }
4013
4014 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShaderResource(
4015 ID3D10EffectScalarVariable *iface)
4016 {
4017 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4018 }
4019
4020 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRenderTargetView(
4021 ID3D10EffectScalarVariable *iface)
4022 {
4023 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4024 }
4025
4026 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencilView(
4027 ID3D10EffectScalarVariable *iface)
4028 {
4029 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4030 }
4031
4032 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsConstantBuffer(
4033 ID3D10EffectScalarVariable *iface)
4034 {
4035 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4036 }
4037
4038 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsShader(
4039 ID3D10EffectScalarVariable *iface)
4040 {
4041 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4042 }
4043
4044 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsBlend(
4045 ID3D10EffectScalarVariable *iface)
4046 {
4047 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4048 }
4049
4050 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsDepthStencil(
4051 ID3D10EffectScalarVariable *iface)
4052 {
4053 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4054 }
4055
4056 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsRasterizer(
4057 ID3D10EffectScalarVariable *iface)
4058 {
4059 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4060 }
4061
4062 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_scalar_variable_AsSampler(
4063 ID3D10EffectScalarVariable *iface)
4064 {
4065 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4066 }
4067
4068 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetRawValue(ID3D10EffectScalarVariable *iface,
4069 void *data, UINT offset, UINT count)
4070 {
4071 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4072 }
4073
4074 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetRawValue(ID3D10EffectScalarVariable *iface,
4075 void *data, UINT offset, UINT count)
4076 {
4077 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4078 }
4079
4080 /* ID3D10EffectScalarVariable methods */
4081
4082 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloat(ID3D10EffectScalarVariable *iface,
4083 float value)
4084 {
4085 FIXME("iface %p, value %.8e stub!\n", iface, value);
4086
4087 return E_NOTIMPL;
4088 }
4089
4090 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloat(ID3D10EffectScalarVariable *iface,
4091 float *value)
4092 {
4093 FIXME("iface %p, value %p stub!\n", iface, value);
4094
4095 return E_NOTIMPL;
4096 }
4097
4098 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetFloatArray(ID3D10EffectScalarVariable *iface,
4099 float *values, UINT offset, UINT count)
4100 {
4101 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4102
4103 return E_NOTIMPL;
4104 }
4105
4106 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetFloatArray(ID3D10EffectScalarVariable *iface,
4107 float *values, UINT offset, UINT count)
4108 {
4109 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4110
4111 return E_NOTIMPL;
4112 }
4113
4114 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetInt(ID3D10EffectScalarVariable *iface,
4115 int value)
4116 {
4117 FIXME("iface %p, value %d stub!\n", iface, value);
4118
4119 return E_NOTIMPL;
4120 }
4121
4122 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetInt(ID3D10EffectScalarVariable *iface,
4123 int *value)
4124 {
4125 FIXME("iface %p, value %p stub!\n", iface, value);
4126
4127 return E_NOTIMPL;
4128 }
4129
4130 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetIntArray(ID3D10EffectScalarVariable *iface,
4131 int *values, UINT offset, UINT count)
4132 {
4133 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4134
4135 return E_NOTIMPL;
4136 }
4137
4138 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetIntArray(ID3D10EffectScalarVariable *iface,
4139 int *values, UINT offset, UINT count)
4140 {
4141 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4142
4143 return E_NOTIMPL;
4144 }
4145
4146 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBool(ID3D10EffectScalarVariable *iface,
4147 BOOL value)
4148 {
4149 FIXME("iface %p, value %d stub!\n", iface, value);
4150
4151 return E_NOTIMPL;
4152 }
4153
4154 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBool(ID3D10EffectScalarVariable *iface,
4155 BOOL *value)
4156 {
4157 FIXME("iface %p, value %p stub!\n", iface, value);
4158
4159 return E_NOTIMPL;
4160 }
4161
4162 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_SetBoolArray(ID3D10EffectScalarVariable *iface,
4163 BOOL *values, UINT offset, UINT count)
4164 {
4165 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4166
4167 return E_NOTIMPL;
4168 }
4169
4170 static HRESULT STDMETHODCALLTYPE d3d10_effect_scalar_variable_GetBoolArray(ID3D10EffectScalarVariable *iface,
4171 BOOL *values, UINT offset, UINT count)
4172 {
4173 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4174
4175 return E_NOTIMPL;
4176 }
4177
4178 static const struct ID3D10EffectScalarVariableVtbl d3d10_effect_scalar_variable_vtbl =
4179 {
4180 /* ID3D10EffectVariable methods */
4181 d3d10_effect_scalar_variable_IsValid,
4182 d3d10_effect_scalar_variable_GetType,
4183 d3d10_effect_scalar_variable_GetDesc,
4184 d3d10_effect_scalar_variable_GetAnnotationByIndex,
4185 d3d10_effect_scalar_variable_GetAnnotationByName,
4186 d3d10_effect_scalar_variable_GetMemberByIndex,
4187 d3d10_effect_scalar_variable_GetMemberByName,
4188 d3d10_effect_scalar_variable_GetMemberBySemantic,
4189 d3d10_effect_scalar_variable_GetElement,
4190 d3d10_effect_scalar_variable_GetParentConstantBuffer,
4191 d3d10_effect_scalar_variable_AsScalar,
4192 d3d10_effect_scalar_variable_AsVector,
4193 d3d10_effect_scalar_variable_AsMatrix,
4194 d3d10_effect_scalar_variable_AsString,
4195 d3d10_effect_scalar_variable_AsShaderResource,
4196 d3d10_effect_scalar_variable_AsRenderTargetView,
4197 d3d10_effect_scalar_variable_AsDepthStencilView,
4198 d3d10_effect_scalar_variable_AsConstantBuffer,
4199 d3d10_effect_scalar_variable_AsShader,
4200 d3d10_effect_scalar_variable_AsBlend,
4201 d3d10_effect_scalar_variable_AsDepthStencil,
4202 d3d10_effect_scalar_variable_AsRasterizer,
4203 d3d10_effect_scalar_variable_AsSampler,
4204 d3d10_effect_scalar_variable_SetRawValue,
4205 d3d10_effect_scalar_variable_GetRawValue,
4206 /* ID3D10EffectScalarVariable methods */
4207 d3d10_effect_scalar_variable_SetFloat,
4208 d3d10_effect_scalar_variable_GetFloat,
4209 d3d10_effect_scalar_variable_SetFloatArray,
4210 d3d10_effect_scalar_variable_GetFloatArray,
4211 d3d10_effect_scalar_variable_SetInt,
4212 d3d10_effect_scalar_variable_GetInt,
4213 d3d10_effect_scalar_variable_SetIntArray,
4214 d3d10_effect_scalar_variable_GetIntArray,
4215 d3d10_effect_scalar_variable_SetBool,
4216 d3d10_effect_scalar_variable_GetBool,
4217 d3d10_effect_scalar_variable_SetBoolArray,
4218 d3d10_effect_scalar_variable_GetBoolArray,
4219 };
4220
4221 /* ID3D10EffectVariable methods */
4222
4223 static BOOL STDMETHODCALLTYPE d3d10_effect_vector_variable_IsValid(ID3D10EffectVectorVariable *iface)
4224 {
4225 TRACE("iface %p\n", iface);
4226
4227 return (struct d3d10_effect_variable *)iface != &null_vector_variable;
4228 }
4229
4230 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetType(
4231 ID3D10EffectVectorVariable *iface)
4232 {
4233 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4234 }
4235
4236 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetDesc(ID3D10EffectVectorVariable *iface,
4237 D3D10_EFFECT_VARIABLE_DESC *desc)
4238 {
4239 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4240 }
4241
4242 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByIndex(
4243 ID3D10EffectVectorVariable *iface, UINT index)
4244 {
4245 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4246 }
4247
4248 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetAnnotationByName(
4249 ID3D10EffectVectorVariable *iface, const char *name)
4250 {
4251 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4252 }
4253
4254 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByIndex(
4255 ID3D10EffectVectorVariable *iface, UINT index)
4256 {
4257 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4258 }
4259
4260 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberByName(
4261 ID3D10EffectVectorVariable *iface, const char *name)
4262 {
4263 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4264 }
4265
4266 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetMemberBySemantic(
4267 ID3D10EffectVectorVariable *iface, const char *semantic)
4268 {
4269 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4270 }
4271
4272 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetElement(
4273 ID3D10EffectVectorVariable *iface, UINT index)
4274 {
4275 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4276 }
4277
4278 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_GetParentConstantBuffer(
4279 ID3D10EffectVectorVariable *iface)
4280 {
4281 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4282 }
4283
4284 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsScalar(
4285 ID3D10EffectVectorVariable *iface)
4286 {
4287 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4288 }
4289
4290 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsVector(
4291 ID3D10EffectVectorVariable *iface)
4292 {
4293 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4294 }
4295
4296 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsMatrix(
4297 ID3D10EffectVectorVariable *iface)
4298 {
4299 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4300 }
4301
4302 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsString(
4303 ID3D10EffectVectorVariable *iface)
4304 {
4305 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4306 }
4307
4308 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShaderResource(
4309 ID3D10EffectVectorVariable *iface)
4310 {
4311 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4312 }
4313
4314 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRenderTargetView(
4315 ID3D10EffectVectorVariable *iface)
4316 {
4317 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4318 }
4319
4320 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencilView(
4321 ID3D10EffectVectorVariable *iface)
4322 {
4323 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4324 }
4325
4326 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsConstantBuffer(
4327 ID3D10EffectVectorVariable *iface)
4328 {
4329 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4330 }
4331
4332 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsShader(
4333 ID3D10EffectVectorVariable *iface)
4334 {
4335 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4336 }
4337
4338 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsBlend(
4339 ID3D10EffectVectorVariable *iface)
4340 {
4341 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4342 }
4343
4344 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsDepthStencil(
4345 ID3D10EffectVectorVariable *iface)
4346 {
4347 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4348 }
4349
4350 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsRasterizer(
4351 ID3D10EffectVectorVariable *iface)
4352 {
4353 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4354 }
4355
4356 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_vector_variable_AsSampler(
4357 ID3D10EffectVectorVariable *iface)
4358 {
4359 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4360 }
4361
4362 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetRawValue(ID3D10EffectVectorVariable *iface,
4363 void *data, UINT offset, UINT count)
4364 {
4365 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4366 }
4367
4368 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetRawValue(ID3D10EffectVectorVariable *iface,
4369 void *data, UINT offset, UINT count)
4370 {
4371 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4372 }
4373
4374 /* ID3D10EffectVectorVariable methods */
4375
4376 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVector(ID3D10EffectVectorVariable *iface,
4377 BOOL *value)
4378 {
4379 FIXME("iface %p, value %p stub!\n", iface, value);
4380
4381 return E_NOTIMPL;
4382 }
4383
4384 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVector(ID3D10EffectVectorVariable *iface,
4385 int *value)
4386 {
4387 FIXME("iface %p, value %p stub!\n", iface, value);
4388
4389 return E_NOTIMPL;
4390 }
4391
4392 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVector(ID3D10EffectVectorVariable *iface,
4393 float *value)
4394 {
4395 FIXME("iface %p, value %p stub!\n", iface, value);
4396
4397 return E_NOTIMPL;
4398 }
4399
4400 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVector(ID3D10EffectVectorVariable *iface,
4401 BOOL *value)
4402 {
4403 FIXME("iface %p, value %p stub!\n", iface, value);
4404
4405 return E_NOTIMPL;
4406 }
4407
4408 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVector(ID3D10EffectVectorVariable *iface,
4409 int *value)
4410 {
4411 FIXME("iface %p, value %p stub!\n", iface, value);
4412
4413 return E_NOTIMPL;
4414 }
4415
4416 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVector(ID3D10EffectVectorVariable *iface,
4417 float *value)
4418 {
4419 FIXME("iface %p, value %p stub!\n", iface, value);
4420
4421 return E_NOTIMPL;
4422 }
4423
4424 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetBoolVectorArray(ID3D10EffectVectorVariable *iface,
4425 BOOL *values, UINT offset, UINT count)
4426 {
4427 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4428
4429 return E_NOTIMPL;
4430 }
4431
4432 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetIntVectorArray(ID3D10EffectVectorVariable *iface,
4433 int *values, UINT offset, UINT count)
4434 {
4435 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4436
4437 return E_NOTIMPL;
4438 }
4439
4440 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_SetFloatVectorArray(ID3D10EffectVectorVariable *iface,
4441 float *values, UINT offset, UINT count)
4442 {
4443 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4444
4445 return E_NOTIMPL;
4446 }
4447
4448 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetBoolVectorArray(ID3D10EffectVectorVariable *iface,
4449 BOOL *values, UINT offset, UINT count)
4450 {
4451 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4452
4453 return E_NOTIMPL;
4454 }
4455
4456 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetIntVectorArray(ID3D10EffectVectorVariable *iface,
4457 int *values, UINT offset, UINT count)
4458 {
4459 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4460
4461 return E_NOTIMPL;
4462 }
4463
4464 static HRESULT STDMETHODCALLTYPE d3d10_effect_vector_variable_GetFloatVectorArray(ID3D10EffectVectorVariable *iface,
4465 float *values, UINT offset, UINT count)
4466 {
4467 FIXME("iface %p, values %p, offset %u, count %u stub!\n", iface, values, offset, count);
4468
4469 return E_NOTIMPL;
4470 }
4471
4472 static const struct ID3D10EffectVectorVariableVtbl d3d10_effect_vector_variable_vtbl =
4473 {
4474 /* ID3D10EffectVariable methods */
4475 d3d10_effect_vector_variable_IsValid,
4476 d3d10_effect_vector_variable_GetType,
4477 d3d10_effect_vector_variable_GetDesc,
4478 d3d10_effect_vector_variable_GetAnnotationByIndex,
4479 d3d10_effect_vector_variable_GetAnnotationByName,
4480 d3d10_effect_vector_variable_GetMemberByIndex,
4481 d3d10_effect_vector_variable_GetMemberByName,
4482 d3d10_effect_vector_variable_GetMemberBySemantic,
4483 d3d10_effect_vector_variable_GetElement,
4484 d3d10_effect_vector_variable_GetParentConstantBuffer,
4485 d3d10_effect_vector_variable_AsScalar,
4486 d3d10_effect_vector_variable_AsVector,
4487 d3d10_effect_vector_variable_AsMatrix,
4488 d3d10_effect_vector_variable_AsString,
4489 d3d10_effect_vector_variable_AsShaderResource,
4490 d3d10_effect_vector_variable_AsRenderTargetView,
4491 d3d10_effect_vector_variable_AsDepthStencilView,
4492 d3d10_effect_vector_variable_AsConstantBuffer,
4493 d3d10_effect_vector_variable_AsShader,
4494 d3d10_effect_vector_variable_AsBlend,
4495 d3d10_effect_vector_variable_AsDepthStencil,
4496 d3d10_effect_vector_variable_AsRasterizer,
4497 d3d10_effect_vector_variable_AsSampler,
4498 d3d10_effect_vector_variable_SetRawValue,
4499 d3d10_effect_vector_variable_GetRawValue,
4500 /* ID3D10EffectVectorVariable methods */
4501 d3d10_effect_vector_variable_SetBoolVector,
4502 d3d10_effect_vector_variable_SetIntVector,
4503 d3d10_effect_vector_variable_SetFloatVector,
4504 d3d10_effect_vector_variable_GetBoolVector,
4505 d3d10_effect_vector_variable_GetIntVector,
4506 d3d10_effect_vector_variable_GetFloatVector,
4507 d3d10_effect_vector_variable_SetBoolVectorArray,
4508 d3d10_effect_vector_variable_SetIntVectorArray,
4509 d3d10_effect_vector_variable_SetFloatVectorArray,
4510 d3d10_effect_vector_variable_GetBoolVectorArray,
4511 d3d10_effect_vector_variable_GetIntVectorArray,
4512 d3d10_effect_vector_variable_GetFloatVectorArray,
4513 };
4514
4515 /* ID3D10EffectVariable methods */
4516
4517 static BOOL STDMETHODCALLTYPE d3d10_effect_matrix_variable_IsValid(ID3D10EffectMatrixVariable *iface)
4518 {
4519 TRACE("iface %p\n", iface);
4520
4521 return (struct d3d10_effect_variable *)iface != &null_matrix_variable;
4522 }
4523
4524 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetType(
4525 ID3D10EffectMatrixVariable *iface)
4526 {
4527 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4528 }
4529
4530 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetDesc(ID3D10EffectMatrixVariable *iface,
4531 D3D10_EFFECT_VARIABLE_DESC *desc)
4532 {
4533 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4534 }
4535
4536 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByIndex(
4537 ID3D10EffectMatrixVariable *iface, UINT index)
4538 {
4539 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4540 }
4541
4542 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetAnnotationByName(
4543 ID3D10EffectMatrixVariable *iface, const char *name)
4544 {
4545 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4546 }
4547
4548 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByIndex(
4549 ID3D10EffectMatrixVariable *iface, UINT index)
4550 {
4551 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4552 }
4553
4554 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberByName(
4555 ID3D10EffectMatrixVariable *iface, const char *name)
4556 {
4557 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4558 }
4559
4560 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMemberBySemantic(
4561 ID3D10EffectMatrixVariable *iface, const char *semantic)
4562 {
4563 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4564 }
4565
4566 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetElement(
4567 ID3D10EffectMatrixVariable *iface, UINT index)
4568 {
4569 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4570 }
4571
4572 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetParentConstantBuffer(
4573 ID3D10EffectMatrixVariable *iface)
4574 {
4575 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4576 }
4577
4578 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsScalar(
4579 ID3D10EffectMatrixVariable *iface)
4580 {
4581 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4582 }
4583
4584 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsVector(
4585 ID3D10EffectMatrixVariable *iface)
4586 {
4587 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4588 }
4589
4590 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsMatrix(
4591 ID3D10EffectMatrixVariable *iface)
4592 {
4593 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4594 }
4595
4596 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsString(
4597 ID3D10EffectMatrixVariable *iface)
4598 {
4599 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4600 }
4601
4602 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShaderResource(
4603 ID3D10EffectMatrixVariable *iface)
4604 {
4605 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4606 }
4607
4608 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRenderTargetView(
4609 ID3D10EffectMatrixVariable *iface)
4610 {
4611 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4612 }
4613
4614 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencilView(
4615 ID3D10EffectMatrixVariable *iface)
4616 {
4617 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4618 }
4619
4620 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsConstantBuffer(
4621 ID3D10EffectMatrixVariable *iface)
4622 {
4623 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4624 }
4625
4626 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsShader(
4627 ID3D10EffectMatrixVariable *iface)
4628 {
4629 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4630 }
4631
4632 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsBlend(
4633 ID3D10EffectMatrixVariable *iface)
4634 {
4635 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4636 }
4637
4638 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsDepthStencil(
4639 ID3D10EffectMatrixVariable *iface)
4640 {
4641 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4642 }
4643
4644 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsRasterizer(
4645 ID3D10EffectMatrixVariable *iface)
4646 {
4647 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4648 }
4649
4650 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_matrix_variable_AsSampler(
4651 ID3D10EffectMatrixVariable *iface)
4652 {
4653 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4654 }
4655
4656 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetRawValue(ID3D10EffectMatrixVariable *iface,
4657 void *data, UINT offset, UINT count)
4658 {
4659 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4660 }
4661
4662 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetRawValue(ID3D10EffectMatrixVariable *iface,
4663 void *data, UINT offset, UINT count)
4664 {
4665 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4666 }
4667
4668 /* ID3D10EffectMatrixVariable methods */
4669
4670 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrix(ID3D10EffectMatrixVariable *iface,
4671 float *data)
4672 {
4673 FIXME("iface %p, data %p stub!\n", iface, data);
4674
4675 return E_NOTIMPL;
4676 }
4677
4678 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrix(ID3D10EffectMatrixVariable *iface,
4679 float *data)
4680 {
4681 FIXME("iface %p, data %p stub!\n", iface, data);
4682
4683 return E_NOTIMPL;
4684 }
4685
4686 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixArray(ID3D10EffectMatrixVariable *iface,
4687 float *data, UINT offset, UINT count)
4688 {
4689 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4690
4691 return E_NOTIMPL;
4692 }
4693
4694 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixArray(ID3D10EffectMatrixVariable *iface,
4695 float *data, UINT offset, UINT count)
4696 {
4697 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4698
4699 return E_NOTIMPL;
4700 }
4701
4702 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
4703 float *data)
4704 {
4705 FIXME("iface %p, data %p stub!\n", iface, data);
4706
4707 return E_NOTIMPL;
4708 }
4709
4710 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTranspose(ID3D10EffectMatrixVariable *iface,
4711 float *data)
4712 {
4713 FIXME("iface %p, data %p stub!\n", iface, data);
4714
4715 return E_NOTIMPL;
4716 }
4717
4718 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_SetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
4719 float *data, UINT offset, UINT count)
4720 {
4721 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4722
4723 return E_NOTIMPL;
4724 }
4725
4726 static HRESULT STDMETHODCALLTYPE d3d10_effect_matrix_variable_GetMatrixTransposeArray(ID3D10EffectMatrixVariable *iface,
4727 float *data, UINT offset, UINT count)
4728 {
4729 FIXME("iface %p, data %p, offset %u, count %u stub!\n", iface, data, offset, count);
4730
4731 return E_NOTIMPL;
4732 }
4733
4734
4735 static const struct ID3D10EffectMatrixVariableVtbl d3d10_effect_matrix_variable_vtbl =
4736 {
4737 /* ID3D10EffectVariable methods */
4738 d3d10_effect_matrix_variable_IsValid,
4739 d3d10_effect_matrix_variable_GetType,
4740 d3d10_effect_matrix_variable_GetDesc,
4741 d3d10_effect_matrix_variable_GetAnnotationByIndex,
4742 d3d10_effect_matrix_variable_GetAnnotationByName,
4743 d3d10_effect_matrix_variable_GetMemberByIndex,
4744 d3d10_effect_matrix_variable_GetMemberByName,
4745 d3d10_effect_matrix_variable_GetMemberBySemantic,
4746 d3d10_effect_matrix_variable_GetElement,
4747 d3d10_effect_matrix_variable_GetParentConstantBuffer,
4748 d3d10_effect_matrix_variable_AsScalar,
4749 d3d10_effect_matrix_variable_AsVector,
4750 d3d10_effect_matrix_variable_AsMatrix,
4751 d3d10_effect_matrix_variable_AsString,
4752 d3d10_effect_matrix_variable_AsShaderResource,
4753 d3d10_effect_matrix_variable_AsRenderTargetView,
4754 d3d10_effect_matrix_variable_AsDepthStencilView,
4755 d3d10_effect_matrix_variable_AsConstantBuffer,
4756 d3d10_effect_matrix_variable_AsShader,
4757 d3d10_effect_matrix_variable_AsBlend,
4758 d3d10_effect_matrix_variable_AsDepthStencil,
4759 d3d10_effect_matrix_variable_AsRasterizer,
4760 d3d10_effect_matrix_variable_AsSampler,
4761 d3d10_effect_matrix_variable_SetRawValue,
4762 d3d10_effect_matrix_variable_GetRawValue,
4763 /* ID3D10EffectMatrixVariable methods */
4764 d3d10_effect_matrix_variable_SetMatrix,
4765 d3d10_effect_matrix_variable_GetMatrix,
4766 d3d10_effect_matrix_variable_SetMatrixArray,
4767 d3d10_effect_matrix_variable_GetMatrixArray,
4768 d3d10_effect_matrix_variable_SetMatrixTranspose,
4769 d3d10_effect_matrix_variable_GetMatrixTranspose,
4770 d3d10_effect_matrix_variable_SetMatrixTransposeArray,
4771 d3d10_effect_matrix_variable_GetMatrixTransposeArray,
4772 };
4773
4774 /* ID3D10EffectVariable methods */
4775
4776 static BOOL STDMETHODCALLTYPE d3d10_effect_string_variable_IsValid(ID3D10EffectStringVariable *iface)
4777 {
4778 TRACE("iface %p\n", iface);
4779
4780 return (struct d3d10_effect_variable *)iface != &null_string_variable;
4781 }
4782
4783 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_string_variable_GetType(
4784 ID3D10EffectStringVariable *iface)
4785 {
4786 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4787 }
4788
4789 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetDesc(ID3D10EffectStringVariable *iface,
4790 D3D10_EFFECT_VARIABLE_DESC *desc)
4791 {
4792 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4793 }
4794
4795 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetAnnotationByIndex(
4796 ID3D10EffectStringVariable *iface, UINT index)
4797 {
4798 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
4799 }
4800
4801 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetAnnotationByName(
4802 ID3D10EffectStringVariable *iface, const char *name)
4803 {
4804 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
4805 }
4806
4807 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberByIndex(
4808 ID3D10EffectStringVariable *iface, UINT index)
4809 {
4810 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
4811 }
4812
4813 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberByName(
4814 ID3D10EffectStringVariable *iface, const char *name)
4815 {
4816 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
4817 }
4818
4819 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetMemberBySemantic(
4820 ID3D10EffectStringVariable *iface, const char *semantic)
4821 {
4822 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
4823 }
4824
4825 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_GetElement(
4826 ID3D10EffectStringVariable *iface, UINT index)
4827 {
4828 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
4829 }
4830
4831 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_string_variable_GetParentConstantBuffer(
4832 ID3D10EffectStringVariable *iface)
4833 {
4834 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
4835 }
4836
4837 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsScalar(
4838 ID3D10EffectStringVariable *iface)
4839 {
4840 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
4841 }
4842
4843 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsVector(
4844 ID3D10EffectStringVariable *iface)
4845 {
4846 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
4847 }
4848
4849 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsMatrix(
4850 ID3D10EffectStringVariable *iface)
4851 {
4852 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
4853 }
4854
4855 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsString(
4856 ID3D10EffectStringVariable *iface)
4857 {
4858 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
4859 }
4860
4861 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsShaderResource(
4862 ID3D10EffectStringVariable *iface)
4863 {
4864 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
4865 }
4866
4867 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsRenderTargetView(
4868 ID3D10EffectStringVariable *iface)
4869 {
4870 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
4871 }
4872
4873 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsDepthStencilView(
4874 ID3D10EffectStringVariable *iface)
4875 {
4876 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
4877 }
4878
4879 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_string_variable_AsConstantBuffer(
4880 ID3D10EffectStringVariable *iface)
4881 {
4882 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
4883 }
4884
4885 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsShader(
4886 ID3D10EffectStringVariable *iface)
4887 {
4888 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
4889 }
4890
4891 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsBlend(
4892 ID3D10EffectStringVariable *iface)
4893 {
4894 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
4895 }
4896
4897 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsDepthStencil(
4898 ID3D10EffectStringVariable *iface)
4899 {
4900 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
4901 }
4902
4903 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsRasterizer(
4904 ID3D10EffectStringVariable *iface)
4905 {
4906 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
4907 }
4908
4909 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_string_variable_AsSampler(
4910 ID3D10EffectStringVariable *iface)
4911 {
4912 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
4913 }
4914
4915 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_SetRawValue(ID3D10EffectStringVariable *iface,
4916 void *data, UINT offset, UINT count)
4917 {
4918 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4919 }
4920
4921 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetRawValue(ID3D10EffectStringVariable *iface,
4922 void *data, UINT offset, UINT count)
4923 {
4924 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
4925 }
4926
4927 /* ID3D10EffectStringVariable methods */
4928
4929 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetString(ID3D10EffectStringVariable *iface,
4930 const char **str)
4931 {
4932 FIXME("iface %p, str %p stub!\n", iface, str);
4933
4934 return E_NOTIMPL;
4935 }
4936
4937 static HRESULT STDMETHODCALLTYPE d3d10_effect_string_variable_GetStringArray(ID3D10EffectStringVariable *iface,
4938 const char **strs, UINT offset, UINT count)
4939 {
4940 FIXME("iface %p, strs %p, offset %u, count %u stub!\n", iface, strs, offset, count);
4941
4942 return E_NOTIMPL;
4943 }
4944
4945
4946 static const struct ID3D10EffectStringVariableVtbl d3d10_effect_string_variable_vtbl =
4947 {
4948 /* ID3D10EffectVariable methods */
4949 d3d10_effect_string_variable_IsValid,
4950 d3d10_effect_string_variable_GetType,
4951 d3d10_effect_string_variable_GetDesc,
4952 d3d10_effect_string_variable_GetAnnotationByIndex,
4953 d3d10_effect_string_variable_GetAnnotationByName,
4954 d3d10_effect_string_variable_GetMemberByIndex,
4955 d3d10_effect_string_variable_GetMemberByName,
4956 d3d10_effect_string_variable_GetMemberBySemantic,
4957 d3d10_effect_string_variable_GetElement,
4958 d3d10_effect_string_variable_GetParentConstantBuffer,
4959 d3d10_effect_string_variable_AsScalar,
4960 d3d10_effect_string_variable_AsVector,
4961 d3d10_effect_string_variable_AsMatrix,
4962 d3d10_effect_string_variable_AsString,
4963 d3d10_effect_string_variable_AsShaderResource,
4964 d3d10_effect_string_variable_AsRenderTargetView,
4965 d3d10_effect_string_variable_AsDepthStencilView,
4966 d3d10_effect_string_variable_AsConstantBuffer,
4967 d3d10_effect_string_variable_AsShader,
4968 d3d10_effect_string_variable_AsBlend,
4969 d3d10_effect_string_variable_AsDepthStencil,
4970 d3d10_effect_string_variable_AsRasterizer,
4971 d3d10_effect_string_variable_AsSampler,
4972 d3d10_effect_string_variable_SetRawValue,
4973 d3d10_effect_string_variable_GetRawValue,
4974 /* ID3D10EffectStringVariable methods */
4975 d3d10_effect_string_variable_GetString,
4976 d3d10_effect_string_variable_GetStringArray,
4977 };
4978
4979 /* ID3D10EffectVariable methods */
4980
4981 static BOOL STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_IsValid(ID3D10EffectShaderResourceVariable *iface)
4982 {
4983 TRACE("iface %p\n", iface);
4984
4985 return (struct d3d10_effect_variable *)iface != &null_shader_resource_variable;
4986 }
4987
4988 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetType(
4989 ID3D10EffectShaderResourceVariable *iface)
4990 {
4991 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
4992 }
4993
4994 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetDesc(
4995 ID3D10EffectShaderResourceVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
4996 {
4997 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
4998 }
4999
5000 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetAnnotationByIndex(
5001 ID3D10EffectShaderResourceVariable *iface, UINT index)
5002 {
5003 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5004 }
5005
5006 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetAnnotationByName(
5007 ID3D10EffectShaderResourceVariable *iface, const char *name)
5008 {
5009 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5010 }
5011
5012 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberByIndex(
5013 ID3D10EffectShaderResourceVariable *iface, UINT index)
5014 {
5015 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5016 }
5017
5018 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberByName(
5019 ID3D10EffectShaderResourceVariable *iface, const char *name)
5020 {
5021 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5022 }
5023
5024 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetMemberBySemantic(
5025 ID3D10EffectShaderResourceVariable *iface, const char *semantic)
5026 {
5027 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5028 }
5029
5030 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetElement(
5031 ID3D10EffectShaderResourceVariable *iface, UINT index)
5032 {
5033 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5034 }
5035
5036 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetParentConstantBuffer(
5037 ID3D10EffectShaderResourceVariable *iface)
5038 {
5039 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5040 }
5041
5042 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsScalar(
5043 ID3D10EffectShaderResourceVariable *iface)
5044 {
5045 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5046 }
5047
5048 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsVector(
5049 ID3D10EffectShaderResourceVariable *iface)
5050 {
5051 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5052 }
5053
5054 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsMatrix(
5055 ID3D10EffectShaderResourceVariable *iface)
5056 {
5057 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5058 }
5059
5060 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsString(
5061 ID3D10EffectShaderResourceVariable *iface)
5062 {
5063 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5064 }
5065
5066 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsShaderResource(
5067 ID3D10EffectShaderResourceVariable *iface)
5068 {
5069 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5070 }
5071
5072 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsRenderTargetView(
5073 ID3D10EffectShaderResourceVariable *iface)
5074 {
5075 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5076 }
5077
5078 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsDepthStencilView(
5079 ID3D10EffectShaderResourceVariable *iface)
5080 {
5081 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5082 }
5083
5084 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsConstantBuffer(
5085 ID3D10EffectShaderResourceVariable *iface)
5086 {
5087 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5088 }
5089
5090 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsShader(
5091 ID3D10EffectShaderResourceVariable *iface)
5092 {
5093 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5094 }
5095
5096 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsBlend(
5097 ID3D10EffectShaderResourceVariable *iface)
5098 {
5099 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5100 }
5101
5102 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsDepthStencil(
5103 ID3D10EffectShaderResourceVariable *iface)
5104 {
5105 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5106 }
5107
5108 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsRasterizer(
5109 ID3D10EffectShaderResourceVariable *iface)
5110 {
5111 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5112 }
5113
5114 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_AsSampler(
5115 ID3D10EffectShaderResourceVariable *iface)
5116 {
5117 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5118 }
5119
5120 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetRawValue(
5121 ID3D10EffectShaderResourceVariable *iface, void *data, UINT offset, UINT count)
5122 {
5123 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5124 }
5125
5126 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetRawValue(
5127 ID3D10EffectShaderResourceVariable *iface, void *data, UINT offset, UINT count)
5128 {
5129 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5130 }
5131
5132 /* ID3D10EffectShaderResourceVariable methods */
5133
5134 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetResource(
5135 ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView *resource)
5136 {
5137 FIXME("iface %p, resource %p stub!\n", iface, resource);
5138
5139 return E_NOTIMPL;
5140 }
5141
5142 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetResource(
5143 ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resource)
5144 {
5145 FIXME("iface %p, resource %p stub!\n", iface, resource);
5146
5147 return E_NOTIMPL;
5148 }
5149
5150 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_SetResourceArray(
5151 ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resources, UINT offset, UINT count)
5152 {
5153 FIXME("iface %p, resources %p, offset %u, count %u stub!\n", iface, resources, offset, count);
5154
5155 return E_NOTIMPL;
5156 }
5157
5158 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_resource_variable_GetResourceArray(
5159 ID3D10EffectShaderResourceVariable *iface, ID3D10ShaderResourceView **resources, UINT offset, UINT count)
5160 {
5161 FIXME("iface %p, resources %p, offset %u, count %u stub!\n", iface, resources, offset, count);
5162
5163 return E_NOTIMPL;
5164 }
5165
5166
5167 static const struct ID3D10EffectShaderResourceVariableVtbl d3d10_effect_shader_resource_variable_vtbl =
5168 {
5169 /* ID3D10EffectVariable methods */
5170 d3d10_effect_shader_resource_variable_IsValid,
5171 d3d10_effect_shader_resource_variable_GetType,
5172 d3d10_effect_shader_resource_variable_GetDesc,
5173 d3d10_effect_shader_resource_variable_GetAnnotationByIndex,
5174 d3d10_effect_shader_resource_variable_GetAnnotationByName,
5175 d3d10_effect_shader_resource_variable_GetMemberByIndex,
5176 d3d10_effect_shader_resource_variable_GetMemberByName,
5177 d3d10_effect_shader_resource_variable_GetMemberBySemantic,
5178 d3d10_effect_shader_resource_variable_GetElement,
5179 d3d10_effect_shader_resource_variable_GetParentConstantBuffer,
5180 d3d10_effect_shader_resource_variable_AsScalar,
5181 d3d10_effect_shader_resource_variable_AsVector,
5182 d3d10_effect_shader_resource_variable_AsMatrix,
5183 d3d10_effect_shader_resource_variable_AsString,
5184 d3d10_effect_shader_resource_variable_AsShaderResource,
5185 d3d10_effect_shader_resource_variable_AsRenderTargetView,
5186 d3d10_effect_shader_resource_variable_AsDepthStencilView,
5187 d3d10_effect_shader_resource_variable_AsConstantBuffer,
5188 d3d10_effect_shader_resource_variable_AsShader,
5189 d3d10_effect_shader_resource_variable_AsBlend,
5190 d3d10_effect_shader_resource_variable_AsDepthStencil,
5191 d3d10_effect_shader_resource_variable_AsRasterizer,
5192 d3d10_effect_shader_resource_variable_AsSampler,
5193 d3d10_effect_shader_resource_variable_SetRawValue,
5194 d3d10_effect_shader_resource_variable_GetRawValue,
5195 /* ID3D10EffectShaderResourceVariable methods */
5196 d3d10_effect_shader_resource_variable_SetResource,
5197 d3d10_effect_shader_resource_variable_GetResource,
5198 d3d10_effect_shader_resource_variable_SetResourceArray,
5199 d3d10_effect_shader_resource_variable_GetResourceArray,
5200 };
5201
5202 /* ID3D10EffectVariable methods */
5203
5204 static BOOL STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_IsValid(
5205 ID3D10EffectRenderTargetViewVariable *iface)
5206 {
5207 TRACE("iface %p\n", iface);
5208
5209 return (struct d3d10_effect_variable *)iface != &null_render_target_view_variable;
5210 }
5211
5212 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetType(
5213 ID3D10EffectRenderTargetViewVariable *iface)
5214 {
5215 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5216 }
5217
5218 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetDesc(
5219 ID3D10EffectRenderTargetViewVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
5220 {
5221 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5222 }
5223
5224 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetAnnotationByIndex(
5225 ID3D10EffectRenderTargetViewVariable *iface, UINT index)
5226 {
5227 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5228 }
5229
5230 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetAnnotationByName(
5231 ID3D10EffectRenderTargetViewVariable *iface, const char *name)
5232 {
5233 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5234 }
5235
5236 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberByIndex(
5237 ID3D10EffectRenderTargetViewVariable *iface, UINT index)
5238 {
5239 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5240 }
5241
5242 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberByName(
5243 ID3D10EffectRenderTargetViewVariable *iface, const char *name)
5244 {
5245 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5246 }
5247
5248 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetMemberBySemantic(
5249 ID3D10EffectRenderTargetViewVariable *iface, const char *semantic)
5250 {
5251 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5252 }
5253
5254 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetElement(
5255 ID3D10EffectRenderTargetViewVariable *iface, UINT index)
5256 {
5257 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5258 }
5259
5260 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetParentConstantBuffer(
5261 ID3D10EffectRenderTargetViewVariable *iface)
5262 {
5263 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5264 }
5265
5266 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsScalar(
5267 ID3D10EffectRenderTargetViewVariable *iface)
5268 {
5269 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5270 }
5271
5272 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsVector(
5273 ID3D10EffectRenderTargetViewVariable *iface)
5274 {
5275 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5276 }
5277
5278 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsMatrix(
5279 ID3D10EffectRenderTargetViewVariable *iface)
5280 {
5281 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5282 }
5283
5284 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsString(
5285 ID3D10EffectRenderTargetViewVariable *iface)
5286 {
5287 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5288 }
5289
5290 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsShaderResource(
5291 ID3D10EffectRenderTargetViewVariable *iface)
5292 {
5293 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5294 }
5295
5296 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsRenderTargetView(
5297 ID3D10EffectRenderTargetViewVariable *iface)
5298 {
5299 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5300 }
5301
5302 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsDepthStencilView(
5303 ID3D10EffectRenderTargetViewVariable *iface)
5304 {
5305 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5306 }
5307
5308 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsConstantBuffer(
5309 ID3D10EffectRenderTargetViewVariable *iface)
5310 {
5311 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5312 }
5313
5314 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsShader(
5315 ID3D10EffectRenderTargetViewVariable *iface)
5316 {
5317 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5318 }
5319
5320 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsBlend(
5321 ID3D10EffectRenderTargetViewVariable *iface)
5322 {
5323 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5324 }
5325
5326 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsDepthStencil(
5327 ID3D10EffectRenderTargetViewVariable *iface)
5328 {
5329 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5330 }
5331
5332 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsRasterizer(
5333 ID3D10EffectRenderTargetViewVariable *iface)
5334 {
5335 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5336 }
5337
5338 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_AsSampler(
5339 ID3D10EffectRenderTargetViewVariable *iface)
5340 {
5341 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5342 }
5343
5344 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRawValue(
5345 ID3D10EffectRenderTargetViewVariable *iface, void *data, UINT offset, UINT count)
5346 {
5347 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5348 }
5349
5350 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRawValue(
5351 ID3D10EffectRenderTargetViewVariable *iface, void *data, UINT offset, UINT count)
5352 {
5353 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5354 }
5355
5356 /* ID3D10EffectRenderTargetViewVariable methods */
5357
5358 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRenderTarget(
5359 ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView *view)
5360 {
5361 FIXME("iface %p, view %p stub!\n", iface, view);
5362
5363 return E_NOTIMPL;
5364 }
5365
5366 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRenderTarget(
5367 ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **view)
5368 {
5369 FIXME("iface %p, view %p stub!\n", iface, view);
5370
5371 return E_NOTIMPL;
5372 }
5373
5374 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_SetRenderTargetArray(
5375 ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **views, UINT offset, UINT count)
5376 {
5377 FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5378
5379 return E_NOTIMPL;
5380 }
5381
5382 static HRESULT STDMETHODCALLTYPE d3d10_effect_render_target_view_variable_GetRenderTargetArray(
5383 ID3D10EffectRenderTargetViewVariable *iface, ID3D10RenderTargetView **views, UINT offset, UINT count)
5384 {
5385 FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5386
5387 return E_NOTIMPL;
5388 }
5389
5390
5391 static const struct ID3D10EffectRenderTargetViewVariableVtbl d3d10_effect_render_target_view_variable_vtbl =
5392 {
5393 /* ID3D10EffectVariable methods */
5394 d3d10_effect_render_target_view_variable_IsValid,
5395 d3d10_effect_render_target_view_variable_GetType,
5396 d3d10_effect_render_target_view_variable_GetDesc,
5397 d3d10_effect_render_target_view_variable_GetAnnotationByIndex,
5398 d3d10_effect_render_target_view_variable_GetAnnotationByName,
5399 d3d10_effect_render_target_view_variable_GetMemberByIndex,
5400 d3d10_effect_render_target_view_variable_GetMemberByName,
5401 d3d10_effect_render_target_view_variable_GetMemberBySemantic,
5402 d3d10_effect_render_target_view_variable_GetElement,
5403 d3d10_effect_render_target_view_variable_GetParentConstantBuffer,
5404 d3d10_effect_render_target_view_variable_AsScalar,
5405 d3d10_effect_render_target_view_variable_AsVector,
5406 d3d10_effect_render_target_view_variable_AsMatrix,
5407 d3d10_effect_render_target_view_variable_AsString,
5408 d3d10_effect_render_target_view_variable_AsShaderResource,
5409 d3d10_effect_render_target_view_variable_AsRenderTargetView,
5410 d3d10_effect_render_target_view_variable_AsDepthStencilView,
5411 d3d10_effect_render_target_view_variable_AsConstantBuffer,
5412 d3d10_effect_render_target_view_variable_AsShader,
5413 d3d10_effect_render_target_view_variable_AsBlend,
5414 d3d10_effect_render_target_view_variable_AsDepthStencil,
5415 d3d10_effect_render_target_view_variable_AsRasterizer,
5416 d3d10_effect_render_target_view_variable_AsSampler,
5417 d3d10_effect_render_target_view_variable_SetRawValue,
5418 d3d10_effect_render_target_view_variable_GetRawValue,
5419 /* ID3D10EffectRenderTargetViewVariable methods */
5420 d3d10_effect_render_target_view_variable_SetRenderTarget,
5421 d3d10_effect_render_target_view_variable_GetRenderTarget,
5422 d3d10_effect_render_target_view_variable_SetRenderTargetArray,
5423 d3d10_effect_render_target_view_variable_GetRenderTargetArray,
5424 };
5425
5426 /* ID3D10EffectVariable methods */
5427
5428 static BOOL STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_IsValid(
5429 ID3D10EffectDepthStencilViewVariable *iface)
5430 {
5431 TRACE("iface %p\n", iface);
5432
5433 return (struct d3d10_effect_variable *)iface != &null_depth_stencil_view_variable;
5434 }
5435
5436 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetType(
5437 ID3D10EffectDepthStencilViewVariable *iface)
5438 {
5439 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5440 }
5441
5442 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDesc(
5443 ID3D10EffectDepthStencilViewVariable *iface, D3D10_EFFECT_VARIABLE_DESC *desc)
5444 {
5445 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5446 }
5447
5448 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetAnnotationByIndex(
5449 ID3D10EffectDepthStencilViewVariable *iface, UINT index)
5450 {
5451 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5452 }
5453
5454 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetAnnotationByName(
5455 ID3D10EffectDepthStencilViewVariable *iface, const char *name)
5456 {
5457 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5458 }
5459
5460 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberByIndex(
5461 ID3D10EffectDepthStencilViewVariable *iface, UINT index)
5462 {
5463 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5464 }
5465
5466 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberByName(
5467 ID3D10EffectDepthStencilViewVariable *iface, const char *name)
5468 {
5469 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5470 }
5471
5472 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetMemberBySemantic(
5473 ID3D10EffectDepthStencilViewVariable *iface, const char *semantic)
5474 {
5475 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5476 }
5477
5478 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetElement(
5479 ID3D10EffectDepthStencilViewVariable *iface, UINT index)
5480 {
5481 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5482 }
5483
5484 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetParentConstantBuffer(
5485 ID3D10EffectDepthStencilViewVariable *iface)
5486 {
5487 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5488 }
5489
5490 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsScalar(
5491 ID3D10EffectDepthStencilViewVariable *iface)
5492 {
5493 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5494 }
5495
5496 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsVector(
5497 ID3D10EffectDepthStencilViewVariable *iface)
5498 {
5499 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5500 }
5501
5502 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsMatrix(
5503 ID3D10EffectDepthStencilViewVariable *iface)
5504 {
5505 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5506 }
5507
5508 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsString(
5509 ID3D10EffectDepthStencilViewVariable *iface)
5510 {
5511 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5512 }
5513
5514 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsShaderResource(
5515 ID3D10EffectDepthStencilViewVariable *iface)
5516 {
5517 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5518 }
5519
5520 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsRenderTargetView(
5521 ID3D10EffectDepthStencilViewVariable *iface)
5522 {
5523 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5524 }
5525
5526 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsDepthStencilView(
5527 ID3D10EffectDepthStencilViewVariable *iface)
5528 {
5529 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5530 }
5531
5532 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsConstantBuffer(
5533 ID3D10EffectDepthStencilViewVariable *iface)
5534 {
5535 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5536 }
5537
5538 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsShader(
5539 ID3D10EffectDepthStencilViewVariable *iface)
5540 {
5541 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5542 }
5543
5544 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsBlend(
5545 ID3D10EffectDepthStencilViewVariable *iface)
5546 {
5547 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5548 }
5549
5550 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsDepthStencil(
5551 ID3D10EffectDepthStencilViewVariable *iface)
5552 {
5553 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5554 }
5555
5556 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsRasterizer(
5557 ID3D10EffectDepthStencilViewVariable *iface)
5558 {
5559 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5560 }
5561
5562 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_AsSampler(
5563 ID3D10EffectDepthStencilViewVariable *iface)
5564 {
5565 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5566 }
5567
5568 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetRawValue(
5569 ID3D10EffectDepthStencilViewVariable *iface, void *data, UINT offset, UINT count)
5570 {
5571 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5572 }
5573
5574 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetRawValue(
5575 ID3D10EffectDepthStencilViewVariable *iface, void *data, UINT offset, UINT count)
5576 {
5577 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5578 }
5579
5580 /* ID3D10EffectDepthStencilViewVariable methods */
5581
5582 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetDepthStencil(
5583 ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView *view)
5584 {
5585 FIXME("iface %p, view %p stub!\n", iface, view);
5586
5587 return E_NOTIMPL;
5588 }
5589
5590 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDepthStencil(
5591 ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **view)
5592 {
5593 FIXME("iface %p, view %p stub!\n", iface, view);
5594
5595 return E_NOTIMPL;
5596 }
5597
5598 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_SetDepthStencilArray(
5599 ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **views, UINT offset, UINT count)
5600 {
5601 FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5602
5603 return E_NOTIMPL;
5604 }
5605
5606 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_view_variable_GetDepthStencilArray(
5607 ID3D10EffectDepthStencilViewVariable *iface, ID3D10DepthStencilView **views, UINT offset, UINT count)
5608 {
5609 FIXME("iface %p, views %p, offset %u, count %u stub!\n", iface, views, offset, count);
5610
5611 return E_NOTIMPL;
5612 }
5613
5614
5615 static const struct ID3D10EffectDepthStencilViewVariableVtbl d3d10_effect_depth_stencil_view_variable_vtbl =
5616 {
5617 /* ID3D10EffectVariable methods */
5618 d3d10_effect_depth_stencil_view_variable_IsValid,
5619 d3d10_effect_depth_stencil_view_variable_GetType,
5620 d3d10_effect_depth_stencil_view_variable_GetDesc,
5621 d3d10_effect_depth_stencil_view_variable_GetAnnotationByIndex,
5622 d3d10_effect_depth_stencil_view_variable_GetAnnotationByName,
5623 d3d10_effect_depth_stencil_view_variable_GetMemberByIndex,
5624 d3d10_effect_depth_stencil_view_variable_GetMemberByName,
5625 d3d10_effect_depth_stencil_view_variable_GetMemberBySemantic,
5626 d3d10_effect_depth_stencil_view_variable_GetElement,
5627 d3d10_effect_depth_stencil_view_variable_GetParentConstantBuffer,
5628 d3d10_effect_depth_stencil_view_variable_AsScalar,
5629 d3d10_effect_depth_stencil_view_variable_AsVector,
5630 d3d10_effect_depth_stencil_view_variable_AsMatrix,
5631 d3d10_effect_depth_stencil_view_variable_AsString,
5632 d3d10_effect_depth_stencil_view_variable_AsShaderResource,
5633 d3d10_effect_depth_stencil_view_variable_AsRenderTargetView,
5634 d3d10_effect_depth_stencil_view_variable_AsDepthStencilView,
5635 d3d10_effect_depth_stencil_view_variable_AsConstantBuffer,
5636 d3d10_effect_depth_stencil_view_variable_AsShader,
5637 d3d10_effect_depth_stencil_view_variable_AsBlend,
5638 d3d10_effect_depth_stencil_view_variable_AsDepthStencil,
5639 d3d10_effect_depth_stencil_view_variable_AsRasterizer,
5640 d3d10_effect_depth_stencil_view_variable_AsSampler,
5641 d3d10_effect_depth_stencil_view_variable_SetRawValue,
5642 d3d10_effect_depth_stencil_view_variable_GetRawValue,
5643 /* ID3D10EffectDepthStencilViewVariable methods */
5644 d3d10_effect_depth_stencil_view_variable_SetDepthStencil,
5645 d3d10_effect_depth_stencil_view_variable_GetDepthStencil,
5646 d3d10_effect_depth_stencil_view_variable_SetDepthStencilArray,
5647 d3d10_effect_depth_stencil_view_variable_GetDepthStencilArray,
5648 };
5649
5650 /* ID3D10EffectVariable methods */
5651
5652 static BOOL STDMETHODCALLTYPE d3d10_effect_shader_variable_IsValid(ID3D10EffectShaderVariable *iface)
5653 {
5654 TRACE("iface %p\n", iface);
5655
5656 return (struct d3d10_effect_variable *)iface != &null_shader_variable;
5657 }
5658
5659 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetType(
5660 ID3D10EffectShaderVariable *iface)
5661 {
5662 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
5663 }
5664
5665 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetDesc(ID3D10EffectShaderVariable *iface,
5666 D3D10_EFFECT_VARIABLE_DESC *desc)
5667 {
5668 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
5669 }
5670
5671 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetAnnotationByIndex(
5672 ID3D10EffectShaderVariable *iface, UINT index)
5673 {
5674 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
5675 }
5676
5677 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetAnnotationByName(
5678 ID3D10EffectShaderVariable *iface, const char *name)
5679 {
5680 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
5681 }
5682
5683 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberByIndex(
5684 ID3D10EffectShaderVariable *iface, UINT index)
5685 {
5686 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
5687 }
5688
5689 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberByName(
5690 ID3D10EffectShaderVariable *iface, const char *name)
5691 {
5692 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
5693 }
5694
5695 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetMemberBySemantic(
5696 ID3D10EffectShaderVariable *iface, const char *semantic)
5697 {
5698 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
5699 }
5700
5701 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetElement(
5702 ID3D10EffectShaderVariable *iface, UINT index)
5703 {
5704 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
5705 }
5706
5707 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_variable_GetParentConstantBuffer(
5708 ID3D10EffectShaderVariable *iface)
5709 {
5710 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
5711 }
5712
5713 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsScalar(
5714 ID3D10EffectShaderVariable *iface)
5715 {
5716 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
5717 }
5718
5719 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsVector(
5720 ID3D10EffectShaderVariable *iface)
5721 {
5722 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
5723 }
5724
5725 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsMatrix(
5726 ID3D10EffectShaderVariable *iface)
5727 {
5728 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
5729 }
5730
5731 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsString(
5732 ID3D10EffectShaderVariable *iface)
5733 {
5734 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
5735 }
5736
5737 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsShaderResource(
5738 ID3D10EffectShaderVariable *iface)
5739 {
5740 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
5741 }
5742
5743 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsRenderTargetView(
5744 ID3D10EffectShaderVariable *iface)
5745 {
5746 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
5747 }
5748
5749 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsDepthStencilView(
5750 ID3D10EffectShaderVariable *iface)
5751 {
5752 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
5753 }
5754
5755 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsConstantBuffer(
5756 ID3D10EffectShaderVariable *iface)
5757 {
5758 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
5759 }
5760
5761 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsShader(
5762 ID3D10EffectShaderVariable *iface)
5763 {
5764 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
5765 }
5766
5767 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsBlend(
5768 ID3D10EffectShaderVariable *iface)
5769 {
5770 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
5771 }
5772
5773 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsDepthStencil(
5774 ID3D10EffectShaderVariable *iface)
5775 {
5776 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
5777 }
5778
5779 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsRasterizer(
5780 ID3D10EffectShaderVariable *iface)
5781 {
5782 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
5783 }
5784
5785 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_shader_variable_AsSampler(
5786 ID3D10EffectShaderVariable *iface)
5787 {
5788 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
5789 }
5790
5791 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_SetRawValue(
5792 ID3D10EffectShaderVariable *iface, void *data, UINT offset, UINT count)
5793 {
5794 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5795 }
5796
5797 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetRawValue(
5798 ID3D10EffectShaderVariable *iface, void *data, UINT offset, UINT count)
5799 {
5800 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
5801 }
5802
5803 /* ID3D10EffectShaderVariable methods */
5804
5805 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetShaderDesc(
5806 ID3D10EffectShaderVariable *iface, UINT index, D3D10_EFFECT_SHADER_DESC *desc)
5807 {
5808 FIXME("iface %p, index %u, desc %p stub!\n", iface, index, desc);
5809
5810 return E_NOTIMPL;
5811 }
5812
5813 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetVertexShader(
5814 ID3D10EffectShaderVariable *iface, UINT index, ID3D10VertexShader **shader)
5815 {
5816 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
5817
5818 TRACE("iface %p, index %u, shader %p.\n", iface, index, shader);
5819
5820 if (v->type->element_count)
5821 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
5822
5823 if (v->type->basetype != D3D10_SVT_VERTEXSHADER)
5824 {
5825 WARN("Shader is not a vertex shader.\n");
5826 return E_FAIL;
5827 }
5828
5829 if ((*shader = v->u.shader.shader.vs))
5830 ID3D10VertexShader_AddRef(*shader);
5831
5832 return S_OK;
5833 }
5834
5835 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetGeometryShader(
5836 ID3D10EffectShaderVariable *iface, UINT index, ID3D10GeometryShader **shader)
5837 {
5838 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
5839
5840 TRACE("iface %p, index %u, shader %p.\n", iface, index, shader);
5841
5842 if (v->type->element_count)
5843 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
5844
5845 if (v->type->basetype != D3D10_SVT_GEOMETRYSHADER)
5846 {
5847 WARN("Shader is not a geometry shader.\n");
5848 return E_FAIL;
5849 }
5850
5851 if ((*shader = v->u.shader.shader.gs))
5852 ID3D10GeometryShader_AddRef(*shader);
5853
5854 return S_OK;
5855 }
5856
5857 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetPixelShader(
5858 ID3D10EffectShaderVariable *iface, UINT index, ID3D10PixelShader **shader)
5859 {
5860 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
5861
5862 TRACE("iface %p, index %u, shader %p.\n", iface, index, shader);
5863
5864 if (v->type->element_count)
5865 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
5866
5867 if (v->type->basetype != D3D10_SVT_PIXELSHADER)
5868 {
5869 WARN("Shader is not a pixel shader.\n");
5870 return E_FAIL;
5871 }
5872
5873 if ((*shader = v->u.shader.shader.ps))
5874 ID3D10PixelShader_AddRef(*shader);
5875
5876 return S_OK;
5877 }
5878
5879 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetInputSignatureElementDesc(
5880 ID3D10EffectShaderVariable *iface, UINT shader_index, UINT element_index,
5881 D3D10_SIGNATURE_PARAMETER_DESC *desc)
5882 {
5883 struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
5884 struct d3d10_effect_shader_variable *s;
5885 D3D10_SIGNATURE_PARAMETER_DESC *d;
5886
5887 TRACE("iface %p, shader_index %u, element_index %u, desc %p\n",
5888 iface, shader_index, element_index, desc);
5889
5890 if (!iface->lpVtbl->IsValid(iface))
5891 {
5892 WARN("Null variable specified\n");
5893 return E_FAIL;
5894 }
5895
5896 /* Check shader_index, this crashes on W7/DX10 */
5897 if (shader_index >= This->effect->used_shader_count)
5898 {
5899 WARN("This should crash on W7/DX10!\n");
5900 return E_FAIL;
5901 }
5902
5903 s = &This->effect->used_shaders[shader_index]->u.shader;
5904 if (!s->input_signature.signature)
5905 {
5906 WARN("No shader signature\n");
5907 return D3DERR_INVALIDCALL;
5908 }
5909
5910 /* Check desc for NULL, this crashes on W7/DX10 */
5911 if (!desc)
5912 {
5913 WARN("This should crash on W7/DX10!\n");
5914 return E_FAIL;
5915 }
5916
5917 if (element_index >= s->input_signature.element_count)
5918 {
5919 WARN("Invalid element index specified\n");
5920 return E_INVALIDARG;
5921 }
5922
5923 d = &s->input_signature.elements[element_index];
5924 desc->SemanticName = d->SemanticName;
5925 desc->SemanticIndex = d->SemanticIndex;
5926 desc->SystemValueType = d->SystemValueType;
5927 desc->ComponentType = d->ComponentType;
5928 desc->Register = d->Register;
5929 desc->ReadWriteMask = d->ReadWriteMask;
5930 desc->Mask = d->Mask;
5931
5932 return S_OK;
5933 }
5934
5935 static HRESULT STDMETHODCALLTYPE d3d10_effect_shader_variable_GetOutputSignatureElementDesc(
5936 ID3D10EffectShaderVariable *iface, UINT shader_index, UINT element_index,
5937 D3D10_SIGNATURE_PARAMETER_DESC *desc)
5938 {
5939 struct d3d10_effect_variable *This = (struct d3d10_effect_variable *)iface;
5940 struct d3d10_effect_shader_variable *s;
5941 D3D10_SIGNATURE_PARAMETER_DESC *d;
5942
5943 TRACE("iface %p, shader_index %u, element_index %u, desc %p\n",
5944 iface, shader_index, element_index, desc);
5945
5946 if (!iface->lpVtbl->IsValid(iface))
5947 {
5948 WARN("Null variable specified\n");
5949 return E_FAIL;
5950 }
5951
5952 /* Check shader_index, this crashes on W7/DX10 */
5953 if (shader_index >= This->effect->used_shader_count)
5954 {
5955 WARN("This should crash on W7/DX10!\n");
5956 return E_FAIL;
5957 }
5958
5959 s = &This->effect->used_shaders[shader_index]->u.shader;
5960 if (!s->output_signature.signature)
5961 {
5962 WARN("No shader signature\n");
5963 return D3DERR_INVALIDCALL;
5964 }
5965
5966 /* Check desc for NULL, this crashes on W7/DX10 */
5967 if (!desc)
5968 {
5969 WARN("This should crash on W7/DX10!\n");
5970 return E_FAIL;
5971 }
5972
5973 if (element_index >= s->output_signature.element_count)
5974 {
5975 WARN("Invalid element index specified\n");
5976 return E_INVALIDARG;
5977 }
5978
5979 d = &s->output_signature.elements[element_index];
5980 desc->SemanticName = d->SemanticName;
5981 desc->SemanticIndex = d->SemanticIndex;
5982 desc->SystemValueType = d->SystemValueType;
5983 desc->ComponentType = d->ComponentType;
5984 desc->Register = d->Register;
5985 desc->ReadWriteMask = d->ReadWriteMask;
5986 desc->Mask = d->Mask;
5987
5988 return S_OK;
5989 }
5990
5991
5992 static const struct ID3D10EffectShaderVariableVtbl d3d10_effect_shader_variable_vtbl =
5993 {
5994 /* ID3D10EffectVariable methods */
5995 d3d10_effect_shader_variable_IsValid,
5996 d3d10_effect_shader_variable_GetType,
5997 d3d10_effect_shader_variable_GetDesc,
5998 d3d10_effect_shader_variable_GetAnnotationByIndex,
5999 d3d10_effect_shader_variable_GetAnnotationByName,
6000 d3d10_effect_shader_variable_GetMemberByIndex,
6001 d3d10_effect_shader_variable_GetMemberByName,
6002 d3d10_effect_shader_variable_GetMemberBySemantic,
6003 d3d10_effect_shader_variable_GetElement,
6004 d3d10_effect_shader_variable_GetParentConstantBuffer,
6005 d3d10_effect_shader_variable_AsScalar,
6006 d3d10_effect_shader_variable_AsVector,
6007 d3d10_effect_shader_variable_AsMatrix,
6008 d3d10_effect_shader_variable_AsString,
6009 d3d10_effect_shader_variable_AsShaderResource,
6010 d3d10_effect_shader_variable_AsRenderTargetView,
6011 d3d10_effect_shader_variable_AsDepthStencilView,
6012 d3d10_effect_shader_variable_AsConstantBuffer,
6013 d3d10_effect_shader_variable_AsShader,
6014 d3d10_effect_shader_variable_AsBlend,
6015 d3d10_effect_shader_variable_AsDepthStencil,
6016 d3d10_effect_shader_variable_AsRasterizer,
6017 d3d10_effect_shader_variable_AsSampler,
6018 d3d10_effect_shader_variable_SetRawValue,
6019 d3d10_effect_shader_variable_GetRawValue,
6020 /* ID3D10EffectShaderVariable methods */
6021 d3d10_effect_shader_variable_GetShaderDesc,
6022 d3d10_effect_shader_variable_GetVertexShader,
6023 d3d10_effect_shader_variable_GetGeometryShader,
6024 d3d10_effect_shader_variable_GetPixelShader,
6025 d3d10_effect_shader_variable_GetInputSignatureElementDesc,
6026 d3d10_effect_shader_variable_GetOutputSignatureElementDesc,
6027 };
6028
6029 /* ID3D10EffectVariable methods */
6030
6031 static BOOL STDMETHODCALLTYPE d3d10_effect_blend_variable_IsValid(ID3D10EffectBlendVariable *iface)
6032 {
6033 TRACE("iface %p\n", iface);
6034
6035 return (struct d3d10_effect_variable *)iface != &null_blend_variable;
6036 }
6037
6038 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetType(
6039 ID3D10EffectBlendVariable *iface)
6040 {
6041 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
6042 }
6043
6044 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetDesc(ID3D10EffectBlendVariable *iface,
6045 D3D10_EFFECT_VARIABLE_DESC *desc)
6046 {
6047 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
6048 }
6049
6050 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetAnnotationByIndex(
6051 ID3D10EffectBlendVariable *iface, UINT index)
6052 {
6053 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6054 }
6055
6056 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetAnnotationByName(
6057 ID3D10EffectBlendVariable *iface, const char *name)
6058 {
6059 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6060 }
6061
6062 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberByIndex(
6063 ID3D10EffectBlendVariable *iface, UINT index)
6064 {
6065 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6066 }
6067
6068 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberByName(
6069 ID3D10EffectBlendVariable *iface, const char *name)
6070 {
6071 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6072 }
6073
6074 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetMemberBySemantic(
6075 ID3D10EffectBlendVariable *iface, const char *semantic)
6076 {
6077 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6078 }
6079
6080 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetElement(
6081 ID3D10EffectBlendVariable *iface, UINT index)
6082 {
6083 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6084 }
6085
6086 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_blend_variable_GetParentConstantBuffer(
6087 ID3D10EffectBlendVariable *iface)
6088 {
6089 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6090 }
6091
6092 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsScalar(
6093 ID3D10EffectBlendVariable *iface)
6094 {
6095 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6096 }
6097
6098 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsVector(
6099 ID3D10EffectBlendVariable *iface)
6100 {
6101 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6102 }
6103
6104 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsMatrix(
6105 ID3D10EffectBlendVariable *iface)
6106 {
6107 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6108 }
6109
6110 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsString(
6111 ID3D10EffectBlendVariable *iface)
6112 {
6113 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6114 }
6115
6116 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsShaderResource(
6117 ID3D10EffectBlendVariable *iface)
6118 {
6119 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6120 }
6121
6122 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsRenderTargetView(
6123 ID3D10EffectBlendVariable *iface)
6124 {
6125 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6126 }
6127
6128 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsDepthStencilView(
6129 ID3D10EffectBlendVariable *iface)
6130 {
6131 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6132 }
6133
6134 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsConstantBuffer(
6135 ID3D10EffectBlendVariable *iface)
6136 {
6137 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6138 }
6139
6140 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsShader(
6141 ID3D10EffectBlendVariable *iface)
6142 {
6143 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6144 }
6145
6146 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsBlend(
6147 ID3D10EffectBlendVariable *iface)
6148 {
6149 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6150 }
6151
6152 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsDepthStencil(
6153 ID3D10EffectBlendVariable *iface)
6154 {
6155 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6156 }
6157
6158 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsRasterizer(
6159 ID3D10EffectBlendVariable *iface)
6160 {
6161 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6162 }
6163
6164 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_blend_variable_AsSampler(
6165 ID3D10EffectBlendVariable *iface)
6166 {
6167 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6168 }
6169
6170 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_SetRawValue(ID3D10EffectBlendVariable *iface,
6171 void *data, UINT offset, UINT count)
6172 {
6173 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6174 }
6175
6176 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetRawValue(ID3D10EffectBlendVariable *iface,
6177 void *data, UINT offset, UINT count)
6178 {
6179 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6180 }
6181
6182 /* ID3D10EffectBlendVariable methods */
6183
6184 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetBlendState(ID3D10EffectBlendVariable *iface,
6185 UINT index, ID3D10BlendState **blend_state)
6186 {
6187 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6188
6189 TRACE("iface %p, index %u, blend_state %p.\n", iface, index, blend_state);
6190
6191 if (v->type->element_count)
6192 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
6193 else if (index)
6194 return E_FAIL;
6195
6196 if (v->type->basetype != D3D10_SVT_BLEND)
6197 {
6198 WARN("Variable is not a blend state.\n");
6199 return E_FAIL;
6200 }
6201
6202 if ((*blend_state = v->u.state.object.blend))
6203 ID3D10BlendState_AddRef(*blend_state);
6204
6205 return S_OK;
6206 }
6207
6208 static HRESULT STDMETHODCALLTYPE d3d10_effect_blend_variable_GetBackingStore(ID3D10EffectBlendVariable *iface,
6209 UINT index, D3D10_BLEND_DESC *desc)
6210 {
6211 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6212
6213 TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
6214
6215 if (v->type->element_count)
6216 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
6217
6218 if (v->type->basetype != D3D10_SVT_BLEND)
6219 {
6220 WARN("Variable is not a blend state.\n");
6221 return E_FAIL;
6222 }
6223
6224 *desc = v->u.state.desc.blend;
6225
6226 return S_OK;
6227 }
6228
6229
6230 static const struct ID3D10EffectBlendVariableVtbl d3d10_effect_blend_variable_vtbl =
6231 {
6232 /* ID3D10EffectVariable methods */
6233 d3d10_effect_blend_variable_IsValid,
6234 d3d10_effect_blend_variable_GetType,
6235 d3d10_effect_blend_variable_GetDesc,
6236 d3d10_effect_blend_variable_GetAnnotationByIndex,
6237 d3d10_effect_blend_variable_GetAnnotationByName,
6238 d3d10_effect_blend_variable_GetMemberByIndex,
6239 d3d10_effect_blend_variable_GetMemberByName,
6240 d3d10_effect_blend_variable_GetMemberBySemantic,
6241 d3d10_effect_blend_variable_GetElement,
6242 d3d10_effect_blend_variable_GetParentConstantBuffer,
6243 d3d10_effect_blend_variable_AsScalar,
6244 d3d10_effect_blend_variable_AsVector,
6245 d3d10_effect_blend_variable_AsMatrix,
6246 d3d10_effect_blend_variable_AsString,
6247 d3d10_effect_blend_variable_AsShaderResource,
6248 d3d10_effect_blend_variable_AsRenderTargetView,
6249 d3d10_effect_blend_variable_AsDepthStencilView,
6250 d3d10_effect_blend_variable_AsConstantBuffer,
6251 d3d10_effect_blend_variable_AsShader,
6252 d3d10_effect_blend_variable_AsBlend,
6253 d3d10_effect_blend_variable_AsDepthStencil,
6254 d3d10_effect_blend_variable_AsRasterizer,
6255 d3d10_effect_blend_variable_AsSampler,
6256 d3d10_effect_blend_variable_SetRawValue,
6257 d3d10_effect_blend_variable_GetRawValue,
6258 /* ID3D10EffectBlendVariable methods */
6259 d3d10_effect_blend_variable_GetBlendState,
6260 d3d10_effect_blend_variable_GetBackingStore,
6261 };
6262
6263 /* ID3D10EffectVariable methods */
6264
6265 static BOOL STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_IsValid(ID3D10EffectDepthStencilVariable *iface)
6266 {
6267 TRACE("iface %p\n", iface);
6268
6269 return (struct d3d10_effect_variable *)iface != &null_depth_stencil_variable;
6270 }
6271
6272 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetType(
6273 ID3D10EffectDepthStencilVariable *iface)
6274 {
6275 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
6276 }
6277
6278 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetDesc(ID3D10EffectDepthStencilVariable *iface,
6279 D3D10_EFFECT_VARIABLE_DESC *desc)
6280 {
6281 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
6282 }
6283
6284 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetAnnotationByIndex(
6285 ID3D10EffectDepthStencilVariable *iface, UINT index)
6286 {
6287 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6288 }
6289
6290 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetAnnotationByName(
6291 ID3D10EffectDepthStencilVariable *iface, const char *name)
6292 {
6293 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6294 }
6295
6296 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberByIndex(
6297 ID3D10EffectDepthStencilVariable *iface, UINT index)
6298 {
6299 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6300 }
6301
6302 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberByName(
6303 ID3D10EffectDepthStencilVariable *iface, const char *name)
6304 {
6305 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6306 }
6307
6308 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetMemberBySemantic(
6309 ID3D10EffectDepthStencilVariable *iface, const char *semantic)
6310 {
6311 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6312 }
6313
6314 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetElement(
6315 ID3D10EffectDepthStencilVariable *iface, UINT index)
6316 {
6317 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6318 }
6319
6320 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetParentConstantBuffer(
6321 ID3D10EffectDepthStencilVariable *iface)
6322 {
6323 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6324 }
6325
6326 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsScalar(
6327 ID3D10EffectDepthStencilVariable *iface)
6328 {
6329 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6330 }
6331
6332 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsVector(
6333 ID3D10EffectDepthStencilVariable *iface)
6334 {
6335 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6336 }
6337
6338 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsMatrix(
6339 ID3D10EffectDepthStencilVariable *iface)
6340 {
6341 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6342 }
6343
6344 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsString(
6345 ID3D10EffectDepthStencilVariable *iface)
6346 {
6347 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6348 }
6349
6350 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsShaderResource(
6351 ID3D10EffectDepthStencilVariable *iface)
6352 {
6353 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6354 }
6355
6356 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsRenderTargetView(
6357 ID3D10EffectDepthStencilVariable *iface)
6358 {
6359 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6360 }
6361
6362 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsDepthStencilView(
6363 ID3D10EffectDepthStencilVariable *iface)
6364 {
6365 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6366 }
6367
6368 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsConstantBuffer(
6369 ID3D10EffectDepthStencilVariable *iface)
6370 {
6371 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6372 }
6373
6374 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsShader(
6375 ID3D10EffectDepthStencilVariable *iface)
6376 {
6377 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6378 }
6379
6380 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsBlend(
6381 ID3D10EffectDepthStencilVariable *iface)
6382 {
6383 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6384 }
6385
6386 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsDepthStencil(
6387 ID3D10EffectDepthStencilVariable *iface)
6388 {
6389 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6390 }
6391
6392 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsRasterizer(
6393 ID3D10EffectDepthStencilVariable *iface)
6394 {
6395 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6396 }
6397
6398 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_AsSampler(
6399 ID3D10EffectDepthStencilVariable *iface)
6400 {
6401 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6402 }
6403
6404 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_SetRawValue(ID3D10EffectDepthStencilVariable *iface,
6405 void *data, UINT offset, UINT count)
6406 {
6407 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6408 }
6409
6410 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetRawValue(ID3D10EffectDepthStencilVariable *iface,
6411 void *data, UINT offset, UINT count)
6412 {
6413 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6414 }
6415
6416 /* ID3D10EffectDepthStencilVariable methods */
6417
6418 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetDepthStencilState(ID3D10EffectDepthStencilVariable *iface,
6419 UINT index, ID3D10DepthStencilState **depth_stencil_state)
6420 {
6421 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6422
6423 TRACE("iface %p, index %u, depth_stencil_state %p.\n", iface, index, depth_stencil_state);
6424
6425 if (v->type->element_count)
6426 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
6427 else if (index)
6428 return E_FAIL;
6429
6430 if (v->type->basetype != D3D10_SVT_DEPTHSTENCIL)
6431 {
6432 WARN("Variable is not a depth stencil state.\n");
6433 return E_FAIL;
6434 }
6435
6436 if ((*depth_stencil_state = v->u.state.object.depth_stencil))
6437 ID3D10DepthStencilState_AddRef(*depth_stencil_state);
6438
6439 return S_OK;
6440 }
6441
6442 static HRESULT STDMETHODCALLTYPE d3d10_effect_depth_stencil_variable_GetBackingStore(ID3D10EffectDepthStencilVariable *iface,
6443 UINT index, D3D10_DEPTH_STENCIL_DESC *desc)
6444 {
6445 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6446
6447 TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
6448
6449 if (v->type->element_count)
6450 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
6451
6452 if (v->type->basetype != D3D10_SVT_DEPTHSTENCIL)
6453 {
6454 WARN("Variable is not a depth stencil state.\n");
6455 return E_FAIL;
6456 }
6457
6458 *desc = v->u.state.desc.depth_stencil;
6459
6460 return S_OK;
6461 }
6462
6463
6464 static const struct ID3D10EffectDepthStencilVariableVtbl d3d10_effect_depth_stencil_variable_vtbl =
6465 {
6466 /* ID3D10EffectVariable methods */
6467 d3d10_effect_depth_stencil_variable_IsValid,
6468 d3d10_effect_depth_stencil_variable_GetType,
6469 d3d10_effect_depth_stencil_variable_GetDesc,
6470 d3d10_effect_depth_stencil_variable_GetAnnotationByIndex,
6471 d3d10_effect_depth_stencil_variable_GetAnnotationByName,
6472 d3d10_effect_depth_stencil_variable_GetMemberByIndex,
6473 d3d10_effect_depth_stencil_variable_GetMemberByName,
6474 d3d10_effect_depth_stencil_variable_GetMemberBySemantic,
6475 d3d10_effect_depth_stencil_variable_GetElement,
6476 d3d10_effect_depth_stencil_variable_GetParentConstantBuffer,
6477 d3d10_effect_depth_stencil_variable_AsScalar,
6478 d3d10_effect_depth_stencil_variable_AsVector,
6479 d3d10_effect_depth_stencil_variable_AsMatrix,
6480 d3d10_effect_depth_stencil_variable_AsString,
6481 d3d10_effect_depth_stencil_variable_AsShaderResource,
6482 d3d10_effect_depth_stencil_variable_AsRenderTargetView,
6483 d3d10_effect_depth_stencil_variable_AsDepthStencilView,
6484 d3d10_effect_depth_stencil_variable_AsConstantBuffer,
6485 d3d10_effect_depth_stencil_variable_AsShader,
6486 d3d10_effect_depth_stencil_variable_AsBlend,
6487 d3d10_effect_depth_stencil_variable_AsDepthStencil,
6488 d3d10_effect_depth_stencil_variable_AsRasterizer,
6489 d3d10_effect_depth_stencil_variable_AsSampler,
6490 d3d10_effect_depth_stencil_variable_SetRawValue,
6491 d3d10_effect_depth_stencil_variable_GetRawValue,
6492 /* ID3D10EffectDepthStencilVariable methods */
6493 d3d10_effect_depth_stencil_variable_GetDepthStencilState,
6494 d3d10_effect_depth_stencil_variable_GetBackingStore,
6495 };
6496
6497 /* ID3D10EffectVariable methods */
6498
6499 static BOOL STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_IsValid(ID3D10EffectRasterizerVariable *iface)
6500 {
6501 TRACE("iface %p\n", iface);
6502
6503 return (struct d3d10_effect_variable *)iface != &null_rasterizer_variable;
6504 }
6505
6506 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetType(
6507 ID3D10EffectRasterizerVariable *iface)
6508 {
6509 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
6510 }
6511
6512 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetDesc(ID3D10EffectRasterizerVariable *iface,
6513 D3D10_EFFECT_VARIABLE_DESC *desc)
6514 {
6515 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
6516 }
6517
6518 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetAnnotationByIndex(
6519 ID3D10EffectRasterizerVariable *iface, UINT index)
6520 {
6521 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6522 }
6523
6524 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetAnnotationByName(
6525 ID3D10EffectRasterizerVariable *iface, const char *name)
6526 {
6527 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6528 }
6529
6530 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberByIndex(
6531 ID3D10EffectRasterizerVariable *iface, UINT index)
6532 {
6533 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6534 }
6535
6536 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberByName(
6537 ID3D10EffectRasterizerVariable *iface, const char *name)
6538 {
6539 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6540 }
6541
6542 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetMemberBySemantic(
6543 ID3D10EffectRasterizerVariable *iface, const char *semantic)
6544 {
6545 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6546 }
6547
6548 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetElement(
6549 ID3D10EffectRasterizerVariable *iface, UINT index)
6550 {
6551 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6552 }
6553
6554 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetParentConstantBuffer(
6555 ID3D10EffectRasterizerVariable *iface)
6556 {
6557 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6558 }
6559
6560 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsScalar(
6561 ID3D10EffectRasterizerVariable *iface)
6562 {
6563 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6564 }
6565
6566 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsVector(
6567 ID3D10EffectRasterizerVariable *iface)
6568 {
6569 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6570 }
6571
6572 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsMatrix(
6573 ID3D10EffectRasterizerVariable *iface)
6574 {
6575 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6576 }
6577
6578 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsString(
6579 ID3D10EffectRasterizerVariable *iface)
6580 {
6581 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6582 }
6583
6584 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsShaderResource(
6585 ID3D10EffectRasterizerVariable *iface)
6586 {
6587 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6588 }
6589
6590 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsRenderTargetView(
6591 ID3D10EffectRasterizerVariable *iface)
6592 {
6593 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6594 }
6595
6596 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsDepthStencilView(
6597 ID3D10EffectRasterizerVariable *iface)
6598 {
6599 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6600 }
6601
6602 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsConstantBuffer(
6603 ID3D10EffectRasterizerVariable *iface)
6604 {
6605 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6606 }
6607
6608 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsShader(
6609 ID3D10EffectRasterizerVariable *iface)
6610 {
6611 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6612 }
6613
6614 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsBlend(
6615 ID3D10EffectRasterizerVariable *iface)
6616 {
6617 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6618 }
6619
6620 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsDepthStencil(
6621 ID3D10EffectRasterizerVariable *iface)
6622 {
6623 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6624 }
6625
6626 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsRasterizer(
6627 ID3D10EffectRasterizerVariable *iface)
6628 {
6629 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6630 }
6631
6632 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_AsSampler(
6633 ID3D10EffectRasterizerVariable *iface)
6634 {
6635 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6636 }
6637
6638 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_SetRawValue(ID3D10EffectRasterizerVariable *iface,
6639 void *data, UINT offset, UINT count)
6640 {
6641 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6642 }
6643
6644 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetRawValue(ID3D10EffectRasterizerVariable *iface,
6645 void *data, UINT offset, UINT count)
6646 {
6647 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6648 }
6649
6650 /* ID3D10EffectRasterizerVariable methods */
6651
6652 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetRasterizerState(ID3D10EffectRasterizerVariable *iface,
6653 UINT index, ID3D10RasterizerState **rasterizer_state)
6654 {
6655 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6656
6657 TRACE("iface %p, index %u, rasterizer_state %p.\n", iface, index, rasterizer_state);
6658
6659 if (v->type->element_count)
6660 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
6661 else if (index)
6662 return E_FAIL;
6663
6664 if (v->type->basetype != D3D10_SVT_RASTERIZER)
6665 {
6666 WARN("Variable is not a rasterizer state.\n");
6667 return E_FAIL;
6668 }
6669
6670 if ((*rasterizer_state = v->u.state.object.rasterizer))
6671 ID3D10RasterizerState_AddRef(*rasterizer_state);
6672
6673 return S_OK;
6674 }
6675
6676 static HRESULT STDMETHODCALLTYPE d3d10_effect_rasterizer_variable_GetBackingStore(ID3D10EffectRasterizerVariable *iface,
6677 UINT index, D3D10_RASTERIZER_DESC *desc)
6678 {
6679 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6680
6681 TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
6682
6683 if (v->type->element_count)
6684 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
6685
6686 if (v->type->basetype != D3D10_SVT_RASTERIZER)
6687 {
6688 WARN("Variable is not a rasterizer state.\n");
6689 return E_FAIL;
6690 }
6691
6692 *desc = v->u.state.desc.rasterizer;
6693
6694 return S_OK;
6695 }
6696
6697
6698 static const struct ID3D10EffectRasterizerVariableVtbl d3d10_effect_rasterizer_variable_vtbl =
6699 {
6700 /* ID3D10EffectVariable methods */
6701 d3d10_effect_rasterizer_variable_IsValid,
6702 d3d10_effect_rasterizer_variable_GetType,
6703 d3d10_effect_rasterizer_variable_GetDesc,
6704 d3d10_effect_rasterizer_variable_GetAnnotationByIndex,
6705 d3d10_effect_rasterizer_variable_GetAnnotationByName,
6706 d3d10_effect_rasterizer_variable_GetMemberByIndex,
6707 d3d10_effect_rasterizer_variable_GetMemberByName,
6708 d3d10_effect_rasterizer_variable_GetMemberBySemantic,
6709 d3d10_effect_rasterizer_variable_GetElement,
6710 d3d10_effect_rasterizer_variable_GetParentConstantBuffer,
6711 d3d10_effect_rasterizer_variable_AsScalar,
6712 d3d10_effect_rasterizer_variable_AsVector,
6713 d3d10_effect_rasterizer_variable_AsMatrix,
6714 d3d10_effect_rasterizer_variable_AsString,
6715 d3d10_effect_rasterizer_variable_AsShaderResource,
6716 d3d10_effect_rasterizer_variable_AsRenderTargetView,
6717 d3d10_effect_rasterizer_variable_AsDepthStencilView,
6718 d3d10_effect_rasterizer_variable_AsConstantBuffer,
6719 d3d10_effect_rasterizer_variable_AsShader,
6720 d3d10_effect_rasterizer_variable_AsBlend,
6721 d3d10_effect_rasterizer_variable_AsDepthStencil,
6722 d3d10_effect_rasterizer_variable_AsRasterizer,
6723 d3d10_effect_rasterizer_variable_AsSampler,
6724 d3d10_effect_rasterizer_variable_SetRawValue,
6725 d3d10_effect_rasterizer_variable_GetRawValue,
6726 /* ID3D10EffectRasterizerVariable methods */
6727 d3d10_effect_rasterizer_variable_GetRasterizerState,
6728 d3d10_effect_rasterizer_variable_GetBackingStore,
6729 };
6730
6731 /* ID3D10EffectVariable methods */
6732
6733 static BOOL STDMETHODCALLTYPE d3d10_effect_sampler_variable_IsValid(ID3D10EffectSamplerVariable *iface)
6734 {
6735 TRACE("iface %p\n", iface);
6736
6737 return (struct d3d10_effect_variable *)iface != &null_sampler_variable;
6738 }
6739
6740 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetType(
6741 ID3D10EffectSamplerVariable *iface)
6742 {
6743 return d3d10_effect_variable_GetType((ID3D10EffectVariable *)iface);
6744 }
6745
6746 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetDesc(ID3D10EffectSamplerVariable *iface,
6747 D3D10_EFFECT_VARIABLE_DESC *desc)
6748 {
6749 return d3d10_effect_variable_GetDesc((ID3D10EffectVariable *)iface, desc);
6750 }
6751
6752 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetAnnotationByIndex(
6753 ID3D10EffectSamplerVariable *iface, UINT index)
6754 {
6755 return d3d10_effect_variable_GetAnnotationByIndex((ID3D10EffectVariable *)iface, index);
6756 }
6757
6758 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetAnnotationByName(
6759 ID3D10EffectSamplerVariable *iface, const char *name)
6760 {
6761 return d3d10_effect_variable_GetAnnotationByName((ID3D10EffectVariable *)iface, name);
6762 }
6763
6764 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberByIndex(
6765 ID3D10EffectSamplerVariable *iface, UINT index)
6766 {
6767 return d3d10_effect_variable_GetMemberByIndex((ID3D10EffectVariable *)iface, index);
6768 }
6769
6770 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberByName(
6771 ID3D10EffectSamplerVariable *iface, const char *name)
6772 {
6773 return d3d10_effect_variable_GetMemberByName((ID3D10EffectVariable *)iface, name);
6774 }
6775
6776 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetMemberBySemantic(
6777 ID3D10EffectSamplerVariable *iface, const char *semantic)
6778 {
6779 return d3d10_effect_variable_GetMemberBySemantic((ID3D10EffectVariable *)iface, semantic);
6780 }
6781
6782 static struct ID3D10EffectVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetElement(
6783 ID3D10EffectSamplerVariable *iface, UINT index)
6784 {
6785 return d3d10_effect_variable_GetElement((ID3D10EffectVariable *)iface, index);
6786 }
6787
6788 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetParentConstantBuffer(
6789 ID3D10EffectSamplerVariable *iface)
6790 {
6791 return d3d10_effect_variable_GetParentConstantBuffer((ID3D10EffectVariable *)iface);
6792 }
6793
6794 static struct ID3D10EffectScalarVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsScalar(
6795 ID3D10EffectSamplerVariable *iface)
6796 {
6797 return d3d10_effect_variable_AsScalar((ID3D10EffectVariable *)iface);
6798 }
6799
6800 static struct ID3D10EffectVectorVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsVector(
6801 ID3D10EffectSamplerVariable *iface)
6802 {
6803 return d3d10_effect_variable_AsVector((ID3D10EffectVariable *)iface);
6804 }
6805
6806 static struct ID3D10EffectMatrixVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsMatrix(
6807 ID3D10EffectSamplerVariable *iface)
6808 {
6809 return d3d10_effect_variable_AsMatrix((ID3D10EffectVariable *)iface);
6810 }
6811
6812 static struct ID3D10EffectStringVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsString(
6813 ID3D10EffectSamplerVariable *iface)
6814 {
6815 return d3d10_effect_variable_AsString((ID3D10EffectVariable *)iface);
6816 }
6817
6818 static struct ID3D10EffectShaderResourceVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsShaderResource(
6819 ID3D10EffectSamplerVariable *iface)
6820 {
6821 return d3d10_effect_variable_AsShaderResource((ID3D10EffectVariable *)iface);
6822 }
6823
6824 static struct ID3D10EffectRenderTargetViewVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsRenderTargetView(
6825 ID3D10EffectSamplerVariable *iface)
6826 {
6827 return d3d10_effect_variable_AsRenderTargetView((ID3D10EffectVariable *)iface);
6828 }
6829
6830 static struct ID3D10EffectDepthStencilViewVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsDepthStencilView(
6831 ID3D10EffectSamplerVariable *iface)
6832 {
6833 return d3d10_effect_variable_AsDepthStencilView((ID3D10EffectVariable *)iface);
6834 }
6835
6836 static struct ID3D10EffectConstantBuffer * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsConstantBuffer(
6837 ID3D10EffectSamplerVariable *iface)
6838 {
6839 return d3d10_effect_variable_AsConstantBuffer((ID3D10EffectVariable *)iface);
6840 }
6841
6842 static struct ID3D10EffectShaderVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsShader(
6843 ID3D10EffectSamplerVariable *iface)
6844 {
6845 return d3d10_effect_variable_AsShader((ID3D10EffectVariable *)iface);
6846 }
6847
6848 static struct ID3D10EffectBlendVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsBlend(
6849 ID3D10EffectSamplerVariable *iface)
6850 {
6851 return d3d10_effect_variable_AsBlend((ID3D10EffectVariable *)iface);
6852 }
6853
6854 static struct ID3D10EffectDepthStencilVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsDepthStencil(
6855 ID3D10EffectSamplerVariable *iface)
6856 {
6857 return d3d10_effect_variable_AsDepthStencil((ID3D10EffectVariable *)iface);
6858 }
6859
6860 static struct ID3D10EffectRasterizerVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsRasterizer(
6861 ID3D10EffectSamplerVariable *iface)
6862 {
6863 return d3d10_effect_variable_AsRasterizer((ID3D10EffectVariable *)iface);
6864 }
6865
6866 static struct ID3D10EffectSamplerVariable * STDMETHODCALLTYPE d3d10_effect_sampler_variable_AsSampler(
6867 ID3D10EffectSamplerVariable *iface)
6868 {
6869 return d3d10_effect_variable_AsSampler((ID3D10EffectVariable *)iface);
6870 }
6871
6872 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_SetRawValue(ID3D10EffectSamplerVariable *iface,
6873 void *data, UINT offset, UINT count)
6874 {
6875 return d3d10_effect_variable_SetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6876 }
6877
6878 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetRawValue(ID3D10EffectSamplerVariable *iface,
6879 void *data, UINT offset, UINT count)
6880 {
6881 return d3d10_effect_variable_GetRawValue((ID3D10EffectVariable *)iface, data, offset, count);
6882 }
6883
6884 /* ID3D10EffectSamplerVariable methods */
6885
6886 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetSampler(ID3D10EffectSamplerVariable *iface,
6887 UINT index, ID3D10SamplerState **sampler)
6888 {
6889 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6890
6891 TRACE("iface %p, index %u, sampler %p.\n", iface, index, sampler);
6892
6893 if (v->type->element_count)
6894 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
6895 else if (index)
6896 return E_FAIL;
6897
6898 if (v->type->basetype != D3D10_SVT_SAMPLER)
6899 {
6900 WARN("Variable is not a sampler state.\n");
6901 return E_FAIL;
6902 }
6903
6904 if ((*sampler = v->u.state.object.sampler))
6905 ID3D10SamplerState_AddRef(*sampler);
6906
6907 return S_OK;
6908 }
6909
6910 static HRESULT STDMETHODCALLTYPE d3d10_effect_sampler_variable_GetBackingStore(ID3D10EffectSamplerVariable *iface,
6911 UINT index, D3D10_SAMPLER_DESC *desc)
6912 {
6913 struct d3d10_effect_variable *v = impl_from_ID3D10EffectVariable((ID3D10EffectVariable *)iface);
6914
6915 TRACE("iface %p, index %u, desc %p.\n", iface, index, desc);
6916
6917 if (v->type->element_count)
6918 v = impl_from_ID3D10EffectVariable(iface->lpVtbl->GetElement(iface, index));
6919
6920 if (v->type->basetype != D3D10_SVT_SAMPLER)
6921 {
6922 WARN("Variable is not a sampler state.\n");
6923 return E_FAIL;
6924 }
6925
6926 *desc = v->u.state.desc.sampler;
6927
6928 return S_OK;
6929 }
6930
6931
6932 static const struct ID3D10EffectSamplerVariableVtbl d3d10_effect_sampler_variable_vtbl =
6933 {
6934 /* ID3D10EffectVariable methods */
6935 d3d10_effect_sampler_variable_IsValid,
6936 d3d10_effect_sampler_variable_GetType,
6937 d3d10_effect_sampler_variable_GetDesc,
6938 d3d10_effect_sampler_variable_GetAnnotationByIndex,
6939 d3d10_effect_sampler_variable_GetAnnotationByName,
6940 d3d10_effect_sampler_variable_GetMemberByIndex,
6941 d3d10_effect_sampler_variable_GetMemberByName,
6942 d3d10_effect_sampler_variable_GetMemberBySemantic,
6943 d3d10_effect_sampler_variable_GetElement,
6944 d3d10_effect_sampler_variable_GetParentConstantBuffer,
6945 d3d10_effect_sampler_variable_AsScalar,
6946 d3d10_effect_sampler_variable_AsVector,
6947 d3d10_effect_sampler_variable_AsMatrix,
6948 d3d10_effect_sampler_variable_AsString,
6949 d3d10_effect_sampler_variable_AsShaderResource,
6950 d3d10_effect_sampler_variable_AsRenderTargetView,
6951 d3d10_effect_sampler_variable_AsDepthStencilView,
6952 d3d10_effect_sampler_variable_AsConstantBuffer,
6953 d3d10_effect_sampler_variable_AsShader,
6954 d3d10_effect_sampler_variable_AsBlend,
6955 d3d10_effect_sampler_variable_AsDepthStencil,
6956 d3d10_effect_sampler_variable_AsRasterizer,
6957 d3d10_effect_sampler_variable_AsSampler,
6958 d3d10_effect_sampler_variable_SetRawValue,
6959 d3d10_effect_sampler_variable_GetRawValue,
6960 /* ID3D10EffectSamplerVariable methods */
6961 d3d10_effect_sampler_variable_GetSampler,
6962 d3d10_effect_sampler_variable_GetBackingStore,
6963 };
6964
6965 /* ID3D10EffectType methods */
6966
6967 static inline struct d3d10_effect_type *impl_from_ID3D10EffectType(ID3D10EffectType *iface)
6968 {
6969 return CONTAINING_RECORD(iface, struct d3d10_effect_type, ID3D10EffectType_iface);
6970 }
6971
6972 static BOOL STDMETHODCALLTYPE d3d10_effect_type_IsValid(ID3D10EffectType *iface)
6973 {
6974 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6975
6976 TRACE("iface %p\n", iface);
6977
6978 return This != &null_type;
6979 }
6980
6981 static HRESULT STDMETHODCALLTYPE d3d10_effect_type_GetDesc(ID3D10EffectType *iface, D3D10_EFFECT_TYPE_DESC *desc)
6982 {
6983 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
6984
6985 TRACE("iface %p, desc %p\n", iface, desc);
6986
6987 if (This == &null_type)
6988 {
6989 WARN("Null type specified\n");
6990 return E_FAIL;
6991 }
6992
6993 if (!desc)
6994 {
6995 WARN("Invalid argument specified\n");
6996 return E_INVALIDARG;
6997 }
6998
6999 desc->TypeName = This->name;
7000 desc->Class = This->type_class;
7001 desc->Type = This->basetype;
7002 desc->Elements = This->element_count;
7003 desc->Members = This->member_count;
7004 desc->Rows = This->row_count;
7005 desc->Columns = This->column_count;
7006 desc->PackedSize = This->size_packed;
7007 desc->UnpackedSize = This->size_unpacked;
7008 desc->Stride = This->stride;
7009
7010 return S_OK;
7011 }
7012
7013 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByIndex(ID3D10EffectType *iface,
7014 UINT index)
7015 {
7016 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
7017 struct d3d10_effect_type *t;
7018
7019 TRACE("iface %p, index %u\n", iface, index);
7020
7021 if (index >= This->member_count)
7022 {
7023 WARN("Invalid index specified\n");
7024 return &null_type.ID3D10EffectType_iface;
7025 }
7026
7027 t = (&This->members[index])->type;
7028
7029 TRACE("Returning member %p, %s\n", t, debugstr_a(t->name));
7030
7031 return &t->ID3D10EffectType_iface;
7032 }
7033
7034 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeByName(ID3D10EffectType *iface,
7035 const char *name)
7036 {
7037 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
7038 unsigned int i;
7039
7040 TRACE("iface %p, name %s\n", iface, debugstr_a(name));
7041
7042 if (!name)
7043 {
7044 WARN("Invalid name specified\n");
7045 return &null_type.ID3D10EffectType_iface;
7046 }
7047
7048 for (i = 0; i < This->member_count; ++i)
7049 {
7050 struct d3d10_effect_type_member *typem = &This->members[i];
7051
7052 if (typem->name && !strcmp(typem->name, name))
7053 {
7054 TRACE("Returning type %p.\n", typem->type);
7055 return &typem->type->ID3D10EffectType_iface;
7056 }
7057 }
7058
7059 WARN("Invalid name specified\n");
7060
7061 return &null_type.ID3D10EffectType_iface;
7062 }
7063
7064 static struct ID3D10EffectType * STDMETHODCALLTYPE d3d10_effect_type_GetMemberTypeBySemantic(ID3D10EffectType *iface,
7065 const char *semantic)
7066 {
7067 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
7068 unsigned int i;
7069
7070 TRACE("iface %p, semantic %s\n", iface, debugstr_a(semantic));
7071
7072 if (!semantic)
7073 {
7074 WARN("Invalid semantic specified\n");
7075 return &null_type.ID3D10EffectType_iface;
7076 }
7077
7078 for (i = 0; i < This->member_count; ++i)
7079 {
7080 struct d3d10_effect_type_member *typem = &This->members[i];
7081
7082 if (typem->semantic && !strcmp(typem->semantic, semantic))
7083 {
7084 TRACE("Returning type %p.\n", typem->type);
7085 return &typem->type->ID3D10EffectType_iface;
7086 }
7087 }
7088
7089 WARN("Invalid semantic specified\n");
7090
7091 return &null_type.ID3D10EffectType_iface;
7092 }
7093
7094 static const char * STDMETHODCALLTYPE d3d10_effect_type_GetMemberName(ID3D10EffectType *iface, UINT index)
7095 {
7096 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
7097 struct d3d10_effect_type_member *typem;
7098
7099 TRACE("iface %p, index %u\n", iface, index);
7100
7101 if (index >= This->member_count)
7102 {
7103 WARN("Invalid index specified\n");
7104 return NULL;
7105 }
7106
7107 typem = &This->members[index];
7108
7109 TRACE("Returning name %s\n", debugstr_a(typem->name));
7110
7111 return typem->name;
7112 }
7113
7114 static const char * STDMETHODCALLTYPE d3d10_effect_type_GetMemberSemantic(ID3D10EffectType *iface, UINT index)
7115 {
7116 struct d3d10_effect_type *This = impl_from_ID3D10EffectType(iface);
7117 struct d3d10_effect_type_member *typem;
7118
7119 TRACE("iface %p, index %u\n", iface, index);
7120
7121 if (index >= This->member_count)
7122 {
7123 WARN("Invalid index specified\n");
7124 return NULL;
7125 }
7126
7127 typem = &This->members[index];
7128
7129 TRACE("Returning semantic %s\n", debugstr_a(typem->semantic));
7130
7131 return typem->semantic;
7132 }
7133
7134 static const struct ID3D10EffectTypeVtbl d3d10_effect_type_vtbl =
7135 {
7136 /* ID3D10EffectType */
7137 d3d10_effect_type_IsValid,
7138 d3d10_effect_type_GetDesc,
7139 d3d10_effect_type_GetMemberTypeByIndex,
7140 d3d10_effect_type_GetMemberTypeByName,
7141 d3d10_effect_type_GetMemberTypeBySemantic,
7142 d3d10_effect_type_GetMemberName,
7143 d3d10_effect_type_GetMemberSemantic,
7144 };
Windows API implementation