2 * Unit tests for (a few) ddraw surface functions
4 * Copyright (C) 2005 Antoine Chavasse (a.chavasse@gmail.com)
5 * Copyright (C) 2005 Christian Costa
6 * Copyright 2005 Ivan Leo Puoti
7 * Copyright (C) 2007 Stefan Dösinger
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.
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.
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
26 #include "wine/test.h"
30 static LPDIRECTDRAW lpDD
= NULL
;
32 static BOOL
CreateDirectDraw(void)
36 rc
= DirectDrawCreate(NULL
, &lpDD
, NULL
);
37 ok(rc
==DD_OK
|| rc
==DDERR_NODIRECTDRAWSUPPORT
, "DirectDrawCreateEx returned: %x\n", rc
);
39 trace("DirectDrawCreateEx() failed with an error %x\n", rc
);
43 rc
= IDirectDraw_SetCooperativeLevel(lpDD
, NULL
, DDSCL_NORMAL
);
44 ok(rc
==DD_OK
,"SetCooperativeLevel returned: %x\n",rc
);
50 static void ReleaseDirectDraw(void)
54 IDirectDraw_Release(lpDD
);
59 static void MipMapCreationTest(void)
61 LPDIRECTDRAWSURFACE lpDDSMipMapTest
;
65 /* First mipmap creation test: create a surface with DDSCAPS_COMPLEX,
66 DDSCAPS_MIPMAP, and DDSD_MIPMAPCOUNT. This create the number of
67 requested mipmap levels. */
68 ddsd
.dwSize
= sizeof(ddsd
);
69 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_MIPMAPCOUNT
;
70 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
71 U2(ddsd
).dwMipMapCount
= 3;
74 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpDDSMipMapTest
, NULL
);
75 ok(rc
==DD_OK
,"CreateSurface returned: %x\n",rc
);
77 skip("failed to create surface\n");
81 /* Check the number of created mipmaps */
82 memset(&ddsd
, 0, sizeof(DDSURFACEDESC
));
83 ddsd
.dwSize
= sizeof(ddsd
);
84 rc
= IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest
, &ddsd
);
85 ok(rc
==DD_OK
,"GetSurfaceDesc returned: %x\n",rc
);
86 ok(ddsd
.dwFlags
& DDSD_MIPMAPCOUNT
,
87 "GetSurfaceDesc returned no mipmapcount.\n");
88 ok(U2(ddsd
).dwMipMapCount
== 3, "Incorrect mipmap count: %d.\n",
89 U2(ddsd
).dwMipMapCount
);
91 /* Destroy the surface. */
92 IDirectDrawSurface_Release(lpDDSMipMapTest
);
95 /* Second mipmap creation test: create a surface without a mipmap
96 count, with DDSCAPS_MIPMAP and without DDSCAPS_COMPLEX.
97 This creates a single mipmap level. */
98 memset(&ddsd
, 0, sizeof(DDSURFACEDESC
));
99 ddsd
.dwSize
= sizeof(ddsd
);
100 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
101 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_MIPMAP
;
104 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpDDSMipMapTest
, NULL
);
105 ok(rc
==DD_OK
,"CreateSurface returned: %x\n",rc
);
107 skip("failed to create surface\n");
110 /* Check the number of created mipmaps */
111 memset(&ddsd
, 0, sizeof(DDSURFACEDESC
));
112 ddsd
.dwSize
= sizeof(ddsd
);
113 rc
= IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest
, &ddsd
);
114 ok(rc
==DD_OK
,"GetSurfaceDesc returned: %x\n",rc
);
115 ok(ddsd
.dwFlags
& DDSD_MIPMAPCOUNT
,
116 "GetSurfaceDesc returned no mipmapcount.\n");
117 ok(U2(ddsd
).dwMipMapCount
== 1, "Incorrect mipmap count: %d.\n",
118 U2(ddsd
).dwMipMapCount
);
120 /* Destroy the surface. */
121 IDirectDrawSurface_Release(lpDDSMipMapTest
);
124 /* Third mipmap creation test: create a surface with DDSCAPS_MIPMAP,
125 DDSCAPS_COMPLEX and without DDSD_MIPMAPCOUNT.
126 It's an undocumented features where a chain of mipmaps, starting from
127 he specified size and down to the smallest size, is automatically
129 Anarchy Online needs this feature to work. */
130 memset(&ddsd
, 0, sizeof(DDSURFACEDESC
));
131 ddsd
.dwSize
= sizeof(ddsd
);
132 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
133 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
136 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpDDSMipMapTest
, NULL
);
137 ok(rc
==DD_OK
,"CreateSurface returned: %x\n",rc
);
139 skip("failed to create surface\n");
143 /* Check the number of created mipmaps */
144 memset(&ddsd
, 0, sizeof(DDSURFACEDESC
));
145 ddsd
.dwSize
= sizeof(ddsd
);
146 rc
= IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest
, &ddsd
);
147 ok(rc
==DD_OK
,"GetSurfaceDesc returned: %x\n",rc
);
148 ok(ddsd
.dwFlags
& DDSD_MIPMAPCOUNT
,
149 "GetSurfaceDesc returned no mipmapcount.\n");
150 ok(U2(ddsd
).dwMipMapCount
== 6, "Incorrect mipmap count: %d.\n",
151 U2(ddsd
).dwMipMapCount
);
153 /* Destroy the surface. */
154 IDirectDrawSurface_Release(lpDDSMipMapTest
);
157 /* Fourth mipmap creation test: same as above with a different texture
159 The purpose is to verify that the number of generated mipmaps is
160 dependent on the smallest dimension. */
161 memset(&ddsd
, 0, sizeof(DDSURFACEDESC
));
162 ddsd
.dwSize
= sizeof(ddsd
);
163 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
164 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
167 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpDDSMipMapTest
, NULL
);
168 ok(rc
==DD_OK
,"CreateSurface returned: %x\n",rc
);
170 skip("failed to create surface\n");
174 /* Check the number of created mipmaps */
175 memset(&ddsd
, 0, sizeof(DDSURFACEDESC
));
176 ddsd
.dwSize
= sizeof(ddsd
);
177 rc
= IDirectDrawSurface_GetSurfaceDesc(lpDDSMipMapTest
, &ddsd
);
178 ok(rc
==DD_OK
,"GetSurfaceDesc returned: %x\n",rc
);
179 ok(ddsd
.dwFlags
& DDSD_MIPMAPCOUNT
,
180 "GetSurfaceDesc returned no mipmapcount.\n");
181 ok(U2(ddsd
).dwMipMapCount
== 6, "Incorrect mipmap count: %d.\n",
182 U2(ddsd
).dwMipMapCount
);
184 /* Destroy the surface. */
185 IDirectDrawSurface_Release(lpDDSMipMapTest
);
188 /* Fifth mipmap creation test: try to create a surface with
189 DDSCAPS_COMPLEX, DDSCAPS_MIPMAP, DDSD_MIPMAPCOUNT,
190 where dwMipMapCount = 0. This should fail. */
192 ddsd
.dwSize
= sizeof(ddsd
);
193 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_MIPMAPCOUNT
;
194 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
195 U2(ddsd
).dwMipMapCount
= 0;
198 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpDDSMipMapTest
, NULL
);
199 ok(rc
==DDERR_INVALIDPARAMS
,"CreateSurface returned: %x\n",rc
);
201 /* Destroy the surface. */
203 IDirectDrawSurface_Release(lpDDSMipMapTest
);
207 static void SrcColorKey32BlitTest(void)
209 LPDIRECTDRAWSURFACE lpSrc
;
210 LPDIRECTDRAWSURFACE lpDst
;
211 DDSURFACEDESC ddsd
, ddsd2
, ddsd3
;
212 DDCOLORKEY DDColorKey
;
217 ddsd2
.dwSize
= sizeof(ddsd2
);
218 ddsd2
.ddpfPixelFormat
.dwSize
= sizeof(ddsd2
.ddpfPixelFormat
);
220 ddsd
.dwSize
= sizeof(ddsd
);
221 ddsd
.ddpfPixelFormat
.dwSize
= sizeof(ddsd
.ddpfPixelFormat
);
222 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
;
223 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
226 ddsd
.ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
227 U1(ddsd
.ddpfPixelFormat
).dwRGBBitCount
= 32;
228 U2(ddsd
.ddpfPixelFormat
).dwRBitMask
= 0xFF0000;
229 U3(ddsd
.ddpfPixelFormat
).dwGBitMask
= 0x00FF00;
230 U4(ddsd
.ddpfPixelFormat
).dwBBitMask
= 0x0000FF;
231 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpDst
, NULL
);
232 ok(rc
==DD_OK
,"CreateSurface returned: %x\n",rc
);
234 skip("failed to create surface\n");
238 ddsd
.dwFlags
|= DDSD_CKSRCBLT
;
239 ddsd
.ddckCKSrcBlt
.dwColorSpaceLowValue
= 0xFF00FF;
240 ddsd
.ddckCKSrcBlt
.dwColorSpaceHighValue
= 0xFF00FF;
241 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpSrc
, NULL
);
242 ok(rc
==DD_OK
,"CreateSurface returned: %x\n",rc
);
244 skip("failed to create surface\n");
248 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
249 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
250 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
251 lpData
[0] = 0xCCCCCCCC;
252 lpData
[1] = 0xCCCCCCCC;
253 lpData
[2] = 0xCCCCCCCC;
254 lpData
[3] = 0xCCCCCCCC;
256 memset(&ddsd3
, 0, sizeof(ddsd3
));
257 ddsd3
.dwSize
= sizeof(ddsd3
);
258 ddsd3
.ddpfPixelFormat
.dwSize
= sizeof(ddsd3
.ddpfPixelFormat
);
259 rc
= IDirectDrawSurface_GetSurfaceDesc(lpDst
, &ddsd3
);
260 ok(rc
== DD_OK
, "IDirectDrawSurface_GetSurfaceDesc between a lock/unlock pair returned %08x\n", rc
);
261 ok(ddsd3
.lpSurface
== ddsd3
.lpSurface
, "lpSurface from GetSurfaceDesc(%p) differs from the one returned by Lock(%p)\n", ddsd3
.lpSurface
, ddsd2
.lpSurface
);
263 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
264 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
266 memset(&ddsd3
, 0, sizeof(ddsd3
));
267 ddsd3
.dwSize
= sizeof(ddsd3
);
268 ddsd3
.ddpfPixelFormat
.dwSize
= sizeof(ddsd3
.ddpfPixelFormat
);
269 rc
= IDirectDrawSurface_GetSurfaceDesc(lpDst
, &ddsd3
);
270 ok(rc
== DD_OK
, "IDirectDrawSurface_GetSurfaceDesc between a lock/unlock pair returned %08x\n", rc
);
271 ok(ddsd3
.lpSurface
== NULL
, "lpSurface from GetSurfaceDesc(%p) is not NULL after unlock\n", ddsd3
.lpSurface
);
273 rc
= IDirectDrawSurface_Lock(lpSrc
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
274 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
275 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
276 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
277 lpData
[0] = 0x77010203;
278 lpData
[1] = 0x00010203;
279 lpData
[2] = 0x77FF00FF;
280 lpData
[3] = 0x00FF00FF;
281 rc
= IDirectDrawSurface_Unlock(lpSrc
, NULL
);
282 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
284 IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRC
, NULL
);
286 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
287 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
288 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
289 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
290 /* Different behavior on some drivers / windows versions. Some versions ignore the X channel when
291 * color keying, but copy it to the destination surface. Others apply it for color keying, but
292 * do not copy it into the destination surface.
294 if(lpData
[0]==0x00010203) {
295 trace("X channel was not copied into the destination surface\n");
296 ok((lpData
[0]==0x00010203)&&(lpData
[1]==0x00010203)&&(lpData
[2]==0x00FF00FF)&&(lpData
[3]==0xCCCCCCCC),
297 "Destination data after blitting is not correct\n");
299 ok((lpData
[0]==0x77010203)&&(lpData
[1]==0x00010203)&&(lpData
[2]==0xCCCCCCCC)&&(lpData
[3]==0xCCCCCCCC),
300 "Destination data after blitting is not correct\n");
302 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
303 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
305 /* Also test SetColorKey */
306 IDirectDrawSurface_GetColorKey(lpSrc
, DDCKEY_SRCBLT
, &DDColorKey
);
307 ok(DDColorKey
.dwColorSpaceLowValue
== 0xFF00FF && DDColorKey
.dwColorSpaceHighValue
== 0xFF00FF,
308 "GetColorKey does not return the colorkey used at surface creation\n");
310 DDColorKey
.dwColorSpaceLowValue
= 0x00FF00;
311 DDColorKey
.dwColorSpaceHighValue
= 0x00FF00;
312 IDirectDrawSurface_SetColorKey(lpSrc
, DDCKEY_SRCBLT
, &DDColorKey
);
314 DDColorKey
.dwColorSpaceLowValue
= 0;
315 DDColorKey
.dwColorSpaceHighValue
= 0;
316 IDirectDrawSurface_GetColorKey(lpSrc
, DDCKEY_SRCBLT
, &DDColorKey
);
317 ok(DDColorKey
.dwColorSpaceLowValue
== 0x00FF00 && DDColorKey
.dwColorSpaceHighValue
== 0x00FF00,
318 "GetColorKey does not return the colorkey set with SetColorKey\n");
320 ddsd
.ddckCKSrcBlt
.dwColorSpaceLowValue
= 0;
321 ddsd
.ddckCKSrcBlt
.dwColorSpaceHighValue
= 0;
322 IDirectDrawSurface_GetSurfaceDesc(lpSrc
, &ddsd
);
323 ok(ddsd
.ddckCKSrcBlt
.dwColorSpaceLowValue
== 0x00FF00 && ddsd
.ddckCKSrcBlt
.dwColorSpaceHighValue
== 0x00FF00,
324 "GetSurfaceDesc does not return the colorkey set with SetColorKey\n");
326 IDirectDrawSurface_Release(lpSrc
);
327 IDirectDrawSurface_Release(lpDst
);
329 /* start with a new set of surfaces to test the color keying parameters to blit */
330 memset(&ddsd
, 0, sizeof(ddsd
));
331 ddsd
.dwSize
= sizeof(ddsd
);
332 ddsd
.ddpfPixelFormat
.dwSize
= sizeof(ddsd
.ddpfPixelFormat
);
333 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CKSRCBLT
| DDSD_CKDESTBLT
;
334 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
337 ddsd
.ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
338 U1(ddsd
.ddpfPixelFormat
).dwRGBBitCount
= 32;
339 U2(ddsd
.ddpfPixelFormat
).dwRBitMask
= 0xFF0000;
340 U3(ddsd
.ddpfPixelFormat
).dwGBitMask
= 0x00FF00;
341 U4(ddsd
.ddpfPixelFormat
).dwBBitMask
= 0x0000FF;
342 ddsd
.ddckCKDestBlt
.dwColorSpaceLowValue
= 0xFF0000;
343 ddsd
.ddckCKDestBlt
.dwColorSpaceHighValue
= 0xFF0000;
344 ddsd
.ddckCKSrcBlt
.dwColorSpaceLowValue
= 0x00FF00;
345 ddsd
.ddckCKSrcBlt
.dwColorSpaceHighValue
= 0x00FF00;
346 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpDst
, NULL
);
347 ok(rc
==DD_OK
|| rc
== DDERR_NOCOLORKEYHW
,"CreateSurface returned: %x\n",rc
);
350 skip("Failed to create surface\n");
354 /* start with a new set of surfaces to test the color keying parameters to blit */
355 memset(&ddsd
, 0, sizeof(ddsd
));
356 ddsd
.dwSize
= sizeof(ddsd
);
357 ddsd
.ddpfPixelFormat
.dwSize
= sizeof(ddsd
.ddpfPixelFormat
);
358 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CKSRCBLT
| DDSD_CKDESTBLT
;
359 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
362 ddsd
.ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
363 U1(ddsd
.ddpfPixelFormat
).dwRGBBitCount
= 32;
364 U2(ddsd
.ddpfPixelFormat
).dwRBitMask
= 0xFF0000;
365 U3(ddsd
.ddpfPixelFormat
).dwGBitMask
= 0x00FF00;
366 U4(ddsd
.ddpfPixelFormat
).dwBBitMask
= 0x0000FF;
367 ddsd
.ddckCKSrcBlt
.dwColorSpaceLowValue
= 0x0000FF;
368 ddsd
.ddckCKSrcBlt
.dwColorSpaceHighValue
= 0x0000FF;
369 ddsd
.ddckCKDestBlt
.dwColorSpaceLowValue
= 0x000000;
370 ddsd
.ddckCKDestBlt
.dwColorSpaceHighValue
= 0x000000;
371 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpSrc
, NULL
);
372 ok(rc
==DD_OK
|| rc
== DDERR_NOCOLORKEYHW
,"CreateSurface returned: %x\n",rc
);
375 skip("Failed to create surface\n");
376 IDirectDrawSurface_Release(lpDst
);
380 memset(&fx
, 0, sizeof(fx
));
381 fx
.dwSize
= sizeof(fx
);
382 fx
.ddckSrcColorkey
.dwColorSpaceHighValue
= 0x110000;
383 fx
.ddckSrcColorkey
.dwColorSpaceLowValue
= 0x110000;
384 fx
.ddckDestColorkey
.dwColorSpaceHighValue
= 0x001100;
385 fx
.ddckDestColorkey
.dwColorSpaceLowValue
= 0x001100;
387 rc
= IDirectDrawSurface_Lock(lpSrc
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
388 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
389 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
390 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
391 lpData
[0] = 0x000000FF; /* Applies to src blt key in src surface */
392 lpData
[1] = 0x00000000; /* Applies to dst blt key in src surface */
393 lpData
[2] = 0x00FF0000; /* Dst color key in dst surface */
394 lpData
[3] = 0x0000FF00; /* Src color key in dst surface */
395 lpData
[4] = 0x00001100; /* Src color key in ddbltfx */
396 lpData
[5] = 0x00110000; /* Dst color key in ddbltfx */
397 rc
= IDirectDrawSurface_Unlock(lpSrc
, NULL
);
398 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
400 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
401 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
402 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
403 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
404 lpData
[0] = 0x55555555;
405 lpData
[1] = 0x55555555;
406 lpData
[2] = 0x55555555;
407 lpData
[3] = 0x55555555;
408 lpData
[4] = 0x55555555;
409 lpData
[5] = 0x55555555;
410 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
411 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
413 /* Test a blit without keying */
414 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, 0, &fx
);
415 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
417 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
418 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
419 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
420 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
421 /* Should have copied src data unmodified to dst */
422 ok(lpData
[0] == 0x000000FF &&
423 lpData
[1] == 0x00000000 &&
424 lpData
[2] == 0x00FF0000 &&
425 lpData
[3] == 0x0000FF00 &&
426 lpData
[4] == 0x00001100 &&
427 lpData
[5] == 0x00110000, "Surface data after unkeyed blit does not match\n");
429 lpData
[0] = 0x55555555;
430 lpData
[1] = 0x55555555;
431 lpData
[2] = 0x55555555;
432 lpData
[3] = 0x55555555;
433 lpData
[4] = 0x55555555;
434 lpData
[5] = 0x55555555;
435 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
436 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
439 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRC
, &fx
);
440 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
442 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
443 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
444 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
445 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
447 ok(lpData
[0] == 0x55555555 && /* Here the src key applied */
448 lpData
[1] == 0x00000000 &&
449 lpData
[2] == 0x00FF0000 &&
450 lpData
[3] == 0x0000FF00 &&
451 lpData
[4] == 0x00001100 &&
452 lpData
[5] == 0x00110000, "Surface data after srckey blit does not match\n");
454 lpData
[0] = 0x55555555;
455 lpData
[1] = 0x55555555;
456 lpData
[2] = 0x55555555;
457 lpData
[3] = 0x55555555;
458 lpData
[4] = 0x55555555;
459 lpData
[5] = 0x55555555;
460 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
461 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
464 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRCOVERRIDE
, &fx
);
465 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
467 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
468 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
469 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
470 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
472 ok(lpData
[0] == 0x000000FF &&
473 lpData
[1] == 0x00000000 &&
474 lpData
[2] == 0x00FF0000 &&
475 lpData
[3] == 0x0000FF00 &&
476 lpData
[4] == 0x00001100 &&
477 lpData
[5] == 0x55555555, /* Override key applies here */
478 "Surface data after src override key blit does not match\n");
480 lpData
[0] = 0x55555555;
481 lpData
[1] = 0x55555555;
482 lpData
[2] = 0x55555555;
483 lpData
[3] = 0x55555555;
484 lpData
[4] = 0x55555555;
485 lpData
[5] = 0x55555555;
486 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
487 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
489 /* Src override AND src key. That is not supposed to work */
490 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRC
| DDBLT_KEYSRCOVERRIDE
, &fx
);
491 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
493 /* Verify that the destination is unchanged */
494 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
495 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
496 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
497 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
499 ok(lpData
[0] == 0x55555555 &&
500 lpData
[1] == 0x55555555 &&
501 lpData
[2] == 0x55555555 &&
502 lpData
[3] == 0x55555555 &&
503 lpData
[4] == 0x55555555 &&
504 lpData
[5] == 0x55555555, /* Override key applies here */
505 "Surface data after src key blit with override does not match\n");
507 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
508 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
509 lpData
[2] = 0x00001100; /* Dest key in override */
510 lpData
[3] = 0x00001100; /* Dest key in override */
511 lpData
[4] = 0x00000000; /* Dest key in src surface */
512 lpData
[5] = 0x00000000; /* Dest key in src surface */
513 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
514 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
517 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDEST
, &fx
);
518 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
520 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
521 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
522 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
523 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
525 /* DirectDraw uses the dest blit key from the SOURCE surface ! */
526 ok(lpData
[0] == 0x00ff0000 &&
527 lpData
[1] == 0x00ff0000 &&
528 lpData
[2] == 0x00001100 &&
529 lpData
[3] == 0x00001100 &&
530 lpData
[4] == 0x00001100 && /* Key applies here */
531 lpData
[5] == 0x00110000, /* Key applies here */
532 "Surface data after dest key blit does not match\n");
534 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
535 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
536 lpData
[2] = 0x00001100; /* Dest key in override */
537 lpData
[3] = 0x00001100; /* Dest key in override */
538 lpData
[4] = 0x00000000; /* Dest key in src surface */
539 lpData
[5] = 0x00000000; /* Dest key in src surface */
540 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
541 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
543 /* Dest override key blit */
544 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDESTOVERRIDE
, &fx
);
545 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
547 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
548 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
549 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
550 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
552 ok(lpData
[0] == 0x00FF0000 &&
553 lpData
[1] == 0x00FF0000 &&
554 lpData
[2] == 0x00FF0000 && /* Key applies here */
555 lpData
[3] == 0x0000FF00 && /* Key applies here */
556 lpData
[4] == 0x00000000 &&
557 lpData
[5] == 0x00000000,
558 "Surface data after dest key override blit does not match\n");
560 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
561 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
562 lpData
[2] = 0x00001100; /* Dest key in override */
563 lpData
[3] = 0x00001100; /* Dest key in override */
564 lpData
[4] = 0x00000000; /* Dest key in src surface */
565 lpData
[5] = 0x00000000; /* Dest key in src surface */
566 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
567 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
569 /* Dest override key blit. Supposed to fail too */
570 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDEST
| DDBLT_KEYDESTOVERRIDE
, &fx
);
571 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
573 /* Check for unchanged data */
574 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
575 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
576 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
577 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
579 ok(lpData
[0] == 0x00FF0000 &&
580 lpData
[1] == 0x00FF0000 &&
581 lpData
[2] == 0x00001100 && /* Key applies here */
582 lpData
[3] == 0x00001100 && /* Key applies here */
583 lpData
[4] == 0x00000000 &&
584 lpData
[5] == 0x00000000,
585 "Surface data with dest key and dest override does not match\n");
587 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
588 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
589 lpData
[2] = 0x00001100; /* Dest key in override */
590 lpData
[3] = 0x00001100; /* Dest key in override */
591 lpData
[4] = 0x00000000; /* Dest key in src surface */
592 lpData
[5] = 0x00000000; /* Dest key in src surface */
593 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
594 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
596 /* Modify the source data a bit to give some more conclusive results */
597 rc
= IDirectDrawSurface_Lock(lpSrc
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
598 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
599 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
600 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
601 lpData
[5] = 0x000000FF; /* Applies to src blt key in src surface */
602 rc
= IDirectDrawSurface_Unlock(lpSrc
, NULL
);
603 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
605 /* Source and destination key */
606 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDEST
| DDBLT_KEYSRC
, &fx
);
607 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
609 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
610 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
611 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
612 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
614 ok(lpData
[0] == 0x00FF0000 && /* Masked by Destination key */
615 lpData
[1] == 0x00FF0000 && /* Masked by Destination key */
616 lpData
[2] == 0x00001100 && /* Masked by Destination key */
617 lpData
[3] == 0x00001100 && /* Masked by Destination key */
618 lpData
[4] == 0x00001100 && /* Allowed by destination key, not masked by source key */
619 lpData
[5] == 0x00000000, /* Allowed by dst key, but masked by source key */
620 "Surface data with src key and dest key blit does not match\n");
622 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
623 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
624 lpData
[2] = 0x00001100; /* Dest key in override */
625 lpData
[3] = 0x00001100; /* Dest key in override */
626 lpData
[4] = 0x00000000; /* Dest key in src surface */
627 lpData
[5] = 0x00000000; /* Dest key in src surface */
628 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
629 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
631 /* Override keys without ddbltfx parameter fail */
632 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDESTOVERRIDE
, NULL
);
633 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
634 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRCOVERRIDE
, NULL
);
635 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
637 /* Try blitting without keys in the source surface*/
638 rc
= IDirectDrawSurface_SetColorKey(lpSrc
, DDCKEY_SRCBLT
, NULL
);
639 ok(rc
== DD_OK
, "SetColorKey returned %x\n", rc
);
640 rc
= IDirectDrawSurface_SetColorKey(lpSrc
, DDCKEY_DESTBLT
, NULL
);
641 ok(rc
== DD_OK
, "SetColorKey returned %x\n", rc
);
643 /* That fails now. Do not bother to check that the data is unmodified */
644 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRC
, &fx
);
645 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
647 /* Dest key blit still works. Which key is used this time??? */
648 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDEST
, &fx
);
649 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
651 /* With korrectly passed override keys no key in the surface is needed.
652 * Again, the result was checked before, no need to do that again
654 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDESTOVERRIDE
, &fx
);
655 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
656 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRCOVERRIDE
, &fx
);
657 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
659 IDirectDrawSurface_Release(lpSrc
);
660 IDirectDrawSurface_Release(lpDst
);
663 static void QueryInterface(void)
665 LPDIRECTDRAWSURFACE dsurface
;
666 DDSURFACEDESC surface
;
670 /* Create a surface */
671 ZeroMemory(&surface
, sizeof(surface
));
672 surface
.dwSize
= sizeof(surface
);
673 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
674 surface
.dwHeight
= 10;
675 surface
.dwWidth
= 10;
676 ret
= IDirectDraw_CreateSurface(lpDD
, &surface
, &dsurface
, NULL
);
679 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
683 /* Call IUnknown::QueryInterface */
684 ret
= IDirectDrawSurface_QueryInterface(dsurface
, 0, &object
);
685 ok(ret
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface::QueryInterface returned %x\n", ret
);
687 IDirectDrawSurface_Release(dsurface
);
690 /* The following tests test which interface is returned by IDirectDrawSurfaceX::GetDDInterface.
691 * It uses refcounts to test that and compares the interface addresses. Partially fits here, and
692 * partially in the refcount test
695 static unsigned long getref(IUnknown
*iface
)
697 IUnknown_AddRef(iface
);
698 return IUnknown_Release(iface
);
701 static void GetDDInterface_1(void)
703 LPDIRECTDRAWSURFACE dsurface
;
704 LPDIRECTDRAWSURFACE2 dsurface2
;
705 DDSURFACEDESC surface
;
710 unsigned long ref1
, ref2
, ref4
, ref7
;
713 /* Create a surface */
714 ZeroMemory(&surface
, sizeof(surface
));
715 surface
.dwSize
= sizeof(surface
);
716 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
717 surface
.dwHeight
= 10;
718 surface
.dwWidth
= 10;
719 ret
= IDirectDraw_CreateSurface(lpDD
, &surface
, &dsurface
, NULL
);
722 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
725 ret
= IDirectDrawSurface_QueryInterface(dsurface
, &IID_IDirectDrawSurface2
, (void **) &dsurface2
);
726 ok(ret
== DD_OK
, "IDirectDrawSurface_QueryInterface returned %08x\n", ret
);
727 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw2
, (void **) &dd2
);
728 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
729 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw4
, (void **) &dd4
);
730 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
731 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
732 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
734 ref1
= getref((IUnknown
*) lpDD
);
735 ok(ref1
== 1, "IDirectDraw refcount is %ld\n", ref1
);
736 ref2
= getref((IUnknown
*) dd2
);
737 ok(ref2
== 1, "IDirectDraw2 refcount is %ld\n", ref2
);
738 ref4
= getref((IUnknown
*) dd4
);
739 ok(ref4
== 1, "IDirectDraw4 refcount is %ld\n", ref4
);
740 ref7
= getref((IUnknown
*) dd7
);
741 ok(ref7
== 1, "IDirectDraw7 refcount is %ld\n", ref7
);
744 ret
= IDirectDrawSurface2_GetDDInterface(dsurface2
, &dd
);
745 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
746 ok(getref((IUnknown
*) lpDD
) == ref1
+ 1, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
747 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
748 ok(getref((IUnknown
*) dd4
) == ref4
+ 0, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
749 ok(getref((IUnknown
*) dd7
) == ref7
+ 0, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
751 ok(dd
== lpDD
, "Returned interface pointer is not equal to the creation interface\n");
752 IUnknown_Release((IUnknown
*) dd
);
754 /* try a NULL pointer */
755 ret
= IDirectDrawSurface2_GetDDInterface(dsurface2
, NULL
);
756 ok(ret
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
758 IDirectDraw_Release(dd2
);
759 IDirectDraw_Release(dd4
);
760 IDirectDraw_Release(dd7
);
761 IDirectDrawSurface2_Release(dsurface2
);
762 IDirectDrawSurface_Release(dsurface
);
765 static void GetDDInterface_2(void)
767 LPDIRECTDRAWSURFACE dsurface
;
768 LPDIRECTDRAWSURFACE2 dsurface2
;
769 DDSURFACEDESC surface
;
774 unsigned long ref1
, ref2
, ref4
, ref7
;
777 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw2
, (void **) &dd2
);
778 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
779 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw4
, (void **) &dd4
);
780 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
781 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
782 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
784 /* Create a surface */
785 ZeroMemory(&surface
, sizeof(surface
));
786 surface
.dwSize
= sizeof(surface
);
787 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
788 surface
.dwHeight
= 10;
789 surface
.dwWidth
= 10;
790 ret
= IDirectDraw2_CreateSurface(dd2
, &surface
, &dsurface
, NULL
);
793 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
796 ret
= IDirectDrawSurface_QueryInterface(dsurface
, &IID_IDirectDrawSurface2
, (void **) &dsurface2
);
797 ok(ret
== DD_OK
, "IDirectDrawSurface_QueryInterface returned %08x\n", ret
);
799 ref1
= getref((IUnknown
*) lpDD
);
800 ok(ref1
== 1, "IDirectDraw refcount is %ld\n", ref1
);
801 ref2
= getref((IUnknown
*) dd2
);
802 ok(ref2
== 1, "IDirectDraw2 refcount is %ld\n", ref2
);
803 ref4
= getref((IUnknown
*) dd4
);
804 ok(ref4
== 1, "IDirectDraw4 refcount is %ld\n", ref4
);
805 ref7
= getref((IUnknown
*) dd7
);
806 ok(ref7
== 1, "IDirectDraw7 refcount is %ld\n", ref7
);
809 ret
= IDirectDrawSurface2_GetDDInterface(dsurface2
, &dd
);
810 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
811 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
812 ok(getref((IUnknown
*) dd2
) == ref2
+ 1, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
813 ok(getref((IUnknown
*) dd4
) == ref4
+ 0, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
814 ok(getref((IUnknown
*) dd7
) == ref7
+ 0, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
816 ok(dd
== dd2
, "Returned interface pointer is not equal to the creation interface\n");
817 IUnknown_Release((IUnknown
*) dd
);
819 IDirectDraw_Release(dd2
);
820 IDirectDraw_Release(dd4
);
821 IDirectDraw_Release(dd7
);
822 IDirectDrawSurface2_Release(dsurface2
);
823 IDirectDrawSurface_Release(dsurface
);
826 static void GetDDInterface_4(void)
828 LPDIRECTDRAWSURFACE2 dsurface2
;
829 LPDIRECTDRAWSURFACE4 dsurface4
;
830 DDSURFACEDESC2 surface
;
835 unsigned long ref1
, ref2
, ref4
, ref7
;
838 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw2
, (void **) &dd2
);
839 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
840 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw4
, (void **) &dd4
);
841 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
842 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
843 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
845 /* Create a surface */
846 ZeroMemory(&surface
, sizeof(surface
));
847 surface
.dwSize
= sizeof(surface
);
848 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
849 surface
.dwHeight
= 10;
850 surface
.dwWidth
= 10;
851 ret
= IDirectDraw4_CreateSurface(dd4
, &surface
, &dsurface4
, NULL
);
854 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
857 ret
= IDirectDrawSurface4_QueryInterface(dsurface4
, &IID_IDirectDrawSurface2
, (void **) &dsurface2
);
858 ok(ret
== DD_OK
, "IDirectDrawSurface_QueryInterface returned %08x\n", ret
);
860 ref1
= getref((IUnknown
*) lpDD
);
861 ok(ref1
== 1, "IDirectDraw refcount is %ld\n", ref1
);
862 ref2
= getref((IUnknown
*) dd2
);
863 ok(ref2
== 1, "IDirectDraw2 refcount is %ld\n", ref2
);
864 ref4
= getref((IUnknown
*) dd4
);
865 ok(ref4
== 2, "IDirectDraw4 refcount is %ld\n", ref4
);
866 ref7
= getref((IUnknown
*) dd7
);
867 ok(ref7
== 1, "IDirectDraw7 refcount is %ld\n", ref7
);
869 ret
= IDirectDrawSurface4_GetDDInterface(dsurface4
, &dd
);
870 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
871 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
872 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
873 ok(getref((IUnknown
*) dd4
) == ref4
+ 1, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
874 ok(getref((IUnknown
*) dd7
) == ref7
+ 0, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
876 ok(dd
== dd4
, "Returned interface pointer is not equal to the creation interface\n");
877 IUnknown_Release((IUnknown
*) dd
);
879 /* Now test what happens if we QI the surface for some other version - It should still return the creation interface */
880 ret
= IDirectDrawSurface2_GetDDInterface(dsurface2
, &dd
);
881 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
882 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
883 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
884 ok(getref((IUnknown
*) dd4
) == ref4
+ 1, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
885 ok(getref((IUnknown
*) dd7
) == ref7
+ 0, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
887 ok(dd
== dd4
, "Returned interface pointer is not equal to the creation interface\n");
888 IUnknown_Release((IUnknown
*) dd
);
890 IDirectDraw_Release(dd2
);
891 IDirectDraw_Release(dd4
);
892 IDirectDraw_Release(dd7
);
893 IDirectDrawSurface4_Release(dsurface4
);
894 IDirectDrawSurface2_Release(dsurface2
);
897 static void GetDDInterface_7(void)
899 LPDIRECTDRAWSURFACE4 dsurface4
;
900 LPDIRECTDRAWSURFACE7 dsurface7
;
901 DDSURFACEDESC2 surface
;
906 unsigned long ref1
, ref2
, ref4
, ref7
;
909 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw2
, (void **) &dd2
);
910 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
911 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw4
, (void **) &dd4
);
912 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
913 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
914 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
916 /* Create a surface */
917 ZeroMemory(&surface
, sizeof(surface
));
918 surface
.dwSize
= sizeof(surface
);
919 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
920 surface
.dwHeight
= 10;
921 surface
.dwWidth
= 10;
922 ret
= IDirectDraw7_CreateSurface(dd7
, &surface
, &dsurface7
, NULL
);
925 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
928 ret
= IDirectDrawSurface7_QueryInterface(dsurface7
, &IID_IDirectDrawSurface4
, (void **) &dsurface4
);
929 ok(ret
== DD_OK
, "IDirectDrawSurface_QueryInterface returned %08x\n", ret
);
931 ref1
= getref((IUnknown
*) lpDD
);
932 ok(ref1
== 1, "IDirectDraw refcount is %ld\n", ref1
);
933 ref2
= getref((IUnknown
*) dd2
);
934 ok(ref2
== 1, "IDirectDraw2 refcount is %ld\n", ref2
);
935 ref4
= getref((IUnknown
*) dd4
);
936 ok(ref4
== 1, "IDirectDraw4 refcount is %ld\n", ref4
);
937 ref7
= getref((IUnknown
*) dd7
);
938 ok(ref7
== 2, "IDirectDraw7 refcount is %ld\n", ref7
);
940 ret
= IDirectDrawSurface7_GetDDInterface(dsurface7
, &dd
);
941 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
942 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
943 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
944 ok(getref((IUnknown
*) dd4
) == ref4
+ 0, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
945 ok(getref((IUnknown
*) dd7
) == ref7
+ 1, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
947 ok(dd
== dd7
, "Returned interface pointer is not equal to the creation interface\n");
948 IUnknown_Release((IUnknown
*) dd
);
950 /* Now test what happens if we QI the surface for some other version - It should still return the creation interface */
951 ret
= IDirectDrawSurface4_GetDDInterface(dsurface4
, &dd
);
952 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
953 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
954 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
955 ok(getref((IUnknown
*) dd4
) == ref4
+ 0, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
956 ok(getref((IUnknown
*) dd7
) == ref7
+ 1, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
958 ok(dd
== dd7
, "Returned interface pointer is not equal to the creation interface\n");
959 IUnknown_Release((IUnknown
*) dd
);
961 IDirectDraw_Release(dd2
);
962 IDirectDraw_Release(dd4
);
963 IDirectDraw_Release(dd7
);
964 IDirectDrawSurface4_Release(dsurface4
);
965 IDirectDrawSurface7_Release(dsurface7
);
968 #define MAXEXPECTED 8 /* Can match up to 8 expected surfaces */
971 IDirectDrawSurface
*expected
[MAXEXPECTED
];
975 static HRESULT WINAPI
enumCB(IDirectDrawSurface
*surf
, DDSURFACEDESC
*desc
, void *ctx
)
980 for(i
= 0; i
< MAXEXPECTED
; i
++)
982 if(((struct enumstruct
*)ctx
)->expected
[i
] == surf
) found
= TRUE
;
985 ok(found
, "Unexpected surface %p enumerated\n", surf
);
986 ((struct enumstruct
*)ctx
)->count
++;
987 IDirectDrawSurface_Release(surf
);
991 static void EnumTest(void)
995 IDirectDrawSurface
*surface
;
996 struct enumstruct ctx
;
998 ddsd
.dwSize
= sizeof(ddsd
);
999 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_MIPMAPCOUNT
;
1000 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
1001 U2(ddsd
).dwMipMapCount
= 3;
1004 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface
, NULL
);
1005 ok(rc
==DD_OK
,"CreateSurface returned: %x\n",rc
);
1007 memset(&ctx
, 0, sizeof(ctx
));
1008 ctx
.expected
[0] = surface
;
1009 rc
= IDirectDrawSurface_GetAttachedSurface(ctx
.expected
[0], &ddsd
.ddsCaps
, &ctx
.expected
[1]);
1010 ok(rc
== DD_OK
, "GetAttachedSurface returned %08x\n", rc
);
1011 rc
= IDirectDrawSurface_GetAttachedSurface(ctx
.expected
[1], &ddsd
.ddsCaps
, &ctx
.expected
[2]);
1012 ok(rc
== DD_OK
, "GetAttachedSurface returned %08x\n", rc
);
1013 rc
= IDirectDrawSurface_GetAttachedSurface(ctx
.expected
[2], &ddsd
.ddsCaps
, &ctx
.expected
[3]);
1014 ok(rc
== DDERR_NOTFOUND
, "GetAttachedSurface returned %08x\n", rc
);
1017 rc
= IDirectDraw_EnumSurfaces(lpDD
, DDENUMSURFACES_DOESEXIST
| DDENUMSURFACES_ALL
, &ddsd
, (void *) &ctx
, enumCB
);
1018 ok(rc
== DD_OK
, "IDirectDraw_EnumSurfaces returned %08x\n", rc
);
1019 ok(ctx
.count
== 3, "%d surfaces enumerated, expected 3\n", ctx
.count
);
1021 IDirectDrawSurface_Release(ctx
.expected
[2]);
1022 IDirectDrawSurface_Release(ctx
.expected
[1]);
1023 IDirectDrawSurface_Release(surface
);
1026 HRESULT WINAPI
SurfaceCounter(IDirectDrawSurface7
*surface
, DDSURFACEDESC2
*desc
, void *context
)
1028 UINT
*num
= context
;
1030 IDirectDrawSurface_Release(surface
);
1031 return DDENUMRET_OK
;
1034 static void AttachmentTest7(void)
1038 IDirectDrawSurface7
*surface1
, *surface2
, *surface3
, *surface4
;
1039 DDSURFACEDESC2 ddsd
;
1041 DDSCAPS2 caps
= {DDSCAPS_TEXTURE
, 0, 0, 0};
1042 HWND window
= CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW
, 100, 100, 160, 160, NULL
, NULL
, NULL
, NULL
);
1044 hr
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
1045 ok(hr
== DD_OK
, "IDirectDraw_QueryInterface returned %08x\n", hr
);
1047 memset(&ddsd
, 0, sizeof(ddsd
));
1048 ddsd
.dwSize
= sizeof(ddsd
);
1049 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_MIPMAPCOUNT
;
1050 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
1051 U2(ddsd
).dwMipMapCount
= 3; /* Will create 128x128, 64x64, 32x32 */
1053 ddsd
.dwHeight
= 128;
1054 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface1
, NULL
);
1055 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1059 IDirectDrawSurface7_EnumAttachedSurfaces(surface1
, &num
, SurfaceCounter
);
1060 ok(num
== 1, "Mipmap root has %d surfaces attached, expected 1\n", num
);
1064 hr
= IDirectDrawSurface7_GetAttachedSurface(surface1
, &caps
, &surface2
);
1065 ok(hr
== DD_OK
, "GetAttachedSurface returned %08x\n", hr
);
1067 IDirectDrawSurface7_EnumAttachedSurfaces(surface2
, &num
, SurfaceCounter
);
1068 ok(num
== 1, "First mip level has %d surfaces attached, expected 1\n", num
);
1072 hr
= IDirectDrawSurface7_GetAttachedSurface(surface2
, &caps
, &surface3
);
1073 ok(hr
== DD_OK
, "GetAttachedSurface returned %08x\n", hr
);
1074 IDirectDrawSurface7_Release(surface2
);
1076 IDirectDrawSurface7_EnumAttachedSurfaces(surface3
, &num
, SurfaceCounter
);
1077 ok(num
== 0, "Second mip level has %d surfaces attached, expected 1\n", num
);
1079 /* Mip level 3 is still needed */
1081 /* Try to attach a 16x16 miplevel - Should not work as far I can see */
1082 memset(&ddsd
, 0, sizeof(ddsd
));
1083 ddsd
.dwSize
= sizeof(ddsd
);
1084 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1085 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
;
1088 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface2
, NULL
);
1089 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1091 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface2
);
1092 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 128x128 texture root returned %08x\n", hr
);
1093 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface1
);
1094 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 128x128 texture root to a 16x16 texture returned %08x\n", hr
);
1095 hr
= IDirectDrawSurface7_AddAttachedSurface(surface3
, surface2
);
1096 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 32x32 texture mip level returned %08x\n", hr
);
1097 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface3
);
1098 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 32x32 texture mip level to a 16x16 surface returned %08x\n", hr
);
1100 IDirectDrawSurface7_Release(surface2
);
1102 memset(&ddsd
, 0, sizeof(ddsd
));
1103 ddsd
.dwSize
= sizeof(ddsd
);
1104 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1105 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_SYSTEMMEMORY
| DDSCAPS_OFFSCREENPLAIN
;
1108 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface2
, NULL
);
1109 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1111 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface2
);
1112 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr
);
1113 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface1
);
1114 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr
);
1115 hr
= IDirectDrawSurface7_AddAttachedSurface(surface3
, surface2
);
1116 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr
);
1117 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface3
);
1118 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 32x32 texture mip level to a 16x16 offscreen plain surface returned %08x\n", hr
);
1120 IDirectDrawSurface7_Release(surface3
);
1121 IDirectDrawSurface7_Release(surface2
);
1122 IDirectDrawSurface7_Release(surface1
);
1124 hr
= IDirectDraw7_SetCooperativeLevel(dd7
, window
, DDSCL_EXCLUSIVE
| DDSCL_FULLSCREEN
);
1125 ok(hr
== DD_OK
, "SetCooperativeLevel returned %08x\n", hr
);
1127 memset(&ddsd
, 0, sizeof(ddsd
));
1128 ddsd
.dwSize
= sizeof(ddsd
);
1129 ddsd
.dwFlags
= DDSD_BACKBUFFERCOUNT
| DDSD_CAPS
;
1130 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_COMPLEX
| DDSCAPS_FLIP
;
1131 ddsd
.dwBackBufferCount
= 2;
1132 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface1
, NULL
);
1133 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1136 IDirectDrawSurface7_EnumAttachedSurfaces(surface1
, &num
, SurfaceCounter
);
1137 ok(num
== 1, "Primary surface has %d surfaces attached, expected 1\n", num
);
1138 IDirectDrawSurface7_Release(surface1
);
1140 /* Those are some invalid descriptions, no need to test attachments with them */
1141 memset(&ddsd
, 0, sizeof(ddsd
));
1142 ddsd
.dwSize
= sizeof(ddsd
);
1143 ddsd
.dwFlags
= DDSD_CAPS
;
1144 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_FRONTBUFFER
;
1145 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface1
, NULL
);
1146 ok(hr
==DDERR_INVALIDCAPS
,"CreateSurface returned: %x\n",hr
);
1147 memset(&ddsd
, 0, sizeof(ddsd
));
1148 ddsd
.dwSize
= sizeof(ddsd
);
1149 ddsd
.dwFlags
= DDSD_CAPS
;
1150 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_BACKBUFFER
;
1151 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface2
, NULL
);
1152 ok(hr
==DDERR_INVALIDCAPS
,"CreateSurface returned: %x\n",hr
);
1154 /* Try a single primary and two offscreen plain surfaces */
1155 memset(&ddsd
, 0, sizeof(ddsd
));
1156 ddsd
.dwSize
= sizeof(ddsd
);
1157 ddsd
.dwFlags
= DDSD_CAPS
;
1158 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
;
1159 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface1
, NULL
);
1160 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1162 memset(&ddsd
, 0, sizeof(ddsd
));
1163 ddsd
.dwSize
= sizeof(ddsd
);
1164 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1165 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1166 ddsd
.dwWidth
= GetSystemMetrics(SM_CXSCREEN
);
1167 ddsd
.dwHeight
= GetSystemMetrics(SM_CYSCREEN
);
1168 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface2
, NULL
);
1169 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1171 memset(&ddsd
, 0, sizeof(ddsd
));
1172 ddsd
.dwSize
= sizeof(ddsd
);
1173 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1174 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1175 ddsd
.dwWidth
= GetSystemMetrics(SM_CXSCREEN
);
1176 ddsd
.dwHeight
= GetSystemMetrics(SM_CYSCREEN
);
1177 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface3
, NULL
);
1178 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1180 /* This one has a different size */
1181 memset(&ddsd
, 0, sizeof(ddsd
));
1182 ddsd
.dwSize
= sizeof(ddsd
);
1183 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1184 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1186 ddsd
.dwHeight
= 128;
1187 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface4
, NULL
);
1188 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1190 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface2
);
1191 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching an offscreen plain surface to a front buffer returned %08x\n", hr
);
1192 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface1
);
1193 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a front buffer to an offscreen plain surface returned %08x\n", hr
);
1194 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface3
);
1195 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching an offscreen plain surface to another offscreen plain surface returned %08x\n", hr
);
1196 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface4
);
1197 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching an offscreen plain surface to a front buffer of different size returned %08x\n", hr
);
1198 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface1
);
1199 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a front buffer to an offscreen plain surface of different size returned %08x\n", hr
);
1201 IDirectDrawSurface7_Release(surface4
);
1202 IDirectDrawSurface7_Release(surface3
);
1203 IDirectDrawSurface7_Release(surface2
);
1204 IDirectDrawSurface7_Release(surface1
);
1206 hr
=IDirectDraw7_SetCooperativeLevel(dd7
, NULL
, DDSCL_NORMAL
);
1207 ok(hr
== DD_OK
, "SetCooperativeLevel returned %08x\n", hr
);
1208 IDirectDraw7_Release(dd7
);
1211 static void AttachmentTest(void)
1214 IDirectDrawSurface
*surface1
, *surface2
, *surface3
, *surface4
;
1216 DDSCAPS caps
= {DDSCAPS_TEXTURE
};
1217 HWND window
= CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW
, 100, 100, 160, 160, NULL
, NULL
, NULL
, NULL
);
1219 memset(&ddsd
, 0, sizeof(ddsd
));
1220 ddsd
.dwSize
= sizeof(ddsd
);
1221 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_MIPMAPCOUNT
;
1222 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
1223 U2(ddsd
).dwMipMapCount
= 3; /* Will create 128x128, 64x64, 32x32 */
1225 ddsd
.dwHeight
= 128;
1226 hr
= IDirectDraw7_CreateSurface(lpDD
, &ddsd
, &surface1
, NULL
);
1227 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1229 hr
= IDirectDrawSurface7_GetAttachedSurface(surface1
, &caps
, &surface2
);
1230 ok(hr
== DD_OK
, "GetAttachedSurface returned %08x\n", hr
);
1231 hr
= IDirectDrawSurface7_GetAttachedSurface(surface2
, &caps
, &surface3
);
1232 ok(hr
== DD_OK
, "GetAttachedSurface returned %08x\n", hr
);
1234 /* Try to attach a 16x16 miplevel - Should not work as far I can see */
1235 memset(&ddsd
, 0, sizeof(ddsd
));
1236 ddsd
.dwSize
= sizeof(ddsd
);
1237 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1238 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
;
1241 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface4
, NULL
);
1242 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1244 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface4
);
1245 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 128x128 texture root returned %08x\n", hr
);
1246 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface1
);
1247 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 128x128 texture root to a 16x16 texture returned %08x\n", hr
);
1248 hr
= IDirectDrawSurface7_AddAttachedSurface(surface3
, surface4
);
1249 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 32x32 texture mip level returned %08x\n", hr
);
1250 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface3
);
1251 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 32x32 texture mip level to a 16x16 surface returned %08x\n", hr
);
1252 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface4
);
1253 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 64x64 texture sublevel returned %08x\n", hr
);
1254 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface2
);
1255 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 64x64 texture sublevel to a 16x16 texture returned %08x\n", hr
);
1257 IDirectDrawSurface7_Release(surface4
);
1259 memset(&ddsd
, 0, sizeof(ddsd
));
1260 ddsd
.dwSize
= sizeof(ddsd
);
1261 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1262 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_SYSTEMMEMORY
| DDSCAPS_OFFSCREENPLAIN
;
1265 hr
= IDirectDraw7_CreateSurface(lpDD
, &ddsd
, &surface4
, NULL
);
1266 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1268 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface4
); /* Succeeds on refrast */
1269 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr
);
1270 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface1
, 0, surface4
);
1271 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface1
); /* Succeeds on refrast */
1272 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr
);
1273 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface1
, 0, surface1
);
1274 hr
= IDirectDrawSurface7_AddAttachedSurface(surface3
, surface4
); /* Succeeds on refrast */
1275 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr
);
1276 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface3
, 0, surface4
);
1277 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface3
);
1278 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 32x32 texture mip level to a 16x16 offscreen plain surface returned %08x\n", hr
);
1279 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface4
, 0, surface3
);
1280 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface4
); /* Succeeds on refrast */
1281 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 64x64 texture sublevel returned %08x\n", hr
);
1282 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface2
, 0, surface4
);
1283 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface2
);
1284 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 64x64 texture sublevel to a 16x16 offscreen plain surface returned %08x\n", hr
);
1285 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface4
, 0, surface2
);
1287 IDirectDrawSurface7_Release(surface4
);
1288 IDirectDrawSurface7_Release(surface3
);
1289 IDirectDrawSurface7_Release(surface2
);
1290 IDirectDrawSurface7_Release(surface1
);
1292 hr
= IDirectDraw_SetCooperativeLevel(lpDD
, window
, DDSCL_EXCLUSIVE
| DDSCL_FULLSCREEN
);
1293 ok(hr
== DD_OK
, "SetCooperativeLevel returned %08x\n", hr
);
1295 /* Creating a back buffer as-is, is not allowed. No need to perform attachment tests */
1296 memset(&ddsd
, 0, sizeof(ddsd
));
1297 ddsd
.dwSize
= sizeof(ddsd
);
1298 ddsd
.dwFlags
= DDSD_CAPS
;
1299 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_BACKBUFFER
;
1300 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface2
, NULL
);
1301 ok(hr
==DDERR_INVALIDCAPS
,"CreateSurface returned: %x\n",hr
);
1302 /* This old ddraw version happily creates explicit front buffers */
1303 memset(&ddsd
, 0, sizeof(ddsd
));
1304 ddsd
.dwSize
= sizeof(ddsd
);
1305 ddsd
.dwFlags
= DDSD_CAPS
;
1306 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_FRONTBUFFER
;
1307 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface1
, NULL
);
1308 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1309 IDirectDrawSurface_Release(surface1
);
1311 /* Try a single primary and two offscreen plain surfaces */
1312 memset(&ddsd
, 0, sizeof(ddsd
));
1313 ddsd
.dwSize
= sizeof(ddsd
);
1314 ddsd
.dwFlags
= DDSD_CAPS
;
1315 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
;
1316 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface1
, NULL
);
1317 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1319 memset(&ddsd
, 0, sizeof(ddsd
));
1320 ddsd
.dwSize
= sizeof(ddsd
);
1321 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1322 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1323 ddsd
.dwWidth
= GetSystemMetrics(SM_CXSCREEN
);
1324 ddsd
.dwHeight
= GetSystemMetrics(SM_CYSCREEN
);
1325 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface2
, NULL
);
1326 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1328 memset(&ddsd
, 0, sizeof(ddsd
));
1329 ddsd
.dwSize
= sizeof(ddsd
);
1330 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1331 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1332 ddsd
.dwWidth
= GetSystemMetrics(SM_CXSCREEN
);
1333 ddsd
.dwHeight
= GetSystemMetrics(SM_CYSCREEN
);
1334 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface3
, NULL
);
1335 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1337 /* This one has a different size */
1338 memset(&ddsd
, 0, sizeof(ddsd
));
1339 ddsd
.dwSize
= sizeof(ddsd
);
1340 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1341 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1343 ddsd
.dwHeight
= 128;
1344 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface4
, NULL
);
1345 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1347 hr
= IDirectDrawSurface_AddAttachedSurface(surface1
, surface2
);
1348 ok(hr
== DD_OK
, "Attaching an offscreen plain surface to a front buffer returned %08x\n", hr
);
1349 /* Try the reverse without detaching first */
1350 hr
= IDirectDrawSurface_AddAttachedSurface(surface2
, surface1
);
1351 ok(hr
== DDERR_SURFACEALREADYATTACHED
, "Attaching an attached surface to its attachee returned %08x\n", hr
);
1352 hr
= IDirectDrawSurface_DeleteAttachedSurface(surface1
, 0, surface2
);
1353 ok(hr
== DD_OK
, "DeleteAttachedSurface failed with %08x\n", hr
);
1354 hr
= IDirectDrawSurface_AddAttachedSurface(surface2
, surface1
);
1355 ok(hr
== DD_OK
, "Attaching a front buffer to an offscreen plain surface returned %08x\n", hr
);
1356 /* Try to detach reversed */
1357 hr
= IDirectDrawSurface_DeleteAttachedSurface(surface1
, 0, surface2
);
1358 ok(hr
== DDERR_CANNOTDETACHSURFACE
, "DeleteAttachedSurface returned %08x\n", hr
);
1359 /* Now the proper detach */
1360 hr
= IDirectDrawSurface_DeleteAttachedSurface(surface2
, 0, surface1
);
1361 ok(hr
== DD_OK
, "DeleteAttachedSurface failed with %08x\n", hr
);
1362 hr
= IDirectDrawSurface_AddAttachedSurface(surface2
, surface3
); /* Fails on refrast */
1363 ok(hr
== DD_OK
, "Attaching an offscreen plain surface to another offscreen plain surface returned %08x\n", hr
);
1366 hr
= IDirectDrawSurface_DeleteAttachedSurface(surface2
, 0, surface3
);
1367 ok(hr
== DD_OK
, "DeleteAttachedSurface failed with %08x\n", hr
);
1369 hr
= IDirectDrawSurface_AddAttachedSurface(surface1
, surface4
);
1370 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching an offscreen plain surface to a front buffer of different size returned %08x\n", hr
);
1371 hr
= IDirectDrawSurface_AddAttachedSurface(surface4
, surface1
);
1372 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a front buffer to an offscreen plain surface of different size returned %08x\n", hr
);
1374 IDirectDrawSurface_Release(surface4
);
1375 IDirectDrawSurface_Release(surface3
);
1376 IDirectDrawSurface_Release(surface2
);
1377 IDirectDrawSurface_Release(surface1
);
1379 hr
=IDirectDraw_SetCooperativeLevel(lpDD
, NULL
, DDSCL_NORMAL
);
1380 ok(hr
== DD_OK
, "SetCooperativeLevel returned %08x\n", hr
);
1382 DestroyWindow(window
);
1387 DWORD width
, height
;
1392 HRESULT WINAPI
CubeTestLvl2Enum(IDirectDrawSurface7
*surface
, DDSURFACEDESC2
*desc
, void *context
)
1394 UINT
*mips
= context
;
1397 IDirectDrawSurface7_EnumAttachedSurfaces(surface
,
1401 return DDENUMRET_OK
;
1404 HRESULT WINAPI
CubeTestLvl1Enum(IDirectDrawSurface7
*surface
, DDSURFACEDESC2
*desc
, void *context
)
1407 UINT
*num
= (UINT
*) context
;
1408 static const struct compare expected
[] =
1412 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1413 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_NEGATIVEZ
,
1418 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1419 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_POSITIVEZ
,
1424 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1425 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_NEGATIVEY
,
1430 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1431 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_POSITIVEY
,
1436 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1437 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_NEGATIVEX
,
1441 64, 64, /* This is the first mipmap */
1442 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1443 DDSCAPS2_MIPMAPSUBLEVEL
| DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_POSITIVEX
,
1449 IDirectDrawSurface7_EnumAttachedSurfaces(surface
,
1453 ok(desc
->dwWidth
== expected
[*num
].width
, "Surface width is %d expected %d\n", desc
->dwWidth
, expected
[*num
].width
);
1454 ok(desc
->dwHeight
== expected
[*num
].height
, "Surface height is %d expected %d\n", desc
->dwHeight
, expected
[*num
].height
);
1455 ok(desc
->ddsCaps
.dwCaps
== expected
[*num
].caps
, "Surface caps are %08x expected %08x\n", desc
->ddsCaps
.dwCaps
, expected
[*num
].caps
);
1456 ok(desc
->ddsCaps
.dwCaps2
== expected
[*num
].caps2
, "Surface caps2 are %08x expected %08x\n", desc
->ddsCaps
.dwCaps2
, expected
[*num
].caps2
);
1457 ok(mips
== expected
[*num
].mips
, "Surface has %d mipmaps, expected %d\n", mips
, expected
[*num
].mips
);
1461 IDirectDrawSurface7_Release(surface
);
1463 return DDENUMRET_OK
;
1466 static void CubeMapTest(void)
1468 IDirectDraw7
*dd7
= NULL
;
1469 IDirectDrawSurface7
*cubemap
;
1470 DDSURFACEDESC2 ddsd
;
1473 struct enumstruct ctx
;
1475 hr
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
1476 ok(hr
== DD_OK
, "IDirectDraw::QueryInterface returned %08x\n", hr
);
1478 memset(&ddsd
, 0, sizeof(ddsd
));
1479 ddsd
.dwSize
= sizeof(ddsd
);
1480 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1481 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1483 ddsd
.dwHeight
= 128;
1484 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
| DDSCAPS_SYSTEMMEMORY
;
1485 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_ALLFACES
;
1488 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1489 U1(U4(ddsd
).ddpfPixelFormat
).dwRGBBitCount
= 16;
1490 U2(U4(ddsd
).ddpfPixelFormat
).dwRBitMask
= 0xF800;
1491 U3(U4(ddsd
).ddpfPixelFormat
).dwGBitMask
= 0x07E0;
1492 U4(U4(ddsd
).ddpfPixelFormat
).dwBBitMask
= 0x001F;
1494 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &cubemap
, NULL
);
1495 ok(hr
== DD_OK
, "IDirectDraw7::CreateSurface returned %08x\n", hr
);
1497 hr
= IDirectDrawSurface7_GetSurfaceDesc(cubemap
, &ddsd
);
1498 ok(hr
== DD_OK
, "IDirectDrawSurface7_GetSurfaceDesc returned %08x\n", hr
);
1499 ok(ddsd
.ddsCaps
.dwCaps
== (DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
),
1500 "Root Caps are %08x\n", ddsd
.ddsCaps
.dwCaps
);
1501 ok(ddsd
.ddsCaps
.dwCaps2
== (DDSCAPS2_CUBEMAP_POSITIVEX
| DDSCAPS2_CUBEMAP
),
1502 "Root Caps2 are %08x\n", ddsd
.ddsCaps
.dwCaps2
);
1504 IDirectDrawSurface7_EnumAttachedSurfaces(cubemap
,
1507 trace("Enumerated %d surfaces in total\n", num
);
1508 ok(num
== 6, "Surface has %d attachments\n", num
);
1509 IDirectDrawSurface7_Release(cubemap
);
1511 /* What happens if I do not specify any faces? */
1512 memset(&ddsd
, 0, sizeof(ddsd
));
1513 ddsd
.dwSize
= sizeof(ddsd
);
1514 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1515 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1517 ddsd
.dwHeight
= 128;
1518 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
| DDSCAPS_SYSTEMMEMORY
;
1519 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_CUBEMAP
;
1522 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1523 U1(U4(ddsd
).ddpfPixelFormat
).dwRGBBitCount
= 16;
1524 U2(U4(ddsd
).ddpfPixelFormat
).dwRBitMask
= 0xF800;
1525 U3(U4(ddsd
).ddpfPixelFormat
).dwGBitMask
= 0x07E0;
1526 U4(U4(ddsd
).ddpfPixelFormat
).dwBBitMask
= 0x001F;
1528 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &cubemap
, NULL
);
1529 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDraw7::CreateSurface asking for a cube map without faces returned %08x\n", hr
);
1531 /* Cube map faces without a cube map? */
1532 memset(&ddsd
, 0, sizeof(ddsd
));
1533 ddsd
.dwSize
= sizeof(ddsd
);
1534 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1535 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1537 ddsd
.dwHeight
= 128;
1538 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
| DDSCAPS_SYSTEMMEMORY
;
1539 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_CUBEMAP_ALLFACES
;
1542 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1543 U1(U4(ddsd
).ddpfPixelFormat
).dwRGBBitCount
= 16;
1544 U2(U4(ddsd
).ddpfPixelFormat
).dwRBitMask
= 0xF800;
1545 U3(U4(ddsd
).ddpfPixelFormat
).dwGBitMask
= 0x07E0;
1546 U4(U4(ddsd
).ddpfPixelFormat
).dwBBitMask
= 0x001F;
1548 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &cubemap
, NULL
);
1549 ok(hr
== DDERR_INVALIDCAPS
, "IDirectDraw7::CreateSurface returned %08x\n", hr
);
1551 memset(&ddsd
, 0, sizeof(ddsd
));
1552 ddsd
.dwSize
= sizeof(ddsd
);
1553 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1554 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1556 ddsd
.dwHeight
= 128;
1557 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
| DDSCAPS_SYSTEMMEMORY
;
1558 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_CUBEMAP_POSITIVEX
;
1561 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1562 U1(U4(ddsd
).ddpfPixelFormat
).dwRGBBitCount
= 16;
1563 U2(U4(ddsd
).ddpfPixelFormat
).dwRBitMask
= 0xF800;
1564 U3(U4(ddsd
).ddpfPixelFormat
).dwGBitMask
= 0x07E0;
1565 U4(U4(ddsd
).ddpfPixelFormat
).dwBBitMask
= 0x001F;
1567 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &cubemap
, NULL
);
1568 ok(hr
== DDERR_INVALIDCAPS
, "IDirectDraw7::CreateSurface returned %08x\n", hr
);
1570 /* Make sure everything is cleaned up properly. Use the enumSurfaces test infrastructure */
1571 memset(&ctx
, 0, sizeof(ctx
));
1572 memset(&ddsd
, 0, sizeof(ddsd
));
1573 ddsd
.dwSize
= sizeof(DDSURFACEDESC
);
1574 hr
= IDirectDraw_EnumSurfaces(lpDD
, DDENUMSURFACES_DOESEXIST
| DDENUMSURFACES_ALL
, (DDSURFACEDESC
*) &ddsd
, (void *) &ctx
, enumCB
);
1575 ok(hr
== DD_OK
, "IDirectDraw_EnumSurfaces returned %08x\n", hr
);
1576 ok(ctx
.count
== 0, "%d surfaces enumerated, expected 0\n", ctx
.count
);
1578 IDirectDraw7_Release(dd7
);
1581 static void test_lockrect_invalid(void)
1594 {68, 60, 60, 68}, /* left > right */
1595 {60, 68, 68, 60}, /* top > bottom */
1596 {-8, 60, 0, 68}, /* left < surface */
1597 {60, -8, 68, 0}, /* top < surface */
1598 {-16, 60, -8, 68}, /* right < surface */
1599 {60, -16, 68, -8}, /* bottom < surface */
1600 {60, 60, 136, 68}, /* right > surface */
1601 {60, 60, 68, 136}, /* bottom > surface */
1602 {136, 60, 144, 68}, /* left > surface */
1603 {60, 136, 68, 144}, /* top > surface */
1606 const DWORD dds_caps
[] = {
1607 DDSCAPS_OFFSCREENPLAIN
1610 for (j
= 0; j
< (sizeof(dds_caps
) / sizeof(*dds_caps
)); ++j
)
1612 IDirectDrawSurface
*surface
= 0;
1613 DDSURFACEDESC surface_desc
= {0};
1614 DDSURFACEDESC locked_desc
= {0};
1617 surface_desc
.dwSize
= sizeof(surface_desc
);
1618 surface_desc
.ddpfPixelFormat
.dwSize
= sizeof(surface_desc
.ddpfPixelFormat
);
1619 surface_desc
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
;
1620 surface_desc
.ddsCaps
.dwCaps
= dds_caps
[j
];
1621 surface_desc
.dwWidth
= 128;
1622 surface_desc
.dwHeight
= 128;
1623 surface_desc
.ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1624 U1(surface_desc
.ddpfPixelFormat
).dwRGBBitCount
= 32;
1625 U2(surface_desc
.ddpfPixelFormat
).dwRBitMask
= 0xFF0000;
1626 U3(surface_desc
.ddpfPixelFormat
).dwGBitMask
= 0x00FF00;
1627 U4(surface_desc
.ddpfPixelFormat
).dwBBitMask
= 0x0000FF;
1629 hr
= IDirectDraw_CreateSurface(lpDD
, &surface_desc
, &surface
, NULL
);
1630 ok(SUCCEEDED(hr
), "CreateSurface failed (0x%08x)\n", hr
);
1632 skip("failed to create surface\n");
1636 for (i
= 0; i
< (sizeof(valid
) / sizeof(*valid
)); ++i
)
1638 RECT
*rect
= &valid
[i
];
1640 memset(&locked_desc
, 0, sizeof(locked_desc
));
1641 locked_desc
.dwSize
= sizeof(locked_desc
);
1643 hr
= IDirectDrawSurface_Lock(surface
, rect
, &locked_desc
, DDLOCK_WAIT
, NULL
);
1644 ok(SUCCEEDED(hr
), "Lock failed (0x%08x) for rect [%d, %d]->[%d, %d]\n",
1645 hr
, rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
1647 hr
= IDirectDrawSurface_Unlock(surface
, NULL
);
1648 ok(SUCCEEDED(hr
), "Unlock failed (0x%08x)\n", hr
);
1651 for (i
= 0; i
< (sizeof(invalid
) / sizeof(*invalid
)); ++i
)
1653 RECT
*rect
= &invalid
[i
];
1655 memset(&locked_desc
, 1, sizeof(locked_desc
));
1656 locked_desc
.dwSize
= sizeof(locked_desc
);
1658 hr
= IDirectDrawSurface_Lock(surface
, rect
, &locked_desc
, DDLOCK_WAIT
, NULL
);
1659 ok(hr
== DDERR_INVALIDPARAMS
, "Lock returned 0x%08x for rect [%d, %d]->[%d, %d]"
1660 ", expected DDERR_INVALIDPARAMS (0x%08x)\n", hr
, rect
->left
, rect
->top
,
1661 rect
->right
, rect
->bottom
, DDERR_INVALIDPARAMS
);
1662 ok(!locked_desc
.lpSurface
, "IDirectDrawSurface_Lock did not set lpSurface in the surface desc to zero.\n");
1665 hr
= IDirectDrawSurface_Lock(surface
, NULL
, &locked_desc
, DDLOCK_WAIT
, NULL
);
1666 ok(hr
== DD_OK
, "IDirectDrawSurface_Lock(rect = NULL) failed (0x%08x)\n", hr
);
1667 hr
= IDirectDrawSurface_Lock(surface
, NULL
, &locked_desc
, DDLOCK_WAIT
, NULL
);
1668 ok(hr
== DDERR_SURFACEBUSY
, "Double lock(rect = NULL) returned 0x%08x\n", hr
);
1670 hr
= IDirectDrawSurface_Unlock(surface
, NULL
);
1671 ok(SUCCEEDED(hr
), "Unlock failed (0x%08x)\n", hr
);
1673 hr
= IDirectDrawSurface_Unlock(surface
, NULL
);
1674 ok(SUCCEEDED(hr
), "Unlock failed (0x%08x)\n", hr
);
1676 memset(&locked_desc
, 0, sizeof(locked_desc
));
1677 locked_desc
.dwSize
= sizeof(locked_desc
);
1678 hr
= IDirectDrawSurface_Lock(surface
, &valid
[0], &locked_desc
, DDLOCK_WAIT
, NULL
);
1679 ok(hr
== DD_OK
, "IDirectDrawSurface_Lock(rect = [%d, %d]->[%d, %d]) failed (0x%08x)\n",
1680 valid
[0].left
, valid
[0].top
, valid
[0].right
, valid
[0].bottom
, hr
);
1681 hr
= IDirectDrawSurface_Lock(surface
, &valid
[0], &locked_desc
, DDLOCK_WAIT
, NULL
);
1682 ok(hr
== DDERR_SURFACEBUSY
, "Double lock(rect = [%d, %d]->[%d, %d]) failed (0x%08x)\n",
1683 valid
[0].left
, valid
[0].top
, valid
[0].right
, valid
[0].bottom
, hr
);
1685 /* Locking a different rectangle returns DD_OK, but it seems to break the surface.
1686 * Afterwards unlocking the surface fails(NULL rectangle, and both locked rectangles
1689 hr
= IDirectDrawSurface_Unlock(surface
, NULL
);
1690 ok(hr
== DD_OK
, "Unlock returned (0x%08x)\n", hr
);
1692 IDirectDrawSurface_Release(surface
);
1696 static void CompressedTest(void)
1699 IDirectDrawSurface7
*surface
;
1700 DDSURFACEDESC2 ddsd
, ddsd2
;
1701 IDirectDraw7
*dd7
= NULL
;
1702 RECT r
= { 0, 0, 128, 128 };
1703 RECT r2
= { 32, 32, 64, 64 };
1705 hr
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
1706 ok(hr
== DD_OK
, "IDirectDraw::QueryInterface returned %08x\n", hr
);
1708 memset(&ddsd
, 0, sizeof(ddsd
));
1709 ddsd
.dwSize
= sizeof(ddsd
);
1710 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1711 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1713 ddsd
.dwHeight
= 128;
1714 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
;
1715 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_FOURCC
;
1716 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','1');
1718 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1719 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1721 skip("failed to create surface\n");
1725 memset(&ddsd2
, 0, sizeof(ddsd2
));
1726 ddsd2
.dwSize
= sizeof(ddsd2
);
1727 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1728 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1729 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1731 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1732 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1733 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1734 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1735 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1736 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1737 ok(U1(ddsd2
).dwLinearSize
== 8192, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1738 ok(ddsd2
.ddsCaps
.dwCaps2
== 0, "Caps2: %08x\n", ddsd2
.ddsCaps
.dwCaps2
);
1739 IDirectDrawSurface7_Release(surface
);
1741 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','3');
1742 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1743 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1745 skip("failed to create surface\n");
1749 memset(&ddsd2
, 0, sizeof(ddsd2
));
1750 ddsd2
.dwSize
= sizeof(ddsd2
);
1751 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1752 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1753 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1755 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1756 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1757 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1758 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1759 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1760 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1761 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1762 IDirectDrawSurface7_Release(surface
);
1764 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','5');
1765 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1766 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1768 skip("failed to create surface\n");
1772 memset(&ddsd2
, 0, sizeof(ddsd2
));
1773 ddsd2
.dwSize
= sizeof(ddsd2
);
1774 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1775 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1776 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1778 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1779 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1780 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1781 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1782 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1783 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1784 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1785 ok(ddsd2
.lpSurface
== 0, "Surface memory is at %p, expected NULL\n", ddsd2
.lpSurface
);
1787 memset(&ddsd2
, 0, sizeof(ddsd2
));
1788 ddsd2
.dwSize
= sizeof(ddsd2
);
1789 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1791 /* Show that the description is not changed when locking the surface. What is really interesting
1792 * about this is that DDSD_LPSURFACE isn't set.
1794 hr
= IDirectDrawSurface7_Lock(surface
, NULL
, &ddsd2
, DDLOCK_READONLY
, 0);
1795 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1797 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1798 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1799 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1800 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1801 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1802 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1803 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1804 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1806 hr
= IDirectDrawSurface7_Unlock(surface
, NULL
);
1807 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1809 /* Now what about a locking rect? */
1810 hr
= IDirectDrawSurface7_Lock(surface
, &r
, &ddsd2
, DDLOCK_READONLY
, 0);
1811 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1813 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1814 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1815 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1816 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1817 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1818 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1819 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1820 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1822 hr
= IDirectDrawSurface7_Unlock(surface
, &r
);
1823 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1825 /* Now what about a different locking offset? */
1826 hr
= IDirectDrawSurface7_Lock(surface
, &r2
, &ddsd2
, DDLOCK_READONLY
, 0);
1827 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1829 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1830 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1831 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1832 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1833 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1834 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1835 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1836 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1838 hr
= IDirectDrawSurface7_Unlock(surface
, &r2
);
1839 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1840 IDirectDrawSurface7_Release(surface
);
1842 /* Try this with video memory. A kind of surprise. It still has the LINEARSIZE flag set,
1843 * but seems to have a pitch instead.
1845 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
;
1846 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','1');
1848 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1849 ok(hr
== DD_OK
|| hr
== DDERR_NOTEXTUREHW
|| hr
== DDERR_INVALIDPARAMS
,
1850 "CreateSurface returned %08x\n", hr
);
1852 /* Not supported everywhere */
1855 memset(&ddsd2
, 0, sizeof(ddsd2
));
1856 ddsd2
.dwSize
= sizeof(ddsd2
);
1857 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1858 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1859 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1861 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1862 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1863 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1864 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1865 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1866 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1867 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1868 ok(ddsd2
.ddsCaps
.dwCaps2
== 0, "Caps2: %08x\n", ddsd2
.ddsCaps
.dwCaps2
);
1869 IDirectDrawSurface7_Release(surface
);
1871 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','3');
1872 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1873 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1875 memset(&ddsd2
, 0, sizeof(ddsd2
));
1876 ddsd2
.dwSize
= sizeof(ddsd2
);
1877 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1878 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1879 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1881 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1882 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1883 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1884 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1885 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1886 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1887 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1888 IDirectDrawSurface7_Release(surface
);
1890 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','5');
1891 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1892 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1894 memset(&ddsd2
, 0, sizeof(ddsd2
));
1895 ddsd2
.dwSize
= sizeof(ddsd2
);
1896 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1897 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1898 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1900 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1901 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1902 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1903 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1904 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1905 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1906 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1907 ok(ddsd2
.lpSurface
== 0, "Surface memory is at %p, expected NULL\n", ddsd2
.lpSurface
);
1909 memset(&ddsd2
, 0, sizeof(ddsd2
));
1910 ddsd2
.dwSize
= sizeof(ddsd2
);
1911 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1913 /* Show that the description is not changed when locking the surface. What is really interesting
1914 * about this is that DDSD_LPSURFACE isn't set.
1916 hr
= IDirectDrawSurface7_Lock(surface
, NULL
, &ddsd2
, DDLOCK_READONLY
, 0);
1917 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1919 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1920 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1921 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1922 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1923 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1924 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1925 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1926 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1928 hr
= IDirectDrawSurface7_Unlock(surface
, NULL
);
1929 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1931 /* Now what about a locking rect? */
1932 hr
= IDirectDrawSurface7_Lock(surface
, &r
, &ddsd2
, DDLOCK_READONLY
, 0);
1933 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1935 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1936 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1937 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1938 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1939 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1940 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1941 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1942 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1944 hr
= IDirectDrawSurface7_Unlock(surface
, &r
);
1945 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1947 /* Now what about a different locking offset? */
1948 hr
= IDirectDrawSurface7_Lock(surface
, &r2
, &ddsd2
, DDLOCK_READONLY
, 0);
1949 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1951 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1952 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1953 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1954 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1955 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1956 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1957 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1958 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1960 hr
= IDirectDrawSurface7_Unlock(surface
, &r2
);
1961 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1963 IDirectDrawSurface7_Release(surface
);
1967 skip("Hardware DXTN textures not supported\n");
1970 /* What happens to managed textures? Interestingly, Windows reports them as being in system
1971 * memory. The linear size fits again.
1973 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
;
1974 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_TEXTUREMANAGE
;
1975 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','1');
1977 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1978 ok(hr
== DD_OK
|| hr
== DDERR_NOTEXTUREHW
, "CreateSurface returned %08x\n", hr
);
1980 /* Not supported everywhere */
1983 memset(&ddsd2
, 0, sizeof(ddsd2
));
1984 ddsd2
.dwSize
= sizeof(ddsd2
);
1985 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1986 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1987 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1989 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1990 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1991 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1992 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1993 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1994 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1995 ok(U1(ddsd2
).dwLinearSize
== 8192, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1996 ok(ddsd2
.ddsCaps
.dwCaps2
== DDSCAPS2_TEXTUREMANAGE
, "Caps2: %08x\n", ddsd2
.ddsCaps
.dwCaps2
);
1997 IDirectDrawSurface7_Release(surface
);
1999 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','3');
2000 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
2001 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
2003 memset(&ddsd2
, 0, sizeof(ddsd2
));
2004 ddsd2
.dwSize
= sizeof(ddsd2
);
2005 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
2006 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
2007 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
2009 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
2010 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
2011 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
2012 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
2013 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2014 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2015 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
2016 IDirectDrawSurface7_Release(surface
);
2018 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','5');
2019 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
2020 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
2022 memset(&ddsd2
, 0, sizeof(ddsd2
));
2023 ddsd2
.dwSize
= sizeof(ddsd2
);
2024 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
2025 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
2026 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
2028 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
2029 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
2030 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
2031 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
2032 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2033 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2034 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
2035 ok(ddsd2
.lpSurface
== 0, "Surface memory is at %p, expected NULL\n", ddsd2
.lpSurface
);
2037 memset(&ddsd2
, 0, sizeof(ddsd2
));
2038 ddsd2
.dwSize
= sizeof(ddsd2
);
2039 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
2041 /* Show that the description is not changed when locking the surface. What is really interesting
2042 * about this is that DDSD_LPSURFACE isn't set.
2044 hr
= IDirectDrawSurface7_Lock(surface
, NULL
, &ddsd2
, DDLOCK_READONLY
, 0);
2045 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
2047 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
2048 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
2049 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
2050 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
2051 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2052 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2053 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
2054 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
2056 hr
= IDirectDrawSurface7_Unlock(surface
, NULL
);
2057 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
2059 /* Now what about a locking rect? */
2060 hr
= IDirectDrawSurface7_Lock(surface
, &r
, &ddsd2
, DDLOCK_READONLY
, 0);
2061 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
2063 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
2064 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
2065 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
2066 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
2067 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2068 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2069 ok(U1(ddsd2
).dwLinearSize
== 16384, "\"Linear\" size is %d\n", U1(ddsd2
).dwLinearSize
);
2070 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
2072 hr
= IDirectDrawSurface7_Unlock(surface
, &r
);
2073 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
2075 /* Now what about a different locking offset? */
2076 hr
= IDirectDrawSurface7_Lock(surface
, &r2
, &ddsd2
, DDLOCK_READONLY
, 0);
2077 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
2079 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
2080 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
2081 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
2082 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
2083 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2084 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2085 ok(U1(ddsd2
).dwLinearSize
== 16384, "\"Linear\" size is %d\n", U1(ddsd2
).dwLinearSize
);
2086 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
2088 hr
= IDirectDrawSurface7_Unlock(surface
, &r2
);
2089 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
2091 IDirectDrawSurface7_Release(surface
);
2095 skip("Hardware DXTN textures not supported\n");
2098 IDirectDraw7_Release(dd7
);
2101 static void SizeTest(void)
2103 LPDIRECTDRAWSURFACE dsurface
= NULL
;
2106 HWND window
= CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW
, 100, 100, 160, 160, NULL
, NULL
, NULL
, NULL
);
2108 /* Create an offscreen surface surface without a size */
2109 ZeroMemory(&desc
, sizeof(desc
));
2110 desc
.dwSize
= sizeof(desc
);
2111 desc
.dwFlags
= DDSD_CAPS
;
2112 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2113 trace("before offscreenplain create dsurface = %p\n", dsurface
);
2114 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2115 ok(ret
== DDERR_INVALIDPARAMS
, "Creating an offscreen plain surface without a size info returned %08x (dsurface=%p)\n", ret
, dsurface
);
2118 trace("Surface at %p\n", dsurface
);
2119 IDirectDrawSurface_Release(dsurface
);
2123 /* Create an offscreen surface surface with only a width parameter */
2124 ZeroMemory(&desc
, sizeof(desc
));
2125 desc
.dwSize
= sizeof(desc
);
2126 desc
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
;
2127 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2129 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2130 ok(ret
== DDERR_INVALIDPARAMS
, "Creating an offscreen plain surface without hight info returned %08x\n", ret
);
2133 IDirectDrawSurface_Release(dsurface
);
2137 /* Create an offscreen surface surface with only a height parameter */
2138 ZeroMemory(&desc
, sizeof(desc
));
2139 desc
.dwSize
= sizeof(desc
);
2140 desc
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
;
2141 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2142 desc
.dwHeight
= 128;
2143 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2144 ok(ret
== DDERR_INVALIDPARAMS
, "Creating an offscreen plain surface without width info returned %08x\n", ret
);
2147 IDirectDrawSurface_Release(dsurface
);
2152 ZeroMemory(&desc
, sizeof(desc
));
2153 desc
.dwSize
= sizeof(desc
);
2154 desc
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
| DDSD_WIDTH
;
2155 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2156 desc
.dwHeight
= 128;
2158 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2159 ok(ret
== DD_OK
, "Creating an offscreen plain surface with width and height info returned %08x\n", ret
);
2162 IDirectDrawSurface_Release(dsurface
);
2166 /* Test a primary surface size */
2167 ret
= IDirectDraw_SetCooperativeLevel(lpDD
, window
, DDSCL_NORMAL
);
2168 ok(ret
== DD_OK
, "SetCooperativeLevel failed with %08x\n", ret
);
2170 ZeroMemory(&desc
, sizeof(desc
));
2171 desc
.dwSize
= sizeof(desc
);
2172 desc
.dwFlags
= DDSD_CAPS
;
2173 desc
.ddsCaps
.dwCaps
|= DDSCAPS_PRIMARYSURFACE
;
2174 desc
.dwHeight
= 128; /* Keep them set to check what happens */
2175 desc
.dwWidth
= 128; /* Keep them set to check what happens */
2176 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2177 ok(ret
== DD_OK
, "Creating a primary surface without width and height info returned %08x\n", ret
);
2180 ret
= IDirectDrawSurface_GetSurfaceDesc(dsurface
, &desc
);
2181 ok(ret
== DD_OK
, "GetSurfaceDesc returned %x\n", ret
);
2183 IDirectDrawSurface_Release(dsurface
);
2186 ok(desc
.dwFlags
& DDSD_WIDTH
, "Primary surface doesn't have width set\n");
2187 ok(desc
.dwFlags
& DDSD_HEIGHT
, "Primary surface doesn't have height set\n");
2188 ok(desc
.dwWidth
== GetSystemMetrics(SM_CXSCREEN
), "Surface width differs from screen width\n");
2189 ok(desc
.dwHeight
== GetSystemMetrics(SM_CYSCREEN
), "Surface height differs from screen height\n");
2191 ret
= IDirectDraw_SetCooperativeLevel(lpDD
, NULL
, DDSCL_NORMAL
);
2192 ok(ret
== DD_OK
, "SetCooperativeLevel failed with %08x\n", ret
);
2195 static void PrivateDataTest(void)
2198 IDirectDrawSurface7
*surface7
= NULL
;
2199 IDirectDrawSurface
*surface
= NULL
;
2203 DWORD size
= sizeof(IUnknown
*);
2205 ZeroMemory(&desc
, sizeof(desc
));
2206 desc
.dwSize
= sizeof(desc
);
2207 desc
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
| DDSD_WIDTH
;
2208 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2209 desc
.dwHeight
= 128;
2211 hr
= IDirectDraw_CreateSurface(lpDD
, &desc
, &surface
, NULL
);
2212 ok(hr
== DD_OK
, "Creating an offscreen plain surface failed with %08x\n", hr
);
2217 hr
= IDirectDrawSurface_QueryInterface(surface
, &IID_IDirectDrawSurface7
, (void **) &surface7
);
2218 ok(hr
== DD_OK
, "IDirectDrawSurface_QueryInterface failed with %08x\n", hr
);
2221 IDirectDrawSurface_Release(surface
);
2226 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
/* Abuse this tag */, lpDD
, 0, DDSPD_IUNKNOWNPOINTER
);
2227 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2228 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
/* Abuse this tag */, lpDD
, 5, DDSPD_IUNKNOWNPOINTER
);
2229 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2230 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
/* Abuse this tag */, lpDD
, sizeof(IUnknown
*) * 2, DDSPD_IUNKNOWNPOINTER
);
2231 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2233 ref
= getref((IUnknown
*) lpDD
);
2234 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
/* Abuse this tag */, lpDD
, sizeof(IUnknown
*), DDSPD_IUNKNOWNPOINTER
);
2235 ok(hr
== DD_OK
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2236 ref2
= getref((IUnknown
*) lpDD
);
2237 ok(ref2
== ref
+ 1, "Object reference is %d, expected %d\n", ref2
, ref
+ 1);
2238 hr
= IDirectDrawSurface7_FreePrivateData(surface7
, &IID_IDirectDrawSurface7
);
2239 ref2
= getref((IUnknown
*) lpDD
);
2240 ok(ref2
== ref
, "Object reference is %d, expected %d\n", ref2
, ref
);
2242 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
, lpDD
, sizeof(IUnknown
*), DDSPD_IUNKNOWNPOINTER
);
2243 ok(hr
== DD_OK
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2244 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
, surface7
, sizeof(IUnknown
*), DDSPD_IUNKNOWNPOINTER
);
2245 ok(hr
== DD_OK
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2246 ref2
= getref((IUnknown
*) lpDD
);
2247 ok(ref2
== ref
, "Object reference is %d, expected %d\n", ref2
, ref
);
2249 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
, lpDD
, sizeof(IUnknown
*), DDSPD_IUNKNOWNPOINTER
);
2250 ok(hr
== DD_OK
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2251 hr
= IDirectDrawSurface7_GetPrivateData(surface7
, &IID_IDirectDrawSurface7
, &ptr
, &size
);
2252 ok(hr
== DD_OK
, "IDirectDrawSurface7_GetPrivateData failed with %08x\n", hr
);
2253 ref2
= getref((IUnknown
*) lpDD
);
2254 /* Object is NOT beein addrefed */
2255 ok(ptr
== (IUnknown
*) lpDD
, "Returned interface pointer is %p, expected %p\n", ptr
, lpDD
);
2256 ok(ref2
== ref
+ 1, "Object reference is %d, expected %d. ptr at %p, orig at %p\n", ref2
, ref
+ 1, ptr
, lpDD
);
2258 IDirectDrawSurface_Release(surface
);
2259 IDirectDrawSurface7_Release(surface7
);
2261 /* Destroying the surface frees the held reference */
2262 ref2
= getref((IUnknown
*) lpDD
);
2263 ok(ref2
== ref
, "Object reference is %d, expected %d\n", ref2
, ref
);
2266 static void BltParamTest(void)
2268 IDirectDrawSurface
*surface1
= NULL
, *surface2
= NULL
;
2272 RECT valid
= {10, 10, 20, 20};
2273 RECT invalid1
= {20, 10, 10, 20};
2274 RECT invalid2
= {20, 20, 20, 20};
2275 RECT invalid3
= {-1, -1, 20, 20};
2276 RECT invalid4
= {60, 60, 70, 70};
2278 memset(&desc
, 0, sizeof(desc
));
2279 desc
.dwSize
= sizeof(desc
);
2280 desc
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
| DDSD_WIDTH
;
2281 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2282 desc
.dwHeight
= 128;
2284 hr
= IDirectDraw_CreateSurface(lpDD
, &desc
, &surface1
, NULL
);
2285 ok(hr
== DD_OK
, "Creating an offscreen plain surface failed with %08x\n", hr
);
2289 hr
= IDirectDraw_CreateSurface(lpDD
, &desc
, &surface2
, NULL
);
2290 ok(hr
== DD_OK
, "Creating an offscreen plain surface failed with %08x\n", hr
);
2295 hr
= IDirectDrawSurface_BltFast(surface1
, 0, 0, NULL
, NULL
, 0);
2296 ok(hr
== DD_OK
, "BltFast from NULL surface returned %08x\n", hr
);
2298 hr
= IDirectDrawSurface_BltFast(surface1
, 0, 0, surface2
, NULL
, 0);
2299 ok(hr
== DD_OK
, "BltFast from smaller to bigger surface returned %08x\n", hr
);
2300 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, NULL
, 0);
2301 ok(hr
== DDERR_INVALIDRECT
, "BltFast from bigger to smaller surface returned %08x\n", hr
);
2302 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, &valid
, 0);
2303 ok(hr
== DD_OK
, "BltFast from bigger to smaller surface using a valid rectangle returned %08x\n", hr
);
2304 hr
= IDirectDrawSurface_BltFast(surface2
, 60, 60, surface1
, &valid
, 0);
2305 ok(hr
== DDERR_INVALIDRECT
, "BltFast with a rectangle resulting in an off-surface write returned %08x\n", hr
);
2306 hr
= IDirectDrawSurface_BltFast(surface1
, 90, 90, surface2
, NULL
, 0);
2307 ok(hr
== DDERR_INVALIDRECT
, "BltFast with a rectangle resulting in an off-surface write returned %08x\n", hr
);
2308 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, &invalid1
, 0);
2309 ok(hr
== DDERR_INVALIDRECT
, "BltFast with invalid rectangle 1 returned %08x\n", hr
);
2310 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, &invalid2
, 0);
2311 ok(hr
== DDERR_INVALIDRECT
, "BltFast with invalid rectangle 2 returned %08x\n", hr
);
2312 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, &invalid3
, 0);
2313 ok(hr
== DDERR_INVALIDRECT
, "BltFast with invalid rectangle 3 returned %08x\n", hr
);
2314 hr
= IDirectDrawSurface_BltFast(surface1
, 0, 0, surface2
, &invalid4
, 0);
2315 ok(hr
== DDERR_INVALIDRECT
, "BltFast with invalid rectangle 3 returned %08x\n", hr
);
2316 hr
= IDirectDrawSurface_BltFast(surface1
, 0, 0, surface1
, NULL
, 0);
2317 ok(hr
== DD_OK
, "BltFast blitting a surface onto itself returned %08x\n", hr
);
2319 /* Blt(non-fast) tests */
2320 memset(&BltFx
, 0, sizeof(BltFx
));
2321 BltFx
.dwSize
= sizeof(BltFx
);
2322 U5(BltFx
).dwFillColor
= 0xaabbccdd;
2324 hr
= IDirectDrawSurface_Blt(surface1
, &valid
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2325 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt with a valid rectangle for color fill returned %08x\n", hr
);
2326 hr
= IDirectDrawSurface_Blt(surface1
, &valid
, NULL
, &invalid3
, DDBLT_COLORFILL
, &BltFx
);
2327 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt with a invalid, unused rectangle returned %08x\n", hr
);
2328 hr
= IDirectDrawSurface_Blt(surface2
, &invalid1
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2329 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr
);
2330 hr
= IDirectDrawSurface_Blt(surface2
, &invalid2
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2331 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr
);
2332 hr
= IDirectDrawSurface_Blt(surface2
, &invalid3
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2333 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr
);
2334 hr
= IDirectDrawSurface_Blt(surface2
, &invalid4
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2335 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr
);
2337 /* Valid on surface 1 */
2338 hr
= IDirectDrawSurface_Blt(surface1
, &invalid4
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2339 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt with a subrectangle fill returned %08x\n", hr
);
2341 /* Works - stretched blit */
2342 hr
= IDirectDrawSurface_Blt(surface1
, NULL
, surface2
, NULL
, 0, NULL
);
2343 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt from a smaller to a bigger surface returned %08x\n", hr
);
2344 hr
= IDirectDrawSurface_Blt(surface2
, NULL
, surface1
, NULL
, 0, NULL
);
2345 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt from a bigger to a smaller surface %08x\n", hr
);
2347 /* Invalid dest rects in sourced blits */
2348 hr
= IDirectDrawSurface_Blt(surface2
, &invalid1
, surface1
, NULL
, 0, NULL
);
2349 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr
);
2350 hr
= IDirectDrawSurface_Blt(surface2
, &invalid2
, surface1
, NULL
, 0, NULL
);
2351 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr
);
2352 hr
= IDirectDrawSurface_Blt(surface2
, &invalid3
, surface1
, NULL
, 0, NULL
);
2353 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr
);
2354 hr
= IDirectDrawSurface_Blt(surface2
, &invalid4
, surface1
, NULL
, 0, NULL
);
2355 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr
);
2357 /* Invalid src rects */
2358 hr
= IDirectDrawSurface_Blt(surface2
, NULL
, surface1
, &invalid1
, 0, NULL
);
2359 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr
);
2360 hr
= IDirectDrawSurface_Blt(surface2
, NULL
, surface1
, &invalid2
, 0, NULL
);
2361 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr
);
2362 hr
= IDirectDrawSurface_Blt(surface2
, NULL
, surface1
, &invalid3
, 0, NULL
);
2363 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr
);
2364 hr
= IDirectDrawSurface_Blt(surface1
, NULL
, surface2
, &invalid4
, 0, NULL
);
2365 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr
);
2367 IDirectDrawSurface_Release(surface1
);
2368 IDirectDrawSurface_Release(surface2
);
2371 static void PaletteTest(void)
2374 IDirectDrawPalette
*palette
;
2375 PALETTEENTRY Table
[256];
2376 PALETTEENTRY palEntries
[256];
2379 for(i
=0; i
<256; i
++)
2381 Table
[i
].peRed
= 0xff;
2382 Table
[i
].peGreen
= 0;
2383 Table
[i
].peBlue
= 0;
2384 Table
[i
].peFlags
= 0;
2387 /* Create a 8bit palette without DDPCAPS_ALLOW256 set */
2388 hr
= IDirectDraw_CreatePalette(lpDD
, DDPCAPS_8BIT
, Table
, &palette
, NULL
);
2389 ok(hr
== DD_OK
, "CreatePalette failed with %08x\n", hr
);
2391 /* Read back the palette and verify the entries. Without DDPCAPS_ALLOW256 set
2392 / entry 0 and 255 should have been overwritten with black and white */
2393 IDirectDrawPalette_GetEntries(palette
, 0, 0, 256, &palEntries
[0]);
2394 ok(hr
== DD_OK
, "GetEntries failed with %08x\n", hr
);
2397 ok((palEntries
[0].peRed
== 0) && (palEntries
[0].peGreen
== 0) && (palEntries
[0].peBlue
== 0),
2398 "Palette entry 0 of a palette without DDPCAPS_ALLOW256 set should be (0,0,0) but it is (%d,%d,%d)\n",
2399 palEntries
[0].peRed
, palEntries
[0].peGreen
, palEntries
[0].peBlue
);
2400 ok((palEntries
[255].peRed
== 255) && (palEntries
[255].peGreen
== 255) && (palEntries
[255].peBlue
== 255),
2401 "Palette entry 255 of a palette without DDPCAPS_ALLOW256 set should be (255,255,255) but it is (%d,%d,%d)\n",
2402 palEntries
[255].peRed
, palEntries
[255].peGreen
, palEntries
[255].peBlue
);
2404 /* Entry 1-254 should contain red */
2405 for(i
=1; i
<255; i
++)
2406 ok((palEntries
[i
].peRed
== 255) && (palEntries
[i
].peGreen
== 0) && (palEntries
[i
].peBlue
== 0),
2407 "Palette entry %d should have contained (255,0,0) but was set to %d,%d,%d)\n",
2408 i
, palEntries
[i
].peRed
, palEntries
[i
].peGreen
, palEntries
[i
].peBlue
);
2411 /* CreatePalette without DDPCAPS_ALLOW256 ignores entry 0 and 255,
2412 / now check we are able to update the entries afterwards. */
2413 IDirectDrawPalette_SetEntries(palette
, 0, 0, 256, &Table
[0]);
2414 ok(hr
== DD_OK
, "SetEntries failed with %08x\n", hr
);
2415 IDirectDrawPalette_GetEntries(palette
, 0, 0, 256, &palEntries
[0]);
2416 ok(hr
== DD_OK
, "GetEntries failed with %08x\n", hr
);
2419 ok((palEntries
[0].peRed
== 0) && (palEntries
[0].peGreen
== 0) && (palEntries
[0].peBlue
== 0),
2420 "Palette entry 0 should have been set to (0,0,0) but it contains (%d,%d,%d)\n",
2421 palEntries
[0].peRed
, palEntries
[0].peGreen
, palEntries
[0].peBlue
);
2422 ok((palEntries
[255].peRed
== 255) && (palEntries
[255].peGreen
== 255) && (palEntries
[255].peBlue
== 255),
2423 "Palette entry 255 should have been set to (255,255,255) but it contains (%d,%d,%d)\n",
2424 palEntries
[255].peRed
, palEntries
[255].peGreen
, palEntries
[255].peBlue
);
2426 IDirectDrawPalette_Release(palette
);
2428 /* Create a 8bit palette with DDPCAPS_ALLOW256 set */
2429 hr
= IDirectDraw_CreatePalette(lpDD
, DDPCAPS_ALLOW256
| DDPCAPS_8BIT
, Table
, &palette
, NULL
);
2430 ok(hr
== DD_OK
, "CreatePalette failed with %08x\n", hr
);
2431 IDirectDrawPalette_GetEntries(palette
, 0, 0, 256, &palEntries
[0]);
2432 ok(hr
== DD_OK
, "GetEntries failed with %08x\n", hr
);
2435 /* All entries should contain red */
2436 for(i
=0; i
<256; i
++)
2437 ok((palEntries
[i
].peRed
== 255) && (palEntries
[i
].peGreen
== 0) && (palEntries
[i
].peBlue
== 0),
2438 "Palette entry %d should have contained (255,0,0) but was set to %d,%d,%d)\n",
2439 i
, palEntries
[i
].peRed
, palEntries
[i
].peGreen
, palEntries
[i
].peBlue
);
2441 IDirectDrawPalette_Release(palette
);
2444 static void StructSizeTest(void)
2446 IDirectDrawSurface
*surface1
;
2447 IDirectDrawSurface7
*surface7
;
2449 DDSURFACEDESC desc1
;
2450 DDSURFACEDESC2 desc2
;
2451 char blob
[1024]; /* To get a bunch of writable memory */
2453 DDSURFACEDESC create
;
2456 memset(&desc
, 0, sizeof(desc
));
2457 memset(&create
, 0, sizeof(create
));
2459 memset(&create
, 0, sizeof(create
));
2460 create
.dwSize
= sizeof(create
);
2461 create
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
| DDSD_WIDTH
;
2462 create
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2463 create
.dwHeight
= 128;
2464 create
.dwWidth
= 128;
2465 hr
= IDirectDraw_CreateSurface(lpDD
, &create
, &surface1
, NULL
);
2466 ok(hr
== DD_OK
, "Creating an offscreen plain surface failed with %08x\n", hr
);
2467 hr
= IDirectDrawSurface_QueryInterface(surface1
, &IID_IDirectDrawSurface7
, (void **) &surface7
);
2468 ok(hr
== DD_OK
, "IDirectDrawSurface_QueryInterface failed with %08x\n", hr
);
2470 desc
.desc1
.dwSize
= sizeof(DDSURFACEDESC
);
2471 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2472 ok(hr
== DD_OK
, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr
);
2473 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2474 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr
);
2476 desc
.desc2
.dwSize
= sizeof(DDSURFACEDESC2
);
2477 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2478 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr
);
2479 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2480 ok(hr
== DD_OK
, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr
);
2482 desc
.desc2
.dwSize
= 0;
2483 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2484 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_GetSurfaceDesc with desc size 0 returned %08x\n", hr
);
2485 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2486 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetSurfaceDesc with desc size 0 returned %08x\n", hr
);
2488 desc
.desc1
.dwSize
= sizeof(DDSURFACEDESC
) + 1;
2489 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2490 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr
);
2491 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2492 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr
);
2494 desc
.desc2
.dwSize
= sizeof(DDSURFACEDESC2
) + 1;
2495 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2496 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr
);
2497 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2498 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr
);
2500 /* Tests for Lock() */
2502 desc
.desc1
.dwSize
= sizeof(DDSURFACEDESC
);
2503 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2504 ok(hr
== DD_OK
, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr
);
2505 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2506 ok(desc
.desc1
.dwSize
== sizeof(DDSURFACEDESC
), "Destination size was changed to %d\n", desc
.desc1
.dwSize
);
2507 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2508 ok(hr
== DD_OK
, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr
);
2509 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2510 ok(desc
.desc2
.dwSize
== sizeof(DDSURFACEDESC
), "Destination size was changed to %d\n", desc
.desc1
.dwSize
);
2512 desc
.desc2
.dwSize
= sizeof(DDSURFACEDESC2
);
2513 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2514 ok(hr
== DD_OK
, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr
);
2515 ok(desc
.desc1
.dwSize
== sizeof(DDSURFACEDESC2
), "Destination size was changed to %d\n", desc
.desc1
.dwSize
);
2516 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2517 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2518 ok(hr
== DD_OK
, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr
);
2519 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2520 ok(desc
.desc2
.dwSize
== sizeof(DDSURFACEDESC2
), "Destination size was changed to %d\n", desc
.desc1
.dwSize
);
2522 desc
.desc2
.dwSize
= 0;
2523 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2524 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Lock with desc size 0 returned %08x\n", hr
);
2525 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2526 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2527 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_Lock with desc size 0 returned %08x\n", hr
);
2528 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2530 desc
.desc1
.dwSize
= sizeof(DDSURFACEDESC
) + 1;
2531 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2532 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr
);
2533 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2534 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2535 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr
);
2536 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2538 desc
.desc2
.dwSize
= sizeof(DDSURFACEDESC2
) + 1;
2539 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2540 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr
);
2541 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2542 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2543 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr
);
2544 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2546 IDirectDrawSurface7_Release(surface7
);
2547 IDirectDrawSurface_Release(surface1
);
2550 START_TEST(dsurface
)
2552 if (!CreateDirectDraw())
2554 MipMapCreationTest();
2555 SrcColorKey32BlitTest();
2565 test_lockrect_invalid();
2572 ReleaseDirectDraw();