VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/vertexdeclaration.c@ 48345

Last change on this file since 48345 was 48345, checked in by vboxsync, 11 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette