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