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