VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d8/vertexdeclaration.c@ 16477

Last change on this file since 16477 was 16477, checked in by vboxsync, 16 years ago

LGPL disclaimer by filemuncher
  • Property svn:eol-style set to native
File size: 13.6 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 * Sun 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, Sun 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/* IUnknown */
39static HRESULT WINAPI IDirect3DVertexDeclaration8Impl_QueryInterface(IDirect3DVertexDeclaration8 *iface, REFIID riid, void **obj_ptr)
40{
41 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), obj_ptr);
42
43 if (IsEqualGUID(riid, &IID_IUnknown)
44 || IsEqualGUID(riid, &IID_IDirect3DVertexDeclaration8))
45 {
46 IUnknown_AddRef(iface);
47 *obj_ptr = iface;
48 return S_OK;
49 }
50
51 *obj_ptr = NULL;
52 return E_NOINTERFACE;
53}
54
55static ULONG WINAPI IDirect3DVertexDeclaration8Impl_AddRef(IDirect3DVertexDeclaration8 *iface)
56{
57 IDirect3DVertexDeclaration8Impl *This = (IDirect3DVertexDeclaration8Impl *)iface;
58
59 ULONG ref_count = InterlockedIncrement(&This->ref_count);
60 TRACE("(%p) : AddRef increasing to %d\n", This, ref_count);
61
62 return ref_count;
63}
64
65static ULONG WINAPI IDirect3DVertexDeclaration8Impl_Release(IDirect3DVertexDeclaration8 *iface)
66{
67 IDirect3DVertexDeclaration8Impl *This = (IDirect3DVertexDeclaration8Impl *)iface;
68
69 ULONG ref_count = InterlockedDecrement(&This->ref_count);
70 TRACE("(%p) : Releasing to %d\n", This, ref_count);
71
72 if (!ref_count) {
73 IWineD3DVertexDeclaration_Release(This->wined3d_vertex_declaration);
74 HeapFree(GetProcessHeap(), 0, This->elements);
75 HeapFree(GetProcessHeap(), 0, This);
76 }
77
78 return ref_count;
79}
80
81static const char *debug_d3dvsdt_type(D3DVSDT_TYPE d3dvsdt_type)
82{
83 switch (d3dvsdt_type)
84 {
85#define D3DVSDT_TYPE_TO_STR(u) case u: return #u
86 D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT1);
87 D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT2);
88 D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT3);
89 D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT4);
90 D3DVSDT_TYPE_TO_STR(D3DVSDT_D3DCOLOR);
91 D3DVSDT_TYPE_TO_STR(D3DVSDT_UBYTE4);
92 D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT2);
93 D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT4);
94#undef D3DVSDT_TYPE_TO_STR
95 default:
96 FIXME("Unrecognized D3DVSDT_TYPE %#x\n", d3dvsdt_type);
97 return "unrecognized";
98 }
99}
100
101static const char *debug_d3dvsde_register(D3DVSDE_REGISTER d3dvsde_register)
102{
103 switch (d3dvsde_register)
104 {
105#define D3DVSDE_REGISTER_TO_STR(u) case u: return #u
106 D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION);
107 D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDWEIGHT);
108 D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDINDICES);
109 D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL);
110 D3DVSDE_REGISTER_TO_STR(D3DVSDE_PSIZE);
111 D3DVSDE_REGISTER_TO_STR(D3DVSDE_DIFFUSE);
112 D3DVSDE_REGISTER_TO_STR(D3DVSDE_SPECULAR);
113 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD0);
114 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD1);
115 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD2);
116 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD3);
117 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD4);
118 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD5);
119 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD6);
120 D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD7);
121 D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION2);
122 D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL2);
123#undef D3DVSDE_REGISTER_TO_STR
124 default:
125 FIXME("Unrecognized D3DVSDE_REGISTER %#x\n", d3dvsde_register);
126 return "unrecognized";
127 }
128}
129
130size_t parse_token(const DWORD* pToken)
131{
132 const DWORD token = *pToken;
133 size_t tokenlen = 1;
134
135 switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */
136 case D3DVSD_TOKEN_NOP:
137 TRACE(" 0x%08x NOP()\n", token);
138 break;
139
140 case D3DVSD_TOKEN_STREAM:
141 if (token & D3DVSD_STREAMTESSMASK)
142 {
143 TRACE(" 0x%08x STREAM_TESS()\n", token);
144 } else {
145 TRACE(" 0x%08x STREAM(%u)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
146 }
147 break;
148
149 case D3DVSD_TOKEN_STREAMDATA:
150 if (token & 0x10000000)
151 {
152 TRACE(" 0x%08x SKIP(%u)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
153 } else {
154 DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
155 DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
156 TRACE(" 0x%08x REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
157 }
158 break;
159
160 case D3DVSD_TOKEN_TESSELLATOR:
161 if (token & 0x10000000)
162 {
163 DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
164 DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
165 TRACE(" 0x%08x TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
166 } else {
167 DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
168 DWORD regout = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
169 DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT);
170 TRACE(" 0x%08x TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin),
171 debug_d3dvsde_register(regout), debug_d3dvsdt_type(type));
172 }
173 break;
174
175 case D3DVSD_TOKEN_CONSTMEM:
176 {
177 DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
178 tokenlen = (4 * count) + 1;
179 }
180 break;
181
182 case D3DVSD_TOKEN_EXT:
183 {
184 DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
185 DWORD extinfo = ((token & D3DVSD_EXTINFOMASK) >> D3DVSD_EXTINFOSHIFT);
186 TRACE(" 0x%08x EXT(%u, %u)\n", token, count, extinfo);
187 /* todo ... print extension */
188 tokenlen = count + 1;
189 }
190 break;
191
192 case D3DVSD_TOKEN_END:
193 TRACE(" 0x%08x END()\n", token);
194 break;
195
196 default:
197 TRACE(" 0x%08x UNKNOWN\n", token);
198 /* argg error */
199 }
200
201 return tokenlen;
202}
203
204void load_local_constants(const DWORD *d3d8_elements, IWineD3DVertexShader *wined3d_vertex_shader)
205{
206 const DWORD *token = d3d8_elements;
207
208 while (*token != D3DVSD_END())
209 {
210 if (((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) == D3DVSD_TOKEN_CONSTMEM)
211 {
212 DWORD count = ((*token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
213 DWORD constant_idx = ((*token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
214 HRESULT hr;
215
216 if (TRACE_ON(d3d8))
217 {
218 DWORD i;
219 for (i = 0; i < count; ++i)
220 {
221 TRACE("c[%u] = (%8f, %8f, %8f, %8f)\n",
222 constant_idx,
223 *(const float *)(token + i * 4 + 1),
224 *(const float *)(token + i * 4 + 2),
225 *(const float *)(token + i * 4 + 3),
226 *(const float *)(token + i * 4 + 4));
227 }
228 }
229 hr = IWineD3DVertexShader_SetLocalConstantsF(wined3d_vertex_shader, constant_idx, (const float *)token+1, count);
230 if (FAILED(hr)) ERR("Failed setting shader constants\n");
231 }
232
233 token += parse_token(token);
234 }
235}
236
237/* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
238static const size_t wined3d_type_sizes[WINED3DDECLTYPE_UNUSED] = {
239 /*WINED3DDECLTYPE_FLOAT1*/ 1 * sizeof(float),
240 /*WINED3DDECLTYPE_FLOAT2*/ 2 * sizeof(float),
241 /*WINED3DDECLTYPE_FLOAT3*/ 3 * sizeof(float),
242 /*WINED3DDECLTYPE_FLOAT4*/ 4 * sizeof(float),
243 /*WINED3DDECLTYPE_D3DCOLOR*/ 4 * sizeof(BYTE),
244 /*WINED3DDECLTYPE_UBYTE4*/ 4 * sizeof(BYTE),
245 /*WINED3DDECLTYPE_SHORT2*/ 2 * sizeof(short int),
246 /*WINED3DDECLTYPE_SHORT4*/ 4 * sizeof(short int),
247 /*WINED3DDECLTYPE_UBYTE4N*/ 4 * sizeof(BYTE),
248 /*WINED3DDECLTYPE_SHORT2N*/ 2 * sizeof(short int),
249 /*WINED3DDECLTYPE_SHORT4N*/ 4 * sizeof(short int),
250 /*WINED3DDECLTYPE_USHORT2N*/ 2 * sizeof(short int),
251 /*WINED3DDECLTYPE_USHORT4N*/ 4 * sizeof(short int),
252 /*WINED3DDECLTYPE_UDEC3*/ 3 * sizeof(short int),
253 /*WINED3DDECLTYPE_DEC3N*/ 3 * sizeof(short int),
254 /*WINED3DDECLTYPE_FLOAT16_2*/ 2 * sizeof(short int),
255 /*WINED3DDECLTYPE_FLOAT16_4*/ 4 * sizeof(short int)
256};
257
258typedef struct {
259 BYTE usage;
260 BYTE usage_idx;
261} wined3d_usage_t;
262
263static const wined3d_usage_t wined3d_usage_lookup[] = {
264 /*D3DVSDE_POSITION*/ {WINED3DDECLUSAGE_POSITION, 0},
265 /*D3DVSDE_BLENDWEIGHT*/ {WINED3DDECLUSAGE_BLENDWEIGHT, 0},
266 /*D3DVSDE_BLENDINDICES*/ {WINED3DDECLUSAGE_BLENDINDICES, 0},
267 /*D3DVSDE_NORMAL*/ {WINED3DDECLUSAGE_NORMAL, 0},
268 /*D3DVSDE_PSIZE*/ {WINED3DDECLUSAGE_PSIZE, 0},
269 /*D3DVSDE_DIFFUSE*/ {WINED3DDECLUSAGE_COLOR, 0},
270 /*D3DVSDE_SPECULAR*/ {WINED3DDECLUSAGE_COLOR, 1},
271 /*D3DVSDE_TEXCOORD0*/ {WINED3DDECLUSAGE_TEXCOORD, 0},
272 /*D3DVSDE_TEXCOORD1*/ {WINED3DDECLUSAGE_TEXCOORD, 1},
273 /*D3DVSDE_TEXCOORD2*/ {WINED3DDECLUSAGE_TEXCOORD, 2},
274 /*D3DVSDE_TEXCOORD3*/ {WINED3DDECLUSAGE_TEXCOORD, 3},
275 /*D3DVSDE_TEXCOORD4*/ {WINED3DDECLUSAGE_TEXCOORD, 4},
276 /*D3DVSDE_TEXCOORD5*/ {WINED3DDECLUSAGE_TEXCOORD, 5},
277 /*D3DVSDE_TEXCOORD6*/ {WINED3DDECLUSAGE_TEXCOORD, 6},
278 /*D3DVSDE_TEXCOORD7*/ {WINED3DDECLUSAGE_TEXCOORD, 7},
279 /*D3DVSDE_POSITION2*/ {WINED3DDECLUSAGE_POSITION, 1},
280 /*D3DVSDE_NORMAL2*/ {WINED3DDECLUSAGE_NORMAL, 1},
281};
282
283/* TODO: find out where rhw (or positionT) is for declaration8 */
284UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3d8_elements_size, WINED3DVERTEXELEMENT **wined3d_elements)
285{
286 const DWORD *token = d3d8_elements;
287 WINED3DVERTEXELEMENT *element;
288 D3DVSD_TOKENTYPE token_type;
289 unsigned int element_count = 0;
290 DWORD stream = 0;
291 int offset = 0;
292
293 TRACE("d3d8_elements %p, wined3d_elements %p\n", d3d8_elements, wined3d_elements);
294
295 /* 128 should be enough for anyone... */
296 *wined3d_elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 128 * sizeof(WINED3DVERTEXELEMENT));
297 while (D3DVSD_END() != *token)
298 {
299 token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
300
301 if (token_type == D3DVSD_TOKEN_STREAM && !(*token & D3DVSD_STREAMTESSMASK))
302 {
303 stream = ((*token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT);
304 offset = 0;
305 } else if (token_type == D3DVSD_TOKEN_STREAMDATA && !(token_type & 0x10000000)) {
306 DWORD type = ((*token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
307 DWORD reg = ((*token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
308
309 TRACE("Adding element %d:\n", element_count);
310
311 element = *wined3d_elements + element_count++;
312 element->Stream = stream;
313 element->Method = WINED3DDECLMETHOD_DEFAULT;
314 element->Usage = wined3d_usage_lookup[reg].usage;
315 element->UsageIndex = wined3d_usage_lookup[reg].usage_idx;
316 element->Type = type;
317 element->Offset = offset;
318 element->Reg = reg;
319
320 offset += wined3d_type_sizes[type];
321 } else if (token_type == D3DVSD_TOKEN_STREAMDATA && (token_type & 0x10000000)) {
322 TRACE(" 0x%08x SKIP(%u)\n", token_type, ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
323 offset += sizeof(DWORD) * ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
324 }
325
326 if (element_count >= 127) {
327 ERR("More than 127 elements?\n");
328 break;
329 }
330
331 token += parse_token(token);
332 }
333
334 /* END */
335 element = *wined3d_elements + element_count++;
336 element->Stream = 0xFF;
337 element->Type = WINED3DDECLTYPE_UNUSED;
338
339 *d3d8_elements_size = (++token - d3d8_elements) * sizeof(DWORD);
340
341 return element_count;
342}
343
344const IDirect3DVertexDeclaration8Vtbl Direct3DVertexDeclaration8_Vtbl =
345{
346 IDirect3DVertexDeclaration8Impl_QueryInterface,
347 IDirect3DVertexDeclaration8Impl_AddRef,
348 IDirect3DVertexDeclaration8Impl_Release
349};
Note: See TracBrowser for help on using the repository browser.

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