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