?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d8/tests: Add test for clip planes limits.
[wine.git] / dlls / ddraw / utils.c
blob37851589d2049d0831762fe548b216e842e75db1
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 static float colour_to_float(DWORD colour, DWORD mask)
565 {
566 if (!mask)
567 return 0.0f;
568 return (float)(colour & mask) / (float)mask;
569 }
570
571 BOOL wined3d_colour_from_ddraw_colour(const DDPIXELFORMAT *pf, const struct ddraw_palette *palette,
572 DWORD colour, struct wined3d_color *wined3d_colour)
573 {
574 if (pf->dwFlags & DDPF_ALPHA)
575 {
576 DWORD size, mask;
577
578 size = pf->u1.dwAlphaBitDepth;
579 mask = size < 32 ? (1u << size) - 1 : ~0u;
580 wined3d_colour->r = 0.0f;
581 wined3d_colour->g = 0.0f;
582 wined3d_colour->b = 0.0f;
583 wined3d_colour->a = colour_to_float(colour, mask);
584 return TRUE;
585 }
586
587 if (pf->dwFlags & DDPF_FOURCC)
588 {
589 WARN("FourCC formats not supported.\n");
590 goto fail;
591 }
592
593 if (pf->dwFlags & DDPF_PALETTEINDEXED8)
594 {
595 PALETTEENTRY entry;
596
597 colour &= 0xff;
598 if (!palette || FAILED(wined3d_palette_get_entries(palette->wined3d_palette, 0, colour, 1, &entry)))
599 {
600 wined3d_colour->r = 0.0f;
601 wined3d_colour->g = 0.0f;
602 wined3d_colour->b = 0.0f;
603 }
604 else
605 {
606 wined3d_colour->r = entry.peRed / 255.0f;
607 wined3d_colour->g = entry.peGreen / 255.0f;
608 wined3d_colour->b = entry.peBlue / 255.0f;
609 }
610 wined3d_colour->a = colour / 255.0f;
611 return TRUE;
612 }
613
614 if (pf->dwFlags & DDPF_RGB)
615 {
616 wined3d_colour->r = colour_to_float(colour, pf->u2.dwRBitMask);
617 wined3d_colour->g = colour_to_float(colour, pf->u3.dwGBitMask);
618 wined3d_colour->b = colour_to_float(colour, pf->u4.dwBBitMask);
619 if (pf->dwFlags & DDPF_ALPHAPIXELS)
620 wined3d_colour->a = colour_to_float(colour, pf->u5.dwRGBAlphaBitMask);
621 else
622 wined3d_colour->a = 0.0f;
623 return TRUE;
624 }
625
626 if (pf->dwFlags & DDPF_ZBUFFER)
627 {
628 wined3d_colour->r = colour_to_float(colour, pf->u3.dwZBitMask);
629 if (pf->dwFlags & DDPF_STENCILBUFFER)
630 wined3d_colour->g = colour_to_float(colour, pf->u4.dwStencilBitMask);
631 else
632 wined3d_colour->g = 0.0f;
633 wined3d_colour->b = 0.0f;
634 wined3d_colour->a = 0.0f;
635 return TRUE;
636 }
637
638 FIXME("Unhandled pixel format.\n");
639 DDRAW_dump_pixelformat(pf);
640
641 fail:
642 wined3d_colour->r = 0.0f;
643 wined3d_colour->g = 0.0f;
644 wined3d_colour->b = 0.0f;
645 wined3d_colour->a = 0.0f;
646
647 return FALSE;
648 }
649
650 /*****************************************************************************
651 * Various dumping functions.
652 *
653 * They write the contents of a specific function to a TRACE.
654 *
655 *****************************************************************************/
656 static void
657 DDRAW_dump_DWORD(const void *in)
658 {
659 TRACE("%d\n", *((const DWORD *) in));
660 }
661 static void
662 DDRAW_dump_PTR(const void *in)
663 {
664 TRACE("%p\n", *((const void * const*) in));
665 }
666 static void
667 DDRAW_dump_DDCOLORKEY(const DDCOLORKEY *ddck)
668 {
669 TRACE("Low : 0x%08x - High : 0x%08x\n", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue);
670 }
671
672 static void DDRAW_dump_flags_nolf(DWORD flags, const struct flag_info *names, size_t num_names)
673 {
674 unsigned int i;
675
676 for (i=0; i < num_names; i++)
677 if ((flags & names[i].val) || /* standard flag value */
678 ((!flags) && (!names[i].val))) /* zero value only */
679 TRACE("%s ", names[i].name);
680 }
681
682 static void DDRAW_dump_flags(DWORD flags, const struct flag_info *names, size_t num_names)
683 {
684 DDRAW_dump_flags_nolf(flags, names, num_names);
685 TRACE("\n");
686 }
687
688 void DDRAW_dump_DDSCAPS2(const DDSCAPS2 *in)
689 {
690 static const struct flag_info flags[] =
691 {
692 FE(DDSCAPS_RESERVED1),
693 FE(DDSCAPS_ALPHA),
694 FE(DDSCAPS_BACKBUFFER),
695 FE(DDSCAPS_COMPLEX),
696 FE(DDSCAPS_FLIP),
697 FE(DDSCAPS_FRONTBUFFER),
698 FE(DDSCAPS_OFFSCREENPLAIN),
699 FE(DDSCAPS_OVERLAY),
700 FE(DDSCAPS_PALETTE),
701 FE(DDSCAPS_PRIMARYSURFACE),
702 FE(DDSCAPS_PRIMARYSURFACELEFT),
703 FE(DDSCAPS_SYSTEMMEMORY),
704 FE(DDSCAPS_TEXTURE),
705 FE(DDSCAPS_3DDEVICE),
706 FE(DDSCAPS_VIDEOMEMORY),
707 FE(DDSCAPS_VISIBLE),
708 FE(DDSCAPS_WRITEONLY),
709 FE(DDSCAPS_ZBUFFER),
710 FE(DDSCAPS_OWNDC),
711 FE(DDSCAPS_LIVEVIDEO),
712 FE(DDSCAPS_HWCODEC),
713 FE(DDSCAPS_MODEX),
714 FE(DDSCAPS_MIPMAP),
715 FE(DDSCAPS_RESERVED2),
716 FE(DDSCAPS_ALLOCONLOAD),
717 FE(DDSCAPS_VIDEOPORT),
718 FE(DDSCAPS_LOCALVIDMEM),
719 FE(DDSCAPS_NONLOCALVIDMEM),
720 FE(DDSCAPS_STANDARDVGAMODE),
721 FE(DDSCAPS_OPTIMIZED)
722 };
723 static const struct flag_info flags2[] =
724 {
725 FE(DDSCAPS2_HARDWAREDEINTERLACE),
726 FE(DDSCAPS2_HINTDYNAMIC),
727 FE(DDSCAPS2_HINTSTATIC),
728 FE(DDSCAPS2_TEXTUREMANAGE),
729 FE(DDSCAPS2_RESERVED1),
730 FE(DDSCAPS2_RESERVED2),
731 FE(DDSCAPS2_OPAQUE),
732 FE(DDSCAPS2_HINTANTIALIASING),
733 FE(DDSCAPS2_CUBEMAP),
734 FE(DDSCAPS2_CUBEMAP_POSITIVEX),
735 FE(DDSCAPS2_CUBEMAP_NEGATIVEX),
736 FE(DDSCAPS2_CUBEMAP_POSITIVEY),
737 FE(DDSCAPS2_CUBEMAP_NEGATIVEY),
738 FE(DDSCAPS2_CUBEMAP_POSITIVEZ),
739 FE(DDSCAPS2_CUBEMAP_NEGATIVEZ),
740 FE(DDSCAPS2_MIPMAPSUBLEVEL),
741 FE(DDSCAPS2_D3DTEXTUREMANAGE),
742 FE(DDSCAPS2_DONOTPERSIST),
743 FE(DDSCAPS2_STEREOSURFACELEFT)
744 };
745
746 DDRAW_dump_flags_nolf(in->dwCaps, flags, sizeof(flags)/sizeof(flags[0]));
747 DDRAW_dump_flags(in->dwCaps2, flags2, sizeof(flags2)/sizeof(flags2[0]));
748 }
749
750 static void
751 DDRAW_dump_DDSCAPS(const DDSCAPS *in)
752 {
753 DDSCAPS2 in_bis;
754
755 in_bis.dwCaps = in->dwCaps;
756 in_bis.dwCaps2 = 0;
757 in_bis.dwCaps3 = 0;
758 in_bis.u1.dwCaps4 = 0;
759
760 DDRAW_dump_DDSCAPS2(&in_bis);
761 }
762
763 static void
764 DDRAW_dump_pixelformat_flag(DWORD flagmask)
765 {
766 static const struct flag_info flags[] =
767 {
768 FE(DDPF_ALPHAPIXELS),
769 FE(DDPF_ALPHA),
770 FE(DDPF_FOURCC),
771 FE(DDPF_PALETTEINDEXED4),
772 FE(DDPF_PALETTEINDEXEDTO8),
773 FE(DDPF_PALETTEINDEXED8),
774 FE(DDPF_RGB),
775 FE(DDPF_COMPRESSED),
776 FE(DDPF_RGBTOYUV),
777 FE(DDPF_YUV),
778 FE(DDPF_ZBUFFER),
779 FE(DDPF_PALETTEINDEXED1),
780 FE(DDPF_PALETTEINDEXED2),
781 FE(DDPF_ZPIXELS)
782 };
783
784 DDRAW_dump_flags_nolf(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
785 }
786
787 static void DDRAW_dump_members(DWORD flags, const void *data, const struct member_info *mems, size_t num_mems)
788 {
789 unsigned int i;
790
791 for (i=0; i < num_mems; i++)
792 {
793 if (mems[i].val & flags)
794 {
795 TRACE(" - %s : ", mems[i].name);
796 mems[i].func((const char *)data + mems[i].offset);
797 }
798 }
799 }
800
801 static void
802 DDRAW_dump_pixelformat(const DDPIXELFORMAT *pf)
803 {
804 TRACE("( ");
805 DDRAW_dump_pixelformat_flag(pf->dwFlags);
806 if (pf->dwFlags & DDPF_FOURCC)
807 TRACE(", dwFourCC code '%c%c%c%c' (0x%08x) - %u bits per pixel",
808 (unsigned char)( pf->dwFourCC &0xff),
809 (unsigned char)((pf->dwFourCC>> 8)&0xff),
810 (unsigned char)((pf->dwFourCC>>16)&0xff),
811 (unsigned char)((pf->dwFourCC>>24)&0xff),
812 pf->dwFourCC,
813 pf->u1.dwYUVBitCount);
814 if (pf->dwFlags & DDPF_RGB)
815 {
816 TRACE(", RGB bits: %u, R 0x%08x G 0x%08x B 0x%08x",
817 pf->u1.dwRGBBitCount,
818 pf->u2.dwRBitMask,
819 pf->u3.dwGBitMask,
820 pf->u4.dwBBitMask);
821 if (pf->dwFlags & DDPF_ALPHAPIXELS)
822 TRACE(" A 0x%08x", pf->u5.dwRGBAlphaBitMask);
823 if (pf->dwFlags & DDPF_ZPIXELS)
824 TRACE(" Z 0x%08x", pf->u5.dwRGBZBitMask);
825 }
826 if (pf->dwFlags & DDPF_ZBUFFER)
827 TRACE(", Z bits: %u", pf->u1.dwZBufferBitDepth);
828 if (pf->dwFlags & DDPF_ALPHA)
829 TRACE(", Alpha bits: %u", pf->u1.dwAlphaBitDepth);
830 if (pf->dwFlags & DDPF_BUMPDUDV)
831 TRACE(", Bump bits: %u, U 0x%08x V 0x%08x L 0x%08x",
832 pf->u1.dwBumpBitCount,
833 pf->u2.dwBumpDuBitMask,
834 pf->u3.dwBumpDvBitMask,
835 pf->u4.dwBumpLuminanceBitMask);
836 TRACE(")\n");
837 }
838
839 void DDRAW_dump_surface_desc(const DDSURFACEDESC2 *lpddsd)
840 {
841 #define STRUCT DDSURFACEDESC2
842 static const struct member_info members[] =
843 {
844 ME(DDSD_HEIGHT, DDRAW_dump_DWORD, dwHeight),
845 ME(DDSD_WIDTH, DDRAW_dump_DWORD, dwWidth),
846 ME(DDSD_PITCH, DDRAW_dump_DWORD, u1 /* lPitch */),
847 ME(DDSD_LINEARSIZE, DDRAW_dump_DWORD, u1 /* dwLinearSize */),
848 ME(DDSD_BACKBUFFERCOUNT, DDRAW_dump_DWORD, u5.dwBackBufferCount),
849 ME(DDSD_MIPMAPCOUNT, DDRAW_dump_DWORD, u2 /* dwMipMapCount */),
850 ME(DDSD_ZBUFFERBITDEPTH, DDRAW_dump_DWORD, u2 /* dwZBufferBitDepth */), /* This is for 'old-style' D3D */
851 ME(DDSD_REFRESHRATE, DDRAW_dump_DWORD, u2 /* dwRefreshRate */),
852 ME(DDSD_ALPHABITDEPTH, DDRAW_dump_DWORD, dwAlphaBitDepth),
853 ME(DDSD_LPSURFACE, DDRAW_dump_PTR, lpSurface),
854 ME(DDSD_CKDESTOVERLAY, DDRAW_dump_DDCOLORKEY, u3 /* ddckCKDestOverlay */),
855 ME(DDSD_CKDESTBLT, DDRAW_dump_DDCOLORKEY, ddckCKDestBlt),
856 ME(DDSD_CKSRCOVERLAY, DDRAW_dump_DDCOLORKEY, ddckCKSrcOverlay),
857 ME(DDSD_CKSRCBLT, DDRAW_dump_DDCOLORKEY, ddckCKSrcBlt),
858 ME(DDSD_PIXELFORMAT, DDRAW_dump_pixelformat, u4 /* ddpfPixelFormat */)
859 };
860 static const struct member_info members_caps[] =
861 {
862 ME(DDSD_CAPS, DDRAW_dump_DDSCAPS, ddsCaps)
863 };
864 static const struct member_info members_caps2[] =
865 {
866 ME(DDSD_CAPS, DDRAW_dump_DDSCAPS2, ddsCaps)
867 };
868 #undef STRUCT
869
870 if (NULL == lpddsd)
871 {
872 TRACE("(null)\n");
873 }
874 else
875 {
876 if (lpddsd->dwSize >= sizeof(DDSURFACEDESC2))
877 {
878 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps2, 1);
879 }
880 else
881 {
882 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps, 1);
883 }
884 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members,
885 sizeof(members)/sizeof(members[0]));
886 }
887 }
888
889 void
890 dump_D3DMATRIX(const D3DMATRIX *mat)
891 {
892 TRACE(" %f %f %f %f\n", mat->_11, mat->_12, mat->_13, mat->_14);
893 TRACE(" %f %f %f %f\n", mat->_21, mat->_22, mat->_23, mat->_24);
894 TRACE(" %f %f %f %f\n", mat->_31, mat->_32, mat->_33, mat->_34);
895 TRACE(" %f %f %f %f\n", mat->_41, mat->_42, mat->_43, mat->_44);
896 }
897
898 DWORD
899 get_flexible_vertex_size(DWORD d3dvtVertexType)
900 {
901 DWORD size = 0;
902 DWORD i;
903
904 if (d3dvtVertexType & D3DFVF_NORMAL) size += 3 * sizeof(D3DVALUE);
905 if (d3dvtVertexType & D3DFVF_DIFFUSE) size += sizeof(DWORD);
906 if (d3dvtVertexType & D3DFVF_SPECULAR) size += sizeof(DWORD);
907 if (d3dvtVertexType & D3DFVF_RESERVED1) size += sizeof(DWORD);
908 switch (d3dvtVertexType & D3DFVF_POSITION_MASK)
909 {
910 case D3DFVF_XYZ: size += 3 * sizeof(D3DVALUE); break;
911 case D3DFVF_XYZRHW: size += 4 * sizeof(D3DVALUE); break;
912 case D3DFVF_XYZB1: size += 4 * sizeof(D3DVALUE); break;
913 case D3DFVF_XYZB2: size += 5 * sizeof(D3DVALUE); break;
914 case D3DFVF_XYZB3: size += 6 * sizeof(D3DVALUE); break;
915 case D3DFVF_XYZB4: size += 7 * sizeof(D3DVALUE); break;
916 case D3DFVF_XYZB5: size += 8 * sizeof(D3DVALUE); break;
917 default: ERR("Unexpected position mask\n");
918 }
919 for (i = 0; i < GET_TEXCOUNT_FROM_FVF(d3dvtVertexType); i++)
920 {
921 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(D3DVALUE);
922 }
923
924 return size;
925 }
926
927 void DDRAW_Convert_DDSCAPS_1_To_2(const DDSCAPS* pIn, DDSCAPS2* pOut)
928 {
929 /* 2 adds three additional caps fields to the end. Both versions
930 * are unversioned. */
931 pOut->dwCaps = pIn->dwCaps;
932 pOut->dwCaps2 = 0;
933 pOut->dwCaps3 = 0;
934 pOut->u1.dwCaps4 = 0;
935 }
936
937 void DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(const DDDEVICEIDENTIFIER2* pIn, DDDEVICEIDENTIFIER* pOut)
938 {
939 /* 2 adds a dwWHQLLevel field to the end. Both structures are
940 * unversioned. */
941 memcpy(pOut, pIn, sizeof(*pOut));
942 }
943
944 void DDRAW_dump_cooperativelevel(DWORD cooplevel)
945 {
946 static const struct flag_info flags[] =
947 {
948 FE(DDSCL_FULLSCREEN),
949 FE(DDSCL_ALLOWREBOOT),
950 FE(DDSCL_NOWINDOWCHANGES),
951 FE(DDSCL_NORMAL),
952 FE(DDSCL_ALLOWMODEX),
953 FE(DDSCL_EXCLUSIVE),
954 FE(DDSCL_SETFOCUSWINDOW),
955 FE(DDSCL_SETDEVICEWINDOW),
956 FE(DDSCL_CREATEDEVICEWINDOW)
957 };
958
959 if (TRACE_ON(ddraw))
960 {
961 TRACE(" - ");
962 DDRAW_dump_flags(cooplevel, flags, sizeof(flags)/sizeof(flags[0]));
963 }
964 }
965
966 void DDRAW_dump_DDCAPS(const DDCAPS *lpcaps)
967 {
968 static const struct flag_info flags1[] =
969 {
970 FE(DDCAPS_3D),
971 FE(DDCAPS_ALIGNBOUNDARYDEST),
972 FE(DDCAPS_ALIGNSIZEDEST),
973 FE(DDCAPS_ALIGNBOUNDARYSRC),
974 FE(DDCAPS_ALIGNSIZESRC),
975 FE(DDCAPS_ALIGNSTRIDE),
976 FE(DDCAPS_BLT),
977 FE(DDCAPS_BLTQUEUE),
978 FE(DDCAPS_BLTFOURCC),
979 FE(DDCAPS_BLTSTRETCH),
980 FE(DDCAPS_GDI),
981 FE(DDCAPS_OVERLAY),
982 FE(DDCAPS_OVERLAYCANTCLIP),
983 FE(DDCAPS_OVERLAYFOURCC),
984 FE(DDCAPS_OVERLAYSTRETCH),
985 FE(DDCAPS_PALETTE),
986 FE(DDCAPS_PALETTEVSYNC),
987 FE(DDCAPS_READSCANLINE),
988 FE(DDCAPS_STEREOVIEW),
989 FE(DDCAPS_VBI),
990 FE(DDCAPS_ZBLTS),
991 FE(DDCAPS_ZOVERLAYS),
992 FE(DDCAPS_COLORKEY),
993 FE(DDCAPS_ALPHA),
994 FE(DDCAPS_COLORKEYHWASSIST),
995 FE(DDCAPS_NOHARDWARE),
996 FE(DDCAPS_BLTCOLORFILL),
997 FE(DDCAPS_BANKSWITCHED),
998 FE(DDCAPS_BLTDEPTHFILL),
999 FE(DDCAPS_CANCLIP),
1000 FE(DDCAPS_CANCLIPSTRETCHED),
1001 FE(DDCAPS_CANBLTSYSMEM)
1002 };
1003 static const struct flag_info flags2[] =
1004 {
1005 FE(DDCAPS2_CERTIFIED),
1006 FE(DDCAPS2_NO2DDURING3DSCENE),
1007 FE(DDCAPS2_VIDEOPORT),
1008 FE(DDCAPS2_AUTOFLIPOVERLAY),
1009 FE(DDCAPS2_CANBOBINTERLEAVED),
1010 FE(DDCAPS2_CANBOBNONINTERLEAVED),
1011 FE(DDCAPS2_COLORCONTROLOVERLAY),
1012 FE(DDCAPS2_COLORCONTROLPRIMARY),
1013 FE(DDCAPS2_CANDROPZ16BIT),
1014 FE(DDCAPS2_NONLOCALVIDMEM),
1015 FE(DDCAPS2_NONLOCALVIDMEMCAPS),
1016 FE(DDCAPS2_NOPAGELOCKREQUIRED),
1017 FE(DDCAPS2_WIDESURFACES),
1018 FE(DDCAPS2_CANFLIPODDEVEN),
1019 FE(DDCAPS2_CANBOBHARDWARE),
1020 FE(DDCAPS2_COPYFOURCC),
1021 FE(DDCAPS2_PRIMARYGAMMA),
1022 FE(DDCAPS2_CANRENDERWINDOWED),
1023 FE(DDCAPS2_CANCALIBRATEGAMMA),
1024 FE(DDCAPS2_FLIPINTERVAL),
1025 FE(DDCAPS2_FLIPNOVSYNC),
1026 FE(DDCAPS2_CANMANAGETEXTURE),
1027 FE(DDCAPS2_TEXMANINNONLOCALVIDMEM),
1028 FE(DDCAPS2_STEREO),
1029 FE(DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL)
1030 };
1031 static const struct flag_info flags3[] =
1032 {
1033 FE(DDCKEYCAPS_DESTBLT),
1034 FE(DDCKEYCAPS_DESTBLTCLRSPACE),
1035 FE(DDCKEYCAPS_DESTBLTCLRSPACEYUV),
1036 FE(DDCKEYCAPS_DESTBLTYUV),
1037 FE(DDCKEYCAPS_DESTOVERLAY),
1038 FE(DDCKEYCAPS_DESTOVERLAYCLRSPACE),
1039 FE(DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV),
1040 FE(DDCKEYCAPS_DESTOVERLAYONEACTIVE),
1041 FE(DDCKEYCAPS_DESTOVERLAYYUV),
1042 FE(DDCKEYCAPS_SRCBLT),
1043 FE(DDCKEYCAPS_SRCBLTCLRSPACE),
1044 FE(DDCKEYCAPS_SRCBLTCLRSPACEYUV),
1045 FE(DDCKEYCAPS_SRCBLTYUV),
1046 FE(DDCKEYCAPS_SRCOVERLAY),
1047 FE(DDCKEYCAPS_SRCOVERLAYCLRSPACE),
1048 FE(DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV),
1049 FE(DDCKEYCAPS_SRCOVERLAYONEACTIVE),
1050 FE(DDCKEYCAPS_SRCOVERLAYYUV),
1051 FE(DDCKEYCAPS_NOCOSTOVERLAY)
1052 };
1053 static const struct flag_info flags4[] =
1054 {
1055 FE(DDFXCAPS_BLTALPHA),
1056 FE(DDFXCAPS_OVERLAYALPHA),
1057 FE(DDFXCAPS_BLTARITHSTRETCHYN),
1058 FE(DDFXCAPS_BLTARITHSTRETCHY),
1059 FE(DDFXCAPS_BLTMIRRORLEFTRIGHT),
1060 FE(DDFXCAPS_BLTMIRRORUPDOWN),
1061 FE(DDFXCAPS_BLTROTATION),
1062 FE(DDFXCAPS_BLTROTATION90),
1063 FE(DDFXCAPS_BLTSHRINKX),
1064 FE(DDFXCAPS_BLTSHRINKXN),
1065 FE(DDFXCAPS_BLTSHRINKY),
1066 FE(DDFXCAPS_BLTSHRINKYN),
1067 FE(DDFXCAPS_BLTSTRETCHX),
1068 FE(DDFXCAPS_BLTSTRETCHXN),
1069 FE(DDFXCAPS_BLTSTRETCHY),
1070 FE(DDFXCAPS_BLTSTRETCHYN),
1071 FE(DDFXCAPS_OVERLAYARITHSTRETCHY),
1072 FE(DDFXCAPS_OVERLAYARITHSTRETCHYN),
1073 FE(DDFXCAPS_OVERLAYSHRINKX),
1074 FE(DDFXCAPS_OVERLAYSHRINKXN),
1075 FE(DDFXCAPS_OVERLAYSHRINKY),
1076 FE(DDFXCAPS_OVERLAYSHRINKYN),
1077 FE(DDFXCAPS_OVERLAYSTRETCHX),
1078 FE(DDFXCAPS_OVERLAYSTRETCHXN),
1079 FE(DDFXCAPS_OVERLAYSTRETCHY),
1080 FE(DDFXCAPS_OVERLAYSTRETCHYN),
1081 FE(DDFXCAPS_OVERLAYMIRRORLEFTRIGHT),
1082 FE(DDFXCAPS_OVERLAYMIRRORUPDOWN)
1083 };
1084 static const struct flag_info flags5[] =
1085 {
1086 FE(DDFXALPHACAPS_BLTALPHAEDGEBLEND),
1087 FE(DDFXALPHACAPS_BLTALPHAPIXELS),
1088 FE(DDFXALPHACAPS_BLTALPHAPIXELSNEG),
1089 FE(DDFXALPHACAPS_BLTALPHASURFACES),
1090 FE(DDFXALPHACAPS_BLTALPHASURFACESNEG),
1091 FE(DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND),
1092 FE(DDFXALPHACAPS_OVERLAYALPHAPIXELS),
1093 FE(DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG),
1094 FE(DDFXALPHACAPS_OVERLAYALPHASURFACES),
1095 FE(DDFXALPHACAPS_OVERLAYALPHASURFACESNEG)
1096 };
1097 static const struct flag_info flags6[] =
1098 {
1099 FE(DDPCAPS_4BIT),
1100 FE(DDPCAPS_8BITENTRIES),
1101 FE(DDPCAPS_8BIT),
1102 FE(DDPCAPS_INITIALIZE),
1103 FE(DDPCAPS_PRIMARYSURFACE),
1104 FE(DDPCAPS_PRIMARYSURFACELEFT),
1105 FE(DDPCAPS_ALLOW256),
1106 FE(DDPCAPS_VSYNC),
1107 FE(DDPCAPS_1BIT),
1108 FE(DDPCAPS_2BIT),
1109 FE(DDPCAPS_ALPHA),
1110 };
1111 static const struct flag_info flags7[] =
1112 {
1113 FE(DDSVCAPS_RESERVED1),
1114 FE(DDSVCAPS_RESERVED2),
1115 FE(DDSVCAPS_RESERVED3),
1116 FE(DDSVCAPS_RESERVED4),
1117 FE(DDSVCAPS_STEREOSEQUENTIAL),
1118 };
1119
1120 TRACE(" - dwSize : %d\n", lpcaps->dwSize);
1121 TRACE(" - dwCaps : "); DDRAW_dump_flags(lpcaps->dwCaps, flags1, sizeof(flags1)/sizeof(flags1[0]));
1122 TRACE(" - dwCaps2 : "); DDRAW_dump_flags(lpcaps->dwCaps2, flags2, sizeof(flags2)/sizeof(flags2[0]));
1123 TRACE(" - dwCKeyCaps : "); DDRAW_dump_flags(lpcaps->dwCKeyCaps, flags3, sizeof(flags3)/sizeof(flags3[0]));
1124 TRACE(" - dwFXCaps : "); DDRAW_dump_flags(lpcaps->dwFXCaps, flags4, sizeof(flags4)/sizeof(flags4[0]));
1125 TRACE(" - dwFXAlphaCaps : "); DDRAW_dump_flags(lpcaps->dwFXAlphaCaps, flags5, sizeof(flags5)/sizeof(flags5[0]));
1126 TRACE(" - dwPalCaps : "); DDRAW_dump_flags(lpcaps->dwPalCaps, flags6, sizeof(flags6)/sizeof(flags6[0]));
1127 TRACE(" - dwSVCaps : "); DDRAW_dump_flags(lpcaps->dwSVCaps, flags7, sizeof(flags7)/sizeof(flags7[0]));
1128 TRACE("...\n");
1129 TRACE(" - dwNumFourCCCodes : %d\n", lpcaps->dwNumFourCCCodes);
1130 TRACE(" - dwCurrVisibleOverlays : %d\n", lpcaps->dwCurrVisibleOverlays);
1131 TRACE(" - dwMinOverlayStretch : %d\n", lpcaps->dwMinOverlayStretch);
1132 TRACE(" - dwMaxOverlayStretch : %d\n", lpcaps->dwMaxOverlayStretch);
1133 TRACE("...\n");
1134 TRACE(" - ddsCaps : "); DDRAW_dump_DDSCAPS2(&lpcaps->ddsCaps);
1135 }
1136
1137 /*****************************************************************************
1138 * multiply_matrix
1139 *
1140 * Multiplies 2 4x4 matrices src1 and src2, and stores the result in dest.
1141 *
1142 * Params:
1143 * dest: Pointer to the destination matrix
1144 * src1: Pointer to the first source matrix
1145 * src2: Pointer to the second source matrix
1146 *
1147 *****************************************************************************/
1148 void
1149 multiply_matrix(D3DMATRIX *dest,
1150 const D3DMATRIX *src1,
1151 const D3DMATRIX *src2)
1152 {
1153 D3DMATRIX temp;
1154
1155 /* Now do the multiplication 'by hand'.
1156 I know that all this could be optimised, but this will be done later :-) */
1157 temp._11 = (src1->_11 * src2->_11) + (src1->_21 * src2->_12) + (src1->_31 * src2->_13) + (src1->_41 * src2->_14);
1158 temp._21 = (src1->_11 * src2->_21) + (src1->_21 * src2->_22) + (src1->_31 * src2->_23) + (src1->_41 * src2->_24);
1159 temp._31 = (src1->_11 * src2->_31) + (src1->_21 * src2->_32) + (src1->_31 * src2->_33) + (src1->_41 * src2->_34);
1160 temp._41 = (src1->_11 * src2->_41) + (src1->_21 * src2->_42) + (src1->_31 * src2->_43) + (src1->_41 * src2->_44);
1161
1162 temp._12 = (src1->_12 * src2->_11) + (src1->_22 * src2->_12) + (src1->_32 * src2->_13) + (src1->_42 * src2->_14);
1163 temp._22 = (src1->_12 * src2->_21) + (src1->_22 * src2->_22) + (src1->_32 * src2->_23) + (src1->_42 * src2->_24);
1164 temp._32 = (src1->_12 * src2->_31) + (src1->_22 * src2->_32) + (src1->_32 * src2->_33) + (src1->_42 * src2->_34);
1165 temp._42 = (src1->_12 * src2->_41) + (src1->_22 * src2->_42) + (src1->_32 * src2->_43) + (src1->_42 * src2->_44);
1166
1167 temp._13 = (src1->_13 * src2->_11) + (src1->_23 * src2->_12) + (src1->_33 * src2->_13) + (src1->_43 * src2->_14);
1168 temp._23 = (src1->_13 * src2->_21) + (src1->_23 * src2->_22) + (src1->_33 * src2->_23) + (src1->_43 * src2->_24);
1169 temp._33 = (src1->_13 * src2->_31) + (src1->_23 * src2->_32) + (src1->_33 * src2->_33) + (src1->_43 * src2->_34);
1170 temp._43 = (src1->_13 * src2->_41) + (src1->_23 * src2->_42) + (src1->_33 * src2->_43) + (src1->_43 * src2->_44);
1171
1172 temp._14 = (src1->_14 * src2->_11) + (src1->_24 * src2->_12) + (src1->_34 * src2->_13) + (src1->_44 * src2->_14);
1173 temp._24 = (src1->_14 * src2->_21) + (src1->_24 * src2->_22) + (src1->_34 * src2->_23) + (src1->_44 * src2->_24);
1174 temp._34 = (src1->_14 * src2->_31) + (src1->_24 * src2->_32) + (src1->_34 * src2->_33) + (src1->_44 * src2->_34);
1175 temp._44 = (src1->_14 * src2->_41) + (src1->_24 * src2->_42) + (src1->_34 * src2->_43) + (src1->_44 * src2->_44);
1176
1177 /* And copy the new matrix in the good storage.. */
1178 memcpy(dest, &temp, 16 * sizeof(D3DVALUE));
1179 }
1180
1181 HRESULT
1182 hr_ddraw_from_wined3d(HRESULT hr)
1183 {
1184 switch(hr)
1185 {
1186 case WINED3DERR_INVALIDCALL: return DDERR_INVALIDPARAMS;
1187 default: return hr;
1188 }
1189 }
1190
1191 /* Note that this function writes the full sizeof(DDSURFACEDESC2) size, don't use it
1192 * for writing into application-provided DDSURFACEDESC2 structures if the size may
1193 * be different */
1194 void DDSD_to_DDSD2(const DDSURFACEDESC *in, DDSURFACEDESC2 *out)
1195 {
1196 /* The output of this function is never passed to the application directly, so
1197 * the memset is not strictly needed. CreateSurface still has problems with this
1198 * though. Don't forget to set ddsCaps.dwCaps2/3/4 to 0 when removing this */
1199 memset(out, 0x00, sizeof(*out));
1200 out->dwSize = sizeof(*out);
1201 out->dwFlags = in->dwFlags & ~DDSD_ZBUFFERBITDEPTH;
1202 if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth;
1203 if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight;
1204 if (in->dwFlags & DDSD_PIXELFORMAT) out->u4.ddpfPixelFormat = in->ddpfPixelFormat;
1205 else if(in->dwFlags & DDSD_ZBUFFERBITDEPTH)
1206 {
1207 out->dwFlags |= DDSD_PIXELFORMAT;
1208 memset(&out->u4.ddpfPixelFormat, 0, sizeof(out->u4.ddpfPixelFormat));
1209 out->u4.ddpfPixelFormat.dwSize = sizeof(out->u4.ddpfPixelFormat);
1210 out->u4.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER;
1211 out->u4.ddpfPixelFormat.u1.dwZBufferBitDepth = in->u2.dwZBufferBitDepth;
1212 /* 0 is not a valid DDSURFACEDESC / DDPIXELFORMAT on either side of the
1213 * conversion */
1214 out->u4.ddpfPixelFormat.u3.dwZBitMask = ~0U >> (32 - in->u2.dwZBufferBitDepth);
1215 }
1216 /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */
1217 out->ddsCaps.dwCaps = in->ddsCaps.dwCaps;
1218 if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch;
1219 if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->u5.dwBackBufferCount = in->dwBackBufferCount;
1220 if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth;
1221 /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */
1222 out->lpSurface = in->lpSurface;
1223 if (in->dwFlags & DDSD_CKDESTOVERLAY) out->u3.ddckCKDestOverlay = in->ddckCKDestOverlay;
1224 if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt;
1225 if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay;
1226 if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt;
1227 if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount;
1228 if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate;
1229 if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize;
1230 /* Does not exist in DDSURFACEDESC:
1231 * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE,
1232 */
1233 }
1234
1235 /* Note that this function writes the full sizeof(DDSURFACEDESC) size, don't use it
1236 * for writing into application-provided DDSURFACEDESC structures if the size may
1237 * be different */
1238 void DDSD2_to_DDSD(const DDSURFACEDESC2 *in, DDSURFACEDESC *out)
1239 {
1240 memset(out, 0, sizeof(*out));
1241 out->dwSize = sizeof(*out);
1242 out->dwFlags = in->dwFlags;
1243 if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth;
1244 if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight;
1245 if (in->dwFlags & DDSD_PIXELFORMAT)
1246 {
1247 out->ddpfPixelFormat = in->u4.ddpfPixelFormat;
1248 if ((in->dwFlags & DDSD_CAPS) && (in->ddsCaps.dwCaps & DDSCAPS_ZBUFFER))
1249 {
1250 /* Z buffers have DDSD_ZBUFFERBITDEPTH set, but not DDSD_PIXELFORMAT. They do
1251 * have valid data in ddpfPixelFormat though */
1252 out->dwFlags &= ~DDSD_PIXELFORMAT;
1253 out->dwFlags |= DDSD_ZBUFFERBITDEPTH;
1254 out->u2.dwZBufferBitDepth = in->u4.ddpfPixelFormat.u1.dwZBufferBitDepth;
1255 }
1256 }
1257 /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */
1258 out->ddsCaps.dwCaps = in->ddsCaps.dwCaps;
1259 if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch;
1260 if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->dwBackBufferCount = in->u5.dwBackBufferCount;
1261 if (in->dwFlags & DDSD_ZBUFFERBITDEPTH) out->u2.dwZBufferBitDepth = in->u2.dwMipMapCount; /* same union */
1262 if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth;
1263 /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */
1264 out->lpSurface = in->lpSurface;
1265 if (in->dwFlags & DDSD_CKDESTOVERLAY) out->ddckCKDestOverlay = in->u3.ddckCKDestOverlay;
1266 if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt;
1267 if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay;
1268 if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt;
1269 if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount;
1270 if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate;
1271 if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize;
1272 /* Does not exist in DDSURFACEDESC:
1273 * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE,
1274 */
1275 if (in->dwFlags & DDSD_TEXTURESTAGE) WARN("Does not exist in DDSURFACEDESC: DDSD_TEXTURESTAGE\n");
1276 if (in->dwFlags & DDSD_FVF) WARN("Does not exist in DDSURFACEDESC: DDSD_FVF\n");
1277 if (in->dwFlags & DDSD_SRCVBHANDLE) WARN("Does not exist in DDSURFACEDESC: DDSD_SRCVBHANDLE\n");
1278 out->dwFlags &= ~(DDSD_TEXTURESTAGE | DDSD_FVF | DDSD_SRCVBHANDLE);
1279 }
Windows API implementation