?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Translate signal to trap when trap code is 0 on ARM.
[wine.git] / dlls / ddraw / utils.c
blobb0a028d4a57b7b68b2eea2eba511de368abcce84
1 /*
2 * DirectDraw helper functions
3 *
4 * Copyright (c) 1997-2000 Marcus Meissner
5 * Copyright (c) 1998 Lionel Ulmer
6 * Copyright (c) 2000 TransGaming Technologies Inc.
7 * Copyright (c) 2006 Stefan Dösinger
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include "ddraw_private.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
30
31 static void DDRAW_dump_pixelformat(const DDPIXELFORMAT *pf);
32
33 void ddrawformat_from_wined3dformat(DDPIXELFORMAT *DDPixelFormat, enum wined3d_format_id wined3d_format)
34 {
35 DWORD Size = DDPixelFormat->dwSize;
36
37 if(Size==0) return;
38
39 memset(DDPixelFormat, 0x00, Size);
40 DDPixelFormat->dwSize = Size;
41 switch (wined3d_format)
42 {
43 case WINED3DFMT_B8G8R8_UNORM:
44 DDPixelFormat->dwFlags = DDPF_RGB;
45 DDPixelFormat->dwFourCC = 0;
46 DDPixelFormat->u1.dwRGBBitCount = 24;
47 DDPixelFormat->u2.dwRBitMask = 0x00ff0000;
48 DDPixelFormat->u3.dwGBitMask = 0x0000ff00;
49 DDPixelFormat->u4.dwBBitMask = 0x000000ff;
50 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
51 break;
52
53 case WINED3DFMT_B8G8R8A8_UNORM:
54 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
55 DDPixelFormat->dwFourCC = 0;
56 DDPixelFormat->u1.dwRGBBitCount = 32;
57 DDPixelFormat->u2.dwRBitMask = 0x00ff0000;
58 DDPixelFormat->u3.dwGBitMask = 0x0000ff00;
59 DDPixelFormat->u4.dwBBitMask = 0x000000ff;
60 DDPixelFormat->u5.dwRGBAlphaBitMask = 0xff000000;
61 break;
62
63 case WINED3DFMT_B8G8R8X8_UNORM:
64 DDPixelFormat->dwFlags = DDPF_RGB;
65 DDPixelFormat->dwFourCC = 0;
66 DDPixelFormat->u1.dwRGBBitCount = 32;
67 DDPixelFormat->u2.dwRBitMask = 0x00ff0000;
68 DDPixelFormat->u3.dwGBitMask = 0x0000ff00;
69 DDPixelFormat->u4.dwBBitMask = 0x000000ff;
70 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
71 break;
72
73 case WINED3DFMT_R8G8B8X8_UNORM:
74 DDPixelFormat->dwFlags = DDPF_RGB;
75 DDPixelFormat->dwFourCC = 0;
76 DDPixelFormat->u1.dwRGBBitCount = 32;
77 DDPixelFormat->u2.dwRBitMask = 0x000000ff;
78 DDPixelFormat->u3.dwGBitMask = 0x0000ff00;
79 DDPixelFormat->u4.dwBBitMask = 0x00ff0000;
80 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
81 break;
82
83 case WINED3DFMT_B5G6R5_UNORM:
84 DDPixelFormat->dwFlags = DDPF_RGB;
85 DDPixelFormat->dwFourCC = 0;
86 DDPixelFormat->u1.dwRGBBitCount = 16;
87 DDPixelFormat->u2.dwRBitMask = 0xF800;
88 DDPixelFormat->u3.dwGBitMask = 0x07E0;
89 DDPixelFormat->u4.dwBBitMask = 0x001F;
90 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
91 break;
92
93 case WINED3DFMT_B5G5R5X1_UNORM:
94 DDPixelFormat->dwFlags = DDPF_RGB;
95 DDPixelFormat->dwFourCC = 0;
96 DDPixelFormat->u1.dwRGBBitCount = 16;
97 DDPixelFormat->u2.dwRBitMask = 0x7C00;
98 DDPixelFormat->u3.dwGBitMask = 0x03E0;
99 DDPixelFormat->u4.dwBBitMask = 0x001F;
100 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
101 break;
102
103 case WINED3DFMT_B5G5R5A1_UNORM:
104 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
105 DDPixelFormat->dwFourCC = 0;
106 DDPixelFormat->u1.dwRGBBitCount = 16;
107 DDPixelFormat->u2.dwRBitMask = 0x7C00;
108 DDPixelFormat->u3.dwGBitMask = 0x03E0;
109 DDPixelFormat->u4.dwBBitMask = 0x001F;
110 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x8000;
111 break;
112
113 case WINED3DFMT_B4G4R4A4_UNORM:
114 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
115 DDPixelFormat->dwFourCC = 0;
116 DDPixelFormat->u1.dwRGBBitCount = 16;
117 DDPixelFormat->u2.dwRBitMask = 0x0F00;
118 DDPixelFormat->u3.dwGBitMask = 0x00F0;
119 DDPixelFormat->u4.dwBBitMask = 0x000F;
120 DDPixelFormat->u5.dwRGBAlphaBitMask = 0xF000;
121 break;
122
123 case WINED3DFMT_B2G3R3_UNORM:
124 DDPixelFormat->dwFlags = DDPF_RGB;
125 DDPixelFormat->dwFourCC = 0;
126 DDPixelFormat->u1.dwRGBBitCount = 8;
127 DDPixelFormat->u2.dwRBitMask = 0xE0;
128 DDPixelFormat->u3.dwGBitMask = 0x1C;
129 DDPixelFormat->u4.dwBBitMask = 0x03;
130 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0;
131 break;
132
133 case WINED3DFMT_P8_UINT:
134 DDPixelFormat->dwFlags = DDPF_PALETTEINDEXED8 | DDPF_RGB;
135 DDPixelFormat->dwFourCC = 0;
136 DDPixelFormat->u1.dwRGBBitCount = 8;
137 DDPixelFormat->u2.dwRBitMask = 0x00;
138 DDPixelFormat->u3.dwGBitMask = 0x00;
139 DDPixelFormat->u4.dwBBitMask = 0x00;
140 break;
141
142 case WINED3DFMT_A8_UNORM:
143 DDPixelFormat->dwFlags = DDPF_ALPHA;
144 DDPixelFormat->dwFourCC = 0;
145 DDPixelFormat->u1.dwAlphaBitDepth = 8;
146 DDPixelFormat->u2.dwRBitMask = 0x0;
147 DDPixelFormat->u3.dwZBitMask = 0x0;
148 DDPixelFormat->u4.dwStencilBitMask = 0x0;
149 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0;
150 break;
151
152 case WINED3DFMT_B2G3R3A8_UNORM:
153 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
154 DDPixelFormat->dwFourCC = 0;
155 DDPixelFormat->u1.dwRGBBitCount = 16;
156 DDPixelFormat->u2.dwRBitMask = 0x00E0;
157 DDPixelFormat->u3.dwGBitMask = 0x001C;
158 DDPixelFormat->u4.dwBBitMask = 0x0003;
159 DDPixelFormat->u5.dwRGBAlphaBitMask = 0xFF00;
160 break;
161
162 case WINED3DFMT_B4G4R4X4_UNORM:
163 DDPixelFormat->dwFlags = DDPF_RGB;
164 DDPixelFormat->dwFourCC = 0;
165 DDPixelFormat->u1.dwRGBBitCount = 16;
166 DDPixelFormat->u2.dwRBitMask = 0x0F00;
167 DDPixelFormat->u3.dwGBitMask = 0x00F0;
168 DDPixelFormat->u4.dwBBitMask = 0x000F;
169 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
170 break;
171
172 /* How are Z buffer bit depth and Stencil buffer bit depth related?
173 */
174 case WINED3DFMT_D16_UNORM:
175 DDPixelFormat->dwFlags = DDPF_ZBUFFER;
176 DDPixelFormat->dwFourCC = 0;
177 DDPixelFormat->u1.dwZBufferBitDepth = 16;
178 DDPixelFormat->u2.dwStencilBitDepth = 0;
179 DDPixelFormat->u3.dwZBitMask = 0x0000FFFF;
180 DDPixelFormat->u4.dwStencilBitMask = 0x0;
181 DDPixelFormat->u5.dwRGBZBitMask = 0x00000000;
182 break;
183
184 case WINED3DFMT_D32_UNORM:
185 DDPixelFormat->dwFlags = DDPF_ZBUFFER;
186 DDPixelFormat->dwFourCC = 0;
187 DDPixelFormat->u1.dwZBufferBitDepth = 32;
188 DDPixelFormat->u2.dwStencilBitDepth = 0;
189 DDPixelFormat->u3.dwZBitMask = 0xFFFFFFFF;
190 DDPixelFormat->u4.dwStencilBitMask = 0x0;
191 DDPixelFormat->u5.dwRGBZBitMask = 0x00000000;
192 break;
193
194 case WINED3DFMT_S4X4_UINT_D24_UNORM:
195 DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER;
196 DDPixelFormat->dwFourCC = 0;
197 /* Should I set dwZBufferBitDepth to 32 here? */
198 DDPixelFormat->u1.dwZBufferBitDepth = 32;
199 DDPixelFormat->u2.dwStencilBitDepth = 4;
200 DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF;
201 DDPixelFormat->u4.dwStencilBitMask = 0x0F000000;
202 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
203 break;
204
205 case WINED3DFMT_D24_UNORM_S8_UINT:
206 DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER;
207 DDPixelFormat->dwFourCC = 0;
208 DDPixelFormat->u1.dwZBufferBitDepth = 32;
209 DDPixelFormat->u2.dwStencilBitDepth = 8;
210 DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF;
211 DDPixelFormat->u4.dwStencilBitMask = 0xFF000000;
212 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
213 break;
214
215 case WINED3DFMT_X8D24_UNORM:
216 DDPixelFormat->dwFlags = DDPF_ZBUFFER;
217 DDPixelFormat->dwFourCC = 0;
218 DDPixelFormat->u1.dwZBufferBitDepth = 32;
219 DDPixelFormat->u2.dwStencilBitDepth = 0;
220 DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF;
221 DDPixelFormat->u4.dwStencilBitMask = 0x00000000;
222 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
223 break;
224
225 case WINED3DFMT_S1_UINT_D15_UNORM:
226 DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER;
227 DDPixelFormat->dwFourCC = 0;
228 DDPixelFormat->u1.dwZBufferBitDepth = 16;
229 DDPixelFormat->u2.dwStencilBitDepth = 1;
230 DDPixelFormat->u3.dwZBitMask = 0x7fff;
231 DDPixelFormat->u4.dwStencilBitMask = 0x8000;
232 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
233 break;
234
235 case WINED3DFMT_UYVY:
236 case WINED3DFMT_YUY2:
237 DDPixelFormat->u1.dwYUVBitCount = 16;
238 DDPixelFormat->dwFlags = DDPF_FOURCC;
239 DDPixelFormat->dwFourCC = wined3d_format;
240 break;
241
242 case WINED3DFMT_YV12:
243 DDPixelFormat->u1.dwYUVBitCount = 12;
244 DDPixelFormat->dwFlags = DDPF_FOURCC;
245 DDPixelFormat->dwFourCC = wined3d_format;
246 break;
247
248 case WINED3DFMT_DXT1:
249 case WINED3DFMT_DXT2:
250 case WINED3DFMT_DXT3:
251 case WINED3DFMT_DXT4:
252 case WINED3DFMT_DXT5:
253 case WINED3DFMT_MULTI2_ARGB8:
254 case WINED3DFMT_G8R8_G8B8:
255 case WINED3DFMT_R8G8_B8G8:
256 DDPixelFormat->dwFlags = DDPF_FOURCC;
257 DDPixelFormat->dwFourCC = wined3d_format;
258 break;
259
260 /* Luminance */
261 case WINED3DFMT_L8_UNORM:
262 DDPixelFormat->dwFlags = DDPF_LUMINANCE;
263 DDPixelFormat->dwFourCC = 0;
264 DDPixelFormat->u1.dwLuminanceBitCount = 8;
265 DDPixelFormat->u2.dwLuminanceBitMask = 0xff;
266 DDPixelFormat->u3.dwBumpDvBitMask = 0x0;
267 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0;
268 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0;
269 break;
270
271 case WINED3DFMT_L4A4_UNORM:
272 DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE;
273 DDPixelFormat->dwFourCC = 0;
274 DDPixelFormat->u1.dwLuminanceBitCount = 4;
275 DDPixelFormat->u2.dwLuminanceBitMask = 0x0f;
276 DDPixelFormat->u3.dwBumpDvBitMask = 0x0;
277 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0;
278 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0xf0;
279 break;
280
281 case WINED3DFMT_L8A8_UNORM:
282 DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE;
283 DDPixelFormat->dwFourCC = 0;
284 DDPixelFormat->u1.dwLuminanceBitCount = 16;
285 DDPixelFormat->u2.dwLuminanceBitMask = 0x00ff;
286 DDPixelFormat->u3.dwBumpDvBitMask = 0x0;
287 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0;
288 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0xff00;
289 break;
290
291 /* Bump mapping */
292 case WINED3DFMT_R8G8_SNORM:
293 DDPixelFormat->dwFlags = DDPF_BUMPDUDV;
294 DDPixelFormat->dwFourCC = 0;
295 DDPixelFormat->u1.dwBumpBitCount = 16;
296 DDPixelFormat->u2.dwBumpDuBitMask = 0x000000ff;
297 DDPixelFormat->u3.dwBumpDvBitMask = 0x0000ff00;
298 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x00000000;
299 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000;
300 break;
301
302 case WINED3DFMT_R5G5_SNORM_L6_UNORM:
303 DDPixelFormat->dwFlags = DDPF_BUMPDUDV | DDPF_BUMPLUMINANCE;
304 DDPixelFormat->dwFourCC = 0;
305 DDPixelFormat->u1.dwBumpBitCount = 16;
306 DDPixelFormat->u2.dwBumpDuBitMask = 0x0000001f;
307 DDPixelFormat->u3.dwBumpDvBitMask = 0x000003e0;
308 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0000fc00;
309 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000;
310 break;
311
312 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
313 DDPixelFormat->dwFlags = DDPF_BUMPDUDV | DDPF_BUMPLUMINANCE;
314 DDPixelFormat->dwFourCC = 0;
315 DDPixelFormat->u1.dwBumpBitCount = 32;
316 DDPixelFormat->u2.dwBumpDuBitMask = 0x000000ff;
317 DDPixelFormat->u3.dwBumpDvBitMask = 0x0000ff00;
318 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x00ff0000;
319 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000;
320 break;
321
322 default:
323 FIXME("Unhandled wined3d format %#x.\n", wined3d_format);
324 break;
325 }
326
327 if(TRACE_ON(ddraw)) {
328 TRACE("Returning: ");
329 DDRAW_dump_pixelformat(DDPixelFormat);
330 }
331 }
332
333 enum wined3d_format_id wined3dformat_from_ddrawformat(const DDPIXELFORMAT *DDPixelFormat)
334 {
335 TRACE("Convert a DirectDraw Pixelformat to a WineD3D Pixelformat\n");
336 if(TRACE_ON(ddraw))
337 {
338 DDRAW_dump_pixelformat(DDPixelFormat);
339 }
340
341 if(DDPixelFormat->dwFlags & DDPF_PALETTEINDEXED8)
342 {
343 return WINED3DFMT_P8_UINT;
344 }
345 else if(DDPixelFormat->dwFlags & (DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2 | DDPF_PALETTEINDEXED4) )
346 {
347 FIXME("DDPF_PALETTEINDEXED1 to DDPF_PALETTEINDEXED4 are not supported by WineD3D (yet). Returning WINED3DFMT_P8\n");
348 return WINED3DFMT_P8_UINT;
349 }
350 else if(DDPixelFormat->dwFlags & DDPF_RGB)
351 {
352 switch(DDPixelFormat->u1.dwRGBBitCount)
353 {
354 case 8:
355 /* This is the only format that can match here */
356 return WINED3DFMT_B2G3R3_UNORM;
357
358 case 16:
359 /* Read the Color masks */
360 if( (DDPixelFormat->u2.dwRBitMask == 0xF800) &&
361 (DDPixelFormat->u3.dwGBitMask == 0x07E0) &&
362 (DDPixelFormat->u4.dwBBitMask == 0x001F) )
363 {
364 return WINED3DFMT_B5G6R5_UNORM;
365 }
366
367 if( (DDPixelFormat->u2.dwRBitMask == 0x7C00) &&
368 (DDPixelFormat->u3.dwGBitMask == 0x03E0) &&
369 (DDPixelFormat->u4.dwBBitMask == 0x001F) )
370 {
371 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
372 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0x8000))
373 return WINED3DFMT_B5G5R5A1_UNORM;
374 else
375 return WINED3DFMT_B5G5R5X1_UNORM;
376 }
377
378 if( (DDPixelFormat->u2.dwRBitMask == 0x0F00) &&
379 (DDPixelFormat->u3.dwGBitMask == 0x00F0) &&
380 (DDPixelFormat->u4.dwBBitMask == 0x000F) )
381 {
382 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
383 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xF000))
384 return WINED3DFMT_B4G4R4A4_UNORM;
385 else
386 return WINED3DFMT_B4G4R4X4_UNORM;
387 }
388
389 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
390 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xFF00) &&
391 (DDPixelFormat->u2.dwRBitMask == 0x00E0) &&
392 (DDPixelFormat->u3.dwGBitMask == 0x001C) &&
393 (DDPixelFormat->u4.dwBBitMask == 0x0003) )
394 {
395 return WINED3DFMT_B2G3R3A8_UNORM;
396 }
397 WARN("16 bit RGB Pixel format does not match.\n");
398 return WINED3DFMT_UNKNOWN;
399
400 case 24:
401 return WINED3DFMT_B8G8R8_UNORM;
402
403 case 32:
404 /* Read the Color masks */
405 if( (DDPixelFormat->u2.dwRBitMask == 0x00FF0000) &&
406 (DDPixelFormat->u3.dwGBitMask == 0x0000FF00) &&
407 (DDPixelFormat->u4.dwBBitMask == 0x000000FF) )
408 {
409 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
410 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xFF000000))
411 return WINED3DFMT_B8G8R8A8_UNORM;
412 else
413 return WINED3DFMT_B8G8R8X8_UNORM;
414
415 }
416 WARN("32 bit RGB pixel format does not match.\n");
417 return WINED3DFMT_UNKNOWN;
418
419 default:
420 WARN("Invalid dwRGBBitCount in Pixelformat structure.\n");
421 return WINED3DFMT_UNKNOWN;
422 }
423 }
424 else if( (DDPixelFormat->dwFlags & DDPF_ALPHA) )
425 {
426 /* Alpha only Pixelformat */
427 switch(DDPixelFormat->u1.dwAlphaBitDepth)
428 {
429 case 8:
430 return WINED3DFMT_A8_UNORM;
431
432 default:
433 WARN("Invalid AlphaBitDepth in Alpha-Only Pixelformat.\n");
434 return WINED3DFMT_UNKNOWN;
435 }
436 }
437 else if(DDPixelFormat->dwFlags & DDPF_LUMINANCE)
438 {
439 /* Luminance-only or luminance-alpha */
440 if(DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS)
441 {
442 /* Luminance with Alpha */
443 switch(DDPixelFormat->u1.dwLuminanceBitCount)
444 {
445 case 4:
446 if(DDPixelFormat->u1.dwAlphaBitDepth == 4)
447 return WINED3DFMT_L4A4_UNORM;
448 WARN("Unknown Alpha / Luminance bit depth combination.\n");
449 return WINED3DFMT_UNKNOWN;
450
451 case 6:
452 FIXME("A luminance Pixelformat shouldn't have 6 luminance bits. Returning D3DFMT_L6V5U5 for now.\n");
453 return WINED3DFMT_R5G5_SNORM_L6_UNORM;
454
455 case 8:
456 if(DDPixelFormat->u1.dwAlphaBitDepth == 8)
457 return WINED3DFMT_L8A8_UNORM;
458 WARN("Unknown Alpha / Lumincase bit depth combination.\n");
459 return WINED3DFMT_UNKNOWN;
460 }
461 }
462 else
463 {
464 /* Luminance-only */
465 switch(DDPixelFormat->u1.dwLuminanceBitCount)
466 {
467 case 6:
468 FIXME("A luminance Pixelformat shouldn't have 6 luminance bits. Returning D3DFMT_L6V5U5 for now.\n");
469 return WINED3DFMT_R5G5_SNORM_L6_UNORM;
470
471 case 8:
472 return WINED3DFMT_L8_UNORM;
473
474 default:
475 WARN("Unknown luminance-only bit depth 0x%x.\n", DDPixelFormat->u1.dwLuminanceBitCount);
476 return WINED3DFMT_UNKNOWN;
477 }
478 }
479 }
480 else if(DDPixelFormat->dwFlags & DDPF_ZBUFFER)
481 {
482 /* Z buffer */
483 if(DDPixelFormat->dwFlags & DDPF_STENCILBUFFER)
484 {
485 switch(DDPixelFormat->u1.dwZBufferBitDepth)
486 {
487 case 16:
488 if (DDPixelFormat->u2.dwStencilBitDepth == 1) return WINED3DFMT_S1_UINT_D15_UNORM;
489 WARN("Unknown depth stencil format: 16 z bits, %u stencil bits.\n",
490 DDPixelFormat->u2.dwStencilBitDepth);
491 return WINED3DFMT_UNKNOWN;
492
493 case 32:
494 if (DDPixelFormat->u2.dwStencilBitDepth == 8) return WINED3DFMT_D24_UNORM_S8_UINT;
495 else if (DDPixelFormat->u2.dwStencilBitDepth == 4) return WINED3DFMT_S4X4_UINT_D24_UNORM;
496 WARN("Unknown depth stencil format: 32 z bits, %u stencil bits.\n",
497 DDPixelFormat->u2.dwStencilBitDepth);
498 return WINED3DFMT_UNKNOWN;
499
500 default:
501 WARN("Unknown depth stencil format: %u z bits, %u stencil bits.\n",
502 DDPixelFormat->u1.dwZBufferBitDepth, DDPixelFormat->u2.dwStencilBitDepth);
503 return WINED3DFMT_UNKNOWN;
504 }
505 }
506 else
507 {
508 switch(DDPixelFormat->u1.dwZBufferBitDepth)
509 {
510 case 16:
511 return WINED3DFMT_D16_UNORM;
512
513 case 24:
514 return WINED3DFMT_X8D24_UNORM;
515
516 case 32:
517 if (DDPixelFormat->u3.dwZBitMask == 0x00FFFFFF) return WINED3DFMT_X8D24_UNORM;
518 else if (DDPixelFormat->u3.dwZBitMask == 0xFFFFFF00) return WINED3DFMT_X8D24_UNORM;
519 else if (DDPixelFormat->u3.dwZBitMask == 0xFFFFFFFF) return WINED3DFMT_D32_UNORM;
520 WARN("Unknown depth-only format: 32 z bits, mask 0x%08x\n",
521 DDPixelFormat->u3.dwZBitMask);
522 return WINED3DFMT_UNKNOWN;
523
524 default:
525 WARN("Unknown depth-only format: %u z bits, mask 0x%08x\n",
526 DDPixelFormat->u1.dwZBufferBitDepth, DDPixelFormat->u3.dwZBitMask);
527 return WINED3DFMT_UNKNOWN;
528 }
529 }
530 }
531 else if(DDPixelFormat->dwFlags & DDPF_FOURCC)
532 {
533 return DDPixelFormat->dwFourCC;
534 }
535 else if(DDPixelFormat->dwFlags & DDPF_BUMPDUDV)
536 {
537 if( (DDPixelFormat->u1.dwBumpBitCount == 16 ) &&
538 (DDPixelFormat->u2.dwBumpDuBitMask == 0x000000ff) &&
539 (DDPixelFormat->u3.dwBumpDvBitMask == 0x0000ff00) &&
540 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x00000000) )
541 {
542 return WINED3DFMT_R8G8_SNORM;
543 }
544 else if ( (DDPixelFormat->u1.dwBumpBitCount == 16 ) &&
545 (DDPixelFormat->u2.dwBumpDuBitMask == 0x0000001f) &&
546 (DDPixelFormat->u3.dwBumpDvBitMask == 0x000003e0) &&
547 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x0000fc00) )
548 {
549 return WINED3DFMT_R5G5_SNORM_L6_UNORM;
550 }
551 else if ( (DDPixelFormat->u1.dwBumpBitCount == 32 ) &&
552 (DDPixelFormat->u2.dwBumpDuBitMask == 0x000000ff) &&
553 (DDPixelFormat->u3.dwBumpDvBitMask == 0x0000ff00) &&
554 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x00ff0000) )
555 {
556 return WINED3DFMT_R8G8_SNORM_L8X8_UNORM;
557 }
558 }
559
560 WARN("Unknown Pixelformat.\n");
561 return WINED3DFMT_UNKNOWN;
562 }
563
564 unsigned int wined3dmapflags_from_ddrawmapflags(unsigned int flags)
565 {
566 static const unsigned int handled = DDLOCK_NOSYSLOCK
567 | DDLOCK_NOOVERWRITE
568 | DDLOCK_DISCARDCONTENTS
569 | DDLOCK_DONOTWAIT;
570 unsigned int wined3d_flags;
571
572 wined3d_flags = flags & handled;
573 if (!(flags & (DDLOCK_NOOVERWRITE | DDLOCK_DISCARDCONTENTS | DDLOCK_WRITEONLY)))
574 wined3d_flags |= WINED3D_MAP_READ;
575 if (!(flags & DDLOCK_READONLY))
576 wined3d_flags |= WINED3D_MAP_WRITE;
577 if (!(wined3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE)))
578 wined3d_flags |= WINED3D_MAP_READ | WINED3D_MAP_WRITE;
579 if (flags & DDLOCK_NODIRTYUPDATE)
580 wined3d_flags |= WINED3D_MAP_NO_DIRTY_UPDATE;
581 flags &= ~(handled | DDLOCK_WAIT | DDLOCK_READONLY | DDLOCK_WRITEONLY | DDLOCK_NODIRTYUPDATE);
582
583 if (flags)
584 FIXME("Unhandled flags %#x.\n", flags);
585
586 return wined3d_flags;
587 }
588
589 static float colour_to_float(DWORD colour, DWORD mask)
590 {
591 if (!mask)
592 return 0.0f;
593 return (float)(colour & mask) / (float)mask;
594 }
595
596 BOOL wined3d_colour_from_ddraw_colour(const DDPIXELFORMAT *pf, const struct ddraw_palette *palette,
597 DWORD colour, struct wined3d_color *wined3d_colour)
598 {
599 if (pf->dwFlags & DDPF_ALPHA)
600 {
601 DWORD size, mask;
602
603 size = pf->u1.dwAlphaBitDepth;
604 mask = size < 32 ? (1u << size) - 1 : ~0u;
605 wined3d_colour->r = 0.0f;
606 wined3d_colour->g = 0.0f;
607 wined3d_colour->b = 0.0f;
608 wined3d_colour->a = colour_to_float(colour, mask);
609 return TRUE;
610 }
611
612 if (pf->dwFlags & DDPF_FOURCC)
613 {
614 WARN("FourCC formats not supported.\n");
615 goto fail;
616 }
617
618 if (pf->dwFlags & DDPF_PALETTEINDEXED8)
619 {
620 PALETTEENTRY entry;
621
622 colour &= 0xff;
623 if (!palette || FAILED(wined3d_palette_get_entries(palette->wined3d_palette, 0, colour, 1, &entry)))
624 {
625 wined3d_colour->r = 0.0f;
626 wined3d_colour->g = 0.0f;
627 wined3d_colour->b = 0.0f;
628 }
629 else
630 {
631 wined3d_colour->r = entry.peRed / 255.0f;
632 wined3d_colour->g = entry.peGreen / 255.0f;
633 wined3d_colour->b = entry.peBlue / 255.0f;
634 }
635 wined3d_colour->a = colour / 255.0f;
636 return TRUE;
637 }
638
639 if (pf->dwFlags & DDPF_RGB)
640 {
641 wined3d_colour->r = colour_to_float(colour, pf->u2.dwRBitMask);
642 wined3d_colour->g = colour_to_float(colour, pf->u3.dwGBitMask);
643 wined3d_colour->b = colour_to_float(colour, pf->u4.dwBBitMask);
644 if (pf->dwFlags & DDPF_ALPHAPIXELS)
645 wined3d_colour->a = colour_to_float(colour, pf->u5.dwRGBAlphaBitMask);
646 else
647 wined3d_colour->a = 0.0f;
648 return TRUE;
649 }
650
651 if (pf->dwFlags & DDPF_ZBUFFER)
652 {
653 wined3d_colour->r = colour_to_float(colour, pf->u3.dwZBitMask);
654 if (pf->dwFlags & DDPF_STENCILBUFFER)
655 wined3d_colour->g = colour_to_float(colour, pf->u4.dwStencilBitMask);
656 else
657 wined3d_colour->g = 0.0f;
658 wined3d_colour->b = 0.0f;
659 wined3d_colour->a = 0.0f;
660 return TRUE;
661 }
662
663 FIXME("Unhandled pixel format.\n");
664 DDRAW_dump_pixelformat(pf);
665
666 fail:
667 wined3d_colour->r = 0.0f;
668 wined3d_colour->g = 0.0f;
669 wined3d_colour->b = 0.0f;
670 wined3d_colour->a = 0.0f;
671
672 return FALSE;
673 }
674
675 /*****************************************************************************
676 * Various dumping functions.
677 *
678 * They write the contents of a specific function to a TRACE.
679 *
680 *****************************************************************************/
681 static void
682 DDRAW_dump_DWORD(const void *in)
683 {
684 TRACE("%d\n", *((const DWORD *) in));
685 }
686 static void
687 DDRAW_dump_PTR(const void *in)
688 {
689 TRACE("%p\n", *((const void * const*) in));
690 }
691 static void
692 DDRAW_dump_DDCOLORKEY(const DDCOLORKEY *ddck)
693 {
694 TRACE("Low : 0x%08x - High : 0x%08x\n", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue);
695 }
696
697 static void DDRAW_dump_flags_nolf(DWORD flags, const struct flag_info *names, size_t num_names)
698 {
699 unsigned int i;
700
701 for (i=0; i < num_names; i++)
702 if ((flags & names[i].val) || /* standard flag value */
703 ((!flags) && (!names[i].val))) /* zero value only */
704 TRACE("%s ", names[i].name);
705 }
706
707 static void DDRAW_dump_flags(DWORD flags, const struct flag_info *names, size_t num_names)
708 {
709 DDRAW_dump_flags_nolf(flags, names, num_names);
710 TRACE("\n");
711 }
712
713 void DDRAW_dump_DDSCAPS2(const DDSCAPS2 *in)
714 {
715 static const struct flag_info flags[] =
716 {
717 FE(DDSCAPS_RESERVED1),
718 FE(DDSCAPS_ALPHA),
719 FE(DDSCAPS_BACKBUFFER),
720 FE(DDSCAPS_COMPLEX),
721 FE(DDSCAPS_FLIP),
722 FE(DDSCAPS_FRONTBUFFER),
723 FE(DDSCAPS_OFFSCREENPLAIN),
724 FE(DDSCAPS_OVERLAY),
725 FE(DDSCAPS_PALETTE),
726 FE(DDSCAPS_PRIMARYSURFACE),
727 FE(DDSCAPS_PRIMARYSURFACELEFT),
728 FE(DDSCAPS_SYSTEMMEMORY),
729 FE(DDSCAPS_TEXTURE),
730 FE(DDSCAPS_3DDEVICE),
731 FE(DDSCAPS_VIDEOMEMORY),
732 FE(DDSCAPS_VISIBLE),
733 FE(DDSCAPS_WRITEONLY),
734 FE(DDSCAPS_ZBUFFER),
735 FE(DDSCAPS_OWNDC),
736 FE(DDSCAPS_LIVEVIDEO),
737 FE(DDSCAPS_HWCODEC),
738 FE(DDSCAPS_MODEX),
739 FE(DDSCAPS_MIPMAP),
740 FE(DDSCAPS_RESERVED2),
741 FE(DDSCAPS_ALLOCONLOAD),
742 FE(DDSCAPS_VIDEOPORT),
743 FE(DDSCAPS_LOCALVIDMEM),
744 FE(DDSCAPS_NONLOCALVIDMEM),
745 FE(DDSCAPS_STANDARDVGAMODE),
746 FE(DDSCAPS_OPTIMIZED)
747 };
748 static const struct flag_info flags2[] =
749 {
750 FE(DDSCAPS2_HARDWAREDEINTERLACE),
751 FE(DDSCAPS2_HINTDYNAMIC),
752 FE(DDSCAPS2_HINTSTATIC),
753 FE(DDSCAPS2_TEXTUREMANAGE),
754 FE(DDSCAPS2_RESERVED1),
755 FE(DDSCAPS2_RESERVED2),
756 FE(DDSCAPS2_OPAQUE),
757 FE(DDSCAPS2_HINTANTIALIASING),
758 FE(DDSCAPS2_CUBEMAP),
759 FE(DDSCAPS2_CUBEMAP_POSITIVEX),
760 FE(DDSCAPS2_CUBEMAP_NEGATIVEX),
761 FE(DDSCAPS2_CUBEMAP_POSITIVEY),
762 FE(DDSCAPS2_CUBEMAP_NEGATIVEY),
763 FE(DDSCAPS2_CUBEMAP_POSITIVEZ),
764 FE(DDSCAPS2_CUBEMAP_NEGATIVEZ),
765 FE(DDSCAPS2_MIPMAPSUBLEVEL),
766 FE(DDSCAPS2_D3DTEXTUREMANAGE),
767 FE(DDSCAPS2_DONOTPERSIST),
768 FE(DDSCAPS2_STEREOSURFACELEFT)
769 };
770
771 DDRAW_dump_flags_nolf(in->dwCaps, flags, ARRAY_SIZE(flags));
772 DDRAW_dump_flags(in->dwCaps2, flags2, ARRAY_SIZE(flags2));
773 }
774
775 static void
776 DDRAW_dump_DDSCAPS(const DDSCAPS *in)
777 {
778 DDSCAPS2 in_bis;
779
780 in_bis.dwCaps = in->dwCaps;
781 in_bis.dwCaps2 = 0;
782 in_bis.dwCaps3 = 0;
783 in_bis.u1.dwCaps4 = 0;
784
785 DDRAW_dump_DDSCAPS2(&in_bis);
786 }
787
788 static void
789 DDRAW_dump_pixelformat_flag(DWORD flagmask)
790 {
791 static const struct flag_info flags[] =
792 {
793 FE(DDPF_ALPHAPIXELS),
794 FE(DDPF_ALPHA),
795 FE(DDPF_FOURCC),
796 FE(DDPF_PALETTEINDEXED4),
797 FE(DDPF_PALETTEINDEXEDTO8),
798 FE(DDPF_PALETTEINDEXED8),
799 FE(DDPF_RGB),
800 FE(DDPF_COMPRESSED),
801 FE(DDPF_RGBTOYUV),
802 FE(DDPF_YUV),
803 FE(DDPF_ZBUFFER),
804 FE(DDPF_PALETTEINDEXED1),
805 FE(DDPF_PALETTEINDEXED2),
806 FE(DDPF_ZPIXELS)
807 };
808
809 DDRAW_dump_flags_nolf(flagmask, flags, ARRAY_SIZE(flags));
810 }
811
812 static void DDRAW_dump_members(DWORD flags, const void *data, const struct member_info *mems, size_t num_mems)
813 {
814 unsigned int i;
815
816 for (i=0; i < num_mems; i++)
817 {
818 if (mems[i].val & flags)
819 {
820 TRACE(" - %s : ", mems[i].name);
821 mems[i].func((const char *)data + mems[i].offset);
822 }
823 }
824 }
825
826 static void
827 DDRAW_dump_pixelformat(const DDPIXELFORMAT *pf)
828 {
829 TRACE("( ");
830 DDRAW_dump_pixelformat_flag(pf->dwFlags);
831 if (pf->dwFlags & DDPF_FOURCC)
832 TRACE(", dwFourCC code '%c%c%c%c' (0x%08x) - %u bits per pixel",
833 (unsigned char)( pf->dwFourCC &0xff),
834 (unsigned char)((pf->dwFourCC>> 8)&0xff),
835 (unsigned char)((pf->dwFourCC>>16)&0xff),
836 (unsigned char)((pf->dwFourCC>>24)&0xff),
837 pf->dwFourCC,
838 pf->u1.dwYUVBitCount);
839 if (pf->dwFlags & DDPF_RGB)
840 {
841 TRACE(", RGB bits: %u, R 0x%08x G 0x%08x B 0x%08x",
842 pf->u1.dwRGBBitCount,
843 pf->u2.dwRBitMask,
844 pf->u3.dwGBitMask,
845 pf->u4.dwBBitMask);
846 if (pf->dwFlags & DDPF_ALPHAPIXELS)
847 TRACE(" A 0x%08x", pf->u5.dwRGBAlphaBitMask);
848 if (pf->dwFlags & DDPF_ZPIXELS)
849 TRACE(" Z 0x%08x", pf->u5.dwRGBZBitMask);
850 }
851 if (pf->dwFlags & DDPF_ZBUFFER)
852 TRACE(", Z bits: %u", pf->u1.dwZBufferBitDepth);
853 if (pf->dwFlags & DDPF_ALPHA)
854 TRACE(", Alpha bits: %u", pf->u1.dwAlphaBitDepth);
855 if (pf->dwFlags & DDPF_BUMPDUDV)
856 TRACE(", Bump bits: %u, U 0x%08x V 0x%08x L 0x%08x",
857 pf->u1.dwBumpBitCount,
858 pf->u2.dwBumpDuBitMask,
859 pf->u3.dwBumpDvBitMask,
860 pf->u4.dwBumpLuminanceBitMask);
861 TRACE(")\n");
862 }
863
864 void DDRAW_dump_surface_desc(const DDSURFACEDESC2 *lpddsd)
865 {
866 #define STRUCT DDSURFACEDESC2
867 static const struct member_info members[] =
868 {
869 ME(DDSD_HEIGHT, DDRAW_dump_DWORD, dwHeight),
870 ME(DDSD_WIDTH, DDRAW_dump_DWORD, dwWidth),
871 ME(DDSD_PITCH, DDRAW_dump_DWORD, u1 /* lPitch */),
872 ME(DDSD_LINEARSIZE, DDRAW_dump_DWORD, u1 /* dwLinearSize */),
873 ME(DDSD_BACKBUFFERCOUNT, DDRAW_dump_DWORD, u5.dwBackBufferCount),
874 ME(DDSD_MIPMAPCOUNT, DDRAW_dump_DWORD, u2 /* dwMipMapCount */),
875 ME(DDSD_ZBUFFERBITDEPTH, DDRAW_dump_DWORD, u2 /* dwZBufferBitDepth */), /* This is for 'old-style' D3D */
876 ME(DDSD_REFRESHRATE, DDRAW_dump_DWORD, u2 /* dwRefreshRate */),
877 ME(DDSD_ALPHABITDEPTH, DDRAW_dump_DWORD, dwAlphaBitDepth),
878 ME(DDSD_LPSURFACE, DDRAW_dump_PTR, lpSurface),
879 ME(DDSD_CKDESTOVERLAY, DDRAW_dump_DDCOLORKEY, u3 /* ddckCKDestOverlay */),
880 ME(DDSD_CKDESTBLT, DDRAW_dump_DDCOLORKEY, ddckCKDestBlt),
881 ME(DDSD_CKSRCOVERLAY, DDRAW_dump_DDCOLORKEY, ddckCKSrcOverlay),
882 ME(DDSD_CKSRCBLT, DDRAW_dump_DDCOLORKEY, ddckCKSrcBlt),
883 ME(DDSD_PIXELFORMAT, DDRAW_dump_pixelformat, u4 /* ddpfPixelFormat */)
884 };
885 static const struct member_info members_caps[] =
886 {
887 ME(DDSD_CAPS, DDRAW_dump_DDSCAPS, ddsCaps)
888 };
889 static const struct member_info members_caps2[] =
890 {
891 ME(DDSD_CAPS, DDRAW_dump_DDSCAPS2, ddsCaps)
892 };
893 #undef STRUCT
894
895 if (NULL == lpddsd)
896 {
897 TRACE("(null)\n");
898 }
899 else
900 {
901 if (lpddsd->dwSize >= sizeof(DDSURFACEDESC2))
902 {
903 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps2, 1);
904 }
905 else
906 {
907 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps, 1);
908 }
909 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members, ARRAY_SIZE(members));
910 }
911 }
912
913 void
914 dump_D3DMATRIX(const D3DMATRIX *mat)
915 {
916 TRACE(" %f %f %f %f\n", mat->_11, mat->_12, mat->_13, mat->_14);
917 TRACE(" %f %f %f %f\n", mat->_21, mat->_22, mat->_23, mat->_24);
918 TRACE(" %f %f %f %f\n", mat->_31, mat->_32, mat->_33, mat->_34);
919 TRACE(" %f %f %f %f\n", mat->_41, mat->_42, mat->_43, mat->_44);
920 }
921
922 DWORD
923 get_flexible_vertex_size(DWORD d3dvtVertexType)
924 {
925 DWORD size = 0;
926 DWORD i;
927
928 if (d3dvtVertexType & D3DFVF_NORMAL) size += 3 * sizeof(D3DVALUE);
929 if (d3dvtVertexType & D3DFVF_DIFFUSE) size += sizeof(DWORD);
930 if (d3dvtVertexType & D3DFVF_SPECULAR) size += sizeof(DWORD);
931 if (d3dvtVertexType & D3DFVF_RESERVED1) size += sizeof(DWORD);
932 switch (d3dvtVertexType & D3DFVF_POSITION_MASK)
933 {
934 case D3DFVF_XYZ: size += 3 * sizeof(D3DVALUE); break;
935 case D3DFVF_XYZRHW: size += 4 * sizeof(D3DVALUE); break;
936 case D3DFVF_XYZB1: size += 4 * sizeof(D3DVALUE); break;
937 case D3DFVF_XYZB2: size += 5 * sizeof(D3DVALUE); break;
938 case D3DFVF_XYZB3: size += 6 * sizeof(D3DVALUE); break;
939 case D3DFVF_XYZB4: size += 7 * sizeof(D3DVALUE); break;
940 case D3DFVF_XYZB5: size += 8 * sizeof(D3DVALUE); break;
941 default: ERR("Unexpected position mask\n");
942 }
943 for (i = 0; i < GET_TEXCOUNT_FROM_FVF(d3dvtVertexType); i++)
944 {
945 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(D3DVALUE);
946 }
947
948 return size;
949 }
950
951 void DDRAW_Convert_DDSCAPS_1_To_2(const DDSCAPS* pIn, DDSCAPS2* pOut)
952 {
953 /* 2 adds three additional caps fields to the end. Both versions
954 * are unversioned. */
955 pOut->dwCaps = pIn->dwCaps;
956 pOut->dwCaps2 = 0;
957 pOut->dwCaps3 = 0;
958 pOut->u1.dwCaps4 = 0;
959 }
960
961 void DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(const DDDEVICEIDENTIFIER2* pIn, DDDEVICEIDENTIFIER* pOut)
962 {
963 /* 2 adds a dwWHQLLevel field to the end. Both structures are
964 * unversioned. */
965 memcpy(pOut, pIn, sizeof(*pOut));
966 }
967
968 void DDRAW_dump_cooperativelevel(DWORD cooplevel)
969 {
970 static const struct flag_info flags[] =
971 {
972 FE(DDSCL_FULLSCREEN),
973 FE(DDSCL_ALLOWREBOOT),
974 FE(DDSCL_NOWINDOWCHANGES),
975 FE(DDSCL_NORMAL),
976 FE(DDSCL_ALLOWMODEX),
977 FE(DDSCL_EXCLUSIVE),
978 FE(DDSCL_SETFOCUSWINDOW),
979 FE(DDSCL_SETDEVICEWINDOW),
980 FE(DDSCL_CREATEDEVICEWINDOW)
981 };
982
983 if (TRACE_ON(ddraw))
984 {
985 TRACE(" - ");
986 DDRAW_dump_flags(cooplevel, flags, ARRAY_SIZE(flags));
987 }
988 }
989
990 void DDRAW_dump_DDCAPS(const DDCAPS *lpcaps)
991 {
992 static const struct flag_info flags1[] =
993 {
994 FE(DDCAPS_3D),
995 FE(DDCAPS_ALIGNBOUNDARYDEST),
996 FE(DDCAPS_ALIGNSIZEDEST),
997 FE(DDCAPS_ALIGNBOUNDARYSRC),
998 FE(DDCAPS_ALIGNSIZESRC),
999 FE(DDCAPS_ALIGNSTRIDE),
1000 FE(DDCAPS_BLT),
1001 FE(DDCAPS_BLTQUEUE),
1002 FE(DDCAPS_BLTFOURCC),
1003 FE(DDCAPS_BLTSTRETCH),
1004 FE(DDCAPS_GDI),
1005 FE(DDCAPS_OVERLAY),
1006 FE(DDCAPS_OVERLAYCANTCLIP),
1007 FE(DDCAPS_OVERLAYFOURCC),
1008 FE(DDCAPS_OVERLAYSTRETCH),
1009 FE(DDCAPS_PALETTE),
1010 FE(DDCAPS_PALETTEVSYNC),
1011 FE(DDCAPS_READSCANLINE),
1012 FE(DDCAPS_STEREOVIEW),
1013 FE(DDCAPS_VBI),
1014 FE(DDCAPS_ZBLTS),
1015 FE(DDCAPS_ZOVERLAYS),
1016 FE(DDCAPS_COLORKEY),
1017 FE(DDCAPS_ALPHA),
1018 FE(DDCAPS_COLORKEYHWASSIST),
1019 FE(DDCAPS_NOHARDWARE),
1020 FE(DDCAPS_BLTCOLORFILL),
1021 FE(DDCAPS_BANKSWITCHED),
1022 FE(DDCAPS_BLTDEPTHFILL),
1023 FE(DDCAPS_CANCLIP),
1024 FE(DDCAPS_CANCLIPSTRETCHED),
1025 FE(DDCAPS_CANBLTSYSMEM)
1026 };
1027 static const struct flag_info flags2[] =
1028 {
1029 FE(DDCAPS2_CERTIFIED),
1030 FE(DDCAPS2_NO2DDURING3DSCENE),
1031 FE(DDCAPS2_VIDEOPORT),
1032 FE(DDCAPS2_AUTOFLIPOVERLAY),
1033 FE(DDCAPS2_CANBOBINTERLEAVED),
1034 FE(DDCAPS2_CANBOBNONINTERLEAVED),
1035 FE(DDCAPS2_COLORCONTROLOVERLAY),
1036 FE(DDCAPS2_COLORCONTROLPRIMARY),
1037 FE(DDCAPS2_CANDROPZ16BIT),
1038 FE(DDCAPS2_NONLOCALVIDMEM),
1039 FE(DDCAPS2_NONLOCALVIDMEMCAPS),
1040 FE(DDCAPS2_NOPAGELOCKREQUIRED),
1041 FE(DDCAPS2_WIDESURFACES),
1042 FE(DDCAPS2_CANFLIPODDEVEN),
1043 FE(DDCAPS2_CANBOBHARDWARE),
1044 FE(DDCAPS2_COPYFOURCC),
1045 FE(DDCAPS2_PRIMARYGAMMA),
1046 FE(DDCAPS2_CANRENDERWINDOWED),
1047 FE(DDCAPS2_CANCALIBRATEGAMMA),
1048 FE(DDCAPS2_FLIPINTERVAL),
1049 FE(DDCAPS2_FLIPNOVSYNC),
1050 FE(DDCAPS2_CANMANAGETEXTURE),
1051 FE(DDCAPS2_TEXMANINNONLOCALVIDMEM),
1052 FE(DDCAPS2_STEREO),
1053 FE(DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL)
1054 };
1055 static const struct flag_info flags3[] =
1056 {
1057 FE(DDCKEYCAPS_DESTBLT),
1058 FE(DDCKEYCAPS_DESTBLTCLRSPACE),
1059 FE(DDCKEYCAPS_DESTBLTCLRSPACEYUV),
1060 FE(DDCKEYCAPS_DESTBLTYUV),
1061 FE(DDCKEYCAPS_DESTOVERLAY),
1062 FE(DDCKEYCAPS_DESTOVERLAYCLRSPACE),
1063 FE(DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV),
1064 FE(DDCKEYCAPS_DESTOVERLAYONEACTIVE),
1065 FE(DDCKEYCAPS_DESTOVERLAYYUV),
1066 FE(DDCKEYCAPS_SRCBLT),
1067 FE(DDCKEYCAPS_SRCBLTCLRSPACE),
1068 FE(DDCKEYCAPS_SRCBLTCLRSPACEYUV),
1069 FE(DDCKEYCAPS_SRCBLTYUV),
1070 FE(DDCKEYCAPS_SRCOVERLAY),
1071 FE(DDCKEYCAPS_SRCOVERLAYCLRSPACE),
1072 FE(DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV),
1073 FE(DDCKEYCAPS_SRCOVERLAYONEACTIVE),
1074 FE(DDCKEYCAPS_SRCOVERLAYYUV),
1075 FE(DDCKEYCAPS_NOCOSTOVERLAY)
1076 };
1077 static const struct flag_info flags4[] =
1078 {
1079 FE(DDFXCAPS_BLTALPHA),
1080 FE(DDFXCAPS_OVERLAYALPHA),
1081 FE(DDFXCAPS_BLTARITHSTRETCHYN),
1082 FE(DDFXCAPS_BLTARITHSTRETCHY),
1083 FE(DDFXCAPS_BLTMIRRORLEFTRIGHT),
1084 FE(DDFXCAPS_BLTMIRRORUPDOWN),
1085 FE(DDFXCAPS_BLTROTATION),
1086 FE(DDFXCAPS_BLTROTATION90),
1087 FE(DDFXCAPS_BLTSHRINKX),
1088 FE(DDFXCAPS_BLTSHRINKXN),
1089 FE(DDFXCAPS_BLTSHRINKY),
1090 FE(DDFXCAPS_BLTSHRINKYN),
1091 FE(DDFXCAPS_BLTSTRETCHX),
1092 FE(DDFXCAPS_BLTSTRETCHXN),
1093 FE(DDFXCAPS_BLTSTRETCHY),
1094 FE(DDFXCAPS_BLTSTRETCHYN),
1095 FE(DDFXCAPS_OVERLAYARITHSTRETCHY),
1096 FE(DDFXCAPS_OVERLAYARITHSTRETCHYN),
1097 FE(DDFXCAPS_OVERLAYSHRINKX),
1098 FE(DDFXCAPS_OVERLAYSHRINKXN),
1099 FE(DDFXCAPS_OVERLAYSHRINKY),
1100 FE(DDFXCAPS_OVERLAYSHRINKYN),
1101 FE(DDFXCAPS_OVERLAYSTRETCHX),
1102 FE(DDFXCAPS_OVERLAYSTRETCHXN),
1103 FE(DDFXCAPS_OVERLAYSTRETCHY),
1104 FE(DDFXCAPS_OVERLAYSTRETCHYN),
1105 FE(DDFXCAPS_OVERLAYMIRRORLEFTRIGHT),
1106 FE(DDFXCAPS_OVERLAYMIRRORUPDOWN)
1107 };
1108 static const struct flag_info flags5[] =
1109 {
1110 FE(DDFXALPHACAPS_BLTALPHAEDGEBLEND),
1111 FE(DDFXALPHACAPS_BLTALPHAPIXELS),
1112 FE(DDFXALPHACAPS_BLTALPHAPIXELSNEG),
1113 FE(DDFXALPHACAPS_BLTALPHASURFACES),
1114 FE(DDFXALPHACAPS_BLTALPHASURFACESNEG),
1115 FE(DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND),
1116 FE(DDFXALPHACAPS_OVERLAYALPHAPIXELS),
1117 FE(DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG),
1118 FE(DDFXALPHACAPS_OVERLAYALPHASURFACES),
1119 FE(DDFXALPHACAPS_OVERLAYALPHASURFACESNEG)
1120 };
1121 static const struct flag_info flags6[] =
1122 {
1123 FE(DDPCAPS_4BIT),
1124 FE(DDPCAPS_8BITENTRIES),
1125 FE(DDPCAPS_8BIT),
1126 FE(DDPCAPS_INITIALIZE),
1127 FE(DDPCAPS_PRIMARYSURFACE),
1128 FE(DDPCAPS_PRIMARYSURFACELEFT),
1129 FE(DDPCAPS_ALLOW256),
1130 FE(DDPCAPS_VSYNC),
1131 FE(DDPCAPS_1BIT),
1132 FE(DDPCAPS_2BIT),
1133 FE(DDPCAPS_ALPHA),
1134 };
1135 static const struct flag_info flags7[] =
1136 {
1137 FE(DDSVCAPS_RESERVED1),
1138 FE(DDSVCAPS_RESERVED2),
1139 FE(DDSVCAPS_RESERVED3),
1140 FE(DDSVCAPS_RESERVED4),
1141 FE(DDSVCAPS_STEREOSEQUENTIAL),
1142 };
1143
1144 TRACE(" - dwSize : %d\n", lpcaps->dwSize);
1145 TRACE(" - dwCaps : "); DDRAW_dump_flags(lpcaps->dwCaps, flags1, ARRAY_SIZE(flags1));
1146 TRACE(" - dwCaps2 : "); DDRAW_dump_flags(lpcaps->dwCaps2, flags2, ARRAY_SIZE(flags2));
1147 TRACE(" - dwCKeyCaps : "); DDRAW_dump_flags(lpcaps->dwCKeyCaps, flags3, ARRAY_SIZE(flags3));
1148 TRACE(" - dwFXCaps : "); DDRAW_dump_flags(lpcaps->dwFXCaps, flags4, ARRAY_SIZE(flags4));
1149 TRACE(" - dwFXAlphaCaps : "); DDRAW_dump_flags(lpcaps->dwFXAlphaCaps, flags5, ARRAY_SIZE(flags5));
1150 TRACE(" - dwPalCaps : "); DDRAW_dump_flags(lpcaps->dwPalCaps, flags6, ARRAY_SIZE(flags6));
1151 TRACE(" - dwSVCaps : "); DDRAW_dump_flags(lpcaps->dwSVCaps, flags7, ARRAY_SIZE(flags7));
1152 TRACE("...\n");
1153 TRACE(" - dwNumFourCCCodes : %d\n", lpcaps->dwNumFourCCCodes);
1154 TRACE(" - dwCurrVisibleOverlays : %d\n", lpcaps->dwCurrVisibleOverlays);
1155 TRACE(" - dwMinOverlayStretch : %d\n", lpcaps->dwMinOverlayStretch);
1156 TRACE(" - dwMaxOverlayStretch : %d\n", lpcaps->dwMaxOverlayStretch);
1157 TRACE("...\n");
1158 TRACE(" - ddsCaps : "); DDRAW_dump_DDSCAPS2(&lpcaps->ddsCaps);
1159 }
1160
1161 /*****************************************************************************
1162 * multiply_matrix
1163 *
1164 * Multiplies 2 4x4 matrices src1 and src2, and stores the result in dest.
1165 *
1166 * Params:
1167 * dest: Pointer to the destination matrix
1168 * src1: Pointer to the first source matrix
1169 * src2: Pointer to the second source matrix
1170 *
1171 *****************************************************************************/
1172 void
1173 multiply_matrix(D3DMATRIX *dest,
1174 const D3DMATRIX *src1,
1175 const D3DMATRIX *src2)
1176 {
1177 D3DMATRIX temp;
1178
1179 /* Now do the multiplication 'by hand'.
1180 I know that all this could be optimised, but this will be done later :-) */
1181 temp._11 = (src1->_11 * src2->_11) + (src1->_21 * src2->_12) + (src1->_31 * src2->_13) + (src1->_41 * src2->_14);
1182 temp._21 = (src1->_11 * src2->_21) + (src1->_21 * src2->_22) + (src1->_31 * src2->_23) + (src1->_41 * src2->_24);
1183 temp._31 = (src1->_11 * src2->_31) + (src1->_21 * src2->_32) + (src1->_31 * src2->_33) + (src1->_41 * src2->_34);
1184 temp._41 = (src1->_11 * src2->_41) + (src1->_21 * src2->_42) + (src1->_31 * src2->_43) + (src1->_41 * src2->_44);
1185
1186 temp._12 = (src1->_12 * src2->_11) + (src1->_22 * src2->_12) + (src1->_32 * src2->_13) + (src1->_42 * src2->_14);
1187 temp._22 = (src1->_12 * src2->_21) + (src1->_22 * src2->_22) + (src1->_32 * src2->_23) + (src1->_42 * src2->_24);
1188 temp._32 = (src1->_12 * src2->_31) + (src1->_22 * src2->_32) + (src1->_32 * src2->_33) + (src1->_42 * src2->_34);
1189 temp._42 = (src1->_12 * src2->_41) + (src1->_22 * src2->_42) + (src1->_32 * src2->_43) + (src1->_42 * src2->_44);
1190
1191 temp._13 = (src1->_13 * src2->_11) + (src1->_23 * src2->_12) + (src1->_33 * src2->_13) + (src1->_43 * src2->_14);
1192 temp._23 = (src1->_13 * src2->_21) + (src1->_23 * src2->_22) + (src1->_33 * src2->_23) + (src1->_43 * src2->_24);
1193 temp._33 = (src1->_13 * src2->_31) + (src1->_23 * src2->_32) + (src1->_33 * src2->_33) + (src1->_43 * src2->_34);
1194 temp._43 = (src1->_13 * src2->_41) + (src1->_23 * src2->_42) + (src1->_33 * src2->_43) + (src1->_43 * src2->_44);
1195
1196 temp._14 = (src1->_14 * src2->_11) + (src1->_24 * src2->_12) + (src1->_34 * src2->_13) + (src1->_44 * src2->_14);
1197 temp._24 = (src1->_14 * src2->_21) + (src1->_24 * src2->_22) + (src1->_34 * src2->_23) + (src1->_44 * src2->_24);
1198 temp._34 = (src1->_14 * src2->_31) + (src1->_24 * src2->_32) + (src1->_34 * src2->_33) + (src1->_44 * src2->_34);
1199 temp._44 = (src1->_14 * src2->_41) + (src1->_24 * src2->_42) + (src1->_34 * src2->_43) + (src1->_44 * src2->_44);
1200
1201 /* And copy the new matrix in the good storage.. */
1202 memcpy(dest, &temp, 16 * sizeof(D3DVALUE));
1203 }
1204
1205 HRESULT
1206 hr_ddraw_from_wined3d(HRESULT hr)
1207 {
1208 switch(hr)
1209 {
1210 case WINED3DERR_INVALIDCALL: return DDERR_INVALIDPARAMS;
1211 default: return hr;
1212 }
1213 }
1214
1215 /* Note that this function writes the full sizeof(DDSURFACEDESC2) size, don't use it
1216 * for writing into application-provided DDSURFACEDESC2 structures if the size may
1217 * be different */
1218 void DDSD_to_DDSD2(const DDSURFACEDESC *in, DDSURFACEDESC2 *out)
1219 {
1220 /* The output of this function is never passed to the application directly, so
1221 * the memset is not strictly needed. CreateSurface still has problems with this
1222 * though. Don't forget to set ddsCaps.dwCaps2/3/4 to 0 when removing this */
1223 memset(out, 0x00, sizeof(*out));
1224 out->dwSize = sizeof(*out);
1225 out->dwFlags = in->dwFlags & ~DDSD_ZBUFFERBITDEPTH;
1226 if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth;
1227 if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight;
1228 if (in->dwFlags & DDSD_PIXELFORMAT) out->u4.ddpfPixelFormat = in->ddpfPixelFormat;
1229 else if(in->dwFlags & DDSD_ZBUFFERBITDEPTH)
1230 {
1231 out->dwFlags |= DDSD_PIXELFORMAT;
1232 memset(&out->u4.ddpfPixelFormat, 0, sizeof(out->u4.ddpfPixelFormat));
1233 out->u4.ddpfPixelFormat.dwSize = sizeof(out->u4.ddpfPixelFormat);
1234 out->u4.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER;
1235 out->u4.ddpfPixelFormat.u1.dwZBufferBitDepth = in->u2.dwZBufferBitDepth;
1236 /* 0 is not a valid DDSURFACEDESC / DDPIXELFORMAT on either side of the
1237 * conversion */
1238 out->u4.ddpfPixelFormat.u3.dwZBitMask = ~0U >> (32 - in->u2.dwZBufferBitDepth);
1239 }
1240 /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */
1241 out->ddsCaps.dwCaps = in->ddsCaps.dwCaps;
1242 if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch;
1243 if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->u5.dwBackBufferCount = in->dwBackBufferCount;
1244 if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth;
1245 /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */
1246 out->lpSurface = in->lpSurface;
1247 if (in->dwFlags & DDSD_CKDESTOVERLAY) out->u3.ddckCKDestOverlay = in->ddckCKDestOverlay;
1248 if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt;
1249 if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay;
1250 if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt;
1251 if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount;
1252 if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate;
1253 if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize;
1254 /* Does not exist in DDSURFACEDESC:
1255 * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE,
1256 */
1257 }
1258
1259 /* Note that this function writes the full sizeof(DDSURFACEDESC) size, don't use it
1260 * for writing into application-provided DDSURFACEDESC structures if the size may
1261 * be different */
1262 void DDSD2_to_DDSD(const DDSURFACEDESC2 *in, DDSURFACEDESC *out)
1263 {
1264 memset(out, 0, sizeof(*out));
1265 out->dwSize = sizeof(*out);
1266 out->dwFlags = in->dwFlags;
1267 if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth;
1268 if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight;
1269 if (in->dwFlags & DDSD_PIXELFORMAT)
1270 {
1271 out->ddpfPixelFormat = in->u4.ddpfPixelFormat;
1272 if ((in->dwFlags & DDSD_CAPS) && (in->ddsCaps.dwCaps & DDSCAPS_ZBUFFER))
1273 {
1274 /* Z buffers have DDSD_ZBUFFERBITDEPTH set, but not DDSD_PIXELFORMAT. They do
1275 * have valid data in ddpfPixelFormat though */
1276 out->dwFlags &= ~DDSD_PIXELFORMAT;
1277 out->dwFlags |= DDSD_ZBUFFERBITDEPTH;
1278 out->u2.dwZBufferBitDepth = in->u4.ddpfPixelFormat.u1.dwZBufferBitDepth;
1279 }
1280 }
1281 /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */
1282 out->ddsCaps.dwCaps = in->ddsCaps.dwCaps;
1283 if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch;
1284 if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->dwBackBufferCount = in->u5.dwBackBufferCount;
1285 if (in->dwFlags & DDSD_ZBUFFERBITDEPTH) out->u2.dwZBufferBitDepth = in->u2.dwMipMapCount; /* same union */
1286 if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth;
1287 /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */
1288 out->lpSurface = in->lpSurface;
1289 if (in->dwFlags & DDSD_CKDESTOVERLAY) out->ddckCKDestOverlay = in->u3.ddckCKDestOverlay;
1290 if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt;
1291 if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay;
1292 if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt;
1293 if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount;
1294 if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate;
1295 if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize;
1296 /* Does not exist in DDSURFACEDESC:
1297 * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE,
1298 */
1299 if (in->dwFlags & DDSD_TEXTURESTAGE) WARN("Does not exist in DDSURFACEDESC: DDSD_TEXTURESTAGE\n");
1300 if (in->dwFlags & DDSD_FVF) WARN("Does not exist in DDSURFACEDESC: DDSD_FVF\n");
1301 if (in->dwFlags & DDSD_SRCVBHANDLE) WARN("Does not exist in DDSURFACEDESC: DDSD_SRCVBHANDLE\n");
1302 out->dwFlags &= ~(DDSD_TEXTURESTAGE | DDSD_FVF | DDSD_SRCVBHANDLE);
1303 }
Windows API implementation