1 /*
2 * IDirect3DVertexDeclaration8 implementation
3 *
4 * Copyright 2007 Henri Verbeet
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 /* IDirect3DVertexDeclaration8 is internal to our implementation.
22 * It's not visible in the API. */
23
24 #include "config.h"
25 #include "d3d8_private.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
28
debug_d3dvsdt_type(D3DVSDT_TYPE d3dvsdt_type)29 static const char *debug_d3dvsdt_type(D3DVSDT_TYPE d3dvsdt_type)
30 {
31 switch (d3dvsdt_type)
32 {
33 #define D3DVSDT_TYPE_TO_STR(u) case u: return #u
34 D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT1);
35 D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT2);
36 D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT3);
37 D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT4);
38 D3DVSDT_TYPE_TO_STR(D3DVSDT_D3DCOLOR);
39 D3DVSDT_TYPE_TO_STR(D3DVSDT_UBYTE4);
40 D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT2);
41 D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT4);
42 #undef D3DVSDT_TYPE_TO_STR
43 default:
44 FIXME("Unrecognized D3DVSDT_TYPE %#x\n", d3dvsdt_type);
45 return "unrecognized";
46 }
47 }
48
debug_d3dvsde_register(D3DVSDE_REGISTER d3dvsde_register)49 static const char *debug_d3dvsde_register(D3DVSDE_REGISTER d3dvsde_register)
50 {
51 switch (d3dvsde_register)
52 {
53 #define D3DVSDE_REGISTER_TO_STR(u) case u: return #u
54 D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION);
55 D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDWEIGHT);
56 D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDINDICES);
57 D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL);
58 D3DVSDE_REGISTER_TO_STR(D3DVSDE_PSIZE);
59 D3DVSDE_REGISTER_TO_STR(D3DVSDE_DIFFUSE);
60 D3DVSDE_REGISTER_TO_STR(D3DVSDE_SPECULAR);
61 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD0);
62 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD1);
63 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD2);
64 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD3);
65 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD4);
66 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD5);
67 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD6);
68 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD7);
69 D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION2);
70 D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL2);
71 #undef D3DVSDE_REGISTER_TO_STR
72 default:
73 FIXME("Unrecognized D3DVSDE_REGISTER %#x\n", d3dvsde_register);
74 return "unrecognized";
75 }
76 }
77
parse_token(const DWORD * pToken)78 size_t parse_token(const DWORD* pToken)
79 {
80 const DWORD token = *pToken;
81 size_t tokenlen = 1;
82
83 switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */
84 case D3DVSD_TOKEN_NOP:
85 TRACE(" 0x%08x NOP()\n", token);
86 break;
87
88 case D3DVSD_TOKEN_STREAM:
89 if (token & D3DVSD_STREAMTESSMASK)
90 {
91 TRACE(" 0x%08x STREAM_TESS()\n", token);
92 } else {
93 TRACE(" 0x%08x STREAM(%u)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
94 }
95 break;
96
97 case D3DVSD_TOKEN_STREAMDATA:
98 if (token & 0x10000000)
99 {
100 TRACE(" 0x%08x SKIP(%u)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
101 } else {
102 DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
103 DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
104 TRACE(" 0x%08x REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
105 }
106 break;
107
108 case D3DVSD_TOKEN_TESSELLATOR:
109 if (token & 0x10000000)
110 {
111 DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
112 DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
113 TRACE(" 0x%08x TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
114 } else {
115 DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
116 DWORD regout = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
117 DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT);
118 TRACE(" 0x%08x TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin),
119 debug_d3dvsde_register(regout), debug_d3dvsdt_type(type));
120 }
121 break;
122
123 case D3DVSD_TOKEN_CONSTMEM:
124 {
125 DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
126 tokenlen = (4 * count) + 1;
127 }
128 break;
129
130 case D3DVSD_TOKEN_EXT:
131 {
132 DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
133 DWORD extinfo = ((token & D3DVSD_EXTINFOMASK) >> D3DVSD_EXTINFOSHIFT);
134 TRACE(" 0x%08x EXT(%u, %u)\n", token, count, extinfo);
135 /* todo ... print extension */
136 tokenlen = count + 1;
137 }
138 break;
139
140 case D3DVSD_TOKEN_END:
141 TRACE(" 0x%08x END()\n", token);
142 break;
143
144 default:
145 TRACE(" 0x%08x UNKNOWN\n", token);
146 /* arg error */
147 }
148
149 return tokenlen;
150 }
151
load_local_constants(const DWORD * d3d8_elements,struct wined3d_shader * wined3d_vertex_shader)152 void load_local_constants(const DWORD *d3d8_elements, struct wined3d_shader *wined3d_vertex_shader)
153 {
154 const DWORD *token = d3d8_elements;
155
156 while (*token != D3DVSD_END())
157 {
158 if (((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) == D3DVSD_TOKEN_CONSTMEM)
159 {
160 DWORD count = ((*token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
161 DWORD constant_idx = ((*token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
162 HRESULT hr;
163
164 if (TRACE_ON(d3d8))
165 {
166 DWORD i;
167 for (i = 0; i < count; ++i)
168 {
169 TRACE("c[%u] = (%8f, %8f, %8f, %8f)\n",
170 constant_idx,
171 *(const float *)(token + i * 4 + 1),
172 *(const float *)(token + i * 4 + 2),
173 *(const float *)(token + i * 4 + 3),
174 *(const float *)(token + i * 4 + 4));
175 }
176 }
177 hr = wined3d_shader_set_local_constants_float(wined3d_vertex_shader,
178 constant_idx, (const float *)token + 1, count);
179 if (FAILED(hr)) ERR("Failed setting shader constants\n");
180 }
181
182 token += parse_token(token);
183 }
184 }
185
186 /* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
187 static const size_t wined3d_type_sizes[] =
188 {
189 /*WINED3DDECLTYPE_FLOAT1*/ 1 * sizeof(float),
190 /*WINED3DDECLTYPE_FLOAT2*/ 2 * sizeof(float),
191 /*WINED3DDECLTYPE_FLOAT3*/ 3 * sizeof(float),
192 /*WINED3DDECLTYPE_FLOAT4*/ 4 * sizeof(float),
193 /*WINED3DDECLTYPE_D3DCOLOR*/ 4 * sizeof(BYTE),
194 /*WINED3DDECLTYPE_UBYTE4*/ 4 * sizeof(BYTE),
195 /*WINED3DDECLTYPE_SHORT2*/ 2 * sizeof(short int),
196 /*WINED3DDECLTYPE_SHORT4*/ 4 * sizeof(short int),
197 /*WINED3DDECLTYPE_UBYTE4N*/ 4 * sizeof(BYTE),
198 /*WINED3DDECLTYPE_SHORT2N*/ 2 * sizeof(short int),
199 /*WINED3DDECLTYPE_SHORT4N*/ 4 * sizeof(short int),
200 /*WINED3DDECLTYPE_USHORT2N*/ 2 * sizeof(short int),
201 /*WINED3DDECLTYPE_USHORT4N*/ 4 * sizeof(short int),
202 /*WINED3DDECLTYPE_UDEC3*/ 3 * sizeof(short int),
203 /*WINED3DDECLTYPE_DEC3N*/ 3 * sizeof(short int),
204 /*WINED3DDECLTYPE_FLOAT16_2*/ 2 * sizeof(short int),
205 /*WINED3DDECLTYPE_FLOAT16_4*/ 4 * sizeof(short int)
206 };
207
208 static const enum wined3d_format_id wined3d_format_lookup[] =
209 {
210 /*WINED3DDECLTYPE_FLOAT1*/ WINED3DFMT_R32_FLOAT,
211 /*WINED3DDECLTYPE_FLOAT2*/ WINED3DFMT_R32G32_FLOAT,
212 /*WINED3DDECLTYPE_FLOAT3*/ WINED3DFMT_R32G32B32_FLOAT,
213 /*WINED3DDECLTYPE_FLOAT4*/ WINED3DFMT_R32G32B32A32_FLOAT,
214 /*WINED3DDECLTYPE_D3DCOLOR*/ WINED3DFMT_B8G8R8A8_UNORM,
215 /*WINED3DDECLTYPE_UBYTE4*/ WINED3DFMT_R8G8B8A8_UINT,
216 /*WINED3DDECLTYPE_SHORT2*/ WINED3DFMT_R16G16_SINT,
217 /*WINED3DDECLTYPE_SHORT4*/ WINED3DFMT_R16G16B16A16_SINT,
218 /*WINED3DDECLTYPE_UBYTE4N*/ WINED3DFMT_R8G8B8A8_UNORM,
219 /*WINED3DDECLTYPE_SHORT2N*/ WINED3DFMT_R16G16_SNORM,
220 /*WINED3DDECLTYPE_SHORT4N*/ WINED3DFMT_R16G16B16A16_SNORM,
221 /*WINED3DDECLTYPE_USHORT2N*/ WINED3DFMT_R16G16_UNORM,
222 /*WINED3DDECLTYPE_USHORT4N*/ WINED3DFMT_R16G16B16A16_UNORM,
223 /*WINED3DDECLTYPE_UDEC3*/ WINED3DFMT_R10G10B10X2_UINT,
224 /*WINED3DDECLTYPE_DEC3N*/ WINED3DFMT_R10G10B10X2_SNORM,
225 /*WINED3DDECLTYPE_FLOAT16_2*/ WINED3DFMT_R16G16_FLOAT,
226 /*WINED3DDECLTYPE_FLOAT16_4*/ WINED3DFMT_R16G16B16A16_FLOAT,
227 };
228
229 static const struct
230 {
231 BYTE usage;
232 BYTE usage_idx;
233 }
234 wined3d_usage_lookup[] =
235 {
236 /* D3DVSDE_POSITION */ {WINED3D_DECL_USAGE_POSITION, 0},
237 /* D3DVSDE_BLENDWEIGHT */ {WINED3D_DECL_USAGE_BLEND_WEIGHT, 0},
238 /* D3DVSDE_BLENDINDICES */ {WINED3D_DECL_USAGE_BLEND_INDICES, 0},
239 /* D3DVSDE_NORMAL */ {WINED3D_DECL_USAGE_NORMAL, 0},
240 /* D3DVSDE_PSIZE */ {WINED3D_DECL_USAGE_PSIZE, 0},
241 /* D3DVSDE_DIFFUSE */ {WINED3D_DECL_USAGE_COLOR, 0},
242 /* D3DVSDE_SPECULAR */ {WINED3D_DECL_USAGE_COLOR, 1},
243 /* D3DVSDE_TEXCOORD0 */ {WINED3D_DECL_USAGE_TEXCOORD, 0},
244 /* D3DVSDE_TEXCOORD1 */ {WINED3D_DECL_USAGE_TEXCOORD, 1},
245 /* D3DVSDE_TEXCOORD2 */ {WINED3D_DECL_USAGE_TEXCOORD, 2},
246 /* D3DVSDE_TEXCOORD3 */ {WINED3D_DECL_USAGE_TEXCOORD, 3},
247 /* D3DVSDE_TEXCOORD4 */ {WINED3D_DECL_USAGE_TEXCOORD, 4},
248 /* D3DVSDE_TEXCOORD5 */ {WINED3D_DECL_USAGE_TEXCOORD, 5},
249 /* D3DVSDE_TEXCOORD6 */ {WINED3D_DECL_USAGE_TEXCOORD, 6},
250 /* D3DVSDE_TEXCOORD7 */ {WINED3D_DECL_USAGE_TEXCOORD, 7},
251 /* D3DVSDE_POSITION2 */ {WINED3D_DECL_USAGE_POSITION, 1},
252 /* D3DVSDE_NORMAL2 */ {WINED3D_DECL_USAGE_NORMAL, 1},
253 };
254
255 /* TODO: find out where rhw (or positionT) is for declaration8 */
convert_to_wined3d_declaration(const DWORD * d3d8_elements,DWORD * d3d8_elements_size,struct wined3d_vertex_element ** wined3d_elements)256 static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3d8_elements_size,
257 struct wined3d_vertex_element **wined3d_elements)
258 {
259 struct wined3d_vertex_element *element;
260 const DWORD *token = d3d8_elements;
261 D3DVSD_TOKENTYPE token_type;
262 unsigned int element_count = 0;
263 WORD stream = 0;
264 int offset = 0;
265
266 TRACE("d3d8_elements %p, d3d8_elements_size %p, wined3d_elements %p\n", d3d8_elements, d3d8_elements_size, wined3d_elements);
267
268 /* 128 should be enough for anyone... */
269 *wined3d_elements = heap_alloc_zero(128 * sizeof(**wined3d_elements));
270 while (D3DVSD_END() != *token)
271 {
272 token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
273
274 if (token_type == D3DVSD_TOKEN_STREAM && !(*token & D3DVSD_STREAMTESSMASK))
275 {
276 stream = ((*token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT);
277 offset = 0;
278 } else if (token_type == D3DVSD_TOKEN_STREAMDATA && !(*token & D3DVSD_DATALOADTYPEMASK)) {
279 DWORD type = ((*token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
280 DWORD reg = ((*token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
281
282 TRACE("Adding element %d:\n", element_count);
283
284 element = *wined3d_elements + element_count++;
285 element->format = wined3d_format_lookup[type];
286 element->input_slot = stream;
287 element->offset = offset;
288 element->output_slot = reg;
289 element->input_slot_class = WINED3D_INPUT_PER_VERTEX_DATA;
290 element->instance_data_step_rate = 0;
291 element->method = WINED3D_DECL_METHOD_DEFAULT;
292 element->usage = wined3d_usage_lookup[reg].usage;
293 element->usage_idx = wined3d_usage_lookup[reg].usage_idx;
294
295 offset += wined3d_type_sizes[type];
296 } else if (token_type == D3DVSD_TOKEN_STREAMDATA && (*token & D3DVSD_DATALOADTYPEMASK)) {
297 TRACE(" 0x%08x SKIP(%u)\n", token_type, ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
298 offset += sizeof(DWORD) * ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
299 }
300
301 if (element_count >= 127) {
302 ERR("More than 127 elements?\n");
303 break;
304 }
305
306 token += parse_token(token);
307 }
308
309 *d3d8_elements_size = (++token - d3d8_elements) * sizeof(DWORD);
310
311 return element_count;
312 }
313
d3d8_vertexdeclaration_wined3d_object_destroyed(void * parent)314 static void STDMETHODCALLTYPE d3d8_vertexdeclaration_wined3d_object_destroyed(void *parent)
315 {
316 struct d3d8_vertex_declaration *declaration = parent;
317 heap_free(declaration->elements);
318 heap_free(declaration);
319 }
320
d3d8_vertex_declaration_destroy(struct d3d8_vertex_declaration * declaration)321 void d3d8_vertex_declaration_destroy(struct d3d8_vertex_declaration *declaration)
322 {
323 TRACE("declaration %p.\n", declaration);
324
325 wined3d_mutex_lock();
326 wined3d_vertex_declaration_decref(declaration->wined3d_vertex_declaration);
327 wined3d_mutex_unlock();
328 }
329
330 static const struct wined3d_parent_ops d3d8_vertexdeclaration_wined3d_parent_ops =
331 {
332 d3d8_vertexdeclaration_wined3d_object_destroyed,
333 };
334
d3d8_vertex_declaration_init(struct d3d8_vertex_declaration * declaration,struct d3d8_device * device,const DWORD * elements,DWORD shader_handle)335 HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration,
336 struct d3d8_device *device, const DWORD *elements, DWORD shader_handle)
337 {
338 struct wined3d_vertex_element *wined3d_elements;
339 UINT wined3d_element_count;
340 HRESULT hr;
341
342 declaration->shader_handle = shader_handle;
343
344 wined3d_element_count = convert_to_wined3d_declaration(elements, &declaration->elements_size, &wined3d_elements);
345 if (!(declaration->elements = heap_alloc(declaration->elements_size)))
346 {
347 ERR("Failed to allocate vertex declaration elements memory.\n");
348 heap_free(wined3d_elements);
349 return E_OUTOFMEMORY;
350 }
351
352 memcpy(declaration->elements, elements, declaration->elements_size);
353
354 wined3d_mutex_lock();
355 hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count,
356 declaration, &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
357 wined3d_mutex_unlock();
358 heap_free(wined3d_elements);
359 if (FAILED(hr))
360 {
361 WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
362 heap_free(declaration->elements);
363 return hr;
364 }
365
366 return D3D_OK;
367 }
368
d3d8_vertex_declaration_init_fvf(struct d3d8_vertex_declaration * declaration,struct d3d8_device * device,DWORD fvf)369 HRESULT d3d8_vertex_declaration_init_fvf(struct d3d8_vertex_declaration *declaration,
370 struct d3d8_device *device, DWORD fvf)
371 {
372 HRESULT hr;
373
374 declaration->elements = NULL;
375 declaration->elements_size = 0;
376 declaration->shader_handle = fvf;
377
378 hr = wined3d_vertex_declaration_create_from_fvf(device->wined3d_device, fvf, declaration,
379 &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
380 if (FAILED(hr))
381 {
382 WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
383 return hr;
384 }
385
386 return D3D_OK;
387 }
388