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